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