forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
471 lines
11 KiB
471 lines
11 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* PCIe Native PME support |
|
* |
|
* Copyright (C) 2007 - 2009 Intel Corp |
|
* Copyright (C) 2007 - 2009 Shaohua Li <[email protected]> |
|
* Copyright (C) 2009 Rafael J. Wysocki <[email protected]>, Novell Inc. |
|
*/ |
|
|
|
#define dev_fmt(fmt) "PME: " fmt |
|
|
|
#include <linux/pci.h> |
|
#include <linux/kernel.h> |
|
#include <linux/errno.h> |
|
#include <linux/slab.h> |
|
#include <linux/init.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/device.h> |
|
#include <linux/pm_runtime.h> |
|
|
|
#include "../pci.h" |
|
#include "portdrv.h" |
|
|
|
/* |
|
* If this switch is set, MSI will not be used for PCIe PME signaling. This |
|
* causes the PCIe port driver to use INTx interrupts only, but it turns out |
|
* that using MSI for PCIe PME signaling doesn't play well with PCIe PME-based |
|
* wake-up from system sleep states. |
|
*/ |
|
bool pcie_pme_msi_disabled; |
|
|
|
static int __init pcie_pme_setup(char *str) |
|
{ |
|
if (!strncmp(str, "nomsi", 5)) |
|
pcie_pme_msi_disabled = true; |
|
|
|
return 1; |
|
} |
|
__setup("pcie_pme=", pcie_pme_setup); |
|
|
|
struct pcie_pme_service_data { |
|
spinlock_t lock; |
|
struct pcie_device *srv; |
|
struct work_struct work; |
|
bool noirq; /* If set, keep the PME interrupt disabled. */ |
|
}; |
|
|
|
/** |
|
* pcie_pme_interrupt_enable - Enable/disable PCIe PME interrupt generation. |
|
* @dev: PCIe root port or event collector. |
|
* @enable: Enable or disable the interrupt. |
|
*/ |
|
void pcie_pme_interrupt_enable(struct pci_dev *dev, bool enable) |
|
{ |
|
if (enable) |
|
pcie_capability_set_word(dev, PCI_EXP_RTCTL, |
|
PCI_EXP_RTCTL_PMEIE); |
|
else |
|
pcie_capability_clear_word(dev, PCI_EXP_RTCTL, |
|
PCI_EXP_RTCTL_PMEIE); |
|
} |
|
|
|
/** |
|
* pcie_pme_walk_bus - Scan a PCI bus for devices asserting PME#. |
|
* @bus: PCI bus to scan. |
|
* |
|
* Scan given PCI bus and all buses under it for devices asserting PME#. |
|
*/ |
|
static bool pcie_pme_walk_bus(struct pci_bus *bus) |
|
{ |
|
struct pci_dev *dev; |
|
bool ret = false; |
|
|
|
list_for_each_entry(dev, &bus->devices, bus_list) { |
|
/* Skip PCIe devices in case we started from a root port. */ |
|
if (!pci_is_pcie(dev) && pci_check_pme_status(dev)) { |
|
if (dev->pme_poll) |
|
dev->pme_poll = false; |
|
|
|
pci_wakeup_event(dev); |
|
pm_request_resume(&dev->dev); |
|
ret = true; |
|
} |
|
|
|
if (dev->subordinate && pcie_pme_walk_bus(dev->subordinate)) |
|
ret = true; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
/** |
|
* pcie_pme_from_pci_bridge - Check if PCIe-PCI bridge generated a PME. |
|
* @bus: Secondary bus of the bridge. |
|
* @devfn: Device/function number to check. |
|
* |
|
* PME from PCI devices under a PCIe-PCI bridge may be converted to an in-band |
|
* PCIe PME message. In such that case the bridge should use the Requester ID |
|
* of device/function number 0 on its secondary bus. |
|
*/ |
|
static bool pcie_pme_from_pci_bridge(struct pci_bus *bus, u8 devfn) |
|
{ |
|
struct pci_dev *dev; |
|
bool found = false; |
|
|
|
if (devfn) |
|
return false; |
|
|
|
dev = pci_dev_get(bus->self); |
|
if (!dev) |
|
return false; |
|
|
|
if (pci_is_pcie(dev) && pci_pcie_type(dev) == PCI_EXP_TYPE_PCI_BRIDGE) { |
|
down_read(&pci_bus_sem); |
|
if (pcie_pme_walk_bus(bus)) |
|
found = true; |
|
up_read(&pci_bus_sem); |
|
} |
|
|
|
pci_dev_put(dev); |
|
return found; |
|
} |
|
|
|
/** |
|
* pcie_pme_handle_request - Find device that generated PME and handle it. |
|
* @port: Root port or event collector that generated the PME interrupt. |
|
* @req_id: PCIe Requester ID of the device that generated the PME. |
|
*/ |
|
static void pcie_pme_handle_request(struct pci_dev *port, u16 req_id) |
|
{ |
|
u8 busnr = req_id >> 8, devfn = req_id & 0xff; |
|
struct pci_bus *bus; |
|
struct pci_dev *dev; |
|
bool found = false; |
|
|
|
/* First, check if the PME is from the root port itself. */ |
|
if (port->devfn == devfn && port->bus->number == busnr) { |
|
if (port->pme_poll) |
|
port->pme_poll = false; |
|
|
|
if (pci_check_pme_status(port)) { |
|
pm_request_resume(&port->dev); |
|
found = true; |
|
} else { |
|
/* |
|
* Apparently, the root port generated the PME on behalf |
|
* of a non-PCIe device downstream. If this is done by |
|
* a root port, the Requester ID field in its status |
|
* register may contain either the root port's, or the |
|
* source device's information (PCI Express Base |
|
* Specification, Rev. 2.0, Section 6.1.9). |
|
*/ |
|
down_read(&pci_bus_sem); |
|
found = pcie_pme_walk_bus(port->subordinate); |
|
up_read(&pci_bus_sem); |
|
} |
|
goto out; |
|
} |
|
|
|
/* Second, find the bus the source device is on. */ |
|
bus = pci_find_bus(pci_domain_nr(port->bus), busnr); |
|
if (!bus) |
|
goto out; |
|
|
|
/* Next, check if the PME is from a PCIe-PCI bridge. */ |
|
found = pcie_pme_from_pci_bridge(bus, devfn); |
|
if (found) |
|
goto out; |
|
|
|
/* Finally, try to find the PME source on the bus. */ |
|
down_read(&pci_bus_sem); |
|
list_for_each_entry(dev, &bus->devices, bus_list) { |
|
pci_dev_get(dev); |
|
if (dev->devfn == devfn) { |
|
found = true; |
|
break; |
|
} |
|
pci_dev_put(dev); |
|
} |
|
up_read(&pci_bus_sem); |
|
|
|
if (found) { |
|
/* The device is there, but we have to check its PME status. */ |
|
found = pci_check_pme_status(dev); |
|
if (found) { |
|
if (dev->pme_poll) |
|
dev->pme_poll = false; |
|
|
|
pci_wakeup_event(dev); |
|
pm_request_resume(&dev->dev); |
|
} |
|
pci_dev_put(dev); |
|
} else if (devfn) { |
|
/* |
|
* The device is not there, but we can still try to recover by |
|
* assuming that the PME was reported by a PCIe-PCI bridge that |
|
* used devfn different from zero. |
|
*/ |
|
pci_info(port, "interrupt generated for non-existent device %02x:%02x.%d\n", |
|
busnr, PCI_SLOT(devfn), PCI_FUNC(devfn)); |
|
found = pcie_pme_from_pci_bridge(bus, 0); |
|
} |
|
|
|
out: |
|
if (!found) |
|
pci_info(port, "Spurious native interrupt!\n"); |
|
} |
|
|
|
/** |
|
* pcie_pme_work_fn - Work handler for PCIe PME interrupt. |
|
* @work: Work structure giving access to service data. |
|
*/ |
|
static void pcie_pme_work_fn(struct work_struct *work) |
|
{ |
|
struct pcie_pme_service_data *data = |
|
container_of(work, struct pcie_pme_service_data, work); |
|
struct pci_dev *port = data->srv->port; |
|
u32 rtsta; |
|
|
|
spin_lock_irq(&data->lock); |
|
|
|
for (;;) { |
|
if (data->noirq) |
|
break; |
|
|
|
pcie_capability_read_dword(port, PCI_EXP_RTSTA, &rtsta); |
|
if (rtsta == (u32) ~0) |
|
break; |
|
|
|
if (rtsta & PCI_EXP_RTSTA_PME) { |
|
/* |
|
* Clear PME status of the port. If there are other |
|
* pending PMEs, the status will be set again. |
|
*/ |
|
pcie_clear_root_pme_status(port); |
|
|
|
spin_unlock_irq(&data->lock); |
|
pcie_pme_handle_request(port, rtsta & 0xffff); |
|
spin_lock_irq(&data->lock); |
|
|
|
continue; |
|
} |
|
|
|
/* No need to loop if there are no more PMEs pending. */ |
|
if (!(rtsta & PCI_EXP_RTSTA_PENDING)) |
|
break; |
|
|
|
spin_unlock_irq(&data->lock); |
|
cpu_relax(); |
|
spin_lock_irq(&data->lock); |
|
} |
|
|
|
if (!data->noirq) |
|
pcie_pme_interrupt_enable(port, true); |
|
|
|
spin_unlock_irq(&data->lock); |
|
} |
|
|
|
/** |
|
* pcie_pme_irq - Interrupt handler for PCIe root port PME interrupt. |
|
* @irq: Interrupt vector. |
|
* @context: Interrupt context pointer. |
|
*/ |
|
static irqreturn_t pcie_pme_irq(int irq, void *context) |
|
{ |
|
struct pci_dev *port; |
|
struct pcie_pme_service_data *data; |
|
u32 rtsta; |
|
unsigned long flags; |
|
|
|
port = ((struct pcie_device *)context)->port; |
|
data = get_service_data((struct pcie_device *)context); |
|
|
|
spin_lock_irqsave(&data->lock, flags); |
|
pcie_capability_read_dword(port, PCI_EXP_RTSTA, &rtsta); |
|
|
|
if (rtsta == (u32) ~0 || !(rtsta & PCI_EXP_RTSTA_PME)) { |
|
spin_unlock_irqrestore(&data->lock, flags); |
|
return IRQ_NONE; |
|
} |
|
|
|
pcie_pme_interrupt_enable(port, false); |
|
spin_unlock_irqrestore(&data->lock, flags); |
|
|
|
/* We don't use pm_wq, because it's freezable. */ |
|
schedule_work(&data->work); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
/** |
|
* pcie_pme_can_wakeup - Set the wakeup capability flag. |
|
* @dev: PCI device to handle. |
|
* @ign: Ignored. |
|
*/ |
|
static int pcie_pme_can_wakeup(struct pci_dev *dev, void *ign) |
|
{ |
|
device_set_wakeup_capable(&dev->dev, true); |
|
return 0; |
|
} |
|
|
|
/** |
|
* pcie_pme_mark_devices - Set the wakeup flag for devices below a port. |
|
* @port: PCIe root port or event collector to handle. |
|
* |
|
* For each device below given root port, including the port itself (or for each |
|
* root complex integrated endpoint if @port is a root complex event collector) |
|
* set the flag indicating that it can signal run-time wake-up events. |
|
*/ |
|
static void pcie_pme_mark_devices(struct pci_dev *port) |
|
{ |
|
pcie_pme_can_wakeup(port, NULL); |
|
|
|
if (pci_pcie_type(port) == PCI_EXP_TYPE_RC_EC) |
|
pcie_walk_rcec(port, pcie_pme_can_wakeup, NULL); |
|
else if (port->subordinate) |
|
pci_walk_bus(port->subordinate, pcie_pme_can_wakeup, NULL); |
|
} |
|
|
|
/** |
|
* pcie_pme_probe - Initialize PCIe PME service for given root port. |
|
* @srv: PCIe service to initialize. |
|
*/ |
|
static int pcie_pme_probe(struct pcie_device *srv) |
|
{ |
|
struct pci_dev *port = srv->port; |
|
struct pcie_pme_service_data *data; |
|
int type = pci_pcie_type(port); |
|
int ret; |
|
|
|
/* Limit to Root Ports or Root Complex Event Collectors */ |
|
if (type != PCI_EXP_TYPE_RC_EC && |
|
type != PCI_EXP_TYPE_ROOT_PORT) |
|
return -ENODEV; |
|
|
|
data = kzalloc(sizeof(*data), GFP_KERNEL); |
|
if (!data) |
|
return -ENOMEM; |
|
|
|
spin_lock_init(&data->lock); |
|
INIT_WORK(&data->work, pcie_pme_work_fn); |
|
data->srv = srv; |
|
set_service_data(srv, data); |
|
|
|
pcie_pme_interrupt_enable(port, false); |
|
pcie_clear_root_pme_status(port); |
|
|
|
ret = request_irq(srv->irq, pcie_pme_irq, IRQF_SHARED, "PCIe PME", srv); |
|
if (ret) { |
|
kfree(data); |
|
return ret; |
|
} |
|
|
|
pci_info(port, "Signaling with IRQ %d\n", srv->irq); |
|
|
|
pcie_pme_mark_devices(port); |
|
pcie_pme_interrupt_enable(port, true); |
|
return 0; |
|
} |
|
|
|
static bool pcie_pme_check_wakeup(struct pci_bus *bus) |
|
{ |
|
struct pci_dev *dev; |
|
|
|
if (!bus) |
|
return false; |
|
|
|
list_for_each_entry(dev, &bus->devices, bus_list) |
|
if (device_may_wakeup(&dev->dev) |
|
|| pcie_pme_check_wakeup(dev->subordinate)) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
static void pcie_pme_disable_interrupt(struct pci_dev *port, |
|
struct pcie_pme_service_data *data) |
|
{ |
|
spin_lock_irq(&data->lock); |
|
pcie_pme_interrupt_enable(port, false); |
|
pcie_clear_root_pme_status(port); |
|
data->noirq = true; |
|
spin_unlock_irq(&data->lock); |
|
} |
|
|
|
/** |
|
* pcie_pme_suspend - Suspend PCIe PME service device. |
|
* @srv: PCIe service device to suspend. |
|
*/ |
|
static int pcie_pme_suspend(struct pcie_device *srv) |
|
{ |
|
struct pcie_pme_service_data *data = get_service_data(srv); |
|
struct pci_dev *port = srv->port; |
|
bool wakeup; |
|
int ret; |
|
|
|
if (device_may_wakeup(&port->dev)) { |
|
wakeup = true; |
|
} else { |
|
down_read(&pci_bus_sem); |
|
wakeup = pcie_pme_check_wakeup(port->subordinate); |
|
up_read(&pci_bus_sem); |
|
} |
|
if (wakeup) { |
|
ret = enable_irq_wake(srv->irq); |
|
if (!ret) |
|
return 0; |
|
} |
|
|
|
pcie_pme_disable_interrupt(port, data); |
|
|
|
synchronize_irq(srv->irq); |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* pcie_pme_resume - Resume PCIe PME service device. |
|
* @srv: PCIe service device to resume. |
|
*/ |
|
static int pcie_pme_resume(struct pcie_device *srv) |
|
{ |
|
struct pcie_pme_service_data *data = get_service_data(srv); |
|
|
|
spin_lock_irq(&data->lock); |
|
if (data->noirq) { |
|
struct pci_dev *port = srv->port; |
|
|
|
pcie_clear_root_pme_status(port); |
|
pcie_pme_interrupt_enable(port, true); |
|
data->noirq = false; |
|
} else { |
|
disable_irq_wake(srv->irq); |
|
} |
|
spin_unlock_irq(&data->lock); |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* pcie_pme_remove - Prepare PCIe PME service device for removal. |
|
* @srv: PCIe service device to remove. |
|
*/ |
|
static void pcie_pme_remove(struct pcie_device *srv) |
|
{ |
|
struct pcie_pme_service_data *data = get_service_data(srv); |
|
|
|
pcie_pme_disable_interrupt(srv->port, data); |
|
free_irq(srv->irq, srv); |
|
cancel_work_sync(&data->work); |
|
kfree(data); |
|
} |
|
|
|
static struct pcie_port_service_driver pcie_pme_driver = { |
|
.name = "pcie_pme", |
|
.port_type = PCIE_ANY_PORT, |
|
.service = PCIE_PORT_SERVICE_PME, |
|
|
|
.probe = pcie_pme_probe, |
|
.suspend = pcie_pme_suspend, |
|
.resume = pcie_pme_resume, |
|
.remove = pcie_pme_remove, |
|
}; |
|
|
|
/** |
|
* pcie_pme_init - Register the PCIe PME service driver. |
|
*/ |
|
int __init pcie_pme_init(void) |
|
{ |
|
return pcie_port_service_register(&pcie_pme_driver); |
|
}
|
|
|