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