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