1 /** 2 * PCI Endpoint *Controller* (EPC) 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/slab.h> 22 #include <linux/module.h> 23 #include <linux/of_device.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 class *pci_epc_class; 30 31 static void devm_pci_epc_release(struct device *dev, void *res) 32 { 33 struct pci_epc *epc = *(struct pci_epc **)res; 34 35 pci_epc_destroy(epc); 36 } 37 38 static int devm_pci_epc_match(struct device *dev, void *res, void *match_data) 39 { 40 struct pci_epc **epc = res; 41 42 return *epc == match_data; 43 } 44 45 /** 46 * pci_epc_put() - release the PCI endpoint controller 47 * @epc: epc returned by pci_epc_get() 48 * 49 * release the refcount the caller obtained by invoking pci_epc_get() 50 */ 51 void pci_epc_put(struct pci_epc *epc) 52 { 53 if (!epc || IS_ERR(epc)) 54 return; 55 56 module_put(epc->ops->owner); 57 put_device(&epc->dev); 58 } 59 EXPORT_SYMBOL_GPL(pci_epc_put); 60 61 /** 62 * pci_epc_get() - get the PCI endpoint controller 63 * @epc_name: device name of the endpoint controller 64 * 65 * Invoke to get struct pci_epc * corresponding to the device name of the 66 * endpoint controller 67 */ 68 struct pci_epc *pci_epc_get(const char *epc_name) 69 { 70 int ret = -EINVAL; 71 struct pci_epc *epc; 72 struct device *dev; 73 struct class_dev_iter iter; 74 75 class_dev_iter_init(&iter, pci_epc_class, NULL, NULL); 76 while ((dev = class_dev_iter_next(&iter))) { 77 if (strcmp(epc_name, dev_name(dev))) 78 continue; 79 80 epc = to_pci_epc(dev); 81 if (!try_module_get(epc->ops->owner)) { 82 ret = -EINVAL; 83 goto err; 84 } 85 86 class_dev_iter_exit(&iter); 87 get_device(&epc->dev); 88 return epc; 89 } 90 91 err: 92 class_dev_iter_exit(&iter); 93 return ERR_PTR(ret); 94 } 95 EXPORT_SYMBOL_GPL(pci_epc_get); 96 97 /** 98 * pci_epc_stop() - stop the PCI link 99 * @epc: the link of the EPC device that has to be stopped 100 * 101 * Invoke to stop the PCI link 102 */ 103 void pci_epc_stop(struct pci_epc *epc) 104 { 105 unsigned long flags; 106 107 if (IS_ERR(epc) || !epc->ops->stop) 108 return; 109 110 spin_lock_irqsave(&epc->lock, flags); 111 epc->ops->stop(epc); 112 spin_unlock_irqrestore(&epc->lock, flags); 113 } 114 EXPORT_SYMBOL_GPL(pci_epc_stop); 115 116 /** 117 * pci_epc_start() - start the PCI link 118 * @epc: the link of *this* EPC device has to be started 119 * 120 * Invoke to start the PCI link 121 */ 122 int pci_epc_start(struct pci_epc *epc) 123 { 124 int ret; 125 unsigned long flags; 126 127 if (IS_ERR(epc)) 128 return -EINVAL; 129 130 if (!epc->ops->start) 131 return 0; 132 133 spin_lock_irqsave(&epc->lock, flags); 134 ret = epc->ops->start(epc); 135 spin_unlock_irqrestore(&epc->lock, flags); 136 137 return ret; 138 } 139 EXPORT_SYMBOL_GPL(pci_epc_start); 140 141 /** 142 * pci_epc_raise_irq() - interrupt the host system 143 * @epc: the EPC device which has to interrupt the host 144 * @type: specify the type of interrupt; legacy or MSI 145 * @interrupt_num: the MSI interrupt number 146 * 147 * Invoke to raise an MSI or legacy interrupt 148 */ 149 int pci_epc_raise_irq(struct pci_epc *epc, enum pci_epc_irq_type type, 150 u8 interrupt_num) 151 { 152 int ret; 153 unsigned long flags; 154 155 if (IS_ERR(epc)) 156 return -EINVAL; 157 158 if (!epc->ops->raise_irq) 159 return 0; 160 161 spin_lock_irqsave(&epc->lock, flags); 162 ret = epc->ops->raise_irq(epc, type, interrupt_num); 163 spin_unlock_irqrestore(&epc->lock, flags); 164 165 return ret; 166 } 167 EXPORT_SYMBOL_GPL(pci_epc_raise_irq); 168 169 /** 170 * pci_epc_get_msi() - get the number of MSI interrupt numbers allocated 171 * @epc: the EPC device to which MSI interrupts was requested 172 * 173 * Invoke to get the number of MSI interrupts allocated by the RC 174 */ 175 int pci_epc_get_msi(struct pci_epc *epc) 176 { 177 int interrupt; 178 unsigned long flags; 179 180 if (IS_ERR(epc)) 181 return 0; 182 183 if (!epc->ops->get_msi) 184 return 0; 185 186 spin_lock_irqsave(&epc->lock, flags); 187 interrupt = epc->ops->get_msi(epc); 188 spin_unlock_irqrestore(&epc->lock, flags); 189 190 if (interrupt < 0) 191 return 0; 192 193 interrupt = 1 << interrupt; 194 195 return interrupt; 196 } 197 EXPORT_SYMBOL_GPL(pci_epc_get_msi); 198 199 /** 200 * pci_epc_set_msi() - set the number of MSI interrupt numbers required 201 * @epc: the EPC device on which MSI has to be configured 202 * @interrupts: number of MSI interrupts required by the EPF 203 * 204 * Invoke to set the required number of MSI interrupts. 205 */ 206 int pci_epc_set_msi(struct pci_epc *epc, u8 interrupts) 207 { 208 int ret; 209 u8 encode_int; 210 unsigned long flags; 211 212 if (IS_ERR(epc)) 213 return -EINVAL; 214 215 if (!epc->ops->set_msi) 216 return 0; 217 218 encode_int = order_base_2(interrupts); 219 220 spin_lock_irqsave(&epc->lock, flags); 221 ret = epc->ops->set_msi(epc, encode_int); 222 spin_unlock_irqrestore(&epc->lock, flags); 223 224 return ret; 225 } 226 EXPORT_SYMBOL_GPL(pci_epc_set_msi); 227 228 /** 229 * pci_epc_unmap_addr() - unmap CPU address from PCI address 230 * @epc: the EPC device on which address is allocated 231 * @phys_addr: physical address of the local system 232 * 233 * Invoke to unmap the CPU address from PCI address. 234 */ 235 void pci_epc_unmap_addr(struct pci_epc *epc, phys_addr_t phys_addr) 236 { 237 unsigned long flags; 238 239 if (IS_ERR(epc)) 240 return; 241 242 if (!epc->ops->unmap_addr) 243 return; 244 245 spin_lock_irqsave(&epc->lock, flags); 246 epc->ops->unmap_addr(epc, phys_addr); 247 spin_unlock_irqrestore(&epc->lock, flags); 248 } 249 EXPORT_SYMBOL_GPL(pci_epc_unmap_addr); 250 251 /** 252 * pci_epc_map_addr() - map CPU address to PCI address 253 * @epc: the EPC device on which address is allocated 254 * @phys_addr: physical address of the local system 255 * @pci_addr: PCI address to which the physical address should be mapped 256 * @size: the size of the allocation 257 * 258 * Invoke to map CPU address with PCI address. 259 */ 260 int pci_epc_map_addr(struct pci_epc *epc, phys_addr_t phys_addr, 261 u64 pci_addr, size_t size) 262 { 263 int ret; 264 unsigned long flags; 265 266 if (IS_ERR(epc)) 267 return -EINVAL; 268 269 if (!epc->ops->map_addr) 270 return 0; 271 272 spin_lock_irqsave(&epc->lock, flags); 273 ret = epc->ops->map_addr(epc, phys_addr, pci_addr, size); 274 spin_unlock_irqrestore(&epc->lock, flags); 275 276 return ret; 277 } 278 EXPORT_SYMBOL_GPL(pci_epc_map_addr); 279 280 /** 281 * pci_epc_clear_bar() - reset the BAR 282 * @epc: the EPC device for which the BAR has to be cleared 283 * @bar: the BAR number that has to be reset 284 * 285 * Invoke to reset the BAR of the endpoint device. 286 */ 287 void pci_epc_clear_bar(struct pci_epc *epc, int bar) 288 { 289 unsigned long flags; 290 291 if (IS_ERR(epc)) 292 return; 293 294 if (!epc->ops->clear_bar) 295 return; 296 297 spin_lock_irqsave(&epc->lock, flags); 298 epc->ops->clear_bar(epc, bar); 299 spin_unlock_irqrestore(&epc->lock, flags); 300 } 301 EXPORT_SYMBOL_GPL(pci_epc_clear_bar); 302 303 /** 304 * pci_epc_set_bar() - configure BAR in order for host to assign PCI addr space 305 * @epc: the EPC device on which BAR has to be configured 306 * @bar: the BAR number that has to be configured 307 * @size: the size of the addr space 308 * @flags: specify memory allocation/io allocation/32bit address/64 bit address 309 * 310 * Invoke to configure the BAR of the endpoint device. 311 */ 312 int pci_epc_set_bar(struct pci_epc *epc, enum pci_barno bar, 313 dma_addr_t bar_phys, size_t size, int flags) 314 { 315 int ret; 316 unsigned long irq_flags; 317 318 if (IS_ERR(epc)) 319 return -EINVAL; 320 321 if (!epc->ops->set_bar) 322 return 0; 323 324 spin_lock_irqsave(&epc->lock, irq_flags); 325 ret = epc->ops->set_bar(epc, bar, bar_phys, size, flags); 326 spin_unlock_irqrestore(&epc->lock, irq_flags); 327 328 return ret; 329 } 330 EXPORT_SYMBOL_GPL(pci_epc_set_bar); 331 332 /** 333 * pci_epc_write_header() - write standard configuration header 334 * @epc: the EPC device to which the configuration header should be written 335 * @header: standard configuration header fields 336 * 337 * Invoke to write the configuration header to the endpoint controller. Every 338 * endpoint controller will have a dedicated location to which the standard 339 * configuration header would be written. The callback function should write 340 * the header fields to this dedicated location. 341 */ 342 int pci_epc_write_header(struct pci_epc *epc, struct pci_epf_header *header) 343 { 344 int ret; 345 unsigned long flags; 346 347 if (IS_ERR(epc)) 348 return -EINVAL; 349 350 if (!epc->ops->write_header) 351 return 0; 352 353 spin_lock_irqsave(&epc->lock, flags); 354 ret = epc->ops->write_header(epc, header); 355 spin_unlock_irqrestore(&epc->lock, flags); 356 357 return ret; 358 } 359 EXPORT_SYMBOL_GPL(pci_epc_write_header); 360 361 /** 362 * pci_epc_add_epf() - bind PCI endpoint function to an endpoint controller 363 * @epc: the EPC device to which the endpoint function should be added 364 * @epf: the endpoint function to be added 365 * 366 * A PCI endpoint device can have one or more functions. In the case of PCIe, 367 * the specification allows up to 8 PCIe endpoint functions. Invoke 368 * pci_epc_add_epf() to add a PCI endpoint function to an endpoint controller. 369 */ 370 int pci_epc_add_epf(struct pci_epc *epc, struct pci_epf *epf) 371 { 372 unsigned long flags; 373 374 if (epf->epc) 375 return -EBUSY; 376 377 if (IS_ERR(epc)) 378 return -EINVAL; 379 380 if (epf->func_no > epc->max_functions - 1) 381 return -EINVAL; 382 383 epf->epc = epc; 384 385 spin_lock_irqsave(&epc->lock, flags); 386 list_add_tail(&epf->list, &epc->pci_epf); 387 spin_unlock_irqrestore(&epc->lock, flags); 388 389 return 0; 390 } 391 EXPORT_SYMBOL_GPL(pci_epc_add_epf); 392 393 /** 394 * pci_epc_remove_epf() - remove PCI endpoint function from endpoint controller 395 * @epc: the EPC device from which the endpoint function should be removed 396 * @epf: the endpoint function to be removed 397 * 398 * Invoke to remove PCI endpoint function from the endpoint controller. 399 */ 400 void pci_epc_remove_epf(struct pci_epc *epc, struct pci_epf *epf) 401 { 402 unsigned long flags; 403 404 if (!epc || IS_ERR(epc)) 405 return; 406 407 spin_lock_irqsave(&epc->lock, flags); 408 list_del(&epf->list); 409 spin_unlock_irqrestore(&epc->lock, flags); 410 } 411 EXPORT_SYMBOL_GPL(pci_epc_remove_epf); 412 413 /** 414 * pci_epc_linkup() - Notify the EPF device that EPC device has established a 415 * connection with the Root Complex. 416 * @epc: the EPC device which has established link with the host 417 * 418 * Invoke to Notify the EPF device that the EPC device has established a 419 * connection with the Root Complex. 420 */ 421 void pci_epc_linkup(struct pci_epc *epc) 422 { 423 unsigned long flags; 424 struct pci_epf *epf; 425 426 if (!epc || IS_ERR(epc)) 427 return; 428 429 spin_lock_irqsave(&epc->lock, flags); 430 list_for_each_entry(epf, &epc->pci_epf, list) 431 pci_epf_linkup(epf); 432 spin_unlock_irqrestore(&epc->lock, flags); 433 } 434 EXPORT_SYMBOL_GPL(pci_epc_linkup); 435 436 /** 437 * pci_epc_destroy() - destroy the EPC device 438 * @epc: the EPC device that has to be destroyed 439 * 440 * Invoke to destroy the PCI EPC device 441 */ 442 void pci_epc_destroy(struct pci_epc *epc) 443 { 444 pci_ep_cfs_remove_epc_group(epc->group); 445 device_unregister(&epc->dev); 446 kfree(epc); 447 } 448 EXPORT_SYMBOL_GPL(pci_epc_destroy); 449 450 /** 451 * devm_pci_epc_destroy() - destroy the EPC device 452 * @dev: device that wants to destroy the EPC 453 * @epc: the EPC device that has to be destroyed 454 * 455 * Invoke to destroy the devres associated with this 456 * pci_epc and destroy the EPC device. 457 */ 458 void devm_pci_epc_destroy(struct device *dev, struct pci_epc *epc) 459 { 460 int r; 461 462 r = devres_destroy(dev, devm_pci_epc_release, devm_pci_epc_match, 463 epc); 464 dev_WARN_ONCE(dev, r, "couldn't find PCI EPC resource\n"); 465 } 466 EXPORT_SYMBOL_GPL(devm_pci_epc_destroy); 467 468 /** 469 * __pci_epc_create() - create a new endpoint controller (EPC) device 470 * @dev: device that is creating the new EPC 471 * @ops: function pointers for performing EPC operations 472 * @owner: the owner of the module that creates the EPC device 473 * 474 * Invoke to create a new EPC device and add it to pci_epc class. 475 */ 476 struct pci_epc * 477 __pci_epc_create(struct device *dev, const struct pci_epc_ops *ops, 478 struct module *owner) 479 { 480 int ret; 481 struct pci_epc *epc; 482 483 if (WARN_ON(!dev)) { 484 ret = -EINVAL; 485 goto err_ret; 486 } 487 488 epc = kzalloc(sizeof(*epc), GFP_KERNEL); 489 if (!epc) { 490 ret = -ENOMEM; 491 goto err_ret; 492 } 493 494 spin_lock_init(&epc->lock); 495 INIT_LIST_HEAD(&epc->pci_epf); 496 497 device_initialize(&epc->dev); 498 epc->dev.class = pci_epc_class; 499 epc->dev.parent = dev; 500 epc->ops = ops; 501 502 ret = dev_set_name(&epc->dev, "%s", dev_name(dev)); 503 if (ret) 504 goto put_dev; 505 506 ret = device_add(&epc->dev); 507 if (ret) 508 goto put_dev; 509 510 epc->group = pci_ep_cfs_add_epc_group(dev_name(dev)); 511 512 return epc; 513 514 put_dev: 515 put_device(&epc->dev); 516 kfree(epc); 517 518 err_ret: 519 return ERR_PTR(ret); 520 } 521 EXPORT_SYMBOL_GPL(__pci_epc_create); 522 523 /** 524 * __devm_pci_epc_create() - create a new endpoint controller (EPC) device 525 * @dev: device that is creating the new EPC 526 * @ops: function pointers for performing EPC operations 527 * @owner: the owner of the module that creates the EPC device 528 * 529 * Invoke to create a new EPC device and add it to pci_epc class. 530 * While at that, it also associates the device with the pci_epc using devres. 531 * On driver detach, release function is invoked on the devres data, 532 * then, devres data is freed. 533 */ 534 struct pci_epc * 535 __devm_pci_epc_create(struct device *dev, const struct pci_epc_ops *ops, 536 struct module *owner) 537 { 538 struct pci_epc **ptr, *epc; 539 540 ptr = devres_alloc(devm_pci_epc_release, sizeof(*ptr), GFP_KERNEL); 541 if (!ptr) 542 return ERR_PTR(-ENOMEM); 543 544 epc = __pci_epc_create(dev, ops, owner); 545 if (!IS_ERR(epc)) { 546 *ptr = epc; 547 devres_add(dev, ptr); 548 } else { 549 devres_free(ptr); 550 } 551 552 return epc; 553 } 554 EXPORT_SYMBOL_GPL(__devm_pci_epc_create); 555 556 static int __init pci_epc_init(void) 557 { 558 pci_epc_class = class_create(THIS_MODULE, "pci_epc"); 559 if (IS_ERR(pci_epc_class)) { 560 pr_err("failed to create pci epc class --> %ld\n", 561 PTR_ERR(pci_epc_class)); 562 return PTR_ERR(pci_epc_class); 563 } 564 565 return 0; 566 } 567 module_init(pci_epc_init); 568 569 static void __exit pci_epc_exit(void) 570 { 571 class_destroy(pci_epc_class); 572 } 573 module_exit(pci_epc_exit); 574 575 MODULE_DESCRIPTION("PCI EPC Library"); 576 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>"); 577 MODULE_LICENSE("GPL v2"); 578