blob: ef34ad76532c2df9bb6e921f136ba16abf536f25 [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>
Yu Zhao74bb1bc2009-03-20 11:25:16 +080032#include <linux/irqreturn.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 */
49#define PCI_DEVID(bus, devfn) ((((u16)bus) << 8) | devfn)
50/* 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
73/* This defines the direction arg to the DMA mapping routines. */
74#define PCI_DMA_BIDIRECTIONAL 0
75#define PCI_DMA_TODEVICE 1
76#define PCI_DMA_FROMDEVICE 2
77#define PCI_DMA_NONE 3
78
Yu Zhaofde09c62008-11-22 02:39:32 +080079/*
80 * For PCI devices, the region numbers are assigned this way:
81 */
82enum {
83 /* #0-5: standard PCI resources */
84 PCI_STD_RESOURCES,
85 PCI_STD_RESOURCE_END = 5,
86
87 /* #6: expansion ROM resource */
88 PCI_ROM_RESOURCE,
89
Yu Zhaod1b054d2009-03-20 11:25:11 +080090 /* device specific resources */
91#ifdef CONFIG_PCI_IOV
92 PCI_IOV_RESOURCES,
93 PCI_IOV_RESOURCE_END = PCI_IOV_RESOURCES + PCI_SRIOV_NUM_BARS - 1,
94#endif
95
Yu Zhaofde09c62008-11-22 02:39:32 +080096 /* resources assigned to buses behind the bridge */
97#define PCI_BRIDGE_RESOURCE_NUM 4
98
99 PCI_BRIDGE_RESOURCES,
100 PCI_BRIDGE_RESOURCE_END = PCI_BRIDGE_RESOURCES +
101 PCI_BRIDGE_RESOURCE_NUM - 1,
102
103 /* total resources associated with a PCI device */
104 PCI_NUM_RESOURCES,
105
106 /* preserve this for compatibility */
Yinghai Lucda57bf2012-01-04 15:49:45 -0800107 DEVICE_COUNT_RESOURCE = PCI_NUM_RESOURCES,
Yu Zhaofde09c62008-11-22 02:39:32 +0800108};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110typedef int __bitwise pci_power_t;
111
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -0700112#define PCI_D0 ((pci_power_t __force) 0)
113#define PCI_D1 ((pci_power_t __force) 1)
114#define PCI_D2 ((pci_power_t __force) 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115#define PCI_D3hot ((pci_power_t __force) 3)
116#define PCI_D3cold ((pci_power_t __force) 4)
Daniel Ritz3fe9d192005-08-17 15:32:19 -0700117#define PCI_UNKNOWN ((pci_power_t __force) 5)
Pavel Machek438510f2005-04-16 15:25:24 -0700118#define PCI_POWER_ERROR ((pci_power_t __force) -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Alan Stern00240c32009-04-27 13:33:16 -0400120/* Remember to update this when the list above changes! */
121extern const char *pci_power_names[];
122
123static inline const char *pci_power_name(pci_power_t state)
124{
125 return pci_power_names[1 + (int) state];
126}
127
Huang Ying448bd852012-06-23 10:23:51 +0800128#define PCI_PM_D2_DELAY 200
129#define PCI_PM_D3_WAIT 10
130#define PCI_PM_D3COLD_WAIT 100
131#define PCI_PM_BUS_WAIT 50
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100132
linas392a1ce2005-11-16 17:10:41 -0600133/** The pci_channel state describes connectivity between the CPU and
134 * the pci device. If some PCI bus between here and the pci device
135 * has crashed or locked up, this info is reflected here.
136 */
137typedef unsigned int __bitwise pci_channel_state_t;
138
139enum pci_channel_state {
140 /* I/O channel is in normal state */
141 pci_channel_io_normal = (__force pci_channel_state_t) 1,
142
143 /* I/O to channel is blocked */
144 pci_channel_io_frozen = (__force pci_channel_state_t) 2,
145
146 /* PCI card is dead */
147 pci_channel_io_perm_failure = (__force pci_channel_state_t) 3,
148};
149
Brian Kingf7bdd122007-04-06 16:39:36 -0500150typedef unsigned int __bitwise pcie_reset_state_t;
151
152enum pcie_reset_state {
153 /* Reset is NOT asserted (Use to deassert reset) */
154 pcie_deassert_reset = (__force pcie_reset_state_t) 1,
155
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700156 /* Use #PERST to reset PCIe device */
Brian Kingf7bdd122007-04-06 16:39:36 -0500157 pcie_warm_reset = (__force pcie_reset_state_t) 2,
158
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700159 /* Use PCIe Hot Reset to reset device */
Brian Kingf7bdd122007-04-06 16:39:36 -0500160 pcie_hot_reset = (__force pcie_reset_state_t) 3
161};
162
David Millerba698ad2007-10-25 01:16:30 -0700163typedef unsigned short __bitwise pci_dev_flags_t;
164enum pci_dev_flags {
165 /* INTX_DISABLE in PCI_COMMAND register disables MSI
166 * generation too.
167 */
168 PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG = (__force pci_dev_flags_t) 1,
Alan Cox979b1792008-07-24 17:18:38 +0100169 /* Device configuration is irrevocably lost if disabled into D3 */
170 PCI_DEV_FLAGS_NO_D3 = (__force pci_dev_flags_t) 2,
Greg Rose67778292011-07-22 05:46:07 +0000171 /* Provide indication device is assigned by a Virtual Machine Manager */
172 PCI_DEV_FLAGS_ASSIGNED = (__force pci_dev_flags_t) 4,
David Millerba698ad2007-10-25 01:16:30 -0700173};
174
Stefan Assmanne1d3a902008-06-11 16:35:17 +0200175enum pci_irq_reroute_variant {
176 INTEL_IRQ_REROUTE_VARIANT = 1,
177 MAX_IRQ_REROUTE_VARIANTS = 3
178};
179
Michael S. Tsirkin6e325a62006-02-14 18:52:22 +0200180typedef unsigned short __bitwise pci_bus_flags_t;
181enum pci_bus_flags {
Peter Orubad556ad42007-05-15 13:59:13 +0200182 PCI_BUS_FLAGS_NO_MSI = (__force pci_bus_flags_t) 1,
183 PCI_BUS_FLAGS_NO_MMRBC = (__force pci_bus_flags_t) 2,
Michael S. Tsirkin6e325a62006-02-14 18:52:22 +0200184};
185
Jacob Keller59da3812013-07-31 06:53:21 +0000186/* These values come from the PCI Express Spec */
187enum pcie_link_width {
188 PCIE_LNK_WIDTH_RESRV = 0x00,
189 PCIE_LNK_X1 = 0x01,
190 PCIE_LNK_X2 = 0x02,
191 PCIE_LNK_X4 = 0x04,
192 PCIE_LNK_X8 = 0x08,
193 PCIE_LNK_X12 = 0x0C,
194 PCIE_LNK_X16 = 0x10,
195 PCIE_LNK_X32 = 0x20,
196 PCIE_LNK_WIDTH_UNKNOWN = 0xFF,
197};
198
Matthew Wilcox536c8cb2009-12-13 08:11:31 -0500199/* Based on the PCI Hotplug Spec, but some values are made up by us */
200enum pci_bus_speed {
201 PCI_SPEED_33MHz = 0x00,
202 PCI_SPEED_66MHz = 0x01,
203 PCI_SPEED_66MHz_PCIX = 0x02,
204 PCI_SPEED_100MHz_PCIX = 0x03,
205 PCI_SPEED_133MHz_PCIX = 0x04,
206 PCI_SPEED_66MHz_PCIX_ECC = 0x05,
207 PCI_SPEED_100MHz_PCIX_ECC = 0x06,
208 PCI_SPEED_133MHz_PCIX_ECC = 0x07,
209 PCI_SPEED_66MHz_PCIX_266 = 0x09,
210 PCI_SPEED_100MHz_PCIX_266 = 0x0a,
211 PCI_SPEED_133MHz_PCIX_266 = 0x0b,
Matthew Wilcox45b4cdd52009-12-13 08:11:34 -0500212 AGP_UNKNOWN = 0x0c,
213 AGP_1X = 0x0d,
214 AGP_2X = 0x0e,
215 AGP_4X = 0x0f,
216 AGP_8X = 0x10,
Matthew Wilcox536c8cb2009-12-13 08:11:31 -0500217 PCI_SPEED_66MHz_PCIX_533 = 0x11,
218 PCI_SPEED_100MHz_PCIX_533 = 0x12,
219 PCI_SPEED_133MHz_PCIX_533 = 0x13,
220 PCIE_SPEED_2_5GT = 0x14,
221 PCIE_SPEED_5_0GT = 0x15,
Matthew Wilcox9dfd97f2009-12-13 08:11:35 -0500222 PCIE_SPEED_8_0GT = 0x16,
Matthew Wilcox536c8cb2009-12-13 08:11:31 -0500223 PCI_SPEED_UNKNOWN = 0xff,
224};
225
Alex Williamson24a4742f2011-05-10 10:02:11 -0600226struct pci_cap_saved_data {
Alex Williamsonfd0f7f72013-12-17 16:43:45 -0700227 u16 cap_nr;
228 bool cap_extended;
Alex Williamson24a4742f2011-05-10 10:02:11 -0600229 unsigned int size;
230 u32 data[0];
231};
232
Shaohua Li41017f02006-02-08 17:11:38 +0800233struct pci_cap_saved_state {
234 struct hlist_node next;
Alex Williamson24a4742f2011-05-10 10:02:11 -0600235 struct pci_cap_saved_data cap;
Shaohua Li41017f02006-02-08 17:11:38 +0800236};
237
Shaohua Li7d715a62008-02-25 09:46:41 +0800238struct pcie_link_state;
Jesse Barnesee69439c2008-04-28 12:30:35 -0700239struct pci_vpd;
Yu Zhaod1b054d2009-03-20 11:25:11 +0800240struct pci_sriov;
Yu Zhao302b4212009-05-18 13:51:32 +0800241struct pci_ats;
Jesse Barnesee69439c2008-04-28 12:30:35 -0700242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243/*
244 * The pci_dev structure is used to describe PCI devices.
245 */
246struct pci_dev {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 struct list_head bus_list; /* node in per-bus list */
248 struct pci_bus *bus; /* bus this device is on */
249 struct pci_bus *subordinate; /* bus this device bridges to */
250
251 void *sysdata; /* hook for sys-specific extension */
252 struct proc_dir_entry *procent; /* device entry in /proc/bus/pci */
Alex Chiangf46753c2008-06-10 15:28:50 -0600253 struct pci_slot *slot; /* Physical slot this device is in */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255 unsigned int devfn; /* encoded device & function index */
256 unsigned short vendor;
257 unsigned short device;
258 unsigned short subsystem_vendor;
259 unsigned short subsystem_device;
260 unsigned int class; /* 3 bytes: (base,sub,prog-if) */
Auke Kokb8a3a522007-06-08 15:46:30 -0700261 u8 revision; /* PCI revision, low byte of class word */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 u8 hdr_type; /* PCI header type (`multi' flag masked out) */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700263 u8 pcie_cap; /* PCIe capability offset */
Gavin Shane375b562013-04-04 16:54:30 +0000264 u8 msi_cap; /* MSI capability offset */
265 u8 msix_cap; /* MSI-X capability offset */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700266 u8 pcie_mpss:3; /* PCIe Max Payload Size Supported */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 u8 rom_base_reg; /* which config register controls the ROM */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700268 u8 pin; /* which interrupt pin this device uses */
269 u16 pcie_flags_reg; /* cached PCIe Capabilities Register */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
271 struct pci_driver *driver; /* which driver has allocated this device */
272 u64 dma_mask; /* Mask of the bits of bus address this
273 device implements. Normally this is
274 0xffffffff. You only need to change
275 this if your device has broken DMA
276 or supports 64-bit transfers. */
277
FUJITA Tomonori4d57cdf2008-02-04 22:27:55 -0800278 struct device_dma_parameters dma_parms;
279
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 pci_power_t current_state; /* Current operating state. In ACPI-speak,
281 this is D0-D3, D0 being fully functional,
282 and D3 being off. */
Bjorn Helgaas703860e2013-04-17 16:57:56 -0600283 u8 pm_cap; /* PM capability offset */
Rafael J. Wysocki337001b2008-07-07 03:36:24 +0200284 unsigned int pme_support:5; /* Bitmask of states from which PME#
285 can be generated */
Rafael J. Wysockic7f48652010-02-17 23:39:08 +0100286 unsigned int pme_interrupt:1;
Rafael J. Wysocki379021d2011-10-03 23:16:33 +0200287 unsigned int pme_poll:1; /* Poll device's PME status bit */
Rafael J. Wysocki337001b2008-07-07 03:36:24 +0200288 unsigned int d1_support:1; /* Low power state D1 is supported */
289 unsigned int d2_support:1; /* Low power state D2 is supported */
Huang Ying448bd852012-06-23 10:23:51 +0800290 unsigned int no_d1d2:1; /* D1 and D2 are forbidden */
291 unsigned int no_d3cold:1; /* D3cold is forbidden */
292 unsigned int d3cold_allowed:1; /* D3cold is allowed by user */
Jacob Pan253d2e52010-07-16 10:19:22 -0700293 unsigned int mmio_always_on:1; /* disallow turning off io/mem
294 decoding during bar sizing */
Rafael J. Wysockie80bb092009-09-08 23:14:49 +0200295 unsigned int wakeup_prepared:1;
Huang Ying448bd852012-06-23 10:23:51 +0800296 unsigned int runtime_d3cold:1; /* whether go through runtime
297 D3cold, not set for devices
298 powered on/off by the
299 corresponding bridge */
Rafael J. Wysocki1ae861e2009-12-31 12:15:54 +0100300 unsigned int d3_delay; /* D3->D0 transition time in ms */
Huang Ying448bd852012-06-23 10:23:51 +0800301 unsigned int d3cold_delay; /* D3cold->D0 transition time in ms */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Shaohua Li7d715a62008-02-25 09:46:41 +0800303#ifdef CONFIG_PCIEASPM
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700304 struct pcie_link_state *link_state; /* ASPM link state */
Shaohua Li7d715a62008-02-25 09:46:41 +0800305#endif
306
linas392a1ce2005-11-16 17:10:41 -0600307 pci_channel_state_t error_state; /* current connectivity state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 struct device dev; /* Generic device interface */
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 int cfg_size; /* Size of configuration space */
311
312 /*
313 * Instead of touching interrupt line and base address registers
314 * directly, use the values stored here. They might be different!
315 */
316 unsigned int irq;
317 struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
318
Yinghai Lu58d9a382013-01-21 13:20:51 -0800319 bool match_driver; /* Skip attaching driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 /* These fields are used by common fixups */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700321 unsigned int transparent:1; /* Subtractive decode PCI bridge */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 unsigned int multifunction:1;/* Part of multi-function device */
323 /* keep track of device state */
Greg Kroah-Hartman8a1bc902008-02-14 14:56:56 -0800324 unsigned int is_added:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 unsigned int is_busmaster:1; /* device is busmaster */
Kristen Accardi4602b882005-08-16 15:15:58 -0700326 unsigned int no_msi:1; /* device may not use msi */
Jan Kiszkafb51ccb2011-11-04 09:45:59 +0100327 unsigned int block_cfg_access:1; /* config space access is blocked */
Doug Thompsonbd8481e2006-05-08 17:06:09 -0700328 unsigned int broken_parity_status:1; /* Device generates false positive parity */
Stefan Assmanne1d3a902008-06-11 16:35:17 +0200329 unsigned int irq_reroute_variant:2; /* device needs IRQ rerouting variant */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700330 unsigned int msi_enabled:1;
Shaohua Li99dc8042006-05-26 10:58:27 +0800331 unsigned int msix_enabled:1;
Yu Zhao58c3a722008-10-14 14:02:53 +0800332 unsigned int ari_enabled:1; /* ARI forwarding */
Tejun Heo9ac78492007-01-20 16:00:26 +0900333 unsigned int is_managed:1;
Mike Mason260d7032009-07-30 15:33:21 -0700334 unsigned int needs_freset:1; /* Dev requires fundamental reset */
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100335 unsigned int state_saved:1;
Yu Zhaod1b054d2009-03-20 11:25:11 +0800336 unsigned int is_physfn:1;
Yu Zhaodd7cc442009-03-20 11:25:15 +0800337 unsigned int is_virtfn:1;
Michael S. Tsirkin711d5772009-07-27 23:37:48 +0300338 unsigned int reset_fn:1;
Eric W. Biederman28760482009-09-09 14:09:24 -0700339 unsigned int is_hotplug_bridge:1;
Huang Yingaffb72c2010-05-18 14:35:16 +0800340 unsigned int __aer_firmware_first_valid:1;
341 unsigned int __aer_firmware_first:1;
Bjorn Helgaasfbebb9f2012-06-16 14:40:22 -0600342 unsigned int broken_intx_masking:1;
Bjorn Helgaas2b28ae12012-07-09 13:38:57 -0600343 unsigned int io_window_1k:1; /* Intel P2P bridge 1K I/O windows */
David Millerba698ad2007-10-25 01:16:30 -0700344 pci_dev_flags_t dev_flags;
Inaky Perez-Gonzalezbae94d02006-11-22 12:40:31 -0800345 atomic_t enable_cnt; /* pci_enable_device has been called */
Kristen Accardi4602b882005-08-16 15:15:58 -0700346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 u32 saved_config_space[16]; /* config space saved at suspend time */
Shaohua Li41017f02006-02-08 17:11:38 +0800348 struct hlist_head saved_cap_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */
350 int rom_attr_enabled; /* has display of the rom attribute been enabled? */
351 struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700352 struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE]; /* sysfs file for WC mapping of resources */
Eric W. Biedermanded86d82007-01-28 12:42:52 -0700353#ifdef CONFIG_PCI_MSI
Michael Ellerman4aa9bc92007-04-05 17:19:10 +1000354 struct list_head msi_list;
Neil Hormanda8d1c82011-10-06 14:08:18 -0400355 struct kset *msi_kset;
Eric W. Biedermanded86d82007-01-28 12:42:52 -0700356#endif
Ben Hutchings94e61082008-03-05 16:52:39 +0000357 struct pci_vpd *vpd;
Joerg Roedel466b3dd2011-10-30 16:35:08 +0100358#ifdef CONFIG_PCI_ATS
Yu Zhaodd7cc442009-03-20 11:25:15 +0800359 union {
360 struct pci_sriov *sriov; /* SR-IOV capability related */
361 struct pci_dev *physfn; /* the PF this VF is associated with */
362 };
Yu Zhao302b4212009-05-18 13:51:32 +0800363 struct pci_ats *ats; /* Address Translation Service */
Yu Zhaod1b054d2009-03-20 11:25:11 +0800364#endif
Bjorn Helgaasdbd3fc32012-12-10 11:24:42 -0700365 phys_addr_t rom; /* Physical address of ROM if it's not from the BAR */
Matthew Garrett84c1b802012-12-05 14:33:27 -0700366 size_t romlen; /* Length of ROM if it's not from the BAR */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367};
368
Yinghaidda56542010-04-09 01:07:55 +0100369static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
370{
371#ifdef CONFIG_PCI_IOV
372 if (dev->is_virtfn)
373 dev = dev->physfn;
374#endif
Yinghaidda56542010-04-09 01:07:55 +0100375 return dev;
376}
377
Gu Zheng3c6e6ae2013-05-25 21:48:30 +0800378struct pci_dev *pci_alloc_dev(struct pci_bus *bus);
379struct pci_dev * __deprecated alloc_pci_dev(void);
Michael Ellerman65891212007-04-05 17:19:08 +1000380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381#define to_pci_dev(n) container_of(n, struct pci_dev, dev)
382#define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
383
Linas Vepstasa7369f12006-12-12 16:55:59 -0600384static inline int pci_channel_offline(struct pci_dev *pdev)
385{
386 return (pdev->error_state != pci_channel_io_normal);
387}
388
Yinghai Lu67cdc822012-05-17 18:51:12 -0700389extern struct resource busn_resource;
390
Bjorn Helgaas0efd5aa2012-02-23 20:19:00 -0700391struct pci_host_bridge_window {
392 struct list_head list;
393 struct resource *res; /* host bridge aperture (CPU address) */
394 resource_size_t offset; /* bus address + offset = CPU address */
395};
Shaohua Li41017f02006-02-08 17:11:38 +0800396
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700397struct pci_host_bridge {
Yinghai Lu7b543662012-04-02 18:31:53 -0700398 struct device dev;
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700399 struct pci_bus *bus; /* root bus */
Bjorn Helgaas0efd5aa2012-02-23 20:19:00 -0700400 struct list_head windows; /* pci_host_bridge_windows */
Yinghai Lu4fa26492012-04-02 18:31:53 -0700401 void (*release_fn)(struct pci_host_bridge *);
402 void *release_data;
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700403};
Shaohua Li41017f02006-02-08 17:11:38 +0800404
Yinghai Lu7b543662012-04-02 18:31:53 -0700405#define to_pci_host_bridge(n) container_of(n, struct pci_host_bridge, dev)
Yinghai Lu4fa26492012-04-02 18:31:53 -0700406void pci_set_host_bridge_release(struct pci_host_bridge *bridge,
407 void (*release_fn)(struct pci_host_bridge *),
408 void *release_data);
Yinghai Lu7b543662012-04-02 18:31:53 -0700409
Rafael J. Wysocki6c0cc952013-01-09 22:33:37 +0100410int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge);
411
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -0700412/*
413 * The first PCI_BRIDGE_RESOURCE_NUM PCI bus resources (those that correspond
414 * to P2P or CardBus bridge windows) go in a table. Additional ones (for
415 * buses below host bridges or subtractive decode bridges) go in the list.
416 * Use pci_bus_for_each_resource() to iterate through all the resources.
417 */
418
419/*
420 * PCI_SUBTRACTIVE_DECODE means the bridge forwards the window implicitly
421 * and there's no way to program the bridge with the details of the window.
422 * This does not apply to ACPI _CRS windows, even with the _DEC subtractive-
423 * decode bit set, because they are explicit and can be programmed with _SRS.
424 */
425#define PCI_SUBTRACTIVE_DECODE 0x1
426
427struct pci_bus_resource {
428 struct list_head list;
429 struct resource *res;
430 unsigned int flags;
431};
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -0700432
433#define PCI_REGION_FLAG_MASK 0x0fU /* These bits of resource flags tell us the PCI region flags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435struct pci_bus {
436 struct list_head node; /* node in list of buses */
437 struct pci_bus *parent; /* parent bus this bridge is on */
438 struct list_head children; /* list of child buses */
439 struct list_head devices; /* list of devices on this bus */
440 struct pci_dev *self; /* bridge device as seen by parent */
Alex Chiangf46753c2008-06-10 15:28:50 -0600441 struct list_head slots; /* list of slots on this bus */
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -0700442 struct resource *resource[PCI_BRIDGE_RESOURCE_NUM];
443 struct list_head resources; /* address space routed to this bus */
Yinghai Lu92f02432012-05-17 18:51:11 -0700444 struct resource busn_res; /* bus numbers routed to this bus */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446 struct pci_ops *ops; /* configuration access functions */
Thierry Reding0cbdcfc2013-08-09 22:27:08 +0200447 struct msi_chip *msi; /* MSI controller */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 void *sysdata; /* hook for sys-specific extension */
449 struct proc_dir_entry *procdir; /* directory entry in /proc/bus/pci */
450
451 unsigned char number; /* bus number */
452 unsigned char primary; /* number of primary bridge */
Matthew Wilcox3749c512009-12-13 08:11:32 -0500453 unsigned char max_bus_speed; /* enum pci_bus_speed */
454 unsigned char cur_bus_speed; /* enum pci_bus_speed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456 char name[48];
457
458 unsigned short bridge_ctl; /* manage NO_ISA/FBB/et al behaviors */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700459 pci_bus_flags_t bus_flags; /* inherited by child buses */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 struct device *bridge;
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400461 struct device dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 struct bin_attribute *legacy_io; /* legacy I/O for this bus */
463 struct bin_attribute *legacy_mem; /* legacy mem */
Greg Kroah-Hartmancc74d962008-03-12 21:48:03 -0700464 unsigned int is_added:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465};
466
467#define pci_bus_b(n) list_entry(n, struct pci_bus, node)
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400468#define to_pci_bus(n) container_of(n, struct pci_bus, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600470/*
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700471 * Returns true if the PCI bus is root (behind host-PCI bridge),
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600472 * false otherwise
Bjorn Helgaas77a0dfc2013-09-24 15:14:57 -0600473 *
474 * Some code assumes that "bus->self == NULL" means that bus is a root bus.
475 * This is incorrect because "virtual" buses added for SR-IOV (via
476 * virtfn_add_bus()) have "bus->self == NULL" but are not root buses.
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600477 */
478static inline bool pci_is_root_bus(struct pci_bus *pbus)
479{
480 return !(pbus->parent);
481}
482
Bjorn Helgaasc6bde212013-11-06 10:11:48 -0700483static inline struct pci_dev *pci_upstream_bridge(struct pci_dev *dev)
484{
485 dev = pci_physfn(dev);
486 if (pci_is_root_bus(dev->bus))
487 return NULL;
488
489 return dev->bus->self;
490}
491
Rafael J. Wysocki16cf0eb2009-01-05 14:50:27 +0100492#ifdef CONFIG_PCI_MSI
493static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev)
494{
495 return pci_dev->msi_enabled || pci_dev->msix_enabled;
496}
497#else
498static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev) { return false; }
499#endif
500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501/*
502 * Error values that may be returned by PCI functions.
503 */
504#define PCIBIOS_SUCCESSFUL 0x00
505#define PCIBIOS_FUNC_NOT_SUPPORTED 0x81
506#define PCIBIOS_BAD_VENDOR_ID 0x83
507#define PCIBIOS_DEVICE_NOT_FOUND 0x86
508#define PCIBIOS_BAD_REGISTER_NUMBER 0x87
509#define PCIBIOS_SET_FAILED 0x88
510#define PCIBIOS_BUFFER_TOO_SMALL 0x89
511
Alex Williamsona6961652012-06-11 05:27:33 +0000512/*
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700513 * Translate above to generic errno for passing back through non-PCI code.
Alex Williamsona6961652012-06-11 05:27:33 +0000514 */
515static inline int pcibios_err_to_errno(int err)
516{
517 if (err <= PCIBIOS_SUCCESSFUL)
518 return err; /* Assume already errno */
519
520 switch (err) {
521 case PCIBIOS_FUNC_NOT_SUPPORTED:
522 return -ENOENT;
523 case PCIBIOS_BAD_VENDOR_ID:
524 return -EINVAL;
525 case PCIBIOS_DEVICE_NOT_FOUND:
526 return -ENODEV;
527 case PCIBIOS_BAD_REGISTER_NUMBER:
528 return -EFAULT;
529 case PCIBIOS_SET_FAILED:
530 return -EIO;
531 case PCIBIOS_BUFFER_TOO_SMALL:
532 return -ENOSPC;
533 }
534
535 return -ENOTTY;
536}
537
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538/* Low-level architecture-dependent routines */
539
540struct pci_ops {
541 int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
542 int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
543};
544
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500545/*
546 * ACPI needs to be able to access PCI config space before we've done a
547 * PCI bus scan and created pci_bus structures.
548 */
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600549int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
550 int reg, int len, u32 *val);
551int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
552 int reg, int len, u32 val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554struct pci_bus_region {
Benjamin Herrenschmidtc40a22e2007-12-10 17:32:15 +1100555 resource_size_t start;
556 resource_size_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557};
558
559struct pci_dynids {
560 spinlock_t lock; /* protects list, index */
561 struct list_head list; /* for IDs added at runtime */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562};
563
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700564
565/*
566 * PCI Error Recovery System (PCI-ERS). If a PCI device driver provides
567 * a set of callbacks in struct pci_error_handlers, that device driver
568 * will be notified of PCI bus errors, and will be driven to recovery
569 * when an error occurs.
linas392a1ce2005-11-16 17:10:41 -0600570 */
571
572typedef unsigned int __bitwise pci_ers_result_t;
573
574enum pci_ers_result {
575 /* no result/none/not supported in device driver */
576 PCI_ERS_RESULT_NONE = (__force pci_ers_result_t) 1,
577
578 /* Device driver can recover without slot reset */
579 PCI_ERS_RESULT_CAN_RECOVER = (__force pci_ers_result_t) 2,
580
581 /* Device driver wants slot to be reset. */
582 PCI_ERS_RESULT_NEED_RESET = (__force pci_ers_result_t) 3,
583
584 /* Device has completely failed, is unrecoverable */
585 PCI_ERS_RESULT_DISCONNECT = (__force pci_ers_result_t) 4,
586
587 /* Device driver is fully recovered and operational */
588 PCI_ERS_RESULT_RECOVERED = (__force pci_ers_result_t) 5,
Vijay Mohan Pandarathil918b40532012-11-17 11:47:18 +0000589
590 /* No AER capabilities registered for the driver */
591 PCI_ERS_RESULT_NO_AER_DRIVER = (__force pci_ers_result_t) 6,
linas392a1ce2005-11-16 17:10:41 -0600592};
593
594/* PCI bus error event callbacks */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800595struct pci_error_handlers {
linas392a1ce2005-11-16 17:10:41 -0600596 /* PCI bus error detected on this device */
597 pci_ers_result_t (*error_detected)(struct pci_dev *dev,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800598 enum pci_channel_state error);
linas392a1ce2005-11-16 17:10:41 -0600599
600 /* MMIO has been re-enabled, but not DMA */
601 pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);
602
603 /* PCI Express link has been reset */
604 pci_ers_result_t (*link_reset)(struct pci_dev *dev);
605
606 /* PCI slot has been reset */
607 pci_ers_result_t (*slot_reset)(struct pci_dev *dev);
608
609 /* Device driver may resume normal operations */
610 void (*resume)(struct pci_dev *dev);
611};
612
linas392a1ce2005-11-16 17:10:41 -0600613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614struct module;
615struct pci_driver {
616 struct list_head node;
Stephen Hemminger42b21932010-09-02 14:28:51 -0700617 const char *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 const struct pci_device_id *id_table; /* must be non-NULL for probe to be called */
619 int (*probe) (struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */
620 void (*remove) (struct pci_dev *dev); /* Device removed (NULL if not a hot-plug capable driver) */
621 int (*suspend) (struct pci_dev *dev, pm_message_t state); /* Device suspended */
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700622 int (*suspend_late) (struct pci_dev *dev, pm_message_t state);
623 int (*resume_early) (struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 int (*resume) (struct pci_dev *dev); /* Device woken up */
Greg KHc8958172005-04-08 14:53:31 +0900625 void (*shutdown) (struct pci_dev *dev);
Donald Dutile17893822012-11-05 15:20:36 -0500626 int (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* PF pdev */
Stephen Hemminger49453022012-09-07 09:33:14 -0700627 const struct pci_error_handlers *err_handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 struct device_driver driver;
629 struct pci_dynids dynids;
630};
631
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800632#define to_pci_driver(drv) container_of(drv, struct pci_driver, driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
634/**
Andrew Morton9f9351b2008-03-10 11:43:34 -0700635 * DEFINE_PCI_DEVICE_TABLE - macro used to describe a pci device table
Jonas Bonn90a1ba02008-02-22 11:02:21 +0100636 * @_table: device table name
637 *
638 * This macro is used to create a struct pci_device_id array (a device table)
639 * in a generic manner.
640 */
Andrew Morton9f9351b2008-03-10 11:43:34 -0700641#define DEFINE_PCI_DEVICE_TABLE(_table) \
Bill Pemberton15856ad2012-11-21 15:35:00 -0500642 const struct pci_device_id _table[]
Jonas Bonn90a1ba02008-02-22 11:02:21 +0100643
644/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 * PCI_DEVICE - macro used to describe a specific pci device
646 * @vend: the 16 bit PCI Vendor ID
647 * @dev: the 16 bit PCI Device ID
648 *
649 * This macro is used to create a struct pci_device_id that matches a
650 * specific device. The subvendor and subdevice fields will be set to
651 * PCI_ANY_ID.
652 */
653#define PCI_DEVICE(vend,dev) \
654 .vendor = (vend), .device = (dev), \
655 .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
656
657/**
Nithin Nayak Sujir3d567e02012-11-14 14:44:26 +0000658 * PCI_DEVICE_SUB - macro used to describe a specific pci device with subsystem
659 * @vend: the 16 bit PCI Vendor ID
660 * @dev: the 16 bit PCI Device ID
661 * @subvend: the 16 bit PCI Subvendor ID
662 * @subdev: the 16 bit PCI Subdevice ID
663 *
664 * This macro is used to create a struct pci_device_id that matches a
665 * specific device with subsystem information.
666 */
667#define PCI_DEVICE_SUB(vend, dev, subvend, subdev) \
668 .vendor = (vend), .device = (dev), \
669 .subvendor = (subvend), .subdevice = (subdev)
670
671/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
673 * @dev_class: the class, subclass, prog-if triple for this device
674 * @dev_class_mask: the class mask for this device
675 *
676 * This macro is used to create a struct pci_device_id that matches a
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -0700677 * specific PCI class. The vendor, device, subvendor, and subdevice
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 * fields will be set to PCI_ANY_ID.
679 */
680#define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
681 .class = (dev_class), .class_mask = (dev_class_mask), \
682 .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
683 .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
684
Alan Cox1597cac2006-12-04 15:14:45 -0800685/**
686 * PCI_VDEVICE - macro used to describe a specific pci device in short form
Zhao, Yuc322b282008-10-13 19:36:05 +0800687 * @vendor: the vendor name
688 * @device: the 16 bit PCI Device ID
Alan Cox1597cac2006-12-04 15:14:45 -0800689 *
690 * This macro is used to create a struct pci_device_id that matches a
691 * specific PCI device. The subvendor, and subdevice fields will be set
692 * to PCI_ANY_ID. The macro allows the next field to follow as the device
693 * private data.
694 */
695
696#define PCI_VDEVICE(vendor, device) \
697 PCI_VENDOR_ID_##vendor, (device), \
698 PCI_ANY_ID, PCI_ANY_ID, 0, 0
699
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700/* these external functions are only available when PCI support is enabled */
701#ifdef CONFIG_PCI
702
Bjorn Helgaasa58674f2013-08-22 11:24:44 +0800703void pcie_bus_configure_settings(struct pci_bus *bus);
Jon Masonb03e7492011-07-20 15:20:54 -0500704
705enum pcie_bus_config_types {
Jon Mason5f39e672011-10-03 09:50:20 -0500706 PCIE_BUS_TUNE_OFF,
Jon Masonb03e7492011-07-20 15:20:54 -0500707 PCIE_BUS_SAFE,
Jon Mason5f39e672011-10-03 09:50:20 -0500708 PCIE_BUS_PERFORMANCE,
Jon Masonb03e7492011-07-20 15:20:54 -0500709 PCIE_BUS_PEER2PEER,
710};
711
712extern enum pcie_bus_config_types pcie_bus_config;
713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714extern struct bus_type pci_bus_type;
715
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700716/* Do NOT directly access these two variables, unless you are arch-specific PCI
717 * code, or PCI core code. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718extern struct list_head pci_root_buses; /* list of all known PCI buses */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700719/* Some device drivers need know if PCI is initiated */
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600720int no_pci_devices(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Yinghai Lu3c449ed2012-11-03 21:39:31 -0700722void pcibios_resource_survey_bus(struct pci_bus *bus);
Jiang Liu10a95742013-04-12 05:44:20 +0000723void pcibios_add_bus(struct pci_bus *bus);
724void pcibios_remove_bus(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725void pcibios_fixup_bus(struct pci_bus *);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700726int __must_check pcibios_enable_device(struct pci_dev *, int mask);
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700727/* Architecture-specific versions may override this (weak) */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800728char *pcibios_setup(char *str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730/* Used only when drivers/pci/setup.c is used */
Dominik Brodowski3b7a17f2010-01-01 17:40:50 +0100731resource_size_t pcibios_align_resource(void *, const struct resource *,
Dominik Brodowskib26b2d42010-01-01 17:40:49 +0100732 resource_size_t,
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700733 resource_size_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734void pcibios_update_irq(struct pci_dev *, int irq);
735
Benjamin Herrenschmidt2d1c8612009-12-09 17:52:13 +1100736/* Weak but can be overriden by arch */
737void pci_fixup_cardbus(struct pci_bus *);
738
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739/* Generic PCI functions used internally */
740
Bjorn Helgaas36a66cd2012-02-23 20:19:00 -0700741void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
742 struct resource *res);
743void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
744 struct pci_bus_region *region);
Mauro Carvalho Chehabd1fd4fb2009-07-10 18:39:53 -0300745void pcibios_scan_specific_bus(int busn);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600746struct pci_bus *pci_find_bus(int domain, int busnr);
akpm@linux-foundation.orgc48f1672009-02-03 15:45:26 -0800747void pci_bus_add_devices(const struct pci_bus *bus);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800748struct pci_bus *pci_scan_bus_parented(struct device *parent, int bus,
749 struct pci_ops *ops, void *sysdata);
Bjorn Helgaasde4b2f72011-10-28 16:25:55 -0600750struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata);
Bjorn Helgaas166c6372011-10-28 16:25:45 -0600751struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
752 struct pci_ops *ops, void *sysdata,
753 struct list_head *resources);
Yinghai Lu98a35832012-05-18 11:35:50 -0600754int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int busmax);
755int pci_bus_update_busn_res_end(struct pci_bus *b, int busmax);
756void pci_bus_release_busn_res(struct pci_bus *b);
Bill Pemberton15856ad2012-11-21 15:35:00 -0500757struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
Bjorn Helgaasa2ebb822011-10-28 16:25:50 -0600758 struct pci_ops *ops, void *sysdata,
759 struct list_head *resources);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800760struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
761 int busnr);
Matthew Wilcox3749c512009-12-13 08:11:32 -0500762void pcie_update_link_speed(struct pci_bus *bus, u16 link_status);
Alex Chiangf46753c2008-06-10 15:28:50 -0600763struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
Alex Chiang828f3762008-10-20 17:40:52 -0600764 const char *name,
765 struct hotplug_slot *hotplug);
Alex Chiangf46753c2008-06-10 15:28:50 -0600766void pci_destroy_slot(struct pci_slot *slot);
Alex Chiangd25b7c82008-10-20 17:40:47 -0600767void pci_renumber_slot(struct pci_slot *slot, int slot_nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768int pci_scan_slot(struct pci_bus *bus, int devfn);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800769struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn);
Paul Mackerrascdb9b9f2005-09-06 09:31:03 +1000770void pci_device_add(struct pci_dev *dev, struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771unsigned int pci_scan_child_bus(struct pci_bus *bus);
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700772int __must_check pci_bus_add_device(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773void pci_read_bridge_bases(struct pci_bus *child);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800774struct resource *pci_find_parent_resource(const struct pci_dev *dev,
775 struct resource *res);
John Crispin3df425f2012-04-12 17:33:07 +0200776u8 pci_swizzle_interrupt_pin(const struct pci_dev *dev, u8 pin);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777int pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge);
Bjorn Helgaas68feac82008-12-16 21:36:55 -0700778u8 pci_common_swizzle(struct pci_dev *dev, u8 *pinp);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600779struct pci_dev *pci_dev_get(struct pci_dev *dev);
780void pci_dev_put(struct pci_dev *dev);
781void pci_remove_bus(struct pci_bus *b);
782void pci_stop_and_remove_bus_device(struct pci_dev *dev);
Yinghai Lucdfcc572012-10-30 14:31:38 -0600783void pci_stop_root_bus(struct pci_bus *bus);
784void pci_remove_root_bus(struct pci_bus *bus);
Dominik Brodowskib3743fa2005-09-09 13:03:23 -0700785void pci_setup_cardbus(struct pci_bus *bus);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600786void pci_sort_breadthfirst(void);
Williams, Mitch Afb8a0d92010-02-10 01:43:04 +0000787#define dev_is_pci(d) ((d)->bus == &pci_bus_type)
788#define dev_is_pf(d) ((dev_is_pci(d) ? to_pci_dev(d)->is_physfn : false))
789#define dev_num_vf(d) ((dev_is_pci(d) ? pci_num_vf(to_pci_dev(d)) : 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
791/* Generic PCI functions exported to card drivers */
792
James Bottomley388c8c12008-08-03 13:02:12 -0500793enum pci_lost_interrupt_reason {
794 PCI_LOST_IRQ_NO_INFORMATION = 0,
795 PCI_LOST_IRQ_DISABLE_MSI,
796 PCI_LOST_IRQ_DISABLE_MSIX,
797 PCI_LOST_IRQ_DISABLE_ACPI,
798};
799enum pci_lost_interrupt_reason pci_lost_interrupt(struct pci_dev *dev);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800800int pci_find_capability(struct pci_dev *dev, int cap);
801int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap);
802int pci_find_ext_capability(struct pci_dev *dev, int cap);
Bjorn Helgaas44a9a362012-07-13 14:24:59 -0600803int pci_find_next_ext_capability(struct pci_dev *dev, int pos, int cap);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800804int pci_find_ht_capability(struct pci_dev *dev, int ht_cap);
805int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap);
Alan Cox29f3eb62006-10-16 16:20:21 -0700806struct pci_bus *pci_find_next_bus(const struct pci_bus *from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
Andrew Mortond42552c2006-10-21 10:24:12 -0700808struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device,
809 struct pci_dev *from);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800810struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 unsigned int ss_vendor, unsigned int ss_device,
Greg KHb08508c2008-08-26 08:20:34 -0700812 struct pci_dev *from);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800813struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);
Andrew Patterson3c299dc2009-10-12 13:14:00 -0600814struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
815 unsigned int devfn);
816static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
817 unsigned int devfn)
818{
819 return pci_get_domain_bus_and_slot(0, bus, devfn);
820}
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800821struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822int pci_dev_present(const struct pci_device_id *ids);
823
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800824int pci_bus_read_config_byte(struct pci_bus *bus, unsigned int devfn,
825 int where, u8 *val);
826int pci_bus_read_config_word(struct pci_bus *bus, unsigned int devfn,
827 int where, u16 *val);
828int pci_bus_read_config_dword(struct pci_bus *bus, unsigned int devfn,
829 int where, u32 *val);
830int pci_bus_write_config_byte(struct pci_bus *bus, unsigned int devfn,
831 int where, u8 val);
832int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn,
833 int where, u16 val);
834int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
835 int where, u32 val);
Huang Yinga72b46c2009-04-24 10:45:17 +0800836struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
Al Virobf362f72012-03-19 00:01:09 +0000838static inline int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800840 return pci_bus_read_config_byte(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
Al Virobf362f72012-03-19 00:01:09 +0000842static inline int pci_read_config_word(const struct pci_dev *dev, int where, u16 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800844 return pci_bus_read_config_word(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845}
Al Virobf362f72012-03-19 00:01:09 +0000846static inline int pci_read_config_dword(const struct pci_dev *dev, int where,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800847 u32 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800849 return pci_bus_read_config_dword(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850}
Al Virobf362f72012-03-19 00:01:09 +0000851static inline int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800853 return pci_bus_write_config_byte(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854}
Al Virobf362f72012-03-19 00:01:09 +0000855static inline int pci_write_config_word(const struct pci_dev *dev, int where, u16 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800857 return pci_bus_write_config_word(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858}
Al Virobf362f72012-03-19 00:01:09 +0000859static inline int pci_write_config_dword(const struct pci_dev *dev, int where,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800860 u32 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800862 return pci_bus_write_config_dword(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863}
864
Jiang Liu8c0d3a02012-07-24 17:20:05 +0800865int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val);
866int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val);
867int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val);
868int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val);
869int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos,
870 u16 clear, u16 set);
871int pcie_capability_clear_and_set_dword(struct pci_dev *dev, int pos,
872 u32 clear, u32 set);
873
874static inline int pcie_capability_set_word(struct pci_dev *dev, int pos,
875 u16 set)
876{
877 return pcie_capability_clear_and_set_word(dev, pos, 0, set);
878}
879
880static inline int pcie_capability_set_dword(struct pci_dev *dev, int pos,
881 u32 set)
882{
883 return pcie_capability_clear_and_set_dword(dev, pos, 0, set);
884}
885
886static inline int pcie_capability_clear_word(struct pci_dev *dev, int pos,
887 u16 clear)
888{
889 return pcie_capability_clear_and_set_word(dev, pos, clear, 0);
890}
891
892static inline int pcie_capability_clear_dword(struct pci_dev *dev, int pos,
893 u32 clear)
894{
895 return pcie_capability_clear_and_set_dword(dev, pos, clear, 0);
896}
897
Alex Williamsonc63587d2012-06-11 05:27:19 +0000898/* user-space driven config access */
899int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
900int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
901int pci_user_read_config_dword(struct pci_dev *dev, int where, u32 *val);
902int pci_user_write_config_byte(struct pci_dev *dev, int where, u8 val);
903int pci_user_write_config_word(struct pci_dev *dev, int where, u16 val);
904int pci_user_write_config_dword(struct pci_dev *dev, int where, u32 val);
905
Andrew Morton4a7fb632006-08-14 22:43:17 -0700906int __must_check pci_enable_device(struct pci_dev *dev);
Benjamin Herrenschmidtb7189892007-12-20 15:28:08 +1100907int __must_check pci_enable_device_io(struct pci_dev *dev);
908int __must_check pci_enable_device_mem(struct pci_dev *dev);
Tejun Heo0b62e132007-07-27 14:43:35 +0900909int __must_check pci_reenable_device(struct pci_dev *);
Tejun Heo9ac78492007-01-20 16:00:26 +0900910int __must_check pcim_enable_device(struct pci_dev *pdev);
911void pcim_pin_device(struct pci_dev *pdev);
912
Yuji Shimada296ccb02009-04-03 16:41:46 +0900913static inline int pci_is_enabled(struct pci_dev *pdev)
914{
915 return (atomic_read(&pdev->enable_cnt) > 0);
916}
917
Tejun Heo9ac78492007-01-20 16:00:26 +0900918static inline int pci_is_managed(struct pci_dev *pdev)
919{
920 return pdev->is_managed;
921}
922
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923void pci_disable_device(struct pci_dev *dev);
Myron Stowe96c55902011-10-28 15:48:38 -0600924
925extern unsigned int pcibios_max_latency;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926void pci_set_master(struct pci_dev *dev);
Ben Hutchings6a479072008-12-23 03:08:29 +0000927void pci_clear_master(struct pci_dev *dev);
Myron Stowe96c55902011-10-28 15:48:38 -0600928
Brian Kingf7bdd122007-04-06 16:39:36 -0500929int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
Tejun Heo15ea76d2009-09-22 17:34:48 +0900930int pci_set_cacheline_size(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931#define HAVE_PCI_SET_MWI
Andrew Morton4a7fb632006-08-14 22:43:17 -0700932int __must_check pci_set_mwi(struct pci_dev *dev);
Randy Dunlap694625c2007-07-09 11:55:54 -0700933int pci_try_set_mwi(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934void pci_clear_mwi(struct pci_dev *dev);
Brett M Russa04ce0f2005-08-15 15:23:41 -0400935void pci_intx(struct pci_dev *dev, int enable);
Jan Kiszkaa2e27782011-11-04 09:46:00 +0100936bool pci_intx_mask_supported(struct pci_dev *dev);
937bool pci_check_and_mask_intx(struct pci_dev *dev);
938bool pci_check_and_unmask_intx(struct pci_dev *dev);
Eric W. Biedermanf5f2b132007-03-05 00:30:07 -0800939void pci_msi_off(struct pci_dev *dev);
FUJITA Tomonori4d57cdf2008-02-04 22:27:55 -0800940int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size);
FUJITA Tomonori59fc67d2008-02-04 22:28:14 -0800941int pci_set_dma_seg_boundary(struct pci_dev *dev, unsigned long mask);
Alex Williamson157e8762013-12-17 16:43:39 -0700942int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask);
Casey Leedom3775a202013-08-06 15:48:36 +0530943int pci_wait_for_pending_transaction(struct pci_dev *dev);
Peter Orubad556ad42007-05-15 13:59:13 +0200944int pcix_get_max_mmrbc(struct pci_dev *dev);
945int pcix_get_mmrbc(struct pci_dev *dev);
946int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
Brice Goglin2637e5b2007-08-14 12:43:48 +0200947int pcie_get_readrq(struct pci_dev *dev);
Peter Orubad556ad42007-05-15 13:59:13 +0200948int pcie_set_readrq(struct pci_dev *dev, int rq);
Jon Masonb03e7492011-07-20 15:20:54 -0500949int pcie_get_mps(struct pci_dev *dev);
950int pcie_set_mps(struct pci_dev *dev, int mps);
Jacob Keller81377c82013-07-31 06:53:26 +0000951int pcie_get_minimum_link(struct pci_dev *dev, enum pci_bus_speed *speed,
952 enum pcie_link_width *width);
Yu Zhao8c1c6992009-06-13 15:52:13 +0800953int __pci_reset_function(struct pci_dev *dev);
Konrad Rzeszutek Wilka96d6272012-01-04 14:23:56 -0500954int __pci_reset_function_locked(struct pci_dev *dev);
Sheng Yang8dd7f802008-10-21 17:38:25 +0800955int pci_reset_function(struct pci_dev *dev);
Alex Williamson9a3d2b92013-08-14 14:06:05 -0600956int pci_probe_reset_slot(struct pci_slot *slot);
Alex Williamson090a3c52013-08-08 14:09:55 -0600957int pci_reset_slot(struct pci_slot *slot);
Alex Williamson9a3d2b92013-08-14 14:06:05 -0600958int pci_probe_reset_bus(struct pci_bus *bus);
Alex Williamson090a3c52013-08-08 14:09:55 -0600959int pci_reset_bus(struct pci_bus *bus);
Alex Williamson64e86742013-08-08 14:09:24 -0600960void pci_reset_bridge_secondary_bus(struct pci_dev *dev);
Yu Zhao14add802008-11-22 02:38:52 +0800961void pci_update_resource(struct pci_dev *dev, int resno);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700962int __must_check pci_assign_resource(struct pci_dev *dev, int i);
Ram Pai2bbc6942011-07-25 13:08:39 -0700963int __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 +0900964int pci_select_bars(struct pci_dev *dev, unsigned long flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
966/* ROM control related routines */
Alan Coxe416de52008-09-23 17:25:10 +0100967int pci_enable_rom(struct pci_dev *pdev);
968void pci_disable_rom(struct pci_dev *pdev);
Dave Jones144a50e2005-08-09 00:20:10 -0400969void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
Timothy S. Nelson97c44832009-01-30 06:12:47 +1100971size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size);
Matthew Garrettfffe01f2013-03-26 17:25:54 -0400972void __iomem __must_check *pci_platform_rom(struct pci_dev *pdev, size_t *size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
974/* Power management related routines */
975int pci_save_state(struct pci_dev *dev);
Jon Mason1d3c16a2010-11-30 17:43:26 -0600976void pci_restore_state(struct pci_dev *dev);
Alex Williamsonffbdd3f2011-05-10 10:02:27 -0600977struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
978int pci_load_saved_state(struct pci_dev *dev, struct pci_saved_state *state);
979int pci_load_and_free_saved_state(struct pci_dev *dev,
980 struct pci_saved_state **state);
Alex Williamsonfd0f7f72013-12-17 16:43:45 -0700981struct pci_cap_saved_state *pci_find_saved_cap(struct pci_dev *dev, char cap);
982struct pci_cap_saved_state *pci_find_saved_ext_cap(struct pci_dev *dev,
983 u16 cap);
984int pci_add_cap_save_buffer(struct pci_dev *dev, char cap, unsigned int size);
985int pci_add_ext_cap_save_buffer(struct pci_dev *dev,
986 u16 cap, unsigned int size);
Rafael J. Wysocki0e5dd462009-03-26 22:51:40 +0100987int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state);
Linus Torvalds9c8550e2005-09-09 15:43:46 -0700988int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
989pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
Rafael J. Wysockie5899e12008-07-19 14:39:24 +0200990bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
Rafael J. Wysocki5a6c9b62008-08-08 00:14:24 +0200991void pci_pme_active(struct pci_dev *dev, bool enable);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100992int __pci_enable_wake(struct pci_dev *dev, pci_power_t state,
993 bool runtime, bool enable);
Rafael J. Wysocki0235c4f2008-08-18 21:38:00 +0200994int pci_wake_from_d3(struct pci_dev *dev, bool enable);
Rafael J. Wysockie5899e12008-07-19 14:39:24 +0200995pci_power_t pci_target_state(struct pci_dev *dev);
Rafael J. Wysocki404cc2d2008-07-07 03:35:26 +0200996int pci_prepare_to_sleep(struct pci_dev *dev);
997int pci_back_from_sleep(struct pci_dev *dev);
Rafael J. Wysockib67ea762010-02-17 23:44:09 +0100998bool pci_dev_run_wake(struct pci_dev *dev);
Matthew Garrettbf4d2902010-10-04 14:22:26 -0400999bool pci_check_pme_status(struct pci_dev *dev);
Matthew Garrettbf4d2902010-10-04 14:22:26 -04001000void pci_pme_wakeup_bus(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001002static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
1003 bool enable)
1004{
1005 return __pci_enable_wake(dev, state, false, enable);
1006}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
Alex Williamson425c1b22013-12-17 16:43:51 -07001008/* PCI Virtual Channel */
1009int pci_save_vc_state(struct pci_dev *dev);
1010void pci_restore_vc_state(struct pci_dev *dev);
1011void pci_allocate_vc_save_buffers(struct pci_dev *dev);
1012
Jesse Barnesb48d4422010-10-19 13:07:57 -07001013#define PCI_EXP_IDO_REQUEST (1<<0)
1014#define PCI_EXP_IDO_COMPLETION (1<<1)
1015void pci_enable_ido(struct pci_dev *dev, unsigned long type);
1016void pci_disable_ido(struct pci_dev *dev, unsigned long type);
1017
Jesse Barnes48a92a82011-01-10 12:46:36 -08001018enum pci_obff_signal_type {
Myron Stowe688398b2011-07-07 15:00:36 -06001019 PCI_EXP_OBFF_SIGNAL_L0 = 0,
1020 PCI_EXP_OBFF_SIGNAL_ALWAYS = 1,
Jesse Barnes48a92a82011-01-10 12:46:36 -08001021};
1022int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type);
1023void pci_disable_obff(struct pci_dev *dev);
1024
Jesse Barnes51c2e0a2011-01-14 08:53:04 -08001025int pci_enable_ltr(struct pci_dev *dev);
1026void pci_disable_ltr(struct pci_dev *dev);
1027int pci_set_ltr(struct pci_dev *dev, int snoop_lat_ns, int nosnoop_lat_ns);
1028
Benjamin Herrenschmidtbb209c82010-01-26 17:10:03 +00001029/* For use by arch with custom probe code */
1030void set_pcie_port_type(struct pci_dev *pdev);
1031void set_pcie_hotplug_bridge(struct pci_dev *pdev);
1032
Kumar Galace5ccde2007-07-16 23:27:10 -05001033/* Functions for PCI Hotplug drivers to use */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001034int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
Yinghai Lu2f320522012-01-21 02:08:22 -08001035unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge);
Alex Chiang3ed4fd92009-03-20 14:56:25 -06001036unsigned int pci_rescan_bus(struct pci_bus *bus);
Kumar Galace5ccde2007-07-16 23:27:10 -05001037
Stephen Hemminger287d19c2008-12-18 09:17:16 -08001038/* Vital product data routines */
1039ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
1040ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void *buf);
Stephen Hemmingerdb567942008-12-18 09:17:16 -08001041int pci_vpd_truncate(struct pci_dev *dev, size_t size);
Stephen Hemminger287d19c2008-12-18 09:17:16 -08001042
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043/* Helper functions for low-level code (drivers/pci/setup-[bus,res].c) */
Myron Stowe925845b2011-11-21 11:54:13 -07001044resource_size_t pcibios_retrieve_fw_addr(struct pci_dev *dev, int idx);
Andrew Mortonea741552009-02-18 10:44:29 -08001045void pci_bus_assign_resources(const struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046void pci_bus_size_bridges(struct pci_bus *bus);
1047int pci_claim_resource(struct pci_dev *, int);
1048void pci_assign_unassigned_resources(void);
Yinghai Lu6841ec62010-01-22 01:02:25 -08001049void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge);
Yinghai Lu17787942012-10-30 14:31:10 -06001050void pci_assign_unassigned_bus_resources(struct pci_bus *bus);
Yinghai Lu39772032013-07-22 14:37:18 -07001051void pci_assign_unassigned_root_bus_resources(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052void pdev_enable_device(struct pci_dev *);
Bjorn Helgaas842de402008-03-04 11:56:47 -07001053int pci_enable_resources(struct pci_dev *, int mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
Ralf Baechled5341942011-06-10 15:30:21 +01001055 int (*)(const struct pci_dev *, u8, u8));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056#define HAVE_PCI_REQ_REGIONS 2
Andrew Morton4a7fb632006-08-14 22:43:17 -07001057int __must_check pci_request_regions(struct pci_dev *, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001058int __must_check pci_request_regions_exclusive(struct pci_dev *, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059void pci_release_regions(struct pci_dev *);
Andrew Morton4a7fb632006-08-14 22:43:17 -07001060int __must_check pci_request_region(struct pci_dev *, int, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001061int __must_check pci_request_region_exclusive(struct pci_dev *, int, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062void pci_release_region(struct pci_dev *, int);
Hidetoshi Setoc87deff2006-12-18 10:31:06 +09001063int pci_request_selected_regions(struct pci_dev *, int, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001064int pci_request_selected_regions_exclusive(struct pci_dev *, int, const char *);
Hidetoshi Setoc87deff2006-12-18 10:31:06 +09001065void pci_release_selected_regions(struct pci_dev *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
1067/* drivers/pci/bus.c */
Jiang Liufe830ef2013-05-25 21:48:29 +08001068struct pci_bus *pci_bus_get(struct pci_bus *bus);
1069void pci_bus_put(struct pci_bus *bus);
Bjorn Helgaas45ca9e92011-10-28 16:25:35 -06001070void pci_add_resource(struct list_head *resources, struct resource *res);
Bjorn Helgaas0efd5aa2012-02-23 20:19:00 -07001071void pci_add_resource_offset(struct list_head *resources, struct resource *res,
1072 resource_size_t offset);
Bjorn Helgaas45ca9e92011-10-28 16:25:35 -06001073void pci_free_resource_list(struct list_head *resources);
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -07001074void pci_bus_add_resource(struct pci_bus *bus, struct resource *res, unsigned int flags);
1075struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n);
1076void pci_bus_remove_resources(struct pci_bus *bus);
1077
Bjorn Helgaas89a74ec2010-02-23 10:24:31 -07001078#define pci_bus_for_each_resource(bus, res, i) \
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -07001079 for (i = 0; \
1080 (res = pci_bus_resource_n(bus, i)) || i < PCI_BRIDGE_RESOURCE_NUM; \
1081 i++)
Bjorn Helgaas89a74ec2010-02-23 10:24:31 -07001082
Andrew Morton4a7fb632006-08-14 22:43:17 -07001083int __must_check pci_bus_alloc_resource(struct pci_bus *bus,
1084 struct resource *res, resource_size_t size,
1085 resource_size_t align, resource_size_t min,
1086 unsigned int type_mask,
Dominik Brodowski3b7a17f2010-01-01 17:40:50 +01001087 resource_size_t (*alignf)(void *,
1088 const struct resource *,
Dominik Brodowskib26b2d42010-01-01 17:40:49 +01001089 resource_size_t,
1090 resource_size_t),
Andrew Morton4a7fb632006-08-14 22:43:17 -07001091 void *alignf_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
Laurent riffard863b18f2005-10-27 23:12:54 +02001093/* Proper probing supporting hot-pluggable devices */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001094int __must_check __pci_register_driver(struct pci_driver *, struct module *,
1095 const char *mod_name);
Andrew Mortonbba81162008-07-30 12:07:04 -07001096
1097/*
1098 * pci_register_driver must be a macro so that KBUILD_MODNAME can be expanded
1099 */
1100#define pci_register_driver(driver) \
1101 __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
Laurent riffard863b18f2005-10-27 23:12:54 +02001102
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001103void pci_unregister_driver(struct pci_driver *dev);
Greg Kroah-Hartmanaad4f402011-11-18 10:12:49 -08001104
1105/**
1106 * module_pci_driver() - Helper macro for registering a PCI driver
1107 * @__pci_driver: pci_driver struct
1108 *
1109 * Helper macro for PCI drivers which do not do anything special in module
1110 * init/exit. This eliminates a lot of boilerplate. Each module may only
1111 * use this macro once, and calling it replaces module_init() and module_exit()
1112 */
1113#define module_pci_driver(__pci_driver) \
1114 module_driver(__pci_driver, pci_register_driver, \
1115 pci_unregister_driver)
1116
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001117struct pci_driver *pci_dev_driver(const struct pci_dev *dev);
Tejun Heo9dba9102009-09-03 15:26:36 +09001118int pci_add_dynid(struct pci_driver *drv,
1119 unsigned int vendor, unsigned int device,
1120 unsigned int subvendor, unsigned int subdevice,
1121 unsigned int class, unsigned int class_mask,
1122 unsigned long driver_data);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001123const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
1124 struct pci_dev *dev);
1125int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max,
1126 int pass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127
Zhang, Yanmin70298c62009-06-16 13:34:38 +08001128void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
Paul Mackerrascecf4862005-08-18 14:33:01 +10001129 void *userdata);
Yinghai Lu70b9f7d2008-04-28 16:27:23 -07001130int pci_cfg_space_size_ext(struct pci_dev *dev);
Benjamin Herrenschmidtac7dc652005-12-13 18:09:16 +11001131int pci_cfg_space_size(struct pci_dev *dev);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001132unsigned char pci_bus_max_busnr(struct pci_bus *bus);
Benjamin Herrenschmidte2444272011-09-11 14:08:38 -03001133void pci_setup_bridge(struct pci_bus *bus);
Gavin Shanac5ad932012-09-11 16:59:45 -06001134resource_size_t pcibios_window_alignment(struct pci_bus *bus,
1135 unsigned long type);
Paul Mackerrascecf4862005-08-18 14:33:01 +10001136
Dave Airlie3448a192010-06-01 15:32:24 +10001137#define PCI_VGA_STATE_CHANGE_BRIDGE (1 << 0)
1138#define PCI_VGA_STATE_CHANGE_DECODES (1 << 1)
1139
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001140int pci_set_vga_state(struct pci_dev *pdev, bool decode,
Dave Airlie3448a192010-06-01 15:32:24 +10001141 unsigned int command_bits, u32 flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142/* kmem_cache style wrapper around pci_alloc_consistent() */
1143
FUJITA Tomonorif41b1772010-03-10 15:23:30 -08001144#include <linux/pci-dma.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145#include <linux/dmapool.h>
1146
1147#define pci_pool dma_pool
1148#define pci_pool_create(name, pdev, size, align, allocation) \
1149 dma_pool_create(name, &pdev->dev, size, align, allocation)
1150#define pci_pool_destroy(pool) dma_pool_destroy(pool)
1151#define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
1152#define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
1153
David S. Millere24c2d92005-06-02 12:55:50 -07001154enum pci_dma_burst_strategy {
1155 PCI_DMA_BURST_INFINITY, /* make bursts as large as possible,
1156 strategy_parameter is N/A */
1157 PCI_DMA_BURST_BOUNDARY, /* disconnect at every strategy_parameter
1158 byte boundaries */
1159 PCI_DMA_BURST_MULTIPLE, /* disconnect at some multiple of
1160 strategy_parameter byte boundaries */
1161};
1162
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163struct msix_entry {
Yinghai Lu16dbef42008-08-15 19:36:45 -07001164 u32 vector; /* kernel uses to write allocated vector */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 u16 entry; /* driver uses to specify entry, OS writes */
1166};
1167
Eric W. Biederman0366f8f2006-10-04 02:16:33 -07001168
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169#ifndef CONFIG_PCI_MSI
Matthew Wilcox1c8d7b02009-03-17 08:54:10 -04001170static inline int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001171{
1172 return -1;
1173}
1174
Alexander Gordeev08261d82012-11-19 16:02:10 +01001175static inline int
1176pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec)
1177{
1178 return -1;
1179}
1180
Yinghai Lud52877c2008-04-23 14:58:09 -07001181static inline void pci_msi_shutdown(struct pci_dev *dev)
1182{ }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001183static inline void pci_disable_msi(struct pci_dev *dev)
1184{ }
1185
Rafael J. Wysockia52e2e32009-01-24 00:21:14 +01001186static inline int pci_msix_table_size(struct pci_dev *dev)
1187{
1188 return 0;
1189}
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001190static inline int pci_enable_msix(struct pci_dev *dev,
1191 struct msix_entry *entries, int nvec)
1192{
1193 return -1;
1194}
1195
Yinghai Lud52877c2008-04-23 14:58:09 -07001196static inline void pci_msix_shutdown(struct pci_dev *dev)
1197{ }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001198static inline void pci_disable_msix(struct pci_dev *dev)
1199{ }
1200
1201static inline void msi_remove_pci_irq_vectors(struct pci_dev *dev)
1202{ }
1203
1204static inline void pci_restore_msi_state(struct pci_dev *dev)
1205{ }
Andrew Patterson07ae95f2008-11-10 15:31:05 -07001206static inline int pci_msi_enabled(void)
1207{
1208 return 0;
1209}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210#else
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001211int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec);
1212int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec);
1213void pci_msi_shutdown(struct pci_dev *dev);
1214void pci_disable_msi(struct pci_dev *dev);
1215int pci_msix_table_size(struct pci_dev *dev);
1216int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec);
1217void pci_msix_shutdown(struct pci_dev *dev);
1218void pci_disable_msix(struct pci_dev *dev);
1219void msi_remove_pci_irq_vectors(struct pci_dev *dev);
1220void pci_restore_msi_state(struct pci_dev *dev);
1221int pci_msi_enabled(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222#endif
1223
Markus Trippelsdorfab0724f2011-01-15 00:07:22 +01001224#ifdef CONFIG_PCIEPORTBUS
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001225extern bool pcie_ports_disabled;
1226extern bool pcie_ports_auto;
Markus Trippelsdorfab0724f2011-01-15 00:07:22 +01001227#else
1228#define pcie_ports_disabled true
1229#define pcie_ports_auto false
1230#endif
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001231
Andrew Patterson3e1b1602008-11-10 15:30:55 -07001232#ifndef CONFIG_PCIEASPM
Rafael J. Wysocki8b8bae92011-03-05 13:21:51 +01001233static inline int pcie_aspm_enabled(void) { return 0; }
1234static inline bool pcie_aspm_support_enabled(void) { return false; }
Andrew Patterson3e1b1602008-11-10 15:30:55 -07001235#else
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001236int pcie_aspm_enabled(void);
1237bool pcie_aspm_support_enabled(void);
Andrew Patterson3e1b1602008-11-10 15:30:55 -07001238#endif
1239
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001240#ifdef CONFIG_PCIEAER
1241void pci_no_aer(void);
1242bool pci_aer_available(void);
1243#else
1244static inline void pci_no_aer(void) { }
1245static inline bool pci_aer_available(void) { return false; }
1246#endif
1247
Andrew Patterson43c16402009-04-22 16:52:09 -06001248#ifndef CONFIG_PCIE_ECRC
1249static inline void pcie_set_ecrc_checking(struct pci_dev *dev)
1250{
1251 return;
1252}
1253static inline void pcie_ecrc_get_policy(char *str) {};
1254#else
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001255void pcie_set_ecrc_checking(struct pci_dev *dev);
1256void pcie_ecrc_get_policy(char *str);
Andrew Patterson43c16402009-04-22 16:52:09 -06001257#endif
1258
Matthew Wilcox1c8d7b02009-03-17 08:54:10 -04001259#define pci_enable_msi(pdev) pci_enable_msi_block(pdev, 1)
1260
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001261#ifdef CONFIG_HT_IRQ
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001262/* The functions a driver should call */
1263int ht_create_irq(struct pci_dev *dev, int idx);
1264void ht_destroy_irq(unsigned int irq);
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001265#endif /* CONFIG_HT_IRQ */
1266
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001267void pci_cfg_access_lock(struct pci_dev *dev);
1268bool pci_cfg_access_trylock(struct pci_dev *dev);
1269void pci_cfg_access_unlock(struct pci_dev *dev);
Brian Kinge04b0ea2005-09-27 01:21:55 -07001270
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001271/*
1272 * PCI domain support. Sometimes called PCI segment (eg by ACPI),
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001273 * a PCI domain is defined to be a set of PCI buses which share
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001274 * configuration space.
1275 */
Jeff Garzik32a2eea72007-10-11 16:57:27 -04001276#ifdef CONFIG_PCI_DOMAINS
1277extern int pci_domains_supported;
1278#else
1279enum { pci_domains_supported = 0 };
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001280static inline int pci_domain_nr(struct pci_bus *bus)
1281{
1282 return 0;
1283}
1284
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001285static inline int pci_proc_domain(struct pci_bus *bus)
1286{
1287 return 0;
1288}
Jeff Garzik32a2eea72007-10-11 16:57:27 -04001289#endif /* CONFIG_PCI_DOMAINS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290
Mike Travis95a8b6e2010-02-02 14:38:13 -08001291/* some architectures require additional setup to direct VGA traffic */
1292typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode,
Dave Airlie3448a192010-06-01 15:32:24 +10001293 unsigned int command_bits, u32 flags);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001294void pci_register_set_vga_state(arch_set_vga_state_t func);
Mike Travis95a8b6e2010-02-02 14:38:13 -08001295
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001296#else /* CONFIG_PCI is not enabled */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297
1298/*
1299 * If the system does not have PCI, clearly these return errors. Define
1300 * these as simple inline functions to avoid hair in drivers.
1301 */
1302
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001303#define _PCI_NOP(o, s, t) \
1304 static inline int pci_##o##_config_##s(struct pci_dev *dev, \
1305 int where, t val) \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 { return PCIBIOS_FUNC_NOT_SUPPORTED; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001307
1308#define _PCI_NOP_ALL(o, x) _PCI_NOP(o, byte, u8 x) \
1309 _PCI_NOP(o, word, u16 x) \
1310 _PCI_NOP(o, dword, u32 x)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311_PCI_NOP_ALL(read, *)
1312_PCI_NOP_ALL(write,)
1313
Andrew Mortond42552c2006-10-21 10:24:12 -07001314static inline struct pci_dev *pci_get_device(unsigned int vendor,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001315 unsigned int device,
1316 struct pci_dev *from)
1317{
1318 return NULL;
1319}
Andrew Mortond42552c2006-10-21 10:24:12 -07001320
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001321static inline struct pci_dev *pci_get_subsys(unsigned int vendor,
1322 unsigned int device,
1323 unsigned int ss_vendor,
1324 unsigned int ss_device,
Greg KHb08508c2008-08-26 08:20:34 -07001325 struct pci_dev *from)
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001326{
1327 return NULL;
1328}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001330static inline struct pci_dev *pci_get_class(unsigned int class,
1331 struct pci_dev *from)
1332{
1333 return NULL;
1334}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
1336#define pci_dev_present(ids) (0)
Zhang, Yanmined4aaad2007-07-15 23:39:39 -07001337#define no_pci_devices() (1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338#define pci_dev_put(dev) do { } while (0)
1339
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001340static inline void pci_set_master(struct pci_dev *dev)
1341{ }
1342
1343static inline int pci_enable_device(struct pci_dev *dev)
1344{
1345 return -EIO;
1346}
1347
1348static inline void pci_disable_device(struct pci_dev *dev)
1349{ }
1350
1351static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
1352{
1353 return -EIO;
1354}
1355
Randy Dunlap80be0382008-06-30 11:35:53 -07001356static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
1357{
1358 return -EIO;
1359}
1360
FUJITA Tomonori4d57cdf2008-02-04 22:27:55 -08001361static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
1362 unsigned int size)
1363{
1364 return -EIO;
1365}
1366
FUJITA Tomonori59fc67d2008-02-04 22:28:14 -08001367static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
1368 unsigned long mask)
1369{
1370 return -EIO;
1371}
1372
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001373static inline int pci_assign_resource(struct pci_dev *dev, int i)
1374{
1375 return -EBUSY;
1376}
1377
1378static inline int __pci_register_driver(struct pci_driver *drv,
1379 struct module *owner)
1380{
1381 return 0;
1382}
1383
1384static inline int pci_register_driver(struct pci_driver *drv)
1385{
1386 return 0;
1387}
1388
1389static inline void pci_unregister_driver(struct pci_driver *drv)
1390{ }
1391
1392static inline int pci_find_capability(struct pci_dev *dev, int cap)
1393{
1394 return 0;
1395}
1396
1397static inline int pci_find_next_capability(struct pci_dev *dev, u8 post,
1398 int cap)
1399{
1400 return 0;
1401}
1402
1403static inline int pci_find_ext_capability(struct pci_dev *dev, int cap)
1404{
1405 return 0;
1406}
1407
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408/* Power management related routines */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001409static inline int pci_save_state(struct pci_dev *dev)
1410{
1411 return 0;
1412}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Jon Mason1d3c16a2010-11-30 17:43:26 -06001414static inline void pci_restore_state(struct pci_dev *dev)
1415{ }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001416
1417static inline int pci_set_power_state(struct pci_dev *dev, pci_power_t state)
1418{
1419 return 0;
1420}
1421
Randy Dunlap34492482011-02-14 12:27:50 -08001422static inline int pci_wake_from_d3(struct pci_dev *dev, bool enable)
1423{
1424 return 0;
1425}
1426
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001427static inline pci_power_t pci_choose_state(struct pci_dev *dev,
1428 pm_message_t state)
1429{
1430 return PCI_D0;
1431}
1432
1433static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
1434 int enable)
1435{
1436 return 0;
1437}
1438
Jesse Barnesb48d4422010-10-19 13:07:57 -07001439static inline void pci_enable_ido(struct pci_dev *dev, unsigned long type)
1440{
1441}
1442
1443static inline void pci_disable_ido(struct pci_dev *dev, unsigned long type)
1444{
1445}
1446
Jesse Barnes48a92a82011-01-10 12:46:36 -08001447static inline int pci_enable_obff(struct pci_dev *dev, unsigned long type)
1448{
1449 return 0;
1450}
1451
1452static inline void pci_disable_obff(struct pci_dev *dev)
1453{
1454}
1455
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001456static inline int pci_request_regions(struct pci_dev *dev, const char *res_name)
1457{
1458 return -EIO;
1459}
1460
1461static inline void pci_release_regions(struct pci_dev *dev)
1462{ }
Sergei Shtylyov0da0ead2007-04-01 21:13:58 +04001463
Kumar Galaa46e8122005-07-29 12:16:27 -07001464#define pci_dma_burst_advice(pdev, strat, strategy_parameter) do { } while (0)
1465
Jan Kiszkafb51ccb2011-11-04 09:45:59 +01001466static inline void pci_block_cfg_access(struct pci_dev *dev)
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001467{ }
1468
Jan Kiszkafb51ccb2011-11-04 09:45:59 +01001469static inline int pci_block_cfg_access_in_atomic(struct pci_dev *dev)
1470{ return 0; }
1471
1472static inline void pci_unblock_cfg_access(struct pci_dev *dev)
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001473{ }
Brian Kinge04b0ea2005-09-27 01:21:55 -07001474
Randy Dunlapd80d0212007-07-01 12:06:37 -07001475static inline struct pci_bus *pci_find_next_bus(const struct pci_bus *from)
1476{ return NULL; }
1477
1478static inline struct pci_dev *pci_get_slot(struct pci_bus *bus,
1479 unsigned int devfn)
1480{ return NULL; }
1481
1482static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
1483 unsigned int devfn)
1484{ return NULL; }
1485
Dave Airlie92298e62010-08-13 10:22:17 +10001486static inline int pci_domain_nr(struct pci_bus *bus)
1487{ return 0; }
1488
Alex Williamson12ea6ca2012-06-11 05:26:55 +00001489static inline struct pci_dev *pci_dev_get(struct pci_dev *dev)
1490{ return NULL; }
1491
Williams, Mitch Afb8a0d92010-02-10 01:43:04 +00001492#define dev_is_pci(d) (false)
1493#define dev_is_pf(d) (false)
1494#define dev_num_vf(d) (0)
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001495#endif /* CONFIG_PCI */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001497/* Include architecture-dependent settings and functions */
1498
1499#include <asm/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
Yinghai Lu1f82de12009-04-23 20:48:32 -07001501#ifndef PCIBIOS_MAX_MEM_32
1502#define PCIBIOS_MAX_MEM_32 (-1)
1503#endif
1504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505/* these helpers provide future and backwards compatibility
1506 * for accessing popular PCI BAR info */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001507#define pci_resource_start(dev, bar) ((dev)->resource[(bar)].start)
1508#define pci_resource_end(dev, bar) ((dev)->resource[(bar)].end)
1509#define pci_resource_flags(dev, bar) ((dev)->resource[(bar)].flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510#define pci_resource_len(dev,bar) \
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001511 ((pci_resource_start((dev), (bar)) == 0 && \
1512 pci_resource_end((dev), (bar)) == \
1513 pci_resource_start((dev), (bar))) ? 0 : \
1514 \
1515 (pci_resource_end((dev), (bar)) - \
1516 pci_resource_start((dev), (bar)) + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
1518/* Similar to the helpers above, these manipulate per-pci_dev
1519 * driver-specific data. They are really just a wrapper around
1520 * the generic device structure functions of these calls.
1521 */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001522static inline void *pci_get_drvdata(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523{
1524 return dev_get_drvdata(&pdev->dev);
1525}
1526
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001527static inline void pci_set_drvdata(struct pci_dev *pdev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528{
1529 dev_set_drvdata(&pdev->dev, data);
1530}
1531
1532/* If you want to know what to call your pci_dev, ask this function.
1533 * Again, it's a wrapper around the generic device.
1534 */
Alexey Zaytsev2fc90f62009-06-24 16:22:30 +04001535static inline const char *pci_name(const struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536{
Greg KHc6c4f072008-07-03 09:49:39 -07001537 return dev_name(&pdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538}
1539
Michael Ellerman2311b1f2005-05-13 17:44:10 +10001540
1541/* Some archs don't want to expose struct resource to userland as-is
1542 * in sysfs and /proc
1543 */
1544#ifndef HAVE_ARCH_PCI_RESOURCE_TO_USER
1545static inline void pci_resource_to_user(const struct pci_dev *dev, int bar,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001546 const struct resource *rsrc, resource_size_t *start,
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -07001547 resource_size_t *end)
Michael Ellerman2311b1f2005-05-13 17:44:10 +10001548{
1549 *start = rsrc->start;
1550 *end = rsrc->end;
1551}
1552#endif /* HAVE_ARCH_PCI_RESOURCE_TO_USER */
1553
1554
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555/*
1556 * The world is not perfect and supplies us with broken PCI devices.
1557 * For at least a part of these bugs we need a work-around, so both
1558 * generic (drivers/pci/quirks.c) and per-architecture code can define
1559 * fixup hooks to be called for particular buggy devices.
1560 */
1561
1562struct pci_fixup {
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001563 u16 vendor; /* You can use PCI_ANY_ID here of course */
1564 u16 device; /* You can use PCI_ANY_ID here of course */
1565 u32 class; /* You can use PCI_ANY_ID here too */
1566 unsigned int class_shift; /* should be 0, 8, 16 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 void (*hook)(struct pci_dev *dev);
1568};
1569
1570enum pci_fixup_pass {
1571 pci_fixup_early, /* Before probing BARs */
1572 pci_fixup_header, /* After reading configuration header */
1573 pci_fixup_final, /* Final phase of device fixups */
1574 pci_fixup_enable, /* pci_enable_device() time */
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001575 pci_fixup_resume, /* pci_device_resume() */
1576 pci_fixup_suspend, /* pci_device_suspend */
1577 pci_fixup_resume_early, /* pci_device_resume_early() */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578};
1579
1580/* Anonymous variables would be nice... */
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001581#define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, class, \
1582 class_shift, hook) \
Mathias Krause769ae542012-09-02 23:37:24 +02001583 static const struct pci_fixup __pci_fixup_##name __used \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001584 __attribute__((__section__(#section), aligned((sizeof(void *))))) \
1585 = { vendor, device, class, class_shift, hook };
1586
1587#define DECLARE_PCI_FIXUP_CLASS_EARLY(vendor, device, class, \
1588 class_shift, hook) \
1589 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early, \
1590 vendor##device##hook, vendor, device, class, class_shift, hook)
1591#define DECLARE_PCI_FIXUP_CLASS_HEADER(vendor, device, class, \
1592 class_shift, hook) \
1593 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header, \
1594 vendor##device##hook, vendor, device, class, class_shift, hook)
1595#define DECLARE_PCI_FIXUP_CLASS_FINAL(vendor, device, class, \
1596 class_shift, hook) \
1597 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final, \
1598 vendor##device##hook, vendor, device, class, class_shift, hook)
1599#define DECLARE_PCI_FIXUP_CLASS_ENABLE(vendor, device, class, \
1600 class_shift, hook) \
1601 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable, \
1602 vendor##device##hook, vendor, device, class, class_shift, hook)
1603#define DECLARE_PCI_FIXUP_CLASS_RESUME(vendor, device, class, \
1604 class_shift, hook) \
1605 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume, \
1606 resume##vendor##device##hook, vendor, device, class, \
1607 class_shift, hook)
1608#define DECLARE_PCI_FIXUP_CLASS_RESUME_EARLY(vendor, device, class, \
1609 class_shift, hook) \
1610 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early, \
1611 resume_early##vendor##device##hook, vendor, device, \
1612 class, class_shift, hook)
1613#define DECLARE_PCI_FIXUP_CLASS_SUSPEND(vendor, device, class, \
1614 class_shift, hook) \
1615 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend, \
1616 suspend##vendor##device##hook, vendor, device, class, \
1617 class_shift, hook)
1618
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619#define DECLARE_PCI_FIXUP_EARLY(vendor, device, hook) \
1620 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001621 vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622#define DECLARE_PCI_FIXUP_HEADER(vendor, device, hook) \
1623 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001624 vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625#define DECLARE_PCI_FIXUP_FINAL(vendor, device, hook) \
1626 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001627 vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628#define DECLARE_PCI_FIXUP_ENABLE(vendor, device, hook) \
1629 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001630 vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
Alan Cox1597cac2006-12-04 15:14:45 -08001631#define DECLARE_PCI_FIXUP_RESUME(vendor, device, hook) \
1632 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001633 resume##vendor##device##hook, vendor, device, \
1634 PCI_ANY_ID, 0, hook)
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001635#define DECLARE_PCI_FIXUP_RESUME_EARLY(vendor, device, hook) \
1636 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001637 resume_early##vendor##device##hook, vendor, device, \
1638 PCI_ANY_ID, 0, hook)
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001639#define DECLARE_PCI_FIXUP_SUSPEND(vendor, device, hook) \
1640 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001641 suspend##vendor##device##hook, vendor, device, \
1642 PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001644#ifdef CONFIG_PCI_QUIRKS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
Alex Williamson12ea6ca2012-06-11 05:26:55 +00001646struct pci_dev *pci_get_dma_source(struct pci_dev *dev);
Alex Williamsonad805752012-06-11 05:27:07 +00001647int pci_dev_specific_acs_enabled(struct pci_dev *dev, u16 acs_flags);
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001648#else
1649static inline void pci_fixup_device(enum pci_fixup_pass pass,
1650 struct pci_dev *dev) {}
Alex Williamson12ea6ca2012-06-11 05:26:55 +00001651static inline struct pci_dev *pci_get_dma_source(struct pci_dev *dev)
1652{
1653 return pci_dev_get(dev);
1654}
Alex Williamsonad805752012-06-11 05:27:07 +00001655static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
1656 u16 acs_flags)
1657{
1658 return -ENOTTY;
1659}
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001660#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001662void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);
Al Viro5ea81762007-02-11 15:41:31 +00001663void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001664void __iomem * const *pcim_iomap_table(struct pci_dev *pdev);
Yinghai Lufb7ebfe2012-01-04 15:50:02 -08001665int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name);
1666int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask,
Tejun Heo916fbfb2008-03-12 15:26:34 +09001667 const char *name);
Yinghai Lufb7ebfe2012-01-04 15:50:02 -08001668void pcim_iounmap_regions(struct pci_dev *pdev, int mask);
Al Viro5ea81762007-02-11 15:41:31 +00001669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670extern int pci_pci_problems;
Alan Cox236561e2006-09-30 23:27:03 -07001671#define PCIPCI_FAIL 1 /* No PCI PCI DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672#define PCIPCI_TRITON 2
1673#define PCIPCI_NATOMA 4
1674#define PCIPCI_VIAETBF 8
1675#define PCIPCI_VSFX 16
Alan Cox236561e2006-09-30 23:27:03 -07001676#define PCIPCI_ALIMAGIK 32 /* Need low latency setting */
1677#define PCIAGP_FAIL 64 /* No PCI to AGP DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
Atsushi Nemoto4516a612007-02-05 16:36:06 -08001679extern unsigned long pci_cardbus_io_size;
1680extern unsigned long pci_cardbus_mem_size;
Bill Pemberton15856ad2012-11-21 15:35:00 -05001681extern u8 pci_dfl_cache_line_size;
Jesse Barnesac1aa472009-10-26 13:20:44 -07001682extern u8 pci_cache_line_size;
Atsushi Nemoto4516a612007-02-05 16:36:06 -08001683
Eric W. Biederman28760482009-09-09 14:09:24 -07001684extern unsigned long pci_hotplug_io_size;
1685extern unsigned long pci_hotplug_mem_size;
1686
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001687/* Architecture-specific versions may override these (weak) */
Adrian Bunk19792a02008-05-05 21:25:47 +03001688int pcibios_add_platform_entries(struct pci_dev *dev);
1689void pcibios_disable_device(struct pci_dev *dev);
Myron Stowecfce9fb2011-10-28 15:47:35 -06001690void pcibios_set_master(struct pci_dev *dev);
Adrian Bunk19792a02008-05-05 21:25:47 +03001691int pcibios_set_pcie_reset_state(struct pci_dev *dev,
1692 enum pcie_reset_state state);
Matthew Garretteca0d462012-12-05 14:33:27 -07001693int pcibios_add_device(struct pci_dev *dev);
Sebastian Ott6ae32c52013-06-04 19:18:14 +02001694void pcibios_release_device(struct pci_dev *dev);
Michael Ellerman575e3342007-05-08 12:03:07 +10001695
Sebastian Ott699c1982013-08-20 16:41:02 +02001696#ifdef CONFIG_HIBERNATE_CALLBACKS
1697extern struct dev_pm_ops pcibios_pm_ops;
1698#endif
1699
Robert Hancock7752d5c2008-02-15 01:27:20 -08001700#ifdef CONFIG_PCI_MMCONFIG
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001701void __init pci_mmcfg_early_init(void);
1702void __init pci_mmcfg_late_init(void);
Robert Hancock7752d5c2008-02-15 01:27:20 -08001703#else
Yinghai Lubb63b422008-02-28 23:56:50 -08001704static inline void pci_mmcfg_early_init(void) { }
Robert Hancock7752d5c2008-02-15 01:27:20 -08001705static inline void pci_mmcfg_late_init(void) { }
1706#endif
1707
Taku Izumi642c92d2012-10-30 15:26:18 +09001708int pci_ext_cfg_avail(void);
Andrew Patterson0ef5f8f2008-11-10 15:30:50 -07001709
Andrew Morton1684f5d2008-12-01 14:30:30 -08001710void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar);
Arjan van de Venaa42d7c2008-09-28 16:36:11 -07001711
Yu Zhaodd7cc442009-03-20 11:25:15 +08001712#ifdef CONFIG_PCI_IOV
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001713int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn);
1714void pci_disable_sriov(struct pci_dev *dev);
1715irqreturn_t pci_sriov_migration(struct pci_dev *dev);
1716int pci_num_vf(struct pci_dev *dev);
Alexander Duyck5a8eb242013-04-25 04:42:29 +00001717int pci_vfs_assigned(struct pci_dev *dev);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001718int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs);
1719int pci_sriov_get_totalvfs(struct pci_dev *dev);
Yu Zhaodd7cc442009-03-20 11:25:15 +08001720#else
1721static inline int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
1722{
1723 return -ENODEV;
1724}
1725static inline void pci_disable_sriov(struct pci_dev *dev)
1726{
1727}
Yu Zhao74bb1bc2009-03-20 11:25:16 +08001728static inline irqreturn_t pci_sriov_migration(struct pci_dev *dev)
1729{
1730 return IRQ_NONE;
1731}
Williams, Mitch Afb8a0d92010-02-10 01:43:04 +00001732static inline int pci_num_vf(struct pci_dev *dev)
1733{
1734 return 0;
1735}
Alexander Duyck5a8eb242013-04-25 04:42:29 +00001736static inline int pci_vfs_assigned(struct pci_dev *dev)
1737{
1738 return 0;
1739}
Donald Dutilebff73152012-11-05 15:20:37 -05001740static inline int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs)
1741{
1742 return 0;
1743}
1744static inline int pci_sriov_get_totalvfs(struct pci_dev *dev)
1745{
1746 return 0;
1747}
Yu Zhaodd7cc442009-03-20 11:25:15 +08001748#endif
1749
Kenji Kaneshigec825bc92009-06-16 11:01:25 +09001750#if defined(CONFIG_HOTPLUG_PCI) || defined(CONFIG_HOTPLUG_PCI_MODULE)
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001751void pci_hp_create_module_link(struct pci_slot *pci_slot);
1752void pci_hp_remove_module_link(struct pci_slot *pci_slot);
Kenji Kaneshigec825bc92009-06-16 11:01:25 +09001753#endif
1754
Kenji Kaneshiged7b7e602009-11-11 14:29:54 +09001755/**
1756 * pci_pcie_cap - get the saved PCIe capability offset
1757 * @dev: PCI device
1758 *
1759 * PCIe capability offset is calculated at PCI device initialization
1760 * time and saved in the data structure. This function returns saved
1761 * PCIe capability offset. Using this instead of pci_find_capability()
1762 * reduces unnecessary search in the PCI configuration space. If you
1763 * need to calculate PCIe capability offset from raw device for some
1764 * reasons, please use pci_find_capability() instead.
1765 */
1766static inline int pci_pcie_cap(struct pci_dev *dev)
1767{
1768 return dev->pcie_cap;
1769}
1770
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001771/**
1772 * pci_is_pcie - check if the PCI device is PCI Express capable
1773 * @dev: PCI device
1774 *
Joe Perchesa895c282013-09-03 13:31:05 -07001775 * Returns: true if the PCI device is PCI Express capable, false otherwise.
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001776 */
1777static inline bool pci_is_pcie(struct pci_dev *dev)
1778{
Joe Perchesa895c282013-09-03 13:31:05 -07001779 return pci_pcie_cap(dev);
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001780}
1781
Yijing Wang786e2282012-07-24 17:20:02 +08001782/**
Myron Stowe7c9c0032013-01-25 17:55:39 -07001783 * pcie_caps_reg - get the PCIe Capabilities Register
1784 * @dev: PCI device
1785 */
1786static inline u16 pcie_caps_reg(const struct pci_dev *dev)
1787{
1788 return dev->pcie_flags_reg;
1789}
1790
1791/**
Yijing Wang786e2282012-07-24 17:20:02 +08001792 * pci_pcie_type - get the PCIe device/port type
1793 * @dev: PCI device
1794 */
1795static inline int pci_pcie_type(const struct pci_dev *dev)
1796{
Myron Stowe1c531d82013-01-25 17:55:45 -07001797 return (pcie_caps_reg(dev) & PCI_EXP_FLAGS_TYPE) >> 4;
Yijing Wang786e2282012-07-24 17:20:02 +08001798}
1799
Chris Wright5d990b62009-12-04 12:15:21 -08001800void pci_request_acs(void);
Alex Williamsonad805752012-06-11 05:27:07 +00001801bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags);
1802bool pci_acs_path_enabled(struct pci_dev *start,
1803 struct pci_dev *end, u16 acs_flags);
Matt Carlsona2ce7662010-02-26 14:04:39 +00001804
Matt Carlson7ad506f2010-02-26 14:04:40 +00001805#define PCI_VPD_LRDT 0x80 /* Large Resource Data Type */
1806#define PCI_VPD_LRDT_ID(x) (x | PCI_VPD_LRDT)
1807
1808/* Large Resource Data Type Tag Item Names */
1809#define PCI_VPD_LTIN_ID_STRING 0x02 /* Identifier String */
1810#define PCI_VPD_LTIN_RO_DATA 0x10 /* Read-Only Data */
1811#define PCI_VPD_LTIN_RW_DATA 0x11 /* Read-Write Data */
1812
1813#define PCI_VPD_LRDT_ID_STRING PCI_VPD_LRDT_ID(PCI_VPD_LTIN_ID_STRING)
1814#define PCI_VPD_LRDT_RO_DATA PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RO_DATA)
1815#define PCI_VPD_LRDT_RW_DATA PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RW_DATA)
1816
1817/* Small Resource Data Type Tag Item Names */
1818#define PCI_VPD_STIN_END 0x78 /* End */
1819
1820#define PCI_VPD_SRDT_END PCI_VPD_STIN_END
1821
1822#define PCI_VPD_SRDT_TIN_MASK 0x78
1823#define PCI_VPD_SRDT_LEN_MASK 0x07
1824
1825#define PCI_VPD_LRDT_TAG_SIZE 3
1826#define PCI_VPD_SRDT_TAG_SIZE 1
Matt Carlsona2ce7662010-02-26 14:04:39 +00001827
Matt Carlsone1d5bda2010-02-26 14:04:42 +00001828#define PCI_VPD_INFO_FLD_HDR_SIZE 3
1829
Matt Carlson4067a852010-02-26 14:04:43 +00001830#define PCI_VPD_RO_KEYWORD_PARTNO "PN"
1831#define PCI_VPD_RO_KEYWORD_MFR_ID "MN"
1832#define PCI_VPD_RO_KEYWORD_VENDOR0 "V0"
Matt Carlsond4894f32011-03-09 16:58:21 +00001833#define PCI_VPD_RO_KEYWORD_CHKSUM "RV"
Matt Carlson4067a852010-02-26 14:04:43 +00001834
Matt Carlsona2ce7662010-02-26 14:04:39 +00001835/**
1836 * pci_vpd_lrdt_size - Extracts the Large Resource Data Type length
1837 * @lrdt: Pointer to the beginning of the Large Resource Data Type tag
1838 *
1839 * Returns the extracted Large Resource Data Type length.
1840 */
1841static inline u16 pci_vpd_lrdt_size(const u8 *lrdt)
1842{
1843 return (u16)lrdt[1] + ((u16)lrdt[2] << 8);
1844}
1845
Matt Carlson7ad506f2010-02-26 14:04:40 +00001846/**
1847 * pci_vpd_srdt_size - Extracts the Small Resource Data Type length
1848 * @lrdt: Pointer to the beginning of the Small Resource Data Type tag
1849 *
1850 * Returns the extracted Small Resource Data Type length.
1851 */
1852static inline u8 pci_vpd_srdt_size(const u8 *srdt)
1853{
1854 return (*srdt) & PCI_VPD_SRDT_LEN_MASK;
1855}
1856
Matt Carlsonb55ac1b2010-02-26 14:04:41 +00001857/**
Matt Carlsone1d5bda2010-02-26 14:04:42 +00001858 * pci_vpd_info_field_size - Extracts the information field length
1859 * @lrdt: Pointer to the beginning of an information field header
1860 *
1861 * Returns the extracted information field length.
1862 */
1863static inline u8 pci_vpd_info_field_size(const u8 *info_field)
1864{
1865 return info_field[2];
1866}
1867
1868/**
Matt Carlsonb55ac1b2010-02-26 14:04:41 +00001869 * pci_vpd_find_tag - Locates the Resource Data Type tag provided
1870 * @buf: Pointer to buffered vpd data
1871 * @off: The offset into the buffer at which to begin the search
1872 * @len: The length of the vpd buffer
1873 * @rdt: The Resource Data Type to search for
1874 *
1875 * Returns the index where the Resource Data Type was found or
1876 * -ENOENT otherwise.
1877 */
1878int pci_vpd_find_tag(const u8 *buf, unsigned int off, unsigned int len, u8 rdt);
1879
Matt Carlson4067a852010-02-26 14:04:43 +00001880/**
1881 * pci_vpd_find_info_keyword - Locates an information field keyword in the VPD
1882 * @buf: Pointer to buffered vpd data
1883 * @off: The offset into the buffer at which to begin the search
1884 * @len: The length of the buffer area, relative to off, in which to search
1885 * @kw: The keyword to search for
1886 *
1887 * Returns the index where the information field keyword was found or
1888 * -ENOENT otherwise.
1889 */
1890int pci_vpd_find_info_keyword(const u8 *buf, unsigned int off,
1891 unsigned int len, const char *kw);
1892
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10001893/* PCI <-> OF binding helpers */
1894#ifdef CONFIG_OF
1895struct device_node;
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001896void pci_set_of_node(struct pci_dev *dev);
1897void pci_release_of_node(struct pci_dev *dev);
1898void pci_set_bus_of_node(struct pci_bus *bus);
1899void pci_release_bus_of_node(struct pci_bus *bus);
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10001900
1901/* Arch may override this (weak) */
Bjorn Helgaas723ec4d2013-04-17 10:31:34 -06001902struct device_node *pcibios_get_phb_of_node(struct pci_bus *bus);
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10001903
John Crispin3df425f2012-04-12 17:33:07 +02001904static inline struct device_node *
1905pci_device_to_OF_node(const struct pci_dev *pdev)
Benjamin Herrenschmidt64099d92011-04-07 13:09:47 +10001906{
1907 return pdev ? pdev->dev.of_node : NULL;
1908}
1909
Benjamin Herrenschmidtef3b4f82011-04-11 11:34:33 +10001910static inline struct device_node *pci_bus_to_OF_node(struct pci_bus *bus)
1911{
1912 return bus ? bus->dev.of_node : NULL;
1913}
1914
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10001915#else /* CONFIG_OF */
1916static inline void pci_set_of_node(struct pci_dev *dev) { }
1917static inline void pci_release_of_node(struct pci_dev *dev) { }
1918static inline void pci_set_bus_of_node(struct pci_bus *bus) { }
1919static inline void pci_release_bus_of_node(struct pci_bus *bus) { }
1920#endif /* CONFIG_OF */
1921
Gavin Shaneb740b52012-02-27 20:04:04 +00001922#ifdef CONFIG_EEH
1923static inline struct eeh_dev *pci_dev_to_eeh_dev(struct pci_dev *pdev)
1924{
1925 return pdev->dev.archdata.edev;
1926}
1927#endif
1928
Ohad Ben-Cohen166e9272011-06-10 21:42:27 +03001929/**
1930 * pci_find_upstream_pcie_bridge - find upstream PCIe-to-PCI bridge of a device
1931 * @pdev: the PCI device
1932 *
1933 * if the device is PCIE, return NULL
1934 * if the device isn't connected to a PCIe bridge (that is its parent is a
1935 * legacy PCI bridge and the bridge is directly connected to bus 0), return its
1936 * parent
1937 */
1938struct pci_dev *pci_find_upstream_pcie_bridge(struct pci_dev *pdev);
1939
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940#endif /* LINUX_PCI_H */