Pileus Git - ~andy/linux/blob - drivers/pci/pcie/portdrv_core.c

   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
  22 bool pciehp_msi_disabled;
  23
  24 static 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  */
  40 static 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 aleady in the array
  50  *
  51  * Return value: Position of the added entry in the array
  52  */
  53 static 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  */
  74 static 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_table_size(dev);
  83         if (!nr_entries)
  84                 return -EINVAL;
  85         if (nr_entries > PCIE_PORT_MAX_MSIX_ENTRIES)
  86                 nr_entries = PCIE_PORT_MAX_MSIX_ENTRIES;
  87
  88         msix_entries = kzalloc(sizeof(*msix_entries) * nr_entries, GFP_KERNEL);
  89         if (!msix_entries)
  90                 return -ENOMEM;
  91
  92         /*
  93          * Allocate as many entries as the port wants, so that we can check
  94          * which of them will be useful.  Moreover, if nr_entries is correctly
  95          * equal to the number of entries this port actually uses, we'll happily
  96          * go through without any tricks.
  97          */
  98         for (i = 0; i < nr_entries; i++)
  99                 msix_entries[i].entry = i;
 100
 101         status = pci_enable_msix(dev, msix_entries, nr_entries);
 102         if (status)
 103                 goto Exit;
 104
 105         for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
 106                 idx[i] = -1;
 107         status = -EIO;
 108         nvec = 0;
 109
 110         if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) {
 111                 int entry;
 112
 113                 /*
 114                  * The code below follows the PCI Express Base Specification 2.0
 115                  * stating in Section 6.1.6 that "PME and Hot-Plug Event
 116                  * interrupts (when both are implemented) always share the same
 117                  * MSI or MSI-X vector, as indicated by the Interrupt Message
 118                  * Number field in the PCI Express Capabilities register", where
 119                  * according to Section 7.8.2 of the specification "For MSI-X,
 120                  * the value in this field indicates which MSI-X Table entry is
 121                  * used to generate the interrupt message."
 122                  */
 123                 pos = pci_pcie_cap(dev);
 124                 pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &reg16);
 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, &reg32);
 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(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  */
 199 static int init_service_irqs(struct pci_dev *dev, int *irqs, int mask)
 200 {
 201         int i, irq = -1;
 202
 203         /* We have to use INTx if MSI cannot be used for PCIe PME or pciehp. */
 204         if (((mask & PCIE_PORT_SERVICE_PME) && pcie_pme_no_msi()) ||
 205             ((mask & PCIE_PORT_SERVICE_HP) && pciehp_no_msi())) {
 206                 if (dev->pin)
 207                         irq = dev->irq;
 208                 goto no_msi;
 209         }
 210
 211         /* Try to use MSI-X if supported */
 212         if (!pcie_port_enable_msix(dev, irqs, mask))
 213                 return 0;
 214
 215         /* We're not going to use MSI-X, so try MSI and fall back to INTx */
 216         if (!pci_enable_msi(dev) || dev->pin)
 217                 irq = dev->irq;
 218
 219  no_msi:
 220         for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
 221                 irqs[i] = irq;
 222         irqs[PCIE_PORT_SERVICE_VC_SHIFT] = -1;
 223
 224         if (irq < 0)
 225                 return -ENODEV;
 226         return 0;
 227 }
 228
 229 static void cleanup_service_irqs(struct pci_dev *dev)
 230 {
 231         if (dev->msix_enabled)
 232                 pci_disable_msix(dev);
 233         else if (dev->msi_enabled)
 234                 pci_disable_msi(dev);
 235 }
 236
 237 /**
 238  * get_port_device_capability - discover capabilities of a PCI Express port
 239  * @dev: PCI Express port to examine
 240  *
 241  * The capabilities are read from the port's PCI Express configuration registers
 242  * as described in PCI Express Base Specification 1.0a sections 7.8.2, 7.8.9 and
 243  * 7.9 - 7.11.
 244  *
 245  * Return value: Bitmask of discovered port capabilities
 246  */
 247 static int get_port_device_capability(struct pci_dev *dev)
 248 {
 249         int services = 0, pos;
 250         u16 reg16;
 251         u32 reg32;
 252         int cap_mask = 0;
 253         int err;
 254
 255         if (pcie_ports_disabled)
 256                 return 0;
 257
 258         err = pcie_port_platform_notify(dev, &cap_mask);
 259         if (!pcie_ports_auto) {
 260                 cap_mask = PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP
 261                                 | PCIE_PORT_SERVICE_VC;
 262                 if (pci_aer_available())
 263                         cap_mask |= PCIE_PORT_SERVICE_AER;
 264         } else if (err) {
 265                         return 0;
 266         }
 267
 268         pos = pci_pcie_cap(dev);
 269         pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &reg16);
 270         /* Hot-Plug Capable */
 271         if ((cap_mask & PCIE_PORT_SERVICE_HP) && (reg16 & PCI_EXP_FLAGS_SLOT)) {
 272                 pci_read_config_dword(dev, pos + PCI_EXP_SLTCAP, &reg32);
 273                 if (reg32 & PCI_EXP_SLTCAP_HPC) {
 274                         services |= PCIE_PORT_SERVICE_HP;
 275                         /*
 276                          * Disable hot-plug interrupts in case they have been
 277                          * enabled by the BIOS and the hot-plug service driver
 278                          * is not loaded.
 279                          */
 280                         pos += PCI_EXP_SLTCTL;
 281                         pci_read_config_word(dev, pos, &reg16);
 282                         reg16 &= ~(PCI_EXP_SLTCTL_CCIE | PCI_EXP_SLTCTL_HPIE);
 283                         pci_write_config_word(dev, pos, reg16);
 284                 }
 285         }
 286         /* AER capable */
 287         if ((cap_mask & PCIE_PORT_SERVICE_AER)
 288             && pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR)) {
 289                 services |= PCIE_PORT_SERVICE_AER;
 290                 /*
 291                  * Disable AER on this port in case it's been enabled by the
 292                  * BIOS (the AER service driver will enable it when necessary).
 293                  */
 294                 pci_disable_pcie_error_reporting(dev);
 295         }
 296         /* VC support */
 297         if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
 298                 services |= PCIE_PORT_SERVICE_VC;
 299         /* Root ports are capable of generating PME too */
 300         if ((cap_mask & PCIE_PORT_SERVICE_PME)
 301             && dev->pcie_type == PCI_EXP_TYPE_ROOT_PORT) {
 302                 services |= PCIE_PORT_SERVICE_PME;
 303                 /*
 304                  * Disable PME interrupt on this port in case it's been enabled
 305                  * by the BIOS (the PME service driver will enable it when
 306                  * necessary).
 307                  */
 308                 pcie_pme_interrupt_enable(dev, false);
 309         }
 310
 311         return services;
 312 }
 313
 314 /**
 315  * pcie_device_init - allocate and initialize PCI Express port service device
 316  * @pdev: PCI Express port to associate the service device with
 317  * @service: Type of service to associate with the service device
 318  * @irq: Interrupt vector to associate with the service device
 319  */
 320 static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
 321 {
 322         int retval;
 323         struct pcie_device *pcie;
 324         struct device *device;
 325
 326         pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
 327         if (!pcie)
 328                 return -ENOMEM;
 329         pcie->port = pdev;
 330         pcie->irq = irq;
 331         pcie->service = service;
 332
 333         /* Initialize generic device interface */
 334         device = &pcie->device;
 335         device->bus = &pcie_port_bus_type;
 336         device->release = release_pcie_device;  /* callback to free pcie dev */
 337         dev_set_name(device, "%s:pcie%02x",
 338                      pci_name(pdev),
 339                      get_descriptor_id(pdev->pcie_type, service));
 340         device->parent = &pdev->dev;
 341         device_enable_async_suspend(device);
 342
 343         retval = device_register(device);
 344         if (retval)
 345                 kfree(pcie);
 346         else
 347                 get_device(device);
 348         return retval;
 349 }
 350
 351 /**
 352  * pcie_port_device_register - register PCI Express port
 353  * @dev: PCI Express port to register
 354  *
 355  * Allocate the port extension structure and register services associated with
 356  * the port.
 357  */
 358 int pcie_port_device_register(struct pci_dev *dev)
 359 {
 360         int status, capabilities, i, nr_service;
 361         int irqs[PCIE_PORT_DEVICE_MAXSERVICES];
 362
 363         /* Enable PCI Express port device */
 364         status = pci_enable_device(dev);
 365         if (status)
 366                 return status;
 367
 368         /* Get and check PCI Express port services */
 369         capabilities = get_port_device_capability(dev);
 370         if (!capabilities)
 371                 return 0;
 372
 373         pci_set_master(dev);
 374         /*
 375          * Initialize service irqs. Don't use service devices that
 376          * require interrupts if there is no way to generate them.
 377          */
 378         status = init_service_irqs(dev, irqs, capabilities);
 379         if (status) {
 380                 capabilities &= PCIE_PORT_SERVICE_VC;
 381                 if (!capabilities)
 382                         goto error_disable;
 383         }
 384
 385         /* Allocate child services if any */
 386         status = -ENODEV;
 387         nr_service = 0;
 388         for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
 389                 int service = 1 << i;
 390                 if (!(capabilities & service))
 391                         continue;
 392                 if (!pcie_device_init(dev, service, irqs[i]))
 393                         nr_service++;
 394         }
 395         if (!nr_service)
 396                 goto error_cleanup_irqs;
 397
 398         return 0;
 399
 400 error_cleanup_irqs:
 401         cleanup_service_irqs(dev);
 402 error_disable:
 403         pci_disable_device(dev);
 404         return status;
 405 }
 406
 407 #ifdef CONFIG_PM
 408 static int suspend_iter(struct device *dev, void *data)
 409 {
 410         struct pcie_port_service_driver *service_driver;
 411
 412         if ((dev->bus == &pcie_port_bus_type) && dev->driver) {
 413                 service_driver = to_service_driver(dev->driver);
 414                 if (service_driver->suspend)
 415                         service_driver->suspend(to_pcie_device(dev));
 416         }
 417         return 0;
 418 }
 419
 420 /**
 421  * pcie_port_device_suspend - suspend port services associated with a PCIe port
 422  * @dev: PCI Express port to handle
 423  */
 424 int pcie_port_device_suspend(struct device *dev)
 425 {
 426         return device_for_each_child(dev, NULL, suspend_iter);
 427 }
 428
 429 static int resume_iter(struct device *dev, void *data)
 430 {
 431         struct pcie_port_service_driver *service_driver;
 432
 433         if ((dev->bus == &pcie_port_bus_type) &&
 434             (dev->driver)) {
 435                 service_driver = to_service_driver(dev->driver);
 436                 if (service_driver->resume)
 437                         service_driver->resume(to_pcie_device(dev));
 438         }
 439         return 0;
 440 }
 441
 442 /**
 443  * pcie_port_device_suspend - resume port services associated with a PCIe port
 444  * @dev: PCI Express port to handle
 445  */
 446 int pcie_port_device_resume(struct device *dev)
 447 {
 448         return device_for_each_child(dev, NULL, resume_iter);
 449 }
 450 #endif /* PM */
 451
 452 static int remove_iter(struct device *dev, void *data)
 453 {
 454         if (dev->bus == &pcie_port_bus_type) {
 455                 put_device(dev);
 456                 device_unregister(dev);
 457         }
 458         return 0;
 459 }
 460
 461 /**
 462  * pcie_port_device_remove - unregister PCI Express port service devices
 463  * @dev: PCI Express port the service devices to unregister are associated with
 464  *
 465  * Remove PCI Express port service devices associated with given port and
 466  * disable MSI-X or MSI for the port.
 467  */
 468 void pcie_port_device_remove(struct pci_dev *dev)
 469 {
 470         device_for_each_child(&dev->dev, NULL, remove_iter);
 471         cleanup_service_irqs(dev);
 472         pci_disable_device(dev);
 473 }
 474
 475 /**
 476  * pcie_port_probe_service - probe driver for given PCI Express port service
 477  * @dev: PCI Express port service device to probe against
 478  *
 479  * If PCI Express port service driver is registered with
 480  * pcie_port_service_register(), this function will be called by the driver core
 481  * whenever match is found between the driver and a port service device.
 482  */
 483 static int pcie_port_probe_service(struct device *dev)
 484 {
 485         struct pcie_device *pciedev;
 486         struct pcie_port_service_driver *driver;
 487         int status;
 488
 489         if (!dev || !dev->driver)
 490                 return -ENODEV;
 491
 492         driver = to_service_driver(dev->driver);
 493         if (!driver || !driver->probe)
 494                 return -ENODEV;
 495
 496         pciedev = to_pcie_device(dev);
 497         status = driver->probe(pciedev);
 498         if (!status) {
 499                 dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n",
 500                         driver->name);
 501                 get_device(dev);
 502         }
 503         return status;
 504 }
 505
 506 /**
 507  * pcie_port_remove_service - detach driver from given PCI Express port service
 508  * @dev: PCI Express port service device to handle
 509  *
 510  * If PCI Express port service driver is registered with
 511  * pcie_port_service_register(), this function will be called by the driver core
 512  * when device_unregister() is called for the port service device associated
 513  * with the driver.
 514  */
 515 static int pcie_port_remove_service(struct device *dev)
 516 {
 517         struct pcie_device *pciedev;
 518         struct pcie_port_service_driver *driver;
 519
 520         if (!dev || !dev->driver)
 521                 return 0;
 522
 523         pciedev = to_pcie_device(dev);
 524         driver = to_service_driver(dev->driver);
 525         if (driver && driver->remove) {
 526                 dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n",
 527                         driver->name);
 528                 driver->remove(pciedev);
 529                 put_device(dev);
 530         }
 531         return 0;
 532 }
 533
 534 /**
 535  * pcie_port_shutdown_service - shut down given PCI Express port service
 536  * @dev: PCI Express port service device to handle
 537  *
 538  * If PCI Express port service driver is registered with
 539  * pcie_port_service_register(), this function will be called by the driver core
 540  * when device_shutdown() is called for the port service device associated
 541  * with the driver.
 542  */
 543 static void pcie_port_shutdown_service(struct device *dev) {}
 544
 545 /**
 546  * pcie_port_service_register - register PCI Express port service driver
 547  * @new: PCI Express port service driver to register
 548  */
 549 int pcie_port_service_register(struct pcie_port_service_driver *new)
 550 {
 551         if (pcie_ports_disabled)
 552                 return -ENODEV;
 553
 554         new->driver.name = (char *)new->name;
 555         new->driver.bus = &pcie_port_bus_type;
 556         new->driver.probe = pcie_port_probe_service;
 557         new->driver.remove = pcie_port_remove_service;
 558         new->driver.shutdown = pcie_port_shutdown_service;
 559
 560         return driver_register(&new->driver);
 561 }
 562 EXPORT_SYMBOL(pcie_port_service_register);
 563
 564 /**
 565  * pcie_port_service_unregister - unregister PCI Express port service driver
 566  * @drv: PCI Express port service driver to unregister
 567  */
 568 void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
 569 {
 570         driver_unregister(&drv->driver);
 571 }
 572 EXPORT_SYMBOL(pcie_port_service_unregister);