1/* 2 * File: portdrv_core.c 3 * Purpose: PCI Express Port Bus Driver's Core Functions 4 * 5 * Copyright (C) 2004 Intel 6 * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com) 7 */ 8 9#include <linux/module.h> 10#include <linux/pci.h> 11#include <linux/kernel.h> 12#include <linux/errno.h> 13#include <linux/pm.h> 14#include <linux/string.h> 15#include <linux/slab.h> 16#include <linux/pcieport_if.h> 17#include <linux/aer.h> 18 19#include "../pci.h" 20#include "portdrv.h" 21 22bool pciehp_msi_disabled; 23 24static int __init pciehp_setup(char *str) 25{ 26 if (!strncmp(str, "nomsi", 5)) 27 pciehp_msi_disabled = true; 28 29 return 1; 30} 31__setup("pcie_hp=", pciehp_setup); 32 33/** 34 * release_pcie_device - free PCI Express port service device structure 35 * @dev: Port service device to release 36 * 37 * Invoked automatically when device is being removed in response to 38 * device_unregister(dev). Release all resources being claimed. 39 */ 40static void release_pcie_device(struct device *dev) 41{ 42 kfree(to_pcie_device(dev)); 43} 44 45/** 46 * pcie_port_msix_add_entry - add entry to given array of MSI-X entries 47 * @entries: Array of MSI-X entries 48 * @new_entry: Index of the entry to add to the array 49 * @nr_entries: Number of entries already in the array 50 * 51 * Return value: Position of the added entry in the array 52 */ 53static int pcie_port_msix_add_entry( 54 struct msix_entry *entries, int new_entry, int nr_entries) 55{ 56 int j; 57 58 for (j = 0; j < nr_entries; j++) 59 if (entries[j].entry == new_entry) 60 return j; 61 62 entries[j].entry = new_entry; 63 return j; 64} 65 66/** 67 * pcie_port_enable_msix - try to set up MSI-X as interrupt mode for given port 68 * @dev: PCI Express port to handle 69 * @vectors: Array of interrupt vectors to populate 70 * @mask: Bitmask of port capabilities returned by get_port_device_capability() 71 * 72 * Return value: 0 on success, error code on failure 73 */ 74static int pcie_port_enable_msix(struct pci_dev *dev, int *vectors, int mask) 75{ 76 struct msix_entry *msix_entries; 77 int idx[PCIE_PORT_DEVICE_MAXSERVICES]; 78 int nr_entries, status, pos, i, nvec; 79 u16 reg16; 80 u32 reg32; 81 82 nr_entries = pci_msix_vec_count(dev); 83 if (nr_entries < 0) 84 return nr_entries; 85 BUG_ON(!nr_entries); 86 if (nr_entries > PCIE_PORT_MAX_MSIX_ENTRIES) 87 nr_entries = PCIE_PORT_MAX_MSIX_ENTRIES; 88 89 msix_entries = kzalloc(sizeof(*msix_entries) * nr_entries, GFP_KERNEL); 90 if (!msix_entries) 91 return -ENOMEM; 92 93 /* 94 * Allocate as many entries as the port wants, so that we can check 95 * which of them will be useful. Moreover, if nr_entries is correctly 96 * equal to the number of entries this port actually uses, we'll happily 97 * go through without any tricks. 98 */ 99 for (i = 0; i < nr_entries; i++) 100 msix_entries[i].entry = i; 101 102 status = pci_enable_msix_exact(dev, msix_entries, nr_entries); 103 if (status) 104 goto Exit; 105 106 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) 107 idx[i] = -1; 108 status = -EIO; 109 nvec = 0; 110 111 if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) { 112 int entry; 113 114 /* 115 * The code below follows the PCI Express Base Specification 2.0 116 * stating in Section 6.1.6 that "PME and Hot-Plug Event 117 * interrupts (when both are implemented) always share the same 118 * MSI or MSI-X vector, as indicated by the Interrupt Message 119 * Number field in the PCI Express Capabilities register", where 120 * according to Section 7.8.2 of the specification "For MSI-X, 121 * the value in this field indicates which MSI-X Table entry is 122 * used to generate the interrupt message." 123 */ 124 pcie_capability_read_word(dev, PCI_EXP_FLAGS, ®16); 125 entry = (reg16 & PCI_EXP_FLAGS_IRQ) >> 9; 126 if (entry >= nr_entries) 127 goto Error; 128 129 i = pcie_port_msix_add_entry(msix_entries, entry, nvec); 130 if (i == nvec) 131 nvec++; 132 133 idx[PCIE_PORT_SERVICE_PME_SHIFT] = i; 134 idx[PCIE_PORT_SERVICE_HP_SHIFT] = i; 135 } 136 137 if (mask & PCIE_PORT_SERVICE_AER) { 138 int entry; 139 140 /* 141 * The code below follows Section 7.10.10 of the PCI Express 142 * Base Specification 2.0 stating that bits 31-27 of the Root 143 * Error Status Register contain a value indicating which of the 144 * MSI/MSI-X vectors assigned to the port is going to be used 145 * for AER, where "For MSI-X, the value in this register 146 * indicates which MSI-X Table entry is used to generate the 147 * interrupt message." 148 */ 149 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR); 150 pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, ®32); 151 entry = reg32 >> 27; 152 if (entry >= nr_entries) 153 goto Error; 154 155 i = pcie_port_msix_add_entry(msix_entries, entry, nvec); 156 if (i == nvec) 157 nvec++; 158 159 idx[PCIE_PORT_SERVICE_AER_SHIFT] = i; 160 } 161 162 /* 163 * If nvec is equal to the allocated number of entries, we can just use 164 * what we have. Otherwise, the port has some extra entries not for the 165 * services we know and we need to work around that. 166 */ 167 if (nvec == nr_entries) { 168 status = 0; 169 } else { 170 /* Drop the temporary MSI-X setup */ 171 pci_disable_msix(dev); 172 173 /* Now allocate the MSI-X vectors for real */ 174 status = pci_enable_msix_exact(dev, msix_entries, nvec); 175 if (status) 176 goto Exit; 177 } 178 179 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) 180 vectors[i] = idx[i] >= 0 ? msix_entries[idx[i]].vector : -1; 181 182 Exit: 183 kfree(msix_entries); 184 return status; 185 186 Error: 187 pci_disable_msix(dev); 188 goto Exit; 189} 190 191/** 192 * init_service_irqs - initialize irqs for PCI Express port services 193 * @dev: PCI Express port to handle 194 * @irqs: Array of irqs to populate 195 * @mask: Bitmask of port capabilities returned by get_port_device_capability() 196 * 197 * Return value: Interrupt mode associated with the port 198 */ 199static int init_service_irqs(struct pci_dev *dev, int *irqs, int mask) 200{ 201 int i, irq = -1; 202 203 /* 204 * If MSI cannot be used for PCIe PME or hotplug, we have to use 205 * INTx or other interrupts, e.g. system shared interrupt. 206 */ 207 if (((mask & PCIE_PORT_SERVICE_PME) && pcie_pme_no_msi()) || 208 ((mask & PCIE_PORT_SERVICE_HP) && pciehp_no_msi())) { 209 if (dev->irq) 210 irq = dev->irq; 211 goto no_msi; 212 } 213 214 /* Try to use MSI-X if supported */ 215 if (!pcie_port_enable_msix(dev, irqs, mask)) 216 return 0; 217 218 /* 219 * We're not going to use MSI-X, so try MSI and fall back to INTx. 220 * If neither MSI/MSI-X nor INTx available, try other interrupt. On 221 * some platforms, root port doesn't support MSI/MSI-X/INTx in RC mode. 222 */ 223 if (!pci_enable_msi(dev) || dev->irq) 224 irq = dev->irq; 225 226 no_msi: 227 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) 228 irqs[i] = irq; 229 irqs[PCIE_PORT_SERVICE_VC_SHIFT] = -1; 230 231 if (irq < 0) 232 return -ENODEV; 233 return 0; 234} 235 236static void cleanup_service_irqs(struct pci_dev *dev) 237{ 238 if (dev->msix_enabled) 239 pci_disable_msix(dev); 240 else if (dev->msi_enabled) 241 pci_disable_msi(dev); 242} 243 244/** 245 * get_port_device_capability - discover capabilities of a PCI Express port 246 * @dev: PCI Express port to examine 247 * 248 * The capabilities are read from the port's PCI Express configuration registers 249 * as described in PCI Express Base Specification 1.0a sections 7.8.2, 7.8.9 and 250 * 7.9 - 7.11. 251 * 252 * Return value: Bitmask of discovered port capabilities 253 */ 254static int get_port_device_capability(struct pci_dev *dev) 255{ 256 int services = 0; 257 u32 reg32; 258 int cap_mask = 0; 259 int err; 260 261 if (pcie_ports_disabled) 262 return 0; 263 264 cap_mask = PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP 265 | PCIE_PORT_SERVICE_VC; 266 if (pci_aer_available()) 267 cap_mask |= PCIE_PORT_SERVICE_AER; 268 269 if (pcie_ports_auto) { 270 err = pcie_port_platform_notify(dev, &cap_mask); 271 if (err) 272 return 0; 273 } 274 275 /* Hot-Plug Capable */ 276 if ((cap_mask & PCIE_PORT_SERVICE_HP) && 277 pcie_caps_reg(dev) & PCI_EXP_FLAGS_SLOT) { 278 pcie_capability_read_dword(dev, PCI_EXP_SLTCAP, ®32); 279 if (reg32 & PCI_EXP_SLTCAP_HPC) { 280 services |= PCIE_PORT_SERVICE_HP; 281 /* 282 * Disable hot-plug interrupts in case they have been 283 * enabled by the BIOS and the hot-plug service driver 284 * is not loaded. 285 */ 286 pcie_capability_clear_word(dev, PCI_EXP_SLTCTL, 287 PCI_EXP_SLTCTL_CCIE | PCI_EXP_SLTCTL_HPIE); 288 } 289 } 290 /* AER capable */ 291 if ((cap_mask & PCIE_PORT_SERVICE_AER) 292 && pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR)) { 293 services |= PCIE_PORT_SERVICE_AER; 294 /* 295 * Disable AER on this port in case it's been enabled by the 296 * BIOS (the AER service driver will enable it when necessary). 297 */ 298 pci_disable_pcie_error_reporting(dev); 299 } 300 /* VC support */ 301 if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC)) 302 services |= PCIE_PORT_SERVICE_VC; 303 /* Root ports are capable of generating PME too */ 304 if ((cap_mask & PCIE_PORT_SERVICE_PME) 305 && pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT) { 306 services |= PCIE_PORT_SERVICE_PME; 307 /* 308 * Disable PME interrupt on this port in case it's been enabled 309 * by the BIOS (the PME service driver will enable it when 310 * necessary). 311 */ 312 pcie_pme_interrupt_enable(dev, false); 313 } 314 315 return services; 316} 317 318/** 319 * pcie_device_init - allocate and initialize PCI Express port service device 320 * @pdev: PCI Express port to associate the service device with 321 * @service: Type of service to associate with the service device 322 * @irq: Interrupt vector to associate with the service device 323 */ 324static int pcie_device_init(struct pci_dev *pdev, int service, int irq) 325{ 326 int retval; 327 struct pcie_device *pcie; 328 struct device *device; 329 330 pcie = kzalloc(sizeof(*pcie), GFP_KERNEL); 331 if (!pcie) 332 return -ENOMEM; 333 pcie->port = pdev; 334 pcie->irq = irq; 335 pcie->service = service; 336 337 /* Initialize generic device interface */ 338 device = &pcie->device; 339 device->bus = &pcie_port_bus_type; 340 device->release = release_pcie_device; /* callback to free pcie dev */ 341 dev_set_name(device, "%s:pcie%02x", 342 pci_name(pdev), 343 get_descriptor_id(pci_pcie_type(pdev), service)); 344 device->parent = &pdev->dev; 345 device_enable_async_suspend(device); 346 347 retval = device_register(device); 348 if (retval) { 349 put_device(device); 350 return retval; 351 } 352 353 return 0; 354} 355 356/** 357 * pcie_port_device_register - register PCI Express port 358 * @dev: PCI Express port to register 359 * 360 * Allocate the port extension structure and register services associated with 361 * the port. 362 */ 363int pcie_port_device_register(struct pci_dev *dev) 364{ 365 int status, capabilities, i, nr_service; 366 int irqs[PCIE_PORT_DEVICE_MAXSERVICES]; 367 368 /* Enable PCI Express port device */ 369 status = pci_enable_device(dev); 370 if (status) 371 return status; 372 373 /* Get and check PCI Express port services */ 374 capabilities = get_port_device_capability(dev); 375 if (!capabilities) 376 return 0; 377 378 pci_set_master(dev); 379 /* 380 * Initialize service irqs. Don't use service devices that 381 * require interrupts if there is no way to generate them. 382 * However, some drivers may have a polling mode (e.g. pciehp_poll_mode) 383 * that can be used in the absence of irqs. Allow them to determine 384 * if that is to be used. 385 */ 386 status = init_service_irqs(dev, irqs, capabilities); 387 if (status) { 388 capabilities &= PCIE_PORT_SERVICE_VC | PCIE_PORT_SERVICE_HP; 389 if (!capabilities) 390 goto error_disable; 391 } 392 393 /* Allocate child services if any */ 394 status = -ENODEV; 395 nr_service = 0; 396 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) { 397 int service = 1 << i; 398 if (!(capabilities & service)) 399 continue; 400 if (!pcie_device_init(dev, service, irqs[i])) 401 nr_service++; 402 } 403 if (!nr_service) 404 goto error_cleanup_irqs; 405 406 return 0; 407 408error_cleanup_irqs: 409 cleanup_service_irqs(dev); 410error_disable: 411 pci_disable_device(dev); 412 return status; 413} 414 415#ifdef CONFIG_PM 416static int suspend_iter(struct device *dev, void *data) 417{ 418 struct pcie_port_service_driver *service_driver; 419 420 if ((dev->bus == &pcie_port_bus_type) && dev->driver) { 421 service_driver = to_service_driver(dev->driver); 422 if (service_driver->suspend) 423 service_driver->suspend(to_pcie_device(dev)); 424 } 425 return 0; 426} 427 428/** 429 * pcie_port_device_suspend - suspend port services associated with a PCIe port 430 * @dev: PCI Express port to handle 431 */ 432int pcie_port_device_suspend(struct device *dev) 433{ 434 return device_for_each_child(dev, NULL, suspend_iter); 435} 436 437static int resume_iter(struct device *dev, void *data) 438{ 439 struct pcie_port_service_driver *service_driver; 440 441 if ((dev->bus == &pcie_port_bus_type) && 442 (dev->driver)) { 443 service_driver = to_service_driver(dev->driver); 444 if (service_driver->resume) 445 service_driver->resume(to_pcie_device(dev)); 446 } 447 return 0; 448} 449 450/** 451 * pcie_port_device_suspend - resume port services associated with a PCIe port 452 * @dev: PCI Express port to handle 453 */ 454int pcie_port_device_resume(struct device *dev) 455{ 456 return device_for_each_child(dev, NULL, resume_iter); 457} 458#endif /* PM */ 459 460static int remove_iter(struct device *dev, void *data) 461{ 462 if (dev->bus == &pcie_port_bus_type) 463 device_unregister(dev); 464 return 0; 465} 466 467/** 468 * pcie_port_device_remove - unregister PCI Express port service devices 469 * @dev: PCI Express port the service devices to unregister are associated with 470 * 471 * Remove PCI Express port service devices associated with given port and 472 * disable MSI-X or MSI for the port. 473 */ 474void pcie_port_device_remove(struct pci_dev *dev) 475{ 476 device_for_each_child(&dev->dev, NULL, remove_iter); 477 cleanup_service_irqs(dev); 478 pci_disable_device(dev); 479} 480 481/** 482 * pcie_port_probe_service - probe driver for given PCI Express port service 483 * @dev: PCI Express port service device to probe against 484 * 485 * If PCI Express port service driver is registered with 486 * pcie_port_service_register(), this function will be called by the driver core 487 * whenever match is found between the driver and a port service device. 488 */ 489static int pcie_port_probe_service(struct device *dev) 490{ 491 struct pcie_device *pciedev; 492 struct pcie_port_service_driver *driver; 493 int status; 494 495 if (!dev || !dev->driver) 496 return -ENODEV; 497 498 driver = to_service_driver(dev->driver); 499 if (!driver || !driver->probe) 500 return -ENODEV; 501 502 pciedev = to_pcie_device(dev); 503 status = driver->probe(pciedev); 504 if (status) 505 return status; 506 507 dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n", driver->name); 508 get_device(dev); 509 return 0; 510} 511 512/** 513 * pcie_port_remove_service - detach driver from given PCI Express port service 514 * @dev: PCI Express port service device to handle 515 * 516 * If PCI Express port service driver is registered with 517 * pcie_port_service_register(), this function will be called by the driver core 518 * when device_unregister() is called for the port service device associated 519 * with the driver. 520 */ 521static int pcie_port_remove_service(struct device *dev) 522{ 523 struct pcie_device *pciedev; 524 struct pcie_port_service_driver *driver; 525 526 if (!dev || !dev->driver) 527 return 0; 528 529 pciedev = to_pcie_device(dev); 530 driver = to_service_driver(dev->driver); 531 if (driver && driver->remove) { 532 dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n", 533 driver->name); 534 driver->remove(pciedev); 535 put_device(dev); 536 } 537 return 0; 538} 539 540/** 541 * pcie_port_shutdown_service - shut down given PCI Express port service 542 * @dev: PCI Express port service device to handle 543 * 544 * If PCI Express port service driver is registered with 545 * pcie_port_service_register(), this function will be called by the driver core 546 * when device_shutdown() is called for the port service device associated 547 * with the driver. 548 */ 549static void pcie_port_shutdown_service(struct device *dev) {} 550 551/** 552 * pcie_port_service_register - register PCI Express port service driver 553 * @new: PCI Express port service driver to register 554 */ 555int pcie_port_service_register(struct pcie_port_service_driver *new) 556{ 557 if (pcie_ports_disabled) 558 return -ENODEV; 559 560 new->driver.name = new->name; 561 new->driver.bus = &pcie_port_bus_type; 562 new->driver.probe = pcie_port_probe_service; 563 new->driver.remove = pcie_port_remove_service; 564 new->driver.shutdown = pcie_port_shutdown_service; 565 566 return driver_register(&new->driver); 567} 568EXPORT_SYMBOL(pcie_port_service_register); 569 570/** 571 * pcie_port_service_unregister - unregister PCI Express port service driver 572 * @drv: PCI Express port service driver to unregister 573 */ 574void pcie_port_service_unregister(struct pcie_port_service_driver *drv) 575{ 576 driver_unregister(&drv->driver); 577} 578EXPORT_SYMBOL(pcie_port_service_unregister); 579