1 /* 2 * PCIe Native PME support 3 * 4 * Copyright (C) 2007 - 2009 Intel Corp 5 * Copyright (C) 2007 - 2009 Shaohua Li <shaohua.li@intel.com> 6 * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc. 7 * 8 * This file is subject to the terms and conditions of the GNU General Public 9 * License V2. See the file "COPYING" in the main directory of this archive 10 * for more details. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/pci.h> 15 #include <linux/kernel.h> 16 #include <linux/errno.h> 17 #include <linux/slab.h> 18 #include <linux/init.h> 19 #include <linux/interrupt.h> 20 #include <linux/device.h> 21 #include <linux/pcieport_if.h> 22 #include <linux/pm_runtime.h> 23 24 #include "../pci.h" 25 #include "portdrv.h" 26 27 /* 28 * If this switch is set, MSI will not be used for PCIe PME signaling. This 29 * causes the PCIe port driver to use INTx interrupts only, but it turns out 30 * that using MSI for PCIe PME signaling doesn't play well with PCIe PME-based 31 * wake-up from system sleep states. 32 */ 33 bool pcie_pme_msi_disabled; 34 35 static int __init pcie_pme_setup(char *str) 36 { 37 if (!strncmp(str, "nomsi", 5)) 38 pcie_pme_msi_disabled = true; 39 40 return 1; 41 } 42 __setup("pcie_pme=", pcie_pme_setup); 43 44 struct pcie_pme_service_data { 45 spinlock_t lock; 46 struct pcie_device *srv; 47 struct work_struct work; 48 bool noirq; /* Don't enable the PME interrupt used by this service. */ 49 }; 50 51 /** 52 * pcie_pme_interrupt_enable - Enable/disable PCIe PME interrupt generation. 53 * @dev: PCIe root port or event collector. 54 * @enable: Enable or disable the interrupt. 55 */ 56 void pcie_pme_interrupt_enable(struct pci_dev *dev, bool enable) 57 { 58 if (enable) 59 pcie_capability_set_word(dev, PCI_EXP_RTCTL, 60 PCI_EXP_RTCTL_PMEIE); 61 else 62 pcie_capability_clear_word(dev, PCI_EXP_RTCTL, 63 PCI_EXP_RTCTL_PMEIE); 64 } 65 66 /** 67 * pcie_pme_walk_bus - Scan a PCI bus for devices asserting PME#. 68 * @bus: PCI bus to scan. 69 * 70 * Scan given PCI bus and all buses under it for devices asserting PME#. 71 */ 72 static bool pcie_pme_walk_bus(struct pci_bus *bus) 73 { 74 struct pci_dev *dev; 75 bool ret = false; 76 77 list_for_each_entry(dev, &bus->devices, bus_list) { 78 /* Skip PCIe devices in case we started from a root port. */ 79 if (!pci_is_pcie(dev) && pci_check_pme_status(dev)) { 80 if (dev->pme_poll) 81 dev->pme_poll = false; 82 83 pci_wakeup_event(dev); 84 pm_request_resume(&dev->dev); 85 ret = true; 86 } 87 88 if (dev->subordinate && pcie_pme_walk_bus(dev->subordinate)) 89 ret = true; 90 } 91 92 return ret; 93 } 94 95 /** 96 * pcie_pme_from_pci_bridge - Check if PCIe-PCI bridge generated a PME. 97 * @bus: Secondary bus of the bridge. 98 * @devfn: Device/function number to check. 99 * 100 * PME from PCI devices under a PCIe-PCI bridge may be converted to an in-band 101 * PCIe PME message. In such that case the bridge should use the Requester ID 102 * of device/function number 0 on its secondary bus. 103 */ 104 static bool pcie_pme_from_pci_bridge(struct pci_bus *bus, u8 devfn) 105 { 106 struct pci_dev *dev; 107 bool found = false; 108 109 if (devfn) 110 return false; 111 112 dev = pci_dev_get(bus->self); 113 if (!dev) 114 return false; 115 116 if (pci_is_pcie(dev) && pci_pcie_type(dev) == PCI_EXP_TYPE_PCI_BRIDGE) { 117 down_read(&pci_bus_sem); 118 if (pcie_pme_walk_bus(bus)) 119 found = true; 120 up_read(&pci_bus_sem); 121 } 122 123 pci_dev_put(dev); 124 return found; 125 } 126 127 /** 128 * pcie_pme_handle_request - Find device that generated PME and handle it. 129 * @port: Root port or event collector that generated the PME interrupt. 130 * @req_id: PCIe Requester ID of the device that generated the PME. 131 */ 132 static void pcie_pme_handle_request(struct pci_dev *port, u16 req_id) 133 { 134 u8 busnr = req_id >> 8, devfn = req_id & 0xff; 135 struct pci_bus *bus; 136 struct pci_dev *dev; 137 bool found = false; 138 139 /* First, check if the PME is from the root port itself. */ 140 if (port->devfn == devfn && port->bus->number == busnr) { 141 if (port->pme_poll) 142 port->pme_poll = false; 143 144 if (pci_check_pme_status(port)) { 145 pm_request_resume(&port->dev); 146 found = true; 147 } else { 148 /* 149 * Apparently, the root port generated the PME on behalf 150 * of a non-PCIe device downstream. If this is done by 151 * a root port, the Requester ID field in its status 152 * register may contain either the root port's, or the 153 * source device's information (PCI Express Base 154 * Specification, Rev. 2.0, Section 6.1.9). 155 */ 156 down_read(&pci_bus_sem); 157 found = pcie_pme_walk_bus(port->subordinate); 158 up_read(&pci_bus_sem); 159 } 160 goto out; 161 } 162 163 /* Second, find the bus the source device is on. */ 164 bus = pci_find_bus(pci_domain_nr(port->bus), busnr); 165 if (!bus) 166 goto out; 167 168 /* Next, check if the PME is from a PCIe-PCI bridge. */ 169 found = pcie_pme_from_pci_bridge(bus, devfn); 170 if (found) 171 goto out; 172 173 /* Finally, try to find the PME source on the bus. */ 174 down_read(&pci_bus_sem); 175 list_for_each_entry(dev, &bus->devices, bus_list) { 176 pci_dev_get(dev); 177 if (dev->devfn == devfn) { 178 found = true; 179 break; 180 } 181 pci_dev_put(dev); 182 } 183 up_read(&pci_bus_sem); 184 185 if (found) { 186 /* The device is there, but we have to check its PME status. */ 187 found = pci_check_pme_status(dev); 188 if (found) { 189 if (dev->pme_poll) 190 dev->pme_poll = false; 191 192 pci_wakeup_event(dev); 193 pm_request_resume(&dev->dev); 194 } 195 pci_dev_put(dev); 196 } else if (devfn) { 197 /* 198 * The device is not there, but we can still try to recover by 199 * assuming that the PME was reported by a PCIe-PCI bridge that 200 * used devfn different from zero. 201 */ 202 dev_dbg(&port->dev, "PME interrupt generated for non-existent device %02x:%02x.%d\n", 203 busnr, PCI_SLOT(devfn), PCI_FUNC(devfn)); 204 found = pcie_pme_from_pci_bridge(bus, 0); 205 } 206 207 out: 208 if (!found) 209 dev_dbg(&port->dev, "Spurious native PME interrupt!\n"); 210 } 211 212 /** 213 * pcie_pme_work_fn - Work handler for PCIe PME interrupt. 214 * @work: Work structure giving access to service data. 215 */ 216 static void pcie_pme_work_fn(struct work_struct *work) 217 { 218 struct pcie_pme_service_data *data = 219 container_of(work, struct pcie_pme_service_data, work); 220 struct pci_dev *port = data->srv->port; 221 u32 rtsta; 222 223 spin_lock_irq(&data->lock); 224 225 for (;;) { 226 if (data->noirq) 227 break; 228 229 pcie_capability_read_dword(port, PCI_EXP_RTSTA, &rtsta); 230 if (rtsta & PCI_EXP_RTSTA_PME) { 231 /* 232 * Clear PME status of the port. If there are other 233 * pending PMEs, the status will be set again. 234 */ 235 pcie_clear_root_pme_status(port); 236 237 spin_unlock_irq(&data->lock); 238 pcie_pme_handle_request(port, rtsta & 0xffff); 239 spin_lock_irq(&data->lock); 240 241 continue; 242 } 243 244 /* No need to loop if there are no more PMEs pending. */ 245 if (!(rtsta & PCI_EXP_RTSTA_PENDING)) 246 break; 247 248 spin_unlock_irq(&data->lock); 249 cpu_relax(); 250 spin_lock_irq(&data->lock); 251 } 252 253 if (!data->noirq) 254 pcie_pme_interrupt_enable(port, true); 255 256 spin_unlock_irq(&data->lock); 257 } 258 259 /** 260 * pcie_pme_irq - Interrupt handler for PCIe root port PME interrupt. 261 * @irq: Interrupt vector. 262 * @context: Interrupt context pointer. 263 */ 264 static irqreturn_t pcie_pme_irq(int irq, void *context) 265 { 266 struct pci_dev *port; 267 struct pcie_pme_service_data *data; 268 u32 rtsta; 269 unsigned long flags; 270 271 port = ((struct pcie_device *)context)->port; 272 data = get_service_data((struct pcie_device *)context); 273 274 spin_lock_irqsave(&data->lock, flags); 275 pcie_capability_read_dword(port, PCI_EXP_RTSTA, &rtsta); 276 277 if (!(rtsta & PCI_EXP_RTSTA_PME)) { 278 spin_unlock_irqrestore(&data->lock, flags); 279 return IRQ_NONE; 280 } 281 282 pcie_pme_interrupt_enable(port, false); 283 spin_unlock_irqrestore(&data->lock, flags); 284 285 /* We don't use pm_wq, because it's freezable. */ 286 schedule_work(&data->work); 287 288 return IRQ_HANDLED; 289 } 290 291 /** 292 * pcie_pme_set_native - Set the PME interrupt flag for given device. 293 * @dev: PCI device to handle. 294 * @ign: Ignored. 295 */ 296 static int pcie_pme_set_native(struct pci_dev *dev, void *ign) 297 { 298 dev_info(&dev->dev, "Signaling PME through PCIe PME interrupt\n"); 299 300 device_set_run_wake(&dev->dev, true); 301 dev->pme_interrupt = true; 302 return 0; 303 } 304 305 /** 306 * pcie_pme_mark_devices - Set the PME interrupt flag for devices below a port. 307 * @port: PCIe root port or event collector to handle. 308 * 309 * For each device below given root port, including the port itself (or for each 310 * root complex integrated endpoint if @port is a root complex event collector) 311 * set the flag indicating that it can signal run-time wake-up events via PCIe 312 * PME interrupts. 313 */ 314 static void pcie_pme_mark_devices(struct pci_dev *port) 315 { 316 pcie_pme_set_native(port, NULL); 317 if (port->subordinate) { 318 pci_walk_bus(port->subordinate, pcie_pme_set_native, NULL); 319 } else { 320 struct pci_bus *bus = port->bus; 321 struct pci_dev *dev; 322 323 /* Check if this is a root port event collector. */ 324 if (pci_pcie_type(port) != PCI_EXP_TYPE_RC_EC || !bus) 325 return; 326 327 down_read(&pci_bus_sem); 328 list_for_each_entry(dev, &bus->devices, bus_list) 329 if (pci_is_pcie(dev) 330 && pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END) 331 pcie_pme_set_native(dev, NULL); 332 up_read(&pci_bus_sem); 333 } 334 } 335 336 /** 337 * pcie_pme_probe - Initialize PCIe PME service for given root port. 338 * @srv: PCIe service to initialize. 339 */ 340 static int pcie_pme_probe(struct pcie_device *srv) 341 { 342 struct pci_dev *port; 343 struct pcie_pme_service_data *data; 344 int ret; 345 346 data = kzalloc(sizeof(*data), GFP_KERNEL); 347 if (!data) 348 return -ENOMEM; 349 350 spin_lock_init(&data->lock); 351 INIT_WORK(&data->work, pcie_pme_work_fn); 352 data->srv = srv; 353 set_service_data(srv, data); 354 355 port = srv->port; 356 pcie_pme_interrupt_enable(port, false); 357 pcie_clear_root_pme_status(port); 358 359 ret = request_irq(srv->irq, pcie_pme_irq, IRQF_SHARED, "PCIe PME", srv); 360 if (ret) { 361 kfree(data); 362 } else { 363 pcie_pme_mark_devices(port); 364 pcie_pme_interrupt_enable(port, true); 365 } 366 367 return ret; 368 } 369 370 /** 371 * pcie_pme_suspend - Suspend PCIe PME service device. 372 * @srv: PCIe service device to suspend. 373 */ 374 static int pcie_pme_suspend(struct pcie_device *srv) 375 { 376 struct pcie_pme_service_data *data = get_service_data(srv); 377 struct pci_dev *port = srv->port; 378 379 spin_lock_irq(&data->lock); 380 pcie_pme_interrupt_enable(port, false); 381 pcie_clear_root_pme_status(port); 382 data->noirq = true; 383 spin_unlock_irq(&data->lock); 384 385 synchronize_irq(srv->irq); 386 387 return 0; 388 } 389 390 /** 391 * pcie_pme_resume - Resume PCIe PME service device. 392 * @srv - PCIe service device to resume. 393 */ 394 static int pcie_pme_resume(struct pcie_device *srv) 395 { 396 struct pcie_pme_service_data *data = get_service_data(srv); 397 struct pci_dev *port = srv->port; 398 399 spin_lock_irq(&data->lock); 400 data->noirq = false; 401 pcie_clear_root_pme_status(port); 402 pcie_pme_interrupt_enable(port, true); 403 spin_unlock_irq(&data->lock); 404 405 return 0; 406 } 407 408 /** 409 * pcie_pme_remove - Prepare PCIe PME service device for removal. 410 * @srv - PCIe service device to remove. 411 */ 412 static void pcie_pme_remove(struct pcie_device *srv) 413 { 414 pcie_pme_suspend(srv); 415 free_irq(srv->irq, srv); 416 kfree(get_service_data(srv)); 417 } 418 419 static struct pcie_port_service_driver pcie_pme_driver = { 420 .name = "pcie_pme", 421 .port_type = PCI_EXP_TYPE_ROOT_PORT, 422 .service = PCIE_PORT_SERVICE_PME, 423 424 .probe = pcie_pme_probe, 425 .suspend = pcie_pme_suspend, 426 .resume = pcie_pme_resume, 427 .remove = pcie_pme_remove, 428 }; 429 430 /** 431 * pcie_pme_service_init - Register the PCIe PME service driver. 432 */ 433 static int __init pcie_pme_service_init(void) 434 { 435 return pcie_port_service_register(&pcie_pme_driver); 436 } 437 438 module_init(pcie_pme_service_init); 439