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