blob: beacb17e81fb1b29b2c81d88e60469f44a8289c1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * pci.h
3 *
4 * PCI defines and function prototypes
5 * Copyright 1994, Drew Eckhardt
6 * Copyright 1997--1999 Martin Mares <mj@ucw.cz>
7 *
8 * For more information, please consult the following manuals (look at
9 * http://www.pcisig.com/ for how to get them):
10 *
11 * PCI BIOS Specification
12 * PCI Local Bus Specification
13 * PCI to PCI Bridge Specification
14 * PCI System Design Guide
15 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#ifndef LINUX_PCI_H
17#define LINUX_PCI_H
18
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
David Woodhouse778382e2006-04-29 01:46:02 +010020#include <linux/mod_devicetable.h>
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/types.h>
Sam Ravnborg98db6f12008-04-29 22:38:48 +020023#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/ioport.h>
25#include <linux/list.h>
Andrew Morton4a7fb632006-08-14 22:43:17 -070026#include <linux/compiler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/errno.h>
Alex Chiangf46753c2008-06-10 15:28:50 -060028#include <linux/kobject.h>
Arun Sharma600634972011-07-26 16:09:06 -070029#include <linux/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/device.h>
Stephen Rothwell1388cc92008-10-22 13:39:55 +110031#include <linux/io.h>
Jiang Liu14d76b62015-02-05 13:44:44 +080032#include <linux/resource_ext.h>
David Howells607ca462012-10-13 10:46:48 +010033#include <uapi/linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Adrian Bunk7e7a43c2006-12-19 13:12:07 -080035#include <linux/pci_ids.h>
36
Shuah Khan85467132013-02-27 17:06:45 -070037/*
38 * The PCI interface treats multi-function devices as independent
39 * devices. The slot/function address of each device is encoded
40 * in a single byte as follows:
41 *
42 * 7:3 = slot
43 * 2:0 = function
Bjorn Helgaasf7625982013-11-14 11:28:18 -070044 *
45 * PCI_DEVFN(), PCI_SLOT(), and PCI_FUNC() are defined in uapi/linux/pci.h.
Shuah Khan85467132013-02-27 17:06:45 -070046 * In the interest of not exposing interfaces to user-space unnecessarily,
Bjorn Helgaasf7625982013-11-14 11:28:18 -070047 * the following kernel-only defines are being added here.
Shuah Khan85467132013-02-27 17:06:45 -070048 */
Megan Kamiya63ddc0b2014-09-05 20:19:10 -070049#define PCI_DEVID(bus, devfn) ((((u16)(bus)) << 8) | (devfn))
Shuah Khan85467132013-02-27 17:06:45 -070050/* return bus from PCI devid = ((u16)bus_number) << 8) | devfn */
51#define PCI_BUS_NUM(x) (((x) >> 8) & 0xff)
52
Alex Chiangf46753c2008-06-10 15:28:50 -060053/* pci_slot represents a physical slot */
54struct pci_slot {
55 struct pci_bus *bus; /* The bus this slot is on */
56 struct list_head list; /* node in list of slots on this bus */
57 struct hotplug_slot *hotplug; /* Hotplug info (migrate over time) */
58 unsigned char number; /* PCI_SLOT(pci_dev->devfn) */
59 struct kobject kobj;
60};
61
Alex Chiang0ad772e2008-10-20 17:41:07 -060062static inline const char *pci_slot_name(const struct pci_slot *slot)
63{
64 return kobject_name(&slot->kobj);
65}
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067/* File state for mmap()s on /proc/bus/pci/X/Y */
68enum pci_mmap_state {
69 pci_mmap_io,
70 pci_mmap_mem
71};
72
Yu Zhaofde09c62008-11-22 02:39:32 +080073/*
74 * For PCI devices, the region numbers are assigned this way:
75 */
76enum {
77 /* #0-5: standard PCI resources */
78 PCI_STD_RESOURCES,
79 PCI_STD_RESOURCE_END = 5,
80
81 /* #6: expansion ROM resource */
82 PCI_ROM_RESOURCE,
83
Yu Zhaod1b054d2009-03-20 11:25:11 +080084 /* device specific resources */
85#ifdef CONFIG_PCI_IOV
86 PCI_IOV_RESOURCES,
87 PCI_IOV_RESOURCE_END = PCI_IOV_RESOURCES + PCI_SRIOV_NUM_BARS - 1,
88#endif
89
Yu Zhaofde09c62008-11-22 02:39:32 +080090 /* resources assigned to buses behind the bridge */
91#define PCI_BRIDGE_RESOURCE_NUM 4
92
93 PCI_BRIDGE_RESOURCES,
94 PCI_BRIDGE_RESOURCE_END = PCI_BRIDGE_RESOURCES +
95 PCI_BRIDGE_RESOURCE_NUM - 1,
96
97 /* total resources associated with a PCI device */
98 PCI_NUM_RESOURCES,
99
100 /* preserve this for compatibility */
Yinghai Lucda57bf2012-01-04 15:49:45 -0800101 DEVICE_COUNT_RESOURCE = PCI_NUM_RESOURCES,
Yu Zhaofde09c62008-11-22 02:39:32 +0800102};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Bjorn Helgaas224abb62016-06-17 15:23:52 -0500104/*
105 * pci_power_t values must match the bits in the Capabilities PME_Support
106 * and Control/Status PowerState fields in the Power Management capability.
107 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108typedef int __bitwise pci_power_t;
109
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -0700110#define PCI_D0 ((pci_power_t __force) 0)
111#define PCI_D1 ((pci_power_t __force) 1)
112#define PCI_D2 ((pci_power_t __force) 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113#define PCI_D3hot ((pci_power_t __force) 3)
114#define PCI_D3cold ((pci_power_t __force) 4)
Daniel Ritz3fe9d192005-08-17 15:32:19 -0700115#define PCI_UNKNOWN ((pci_power_t __force) 5)
Pavel Machek438510f2005-04-16 15:25:24 -0700116#define PCI_POWER_ERROR ((pci_power_t __force) -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Alan Stern00240c32009-04-27 13:33:16 -0400118/* Remember to update this when the list above changes! */
119extern const char *pci_power_names[];
120
121static inline const char *pci_power_name(pci_power_t state)
122{
Andy Shevchenko9661e782016-06-07 20:48:33 +0300123 return pci_power_names[1 + (__force int) state];
Alan Stern00240c32009-04-27 13:33:16 -0400124}
125
Huang Ying448bd852012-06-23 10:23:51 +0800126#define PCI_PM_D2_DELAY 200
127#define PCI_PM_D3_WAIT 10
128#define PCI_PM_D3COLD_WAIT 100
129#define PCI_PM_BUS_WAIT 50
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100130
linas392a1ce2005-11-16 17:10:41 -0600131/** The pci_channel state describes connectivity between the CPU and
132 * the pci device. If some PCI bus between here and the pci device
133 * has crashed or locked up, this info is reflected here.
134 */
135typedef unsigned int __bitwise pci_channel_state_t;
136
137enum pci_channel_state {
138 /* I/O channel is in normal state */
139 pci_channel_io_normal = (__force pci_channel_state_t) 1,
140
141 /* I/O to channel is blocked */
142 pci_channel_io_frozen = (__force pci_channel_state_t) 2,
143
144 /* PCI card is dead */
145 pci_channel_io_perm_failure = (__force pci_channel_state_t) 3,
146};
147
Brian Kingf7bdd122007-04-06 16:39:36 -0500148typedef unsigned int __bitwise pcie_reset_state_t;
149
150enum pcie_reset_state {
151 /* Reset is NOT asserted (Use to deassert reset) */
152 pcie_deassert_reset = (__force pcie_reset_state_t) 1,
153
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700154 /* Use #PERST to reset PCIe device */
Brian Kingf7bdd122007-04-06 16:39:36 -0500155 pcie_warm_reset = (__force pcie_reset_state_t) 2,
156
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700157 /* Use PCIe Hot Reset to reset device */
Brian Kingf7bdd122007-04-06 16:39:36 -0500158 pcie_hot_reset = (__force pcie_reset_state_t) 3
159};
160
David Millerba698ad2007-10-25 01:16:30 -0700161typedef unsigned short __bitwise pci_dev_flags_t;
162enum pci_dev_flags {
163 /* INTX_DISABLE in PCI_COMMAND register disables MSI
164 * generation too.
165 */
Alex Williamson6b121592014-05-22 17:07:36 -0600166 PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG = (__force pci_dev_flags_t) (1 << 0),
Alan Cox979b1792008-07-24 17:18:38 +0100167 /* Device configuration is irrevocably lost if disabled into D3 */
Alex Williamson6b121592014-05-22 17:07:36 -0600168 PCI_DEV_FLAGS_NO_D3 = (__force pci_dev_flags_t) (1 << 1),
Greg Rose67778292011-07-22 05:46:07 +0000169 /* Provide indication device is assigned by a Virtual Machine Manager */
Alex Williamson6b121592014-05-22 17:07:36 -0600170 PCI_DEV_FLAGS_ASSIGNED = (__force pci_dev_flags_t) (1 << 2),
Alex Williamson5757a762014-02-03 14:27:39 -0700171 /* Flag for quirk use to store if quirk-specific ACS is enabled */
Alex Williamson6b121592014-05-22 17:07:36 -0600172 PCI_DEV_FLAGS_ACS_ENABLED_QUIRK = (__force pci_dev_flags_t) (1 << 3),
Alex Williamsonc8fe16e2014-05-28 14:57:02 -0600173 /* Use a PCIe-to-PCI bridge alias even if !pci_is_pcie */
174 PCI_DEV_FLAG_PCIE_BRIDGE_ALIAS = (__force pci_dev_flags_t) (1 << 5),
Alex Williamsonf331a852015-01-15 18:16:04 -0600175 /* Do not use bus resets for device */
176 PCI_DEV_FLAGS_NO_BUS_RESET = (__force pci_dev_flags_t) (1 << 6),
Alex Williamson51e53732014-11-21 11:24:08 -0700177 /* Do not use PM reset even if device advertises NoSoftRst- */
178 PCI_DEV_FLAGS_NO_PM_RESET = (__force pci_dev_flags_t) (1 << 7),
Mark Rustad932c4352015-07-13 11:40:02 -0700179 /* Get VPD from function 0 VPD */
180 PCI_DEV_FLAGS_VPD_REF_F0 = (__force pci_dev_flags_t) (1 << 8),
David Millerba698ad2007-10-25 01:16:30 -0700181};
182
Stefan Assmanne1d3a902008-06-11 16:35:17 +0200183enum pci_irq_reroute_variant {
184 INTEL_IRQ_REROUTE_VARIANT = 1,
185 MAX_IRQ_REROUTE_VARIANTS = 3
186};
187
Michael S. Tsirkin6e325a62006-02-14 18:52:22 +0200188typedef unsigned short __bitwise pci_bus_flags_t;
189enum pci_bus_flags {
Jon Derrick032c3d82016-08-25 17:26:10 -0600190 PCI_BUS_FLAGS_NO_MSI = (__force pci_bus_flags_t) 1,
191 PCI_BUS_FLAGS_NO_MMRBC = (__force pci_bus_flags_t) 2,
192 PCI_BUS_FLAGS_NO_AERSID = (__force pci_bus_flags_t) 4,
Michael S. Tsirkin6e325a62006-02-14 18:52:22 +0200193};
194
Jacob Keller59da3812013-07-31 06:53:21 +0000195/* These values come from the PCI Express Spec */
196enum pcie_link_width {
197 PCIE_LNK_WIDTH_RESRV = 0x00,
198 PCIE_LNK_X1 = 0x01,
199 PCIE_LNK_X2 = 0x02,
200 PCIE_LNK_X4 = 0x04,
201 PCIE_LNK_X8 = 0x08,
202 PCIE_LNK_X12 = 0x0C,
203 PCIE_LNK_X16 = 0x10,
204 PCIE_LNK_X32 = 0x20,
205 PCIE_LNK_WIDTH_UNKNOWN = 0xFF,
206};
207
Matthew Wilcox536c8cb2009-12-13 08:11:31 -0500208/* Based on the PCI Hotplug Spec, but some values are made up by us */
209enum pci_bus_speed {
210 PCI_SPEED_33MHz = 0x00,
211 PCI_SPEED_66MHz = 0x01,
212 PCI_SPEED_66MHz_PCIX = 0x02,
213 PCI_SPEED_100MHz_PCIX = 0x03,
214 PCI_SPEED_133MHz_PCIX = 0x04,
215 PCI_SPEED_66MHz_PCIX_ECC = 0x05,
216 PCI_SPEED_100MHz_PCIX_ECC = 0x06,
217 PCI_SPEED_133MHz_PCIX_ECC = 0x07,
218 PCI_SPEED_66MHz_PCIX_266 = 0x09,
219 PCI_SPEED_100MHz_PCIX_266 = 0x0a,
220 PCI_SPEED_133MHz_PCIX_266 = 0x0b,
Matthew Wilcox45b4cdd52009-12-13 08:11:34 -0500221 AGP_UNKNOWN = 0x0c,
222 AGP_1X = 0x0d,
223 AGP_2X = 0x0e,
224 AGP_4X = 0x0f,
225 AGP_8X = 0x10,
Matthew Wilcox536c8cb2009-12-13 08:11:31 -0500226 PCI_SPEED_66MHz_PCIX_533 = 0x11,
227 PCI_SPEED_100MHz_PCIX_533 = 0x12,
228 PCI_SPEED_133MHz_PCIX_533 = 0x13,
229 PCIE_SPEED_2_5GT = 0x14,
230 PCIE_SPEED_5_0GT = 0x15,
Matthew Wilcox9dfd97f2009-12-13 08:11:35 -0500231 PCIE_SPEED_8_0GT = 0x16,
Matthew Wilcox536c8cb2009-12-13 08:11:31 -0500232 PCI_SPEED_UNKNOWN = 0xff,
233};
234
Alex Williamson24a4742f2011-05-10 10:02:11 -0600235struct pci_cap_saved_data {
Alex Williamsonfd0f7f72013-12-17 16:43:45 -0700236 u16 cap_nr;
237 bool cap_extended;
Alex Williamson24a4742f2011-05-10 10:02:11 -0600238 unsigned int size;
239 u32 data[0];
240};
241
Shaohua Li41017f02006-02-08 17:11:38 +0800242struct pci_cap_saved_state {
243 struct hlist_node next;
Alex Williamson24a4742f2011-05-10 10:02:11 -0600244 struct pci_cap_saved_data cap;
Shaohua Li41017f02006-02-08 17:11:38 +0800245};
246
Shaohua Li7d715a62008-02-25 09:46:41 +0800247struct pcie_link_state;
Jesse Barnesee69439c2008-04-28 12:30:35 -0700248struct pci_vpd;
Yu Zhaod1b054d2009-03-20 11:25:11 +0800249struct pci_sriov;
Yu Zhao302b4212009-05-18 13:51:32 +0800250struct pci_ats;
Jesse Barnesee69439c2008-04-28 12:30:35 -0700251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252/*
253 * The pci_dev structure is used to describe PCI devices.
254 */
255struct pci_dev {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 struct list_head bus_list; /* node in per-bus list */
257 struct pci_bus *bus; /* bus this device is on */
258 struct pci_bus *subordinate; /* bus this device bridges to */
259
260 void *sysdata; /* hook for sys-specific extension */
261 struct proc_dir_entry *procent; /* device entry in /proc/bus/pci */
Alex Chiangf46753c2008-06-10 15:28:50 -0600262 struct pci_slot *slot; /* Physical slot this device is in */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 unsigned int devfn; /* encoded device & function index */
265 unsigned short vendor;
266 unsigned short device;
267 unsigned short subsystem_vendor;
268 unsigned short subsystem_device;
269 unsigned int class; /* 3 bytes: (base,sub,prog-if) */
Auke Kokb8a3a522007-06-08 15:46:30 -0700270 u8 revision; /* PCI revision, low byte of class word */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 u8 hdr_type; /* PCI header type (`multi' flag masked out) */
Keith Busch66b80802016-09-27 16:23:34 -0400272#ifdef CONFIG_PCIEAER
273 u16 aer_cap; /* AER capability offset */
274#endif
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700275 u8 pcie_cap; /* PCIe capability offset */
Gavin Shane375b562013-04-04 16:54:30 +0000276 u8 msi_cap; /* MSI capability offset */
277 u8 msix_cap; /* MSI-X capability offset */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700278 u8 pcie_mpss:3; /* PCIe Max Payload Size Supported */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 u8 rom_base_reg; /* which config register controls the ROM */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700280 u8 pin; /* which interrupt pin this device uses */
281 u16 pcie_flags_reg; /* cached PCIe Capabilities Register */
Jacek Lawrynowicz338c3142016-03-03 15:38:02 +0100282 unsigned long *dma_alias_mask;/* mask of enabled devfn aliases */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
284 struct pci_driver *driver; /* which driver has allocated this device */
285 u64 dma_mask; /* Mask of the bits of bus address this
286 device implements. Normally this is
287 0xffffffff. You only need to change
288 this if your device has broken DMA
289 or supports 64-bit transfers. */
290
FUJITA Tomonori4d57cdf2008-02-04 22:27:55 -0800291 struct device_dma_parameters dma_parms;
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 pci_power_t current_state; /* Current operating state. In ACPI-speak,
294 this is D0-D3, D0 being fully functional,
295 and D3 being off. */
Bjorn Helgaas703860e2013-04-17 16:57:56 -0600296 u8 pm_cap; /* PM capability offset */
Rafael J. Wysocki337001b2008-07-07 03:36:24 +0200297 unsigned int pme_support:5; /* Bitmask of states from which PME#
298 can be generated */
Rafael J. Wysockic7f48652010-02-17 23:39:08 +0100299 unsigned int pme_interrupt:1;
Rafael J. Wysocki379021d2011-10-03 23:16:33 +0200300 unsigned int pme_poll:1; /* Poll device's PME status bit */
Rafael J. Wysocki337001b2008-07-07 03:36:24 +0200301 unsigned int d1_support:1; /* Low power state D1 is supported */
302 unsigned int d2_support:1; /* Low power state D2 is supported */
Huang Ying448bd852012-06-23 10:23:51 +0800303 unsigned int no_d1d2:1; /* D1 and D2 are forbidden */
304 unsigned int no_d3cold:1; /* D3cold is forbidden */
Mika Westerberg9d26d3a2016-06-02 11:17:12 +0300305 unsigned int bridge_d3:1; /* Allow D3 for bridge */
Huang Ying448bd852012-06-23 10:23:51 +0800306 unsigned int d3cold_allowed:1; /* D3cold is allowed by user */
Jacob Pan253d2e52010-07-16 10:19:22 -0700307 unsigned int mmio_always_on:1; /* disallow turning off io/mem
308 decoding during bar sizing */
Rafael J. Wysockie80bb092009-09-08 23:14:49 +0200309 unsigned int wakeup_prepared:1;
Huang Ying448bd852012-06-23 10:23:51 +0800310 unsigned int runtime_d3cold:1; /* whether go through runtime
311 D3cold, not set for devices
312 powered on/off by the
313 corresponding bridge */
Bjorn Helgaasb440bde2014-09-10 13:45:01 -0600314 unsigned int ignore_hotplug:1; /* Ignore hotplug events */
Keith Busch576243b2016-09-13 10:31:59 -0600315 unsigned int hotplug_user_indicators:1; /* SlotCtl indicators
316 controlled exclusively by
317 user sysfs */
Rafael J. Wysocki1ae861e2009-12-31 12:15:54 +0100318 unsigned int d3_delay; /* D3->D0 transition time in ms */
Huang Ying448bd852012-06-23 10:23:51 +0800319 unsigned int d3cold_delay; /* D3cold->D0 transition time in ms */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320
Shaohua Li7d715a62008-02-25 09:46:41 +0800321#ifdef CONFIG_PCIEASPM
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700322 struct pcie_link_state *link_state; /* ASPM link state */
Shaohua Li7d715a62008-02-25 09:46:41 +0800323#endif
324
linas392a1ce2005-11-16 17:10:41 -0600325 pci_channel_state_t error_state; /* current connectivity state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 struct device dev; /* Generic device interface */
327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 int cfg_size; /* Size of configuration space */
329
330 /*
331 * Instead of touching interrupt line and base address registers
332 * directly, use the values stored here. They might be different!
333 */
334 unsigned int irq;
Christoph Hellwig4ef33682016-07-12 18:20:18 +0900335 struct cpumask *irq_affinity;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
337
Yinghai Lu58d9a382013-01-21 13:20:51 -0800338 bool match_driver; /* Skip attaching driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 /* These fields are used by common fixups */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700340 unsigned int transparent:1; /* Subtractive decode PCI bridge */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 unsigned int multifunction:1;/* Part of multi-function device */
342 /* keep track of device state */
Greg Kroah-Hartman8a1bc902008-02-14 14:56:56 -0800343 unsigned int is_added:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 unsigned int is_busmaster:1; /* device is busmaster */
Kristen Accardi4602b882005-08-16 15:15:58 -0700345 unsigned int no_msi:1; /* device may not use msi */
Benjamin Herrenschmidtf144d142014-10-03 15:13:24 +1000346 unsigned int no_64bit_msi:1; /* device may only use 32-bit MSIs */
Jan Kiszkafb51ccb2011-11-04 09:45:59 +0100347 unsigned int block_cfg_access:1; /* config space access is blocked */
Doug Thompsonbd8481e2006-05-08 17:06:09 -0700348 unsigned int broken_parity_status:1; /* Device generates false positive parity */
Stefan Assmanne1d3a902008-06-11 16:35:17 +0200349 unsigned int irq_reroute_variant:2; /* device needs IRQ rerouting variant */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700350 unsigned int msi_enabled:1;
Shaohua Li99dc8042006-05-26 10:58:27 +0800351 unsigned int msix_enabled:1;
Yu Zhao58c3a722008-10-14 14:02:53 +0800352 unsigned int ari_enabled:1; /* ARI forwarding */
Bjorn Helgaasd544d752015-07-17 15:15:19 -0500353 unsigned int ats_enabled:1; /* Address Translation Service */
Tejun Heo9ac78492007-01-20 16:00:26 +0900354 unsigned int is_managed:1;
Mike Mason260d7032009-07-30 15:33:21 -0700355 unsigned int needs_freset:1; /* Dev requires fundamental reset */
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100356 unsigned int state_saved:1;
Yu Zhaod1b054d2009-03-20 11:25:11 +0800357 unsigned int is_physfn:1;
Yu Zhaodd7cc442009-03-20 11:25:15 +0800358 unsigned int is_virtfn:1;
Michael S. Tsirkin711d5772009-07-27 23:37:48 +0300359 unsigned int reset_fn:1;
Eric W. Biederman28760482009-09-09 14:09:24 -0700360 unsigned int is_hotplug_bridge:1;
Huang Yingaffb72c2010-05-18 14:35:16 +0800361 unsigned int __aer_firmware_first_valid:1;
362 unsigned int __aer_firmware_first:1;
Bjorn Helgaasfbebb9f2012-06-16 14:40:22 -0600363 unsigned int broken_intx_masking:1;
Bjorn Helgaas2b28ae12012-07-09 13:38:57 -0600364 unsigned int io_window_1k:1; /* Intel P2P bridge 1K I/O windows */
Jiang Liucffe0a22014-10-27 13:21:42 +0800365 unsigned int irq_managed:1;
Yijing Wangd0751b92015-05-21 15:05:02 +0800366 unsigned int has_secondary_link:1;
Bjorn Helgaasb84106b2016-02-25 14:35:57 -0600367 unsigned int non_compliant_bars:1; /* broken BARs; ignore them */
David Millerba698ad2007-10-25 01:16:30 -0700368 pci_dev_flags_t dev_flags;
Inaky Perez-Gonzalezbae94d02006-11-22 12:40:31 -0800369 atomic_t enable_cnt; /* pci_enable_device has been called */
Kristen Accardi4602b882005-08-16 15:15:58 -0700370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 u32 saved_config_space[16]; /* config space saved at suspend time */
Shaohua Li41017f02006-02-08 17:11:38 +0800372 struct hlist_head saved_cap_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */
374 int rom_attr_enabled; /* has display of the rom attribute been enabled? */
375 struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700376 struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE]; /* sysfs file for WC mapping of resources */
Jonathan Yong9bb04a02016-06-11 14:13:38 -0500377
378#ifdef CONFIG_PCIE_PTM
379 unsigned int ptm_root:1;
380 unsigned int ptm_enabled:1;
Bjorn Helgaas8b2ec3182016-06-12 16:26:40 -0500381 u8 ptm_granularity;
Jonathan Yong9bb04a02016-06-11 14:13:38 -0500382#endif
Eric W. Biedermanded86d82007-01-28 12:42:52 -0700383#ifdef CONFIG_PCI_MSI
Greg Kroah-Hartman1c51b502013-12-19 12:30:17 -0800384 const struct attribute_group **msi_irq_groups;
Eric W. Biedermanded86d82007-01-28 12:42:52 -0700385#endif
Ben Hutchings94e61082008-03-05 16:52:39 +0000386 struct pci_vpd *vpd;
Joerg Roedel466b3dd2011-10-30 16:35:08 +0100387#ifdef CONFIG_PCI_ATS
Yu Zhaodd7cc442009-03-20 11:25:15 +0800388 union {
389 struct pci_sriov *sriov; /* SR-IOV capability related */
390 struct pci_dev *physfn; /* the PF this VF is associated with */
391 };
Bjorn Helgaas67930992015-07-17 15:27:34 -0500392 u16 ats_cap; /* ATS Capability offset */
393 u8 ats_stu; /* ATS Smallest Translation Unit */
Bjorn Helgaasd544d752015-07-17 15:15:19 -0500394 atomic_t ats_ref_cnt; /* number of VFs with ATS enabled */
Yu Zhaod1b054d2009-03-20 11:25:11 +0800395#endif
Bjorn Helgaasdbd3fc32012-12-10 11:24:42 -0700396 phys_addr_t rom; /* Physical address of ROM if it's not from the BAR */
Matthew Garrett84c1b802012-12-05 14:33:27 -0700397 size_t romlen; /* Length of ROM if it's not from the BAR */
Alex Williamson782a9852014-05-20 08:53:21 -0600398 char *driver_override; /* Driver name to force a match */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399};
400
Yinghaidda56542010-04-09 01:07:55 +0100401static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
402{
403#ifdef CONFIG_PCI_IOV
404 if (dev->is_virtfn)
405 dev = dev->physfn;
406#endif
Yinghaidda56542010-04-09 01:07:55 +0100407 return dev;
408}
409
Gu Zheng3c6e6ae2013-05-25 21:48:30 +0800410struct pci_dev *pci_alloc_dev(struct pci_bus *bus);
Michael Ellerman65891212007-04-05 17:19:08 +1000411
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412#define to_pci_dev(n) container_of(n, struct pci_dev, dev)
413#define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
414
Linas Vepstasa7369f12006-12-12 16:55:59 -0600415static inline int pci_channel_offline(struct pci_dev *pdev)
416{
417 return (pdev->error_state != pci_channel_io_normal);
418}
419
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700420struct pci_host_bridge {
Yinghai Lu7b543662012-04-02 18:31:53 -0700421 struct device dev;
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700422 struct pci_bus *bus; /* root bus */
Arnd Bergmann37d6a0a2016-11-25 11:57:09 +0100423 struct pci_ops *ops;
424 void *sysdata;
425 int busnr;
Jiang Liu14d76b62015-02-05 13:44:44 +0800426 struct list_head windows; /* resource_entry */
Yinghai Lu4fa26492012-04-02 18:31:53 -0700427 void (*release_fn)(struct pci_host_bridge *);
428 void *release_data;
Arnd Bergmann37d6a0a2016-11-25 11:57:09 +0100429 struct msi_controller *msi;
Aaron Lue33caa82015-03-25 14:37:06 +0800430 unsigned int ignore_reset_delay:1; /* for entire hierarchy */
Gabriele Paoloni7c7a0e92015-11-11 09:12:25 +0800431 /* Resource alignment requirements */
432 resource_size_t (*align_resource)(struct pci_dev *dev,
433 const struct resource *res,
434 resource_size_t start,
435 resource_size_t size,
436 resource_size_t align);
Thierry Reding59094062016-11-25 11:57:10 +0100437 unsigned long private[0] ____cacheline_aligned;
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700438};
Shaohua Li41017f02006-02-08 17:11:38 +0800439
Yinghai Lu7b543662012-04-02 18:31:53 -0700440#define to_pci_host_bridge(n) container_of(n, struct pci_host_bridge, dev)
Gabriele Paoloni7c7a0e92015-11-11 09:12:25 +0800441
Thierry Reding59094062016-11-25 11:57:10 +0100442static inline void *pci_host_bridge_priv(struct pci_host_bridge *bridge)
443{
444 return (void *)bridge->private;
445}
446
447static inline struct pci_host_bridge *pci_host_bridge_from_priv(void *priv)
448{
449 return container_of(priv, struct pci_host_bridge, private);
450}
451
Gabriele Paoloni7c7a0e92015-11-11 09:12:25 +0800452struct pci_host_bridge *pci_find_host_bridge(struct pci_bus *bus);
453
Yinghai Lu4fa26492012-04-02 18:31:53 -0700454void pci_set_host_bridge_release(struct pci_host_bridge *bridge,
455 void (*release_fn)(struct pci_host_bridge *),
456 void *release_data);
Yinghai Lu7b543662012-04-02 18:31:53 -0700457
Rafael J. Wysocki6c0cc952013-01-09 22:33:37 +0100458int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge);
459
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -0700460/*
461 * The first PCI_BRIDGE_RESOURCE_NUM PCI bus resources (those that correspond
462 * to P2P or CardBus bridge windows) go in a table. Additional ones (for
463 * buses below host bridges or subtractive decode bridges) go in the list.
464 * Use pci_bus_for_each_resource() to iterate through all the resources.
465 */
466
467/*
468 * PCI_SUBTRACTIVE_DECODE means the bridge forwards the window implicitly
469 * and there's no way to program the bridge with the details of the window.
470 * This does not apply to ACPI _CRS windows, even with the _DEC subtractive-
471 * decode bit set, because they are explicit and can be programmed with _SRS.
472 */
473#define PCI_SUBTRACTIVE_DECODE 0x1
474
475struct pci_bus_resource {
476 struct list_head list;
477 struct resource *res;
478 unsigned int flags;
479};
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -0700480
481#define PCI_REGION_FLAG_MASK 0x0fU /* These bits of resource flags tell us the PCI region flags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483struct pci_bus {
484 struct list_head node; /* node in list of buses */
485 struct pci_bus *parent; /* parent bus this bridge is on */
486 struct list_head children; /* list of child buses */
487 struct list_head devices; /* list of devices on this bus */
488 struct pci_dev *self; /* bridge device as seen by parent */
Yijing Wang67546762015-07-17 17:16:31 +0800489 struct list_head slots; /* list of slots on this bus;
490 protected by pci_slot_mutex */
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -0700491 struct resource *resource[PCI_BRIDGE_RESOURCE_NUM];
492 struct list_head resources; /* address space routed to this bus */
Yinghai Lu92f02432012-05-17 18:51:11 -0700493 struct resource busn_res; /* bus numbers routed to this bus */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
495 struct pci_ops *ops; /* configuration access functions */
Yijing Wangc2791b82014-11-11 17:45:45 -0700496 struct msi_controller *msi; /* MSI controller */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 void *sysdata; /* hook for sys-specific extension */
498 struct proc_dir_entry *procdir; /* directory entry in /proc/bus/pci */
499
500 unsigned char number; /* bus number */
501 unsigned char primary; /* number of primary bridge */
Matthew Wilcox3749c512009-12-13 08:11:32 -0500502 unsigned char max_bus_speed; /* enum pci_bus_speed */
503 unsigned char cur_bus_speed; /* enum pci_bus_speed */
Catalin Marinas670ba0c2014-09-29 15:29:26 +0100504#ifdef CONFIG_PCI_DOMAINS_GENERIC
505 int domain_nr;
506#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
508 char name[48];
509
510 unsigned short bridge_ctl; /* manage NO_ISA/FBB/et al behaviors */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700511 pci_bus_flags_t bus_flags; /* inherited by child buses */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 struct device *bridge;
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400513 struct device dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 struct bin_attribute *legacy_io; /* legacy I/O for this bus */
515 struct bin_attribute *legacy_mem; /* legacy mem */
Greg Kroah-Hartmancc74d962008-03-12 21:48:03 -0700516 unsigned int is_added:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517};
518
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400519#define to_pci_bus(n) container_of(n, struct pci_bus, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600521/*
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700522 * Returns true if the PCI bus is root (behind host-PCI bridge),
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600523 * false otherwise
Bjorn Helgaas77a0dfc2013-09-24 15:14:57 -0600524 *
525 * Some code assumes that "bus->self == NULL" means that bus is a root bus.
526 * This is incorrect because "virtual" buses added for SR-IOV (via
527 * virtfn_add_bus()) have "bus->self == NULL" but are not root buses.
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600528 */
529static inline bool pci_is_root_bus(struct pci_bus *pbus)
530{
531 return !(pbus->parent);
532}
533
Yijing Wang1c864382014-05-04 12:23:37 +0800534/**
535 * pci_is_bridge - check if the PCI device is a bridge
536 * @dev: PCI device
537 *
538 * Return true if the PCI device is bridge whether it has subordinate
539 * or not.
540 */
541static inline bool pci_is_bridge(struct pci_dev *dev)
542{
543 return dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
544 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS;
545}
546
Bjorn Helgaasc6bde212013-11-06 10:11:48 -0700547static inline struct pci_dev *pci_upstream_bridge(struct pci_dev *dev)
548{
549 dev = pci_physfn(dev);
550 if (pci_is_root_bus(dev->bus))
551 return NULL;
552
553 return dev->bus->self;
554}
555
Murali Karicheri6675a602015-03-03 12:52:11 -0500556struct device *pci_get_host_bridge_device(struct pci_dev *dev);
557void pci_put_host_bridge_device(struct device *dev);
558
Rafael J. Wysocki16cf0eb2009-01-05 14:50:27 +0100559#ifdef CONFIG_PCI_MSI
560static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev)
561{
562 return pci_dev->msi_enabled || pci_dev->msix_enabled;
563}
564#else
565static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev) { return false; }
566#endif
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568/*
569 * Error values that may be returned by PCI functions.
570 */
571#define PCIBIOS_SUCCESSFUL 0x00
572#define PCIBIOS_FUNC_NOT_SUPPORTED 0x81
573#define PCIBIOS_BAD_VENDOR_ID 0x83
574#define PCIBIOS_DEVICE_NOT_FOUND 0x86
575#define PCIBIOS_BAD_REGISTER_NUMBER 0x87
576#define PCIBIOS_SET_FAILED 0x88
577#define PCIBIOS_BUFFER_TOO_SMALL 0x89
578
Alex Williamsona6961652012-06-11 05:27:33 +0000579/*
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700580 * Translate above to generic errno for passing back through non-PCI code.
Alex Williamsona6961652012-06-11 05:27:33 +0000581 */
582static inline int pcibios_err_to_errno(int err)
583{
584 if (err <= PCIBIOS_SUCCESSFUL)
585 return err; /* Assume already errno */
586
587 switch (err) {
588 case PCIBIOS_FUNC_NOT_SUPPORTED:
589 return -ENOENT;
590 case PCIBIOS_BAD_VENDOR_ID:
Gavin Shand97ffe22014-05-21 15:23:30 +1000591 return -ENOTTY;
Alex Williamsona6961652012-06-11 05:27:33 +0000592 case PCIBIOS_DEVICE_NOT_FOUND:
593 return -ENODEV;
594 case PCIBIOS_BAD_REGISTER_NUMBER:
595 return -EFAULT;
596 case PCIBIOS_SET_FAILED:
597 return -EIO;
598 case PCIBIOS_BUFFER_TOO_SMALL:
599 return -ENOSPC;
600 }
601
Gavin Shand97ffe22014-05-21 15:23:30 +1000602 return -ERANGE;
Alex Williamsona6961652012-06-11 05:27:33 +0000603}
604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605/* Low-level architecture-dependent routines */
606
607struct pci_ops {
Thierry Reding057bd2e2016-02-09 15:30:47 +0100608 int (*add_bus)(struct pci_bus *bus);
609 void (*remove_bus)(struct pci_bus *bus);
Rob Herring1f94a942015-01-09 20:34:39 -0600610 void __iomem *(*map_bus)(struct pci_bus *bus, unsigned int devfn, int where);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
612 int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
613};
614
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500615/*
616 * ACPI needs to be able to access PCI config space before we've done a
617 * PCI bus scan and created pci_bus structures.
618 */
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600619int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
620 int reg, int len, u32 *val);
621int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
622 int reg, int len, u32 val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
Yinghai Lu3a9ad0b2015-05-27 17:23:51 -0700624#ifdef CONFIG_PCI_BUS_ADDR_T_64BIT
625typedef u64 pci_bus_addr_t;
626#else
627typedef u32 pci_bus_addr_t;
628#endif
629
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630struct pci_bus_region {
Yinghai Lu3a9ad0b2015-05-27 17:23:51 -0700631 pci_bus_addr_t start;
632 pci_bus_addr_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633};
634
635struct pci_dynids {
636 spinlock_t lock; /* protects list, index */
637 struct list_head list; /* for IDs added at runtime */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638};
639
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700640
641/*
642 * PCI Error Recovery System (PCI-ERS). If a PCI device driver provides
643 * a set of callbacks in struct pci_error_handlers, that device driver
644 * will be notified of PCI bus errors, and will be driven to recovery
645 * when an error occurs.
linas392a1ce2005-11-16 17:10:41 -0600646 */
647
648typedef unsigned int __bitwise pci_ers_result_t;
649
650enum pci_ers_result {
651 /* no result/none/not supported in device driver */
652 PCI_ERS_RESULT_NONE = (__force pci_ers_result_t) 1,
653
654 /* Device driver can recover without slot reset */
655 PCI_ERS_RESULT_CAN_RECOVER = (__force pci_ers_result_t) 2,
656
657 /* Device driver wants slot to be reset. */
658 PCI_ERS_RESULT_NEED_RESET = (__force pci_ers_result_t) 3,
659
660 /* Device has completely failed, is unrecoverable */
661 PCI_ERS_RESULT_DISCONNECT = (__force pci_ers_result_t) 4,
662
663 /* Device driver is fully recovered and operational */
664 PCI_ERS_RESULT_RECOVERED = (__force pci_ers_result_t) 5,
Vijay Mohan Pandarathil918b40532012-11-17 11:47:18 +0000665
666 /* No AER capabilities registered for the driver */
667 PCI_ERS_RESULT_NO_AER_DRIVER = (__force pci_ers_result_t) 6,
linas392a1ce2005-11-16 17:10:41 -0600668};
669
670/* PCI bus error event callbacks */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800671struct pci_error_handlers {
linas392a1ce2005-11-16 17:10:41 -0600672 /* PCI bus error detected on this device */
673 pci_ers_result_t (*error_detected)(struct pci_dev *dev,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800674 enum pci_channel_state error);
linas392a1ce2005-11-16 17:10:41 -0600675
676 /* MMIO has been re-enabled, but not DMA */
677 pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);
678
679 /* PCI Express link has been reset */
680 pci_ers_result_t (*link_reset)(struct pci_dev *dev);
681
682 /* PCI slot has been reset */
683 pci_ers_result_t (*slot_reset)(struct pci_dev *dev);
684
Keith Busch3ebe7f92014-05-02 10:40:42 -0600685 /* PCI function reset prepare or completed */
686 void (*reset_notify)(struct pci_dev *dev, bool prepare);
687
linas392a1ce2005-11-16 17:10:41 -0600688 /* Device driver may resume normal operations */
689 void (*resume)(struct pci_dev *dev);
690};
691
linas392a1ce2005-11-16 17:10:41 -0600692
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693struct module;
694struct pci_driver {
695 struct list_head node;
Stephen Hemminger42b21932010-09-02 14:28:51 -0700696 const char *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 const struct pci_device_id *id_table; /* must be non-NULL for probe to be called */
698 int (*probe) (struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */
699 void (*remove) (struct pci_dev *dev); /* Device removed (NULL if not a hot-plug capable driver) */
700 int (*suspend) (struct pci_dev *dev, pm_message_t state); /* Device suspended */
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700701 int (*suspend_late) (struct pci_dev *dev, pm_message_t state);
702 int (*resume_early) (struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 int (*resume) (struct pci_dev *dev); /* Device woken up */
Greg KHc8958172005-04-08 14:53:31 +0900704 void (*shutdown) (struct pci_dev *dev);
Donald Dutile17893822012-11-05 15:20:36 -0500705 int (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* PF pdev */
Stephen Hemminger49453022012-09-07 09:33:14 -0700706 const struct pci_error_handlers *err_handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 struct device_driver driver;
708 struct pci_dynids dynids;
709};
710
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800711#define to_pci_driver(drv) container_of(drv, struct pci_driver, driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
713/**
714 * PCI_DEVICE - macro used to describe a specific pci device
715 * @vend: the 16 bit PCI Vendor ID
716 * @dev: the 16 bit PCI Device ID
717 *
718 * This macro is used to create a struct pci_device_id that matches a
719 * specific device. The subvendor and subdevice fields will be set to
720 * PCI_ANY_ID.
721 */
722#define PCI_DEVICE(vend,dev) \
723 .vendor = (vend), .device = (dev), \
724 .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
725
726/**
Nithin Nayak Sujir3d567e02012-11-14 14:44:26 +0000727 * PCI_DEVICE_SUB - macro used to describe a specific pci device with subsystem
728 * @vend: the 16 bit PCI Vendor ID
729 * @dev: the 16 bit PCI Device ID
730 * @subvend: the 16 bit PCI Subvendor ID
731 * @subdev: the 16 bit PCI Subdevice ID
732 *
733 * This macro is used to create a struct pci_device_id that matches a
734 * specific device with subsystem information.
735 */
736#define PCI_DEVICE_SUB(vend, dev, subvend, subdev) \
737 .vendor = (vend), .device = (dev), \
738 .subvendor = (subvend), .subdevice = (subdev)
739
740/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
742 * @dev_class: the class, subclass, prog-if triple for this device
743 * @dev_class_mask: the class mask for this device
744 *
745 * This macro is used to create a struct pci_device_id that matches a
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -0700746 * specific PCI class. The vendor, device, subvendor, and subdevice
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 * fields will be set to PCI_ANY_ID.
748 */
749#define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
750 .class = (dev_class), .class_mask = (dev_class_mask), \
751 .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
752 .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
753
Alan Cox1597cac2006-12-04 15:14:45 -0800754/**
755 * PCI_VDEVICE - macro used to describe a specific pci device in short form
Mark Rustadc1309042014-03-31 14:58:39 -0700756 * @vend: the vendor name
757 * @dev: the 16 bit PCI Device ID
Alan Cox1597cac2006-12-04 15:14:45 -0800758 *
759 * This macro is used to create a struct pci_device_id that matches a
760 * specific PCI device. The subvendor, and subdevice fields will be set
761 * to PCI_ANY_ID. The macro allows the next field to follow as the device
762 * private data.
763 */
764
Mark Rustadc1309042014-03-31 14:58:39 -0700765#define PCI_VDEVICE(vend, dev) \
766 .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
767 .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
Alan Cox1597cac2006-12-04 15:14:45 -0800768
Bjorn Helgaas5bbe0292016-02-05 14:57:47 -0600769enum {
770 PCI_REASSIGN_ALL_RSRC = 0x00000001, /* ignore firmware setup */
771 PCI_REASSIGN_ALL_BUS = 0x00000002, /* reassign all bus numbers */
772 PCI_PROBE_ONLY = 0x00000004, /* use existing setup */
773 PCI_CAN_SKIP_ISA_ALIGN = 0x00000008, /* don't do ISA alignment */
774 PCI_ENABLE_PROC_DOMAINS = 0x00000010, /* enable domains in /proc */
775 PCI_COMPAT_DOMAIN_0 = 0x00000020, /* ... except domain 0 */
776 PCI_SCAN_ALL_PCIE_DEVS = 0x00000040, /* scan all, not just dev 0 */
777};
778
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779/* these external functions are only available when PCI support is enabled */
780#ifdef CONFIG_PCI
781
Bjorn Helgaas5bbe0292016-02-05 14:57:47 -0600782extern unsigned int pci_flags;
783
784static inline void pci_set_flags(int flags) { pci_flags = flags; }
785static inline void pci_add_flags(int flags) { pci_flags |= flags; }
786static inline void pci_clear_flags(int flags) { pci_flags &= ~flags; }
787static inline int pci_has_flag(int flag) { return pci_flags & flag; }
788
Bjorn Helgaasa58674f2013-08-22 11:24:44 +0800789void pcie_bus_configure_settings(struct pci_bus *bus);
Jon Masonb03e7492011-07-20 15:20:54 -0500790
791enum pcie_bus_config_types {
Keith Busch27d868b2015-08-24 08:48:16 -0500792 PCIE_BUS_TUNE_OFF, /* don't touch MPS at all */
793 PCIE_BUS_DEFAULT, /* ensure MPS matches upstream bridge */
794 PCIE_BUS_SAFE, /* use largest MPS boot-time devices support */
795 PCIE_BUS_PERFORMANCE, /* use MPS and MRRS for best performance */
796 PCIE_BUS_PEER2PEER, /* set MPS = 128 for all devices */
Jon Masonb03e7492011-07-20 15:20:54 -0500797};
798
799extern enum pcie_bus_config_types pcie_bus_config;
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801extern struct bus_type pci_bus_type;
802
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700803/* Do NOT directly access these two variables, unless you are arch-specific PCI
804 * code, or PCI core code. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805extern struct list_head pci_root_buses; /* list of all known PCI buses */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700806/* Some device drivers need know if PCI is initiated */
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600807int no_pci_devices(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
Yinghai Lu3c449ed2012-11-03 21:39:31 -0700809void pcibios_resource_survey_bus(struct pci_bus *bus);
Wei Yang7b770612016-03-04 10:53:04 +1100810void pcibios_bus_add_device(struct pci_dev *pdev);
Jiang Liu10a95742013-04-12 05:44:20 +0000811void pcibios_add_bus(struct pci_bus *bus);
812void pcibios_remove_bus(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813void pcibios_fixup_bus(struct pci_bus *);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700814int __must_check pcibios_enable_device(struct pci_dev *, int mask);
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700815/* Architecture-specific versions may override this (weak) */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800816char *pcibios_setup(char *str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
818/* Used only when drivers/pci/setup.c is used */
Dominik Brodowski3b7a17f2010-01-01 17:40:50 +0100819resource_size_t pcibios_align_resource(void *, const struct resource *,
Dominik Brodowskib26b2d42010-01-01 17:40:49 +0100820 resource_size_t,
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700821 resource_size_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822void pcibios_update_irq(struct pci_dev *, int irq);
823
Benjamin Herrenschmidt2d1c8612009-12-09 17:52:13 +1100824/* Weak but can be overriden by arch */
825void pci_fixup_cardbus(struct pci_bus *);
826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827/* Generic PCI functions used internally */
828
Yinghai Lufc279852013-12-09 22:54:40 -0800829void pcibios_resource_to_bus(struct pci_bus *bus, struct pci_bus_region *region,
Bjorn Helgaas36a66cd2012-02-23 20:19:00 -0700830 struct resource *res);
Yinghai Lufc279852013-12-09 22:54:40 -0800831void pcibios_bus_to_resource(struct pci_bus *bus, struct resource *res,
Bjorn Helgaas36a66cd2012-02-23 20:19:00 -0700832 struct pci_bus_region *region);
Mauro Carvalho Chehabd1fd4fb2009-07-10 18:39:53 -0300833void pcibios_scan_specific_bus(int busn);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600834struct pci_bus *pci_find_bus(int domain, int busnr);
akpm@linux-foundation.orgc48f1672009-02-03 15:45:26 -0800835void pci_bus_add_devices(const struct pci_bus *bus);
Bjorn Helgaasde4b2f72011-10-28 16:25:55 -0600836struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata);
Bjorn Helgaas166c6372011-10-28 16:25:45 -0600837struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
838 struct pci_ops *ops, void *sysdata,
839 struct list_head *resources);
Yinghai Lu98a35832012-05-18 11:35:50 -0600840int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int busmax);
841int pci_bus_update_busn_res_end(struct pci_bus *b, int busmax);
842void pci_bus_release_busn_res(struct pci_bus *b);
Lorenzo Pieralisid2a79262015-08-03 21:27:10 -0500843struct pci_bus *pci_scan_root_bus_msi(struct device *parent, int bus,
844 struct pci_ops *ops, void *sysdata,
845 struct list_head *resources,
846 struct msi_controller *msi);
Bill Pemberton15856ad2012-11-21 15:35:00 -0500847struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
Bjorn Helgaasa2ebb8272011-10-28 16:25:50 -0600848 struct pci_ops *ops, void *sysdata,
849 struct list_head *resources);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800850struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
851 int busnr);
Matthew Wilcox3749c512009-12-13 08:11:32 -0500852void pcie_update_link_speed(struct pci_bus *bus, u16 link_status);
Alex Chiangf46753c2008-06-10 15:28:50 -0600853struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
Alex Chiang828f3762008-10-20 17:40:52 -0600854 const char *name,
855 struct hotplug_slot *hotplug);
Alex Chiangf46753c2008-06-10 15:28:50 -0600856void pci_destroy_slot(struct pci_slot *slot);
Yijing Wang017ffe62015-07-17 17:16:32 +0800857#ifdef CONFIG_SYSFS
858void pci_dev_assign_slot(struct pci_dev *dev);
859#else
860static inline void pci_dev_assign_slot(struct pci_dev *dev) { }
861#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862int pci_scan_slot(struct pci_bus *bus, int devfn);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800863struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn);
Paul Mackerrascdb9b9f2005-09-06 09:31:03 +1000864void pci_device_add(struct pci_dev *dev, struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865unsigned int pci_scan_child_bus(struct pci_bus *bus);
Yijing Wangc893d132014-05-30 11:01:03 +0800866void pci_bus_add_device(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867void pci_read_bridge_bases(struct pci_bus *child);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800868struct resource *pci_find_parent_resource(const struct pci_dev *dev,
869 struct resource *res);
Hariprasad Shenaic56d4452015-10-18 19:55:04 +0530870struct pci_dev *pci_find_pcie_root_port(struct pci_dev *dev);
John Crispin3df425f2012-04-12 17:33:07 +0200871u8 pci_swizzle_interrupt_pin(const struct pci_dev *dev, u8 pin);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872int pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge);
Bjorn Helgaas68feac82008-12-16 21:36:55 -0700873u8 pci_common_swizzle(struct pci_dev *dev, u8 *pinp);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600874struct pci_dev *pci_dev_get(struct pci_dev *dev);
875void pci_dev_put(struct pci_dev *dev);
876void pci_remove_bus(struct pci_bus *b);
877void pci_stop_and_remove_bus_device(struct pci_dev *dev);
Rafael J. Wysocki9d169472014-01-10 15:22:18 +0100878void pci_stop_and_remove_bus_device_locked(struct pci_dev *dev);
Yinghai Lucdfcc572012-10-30 14:31:38 -0600879void pci_stop_root_bus(struct pci_bus *bus);
880void pci_remove_root_bus(struct pci_bus *bus);
Dominik Brodowskib3743fa2005-09-09 13:03:23 -0700881void pci_setup_cardbus(struct pci_bus *bus);
Gavin Shand366d282016-05-20 16:41:25 +1000882void pcibios_setup_bridge(struct pci_bus *bus, unsigned long type);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600883void pci_sort_breadthfirst(void);
Williams, Mitch Afb8a0d92010-02-10 01:43:04 +0000884#define dev_is_pci(d) ((d)->bus == &pci_bus_type)
885#define dev_is_pf(d) ((dev_is_pci(d) ? to_pci_dev(d)->is_physfn : false))
886#define dev_num_vf(d) ((dev_is_pci(d) ? pci_num_vf(to_pci_dev(d)) : 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
888/* Generic PCI functions exported to card drivers */
889
James Bottomley388c8c12008-08-03 13:02:12 -0500890enum pci_lost_interrupt_reason {
891 PCI_LOST_IRQ_NO_INFORMATION = 0,
892 PCI_LOST_IRQ_DISABLE_MSI,
893 PCI_LOST_IRQ_DISABLE_MSIX,
894 PCI_LOST_IRQ_DISABLE_ACPI,
895};
896enum pci_lost_interrupt_reason pci_lost_interrupt(struct pci_dev *dev);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800897int pci_find_capability(struct pci_dev *dev, int cap);
898int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap);
899int pci_find_ext_capability(struct pci_dev *dev, int cap);
Bjorn Helgaas44a9a362012-07-13 14:24:59 -0600900int pci_find_next_ext_capability(struct pci_dev *dev, int pos, int cap);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800901int pci_find_ht_capability(struct pci_dev *dev, int ht_cap);
902int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap);
Alan Cox29f3eb62006-10-16 16:20:21 -0700903struct pci_bus *pci_find_next_bus(const struct pci_bus *from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
Andrew Mortond42552c2006-10-21 10:24:12 -0700905struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device,
906 struct pci_dev *from);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800907struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 unsigned int ss_vendor, unsigned int ss_device,
Greg KHb08508c2008-08-26 08:20:34 -0700909 struct pci_dev *from);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800910struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);
Andrew Patterson3c299dc2009-10-12 13:14:00 -0600911struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
912 unsigned int devfn);
913static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
914 unsigned int devfn)
915{
916 return pci_get_domain_bus_and_slot(0, bus, devfn);
917}
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800918struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919int pci_dev_present(const struct pci_device_id *ids);
920
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800921int pci_bus_read_config_byte(struct pci_bus *bus, unsigned int devfn,
922 int where, u8 *val);
923int pci_bus_read_config_word(struct pci_bus *bus, unsigned int devfn,
924 int where, u16 *val);
925int pci_bus_read_config_dword(struct pci_bus *bus, unsigned int devfn,
926 int where, u32 *val);
927int pci_bus_write_config_byte(struct pci_bus *bus, unsigned int devfn,
928 int where, u8 val);
929int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn,
930 int where, u16 val);
931int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
932 int where, u32 val);
Rob Herring1f94a942015-01-09 20:34:39 -0600933
934int pci_generic_config_read(struct pci_bus *bus, unsigned int devfn,
935 int where, int size, u32 *val);
936int pci_generic_config_write(struct pci_bus *bus, unsigned int devfn,
937 int where, int size, u32 val);
938int pci_generic_config_read32(struct pci_bus *bus, unsigned int devfn,
939 int where, int size, u32 *val);
940int pci_generic_config_write32(struct pci_bus *bus, unsigned int devfn,
941 int where, int size, u32 val);
942
Huang Yinga72b46c2009-04-24 10:45:17 +0800943struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
Al Virobf362f72012-03-19 00:01:09 +0000945static inline int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800947 return pci_bus_read_config_byte(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948}
Al Virobf362f72012-03-19 00:01:09 +0000949static inline int pci_read_config_word(const struct pci_dev *dev, int where, u16 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800951 return pci_bus_read_config_word(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952}
Al Virobf362f72012-03-19 00:01:09 +0000953static inline int pci_read_config_dword(const struct pci_dev *dev, int where,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800954 u32 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800956 return pci_bus_read_config_dword(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957}
Al Virobf362f72012-03-19 00:01:09 +0000958static inline int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800960 return pci_bus_write_config_byte(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961}
Al Virobf362f72012-03-19 00:01:09 +0000962static inline int pci_write_config_word(const struct pci_dev *dev, int where, u16 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800964 return pci_bus_write_config_word(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965}
Al Virobf362f72012-03-19 00:01:09 +0000966static inline int pci_write_config_dword(const struct pci_dev *dev, int where,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800967 u32 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800969 return pci_bus_write_config_dword(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970}
971
Jiang Liu8c0d3a02012-07-24 17:20:05 +0800972int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val);
973int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val);
974int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val);
975int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val);
976int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos,
977 u16 clear, u16 set);
978int pcie_capability_clear_and_set_dword(struct pci_dev *dev, int pos,
979 u32 clear, u32 set);
980
981static inline int pcie_capability_set_word(struct pci_dev *dev, int pos,
982 u16 set)
983{
984 return pcie_capability_clear_and_set_word(dev, pos, 0, set);
985}
986
987static inline int pcie_capability_set_dword(struct pci_dev *dev, int pos,
988 u32 set)
989{
990 return pcie_capability_clear_and_set_dword(dev, pos, 0, set);
991}
992
993static inline int pcie_capability_clear_word(struct pci_dev *dev, int pos,
994 u16 clear)
995{
996 return pcie_capability_clear_and_set_word(dev, pos, clear, 0);
997}
998
999static inline int pcie_capability_clear_dword(struct pci_dev *dev, int pos,
1000 u32 clear)
1001{
1002 return pcie_capability_clear_and_set_dword(dev, pos, clear, 0);
1003}
1004
Alex Williamsonc63587d2012-06-11 05:27:19 +00001005/* user-space driven config access */
1006int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
1007int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
1008int pci_user_read_config_dword(struct pci_dev *dev, int where, u32 *val);
1009int pci_user_write_config_byte(struct pci_dev *dev, int where, u8 val);
1010int pci_user_write_config_word(struct pci_dev *dev, int where, u16 val);
1011int pci_user_write_config_dword(struct pci_dev *dev, int where, u32 val);
1012
Andrew Morton4a7fb632006-08-14 22:43:17 -07001013int __must_check pci_enable_device(struct pci_dev *dev);
Benjamin Herrenschmidtb7189892007-12-20 15:28:08 +11001014int __must_check pci_enable_device_io(struct pci_dev *dev);
1015int __must_check pci_enable_device_mem(struct pci_dev *dev);
Tejun Heo0b62e132007-07-27 14:43:35 +09001016int __must_check pci_reenable_device(struct pci_dev *);
Tejun Heo9ac78492007-01-20 16:00:26 +09001017int __must_check pcim_enable_device(struct pci_dev *pdev);
1018void pcim_pin_device(struct pci_dev *pdev);
1019
Yuji Shimada296ccb02009-04-03 16:41:46 +09001020static inline int pci_is_enabled(struct pci_dev *pdev)
1021{
1022 return (atomic_read(&pdev->enable_cnt) > 0);
1023}
1024
Tejun Heo9ac78492007-01-20 16:00:26 +09001025static inline int pci_is_managed(struct pci_dev *pdev)
1026{
1027 return pdev->is_managed;
1028}
1029
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030void pci_disable_device(struct pci_dev *dev);
Myron Stowe96c55902011-10-28 15:48:38 -06001031
1032extern unsigned int pcibios_max_latency;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033void pci_set_master(struct pci_dev *dev);
Ben Hutchings6a479072008-12-23 03:08:29 +00001034void pci_clear_master(struct pci_dev *dev);
Myron Stowe96c55902011-10-28 15:48:38 -06001035
Brian Kingf7bdd122007-04-06 16:39:36 -05001036int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
Tejun Heo15ea76d2009-09-22 17:34:48 +09001037int pci_set_cacheline_size(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038#define HAVE_PCI_SET_MWI
Andrew Morton4a7fb632006-08-14 22:43:17 -07001039int __must_check pci_set_mwi(struct pci_dev *dev);
Randy Dunlap694625c2007-07-09 11:55:54 -07001040int pci_try_set_mwi(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041void pci_clear_mwi(struct pci_dev *dev);
Brett M Russa04ce0f2005-08-15 15:23:41 -04001042void pci_intx(struct pci_dev *dev, int enable);
Jan Kiszkaa2e27782011-11-04 09:46:00 +01001043bool pci_intx_mask_supported(struct pci_dev *dev);
1044bool pci_check_and_mask_intx(struct pci_dev *dev);
1045bool pci_check_and_unmask_intx(struct pci_dev *dev);
Alex Williamson157e8762013-12-17 16:43:39 -07001046int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask);
Casey Leedom3775a202013-08-06 15:48:36 +05301047int pci_wait_for_pending_transaction(struct pci_dev *dev);
Peter Orubad556ad42007-05-15 13:59:13 +02001048int pcix_get_max_mmrbc(struct pci_dev *dev);
1049int pcix_get_mmrbc(struct pci_dev *dev);
1050int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
Brice Goglin2637e5b2007-08-14 12:43:48 +02001051int pcie_get_readrq(struct pci_dev *dev);
Peter Orubad556ad42007-05-15 13:59:13 +02001052int pcie_set_readrq(struct pci_dev *dev, int rq);
Jon Masonb03e7492011-07-20 15:20:54 -05001053int pcie_get_mps(struct pci_dev *dev);
1054int pcie_set_mps(struct pci_dev *dev, int mps);
Jacob Keller81377c82013-07-31 06:53:26 +00001055int pcie_get_minimum_link(struct pci_dev *dev, enum pci_bus_speed *speed,
1056 enum pcie_link_width *width);
Yu Zhao8c1c6992009-06-13 15:52:13 +08001057int __pci_reset_function(struct pci_dev *dev);
Konrad Rzeszutek Wilka96d6272012-01-04 14:23:56 -05001058int __pci_reset_function_locked(struct pci_dev *dev);
Sheng Yang8dd7f802008-10-21 17:38:25 +08001059int pci_reset_function(struct pci_dev *dev);
Alex Williamson61cf16d2013-12-16 15:14:31 -07001060int pci_try_reset_function(struct pci_dev *dev);
Alex Williamson9a3d2b92013-08-14 14:06:05 -06001061int pci_probe_reset_slot(struct pci_slot *slot);
Alex Williamson090a3c52013-08-08 14:09:55 -06001062int pci_reset_slot(struct pci_slot *slot);
Alex Williamson61cf16d2013-12-16 15:14:31 -07001063int pci_try_reset_slot(struct pci_slot *slot);
Alex Williamson9a3d2b92013-08-14 14:06:05 -06001064int pci_probe_reset_bus(struct pci_bus *bus);
Alex Williamson090a3c52013-08-08 14:09:55 -06001065int pci_reset_bus(struct pci_bus *bus);
Alex Williamson61cf16d2013-12-16 15:14:31 -07001066int pci_try_reset_bus(struct pci_bus *bus);
Gavin Shan9e330022014-06-19 17:22:44 +10001067void pci_reset_secondary_bus(struct pci_dev *dev);
1068void pcibios_reset_secondary_bus(struct pci_dev *dev);
Alex Williamson64e86742013-08-08 14:09:24 -06001069void pci_reset_bridge_secondary_bus(struct pci_dev *dev);
Yu Zhao14add802008-11-22 02:38:52 +08001070void pci_update_resource(struct pci_dev *dev, int resno);
Andrew Morton4a7fb632006-08-14 22:43:17 -07001071int __must_check pci_assign_resource(struct pci_dev *dev, int i);
Ram Pai2bbc6942011-07-25 13:08:39 -07001072int __must_check pci_reassign_resource(struct pci_dev *dev, int i, resource_size_t add_size, resource_size_t align);
Hidetoshi Setoc87deff2006-12-18 10:31:06 +09001073int pci_select_bars(struct pci_dev *dev, unsigned long flags);
Rafael J. Wysocki8496e852013-12-01 02:34:37 +01001074bool pci_device_is_present(struct pci_dev *pdev);
Rafael J. Wysocki08249652015-04-13 16:23:36 +02001075void pci_ignore_hotplug(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
1077/* ROM control related routines */
Alan Coxe416de52008-09-23 17:25:10 +01001078int pci_enable_rom(struct pci_dev *pdev);
1079void pci_disable_rom(struct pci_dev *pdev);
Dave Jones144a50e2005-08-09 00:20:10 -04001080void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
Timothy S. Nelson97c44832009-01-30 06:12:47 +11001082size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size);
Matthew Garrettfffe01f2013-03-26 17:25:54 -04001083void __iomem __must_check *pci_platform_rom(struct pci_dev *pdev, size_t *size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
1085/* Power management related routines */
1086int pci_save_state(struct pci_dev *dev);
Jon Mason1d3c16a2010-11-30 17:43:26 -06001087void pci_restore_state(struct pci_dev *dev);
Alex Williamsonffbdd3f2011-05-10 10:02:27 -06001088struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
Konrad Rzeszutek Wilk98d9b272014-12-03 16:40:31 -05001089int pci_load_saved_state(struct pci_dev *dev,
1090 struct pci_saved_state *state);
Alex Williamsonffbdd3f2011-05-10 10:02:27 -06001091int pci_load_and_free_saved_state(struct pci_dev *dev,
1092 struct pci_saved_state **state);
Alex Williamsonfd0f7f72013-12-17 16:43:45 -07001093struct pci_cap_saved_state *pci_find_saved_cap(struct pci_dev *dev, char cap);
1094struct pci_cap_saved_state *pci_find_saved_ext_cap(struct pci_dev *dev,
1095 u16 cap);
1096int pci_add_cap_save_buffer(struct pci_dev *dev, char cap, unsigned int size);
1097int pci_add_ext_cap_save_buffer(struct pci_dev *dev,
1098 u16 cap, unsigned int size);
Rafael J. Wysocki0e5dd462009-03-26 22:51:40 +01001099int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state);
Linus Torvalds9c8550e2005-09-09 15:43:46 -07001100int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
1101pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
Rafael J. Wysockie5899e12008-07-19 14:39:24 +02001102bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
Rafael J. Wysocki5a6c9b62008-08-08 00:14:24 +02001103void pci_pme_active(struct pci_dev *dev, bool enable);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001104int __pci_enable_wake(struct pci_dev *dev, pci_power_t state,
1105 bool runtime, bool enable);
Rafael J. Wysocki0235c4f2008-08-18 21:38:00 +02001106int pci_wake_from_d3(struct pci_dev *dev, bool enable);
Rafael J. Wysocki404cc2d2008-07-07 03:35:26 +02001107int pci_prepare_to_sleep(struct pci_dev *dev);
1108int pci_back_from_sleep(struct pci_dev *dev);
Rafael J. Wysockib67ea762010-02-17 23:44:09 +01001109bool pci_dev_run_wake(struct pci_dev *dev);
Matthew Garrettbf4d2902010-10-04 14:22:26 -04001110bool pci_check_pme_status(struct pci_dev *dev);
Matthew Garrettbf4d2902010-10-04 14:22:26 -04001111void pci_pme_wakeup_bus(struct pci_bus *bus);
Mika Westerberg9d26d3a2016-06-02 11:17:12 +03001112void pci_d3cold_enable(struct pci_dev *dev);
1113void pci_d3cold_disable(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001115static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
1116 bool enable)
1117{
1118 return __pci_enable_wake(dev, state, false, enable);
1119}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Alex Williamson425c1b22013-12-17 16:43:51 -07001121/* PCI Virtual Channel */
1122int pci_save_vc_state(struct pci_dev *dev);
1123void pci_restore_vc_state(struct pci_dev *dev);
1124void pci_allocate_vc_save_buffers(struct pci_dev *dev);
Jesse Barnes51c2e0a2011-01-14 08:53:04 -08001125
Benjamin Herrenschmidtbb209c82010-01-26 17:10:03 +00001126/* For use by arch with custom probe code */
1127void set_pcie_port_type(struct pci_dev *pdev);
1128void set_pcie_hotplug_bridge(struct pci_dev *pdev);
1129
Kumar Galace5ccde2007-07-16 23:27:10 -05001130/* Functions for PCI Hotplug drivers to use */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001131int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
Yinghai Lu2f320522012-01-21 02:08:22 -08001132unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge);
Alex Chiang3ed4fd92009-03-20 14:56:25 -06001133unsigned int pci_rescan_bus(struct pci_bus *bus);
Rafael J. Wysocki9d169472014-01-10 15:22:18 +01001134void pci_lock_rescan_remove(void);
1135void pci_unlock_rescan_remove(void);
Kumar Galace5ccde2007-07-16 23:27:10 -05001136
Stephen Hemminger287d19c2008-12-18 09:17:16 -08001137/* Vital product data routines */
1138ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
1139ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void *buf);
Hariprasad Shenaicb921482016-04-15 13:00:11 -05001140int pci_set_vpd_size(struct pci_dev *dev, size_t len);
Stephen Hemminger287d19c2008-12-18 09:17:16 -08001141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142/* Helper functions for low-level code (drivers/pci/setup-[bus,res].c) */
Myron Stowe925845b2011-11-21 11:54:13 -07001143resource_size_t pcibios_retrieve_fw_addr(struct pci_dev *dev, int idx);
Andrew Mortonea741552009-02-18 10:44:29 -08001144void pci_bus_assign_resources(const struct pci_bus *bus);
Lorenzo Pieralisi765bf9b2016-06-08 12:04:47 +01001145void pci_bus_claim_resources(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146void pci_bus_size_bridges(struct pci_bus *bus);
1147int pci_claim_resource(struct pci_dev *, int);
Yinghai Lu8505e722015-01-15 16:21:49 -06001148int pci_claim_bridge_resource(struct pci_dev *bridge, int i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149void pci_assign_unassigned_resources(void);
Yinghai Lu6841ec62010-01-22 01:02:25 -08001150void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge);
Yinghai Lu17787942012-10-30 14:31:10 -06001151void pci_assign_unassigned_bus_resources(struct pci_bus *bus);
Yinghai Lu39772032013-07-22 14:37:18 -07001152void pci_assign_unassigned_root_bus_resources(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153void pdev_enable_device(struct pci_dev *);
Bjorn Helgaas842de402008-03-04 11:56:47 -07001154int pci_enable_resources(struct pci_dev *, int mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
Ralf Baechled5341942011-06-10 15:30:21 +01001156 int (*)(const struct pci_dev *, u8, u8));
Mika Westerbergafd29f92016-09-15 11:07:03 +03001157struct resource *pci_find_resource(struct pci_dev *dev, struct resource *res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158#define HAVE_PCI_REQ_REGIONS 2
Andrew Morton4a7fb632006-08-14 22:43:17 -07001159int __must_check pci_request_regions(struct pci_dev *, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001160int __must_check pci_request_regions_exclusive(struct pci_dev *, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161void pci_release_regions(struct pci_dev *);
Andrew Morton4a7fb632006-08-14 22:43:17 -07001162int __must_check pci_request_region(struct pci_dev *, int, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001163int __must_check pci_request_region_exclusive(struct pci_dev *, int, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164void pci_release_region(struct pci_dev *, int);
Hidetoshi Setoc87deff2006-12-18 10:31:06 +09001165int pci_request_selected_regions(struct pci_dev *, int, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001166int pci_request_selected_regions_exclusive(struct pci_dev *, int, const char *);
Hidetoshi Setoc87deff2006-12-18 10:31:06 +09001167void pci_release_selected_regions(struct pci_dev *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
1169/* drivers/pci/bus.c */
Jiang Liufe830ef2013-05-25 21:48:29 +08001170struct pci_bus *pci_bus_get(struct pci_bus *bus);
1171void pci_bus_put(struct pci_bus *bus);
Bjorn Helgaas45ca9e92011-10-28 16:25:35 -06001172void pci_add_resource(struct list_head *resources, struct resource *res);
Bjorn Helgaas0efd5aa2012-02-23 20:19:00 -07001173void pci_add_resource_offset(struct list_head *resources, struct resource *res,
1174 resource_size_t offset);
Bjorn Helgaas45ca9e92011-10-28 16:25:35 -06001175void pci_free_resource_list(struct list_head *resources);
Bjorn Helgaas950334b2016-05-28 18:09:16 -05001176void pci_bus_add_resource(struct pci_bus *bus, struct resource *res,
1177 unsigned int flags);
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -07001178struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n);
1179void pci_bus_remove_resources(struct pci_bus *bus);
Bjorn Helgaas950334b2016-05-28 18:09:16 -05001180int devm_request_pci_bus_resources(struct device *dev,
1181 struct list_head *resources);
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -07001182
Bjorn Helgaas89a74ec2010-02-23 10:24:31 -07001183#define pci_bus_for_each_resource(bus, res, i) \
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -07001184 for (i = 0; \
1185 (res = pci_bus_resource_n(bus, i)) || i < PCI_BRIDGE_RESOURCE_NUM; \
1186 i++)
Bjorn Helgaas89a74ec2010-02-23 10:24:31 -07001187
Andrew Morton4a7fb632006-08-14 22:43:17 -07001188int __must_check pci_bus_alloc_resource(struct pci_bus *bus,
1189 struct resource *res, resource_size_t size,
1190 resource_size_t align, resource_size_t min,
Bjorn Helgaas664c2842014-03-07 13:51:12 -07001191 unsigned long type_mask,
Dominik Brodowski3b7a17f2010-01-01 17:40:50 +01001192 resource_size_t (*alignf)(void *,
1193 const struct resource *,
Dominik Brodowskib26b2d42010-01-01 17:40:49 +01001194 resource_size_t,
1195 resource_size_t),
Andrew Morton4a7fb632006-08-14 22:43:17 -07001196 void *alignf_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
Liviu Dudau8b921ac2014-09-29 15:29:30 +01001198
Tomasz Nowickic5076cf2016-05-11 17:34:51 -05001199int pci_register_io_range(phys_addr_t addr, resource_size_t size);
1200unsigned long pci_address_to_pio(phys_addr_t addr);
1201phys_addr_t pci_pio_to_address(unsigned long pio);
Liviu Dudau8b921ac2014-09-29 15:29:30 +01001202int pci_remap_iospace(const struct resource *res, phys_addr_t phys_addr);
Sinan Kaya4d3f1382016-06-10 21:55:11 +02001203void pci_unmap_iospace(struct resource *res);
Liviu Dudau8b921ac2014-09-29 15:29:30 +01001204
Yinghai Lu3a9ad0b2015-05-27 17:23:51 -07001205static inline pci_bus_addr_t pci_bus_address(struct pci_dev *pdev, int bar)
Bjorn Helgaas06cf56e2013-12-21 08:33:26 -07001206{
1207 struct pci_bus_region region;
1208
1209 pcibios_resource_to_bus(pdev->bus, &region, &pdev->resource[bar]);
1210 return region.start;
1211}
1212
Laurent riffard863b18f2005-10-27 23:12:54 +02001213/* Proper probing supporting hot-pluggable devices */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001214int __must_check __pci_register_driver(struct pci_driver *, struct module *,
1215 const char *mod_name);
Andrew Mortonbba81162008-07-30 12:07:04 -07001216
1217/*
1218 * pci_register_driver must be a macro so that KBUILD_MODNAME can be expanded
1219 */
1220#define pci_register_driver(driver) \
1221 __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
Laurent riffard863b18f2005-10-27 23:12:54 +02001222
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001223void pci_unregister_driver(struct pci_driver *dev);
Greg Kroah-Hartmanaad4f402011-11-18 10:12:49 -08001224
1225/**
1226 * module_pci_driver() - Helper macro for registering a PCI driver
1227 * @__pci_driver: pci_driver struct
1228 *
1229 * Helper macro for PCI drivers which do not do anything special in module
1230 * init/exit. This eliminates a lot of boilerplate. Each module may only
1231 * use this macro once, and calling it replaces module_init() and module_exit()
1232 */
1233#define module_pci_driver(__pci_driver) \
1234 module_driver(__pci_driver, pci_register_driver, \
1235 pci_unregister_driver)
1236
Paul Gortmakerb4eb6cd2015-08-25 20:25:37 -04001237/**
1238 * builtin_pci_driver() - Helper macro for registering a PCI driver
1239 * @__pci_driver: pci_driver struct
1240 *
1241 * Helper macro for PCI drivers which do not do anything special in their
1242 * init code. This eliminates a lot of boilerplate. Each driver may only
1243 * use this macro once, and calling it replaces device_initcall(...)
1244 */
1245#define builtin_pci_driver(__pci_driver) \
1246 builtin_driver(__pci_driver, pci_register_driver)
1247
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001248struct pci_driver *pci_dev_driver(const struct pci_dev *dev);
Tejun Heo9dba9102009-09-03 15:26:36 +09001249int pci_add_dynid(struct pci_driver *drv,
1250 unsigned int vendor, unsigned int device,
1251 unsigned int subvendor, unsigned int subdevice,
1252 unsigned int class, unsigned int class_mask,
1253 unsigned long driver_data);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001254const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
1255 struct pci_dev *dev);
1256int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max,
1257 int pass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258
Zhang, Yanmin70298c62009-06-16 13:34:38 +08001259void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
Paul Mackerrascecf4862005-08-18 14:33:01 +10001260 void *userdata);
Benjamin Herrenschmidtac7dc652005-12-13 18:09:16 +11001261int pci_cfg_space_size(struct pci_dev *dev);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001262unsigned char pci_bus_max_busnr(struct pci_bus *bus);
Benjamin Herrenschmidte2444272011-09-11 14:08:38 -03001263void pci_setup_bridge(struct pci_bus *bus);
Gavin Shanac5ad932012-09-11 16:59:45 -06001264resource_size_t pcibios_window_alignment(struct pci_bus *bus,
1265 unsigned long type);
Wei Yang978d2d62015-03-25 16:23:50 +08001266resource_size_t pcibios_iov_resource_alignment(struct pci_dev *dev, int resno);
Paul Mackerrascecf4862005-08-18 14:33:01 +10001267
Dave Airlie3448a192010-06-01 15:32:24 +10001268#define PCI_VGA_STATE_CHANGE_BRIDGE (1 << 0)
1269#define PCI_VGA_STATE_CHANGE_DECODES (1 << 1)
1270
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001271int pci_set_vga_state(struct pci_dev *pdev, bool decode,
Dave Airlie3448a192010-06-01 15:32:24 +10001272 unsigned int command_bits, u32 flags);
Bjorn Helgaasfe537672016-03-07 11:39:16 -06001273
Christoph Hellwig4fe0d152016-08-11 07:11:04 -07001274#define PCI_IRQ_LEGACY (1 << 0) /* allow legacy interrupts */
1275#define PCI_IRQ_MSI (1 << 1) /* allow MSI interrupts */
1276#define PCI_IRQ_MSIX (1 << 2) /* allow MSI-X interrupts */
1277#define PCI_IRQ_AFFINITY (1 << 3) /* auto-assign affinity */
1278#define PCI_IRQ_ALL_TYPES \
1279 (PCI_IRQ_LEGACY | PCI_IRQ_MSI | PCI_IRQ_MSIX)
Christoph Hellwigaff17162016-07-12 18:20:17 +09001280
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281/* kmem_cache style wrapper around pci_alloc_consistent() */
1282
FUJITA Tomonorif41b1772010-03-10 15:23:30 -08001283#include <linux/pci-dma.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284#include <linux/dmapool.h>
1285
1286#define pci_pool dma_pool
1287#define pci_pool_create(name, pdev, size, align, allocation) \
1288 dma_pool_create(name, &pdev->dev, size, align, allocation)
1289#define pci_pool_destroy(pool) dma_pool_destroy(pool)
1290#define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
Sean O. Stalley01a7fd32015-09-08 15:02:30 -07001291#define pci_pool_zalloc(pool, flags, handle) \
1292 dma_pool_zalloc(pool, flags, handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293#define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
1294
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295struct msix_entry {
Yinghai Lu16dbef42008-08-15 19:36:45 -07001296 u32 vector; /* kernel uses to write allocated vector */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 u16 entry; /* driver uses to specify entry, OS writes */
1298};
1299
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001300#ifdef CONFIG_PCI_MSI
1301int pci_msi_vec_count(struct pci_dev *dev);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001302void pci_msi_shutdown(struct pci_dev *dev);
1303void pci_disable_msi(struct pci_dev *dev);
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001304int pci_msix_vec_count(struct pci_dev *dev);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001305int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec);
1306void pci_msix_shutdown(struct pci_dev *dev);
1307void pci_disable_msix(struct pci_dev *dev);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001308void pci_restore_msi_state(struct pci_dev *dev);
1309int pci_msi_enabled(void);
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001310int pci_enable_msi_range(struct pci_dev *dev, int minvec, int maxvec);
Alexander Gordeevf7fc32c2014-02-13 15:25:02 +01001311static inline int pci_enable_msi_exact(struct pci_dev *dev, int nvec)
1312{
1313 int rc = pci_enable_msi_range(dev, nvec, nvec);
1314 if (rc < 0)
1315 return rc;
1316 return 0;
1317}
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001318int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
1319 int minvec, int maxvec);
Alexander Gordeevf7fc32c2014-02-13 15:25:02 +01001320static inline int pci_enable_msix_exact(struct pci_dev *dev,
1321 struct msix_entry *entries, int nvec)
1322{
1323 int rc = pci_enable_msix_range(dev, entries, nvec, nvec);
1324 if (rc < 0)
1325 return rc;
1326 return 0;
1327}
Christoph Hellwigaff17162016-07-12 18:20:17 +09001328int pci_alloc_irq_vectors(struct pci_dev *dev, unsigned int min_vecs,
1329 unsigned int max_vecs, unsigned int flags);
1330void pci_free_irq_vectors(struct pci_dev *dev);
1331int pci_irq_vector(struct pci_dev *dev, unsigned int nr);
Thomas Gleixneree8d41e2016-09-14 16:18:51 +02001332const struct cpumask *pci_irq_get_affinity(struct pci_dev *pdev, int vec);
Christoph Hellwigaff17162016-07-12 18:20:17 +09001333
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001334#else
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001335static inline int pci_msi_vec_count(struct pci_dev *dev) { return -ENOSYS; }
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001336static inline void pci_msi_shutdown(struct pci_dev *dev) { }
1337static inline void pci_disable_msi(struct pci_dev *dev) { }
1338static inline int pci_msix_vec_count(struct pci_dev *dev) { return -ENOSYS; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001339static inline int pci_enable_msix(struct pci_dev *dev,
1340 struct msix_entry *entries, int nvec)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001341{ return -ENOSYS; }
1342static inline void pci_msix_shutdown(struct pci_dev *dev) { }
1343static inline void pci_disable_msix(struct pci_dev *dev) { }
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001344static inline void pci_restore_msi_state(struct pci_dev *dev) { }
1345static inline int pci_msi_enabled(void) { return 0; }
Alexander Gordeev302a2522013-12-30 08:28:16 +01001346static inline int pci_enable_msi_range(struct pci_dev *dev, int minvec,
1347 int maxvec)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001348{ return -ENOSYS; }
Alexander Gordeevf7fc32c2014-02-13 15:25:02 +01001349static inline int pci_enable_msi_exact(struct pci_dev *dev, int nvec)
1350{ return -ENOSYS; }
Alexander Gordeev302a2522013-12-30 08:28:16 +01001351static inline int pci_enable_msix_range(struct pci_dev *dev,
1352 struct msix_entry *entries, int minvec, int maxvec)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001353{ return -ENOSYS; }
Alexander Gordeevf7fc32c2014-02-13 15:25:02 +01001354static inline int pci_enable_msix_exact(struct pci_dev *dev,
1355 struct msix_entry *entries, int nvec)
1356{ return -ENOSYS; }
Christoph Hellwigaff17162016-07-12 18:20:17 +09001357static inline int pci_alloc_irq_vectors(struct pci_dev *dev,
1358 unsigned int min_vecs, unsigned int max_vecs,
1359 unsigned int flags)
1360{
1361 if (min_vecs > 1)
1362 return -EINVAL;
1363 return 1;
1364}
1365static inline void pci_free_irq_vectors(struct pci_dev *dev)
1366{
1367}
1368
1369static inline int pci_irq_vector(struct pci_dev *dev, unsigned int nr)
1370{
1371 if (WARN_ON_ONCE(nr > 0))
1372 return -EINVAL;
1373 return dev->irq;
1374}
Thomas Gleixneree8d41e2016-09-14 16:18:51 +02001375static inline const struct cpumask *pci_irq_get_affinity(struct pci_dev *pdev,
1376 int vec)
1377{
1378 return cpu_possible_mask;
1379}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380#endif
1381
Markus Trippelsdorfab0724f2011-01-15 00:07:22 +01001382#ifdef CONFIG_PCIEPORTBUS
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001383extern bool pcie_ports_disabled;
1384extern bool pcie_ports_auto;
Markus Trippelsdorfab0724f2011-01-15 00:07:22 +01001385#else
1386#define pcie_ports_disabled true
1387#define pcie_ports_auto false
1388#endif
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001389
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001390#ifdef CONFIG_PCIEASPM
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001391bool pcie_aspm_support_enabled(void);
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001392#else
1393static inline bool pcie_aspm_support_enabled(void) { return false; }
Andrew Patterson3e1b1602008-11-10 15:30:55 -07001394#endif
1395
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001396#ifdef CONFIG_PCIEAER
1397void pci_no_aer(void);
1398bool pci_aer_available(void);
Keith Busch66b80802016-09-27 16:23:34 -04001399int pci_aer_init(struct pci_dev *dev);
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001400#else
1401static inline void pci_no_aer(void) { }
1402static inline bool pci_aer_available(void) { return false; }
Keith Busch66b80802016-09-27 16:23:34 -04001403static inline int pci_aer_init(struct pci_dev *d) { return -ENODEV; }
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001404#endif
1405
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001406#ifdef CONFIG_PCIE_ECRC
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001407void pcie_set_ecrc_checking(struct pci_dev *dev);
1408void pcie_ecrc_get_policy(char *str);
Bjorn Helgaas4c859802014-01-13 17:01:11 -07001409#else
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001410static inline void pcie_set_ecrc_checking(struct pci_dev *dev) { }
1411static inline void pcie_ecrc_get_policy(char *str) { }
Andrew Patterson43c16402009-04-22 16:52:09 -06001412#endif
1413
Alexander Gordeev034cd972014-04-14 15:28:35 +02001414#define pci_enable_msi(pdev) pci_enable_msi_exact(pdev, 1)
Matthew Wilcox1c8d7b02009-03-17 08:54:10 -04001415
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001416#ifdef CONFIG_HT_IRQ
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001417/* The functions a driver should call */
1418int ht_create_irq(struct pci_dev *dev, int idx);
1419void ht_destroy_irq(unsigned int irq);
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001420#endif /* CONFIG_HT_IRQ */
1421
Bjorn Helgaasedc90fe2015-07-17 15:05:46 -05001422#ifdef CONFIG_PCI_ATS
1423/* Address Translation Service */
1424void pci_ats_init(struct pci_dev *dev);
Bjorn Helgaasff9bee82015-07-17 15:55:48 -05001425int pci_enable_ats(struct pci_dev *dev, int ps);
1426void pci_disable_ats(struct pci_dev *dev);
1427int pci_ats_queue_depth(struct pci_dev *dev);
Bjorn Helgaasedc90fe2015-07-17 15:05:46 -05001428#else
Bjorn Helgaasff9bee82015-07-17 15:55:48 -05001429static inline void pci_ats_init(struct pci_dev *d) { }
1430static inline int pci_enable_ats(struct pci_dev *d, int ps) { return -ENODEV; }
1431static inline void pci_disable_ats(struct pci_dev *d) { }
1432static inline int pci_ats_queue_depth(struct pci_dev *d) { return -ENODEV; }
Bjorn Helgaasedc90fe2015-07-17 15:05:46 -05001433#endif
1434
Bjorn Helgaaseec097d2016-06-13 11:01:51 -05001435#ifdef CONFIG_PCIE_PTM
1436int pci_enable_ptm(struct pci_dev *dev, u8 *granularity);
1437#else
1438static inline int pci_enable_ptm(struct pci_dev *dev, u8 *granularity)
1439{ return -EINVAL; }
1440#endif
1441
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001442void pci_cfg_access_lock(struct pci_dev *dev);
1443bool pci_cfg_access_trylock(struct pci_dev *dev);
1444void pci_cfg_access_unlock(struct pci_dev *dev);
Brian Kinge04b0ea2005-09-27 01:21:55 -07001445
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001446/*
1447 * PCI domain support. Sometimes called PCI segment (eg by ACPI),
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001448 * a PCI domain is defined to be a set of PCI buses which share
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001449 * configuration space.
1450 */
Jeff Garzik32a2eea2007-10-11 16:57:27 -04001451#ifdef CONFIG_PCI_DOMAINS
1452extern int pci_domains_supported;
Liviu Dudau41e5c0f2014-09-29 15:29:27 +01001453int pci_get_new_domain_nr(void);
Jeff Garzik32a2eea2007-10-11 16:57:27 -04001454#else
1455enum { pci_domains_supported = 0 };
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001456static inline int pci_domain_nr(struct pci_bus *bus) { return 0; }
1457static inline int pci_proc_domain(struct pci_bus *bus) { return 0; }
Liviu Dudau41e5c0f2014-09-29 15:29:27 +01001458static inline int pci_get_new_domain_nr(void) { return -ENOSYS; }
Jeff Garzik32a2eea2007-10-11 16:57:27 -04001459#endif /* CONFIG_PCI_DOMAINS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
Catalin Marinas670ba0c2014-09-29 15:29:26 +01001461/*
1462 * Generic implementation for PCI domain support. If your
1463 * architecture does not need custom management of PCI
1464 * domains then this implementation will be used
1465 */
1466#ifdef CONFIG_PCI_DOMAINS_GENERIC
1467static inline int pci_domain_nr(struct pci_bus *bus)
1468{
1469 return bus->domain_nr;
1470}
Tomasz Nowicki2ab51dd2016-06-10 15:36:26 -05001471#ifdef CONFIG_ACPI
1472int acpi_pci_bus_find_domain_nr(struct pci_bus *bus);
Catalin Marinas670ba0c2014-09-29 15:29:26 +01001473#else
Tomasz Nowicki2ab51dd2016-06-10 15:36:26 -05001474static inline int acpi_pci_bus_find_domain_nr(struct pci_bus *bus)
1475{ return 0; }
1476#endif
Tomasz Nowicki9c7cb892016-06-10 21:55:14 +02001477int pci_bus_find_domain_nr(struct pci_bus *bus, struct device *parent);
Catalin Marinas670ba0c2014-09-29 15:29:26 +01001478#endif
1479
Mike Travis95a8b6e2010-02-02 14:38:13 -08001480/* some architectures require additional setup to direct VGA traffic */
1481typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode,
Dave Airlie3448a192010-06-01 15:32:24 +10001482 unsigned int command_bits, u32 flags);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001483void pci_register_set_vga_state(arch_set_vga_state_t func);
Mike Travis95a8b6e2010-02-02 14:38:13 -08001484
Johannes Thumshirnbe9d2e82016-06-07 09:44:01 +02001485static inline int
1486pci_request_io_regions(struct pci_dev *pdev, const char *name)
1487{
1488 return pci_request_selected_regions(pdev,
1489 pci_select_bars(pdev, IORESOURCE_IO), name);
1490}
1491
1492static inline void
1493pci_release_io_regions(struct pci_dev *pdev)
1494{
1495 return pci_release_selected_regions(pdev,
1496 pci_select_bars(pdev, IORESOURCE_IO));
1497}
1498
1499static inline int
1500pci_request_mem_regions(struct pci_dev *pdev, const char *name)
1501{
1502 return pci_request_selected_regions(pdev,
1503 pci_select_bars(pdev, IORESOURCE_MEM), name);
1504}
1505
1506static inline void
1507pci_release_mem_regions(struct pci_dev *pdev)
1508{
1509 return pci_release_selected_regions(pdev,
1510 pci_select_bars(pdev, IORESOURCE_MEM));
1511}
1512
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001513#else /* CONFIG_PCI is not enabled */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
Bjorn Helgaas5bbe0292016-02-05 14:57:47 -06001515static inline void pci_set_flags(int flags) { }
1516static inline void pci_add_flags(int flags) { }
1517static inline void pci_clear_flags(int flags) { }
1518static inline int pci_has_flag(int flag) { return 0; }
1519
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520/*
1521 * If the system does not have PCI, clearly these return errors. Define
1522 * these as simple inline functions to avoid hair in drivers.
1523 */
1524
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001525#define _PCI_NOP(o, s, t) \
1526 static inline int pci_##o##_config_##s(struct pci_dev *dev, \
1527 int where, t val) \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 { return PCIBIOS_FUNC_NOT_SUPPORTED; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001529
1530#define _PCI_NOP_ALL(o, x) _PCI_NOP(o, byte, u8 x) \
1531 _PCI_NOP(o, word, u16 x) \
1532 _PCI_NOP(o, dword, u32 x)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533_PCI_NOP_ALL(read, *)
1534_PCI_NOP_ALL(write,)
1535
Andrew Mortond42552c2006-10-21 10:24:12 -07001536static inline struct pci_dev *pci_get_device(unsigned int vendor,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001537 unsigned int device,
1538 struct pci_dev *from)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001539{ return NULL; }
Andrew Mortond42552c2006-10-21 10:24:12 -07001540
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001541static inline struct pci_dev *pci_get_subsys(unsigned int vendor,
1542 unsigned int device,
1543 unsigned int ss_vendor,
1544 unsigned int ss_device,
Greg KHb08508c2008-08-26 08:20:34 -07001545 struct pci_dev *from)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001546{ return NULL; }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001548static inline struct pci_dev *pci_get_class(unsigned int class,
1549 struct pci_dev *from)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001550{ return NULL; }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
1552#define pci_dev_present(ids) (0)
Zhang, Yanmined4aaad2007-07-15 23:39:39 -07001553#define no_pci_devices() (1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554#define pci_dev_put(dev) do { } while (0)
1555
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001556static inline void pci_set_master(struct pci_dev *dev) { }
1557static inline int pci_enable_device(struct pci_dev *dev) { return -EIO; }
1558static inline void pci_disable_device(struct pci_dev *dev) { }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001559static inline int pci_assign_resource(struct pci_dev *dev, int i)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001560{ return -EBUSY; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001561static inline int __pci_register_driver(struct pci_driver *drv,
1562 struct module *owner)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001563{ return 0; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001564static inline int pci_register_driver(struct pci_driver *drv)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001565{ return 0; }
1566static inline void pci_unregister_driver(struct pci_driver *drv) { }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001567static inline int pci_find_capability(struct pci_dev *dev, int cap)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001568{ return 0; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001569static inline int pci_find_next_capability(struct pci_dev *dev, u8 post,
1570 int cap)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001571{ return 0; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001572static inline int pci_find_ext_capability(struct pci_dev *dev, int cap)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001573{ return 0; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001574
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575/* Power management related routines */
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001576static inline int pci_save_state(struct pci_dev *dev) { return 0; }
1577static inline void pci_restore_state(struct pci_dev *dev) { }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001578static inline int pci_set_power_state(struct pci_dev *dev, pci_power_t state)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001579{ return 0; }
Randy Dunlap34492482011-02-14 12:27:50 -08001580static inline int pci_wake_from_d3(struct pci_dev *dev, bool enable)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001581{ return 0; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001582static inline pci_power_t pci_choose_state(struct pci_dev *dev,
1583 pm_message_t state)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001584{ return PCI_D0; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001585static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
1586 int enable)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001587{ return 0; }
Jesse Barnes48a92a82011-01-10 12:46:36 -08001588
Mika Westerbergafd29f92016-09-15 11:07:03 +03001589static inline struct resource *pci_find_resource(struct pci_dev *dev,
1590 struct resource *res)
1591{ return NULL; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001592static inline int pci_request_regions(struct pci_dev *dev, const char *res_name)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001593{ return -EIO; }
1594static inline void pci_release_regions(struct pci_dev *dev) { }
Sergei Shtylyov0da0ead2007-04-01 21:13:58 +04001595
Tomasz Nowickic5076cf2016-05-11 17:34:51 -05001596static inline unsigned long pci_address_to_pio(phys_addr_t addr) { return -1; }
1597
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001598static inline void pci_block_cfg_access(struct pci_dev *dev) { }
Jan Kiszkafb51ccb2011-11-04 09:45:59 +01001599static inline int pci_block_cfg_access_in_atomic(struct pci_dev *dev)
1600{ return 0; }
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001601static inline void pci_unblock_cfg_access(struct pci_dev *dev) { }
Brian Kinge04b0ea2005-09-27 01:21:55 -07001602
Randy Dunlapd80d0212007-07-01 12:06:37 -07001603static inline struct pci_bus *pci_find_next_bus(const struct pci_bus *from)
1604{ return NULL; }
Randy Dunlapd80d0212007-07-01 12:06:37 -07001605static inline struct pci_dev *pci_get_slot(struct pci_bus *bus,
1606 unsigned int devfn)
1607{ return NULL; }
Randy Dunlapd80d0212007-07-01 12:06:37 -07001608static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
1609 unsigned int devfn)
1610{ return NULL; }
1611
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001612static inline int pci_domain_nr(struct pci_bus *bus) { return 0; }
1613static inline struct pci_dev *pci_dev_get(struct pci_dev *dev) { return NULL; }
Liviu Dudau41e5c0f2014-09-29 15:29:27 +01001614static inline int pci_get_new_domain_nr(void) { return -ENOSYS; }
Alex Williamson12ea6ca2012-06-11 05:26:55 +00001615
Williams, Mitch Afb8a0d92010-02-10 01:43:04 +00001616#define dev_is_pci(d) (false)
1617#define dev_is_pf(d) (false)
1618#define dev_num_vf(d) (0)
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001619#endif /* CONFIG_PCI */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001621/* Include architecture-dependent settings and functions */
1622
1623#include <asm/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624
Jake Oshins92016ba2016-02-16 21:56:21 +00001625#ifndef pci_root_bus_fwnode
1626#define pci_root_bus_fwnode(bus) NULL
1627#endif
1628
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629/* these helpers provide future and backwards compatibility
1630 * for accessing popular PCI BAR info */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001631#define pci_resource_start(dev, bar) ((dev)->resource[(bar)].start)
1632#define pci_resource_end(dev, bar) ((dev)->resource[(bar)].end)
1633#define pci_resource_flags(dev, bar) ((dev)->resource[(bar)].flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634#define pci_resource_len(dev,bar) \
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001635 ((pci_resource_start((dev), (bar)) == 0 && \
1636 pci_resource_end((dev), (bar)) == \
1637 pci_resource_start((dev), (bar))) ? 0 : \
1638 \
1639 (pci_resource_end((dev), (bar)) - \
1640 pci_resource_start((dev), (bar)) + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
1642/* Similar to the helpers above, these manipulate per-pci_dev
1643 * driver-specific data. They are really just a wrapper around
1644 * the generic device structure functions of these calls.
1645 */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001646static inline void *pci_get_drvdata(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647{
1648 return dev_get_drvdata(&pdev->dev);
1649}
1650
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001651static inline void pci_set_drvdata(struct pci_dev *pdev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652{
1653 dev_set_drvdata(&pdev->dev, data);
1654}
1655
1656/* If you want to know what to call your pci_dev, ask this function.
1657 * Again, it's a wrapper around the generic device.
1658 */
Alexey Zaytsev2fc90f62009-06-24 16:22:30 +04001659static inline const char *pci_name(const struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660{
Greg KHc6c4f072008-07-03 09:49:39 -07001661 return dev_name(&pdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662}
1663
Michael Ellerman2311b1f2005-05-13 17:44:10 +10001664
1665/* Some archs don't want to expose struct resource to userland as-is
1666 * in sysfs and /proc
1667 */
Bjorn Helgaas8221a012016-06-17 14:43:34 -05001668#ifdef HAVE_ARCH_PCI_RESOURCE_TO_USER
1669void pci_resource_to_user(const struct pci_dev *dev, int bar,
1670 const struct resource *rsrc,
1671 resource_size_t *start, resource_size_t *end);
1672#else
Michael Ellerman2311b1f2005-05-13 17:44:10 +10001673static inline void pci_resource_to_user(const struct pci_dev *dev, int bar,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001674 const struct resource *rsrc, resource_size_t *start,
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -07001675 resource_size_t *end)
Michael Ellerman2311b1f2005-05-13 17:44:10 +10001676{
1677 *start = rsrc->start;
1678 *end = rsrc->end;
1679}
1680#endif /* HAVE_ARCH_PCI_RESOURCE_TO_USER */
1681
1682
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683/*
1684 * The world is not perfect and supplies us with broken PCI devices.
1685 * For at least a part of these bugs we need a work-around, so both
1686 * generic (drivers/pci/quirks.c) and per-architecture code can define
1687 * fixup hooks to be called for particular buggy devices.
1688 */
1689
1690struct pci_fixup {
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001691 u16 vendor; /* You can use PCI_ANY_ID here of course */
1692 u16 device; /* You can use PCI_ANY_ID here of course */
1693 u32 class; /* You can use PCI_ANY_ID here too */
1694 unsigned int class_shift; /* should be 0, 8, 16 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 void (*hook)(struct pci_dev *dev);
1696};
1697
1698enum pci_fixup_pass {
1699 pci_fixup_early, /* Before probing BARs */
1700 pci_fixup_header, /* After reading configuration header */
1701 pci_fixup_final, /* Final phase of device fixups */
1702 pci_fixup_enable, /* pci_enable_device() time */
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001703 pci_fixup_resume, /* pci_device_resume() */
Andreas Noever7d2a01b2014-06-03 22:04:09 +02001704 pci_fixup_suspend, /* pci_device_suspend() */
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001705 pci_fixup_resume_early, /* pci_device_resume_early() */
Andreas Noever7d2a01b2014-06-03 22:04:09 +02001706 pci_fixup_suspend_late, /* pci_device_suspend_late() */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707};
1708
1709/* Anonymous variables would be nice... */
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001710#define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, class, \
1711 class_shift, hook) \
Michal Marekecf61c72013-11-11 14:40:35 +01001712 static const struct pci_fixup __PASTE(__pci_fixup_##name,__LINE__) __used \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001713 __attribute__((__section__(#section), aligned((sizeof(void *))))) \
1714 = { vendor, device, class, class_shift, hook };
1715
1716#define DECLARE_PCI_FIXUP_CLASS_EARLY(vendor, device, class, \
1717 class_shift, hook) \
1718 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early, \
Michal Marekecf61c72013-11-11 14:40:35 +01001719 hook, vendor, device, class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001720#define DECLARE_PCI_FIXUP_CLASS_HEADER(vendor, device, class, \
1721 class_shift, hook) \
1722 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header, \
Michal Marekecf61c72013-11-11 14:40:35 +01001723 hook, vendor, device, class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001724#define DECLARE_PCI_FIXUP_CLASS_FINAL(vendor, device, class, \
1725 class_shift, hook) \
1726 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final, \
Michal Marekecf61c72013-11-11 14:40:35 +01001727 hook, vendor, device, class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001728#define DECLARE_PCI_FIXUP_CLASS_ENABLE(vendor, device, class, \
1729 class_shift, hook) \
1730 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable, \
Michal Marekecf61c72013-11-11 14:40:35 +01001731 hook, vendor, device, class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001732#define DECLARE_PCI_FIXUP_CLASS_RESUME(vendor, device, class, \
1733 class_shift, hook) \
1734 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume, \
Michal Marekecf61c72013-11-11 14:40:35 +01001735 resume##hook, vendor, device, class, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001736 class_shift, hook)
1737#define DECLARE_PCI_FIXUP_CLASS_RESUME_EARLY(vendor, device, class, \
1738 class_shift, hook) \
1739 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early, \
Michal Marekecf61c72013-11-11 14:40:35 +01001740 resume_early##hook, vendor, device, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001741 class, class_shift, hook)
1742#define DECLARE_PCI_FIXUP_CLASS_SUSPEND(vendor, device, class, \
1743 class_shift, hook) \
1744 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend, \
Michal Marekecf61c72013-11-11 14:40:35 +01001745 suspend##hook, vendor, device, class, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001746 class_shift, hook)
Andreas Noever7d2a01b2014-06-03 22:04:09 +02001747#define DECLARE_PCI_FIXUP_CLASS_SUSPEND_LATE(vendor, device, class, \
1748 class_shift, hook) \
1749 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend_late, \
1750 suspend_late##hook, vendor, device, \
1751 class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001752
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753#define DECLARE_PCI_FIXUP_EARLY(vendor, device, hook) \
1754 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early, \
Michal Marekecf61c72013-11-11 14:40:35 +01001755 hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756#define DECLARE_PCI_FIXUP_HEADER(vendor, device, hook) \
1757 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header, \
Michal Marekecf61c72013-11-11 14:40:35 +01001758 hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759#define DECLARE_PCI_FIXUP_FINAL(vendor, device, hook) \
1760 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final, \
Michal Marekecf61c72013-11-11 14:40:35 +01001761 hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762#define DECLARE_PCI_FIXUP_ENABLE(vendor, device, hook) \
1763 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable, \
Michal Marekecf61c72013-11-11 14:40:35 +01001764 hook, vendor, device, PCI_ANY_ID, 0, hook)
Alan Cox1597cac2006-12-04 15:14:45 -08001765#define DECLARE_PCI_FIXUP_RESUME(vendor, device, hook) \
1766 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume, \
Michal Marekecf61c72013-11-11 14:40:35 +01001767 resume##hook, vendor, device, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001768 PCI_ANY_ID, 0, hook)
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001769#define DECLARE_PCI_FIXUP_RESUME_EARLY(vendor, device, hook) \
1770 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early, \
Michal Marekecf61c72013-11-11 14:40:35 +01001771 resume_early##hook, vendor, device, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001772 PCI_ANY_ID, 0, hook)
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001773#define DECLARE_PCI_FIXUP_SUSPEND(vendor, device, hook) \
1774 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend, \
Michal Marekecf61c72013-11-11 14:40:35 +01001775 suspend##hook, vendor, device, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001776 PCI_ANY_ID, 0, hook)
Andreas Noever7d2a01b2014-06-03 22:04:09 +02001777#define DECLARE_PCI_FIXUP_SUSPEND_LATE(vendor, device, hook) \
1778 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend_late, \
1779 suspend_late##hook, vendor, device, \
1780 PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001782#ifdef CONFIG_PCI_QUIRKS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
Alex Williamsonad805752012-06-11 05:27:07 +00001784int pci_dev_specific_acs_enabled(struct pci_dev *dev, u16 acs_flags);
Alex Williamsonc1d61c92016-03-31 16:34:32 -06001785int pci_dev_specific_enable_acs(struct pci_dev *dev);
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001786#else
1787static inline void pci_fixup_device(enum pci_fixup_pass pass,
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001788 struct pci_dev *dev) { }
Alex Williamsonad805752012-06-11 05:27:07 +00001789static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
1790 u16 acs_flags)
1791{
1792 return -ENOTTY;
1793}
Alex Williamsonc1d61c92016-03-31 16:34:32 -06001794static inline int pci_dev_specific_enable_acs(struct pci_dev *dev)
1795{
1796 return -ENOTTY;
1797}
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001798#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001800void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);
Al Viro5ea81762007-02-11 15:41:31 +00001801void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001802void __iomem * const *pcim_iomap_table(struct pci_dev *pdev);
Yinghai Lufb7ebfe2012-01-04 15:50:02 -08001803int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name);
1804int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask,
Tejun Heo916fbfb2008-03-12 15:26:34 +09001805 const char *name);
Yinghai Lufb7ebfe2012-01-04 15:50:02 -08001806void pcim_iounmap_regions(struct pci_dev *pdev, int mask);
Al Viro5ea81762007-02-11 15:41:31 +00001807
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808extern int pci_pci_problems;
Alan Cox236561e2006-09-30 23:27:03 -07001809#define PCIPCI_FAIL 1 /* No PCI PCI DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810#define PCIPCI_TRITON 2
1811#define PCIPCI_NATOMA 4
1812#define PCIPCI_VIAETBF 8
1813#define PCIPCI_VSFX 16
Alan Cox236561e2006-09-30 23:27:03 -07001814#define PCIPCI_ALIMAGIK 32 /* Need low latency setting */
1815#define PCIAGP_FAIL 64 /* No PCI to AGP DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816
Atsushi Nemoto4516a612007-02-05 16:36:06 -08001817extern unsigned long pci_cardbus_io_size;
1818extern unsigned long pci_cardbus_mem_size;
Bill Pemberton15856ad2012-11-21 15:35:00 -05001819extern u8 pci_dfl_cache_line_size;
Jesse Barnesac1aa472009-10-26 13:20:44 -07001820extern u8 pci_cache_line_size;
Atsushi Nemoto4516a612007-02-05 16:36:06 -08001821
Eric W. Biederman28760482009-09-09 14:09:24 -07001822extern unsigned long pci_hotplug_io_size;
1823extern unsigned long pci_hotplug_mem_size;
Keith Busche16b4662016-07-21 21:40:28 -06001824extern unsigned long pci_hotplug_bus_size;
Eric W. Biederman28760482009-09-09 14:09:24 -07001825
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001826/* Architecture-specific versions may override these (weak) */
Adrian Bunk19792a02008-05-05 21:25:47 +03001827void pcibios_disable_device(struct pci_dev *dev);
Myron Stowecfce9fb2011-10-28 15:47:35 -06001828void pcibios_set_master(struct pci_dev *dev);
Adrian Bunk19792a02008-05-05 21:25:47 +03001829int pcibios_set_pcie_reset_state(struct pci_dev *dev,
1830 enum pcie_reset_state state);
Matthew Garretteca0d4672012-12-05 14:33:27 -07001831int pcibios_add_device(struct pci_dev *dev);
Sebastian Ott6ae32c52013-06-04 19:18:14 +02001832void pcibios_release_device(struct pci_dev *dev);
Hanjun Guoa43ae582014-05-06 11:29:52 +08001833void pcibios_penalize_isa_irq(int irq, int active);
Jiang Liu890e4842015-06-10 16:54:58 +08001834int pcibios_alloc_irq(struct pci_dev *dev);
1835void pcibios_free_irq(struct pci_dev *dev);
Michael Ellerman575e3342007-05-08 12:03:07 +10001836
Sebastian Ott699c1982013-08-20 16:41:02 +02001837#ifdef CONFIG_HIBERNATE_CALLBACKS
1838extern struct dev_pm_ops pcibios_pm_ops;
1839#endif
1840
Tomasz Nowicki935c7602016-06-10 21:55:13 +02001841#if defined(CONFIG_PCI_MMCONFIG) || defined(CONFIG_ACPI_MCFG)
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001842void __init pci_mmcfg_early_init(void);
1843void __init pci_mmcfg_late_init(void);
Robert Hancock7752d5c2008-02-15 01:27:20 -08001844#else
Yinghai Lubb63b422008-02-28 23:56:50 -08001845static inline void pci_mmcfg_early_init(void) { }
Robert Hancock7752d5c2008-02-15 01:27:20 -08001846static inline void pci_mmcfg_late_init(void) { }
1847#endif
1848
Taku Izumi642c92d2012-10-30 15:26:18 +09001849int pci_ext_cfg_avail(void);
Andrew Patterson0ef5f8f2008-11-10 15:30:50 -07001850
Andrew Morton1684f5d2008-12-01 14:30:30 -08001851void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar);
Luis R. Rodriguezc43996f2015-08-24 12:13:23 -07001852void __iomem *pci_ioremap_wc_bar(struct pci_dev *pdev, int bar);
Arjan van de Venaa42d7c2008-09-28 16:36:11 -07001853
Yu Zhaodd7cc442009-03-20 11:25:15 +08001854#ifdef CONFIG_PCI_IOV
Wei Yangb07579c2015-03-25 16:23:48 +08001855int pci_iov_virtfn_bus(struct pci_dev *dev, int id);
1856int pci_iov_virtfn_devfn(struct pci_dev *dev, int id);
1857
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001858int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn);
1859void pci_disable_sriov(struct pci_dev *dev);
Wei Yangc194f7e2016-03-04 10:53:03 +11001860int pci_iov_add_virtfn(struct pci_dev *dev, int id, int reset);
1861void pci_iov_remove_virtfn(struct pci_dev *dev, int id, int reset);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001862int pci_num_vf(struct pci_dev *dev);
Alexander Duyck5a8eb242013-04-25 04:42:29 +00001863int pci_vfs_assigned(struct pci_dev *dev);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001864int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs);
1865int pci_sriov_get_totalvfs(struct pci_dev *dev);
Wei Yang0e6c9122015-03-25 16:23:44 +08001866resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno);
Yu Zhaodd7cc442009-03-20 11:25:15 +08001867#else
Wei Yangb07579c2015-03-25 16:23:48 +08001868static inline int pci_iov_virtfn_bus(struct pci_dev *dev, int id)
1869{
1870 return -ENOSYS;
1871}
1872static inline int pci_iov_virtfn_devfn(struct pci_dev *dev, int id)
1873{
1874 return -ENOSYS;
1875}
Yu Zhaodd7cc442009-03-20 11:25:15 +08001876static inline int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001877{ return -ENODEV; }
Wei Yangc194f7e2016-03-04 10:53:03 +11001878static inline int pci_iov_add_virtfn(struct pci_dev *dev, int id, int reset)
1879{
1880 return -ENOSYS;
1881}
1882static inline void pci_iov_remove_virtfn(struct pci_dev *dev,
1883 int id, int reset) { }
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001884static inline void pci_disable_sriov(struct pci_dev *dev) { }
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001885static inline int pci_num_vf(struct pci_dev *dev) { return 0; }
Alexander Duyck5a8eb242013-04-25 04:42:29 +00001886static inline int pci_vfs_assigned(struct pci_dev *dev)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001887{ return 0; }
Donald Dutilebff73152012-11-05 15:20:37 -05001888static inline int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001889{ return 0; }
Donald Dutilebff73152012-11-05 15:20:37 -05001890static inline int pci_sriov_get_totalvfs(struct pci_dev *dev)
Bjorn Helgaas2ee546c2014-01-13 17:15:01 -07001891{ return 0; }
Wei Yang0e6c9122015-03-25 16:23:44 +08001892static inline resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno)
1893{ return 0; }
Yu Zhaodd7cc442009-03-20 11:25:15 +08001894#endif
1895
Kenji Kaneshigec825bc92009-06-16 11:01:25 +09001896#if defined(CONFIG_HOTPLUG_PCI) || defined(CONFIG_HOTPLUG_PCI_MODULE)
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001897void pci_hp_create_module_link(struct pci_slot *pci_slot);
1898void pci_hp_remove_module_link(struct pci_slot *pci_slot);
Kenji Kaneshigec825bc92009-06-16 11:01:25 +09001899#endif
1900
Kenji Kaneshiged7b7e602009-11-11 14:29:54 +09001901/**
1902 * pci_pcie_cap - get the saved PCIe capability offset
1903 * @dev: PCI device
1904 *
1905 * PCIe capability offset is calculated at PCI device initialization
1906 * time and saved in the data structure. This function returns saved
1907 * PCIe capability offset. Using this instead of pci_find_capability()
1908 * reduces unnecessary search in the PCI configuration space. If you
1909 * need to calculate PCIe capability offset from raw device for some
1910 * reasons, please use pci_find_capability() instead.
1911 */
1912static inline int pci_pcie_cap(struct pci_dev *dev)
1913{
1914 return dev->pcie_cap;
1915}
1916
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001917/**
1918 * pci_is_pcie - check if the PCI device is PCI Express capable
1919 * @dev: PCI device
1920 *
Joe Perchesa895c282013-09-03 13:31:05 -07001921 * Returns: true if the PCI device is PCI Express capable, false otherwise.
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001922 */
1923static inline bool pci_is_pcie(struct pci_dev *dev)
1924{
Joe Perchesa895c282013-09-03 13:31:05 -07001925 return pci_pcie_cap(dev);
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001926}
1927
Yijing Wang786e2282012-07-24 17:20:02 +08001928/**
Myron Stowe7c9c0032013-01-25 17:55:39 -07001929 * pcie_caps_reg - get the PCIe Capabilities Register
1930 * @dev: PCI device
1931 */
1932static inline u16 pcie_caps_reg(const struct pci_dev *dev)
1933{
1934 return dev->pcie_flags_reg;
1935}
1936
1937/**
Yijing Wang786e2282012-07-24 17:20:02 +08001938 * pci_pcie_type - get the PCIe device/port type
1939 * @dev: PCI device
1940 */
1941static inline int pci_pcie_type(const struct pci_dev *dev)
1942{
Myron Stowe1c531d82013-01-25 17:55:45 -07001943 return (pcie_caps_reg(dev) & PCI_EXP_FLAGS_TYPE) >> 4;
Yijing Wang786e2282012-07-24 17:20:02 +08001944}
1945
Chris Wright5d990b62009-12-04 12:15:21 -08001946void pci_request_acs(void);
Alex Williamsonad805752012-06-11 05:27:07 +00001947bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags);
1948bool pci_acs_path_enabled(struct pci_dev *start,
1949 struct pci_dev *end, u16 acs_flags);
Matt Carlsona2ce7662010-02-26 14:04:39 +00001950
Matt Carlson7ad506f2010-02-26 14:04:40 +00001951#define PCI_VPD_LRDT 0x80 /* Large Resource Data Type */
Megan Kamiya63ddc0b2014-09-05 20:19:10 -07001952#define PCI_VPD_LRDT_ID(x) ((x) | PCI_VPD_LRDT)
Matt Carlson7ad506f2010-02-26 14:04:40 +00001953
1954/* Large Resource Data Type Tag Item Names */
1955#define PCI_VPD_LTIN_ID_STRING 0x02 /* Identifier String */
1956#define PCI_VPD_LTIN_RO_DATA 0x10 /* Read-Only Data */
1957#define PCI_VPD_LTIN_RW_DATA 0x11 /* Read-Write Data */
1958
1959#define PCI_VPD_LRDT_ID_STRING PCI_VPD_LRDT_ID(PCI_VPD_LTIN_ID_STRING)
1960#define PCI_VPD_LRDT_RO_DATA PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RO_DATA)
1961#define PCI_VPD_LRDT_RW_DATA PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RW_DATA)
1962
1963/* Small Resource Data Type Tag Item Names */
Hannes Reinecke9eb45d52016-02-15 09:41:59 +01001964#define PCI_VPD_STIN_END 0x0f /* End */
Matt Carlson7ad506f2010-02-26 14:04:40 +00001965
Hannes Reinecke9eb45d52016-02-15 09:41:59 +01001966#define PCI_VPD_SRDT_END (PCI_VPD_STIN_END << 3)
Matt Carlson7ad506f2010-02-26 14:04:40 +00001967
1968#define PCI_VPD_SRDT_TIN_MASK 0x78
1969#define PCI_VPD_SRDT_LEN_MASK 0x07
Hannes Reinecke9eb45d52016-02-15 09:41:59 +01001970#define PCI_VPD_LRDT_TIN_MASK 0x7f
Matt Carlson7ad506f2010-02-26 14:04:40 +00001971
1972#define PCI_VPD_LRDT_TAG_SIZE 3
1973#define PCI_VPD_SRDT_TAG_SIZE 1
Matt Carlsona2ce7662010-02-26 14:04:39 +00001974
Matt Carlsone1d5bda2010-02-26 14:04:42 +00001975#define PCI_VPD_INFO_FLD_HDR_SIZE 3
1976
Matt Carlson4067a852010-02-26 14:04:43 +00001977#define PCI_VPD_RO_KEYWORD_PARTNO "PN"
1978#define PCI_VPD_RO_KEYWORD_MFR_ID "MN"
1979#define PCI_VPD_RO_KEYWORD_VENDOR0 "V0"
Matt Carlsond4894f32011-03-09 16:58:21 +00001980#define PCI_VPD_RO_KEYWORD_CHKSUM "RV"
Matt Carlson4067a852010-02-26 14:04:43 +00001981
Matt Carlsona2ce7662010-02-26 14:04:39 +00001982/**
1983 * pci_vpd_lrdt_size - Extracts the Large Resource Data Type length
1984 * @lrdt: Pointer to the beginning of the Large Resource Data Type tag
1985 *
1986 * Returns the extracted Large Resource Data Type length.
1987 */
1988static inline u16 pci_vpd_lrdt_size(const u8 *lrdt)
1989{
1990 return (u16)lrdt[1] + ((u16)lrdt[2] << 8);
1991}
1992
Matt Carlson7ad506f2010-02-26 14:04:40 +00001993/**
Hannes Reinecke9eb45d52016-02-15 09:41:59 +01001994 * pci_vpd_lrdt_tag - Extracts the Large Resource Data Type Tag Item
1995 * @lrdt: Pointer to the beginning of the Large Resource Data Type tag
1996 *
1997 * Returns the extracted Large Resource Data Type Tag item.
1998 */
1999static inline u16 pci_vpd_lrdt_tag(const u8 *lrdt)
2000{
2001 return (u16)(lrdt[0] & PCI_VPD_LRDT_TIN_MASK);
2002}
2003
2004/**
Matt Carlson7ad506f2010-02-26 14:04:40 +00002005 * pci_vpd_srdt_size - Extracts the Small Resource Data Type length
2006 * @lrdt: Pointer to the beginning of the Small Resource Data Type tag
2007 *
2008 * Returns the extracted Small Resource Data Type length.
2009 */
2010static inline u8 pci_vpd_srdt_size(const u8 *srdt)
2011{
2012 return (*srdt) & PCI_VPD_SRDT_LEN_MASK;
2013}
2014
Matt Carlsonb55ac1b2010-02-26 14:04:41 +00002015/**
Hannes Reinecke9eb45d52016-02-15 09:41:59 +01002016 * pci_vpd_srdt_tag - Extracts the Small Resource Data Type Tag Item
2017 * @lrdt: Pointer to the beginning of the Small Resource Data Type tag
2018 *
2019 * Returns the extracted Small Resource Data Type Tag Item.
2020 */
2021static inline u8 pci_vpd_srdt_tag(const u8 *srdt)
2022{
2023 return ((*srdt) & PCI_VPD_SRDT_TIN_MASK) >> 3;
2024}
2025
2026/**
Matt Carlsone1d5bda2010-02-26 14:04:42 +00002027 * pci_vpd_info_field_size - Extracts the information field length
2028 * @lrdt: Pointer to the beginning of an information field header
2029 *
2030 * Returns the extracted information field length.
2031 */
2032static inline u8 pci_vpd_info_field_size(const u8 *info_field)
2033{
2034 return info_field[2];
2035}
2036
2037/**
Matt Carlsonb55ac1b2010-02-26 14:04:41 +00002038 * pci_vpd_find_tag - Locates the Resource Data Type tag provided
2039 * @buf: Pointer to buffered vpd data
2040 * @off: The offset into the buffer at which to begin the search
2041 * @len: The length of the vpd buffer
2042 * @rdt: The Resource Data Type to search for
2043 *
2044 * Returns the index where the Resource Data Type was found or
2045 * -ENOENT otherwise.
2046 */
2047int pci_vpd_find_tag(const u8 *buf, unsigned int off, unsigned int len, u8 rdt);
2048
Matt Carlson4067a852010-02-26 14:04:43 +00002049/**
2050 * pci_vpd_find_info_keyword - Locates an information field keyword in the VPD
2051 * @buf: Pointer to buffered vpd data
2052 * @off: The offset into the buffer at which to begin the search
2053 * @len: The length of the buffer area, relative to off, in which to search
2054 * @kw: The keyword to search for
2055 *
2056 * Returns the index where the information field keyword was found or
2057 * -ENOENT otherwise.
2058 */
2059int pci_vpd_find_info_keyword(const u8 *buf, unsigned int off,
2060 unsigned int len, const char *kw);
2061
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10002062/* PCI <-> OF binding helpers */
2063#ifdef CONFIG_OF
2064struct device_node;
Marc Zyngierb165e2b2015-07-28 14:46:12 +01002065struct irq_domain;
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06002066void pci_set_of_node(struct pci_dev *dev);
2067void pci_release_of_node(struct pci_dev *dev);
2068void pci_set_bus_of_node(struct pci_bus *bus);
2069void pci_release_bus_of_node(struct pci_bus *bus);
Marc Zyngierb165e2b2015-07-28 14:46:12 +01002070struct irq_domain *pci_host_bridge_of_msi_domain(struct pci_bus *bus);
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10002071
2072/* Arch may override this (weak) */
Bjorn Helgaas723ec4d2013-04-17 10:31:34 -06002073struct device_node *pcibios_get_phb_of_node(struct pci_bus *bus);
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10002074
John Crispin3df425f2012-04-12 17:33:07 +02002075static inline struct device_node *
2076pci_device_to_OF_node(const struct pci_dev *pdev)
Benjamin Herrenschmidt64099d92011-04-07 13:09:47 +10002077{
2078 return pdev ? pdev->dev.of_node : NULL;
2079}
2080
Benjamin Herrenschmidtef3b4f82011-04-11 11:34:33 +10002081static inline struct device_node *pci_bus_to_OF_node(struct pci_bus *bus)
2082{
2083 return bus ? bus->dev.of_node : NULL;
2084}
2085
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10002086#else /* CONFIG_OF */
2087static inline void pci_set_of_node(struct pci_dev *dev) { }
2088static inline void pci_release_of_node(struct pci_dev *dev) { }
2089static inline void pci_set_bus_of_node(struct pci_bus *bus) { }
2090static inline void pci_release_bus_of_node(struct pci_bus *bus) { }
Kevin Haof0b66a22015-02-03 09:29:52 -06002091static inline struct device_node *
2092pci_device_to_OF_node(const struct pci_dev *pdev) { return NULL; }
Marc Zyngierb165e2b2015-07-28 14:46:12 +01002093static inline struct irq_domain *
2094pci_host_bridge_of_msi_domain(struct pci_bus *bus) { return NULL; }
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10002095#endif /* CONFIG_OF */
2096
Suravee Suthikulpanit471036b2015-12-10 08:55:27 -08002097#ifdef CONFIG_ACPI
2098struct irq_domain *pci_host_bridge_acpi_msi_domain(struct pci_bus *bus);
2099
2100void
2101pci_msi_register_fwnode_provider(struct fwnode_handle *(*fn)(struct device *));
2102#else
2103static inline struct irq_domain *
2104pci_host_bridge_acpi_msi_domain(struct pci_bus *bus) { return NULL; }
2105#endif
2106
Gavin Shaneb740b52012-02-27 20:04:04 +00002107#ifdef CONFIG_EEH
2108static inline struct eeh_dev *pci_dev_to_eeh_dev(struct pci_dev *pdev)
2109{
2110 return pdev->dev.archdata.edev;
2111}
2112#endif
2113
Bjorn Helgaasf0af9592016-02-24 13:43:45 -06002114void pci_add_dma_alias(struct pci_dev *dev, u8 devfn);
Jacek Lawrynowicz338c3142016-03-03 15:38:02 +01002115bool pci_devs_are_dma_aliases(struct pci_dev *dev1, struct pci_dev *dev2);
Alex Williamsonc25dc822014-05-22 17:07:30 -06002116int pci_for_each_dma_alias(struct pci_dev *pdev,
2117 int (*fn)(struct pci_dev *pdev,
2118 u16 alias, void *data), void *data);
2119
Ethan Zhaoce052982014-09-09 10:21:25 +08002120/* helper functions for operation of device flag */
2121static inline void pci_set_dev_assigned(struct pci_dev *pdev)
2122{
2123 pdev->dev_flags |= PCI_DEV_FLAGS_ASSIGNED;
2124}
2125static inline void pci_clear_dev_assigned(struct pci_dev *pdev)
2126{
2127 pdev->dev_flags &= ~PCI_DEV_FLAGS_ASSIGNED;
2128}
2129static inline bool pci_is_dev_assigned(struct pci_dev *pdev)
2130{
2131 return (pdev->dev_flags & PCI_DEV_FLAGS_ASSIGNED) == PCI_DEV_FLAGS_ASSIGNED;
2132}
Alex Williamson19bdb6e2015-05-26 15:11:44 -06002133
2134/**
2135 * pci_ari_enabled - query ARI forwarding status
2136 * @bus: the PCI bus
2137 *
2138 * Returns true if ARI forwarding is enabled.
2139 */
2140static inline bool pci_ari_enabled(struct pci_bus *bus)
2141{
2142 return bus->self && bus->self->ari_enabled;
2143}
Christoph Hellwigbc4b0242016-03-07 10:40:02 -06002144
2145/* provide the legacy pci_dma_* API */
2146#include <linux/pci-dma-compat.h>
2147
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148#endif /* LINUX_PCI_H */