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"); 399