xref: /openbmc/linux/drivers/pci/pcie/pme.c (revision 5d0e4d78)
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 & PCI_EXP_RTSTA_PME) {
230 			/*
231 			 * Clear PME status of the port.  If there are other
232 			 * pending PMEs, the status will be set again.
233 			 */
234 			pcie_clear_root_pme_status(port);
235 
236 			spin_unlock_irq(&data->lock);
237 			pcie_pme_handle_request(port, rtsta & 0xffff);
238 			spin_lock_irq(&data->lock);
239 
240 			continue;
241 		}
242 
243 		/* No need to loop if there are no more PMEs pending. */
244 		if (!(rtsta & PCI_EXP_RTSTA_PENDING))
245 			break;
246 
247 		spin_unlock_irq(&data->lock);
248 		cpu_relax();
249 		spin_lock_irq(&data->lock);
250 	}
251 
252 	if (!data->noirq)
253 		pcie_pme_interrupt_enable(port, true);
254 
255 	spin_unlock_irq(&data->lock);
256 }
257 
258 /**
259  * pcie_pme_irq - Interrupt handler for PCIe root port PME interrupt.
260  * @irq: Interrupt vector.
261  * @context: Interrupt context pointer.
262  */
263 static irqreturn_t pcie_pme_irq(int irq, void *context)
264 {
265 	struct pci_dev *port;
266 	struct pcie_pme_service_data *data;
267 	u32 rtsta;
268 	unsigned long flags;
269 
270 	port = ((struct pcie_device *)context)->port;
271 	data = get_service_data((struct pcie_device *)context);
272 
273 	spin_lock_irqsave(&data->lock, flags);
274 	pcie_capability_read_dword(port, PCI_EXP_RTSTA, &rtsta);
275 
276 	if (!(rtsta & PCI_EXP_RTSTA_PME)) {
277 		spin_unlock_irqrestore(&data->lock, flags);
278 		return IRQ_NONE;
279 	}
280 
281 	pcie_pme_interrupt_enable(port, false);
282 	spin_unlock_irqrestore(&data->lock, flags);
283 
284 	/* We don't use pm_wq, because it's freezable. */
285 	schedule_work(&data->work);
286 
287 	return IRQ_HANDLED;
288 }
289 
290 /**
291  * pcie_pme_can_wakeup - Set the wakeup capability flag.
292  * @dev: PCI device to handle.
293  * @ign: Ignored.
294  */
295 static int pcie_pme_can_wakeup(struct pci_dev *dev, void *ign)
296 {
297 	device_set_wakeup_capable(&dev->dev, true);
298 	return 0;
299 }
300 
301 /**
302  * pcie_pme_mark_devices - Set the wakeup flag for devices below a port.
303  * @port: PCIe root port or event collector to handle.
304  *
305  * For each device below given root port, including the port itself (or for each
306  * root complex integrated endpoint if @port is a root complex event collector)
307  * set the flag indicating that it can signal run-time wake-up events.
308  */
309 static void pcie_pme_mark_devices(struct pci_dev *port)
310 {
311 	pcie_pme_can_wakeup(port, NULL);
312 	if (port->subordinate)
313 		pci_walk_bus(port->subordinate, pcie_pme_can_wakeup, NULL);
314 }
315 
316 /**
317  * pcie_pme_probe - Initialize PCIe PME service for given root port.
318  * @srv: PCIe service to initialize.
319  */
320 static int pcie_pme_probe(struct pcie_device *srv)
321 {
322 	struct pci_dev *port;
323 	struct pcie_pme_service_data *data;
324 	int ret;
325 
326 	data = kzalloc(sizeof(*data), GFP_KERNEL);
327 	if (!data)
328 		return -ENOMEM;
329 
330 	spin_lock_init(&data->lock);
331 	INIT_WORK(&data->work, pcie_pme_work_fn);
332 	data->srv = srv;
333 	set_service_data(srv, data);
334 
335 	port = srv->port;
336 	pcie_pme_interrupt_enable(port, false);
337 	pcie_clear_root_pme_status(port);
338 
339 	ret = request_irq(srv->irq, pcie_pme_irq, IRQF_SHARED, "PCIe PME", srv);
340 	if (ret) {
341 		kfree(data);
342 		return ret;
343 	}
344 
345 	dev_info(&port->dev, "Signaling PME with IRQ %d\n", srv->irq);
346 
347 	pcie_pme_mark_devices(port);
348 	pcie_pme_interrupt_enable(port, true);
349 	return 0;
350 }
351 
352 static bool pcie_pme_check_wakeup(struct pci_bus *bus)
353 {
354 	struct pci_dev *dev;
355 
356 	if (!bus)
357 		return false;
358 
359 	list_for_each_entry(dev, &bus->devices, bus_list)
360 		if (device_may_wakeup(&dev->dev)
361 		    || pcie_pme_check_wakeup(dev->subordinate))
362 			return true;
363 
364 	return false;
365 }
366 
367 /**
368  * pcie_pme_suspend - Suspend PCIe PME service device.
369  * @srv: PCIe service device to suspend.
370  */
371 static int pcie_pme_suspend(struct pcie_device *srv)
372 {
373 	struct pcie_pme_service_data *data = get_service_data(srv);
374 	struct pci_dev *port = srv->port;
375 	bool wakeup;
376 	int ret;
377 
378 	if (device_may_wakeup(&port->dev)) {
379 		wakeup = true;
380 	} else {
381 		down_read(&pci_bus_sem);
382 		wakeup = pcie_pme_check_wakeup(port->subordinate);
383 		up_read(&pci_bus_sem);
384 	}
385 	if (wakeup) {
386 		ret = enable_irq_wake(srv->irq);
387 		if (!ret)
388 			return 0;
389 	}
390 
391 	spin_lock_irq(&data->lock);
392 	pcie_pme_interrupt_enable(port, false);
393 	pcie_clear_root_pme_status(port);
394 	data->noirq = true;
395 	spin_unlock_irq(&data->lock);
396 
397 	synchronize_irq(srv->irq);
398 
399 	return 0;
400 }
401 
402 /**
403  * pcie_pme_resume - Resume PCIe PME service device.
404  * @srv - PCIe service device to resume.
405  */
406 static int pcie_pme_resume(struct pcie_device *srv)
407 {
408 	struct pcie_pme_service_data *data = get_service_data(srv);
409 
410 	spin_lock_irq(&data->lock);
411 	if (data->noirq) {
412 		struct pci_dev *port = srv->port;
413 
414 		pcie_clear_root_pme_status(port);
415 		pcie_pme_interrupt_enable(port, true);
416 		data->noirq = false;
417 	} else {
418 		disable_irq_wake(srv->irq);
419 	}
420 	spin_unlock_irq(&data->lock);
421 
422 	return 0;
423 }
424 
425 /**
426  * pcie_pme_remove - Prepare PCIe PME service device for removal.
427  * @srv - PCIe service device to remove.
428  */
429 static void pcie_pme_remove(struct pcie_device *srv)
430 {
431 	pcie_pme_suspend(srv);
432 	free_irq(srv->irq, srv);
433 	kfree(get_service_data(srv));
434 }
435 
436 static struct pcie_port_service_driver pcie_pme_driver = {
437 	.name		= "pcie_pme",
438 	.port_type	= PCI_EXP_TYPE_ROOT_PORT,
439 	.service	= PCIE_PORT_SERVICE_PME,
440 
441 	.probe		= pcie_pme_probe,
442 	.suspend	= pcie_pme_suspend,
443 	.resume		= pcie_pme_resume,
444 	.remove		= pcie_pme_remove,
445 };
446 
447 /**
448  * pcie_pme_service_init - Register the PCIe PME service driver.
449  */
450 static int __init pcie_pme_service_init(void)
451 {
452 	return pcie_port_service_register(&pcie_pme_driver);
453 }
454 device_initcall(pcie_pme_service_init);
455