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