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

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

DEFINITIONS
