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 pci_epf *epf;
  25         int index;
  26 };
  27
  28 struct pci_epc_group {
  29         struct config_group group;
  30         struct pci_epc *epc;
  31         bool start;
  32 };
  33
  34 static inline struct pci_epf_group *to_pci_epf_group(struct config_item *item)
  35 {
  36         return container_of(to_config_group(item), struct pci_epf_group, group);
  37 }
  38
  39 static inline struct pci_epc_group *to_pci_epc_group(struct config_item *item)
  40 {
  41         return container_of(to_config_group(item), struct pci_epc_group, group);
  42 }
  43
  44 static ssize_t pci_epc_start_store(struct config_item *item, const char *page,
  45                                    size_t len)
  46 {
  47         int ret;
  48         bool start;
  49         struct pci_epc *epc;
  50         struct pci_epc_group *epc_group = to_pci_epc_group(item);
  51
  52         epc = epc_group->epc;
  53
  54         ret = kstrtobool(page, &start);
  55         if (ret)
  56                 return ret;
  57
  58         if (!start) {
  59                 pci_epc_stop(epc);
  60                 epc_group->start = 0;
  61                 return len;
  62         }
  63
  64         ret = pci_epc_start(epc);
  65         if (ret) {
  66                 dev_err(&epc->dev, "failed to start endpoint controller\n");
  67                 return -EINVAL;
  68         }
  69
  70         epc_group->start = start;
  71
  72         return len;
  73 }
  74
  75 static ssize_t pci_epc_start_show(struct config_item *item, char *page)
  76 {
  77         return sprintf(page, "%d\n",
  78                        to_pci_epc_group(item)->start);
  79 }
  80
  81 CONFIGFS_ATTR(pci_epc_, start);
  82
  83 static struct configfs_attribute *pci_epc_attrs[] = {
  84         &pci_epc_attr_start,
  85         NULL,
  86 };
  87
  88 static int pci_epc_epf_link(struct config_item *epc_item,
  89                             struct config_item *epf_item)
  90 {
  91         int ret;
  92         struct pci_epf_group *epf_group = to_pci_epf_group(epf_item);
  93         struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
  94         struct pci_epc *epc = epc_group->epc;
  95         struct pci_epf *epf = epf_group->epf;
  96
  97         ret = pci_epc_add_epf(epc, epf);
  98         if (ret)
  99                 return ret;
 100
 101         ret = pci_epf_bind(epf);
 102         if (ret) {
 103                 pci_epc_remove_epf(epc, epf);
 104                 return ret;
 105         }
 106
 107         return 0;
 108 }
 109
 110 static void pci_epc_epf_unlink(struct config_item *epc_item,
 111                                struct config_item *epf_item)
 112 {
 113         struct pci_epc *epc;
 114         struct pci_epf *epf;
 115         struct pci_epf_group *epf_group = to_pci_epf_group(epf_item);
 116         struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
 117
 118         WARN_ON_ONCE(epc_group->start);
 119
 120         epc = epc_group->epc;
 121         epf = epf_group->epf;
 122         pci_epf_unbind(epf);
 123         pci_epc_remove_epf(epc, epf);
 124 }
 125
 126 static struct configfs_item_operations pci_epc_item_ops = {
 127         .allow_link     = pci_epc_epf_link,
 128         .drop_link      = pci_epc_epf_unlink,
 129 };
 130
 131 static const struct config_item_type pci_epc_type = {
 132         .ct_item_ops    = &pci_epc_item_ops,
 133         .ct_attrs       = pci_epc_attrs,
 134         .ct_owner       = THIS_MODULE,
 135 };
 136
 137 struct config_group *pci_ep_cfs_add_epc_group(const char *name)
 138 {
 139         int ret;
 140         struct pci_epc *epc;
 141         struct config_group *group;
 142         struct pci_epc_group *epc_group;
 143
 144         epc_group = kzalloc(sizeof(*epc_group), GFP_KERNEL);
 145         if (!epc_group) {
 146                 ret = -ENOMEM;
 147                 goto err;
 148         }
 149
 150         group = &epc_group->group;
 151
 152         config_group_init_type_name(group, name, &pci_epc_type);
 153         ret = configfs_register_group(controllers_group, group);
 154         if (ret) {
 155                 pr_err("failed to register configfs group for %s\n", name);
 156                 goto err_register_group;
 157         }
 158
 159         epc = pci_epc_get(name);
 160         if (IS_ERR(epc)) {
 161                 ret = PTR_ERR(epc);
 162                 goto err_epc_get;
 163         }
 164
 165         epc_group->epc = epc;
 166
 167         return group;
 168
 169 err_epc_get:
 170         configfs_unregister_group(group);
 171
 172 err_register_group:
 173         kfree(epc_group);
 174
 175 err:
 176         return ERR_PTR(ret);
 177 }
 178 EXPORT_SYMBOL(pci_ep_cfs_add_epc_group);
 179
 180 void pci_ep_cfs_remove_epc_group(struct config_group *group)
 181 {
 182         struct pci_epc_group *epc_group;
 183
 184         if (!group)
 185                 return;
 186
 187         epc_group = container_of(group, struct pci_epc_group, group);
 188         pci_epc_put(epc_group->epc);
 189         configfs_unregister_group(&epc_group->group);
 190         kfree(epc_group);
 191 }
 192 EXPORT_SYMBOL(pci_ep_cfs_remove_epc_group);
 193
 194 #define PCI_EPF_HEADER_R(_name)                                                \
 195 static ssize_t pci_epf_##_name##_show(struct config_item *item, char *page)    \
 196 {                                                                              \
 197         struct pci_epf *epf = to_pci_epf_group(item)->epf;                     \
 198         if (WARN_ON_ONCE(!epf->header))                                        \
 199                 return -EINVAL;                                                \
 200         return sprintf(page, "0x%04x\n", epf->header->_name);                  \
 201 }
 202
 203 #define PCI_EPF_HEADER_W_u32(_name)                                            \
 204 static ssize_t pci_epf_##_name##_store(struct config_item *item,               \
 205                                        const char *page, size_t len)           \
 206 {                                                                              \
 207         u32 val;                                                               \
 208         int ret;                                                               \
 209         struct pci_epf *epf = to_pci_epf_group(item)->epf;                     \
 210         if (WARN_ON_ONCE(!epf->header))                                        \
 211                 return -EINVAL;                                                \
 212         ret = kstrtou32(page, 0, &val);                                        \
 213         if (ret)                                                               \
 214                 return ret;                                                    \
 215         epf->header->_name = val;                                              \
 216         return len;                                                            \
 217 }
 218
 219 #define PCI_EPF_HEADER_W_u16(_name)                                            \
 220 static ssize_t pci_epf_##_name##_store(struct config_item *item,               \
 221                                        const char *page, size_t len)           \
 222 {                                                                              \
 223         u16 val;                                                               \
 224         int ret;                                                               \
 225         struct pci_epf *epf = to_pci_epf_group(item)->epf;                     \
 226         if (WARN_ON_ONCE(!epf->header))                                        \
 227                 return -EINVAL;                                                \
 228         ret = kstrtou16(page, 0, &val);                                        \
 229         if (ret)                                                               \
 230                 return ret;                                                    \
 231         epf->header->_name = val;                                              \
 232         return len;                                                            \
 233 }
 234
 235 #define PCI_EPF_HEADER_W_u8(_name)                                             \
 236 static ssize_t pci_epf_##_name##_store(struct config_item *item,               \
 237                                        const char *page, size_t len)           \
 238 {                                                                              \
 239         u8 val;                                                                \
 240         int ret;                                                               \
 241         struct pci_epf *epf = to_pci_epf_group(item)->epf;                     \
 242         if (WARN_ON_ONCE(!epf->header))                                        \
 243                 return -EINVAL;                                                \
 244         ret = kstrtou8(page, 0, &val);                                         \
 245         if (ret)                                                               \
 246                 return ret;                                                    \
 247         epf->header->_name = val;                                              \
 248         return len;                                                            \
 249 }
 250
 251 static ssize_t pci_epf_msi_interrupts_store(struct config_item *item,
 252                                             const char *page, size_t len)
 253 {
 254         u8 val;
 255         int ret;
 256
 257         ret = kstrtou8(page, 0, &val);
 258         if (ret)
 259                 return ret;
 260
 261         to_pci_epf_group(item)->epf->msi_interrupts = val;
 262
 263         return len;
 264 }
 265
 266 static ssize_t pci_epf_msi_interrupts_show(struct config_item *item,
 267                                            char *page)
 268 {
 269         return sprintf(page, "%d\n",
 270                        to_pci_epf_group(item)->epf->msi_interrupts);
 271 }
 272
 273 static ssize_t pci_epf_msix_interrupts_store(struct config_item *item,
 274                                              const char *page, size_t len)
 275 {
 276         u16 val;
 277         int ret;
 278
 279         ret = kstrtou16(page, 0, &val);
 280         if (ret)
 281                 return ret;
 282
 283         to_pci_epf_group(item)->epf->msix_interrupts = val;
 284
 285         return len;
 286 }
 287
 288 static ssize_t pci_epf_msix_interrupts_show(struct config_item *item,
 289                                             char *page)
 290 {
 291         return sprintf(page, "%d\n",
 292                        to_pci_epf_group(item)->epf->msix_interrupts);
 293 }
 294
 295 PCI_EPF_HEADER_R(vendorid)
 296 PCI_EPF_HEADER_W_u16(vendorid)
 297
 298 PCI_EPF_HEADER_R(deviceid)
 299 PCI_EPF_HEADER_W_u16(deviceid)
 300
 301 PCI_EPF_HEADER_R(revid)
 302 PCI_EPF_HEADER_W_u8(revid)
 303
 304 PCI_EPF_HEADER_R(progif_code)
 305 PCI_EPF_HEADER_W_u8(progif_code)
 306
 307 PCI_EPF_HEADER_R(subclass_code)
 308 PCI_EPF_HEADER_W_u8(subclass_code)
 309
 310 PCI_EPF_HEADER_R(baseclass_code)
 311 PCI_EPF_HEADER_W_u8(baseclass_code)
 312
 313 PCI_EPF_HEADER_R(cache_line_size)
 314 PCI_EPF_HEADER_W_u8(cache_line_size)
 315
 316 PCI_EPF_HEADER_R(subsys_vendor_id)
 317 PCI_EPF_HEADER_W_u16(subsys_vendor_id)
 318
 319 PCI_EPF_HEADER_R(subsys_id)
 320 PCI_EPF_HEADER_W_u16(subsys_id)
 321
 322 PCI_EPF_HEADER_R(interrupt_pin)
 323 PCI_EPF_HEADER_W_u8(interrupt_pin)
 324
 325 CONFIGFS_ATTR(pci_epf_, vendorid);
 326 CONFIGFS_ATTR(pci_epf_, deviceid);
 327 CONFIGFS_ATTR(pci_epf_, revid);
 328 CONFIGFS_ATTR(pci_epf_, progif_code);
 329 CONFIGFS_ATTR(pci_epf_, subclass_code);
 330 CONFIGFS_ATTR(pci_epf_, baseclass_code);
 331 CONFIGFS_ATTR(pci_epf_, cache_line_size);
 332 CONFIGFS_ATTR(pci_epf_, subsys_vendor_id);
 333 CONFIGFS_ATTR(pci_epf_, subsys_id);
 334 CONFIGFS_ATTR(pci_epf_, interrupt_pin);
 335 CONFIGFS_ATTR(pci_epf_, msi_interrupts);
 336 CONFIGFS_ATTR(pci_epf_, msix_interrupts);
 337
 338 static struct configfs_attribute *pci_epf_attrs[] = {
 339         &pci_epf_attr_vendorid,
 340         &pci_epf_attr_deviceid,
 341         &pci_epf_attr_revid,
 342         &pci_epf_attr_progif_code,
 343         &pci_epf_attr_subclass_code,
 344         &pci_epf_attr_baseclass_code,
 345         &pci_epf_attr_cache_line_size,
 346         &pci_epf_attr_subsys_vendor_id,
 347         &pci_epf_attr_subsys_id,
 348         &pci_epf_attr_interrupt_pin,
 349         &pci_epf_attr_msi_interrupts,
 350         &pci_epf_attr_msix_interrupts,
 351         NULL,
 352 };
 353
 354 static void pci_epf_release(struct config_item *item)
 355 {
 356         struct pci_epf_group *epf_group = to_pci_epf_group(item);
 357
 358         mutex_lock(&functions_mutex);
 359         idr_remove(&functions_idr, epf_group->index);
 360         mutex_unlock(&functions_mutex);
 361         pci_epf_destroy(epf_group->epf);
 362         kfree(epf_group);
 363 }
 364
 365 static struct configfs_item_operations pci_epf_ops = {
 366         .release                = pci_epf_release,
 367 };
 368
 369 static const struct config_item_type pci_epf_type = {
 370         .ct_item_ops    = &pci_epf_ops,
 371         .ct_attrs       = pci_epf_attrs,
 372         .ct_owner       = THIS_MODULE,
 373 };
 374
 375 static struct config_group *pci_epf_make(struct config_group *group,
 376                                          const char *name)
 377 {
 378         struct pci_epf_group *epf_group;
 379         struct pci_epf *epf;
 380         char *epf_name;
 381         int index, err;
 382
 383         epf_group = kzalloc(sizeof(*epf_group), GFP_KERNEL);
 384         if (!epf_group)
 385                 return ERR_PTR(-ENOMEM);
 386
 387         mutex_lock(&functions_mutex);
 388         index = idr_alloc(&functions_idr, epf_group, 0, 0, GFP_KERNEL);
 389         mutex_unlock(&functions_mutex);
 390         if (index < 0) {
 391                 err = index;
 392                 goto free_group;
 393         }
 394
 395         epf_group->index = index;
 396
 397         config_group_init_type_name(&epf_group->group, name, &pci_epf_type);
 398
 399         epf_name = kasprintf(GFP_KERNEL, "%s.%d",
 400                              group->cg_item.ci_name, epf_group->index);
 401         if (!epf_name) {
 402                 err = -ENOMEM;
 403                 goto remove_idr;
 404         }
 405
 406         epf = pci_epf_create(epf_name);
 407         if (IS_ERR(epf)) {
 408                 pr_err("failed to create endpoint function device\n");
 409                 err = -EINVAL;
 410                 goto free_name;
 411         }
 412
 413         epf_group->epf = epf;
 414
 415         kfree(epf_name);
 416
 417         return &epf_group->group;
 418
 419 free_name:
 420         kfree(epf_name);
 421
 422 remove_idr:
 423         mutex_lock(&functions_mutex);
 424         idr_remove(&functions_idr, epf_group->index);
 425         mutex_unlock(&functions_mutex);
 426
 427 free_group:
 428         kfree(epf_group);
 429
 430         return ERR_PTR(err);
 431 }
 432
 433 static void pci_epf_drop(struct config_group *group, struct config_item *item)
 434 {
 435         config_item_put(item);
 436 }
 437
 438 static struct configfs_group_operations pci_epf_group_ops = {
 439         .make_group     = &pci_epf_make,
 440         .drop_item      = &pci_epf_drop,
 441 };
 442
 443 static const struct config_item_type pci_epf_group_type = {
 444         .ct_group_ops   = &pci_epf_group_ops,
 445         .ct_owner       = THIS_MODULE,
 446 };
 447
 448 struct config_group *pci_ep_cfs_add_epf_group(const char *name)
 449 {
 450         struct config_group *group;
 451
 452         group = configfs_register_default_group(functions_group, name,
 453                                                 &pci_epf_group_type);
 454         if (IS_ERR(group))
 455                 pr_err("failed to register configfs group for %s function\n",
 456                        name);
 457
 458         return group;
 459 }
 460 EXPORT_SYMBOL(pci_ep_cfs_add_epf_group);
 461
 462 void pci_ep_cfs_remove_epf_group(struct config_group *group)
 463 {
 464         if (IS_ERR_OR_NULL(group))
 465                 return;
 466
 467         configfs_unregister_default_group(group);
 468 }
 469 EXPORT_SYMBOL(pci_ep_cfs_remove_epf_group);
 470
 471 static const struct config_item_type pci_functions_type = {
 472         .ct_owner       = THIS_MODULE,
 473 };
 474
 475 static const struct config_item_type pci_controllers_type = {
 476         .ct_owner       = THIS_MODULE,
 477 };
 478
 479 static const struct config_item_type pci_ep_type = {
 480         .ct_owner       = THIS_MODULE,
 481 };
 482
 483 static struct configfs_subsystem pci_ep_cfs_subsys = {
 484         .su_group = {
 485                 .cg_item = {
 486                         .ci_namebuf = "pci_ep",
 487                         .ci_type = &pci_ep_type,
 488                 },
 489         },
 490         .su_mutex = __MUTEX_INITIALIZER(pci_ep_cfs_subsys.su_mutex),
 491 };
 492
 493 static int __init pci_ep_cfs_init(void)
 494 {
 495         int ret;
 496         struct config_group *root = &pci_ep_cfs_subsys.su_group;
 497
 498         config_group_init(root);
 499
 500         ret = configfs_register_subsystem(&pci_ep_cfs_subsys);
 501         if (ret) {
 502                 pr_err("Error %d while registering subsystem %s\n",
 503                        ret, root->cg_item.ci_namebuf);
 504                 goto err;
 505         }
 506
 507         functions_group = configfs_register_default_group(root, "functions",
 508                                                           &pci_functions_type);
 509         if (IS_ERR(functions_group)) {
 510                 ret = PTR_ERR(functions_group);
 511                 pr_err("Error %d while registering functions group\n",
 512                        ret);
 513                 goto err_functions_group;
 514         }
 515
 516         controllers_group =
 517                 configfs_register_default_group(root, "controllers",
 518                                                 &pci_controllers_type);
 519         if (IS_ERR(controllers_group)) {
 520                 ret = PTR_ERR(controllers_group);
 521                 pr_err("Error %d while registering controllers group\n",
 522                        ret);
 523                 goto err_controllers_group;
 524         }
 525
 526         return 0;
 527
 528 err_controllers_group:
 529         configfs_unregister_default_group(functions_group);
 530
 531 err_functions_group:
 532         configfs_unregister_subsystem(&pci_ep_cfs_subsys);
 533
 534 err:
 535         return ret;
 536 }
 537 module_init(pci_ep_cfs_init);
 538
 539 static void __exit pci_ep_cfs_exit(void)
 540 {
 541         configfs_unregister_default_group(controllers_group);
 542         configfs_unregister_default_group(functions_group);
 543         configfs_unregister_subsystem(&pci_ep_cfs_subsys);
 544 }
 545 module_exit(pci_ep_cfs_exit);
 546
 547 MODULE_DESCRIPTION("PCI EP CONFIGFS");
 548 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
 549 MODULE_LICENSE("GPL v2");