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