Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * PCI Bus Services, see include/linux/pci.h for further explanation.
4 : : *
5 : : * Copyright 1993 -- 1997 Drew Eckhardt, Frederic Potter,
6 : : * David Mosberger-Tang
7 : : *
8 : : * Copyright 1997 -- 2000 Martin Mares <mj@ucw.cz>
9 : : */
10 : :
11 : : #include <linux/acpi.h>
12 : : #include <linux/kernel.h>
13 : : #include <linux/delay.h>
14 : : #include <linux/dmi.h>
15 : : #include <linux/init.h>
16 : : #include <linux/msi.h>
17 : : #include <linux/of.h>
18 : : #include <linux/of_pci.h>
19 : : #include <linux/pci.h>
20 : : #include <linux/pm.h>
21 : : #include <linux/slab.h>
22 : : #include <linux/module.h>
23 : : #include <linux/spinlock.h>
24 : : #include <linux/string.h>
25 : : #include <linux/log2.h>
26 : : #include <linux/logic_pio.h>
27 : : #include <linux/pm_wakeup.h>
28 : : #include <linux/interrupt.h>
29 : : #include <linux/device.h>
30 : : #include <linux/pm_runtime.h>
31 : : #include <linux/pci_hotplug.h>
32 : : #include <linux/vmalloc.h>
33 : : #include <linux/pci-ats.h>
34 : : #include <asm/setup.h>
35 : : #include <asm/dma.h>
36 : : #include <linux/aer.h>
37 : : #include "pci.h"
38 : :
39 : : DEFINE_MUTEX(pci_slot_mutex);
40 : :
41 : : const char *pci_power_names[] = {
42 : : "error", "D0", "D1", "D2", "D3hot", "D3cold", "unknown",
43 : : };
44 : : EXPORT_SYMBOL_GPL(pci_power_names);
45 : :
46 : : int isa_dma_bridge_buggy;
47 : : EXPORT_SYMBOL(isa_dma_bridge_buggy);
48 : :
49 : : int pci_pci_problems;
50 : : EXPORT_SYMBOL(pci_pci_problems);
51 : :
52 : : unsigned int pci_pm_d3_delay;
53 : :
54 : : static void pci_pme_list_scan(struct work_struct *work);
55 : :
56 : : static LIST_HEAD(pci_pme_list);
57 : : static DEFINE_MUTEX(pci_pme_list_mutex);
58 : : static DECLARE_DELAYED_WORK(pci_pme_work, pci_pme_list_scan);
59 : :
60 : : struct pci_pme_device {
61 : : struct list_head list;
62 : : struct pci_dev *dev;
63 : : };
64 : :
65 : : #define PME_TIMEOUT 1000 /* How long between PME checks */
66 : :
67 : 0 : static void pci_dev_d3_sleep(struct pci_dev *dev)
68 : : {
69 : 0 : unsigned int delay = dev->d3_delay;
70 : :
71 : 0 : if (delay < pci_pm_d3_delay)
72 : : delay = pci_pm_d3_delay;
73 : :
74 : 0 : if (delay)
75 : 0 : msleep(delay);
76 : : }
77 : :
78 : : #ifdef CONFIG_PCI_DOMAINS
79 : : int pci_domains_supported = 1;
80 : : #endif
81 : :
82 : : #define DEFAULT_CARDBUS_IO_SIZE (256)
83 : : #define DEFAULT_CARDBUS_MEM_SIZE (64*1024*1024)
84 : : /* pci=cbmemsize=nnM,cbiosize=nn can override this */
85 : : unsigned long pci_cardbus_io_size = DEFAULT_CARDBUS_IO_SIZE;
86 : : unsigned long pci_cardbus_mem_size = DEFAULT_CARDBUS_MEM_SIZE;
87 : :
88 : : #define DEFAULT_HOTPLUG_IO_SIZE (256)
89 : : #define DEFAULT_HOTPLUG_MMIO_SIZE (2*1024*1024)
90 : : #define DEFAULT_HOTPLUG_MMIO_PREF_SIZE (2*1024*1024)
91 : : /* hpiosize=nn can override this */
92 : : unsigned long pci_hotplug_io_size = DEFAULT_HOTPLUG_IO_SIZE;
93 : : /*
94 : : * pci=hpmmiosize=nnM overrides non-prefetchable MMIO size,
95 : : * pci=hpmmioprefsize=nnM overrides prefetchable MMIO size;
96 : : * pci=hpmemsize=nnM overrides both
97 : : */
98 : : unsigned long pci_hotplug_mmio_size = DEFAULT_HOTPLUG_MMIO_SIZE;
99 : : unsigned long pci_hotplug_mmio_pref_size = DEFAULT_HOTPLUG_MMIO_PREF_SIZE;
100 : :
101 : : #define DEFAULT_HOTPLUG_BUS_SIZE 1
102 : : unsigned long pci_hotplug_bus_size = DEFAULT_HOTPLUG_BUS_SIZE;
103 : :
104 : : enum pcie_bus_config_types pcie_bus_config = PCIE_BUS_DEFAULT;
105 : :
106 : : /*
107 : : * The default CLS is used if arch didn't set CLS explicitly and not
108 : : * all pci devices agree on the same value. Arch can override either
109 : : * the dfl or actual value as it sees fit. Don't forget this is
110 : : * measured in 32-bit words, not bytes.
111 : : */
112 : : u8 pci_dfl_cache_line_size = L1_CACHE_BYTES >> 2;
113 : : u8 pci_cache_line_size;
114 : :
115 : : /*
116 : : * If we set up a device for bus mastering, we need to check the latency
117 : : * timer as certain BIOSes forget to set it properly.
118 : : */
119 : : unsigned int pcibios_max_latency = 255;
120 : :
121 : : /* If set, the PCIe ARI capability will not be used. */
122 : : static bool pcie_ari_disabled;
123 : :
124 : : /* If set, the PCIe ATS capability will not be used. */
125 : : static bool pcie_ats_disabled;
126 : :
127 : : /* If set, the PCI config space of each device is printed during boot. */
128 : : bool pci_early_dump;
129 : :
130 : 210 : bool pci_ats_disabled(void)
131 : : {
132 : 210 : return pcie_ats_disabled;
133 : : }
134 : : EXPORT_SYMBOL_GPL(pci_ats_disabled);
135 : :
136 : : /* Disable bridge_d3 for all PCIe ports */
137 : : static bool pci_bridge_d3_disable;
138 : : /* Force bridge_d3 for all PCIe ports */
139 : : static bool pci_bridge_d3_force;
140 : :
141 : 0 : static int __init pcie_port_pm_setup(char *str)
142 : : {
143 [ # # ]: 0 : if (!strcmp(str, "off"))
144 : 0 : pci_bridge_d3_disable = true;
145 [ # # ]: 0 : else if (!strcmp(str, "force"))
146 : 0 : pci_bridge_d3_force = true;
147 : 0 : return 1;
148 : : }
149 : : __setup("pcie_port_pm=", pcie_port_pm_setup);
150 : :
151 : : /* Time to wait after a reset for device to become responsive */
152 : : #define PCIE_RESET_READY_POLL_MS 60000
153 : :
154 : : /**
155 : : * pci_bus_max_busnr - returns maximum PCI bus number of given bus' children
156 : : * @bus: pointer to PCI bus structure to search
157 : : *
158 : : * Given a PCI bus, returns the highest PCI bus number present in the set
159 : : * including the given PCI bus and its list of child PCI buses.
160 : : */
161 : 0 : unsigned char pci_bus_max_busnr(struct pci_bus *bus)
162 : : {
163 : 0 : struct pci_bus *tmp;
164 : 0 : unsigned char max, n;
165 : :
166 : 0 : max = bus->busn_res.end;
167 [ # # ]: 0 : list_for_each_entry(tmp, &bus->children, node) {
168 : 0 : n = pci_bus_max_busnr(tmp);
169 : 0 : if (n > max)
170 : : max = n;
171 : : }
172 : 0 : return max;
173 : : }
174 : : EXPORT_SYMBOL_GPL(pci_bus_max_busnr);
175 : :
176 : : #ifdef CONFIG_HAS_IOMEM
177 : 30 : void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar)
178 : : {
179 : 30 : struct resource *res = &pdev->resource[bar];
180 : :
181 : : /*
182 : : * Make sure the BAR is actually a memory resource, not an IO resource
183 : : */
184 [ - + ]: 30 : if (res->flags & IORESOURCE_UNSET || !(res->flags & IORESOURCE_MEM)) {
185 : 0 : pci_warn(pdev, "can't ioremap BAR %d: %pR\n", bar, res);
186 : 0 : return NULL;
187 : : }
188 : 30 : return ioremap(res->start, resource_size(res));
189 : : }
190 : : EXPORT_SYMBOL_GPL(pci_ioremap_bar);
191 : :
192 : 0 : void __iomem *pci_ioremap_wc_bar(struct pci_dev *pdev, int bar)
193 : : {
194 : : /*
195 : : * Make sure the BAR is actually a memory resource, not an IO resource
196 : : */
197 [ # # ]: 0 : if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
198 : 0 : WARN_ON(1);
199 : 0 : return NULL;
200 : : }
201 : 0 : return ioremap_wc(pci_resource_start(pdev, bar),
202 [ # # # # ]: 0 : pci_resource_len(pdev, bar));
203 : : }
204 : : EXPORT_SYMBOL_GPL(pci_ioremap_wc_bar);
205 : : #endif
206 : :
207 : : /**
208 : : * pci_dev_str_match_path - test if a path string matches a device
209 : : * @dev: the PCI device to test
210 : : * @path: string to match the device against
211 : : * @endptr: pointer to the string after the match
212 : : *
213 : : * Test if a string (typically from a kernel parameter) formatted as a
214 : : * path of device/function addresses matches a PCI device. The string must
215 : : * be of the form:
216 : : *
217 : : * [<domain>:]<bus>:<device>.<func>[/<device>.<func>]*
218 : : *
219 : : * A path for a device can be obtained using 'lspci -t'. Using a path
220 : : * is more robust against bus renumbering than using only a single bus,
221 : : * device and function address.
222 : : *
223 : : * Returns 1 if the string matches the device, 0 if it does not and
224 : : * a negative error code if it fails to parse the string.
225 : : */
226 : 0 : static int pci_dev_str_match_path(struct pci_dev *dev, const char *path,
227 : : const char **endptr)
228 : : {
229 : 0 : int ret;
230 : 0 : int seg, bus, slot, func;
231 : 0 : char *wpath, *p;
232 : 0 : char end;
233 : :
234 : 0 : *endptr = strchrnul(path, ';');
235 : :
236 : 0 : wpath = kmemdup_nul(path, *endptr - path, GFP_KERNEL);
237 [ # # ]: 0 : if (!wpath)
238 : : return -ENOMEM;
239 : :
240 : 0 : while (1) {
241 : 0 : p = strrchr(wpath, '/');
242 [ # # ]: 0 : if (!p)
243 : : break;
244 : 0 : ret = sscanf(p, "/%x.%x%c", &slot, &func, &end);
245 [ # # ]: 0 : if (ret != 2) {
246 : 0 : ret = -EINVAL;
247 : 0 : goto free_and_exit;
248 : : }
249 : :
250 [ # # ]: 0 : if (dev->devfn != PCI_DEVFN(slot, func)) {
251 : 0 : ret = 0;
252 : 0 : goto free_and_exit;
253 : : }
254 : :
255 : : /*
256 : : * Note: we don't need to get a reference to the upstream
257 : : * bridge because we hold a reference to the top level
258 : : * device which should hold a reference to the bridge,
259 : : * and so on.
260 : : */
261 [ # # ]: 0 : dev = pci_upstream_bridge(dev);
262 [ # # ]: 0 : if (!dev) {
263 : 0 : ret = 0;
264 : 0 : goto free_and_exit;
265 : : }
266 : :
267 : 0 : *p = 0;
268 : : }
269 : :
270 : 0 : ret = sscanf(wpath, "%x:%x:%x.%x%c", &seg, &bus, &slot,
271 : : &func, &end);
272 [ # # ]: 0 : if (ret != 4) {
273 : 0 : seg = 0;
274 : 0 : ret = sscanf(wpath, "%x:%x.%x%c", &bus, &slot, &func, &end);
275 [ # # ]: 0 : if (ret != 3) {
276 : 0 : ret = -EINVAL;
277 : 0 : goto free_and_exit;
278 : : }
279 : : }
280 : :
281 [ # # ]: 0 : ret = (seg == pci_domain_nr(dev->bus) &&
282 [ # # # # ]: 0 : bus == dev->bus->number &&
283 [ # # ]: 0 : dev->devfn == PCI_DEVFN(slot, func));
284 : :
285 : 0 : free_and_exit:
286 : 0 : kfree(wpath);
287 : 0 : return ret;
288 : : }
289 : :
290 : : /**
291 : : * pci_dev_str_match - test if a string matches a device
292 : : * @dev: the PCI device to test
293 : : * @p: string to match the device against
294 : : * @endptr: pointer to the string after the match
295 : : *
296 : : * Test if a string (typically from a kernel parameter) matches a specified
297 : : * PCI device. The string may be of one of the following formats:
298 : : *
299 : : * [<domain>:]<bus>:<device>.<func>[/<device>.<func>]*
300 : : * pci:<vendor>:<device>[:<subvendor>:<subdevice>]
301 : : *
302 : : * The first format specifies a PCI bus/device/function address which
303 : : * may change if new hardware is inserted, if motherboard firmware changes,
304 : : * or due to changes caused in kernel parameters. If the domain is
305 : : * left unspecified, it is taken to be 0. In order to be robust against
306 : : * bus renumbering issues, a path of PCI device/function numbers may be used
307 : : * to address the specific device. The path for a device can be determined
308 : : * through the use of 'lspci -t'.
309 : : *
310 : : * The second format matches devices using IDs in the configuration
311 : : * space which may match multiple devices in the system. A value of 0
312 : : * for any field will match all devices. (Note: this differs from
313 : : * in-kernel code that uses PCI_ANY_ID which is ~0; this is for
314 : : * legacy reasons and convenience so users don't have to specify
315 : : * FFFFFFFFs on the command line.)
316 : : *
317 : : * Returns 1 if the string matches the device, 0 if it does not and
318 : : * a negative error code if the string cannot be parsed.
319 : : */
320 : 0 : static int pci_dev_str_match(struct pci_dev *dev, const char *p,
321 : : const char **endptr)
322 : : {
323 : 0 : int ret;
324 : 0 : int count;
325 : 0 : unsigned short vendor, device, subsystem_vendor, subsystem_device;
326 : :
327 [ # # ]: 0 : if (strncmp(p, "pci:", 4) == 0) {
328 : : /* PCI vendor/device (subvendor/subdevice) IDs are specified */
329 : 0 : p += 4;
330 : 0 : ret = sscanf(p, "%hx:%hx:%hx:%hx%n", &vendor, &device,
331 : : &subsystem_vendor, &subsystem_device, &count);
332 [ # # ]: 0 : if (ret != 4) {
333 : 0 : ret = sscanf(p, "%hx:%hx%n", &vendor, &device, &count);
334 [ # # ]: 0 : if (ret != 2)
335 : : return -EINVAL;
336 : :
337 : 0 : subsystem_vendor = 0;
338 : 0 : subsystem_device = 0;
339 : : }
340 : :
341 : 0 : p += count;
342 : :
343 [ # # # # ]: 0 : if ((!vendor || vendor == dev->vendor) &&
344 [ # # # # ]: 0 : (!device || device == dev->device) &&
345 [ # # ]: 0 : (!subsystem_vendor ||
346 [ # # ]: 0 : subsystem_vendor == dev->subsystem_vendor) &&
347 [ # # ]: 0 : (!subsystem_device ||
348 [ # # ]: 0 : subsystem_device == dev->subsystem_device))
349 : 0 : goto found;
350 : : } else {
351 : : /*
352 : : * PCI Bus, Device, Function IDs are specified
353 : : * (optionally, may include a path of devfns following it)
354 : : */
355 : 0 : ret = pci_dev_str_match_path(dev, p, &p);
356 [ # # ]: 0 : if (ret < 0)
357 : : return ret;
358 [ # # ]: 0 : else if (ret)
359 : 0 : goto found;
360 : : }
361 : :
362 : 0 : *endptr = p;
363 : 0 : return 0;
364 : :
365 : 0 : found:
366 : 0 : *endptr = p;
367 : 0 : return 1;
368 : : }
369 : :
370 : 300 : static int __pci_find_next_cap_ttl(struct pci_bus *bus, unsigned int devfn,
371 : : u8 pos, int cap, int *ttl)
372 : : {
373 : 300 : u8 id;
374 : 300 : u16 ent;
375 : :
376 : 300 : pci_bus_read_config_byte(bus, devfn, pos, &pos);
377 : :
378 [ + - ]: 810 : while ((*ttl)--) {
379 [ + + ]: 810 : if (pos < 0x40)
380 : : break;
381 : 570 : pos &= ~3;
382 : 570 : pci_bus_read_config_word(bus, devfn, pos, &ent);
383 : :
384 : 570 : id = ent & 0xff;
385 [ + - ]: 570 : if (id == 0xff)
386 : : break;
387 [ + + ]: 570 : if (id == cap)
388 : 60 : return pos;
389 : 510 : pos = (ent >> 8);
390 : : }
391 : : return 0;
392 : : }
393 : :
394 : 300 : static int __pci_find_next_cap(struct pci_bus *bus, unsigned int devfn,
395 : : u8 pos, int cap)
396 : : {
397 : 300 : int ttl = PCI_FIND_CAP_TTL;
398 : :
399 : 300 : return __pci_find_next_cap_ttl(bus, devfn, pos, cap, &ttl);
400 : : }
401 : :
402 : 0 : int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap)
403 : : {
404 : 0 : return __pci_find_next_cap(dev->bus, dev->devfn,
405 : 0 : pos + PCI_CAP_LIST_NEXT, cap);
406 : : }
407 : : EXPORT_SYMBOL_GPL(pci_find_next_capability);
408 : :
409 : 2130 : static int __pci_bus_find_cap_start(struct pci_bus *bus,
410 : : unsigned int devfn, u8 hdr_type)
411 : : {
412 : 2130 : u16 status;
413 : :
414 : 2130 : pci_bus_read_config_word(bus, devfn, PCI_STATUS, &status);
415 [ + + ]: 2130 : if (!(status & PCI_STATUS_CAP_LIST))
416 : : return 0;
417 : :
418 [ - - + ]: 300 : switch (hdr_type) {
419 : : case PCI_HEADER_TYPE_NORMAL:
420 : : case PCI_HEADER_TYPE_BRIDGE:
421 : : return PCI_CAPABILITY_LIST;
422 : 0 : case PCI_HEADER_TYPE_CARDBUS:
423 : 0 : return PCI_CB_CAPABILITY_LIST;
424 : : }
425 : :
426 : 0 : return 0;
427 : : }
428 : :
429 : : /**
430 : : * pci_find_capability - query for devices' capabilities
431 : : * @dev: PCI device to query
432 : : * @cap: capability code
433 : : *
434 : : * Tell if a device supports a given PCI capability.
435 : : * Returns the address of the requested capability structure within the
436 : : * device's PCI configuration space or 0 in case the device does not
437 : : * support it. Possible values for @cap include:
438 : : *
439 : : * %PCI_CAP_ID_PM Power Management
440 : : * %PCI_CAP_ID_AGP Accelerated Graphics Port
441 : : * %PCI_CAP_ID_VPD Vital Product Data
442 : : * %PCI_CAP_ID_SLOTID Slot Identification
443 : : * %PCI_CAP_ID_MSI Message Signalled Interrupts
444 : : * %PCI_CAP_ID_CHSWP CompactPCI HotSwap
445 : : * %PCI_CAP_ID_PCIX PCI-X
446 : : * %PCI_CAP_ID_EXP PCI Express
447 : : */
448 : 2130 : int pci_find_capability(struct pci_dev *dev, int cap)
449 : : {
450 : 2130 : int pos;
451 : :
452 : 2130 : pos = __pci_bus_find_cap_start(dev->bus, dev->devfn, dev->hdr_type);
453 [ + + ]: 2130 : if (pos)
454 : 300 : pos = __pci_find_next_cap(dev->bus, dev->devfn, pos, cap);
455 : :
456 : 2130 : return pos;
457 : : }
458 : : EXPORT_SYMBOL(pci_find_capability);
459 : :
460 : : /**
461 : : * pci_bus_find_capability - query for devices' capabilities
462 : : * @bus: the PCI bus to query
463 : : * @devfn: PCI device to query
464 : : * @cap: capability code
465 : : *
466 : : * Like pci_find_capability() but works for PCI devices that do not have a
467 : : * pci_dev structure set up yet.
468 : : *
469 : : * Returns the address of the requested capability structure within the
470 : : * device's PCI configuration space or 0 in case the device does not
471 : : * support it.
472 : : */
473 : 0 : int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap)
474 : : {
475 : 0 : int pos;
476 : 0 : u8 hdr_type;
477 : :
478 : 0 : pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type);
479 : :
480 : 0 : pos = __pci_bus_find_cap_start(bus, devfn, hdr_type & 0x7f);
481 [ # # ]: 0 : if (pos)
482 : 0 : pos = __pci_find_next_cap(bus, devfn, pos, cap);
483 : :
484 : 0 : return pos;
485 : : }
486 : : EXPORT_SYMBOL(pci_bus_find_capability);
487 : :
488 : : /**
489 : : * pci_find_next_ext_capability - Find an extended capability
490 : : * @dev: PCI device to query
491 : : * @start: address at which to start looking (0 to start at beginning of list)
492 : : * @cap: capability code
493 : : *
494 : : * Returns the address of the next matching extended capability structure
495 : : * within the device's PCI configuration space or 0 if the device does
496 : : * not support it. Some capabilities can occur several times, e.g., the
497 : : * vendor-specific capability, and this provides a way to find them all.
498 : : */
499 : 1980 : int pci_find_next_ext_capability(struct pci_dev *dev, int start, int cap)
500 : : {
501 : 1980 : u32 header;
502 : 1980 : int ttl;
503 : 1980 : int pos = PCI_CFG_SPACE_SIZE;
504 : :
505 : : /* minimum 8 bytes per capability */
506 : 1980 : ttl = (PCI_CFG_SPACE_EXP_SIZE - PCI_CFG_SPACE_SIZE) / 8;
507 : :
508 [ - + ]: 1980 : if (dev->cfg_size <= PCI_CFG_SPACE_SIZE)
509 : : return 0;
510 : :
511 [ # # ]: 0 : if (start)
512 : 0 : pos = start;
513 : :
514 [ # # ]: 0 : if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
515 : : return 0;
516 : :
517 : : /*
518 : : * If we have no capabilities, this is indicated by cap ID,
519 : : * cap version and next pointer all being 0.
520 : : */
521 [ # # ]: 0 : if (header == 0)
522 : : return 0;
523 : :
524 [ # # ]: 0 : while (ttl-- > 0) {
525 [ # # # # ]: 0 : if (PCI_EXT_CAP_ID(header) == cap && pos != start)
526 : 0 : return pos;
527 : :
528 : 0 : pos = PCI_EXT_CAP_NEXT(header);
529 [ # # ]: 0 : if (pos < PCI_CFG_SPACE_SIZE)
530 : : break;
531 : :
532 [ # # ]: 0 : if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
533 : : break;
534 : : }
535 : :
536 : : return 0;
537 : : }
538 : : EXPORT_SYMBOL_GPL(pci_find_next_ext_capability);
539 : :
540 : : /**
541 : : * pci_find_ext_capability - Find an extended capability
542 : : * @dev: PCI device to query
543 : : * @cap: capability code
544 : : *
545 : : * Returns the address of the requested extended capability structure
546 : : * within the device's PCI configuration space or 0 if the device does
547 : : * not support it. Possible values for @cap include:
548 : : *
549 : : * %PCI_EXT_CAP_ID_ERR Advanced Error Reporting
550 : : * %PCI_EXT_CAP_ID_VC Virtual Channel
551 : : * %PCI_EXT_CAP_ID_DSN Device Serial Number
552 : : * %PCI_EXT_CAP_ID_PWR Power Budgeting
553 : : */
554 : 1770 : int pci_find_ext_capability(struct pci_dev *dev, int cap)
555 : : {
556 : 1560 : return pci_find_next_ext_capability(dev, 0, cap);
557 : : }
558 : : EXPORT_SYMBOL_GPL(pci_find_ext_capability);
559 : :
560 : 0 : static int __pci_find_next_ht_cap(struct pci_dev *dev, int pos, int ht_cap)
561 : : {
562 : 0 : int rc, ttl = PCI_FIND_CAP_TTL;
563 : 0 : u8 cap, mask;
564 : :
565 [ # # ]: 0 : if (ht_cap == HT_CAPTYPE_SLAVE || ht_cap == HT_CAPTYPE_HOST)
566 : : mask = HT_3BIT_CAP_MASK;
567 : : else
568 : 0 : mask = HT_5BIT_CAP_MASK;
569 : :
570 : 0 : pos = __pci_find_next_cap_ttl(dev->bus, dev->devfn, pos,
571 : : PCI_CAP_ID_HT, &ttl);
572 [ # # ]: 0 : while (pos) {
573 : 0 : rc = pci_read_config_byte(dev, pos + 3, &cap);
574 [ # # ]: 0 : if (rc != PCIBIOS_SUCCESSFUL)
575 : : return 0;
576 : :
577 [ # # ]: 0 : if ((cap & mask) == ht_cap)
578 : 0 : return pos;
579 : :
580 : 0 : pos = __pci_find_next_cap_ttl(dev->bus, dev->devfn,
581 : 0 : pos + PCI_CAP_LIST_NEXT,
582 : : PCI_CAP_ID_HT, &ttl);
583 : : }
584 : :
585 : : return 0;
586 : : }
587 : : /**
588 : : * pci_find_next_ht_capability - query a device's Hypertransport capabilities
589 : : * @dev: PCI device to query
590 : : * @pos: Position from which to continue searching
591 : : * @ht_cap: Hypertransport capability code
592 : : *
593 : : * To be used in conjunction with pci_find_ht_capability() to search for
594 : : * all capabilities matching @ht_cap. @pos should always be a value returned
595 : : * from pci_find_ht_capability().
596 : : *
597 : : * NB. To be 100% safe against broken PCI devices, the caller should take
598 : : * steps to avoid an infinite loop.
599 : : */
600 : 0 : int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap)
601 : : {
602 : 0 : return __pci_find_next_ht_cap(dev, pos + PCI_CAP_LIST_NEXT, ht_cap);
603 : : }
604 : : EXPORT_SYMBOL_GPL(pci_find_next_ht_capability);
605 : :
606 : : /**
607 : : * pci_find_ht_capability - query a device's Hypertransport capabilities
608 : : * @dev: PCI device to query
609 : : * @ht_cap: Hypertransport capability code
610 : : *
611 : : * Tell if a device supports a given Hypertransport capability.
612 : : * Returns an address within the device's PCI configuration space
613 : : * or 0 in case the device does not support the request capability.
614 : : * The address points to the PCI capability, of type PCI_CAP_ID_HT,
615 : : * which has a Hypertransport capability matching @ht_cap.
616 : : */
617 : 0 : int pci_find_ht_capability(struct pci_dev *dev, int ht_cap)
618 : : {
619 : 0 : int pos;
620 : :
621 : 0 : pos = __pci_bus_find_cap_start(dev->bus, dev->devfn, dev->hdr_type);
622 [ # # ]: 0 : if (pos)
623 : 0 : pos = __pci_find_next_ht_cap(dev, pos, ht_cap);
624 : :
625 : 0 : return pos;
626 : : }
627 : : EXPORT_SYMBOL_GPL(pci_find_ht_capability);
628 : :
629 : : /**
630 : : * pci_find_parent_resource - return resource region of parent bus of given
631 : : * region
632 : : * @dev: PCI device structure contains resources to be searched
633 : : * @res: child resource record for which parent is sought
634 : : *
635 : : * For given resource region of given device, return the resource region of
636 : : * parent bus the given region is contained in.
637 : : */
638 : 390 : struct resource *pci_find_parent_resource(const struct pci_dev *dev,
639 : : struct resource *res)
640 : : {
641 : 390 : const struct pci_bus *bus = dev->bus;
642 : 390 : struct resource *r;
643 : 390 : int i;
644 : :
645 [ + + + - ]: 2520 : pci_bus_for_each_resource(bus, r, i) {
646 [ + + ]: 2520 : if (!r)
647 : 1560 : continue;
648 [ + + + + ]: 1560 : if (resource_contains(r, res)) {
649 : :
650 : : /*
651 : : * If the window is prefetchable but the BAR is
652 : : * not, the allocator made a mistake.
653 : : */
654 [ - + ]: 390 : if (r->flags & IORESOURCE_PREFETCH &&
655 [ # # ]: 0 : !(res->flags & IORESOURCE_PREFETCH))
656 : : return NULL;
657 : :
658 : : /*
659 : : * If we're below a transparent bridge, there may
660 : : * be both a positively-decoded aperture and a
661 : : * subtractively-decoded region that contain the BAR.
662 : : * We want the positively-decoded one, so this depends
663 : : * on pci_bus_for_each_resource() giving us those
664 : : * first.
665 : : */
666 : 390 : return r;
667 : : }
668 : : }
669 : : return NULL;
670 : : }
671 : : EXPORT_SYMBOL(pci_find_parent_resource);
672 : :
673 : : /**
674 : : * pci_find_resource - Return matching PCI device resource
675 : : * @dev: PCI device to query
676 : : * @res: Resource to look for
677 : : *
678 : : * Goes over standard PCI resources (BARs) and checks if the given resource
679 : : * is partially or fully contained in any of them. In that case the
680 : : * matching resource is returned, %NULL otherwise.
681 : : */
682 : 0 : struct resource *pci_find_resource(struct pci_dev *dev, struct resource *res)
683 : : {
684 : 0 : int i;
685 : :
686 [ # # ]: 0 : for (i = 0; i < PCI_STD_NUM_BARS; i++) {
687 : 0 : struct resource *r = &dev->resource[i];
688 : :
689 [ # # # # ]: 0 : if (r->start && resource_contains(r, res))
690 : 0 : return r;
691 : : }
692 : :
693 : : return NULL;
694 : : }
695 : : EXPORT_SYMBOL(pci_find_resource);
696 : :
697 : : /**
698 : : * pci_find_pcie_root_port - return PCIe Root Port
699 : : * @dev: PCI device to query
700 : : *
701 : : * Traverse up the parent chain and return the PCIe Root Port PCI Device
702 : : * for a given PCI Device.
703 : : */
704 : 0 : struct pci_dev *pci_find_pcie_root_port(struct pci_dev *dev)
705 : : {
706 : 0 : struct pci_dev *bridge, *highest_pcie_bridge = dev;
707 : :
708 [ # # ]: 0 : bridge = pci_upstream_bridge(dev);
709 [ # # # # ]: 0 : while (bridge && pci_is_pcie(bridge)) {
710 : 0 : highest_pcie_bridge = bridge;
711 [ # # ]: 0 : bridge = pci_upstream_bridge(bridge);
712 : : }
713 : :
714 [ # # ]: 0 : if (pci_pcie_type(highest_pcie_bridge) != PCI_EXP_TYPE_ROOT_PORT)
715 : 0 : return NULL;
716 : :
717 : : return highest_pcie_bridge;
718 : : }
719 : : EXPORT_SYMBOL(pci_find_pcie_root_port);
720 : :
721 : : /**
722 : : * pci_wait_for_pending - wait for @mask bit(s) to clear in status word @pos
723 : : * @dev: the PCI device to operate on
724 : : * @pos: config space offset of status word
725 : : * @mask: mask of bit(s) to care about in status word
726 : : *
727 : : * Return 1 when mask bit(s) in status word clear, 0 otherwise.
728 : : */
729 : 0 : int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask)
730 : : {
731 : 0 : int i;
732 : :
733 : : /* Wait for Transaction Pending bit clean */
734 [ # # ]: 0 : for (i = 0; i < 4; i++) {
735 : 0 : u16 status;
736 [ # # ]: 0 : if (i)
737 : 0 : msleep((1 << (i - 1)) * 100);
738 : :
739 : 0 : pci_read_config_word(dev, pos, &status);
740 [ # # ]: 0 : if (!(status & mask))
741 : 0 : return 1;
742 : : }
743 : :
744 : : return 0;
745 : : }
746 : :
747 : : /**
748 : : * pci_restore_bars - restore a device's BAR values (e.g. after wake-up)
749 : : * @dev: PCI device to have its BARs restored
750 : : *
751 : : * Restore the BAR values for a given device, so as to make it
752 : : * accessible by its driver.
753 : : */
754 : : static void pci_restore_bars(struct pci_dev *dev)
755 : : {
756 : : int i;
757 : :
758 [ # # ]: 0 : for (i = 0; i < PCI_BRIDGE_RESOURCES; i++)
759 : 0 : pci_update_resource(dev, i);
760 : : }
761 : :
762 : : static const struct pci_platform_pm_ops *pci_platform_pm;
763 : :
764 : 30 : int pci_set_platform_pm(const struct pci_platform_pm_ops *ops)
765 : : {
766 [ + - + - : 30 : if (!ops->is_manageable || !ops->set_state || !ops->get_state ||
+ - ]
767 [ + - + - : 30 : !ops->choose_state || !ops->set_wakeup || !ops->need_resume)
+ - ]
768 : : return -EINVAL;
769 : 30 : pci_platform_pm = ops;
770 : 30 : return 0;
771 : : }
772 : :
773 : 60 : static inline bool platform_pci_power_manageable(struct pci_dev *dev)
774 : : {
775 [ - - - + : 60 : return pci_platform_pm ? pci_platform_pm->is_manageable(dev) : false;
- - ]
776 : : }
777 : :
778 : 0 : static inline int platform_pci_set_power_state(struct pci_dev *dev,
779 : : pci_power_t t)
780 : : {
781 : 0 : return pci_platform_pm ? pci_platform_pm->set_state(dev, t) : -ENOSYS;
782 : : }
783 : :
784 : 0 : static inline pci_power_t platform_pci_get_power_state(struct pci_dev *dev)
785 : : {
786 : 0 : return pci_platform_pm ? pci_platform_pm->get_state(dev) : PCI_UNKNOWN;
787 : : }
788 : :
789 : 0 : static inline void platform_pci_refresh_power_state(struct pci_dev *dev)
790 : : {
791 [ # # ]: 0 : if (pci_platform_pm && pci_platform_pm->refresh_state)
792 : 0 : pci_platform_pm->refresh_state(dev);
793 : : }
794 : :
795 : 0 : static inline pci_power_t platform_pci_choose_state(struct pci_dev *dev)
796 : : {
797 : 0 : return pci_platform_pm ?
798 : 0 : pci_platform_pm->choose_state(dev) : PCI_POWER_ERROR;
799 : : }
800 : :
801 : 0 : static inline int platform_pci_set_wakeup(struct pci_dev *dev, bool enable)
802 : : {
803 : 0 : return pci_platform_pm ?
804 : 0 : pci_platform_pm->set_wakeup(dev, enable) : -ENODEV;
805 : : }
806 : :
807 : 0 : static inline bool platform_pci_need_resume(struct pci_dev *dev)
808 : : {
809 [ # # # # ]: 0 : return pci_platform_pm ? pci_platform_pm->need_resume(dev) : false;
810 : : }
811 : :
812 : 0 : static inline bool platform_pci_bridge_d3(struct pci_dev *dev)
813 : : {
814 [ # # ]: 0 : return pci_platform_pm ? pci_platform_pm->bridge_d3(dev) : false;
815 : : }
816 : :
817 : : /**
818 : : * pci_raw_set_power_state - Use PCI PM registers to set the power state of
819 : : * given PCI device
820 : : * @dev: PCI device to handle.
821 : : * @state: PCI power state (D0, D1, D2, D3hot) to put the device into.
822 : : *
823 : : * RETURN VALUE:
824 : : * -EINVAL if the requested state is invalid.
825 : : * -EIO if device does not support PCI PM or its PM capabilities register has a
826 : : * wrong version, or device doesn't support the requested state.
827 : : * 0 if device already is in the requested state.
828 : : * 0 if device's power state has been successfully changed.
829 : : */
830 : 60 : static int pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
831 : : {
832 : 60 : u16 pmcsr;
833 : 60 : bool need_restore = false;
834 : :
835 : : /* Check if we're already there */
836 [ - + ]: 60 : if (dev->current_state == state)
837 : : return 0;
838 : :
839 [ # # ]: 0 : if (!dev->pm_cap)
840 : : return -EIO;
841 : :
842 [ # # ]: 0 : if (state < PCI_D0 || state > PCI_D3hot)
843 : : return -EINVAL;
844 : :
845 : : /*
846 : : * Validate transition: We can enter D0 from any state, but if
847 : : * we're already in a low-power state, we can only go deeper. E.g.,
848 : : * we can go from D1 to D3, but we can't go directly from D3 to D1;
849 : : * we'd have to go from D3 to D0, then to D1.
850 : : */
851 [ # # # # ]: 0 : if (state != PCI_D0 && dev->current_state <= PCI_D3cold
852 [ # # ]: 0 : && dev->current_state > state) {
853 : 0 : pci_err(dev, "invalid power transition (from %s to %s)\n",
854 : : pci_power_name(dev->current_state),
855 : : pci_power_name(state));
856 : 0 : return -EINVAL;
857 : : }
858 : :
859 : : /* Check if this device supports the desired state */
860 [ # # # # ]: 0 : if ((state == PCI_D1 && !dev->d1_support)
861 [ # # # # ]: 0 : || (state == PCI_D2 && !dev->d2_support))
862 : : return -EIO;
863 : :
864 : 0 : pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
865 [ # # ]: 0 : if (pmcsr == (u16) ~0) {
866 : 0 : pci_err(dev, "can't change power state from %s to %s (config space inaccessible)\n",
867 : : pci_power_name(dev->current_state),
868 : : pci_power_name(state));
869 : 0 : return -EIO;
870 : : }
871 : :
872 : : /*
873 : : * If we're (effectively) in D3, force entire word to 0.
874 : : * This doesn't affect PME_Status, disables PME_En, and
875 : : * sets PowerState to 0.
876 : : */
877 [ # # # ]: 0 : switch (dev->current_state) {
878 : 0 : case PCI_D0:
879 : : case PCI_D1:
880 : : case PCI_D2:
881 : 0 : pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
882 : 0 : pmcsr |= state;
883 : 0 : break;
884 : 0 : case PCI_D3hot:
885 : : case PCI_D3cold:
886 : : case PCI_UNKNOWN: /* Boot-up */
887 [ # # ]: 0 : if ((pmcsr & PCI_PM_CTRL_STATE_MASK) == PCI_D3hot
888 : : && !(pmcsr & PCI_PM_CTRL_NO_SOFT_RESET))
889 : 0 : need_restore = true;
890 : : /* Fall-through - force to D0 */
891 : : default:
892 : 0 : pmcsr = 0;
893 : 0 : break;
894 : : }
895 : :
896 : : /* Enter specified state */
897 : 0 : pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, pmcsr);
898 : :
899 : : /*
900 : : * Mandatory power management transition delays; see PCI PM 1.1
901 : : * 5.6.1 table 18
902 : : */
903 [ # # # # ]: 0 : if (state == PCI_D3hot || dev->current_state == PCI_D3hot)
904 [ # # ]: 0 : pci_dev_d3_sleep(dev);
905 [ # # # # ]: 0 : else if (state == PCI_D2 || dev->current_state == PCI_D2)
906 : 0 : msleep(PCI_PM_D2_DELAY);
907 : :
908 : 0 : pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
909 : 0 : dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
910 [ # # ]: 0 : if (dev->current_state != state)
911 [ # # ]: 0 : pci_info_ratelimited(dev, "refused to change power state from %s to %s\n",
912 : : pci_power_name(dev->current_state),
913 : : pci_power_name(state));
914 : :
915 : : /*
916 : : * According to section 5.4.1 of the "PCI BUS POWER MANAGEMENT
917 : : * INTERFACE SPECIFICATION, REV. 1.2", a device transitioning
918 : : * from D3hot to D0 _may_ perform an internal reset, thereby
919 : : * going to "D0 Uninitialized" rather than "D0 Initialized".
920 : : * For example, at least some versions of the 3c905B and the
921 : : * 3c556B exhibit this behaviour.
922 : : *
923 : : * At least some laptop BIOSen (e.g. the Thinkpad T21) leave
924 : : * devices in a D3hot state at boot. Consequently, we need to
925 : : * restore at least the BARs so that the device will be
926 : : * accessible to its driver.
927 : : */
928 [ # # ]: 0 : if (need_restore)
929 : : pci_restore_bars(dev);
930 : :
931 [ # # ]: 0 : if (dev->bus->self)
932 : 0 : pcie_aspm_pm_state_change(dev->bus->self);
933 : :
934 : : return 0;
935 : : }
936 : :
937 : : /**
938 : : * pci_update_current_state - Read power state of given device and cache it
939 : : * @dev: PCI device to handle.
940 : : * @state: State to cache in case the device doesn't have the PM capability
941 : : *
942 : : * The power state is read from the PMCSR register, which however is
943 : : * inaccessible in D3cold. The platform firmware is therefore queried first
944 : : * to detect accessibility of the register. In case the platform firmware
945 : : * reports an incorrect state or the device isn't power manageable by the
946 : : * platform at all, we try to detect D3cold by testing accessibility of the
947 : : * vendor ID in config space.
948 : : */
949 : 0 : void pci_update_current_state(struct pci_dev *dev, pci_power_t state)
950 : : {
951 [ # # # # : 0 : if (platform_pci_get_power_state(dev) == PCI_D3cold ||
# # ]
952 : : !pci_device_is_present(dev)) {
953 : 0 : dev->current_state = PCI_D3cold;
954 [ # # ]: 0 : } else if (dev->pm_cap) {
955 : 0 : u16 pmcsr;
956 : :
957 : 0 : pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
958 : 0 : dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
959 : : } else {
960 : 0 : dev->current_state = state;
961 : : }
962 : 0 : }
963 : :
964 : : /**
965 : : * pci_refresh_power_state - Refresh the given device's power state data
966 : : * @dev: Target PCI device.
967 : : *
968 : : * Ask the platform to refresh the devices power state information and invoke
969 : : * pci_update_current_state() to update its current PCI power state.
970 : : */
971 : 0 : void pci_refresh_power_state(struct pci_dev *dev)
972 : : {
973 [ # # ]: 0 : if (platform_pci_power_manageable(dev))
974 [ # # ]: 0 : platform_pci_refresh_power_state(dev);
975 : :
976 : 0 : pci_update_current_state(dev, dev->current_state);
977 : 0 : }
978 : :
979 : : /**
980 : : * pci_platform_power_transition - Use platform to change device power state
981 : : * @dev: PCI device to handle.
982 : : * @state: State to put the device into.
983 : : */
984 : 60 : int pci_platform_power_transition(struct pci_dev *dev, pci_power_t state)
985 : : {
986 : 60 : int error;
987 : :
988 [ + - ]: 60 : if (platform_pci_power_manageable(dev)) {
989 [ # # ]: 0 : error = platform_pci_set_power_state(dev, state);
990 [ # # ]: 0 : if (!error)
991 : 0 : pci_update_current_state(dev, state);
992 : : } else
993 : : error = -ENODEV;
994 : :
995 [ - - + - ]: 60 : if (error && !dev->pm_cap) /* Fall back to PCI_D0 */
996 : 60 : dev->current_state = PCI_D0;
997 : :
998 : 60 : return error;
999 : : }
1000 : : EXPORT_SYMBOL_GPL(pci_platform_power_transition);
1001 : :
1002 : : /**
1003 : : * pci_wakeup - Wake up a PCI device
1004 : : * @pci_dev: Device to handle.
1005 : : * @ign: ignored parameter
1006 : : */
1007 : 0 : static int pci_wakeup(struct pci_dev *pci_dev, void *ign)
1008 : : {
1009 : 0 : pci_wakeup_event(pci_dev);
1010 : 0 : pm_request_resume(&pci_dev->dev);
1011 : 0 : return 0;
1012 : : }
1013 : :
1014 : : /**
1015 : : * pci_wakeup_bus - Walk given bus and wake up devices on it
1016 : : * @bus: Top bus of the subtree to walk.
1017 : : */
1018 : 0 : void pci_wakeup_bus(struct pci_bus *bus)
1019 : : {
1020 [ # # ]: 0 : if (bus)
1021 : 0 : pci_walk_bus(bus, pci_wakeup, NULL);
1022 : 0 : }
1023 : :
1024 : 0 : static int pci_dev_wait(struct pci_dev *dev, char *reset_type, int timeout)
1025 : : {
1026 : 0 : int delay = 1;
1027 : 0 : u32 id;
1028 : :
1029 : : /*
1030 : : * After reset, the device should not silently discard config
1031 : : * requests, but it may still indicate that it needs more time by
1032 : : * responding to them with CRS completions. The Root Port will
1033 : : * generally synthesize ~0 data to complete the read (except when
1034 : : * CRS SV is enabled and the read was for the Vendor ID; in that
1035 : : * case it synthesizes 0x0001 data).
1036 : : *
1037 : : * Wait for the device to return a non-CRS completion. Read the
1038 : : * Command register instead of Vendor ID so we don't have to
1039 : : * contend with the CRS SV value.
1040 : : */
1041 : 0 : pci_read_config_dword(dev, PCI_COMMAND, &id);
1042 [ # # ]: 0 : while (id == ~0) {
1043 [ # # ]: 0 : if (delay > timeout) {
1044 : 0 : pci_warn(dev, "not ready %dms after %s; giving up\n",
1045 : : delay - 1, reset_type);
1046 : 0 : return -ENOTTY;
1047 : : }
1048 : :
1049 [ # # ]: 0 : if (delay > 1000)
1050 : 0 : pci_info(dev, "not ready %dms after %s; waiting\n",
1051 : : delay - 1, reset_type);
1052 : :
1053 : 0 : msleep(delay);
1054 : 0 : delay *= 2;
1055 : 0 : pci_read_config_dword(dev, PCI_COMMAND, &id);
1056 : : }
1057 : :
1058 [ # # ]: 0 : if (delay > 1000)
1059 : 0 : pci_info(dev, "ready %dms after %s\n", delay - 1,
1060 : : reset_type);
1061 : :
1062 : : return 0;
1063 : : }
1064 : :
1065 : : /**
1066 : : * pci_power_up - Put the given device into D0
1067 : : * @dev: PCI device to power up
1068 : : */
1069 : 60 : int pci_power_up(struct pci_dev *dev)
1070 : : {
1071 : 60 : pci_platform_power_transition(dev, PCI_D0);
1072 : :
1073 : : /*
1074 : : * Mandatory power management transition delays are handled in
1075 : : * pci_pm_resume_noirq() and pci_pm_runtime_resume() of the
1076 : : * corresponding bridge.
1077 : : */
1078 [ - + ]: 60 : if (dev->runtime_d3cold) {
1079 : : /*
1080 : : * When powering on a bridge from D3cold, the whole hierarchy
1081 : : * may be powered on into D0uninitialized state, resume them to
1082 : : * give them a chance to suspend again
1083 : : */
1084 [ # # ]: 0 : pci_wakeup_bus(dev->subordinate);
1085 : : }
1086 : :
1087 : 60 : return pci_raw_set_power_state(dev, PCI_D0);
1088 : : }
1089 : :
1090 : : /**
1091 : : * __pci_dev_set_current_state - Set current state of a PCI device
1092 : : * @dev: Device to handle
1093 : : * @data: pointer to state to be set
1094 : : */
1095 : 0 : static int __pci_dev_set_current_state(struct pci_dev *dev, void *data)
1096 : : {
1097 : 0 : pci_power_t state = *(pci_power_t *)data;
1098 : :
1099 : 0 : dev->current_state = state;
1100 : 0 : return 0;
1101 : : }
1102 : :
1103 : : /**
1104 : : * pci_bus_set_current_state - Walk given bus and set current state of devices
1105 : : * @bus: Top bus of the subtree to walk.
1106 : : * @state: state to be set
1107 : : */
1108 : 0 : void pci_bus_set_current_state(struct pci_bus *bus, pci_power_t state)
1109 : : {
1110 [ # # ]: 0 : if (bus)
1111 : 0 : pci_walk_bus(bus, __pci_dev_set_current_state, &state);
1112 : 0 : }
1113 : :
1114 : : /**
1115 : : * pci_set_power_state - Set the power state of a PCI device
1116 : : * @dev: PCI device to handle.
1117 : : * @state: PCI power state (D0, D1, D2, D3hot) to put the device into.
1118 : : *
1119 : : * Transition a device to a new power state, using the platform firmware and/or
1120 : : * the device's PCI PM registers.
1121 : : *
1122 : : * RETURN VALUE:
1123 : : * -EINVAL if the requested state is invalid.
1124 : : * -EIO if device does not support PCI PM or its PM capabilities register has a
1125 : : * wrong version, or device doesn't support the requested state.
1126 : : * 0 if the transition is to D1 or D2 but D1 and D2 are not supported.
1127 : : * 0 if device already is in the requested state.
1128 : : * 0 if the transition is to D3 but D3 is not supported.
1129 : : * 0 if device's power state has been successfully changed.
1130 : : */
1131 : 120 : int pci_set_power_state(struct pci_dev *dev, pci_power_t state)
1132 : : {
1133 : 120 : int error;
1134 : :
1135 : : /* Bound the state we're entering */
1136 [ + - ]: 120 : if (state > PCI_D3cold)
1137 : : state = PCI_D3cold;
1138 [ + - ]: 120 : else if (state < PCI_D0)
1139 : : state = PCI_D0;
1140 [ - + - - ]: 120 : else if ((state == PCI_D1 || state == PCI_D2) && pci_no_d1d2(dev))
1141 : :
1142 : : /*
1143 : : * If the device or the parent bridge do not support PCI
1144 : : * PM, ignore the request if we're doing anything other
1145 : : * than putting it into D0 (which would only happen on
1146 : : * boot).
1147 : : */
1148 : : return 0;
1149 : :
1150 : : /* Check if we're already there */
1151 [ + + ]: 120 : if (dev->current_state == state)
1152 : : return 0;
1153 : :
1154 [ + - ]: 60 : if (state == PCI_D0)
1155 : 60 : return pci_power_up(dev);
1156 : :
1157 : : /*
1158 : : * This device is quirked not to be put into D3, so don't put it in
1159 : : * D3
1160 : : */
1161 [ # # # # ]: 0 : if (state >= PCI_D3hot && (dev->dev_flags & PCI_DEV_FLAGS_NO_D3))
1162 : : return 0;
1163 : :
1164 : : /*
1165 : : * To put device in D3cold, we put device into D3hot in native
1166 : : * way, then put device into D3cold with platform ops
1167 : : */
1168 : 0 : error = pci_raw_set_power_state(dev, state > PCI_D3hot ?
1169 : 0 : PCI_D3hot : state);
1170 : :
1171 [ # # ]: 0 : if (pci_platform_power_transition(dev, state))
1172 : : return error;
1173 : :
1174 : : /* Powering off a bridge may power off the whole hierarchy */
1175 [ # # ]: 0 : if (state == PCI_D3cold)
1176 [ # # ]: 0 : pci_bus_set_current_state(dev->subordinate, PCI_D3cold);
1177 : :
1178 : : return 0;
1179 : : }
1180 : : EXPORT_SYMBOL(pci_set_power_state);
1181 : :
1182 : : /**
1183 : : * pci_choose_state - Choose the power state of a PCI device
1184 : : * @dev: PCI device to be suspended
1185 : : * @state: target sleep state for the whole system. This is the value
1186 : : * that is passed to suspend() function.
1187 : : *
1188 : : * Returns PCI power state suitable for given device and given system
1189 : : * message.
1190 : : */
1191 : 0 : pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state)
1192 : : {
1193 : 0 : pci_power_t ret;
1194 : :
1195 [ # # ]: 0 : if (!dev->pm_cap)
1196 : : return PCI_D0;
1197 : :
1198 [ # # ]: 0 : ret = platform_pci_choose_state(dev);
1199 [ # # ]: 0 : if (ret != PCI_POWER_ERROR)
1200 : : return ret;
1201 : :
1202 [ # # # ]: 0 : switch (state.event) {
1203 : : case PM_EVENT_ON:
1204 : : return PCI_D0;
1205 : 0 : case PM_EVENT_FREEZE:
1206 : : case PM_EVENT_PRETHAW:
1207 : : /* REVISIT both freeze and pre-thaw "should" use D0 */
1208 : : case PM_EVENT_SUSPEND:
1209 : : case PM_EVENT_HIBERNATE:
1210 : 0 : return PCI_D3hot;
1211 : 0 : default:
1212 : 0 : pci_info(dev, "unrecognized suspend event %d\n",
1213 : : state.event);
1214 : 0 : BUG();
1215 : : }
1216 : : return PCI_D0;
1217 : : }
1218 : : EXPORT_SYMBOL(pci_choose_state);
1219 : :
1220 : : #define PCI_EXP_SAVE_REGS 7
1221 : :
1222 : 0 : static struct pci_cap_saved_state *_pci_find_saved_cap(struct pci_dev *pci_dev,
1223 : : u16 cap, bool extended)
1224 : : {
1225 : 0 : struct pci_cap_saved_state *tmp;
1226 : :
1227 [ # # # # : 0 : hlist_for_each_entry(tmp, &pci_dev->saved_cap_space, next) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
1228 [ # # # # : 0 : if (tmp->cap.cap_extended == extended && tmp->cap.cap_nr == cap)
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
1229 : : return tmp;
1230 : : }
1231 : : return NULL;
1232 : : }
1233 : :
1234 : 0 : struct pci_cap_saved_state *pci_find_saved_cap(struct pci_dev *dev, char cap)
1235 : : {
1236 [ # # ]: 0 : return _pci_find_saved_cap(dev, cap, false);
1237 : : }
1238 : :
1239 : 0 : struct pci_cap_saved_state *pci_find_saved_ext_cap(struct pci_dev *dev, u16 cap)
1240 : : {
1241 [ # # ]: 0 : return _pci_find_saved_cap(dev, cap, true);
1242 : : }
1243 : :
1244 : 30 : static int pci_save_pcie_state(struct pci_dev *dev)
1245 : : {
1246 : 30 : int i = 0;
1247 : 30 : struct pci_cap_saved_state *save_state;
1248 : 30 : u16 *cap;
1249 : :
1250 [ - + ]: 30 : if (!pci_is_pcie(dev))
1251 : : return 0;
1252 : :
1253 [ # # ]: 0 : save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
1254 [ # # ]: 0 : if (!save_state) {
1255 : 0 : pci_err(dev, "buffer not found in %s\n", __func__);
1256 : 0 : return -ENOMEM;
1257 : : }
1258 : :
1259 : 0 : cap = (u16 *)&save_state->cap.data[0];
1260 : 0 : pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &cap[i++]);
1261 : 0 : pcie_capability_read_word(dev, PCI_EXP_LNKCTL, &cap[i++]);
1262 : 0 : pcie_capability_read_word(dev, PCI_EXP_SLTCTL, &cap[i++]);
1263 : 0 : pcie_capability_read_word(dev, PCI_EXP_RTCTL, &cap[i++]);
1264 : 0 : pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]);
1265 : 0 : pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]);
1266 : 0 : pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]);
1267 : :
1268 : 0 : return 0;
1269 : : }
1270 : :
1271 : 0 : static void pci_restore_pcie_state(struct pci_dev *dev)
1272 : : {
1273 : 0 : int i = 0;
1274 : 0 : struct pci_cap_saved_state *save_state;
1275 : 0 : u16 *cap;
1276 : :
1277 [ # # ]: 0 : save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
1278 [ # # ]: 0 : if (!save_state)
1279 : : return;
1280 : :
1281 : 0 : cap = (u16 *)&save_state->cap.data[0];
1282 : 0 : pcie_capability_write_word(dev, PCI_EXP_DEVCTL, cap[i++]);
1283 : 0 : pcie_capability_write_word(dev, PCI_EXP_LNKCTL, cap[i++]);
1284 : 0 : pcie_capability_write_word(dev, PCI_EXP_SLTCTL, cap[i++]);
1285 : 0 : pcie_capability_write_word(dev, PCI_EXP_RTCTL, cap[i++]);
1286 : 0 : pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]);
1287 : 0 : pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]);
1288 : 0 : pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]);
1289 : : }
1290 : :
1291 : 30 : static int pci_save_pcix_state(struct pci_dev *dev)
1292 : : {
1293 : 30 : int pos;
1294 : 30 : struct pci_cap_saved_state *save_state;
1295 : :
1296 : 30 : pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1297 [ - + ]: 30 : if (!pos)
1298 : : return 0;
1299 : :
1300 [ # # ]: 0 : save_state = pci_find_saved_cap(dev, PCI_CAP_ID_PCIX);
1301 [ # # ]: 0 : if (!save_state) {
1302 : 0 : pci_err(dev, "buffer not found in %s\n", __func__);
1303 : 0 : return -ENOMEM;
1304 : : }
1305 : :
1306 : 0 : pci_read_config_word(dev, pos + PCI_X_CMD,
1307 : 0 : (u16 *)save_state->cap.data);
1308 : :
1309 : 0 : return 0;
1310 : : }
1311 : :
1312 : 0 : static void pci_restore_pcix_state(struct pci_dev *dev)
1313 : : {
1314 : 0 : int i = 0, pos;
1315 : 0 : struct pci_cap_saved_state *save_state;
1316 : 0 : u16 *cap;
1317 : :
1318 [ # # ]: 0 : save_state = pci_find_saved_cap(dev, PCI_CAP_ID_PCIX);
1319 : 0 : pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1320 [ # # ]: 0 : if (!save_state || !pos)
1321 : : return;
1322 : 0 : cap = (u16 *)&save_state->cap.data[0];
1323 : :
1324 : 0 : pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]);
1325 : : }
1326 : :
1327 : 30 : static void pci_save_ltr_state(struct pci_dev *dev)
1328 : : {
1329 : 30 : int ltr;
1330 : 30 : struct pci_cap_saved_state *save_state;
1331 : 30 : u16 *cap;
1332 : :
1333 [ - + ]: 30 : if (!pci_is_pcie(dev))
1334 : : return;
1335 : :
1336 : 0 : ltr = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_LTR);
1337 [ # # ]: 0 : if (!ltr)
1338 : : return;
1339 : :
1340 [ # # ]: 0 : save_state = pci_find_saved_ext_cap(dev, PCI_EXT_CAP_ID_LTR);
1341 [ # # ]: 0 : if (!save_state) {
1342 : 0 : pci_err(dev, "no suspend buffer for LTR; ASPM issues possible after resume\n");
1343 : 0 : return;
1344 : : }
1345 : :
1346 : 0 : cap = (u16 *)&save_state->cap.data[0];
1347 : 0 : pci_read_config_word(dev, ltr + PCI_LTR_MAX_SNOOP_LAT, cap++);
1348 : 0 : pci_read_config_word(dev, ltr + PCI_LTR_MAX_NOSNOOP_LAT, cap++);
1349 : : }
1350 : :
1351 : 0 : static void pci_restore_ltr_state(struct pci_dev *dev)
1352 : : {
1353 : 0 : struct pci_cap_saved_state *save_state;
1354 : 0 : int ltr;
1355 : 0 : u16 *cap;
1356 : :
1357 [ # # ]: 0 : save_state = pci_find_saved_ext_cap(dev, PCI_EXT_CAP_ID_LTR);
1358 : 0 : ltr = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_LTR);
1359 [ # # ]: 0 : if (!save_state || !ltr)
1360 : : return;
1361 : :
1362 : 0 : cap = (u16 *)&save_state->cap.data[0];
1363 : 0 : pci_write_config_word(dev, ltr + PCI_LTR_MAX_SNOOP_LAT, *cap++);
1364 : 0 : pci_write_config_word(dev, ltr + PCI_LTR_MAX_NOSNOOP_LAT, *cap++);
1365 : : }
1366 : :
1367 : : /**
1368 : : * pci_save_state - save the PCI configuration space of a device before
1369 : : * suspending
1370 : : * @dev: PCI device that we're dealing with
1371 : : */
1372 : 30 : int pci_save_state(struct pci_dev *dev)
1373 : : {
1374 : 30 : int i;
1375 : : /* XXX: 100% dword access ok here? */
1376 [ + + ]: 510 : for (i = 0; i < 16; i++) {
1377 : 480 : pci_read_config_dword(dev, i * 4, &dev->saved_config_space[i]);
1378 : 480 : pci_dbg(dev, "saving config space at offset %#x (reading %#x)\n",
1379 : : i * 4, dev->saved_config_space[i]);
1380 : : }
1381 : 30 : dev->state_saved = true;
1382 : :
1383 : 30 : i = pci_save_pcie_state(dev);
1384 [ + - ]: 30 : if (i != 0)
1385 : : return i;
1386 : :
1387 : 30 : i = pci_save_pcix_state(dev);
1388 [ + - ]: 30 : if (i != 0)
1389 : : return i;
1390 : :
1391 : 30 : pci_save_ltr_state(dev);
1392 : 30 : pci_save_dpc_state(dev);
1393 : 30 : pci_save_aer_state(dev);
1394 : 30 : return pci_save_vc_state(dev);
1395 : : }
1396 : : EXPORT_SYMBOL(pci_save_state);
1397 : :
1398 : 0 : static void pci_restore_config_dword(struct pci_dev *pdev, int offset,
1399 : : u32 saved_val, int retry, bool force)
1400 : : {
1401 : 0 : u32 val;
1402 : :
1403 : 0 : pci_read_config_dword(pdev, offset, &val);
1404 [ # # # # ]: 0 : if (!force && val == saved_val)
1405 : : return;
1406 : :
1407 : 0 : for (;;) {
1408 : 0 : pci_dbg(pdev, "restoring config space at offset %#x (was %#x, writing %#x)\n",
1409 : : offset, val, saved_val);
1410 : 0 : pci_write_config_dword(pdev, offset, saved_val);
1411 [ # # ]: 0 : if (retry-- <= 0)
1412 : : return;
1413 : :
1414 : 0 : pci_read_config_dword(pdev, offset, &val);
1415 [ # # ]: 0 : if (val == saved_val)
1416 : : return;
1417 : :
1418 : 0 : mdelay(1);
1419 : : }
1420 : : }
1421 : :
1422 : : static void pci_restore_config_space_range(struct pci_dev *pdev,
1423 : : int start, int end, int retry,
1424 : : bool force)
1425 : : {
1426 : : int index;
1427 : :
1428 [ # # # # : 0 : for (index = end; index >= start; index--)
# # # # #
# # # #
# ]
1429 : 0 : pci_restore_config_dword(pdev, 4 * index,
1430 : : pdev->saved_config_space[index],
1431 : : retry, force);
1432 : : }
1433 : :
1434 : 0 : static void pci_restore_config_space(struct pci_dev *pdev)
1435 : : {
1436 [ # # ]: 0 : if (pdev->hdr_type == PCI_HEADER_TYPE_NORMAL) {
1437 : : pci_restore_config_space_range(pdev, 10, 15, 0, false);
1438 : : /* Restore BARs before the command register. */
1439 : : pci_restore_config_space_range(pdev, 4, 9, 10, false);
1440 : : pci_restore_config_space_range(pdev, 0, 3, 0, false);
1441 [ # # ]: 0 : } else if (pdev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
1442 : : pci_restore_config_space_range(pdev, 12, 15, 0, false);
1443 : :
1444 : : /*
1445 : : * Force rewriting of prefetch registers to avoid S3 resume
1446 : : * issues on Intel PCI bridges that occur when these
1447 : : * registers are not explicitly written.
1448 : : */
1449 : : pci_restore_config_space_range(pdev, 9, 11, 0, true);
1450 : : pci_restore_config_space_range(pdev, 0, 8, 0, false);
1451 : : } else {
1452 : : pci_restore_config_space_range(pdev, 0, 15, 0, false);
1453 : : }
1454 : 0 : }
1455 : :
1456 : 0 : static void pci_restore_rebar_state(struct pci_dev *pdev)
1457 : : {
1458 : 0 : unsigned int pos, nbars, i;
1459 : 0 : u32 ctrl;
1460 : :
1461 : 0 : pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_REBAR);
1462 [ # # ]: 0 : if (!pos)
1463 : 0 : return;
1464 : :
1465 : 0 : pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
1466 : 0 : nbars = (ctrl & PCI_REBAR_CTRL_NBAR_MASK) >>
1467 : : PCI_REBAR_CTRL_NBAR_SHIFT;
1468 : :
1469 [ # # ]: 0 : for (i = 0; i < nbars; i++, pos += 8) {
1470 : 0 : struct resource *res;
1471 : 0 : int bar_idx, size;
1472 : :
1473 : 0 : pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
1474 : 0 : bar_idx = ctrl & PCI_REBAR_CTRL_BAR_IDX;
1475 : 0 : res = pdev->resource + bar_idx;
1476 : 0 : size = ilog2(resource_size(res)) - 20;
1477 : 0 : ctrl &= ~PCI_REBAR_CTRL_BAR_SIZE;
1478 : 0 : ctrl |= size << PCI_REBAR_CTRL_BAR_SHIFT;
1479 : 0 : pci_write_config_dword(pdev, pos + PCI_REBAR_CTRL, ctrl);
1480 : : }
1481 : : }
1482 : :
1483 : : /**
1484 : : * pci_restore_state - Restore the saved state of a PCI device
1485 : : * @dev: PCI device that we're dealing with
1486 : : */
1487 : 0 : void pci_restore_state(struct pci_dev *dev)
1488 : : {
1489 [ # # ]: 0 : if (!dev->state_saved)
1490 : : return;
1491 : :
1492 : : /*
1493 : : * Restore max latencies (in the LTR capability) before enabling
1494 : : * LTR itself (in the PCIe capability).
1495 : : */
1496 : 0 : pci_restore_ltr_state(dev);
1497 : :
1498 : 0 : pci_restore_pcie_state(dev);
1499 : 0 : pci_restore_pasid_state(dev);
1500 : 0 : pci_restore_pri_state(dev);
1501 : 0 : pci_restore_ats_state(dev);
1502 : 0 : pci_restore_vc_state(dev);
1503 : 0 : pci_restore_rebar_state(dev);
1504 : 0 : pci_restore_dpc_state(dev);
1505 : :
1506 : 0 : pci_cleanup_aer_error_status_regs(dev);
1507 : 0 : pci_restore_aer_state(dev);
1508 : :
1509 : 0 : pci_restore_config_space(dev);
1510 : :
1511 : 0 : pci_restore_pcix_state(dev);
1512 : 0 : pci_restore_msi_state(dev);
1513 : :
1514 : : /* Restore ACS and IOV configuration state */
1515 : 0 : pci_enable_acs(dev);
1516 : 0 : pci_restore_iov_state(dev);
1517 : :
1518 : 0 : dev->state_saved = false;
1519 : : }
1520 : : EXPORT_SYMBOL(pci_restore_state);
1521 : :
1522 : : struct pci_saved_state {
1523 : : u32 config_space[16];
1524 : : struct pci_cap_saved_data cap[0];
1525 : : };
1526 : :
1527 : : /**
1528 : : * pci_store_saved_state - Allocate and return an opaque struct containing
1529 : : * the device saved state.
1530 : : * @dev: PCI device that we're dealing with
1531 : : *
1532 : : * Return NULL if no state or error.
1533 : : */
1534 : 0 : struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev)
1535 : : {
1536 : 0 : struct pci_saved_state *state;
1537 : 0 : struct pci_cap_saved_state *tmp;
1538 : 0 : struct pci_cap_saved_data *cap;
1539 : 0 : size_t size;
1540 : :
1541 [ # # ]: 0 : if (!dev->state_saved)
1542 : : return NULL;
1543 : :
1544 : 0 : size = sizeof(*state) + sizeof(struct pci_cap_saved_data);
1545 : :
1546 [ # # # # ]: 0 : hlist_for_each_entry(tmp, &dev->saved_cap_space, next)
1547 [ # # ]: 0 : size += sizeof(struct pci_cap_saved_data) + tmp->cap.size;
1548 : :
1549 : 0 : state = kzalloc(size, GFP_KERNEL);
1550 [ # # ]: 0 : if (!state)
1551 : : return NULL;
1552 : :
1553 : 0 : memcpy(state->config_space, dev->saved_config_space,
1554 : : sizeof(state->config_space));
1555 : :
1556 : 0 : cap = state->cap;
1557 [ # # # # ]: 0 : hlist_for_each_entry(tmp, &dev->saved_cap_space, next) {
1558 : 0 : size_t len = sizeof(struct pci_cap_saved_data) + tmp->cap.size;
1559 : 0 : memcpy(cap, &tmp->cap, len);
1560 [ # # ]: 0 : cap = (struct pci_cap_saved_data *)((u8 *)cap + len);
1561 : : }
1562 : : /* Empty cap_save terminates list */
1563 : :
1564 : : return state;
1565 : : }
1566 : : EXPORT_SYMBOL_GPL(pci_store_saved_state);
1567 : :
1568 : : /**
1569 : : * pci_load_saved_state - Reload the provided save state into struct pci_dev.
1570 : : * @dev: PCI device that we're dealing with
1571 : : * @state: Saved state returned from pci_store_saved_state()
1572 : : */
1573 : 0 : int pci_load_saved_state(struct pci_dev *dev,
1574 : : struct pci_saved_state *state)
1575 : : {
1576 : 0 : struct pci_cap_saved_data *cap;
1577 : :
1578 : 0 : dev->state_saved = false;
1579 : :
1580 [ # # ]: 0 : if (!state)
1581 : : return 0;
1582 : :
1583 : 0 : memcpy(dev->saved_config_space, state->config_space,
1584 : : sizeof(state->config_space));
1585 : :
1586 : 0 : cap = state->cap;
1587 [ # # ]: 0 : while (cap->size) {
1588 : 0 : struct pci_cap_saved_state *tmp;
1589 : :
1590 [ # # ]: 0 : tmp = _pci_find_saved_cap(dev, cap->cap_nr, cap->cap_extended);
1591 [ # # # # ]: 0 : if (!tmp || tmp->cap.size != cap->size)
1592 : : return -EINVAL;
1593 : :
1594 : 0 : memcpy(tmp->cap.data, cap->data, tmp->cap.size);
1595 : 0 : cap = (struct pci_cap_saved_data *)((u8 *)cap +
1596 : 0 : sizeof(struct pci_cap_saved_data) + cap->size);
1597 : : }
1598 : :
1599 : 0 : dev->state_saved = true;
1600 : 0 : return 0;
1601 : : }
1602 : : EXPORT_SYMBOL_GPL(pci_load_saved_state);
1603 : :
1604 : : /**
1605 : : * pci_load_and_free_saved_state - Reload the save state pointed to by state,
1606 : : * and free the memory allocated for it.
1607 : : * @dev: PCI device that we're dealing with
1608 : : * @state: Pointer to saved state returned from pci_store_saved_state()
1609 : : */
1610 : 0 : int pci_load_and_free_saved_state(struct pci_dev *dev,
1611 : : struct pci_saved_state **state)
1612 : : {
1613 : 0 : int ret = pci_load_saved_state(dev, *state);
1614 : 0 : kfree(*state);
1615 : 0 : *state = NULL;
1616 : 0 : return ret;
1617 : : }
1618 : : EXPORT_SYMBOL_GPL(pci_load_and_free_saved_state);
1619 : :
1620 : 0 : int __weak pcibios_enable_device(struct pci_dev *dev, int bars)
1621 : : {
1622 : 0 : return pci_enable_resources(dev, bars);
1623 : : }
1624 : :
1625 : 120 : static int do_pci_enable_device(struct pci_dev *dev, int bars)
1626 : : {
1627 : 120 : int err;
1628 : 120 : struct pci_dev *bridge;
1629 : 120 : u16 cmd;
1630 : 120 : u8 pin;
1631 : :
1632 : 120 : err = pci_set_power_state(dev, PCI_D0);
1633 [ + - ]: 120 : if (err < 0 && err != -EIO)
1634 : : return err;
1635 : :
1636 [ - + ]: 120 : bridge = pci_upstream_bridge(dev);
1637 [ # # ]: 0 : if (bridge)
1638 : 0 : pcie_aspm_powersave_config_link(bridge);
1639 : :
1640 : 120 : err = pcibios_enable_device(dev, bars);
1641 [ + - ]: 120 : if (err < 0)
1642 : : return err;
1643 : 120 : pci_fixup_device(pci_fixup_enable, dev);
1644 : :
1645 [ + - ]: 120 : if (dev->msi_enabled || dev->msix_enabled)
1646 : : return 0;
1647 : :
1648 : 120 : pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
1649 [ + + ]: 120 : if (pin) {
1650 : 30 : pci_read_config_word(dev, PCI_COMMAND, &cmd);
1651 [ - + ]: 30 : if (cmd & PCI_COMMAND_INTX_DISABLE)
1652 : 0 : pci_write_config_word(dev, PCI_COMMAND,
1653 : : cmd & ~PCI_COMMAND_INTX_DISABLE);
1654 : : }
1655 : :
1656 : : return 0;
1657 : : }
1658 : :
1659 : : /**
1660 : : * pci_reenable_device - Resume abandoned device
1661 : : * @dev: PCI device to be resumed
1662 : : *
1663 : : * NOTE: This function is a backend of pci_default_resume() and is not supposed
1664 : : * to be called by normal code, write proper resume handler and use it instead.
1665 : : */
1666 : 0 : int pci_reenable_device(struct pci_dev *dev)
1667 : : {
1668 [ # # ]: 0 : if (pci_is_enabled(dev))
1669 : 0 : return do_pci_enable_device(dev, (1 << PCI_NUM_RESOURCES) - 1);
1670 : : return 0;
1671 : : }
1672 : : EXPORT_SYMBOL(pci_reenable_device);
1673 : :
1674 : 0 : static void pci_enable_bridge(struct pci_dev *dev)
1675 : : {
1676 : 0 : struct pci_dev *bridge;
1677 : 0 : int retval;
1678 : :
1679 [ # # ]: 0 : bridge = pci_upstream_bridge(dev);
1680 [ # # ]: 0 : if (bridge)
1681 : 0 : pci_enable_bridge(bridge);
1682 : :
1683 [ # # ]: 0 : if (pci_is_enabled(dev)) {
1684 [ # # ]: 0 : if (!dev->is_busmaster)
1685 : 0 : pci_set_master(dev);
1686 : 0 : return;
1687 : : }
1688 : :
1689 : 0 : retval = pci_enable_device(dev);
1690 [ # # ]: 0 : if (retval)
1691 : 0 : pci_err(dev, "Error enabling bridge (%d), continuing\n",
1692 : : retval);
1693 : 0 : pci_set_master(dev);
1694 : : }
1695 : :
1696 : 120 : static int pci_enable_device_flags(struct pci_dev *dev, unsigned long flags)
1697 : : {
1698 : 120 : struct pci_dev *bridge;
1699 : 120 : int err;
1700 : 120 : int i, bars = 0;
1701 : :
1702 : : /*
1703 : : * Power state could be unknown at this point, either due to a fresh
1704 : : * boot or a device removal call. So get the current power state
1705 : : * so that things like MSI message writing will behave as expected
1706 : : * (e.g. if the device really is in D0 at enable time).
1707 : : */
1708 [ + + ]: 120 : if (dev->pm_cap) {
1709 : 30 : u16 pmcsr;
1710 : 30 : pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
1711 : 30 : dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
1712 : : }
1713 : :
1714 [ + - ]: 120 : if (atomic_inc_return(&dev->enable_cnt) > 1)
1715 : : return 0; /* already enabled */
1716 : :
1717 [ - + ]: 120 : bridge = pci_upstream_bridge(dev);
1718 [ # # ]: 0 : if (bridge)
1719 : 0 : pci_enable_bridge(bridge);
1720 : :
1721 : : /* only skip sriov related */
1722 [ + + ]: 960 : for (i = 0; i <= PCI_ROM_RESOURCE; i++)
1723 [ + + ]: 840 : if (dev->resource[i].flags & flags)
1724 : 270 : bars |= (1 << i);
1725 [ + + ]: 600 : for (i = PCI_BRIDGE_RESOURCES; i < DEVICE_COUNT_RESOURCE; i++)
1726 [ - + ]: 480 : if (dev->resource[i].flags & flags)
1727 : 0 : bars |= (1 << i);
1728 : :
1729 : 120 : err = do_pci_enable_device(dev, bars);
1730 [ - + ]: 120 : if (err < 0)
1731 : 0 : atomic_dec(&dev->enable_cnt);
1732 : : return err;
1733 : : }
1734 : :
1735 : : /**
1736 : : * pci_enable_device_io - Initialize a device for use with IO space
1737 : : * @dev: PCI device to be initialized
1738 : : *
1739 : : * Initialize device before it's used by a driver. Ask low-level code
1740 : : * to enable I/O resources. Wake up the device if it was suspended.
1741 : : * Beware, this function can fail.
1742 : : */
1743 : 0 : int pci_enable_device_io(struct pci_dev *dev)
1744 : : {
1745 : 0 : return pci_enable_device_flags(dev, IORESOURCE_IO);
1746 : : }
1747 : : EXPORT_SYMBOL(pci_enable_device_io);
1748 : :
1749 : : /**
1750 : : * pci_enable_device_mem - Initialize a device for use with Memory space
1751 : : * @dev: PCI device to be initialized
1752 : : *
1753 : : * Initialize device before it's used by a driver. Ask low-level code
1754 : : * to enable Memory resources. Wake up the device if it was suspended.
1755 : : * Beware, this function can fail.
1756 : : */
1757 : 0 : int pci_enable_device_mem(struct pci_dev *dev)
1758 : : {
1759 : 0 : return pci_enable_device_flags(dev, IORESOURCE_MEM);
1760 : : }
1761 : : EXPORT_SYMBOL(pci_enable_device_mem);
1762 : :
1763 : : /**
1764 : : * pci_enable_device - Initialize device before it's used by a driver.
1765 : : * @dev: PCI device to be initialized
1766 : : *
1767 : : * Initialize device before it's used by a driver. Ask low-level code
1768 : : * to enable I/O and memory. Wake up the device if it was suspended.
1769 : : * Beware, this function can fail.
1770 : : *
1771 : : * Note we don't actually enable the device many times if we call
1772 : : * this function repeatedly (we just increment the count).
1773 : : */
1774 : 120 : int pci_enable_device(struct pci_dev *dev)
1775 : : {
1776 : 30 : return pci_enable_device_flags(dev, IORESOURCE_MEM | IORESOURCE_IO);
1777 : : }
1778 : : EXPORT_SYMBOL(pci_enable_device);
1779 : :
1780 : : /*
1781 : : * Managed PCI resources. This manages device on/off, INTx/MSI/MSI-X
1782 : : * on/off and BAR regions. pci_dev itself records MSI/MSI-X status, so
1783 : : * there's no need to track it separately. pci_devres is initialized
1784 : : * when a device is enabled using managed PCI device enable interface.
1785 : : */
1786 : : struct pci_devres {
1787 : : unsigned int enabled:1;
1788 : : unsigned int pinned:1;
1789 : : unsigned int orig_intx:1;
1790 : : unsigned int restore_intx:1;
1791 : : unsigned int mwi:1;
1792 : : u32 region_mask;
1793 : : };
1794 : :
1795 : 54 : static void pcim_release(struct device *gendev, void *res)
1796 : : {
1797 : 54 : struct pci_dev *dev = to_pci_dev(gendev);
1798 : 54 : struct pci_devres *this = res;
1799 : 54 : int i;
1800 : :
1801 [ - + ]: 54 : if (dev->msi_enabled)
1802 : 0 : pci_disable_msi(dev);
1803 [ - + ]: 54 : if (dev->msix_enabled)
1804 : 0 : pci_disable_msix(dev);
1805 : :
1806 [ + + ]: 648 : for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
1807 [ + + ]: 594 : if (this->region_mask & (1 << i))
1808 : 24 : pci_release_region(dev, i);
1809 : :
1810 [ - + ]: 54 : if (this->mwi)
1811 : 0 : pci_clear_mwi(dev);
1812 : :
1813 [ - + ]: 54 : if (this->restore_intx)
1814 : 0 : pci_intx(dev, this->orig_intx);
1815 : :
1816 [ + - ]: 54 : if (this->enabled && !this->pinned)
1817 : 54 : pci_disable_device(dev);
1818 : 54 : }
1819 : :
1820 : 90 : static struct pci_devres *get_pci_dr(struct pci_dev *pdev)
1821 : : {
1822 : 90 : struct pci_devres *dr, *new_dr;
1823 : :
1824 : 90 : dr = devres_find(&pdev->dev, pcim_release, NULL, NULL);
1825 [ + - ]: 90 : if (dr)
1826 : : return dr;
1827 : :
1828 : 90 : new_dr = devres_alloc(pcim_release, sizeof(*new_dr), GFP_KERNEL);
1829 [ + - ]: 90 : if (!new_dr)
1830 : : return NULL;
1831 : 90 : return devres_get(&pdev->dev, new_dr, NULL, NULL);
1832 : : }
1833 : :
1834 : 258 : static struct pci_devres *find_pci_dr(struct pci_dev *pdev)
1835 : : {
1836 : 258 : if (pci_is_managed(pdev))
1837 : 258 : return devres_find(&pdev->dev, pcim_release, NULL, NULL);
1838 : : return NULL;
1839 : : }
1840 : :
1841 : : /**
1842 : : * pcim_enable_device - Managed pci_enable_device()
1843 : : * @pdev: PCI device to be initialized
1844 : : *
1845 : : * Managed pci_enable_device().
1846 : : */
1847 : 90 : int pcim_enable_device(struct pci_dev *pdev)
1848 : : {
1849 : 90 : struct pci_devres *dr;
1850 : 90 : int rc;
1851 : :
1852 : 90 : dr = get_pci_dr(pdev);
1853 [ + - ]: 90 : if (unlikely(!dr))
1854 : : return -ENOMEM;
1855 [ + - ]: 90 : if (dr->enabled)
1856 : : return 0;
1857 : :
1858 : 90 : rc = pci_enable_device(pdev);
1859 [ + - ]: 90 : if (!rc) {
1860 : 90 : pdev->is_managed = 1;
1861 : 90 : dr->enabled = 1;
1862 : : }
1863 : : return rc;
1864 : : }
1865 : : EXPORT_SYMBOL(pcim_enable_device);
1866 : :
1867 : : /**
1868 : : * pcim_pin_device - Pin managed PCI device
1869 : : * @pdev: PCI device to pin
1870 : : *
1871 : : * Pin managed PCI device @pdev. Pinned device won't be disabled on
1872 : : * driver detach. @pdev must have been enabled with
1873 : : * pcim_enable_device().
1874 : : */
1875 : 0 : void pcim_pin_device(struct pci_dev *pdev)
1876 : : {
1877 : 0 : struct pci_devres *dr;
1878 : :
1879 [ # # ]: 0 : dr = find_pci_dr(pdev);
1880 [ # # # # ]: 0 : WARN_ON(!dr || !dr->enabled);
1881 [ # # ]: 0 : if (dr)
1882 : 0 : dr->pinned = 1;
1883 : 0 : }
1884 : : EXPORT_SYMBOL(pcim_pin_device);
1885 : :
1886 : : /*
1887 : : * pcibios_add_device - provide arch specific hooks when adding device dev
1888 : : * @dev: the PCI device being added
1889 : : *
1890 : : * Permits the platform to provide architecture specific functionality when
1891 : : * devices are added. This is the default implementation. Architecture
1892 : : * implementations can override this.
1893 : : */
1894 : 0 : int __weak pcibios_add_device(struct pci_dev *dev)
1895 : : {
1896 : 0 : return 0;
1897 : : }
1898 : :
1899 : : /**
1900 : : * pcibios_release_device - provide arch specific hooks when releasing
1901 : : * device dev
1902 : : * @dev: the PCI device being released
1903 : : *
1904 : : * Permits the platform to provide architecture specific functionality when
1905 : : * devices are released. This is the default implementation. Architecture
1906 : : * implementations can override this.
1907 : : */
1908 : 0 : void __weak pcibios_release_device(struct pci_dev *dev) {}
1909 : :
1910 : : /**
1911 : : * pcibios_disable_device - disable arch specific PCI resources for device dev
1912 : : * @dev: the PCI device to disable
1913 : : *
1914 : : * Disables architecture specific PCI resources for the device. This
1915 : : * is the default implementation. Architecture implementations can
1916 : : * override this.
1917 : : */
1918 : 0 : void __weak pcibios_disable_device(struct pci_dev *dev) {}
1919 : :
1920 : : /**
1921 : : * pcibios_penalize_isa_irq - penalize an ISA IRQ
1922 : : * @irq: ISA IRQ to penalize
1923 : : * @active: IRQ active or not
1924 : : *
1925 : : * Permits the platform to provide architecture-specific functionality when
1926 : : * penalizing ISA IRQs. This is the default implementation. Architecture
1927 : : * implementations can override this.
1928 : : */
1929 : 0 : void __weak pcibios_penalize_isa_irq(int irq, int active) {}
1930 : :
1931 : 54 : static void do_pci_disable_device(struct pci_dev *dev)
1932 : : {
1933 : 54 : u16 pci_command;
1934 : :
1935 : 54 : pci_read_config_word(dev, PCI_COMMAND, &pci_command);
1936 [ + + ]: 54 : if (pci_command & PCI_COMMAND_MASTER) {
1937 : 24 : pci_command &= ~PCI_COMMAND_MASTER;
1938 : 24 : pci_write_config_word(dev, PCI_COMMAND, pci_command);
1939 : : }
1940 : :
1941 : 54 : pcibios_disable_device(dev);
1942 : 54 : }
1943 : :
1944 : : /**
1945 : : * pci_disable_enabled_device - Disable device without updating enable_cnt
1946 : : * @dev: PCI device to disable
1947 : : *
1948 : : * NOTE: This function is a backend of PCI power management routines and is
1949 : : * not supposed to be called drivers.
1950 : : */
1951 : 0 : void pci_disable_enabled_device(struct pci_dev *dev)
1952 : : {
1953 [ # # ]: 0 : if (pci_is_enabled(dev))
1954 : 0 : do_pci_disable_device(dev);
1955 : 0 : }
1956 : :
1957 : : /**
1958 : : * pci_disable_device - Disable PCI device after use
1959 : : * @dev: PCI device to be disabled
1960 : : *
1961 : : * Signal to the system that the PCI device is not in use by the system
1962 : : * anymore. This only involves disabling PCI bus-mastering, if active.
1963 : : *
1964 : : * Note we don't actually disable the device until all callers of
1965 : : * pci_enable_device() have called pci_disable_device().
1966 : : */
1967 : 54 : void pci_disable_device(struct pci_dev *dev)
1968 : : {
1969 : 54 : struct pci_devres *dr;
1970 : :
1971 [ + - ]: 54 : dr = find_pci_dr(dev);
1972 [ - + ]: 54 : if (dr)
1973 : 0 : dr->enabled = 0;
1974 : :
1975 [ - + - - : 54 : dev_WARN_ONCE(&dev->dev, atomic_read(&dev->enable_cnt) <= 0,
- - ]
1976 : : "disabling already-disabled device");
1977 : :
1978 [ + - ]: 54 : if (atomic_dec_return(&dev->enable_cnt) != 0)
1979 : : return;
1980 : :
1981 : 54 : do_pci_disable_device(dev);
1982 : :
1983 : 54 : dev->is_busmaster = 0;
1984 : : }
1985 : : EXPORT_SYMBOL(pci_disable_device);
1986 : :
1987 : : /**
1988 : : * pcibios_set_pcie_reset_state - set reset state for device dev
1989 : : * @dev: the PCIe device reset
1990 : : * @state: Reset state to enter into
1991 : : *
1992 : : * Set the PCIe reset state for the device. This is the default
1993 : : * implementation. Architecture implementations can override this.
1994 : : */
1995 : 0 : int __weak pcibios_set_pcie_reset_state(struct pci_dev *dev,
1996 : : enum pcie_reset_state state)
1997 : : {
1998 : 0 : return -EINVAL;
1999 : : }
2000 : :
2001 : : /**
2002 : : * pci_set_pcie_reset_state - set reset state for device dev
2003 : : * @dev: the PCIe device reset
2004 : : * @state: Reset state to enter into
2005 : : *
2006 : : * Sets the PCI reset state for the device.
2007 : : */
2008 : 0 : int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state)
2009 : : {
2010 : 0 : return pcibios_set_pcie_reset_state(dev, state);
2011 : : }
2012 : : EXPORT_SYMBOL_GPL(pci_set_pcie_reset_state);
2013 : :
2014 : : /**
2015 : : * pcie_clear_root_pme_status - Clear root port PME interrupt status.
2016 : : * @dev: PCIe root port or event collector.
2017 : : */
2018 : 0 : void pcie_clear_root_pme_status(struct pci_dev *dev)
2019 : : {
2020 : 0 : pcie_capability_set_dword(dev, PCI_EXP_RTSTA, PCI_EXP_RTSTA_PME);
2021 : 0 : }
2022 : :
2023 : : /**
2024 : : * pci_check_pme_status - Check if given device has generated PME.
2025 : : * @dev: Device to check.
2026 : : *
2027 : : * Check the PME status of the device and if set, clear it and clear PME enable
2028 : : * (if set). Return 'true' if PME status and PME enable were both set or
2029 : : * 'false' otherwise.
2030 : : */
2031 : 0 : bool pci_check_pme_status(struct pci_dev *dev)
2032 : : {
2033 : 0 : int pmcsr_pos;
2034 : 0 : u16 pmcsr;
2035 : 0 : bool ret = false;
2036 : :
2037 [ # # ]: 0 : if (!dev->pm_cap)
2038 : : return false;
2039 : :
2040 : 0 : pmcsr_pos = dev->pm_cap + PCI_PM_CTRL;
2041 : 0 : pci_read_config_word(dev, pmcsr_pos, &pmcsr);
2042 [ # # ]: 0 : if (!(pmcsr & PCI_PM_CTRL_PME_STATUS))
2043 : : return false;
2044 : :
2045 : : /* Clear PME status. */
2046 : 0 : pmcsr |= PCI_PM_CTRL_PME_STATUS;
2047 [ # # ]: 0 : if (pmcsr & PCI_PM_CTRL_PME_ENABLE) {
2048 : : /* Disable PME to avoid interrupt flood. */
2049 : 0 : pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
2050 : 0 : ret = true;
2051 : : }
2052 : :
2053 : 0 : pci_write_config_word(dev, pmcsr_pos, pmcsr);
2054 : :
2055 : 0 : return ret;
2056 : : }
2057 : :
2058 : : /**
2059 : : * pci_pme_wakeup - Wake up a PCI device if its PME Status bit is set.
2060 : : * @dev: Device to handle.
2061 : : * @pme_poll_reset: Whether or not to reset the device's pme_poll flag.
2062 : : *
2063 : : * Check if @dev has generated PME and queue a resume request for it in that
2064 : : * case.
2065 : : */
2066 : 0 : static int pci_pme_wakeup(struct pci_dev *dev, void *pme_poll_reset)
2067 : : {
2068 [ # # # # ]: 0 : if (pme_poll_reset && dev->pme_poll)
2069 : 0 : dev->pme_poll = false;
2070 : :
2071 [ # # ]: 0 : if (pci_check_pme_status(dev)) {
2072 : 0 : pci_wakeup_event(dev);
2073 : 0 : pm_request_resume(&dev->dev);
2074 : : }
2075 : 0 : return 0;
2076 : : }
2077 : :
2078 : : /**
2079 : : * pci_pme_wakeup_bus - Walk given bus and wake up devices on it, if necessary.
2080 : : * @bus: Top bus of the subtree to walk.
2081 : : */
2082 : 0 : void pci_pme_wakeup_bus(struct pci_bus *bus)
2083 : : {
2084 [ # # ]: 0 : if (bus)
2085 : 0 : pci_walk_bus(bus, pci_pme_wakeup, (void *)true);
2086 : 0 : }
2087 : :
2088 : :
2089 : : /**
2090 : : * pci_pme_capable - check the capability of PCI device to generate PME#
2091 : : * @dev: PCI device to handle.
2092 : : * @state: PCI state from which device will issue PME#.
2093 : : */
2094 : 0 : bool pci_pme_capable(struct pci_dev *dev, pci_power_t state)
2095 : : {
2096 [ # # # # : 0 : if (!dev->pm_cap)
# # ]
2097 : : return false;
2098 : :
2099 : 0 : return !!(dev->pme_support & (1 << state));
2100 : : }
2101 : : EXPORT_SYMBOL(pci_pme_capable);
2102 : :
2103 : 0 : static void pci_pme_list_scan(struct work_struct *work)
2104 : : {
2105 : 0 : struct pci_pme_device *pme_dev, *n;
2106 : :
2107 : 0 : mutex_lock(&pci_pme_list_mutex);
2108 [ # # ]: 0 : list_for_each_entry_safe(pme_dev, n, &pci_pme_list, list) {
2109 [ # # ]: 0 : if (pme_dev->dev->pme_poll) {
2110 : 0 : struct pci_dev *bridge;
2111 : :
2112 : 0 : bridge = pme_dev->dev->bus->self;
2113 : : /*
2114 : : * If bridge is in low power state, the
2115 : : * configuration space of subordinate devices
2116 : : * may be not accessible
2117 : : */
2118 [ # # # # ]: 0 : if (bridge && bridge->current_state != PCI_D0)
2119 : 0 : continue;
2120 : : /*
2121 : : * If the device is in D3cold it should not be
2122 : : * polled either.
2123 : : */
2124 [ # # ]: 0 : if (pme_dev->dev->current_state == PCI_D3cold)
2125 : 0 : continue;
2126 : :
2127 : 0 : pci_pme_wakeup(pme_dev->dev, NULL);
2128 : : } else {
2129 : 0 : list_del(&pme_dev->list);
2130 : 0 : kfree(pme_dev);
2131 : : }
2132 : : }
2133 [ # # ]: 0 : if (!list_empty(&pci_pme_list))
2134 : 0 : queue_delayed_work(system_freezable_wq, &pci_pme_work,
2135 : : msecs_to_jiffies(PME_TIMEOUT));
2136 : 0 : mutex_unlock(&pci_pme_list_mutex);
2137 : 0 : }
2138 : :
2139 : 0 : static void __pci_pme_active(struct pci_dev *dev, bool enable)
2140 : : {
2141 : 0 : u16 pmcsr;
2142 : :
2143 [ # # ]: 0 : if (!dev->pme_support)
2144 : 0 : return;
2145 : :
2146 : 0 : pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
2147 : : /* Clear PME_Status by writing 1 to it and enable PME# */
2148 : 0 : pmcsr |= PCI_PM_CTRL_PME_STATUS | PCI_PM_CTRL_PME_ENABLE;
2149 [ # # ]: 0 : if (!enable)
2150 : 0 : pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
2151 : :
2152 : 0 : pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, pmcsr);
2153 : : }
2154 : :
2155 : : /**
2156 : : * pci_pme_restore - Restore PME configuration after config space restore.
2157 : : * @dev: PCI device to update.
2158 : : */
2159 : 0 : void pci_pme_restore(struct pci_dev *dev)
2160 : : {
2161 : 0 : u16 pmcsr;
2162 : :
2163 [ # # ]: 0 : if (!dev->pme_support)
2164 : 0 : return;
2165 : :
2166 : 0 : pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
2167 [ # # ]: 0 : if (dev->wakeup_prepared) {
2168 : 0 : pmcsr |= PCI_PM_CTRL_PME_ENABLE;
2169 : 0 : pmcsr &= ~PCI_PM_CTRL_PME_STATUS;
2170 : : } else {
2171 : 0 : pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
2172 : 0 : pmcsr |= PCI_PM_CTRL_PME_STATUS;
2173 : : }
2174 : 0 : pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, pmcsr);
2175 : : }
2176 : :
2177 : : /**
2178 : : * pci_pme_active - enable or disable PCI device's PME# function
2179 : : * @dev: PCI device to handle.
2180 : : * @enable: 'true' to enable PME# generation; 'false' to disable it.
2181 : : *
2182 : : * The caller must verify that the device is capable of generating PME# before
2183 : : * calling this function with @enable equal to 'true'.
2184 : : */
2185 : 0 : void pci_pme_active(struct pci_dev *dev, bool enable)
2186 : : {
2187 : 0 : __pci_pme_active(dev, enable);
2188 : :
2189 : : /*
2190 : : * PCI (as opposed to PCIe) PME requires that the device have
2191 : : * its PME# line hooked up correctly. Not all hardware vendors
2192 : : * do this, so the PME never gets delivered and the device
2193 : : * remains asleep. The easiest way around this is to
2194 : : * periodically walk the list of suspended devices and check
2195 : : * whether any have their PME flag set. The assumption is that
2196 : : * we'll wake up often enough anyway that this won't be a huge
2197 : : * hit, and the power savings from the devices will still be a
2198 : : * win.
2199 : : *
2200 : : * Although PCIe uses in-band PME message instead of PME# line
2201 : : * to report PME, PME does not work for some PCIe devices in
2202 : : * reality. For example, there are devices that set their PME
2203 : : * status bits, but don't really bother to send a PME message;
2204 : : * there are PCI Express Root Ports that don't bother to
2205 : : * trigger interrupts when they receive PME messages from the
2206 : : * devices below. So PME poll is used for PCIe devices too.
2207 : : */
2208 : :
2209 [ # # ]: 0 : if (dev->pme_poll) {
2210 : 0 : struct pci_pme_device *pme_dev;
2211 [ # # ]: 0 : if (enable) {
2212 : 0 : pme_dev = kmalloc(sizeof(struct pci_pme_device),
2213 : : GFP_KERNEL);
2214 [ # # ]: 0 : if (!pme_dev) {
2215 : 0 : pci_warn(dev, "can't enable PME#\n");
2216 : 0 : return;
2217 : : }
2218 : 0 : pme_dev->dev = dev;
2219 : 0 : mutex_lock(&pci_pme_list_mutex);
2220 [ # # ]: 0 : list_add(&pme_dev->list, &pci_pme_list);
2221 [ # # ]: 0 : if (list_is_singular(&pci_pme_list))
2222 : 0 : queue_delayed_work(system_freezable_wq,
2223 : : &pci_pme_work,
2224 : : msecs_to_jiffies(PME_TIMEOUT));
2225 : 0 : mutex_unlock(&pci_pme_list_mutex);
2226 : : } else {
2227 : 0 : mutex_lock(&pci_pme_list_mutex);
2228 [ # # ]: 0 : list_for_each_entry(pme_dev, &pci_pme_list, list) {
2229 [ # # ]: 0 : if (pme_dev->dev == dev) {
2230 : 0 : list_del(&pme_dev->list);
2231 : 0 : kfree(pme_dev);
2232 : 0 : break;
2233 : : }
2234 : : }
2235 : 0 : mutex_unlock(&pci_pme_list_mutex);
2236 : : }
2237 : : }
2238 : :
2239 : : pci_dbg(dev, "PME# %s\n", enable ? "enabled" : "disabled");
2240 : : }
2241 : : EXPORT_SYMBOL(pci_pme_active);
2242 : :
2243 : : /**
2244 : : * __pci_enable_wake - enable PCI device as wakeup event source
2245 : : * @dev: PCI device affected
2246 : : * @state: PCI state from which device will issue wakeup events
2247 : : * @enable: True to enable event generation; false to disable
2248 : : *
2249 : : * This enables the device as a wakeup event source, or disables it.
2250 : : * When such events involves platform-specific hooks, those hooks are
2251 : : * called automatically by this routine.
2252 : : *
2253 : : * Devices with legacy power management (no standard PCI PM capabilities)
2254 : : * always require such platform hooks.
2255 : : *
2256 : : * RETURN VALUE:
2257 : : * 0 is returned on success
2258 : : * -EINVAL is returned if device is not supposed to wake up the system
2259 : : * Error code depending on the platform is returned if both the platform and
2260 : : * the native mechanism fail to enable the generation of wake-up events
2261 : : */
2262 : 0 : static int __pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable)
2263 : : {
2264 : 0 : int ret = 0;
2265 : :
2266 : : /*
2267 : : * Bridges that are not power-manageable directly only signal
2268 : : * wakeup on behalf of subordinate devices which is set up
2269 : : * elsewhere, so skip them. However, bridges that are
2270 : : * power-manageable may signal wakeup for themselves (for example,
2271 : : * on a hotplug event) and they need to be covered here.
2272 : : */
2273 [ # # # # ]: 0 : if (!pci_power_manageable(dev))
2274 : : return 0;
2275 : :
2276 : : /* Don't do the same thing twice in a row for one device. */
2277 [ # # ]: 0 : if (!!enable == !!dev->wakeup_prepared)
2278 : : return 0;
2279 : :
2280 : : /*
2281 : : * According to "PCI System Architecture" 4th ed. by Tom Shanley & Don
2282 : : * Anderson we should be doing PME# wake enable followed by ACPI wake
2283 : : * enable. To disable wake-up we call the platform first, for symmetry.
2284 : : */
2285 : :
2286 [ # # ]: 0 : if (enable) {
2287 : 0 : int error;
2288 : :
2289 [ # # # # ]: 0 : if (pci_pme_capable(dev, state))
2290 : 0 : pci_pme_active(dev, true);
2291 : : else
2292 : : ret = 1;
2293 [ # # ]: 0 : error = platform_pci_set_wakeup(dev, true);
2294 [ # # ]: 0 : if (ret)
2295 : 0 : ret = error;
2296 [ # # ]: 0 : if (!ret)
2297 : 0 : dev->wakeup_prepared = true;
2298 : : } else {
2299 [ # # ]: 0 : platform_pci_set_wakeup(dev, false);
2300 : 0 : pci_pme_active(dev, false);
2301 : 0 : dev->wakeup_prepared = false;
2302 : : }
2303 : :
2304 : : return ret;
2305 : : }
2306 : :
2307 : : /**
2308 : : * pci_enable_wake - change wakeup settings for a PCI device
2309 : : * @pci_dev: Target device
2310 : : * @state: PCI state from which device will issue wakeup events
2311 : : * @enable: Whether or not to enable event generation
2312 : : *
2313 : : * If @enable is set, check device_may_wakeup() for the device before calling
2314 : : * __pci_enable_wake() for it.
2315 : : */
2316 : 0 : int pci_enable_wake(struct pci_dev *pci_dev, pci_power_t state, bool enable)
2317 : : {
2318 [ # # # # ]: 0 : if (enable && !device_may_wakeup(&pci_dev->dev))
2319 : : return -EINVAL;
2320 : :
2321 : 0 : return __pci_enable_wake(pci_dev, state, enable);
2322 : : }
2323 : : EXPORT_SYMBOL(pci_enable_wake);
2324 : :
2325 : : /**
2326 : : * pci_wake_from_d3 - enable/disable device to wake up from D3_hot or D3_cold
2327 : : * @dev: PCI device to prepare
2328 : : * @enable: True to enable wake-up event generation; false to disable
2329 : : *
2330 : : * Many drivers want the device to wake up the system from D3_hot or D3_cold
2331 : : * and this function allows them to set that up cleanly - pci_enable_wake()
2332 : : * should not be called twice in a row to enable wake-up due to PCI PM vs ACPI
2333 : : * ordering constraints.
2334 : : *
2335 : : * This function only returns error code if the device is not allowed to wake
2336 : : * up the system from sleep or it is not capable of generating PME# from both
2337 : : * D3_hot and D3_cold and the platform is unable to enable wake-up power for it.
2338 : : */
2339 : 0 : int pci_wake_from_d3(struct pci_dev *dev, bool enable)
2340 : : {
2341 [ # # ]: 0 : return pci_pme_capable(dev, PCI_D3cold) ?
2342 [ # # ]: 0 : pci_enable_wake(dev, PCI_D3cold, enable) :
2343 : 0 : pci_enable_wake(dev, PCI_D3hot, enable);
2344 : : }
2345 : : EXPORT_SYMBOL(pci_wake_from_d3);
2346 : :
2347 : : /**
2348 : : * pci_target_state - find an appropriate low power state for a given PCI dev
2349 : : * @dev: PCI device
2350 : : * @wakeup: Whether or not wakeup functionality will be enabled for the device.
2351 : : *
2352 : : * Use underlying platform code to find a supported low power state for @dev.
2353 : : * If the platform can't manage @dev, return the deepest state from which it
2354 : : * can generate wake events, based on any available PME info.
2355 : : */
2356 : 0 : static pci_power_t pci_target_state(struct pci_dev *dev, bool wakeup)
2357 : : {
2358 : 0 : pci_power_t target_state = PCI_D3hot;
2359 : :
2360 [ # # ]: 0 : if (platform_pci_power_manageable(dev)) {
2361 : : /*
2362 : : * Call the platform to find the target state for the device.
2363 : : */
2364 [ # # ]: 0 : pci_power_t state = platform_pci_choose_state(dev);
2365 : :
2366 [ # # # ]: 0 : switch (state) {
2367 : : case PCI_POWER_ERROR:
2368 : : case PCI_UNKNOWN:
2369 : : break;
2370 : : case PCI_D1:
2371 : : case PCI_D2:
2372 [ # # # # ]: 0 : if (pci_no_d1d2(dev))
2373 : : break;
2374 : : /* else, fall through */
2375 : : default:
2376 : : target_state = state;
2377 : : }
2378 : :
2379 : 0 : return target_state;
2380 : : }
2381 : :
2382 [ # # ]: 0 : if (!dev->pm_cap)
2383 : 0 : target_state = PCI_D0;
2384 : :
2385 : : /*
2386 : : * If the device is in D3cold even though it's not power-manageable by
2387 : : * the platform, it may have been powered down by non-standard means.
2388 : : * Best to let it slumber.
2389 : : */
2390 [ # # ]: 0 : if (dev->current_state == PCI_D3cold)
2391 : 0 : target_state = PCI_D3cold;
2392 : :
2393 [ # # ]: 0 : if (wakeup) {
2394 : : /*
2395 : : * Find the deepest state from which the device can generate
2396 : : * PME#.
2397 : : */
2398 [ # # ]: 0 : if (dev->pme_support) {
2399 [ # # ]: 0 : while (target_state
2400 [ # # ]: 0 : && !(dev->pme_support & (1 << target_state)))
2401 : 0 : target_state--;
2402 : : }
2403 : : }
2404 : :
2405 : : return target_state;
2406 : : }
2407 : :
2408 : : /**
2409 : : * pci_prepare_to_sleep - prepare PCI device for system-wide transition
2410 : : * into a sleep state
2411 : : * @dev: Device to handle.
2412 : : *
2413 : : * Choose the power state appropriate for the device depending on whether
2414 : : * it can wake up the system and/or is power manageable by the platform
2415 : : * (PCI_D3hot is the default) and put the device into that state.
2416 : : */
2417 : 0 : int pci_prepare_to_sleep(struct pci_dev *dev)
2418 : : {
2419 [ # # ]: 0 : bool wakeup = device_may_wakeup(&dev->dev);
2420 : 0 : pci_power_t target_state = pci_target_state(dev, wakeup);
2421 : 0 : int error;
2422 : :
2423 [ # # ]: 0 : if (target_state == PCI_POWER_ERROR)
2424 : : return -EIO;
2425 : :
2426 : 0 : pci_enable_wake(dev, target_state, wakeup);
2427 : :
2428 : 0 : error = pci_set_power_state(dev, target_state);
2429 : :
2430 [ # # ]: 0 : if (error)
2431 : 0 : pci_enable_wake(dev, target_state, false);
2432 : :
2433 : : return error;
2434 : : }
2435 : : EXPORT_SYMBOL(pci_prepare_to_sleep);
2436 : :
2437 : : /**
2438 : : * pci_back_from_sleep - turn PCI device on during system-wide transition
2439 : : * into working state
2440 : : * @dev: Device to handle.
2441 : : *
2442 : : * Disable device's system wake-up capability and put it into D0.
2443 : : */
2444 : 0 : int pci_back_from_sleep(struct pci_dev *dev)
2445 : : {
2446 : 0 : pci_enable_wake(dev, PCI_D0, false);
2447 : 0 : return pci_set_power_state(dev, PCI_D0);
2448 : : }
2449 : : EXPORT_SYMBOL(pci_back_from_sleep);
2450 : :
2451 : : /**
2452 : : * pci_finish_runtime_suspend - Carry out PCI-specific part of runtime suspend.
2453 : : * @dev: PCI device being suspended.
2454 : : *
2455 : : * Prepare @dev to generate wake-up events at run time and put it into a low
2456 : : * power state.
2457 : : */
2458 : 0 : int pci_finish_runtime_suspend(struct pci_dev *dev)
2459 : : {
2460 : 0 : pci_power_t target_state;
2461 : 0 : int error;
2462 : :
2463 : 0 : target_state = pci_target_state(dev, device_can_wakeup(&dev->dev));
2464 [ # # ]: 0 : if (target_state == PCI_POWER_ERROR)
2465 : : return -EIO;
2466 : :
2467 : 0 : dev->runtime_d3cold = target_state == PCI_D3cold;
2468 : :
2469 : 0 : __pci_enable_wake(dev, target_state, pci_dev_run_wake(dev));
2470 : :
2471 : 0 : error = pci_set_power_state(dev, target_state);
2472 : :
2473 [ # # ]: 0 : if (error) {
2474 : 0 : pci_enable_wake(dev, target_state, false);
2475 : 0 : dev->runtime_d3cold = false;
2476 : : }
2477 : :
2478 : : return error;
2479 : : }
2480 : :
2481 : : /**
2482 : : * pci_dev_run_wake - Check if device can generate run-time wake-up events.
2483 : : * @dev: Device to check.
2484 : : *
2485 : : * Return true if the device itself is capable of generating wake-up events
2486 : : * (through the platform or using the native PCIe PME) or if the device supports
2487 : : * PME and one of its upstream bridges can generate wake-up events.
2488 : : */
2489 : 0 : bool pci_dev_run_wake(struct pci_dev *dev)
2490 : : {
2491 : 0 : struct pci_bus *bus = dev->bus;
2492 : :
2493 [ # # ]: 0 : if (!dev->pme_support)
2494 : : return false;
2495 : :
2496 : : /* PME-capable in principle, but not from the target power state */
2497 [ # # ]: 0 : if (!pci_pme_capable(dev, pci_target_state(dev, true)))
2498 : : return false;
2499 : :
2500 [ # # ]: 0 : if (device_can_wakeup(&dev->dev))
2501 : : return true;
2502 : :
2503 [ # # ]: 0 : while (bus->parent) {
2504 : 0 : struct pci_dev *bridge = bus->self;
2505 : :
2506 [ # # ]: 0 : if (device_can_wakeup(&bridge->dev))
2507 : : return true;
2508 : :
2509 : : bus = bus->parent;
2510 : : }
2511 : :
2512 : : /* We have reached the root bus. */
2513 [ # # ]: 0 : if (bus->bridge)
2514 : 0 : return device_can_wakeup(bus->bridge);
2515 : :
2516 : : return false;
2517 : : }
2518 : : EXPORT_SYMBOL_GPL(pci_dev_run_wake);
2519 : :
2520 : : /**
2521 : : * pci_dev_need_resume - Check if it is necessary to resume the device.
2522 : : * @pci_dev: Device to check.
2523 : : *
2524 : : * Return 'true' if the device is not runtime-suspended or it has to be
2525 : : * reconfigured due to wakeup settings difference between system and runtime
2526 : : * suspend, or the current power state of it is not suitable for the upcoming
2527 : : * (system-wide) transition.
2528 : : */
2529 : 0 : bool pci_dev_need_resume(struct pci_dev *pci_dev)
2530 : : {
2531 : 0 : struct device *dev = &pci_dev->dev;
2532 : 0 : pci_power_t target_state;
2533 : :
2534 [ # # # # ]: 0 : if (!pm_runtime_suspended(dev) || platform_pci_need_resume(pci_dev))
2535 : 0 : return true;
2536 : :
2537 [ # # ]: 0 : target_state = pci_target_state(pci_dev, device_may_wakeup(dev));
2538 : :
2539 : : /*
2540 : : * If the earlier platform check has not triggered, D3cold is just power
2541 : : * removal on top of D3hot, so no need to resume the device in that
2542 : : * case.
2543 : : */
2544 [ # # ]: 0 : return target_state != pci_dev->current_state &&
2545 [ # # # # ]: 0 : target_state != PCI_D3cold &&
2546 : : pci_dev->current_state != PCI_D3hot;
2547 : : }
2548 : :
2549 : : /**
2550 : : * pci_dev_adjust_pme - Adjust PME setting for a suspended device.
2551 : : * @pci_dev: Device to check.
2552 : : *
2553 : : * If the device is suspended and it is not configured for system wakeup,
2554 : : * disable PME for it to prevent it from waking up the system unnecessarily.
2555 : : *
2556 : : * Note that if the device's power state is D3cold and the platform check in
2557 : : * pci_dev_need_resume() has not triggered, the device's configuration need not
2558 : : * be changed.
2559 : : */
2560 : 0 : void pci_dev_adjust_pme(struct pci_dev *pci_dev)
2561 : : {
2562 : 0 : struct device *dev = &pci_dev->dev;
2563 : :
2564 : 0 : spin_lock_irq(&dev->power.lock);
2565 : :
2566 [ # # # # : 0 : if (pm_runtime_suspended(dev) && !device_may_wakeup(dev) &&
# # ]
2567 [ # # ]: 0 : pci_dev->current_state < PCI_D3cold)
2568 : 0 : __pci_pme_active(pci_dev, false);
2569 : :
2570 : 0 : spin_unlock_irq(&dev->power.lock);
2571 : 0 : }
2572 : :
2573 : : /**
2574 : : * pci_dev_complete_resume - Finalize resume from system sleep for a device.
2575 : : * @pci_dev: Device to handle.
2576 : : *
2577 : : * If the device is runtime suspended and wakeup-capable, enable PME for it as
2578 : : * it might have been disabled during the prepare phase of system suspend if
2579 : : * the device was not configured for system wakeup.
2580 : : */
2581 : 0 : void pci_dev_complete_resume(struct pci_dev *pci_dev)
2582 : : {
2583 : 0 : struct device *dev = &pci_dev->dev;
2584 : :
2585 [ # # ]: 0 : if (!pci_dev_run_wake(pci_dev))
2586 : : return;
2587 : :
2588 : 0 : spin_lock_irq(&dev->power.lock);
2589 : :
2590 [ # # # # : 0 : if (pm_runtime_suspended(dev) && pci_dev->current_state < PCI_D3cold)
# # ]
2591 : 0 : __pci_pme_active(pci_dev, true);
2592 : :
2593 : 0 : spin_unlock_irq(&dev->power.lock);
2594 : : }
2595 : :
2596 : 12 : void pci_config_pm_runtime_get(struct pci_dev *pdev)
2597 : : {
2598 : 12 : struct device *dev = &pdev->dev;
2599 : 12 : struct device *parent = dev->parent;
2600 : :
2601 [ + - ]: 12 : if (parent)
2602 : 12 : pm_runtime_get_sync(parent);
2603 : 12 : pm_runtime_get_noresume(dev);
2604 : : /*
2605 : : * pdev->current_state is set to PCI_D3cold during suspending,
2606 : : * so wait until suspending completes
2607 : : */
2608 : 12 : pm_runtime_barrier(dev);
2609 : : /*
2610 : : * Only need to resume devices in D3cold, because config
2611 : : * registers are still accessible for devices suspended but
2612 : : * not in D3cold.
2613 : : */
2614 [ - + ]: 12 : if (pdev->current_state == PCI_D3cold)
2615 : 0 : pm_runtime_resume(dev);
2616 : 12 : }
2617 : :
2618 : 12 : void pci_config_pm_runtime_put(struct pci_dev *pdev)
2619 : : {
2620 : 12 : struct device *dev = &pdev->dev;
2621 : 12 : struct device *parent = dev->parent;
2622 : :
2623 : 12 : pm_runtime_put(dev);
2624 [ + - ]: 12 : if (parent)
2625 : 12 : pm_runtime_put_sync(parent);
2626 : 12 : }
2627 : :
2628 : : static const struct dmi_system_id bridge_d3_blacklist[] = {
2629 : : #ifdef CONFIG_X86
2630 : : {
2631 : : /*
2632 : : * Gigabyte X299 root port is not marked as hotplug capable
2633 : : * which allows Linux to power manage it. However, this
2634 : : * confuses the BIOS SMI handler so don't power manage root
2635 : : * ports on that system.
2636 : : */
2637 : : .ident = "X299 DESIGNARE EX-CF",
2638 : : .matches = {
2639 : : DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
2640 : : DMI_MATCH(DMI_BOARD_NAME, "X299 DESIGNARE EX-CF"),
2641 : : },
2642 : : },
2643 : : #endif
2644 : : { }
2645 : : };
2646 : :
2647 : : /**
2648 : : * pci_bridge_d3_possible - Is it possible to put the bridge into D3
2649 : : * @bridge: Bridge to check
2650 : : *
2651 : : * This function checks if it is possible to move the bridge to D3.
2652 : : * Currently we only allow D3 for recent enough PCIe ports and Thunderbolt.
2653 : : */
2654 : 30 : bool pci_bridge_d3_possible(struct pci_dev *bridge)
2655 : : {
2656 [ - + ]: 30 : if (!pci_is_pcie(bridge))
2657 : : return false;
2658 : :
2659 [ # # ]: 0 : switch (pci_pcie_type(bridge)) {
2660 : 0 : case PCI_EXP_TYPE_ROOT_PORT:
2661 : : case PCI_EXP_TYPE_UPSTREAM:
2662 : : case PCI_EXP_TYPE_DOWNSTREAM:
2663 [ # # ]: 0 : if (pci_bridge_d3_disable)
2664 : : return false;
2665 : :
2666 : : /*
2667 : : * Hotplug ports handled by firmware in System Management Mode
2668 : : * may not be put into D3 by the OS (Thunderbolt on non-Macs).
2669 : : */
2670 [ # # # # ]: 0 : if (bridge->is_hotplug_bridge && !pciehp_is_native(bridge))
2671 : : return false;
2672 : :
2673 [ # # ]: 0 : if (pci_bridge_d3_force)
2674 : : return true;
2675 : :
2676 : : /* Even the oldest 2010 Thunderbolt controller supports D3. */
2677 [ # # ]: 0 : if (bridge->is_thunderbolt)
2678 : : return true;
2679 : :
2680 : : /* Platform might know better if the bridge supports D3 */
2681 [ # # ]: 0 : if (platform_pci_bridge_d3(bridge))
2682 : : return true;
2683 : :
2684 : : /*
2685 : : * Hotplug ports handled natively by the OS were not validated
2686 : : * by vendors for runtime D3 at least until 2018 because there
2687 : : * was no OS support.
2688 : : */
2689 [ # # ]: 0 : if (bridge->is_hotplug_bridge)
2690 : : return false;
2691 : :
2692 [ # # ]: 0 : if (dmi_check_system(bridge_d3_blacklist))
2693 : : return false;
2694 : :
2695 : : /*
2696 : : * It should be safe to put PCIe ports from 2015 or newer
2697 : : * to D3.
2698 : : */
2699 [ # # ]: 0 : if (dmi_get_bios_year() >= 2015)
2700 : 0 : return true;
2701 : : break;
2702 : : }
2703 : :
2704 : : return false;
2705 : : }
2706 : :
2707 : 0 : static int pci_dev_check_d3cold(struct pci_dev *dev, void *data)
2708 : : {
2709 : 0 : bool *d3cold_ok = data;
2710 : :
2711 : 0 : if (/* The device needs to be allowed to go D3cold ... */
2712 [ # # # # ]: 0 : dev->no_d3cold || !dev->d3cold_allowed ||
2713 : :
2714 : : /* ... and if it is wakeup capable to do so from D3cold. */
2715 [ # # ]: 0 : (device_may_wakeup(&dev->dev) &&
2716 [ # # ]: 0 : !pci_pme_capable(dev, PCI_D3cold)) ||
2717 : :
2718 : : /* If it is a bridge it must be allowed to go to D3. */
2719 : : !pci_power_manageable(dev))
2720 : :
2721 : 0 : *d3cold_ok = false;
2722 : :
2723 : 0 : return !*d3cold_ok;
2724 : : }
2725 : :
2726 : : /*
2727 : : * pci_bridge_d3_update - Update bridge D3 capabilities
2728 : : * @dev: PCI device which is changed
2729 : : *
2730 : : * Update upstream bridge PM capabilities accordingly depending on if the
2731 : : * device PM configuration was changed or the device is being removed. The
2732 : : * change is also propagated upstream.
2733 : : */
2734 : 210 : void pci_bridge_d3_update(struct pci_dev *dev)
2735 : : {
2736 [ - + ]: 210 : bool remove = !device_is_registered(&dev->dev);
2737 : 210 : struct pci_dev *bridge;
2738 : 210 : bool d3cold_ok = true;
2739 : :
2740 [ - + ]: 210 : bridge = pci_upstream_bridge(dev);
2741 [ # # # # ]: 0 : if (!bridge || !pci_bridge_d3_possible(bridge))
2742 : 210 : return;
2743 : :
2744 : : /*
2745 : : * If D3 is currently allowed for the bridge, removing one of its
2746 : : * children won't change that.
2747 : : */
2748 [ # # # # ]: 0 : if (remove && bridge->bridge_d3)
2749 : : return;
2750 : :
2751 : : /*
2752 : : * If D3 is currently allowed for the bridge and a child is added or
2753 : : * changed, disallowance of D3 can only be caused by that child, so
2754 : : * we only need to check that single device, not any of its siblings.
2755 : : *
2756 : : * If D3 is currently not allowed for the bridge, checking the device
2757 : : * first may allow us to skip checking its siblings.
2758 : : */
2759 [ # # ]: 0 : if (!remove)
2760 : 0 : pci_dev_check_d3cold(dev, &d3cold_ok);
2761 : :
2762 : : /*
2763 : : * If D3 is currently not allowed for the bridge, this may be caused
2764 : : * either by the device being changed/removed or any of its siblings,
2765 : : * so we need to go through all children to find out if one of them
2766 : : * continues to block D3.
2767 : : */
2768 [ # # # # ]: 0 : if (d3cold_ok && !bridge->bridge_d3)
2769 : 0 : pci_walk_bus(bridge->subordinate, pci_dev_check_d3cold,
2770 : : &d3cold_ok);
2771 : :
2772 [ # # ]: 0 : if (bridge->bridge_d3 != d3cold_ok) {
2773 : 0 : bridge->bridge_d3 = d3cold_ok;
2774 : : /* Propagate change to upstream bridges */
2775 : 0 : pci_bridge_d3_update(bridge);
2776 : : }
2777 : : }
2778 : :
2779 : : /**
2780 : : * pci_d3cold_enable - Enable D3cold for device
2781 : : * @dev: PCI device to handle
2782 : : *
2783 : : * This function can be used in drivers to enable D3cold from the device
2784 : : * they handle. It also updates upstream PCI bridge PM capabilities
2785 : : * accordingly.
2786 : : */
2787 : 0 : void pci_d3cold_enable(struct pci_dev *dev)
2788 : : {
2789 [ # # ]: 0 : if (dev->no_d3cold) {
2790 : 0 : dev->no_d3cold = false;
2791 : 0 : pci_bridge_d3_update(dev);
2792 : : }
2793 : 0 : }
2794 : : EXPORT_SYMBOL_GPL(pci_d3cold_enable);
2795 : :
2796 : : /**
2797 : : * pci_d3cold_disable - Disable D3cold for device
2798 : : * @dev: PCI device to handle
2799 : : *
2800 : : * This function can be used in drivers to disable D3cold from the device
2801 : : * they handle. It also updates upstream PCI bridge PM capabilities
2802 : : * accordingly.
2803 : : */
2804 : 0 : void pci_d3cold_disable(struct pci_dev *dev)
2805 : : {
2806 [ # # ]: 0 : if (!dev->no_d3cold) {
2807 : 0 : dev->no_d3cold = true;
2808 : 0 : pci_bridge_d3_update(dev);
2809 : : }
2810 : 0 : }
2811 : : EXPORT_SYMBOL_GPL(pci_d3cold_disable);
2812 : :
2813 : : /**
2814 : : * pci_pm_init - Initialize PM functions of given PCI device
2815 : : * @dev: PCI device to handle.
2816 : : */
2817 : 210 : void pci_pm_init(struct pci_dev *dev)
2818 : : {
2819 : 210 : int pm;
2820 : 210 : u16 status;
2821 : 210 : u16 pmc;
2822 : :
2823 : 210 : pm_runtime_forbid(&dev->dev);
2824 : 210 : pm_runtime_set_active(&dev->dev);
2825 : 210 : pm_runtime_enable(&dev->dev);
2826 [ + - ]: 210 : device_enable_async_suspend(&dev->dev);
2827 : 210 : dev->wakeup_prepared = false;
2828 : :
2829 : 210 : dev->pm_cap = 0;
2830 : 210 : dev->pme_support = 0;
2831 : :
2832 : : /* find PCI PM capability in list */
2833 : 210 : pm = pci_find_capability(dev, PCI_CAP_ID_PM);
2834 [ + + ]: 210 : if (!pm)
2835 : 180 : return;
2836 : : /* Check device's ability to generate PME# */
2837 : 30 : pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
2838 : :
2839 [ - + ]: 30 : if ((pmc & PCI_PM_CAP_VER_MASK) > 3) {
2840 : 0 : pci_err(dev, "unsupported PM cap regs version (%u)\n",
2841 : : pmc & PCI_PM_CAP_VER_MASK);
2842 : 0 : return;
2843 : : }
2844 : :
2845 : 30 : dev->pm_cap = pm;
2846 : 30 : dev->d3_delay = PCI_PM_D3_WAIT;
2847 : 30 : dev->d3cold_delay = PCI_PM_D3COLD_WAIT;
2848 : 30 : dev->bridge_d3 = pci_bridge_d3_possible(dev);
2849 : 30 : dev->d3cold_allowed = true;
2850 : :
2851 : 30 : dev->d1_support = false;
2852 : 30 : dev->d2_support = false;
2853 [ - + + - ]: 60 : if (!pci_no_d1d2(dev)) {
2854 [ - + ]: 30 : if (pmc & PCI_PM_CAP_D1)
2855 : 0 : dev->d1_support = true;
2856 [ - + ]: 30 : if (pmc & PCI_PM_CAP_D2)
2857 : 0 : dev->d2_support = true;
2858 : :
2859 [ - + ]: 30 : if (dev->d1_support || dev->d2_support)
2860 [ # # # # ]: 0 : pci_info(dev, "supports%s%s\n",
2861 : : dev->d1_support ? " D1" : "",
2862 : : dev->d2_support ? " D2" : "");
2863 : : }
2864 : :
2865 : 30 : pmc &= PCI_PM_CAP_PME_MASK;
2866 [ - + ]: 30 : if (pmc) {
2867 [ # # # # : 0 : pci_info(dev, "PME# supported from%s%s%s%s%s\n",
# # # # #
# ]
2868 : : (pmc & PCI_PM_CAP_PME_D0) ? " D0" : "",
2869 : : (pmc & PCI_PM_CAP_PME_D1) ? " D1" : "",
2870 : : (pmc & PCI_PM_CAP_PME_D2) ? " D2" : "",
2871 : : (pmc & PCI_PM_CAP_PME_D3) ? " D3hot" : "",
2872 : : (pmc & PCI_PM_CAP_PME_D3cold) ? " D3cold" : "");
2873 : 0 : dev->pme_support = pmc >> PCI_PM_CAP_PME_SHIFT;
2874 : 0 : dev->pme_poll = true;
2875 : : /*
2876 : : * Make device's PM flags reflect the wake-up capability, but
2877 : : * let the user space enable it to wake up the system as needed.
2878 : : */
2879 : 0 : device_set_wakeup_capable(&dev->dev, true);
2880 : : /* Disable the PME# generation functionality */
2881 : 0 : pci_pme_active(dev, false);
2882 : : }
2883 : :
2884 : 30 : pci_read_config_word(dev, PCI_STATUS, &status);
2885 [ - + ]: 30 : if (status & PCI_STATUS_IMM_READY)
2886 : 0 : dev->imm_ready = 1;
2887 : : }
2888 : :
2889 : 0 : static unsigned long pci_ea_flags(struct pci_dev *dev, u8 prop)
2890 : : {
2891 : 0 : unsigned long flags = IORESOURCE_PCI_FIXED | IORESOURCE_PCI_EA_BEI;
2892 : :
2893 : 0 : switch (prop) {
2894 : : case PCI_EA_P_MEM:
2895 : : case PCI_EA_P_VF_MEM:
2896 : : flags |= IORESOURCE_MEM;
2897 : : break;
2898 : : case PCI_EA_P_MEM_PREFETCH:
2899 : : case PCI_EA_P_VF_MEM_PREFETCH:
2900 : : flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH;
2901 : : break;
2902 : : case PCI_EA_P_IO:
2903 : : flags |= IORESOURCE_IO;
2904 : : break;
2905 : : default:
2906 : : return 0;
2907 : : }
2908 : :
2909 : : return flags;
2910 : : }
2911 : :
2912 : 0 : static struct resource *pci_ea_get_resource(struct pci_dev *dev, u8 bei,
2913 : : u8 prop)
2914 : : {
2915 : 0 : if (bei <= PCI_EA_BEI_BAR5 && prop <= PCI_EA_P_IO)
2916 : 0 : return &dev->resource[bei];
2917 : : #ifdef CONFIG_PCI_IOV
2918 : : else if (bei >= PCI_EA_BEI_VF_BAR0 && bei <= PCI_EA_BEI_VF_BAR5 &&
2919 : : (prop == PCI_EA_P_VF_MEM || prop == PCI_EA_P_VF_MEM_PREFETCH))
2920 : : return &dev->resource[PCI_IOV_RESOURCES +
2921 : : bei - PCI_EA_BEI_VF_BAR0];
2922 : : #endif
2923 [ # # ]: 0 : else if (bei == PCI_EA_BEI_ROM)
2924 : 0 : return &dev->resource[PCI_ROM_RESOURCE];
2925 : : else
2926 : : return NULL;
2927 : : }
2928 : :
2929 : : /* Read an Enhanced Allocation (EA) entry */
2930 : 0 : static int pci_ea_read(struct pci_dev *dev, int offset)
2931 : : {
2932 : 0 : struct resource *res;
2933 : 0 : int ent_size, ent_offset = offset;
2934 : 0 : resource_size_t start, end;
2935 : 0 : unsigned long flags;
2936 : 0 : u32 dw0, bei, base, max_offset;
2937 : 0 : u8 prop;
2938 : 0 : bool support_64 = (sizeof(resource_size_t) >= 8);
2939 : :
2940 : 0 : pci_read_config_dword(dev, ent_offset, &dw0);
2941 : 0 : ent_offset += 4;
2942 : :
2943 : : /* Entry size field indicates DWORDs after 1st */
2944 : 0 : ent_size = ((dw0 & PCI_EA_ES) + 1) << 2;
2945 : :
2946 [ # # ]: 0 : if (!(dw0 & PCI_EA_ENABLE)) /* Entry not enabled */
2947 : 0 : goto out;
2948 : :
2949 : 0 : bei = (dw0 & PCI_EA_BEI) >> 4;
2950 : 0 : prop = (dw0 & PCI_EA_PP) >> 8;
2951 : :
2952 : : /*
2953 : : * If the Property is in the reserved range, try the Secondary
2954 : : * Property instead.
2955 : : */
2956 [ # # ]: 0 : if (prop > PCI_EA_P_BRIDGE_IO && prop < PCI_EA_P_MEM_RESERVED)
2957 : 0 : prop = (dw0 & PCI_EA_SP) >> 16;
2958 [ # # ]: 0 : if (prop > PCI_EA_P_BRIDGE_IO)
2959 : 0 : goto out;
2960 : :
2961 [ # # ]: 0 : res = pci_ea_get_resource(dev, bei, prop);
2962 [ # # ]: 0 : if (!res) {
2963 : 0 : pci_err(dev, "Unsupported EA entry BEI: %u\n", bei);
2964 : 0 : goto out;
2965 : : }
2966 : :
2967 [ # # ]: 0 : flags = pci_ea_flags(dev, prop);
2968 [ # # ]: 0 : if (!flags) {
2969 : 0 : pci_err(dev, "Unsupported EA properties: %#x\n", prop);
2970 : 0 : goto out;
2971 : : }
2972 : :
2973 : : /* Read Base */
2974 : 0 : pci_read_config_dword(dev, ent_offset, &base);
2975 : 0 : start = (base & PCI_EA_FIELD_MASK);
2976 : 0 : ent_offset += 4;
2977 : :
2978 : : /* Read MaxOffset */
2979 : 0 : pci_read_config_dword(dev, ent_offset, &max_offset);
2980 : 0 : ent_offset += 4;
2981 : :
2982 : : /* Read Base MSBs (if 64-bit entry) */
2983 [ # # ]: 0 : if (base & PCI_EA_IS_64) {
2984 : 0 : u32 base_upper;
2985 : :
2986 : 0 : pci_read_config_dword(dev, ent_offset, &base_upper);
2987 : 0 : ent_offset += 4;
2988 : :
2989 : 0 : flags |= IORESOURCE_MEM_64;
2990 : :
2991 : : /* entry starts above 32-bit boundary, can't use */
2992 : 0 : if (!support_64 && base_upper)
2993 : : goto out;
2994 : :
2995 : 0 : if (support_64)
2996 : 0 : start |= ((u64)base_upper << 32);
2997 : : }
2998 : :
2999 : 0 : end = start + (max_offset | 0x03);
3000 : :
3001 : : /* Read MaxOffset MSBs (if 64-bit entry) */
3002 [ # # ]: 0 : if (max_offset & PCI_EA_IS_64) {
3003 : 0 : u32 max_offset_upper;
3004 : :
3005 : 0 : pci_read_config_dword(dev, ent_offset, &max_offset_upper);
3006 : 0 : ent_offset += 4;
3007 : :
3008 : 0 : flags |= IORESOURCE_MEM_64;
3009 : :
3010 : : /* entry too big, can't use */
3011 : 0 : if (!support_64 && max_offset_upper)
3012 : : goto out;
3013 : :
3014 : 0 : if (support_64)
3015 : 0 : end += ((u64)max_offset_upper << 32);
3016 : : }
3017 : :
3018 [ # # ]: 0 : if (end < start) {
3019 : 0 : pci_err(dev, "EA Entry crosses address boundary\n");
3020 : 0 : goto out;
3021 : : }
3022 : :
3023 [ # # ]: 0 : if (ent_size != ent_offset - offset) {
3024 : 0 : pci_err(dev, "EA Entry Size (%d) does not match length read (%d)\n",
3025 : : ent_size, ent_offset - offset);
3026 : 0 : goto out;
3027 : : }
3028 : :
3029 [ # # ]: 0 : res->name = pci_name(dev);
3030 : 0 : res->start = start;
3031 : 0 : res->end = end;
3032 : 0 : res->flags = flags;
3033 : :
3034 [ # # ]: 0 : if (bei <= PCI_EA_BEI_BAR5)
3035 : 0 : pci_info(dev, "BAR %d: %pR (from Enhanced Allocation, properties %#02x)\n",
3036 : : bei, res, prop);
3037 [ # # ]: 0 : else if (bei == PCI_EA_BEI_ROM)
3038 : 0 : pci_info(dev, "ROM: %pR (from Enhanced Allocation, properties %#02x)\n",
3039 : : res, prop);
3040 [ # # ]: 0 : else if (bei >= PCI_EA_BEI_VF_BAR0 && bei <= PCI_EA_BEI_VF_BAR5)
3041 : 0 : pci_info(dev, "VF BAR %d: %pR (from Enhanced Allocation, properties %#02x)\n",
3042 : : bei - PCI_EA_BEI_VF_BAR0, res, prop);
3043 : : else
3044 : 0 : pci_info(dev, "BEI %d res: %pR (from Enhanced Allocation, properties %#02x)\n",
3045 : : bei, res, prop);
3046 : :
3047 : 0 : out:
3048 : 0 : return offset + ent_size;
3049 : : }
3050 : :
3051 : : /* Enhanced Allocation Initialization */
3052 : 210 : void pci_ea_init(struct pci_dev *dev)
3053 : : {
3054 : 210 : int ea;
3055 : 210 : u8 num_ent;
3056 : 210 : int offset;
3057 : 210 : int i;
3058 : :
3059 : : /* find PCI EA capability in list */
3060 : 210 : ea = pci_find_capability(dev, PCI_CAP_ID_EA);
3061 [ + - ]: 210 : if (!ea)
3062 : 210 : return;
3063 : :
3064 : : /* determine the number of entries */
3065 : 0 : pci_bus_read_config_byte(dev->bus, dev->devfn, ea + PCI_EA_NUM_ENT,
3066 : : &num_ent);
3067 : 0 : num_ent &= PCI_EA_NUM_ENT_MASK;
3068 : :
3069 : 0 : offset = ea + PCI_EA_FIRST_ENT;
3070 : :
3071 : : /* Skip DWORD 2 for type 1 functions */
3072 [ # # ]: 0 : if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)
3073 : 0 : offset += 4;
3074 : :
3075 : : /* parse each EA entry */
3076 [ # # ]: 0 : for (i = 0; i < num_ent; ++i)
3077 : 0 : offset = pci_ea_read(dev, offset);
3078 : : }
3079 : :
3080 : 0 : static void pci_add_saved_cap(struct pci_dev *pci_dev,
3081 : : struct pci_cap_saved_state *new_cap)
3082 : : {
3083 : 0 : hlist_add_head(&new_cap->next, &pci_dev->saved_cap_space);
3084 : : }
3085 : :
3086 : : /**
3087 : : * _pci_add_cap_save_buffer - allocate buffer for saving given
3088 : : * capability registers
3089 : : * @dev: the PCI device
3090 : : * @cap: the capability to allocate the buffer for
3091 : : * @extended: Standard or Extended capability ID
3092 : : * @size: requested size of the buffer
3093 : : */
3094 : 630 : static int _pci_add_cap_save_buffer(struct pci_dev *dev, u16 cap,
3095 : : bool extended, unsigned int size)
3096 : : {
3097 : 630 : int pos;
3098 : 630 : struct pci_cap_saved_state *save_state;
3099 : :
3100 [ + + ]: 630 : if (extended)
3101 : 210 : pos = pci_find_ext_capability(dev, cap);
3102 : : else
3103 : 420 : pos = pci_find_capability(dev, cap);
3104 : :
3105 [ - + ]: 630 : if (!pos)
3106 : : return 0;
3107 : :
3108 : 0 : save_state = kzalloc(sizeof(*save_state) + size, GFP_KERNEL);
3109 [ # # ]: 0 : if (!save_state)
3110 : : return -ENOMEM;
3111 : :
3112 : 0 : save_state->cap.cap_nr = cap;
3113 : 0 : save_state->cap.cap_extended = extended;
3114 : 0 : save_state->cap.size = size;
3115 [ # # ]: 0 : pci_add_saved_cap(dev, save_state);
3116 : :
3117 : 0 : return 0;
3118 : : }
3119 : :
3120 : 420 : int pci_add_cap_save_buffer(struct pci_dev *dev, char cap, unsigned int size)
3121 : : {
3122 : 0 : return _pci_add_cap_save_buffer(dev, cap, false, size);
3123 : : }
3124 : :
3125 : 210 : int pci_add_ext_cap_save_buffer(struct pci_dev *dev, u16 cap, unsigned int size)
3126 : : {
3127 : 0 : return _pci_add_cap_save_buffer(dev, cap, true, size);
3128 : : }
3129 : :
3130 : : /**
3131 : : * pci_allocate_cap_save_buffers - allocate buffers for saving capabilities
3132 : : * @dev: the PCI device
3133 : : */
3134 : 210 : void pci_allocate_cap_save_buffers(struct pci_dev *dev)
3135 : : {
3136 : 210 : int error;
3137 : :
3138 : 210 : error = pci_add_cap_save_buffer(dev, PCI_CAP_ID_EXP,
3139 : : PCI_EXP_SAVE_REGS * sizeof(u16));
3140 [ - + ]: 210 : if (error)
3141 : 0 : pci_err(dev, "unable to preallocate PCI Express save buffer\n");
3142 : :
3143 : 210 : error = pci_add_cap_save_buffer(dev, PCI_CAP_ID_PCIX, sizeof(u16));
3144 [ - + ]: 210 : if (error)
3145 : 0 : pci_err(dev, "unable to preallocate PCI-X save buffer\n");
3146 : :
3147 : 210 : error = pci_add_ext_cap_save_buffer(dev, PCI_EXT_CAP_ID_LTR,
3148 : : 2 * sizeof(u16));
3149 [ - + ]: 210 : if (error)
3150 : 0 : pci_err(dev, "unable to allocate suspend buffer for LTR\n");
3151 : :
3152 : 210 : pci_allocate_vc_save_buffers(dev);
3153 : 210 : }
3154 : :
3155 : 0 : void pci_free_cap_save_buffers(struct pci_dev *dev)
3156 : : {
3157 : 0 : struct pci_cap_saved_state *tmp;
3158 : 0 : struct hlist_node *n;
3159 : :
3160 [ # # # # : 0 : hlist_for_each_entry_safe(tmp, n, &dev->saved_cap_space, next)
# # ]
3161 : 0 : kfree(tmp);
3162 : 0 : }
3163 : :
3164 : : /**
3165 : : * pci_configure_ari - enable or disable ARI forwarding
3166 : : * @dev: the PCI device
3167 : : *
3168 : : * If @dev and its upstream bridge both support ARI, enable ARI in the
3169 : : * bridge. Otherwise, disable ARI in the bridge.
3170 : : */
3171 : 210 : void pci_configure_ari(struct pci_dev *dev)
3172 : : {
3173 : 210 : u32 cap;
3174 : 210 : struct pci_dev *bridge;
3175 : :
3176 [ + - - + : 210 : if (pcie_ari_disabled || !pci_is_pcie(dev) || dev->devfn)
- - ]
3177 : 210 : return;
3178 : :
3179 : 0 : bridge = dev->bus->self;
3180 [ # # ]: 0 : if (!bridge)
3181 : : return;
3182 : :
3183 : 0 : pcie_capability_read_dword(bridge, PCI_EXP_DEVCAP2, &cap);
3184 [ # # ]: 0 : if (!(cap & PCI_EXP_DEVCAP2_ARI))
3185 : : return;
3186 : :
3187 [ # # ]: 0 : if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI)) {
3188 : 0 : pcie_capability_set_word(bridge, PCI_EXP_DEVCTL2,
3189 : : PCI_EXP_DEVCTL2_ARI);
3190 : 0 : bridge->ari_enabled = 1;
3191 : : } else {
3192 : 0 : pcie_capability_clear_word(bridge, PCI_EXP_DEVCTL2,
3193 : : PCI_EXP_DEVCTL2_ARI);
3194 : 0 : bridge->ari_enabled = 0;
3195 : : }
3196 : : }
3197 : :
3198 : : static int pci_acs_enable;
3199 : :
3200 : : /**
3201 : : * pci_request_acs - ask for ACS to be enabled if supported
3202 : : */
3203 : 0 : void pci_request_acs(void)
3204 : : {
3205 : 0 : pci_acs_enable = 1;
3206 : 0 : }
3207 : :
3208 : : static const char *disable_acs_redir_param;
3209 : :
3210 : : /**
3211 : : * pci_disable_acs_redir - disable ACS redirect capabilities
3212 : : * @dev: the PCI device
3213 : : *
3214 : : * For only devices specified in the disable_acs_redir parameter.
3215 : : */
3216 : 210 : static void pci_disable_acs_redir(struct pci_dev *dev)
3217 : : {
3218 : 210 : int ret = 0;
3219 : 210 : const char *p;
3220 : 210 : int pos;
3221 : 210 : u16 ctrl;
3222 : :
3223 [ - + ]: 210 : if (!disable_acs_redir_param)
3224 : 210 : return;
3225 : :
3226 : 0 : p = disable_acs_redir_param;
3227 [ # # ]: 0 : while (*p) {
3228 : 0 : ret = pci_dev_str_match(dev, p, &p);
3229 [ # # ]: 0 : if (ret < 0) {
3230 [ # # ]: 0 : pr_info_once("PCI: Can't parse disable_acs_redir parameter: %s\n",
3231 : : disable_acs_redir_param);
3232 : :
3233 : 0 : break;
3234 [ # # ]: 0 : } else if (ret == 1) {
3235 : : /* Found a match */
3236 : : break;
3237 : : }
3238 : :
3239 [ # # ]: 0 : if (*p != ';' && *p != ',') {
3240 : : /* End of param or invalid format */
3241 : : break;
3242 : : }
3243 : 0 : p++;
3244 : : }
3245 : :
3246 [ # # ]: 0 : if (ret != 1)
3247 : : return;
3248 : :
3249 [ # # ]: 0 : if (!pci_dev_specific_disable_acs_redir(dev))
3250 : : return;
3251 : :
3252 : 0 : pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS);
3253 [ # # ]: 0 : if (!pos) {
3254 : 0 : pci_warn(dev, "cannot disable ACS redirect for this hardware as it does not have ACS capabilities\n");
3255 : 0 : return;
3256 : : }
3257 : :
3258 : 0 : pci_read_config_word(dev, pos + PCI_ACS_CTRL, &ctrl);
3259 : :
3260 : : /* P2P Request & Completion Redirect */
3261 : 0 : ctrl &= ~(PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_EC);
3262 : :
3263 : 0 : pci_write_config_word(dev, pos + PCI_ACS_CTRL, ctrl);
3264 : :
3265 : 0 : pci_info(dev, "disabled ACS redirect\n");
3266 : : }
3267 : :
3268 : : /**
3269 : : * pci_std_enable_acs - enable ACS on devices using standard ACS capabilities
3270 : : * @dev: the PCI device
3271 : : */
3272 : 0 : static void pci_std_enable_acs(struct pci_dev *dev)
3273 : : {
3274 : 0 : int pos;
3275 : 0 : u16 cap;
3276 : 0 : u16 ctrl;
3277 : :
3278 : 0 : pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS);
3279 [ # # ]: 0 : if (!pos)
3280 : 0 : return;
3281 : :
3282 : 0 : pci_read_config_word(dev, pos + PCI_ACS_CAP, &cap);
3283 : 0 : pci_read_config_word(dev, pos + PCI_ACS_CTRL, &ctrl);
3284 : :
3285 : : /* Source Validation */
3286 : 0 : ctrl |= (cap & PCI_ACS_SV);
3287 : :
3288 : : /* P2P Request Redirect */
3289 : 0 : ctrl |= (cap & PCI_ACS_RR);
3290 : :
3291 : : /* P2P Completion Redirect */
3292 : 0 : ctrl |= (cap & PCI_ACS_CR);
3293 : :
3294 : : /* Upstream Forwarding */
3295 : 0 : ctrl |= (cap & PCI_ACS_UF);
3296 : :
3297 : 0 : pci_write_config_word(dev, pos + PCI_ACS_CTRL, ctrl);
3298 : : }
3299 : :
3300 : : /**
3301 : : * pci_enable_acs - enable ACS if hardware support it
3302 : : * @dev: the PCI device
3303 : : */
3304 : 210 : void pci_enable_acs(struct pci_dev *dev)
3305 : : {
3306 [ + - ]: 210 : if (!pci_acs_enable)
3307 : 210 : goto disable_acs_redir;
3308 : :
3309 [ # # ]: 0 : if (!pci_dev_specific_enable_acs(dev))
3310 : 0 : goto disable_acs_redir;
3311 : :
3312 : 0 : pci_std_enable_acs(dev);
3313 : :
3314 : 210 : disable_acs_redir:
3315 : : /*
3316 : : * Note: pci_disable_acs_redir() must be called even if ACS was not
3317 : : * enabled by the kernel because it may have been enabled by
3318 : : * platform firmware. So if we are told to disable it, we should
3319 : : * always disable it after setting the kernel's default
3320 : : * preferences.
3321 : : */
3322 : 210 : pci_disable_acs_redir(dev);
3323 : 210 : }
3324 : :
3325 : 0 : static bool pci_acs_flags_enabled(struct pci_dev *pdev, u16 acs_flags)
3326 : : {
3327 : 0 : int pos;
3328 : 0 : u16 cap, ctrl;
3329 : :
3330 : 0 : pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ACS);
3331 [ # # ]: 0 : if (!pos)
3332 : : return false;
3333 : :
3334 : : /*
3335 : : * Except for egress control, capabilities are either required
3336 : : * or only required if controllable. Features missing from the
3337 : : * capability field can therefore be assumed as hard-wired enabled.
3338 : : */
3339 : 0 : pci_read_config_word(pdev, pos + PCI_ACS_CAP, &cap);
3340 : 0 : acs_flags &= (cap | PCI_ACS_EC);
3341 : :
3342 : 0 : pci_read_config_word(pdev, pos + PCI_ACS_CTRL, &ctrl);
3343 : 0 : return (ctrl & acs_flags) == acs_flags;
3344 : : }
3345 : :
3346 : : /**
3347 : : * pci_acs_enabled - test ACS against required flags for a given device
3348 : : * @pdev: device to test
3349 : : * @acs_flags: required PCI ACS flags
3350 : : *
3351 : : * Return true if the device supports the provided flags. Automatically
3352 : : * filters out flags that are not implemented on multifunction devices.
3353 : : *
3354 : : * Note that this interface checks the effective ACS capabilities of the
3355 : : * device rather than the actual capabilities. For instance, most single
3356 : : * function endpoints are not required to support ACS because they have no
3357 : : * opportunity for peer-to-peer access. We therefore return 'true'
3358 : : * regardless of whether the device exposes an ACS capability. This makes
3359 : : * it much easier for callers of this function to ignore the actual type
3360 : : * or topology of the device when testing ACS support.
3361 : : */
3362 : 0 : bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags)
3363 : : {
3364 : 0 : int ret;
3365 : :
3366 : 0 : ret = pci_dev_specific_acs_enabled(pdev, acs_flags);
3367 [ # # ]: 0 : if (ret >= 0)
3368 : 0 : return ret > 0;
3369 : :
3370 : : /*
3371 : : * Conventional PCI and PCI-X devices never support ACS, either
3372 : : * effectively or actually. The shared bus topology implies that
3373 : : * any device on the bus can receive or snoop DMA.
3374 : : */
3375 [ # # ]: 0 : if (!pci_is_pcie(pdev))
3376 : : return false;
3377 : :
3378 [ # # # # ]: 0 : switch (pci_pcie_type(pdev)) {
3379 : : /*
3380 : : * PCI/X-to-PCIe bridges are not specifically mentioned by the spec,
3381 : : * but since their primary interface is PCI/X, we conservatively
3382 : : * handle them as we would a non-PCIe device.
3383 : : */
3384 : : case PCI_EXP_TYPE_PCIE_BRIDGE:
3385 : : /*
3386 : : * PCIe 3.0, 6.12.1 excludes ACS on these devices. "ACS is never
3387 : : * applicable... must never implement an ACS Extended Capability...".
3388 : : * This seems arbitrary, but we take a conservative interpretation
3389 : : * of this statement.
3390 : : */
3391 : : case PCI_EXP_TYPE_PCI_BRIDGE:
3392 : : case PCI_EXP_TYPE_RC_EC:
3393 : : return false;
3394 : : /*
3395 : : * PCIe 3.0, 6.12.1.1 specifies that downstream and root ports should
3396 : : * implement ACS in order to indicate their peer-to-peer capabilities,
3397 : : * regardless of whether they are single- or multi-function devices.
3398 : : */
3399 : 0 : case PCI_EXP_TYPE_DOWNSTREAM:
3400 : : case PCI_EXP_TYPE_ROOT_PORT:
3401 : 0 : return pci_acs_flags_enabled(pdev, acs_flags);
3402 : : /*
3403 : : * PCIe 3.0, 6.12.1.2 specifies ACS capabilities that should be
3404 : : * implemented by the remaining PCIe types to indicate peer-to-peer
3405 : : * capabilities, but only when they are part of a multifunction
3406 : : * device. The footnote for section 6.12 indicates the specific
3407 : : * PCIe types included here.
3408 : : */
3409 : 0 : case PCI_EXP_TYPE_ENDPOINT:
3410 : : case PCI_EXP_TYPE_UPSTREAM:
3411 : : case PCI_EXP_TYPE_LEG_END:
3412 : : case PCI_EXP_TYPE_RC_END:
3413 [ # # ]: 0 : if (!pdev->multifunction)
3414 : : break;
3415 : :
3416 : 0 : return pci_acs_flags_enabled(pdev, acs_flags);
3417 : : }
3418 : :
3419 : : /*
3420 : : * PCIe 3.0, 6.12.1.3 specifies no ACS capabilities are applicable
3421 : : * to single function devices with the exception of downstream ports.
3422 : : */
3423 : 0 : return true;
3424 : : }
3425 : :
3426 : : /**
3427 : : * pci_acs_path_enable - test ACS flags from start to end in a hierarchy
3428 : : * @start: starting downstream device
3429 : : * @end: ending upstream device or NULL to search to the root bus
3430 : : * @acs_flags: required flags
3431 : : *
3432 : : * Walk up a device tree from start to end testing PCI ACS support. If
3433 : : * any step along the way does not support the required flags, return false.
3434 : : */
3435 : 0 : bool pci_acs_path_enabled(struct pci_dev *start,
3436 : : struct pci_dev *end, u16 acs_flags)
3437 : : {
3438 : 0 : struct pci_dev *pdev, *parent = start;
3439 : :
3440 : 0 : do {
3441 : 0 : pdev = parent;
3442 : :
3443 [ # # ]: 0 : if (!pci_acs_enabled(pdev, acs_flags))
3444 : : return false;
3445 : :
3446 [ # # ]: 0 : if (pci_is_root_bus(pdev->bus))
3447 : 0 : return (end == NULL);
3448 : :
3449 : 0 : parent = pdev->bus->self;
3450 [ # # ]: 0 : } while (pdev != end);
3451 : :
3452 : : return true;
3453 : : }
3454 : :
3455 : : /**
3456 : : * pci_rebar_find_pos - find position of resize ctrl reg for BAR
3457 : : * @pdev: PCI device
3458 : : * @bar: BAR to find
3459 : : *
3460 : : * Helper to find the position of the ctrl register for a BAR.
3461 : : * Returns -ENOTSUPP if resizable BARs are not supported at all.
3462 : : * Returns -ENOENT if no ctrl register for the BAR could be found.
3463 : : */
3464 : 0 : static int pci_rebar_find_pos(struct pci_dev *pdev, int bar)
3465 : : {
3466 : 0 : unsigned int pos, nbars, i;
3467 : 0 : u32 ctrl;
3468 : :
3469 : 0 : pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_REBAR);
3470 [ # # ]: 0 : if (!pos)
3471 : : return -ENOTSUPP;
3472 : :
3473 : 0 : pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
3474 : 0 : nbars = (ctrl & PCI_REBAR_CTRL_NBAR_MASK) >>
3475 : : PCI_REBAR_CTRL_NBAR_SHIFT;
3476 : :
3477 [ # # ]: 0 : for (i = 0; i < nbars; i++, pos += 8) {
3478 : 0 : int bar_idx;
3479 : :
3480 : 0 : pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
3481 : 0 : bar_idx = ctrl & PCI_REBAR_CTRL_BAR_IDX;
3482 [ # # ]: 0 : if (bar_idx == bar)
3483 : 0 : return pos;
3484 : : }
3485 : :
3486 : : return -ENOENT;
3487 : : }
3488 : :
3489 : : /**
3490 : : * pci_rebar_get_possible_sizes - get possible sizes for BAR
3491 : : * @pdev: PCI device
3492 : : * @bar: BAR to query
3493 : : *
3494 : : * Get the possible sizes of a resizable BAR as bitmask defined in the spec
3495 : : * (bit 0=1MB, bit 19=512GB). Returns 0 if BAR isn't resizable.
3496 : : */
3497 : 0 : u32 pci_rebar_get_possible_sizes(struct pci_dev *pdev, int bar)
3498 : : {
3499 : 0 : int pos;
3500 : 0 : u32 cap;
3501 : :
3502 : 0 : pos = pci_rebar_find_pos(pdev, bar);
3503 [ # # ]: 0 : if (pos < 0)
3504 : : return 0;
3505 : :
3506 : 0 : pci_read_config_dword(pdev, pos + PCI_REBAR_CAP, &cap);
3507 : 0 : return (cap & PCI_REBAR_CAP_SIZES) >> 4;
3508 : : }
3509 : :
3510 : : /**
3511 : : * pci_rebar_get_current_size - get the current size of a BAR
3512 : : * @pdev: PCI device
3513 : : * @bar: BAR to set size to
3514 : : *
3515 : : * Read the size of a BAR from the resizable BAR config.
3516 : : * Returns size if found or negative error code.
3517 : : */
3518 : 0 : int pci_rebar_get_current_size(struct pci_dev *pdev, int bar)
3519 : : {
3520 : 0 : int pos;
3521 : 0 : u32 ctrl;
3522 : :
3523 : 0 : pos = pci_rebar_find_pos(pdev, bar);
3524 [ # # ]: 0 : if (pos < 0)
3525 : : return pos;
3526 : :
3527 : 0 : pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
3528 : 0 : return (ctrl & PCI_REBAR_CTRL_BAR_SIZE) >> PCI_REBAR_CTRL_BAR_SHIFT;
3529 : : }
3530 : :
3531 : : /**
3532 : : * pci_rebar_set_size - set a new size for a BAR
3533 : : * @pdev: PCI device
3534 : : * @bar: BAR to set size to
3535 : : * @size: new size as defined in the spec (0=1MB, 19=512GB)
3536 : : *
3537 : : * Set the new size of a BAR as defined in the spec.
3538 : : * Returns zero if resizing was successful, error code otherwise.
3539 : : */
3540 : 0 : int pci_rebar_set_size(struct pci_dev *pdev, int bar, int size)
3541 : : {
3542 : 0 : int pos;
3543 : 0 : u32 ctrl;
3544 : :
3545 : 0 : pos = pci_rebar_find_pos(pdev, bar);
3546 [ # # ]: 0 : if (pos < 0)
3547 : : return pos;
3548 : :
3549 : 0 : pci_read_config_dword(pdev, pos + PCI_REBAR_CTRL, &ctrl);
3550 : 0 : ctrl &= ~PCI_REBAR_CTRL_BAR_SIZE;
3551 : 0 : ctrl |= size << PCI_REBAR_CTRL_BAR_SHIFT;
3552 : 0 : pci_write_config_dword(pdev, pos + PCI_REBAR_CTRL, ctrl);
3553 : 0 : return 0;
3554 : : }
3555 : :
3556 : : /**
3557 : : * pci_enable_atomic_ops_to_root - enable AtomicOp requests to root port
3558 : : * @dev: the PCI device
3559 : : * @cap_mask: mask of desired AtomicOp sizes, including one or more of:
3560 : : * PCI_EXP_DEVCAP2_ATOMIC_COMP32
3561 : : * PCI_EXP_DEVCAP2_ATOMIC_COMP64
3562 : : * PCI_EXP_DEVCAP2_ATOMIC_COMP128
3563 : : *
3564 : : * Return 0 if all upstream bridges support AtomicOp routing, egress
3565 : : * blocking is disabled on all upstream ports, and the root port supports
3566 : : * the requested completion capabilities (32-bit, 64-bit and/or 128-bit
3567 : : * AtomicOp completion), or negative otherwise.
3568 : : */
3569 : 0 : int pci_enable_atomic_ops_to_root(struct pci_dev *dev, u32 cap_mask)
3570 : : {
3571 : 0 : struct pci_bus *bus = dev->bus;
3572 : 0 : struct pci_dev *bridge;
3573 : 0 : u32 cap, ctl2;
3574 : :
3575 [ # # ]: 0 : if (!pci_is_pcie(dev))
3576 : : return -EINVAL;
3577 : :
3578 : : /*
3579 : : * Per PCIe r4.0, sec 6.15, endpoints and root ports may be
3580 : : * AtomicOp requesters. For now, we only support endpoints as
3581 : : * requesters and root ports as completers. No endpoints as
3582 : : * completers, and no peer-to-peer.
3583 : : */
3584 : :
3585 [ # # ]: 0 : switch (pci_pcie_type(dev)) {
3586 : : case PCI_EXP_TYPE_ENDPOINT:
3587 : : case PCI_EXP_TYPE_LEG_END:
3588 : : case PCI_EXP_TYPE_RC_END:
3589 : : break;
3590 : : default:
3591 : : return -EINVAL;
3592 : : }
3593 : :
3594 [ # # ]: 0 : while (bus->parent) {
3595 : 0 : bridge = bus->self;
3596 : :
3597 : 0 : pcie_capability_read_dword(bridge, PCI_EXP_DEVCAP2, &cap);
3598 : :
3599 [ # # # ]: 0 : switch (pci_pcie_type(bridge)) {
3600 : : /* Ensure switch ports support AtomicOp routing */
3601 : 0 : case PCI_EXP_TYPE_UPSTREAM:
3602 : : case PCI_EXP_TYPE_DOWNSTREAM:
3603 [ # # ]: 0 : if (!(cap & PCI_EXP_DEVCAP2_ATOMIC_ROUTE))
3604 : : return -EINVAL;
3605 : : break;
3606 : :
3607 : : /* Ensure root port supports all the sizes we care about */
3608 : 0 : case PCI_EXP_TYPE_ROOT_PORT:
3609 [ # # ]: 0 : if ((cap & cap_mask) != cap_mask)
3610 : : return -EINVAL;
3611 : : break;
3612 : : }
3613 : :
3614 : : /* Ensure upstream ports don't block AtomicOps on egress */
3615 [ # # ]: 0 : if (pci_pcie_type(bridge) == PCI_EXP_TYPE_UPSTREAM) {
3616 : 0 : pcie_capability_read_dword(bridge, PCI_EXP_DEVCTL2,
3617 : : &ctl2);
3618 [ # # ]: 0 : if (ctl2 & PCI_EXP_DEVCTL2_ATOMIC_EGRESS_BLOCK)
3619 : : return -EINVAL;
3620 : : }
3621 : :
3622 : 0 : bus = bus->parent;
3623 : : }
3624 : :
3625 : 0 : pcie_capability_set_word(dev, PCI_EXP_DEVCTL2,
3626 : : PCI_EXP_DEVCTL2_ATOMIC_REQ);
3627 : 0 : return 0;
3628 : : }
3629 : : EXPORT_SYMBOL(pci_enable_atomic_ops_to_root);
3630 : :
3631 : : /**
3632 : : * pci_swizzle_interrupt_pin - swizzle INTx for device behind bridge
3633 : : * @dev: the PCI device
3634 : : * @pin: the INTx pin (1=INTA, 2=INTB, 3=INTC, 4=INTD)
3635 : : *
3636 : : * Perform INTx swizzling for a device behind one level of bridge. This is
3637 : : * required by section 9.1 of the PCI-to-PCI bridge specification for devices
3638 : : * behind bridges on add-in cards. For devices with ARI enabled, the slot
3639 : : * number is always 0 (see the Implementation Note in section 2.2.8.1 of
3640 : : * the PCI Express Base Specification, Revision 2.1)
3641 : : */
3642 : 0 : u8 pci_swizzle_interrupt_pin(const struct pci_dev *dev, u8 pin)
3643 : : {
3644 : 0 : int slot;
3645 : :
3646 [ # # # # : 0 : if (pci_ari_enabled(dev->bus))
# # # # ]
3647 : : slot = 0;
3648 : : else
3649 : 0 : slot = PCI_SLOT(dev->devfn);
3650 : :
3651 : 0 : return (((pin - 1) + slot) % 4) + 1;
3652 : : }
3653 : :
3654 : 0 : int pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge)
3655 : : {
3656 : 0 : u8 pin;
3657 : :
3658 : 0 : pin = dev->pin;
3659 [ # # ]: 0 : if (!pin)
3660 : : return -1;
3661 : :
3662 [ # # ]: 0 : while (!pci_is_root_bus(dev->bus)) {
3663 [ # # ]: 0 : pin = pci_swizzle_interrupt_pin(dev, pin);
3664 : 0 : dev = dev->bus->self;
3665 : : }
3666 : 0 : *bridge = dev;
3667 : 0 : return pin;
3668 : : }
3669 : :
3670 : : /**
3671 : : * pci_common_swizzle - swizzle INTx all the way to root bridge
3672 : : * @dev: the PCI device
3673 : : * @pinp: pointer to the INTx pin value (1=INTA, 2=INTB, 3=INTD, 4=INTD)
3674 : : *
3675 : : * Perform INTx swizzling for a device. This traverses through all PCI-to-PCI
3676 : : * bridges all the way up to a PCI root bus.
3677 : : */
3678 : 0 : u8 pci_common_swizzle(struct pci_dev *dev, u8 *pinp)
3679 : : {
3680 : 0 : u8 pin = *pinp;
3681 : :
3682 [ # # ]: 0 : while (!pci_is_root_bus(dev->bus)) {
3683 [ # # ]: 0 : pin = pci_swizzle_interrupt_pin(dev, pin);
3684 : 0 : dev = dev->bus->self;
3685 : : }
3686 : 0 : *pinp = pin;
3687 : 0 : return PCI_SLOT(dev->devfn);
3688 : : }
3689 : : EXPORT_SYMBOL_GPL(pci_common_swizzle);
3690 : :
3691 : : /**
3692 : : * pci_release_region - Release a PCI bar
3693 : : * @pdev: PCI device whose resources were previously reserved by
3694 : : * pci_request_region()
3695 : : * @bar: BAR to release
3696 : : *
3697 : : * Releases the PCI I/O and memory resources previously reserved by a
3698 : : * successful call to pci_request_region(). Call this function only
3699 : : * after all use of the PCI regions has ceased.
3700 : : */
3701 : 24 : void pci_release_region(struct pci_dev *pdev, int bar)
3702 : : {
3703 : 24 : struct pci_devres *dr;
3704 : :
3705 [ - + - - : 24 : if (pci_resource_len(pdev, bar) == 0)
+ - ]
3706 : : return;
3707 [ - + ]: 24 : if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
3708 [ # # # # ]: 0 : release_region(pci_resource_start(pdev, bar),
3709 : : pci_resource_len(pdev, bar));
3710 [ + - ]: 24 : else if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
3711 [ - + - - ]: 24 : release_mem_region(pci_resource_start(pdev, bar),
3712 : : pci_resource_len(pdev, bar));
3713 : :
3714 [ + - ]: 24 : dr = find_pci_dr(pdev);
3715 [ - + ]: 24 : if (dr)
3716 : 0 : dr->region_mask &= ~(1 << bar);
3717 : : }
3718 : : EXPORT_SYMBOL(pci_release_region);
3719 : :
3720 : : /**
3721 : : * __pci_request_region - Reserved PCI I/O and memory resource
3722 : : * @pdev: PCI device whose resources are to be reserved
3723 : : * @bar: BAR to be reserved
3724 : : * @res_name: Name to be associated with resource.
3725 : : * @exclusive: whether the region access is exclusive or not
3726 : : *
3727 : : * Mark the PCI region associated with PCI device @pdev BAR @bar as
3728 : : * being reserved by owner @res_name. Do not access any
3729 : : * address inside the PCI regions unless this call returns
3730 : : * successfully.
3731 : : *
3732 : : * If @exclusive is set, then the region is marked so that userspace
3733 : : * is explicitly not allowed to map the resource via /dev/mem or
3734 : : * sysfs MMIO access.
3735 : : *
3736 : : * Returns 0 on success, or %EBUSY on error. A warning
3737 : : * message is also printed on failure.
3738 : : */
3739 : 180 : static int __pci_request_region(struct pci_dev *pdev, int bar,
3740 : : const char *res_name, int exclusive)
3741 : : {
3742 : 180 : struct pci_devres *dr;
3743 : :
3744 [ - + - - : 180 : if (pci_resource_len(pdev, bar) == 0)
+ - ]
3745 : : return 0;
3746 : :
3747 [ + + ]: 180 : if (pci_resource_flags(pdev, bar) & IORESOURCE_IO) {
3748 [ - + - - : 150 : if (!request_region(pci_resource_start(pdev, bar),
- + ]
3749 : : pci_resource_len(pdev, bar), res_name))
3750 : 0 : goto err_out;
3751 [ + - ]: 30 : } else if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) {
3752 [ - + - - : 30 : if (!__request_mem_region(pci_resource_start(pdev, bar),
- + ]
3753 : : pci_resource_len(pdev, bar), res_name,
3754 : : exclusive))
3755 : 0 : goto err_out;
3756 : : }
3757 : :
3758 [ + - ]: 180 : dr = find_pci_dr(pdev);
3759 [ + - ]: 180 : if (dr)
3760 : 180 : dr->region_mask |= 1 << bar;
3761 : :
3762 : : return 0;
3763 : :
3764 : 0 : err_out:
3765 : 0 : pci_warn(pdev, "BAR %d: can't reserve %pR\n", bar,
3766 : : &pdev->resource[bar]);
3767 : 0 : return -EBUSY;
3768 : : }
3769 : :
3770 : : /**
3771 : : * pci_request_region - Reserve PCI I/O and memory resource
3772 : : * @pdev: PCI device whose resources are to be reserved
3773 : : * @bar: BAR to be reserved
3774 : : * @res_name: Name to be associated with resource
3775 : : *
3776 : : * Mark the PCI region associated with PCI device @pdev BAR @bar as
3777 : : * being reserved by owner @res_name. Do not access any
3778 : : * address inside the PCI regions unless this call returns
3779 : : * successfully.
3780 : : *
3781 : : * Returns 0 on success, or %EBUSY on error. A warning
3782 : : * message is also printed on failure.
3783 : : */
3784 : 180 : int pci_request_region(struct pci_dev *pdev, int bar, const char *res_name)
3785 : : {
3786 : 180 : return __pci_request_region(pdev, bar, res_name, 0);
3787 : : }
3788 : : EXPORT_SYMBOL(pci_request_region);
3789 : :
3790 : : /**
3791 : : * pci_release_selected_regions - Release selected PCI I/O and memory resources
3792 : : * @pdev: PCI device whose resources were previously reserved
3793 : : * @bars: Bitmask of BARs to be released
3794 : : *
3795 : : * Release selected PCI I/O and memory resources previously reserved.
3796 : : * Call this function only after all use of the PCI regions has ceased.
3797 : : */
3798 : 0 : void pci_release_selected_regions(struct pci_dev *pdev, int bars)
3799 : : {
3800 : 0 : int i;
3801 : :
3802 [ # # # # ]: 0 : for (i = 0; i < PCI_STD_NUM_BARS; i++)
3803 [ # # # # ]: 0 : if (bars & (1 << i))
3804 : 0 : pci_release_region(pdev, i);
3805 : 0 : }
3806 : : EXPORT_SYMBOL(pci_release_selected_regions);
3807 : :
3808 : 0 : static int __pci_request_selected_regions(struct pci_dev *pdev, int bars,
3809 : : const char *res_name, int excl)
3810 : : {
3811 : 0 : int i;
3812 : :
3813 [ # # ]: 0 : for (i = 0; i < PCI_STD_NUM_BARS; i++)
3814 [ # # ]: 0 : if (bars & (1 << i))
3815 [ # # ]: 0 : if (__pci_request_region(pdev, i, res_name, excl))
3816 : 0 : goto err_out;
3817 : : return 0;
3818 : :
3819 : : err_out:
3820 [ # # ]: 0 : while (--i >= 0)
3821 [ # # ]: 0 : if (bars & (1 << i))
3822 : 0 : pci_release_region(pdev, i);
3823 : :
3824 : : return -EBUSY;
3825 : : }
3826 : :
3827 : :
3828 : : /**
3829 : : * pci_request_selected_regions - Reserve selected PCI I/O and memory resources
3830 : : * @pdev: PCI device whose resources are to be reserved
3831 : : * @bars: Bitmask of BARs to be requested
3832 : : * @res_name: Name to be associated with resource
3833 : : */
3834 : 0 : int pci_request_selected_regions(struct pci_dev *pdev, int bars,
3835 : : const char *res_name)
3836 : : {
3837 : 0 : return __pci_request_selected_regions(pdev, bars, res_name, 0);
3838 : : }
3839 : : EXPORT_SYMBOL(pci_request_selected_regions);
3840 : :
3841 : 0 : int pci_request_selected_regions_exclusive(struct pci_dev *pdev, int bars,
3842 : : const char *res_name)
3843 : : {
3844 : 0 : return __pci_request_selected_regions(pdev, bars, res_name,
3845 : : IORESOURCE_EXCLUSIVE);
3846 : : }
3847 : : EXPORT_SYMBOL(pci_request_selected_regions_exclusive);
3848 : :
3849 : : /**
3850 : : * pci_release_regions - Release reserved PCI I/O and memory resources
3851 : : * @pdev: PCI device whose resources were previously reserved by
3852 : : * pci_request_regions()
3853 : : *
3854 : : * Releases all PCI I/O and memory resources previously reserved by a
3855 : : * successful call to pci_request_regions(). Call this function only
3856 : : * after all use of the PCI regions has ceased.
3857 : : */
3858 : :
3859 : 0 : void pci_release_regions(struct pci_dev *pdev)
3860 : : {
3861 : 0 : pci_release_selected_regions(pdev, (1 << PCI_STD_NUM_BARS) - 1);
3862 : 0 : }
3863 : : EXPORT_SYMBOL(pci_release_regions);
3864 : :
3865 : : /**
3866 : : * pci_request_regions - Reserve PCI I/O and memory resources
3867 : : * @pdev: PCI device whose resources are to be reserved
3868 : : * @res_name: Name to be associated with resource.
3869 : : *
3870 : : * Mark all PCI regions associated with PCI device @pdev as
3871 : : * being reserved by owner @res_name. Do not access any
3872 : : * address inside the PCI regions unless this call returns
3873 : : * successfully.
3874 : : *
3875 : : * Returns 0 on success, or %EBUSY on error. A warning
3876 : : * message is also printed on failure.
3877 : : */
3878 : 0 : int pci_request_regions(struct pci_dev *pdev, const char *res_name)
3879 : : {
3880 : 0 : return pci_request_selected_regions(pdev,
3881 : : ((1 << PCI_STD_NUM_BARS) - 1), res_name);
3882 : : }
3883 : : EXPORT_SYMBOL(pci_request_regions);
3884 : :
3885 : : /**
3886 : : * pci_request_regions_exclusive - Reserve PCI I/O and memory resources
3887 : : * @pdev: PCI device whose resources are to be reserved
3888 : : * @res_name: Name to be associated with resource.
3889 : : *
3890 : : * Mark all PCI regions associated with PCI device @pdev as being reserved
3891 : : * by owner @res_name. Do not access any address inside the PCI regions
3892 : : * unless this call returns successfully.
3893 : : *
3894 : : * pci_request_regions_exclusive() will mark the region so that /dev/mem
3895 : : * and the sysfs MMIO access will not be allowed.
3896 : : *
3897 : : * Returns 0 on success, or %EBUSY on error. A warning message is also
3898 : : * printed on failure.
3899 : : */
3900 : 0 : int pci_request_regions_exclusive(struct pci_dev *pdev, const char *res_name)
3901 : : {
3902 : 0 : return pci_request_selected_regions_exclusive(pdev,
3903 : : ((1 << PCI_STD_NUM_BARS) - 1), res_name);
3904 : : }
3905 : : EXPORT_SYMBOL(pci_request_regions_exclusive);
3906 : :
3907 : : /*
3908 : : * Record the PCI IO range (expressed as CPU physical address + size).
3909 : : * Return a negative value if an error has occurred, zero otherwise
3910 : : */
3911 : 0 : int pci_register_io_range(struct fwnode_handle *fwnode, phys_addr_t addr,
3912 : : resource_size_t size)
3913 : : {
3914 : 0 : int ret = 0;
3915 : : #ifdef PCI_IOBASE
3916 : : struct logic_pio_hwaddr *range;
3917 : :
3918 : : if (!size || addr + size < addr)
3919 : : return -EINVAL;
3920 : :
3921 : : range = kzalloc(sizeof(*range), GFP_ATOMIC);
3922 : : if (!range)
3923 : : return -ENOMEM;
3924 : :
3925 : : range->fwnode = fwnode;
3926 : : range->size = size;
3927 : : range->hw_start = addr;
3928 : : range->flags = LOGIC_PIO_CPU_MMIO;
3929 : :
3930 : : ret = logic_pio_register_range(range);
3931 : : if (ret)
3932 : : kfree(range);
3933 : : #endif
3934 : :
3935 : 0 : return ret;
3936 : : }
3937 : :
3938 : 0 : phys_addr_t pci_pio_to_address(unsigned long pio)
3939 : : {
3940 : 0 : phys_addr_t address = (phys_addr_t)OF_BAD_ADDR;
3941 : :
3942 : : #ifdef PCI_IOBASE
3943 : : if (pio >= MMIO_UPPER_LIMIT)
3944 : : return address;
3945 : :
3946 : : address = logic_pio_to_hwaddr(pio);
3947 : : #endif
3948 : :
3949 : 0 : return address;
3950 : : }
3951 : :
3952 : 0 : unsigned long __weak pci_address_to_pio(phys_addr_t address)
3953 : : {
3954 : : #ifdef PCI_IOBASE
3955 : : return logic_pio_trans_cpuaddr(address);
3956 : : #else
3957 [ # # ]: 0 : if (address > IO_SPACE_LIMIT)
3958 : 0 : return (unsigned long)-1;
3959 : :
3960 : : return (unsigned long) address;
3961 : : #endif
3962 : : }
3963 : :
3964 : : /**
3965 : : * pci_remap_iospace - Remap the memory mapped I/O space
3966 : : * @res: Resource describing the I/O space
3967 : : * @phys_addr: physical address of range to be mapped
3968 : : *
3969 : : * Remap the memory mapped I/O space described by the @res and the CPU
3970 : : * physical address @phys_addr into virtual address space. Only
3971 : : * architectures that have memory mapped IO functions defined (and the
3972 : : * PCI_IOBASE value defined) should call this function.
3973 : : */
3974 : 0 : int pci_remap_iospace(const struct resource *res, phys_addr_t phys_addr)
3975 : : {
3976 : : #if defined(PCI_IOBASE) && defined(CONFIG_MMU)
3977 : : unsigned long vaddr = (unsigned long)PCI_IOBASE + res->start;
3978 : :
3979 : : if (!(res->flags & IORESOURCE_IO))
3980 : : return -EINVAL;
3981 : :
3982 : : if (res->end > IO_SPACE_LIMIT)
3983 : : return -EINVAL;
3984 : :
3985 : : return ioremap_page_range(vaddr, vaddr + resource_size(res), phys_addr,
3986 : : pgprot_device(PAGE_KERNEL));
3987 : : #else
3988 : : /*
3989 : : * This architecture does not have memory mapped I/O space,
3990 : : * so this function should never be called
3991 : : */
3992 [ # # ]: 0 : WARN_ONCE(1, "This architecture does not support memory mapped I/O\n");
3993 : 0 : return -ENODEV;
3994 : : #endif
3995 : : }
3996 : : EXPORT_SYMBOL(pci_remap_iospace);
3997 : :
3998 : : /**
3999 : : * pci_unmap_iospace - Unmap the memory mapped I/O space
4000 : : * @res: resource to be unmapped
4001 : : *
4002 : : * Unmap the CPU virtual address @res from virtual address space. Only
4003 : : * architectures that have memory mapped IO functions defined (and the
4004 : : * PCI_IOBASE value defined) should call this function.
4005 : : */
4006 : 0 : void pci_unmap_iospace(struct resource *res)
4007 : : {
4008 : : #if defined(PCI_IOBASE) && defined(CONFIG_MMU)
4009 : : unsigned long vaddr = (unsigned long)PCI_IOBASE + res->start;
4010 : :
4011 : : unmap_kernel_range(vaddr, resource_size(res));
4012 : : #endif
4013 : 0 : }
4014 : : EXPORT_SYMBOL(pci_unmap_iospace);
4015 : :
4016 : 0 : static void devm_pci_unmap_iospace(struct device *dev, void *ptr)
4017 : : {
4018 : 0 : struct resource **res = ptr;
4019 : :
4020 : 0 : pci_unmap_iospace(*res);
4021 : 0 : }
4022 : :
4023 : : /**
4024 : : * devm_pci_remap_iospace - Managed pci_remap_iospace()
4025 : : * @dev: Generic device to remap IO address for
4026 : : * @res: Resource describing the I/O space
4027 : : * @phys_addr: physical address of range to be mapped
4028 : : *
4029 : : * Managed pci_remap_iospace(). Map is automatically unmapped on driver
4030 : : * detach.
4031 : : */
4032 : 0 : int devm_pci_remap_iospace(struct device *dev, const struct resource *res,
4033 : : phys_addr_t phys_addr)
4034 : : {
4035 : 0 : const struct resource **ptr;
4036 : 0 : int error;
4037 : :
4038 : 0 : ptr = devres_alloc(devm_pci_unmap_iospace, sizeof(*ptr), GFP_KERNEL);
4039 [ # # ]: 0 : if (!ptr)
4040 : : return -ENOMEM;
4041 : :
4042 : 0 : error = pci_remap_iospace(res, phys_addr);
4043 [ # # ]: 0 : if (error) {
4044 : 0 : devres_free(ptr);
4045 : : } else {
4046 : 0 : *ptr = res;
4047 : 0 : devres_add(dev, ptr);
4048 : : }
4049 : :
4050 : : return error;
4051 : : }
4052 : : EXPORT_SYMBOL(devm_pci_remap_iospace);
4053 : :
4054 : : /**
4055 : : * devm_pci_remap_cfgspace - Managed pci_remap_cfgspace()
4056 : : * @dev: Generic device to remap IO address for
4057 : : * @offset: Resource address to map
4058 : : * @size: Size of map
4059 : : *
4060 : : * Managed pci_remap_cfgspace(). Map is automatically unmapped on driver
4061 : : * detach.
4062 : : */
4063 : 0 : void __iomem *devm_pci_remap_cfgspace(struct device *dev,
4064 : : resource_size_t offset,
4065 : : resource_size_t size)
4066 : : {
4067 : 0 : void __iomem **ptr, *addr;
4068 : :
4069 : 0 : ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
4070 [ # # ]: 0 : if (!ptr)
4071 : : return NULL;
4072 : :
4073 : 0 : addr = pci_remap_cfgspace(offset, size);
4074 [ # # ]: 0 : if (addr) {
4075 : 0 : *ptr = addr;
4076 : 0 : devres_add(dev, ptr);
4077 : : } else
4078 : 0 : devres_free(ptr);
4079 : :
4080 : : return addr;
4081 : : }
4082 : : EXPORT_SYMBOL(devm_pci_remap_cfgspace);
4083 : :
4084 : : /**
4085 : : * devm_pci_remap_cfg_resource - check, request region and ioremap cfg resource
4086 : : * @dev: generic device to handle the resource for
4087 : : * @res: configuration space resource to be handled
4088 : : *
4089 : : * Checks that a resource is a valid memory region, requests the memory
4090 : : * region and ioremaps with pci_remap_cfgspace() API that ensures the
4091 : : * proper PCI configuration space memory attributes are guaranteed.
4092 : : *
4093 : : * All operations are managed and will be undone on driver detach.
4094 : : *
4095 : : * Returns a pointer to the remapped memory or an ERR_PTR() encoded error code
4096 : : * on failure. Usage example::
4097 : : *
4098 : : * res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
4099 : : * base = devm_pci_remap_cfg_resource(&pdev->dev, res);
4100 : : * if (IS_ERR(base))
4101 : : * return PTR_ERR(base);
4102 : : */
4103 : 0 : void __iomem *devm_pci_remap_cfg_resource(struct device *dev,
4104 : : struct resource *res)
4105 : : {
4106 : 0 : resource_size_t size;
4107 : 0 : const char *name;
4108 : 0 : void __iomem *dest_ptr;
4109 : :
4110 [ # # ]: 0 : BUG_ON(!dev);
4111 : :
4112 [ # # # # ]: 0 : if (!res || resource_type(res) != IORESOURCE_MEM) {
4113 : 0 : dev_err(dev, "invalid resource\n");
4114 : 0 : return IOMEM_ERR_PTR(-EINVAL);
4115 : : }
4116 : :
4117 [ # # ]: 0 : size = resource_size(res);
4118 [ # # ]: 0 : name = res->name ?: dev_name(dev);
4119 : :
4120 [ # # ]: 0 : if (!devm_request_mem_region(dev, res->start, size, name)) {
4121 : 0 : dev_err(dev, "can't request region for resource %pR\n", res);
4122 : 0 : return IOMEM_ERR_PTR(-EBUSY);
4123 : : }
4124 : :
4125 : 0 : dest_ptr = devm_pci_remap_cfgspace(dev, res->start, size);
4126 [ # # ]: 0 : if (!dest_ptr) {
4127 : 0 : dev_err(dev, "ioremap failed for resource %pR\n", res);
4128 : 0 : devm_release_mem_region(dev, res->start, size);
4129 : 0 : dest_ptr = IOMEM_ERR_PTR(-ENOMEM);
4130 : : }
4131 : :
4132 : : return dest_ptr;
4133 : : }
4134 : : EXPORT_SYMBOL(devm_pci_remap_cfg_resource);
4135 : :
4136 : 60 : static void __pci_set_master(struct pci_dev *dev, bool enable)
4137 : : {
4138 : 60 : u16 old_cmd, cmd;
4139 : :
4140 : 60 : pci_read_config_word(dev, PCI_COMMAND, &old_cmd);
4141 [ + - ]: 60 : if (enable)
4142 : 60 : cmd = old_cmd | PCI_COMMAND_MASTER;
4143 : : else
4144 : 0 : cmd = old_cmd & ~PCI_COMMAND_MASTER;
4145 [ + - ]: 60 : if (cmd != old_cmd) {
4146 : 60 : pci_dbg(dev, "%s bus mastering\n",
4147 : : enable ? "enabling" : "disabling");
4148 : 60 : pci_write_config_word(dev, PCI_COMMAND, cmd);
4149 : : }
4150 : 60 : dev->is_busmaster = enable;
4151 : 60 : }
4152 : :
4153 : : /**
4154 : : * pcibios_setup - process "pci=" kernel boot arguments
4155 : : * @str: string used to pass in "pci=" kernel boot arguments
4156 : : *
4157 : : * Process kernel boot arguments. This is the default implementation.
4158 : : * Architecture specific implementations can override this as necessary.
4159 : : */
4160 : 0 : char * __weak __init pcibios_setup(char *str)
4161 : : {
4162 : 0 : return str;
4163 : : }
4164 : :
4165 : : /**
4166 : : * pcibios_set_master - enable PCI bus-mastering for device dev
4167 : : * @dev: the PCI device to enable
4168 : : *
4169 : : * Enables PCI bus-mastering for the device. This is the default
4170 : : * implementation. Architecture specific implementations can override
4171 : : * this if necessary.
4172 : : */
4173 : 60 : void __weak pcibios_set_master(struct pci_dev *dev)
4174 : : {
4175 : 60 : u8 lat;
4176 : :
4177 : : /* The latency timer doesn't apply to PCIe (either Type 0 or Type 1) */
4178 [ + - ]: 60 : if (pci_is_pcie(dev))
4179 : 0 : return;
4180 : :
4181 : 60 : pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4182 [ + - ]: 60 : if (lat < 16)
4183 : 60 : lat = (64 <= pcibios_max_latency) ? 64 : pcibios_max_latency;
4184 [ # # ]: 0 : else if (lat > pcibios_max_latency)
4185 : 0 : lat = pcibios_max_latency;
4186 : : else
4187 : : return;
4188 : :
4189 : 60 : pci_write_config_byte(dev, PCI_LATENCY_TIMER, lat);
4190 : : }
4191 : :
4192 : : /**
4193 : : * pci_set_master - enables bus-mastering for device dev
4194 : : * @dev: the PCI device to enable
4195 : : *
4196 : : * Enables bus-mastering on the device and calls pcibios_set_master()
4197 : : * to do the needed arch specific settings.
4198 : : */
4199 : 60 : void pci_set_master(struct pci_dev *dev)
4200 : : {
4201 : 60 : __pci_set_master(dev, true);
4202 : 60 : pcibios_set_master(dev);
4203 : 0 : }
4204 : : EXPORT_SYMBOL(pci_set_master);
4205 : :
4206 : : /**
4207 : : * pci_clear_master - disables bus-mastering for device dev
4208 : : * @dev: the PCI device to disable
4209 : : */
4210 : 0 : void pci_clear_master(struct pci_dev *dev)
4211 : : {
4212 : 0 : __pci_set_master(dev, false);
4213 : 0 : }
4214 : : EXPORT_SYMBOL(pci_clear_master);
4215 : :
4216 : : /**
4217 : : * pci_set_cacheline_size - ensure the CACHE_LINE_SIZE register is programmed
4218 : : * @dev: the PCI device for which MWI is to be enabled
4219 : : *
4220 : : * Helper function for pci_set_mwi.
4221 : : * Originally copied from drivers/net/acenic.c.
4222 : : * Copyright 1998-2001 by Jes Sorensen, <jes@trained-monkey.org>.
4223 : : *
4224 : : * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
4225 : : */
4226 : 0 : int pci_set_cacheline_size(struct pci_dev *dev)
4227 : : {
4228 : 0 : u8 cacheline_size;
4229 : :
4230 [ # # ]: 0 : if (!pci_cache_line_size)
4231 : : return -EINVAL;
4232 : :
4233 : : /* Validate current setting: the PCI_CACHE_LINE_SIZE must be
4234 : : equal to or multiple of the right value. */
4235 : 0 : pci_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &cacheline_size);
4236 [ # # ]: 0 : if (cacheline_size >= pci_cache_line_size &&
4237 [ # # ]: 0 : (cacheline_size % pci_cache_line_size) == 0)
4238 : : return 0;
4239 : :
4240 : : /* Write the correct value. */
4241 : 0 : pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, pci_cache_line_size);
4242 : : /* Read it back. */
4243 : 0 : pci_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &cacheline_size);
4244 [ # # ]: 0 : if (cacheline_size == pci_cache_line_size)
4245 : : return 0;
4246 : :
4247 : 0 : pci_info(dev, "cache line size of %d is not supported\n",
4248 : : pci_cache_line_size << 2);
4249 : :
4250 : 0 : return -EINVAL;
4251 : : }
4252 : : EXPORT_SYMBOL_GPL(pci_set_cacheline_size);
4253 : :
4254 : : /**
4255 : : * pci_set_mwi - enables memory-write-invalidate PCI transaction
4256 : : * @dev: the PCI device for which MWI is enabled
4257 : : *
4258 : : * Enables the Memory-Write-Invalidate transaction in %PCI_COMMAND.
4259 : : *
4260 : : * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
4261 : : */
4262 : 0 : int pci_set_mwi(struct pci_dev *dev)
4263 : : {
4264 : : #ifdef PCI_DISABLE_MWI
4265 : : return 0;
4266 : : #else
4267 : 0 : int rc;
4268 : 0 : u16 cmd;
4269 : :
4270 : 0 : rc = pci_set_cacheline_size(dev);
4271 [ # # ]: 0 : if (rc)
4272 : : return rc;
4273 : :
4274 : 0 : pci_read_config_word(dev, PCI_COMMAND, &cmd);
4275 [ # # ]: 0 : if (!(cmd & PCI_COMMAND_INVALIDATE)) {
4276 : 0 : pci_dbg(dev, "enabling Mem-Wr-Inval\n");
4277 : 0 : cmd |= PCI_COMMAND_INVALIDATE;
4278 : 0 : pci_write_config_word(dev, PCI_COMMAND, cmd);
4279 : : }
4280 : : return 0;
4281 : : #endif
4282 : : }
4283 : : EXPORT_SYMBOL(pci_set_mwi);
4284 : :
4285 : : /**
4286 : : * pcim_set_mwi - a device-managed pci_set_mwi()
4287 : : * @dev: the PCI device for which MWI is enabled
4288 : : *
4289 : : * Managed pci_set_mwi().
4290 : : *
4291 : : * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
4292 : : */
4293 : 0 : int pcim_set_mwi(struct pci_dev *dev)
4294 : : {
4295 : 0 : struct pci_devres *dr;
4296 : :
4297 [ # # ]: 0 : dr = find_pci_dr(dev);
4298 [ # # ]: 0 : if (!dr)
4299 : 0 : return -ENOMEM;
4300 : :
4301 : 0 : dr->mwi = 1;
4302 : 0 : return pci_set_mwi(dev);
4303 : : }
4304 : : EXPORT_SYMBOL(pcim_set_mwi);
4305 : :
4306 : : /**
4307 : : * pci_try_set_mwi - enables memory-write-invalidate PCI transaction
4308 : : * @dev: the PCI device for which MWI is enabled
4309 : : *
4310 : : * Enables the Memory-Write-Invalidate transaction in %PCI_COMMAND.
4311 : : * Callers are not required to check the return value.
4312 : : *
4313 : : * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
4314 : : */
4315 : 0 : int pci_try_set_mwi(struct pci_dev *dev)
4316 : : {
4317 : : #ifdef PCI_DISABLE_MWI
4318 : : return 0;
4319 : : #else
4320 : 0 : return pci_set_mwi(dev);
4321 : : #endif
4322 : : }
4323 : : EXPORT_SYMBOL(pci_try_set_mwi);
4324 : :
4325 : : /**
4326 : : * pci_clear_mwi - disables Memory-Write-Invalidate for device dev
4327 : : * @dev: the PCI device to disable
4328 : : *
4329 : : * Disables PCI Memory-Write-Invalidate transaction on the device
4330 : : */
4331 : 0 : void pci_clear_mwi(struct pci_dev *dev)
4332 : : {
4333 : : #ifndef PCI_DISABLE_MWI
4334 : 0 : u16 cmd;
4335 : :
4336 : 0 : pci_read_config_word(dev, PCI_COMMAND, &cmd);
4337 [ # # ]: 0 : if (cmd & PCI_COMMAND_INVALIDATE) {
4338 : 0 : cmd &= ~PCI_COMMAND_INVALIDATE;
4339 : 0 : pci_write_config_word(dev, PCI_COMMAND, cmd);
4340 : : }
4341 : : #endif
4342 : 0 : }
4343 : : EXPORT_SYMBOL(pci_clear_mwi);
4344 : :
4345 : : /**
4346 : : * pci_intx - enables/disables PCI INTx for device dev
4347 : : * @pdev: the PCI device to operate on
4348 : : * @enable: boolean: whether to enable or disable PCI INTx
4349 : : *
4350 : : * Enables/disables PCI INTx for device @pdev
4351 : : */
4352 : 0 : void pci_intx(struct pci_dev *pdev, int enable)
4353 : : {
4354 : 0 : u16 pci_command, new;
4355 : :
4356 : 0 : pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
4357 : :
4358 [ # # ]: 0 : if (enable)
4359 : 0 : new = pci_command & ~PCI_COMMAND_INTX_DISABLE;
4360 : : else
4361 : 0 : new = pci_command | PCI_COMMAND_INTX_DISABLE;
4362 : :
4363 [ # # ]: 0 : if (new != pci_command) {
4364 : 0 : struct pci_devres *dr;
4365 : :
4366 : 0 : pci_write_config_word(pdev, PCI_COMMAND, new);
4367 : :
4368 [ # # ]: 0 : dr = find_pci_dr(pdev);
4369 [ # # # # ]: 0 : if (dr && !dr->restore_intx) {
4370 : 0 : dr->restore_intx = 1;
4371 : 0 : dr->orig_intx = !enable;
4372 : : }
4373 : : }
4374 : 0 : }
4375 : : EXPORT_SYMBOL_GPL(pci_intx);
4376 : :
4377 : 0 : static bool pci_check_and_set_intx_mask(struct pci_dev *dev, bool mask)
4378 : : {
4379 : 0 : struct pci_bus *bus = dev->bus;
4380 : 0 : bool mask_updated = true;
4381 : 0 : u32 cmd_status_dword;
4382 : 0 : u16 origcmd, newcmd;
4383 : 0 : unsigned long flags;
4384 : 0 : bool irq_pending;
4385 : :
4386 : : /*
4387 : : * We do a single dword read to retrieve both command and status.
4388 : : * Document assumptions that make this possible.
4389 : : */
4390 : 0 : BUILD_BUG_ON(PCI_COMMAND % 4);
4391 : 0 : BUILD_BUG_ON(PCI_COMMAND + 2 != PCI_STATUS);
4392 : :
4393 : 0 : raw_spin_lock_irqsave(&pci_lock, flags);
4394 : :
4395 : 0 : bus->ops->read(bus, dev->devfn, PCI_COMMAND, 4, &cmd_status_dword);
4396 : :
4397 : 0 : irq_pending = (cmd_status_dword >> 16) & PCI_STATUS_INTERRUPT;
4398 : :
4399 : : /*
4400 : : * Check interrupt status register to see whether our device
4401 : : * triggered the interrupt (when masking) or the next IRQ is
4402 : : * already pending (when unmasking).
4403 : : */
4404 [ # # ]: 0 : if (mask != irq_pending) {
4405 : 0 : mask_updated = false;
4406 : 0 : goto done;
4407 : : }
4408 : :
4409 : 0 : origcmd = cmd_status_dword;
4410 : 0 : newcmd = origcmd & ~PCI_COMMAND_INTX_DISABLE;
4411 [ # # ]: 0 : if (mask)
4412 : 0 : newcmd |= PCI_COMMAND_INTX_DISABLE;
4413 [ # # ]: 0 : if (newcmd != origcmd)
4414 : 0 : bus->ops->write(bus, dev->devfn, PCI_COMMAND, 2, newcmd);
4415 : :
4416 : 0 : done:
4417 : 0 : raw_spin_unlock_irqrestore(&pci_lock, flags);
4418 : :
4419 : 0 : return mask_updated;
4420 : : }
4421 : :
4422 : : /**
4423 : : * pci_check_and_mask_intx - mask INTx on pending interrupt
4424 : : * @dev: the PCI device to operate on
4425 : : *
4426 : : * Check if the device dev has its INTx line asserted, mask it and return
4427 : : * true in that case. False is returned if no interrupt was pending.
4428 : : */
4429 : 0 : bool pci_check_and_mask_intx(struct pci_dev *dev)
4430 : : {
4431 : 0 : return pci_check_and_set_intx_mask(dev, true);
4432 : : }
4433 : : EXPORT_SYMBOL_GPL(pci_check_and_mask_intx);
4434 : :
4435 : : /**
4436 : : * pci_check_and_unmask_intx - unmask INTx if no interrupt is pending
4437 : : * @dev: the PCI device to operate on
4438 : : *
4439 : : * Check if the device dev has its INTx line asserted, unmask it if not and
4440 : : * return true. False is returned and the mask remains active if there was
4441 : : * still an interrupt pending.
4442 : : */
4443 : 0 : bool pci_check_and_unmask_intx(struct pci_dev *dev)
4444 : : {
4445 : 0 : return pci_check_and_set_intx_mask(dev, false);
4446 : : }
4447 : : EXPORT_SYMBOL_GPL(pci_check_and_unmask_intx);
4448 : :
4449 : : /**
4450 : : * pci_wait_for_pending_transaction - wait for pending transaction
4451 : : * @dev: the PCI device to operate on
4452 : : *
4453 : : * Return 0 if transaction is pending 1 otherwise.
4454 : : */
4455 : 0 : int pci_wait_for_pending_transaction(struct pci_dev *dev)
4456 : : {
4457 [ # # ]: 0 : if (!pci_is_pcie(dev))
4458 : : return 1;
4459 : :
4460 : 0 : return pci_wait_for_pending(dev, pci_pcie_cap(dev) + PCI_EXP_DEVSTA,
4461 : : PCI_EXP_DEVSTA_TRPND);
4462 : : }
4463 : : EXPORT_SYMBOL(pci_wait_for_pending_transaction);
4464 : :
4465 : : /**
4466 : : * pcie_has_flr - check if a device supports function level resets
4467 : : * @dev: device to check
4468 : : *
4469 : : * Returns true if the device advertises support for PCIe function level
4470 : : * resets.
4471 : : */
4472 : 210 : bool pcie_has_flr(struct pci_dev *dev)
4473 : : {
4474 : 210 : u32 cap;
4475 : :
4476 [ + - ]: 210 : if (dev->dev_flags & PCI_DEV_FLAGS_NO_FLR_RESET)
4477 : : return false;
4478 : :
4479 : 210 : pcie_capability_read_dword(dev, PCI_EXP_DEVCAP, &cap);
4480 : 210 : return cap & PCI_EXP_DEVCAP_FLR;
4481 : : }
4482 : : EXPORT_SYMBOL_GPL(pcie_has_flr);
4483 : :
4484 : : /**
4485 : : * pcie_flr - initiate a PCIe function level reset
4486 : : * @dev: device to reset
4487 : : *
4488 : : * Initiate a function level reset on @dev. The caller should ensure the
4489 : : * device supports FLR before calling this function, e.g. by using the
4490 : : * pcie_has_flr() helper.
4491 : : */
4492 : 0 : int pcie_flr(struct pci_dev *dev)
4493 : : {
4494 [ # # # # ]: 0 : if (!pci_wait_for_pending_transaction(dev))
4495 : 0 : pci_err(dev, "timed out waiting for pending transaction; performing function level reset anyway\n");
4496 : :
4497 : 0 : pcie_capability_set_word(dev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_BCR_FLR);
4498 : :
4499 [ # # ]: 0 : if (dev->imm_ready)
4500 : : return 0;
4501 : :
4502 : : /*
4503 : : * Per PCIe r4.0, sec 6.6.2, a device must complete an FLR within
4504 : : * 100ms, but may silently discard requests while the FLR is in
4505 : : * progress. Wait 100ms before trying to access the device.
4506 : : */
4507 : 0 : msleep(100);
4508 : :
4509 : 0 : return pci_dev_wait(dev, "FLR", PCIE_RESET_READY_POLL_MS);
4510 : : }
4511 : : EXPORT_SYMBOL_GPL(pcie_flr);
4512 : :
4513 : 210 : static int pci_af_flr(struct pci_dev *dev, int probe)
4514 : : {
4515 : 210 : int pos;
4516 : 210 : u8 cap;
4517 : :
4518 : 210 : pos = pci_find_capability(dev, PCI_CAP_ID_AF);
4519 [ - + ]: 210 : if (!pos)
4520 : : return -ENOTTY;
4521 : :
4522 [ # # ]: 0 : if (dev->dev_flags & PCI_DEV_FLAGS_NO_FLR_RESET)
4523 : : return -ENOTTY;
4524 : :
4525 : 0 : pci_read_config_byte(dev, pos + PCI_AF_CAP, &cap);
4526 [ # # ]: 0 : if (!(cap & PCI_AF_CAP_TP) || !(cap & PCI_AF_CAP_FLR))
4527 : : return -ENOTTY;
4528 : :
4529 [ # # ]: 0 : if (probe)
4530 : : return 0;
4531 : :
4532 : : /*
4533 : : * Wait for Transaction Pending bit to clear. A word-aligned test
4534 : : * is used, so we use the control offset rather than status and shift
4535 : : * the test bit to match.
4536 : : */
4537 [ # # ]: 0 : if (!pci_wait_for_pending(dev, pos + PCI_AF_CTRL,
4538 : : PCI_AF_STATUS_TP << 8))
4539 : 0 : pci_err(dev, "timed out waiting for pending transaction; performing AF function level reset anyway\n");
4540 : :
4541 : 0 : pci_write_config_byte(dev, pos + PCI_AF_CTRL, PCI_AF_CTRL_FLR);
4542 : :
4543 [ # # ]: 0 : if (dev->imm_ready)
4544 : : return 0;
4545 : :
4546 : : /*
4547 : : * Per Advanced Capabilities for Conventional PCI ECN, 13 April 2006,
4548 : : * updated 27 July 2006; a device must complete an FLR within
4549 : : * 100ms, but may silently discard requests while the FLR is in
4550 : : * progress. Wait 100ms before trying to access the device.
4551 : : */
4552 : 0 : msleep(100);
4553 : :
4554 : 0 : return pci_dev_wait(dev, "AF_FLR", PCIE_RESET_READY_POLL_MS);
4555 : : }
4556 : :
4557 : : /**
4558 : : * pci_pm_reset - Put device into PCI_D3 and back into PCI_D0.
4559 : : * @dev: Device to reset.
4560 : : * @probe: If set, only check if the device can be reset this way.
4561 : : *
4562 : : * If @dev supports native PCI PM and its PCI_PM_CTRL_NO_SOFT_RESET flag is
4563 : : * unset, it will be reinitialized internally when going from PCI_D3hot to
4564 : : * PCI_D0. If that's the case and the device is not in a low-power state
4565 : : * already, force it into PCI_D3hot and back to PCI_D0, causing it to be reset.
4566 : : *
4567 : : * NOTE: This causes the caller to sleep for twice the device power transition
4568 : : * cooldown period, which for the D0->D3hot and D3hot->D0 transitions is 10 ms
4569 : : * by default (i.e. unless the @dev's d3_delay field has a different value).
4570 : : * Moreover, only devices in D0 can be reset by this function.
4571 : : */
4572 : 210 : static int pci_pm_reset(struct pci_dev *dev, int probe)
4573 : : {
4574 : 210 : u16 csr;
4575 : :
4576 [ + + + - ]: 210 : if (!dev->pm_cap || dev->dev_flags & PCI_DEV_FLAGS_NO_PM_RESET)
4577 : : return -ENOTTY;
4578 : :
4579 : 30 : pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &csr);
4580 [ + - ]: 30 : if (csr & PCI_PM_CTRL_NO_SOFT_RESET)
4581 : : return -ENOTTY;
4582 : :
4583 [ - + ]: 30 : if (probe)
4584 : : return 0;
4585 : :
4586 [ # # ]: 0 : if (dev->current_state != PCI_D0)
4587 : : return -EINVAL;
4588 : :
4589 : 0 : csr &= ~PCI_PM_CTRL_STATE_MASK;
4590 : 0 : csr |= PCI_D3hot;
4591 : 0 : pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, csr);
4592 [ # # ]: 0 : pci_dev_d3_sleep(dev);
4593 : :
4594 : 0 : csr &= ~PCI_PM_CTRL_STATE_MASK;
4595 : 0 : csr |= PCI_D0;
4596 : 0 : pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, csr);
4597 [ # # ]: 0 : pci_dev_d3_sleep(dev);
4598 : :
4599 : 0 : return pci_dev_wait(dev, "PM D3hot->D0", PCIE_RESET_READY_POLL_MS);
4600 : : }
4601 : :
4602 : : /**
4603 : : * pcie_wait_for_link_delay - Wait until link is active or inactive
4604 : : * @pdev: Bridge device
4605 : : * @active: waiting for active or inactive?
4606 : : * @delay: Delay to wait after link has become active (in ms)
4607 : : *
4608 : : * Use this to wait till link becomes active or inactive.
4609 : : */
4610 : 0 : static bool pcie_wait_for_link_delay(struct pci_dev *pdev, bool active,
4611 : : int delay)
4612 : : {
4613 : 0 : int timeout = 1000;
4614 : 0 : bool ret;
4615 : 0 : u16 lnk_status;
4616 : :
4617 : : /*
4618 : : * Some controllers might not implement link active reporting. In this
4619 : : * case, we wait for 1000 + 100 ms.
4620 : : */
4621 [ # # ]: 0 : if (!pdev->link_active_reporting) {
4622 : 0 : msleep(1100);
4623 : 0 : return true;
4624 : : }
4625 : :
4626 : : /*
4627 : : * PCIe r4.0 sec 6.6.1, a component must enter LTSSM Detect within 20ms,
4628 : : * after which we should expect an link active if the reset was
4629 : : * successful. If so, software must wait a minimum 100ms before sending
4630 : : * configuration requests to devices downstream this port.
4631 : : *
4632 : : * If the link fails to activate, either the device was physically
4633 : : * removed or the link is permanently failed.
4634 : : */
4635 [ # # ]: 0 : if (active)
4636 : 0 : msleep(20);
4637 : 0 : for (;;) {
4638 : 0 : pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status);
4639 : 0 : ret = !!(lnk_status & PCI_EXP_LNKSTA_DLLLA);
4640 [ # # ]: 0 : if (ret == active)
4641 : : break;
4642 [ # # ]: 0 : if (timeout <= 0)
4643 : : break;
4644 : 0 : msleep(10);
4645 : 0 : timeout -= 10;
4646 : : }
4647 [ # # ]: 0 : if (active && ret)
4648 : 0 : msleep(delay);
4649 [ # # ]: 0 : else if (ret != active)
4650 [ # # ]: 0 : pci_info(pdev, "Data Link Layer Link Active not %s in 1000 msec\n",
4651 : : active ? "set" : "cleared");
4652 : 0 : return ret == active;
4653 : : }
4654 : :
4655 : : /**
4656 : : * pcie_wait_for_link - Wait until link is active or inactive
4657 : : * @pdev: Bridge device
4658 : : * @active: waiting for active or inactive?
4659 : : *
4660 : : * Use this to wait till link becomes active or inactive.
4661 : : */
4662 : 0 : bool pcie_wait_for_link(struct pci_dev *pdev, bool active)
4663 : : {
4664 : 0 : return pcie_wait_for_link_delay(pdev, active, 100);
4665 : : }
4666 : :
4667 : : /*
4668 : : * Find maximum D3cold delay required by all the devices on the bus. The
4669 : : * spec says 100 ms, but firmware can lower it and we allow drivers to
4670 : : * increase it as well.
4671 : : *
4672 : : * Called with @pci_bus_sem locked for reading.
4673 : : */
4674 : 0 : static int pci_bus_max_d3cold_delay(const struct pci_bus *bus)
4675 : : {
4676 : 0 : const struct pci_dev *pdev;
4677 : 0 : int min_delay = 100;
4678 : 0 : int max_delay = 0;
4679 : :
4680 [ # # ]: 0 : list_for_each_entry(pdev, &bus->devices, bus_list) {
4681 [ # # ]: 0 : if (pdev->d3cold_delay < min_delay)
4682 : 0 : min_delay = pdev->d3cold_delay;
4683 [ # # ]: 0 : if (pdev->d3cold_delay > max_delay)
4684 : 0 : max_delay = pdev->d3cold_delay;
4685 : : }
4686 : :
4687 : 0 : return max(min_delay, max_delay);
4688 : : }
4689 : :
4690 : : /**
4691 : : * pci_bridge_wait_for_secondary_bus - Wait for secondary bus to be accessible
4692 : : * @dev: PCI bridge
4693 : : *
4694 : : * Handle necessary delays before access to the devices on the secondary
4695 : : * side of the bridge are permitted after D3cold to D0 transition.
4696 : : *
4697 : : * For PCIe this means the delays in PCIe 5.0 section 6.6.1. For
4698 : : * conventional PCI it means Tpvrh + Trhfa specified in PCI 3.0 section
4699 : : * 4.3.2.
4700 : : */
4701 : 0 : void pci_bridge_wait_for_secondary_bus(struct pci_dev *dev)
4702 : : {
4703 : 0 : struct pci_dev *child;
4704 : 0 : int delay;
4705 : :
4706 [ # # ]: 0 : if (pci_dev_is_disconnected(dev))
4707 : : return;
4708 : :
4709 [ # # # # ]: 0 : if (!pci_is_bridge(dev) || !dev->bridge_d3)
4710 : : return;
4711 : :
4712 : 0 : down_read(&pci_bus_sem);
4713 : :
4714 : : /*
4715 : : * We only deal with devices that are present currently on the bus.
4716 : : * For any hot-added devices the access delay is handled in pciehp
4717 : : * board_added(). In case of ACPI hotplug the firmware is expected
4718 : : * to configure the devices before OS is notified.
4719 : : */
4720 [ # # # # ]: 0 : if (!dev->subordinate || list_empty(&dev->subordinate->devices)) {
4721 : 0 : up_read(&pci_bus_sem);
4722 : 0 : return;
4723 : : }
4724 : :
4725 : : /* Take d3cold_delay requirements into account */
4726 : 0 : delay = pci_bus_max_d3cold_delay(dev->subordinate);
4727 [ # # ]: 0 : if (!delay) {
4728 : 0 : up_read(&pci_bus_sem);
4729 : 0 : return;
4730 : : }
4731 : :
4732 : 0 : child = list_first_entry(&dev->subordinate->devices, struct pci_dev,
4733 : : bus_list);
4734 : 0 : up_read(&pci_bus_sem);
4735 : :
4736 : : /*
4737 : : * Conventional PCI and PCI-X we need to wait Tpvrh + Trhfa before
4738 : : * accessing the device after reset (that is 1000 ms + 100 ms). In
4739 : : * practice this should not be needed because we don't do power
4740 : : * management for them (see pci_bridge_d3_possible()).
4741 : : */
4742 [ # # ]: 0 : if (!pci_is_pcie(dev)) {
4743 : 0 : pci_dbg(dev, "waiting %d ms for secondary bus\n", 1000 + delay);
4744 : 0 : msleep(1000 + delay);
4745 : 0 : return;
4746 : : }
4747 : :
4748 : : /*
4749 : : * For PCIe downstream and root ports that do not support speeds
4750 : : * greater than 5 GT/s need to wait minimum 100 ms. For higher
4751 : : * speeds (gen3) we need to wait first for the data link layer to
4752 : : * become active.
4753 : : *
4754 : : * However, 100 ms is the minimum and the PCIe spec says the
4755 : : * software must allow at least 1s before it can determine that the
4756 : : * device that did not respond is a broken device. There is
4757 : : * evidence that 100 ms is not always enough, for example certain
4758 : : * Titan Ridge xHCI controller does not always respond to
4759 : : * configuration requests if we only wait for 100 ms (see
4760 : : * https://bugzilla.kernel.org/show_bug.cgi?id=203885).
4761 : : *
4762 : : * Therefore we wait for 100 ms and check for the device presence.
4763 : : * If it is still not present give it an additional 100 ms.
4764 : : */
4765 [ # # # # ]: 0 : if (!pcie_downstream_port(dev))
4766 : : return;
4767 : :
4768 [ # # ]: 0 : if (pcie_get_speed_cap(dev) <= PCIE_SPEED_5_0GT) {
4769 : 0 : pci_dbg(dev, "waiting %d ms for downstream link\n", delay);
4770 : 0 : msleep(delay);
4771 : : } else {
4772 : 0 : pci_dbg(dev, "waiting %d ms for downstream link, after activation\n",
4773 : : delay);
4774 [ # # ]: 0 : if (!pcie_wait_for_link_delay(dev, true, delay)) {
4775 : : /* Did not train, no need to wait any further */
4776 : : return;
4777 : : }
4778 : : }
4779 : :
4780 [ # # ]: 0 : if (!pci_device_is_present(child)) {
4781 : 0 : pci_dbg(child, "waiting additional %d ms to become accessible\n", delay);
4782 : 0 : msleep(delay);
4783 : : }
4784 : : }
4785 : :
4786 : 0 : void pci_reset_secondary_bus(struct pci_dev *dev)
4787 : : {
4788 : 0 : u16 ctrl;
4789 : :
4790 : 0 : pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &ctrl);
4791 : 0 : ctrl |= PCI_BRIDGE_CTL_BUS_RESET;
4792 : 0 : pci_write_config_word(dev, PCI_BRIDGE_CONTROL, ctrl);
4793 : :
4794 : : /*
4795 : : * PCI spec v3.0 7.6.4.2 requires minimum Trst of 1ms. Double
4796 : : * this to 2ms to ensure that we meet the minimum requirement.
4797 : : */
4798 : 0 : msleep(2);
4799 : :
4800 : 0 : ctrl &= ~PCI_BRIDGE_CTL_BUS_RESET;
4801 : 0 : pci_write_config_word(dev, PCI_BRIDGE_CONTROL, ctrl);
4802 : :
4803 : : /*
4804 : : * Trhfa for conventional PCI is 2^25 clock cycles.
4805 : : * Assuming a minimum 33MHz clock this results in a 1s
4806 : : * delay before we can consider subordinate devices to
4807 : : * be re-initialized. PCIe has some ways to shorten this,
4808 : : * but we don't make use of them yet.
4809 : : */
4810 : 0 : ssleep(1);
4811 : 0 : }
4812 : :
4813 : 0 : void __weak pcibios_reset_secondary_bus(struct pci_dev *dev)
4814 : : {
4815 : 0 : pci_reset_secondary_bus(dev);
4816 : 0 : }
4817 : :
4818 : : /**
4819 : : * pci_bridge_secondary_bus_reset - Reset the secondary bus on a PCI bridge.
4820 : : * @dev: Bridge device
4821 : : *
4822 : : * Use the bridge control register to assert reset on the secondary bus.
4823 : : * Devices on the secondary bus are left in power-on state.
4824 : : */
4825 : 0 : int pci_bridge_secondary_bus_reset(struct pci_dev *dev)
4826 : : {
4827 : 0 : pcibios_reset_secondary_bus(dev);
4828 : :
4829 : 0 : return pci_dev_wait(dev, "bus reset", PCIE_RESET_READY_POLL_MS);
4830 : : }
4831 : : EXPORT_SYMBOL_GPL(pci_bridge_secondary_bus_reset);
4832 : :
4833 : 180 : static int pci_parent_bus_reset(struct pci_dev *dev, int probe)
4834 : : {
4835 : 180 : struct pci_dev *pdev;
4836 : :
4837 [ - + - - ]: 180 : if (pci_is_root_bus(dev->bus) || dev->subordinate ||
4838 [ # # # # ]: 0 : !dev->bus->self || dev->dev_flags & PCI_DEV_FLAGS_NO_BUS_RESET)
4839 : : return -ENOTTY;
4840 : :
4841 [ # # ]: 0 : list_for_each_entry(pdev, &dev->bus->devices, bus_list)
4842 [ # # ]: 0 : if (pdev != dev)
4843 : : return -ENOTTY;
4844 : :
4845 [ # # ]: 0 : if (probe)
4846 : : return 0;
4847 : :
4848 : 0 : return pci_bridge_secondary_bus_reset(dev->bus->self);
4849 : : }
4850 : :
4851 : 30 : static int pci_reset_hotplug_slot(struct hotplug_slot *hotplug, int probe)
4852 : : {
4853 : 30 : int rc = -ENOTTY;
4854 : :
4855 [ + - - + ]: 30 : if (!hotplug || !try_module_get(hotplug->owner))
4856 : 0 : return rc;
4857 : :
4858 [ - + ]: 30 : if (hotplug->ops->reset_slot)
4859 : 0 : rc = hotplug->ops->reset_slot(hotplug, probe);
4860 : :
4861 : 30 : module_put(hotplug->owner);
4862 : :
4863 : 30 : return rc;
4864 : : }
4865 : :
4866 : 180 : static int pci_dev_reset_slot_function(struct pci_dev *dev, int probe)
4867 : : {
4868 : 180 : struct pci_dev *pdev;
4869 : :
4870 [ + - + + ]: 180 : if (dev->subordinate || !dev->slot ||
4871 [ + - ]: 30 : dev->dev_flags & PCI_DEV_FLAGS_NO_BUS_RESET)
4872 : : return -ENOTTY;
4873 : :
4874 [ + + ]: 210 : list_for_each_entry(pdev, &dev->bus->devices, bus_list)
4875 [ + - + - ]: 180 : if (pdev != dev && pdev->slot == dev->slot)
4876 : : return -ENOTTY;
4877 : :
4878 : 30 : return pci_reset_hotplug_slot(dev->slot->hotplug, probe);
4879 : : }
4880 : :
4881 : 0 : static void pci_dev_lock(struct pci_dev *dev)
4882 : : {
4883 : 0 : pci_cfg_access_lock(dev);
4884 : : /* block PM suspend, driver probe, etc. */
4885 : 0 : device_lock(&dev->dev);
4886 : : }
4887 : :
4888 : : /* Return 1 on successful lock, 0 on contention */
4889 : 0 : static int pci_dev_trylock(struct pci_dev *dev)
4890 : : {
4891 [ # # ]: 0 : if (pci_cfg_access_trylock(dev)) {
4892 [ # # ]: 0 : if (device_trylock(&dev->dev))
4893 : : return 1;
4894 : 0 : pci_cfg_access_unlock(dev);
4895 : : }
4896 : :
4897 : : return 0;
4898 : : }
4899 : :
4900 : 0 : static void pci_dev_unlock(struct pci_dev *dev)
4901 : : {
4902 : 0 : device_unlock(&dev->dev);
4903 : 0 : pci_cfg_access_unlock(dev);
4904 : 0 : }
4905 : :
4906 : 0 : static void pci_dev_save_and_disable(struct pci_dev *dev)
4907 : : {
4908 : 0 : const struct pci_error_handlers *err_handler =
4909 [ # # ]: 0 : dev->driver ? dev->driver->err_handler : NULL;
4910 : :
4911 : : /*
4912 : : * dev->driver->err_handler->reset_prepare() is protected against
4913 : : * races with ->remove() by the device lock, which must be held by
4914 : : * the caller.
4915 : : */
4916 [ # # # # ]: 0 : if (err_handler && err_handler->reset_prepare)
4917 : 0 : err_handler->reset_prepare(dev);
4918 : :
4919 : : /*
4920 : : * Wake-up device prior to save. PM registers default to D0 after
4921 : : * reset and a simple register restore doesn't reliably return
4922 : : * to a non-D0 state anyway.
4923 : : */
4924 : 0 : pci_set_power_state(dev, PCI_D0);
4925 : :
4926 : 0 : pci_save_state(dev);
4927 : : /*
4928 : : * Disable the device by clearing the Command register, except for
4929 : : * INTx-disable which is set. This not only disables MMIO and I/O port
4930 : : * BARs, but also prevents the device from being Bus Master, preventing
4931 : : * DMA from the device including MSI/MSI-X interrupts. For PCI 2.3
4932 : : * compliant devices, INTx-disable prevents legacy interrupts.
4933 : : */
4934 : 0 : pci_write_config_word(dev, PCI_COMMAND, PCI_COMMAND_INTX_DISABLE);
4935 : 0 : }
4936 : :
4937 : 0 : static void pci_dev_restore(struct pci_dev *dev)
4938 : : {
4939 : 0 : const struct pci_error_handlers *err_handler =
4940 [ # # ]: 0 : dev->driver ? dev->driver->err_handler : NULL;
4941 : :
4942 : 0 : pci_restore_state(dev);
4943 : :
4944 : : /*
4945 : : * dev->driver->err_handler->reset_done() is protected against
4946 : : * races with ->remove() by the device lock, which must be held by
4947 : : * the caller.
4948 : : */
4949 [ # # # # ]: 0 : if (err_handler && err_handler->reset_done)
4950 : 0 : err_handler->reset_done(dev);
4951 : 0 : }
4952 : :
4953 : : /**
4954 : : * __pci_reset_function_locked - reset a PCI device function while holding
4955 : : * the @dev mutex lock.
4956 : : * @dev: PCI device to reset
4957 : : *
4958 : : * Some devices allow an individual function to be reset without affecting
4959 : : * other functions in the same device. The PCI device must be responsive
4960 : : * to PCI config space in order to use this function.
4961 : : *
4962 : : * The device function is presumed to be unused and the caller is holding
4963 : : * the device mutex lock when this function is called.
4964 : : *
4965 : : * Resetting the device will make the contents of PCI configuration space
4966 : : * random, so any caller of this must be prepared to reinitialise the
4967 : : * device including MSI, bus mastering, BARs, decoding IO and memory spaces,
4968 : : * etc.
4969 : : *
4970 : : * Returns 0 if the device function was successfully reset or negative if the
4971 : : * device doesn't support resetting a single function.
4972 : : */
4973 : 0 : int __pci_reset_function_locked(struct pci_dev *dev)
4974 : : {
4975 : 0 : int rc;
4976 : :
4977 : 0 : might_sleep();
4978 : :
4979 : : /*
4980 : : * A reset method returns -ENOTTY if it doesn't support this device
4981 : : * and we should try the next method.
4982 : : *
4983 : : * If it returns 0 (success), we're finished. If it returns any
4984 : : * other error, we're also finished: this indicates that further
4985 : : * reset mechanisms might be broken on the device.
4986 : : */
4987 : 0 : rc = pci_dev_specific_reset(dev, 0);
4988 [ # # ]: 0 : if (rc != -ENOTTY)
4989 : : return rc;
4990 [ # # ]: 0 : if (pcie_has_flr(dev)) {
4991 : 0 : rc = pcie_flr(dev);
4992 [ # # ]: 0 : if (rc != -ENOTTY)
4993 : : return rc;
4994 : : }
4995 : 0 : rc = pci_af_flr(dev, 0);
4996 [ # # ]: 0 : if (rc != -ENOTTY)
4997 : : return rc;
4998 : 0 : rc = pci_pm_reset(dev, 0);
4999 [ # # ]: 0 : if (rc != -ENOTTY)
5000 : : return rc;
5001 : 0 : rc = pci_dev_reset_slot_function(dev, 0);
5002 [ # # ]: 0 : if (rc != -ENOTTY)
5003 : : return rc;
5004 : 0 : return pci_parent_bus_reset(dev, 0);
5005 : : }
5006 : : EXPORT_SYMBOL_GPL(__pci_reset_function_locked);
5007 : :
5008 : : /**
5009 : : * pci_probe_reset_function - check whether the device can be safely reset
5010 : : * @dev: PCI device to reset
5011 : : *
5012 : : * Some devices allow an individual function to be reset without affecting
5013 : : * other functions in the same device. The PCI device must be responsive
5014 : : * to PCI config space in order to use this function.
5015 : : *
5016 : : * Returns 0 if the device function can be reset or negative if the
5017 : : * device doesn't support resetting a single function.
5018 : : */
5019 : 210 : int pci_probe_reset_function(struct pci_dev *dev)
5020 : : {
5021 : 210 : int rc;
5022 : :
5023 : 210 : might_sleep();
5024 : :
5025 : 210 : rc = pci_dev_specific_reset(dev, 1);
5026 [ + - ]: 210 : if (rc != -ENOTTY)
5027 : : return rc;
5028 [ + - ]: 210 : if (pcie_has_flr(dev))
5029 : : return 0;
5030 : 210 : rc = pci_af_flr(dev, 1);
5031 [ + - ]: 210 : if (rc != -ENOTTY)
5032 : : return rc;
5033 : 210 : rc = pci_pm_reset(dev, 1);
5034 [ + + ]: 210 : if (rc != -ENOTTY)
5035 : : return rc;
5036 : 180 : rc = pci_dev_reset_slot_function(dev, 1);
5037 [ + - ]: 180 : if (rc != -ENOTTY)
5038 : : return rc;
5039 : :
5040 : 180 : return pci_parent_bus_reset(dev, 1);
5041 : : }
5042 : :
5043 : : /**
5044 : : * pci_reset_function - quiesce and reset a PCI device function
5045 : : * @dev: PCI device to reset
5046 : : *
5047 : : * Some devices allow an individual function to be reset without affecting
5048 : : * other functions in the same device. The PCI device must be responsive
5049 : : * to PCI config space in order to use this function.
5050 : : *
5051 : : * This function does not just reset the PCI portion of a device, but
5052 : : * clears all the state associated with the device. This function differs
5053 : : * from __pci_reset_function_locked() in that it saves and restores device state
5054 : : * over the reset and takes the PCI device lock.
5055 : : *
5056 : : * Returns 0 if the device function was successfully reset or negative if the
5057 : : * device doesn't support resetting a single function.
5058 : : */
5059 : 0 : int pci_reset_function(struct pci_dev *dev)
5060 : : {
5061 : 0 : int rc;
5062 : :
5063 [ # # ]: 0 : if (!dev->reset_fn)
5064 : : return -ENOTTY;
5065 : :
5066 : 0 : pci_dev_lock(dev);
5067 : 0 : pci_dev_save_and_disable(dev);
5068 : :
5069 : 0 : rc = __pci_reset_function_locked(dev);
5070 : :
5071 : 0 : pci_dev_restore(dev);
5072 : 0 : pci_dev_unlock(dev);
5073 : :
5074 : 0 : return rc;
5075 : : }
5076 : : EXPORT_SYMBOL_GPL(pci_reset_function);
5077 : :
5078 : : /**
5079 : : * pci_reset_function_locked - quiesce and reset a PCI device function
5080 : : * @dev: PCI device to reset
5081 : : *
5082 : : * Some devices allow an individual function to be reset without affecting
5083 : : * other functions in the same device. The PCI device must be responsive
5084 : : * to PCI config space in order to use this function.
5085 : : *
5086 : : * This function does not just reset the PCI portion of a device, but
5087 : : * clears all the state associated with the device. This function differs
5088 : : * from __pci_reset_function_locked() in that it saves and restores device state
5089 : : * over the reset. It also differs from pci_reset_function() in that it
5090 : : * requires the PCI device lock to be held.
5091 : : *
5092 : : * Returns 0 if the device function was successfully reset or negative if the
5093 : : * device doesn't support resetting a single function.
5094 : : */
5095 : 0 : int pci_reset_function_locked(struct pci_dev *dev)
5096 : : {
5097 : 0 : int rc;
5098 : :
5099 [ # # ]: 0 : if (!dev->reset_fn)
5100 : : return -ENOTTY;
5101 : :
5102 : 0 : pci_dev_save_and_disable(dev);
5103 : :
5104 : 0 : rc = __pci_reset_function_locked(dev);
5105 : :
5106 : 0 : pci_dev_restore(dev);
5107 : :
5108 : 0 : return rc;
5109 : : }
5110 : : EXPORT_SYMBOL_GPL(pci_reset_function_locked);
5111 : :
5112 : : /**
5113 : : * pci_try_reset_function - quiesce and reset a PCI device function
5114 : : * @dev: PCI device to reset
5115 : : *
5116 : : * Same as above, except return -EAGAIN if unable to lock device.
5117 : : */
5118 : 0 : int pci_try_reset_function(struct pci_dev *dev)
5119 : : {
5120 : 0 : int rc;
5121 : :
5122 [ # # ]: 0 : if (!dev->reset_fn)
5123 : : return -ENOTTY;
5124 : :
5125 [ # # ]: 0 : if (!pci_dev_trylock(dev))
5126 : : return -EAGAIN;
5127 : :
5128 : 0 : pci_dev_save_and_disable(dev);
5129 : 0 : rc = __pci_reset_function_locked(dev);
5130 : 0 : pci_dev_restore(dev);
5131 : 0 : pci_dev_unlock(dev);
5132 : :
5133 : 0 : return rc;
5134 : : }
5135 : : EXPORT_SYMBOL_GPL(pci_try_reset_function);
5136 : :
5137 : : /* Do any devices on or below this bus prevent a bus reset? */
5138 : 0 : static bool pci_bus_resetable(struct pci_bus *bus)
5139 : : {
5140 : 0 : struct pci_dev *dev;
5141 : :
5142 : :
5143 [ # # # # ]: 0 : if (bus->self && (bus->self->dev_flags & PCI_DEV_FLAGS_NO_BUS_RESET))
5144 : : return false;
5145 : :
5146 [ # # ]: 0 : list_for_each_entry(dev, &bus->devices, bus_list) {
5147 [ # # ]: 0 : if (dev->dev_flags & PCI_DEV_FLAGS_NO_BUS_RESET ||
5148 [ # # # # ]: 0 : (dev->subordinate && !pci_bus_resetable(dev->subordinate)))
5149 : 0 : return false;
5150 : : }
5151 : :
5152 : : return true;
5153 : : }
5154 : :
5155 : : /* Lock devices from the top of the tree down */
5156 : 0 : static void pci_bus_lock(struct pci_bus *bus)
5157 : : {
5158 : 0 : struct pci_dev *dev;
5159 : :
5160 [ # # ]: 0 : list_for_each_entry(dev, &bus->devices, bus_list) {
5161 : 0 : pci_dev_lock(dev);
5162 [ # # ]: 0 : if (dev->subordinate)
5163 : 0 : pci_bus_lock(dev->subordinate);
5164 : : }
5165 : 0 : }
5166 : :
5167 : : /* Unlock devices from the bottom of the tree up */
5168 : 0 : static void pci_bus_unlock(struct pci_bus *bus)
5169 : : {
5170 : 0 : struct pci_dev *dev;
5171 : :
5172 [ # # ]: 0 : list_for_each_entry(dev, &bus->devices, bus_list) {
5173 [ # # ]: 0 : if (dev->subordinate)
5174 : 0 : pci_bus_unlock(dev->subordinate);
5175 : 0 : pci_dev_unlock(dev);
5176 : : }
5177 : 0 : }
5178 : :
5179 : : /* Return 1 on successful lock, 0 on contention */
5180 : 0 : static int pci_bus_trylock(struct pci_bus *bus)
5181 : : {
5182 : 0 : struct pci_dev *dev;
5183 : :
5184 [ # # ]: 0 : list_for_each_entry(dev, &bus->devices, bus_list) {
5185 [ # # ]: 0 : if (!pci_dev_trylock(dev))
5186 : 0 : goto unlock;
5187 [ # # ]: 0 : if (dev->subordinate) {
5188 [ # # ]: 0 : if (!pci_bus_trylock(dev->subordinate)) {
5189 : 0 : pci_dev_unlock(dev);
5190 : 0 : goto unlock;
5191 : : }
5192 : : }
5193 : : }
5194 : : return 1;
5195 : :
5196 : 0 : unlock:
5197 [ # # ]: 0 : list_for_each_entry_continue_reverse(dev, &bus->devices, bus_list) {
5198 [ # # ]: 0 : if (dev->subordinate)
5199 : 0 : pci_bus_unlock(dev->subordinate);
5200 : 0 : pci_dev_unlock(dev);
5201 : : }
5202 : : return 0;
5203 : : }
5204 : :
5205 : : /* Do any devices on or below this slot prevent a bus reset? */
5206 : 0 : static bool pci_slot_resetable(struct pci_slot *slot)
5207 : : {
5208 : 0 : struct pci_dev *dev;
5209 : :
5210 [ # # ]: 0 : if (slot->bus->self &&
5211 [ # # ]: 0 : (slot->bus->self->dev_flags & PCI_DEV_FLAGS_NO_BUS_RESET))
5212 : : return false;
5213 : :
5214 [ # # ]: 0 : list_for_each_entry(dev, &slot->bus->devices, bus_list) {
5215 [ # # # # ]: 0 : if (!dev->slot || dev->slot != slot)
5216 : 0 : continue;
5217 [ # # ]: 0 : if (dev->dev_flags & PCI_DEV_FLAGS_NO_BUS_RESET ||
5218 [ # # # # ]: 0 : (dev->subordinate && !pci_bus_resetable(dev->subordinate)))
5219 : : return false;
5220 : : }
5221 : :
5222 : : return true;
5223 : : }
5224 : :
5225 : : /* Lock devices from the top of the tree down */
5226 : 0 : static void pci_slot_lock(struct pci_slot *slot)
5227 : : {
5228 : 0 : struct pci_dev *dev;
5229 : :
5230 [ # # ]: 0 : list_for_each_entry(dev, &slot->bus->devices, bus_list) {
5231 [ # # # # ]: 0 : if (!dev->slot || dev->slot != slot)
5232 : 0 : continue;
5233 : 0 : pci_dev_lock(dev);
5234 [ # # ]: 0 : if (dev->subordinate)
5235 : 0 : pci_bus_lock(dev->subordinate);
5236 : : }
5237 : 0 : }
5238 : :
5239 : : /* Unlock devices from the bottom of the tree up */
5240 : 0 : static void pci_slot_unlock(struct pci_slot *slot)
5241 : : {
5242 : 0 : struct pci_dev *dev;
5243 : :
5244 [ # # ]: 0 : list_for_each_entry(dev, &slot->bus->devices, bus_list) {
5245 [ # # # # ]: 0 : if (!dev->slot || dev->slot != slot)
5246 : 0 : continue;
5247 [ # # ]: 0 : if (dev->subordinate)
5248 : 0 : pci_bus_unlock(dev->subordinate);
5249 : 0 : pci_dev_unlock(dev);
5250 : : }
5251 : 0 : }
5252 : :
5253 : : /* Return 1 on successful lock, 0 on contention */
5254 : 0 : static int pci_slot_trylock(struct pci_slot *slot)
5255 : : {
5256 : 0 : struct pci_dev *dev;
5257 : :
5258 [ # # ]: 0 : list_for_each_entry(dev, &slot->bus->devices, bus_list) {
5259 [ # # # # ]: 0 : if (!dev->slot || dev->slot != slot)
5260 : 0 : continue;
5261 [ # # ]: 0 : if (!pci_dev_trylock(dev))
5262 : 0 : goto unlock;
5263 [ # # ]: 0 : if (dev->subordinate) {
5264 [ # # ]: 0 : if (!pci_bus_trylock(dev->subordinate)) {
5265 : 0 : pci_dev_unlock(dev);
5266 : 0 : goto unlock;
5267 : : }
5268 : : }
5269 : : }
5270 : : return 1;
5271 : :
5272 : 0 : unlock:
5273 [ # # ]: 0 : list_for_each_entry_continue_reverse(dev,
5274 : : &slot->bus->devices, bus_list) {
5275 [ # # # # ]: 0 : if (!dev->slot || dev->slot != slot)
5276 : 0 : continue;
5277 [ # # ]: 0 : if (dev->subordinate)
5278 : 0 : pci_bus_unlock(dev->subordinate);
5279 : 0 : pci_dev_unlock(dev);
5280 : : }
5281 : : return 0;
5282 : : }
5283 : :
5284 : : /*
5285 : : * Save and disable devices from the top of the tree down while holding
5286 : : * the @dev mutex lock for the entire tree.
5287 : : */
5288 : 0 : static void pci_bus_save_and_disable_locked(struct pci_bus *bus)
5289 : : {
5290 : 0 : struct pci_dev *dev;
5291 : :
5292 [ # # ]: 0 : list_for_each_entry(dev, &bus->devices, bus_list) {
5293 : 0 : pci_dev_save_and_disable(dev);
5294 [ # # ]: 0 : if (dev->subordinate)
5295 : 0 : pci_bus_save_and_disable_locked(dev->subordinate);
5296 : : }
5297 : 0 : }
5298 : :
5299 : : /*
5300 : : * Restore devices from top of the tree down while holding @dev mutex lock
5301 : : * for the entire tree. Parent bridges need to be restored before we can
5302 : : * get to subordinate devices.
5303 : : */
5304 : 0 : static void pci_bus_restore_locked(struct pci_bus *bus)
5305 : : {
5306 : 0 : struct pci_dev *dev;
5307 : :
5308 [ # # ]: 0 : list_for_each_entry(dev, &bus->devices, bus_list) {
5309 : 0 : pci_dev_restore(dev);
5310 [ # # ]: 0 : if (dev->subordinate)
5311 : 0 : pci_bus_restore_locked(dev->subordinate);
5312 : : }
5313 : 0 : }
5314 : :
5315 : : /*
5316 : : * Save and disable devices from the top of the tree down while holding
5317 : : * the @dev mutex lock for the entire tree.
5318 : : */
5319 : 0 : static void pci_slot_save_and_disable_locked(struct pci_slot *slot)
5320 : : {
5321 : 0 : struct pci_dev *dev;
5322 : :
5323 [ # # ]: 0 : list_for_each_entry(dev, &slot->bus->devices, bus_list) {
5324 [ # # # # ]: 0 : if (!dev->slot || dev->slot != slot)
5325 : 0 : continue;
5326 : 0 : pci_dev_save_and_disable(dev);
5327 [ # # ]: 0 : if (dev->subordinate)
5328 : 0 : pci_bus_save_and_disable_locked(dev->subordinate);
5329 : : }
5330 : 0 : }
5331 : :
5332 : : /*
5333 : : * Restore devices from top of the tree down while holding @dev mutex lock
5334 : : * for the entire tree. Parent bridges need to be restored before we can
5335 : : * get to subordinate devices.
5336 : : */
5337 : 0 : static void pci_slot_restore_locked(struct pci_slot *slot)
5338 : : {
5339 : 0 : struct pci_dev *dev;
5340 : :
5341 [ # # ]: 0 : list_for_each_entry(dev, &slot->bus->devices, bus_list) {
5342 [ # # # # ]: 0 : if (!dev->slot || dev->slot != slot)
5343 : 0 : continue;
5344 : 0 : pci_dev_restore(dev);
5345 [ # # ]: 0 : if (dev->subordinate)
5346 : 0 : pci_bus_restore_locked(dev->subordinate);
5347 : : }
5348 : 0 : }
5349 : :
5350 : 0 : static int pci_slot_reset(struct pci_slot *slot, int probe)
5351 : : {
5352 : 0 : int rc;
5353 : :
5354 [ # # # # ]: 0 : if (!slot || !pci_slot_resetable(slot))
5355 : : return -ENOTTY;
5356 : :
5357 [ # # ]: 0 : if (!probe)
5358 : 0 : pci_slot_lock(slot);
5359 : :
5360 : 0 : might_sleep();
5361 : :
5362 : 0 : rc = pci_reset_hotplug_slot(slot->hotplug, probe);
5363 : :
5364 [ # # ]: 0 : if (!probe)
5365 : 0 : pci_slot_unlock(slot);
5366 : :
5367 : : return rc;
5368 : : }
5369 : :
5370 : : /**
5371 : : * pci_probe_reset_slot - probe whether a PCI slot can be reset
5372 : : * @slot: PCI slot to probe
5373 : : *
5374 : : * Return 0 if slot can be reset, negative if a slot reset is not supported.
5375 : : */
5376 : 0 : int pci_probe_reset_slot(struct pci_slot *slot)
5377 : : {
5378 : 0 : return pci_slot_reset(slot, 1);
5379 : : }
5380 : : EXPORT_SYMBOL_GPL(pci_probe_reset_slot);
5381 : :
5382 : : /**
5383 : : * __pci_reset_slot - Try to reset a PCI slot
5384 : : * @slot: PCI slot to reset
5385 : : *
5386 : : * A PCI bus may host multiple slots, each slot may support a reset mechanism
5387 : : * independent of other slots. For instance, some slots may support slot power
5388 : : * control. In the case of a 1:1 bus to slot architecture, this function may
5389 : : * wrap the bus reset to avoid spurious slot related events such as hotplug.
5390 : : * Generally a slot reset should be attempted before a bus reset. All of the
5391 : : * function of the slot and any subordinate buses behind the slot are reset
5392 : : * through this function. PCI config space of all devices in the slot and
5393 : : * behind the slot is saved before and restored after reset.
5394 : : *
5395 : : * Same as above except return -EAGAIN if the slot cannot be locked
5396 : : */
5397 : 0 : static int __pci_reset_slot(struct pci_slot *slot)
5398 : : {
5399 : 0 : int rc;
5400 : :
5401 : 0 : rc = pci_slot_reset(slot, 1);
5402 [ # # ]: 0 : if (rc)
5403 : : return rc;
5404 : :
5405 [ # # ]: 0 : if (pci_slot_trylock(slot)) {
5406 : 0 : pci_slot_save_and_disable_locked(slot);
5407 : 0 : might_sleep();
5408 : 0 : rc = pci_reset_hotplug_slot(slot->hotplug, 0);
5409 : 0 : pci_slot_restore_locked(slot);
5410 : 0 : pci_slot_unlock(slot);
5411 : : } else
5412 : : rc = -EAGAIN;
5413 : :
5414 : : return rc;
5415 : : }
5416 : :
5417 : 0 : static int pci_bus_reset(struct pci_bus *bus, int probe)
5418 : : {
5419 : 0 : int ret;
5420 : :
5421 [ # # # # ]: 0 : if (!bus->self || !pci_bus_resetable(bus))
5422 : : return -ENOTTY;
5423 : :
5424 [ # # ]: 0 : if (probe)
5425 : : return 0;
5426 : :
5427 : 0 : pci_bus_lock(bus);
5428 : :
5429 : 0 : might_sleep();
5430 : :
5431 : 0 : ret = pci_bridge_secondary_bus_reset(bus->self);
5432 : :
5433 : 0 : pci_bus_unlock(bus);
5434 : :
5435 : 0 : return ret;
5436 : : }
5437 : :
5438 : : /**
5439 : : * pci_bus_error_reset - reset the bridge's subordinate bus
5440 : : * @bridge: The parent device that connects to the bus to reset
5441 : : *
5442 : : * This function will first try to reset the slots on this bus if the method is
5443 : : * available. If slot reset fails or is not available, this will fall back to a
5444 : : * secondary bus reset.
5445 : : */
5446 : 0 : int pci_bus_error_reset(struct pci_dev *bridge)
5447 : : {
5448 : 0 : struct pci_bus *bus = bridge->subordinate;
5449 : 0 : struct pci_slot *slot;
5450 : :
5451 [ # # ]: 0 : if (!bus)
5452 : : return -ENOTTY;
5453 : :
5454 : 0 : mutex_lock(&pci_slot_mutex);
5455 [ # # ]: 0 : if (list_empty(&bus->slots))
5456 : 0 : goto bus_reset;
5457 : :
5458 [ # # ]: 0 : list_for_each_entry(slot, &bus->slots, list)
5459 [ # # ]: 0 : if (pci_probe_reset_slot(slot))
5460 : 0 : goto bus_reset;
5461 : :
5462 [ # # ]: 0 : list_for_each_entry(slot, &bus->slots, list)
5463 [ # # ]: 0 : if (pci_slot_reset(slot, 0))
5464 : 0 : goto bus_reset;
5465 : :
5466 : 0 : mutex_unlock(&pci_slot_mutex);
5467 : 0 : return 0;
5468 : 0 : bus_reset:
5469 : 0 : mutex_unlock(&pci_slot_mutex);
5470 : 0 : return pci_bus_reset(bridge->subordinate, 0);
5471 : : }
5472 : :
5473 : : /**
5474 : : * pci_probe_reset_bus - probe whether a PCI bus can be reset
5475 : : * @bus: PCI bus to probe
5476 : : *
5477 : : * Return 0 if bus can be reset, negative if a bus reset is not supported.
5478 : : */
5479 : 0 : int pci_probe_reset_bus(struct pci_bus *bus)
5480 : : {
5481 : 0 : return pci_bus_reset(bus, 1);
5482 : : }
5483 : : EXPORT_SYMBOL_GPL(pci_probe_reset_bus);
5484 : :
5485 : : /**
5486 : : * __pci_reset_bus - Try to reset a PCI bus
5487 : : * @bus: top level PCI bus to reset
5488 : : *
5489 : : * Same as above except return -EAGAIN if the bus cannot be locked
5490 : : */
5491 : 0 : static int __pci_reset_bus(struct pci_bus *bus)
5492 : : {
5493 : 0 : int rc;
5494 : :
5495 : 0 : rc = pci_bus_reset(bus, 1);
5496 [ # # ]: 0 : if (rc)
5497 : : return rc;
5498 : :
5499 [ # # ]: 0 : if (pci_bus_trylock(bus)) {
5500 : 0 : pci_bus_save_and_disable_locked(bus);
5501 : 0 : might_sleep();
5502 : 0 : rc = pci_bridge_secondary_bus_reset(bus->self);
5503 : 0 : pci_bus_restore_locked(bus);
5504 : 0 : pci_bus_unlock(bus);
5505 : : } else
5506 : : rc = -EAGAIN;
5507 : :
5508 : : return rc;
5509 : : }
5510 : :
5511 : : /**
5512 : : * pci_reset_bus - Try to reset a PCI bus
5513 : : * @pdev: top level PCI device to reset via slot/bus
5514 : : *
5515 : : * Same as above except return -EAGAIN if the bus cannot be locked
5516 : : */
5517 : 0 : int pci_reset_bus(struct pci_dev *pdev)
5518 : : {
5519 : 0 : return (!pci_probe_reset_slot(pdev->slot)) ?
5520 [ # # ]: 0 : __pci_reset_slot(pdev->slot) : __pci_reset_bus(pdev->bus);
5521 : : }
5522 : : EXPORT_SYMBOL_GPL(pci_reset_bus);
5523 : :
5524 : : /**
5525 : : * pcix_get_max_mmrbc - get PCI-X maximum designed memory read byte count
5526 : : * @dev: PCI device to query
5527 : : *
5528 : : * Returns mmrbc: maximum designed memory read count in bytes or
5529 : : * appropriate error value.
5530 : : */
5531 : 0 : int pcix_get_max_mmrbc(struct pci_dev *dev)
5532 : : {
5533 : 0 : int cap;
5534 : 0 : u32 stat;
5535 : :
5536 : 0 : cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
5537 [ # # ]: 0 : if (!cap)
5538 : : return -EINVAL;
5539 : :
5540 [ # # ]: 0 : if (pci_read_config_dword(dev, cap + PCI_X_STATUS, &stat))
5541 : : return -EINVAL;
5542 : :
5543 : 0 : return 512 << ((stat & PCI_X_STATUS_MAX_READ) >> 21);
5544 : : }
5545 : : EXPORT_SYMBOL(pcix_get_max_mmrbc);
5546 : :
5547 : : /**
5548 : : * pcix_get_mmrbc - get PCI-X maximum memory read byte count
5549 : : * @dev: PCI device to query
5550 : : *
5551 : : * Returns mmrbc: maximum memory read count in bytes or appropriate error
5552 : : * value.
5553 : : */
5554 : 0 : int pcix_get_mmrbc(struct pci_dev *dev)
5555 : : {
5556 : 0 : int cap;
5557 : 0 : u16 cmd;
5558 : :
5559 : 0 : cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
5560 [ # # ]: 0 : if (!cap)
5561 : : return -EINVAL;
5562 : :
5563 [ # # ]: 0 : if (pci_read_config_word(dev, cap + PCI_X_CMD, &cmd))
5564 : : return -EINVAL;
5565 : :
5566 : 0 : return 512 << ((cmd & PCI_X_CMD_MAX_READ) >> 2);
5567 : : }
5568 : : EXPORT_SYMBOL(pcix_get_mmrbc);
5569 : :
5570 : : /**
5571 : : * pcix_set_mmrbc - set PCI-X maximum memory read byte count
5572 : : * @dev: PCI device to query
5573 : : * @mmrbc: maximum memory read count in bytes
5574 : : * valid values are 512, 1024, 2048, 4096
5575 : : *
5576 : : * If possible sets maximum memory read byte count, some bridges have errata
5577 : : * that prevent this.
5578 : : */
5579 : 0 : int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc)
5580 : : {
5581 : 0 : int cap;
5582 : 0 : u32 stat, v, o;
5583 : 0 : u16 cmd;
5584 : :
5585 [ # # # # : 0 : if (mmrbc < 512 || mmrbc > 4096 || !is_power_of_2(mmrbc))
# # ]
5586 : : return -EINVAL;
5587 : :
5588 : 0 : v = ffs(mmrbc) - 10;
5589 : :
5590 : 0 : cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
5591 [ # # ]: 0 : if (!cap)
5592 : : return -EINVAL;
5593 : :
5594 [ # # ]: 0 : if (pci_read_config_dword(dev, cap + PCI_X_STATUS, &stat))
5595 : : return -EINVAL;
5596 : :
5597 [ # # ]: 0 : if (v > (stat & PCI_X_STATUS_MAX_READ) >> 21)
5598 : : return -E2BIG;
5599 : :
5600 [ # # ]: 0 : if (pci_read_config_word(dev, cap + PCI_X_CMD, &cmd))
5601 : : return -EINVAL;
5602 : :
5603 : 0 : o = (cmd & PCI_X_CMD_MAX_READ) >> 2;
5604 [ # # ]: 0 : if (o != v) {
5605 [ # # # # ]: 0 : if (v > o && (dev->bus->bus_flags & PCI_BUS_FLAGS_NO_MMRBC))
5606 : : return -EIO;
5607 : :
5608 : 0 : cmd &= ~PCI_X_CMD_MAX_READ;
5609 : 0 : cmd |= v << 2;
5610 [ # # ]: 0 : if (pci_write_config_word(dev, cap + PCI_X_CMD, cmd))
5611 : 0 : return -EIO;
5612 : : }
5613 : : return 0;
5614 : : }
5615 : : EXPORT_SYMBOL(pcix_set_mmrbc);
5616 : :
5617 : : /**
5618 : : * pcie_get_readrq - get PCI Express read request size
5619 : : * @dev: PCI device to query
5620 : : *
5621 : : * Returns maximum memory read request in bytes or appropriate error value.
5622 : : */
5623 : 0 : int pcie_get_readrq(struct pci_dev *dev)
5624 : : {
5625 : 0 : u16 ctl;
5626 : :
5627 : 0 : pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl);
5628 : :
5629 : 0 : return 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12);
5630 : : }
5631 : : EXPORT_SYMBOL(pcie_get_readrq);
5632 : :
5633 : : /**
5634 : : * pcie_set_readrq - set PCI Express maximum memory read request
5635 : : * @dev: PCI device to query
5636 : : * @rq: maximum memory read count in bytes
5637 : : * valid values are 128, 256, 512, 1024, 2048, 4096
5638 : : *
5639 : : * If possible sets maximum memory read request in bytes
5640 : : */
5641 : 0 : int pcie_set_readrq(struct pci_dev *dev, int rq)
5642 : : {
5643 : 0 : u16 v;
5644 : :
5645 [ # # # # : 0 : if (rq < 128 || rq > 4096 || !is_power_of_2(rq))
# # ]
5646 : : return -EINVAL;
5647 : :
5648 : : /*
5649 : : * If using the "performance" PCIe config, we clamp the read rq
5650 : : * size to the max packet size to keep the host bridge from
5651 : : * generating requests larger than we can cope with.
5652 : : */
5653 [ # # ]: 0 : if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
5654 : 0 : int mps = pcie_get_mps(dev);
5655 : :
5656 : 0 : if (mps < rq)
5657 : : rq = mps;
5658 : : }
5659 : :
5660 : 0 : v = (ffs(rq) - 8) << 12;
5661 : :
5662 : 0 : return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
5663 : : PCI_EXP_DEVCTL_READRQ, v);
5664 : : }
5665 : : EXPORT_SYMBOL(pcie_set_readrq);
5666 : :
5667 : : /**
5668 : : * pcie_get_mps - get PCI Express maximum payload size
5669 : : * @dev: PCI device to query
5670 : : *
5671 : : * Returns maximum payload size in bytes
5672 : : */
5673 : 0 : int pcie_get_mps(struct pci_dev *dev)
5674 : : {
5675 : 0 : u16 ctl;
5676 : :
5677 : 0 : pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl);
5678 : :
5679 : 0 : return 128 << ((ctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
5680 : : }
5681 : : EXPORT_SYMBOL(pcie_get_mps);
5682 : :
5683 : : /**
5684 : : * pcie_set_mps - set PCI Express maximum payload size
5685 : : * @dev: PCI device to query
5686 : : * @mps: maximum payload size in bytes
5687 : : * valid values are 128, 256, 512, 1024, 2048, 4096
5688 : : *
5689 : : * If possible sets maximum payload size
5690 : : */
5691 : 0 : int pcie_set_mps(struct pci_dev *dev, int mps)
5692 : : {
5693 : 0 : u16 v;
5694 : :
5695 [ # # # # : 0 : if (mps < 128 || mps > 4096 || !is_power_of_2(mps))
# # ]
5696 : : return -EINVAL;
5697 : :
5698 [ # # ]: 0 : v = ffs(mps) - 8;
5699 [ # # ]: 0 : if (v > dev->pcie_mpss)
5700 : : return -EINVAL;
5701 : 0 : v <<= 5;
5702 : :
5703 : 0 : return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
5704 : : PCI_EXP_DEVCTL_PAYLOAD, v);
5705 : : }
5706 : : EXPORT_SYMBOL(pcie_set_mps);
5707 : :
5708 : : /**
5709 : : * pcie_bandwidth_available - determine minimum link settings of a PCIe
5710 : : * device and its bandwidth limitation
5711 : : * @dev: PCI device to query
5712 : : * @limiting_dev: storage for device causing the bandwidth limitation
5713 : : * @speed: storage for speed of limiting device
5714 : : * @width: storage for width of limiting device
5715 : : *
5716 : : * Walk up the PCI device chain and find the point where the minimum
5717 : : * bandwidth is available. Return the bandwidth available there and (if
5718 : : * limiting_dev, speed, and width pointers are supplied) information about
5719 : : * that point. The bandwidth returned is in Mb/s, i.e., megabits/second of
5720 : : * raw bandwidth.
5721 : : */
5722 : 0 : u32 pcie_bandwidth_available(struct pci_dev *dev, struct pci_dev **limiting_dev,
5723 : : enum pci_bus_speed *speed,
5724 : : enum pcie_link_width *width)
5725 : : {
5726 : 0 : u16 lnksta;
5727 : 0 : enum pci_bus_speed next_speed;
5728 : 0 : enum pcie_link_width next_width;
5729 : 0 : u32 bw, next_bw;
5730 : :
5731 [ # # ]: 0 : if (speed)
5732 : 0 : *speed = PCI_SPEED_UNKNOWN;
5733 [ # # ]: 0 : if (width)
5734 : 0 : *width = PCIE_LNK_WIDTH_UNKNOWN;
5735 : :
5736 : : bw = 0;
5737 : :
5738 [ # # ]: 0 : while (dev) {
5739 : 0 : pcie_capability_read_word(dev, PCI_EXP_LNKSTA, &lnksta);
5740 : :
5741 : 0 : next_speed = pcie_link_speed[lnksta & PCI_EXP_LNKSTA_CLS];
5742 : 0 : next_width = (lnksta & PCI_EXP_LNKSTA_NLW) >>
5743 : : PCI_EXP_LNKSTA_NLW_SHIFT;
5744 : :
5745 [ # # # # : 0 : next_bw = next_width * PCIE_SPEED2MBS_ENC(next_speed);
# # # # ]
5746 : :
5747 : : /* Check if current device limits the total bandwidth */
5748 [ # # ]: 0 : if (!bw || next_bw <= bw) {
5749 : 0 : bw = next_bw;
5750 : :
5751 [ # # ]: 0 : if (limiting_dev)
5752 : 0 : *limiting_dev = dev;
5753 [ # # ]: 0 : if (speed)
5754 : 0 : *speed = next_speed;
5755 [ # # ]: 0 : if (width)
5756 : 0 : *width = next_width;
5757 : : }
5758 : :
5759 [ # # ]: 0 : dev = pci_upstream_bridge(dev);
5760 : : }
5761 : :
5762 : 0 : return bw;
5763 : : }
5764 : : EXPORT_SYMBOL(pcie_bandwidth_available);
5765 : :
5766 : : /**
5767 : : * pcie_get_speed_cap - query for the PCI device's link speed capability
5768 : : * @dev: PCI device to query
5769 : : *
5770 : : * Query the PCI device speed capability. Return the maximum link speed
5771 : : * supported by the device.
5772 : : */
5773 : 0 : enum pci_bus_speed pcie_get_speed_cap(struct pci_dev *dev)
5774 : : {
5775 : 0 : u32 lnkcap2, lnkcap;
5776 : :
5777 : : /*
5778 : : * Link Capabilities 2 was added in PCIe r3.0, sec 7.8.18. The
5779 : : * implementation note there recommends using the Supported Link
5780 : : * Speeds Vector in Link Capabilities 2 when supported.
5781 : : *
5782 : : * Without Link Capabilities 2, i.e., prior to PCIe r3.0, software
5783 : : * should use the Supported Link Speeds field in Link Capabilities,
5784 : : * where only 2.5 GT/s and 5.0 GT/s speeds were defined.
5785 : : */
5786 : 0 : pcie_capability_read_dword(dev, PCI_EXP_LNKCAP2, &lnkcap2);
5787 [ # # ]: 0 : if (lnkcap2) { /* PCIe r3.0-compliant */
5788 [ # # ]: 0 : if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_32_0GB)
5789 : : return PCIE_SPEED_32_0GT;
5790 [ # # ]: 0 : else if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_16_0GB)
5791 : : return PCIE_SPEED_16_0GT;
5792 [ # # ]: 0 : else if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
5793 : : return PCIE_SPEED_8_0GT;
5794 [ # # ]: 0 : else if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB)
5795 : : return PCIE_SPEED_5_0GT;
5796 [ # # ]: 0 : else if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB)
5797 : : return PCIE_SPEED_2_5GT;
5798 : 0 : return PCI_SPEED_UNKNOWN;
5799 : : }
5800 : :
5801 : 0 : pcie_capability_read_dword(dev, PCI_EXP_LNKCAP, &lnkcap);
5802 [ # # ]: 0 : if ((lnkcap & PCI_EXP_LNKCAP_SLS) == PCI_EXP_LNKCAP_SLS_5_0GB)
5803 : : return PCIE_SPEED_5_0GT;
5804 [ # # ]: 0 : else if ((lnkcap & PCI_EXP_LNKCAP_SLS) == PCI_EXP_LNKCAP_SLS_2_5GB)
5805 : 0 : return PCIE_SPEED_2_5GT;
5806 : :
5807 : : return PCI_SPEED_UNKNOWN;
5808 : : }
5809 : : EXPORT_SYMBOL(pcie_get_speed_cap);
5810 : :
5811 : : /**
5812 : : * pcie_get_width_cap - query for the PCI device's link width capability
5813 : : * @dev: PCI device to query
5814 : : *
5815 : : * Query the PCI device width capability. Return the maximum link width
5816 : : * supported by the device.
5817 : : */
5818 : 0 : enum pcie_link_width pcie_get_width_cap(struct pci_dev *dev)
5819 : : {
5820 : 0 : u32 lnkcap;
5821 : :
5822 : 0 : pcie_capability_read_dword(dev, PCI_EXP_LNKCAP, &lnkcap);
5823 [ # # # # ]: 0 : if (lnkcap)
5824 : 0 : return (lnkcap & PCI_EXP_LNKCAP_MLW) >> 4;
5825 : :
5826 : : return PCIE_LNK_WIDTH_UNKNOWN;
5827 : : }
5828 : : EXPORT_SYMBOL(pcie_get_width_cap);
5829 : :
5830 : : /**
5831 : : * pcie_bandwidth_capable - calculate a PCI device's link bandwidth capability
5832 : : * @dev: PCI device
5833 : : * @speed: storage for link speed
5834 : : * @width: storage for link width
5835 : : *
5836 : : * Calculate a PCI device's link bandwidth by querying for its link speed
5837 : : * and width, multiplying them, and applying encoding overhead. The result
5838 : : * is in Mb/s, i.e., megabits/second of raw bandwidth.
5839 : : */
5840 : 0 : u32 pcie_bandwidth_capable(struct pci_dev *dev, enum pci_bus_speed *speed,
5841 : : enum pcie_link_width *width)
5842 : : {
5843 : 0 : *speed = pcie_get_speed_cap(dev);
5844 : 0 : *width = pcie_get_width_cap(dev);
5845 : :
5846 [ # # # # ]: 0 : if (*speed == PCI_SPEED_UNKNOWN || *width == PCIE_LNK_WIDTH_UNKNOWN)
5847 : : return 0;
5848 : :
5849 [ # # # # : 0 : return *width * PCIE_SPEED2MBS_ENC(*speed);
# # # # ]
5850 : : }
5851 : :
5852 : : /**
5853 : : * __pcie_print_link_status - Report the PCI device's link speed and width
5854 : : * @dev: PCI device to query
5855 : : * @verbose: Print info even when enough bandwidth is available
5856 : : *
5857 : : * If the available bandwidth at the device is less than the device is
5858 : : * capable of, report the device's maximum possible bandwidth and the
5859 : : * upstream link that limits its performance. If @verbose, always print
5860 : : * the available bandwidth, even if the device isn't constrained.
5861 : : */
5862 : 0 : void __pcie_print_link_status(struct pci_dev *dev, bool verbose)
5863 : : {
5864 : 0 : enum pcie_link_width width, width_cap;
5865 : 0 : enum pci_bus_speed speed, speed_cap;
5866 : 0 : struct pci_dev *limiting_dev = NULL;
5867 : 0 : u32 bw_avail, bw_cap;
5868 : :
5869 : 0 : bw_cap = pcie_bandwidth_capable(dev, &speed_cap, &width_cap);
5870 : 0 : bw_avail = pcie_bandwidth_available(dev, &limiting_dev, &speed, &width);
5871 : :
5872 [ # # ]: 0 : if (bw_avail >= bw_cap && verbose)
5873 [ # # # # : 0 : pci_info(dev, "%u.%03u Gb/s available PCIe bandwidth (%s x%d link)\n",
# # # # ]
5874 : : bw_cap / 1000, bw_cap % 1000,
5875 : : PCIE_SPEED2STR(speed_cap), width_cap);
5876 [ # # ]: 0 : else if (bw_avail < bw_cap)
5877 [ # # # # : 0 : pci_info(dev, "%u.%03u Gb/s available PCIe bandwidth, limited by %s x%d link at %s (capable of %u.%03u Gb/s with %s x%d link)\n",
# # # # #
# # # # #
# # # # ]
5878 : : bw_avail / 1000, bw_avail % 1000,
5879 : : PCIE_SPEED2STR(speed), width,
5880 : : limiting_dev ? pci_name(limiting_dev) : "<unknown>",
5881 : : bw_cap / 1000, bw_cap % 1000,
5882 : : PCIE_SPEED2STR(speed_cap), width_cap);
5883 : 0 : }
5884 : :
5885 : : /**
5886 : : * pcie_print_link_status - Report the PCI device's link speed and width
5887 : : * @dev: PCI device to query
5888 : : *
5889 : : * Report the available bandwidth at the device.
5890 : : */
5891 : 0 : void pcie_print_link_status(struct pci_dev *dev)
5892 : : {
5893 : 0 : __pcie_print_link_status(dev, true);
5894 : 0 : }
5895 : : EXPORT_SYMBOL(pcie_print_link_status);
5896 : :
5897 : : /**
5898 : : * pci_select_bars - Make BAR mask from the type of resource
5899 : : * @dev: the PCI device for which BAR mask is made
5900 : : * @flags: resource type mask to be selected
5901 : : *
5902 : : * This helper routine makes bar mask from the type of resource.
5903 : : */
5904 : 0 : int pci_select_bars(struct pci_dev *dev, unsigned long flags)
5905 : : {
5906 : 0 : int i, bars = 0;
5907 [ # # ]: 0 : for (i = 0; i < PCI_NUM_RESOURCES; i++)
5908 [ # # ]: 0 : if (pci_resource_flags(dev, i) & flags)
5909 : 0 : bars |= (1 << i);
5910 : 0 : return bars;
5911 : : }
5912 : : EXPORT_SYMBOL(pci_select_bars);
5913 : :
5914 : : /* Some architectures require additional programming to enable VGA */
5915 : : static arch_set_vga_state_t arch_set_vga_state;
5916 : :
5917 : 0 : void __init pci_register_set_vga_state(arch_set_vga_state_t func)
5918 : : {
5919 : 0 : arch_set_vga_state = func; /* NULL disables */
5920 : 0 : }
5921 : :
5922 : 0 : static int pci_set_vga_state_arch(struct pci_dev *dev, bool decode,
5923 : : unsigned int command_bits, u32 flags)
5924 : : {
5925 : 0 : if (arch_set_vga_state)
5926 : 0 : return arch_set_vga_state(dev, decode, command_bits,
5927 : : flags);
5928 : : return 0;
5929 : : }
5930 : :
5931 : : /**
5932 : : * pci_set_vga_state - set VGA decode state on device and parents if requested
5933 : : * @dev: the PCI device
5934 : : * @decode: true = enable decoding, false = disable decoding
5935 : : * @command_bits: PCI_COMMAND_IO and/or PCI_COMMAND_MEMORY
5936 : : * @flags: traverse ancestors and change bridges
5937 : : * CHANGE_BRIDGE_ONLY / CHANGE_BRIDGE
5938 : : */
5939 : 0 : int pci_set_vga_state(struct pci_dev *dev, bool decode,
5940 : : unsigned int command_bits, u32 flags)
5941 : : {
5942 : 0 : struct pci_bus *bus;
5943 : 0 : struct pci_dev *bridge;
5944 : 0 : u16 cmd;
5945 : 0 : int rc;
5946 : :
5947 [ # # # # : 0 : WARN_ON((flags & PCI_VGA_STATE_CHANGE_DECODES) && (command_bits & ~(PCI_COMMAND_IO|PCI_COMMAND_MEMORY)));
# # ]
5948 : :
5949 : : /* ARCH specific VGA enables */
5950 [ # # ]: 0 : rc = pci_set_vga_state_arch(dev, decode, command_bits, flags);
5951 [ # # ]: 0 : if (rc)
5952 : : return rc;
5953 : :
5954 [ # # ]: 0 : if (flags & PCI_VGA_STATE_CHANGE_DECODES) {
5955 : 0 : pci_read_config_word(dev, PCI_COMMAND, &cmd);
5956 [ # # ]: 0 : if (decode == true)
5957 : 0 : cmd |= command_bits;
5958 : : else
5959 : 0 : cmd &= ~command_bits;
5960 : 0 : pci_write_config_word(dev, PCI_COMMAND, cmd);
5961 : : }
5962 : :
5963 [ # # ]: 0 : if (!(flags & PCI_VGA_STATE_CHANGE_BRIDGE))
5964 : : return 0;
5965 : :
5966 : 0 : bus = dev->bus;
5967 [ # # ]: 0 : while (bus) {
5968 : 0 : bridge = bus->self;
5969 [ # # ]: 0 : if (bridge) {
5970 : 0 : pci_read_config_word(bridge, PCI_BRIDGE_CONTROL,
5971 : : &cmd);
5972 [ # # ]: 0 : if (decode == true)
5973 : 0 : cmd |= PCI_BRIDGE_CTL_VGA;
5974 : : else
5975 : 0 : cmd &= ~PCI_BRIDGE_CTL_VGA;
5976 : 0 : pci_write_config_word(bridge, PCI_BRIDGE_CONTROL,
5977 : : cmd);
5978 : : }
5979 : 0 : bus = bus->parent;
5980 : : }
5981 : : return 0;
5982 : : }
5983 : :
5984 : : #ifdef CONFIG_ACPI
5985 : 0 : bool pci_pr3_present(struct pci_dev *pdev)
5986 : : {
5987 : 0 : struct acpi_device *adev;
5988 : :
5989 [ # # ]: 0 : if (acpi_disabled)
5990 : : return false;
5991 : :
5992 [ # # ]: 0 : adev = ACPI_COMPANION(&pdev->dev);
5993 [ # # ]: 0 : if (!adev)
5994 : : return false;
5995 : :
5996 [ # # # # ]: 0 : return adev->power.flags.power_resources &&
5997 : 0 : acpi_has_method(adev->handle, "_PR3");
5998 : : }
5999 : : EXPORT_SYMBOL_GPL(pci_pr3_present);
6000 : : #endif
6001 : :
6002 : : /**
6003 : : * pci_add_dma_alias - Add a DMA devfn alias for a device
6004 : : * @dev: the PCI device for which alias is added
6005 : : * @devfn_from: alias slot and function
6006 : : * @nr_devfns: number of subsequent devfns to alias
6007 : : *
6008 : : * This helper encodes an 8-bit devfn as a bit number in dma_alias_mask
6009 : : * which is used to program permissible bus-devfn source addresses for DMA
6010 : : * requests in an IOMMU. These aliases factor into IOMMU group creation
6011 : : * and are useful for devices generating DMA requests beyond or different
6012 : : * from their logical bus-devfn. Examples include device quirks where the
6013 : : * device simply uses the wrong devfn, as well as non-transparent bridges
6014 : : * where the alias may be a proxy for devices in another domain.
6015 : : *
6016 : : * IOMMU group creation is performed during device discovery or addition,
6017 : : * prior to any potential DMA mapping and therefore prior to driver probing
6018 : : * (especially for userspace assigned devices where IOMMU group definition
6019 : : * cannot be left as a userspace activity). DMA aliases should therefore
6020 : : * be configured via quirks, such as the PCI fixup header quirk.
6021 : : */
6022 : 0 : void pci_add_dma_alias(struct pci_dev *dev, u8 devfn_from, unsigned nr_devfns)
6023 : : {
6024 : 0 : int devfn_to;
6025 : :
6026 : 0 : nr_devfns = min(nr_devfns, (unsigned) MAX_NR_DEVFNS - devfn_from);
6027 : 0 : devfn_to = devfn_from + nr_devfns - 1;
6028 : :
6029 [ # # ]: 0 : if (!dev->dma_alias_mask)
6030 : 0 : dev->dma_alias_mask = bitmap_zalloc(MAX_NR_DEVFNS, GFP_KERNEL);
6031 [ # # ]: 0 : if (!dev->dma_alias_mask) {
6032 : 0 : pci_warn(dev, "Unable to allocate DMA alias mask\n");
6033 : 0 : return;
6034 : : }
6035 : :
6036 [ # # ]: 0 : bitmap_set(dev->dma_alias_mask, devfn_from, nr_devfns);
6037 : :
6038 [ # # ]: 0 : if (nr_devfns == 1)
6039 : 0 : pci_info(dev, "Enabling fixed DMA alias to %02x.%d\n",
6040 : : PCI_SLOT(devfn_from), PCI_FUNC(devfn_from));
6041 [ # # ]: 0 : else if (nr_devfns > 1)
6042 : 0 : pci_info(dev, "Enabling fixed DMA alias for devfn range from %02x.%d to %02x.%d\n",
6043 : : PCI_SLOT(devfn_from), PCI_FUNC(devfn_from),
6044 : : PCI_SLOT(devfn_to), PCI_FUNC(devfn_to));
6045 : : }
6046 : :
6047 : 0 : bool pci_devs_are_dma_aliases(struct pci_dev *dev1, struct pci_dev *dev2)
6048 : : {
6049 [ # # ]: 0 : return (dev1->dma_alias_mask &&
6050 : 0 : test_bit(dev2->devfn, dev1->dma_alias_mask)) ||
6051 [ # # # # ]: 0 : (dev2->dma_alias_mask &&
6052 [ # # ]: 0 : test_bit(dev1->devfn, dev2->dma_alias_mask)) ||
6053 [ # # # # ]: 0 : pci_real_dma_dev(dev1) == dev2 ||
6054 : 0 : pci_real_dma_dev(dev2) == dev1;
6055 : : }
6056 : :
6057 : 0 : bool pci_device_is_present(struct pci_dev *pdev)
6058 : : {
6059 : 0 : u32 v;
6060 : :
6061 [ # # # # : 0 : if (pci_dev_is_disconnected(pdev))
# # ]
6062 : : return false;
6063 : 0 : return pci_bus_read_dev_vendor_id(pdev->bus, pdev->devfn, &v, 0);
6064 : : }
6065 : : EXPORT_SYMBOL_GPL(pci_device_is_present);
6066 : :
6067 : 0 : void pci_ignore_hotplug(struct pci_dev *dev)
6068 : : {
6069 : 0 : struct pci_dev *bridge = dev->bus->self;
6070 : :
6071 : 0 : dev->ignore_hotplug = 1;
6072 : : /* Propagate the "ignore hotplug" setting to the parent bridge. */
6073 [ # # ]: 0 : if (bridge)
6074 : 0 : bridge->ignore_hotplug = 1;
6075 : 0 : }
6076 : : EXPORT_SYMBOL_GPL(pci_ignore_hotplug);
6077 : :
6078 : : /**
6079 : : * pci_real_dma_dev - Get PCI DMA device for PCI device
6080 : : * @dev: the PCI device that may have a PCI DMA alias
6081 : : *
6082 : : * Permits the platform to provide architecture-specific functionality to
6083 : : * devices needing to alias DMA to another PCI device on another PCI bus. If
6084 : : * the PCI device is on the same bus, it is recommended to use
6085 : : * pci_add_dma_alias(). This is the default implementation. Architecture
6086 : : * implementations can override this.
6087 : : */
6088 : 210 : struct pci_dev __weak *pci_real_dma_dev(struct pci_dev *dev)
6089 : : {
6090 : 210 : return dev;
6091 : : }
6092 : :
6093 : 210 : resource_size_t __weak pcibios_default_alignment(void)
6094 : : {
6095 : 210 : return 0;
6096 : : }
6097 : :
6098 : : /*
6099 : : * Arches that don't want to expose struct resource to userland as-is in
6100 : : * sysfs and /proc can implement their own pci_resource_to_user().
6101 : : */
6102 : 0 : void __weak pci_resource_to_user(const struct pci_dev *dev, int bar,
6103 : : const struct resource *rsrc,
6104 : : resource_size_t *start, resource_size_t *end)
6105 : : {
6106 : 0 : *start = rsrc->start;
6107 : 0 : *end = rsrc->end;
6108 : 0 : }
6109 : :
6110 : : static char *resource_alignment_param;
6111 : : static DEFINE_SPINLOCK(resource_alignment_lock);
6112 : :
6113 : : /**
6114 : : * pci_specified_resource_alignment - get resource alignment specified by user.
6115 : : * @dev: the PCI device to get
6116 : : * @resize: whether or not to change resources' size when reassigning alignment
6117 : : *
6118 : : * RETURNS: Resource alignment if it is specified.
6119 : : * Zero if it is not specified.
6120 : : */
6121 : 210 : static resource_size_t pci_specified_resource_alignment(struct pci_dev *dev,
6122 : : bool *resize)
6123 : : {
6124 : 210 : int align_order, count;
6125 : 210 : resource_size_t align = pcibios_default_alignment();
6126 : 210 : const char *p;
6127 : 210 : int ret;
6128 : :
6129 : 210 : spin_lock(&resource_alignment_lock);
6130 : 210 : p = resource_alignment_param;
6131 [ - + - - ]: 210 : if (!p || !*p)
6132 : 210 : goto out;
6133 [ # # ]: 0 : if (pci_has_flag(PCI_PROBE_ONLY)) {
6134 : 0 : align = 0;
6135 [ # # ]: 0 : pr_info_once("PCI: Ignoring requested alignments (PCI_PROBE_ONLY)\n");
6136 : 0 : goto out;
6137 : : }
6138 : :
6139 [ # # ]: 0 : while (*p) {
6140 : 0 : count = 0;
6141 [ # # ]: 0 : if (sscanf(p, "%d%n", &align_order, &count) == 1 &&
6142 [ # # ]: 0 : p[count] == '@') {
6143 : 0 : p += count + 1;
6144 : : } else {
6145 : 0 : align_order = -1;
6146 : : }
6147 : :
6148 : 0 : ret = pci_dev_str_match(dev, p, &p);
6149 [ # # ]: 0 : if (ret == 1) {
6150 : 0 : *resize = true;
6151 [ # # ]: 0 : if (align_order == -1)
6152 : : align = PAGE_SIZE;
6153 : : else
6154 : 0 : align = 1 << align_order;
6155 : : break;
6156 [ # # ]: 0 : } else if (ret < 0) {
6157 : 0 : pr_err("PCI: Can't parse resource_alignment parameter: %s\n",
6158 : : p);
6159 : 0 : break;
6160 : : }
6161 : :
6162 [ # # ]: 0 : if (*p != ';' && *p != ',') {
6163 : : /* End of param or invalid format */
6164 : : break;
6165 : : }
6166 : 0 : p++;
6167 : : }
6168 : 0 : out:
6169 : 210 : spin_unlock(&resource_alignment_lock);
6170 : 210 : return align;
6171 : : }
6172 : :
6173 : 0 : static void pci_request_resource_alignment(struct pci_dev *dev, int bar,
6174 : : resource_size_t align, bool resize)
6175 : : {
6176 : 0 : struct resource *r = &dev->resource[bar];
6177 : 0 : resource_size_t size;
6178 : :
6179 [ # # ]: 0 : if (!(r->flags & IORESOURCE_MEM))
6180 : : return;
6181 : :
6182 [ # # ]: 0 : if (r->flags & IORESOURCE_PCI_FIXED) {
6183 : 0 : pci_info(dev, "BAR%d %pR: ignoring requested alignment %#llx\n",
6184 : : bar, r, (unsigned long long)align);
6185 : 0 : return;
6186 : : }
6187 : :
6188 [ # # ]: 0 : size = resource_size(r);
6189 [ # # ]: 0 : if (size >= align)
6190 : : return;
6191 : :
6192 : : /*
6193 : : * Increase the alignment of the resource. There are two ways we
6194 : : * can do this:
6195 : : *
6196 : : * 1) Increase the size of the resource. BARs are aligned on their
6197 : : * size, so when we reallocate space for this resource, we'll
6198 : : * allocate it with the larger alignment. This also prevents
6199 : : * assignment of any other BARs inside the alignment region, so
6200 : : * if we're requesting page alignment, this means no other BARs
6201 : : * will share the page.
6202 : : *
6203 : : * The disadvantage is that this makes the resource larger than
6204 : : * the hardware BAR, which may break drivers that compute things
6205 : : * based on the resource size, e.g., to find registers at a
6206 : : * fixed offset before the end of the BAR.
6207 : : *
6208 : : * 2) Retain the resource size, but use IORESOURCE_STARTALIGN and
6209 : : * set r->start to the desired alignment. By itself this
6210 : : * doesn't prevent other BARs being put inside the alignment
6211 : : * region, but if we realign *every* resource of every device in
6212 : : * the system, none of them will share an alignment region.
6213 : : *
6214 : : * When the user has requested alignment for only some devices via
6215 : : * the "pci=resource_alignment" argument, "resize" is true and we
6216 : : * use the first method. Otherwise we assume we're aligning all
6217 : : * devices and we use the second.
6218 : : */
6219 : :
6220 : 0 : pci_info(dev, "BAR%d %pR: requesting alignment to %#llx\n",
6221 : : bar, r, (unsigned long long)align);
6222 : :
6223 [ # # ]: 0 : if (resize) {
6224 : 0 : r->start = 0;
6225 : 0 : r->end = align - 1;
6226 : : } else {
6227 : 0 : r->flags &= ~IORESOURCE_SIZEALIGN;
6228 : 0 : r->flags |= IORESOURCE_STARTALIGN;
6229 : 0 : r->start = align;
6230 : 0 : r->end = r->start + size - 1;
6231 : : }
6232 : 0 : r->flags |= IORESOURCE_UNSET;
6233 : : }
6234 : :
6235 : : /*
6236 : : * This function disables memory decoding and releases memory resources
6237 : : * of the device specified by kernel's boot parameter 'pci=resource_alignment='.
6238 : : * It also rounds up size to specified alignment.
6239 : : * Later on, the kernel will assign page-aligned memory resource back
6240 : : * to the device.
6241 : : */
6242 : 210 : void pci_reassigndev_resource_alignment(struct pci_dev *dev)
6243 : : {
6244 : 210 : int i;
6245 : 210 : struct resource *r;
6246 : 210 : resource_size_t align;
6247 : 210 : u16 command;
6248 : 210 : bool resize = false;
6249 : :
6250 : : /*
6251 : : * VF BARs are read-only zero according to SR-IOV spec r1.1, sec
6252 : : * 3.4.1.11. Their resources are allocated from the space
6253 : : * described by the VF BARx register in the PF's SR-IOV capability.
6254 : : * We can't influence their alignment here.
6255 : : */
6256 [ + - ]: 210 : if (dev->is_virtfn)
6257 : 210 : return;
6258 : :
6259 : : /* check if specified PCI is target device to reassign */
6260 : 210 : align = pci_specified_resource_alignment(dev, &resize);
6261 [ - + ]: 210 : if (!align)
6262 : : return;
6263 : :
6264 [ # # ]: 0 : if (dev->hdr_type == PCI_HEADER_TYPE_NORMAL &&
6265 [ # # ]: 0 : (dev->class >> 8) == PCI_CLASS_BRIDGE_HOST) {
6266 : 0 : pci_warn(dev, "Can't reassign resources to host bridge\n");
6267 : 0 : return;
6268 : : }
6269 : :
6270 : 0 : pci_read_config_word(dev, PCI_COMMAND, &command);
6271 : 0 : command &= ~PCI_COMMAND_MEMORY;
6272 : 0 : pci_write_config_word(dev, PCI_COMMAND, command);
6273 : :
6274 [ # # ]: 0 : for (i = 0; i <= PCI_ROM_RESOURCE; i++)
6275 : 0 : pci_request_resource_alignment(dev, i, align, resize);
6276 : :
6277 : : /*
6278 : : * Need to disable bridge's resource window,
6279 : : * to enable the kernel to reassign new resource
6280 : : * window later on.
6281 : : */
6282 [ # # ]: 0 : if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
6283 [ # # ]: 0 : for (i = PCI_BRIDGE_RESOURCES; i < PCI_NUM_RESOURCES; i++) {
6284 : 0 : r = &dev->resource[i];
6285 [ # # ]: 0 : if (!(r->flags & IORESOURCE_MEM))
6286 : 0 : continue;
6287 : 0 : r->flags |= IORESOURCE_UNSET;
6288 : 0 : r->end = resource_size(r) - 1;
6289 : 0 : r->start = 0;
6290 : : }
6291 : 0 : pci_disable_bridge_window(dev);
6292 : : }
6293 : : }
6294 : :
6295 : 0 : static ssize_t resource_alignment_show(struct bus_type *bus, char *buf)
6296 : : {
6297 : 0 : size_t count = 0;
6298 : :
6299 : 0 : spin_lock(&resource_alignment_lock);
6300 [ # # ]: 0 : if (resource_alignment_param)
6301 : 0 : count = snprintf(buf, PAGE_SIZE, "%s", resource_alignment_param);
6302 : 0 : spin_unlock(&resource_alignment_lock);
6303 : :
6304 : : /*
6305 : : * When set by the command line, resource_alignment_param will not
6306 : : * have a trailing line feed, which is ugly. So conditionally add
6307 : : * it here.
6308 : : */
6309 [ # # # # : 0 : if (count >= 2 && buf[count - 2] != '\n' && count < PAGE_SIZE - 1) {
# # ]
6310 : 0 : buf[count - 1] = '\n';
6311 : 0 : buf[count++] = 0;
6312 : : }
6313 : :
6314 : 0 : return count;
6315 : : }
6316 : :
6317 : 0 : static ssize_t resource_alignment_store(struct bus_type *bus,
6318 : : const char *buf, size_t count)
6319 : : {
6320 : 0 : char *param = kstrndup(buf, count, GFP_KERNEL);
6321 : :
6322 [ # # ]: 0 : if (!param)
6323 : : return -ENOMEM;
6324 : :
6325 : 0 : spin_lock(&resource_alignment_lock);
6326 : 0 : kfree(resource_alignment_param);
6327 : 0 : resource_alignment_param = param;
6328 : 0 : spin_unlock(&resource_alignment_lock);
6329 : 0 : return count;
6330 : : }
6331 : :
6332 : : static BUS_ATTR_RW(resource_alignment);
6333 : :
6334 : 30 : static int __init pci_resource_alignment_sysfs_init(void)
6335 : : {
6336 : 30 : return bus_create_file(&pci_bus_type,
6337 : : &bus_attr_resource_alignment);
6338 : : }
6339 : : late_initcall(pci_resource_alignment_sysfs_init);
6340 : :
6341 : 0 : static void pci_no_domains(void)
6342 : : {
6343 : : #ifdef CONFIG_PCI_DOMAINS
6344 : 0 : pci_domains_supported = 0;
6345 : : #endif
6346 : 0 : }
6347 : :
6348 : : #ifdef CONFIG_PCI_DOMAINS_GENERIC
6349 : : static atomic_t __domain_nr = ATOMIC_INIT(-1);
6350 : :
6351 : : static int pci_get_new_domain_nr(void)
6352 : : {
6353 : : return atomic_inc_return(&__domain_nr);
6354 : : }
6355 : :
6356 : : static int of_pci_bus_find_domain_nr(struct device *parent)
6357 : : {
6358 : : static int use_dt_domains = -1;
6359 : : int domain = -1;
6360 : :
6361 : : if (parent)
6362 : : domain = of_get_pci_domain_nr(parent->of_node);
6363 : :
6364 : : /*
6365 : : * Check DT domain and use_dt_domains values.
6366 : : *
6367 : : * If DT domain property is valid (domain >= 0) and
6368 : : * use_dt_domains != 0, the DT assignment is valid since this means
6369 : : * we have not previously allocated a domain number by using
6370 : : * pci_get_new_domain_nr(); we should also update use_dt_domains to
6371 : : * 1, to indicate that we have just assigned a domain number from
6372 : : * DT.
6373 : : *
6374 : : * If DT domain property value is not valid (ie domain < 0), and we
6375 : : * have not previously assigned a domain number from DT
6376 : : * (use_dt_domains != 1) we should assign a domain number by
6377 : : * using the:
6378 : : *
6379 : : * pci_get_new_domain_nr()
6380 : : *
6381 : : * API and update the use_dt_domains value to keep track of method we
6382 : : * are using to assign domain numbers (use_dt_domains = 0).
6383 : : *
6384 : : * All other combinations imply we have a platform that is trying
6385 : : * to mix domain numbers obtained from DT and pci_get_new_domain_nr(),
6386 : : * which is a recipe for domain mishandling and it is prevented by
6387 : : * invalidating the domain value (domain = -1) and printing a
6388 : : * corresponding error.
6389 : : */
6390 : : if (domain >= 0 && use_dt_domains) {
6391 : : use_dt_domains = 1;
6392 : : } else if (domain < 0 && use_dt_domains != 1) {
6393 : : use_dt_domains = 0;
6394 : : domain = pci_get_new_domain_nr();
6395 : : } else {
6396 : : if (parent)
6397 : : pr_err("Node %pOF has ", parent->of_node);
6398 : : pr_err("Inconsistent \"linux,pci-domain\" property in DT\n");
6399 : : domain = -1;
6400 : : }
6401 : :
6402 : : return domain;
6403 : : }
6404 : :
6405 : : int pci_bus_find_domain_nr(struct pci_bus *bus, struct device *parent)
6406 : : {
6407 : : return acpi_disabled ? of_pci_bus_find_domain_nr(parent) :
6408 : : acpi_pci_bus_find_domain_nr(bus);
6409 : : }
6410 : : #endif
6411 : :
6412 : : /**
6413 : : * pci_ext_cfg_avail - can we access extended PCI config space?
6414 : : *
6415 : : * Returns 1 if we can access PCI extended config space (offsets
6416 : : * greater than 0xff). This is the default implementation. Architecture
6417 : : * implementations can override this.
6418 : : */
6419 : 0 : int __weak pci_ext_cfg_avail(void)
6420 : : {
6421 : 0 : return 1;
6422 : : }
6423 : :
6424 : 0 : void __weak pci_fixup_cardbus(struct pci_bus *bus)
6425 : : {
6426 : 0 : }
6427 : : EXPORT_SYMBOL(pci_fixup_cardbus);
6428 : :
6429 : 0 : static int __init pci_setup(char *str)
6430 : : {
6431 [ # # ]: 0 : while (str) {
6432 : 0 : char *k = strchr(str, ',');
6433 [ # # ]: 0 : if (k)
6434 : 0 : *k++ = 0;
6435 [ # # # # : 0 : if (*str && (str = pcibios_setup(str)) && *str) {
# # ]
6436 [ # # ]: 0 : if (!strcmp(str, "nomsi")) {
6437 : 0 : pci_no_msi();
6438 [ # # ]: 0 : } else if (!strncmp(str, "noats", 5)) {
6439 : 0 : pr_info("PCIe: ATS is disabled\n");
6440 : 0 : pcie_ats_disabled = true;
6441 [ # # ]: 0 : } else if (!strcmp(str, "noaer")) {
6442 : 0 : pci_no_aer();
6443 [ # # ]: 0 : } else if (!strcmp(str, "earlydump")) {
6444 : 0 : pci_early_dump = true;
6445 [ # # ]: 0 : } else if (!strncmp(str, "realloc=", 8)) {
6446 : 0 : pci_realloc_get_opt(str + 8);
6447 [ # # ]: 0 : } else if (!strncmp(str, "realloc", 7)) {
6448 : 0 : pci_realloc_get_opt("on");
6449 [ # # ]: 0 : } else if (!strcmp(str, "nodomains")) {
6450 : 0 : pci_no_domains();
6451 [ # # ]: 0 : } else if (!strncmp(str, "noari", 5)) {
6452 : 0 : pcie_ari_disabled = true;
6453 [ # # ]: 0 : } else if (!strncmp(str, "cbiosize=", 9)) {
6454 : 0 : pci_cardbus_io_size = memparse(str + 9, &str);
6455 [ # # ]: 0 : } else if (!strncmp(str, "cbmemsize=", 10)) {
6456 : 0 : pci_cardbus_mem_size = memparse(str + 10, &str);
6457 [ # # ]: 0 : } else if (!strncmp(str, "resource_alignment=", 19)) {
6458 : 0 : resource_alignment_param = str + 19;
6459 [ # # ]: 0 : } else if (!strncmp(str, "ecrc=", 5)) {
6460 : : pcie_ecrc_get_policy(str + 5);
6461 [ # # ]: 0 : } else if (!strncmp(str, "hpiosize=", 9)) {
6462 : 0 : pci_hotplug_io_size = memparse(str + 9, &str);
6463 [ # # ]: 0 : } else if (!strncmp(str, "hpmmiosize=", 11)) {
6464 : 0 : pci_hotplug_mmio_size = memparse(str + 11, &str);
6465 [ # # ]: 0 : } else if (!strncmp(str, "hpmmioprefsize=", 15)) {
6466 : 0 : pci_hotplug_mmio_pref_size = memparse(str + 15, &str);
6467 [ # # ]: 0 : } else if (!strncmp(str, "hpmemsize=", 10)) {
6468 : 0 : pci_hotplug_mmio_size = memparse(str + 10, &str);
6469 : 0 : pci_hotplug_mmio_pref_size = pci_hotplug_mmio_size;
6470 [ # # ]: 0 : } else if (!strncmp(str, "hpbussize=", 10)) {
6471 : 0 : pci_hotplug_bus_size =
6472 : 0 : simple_strtoul(str + 10, &str, 0);
6473 [ # # ]: 0 : if (pci_hotplug_bus_size > 0xff)
6474 : 0 : pci_hotplug_bus_size = DEFAULT_HOTPLUG_BUS_SIZE;
6475 [ # # ]: 0 : } else if (!strncmp(str, "pcie_bus_tune_off", 17)) {
6476 : 0 : pcie_bus_config = PCIE_BUS_TUNE_OFF;
6477 [ # # ]: 0 : } else if (!strncmp(str, "pcie_bus_safe", 13)) {
6478 : 0 : pcie_bus_config = PCIE_BUS_SAFE;
6479 [ # # ]: 0 : } else if (!strncmp(str, "pcie_bus_perf", 13)) {
6480 : 0 : pcie_bus_config = PCIE_BUS_PERFORMANCE;
6481 [ # # ]: 0 : } else if (!strncmp(str, "pcie_bus_peer2peer", 18)) {
6482 : 0 : pcie_bus_config = PCIE_BUS_PEER2PEER;
6483 [ # # ]: 0 : } else if (!strncmp(str, "pcie_scan_all", 13)) {
6484 : 0 : pci_add_flags(PCI_SCAN_ALL_PCIE_DEVS);
6485 [ # # ]: 0 : } else if (!strncmp(str, "disable_acs_redir=", 18)) {
6486 : 0 : disable_acs_redir_param = str + 18;
6487 : : } else {
6488 : 0 : pr_err("PCI: Unknown option `%s'\n", str);
6489 : : }
6490 : : }
6491 : 0 : str = k;
6492 : : }
6493 : 0 : return 0;
6494 : : }
6495 : : early_param("pci", pci_setup);
6496 : :
6497 : : /*
6498 : : * 'resource_alignment_param' and 'disable_acs_redir_param' are initialized
6499 : : * in pci_setup(), above, to point to data in the __initdata section which
6500 : : * will be freed after the init sequence is complete. We can't allocate memory
6501 : : * in pci_setup() because some architectures do not have any memory allocation
6502 : : * service available during an early_param() call. So we allocate memory and
6503 : : * copy the variable here before the init section is freed.
6504 : : *
6505 : : */
6506 : 30 : static int __init pci_realloc_setup_params(void)
6507 : : {
6508 : 30 : resource_alignment_param = kstrdup(resource_alignment_param,
6509 : : GFP_KERNEL);
6510 : 30 : disable_acs_redir_param = kstrdup(disable_acs_redir_param, GFP_KERNEL);
6511 : :
6512 : 30 : return 0;
6513 : : }
6514 : : pure_initcall(pci_realloc_setup_params);
|
