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