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