drivers/pci/endpoint/pci-epf-core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * PCI Endpoint *Function* (EPF) library
   4  *
   5  * Copyright (C) 2017 Texas Instruments
   6  * Author: Kishon Vijay Abraham I <kishon@ti.com>
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/dma-mapping.h>
  11 #include <linux/slab.h>
  12 #include <linux/module.h>
  13
  14 #include <linux/pci-epc.h>
  15 #include <linux/pci-epf.h>
  16 #include <linux/pci-ep-cfs.h>
  17
  18 static DEFINE_MUTEX(pci_epf_mutex);
  19
  20 static struct bus_type pci_epf_bus_type;
  21 static const struct device_type pci_epf_type;
  22
  23 /**
  24  * pci_epf_type_add_cfs() - Help function drivers to expose function specific
  25  *                          attributes in configfs
  26  * @epf: the EPF device that has to be configured using configfs
  27  * @group: the parent configfs group (corresponding to entries in
  28  *         pci_epf_device_id)
  29  *
  30  * Invoke to expose function specific attributes in configfs. If the function
  31  * driver does not have anything to expose (attributes configured by user),
  32  * return NULL.
  33  */
  34 struct config_group *pci_epf_type_add_cfs(struct pci_epf *epf,
  35                                           struct config_group *group)
  36 {
  37         struct config_group *epf_type_group;
  38
  39         if (!epf->driver) {
  40                 dev_err(&epf->dev, "epf device not bound to driver\n");
  41                 return NULL;
  42         }
  43
  44         if (!epf->driver->ops->add_cfs)
  45                 return NULL;
  46
  47         mutex_lock(&epf->lock);
  48         epf_type_group = epf->driver->ops->add_cfs(epf, group);
  49         mutex_unlock(&epf->lock);
  50
  51         return epf_type_group;
  52 }
  53 EXPORT_SYMBOL_GPL(pci_epf_type_add_cfs);
  54
  55 /**
  56  * pci_epf_unbind() - Notify the function driver that the binding between the
  57  *                    EPF device and EPC device has been lost
  58  * @epf: the EPF device which has lost the binding with the EPC device
  59  *
  60  * Invoke to notify the function driver that the binding between the EPF device
  61  * and EPC device has been lost.
  62  */
  63 void pci_epf_unbind(struct pci_epf *epf)
  64 {
  65         if (!epf->driver) {
  66                 dev_WARN(&epf->dev, "epf device not bound to driver\n");
  67                 return;
  68         }
  69
  70         mutex_lock(&epf->lock);
  71         epf->driver->ops->unbind(epf);
  72         mutex_unlock(&epf->lock);
  73         module_put(epf->driver->owner);
  74 }
  75 EXPORT_SYMBOL_GPL(pci_epf_unbind);
  76
  77 /**
  78  * pci_epf_bind() - Notify the function driver that the EPF device has been
  79  *                  bound to a EPC device
  80  * @epf: the EPF device which has been bound to the EPC device
  81  *
  82  * Invoke to notify the function driver that it has been bound to a EPC device
  83  */
  84 int pci_epf_bind(struct pci_epf *epf)
  85 {
  86         int ret;
  87
  88         if (!epf->driver) {
  89                 dev_WARN(&epf->dev, "epf device not bound to driver\n");
  90                 return -EINVAL;
  91         }
  92
  93         if (!try_module_get(epf->driver->owner))
  94                 return -EAGAIN;
  95
  96         mutex_lock(&epf->lock);
  97         ret = epf->driver->ops->bind(epf);
  98         mutex_unlock(&epf->lock);
  99
 100         return ret;
 101 }
 102 EXPORT_SYMBOL_GPL(pci_epf_bind);
 103
 104 /**
 105  * pci_epf_free_space() - free the allocated PCI EPF register space
 106  * @epf: the EPF device from whom to free the memory
 107  * @addr: the virtual address of the PCI EPF register space
 108  * @bar: the BAR number corresponding to the register space
 109  * @type: Identifies if the allocated space is for primary EPC or secondary EPC
 110  *
 111  * Invoke to free the allocated PCI EPF register space.
 112  */
 113 void pci_epf_free_space(struct pci_epf *epf, void *addr, enum pci_barno bar,
 114                         enum pci_epc_interface_type type)
 115 {
 116         struct device *dev = epf->epc->dev.parent;
 117         struct pci_epf_bar *epf_bar;
 118         struct pci_epc *epc;
 119
 120         if (!addr)
 121                 return;
 122
 123         if (type == PRIMARY_INTERFACE) {
 124                 epc = epf->epc;
 125                 epf_bar = epf->bar;
 126         } else {
 127                 epc = epf->sec_epc;
 128                 epf_bar = epf->sec_epc_bar;
 129         }
 130
 131         dev = epc->dev.parent;
 132         dma_free_coherent(dev, epf_bar[bar].size, addr,
 133                           epf_bar[bar].phys_addr);
 134
 135         epf_bar[bar].phys_addr = 0;
 136         epf_bar[bar].addr = NULL;
 137         epf_bar[bar].size = 0;
 138         epf_bar[bar].barno = 0;
 139         epf_bar[bar].flags = 0;
 140 }
 141 EXPORT_SYMBOL_GPL(pci_epf_free_space);
 142
 143 /**
 144  * pci_epf_alloc_space() - allocate memory for the PCI EPF register space
 145  * @epf: the EPF device to whom allocate the memory
 146  * @size: the size of the memory that has to be allocated
 147  * @bar: the BAR number corresponding to the allocated register space
 148  * @align: alignment size for the allocation region
 149  * @type: Identifies if the allocation is for primary EPC or secondary EPC
 150  *
 151  * Invoke to allocate memory for the PCI EPF register space.
 152  */
 153 void *pci_epf_alloc_space(struct pci_epf *epf, size_t size, enum pci_barno bar,
 154                           size_t align, enum pci_epc_interface_type type)
 155 {
 156         struct pci_epf_bar *epf_bar;
 157         dma_addr_t phys_addr;
 158         struct pci_epc *epc;
 159         struct device *dev;
 160         void *space;
 161
 162         if (size < 128)
 163                 size = 128;
 164
 165         if (align)
 166                 size = ALIGN(size, align);
 167         else
 168                 size = roundup_pow_of_two(size);
 169
 170         if (type == PRIMARY_INTERFACE) {
 171                 epc = epf->epc;
 172                 epf_bar = epf->bar;
 173         } else {
 174                 epc = epf->sec_epc;
 175                 epf_bar = epf->sec_epc_bar;
 176         }
 177
 178         dev = epc->dev.parent;
 179         space = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL);
 180         if (!space) {
 181                 dev_err(dev, "failed to allocate mem space\n");
 182                 return NULL;
 183         }
 184
 185         epf_bar[bar].phys_addr = phys_addr;
 186         epf_bar[bar].addr = space;
 187         epf_bar[bar].size = size;
 188         epf_bar[bar].barno = bar;
 189         epf_bar[bar].flags |= upper_32_bits(size) ?
 190                                 PCI_BASE_ADDRESS_MEM_TYPE_64 :
 191                                 PCI_BASE_ADDRESS_MEM_TYPE_32;
 192
 193         return space;
 194 }
 195 EXPORT_SYMBOL_GPL(pci_epf_alloc_space);
 196
 197 static void pci_epf_remove_cfs(struct pci_epf_driver *driver)
 198 {
 199         struct config_group *group, *tmp;
 200
 201         if (!IS_ENABLED(CONFIG_PCI_ENDPOINT_CONFIGFS))
 202                 return;
 203
 204         mutex_lock(&pci_epf_mutex);
 205         list_for_each_entry_safe(group, tmp, &driver->epf_group, group_entry)
 206                 pci_ep_cfs_remove_epf_group(group);
 207         list_del(&driver->epf_group);
 208         mutex_unlock(&pci_epf_mutex);
 209 }
 210
 211 /**
 212  * pci_epf_unregister_driver() - unregister the PCI EPF driver
 213  * @driver: the PCI EPF driver that has to be unregistered
 214  *
 215  * Invoke to unregister the PCI EPF driver.
 216  */
 217 void pci_epf_unregister_driver(struct pci_epf_driver *driver)
 218 {
 219         pci_epf_remove_cfs(driver);
 220         driver_unregister(&driver->driver);
 221 }
 222 EXPORT_SYMBOL_GPL(pci_epf_unregister_driver);
 223
 224 static int pci_epf_add_cfs(struct pci_epf_driver *driver)
 225 {
 226         struct config_group *group;
 227         const struct pci_epf_device_id *id;
 228
 229         if (!IS_ENABLED(CONFIG_PCI_ENDPOINT_CONFIGFS))
 230                 return 0;
 231
 232         INIT_LIST_HEAD(&driver->epf_group);
 233
 234         id = driver->id_table;
 235         while (id->name[0]) {
 236                 group = pci_ep_cfs_add_epf_group(id->name);
 237                 if (IS_ERR(group)) {
 238                         pci_epf_remove_cfs(driver);
 239                         return PTR_ERR(group);
 240                 }
 241
 242                 mutex_lock(&pci_epf_mutex);
 243                 list_add_tail(&group->group_entry, &driver->epf_group);
 244                 mutex_unlock(&pci_epf_mutex);
 245                 id++;
 246         }
 247
 248         return 0;
 249 }
 250
 251 /**
 252  * __pci_epf_register_driver() - register a new PCI EPF driver
 253  * @driver: structure representing PCI EPF driver
 254  * @owner: the owner of the module that registers the PCI EPF driver
 255  *
 256  * Invoke to register a new PCI EPF driver.
 257  */
 258 int __pci_epf_register_driver(struct pci_epf_driver *driver,
 259                               struct module *owner)
 260 {
 261         int ret;
 262
 263         if (!driver->ops)
 264                 return -EINVAL;
 265
 266         if (!driver->ops->bind || !driver->ops->unbind)
 267                 return -EINVAL;
 268
 269         driver->driver.bus = &pci_epf_bus_type;
 270         driver->driver.owner = owner;
 271
 272         ret = driver_register(&driver->driver);
 273         if (ret)
 274                 return ret;
 275
 276         pci_epf_add_cfs(driver);
 277
 278         return 0;
 279 }
 280 EXPORT_SYMBOL_GPL(__pci_epf_register_driver);
 281
 282 /**
 283  * pci_epf_destroy() - destroy the created PCI EPF device
 284  * @epf: the PCI EPF device that has to be destroyed.
 285  *
 286  * Invoke to destroy the PCI EPF device created by invoking pci_epf_create().
 287  */
 288 void pci_epf_destroy(struct pci_epf *epf)
 289 {
 290         device_unregister(&epf->dev);
 291 }
 292 EXPORT_SYMBOL_GPL(pci_epf_destroy);
 293
 294 /**
 295  * pci_epf_create() - create a new PCI EPF device
 296  * @name: the name of the PCI EPF device. This name will be used to bind the
 297  *        the EPF device to a EPF driver
 298  *
 299  * Invoke to create a new PCI EPF device by providing the name of the function
 300  * device.
 301  */
 302 struct pci_epf *pci_epf_create(const char *name)
 303 {
 304         int ret;
 305         struct pci_epf *epf;
 306         struct device *dev;
 307         int len;
 308
 309         epf = kzalloc(sizeof(*epf), GFP_KERNEL);
 310         if (!epf)
 311                 return ERR_PTR(-ENOMEM);
 312
 313         len = strchrnul(name, '.') - name;
 314         epf->name = kstrndup(name, len, GFP_KERNEL);
 315         if (!epf->name) {
 316                 kfree(epf);
 317                 return ERR_PTR(-ENOMEM);
 318         }
 319
 320         dev = &epf->dev;
 321         device_initialize(dev);
 322         dev->bus = &pci_epf_bus_type;
 323         dev->type = &pci_epf_type;
 324         mutex_init(&epf->lock);
 325
 326         ret = dev_set_name(dev, "%s", name);
 327         if (ret) {
 328                 put_device(dev);
 329                 return ERR_PTR(ret);
 330         }
 331
 332         ret = device_add(dev);
 333         if (ret) {
 334                 put_device(dev);
 335                 return ERR_PTR(ret);
 336         }
 337
 338         return epf;
 339 }
 340 EXPORT_SYMBOL_GPL(pci_epf_create);
 341
 342 static void pci_epf_dev_release(struct device *dev)
 343 {
 344         struct pci_epf *epf = to_pci_epf(dev);
 345
 346         kfree(epf->name);
 347         kfree(epf);
 348 }
 349
 350 static const struct device_type pci_epf_type = {
 351         .release        = pci_epf_dev_release,
 352 };
 353
 354 static int
 355 pci_epf_match_id(const struct pci_epf_device_id *id, const struct pci_epf *epf)
 356 {
 357         while (id->name[0]) {
 358                 if (strcmp(epf->name, id->name) == 0)
 359                         return true;
 360                 id++;
 361         }
 362
 363         return false;
 364 }
 365
 366 static int pci_epf_device_match(struct device *dev, struct device_driver *drv)
 367 {
 368         struct pci_epf *epf = to_pci_epf(dev);
 369         struct pci_epf_driver *driver = to_pci_epf_driver(drv);
 370
 371         if (driver->id_table)
 372                 return pci_epf_match_id(driver->id_table, epf);
 373
 374         return !strcmp(epf->name, drv->name);
 375 }
 376
 377 static int pci_epf_device_probe(struct device *dev)
 378 {
 379         struct pci_epf *epf = to_pci_epf(dev);
 380         struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
 381
 382         if (!driver->probe)
 383                 return -ENODEV;
 384
 385         epf->driver = driver;
 386
 387         return driver->probe(epf);
 388 }
 389
 390 static int pci_epf_device_remove(struct device *dev)
 391 {
 392         int ret = 0;
 393         struct pci_epf *epf = to_pci_epf(dev);
 394         struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
 395
 396         if (driver->remove)
 397                 ret = driver->remove(epf);
 398         epf->driver = NULL;
 399
 400         return ret;
 401 }
 402
 403 static struct bus_type pci_epf_bus_type = {
 404         .name           = "pci-epf",
 405         .match          = pci_epf_device_match,
 406         .probe          = pci_epf_device_probe,
 407         .remove         = pci_epf_device_remove,
 408 };
 409
 410 static int __init pci_epf_init(void)
 411 {
 412         int ret;
 413
 414         ret = bus_register(&pci_epf_bus_type);
 415         if (ret) {
 416                 pr_err("failed to register pci epf bus --> %d\n", ret);
 417                 return ret;
 418         }
 419
 420         return 0;
 421 }
 422 module_init(pci_epf_init);
 423
 424 static void __exit pci_epf_exit(void)
 425 {
 426         bus_unregister(&pci_epf_bus_type);
 427 }
 428 module_exit(pci_epf_exit);
 429
 430 MODULE_DESCRIPTION("PCI EPF Library");
 431 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
 432 MODULE_LICENSE("GPL v2");