blob: a13d6825e586972835ba2b3d53ac4ab504ba5369 [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 {
227 char cap_nr;
228 unsigned int size;
229 u32 data[0];
230};
231
Shaohua Li41017f02006-02-08 17:11:38 +0800232struct pci_cap_saved_state {
233 struct hlist_node next;
Alex Williamson24a4742f2011-05-10 10:02:11 -0600234 struct pci_cap_saved_data cap;
Shaohua Li41017f02006-02-08 17:11:38 +0800235};
236
Shaohua Li7d715a62008-02-25 09:46:41 +0800237struct pcie_link_state;
Jesse Barnesee69439c2008-04-28 12:30:35 -0700238struct pci_vpd;
Yu Zhaod1b054d2009-03-20 11:25:11 +0800239struct pci_sriov;
Yu Zhao302b4212009-05-18 13:51:32 +0800240struct pci_ats;
Jesse Barnesee69439c2008-04-28 12:30:35 -0700241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242/*
243 * The pci_dev structure is used to describe PCI devices.
244 */
245struct pci_dev {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 struct list_head bus_list; /* node in per-bus list */
247 struct pci_bus *bus; /* bus this device is on */
248 struct pci_bus *subordinate; /* bus this device bridges to */
249
250 void *sysdata; /* hook for sys-specific extension */
251 struct proc_dir_entry *procent; /* device entry in /proc/bus/pci */
Alex Chiangf46753c2008-06-10 15:28:50 -0600252 struct pci_slot *slot; /* Physical slot this device is in */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254 unsigned int devfn; /* encoded device & function index */
255 unsigned short vendor;
256 unsigned short device;
257 unsigned short subsystem_vendor;
258 unsigned short subsystem_device;
259 unsigned int class; /* 3 bytes: (base,sub,prog-if) */
Auke Kokb8a3a522007-06-08 15:46:30 -0700260 u8 revision; /* PCI revision, low byte of class word */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 u8 hdr_type; /* PCI header type (`multi' flag masked out) */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700262 u8 pcie_cap; /* PCIe capability offset */
Gavin Shane375b562013-04-04 16:54:30 +0000263 u8 msi_cap; /* MSI capability offset */
264 u8 msix_cap; /* MSI-X capability offset */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700265 u8 pcie_mpss:3; /* PCIe Max Payload Size Supported */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 u8 rom_base_reg; /* which config register controls the ROM */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700267 u8 pin; /* which interrupt pin this device uses */
268 u16 pcie_flags_reg; /* cached PCIe Capabilities Register */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 struct pci_driver *driver; /* which driver has allocated this device */
271 u64 dma_mask; /* Mask of the bits of bus address this
272 device implements. Normally this is
273 0xffffffff. You only need to change
274 this if your device has broken DMA
275 or supports 64-bit transfers. */
276
FUJITA Tomonori4d57cdf2008-02-04 22:27:55 -0800277 struct device_dma_parameters dma_parms;
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 pci_power_t current_state; /* Current operating state. In ACPI-speak,
280 this is D0-D3, D0 being fully functional,
281 and D3 being off. */
Bjorn Helgaas703860e2013-04-17 16:57:56 -0600282 u8 pm_cap; /* PM capability offset */
Rafael J. Wysocki337001b2008-07-07 03:36:24 +0200283 unsigned int pme_support:5; /* Bitmask of states from which PME#
284 can be generated */
Rafael J. Wysockic7f48652010-02-17 23:39:08 +0100285 unsigned int pme_interrupt:1;
Rafael J. Wysocki379021d2011-10-03 23:16:33 +0200286 unsigned int pme_poll:1; /* Poll device's PME status bit */
Rafael J. Wysocki337001b2008-07-07 03:36:24 +0200287 unsigned int d1_support:1; /* Low power state D1 is supported */
288 unsigned int d2_support:1; /* Low power state D2 is supported */
Huang Ying448bd852012-06-23 10:23:51 +0800289 unsigned int no_d1d2:1; /* D1 and D2 are forbidden */
290 unsigned int no_d3cold:1; /* D3cold is forbidden */
291 unsigned int d3cold_allowed:1; /* D3cold is allowed by user */
Jacob Pan253d2e52010-07-16 10:19:22 -0700292 unsigned int mmio_always_on:1; /* disallow turning off io/mem
293 decoding during bar sizing */
Rafael J. Wysockie80bb092009-09-08 23:14:49 +0200294 unsigned int wakeup_prepared:1;
Huang Ying448bd852012-06-23 10:23:51 +0800295 unsigned int runtime_d3cold:1; /* whether go through runtime
296 D3cold, not set for devices
297 powered on/off by the
298 corresponding bridge */
Rafael J. Wysocki1ae861e2009-12-31 12:15:54 +0100299 unsigned int d3_delay; /* D3->D0 transition time in ms */
Huang Ying448bd852012-06-23 10:23:51 +0800300 unsigned int d3cold_delay; /* D3cold->D0 transition time in ms */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Shaohua Li7d715a62008-02-25 09:46:41 +0800302#ifdef CONFIG_PCIEASPM
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700303 struct pcie_link_state *link_state; /* ASPM link state */
Shaohua Li7d715a62008-02-25 09:46:41 +0800304#endif
305
linas392a1ce2005-11-16 17:10:41 -0600306 pci_channel_state_t error_state; /* current connectivity state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 struct device dev; /* Generic device interface */
308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 int cfg_size; /* Size of configuration space */
310
311 /*
312 * Instead of touching interrupt line and base address registers
313 * directly, use the values stored here. They might be different!
314 */
315 unsigned int irq;
316 struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
317
Yinghai Lu58d9a382013-01-21 13:20:51 -0800318 bool match_driver; /* Skip attaching driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 /* These fields are used by common fixups */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700320 unsigned int transparent:1; /* Subtractive decode PCI bridge */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 unsigned int multifunction:1;/* Part of multi-function device */
322 /* keep track of device state */
Greg Kroah-Hartman8a1bc902008-02-14 14:56:56 -0800323 unsigned int is_added:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 unsigned int is_busmaster:1; /* device is busmaster */
Kristen Accardi4602b882005-08-16 15:15:58 -0700325 unsigned int no_msi:1; /* device may not use msi */
Jan Kiszkafb51ccb2011-11-04 09:45:59 +0100326 unsigned int block_cfg_access:1; /* config space access is blocked */
Doug Thompsonbd8481e2006-05-08 17:06:09 -0700327 unsigned int broken_parity_status:1; /* Device generates false positive parity */
Stefan Assmanne1d3a902008-06-11 16:35:17 +0200328 unsigned int irq_reroute_variant:2; /* device needs IRQ rerouting variant */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700329 unsigned int msi_enabled:1;
Shaohua Li99dc8042006-05-26 10:58:27 +0800330 unsigned int msix_enabled:1;
Yu Zhao58c3a722008-10-14 14:02:53 +0800331 unsigned int ari_enabled:1; /* ARI forwarding */
Tejun Heo9ac78492007-01-20 16:00:26 +0900332 unsigned int is_managed:1;
Mike Mason260d7032009-07-30 15:33:21 -0700333 unsigned int needs_freset:1; /* Dev requires fundamental reset */
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100334 unsigned int state_saved:1;
Yu Zhaod1b054d2009-03-20 11:25:11 +0800335 unsigned int is_physfn:1;
Yu Zhaodd7cc442009-03-20 11:25:15 +0800336 unsigned int is_virtfn:1;
Michael S. Tsirkin711d5772009-07-27 23:37:48 +0300337 unsigned int reset_fn:1;
Eric W. Biederman28760482009-09-09 14:09:24 -0700338 unsigned int is_hotplug_bridge:1;
Huang Yingaffb72c2010-05-18 14:35:16 +0800339 unsigned int __aer_firmware_first_valid:1;
340 unsigned int __aer_firmware_first:1;
Bjorn Helgaasfbebb9f2012-06-16 14:40:22 -0600341 unsigned int broken_intx_masking:1;
Bjorn Helgaas2b28ae12012-07-09 13:38:57 -0600342 unsigned int io_window_1k:1; /* Intel P2P bridge 1K I/O windows */
David Millerba698ad2007-10-25 01:16:30 -0700343 pci_dev_flags_t dev_flags;
Inaky Perez-Gonzalezbae94d02006-11-22 12:40:31 -0800344 atomic_t enable_cnt; /* pci_enable_device has been called */
Kristen Accardi4602b882005-08-16 15:15:58 -0700345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 u32 saved_config_space[16]; /* config space saved at suspend time */
Shaohua Li41017f02006-02-08 17:11:38 +0800347 struct hlist_head saved_cap_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */
349 int rom_attr_enabled; /* has display of the rom attribute been enabled? */
350 struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700351 struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE]; /* sysfs file for WC mapping of resources */
Eric W. Biedermanded86d82007-01-28 12:42:52 -0700352#ifdef CONFIG_PCI_MSI
Michael Ellerman4aa9bc92007-04-05 17:19:10 +1000353 struct list_head msi_list;
Neil Hormanda8d1c82011-10-06 14:08:18 -0400354 struct kset *msi_kset;
Eric W. Biedermanded86d82007-01-28 12:42:52 -0700355#endif
Ben Hutchings94e61082008-03-05 16:52:39 +0000356 struct pci_vpd *vpd;
Joerg Roedel466b3dd2011-10-30 16:35:08 +0100357#ifdef CONFIG_PCI_ATS
Yu Zhaodd7cc442009-03-20 11:25:15 +0800358 union {
359 struct pci_sriov *sriov; /* SR-IOV capability related */
360 struct pci_dev *physfn; /* the PF this VF is associated with */
361 };
Yu Zhao302b4212009-05-18 13:51:32 +0800362 struct pci_ats *ats; /* Address Translation Service */
Yu Zhaod1b054d2009-03-20 11:25:11 +0800363#endif
Bjorn Helgaasdbd3fc32012-12-10 11:24:42 -0700364 phys_addr_t rom; /* Physical address of ROM if it's not from the BAR */
Matthew Garrett84c1b802012-12-05 14:33:27 -0700365 size_t romlen; /* Length of ROM if it's not from the BAR */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366};
367
Yinghaidda56542010-04-09 01:07:55 +0100368static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
369{
370#ifdef CONFIG_PCI_IOV
371 if (dev->is_virtfn)
372 dev = dev->physfn;
373#endif
Yinghaidda56542010-04-09 01:07:55 +0100374 return dev;
375}
376
Gu Zheng3c6e6ae2013-05-25 21:48:30 +0800377struct pci_dev *pci_alloc_dev(struct pci_bus *bus);
378struct pci_dev * __deprecated alloc_pci_dev(void);
Michael Ellerman65891212007-04-05 17:19:08 +1000379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380#define to_pci_dev(n) container_of(n, struct pci_dev, dev)
381#define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
382
Linas Vepstasa7369f12006-12-12 16:55:59 -0600383static inline int pci_channel_offline(struct pci_dev *pdev)
384{
385 return (pdev->error_state != pci_channel_io_normal);
386}
387
Yinghai Lu67cdc822012-05-17 18:51:12 -0700388extern struct resource busn_resource;
389
Bjorn Helgaas0efd5aa2012-02-23 20:19:00 -0700390struct pci_host_bridge_window {
391 struct list_head list;
392 struct resource *res; /* host bridge aperture (CPU address) */
393 resource_size_t offset; /* bus address + offset = CPU address */
394};
Shaohua Li41017f02006-02-08 17:11:38 +0800395
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700396struct pci_host_bridge {
Yinghai Lu7b543662012-04-02 18:31:53 -0700397 struct device dev;
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700398 struct pci_bus *bus; /* root bus */
Bjorn Helgaas0efd5aa2012-02-23 20:19:00 -0700399 struct list_head windows; /* pci_host_bridge_windows */
Yinghai Lu4fa26492012-04-02 18:31:53 -0700400 void (*release_fn)(struct pci_host_bridge *);
401 void *release_data;
Bjorn Helgaas5a21d702012-02-23 20:18:59 -0700402};
Shaohua Li41017f02006-02-08 17:11:38 +0800403
Yinghai Lu7b543662012-04-02 18:31:53 -0700404#define to_pci_host_bridge(n) container_of(n, struct pci_host_bridge, dev)
Yinghai Lu4fa26492012-04-02 18:31:53 -0700405void pci_set_host_bridge_release(struct pci_host_bridge *bridge,
406 void (*release_fn)(struct pci_host_bridge *),
407 void *release_data);
Yinghai Lu7b543662012-04-02 18:31:53 -0700408
Rafael J. Wysocki6c0cc952013-01-09 22:33:37 +0100409int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge);
410
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -0700411/*
412 * The first PCI_BRIDGE_RESOURCE_NUM PCI bus resources (those that correspond
413 * to P2P or CardBus bridge windows) go in a table. Additional ones (for
414 * buses below host bridges or subtractive decode bridges) go in the list.
415 * Use pci_bus_for_each_resource() to iterate through all the resources.
416 */
417
418/*
419 * PCI_SUBTRACTIVE_DECODE means the bridge forwards the window implicitly
420 * and there's no way to program the bridge with the details of the window.
421 * This does not apply to ACPI _CRS windows, even with the _DEC subtractive-
422 * decode bit set, because they are explicit and can be programmed with _SRS.
423 */
424#define PCI_SUBTRACTIVE_DECODE 0x1
425
426struct pci_bus_resource {
427 struct list_head list;
428 struct resource *res;
429 unsigned int flags;
430};
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -0700431
432#define PCI_REGION_FLAG_MASK 0x0fU /* These bits of resource flags tell us the PCI region flags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434struct pci_bus {
435 struct list_head node; /* node in list of buses */
436 struct pci_bus *parent; /* parent bus this bridge is on */
437 struct list_head children; /* list of child buses */
438 struct list_head devices; /* list of devices on this bus */
439 struct pci_dev *self; /* bridge device as seen by parent */
Alex Chiangf46753c2008-06-10 15:28:50 -0600440 struct list_head slots; /* list of slots on this bus */
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -0700441 struct resource *resource[PCI_BRIDGE_RESOURCE_NUM];
442 struct list_head resources; /* address space routed to this bus */
Yinghai Lu92f02432012-05-17 18:51:11 -0700443 struct resource busn_res; /* bus numbers routed to this bus */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
445 struct pci_ops *ops; /* configuration access functions */
Thierry Reding0cbdcfc2013-08-09 22:27:08 +0200446 struct msi_chip *msi; /* MSI controller */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 void *sysdata; /* hook for sys-specific extension */
448 struct proc_dir_entry *procdir; /* directory entry in /proc/bus/pci */
449
450 unsigned char number; /* bus number */
451 unsigned char primary; /* number of primary bridge */
Matthew Wilcox3749c512009-12-13 08:11:32 -0500452 unsigned char max_bus_speed; /* enum pci_bus_speed */
453 unsigned char cur_bus_speed; /* enum pci_bus_speed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455 char name[48];
456
457 unsigned short bridge_ctl; /* manage NO_ISA/FBB/et al behaviors */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700458 pci_bus_flags_t bus_flags; /* inherited by child buses */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 struct device *bridge;
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400460 struct device dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 struct bin_attribute *legacy_io; /* legacy I/O for this bus */
462 struct bin_attribute *legacy_mem; /* legacy mem */
Greg Kroah-Hartmancc74d962008-03-12 21:48:03 -0700463 unsigned int is_added:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464};
465
466#define pci_bus_b(n) list_entry(n, struct pci_bus, node)
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400467#define to_pci_bus(n) container_of(n, struct pci_bus, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600469/*
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700470 * Returns true if the PCI bus is root (behind host-PCI bridge),
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600471 * false otherwise
Bjorn Helgaas77a0dfc2013-09-24 15:14:57 -0600472 *
473 * Some code assumes that "bus->self == NULL" means that bus is a root bus.
474 * This is incorrect because "virtual" buses added for SR-IOV (via
475 * virtfn_add_bus()) have "bus->self == NULL" but are not root buses.
Kenji Kaneshige79af72d2009-03-20 14:55:55 -0600476 */
477static inline bool pci_is_root_bus(struct pci_bus *pbus)
478{
479 return !(pbus->parent);
480}
481
Bjorn Helgaasc6bde212013-11-06 10:11:48 -0700482static inline struct pci_dev *pci_upstream_bridge(struct pci_dev *dev)
483{
484 dev = pci_physfn(dev);
485 if (pci_is_root_bus(dev->bus))
486 return NULL;
487
488 return dev->bus->self;
489}
490
Rafael J. Wysocki16cf0eb2009-01-05 14:50:27 +0100491#ifdef CONFIG_PCI_MSI
492static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev)
493{
494 return pci_dev->msi_enabled || pci_dev->msix_enabled;
495}
496#else
497static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev) { return false; }
498#endif
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500/*
501 * Error values that may be returned by PCI functions.
502 */
503#define PCIBIOS_SUCCESSFUL 0x00
504#define PCIBIOS_FUNC_NOT_SUPPORTED 0x81
505#define PCIBIOS_BAD_VENDOR_ID 0x83
506#define PCIBIOS_DEVICE_NOT_FOUND 0x86
507#define PCIBIOS_BAD_REGISTER_NUMBER 0x87
508#define PCIBIOS_SET_FAILED 0x88
509#define PCIBIOS_BUFFER_TOO_SMALL 0x89
510
Alex Williamsona6961652012-06-11 05:27:33 +0000511/*
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700512 * Translate above to generic errno for passing back through non-PCI code.
Alex Williamsona6961652012-06-11 05:27:33 +0000513 */
514static inline int pcibios_err_to_errno(int err)
515{
516 if (err <= PCIBIOS_SUCCESSFUL)
517 return err; /* Assume already errno */
518
519 switch (err) {
520 case PCIBIOS_FUNC_NOT_SUPPORTED:
521 return -ENOENT;
522 case PCIBIOS_BAD_VENDOR_ID:
523 return -EINVAL;
524 case PCIBIOS_DEVICE_NOT_FOUND:
525 return -ENODEV;
526 case PCIBIOS_BAD_REGISTER_NUMBER:
527 return -EFAULT;
528 case PCIBIOS_SET_FAILED:
529 return -EIO;
530 case PCIBIOS_BUFFER_TOO_SMALL:
531 return -ENOSPC;
532 }
533
534 return -ENOTTY;
535}
536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537/* Low-level architecture-dependent routines */
538
539struct pci_ops {
540 int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
541 int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
542};
543
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500544/*
545 * ACPI needs to be able to access PCI config space before we've done a
546 * PCI bus scan and created pci_bus structures.
547 */
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600548int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
549 int reg, int len, u32 *val);
550int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
551 int reg, int len, u32 val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
553struct pci_bus_region {
Benjamin Herrenschmidtc40a22e2007-12-10 17:32:15 +1100554 resource_size_t start;
555 resource_size_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556};
557
558struct pci_dynids {
559 spinlock_t lock; /* protects list, index */
560 struct list_head list; /* for IDs added at runtime */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561};
562
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700563
564/*
565 * PCI Error Recovery System (PCI-ERS). If a PCI device driver provides
566 * a set of callbacks in struct pci_error_handlers, that device driver
567 * will be notified of PCI bus errors, and will be driven to recovery
568 * when an error occurs.
linas392a1ce2005-11-16 17:10:41 -0600569 */
570
571typedef unsigned int __bitwise pci_ers_result_t;
572
573enum pci_ers_result {
574 /* no result/none/not supported in device driver */
575 PCI_ERS_RESULT_NONE = (__force pci_ers_result_t) 1,
576
577 /* Device driver can recover without slot reset */
578 PCI_ERS_RESULT_CAN_RECOVER = (__force pci_ers_result_t) 2,
579
580 /* Device driver wants slot to be reset. */
581 PCI_ERS_RESULT_NEED_RESET = (__force pci_ers_result_t) 3,
582
583 /* Device has completely failed, is unrecoverable */
584 PCI_ERS_RESULT_DISCONNECT = (__force pci_ers_result_t) 4,
585
586 /* Device driver is fully recovered and operational */
587 PCI_ERS_RESULT_RECOVERED = (__force pci_ers_result_t) 5,
Vijay Mohan Pandarathil918b40532012-11-17 11:47:18 +0000588
589 /* No AER capabilities registered for the driver */
590 PCI_ERS_RESULT_NO_AER_DRIVER = (__force pci_ers_result_t) 6,
linas392a1ce2005-11-16 17:10:41 -0600591};
592
593/* PCI bus error event callbacks */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800594struct pci_error_handlers {
linas392a1ce2005-11-16 17:10:41 -0600595 /* PCI bus error detected on this device */
596 pci_ers_result_t (*error_detected)(struct pci_dev *dev,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800597 enum pci_channel_state error);
linas392a1ce2005-11-16 17:10:41 -0600598
599 /* MMIO has been re-enabled, but not DMA */
600 pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);
601
602 /* PCI Express link has been reset */
603 pci_ers_result_t (*link_reset)(struct pci_dev *dev);
604
605 /* PCI slot has been reset */
606 pci_ers_result_t (*slot_reset)(struct pci_dev *dev);
607
608 /* Device driver may resume normal operations */
609 void (*resume)(struct pci_dev *dev);
610};
611
linas392a1ce2005-11-16 17:10:41 -0600612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613struct module;
614struct pci_driver {
615 struct list_head node;
Stephen Hemminger42b21932010-09-02 14:28:51 -0700616 const char *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 const struct pci_device_id *id_table; /* must be non-NULL for probe to be called */
618 int (*probe) (struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */
619 void (*remove) (struct pci_dev *dev); /* Device removed (NULL if not a hot-plug capable driver) */
620 int (*suspend) (struct pci_dev *dev, pm_message_t state); /* Device suspended */
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700621 int (*suspend_late) (struct pci_dev *dev, pm_message_t state);
622 int (*resume_early) (struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 int (*resume) (struct pci_dev *dev); /* Device woken up */
Greg KHc8958172005-04-08 14:53:31 +0900624 void (*shutdown) (struct pci_dev *dev);
Donald Dutile17893822012-11-05 15:20:36 -0500625 int (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* PF pdev */
Stephen Hemminger49453022012-09-07 09:33:14 -0700626 const struct pci_error_handlers *err_handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 struct device_driver driver;
628 struct pci_dynids dynids;
629};
630
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800631#define to_pci_driver(drv) container_of(drv, struct pci_driver, driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
633/**
Andrew Morton9f9351b2008-03-10 11:43:34 -0700634 * DEFINE_PCI_DEVICE_TABLE - macro used to describe a pci device table
Jonas Bonn90a1ba02008-02-22 11:02:21 +0100635 * @_table: device table name
636 *
637 * This macro is used to create a struct pci_device_id array (a device table)
638 * in a generic manner.
639 */
Andrew Morton9f9351b2008-03-10 11:43:34 -0700640#define DEFINE_PCI_DEVICE_TABLE(_table) \
Bill Pemberton15856ad2012-11-21 15:35:00 -0500641 const struct pci_device_id _table[]
Jonas Bonn90a1ba02008-02-22 11:02:21 +0100642
643/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 * PCI_DEVICE - macro used to describe a specific pci device
645 * @vend: the 16 bit PCI Vendor ID
646 * @dev: the 16 bit PCI Device ID
647 *
648 * This macro is used to create a struct pci_device_id that matches a
649 * specific device. The subvendor and subdevice fields will be set to
650 * PCI_ANY_ID.
651 */
652#define PCI_DEVICE(vend,dev) \
653 .vendor = (vend), .device = (dev), \
654 .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
655
656/**
Nithin Nayak Sujir3d567e02012-11-14 14:44:26 +0000657 * PCI_DEVICE_SUB - macro used to describe a specific pci device with subsystem
658 * @vend: the 16 bit PCI Vendor ID
659 * @dev: the 16 bit PCI Device ID
660 * @subvend: the 16 bit PCI Subvendor ID
661 * @subdev: the 16 bit PCI Subdevice ID
662 *
663 * This macro is used to create a struct pci_device_id that matches a
664 * specific device with subsystem information.
665 */
666#define PCI_DEVICE_SUB(vend, dev, subvend, subdev) \
667 .vendor = (vend), .device = (dev), \
668 .subvendor = (subvend), .subdevice = (subdev)
669
670/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
672 * @dev_class: the class, subclass, prog-if triple for this device
673 * @dev_class_mask: the class mask for this device
674 *
675 * This macro is used to create a struct pci_device_id that matches a
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -0700676 * specific PCI class. The vendor, device, subvendor, and subdevice
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 * fields will be set to PCI_ANY_ID.
678 */
679#define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
680 .class = (dev_class), .class_mask = (dev_class_mask), \
681 .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
682 .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
683
Alan Cox1597cac2006-12-04 15:14:45 -0800684/**
685 * PCI_VDEVICE - macro used to describe a specific pci device in short form
Zhao, Yuc322b282008-10-13 19:36:05 +0800686 * @vendor: the vendor name
687 * @device: the 16 bit PCI Device ID
Alan Cox1597cac2006-12-04 15:14:45 -0800688 *
689 * This macro is used to create a struct pci_device_id that matches a
690 * specific PCI device. The subvendor, and subdevice fields will be set
691 * to PCI_ANY_ID. The macro allows the next field to follow as the device
692 * private data.
693 */
694
695#define PCI_VDEVICE(vendor, device) \
696 PCI_VENDOR_ID_##vendor, (device), \
697 PCI_ANY_ID, PCI_ANY_ID, 0, 0
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699/* these external functions are only available when PCI support is enabled */
700#ifdef CONFIG_PCI
701
Bjorn Helgaasa58674f2013-08-22 11:24:44 +0800702void pcie_bus_configure_settings(struct pci_bus *bus);
Jon Masonb03e7492011-07-20 15:20:54 -0500703
704enum pcie_bus_config_types {
Jon Mason5f39e672011-10-03 09:50:20 -0500705 PCIE_BUS_TUNE_OFF,
Jon Masonb03e7492011-07-20 15:20:54 -0500706 PCIE_BUS_SAFE,
Jon Mason5f39e672011-10-03 09:50:20 -0500707 PCIE_BUS_PERFORMANCE,
Jon Masonb03e7492011-07-20 15:20:54 -0500708 PCIE_BUS_PEER2PEER,
709};
710
711extern enum pcie_bus_config_types pcie_bus_config;
712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713extern struct bus_type pci_bus_type;
714
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700715/* Do NOT directly access these two variables, unless you are arch-specific PCI
716 * code, or PCI core code. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717extern struct list_head pci_root_buses; /* list of all known PCI buses */
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700718/* Some device drivers need know if PCI is initiated */
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600719int no_pci_devices(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
Yinghai Lu3c449ed2012-11-03 21:39:31 -0700721void pcibios_resource_survey_bus(struct pci_bus *bus);
Jiang Liu10a95742013-04-12 05:44:20 +0000722void pcibios_add_bus(struct pci_bus *bus);
723void pcibios_remove_bus(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724void pcibios_fixup_bus(struct pci_bus *);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700725int __must_check pcibios_enable_device(struct pci_dev *, int mask);
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700726/* Architecture-specific versions may override this (weak) */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800727char *pcibios_setup(char *str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729/* Used only when drivers/pci/setup.c is used */
Dominik Brodowski3b7a17f2010-01-01 17:40:50 +0100730resource_size_t pcibios_align_resource(void *, const struct resource *,
Dominik Brodowskib26b2d42010-01-01 17:40:49 +0100731 resource_size_t,
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700732 resource_size_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733void pcibios_update_irq(struct pci_dev *, int irq);
734
Benjamin Herrenschmidt2d1c8612009-12-09 17:52:13 +1100735/* Weak but can be overriden by arch */
736void pci_fixup_cardbus(struct pci_bus *);
737
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738/* Generic PCI functions used internally */
739
Bjorn Helgaas36a66cd2012-02-23 20:19:00 -0700740void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
741 struct resource *res);
742void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
743 struct pci_bus_region *region);
Mauro Carvalho Chehabd1fd4fb2009-07-10 18:39:53 -0300744void pcibios_scan_specific_bus(int busn);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600745struct pci_bus *pci_find_bus(int domain, int busnr);
akpm@linux-foundation.orgc48f1672009-02-03 15:45:26 -0800746void pci_bus_add_devices(const struct pci_bus *bus);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800747struct pci_bus *pci_scan_bus_parented(struct device *parent, int bus,
748 struct pci_ops *ops, void *sysdata);
Bjorn Helgaasde4b2f72011-10-28 16:25:55 -0600749struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata);
Bjorn Helgaas166c6372011-10-28 16:25:45 -0600750struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
751 struct pci_ops *ops, void *sysdata,
752 struct list_head *resources);
Yinghai Lu98a35832012-05-18 11:35:50 -0600753int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int busmax);
754int pci_bus_update_busn_res_end(struct pci_bus *b, int busmax);
755void pci_bus_release_busn_res(struct pci_bus *b);
Bill Pemberton15856ad2012-11-21 15:35:00 -0500756struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
Bjorn Helgaasa2ebb822011-10-28 16:25:50 -0600757 struct pci_ops *ops, void *sysdata,
758 struct list_head *resources);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800759struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
760 int busnr);
Matthew Wilcox3749c512009-12-13 08:11:32 -0500761void pcie_update_link_speed(struct pci_bus *bus, u16 link_status);
Alex Chiangf46753c2008-06-10 15:28:50 -0600762struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
Alex Chiang828f3762008-10-20 17:40:52 -0600763 const char *name,
764 struct hotplug_slot *hotplug);
Alex Chiangf46753c2008-06-10 15:28:50 -0600765void pci_destroy_slot(struct pci_slot *slot);
Alex Chiangd25b7c82008-10-20 17:40:47 -0600766void pci_renumber_slot(struct pci_slot *slot, int slot_nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767int pci_scan_slot(struct pci_bus *bus, int devfn);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800768struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn);
Paul Mackerrascdb9b9f2005-09-06 09:31:03 +1000769void pci_device_add(struct pci_dev *dev, struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770unsigned int pci_scan_child_bus(struct pci_bus *bus);
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700771int __must_check pci_bus_add_device(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772void pci_read_bridge_bases(struct pci_bus *child);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800773struct resource *pci_find_parent_resource(const struct pci_dev *dev,
774 struct resource *res);
John Crispin3df425f2012-04-12 17:33:07 +0200775u8 pci_swizzle_interrupt_pin(const struct pci_dev *dev, u8 pin);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776int pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge);
Bjorn Helgaas68feac82008-12-16 21:36:55 -0700777u8 pci_common_swizzle(struct pci_dev *dev, u8 *pinp);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600778struct pci_dev *pci_dev_get(struct pci_dev *dev);
779void pci_dev_put(struct pci_dev *dev);
780void pci_remove_bus(struct pci_bus *b);
781void pci_stop_and_remove_bus_device(struct pci_dev *dev);
Yinghai Lucdfcc572012-10-30 14:31:38 -0600782void pci_stop_root_bus(struct pci_bus *bus);
783void pci_remove_root_bus(struct pci_bus *bus);
Dominik Brodowskib3743fa2005-09-09 13:03:23 -0700784void pci_setup_cardbus(struct pci_bus *bus);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -0600785void pci_sort_breadthfirst(void);
Williams, Mitch Afb8a0d92010-02-10 01:43:04 +0000786#define dev_is_pci(d) ((d)->bus == &pci_bus_type)
787#define dev_is_pf(d) ((dev_is_pci(d) ? to_pci_dev(d)->is_physfn : false))
788#define dev_num_vf(d) ((dev_is_pci(d) ? pci_num_vf(to_pci_dev(d)) : 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790/* Generic PCI functions exported to card drivers */
791
James Bottomley388c8c12008-08-03 13:02:12 -0500792enum pci_lost_interrupt_reason {
793 PCI_LOST_IRQ_NO_INFORMATION = 0,
794 PCI_LOST_IRQ_DISABLE_MSI,
795 PCI_LOST_IRQ_DISABLE_MSIX,
796 PCI_LOST_IRQ_DISABLE_ACPI,
797};
798enum pci_lost_interrupt_reason pci_lost_interrupt(struct pci_dev *dev);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800799int pci_find_capability(struct pci_dev *dev, int cap);
800int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap);
801int pci_find_ext_capability(struct pci_dev *dev, int cap);
Bjorn Helgaas44a9a362012-07-13 14:24:59 -0600802int pci_find_next_ext_capability(struct pci_dev *dev, int pos, int cap);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800803int pci_find_ht_capability(struct pci_dev *dev, int ht_cap);
804int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap);
Alan Cox29f3eb62006-10-16 16:20:21 -0700805struct pci_bus *pci_find_next_bus(const struct pci_bus *from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
Andrew Mortond42552c2006-10-21 10:24:12 -0700807struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device,
808 struct pci_dev *from);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800809struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 unsigned int ss_vendor, unsigned int ss_device,
Greg KHb08508c2008-08-26 08:20:34 -0700811 struct pci_dev *from);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800812struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);
Andrew Patterson3c299dc2009-10-12 13:14:00 -0600813struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
814 unsigned int devfn);
815static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
816 unsigned int devfn)
817{
818 return pci_get_domain_bus_and_slot(0, bus, devfn);
819}
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800820struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821int pci_dev_present(const struct pci_device_id *ids);
822
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800823int pci_bus_read_config_byte(struct pci_bus *bus, unsigned int devfn,
824 int where, u8 *val);
825int pci_bus_read_config_word(struct pci_bus *bus, unsigned int devfn,
826 int where, u16 *val);
827int pci_bus_read_config_dword(struct pci_bus *bus, unsigned int devfn,
828 int where, u32 *val);
829int pci_bus_write_config_byte(struct pci_bus *bus, unsigned int devfn,
830 int where, u8 val);
831int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn,
832 int where, u16 val);
833int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
834 int where, u32 val);
Huang Yinga72b46c2009-04-24 10:45:17 +0800835struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
Al Virobf362f72012-03-19 00:01:09 +0000837static inline int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800839 return pci_bus_read_config_byte(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840}
Al Virobf362f72012-03-19 00:01:09 +0000841static inline int pci_read_config_word(const struct pci_dev *dev, int where, u16 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800843 return pci_bus_read_config_word(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844}
Al Virobf362f72012-03-19 00:01:09 +0000845static inline int pci_read_config_dword(const struct pci_dev *dev, int where,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800846 u32 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800848 return pci_bus_read_config_dword(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849}
Al Virobf362f72012-03-19 00:01:09 +0000850static inline int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800852 return pci_bus_write_config_byte(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853}
Al Virobf362f72012-03-19 00:01:09 +0000854static inline int pci_write_config_word(const struct pci_dev *dev, int where, u16 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800856 return pci_bus_write_config_word(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857}
Al Virobf362f72012-03-19 00:01:09 +0000858static inline int pci_write_config_dword(const struct pci_dev *dev, int where,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800859 u32 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -0800861 return pci_bus_write_config_dword(dev->bus, dev->devfn, where, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862}
863
Jiang Liu8c0d3a02012-07-24 17:20:05 +0800864int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val);
865int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val);
866int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val);
867int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val);
868int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos,
869 u16 clear, u16 set);
870int pcie_capability_clear_and_set_dword(struct pci_dev *dev, int pos,
871 u32 clear, u32 set);
872
873static inline int pcie_capability_set_word(struct pci_dev *dev, int pos,
874 u16 set)
875{
876 return pcie_capability_clear_and_set_word(dev, pos, 0, set);
877}
878
879static inline int pcie_capability_set_dword(struct pci_dev *dev, int pos,
880 u32 set)
881{
882 return pcie_capability_clear_and_set_dword(dev, pos, 0, set);
883}
884
885static inline int pcie_capability_clear_word(struct pci_dev *dev, int pos,
886 u16 clear)
887{
888 return pcie_capability_clear_and_set_word(dev, pos, clear, 0);
889}
890
891static inline int pcie_capability_clear_dword(struct pci_dev *dev, int pos,
892 u32 clear)
893{
894 return pcie_capability_clear_and_set_dword(dev, pos, clear, 0);
895}
896
Alex Williamsonc63587d2012-06-11 05:27:19 +0000897/* user-space driven config access */
898int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
899int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
900int pci_user_read_config_dword(struct pci_dev *dev, int where, u32 *val);
901int pci_user_write_config_byte(struct pci_dev *dev, int where, u8 val);
902int pci_user_write_config_word(struct pci_dev *dev, int where, u16 val);
903int pci_user_write_config_dword(struct pci_dev *dev, int where, u32 val);
904
Andrew Morton4a7fb632006-08-14 22:43:17 -0700905int __must_check pci_enable_device(struct pci_dev *dev);
Benjamin Herrenschmidtb7189892007-12-20 15:28:08 +1100906int __must_check pci_enable_device_io(struct pci_dev *dev);
907int __must_check pci_enable_device_mem(struct pci_dev *dev);
Tejun Heo0b62e132007-07-27 14:43:35 +0900908int __must_check pci_reenable_device(struct pci_dev *);
Tejun Heo9ac78492007-01-20 16:00:26 +0900909int __must_check pcim_enable_device(struct pci_dev *pdev);
910void pcim_pin_device(struct pci_dev *pdev);
911
Yuji Shimada296ccb02009-04-03 16:41:46 +0900912static inline int pci_is_enabled(struct pci_dev *pdev)
913{
914 return (atomic_read(&pdev->enable_cnt) > 0);
915}
916
Tejun Heo9ac78492007-01-20 16:00:26 +0900917static inline int pci_is_managed(struct pci_dev *pdev)
918{
919 return pdev->is_managed;
920}
921
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922void pci_disable_device(struct pci_dev *dev);
Myron Stowe96c55902011-10-28 15:48:38 -0600923
924extern unsigned int pcibios_max_latency;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925void pci_set_master(struct pci_dev *dev);
Ben Hutchings6a479072008-12-23 03:08:29 +0000926void pci_clear_master(struct pci_dev *dev);
Myron Stowe96c55902011-10-28 15:48:38 -0600927
Brian Kingf7bdd122007-04-06 16:39:36 -0500928int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
Tejun Heo15ea76d2009-09-22 17:34:48 +0900929int pci_set_cacheline_size(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930#define HAVE_PCI_SET_MWI
Andrew Morton4a7fb632006-08-14 22:43:17 -0700931int __must_check pci_set_mwi(struct pci_dev *dev);
Randy Dunlap694625c2007-07-09 11:55:54 -0700932int pci_try_set_mwi(struct pci_dev *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933void pci_clear_mwi(struct pci_dev *dev);
Brett M Russa04ce0f2005-08-15 15:23:41 -0400934void pci_intx(struct pci_dev *dev, int enable);
Jan Kiszkaa2e27782011-11-04 09:46:00 +0100935bool pci_intx_mask_supported(struct pci_dev *dev);
936bool pci_check_and_mask_intx(struct pci_dev *dev);
937bool pci_check_and_unmask_intx(struct pci_dev *dev);
Eric W. Biedermanf5f2b132007-03-05 00:30:07 -0800938void pci_msi_off(struct pci_dev *dev);
FUJITA Tomonori4d57cdf2008-02-04 22:27:55 -0800939int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size);
FUJITA Tomonori59fc67d2008-02-04 22:28:14 -0800940int pci_set_dma_seg_boundary(struct pci_dev *dev, unsigned long mask);
Casey Leedom3775a202013-08-06 15:48:36 +0530941int pci_wait_for_pending_transaction(struct pci_dev *dev);
Peter Orubad556ad42007-05-15 13:59:13 +0200942int pcix_get_max_mmrbc(struct pci_dev *dev);
943int pcix_get_mmrbc(struct pci_dev *dev);
944int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
Brice Goglin2637e5b2007-08-14 12:43:48 +0200945int pcie_get_readrq(struct pci_dev *dev);
Peter Orubad556ad42007-05-15 13:59:13 +0200946int pcie_set_readrq(struct pci_dev *dev, int rq);
Jon Masonb03e7492011-07-20 15:20:54 -0500947int pcie_get_mps(struct pci_dev *dev);
948int pcie_set_mps(struct pci_dev *dev, int mps);
Jacob Keller81377c82013-07-31 06:53:26 +0000949int pcie_get_minimum_link(struct pci_dev *dev, enum pci_bus_speed *speed,
950 enum pcie_link_width *width);
Yu Zhao8c1c6992009-06-13 15:52:13 +0800951int __pci_reset_function(struct pci_dev *dev);
Konrad Rzeszutek Wilka96d6272012-01-04 14:23:56 -0500952int __pci_reset_function_locked(struct pci_dev *dev);
Sheng Yang8dd7f802008-10-21 17:38:25 +0800953int pci_reset_function(struct pci_dev *dev);
Alex Williamson9a3d2b92013-08-14 14:06:05 -0600954int pci_probe_reset_slot(struct pci_slot *slot);
Alex Williamson090a3c52013-08-08 14:09:55 -0600955int pci_reset_slot(struct pci_slot *slot);
Alex Williamson9a3d2b92013-08-14 14:06:05 -0600956int pci_probe_reset_bus(struct pci_bus *bus);
Alex Williamson090a3c52013-08-08 14:09:55 -0600957int pci_reset_bus(struct pci_bus *bus);
Alex Williamson64e86742013-08-08 14:09:24 -0600958void pci_reset_bridge_secondary_bus(struct pci_dev *dev);
Yu Zhao14add802008-11-22 02:38:52 +0800959void pci_update_resource(struct pci_dev *dev, int resno);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700960int __must_check pci_assign_resource(struct pci_dev *dev, int i);
Ram Pai2bbc6942011-07-25 13:08:39 -0700961int __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 +0900962int pci_select_bars(struct pci_dev *dev, unsigned long flags);
Rafael J. Wysocki8496e852013-12-01 02:34:37 +0100963bool pci_device_is_present(struct pci_dev *pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
965/* ROM control related routines */
Alan Coxe416de52008-09-23 17:25:10 +0100966int pci_enable_rom(struct pci_dev *pdev);
967void pci_disable_rom(struct pci_dev *pdev);
Dave Jones144a50e2005-08-09 00:20:10 -0400968void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
Timothy S. Nelson97c44832009-01-30 06:12:47 +1100970size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size);
Matthew Garrettfffe01f2013-03-26 17:25:54 -0400971void __iomem __must_check *pci_platform_rom(struct pci_dev *pdev, size_t *size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
973/* Power management related routines */
974int pci_save_state(struct pci_dev *dev);
Jon Mason1d3c16a2010-11-30 17:43:26 -0600975void pci_restore_state(struct pci_dev *dev);
Alex Williamsonffbdd3f2011-05-10 10:02:27 -0600976struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
977int pci_load_saved_state(struct pci_dev *dev, struct pci_saved_state *state);
978int pci_load_and_free_saved_state(struct pci_dev *dev,
979 struct pci_saved_state **state);
Rafael J. Wysocki0e5dd462009-03-26 22:51:40 +0100980int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state);
Linus Torvalds9c8550e2005-09-09 15:43:46 -0700981int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
982pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
Rafael J. Wysockie5899e12008-07-19 14:39:24 +0200983bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
Rafael J. Wysocki5a6c9b62008-08-08 00:14:24 +0200984void pci_pme_active(struct pci_dev *dev, bool enable);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100985int __pci_enable_wake(struct pci_dev *dev, pci_power_t state,
986 bool runtime, bool enable);
Rafael J. Wysocki0235c4f2008-08-18 21:38:00 +0200987int pci_wake_from_d3(struct pci_dev *dev, bool enable);
Rafael J. Wysockie5899e12008-07-19 14:39:24 +0200988pci_power_t pci_target_state(struct pci_dev *dev);
Rafael J. Wysocki404cc2d2008-07-07 03:35:26 +0200989int pci_prepare_to_sleep(struct pci_dev *dev);
990int pci_back_from_sleep(struct pci_dev *dev);
Rafael J. Wysockib67ea762010-02-17 23:44:09 +0100991bool pci_dev_run_wake(struct pci_dev *dev);
Matthew Garrettbf4d2902010-10-04 14:22:26 -0400992bool pci_check_pme_status(struct pci_dev *dev);
Matthew Garrettbf4d2902010-10-04 14:22:26 -0400993void pci_pme_wakeup_bus(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100995static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
996 bool enable)
997{
998 return __pci_enable_wake(dev, state, false, enable);
999}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
Jesse Barnesb48d4422010-10-19 13:07:57 -07001001#define PCI_EXP_IDO_REQUEST (1<<0)
1002#define PCI_EXP_IDO_COMPLETION (1<<1)
1003void pci_enable_ido(struct pci_dev *dev, unsigned long type);
1004void pci_disable_ido(struct pci_dev *dev, unsigned long type);
1005
Jesse Barnes48a92a82011-01-10 12:46:36 -08001006enum pci_obff_signal_type {
Myron Stowe688398b2011-07-07 15:00:36 -06001007 PCI_EXP_OBFF_SIGNAL_L0 = 0,
1008 PCI_EXP_OBFF_SIGNAL_ALWAYS = 1,
Jesse Barnes48a92a82011-01-10 12:46:36 -08001009};
1010int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type);
1011void pci_disable_obff(struct pci_dev *dev);
1012
Jesse Barnes51c2e0a2011-01-14 08:53:04 -08001013int pci_enable_ltr(struct pci_dev *dev);
1014void pci_disable_ltr(struct pci_dev *dev);
1015int pci_set_ltr(struct pci_dev *dev, int snoop_lat_ns, int nosnoop_lat_ns);
1016
Benjamin Herrenschmidtbb209c82010-01-26 17:10:03 +00001017/* For use by arch with custom probe code */
1018void set_pcie_port_type(struct pci_dev *pdev);
1019void set_pcie_hotplug_bridge(struct pci_dev *pdev);
1020
Kumar Galace5ccde2007-07-16 23:27:10 -05001021/* Functions for PCI Hotplug drivers to use */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001022int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
Yinghai Lu2f320522012-01-21 02:08:22 -08001023unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge);
Alex Chiang3ed4fd92009-03-20 14:56:25 -06001024unsigned int pci_rescan_bus(struct pci_bus *bus);
Kumar Galace5ccde2007-07-16 23:27:10 -05001025
Stephen Hemminger287d19c2008-12-18 09:17:16 -08001026/* Vital product data routines */
1027ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
1028ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void *buf);
Stephen Hemmingerdb567942008-12-18 09:17:16 -08001029int pci_vpd_truncate(struct pci_dev *dev, size_t size);
Stephen Hemminger287d19c2008-12-18 09:17:16 -08001030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031/* Helper functions for low-level code (drivers/pci/setup-[bus,res].c) */
Myron Stowe925845b2011-11-21 11:54:13 -07001032resource_size_t pcibios_retrieve_fw_addr(struct pci_dev *dev, int idx);
Andrew Mortonea741552009-02-18 10:44:29 -08001033void pci_bus_assign_resources(const struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034void pci_bus_size_bridges(struct pci_bus *bus);
1035int pci_claim_resource(struct pci_dev *, int);
1036void pci_assign_unassigned_resources(void);
Yinghai Lu6841ec62010-01-22 01:02:25 -08001037void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge);
Yinghai Lu17787942012-10-30 14:31:10 -06001038void pci_assign_unassigned_bus_resources(struct pci_bus *bus);
Yinghai Lu39772032013-07-22 14:37:18 -07001039void pci_assign_unassigned_root_bus_resources(struct pci_bus *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040void pdev_enable_device(struct pci_dev *);
Bjorn Helgaas842de402008-03-04 11:56:47 -07001041int pci_enable_resources(struct pci_dev *, int mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
Ralf Baechled5341942011-06-10 15:30:21 +01001043 int (*)(const struct pci_dev *, u8, u8));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044#define HAVE_PCI_REQ_REGIONS 2
Andrew Morton4a7fb632006-08-14 22:43:17 -07001045int __must_check pci_request_regions(struct pci_dev *, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001046int __must_check pci_request_regions_exclusive(struct pci_dev *, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047void pci_release_regions(struct pci_dev *);
Andrew Morton4a7fb632006-08-14 22:43:17 -07001048int __must_check pci_request_region(struct pci_dev *, int, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001049int __must_check pci_request_region_exclusive(struct pci_dev *, int, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050void pci_release_region(struct pci_dev *, int);
Hidetoshi Setoc87deff2006-12-18 10:31:06 +09001051int pci_request_selected_regions(struct pci_dev *, int, const char *);
Arjan van de Vene8de1482008-10-22 19:55:31 -07001052int pci_request_selected_regions_exclusive(struct pci_dev *, int, const char *);
Hidetoshi Setoc87deff2006-12-18 10:31:06 +09001053void pci_release_selected_regions(struct pci_dev *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
1055/* drivers/pci/bus.c */
Jiang Liufe830ef2013-05-25 21:48:29 +08001056struct pci_bus *pci_bus_get(struct pci_bus *bus);
1057void pci_bus_put(struct pci_bus *bus);
Bjorn Helgaas45ca9e92011-10-28 16:25:35 -06001058void pci_add_resource(struct list_head *resources, struct resource *res);
Bjorn Helgaas0efd5aa2012-02-23 20:19:00 -07001059void pci_add_resource_offset(struct list_head *resources, struct resource *res,
1060 resource_size_t offset);
Bjorn Helgaas45ca9e92011-10-28 16:25:35 -06001061void pci_free_resource_list(struct list_head *resources);
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -07001062void pci_bus_add_resource(struct pci_bus *bus, struct resource *res, unsigned int flags);
1063struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n);
1064void pci_bus_remove_resources(struct pci_bus *bus);
1065
Bjorn Helgaas89a74ec2010-02-23 10:24:31 -07001066#define pci_bus_for_each_resource(bus, res, i) \
Bjorn Helgaas2fe2abf2010-02-23 10:24:36 -07001067 for (i = 0; \
1068 (res = pci_bus_resource_n(bus, i)) || i < PCI_BRIDGE_RESOURCE_NUM; \
1069 i++)
Bjorn Helgaas89a74ec2010-02-23 10:24:31 -07001070
Andrew Morton4a7fb632006-08-14 22:43:17 -07001071int __must_check pci_bus_alloc_resource(struct pci_bus *bus,
1072 struct resource *res, resource_size_t size,
1073 resource_size_t align, resource_size_t min,
1074 unsigned int type_mask,
Dominik Brodowski3b7a17f2010-01-01 17:40:50 +01001075 resource_size_t (*alignf)(void *,
1076 const struct resource *,
Dominik Brodowskib26b2d42010-01-01 17:40:49 +01001077 resource_size_t,
1078 resource_size_t),
Andrew Morton4a7fb632006-08-14 22:43:17 -07001079 void *alignf_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
Laurent riffard863b18f2005-10-27 23:12:54 +02001081/* Proper probing supporting hot-pluggable devices */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001082int __must_check __pci_register_driver(struct pci_driver *, struct module *,
1083 const char *mod_name);
Andrew Mortonbba81162008-07-30 12:07:04 -07001084
1085/*
1086 * pci_register_driver must be a macro so that KBUILD_MODNAME can be expanded
1087 */
1088#define pci_register_driver(driver) \
1089 __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
Laurent riffard863b18f2005-10-27 23:12:54 +02001090
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001091void pci_unregister_driver(struct pci_driver *dev);
Greg Kroah-Hartmanaad4f402011-11-18 10:12:49 -08001092
1093/**
1094 * module_pci_driver() - Helper macro for registering a PCI driver
1095 * @__pci_driver: pci_driver struct
1096 *
1097 * Helper macro for PCI drivers which do not do anything special in module
1098 * init/exit. This eliminates a lot of boilerplate. Each module may only
1099 * use this macro once, and calling it replaces module_init() and module_exit()
1100 */
1101#define module_pci_driver(__pci_driver) \
1102 module_driver(__pci_driver, pci_register_driver, \
1103 pci_unregister_driver)
1104
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001105struct pci_driver *pci_dev_driver(const struct pci_dev *dev);
Tejun Heo9dba9102009-09-03 15:26:36 +09001106int pci_add_dynid(struct pci_driver *drv,
1107 unsigned int vendor, unsigned int device,
1108 unsigned int subvendor, unsigned int subdevice,
1109 unsigned int class, unsigned int class_mask,
1110 unsigned long driver_data);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001111const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
1112 struct pci_dev *dev);
1113int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max,
1114 int pass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
Zhang, Yanmin70298c62009-06-16 13:34:38 +08001116void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
Paul Mackerrascecf4862005-08-18 14:33:01 +10001117 void *userdata);
Yinghai Lu70b9f7d2008-04-28 16:27:23 -07001118int pci_cfg_space_size_ext(struct pci_dev *dev);
Benjamin Herrenschmidtac7dc652005-12-13 18:09:16 +11001119int pci_cfg_space_size(struct pci_dev *dev);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001120unsigned char pci_bus_max_busnr(struct pci_bus *bus);
Benjamin Herrenschmidte2444272011-09-11 14:08:38 -03001121void pci_setup_bridge(struct pci_bus *bus);
Gavin Shanac5ad932012-09-11 16:59:45 -06001122resource_size_t pcibios_window_alignment(struct pci_bus *bus,
1123 unsigned long type);
Paul Mackerrascecf4862005-08-18 14:33:01 +10001124
Dave Airlie3448a192010-06-01 15:32:24 +10001125#define PCI_VGA_STATE_CHANGE_BRIDGE (1 << 0)
1126#define PCI_VGA_STATE_CHANGE_DECODES (1 << 1)
1127
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001128int pci_set_vga_state(struct pci_dev *pdev, bool decode,
Dave Airlie3448a192010-06-01 15:32:24 +10001129 unsigned int command_bits, u32 flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130/* kmem_cache style wrapper around pci_alloc_consistent() */
1131
FUJITA Tomonorif41b1772010-03-10 15:23:30 -08001132#include <linux/pci-dma.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133#include <linux/dmapool.h>
1134
1135#define pci_pool dma_pool
1136#define pci_pool_create(name, pdev, size, align, allocation) \
1137 dma_pool_create(name, &pdev->dev, size, align, allocation)
1138#define pci_pool_destroy(pool) dma_pool_destroy(pool)
1139#define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
1140#define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
1141
David S. Millere24c2d92005-06-02 12:55:50 -07001142enum pci_dma_burst_strategy {
1143 PCI_DMA_BURST_INFINITY, /* make bursts as large as possible,
1144 strategy_parameter is N/A */
1145 PCI_DMA_BURST_BOUNDARY, /* disconnect at every strategy_parameter
1146 byte boundaries */
1147 PCI_DMA_BURST_MULTIPLE, /* disconnect at some multiple of
1148 strategy_parameter byte boundaries */
1149};
1150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151struct msix_entry {
Yinghai Lu16dbef42008-08-15 19:36:45 -07001152 u32 vector; /* kernel uses to write allocated vector */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 u16 entry; /* driver uses to specify entry, OS writes */
1154};
1155
Eric W. Biederman0366f8f2006-10-04 02:16:33 -07001156
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157#ifndef CONFIG_PCI_MSI
Matthew Wilcox1c8d7b02009-03-17 08:54:10 -04001158static inline int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001159{
1160 return -1;
1161}
1162
Alexander Gordeev08261d82012-11-19 16:02:10 +01001163static inline int
1164pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec)
1165{
1166 return -1;
1167}
1168
Yinghai Lud52877c2008-04-23 14:58:09 -07001169static inline void pci_msi_shutdown(struct pci_dev *dev)
1170{ }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001171static inline void pci_disable_msi(struct pci_dev *dev)
1172{ }
1173
Rafael J. Wysockia52e2e32009-01-24 00:21:14 +01001174static inline int pci_msix_table_size(struct pci_dev *dev)
1175{
1176 return 0;
1177}
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001178static inline int pci_enable_msix(struct pci_dev *dev,
1179 struct msix_entry *entries, int nvec)
1180{
1181 return -1;
1182}
1183
Yinghai Lud52877c2008-04-23 14:58:09 -07001184static inline void pci_msix_shutdown(struct pci_dev *dev)
1185{ }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001186static inline void pci_disable_msix(struct pci_dev *dev)
1187{ }
1188
1189static inline void msi_remove_pci_irq_vectors(struct pci_dev *dev)
1190{ }
1191
1192static inline void pci_restore_msi_state(struct pci_dev *dev)
1193{ }
Andrew Patterson07ae95f2008-11-10 15:31:05 -07001194static inline int pci_msi_enabled(void)
1195{
1196 return 0;
1197}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198#else
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001199int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec);
1200int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec);
1201void pci_msi_shutdown(struct pci_dev *dev);
1202void pci_disable_msi(struct pci_dev *dev);
1203int pci_msix_table_size(struct pci_dev *dev);
1204int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec);
1205void pci_msix_shutdown(struct pci_dev *dev);
1206void pci_disable_msix(struct pci_dev *dev);
1207void msi_remove_pci_irq_vectors(struct pci_dev *dev);
1208void pci_restore_msi_state(struct pci_dev *dev);
1209int pci_msi_enabled(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210#endif
1211
Markus Trippelsdorfab0724f2011-01-15 00:07:22 +01001212#ifdef CONFIG_PCIEPORTBUS
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001213extern bool pcie_ports_disabled;
1214extern bool pcie_ports_auto;
Markus Trippelsdorfab0724f2011-01-15 00:07:22 +01001215#else
1216#define pcie_ports_disabled true
1217#define pcie_ports_auto false
1218#endif
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001219
Andrew Patterson3e1b1602008-11-10 15:30:55 -07001220#ifndef CONFIG_PCIEASPM
Rafael J. Wysocki8b8bae92011-03-05 13:21:51 +01001221static inline int pcie_aspm_enabled(void) { return 0; }
1222static inline bool pcie_aspm_support_enabled(void) { return false; }
Andrew Patterson3e1b1602008-11-10 15:30:55 -07001223#else
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001224int pcie_aspm_enabled(void);
1225bool pcie_aspm_support_enabled(void);
Andrew Patterson3e1b1602008-11-10 15:30:55 -07001226#endif
1227
Rafael J. Wysocki415e12b2011-01-07 00:55:09 +01001228#ifdef CONFIG_PCIEAER
1229void pci_no_aer(void);
1230bool pci_aer_available(void);
1231#else
1232static inline void pci_no_aer(void) { }
1233static inline bool pci_aer_available(void) { return false; }
1234#endif
1235
Andrew Patterson43c16402009-04-22 16:52:09 -06001236#ifndef CONFIG_PCIE_ECRC
1237static inline void pcie_set_ecrc_checking(struct pci_dev *dev)
1238{
1239 return;
1240}
1241static inline void pcie_ecrc_get_policy(char *str) {};
1242#else
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001243void pcie_set_ecrc_checking(struct pci_dev *dev);
1244void pcie_ecrc_get_policy(char *str);
Andrew Patterson43c16402009-04-22 16:52:09 -06001245#endif
1246
Matthew Wilcox1c8d7b02009-03-17 08:54:10 -04001247#define pci_enable_msi(pdev) pci_enable_msi_block(pdev, 1)
1248
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001249#ifdef CONFIG_HT_IRQ
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001250/* The functions a driver should call */
1251int ht_create_irq(struct pci_dev *dev, int idx);
1252void ht_destroy_irq(unsigned int irq);
Eric W. Biederman8b955b02006-10-04 02:16:55 -07001253#endif /* CONFIG_HT_IRQ */
1254
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001255void pci_cfg_access_lock(struct pci_dev *dev);
1256bool pci_cfg_access_trylock(struct pci_dev *dev);
1257void pci_cfg_access_unlock(struct pci_dev *dev);
Brian Kinge04b0ea2005-09-27 01:21:55 -07001258
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001259/*
1260 * PCI domain support. Sometimes called PCI segment (eg by ACPI),
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001261 * a PCI domain is defined to be a set of PCI buses which share
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001262 * configuration space.
1263 */
Jeff Garzik32a2eea2007-10-11 16:57:27 -04001264#ifdef CONFIG_PCI_DOMAINS
1265extern int pci_domains_supported;
1266#else
1267enum { pci_domains_supported = 0 };
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001268static inline int pci_domain_nr(struct pci_bus *bus)
1269{
1270 return 0;
1271}
1272
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001273static inline int pci_proc_domain(struct pci_bus *bus)
1274{
1275 return 0;
1276}
Jeff Garzik32a2eea2007-10-11 16:57:27 -04001277#endif /* CONFIG_PCI_DOMAINS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278
Mike Travis95a8b6e2010-02-02 14:38:13 -08001279/* some architectures require additional setup to direct VGA traffic */
1280typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode,
Dave Airlie3448a192010-06-01 15:32:24 +10001281 unsigned int command_bits, u32 flags);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001282void pci_register_set_vga_state(arch_set_vga_state_t func);
Mike Travis95a8b6e2010-02-02 14:38:13 -08001283
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001284#else /* CONFIG_PCI is not enabled */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
1286/*
1287 * If the system does not have PCI, clearly these return errors. Define
1288 * these as simple inline functions to avoid hair in drivers.
1289 */
1290
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001291#define _PCI_NOP(o, s, t) \
1292 static inline int pci_##o##_config_##s(struct pci_dev *dev, \
1293 int where, t val) \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 { return PCIBIOS_FUNC_NOT_SUPPORTED; }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001295
1296#define _PCI_NOP_ALL(o, x) _PCI_NOP(o, byte, u8 x) \
1297 _PCI_NOP(o, word, u16 x) \
1298 _PCI_NOP(o, dword, u32 x)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299_PCI_NOP_ALL(read, *)
1300_PCI_NOP_ALL(write,)
1301
Andrew Mortond42552c2006-10-21 10:24:12 -07001302static inline struct pci_dev *pci_get_device(unsigned int vendor,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001303 unsigned int device,
1304 struct pci_dev *from)
1305{
1306 return NULL;
1307}
Andrew Mortond42552c2006-10-21 10:24:12 -07001308
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001309static inline struct pci_dev *pci_get_subsys(unsigned int vendor,
1310 unsigned int device,
1311 unsigned int ss_vendor,
1312 unsigned int ss_device,
Greg KHb08508c2008-08-26 08:20:34 -07001313 struct pci_dev *from)
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001314{
1315 return NULL;
1316}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001318static inline struct pci_dev *pci_get_class(unsigned int class,
1319 struct pci_dev *from)
1320{
1321 return NULL;
1322}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
1324#define pci_dev_present(ids) (0)
Zhang, Yanmined4aaad2007-07-15 23:39:39 -07001325#define no_pci_devices() (1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326#define pci_dev_put(dev) do { } while (0)
1327
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001328static inline void pci_set_master(struct pci_dev *dev)
1329{ }
1330
1331static inline int pci_enable_device(struct pci_dev *dev)
1332{
1333 return -EIO;
1334}
1335
1336static inline void pci_disable_device(struct pci_dev *dev)
1337{ }
1338
1339static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
1340{
1341 return -EIO;
1342}
1343
Randy Dunlap80be0382008-06-30 11:35:53 -07001344static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
1345{
1346 return -EIO;
1347}
1348
FUJITA Tomonori4d57cdf2008-02-04 22:27:55 -08001349static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
1350 unsigned int size)
1351{
1352 return -EIO;
1353}
1354
FUJITA Tomonori59fc67d2008-02-04 22:28:14 -08001355static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
1356 unsigned long mask)
1357{
1358 return -EIO;
1359}
1360
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001361static inline int pci_assign_resource(struct pci_dev *dev, int i)
1362{
1363 return -EBUSY;
1364}
1365
1366static inline int __pci_register_driver(struct pci_driver *drv,
1367 struct module *owner)
1368{
1369 return 0;
1370}
1371
1372static inline int pci_register_driver(struct pci_driver *drv)
1373{
1374 return 0;
1375}
1376
1377static inline void pci_unregister_driver(struct pci_driver *drv)
1378{ }
1379
1380static inline int pci_find_capability(struct pci_dev *dev, int cap)
1381{
1382 return 0;
1383}
1384
1385static inline int pci_find_next_capability(struct pci_dev *dev, u8 post,
1386 int cap)
1387{
1388 return 0;
1389}
1390
1391static inline int pci_find_ext_capability(struct pci_dev *dev, int cap)
1392{
1393 return 0;
1394}
1395
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396/* Power management related routines */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001397static inline int pci_save_state(struct pci_dev *dev)
1398{
1399 return 0;
1400}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
Jon Mason1d3c16a2010-11-30 17:43:26 -06001402static inline void pci_restore_state(struct pci_dev *dev)
1403{ }
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001404
1405static inline int pci_set_power_state(struct pci_dev *dev, pci_power_t state)
1406{
1407 return 0;
1408}
1409
Randy Dunlap34492482011-02-14 12:27:50 -08001410static inline int pci_wake_from_d3(struct pci_dev *dev, bool enable)
1411{
1412 return 0;
1413}
1414
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001415static inline pci_power_t pci_choose_state(struct pci_dev *dev,
1416 pm_message_t state)
1417{
1418 return PCI_D0;
1419}
1420
1421static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
1422 int enable)
1423{
1424 return 0;
1425}
1426
Jesse Barnesb48d4422010-10-19 13:07:57 -07001427static inline void pci_enable_ido(struct pci_dev *dev, unsigned long type)
1428{
1429}
1430
1431static inline void pci_disable_ido(struct pci_dev *dev, unsigned long type)
1432{
1433}
1434
Jesse Barnes48a92a82011-01-10 12:46:36 -08001435static inline int pci_enable_obff(struct pci_dev *dev, unsigned long type)
1436{
1437 return 0;
1438}
1439
1440static inline void pci_disable_obff(struct pci_dev *dev)
1441{
1442}
1443
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001444static inline int pci_request_regions(struct pci_dev *dev, const char *res_name)
1445{
1446 return -EIO;
1447}
1448
1449static inline void pci_release_regions(struct pci_dev *dev)
1450{ }
Sergei Shtylyov0da0ead2007-04-01 21:13:58 +04001451
Kumar Galaa46e8122005-07-29 12:16:27 -07001452#define pci_dma_burst_advice(pdev, strat, strategy_parameter) do { } while (0)
1453
Jan Kiszkafb51ccb2011-11-04 09:45:59 +01001454static inline void pci_block_cfg_access(struct pci_dev *dev)
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001455{ }
1456
Jan Kiszkafb51ccb2011-11-04 09:45:59 +01001457static inline int pci_block_cfg_access_in_atomic(struct pci_dev *dev)
1458{ return 0; }
1459
1460static inline void pci_unblock_cfg_access(struct pci_dev *dev)
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001461{ }
Brian Kinge04b0ea2005-09-27 01:21:55 -07001462
Randy Dunlapd80d0212007-07-01 12:06:37 -07001463static inline struct pci_bus *pci_find_next_bus(const struct pci_bus *from)
1464{ return NULL; }
1465
1466static inline struct pci_dev *pci_get_slot(struct pci_bus *bus,
1467 unsigned int devfn)
1468{ return NULL; }
1469
1470static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
1471 unsigned int devfn)
1472{ return NULL; }
1473
Dave Airlie92298e62010-08-13 10:22:17 +10001474static inline int pci_domain_nr(struct pci_bus *bus)
1475{ return 0; }
1476
Alex Williamson12ea6ca2012-06-11 05:26:55 +00001477static inline struct pci_dev *pci_dev_get(struct pci_dev *dev)
1478{ return NULL; }
1479
Williams, Mitch Afb8a0d92010-02-10 01:43:04 +00001480#define dev_is_pci(d) (false)
1481#define dev_is_pf(d) (false)
1482#define dev_num_vf(d) (0)
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001483#endif /* CONFIG_PCI */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484
Greg Kroah-Hartman4352dfd2005-07-28 11:37:33 -07001485/* Include architecture-dependent settings and functions */
1486
1487#include <asm/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488
Yinghai Lu1f82de12009-04-23 20:48:32 -07001489#ifndef PCIBIOS_MAX_MEM_32
1490#define PCIBIOS_MAX_MEM_32 (-1)
1491#endif
1492
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493/* these helpers provide future and backwards compatibility
1494 * for accessing popular PCI BAR info */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001495#define pci_resource_start(dev, bar) ((dev)->resource[(bar)].start)
1496#define pci_resource_end(dev, bar) ((dev)->resource[(bar)].end)
1497#define pci_resource_flags(dev, bar) ((dev)->resource[(bar)].flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498#define pci_resource_len(dev,bar) \
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001499 ((pci_resource_start((dev), (bar)) == 0 && \
1500 pci_resource_end((dev), (bar)) == \
1501 pci_resource_start((dev), (bar))) ? 0 : \
1502 \
1503 (pci_resource_end((dev), (bar)) - \
1504 pci_resource_start((dev), (bar)) + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505
1506/* Similar to the helpers above, these manipulate per-pci_dev
1507 * driver-specific data. They are really just a wrapper around
1508 * the generic device structure functions of these calls.
1509 */
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001510static inline void *pci_get_drvdata(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511{
1512 return dev_get_drvdata(&pdev->dev);
1513}
1514
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001515static inline void pci_set_drvdata(struct pci_dev *pdev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516{
1517 dev_set_drvdata(&pdev->dev, data);
1518}
1519
1520/* If you want to know what to call your pci_dev, ask this function.
1521 * Again, it's a wrapper around the generic device.
1522 */
Alexey Zaytsev2fc90f62009-06-24 16:22:30 +04001523static inline const char *pci_name(const struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524{
Greg KHc6c4f072008-07-03 09:49:39 -07001525 return dev_name(&pdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526}
1527
Michael Ellerman2311b1f2005-05-13 17:44:10 +10001528
1529/* Some archs don't want to expose struct resource to userland as-is
1530 * in sysfs and /proc
1531 */
1532#ifndef HAVE_ARCH_PCI_RESOURCE_TO_USER
1533static inline void pci_resource_to_user(const struct pci_dev *dev, int bar,
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001534 const struct resource *rsrc, resource_size_t *start,
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -07001535 resource_size_t *end)
Michael Ellerman2311b1f2005-05-13 17:44:10 +10001536{
1537 *start = rsrc->start;
1538 *end = rsrc->end;
1539}
1540#endif /* HAVE_ARCH_PCI_RESOURCE_TO_USER */
1541
1542
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543/*
1544 * The world is not perfect and supplies us with broken PCI devices.
1545 * For at least a part of these bugs we need a work-around, so both
1546 * generic (drivers/pci/quirks.c) and per-architecture code can define
1547 * fixup hooks to be called for particular buggy devices.
1548 */
1549
1550struct pci_fixup {
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001551 u16 vendor; /* You can use PCI_ANY_ID here of course */
1552 u16 device; /* You can use PCI_ANY_ID here of course */
1553 u32 class; /* You can use PCI_ANY_ID here too */
1554 unsigned int class_shift; /* should be 0, 8, 16 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 void (*hook)(struct pci_dev *dev);
1556};
1557
1558enum pci_fixup_pass {
1559 pci_fixup_early, /* Before probing BARs */
1560 pci_fixup_header, /* After reading configuration header */
1561 pci_fixup_final, /* Final phase of device fixups */
1562 pci_fixup_enable, /* pci_enable_device() time */
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001563 pci_fixup_resume, /* pci_device_resume() */
1564 pci_fixup_suspend, /* pci_device_suspend */
1565 pci_fixup_resume_early, /* pci_device_resume_early() */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566};
1567
1568/* Anonymous variables would be nice... */
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001569#define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, class, \
1570 class_shift, hook) \
Michal Marekecf61c72013-11-11 14:40:35 +01001571 static const struct pci_fixup __PASTE(__pci_fixup_##name,__LINE__) __used \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001572 __attribute__((__section__(#section), aligned((sizeof(void *))))) \
1573 = { vendor, device, class, class_shift, hook };
1574
1575#define DECLARE_PCI_FIXUP_CLASS_EARLY(vendor, device, class, \
1576 class_shift, hook) \
1577 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early, \
Michal Marekecf61c72013-11-11 14:40:35 +01001578 hook, vendor, device, class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001579#define DECLARE_PCI_FIXUP_CLASS_HEADER(vendor, device, class, \
1580 class_shift, hook) \
1581 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header, \
Michal Marekecf61c72013-11-11 14:40:35 +01001582 hook, vendor, device, class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001583#define DECLARE_PCI_FIXUP_CLASS_FINAL(vendor, device, class, \
1584 class_shift, hook) \
1585 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final, \
Michal Marekecf61c72013-11-11 14:40:35 +01001586 hook, vendor, device, class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001587#define DECLARE_PCI_FIXUP_CLASS_ENABLE(vendor, device, class, \
1588 class_shift, hook) \
1589 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable, \
Michal Marekecf61c72013-11-11 14:40:35 +01001590 hook, vendor, device, class, class_shift, hook)
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001591#define DECLARE_PCI_FIXUP_CLASS_RESUME(vendor, device, class, \
1592 class_shift, hook) \
1593 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume, \
Michal Marekecf61c72013-11-11 14:40:35 +01001594 resume##hook, vendor, device, class, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001595 class_shift, hook)
1596#define DECLARE_PCI_FIXUP_CLASS_RESUME_EARLY(vendor, device, class, \
1597 class_shift, hook) \
1598 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early, \
Michal Marekecf61c72013-11-11 14:40:35 +01001599 resume_early##hook, vendor, device, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001600 class, class_shift, hook)
1601#define DECLARE_PCI_FIXUP_CLASS_SUSPEND(vendor, device, class, \
1602 class_shift, hook) \
1603 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend, \
Michal Marekecf61c72013-11-11 14:40:35 +01001604 suspend##hook, vendor, device, class, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001605 class_shift, hook)
1606
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607#define DECLARE_PCI_FIXUP_EARLY(vendor, device, hook) \
1608 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early, \
Michal Marekecf61c72013-11-11 14:40:35 +01001609 hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610#define DECLARE_PCI_FIXUP_HEADER(vendor, device, hook) \
1611 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header, \
Michal Marekecf61c72013-11-11 14:40:35 +01001612 hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613#define DECLARE_PCI_FIXUP_FINAL(vendor, device, hook) \
1614 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final, \
Michal Marekecf61c72013-11-11 14:40:35 +01001615 hook, vendor, device, PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616#define DECLARE_PCI_FIXUP_ENABLE(vendor, device, hook) \
1617 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable, \
Michal Marekecf61c72013-11-11 14:40:35 +01001618 hook, vendor, device, PCI_ANY_ID, 0, hook)
Alan Cox1597cac2006-12-04 15:14:45 -08001619#define DECLARE_PCI_FIXUP_RESUME(vendor, device, hook) \
1620 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume, \
Michal Marekecf61c72013-11-11 14:40:35 +01001621 resume##hook, vendor, device, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001622 PCI_ANY_ID, 0, hook)
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001623#define DECLARE_PCI_FIXUP_RESUME_EARLY(vendor, device, hook) \
1624 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early, \
Michal Marekecf61c72013-11-11 14:40:35 +01001625 resume_early##hook, vendor, device, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001626 PCI_ANY_ID, 0, hook)
Rafael J. Wysockie1a2a512008-05-15 21:51:31 +02001627#define DECLARE_PCI_FIXUP_SUSPEND(vendor, device, hook) \
1628 DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend, \
Michal Marekecf61c72013-11-11 14:40:35 +01001629 suspend##hook, vendor, device, \
Yinghai Luf4ca5c62012-02-23 23:46:49 -08001630 PCI_ANY_ID, 0, hook)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001632#ifdef CONFIG_PCI_QUIRKS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
Alex Williamson12ea6ca2012-06-11 05:26:55 +00001634struct pci_dev *pci_get_dma_source(struct pci_dev *dev);
Alex Williamsonad805752012-06-11 05:27:07 +00001635int pci_dev_specific_acs_enabled(struct pci_dev *dev, u16 acs_flags);
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001636#else
1637static inline void pci_fixup_device(enum pci_fixup_pass pass,
1638 struct pci_dev *dev) {}
Alex Williamson12ea6ca2012-06-11 05:26:55 +00001639static inline struct pci_dev *pci_get_dma_source(struct pci_dev *dev)
1640{
1641 return pci_dev_get(dev);
1642}
Alex Williamsonad805752012-06-11 05:27:07 +00001643static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
1644 u16 acs_flags)
1645{
1646 return -ENOTTY;
1647}
Rafael J. Wysocki93177a72010-01-02 22:57:24 +01001648#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001650void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);
Al Viro5ea81762007-02-11 15:41:31 +00001651void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr);
Greg Kroah-Hartman05cca6e2008-01-30 15:21:33 -08001652void __iomem * const *pcim_iomap_table(struct pci_dev *pdev);
Yinghai Lufb7ebfe2012-01-04 15:50:02 -08001653int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name);
1654int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask,
Tejun Heo916fbfb2008-03-12 15:26:34 +09001655 const char *name);
Yinghai Lufb7ebfe2012-01-04 15:50:02 -08001656void pcim_iounmap_regions(struct pci_dev *pdev, int mask);
Al Viro5ea81762007-02-11 15:41:31 +00001657
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658extern int pci_pci_problems;
Alan Cox236561e2006-09-30 23:27:03 -07001659#define PCIPCI_FAIL 1 /* No PCI PCI DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660#define PCIPCI_TRITON 2
1661#define PCIPCI_NATOMA 4
1662#define PCIPCI_VIAETBF 8
1663#define PCIPCI_VSFX 16
Alan Cox236561e2006-09-30 23:27:03 -07001664#define PCIPCI_ALIMAGIK 32 /* Need low latency setting */
1665#define PCIAGP_FAIL 64 /* No PCI to AGP DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
Atsushi Nemoto4516a612007-02-05 16:36:06 -08001667extern unsigned long pci_cardbus_io_size;
1668extern unsigned long pci_cardbus_mem_size;
Bill Pemberton15856ad2012-11-21 15:35:00 -05001669extern u8 pci_dfl_cache_line_size;
Jesse Barnesac1aa472009-10-26 13:20:44 -07001670extern u8 pci_cache_line_size;
Atsushi Nemoto4516a612007-02-05 16:36:06 -08001671
Eric W. Biederman28760482009-09-09 14:09:24 -07001672extern unsigned long pci_hotplug_io_size;
1673extern unsigned long pci_hotplug_mem_size;
1674
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001675/* Architecture-specific versions may override these (weak) */
Adrian Bunk19792a02008-05-05 21:25:47 +03001676int pcibios_add_platform_entries(struct pci_dev *dev);
1677void pcibios_disable_device(struct pci_dev *dev);
Myron Stowecfce9fb2011-10-28 15:47:35 -06001678void pcibios_set_master(struct pci_dev *dev);
Adrian Bunk19792a02008-05-05 21:25:47 +03001679int pcibios_set_pcie_reset_state(struct pci_dev *dev,
1680 enum pcie_reset_state state);
Matthew Garretteca0d462012-12-05 14:33:27 -07001681int pcibios_add_device(struct pci_dev *dev);
Sebastian Ott6ae32c52013-06-04 19:18:14 +02001682void pcibios_release_device(struct pci_dev *dev);
Michael Ellerman575e3342007-05-08 12:03:07 +10001683
Sebastian Ott699c1982013-08-20 16:41:02 +02001684#ifdef CONFIG_HIBERNATE_CALLBACKS
1685extern struct dev_pm_ops pcibios_pm_ops;
1686#endif
1687
Robert Hancock7752d5c2008-02-15 01:27:20 -08001688#ifdef CONFIG_PCI_MMCONFIG
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001689void __init pci_mmcfg_early_init(void);
1690void __init pci_mmcfg_late_init(void);
Robert Hancock7752d5c2008-02-15 01:27:20 -08001691#else
Yinghai Lubb63b422008-02-28 23:56:50 -08001692static inline void pci_mmcfg_early_init(void) { }
Robert Hancock7752d5c2008-02-15 01:27:20 -08001693static inline void pci_mmcfg_late_init(void) { }
1694#endif
1695
Taku Izumi642c92d2012-10-30 15:26:18 +09001696int pci_ext_cfg_avail(void);
Andrew Patterson0ef5f8f2008-11-10 15:30:50 -07001697
Andrew Morton1684f5d2008-12-01 14:30:30 -08001698void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar);
Arjan van de Venaa42d7c2008-09-28 16:36:11 -07001699
Yu Zhaodd7cc442009-03-20 11:25:15 +08001700#ifdef CONFIG_PCI_IOV
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001701int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn);
1702void pci_disable_sriov(struct pci_dev *dev);
1703irqreturn_t pci_sriov_migration(struct pci_dev *dev);
1704int pci_num_vf(struct pci_dev *dev);
Alexander Duyck5a8eb242013-04-25 04:42:29 +00001705int pci_vfs_assigned(struct pci_dev *dev);
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001706int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs);
1707int pci_sriov_get_totalvfs(struct pci_dev *dev);
Yu Zhaodd7cc442009-03-20 11:25:15 +08001708#else
1709static inline int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
1710{
1711 return -ENODEV;
1712}
1713static inline void pci_disable_sriov(struct pci_dev *dev)
1714{
1715}
Yu Zhao74bb1bc2009-03-20 11:25:16 +08001716static inline irqreturn_t pci_sriov_migration(struct pci_dev *dev)
1717{
1718 return IRQ_NONE;
1719}
Williams, Mitch Afb8a0d92010-02-10 01:43:04 +00001720static inline int pci_num_vf(struct pci_dev *dev)
1721{
1722 return 0;
1723}
Alexander Duyck5a8eb242013-04-25 04:42:29 +00001724static inline int pci_vfs_assigned(struct pci_dev *dev)
1725{
1726 return 0;
1727}
Donald Dutilebff73152012-11-05 15:20:37 -05001728static inline int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs)
1729{
1730 return 0;
1731}
1732static inline int pci_sriov_get_totalvfs(struct pci_dev *dev)
1733{
1734 return 0;
1735}
Yu Zhaodd7cc442009-03-20 11:25:15 +08001736#endif
1737
Kenji Kaneshigec825bc92009-06-16 11:01:25 +09001738#if defined(CONFIG_HOTPLUG_PCI) || defined(CONFIG_HOTPLUG_PCI_MODULE)
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001739void pci_hp_create_module_link(struct pci_slot *pci_slot);
1740void pci_hp_remove_module_link(struct pci_slot *pci_slot);
Kenji Kaneshigec825bc92009-06-16 11:01:25 +09001741#endif
1742
Kenji Kaneshiged7b7e602009-11-11 14:29:54 +09001743/**
1744 * pci_pcie_cap - get the saved PCIe capability offset
1745 * @dev: PCI device
1746 *
1747 * PCIe capability offset is calculated at PCI device initialization
1748 * time and saved in the data structure. This function returns saved
1749 * PCIe capability offset. Using this instead of pci_find_capability()
1750 * reduces unnecessary search in the PCI configuration space. If you
1751 * need to calculate PCIe capability offset from raw device for some
1752 * reasons, please use pci_find_capability() instead.
1753 */
1754static inline int pci_pcie_cap(struct pci_dev *dev)
1755{
1756 return dev->pcie_cap;
1757}
1758
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001759/**
1760 * pci_is_pcie - check if the PCI device is PCI Express capable
1761 * @dev: PCI device
1762 *
Joe Perchesa895c282013-09-03 13:31:05 -07001763 * Returns: true if the PCI device is PCI Express capable, false otherwise.
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001764 */
1765static inline bool pci_is_pcie(struct pci_dev *dev)
1766{
Joe Perchesa895c282013-09-03 13:31:05 -07001767 return pci_pcie_cap(dev);
Kenji Kaneshige7eb776c2009-11-11 14:35:22 +09001768}
1769
Yijing Wang786e2282012-07-24 17:20:02 +08001770/**
Myron Stowe7c9c0032013-01-25 17:55:39 -07001771 * pcie_caps_reg - get the PCIe Capabilities Register
1772 * @dev: PCI device
1773 */
1774static inline u16 pcie_caps_reg(const struct pci_dev *dev)
1775{
1776 return dev->pcie_flags_reg;
1777}
1778
1779/**
Yijing Wang786e2282012-07-24 17:20:02 +08001780 * pci_pcie_type - get the PCIe device/port type
1781 * @dev: PCI device
1782 */
1783static inline int pci_pcie_type(const struct pci_dev *dev)
1784{
Myron Stowe1c531d82013-01-25 17:55:45 -07001785 return (pcie_caps_reg(dev) & PCI_EXP_FLAGS_TYPE) >> 4;
Yijing Wang786e2282012-07-24 17:20:02 +08001786}
1787
Chris Wright5d990b62009-12-04 12:15:21 -08001788void pci_request_acs(void);
Alex Williamsonad805752012-06-11 05:27:07 +00001789bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags);
1790bool pci_acs_path_enabled(struct pci_dev *start,
1791 struct pci_dev *end, u16 acs_flags);
Matt Carlsona2ce7662010-02-26 14:04:39 +00001792
Matt Carlson7ad506f2010-02-26 14:04:40 +00001793#define PCI_VPD_LRDT 0x80 /* Large Resource Data Type */
1794#define PCI_VPD_LRDT_ID(x) (x | PCI_VPD_LRDT)
1795
1796/* Large Resource Data Type Tag Item Names */
1797#define PCI_VPD_LTIN_ID_STRING 0x02 /* Identifier String */
1798#define PCI_VPD_LTIN_RO_DATA 0x10 /* Read-Only Data */
1799#define PCI_VPD_LTIN_RW_DATA 0x11 /* Read-Write Data */
1800
1801#define PCI_VPD_LRDT_ID_STRING PCI_VPD_LRDT_ID(PCI_VPD_LTIN_ID_STRING)
1802#define PCI_VPD_LRDT_RO_DATA PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RO_DATA)
1803#define PCI_VPD_LRDT_RW_DATA PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RW_DATA)
1804
1805/* Small Resource Data Type Tag Item Names */
1806#define PCI_VPD_STIN_END 0x78 /* End */
1807
1808#define PCI_VPD_SRDT_END PCI_VPD_STIN_END
1809
1810#define PCI_VPD_SRDT_TIN_MASK 0x78
1811#define PCI_VPD_SRDT_LEN_MASK 0x07
1812
1813#define PCI_VPD_LRDT_TAG_SIZE 3
1814#define PCI_VPD_SRDT_TAG_SIZE 1
Matt Carlsona2ce7662010-02-26 14:04:39 +00001815
Matt Carlsone1d5bda2010-02-26 14:04:42 +00001816#define PCI_VPD_INFO_FLD_HDR_SIZE 3
1817
Matt Carlson4067a852010-02-26 14:04:43 +00001818#define PCI_VPD_RO_KEYWORD_PARTNO "PN"
1819#define PCI_VPD_RO_KEYWORD_MFR_ID "MN"
1820#define PCI_VPD_RO_KEYWORD_VENDOR0 "V0"
Matt Carlsond4894f32011-03-09 16:58:21 +00001821#define PCI_VPD_RO_KEYWORD_CHKSUM "RV"
Matt Carlson4067a852010-02-26 14:04:43 +00001822
Matt Carlsona2ce7662010-02-26 14:04:39 +00001823/**
1824 * pci_vpd_lrdt_size - Extracts the Large Resource Data Type length
1825 * @lrdt: Pointer to the beginning of the Large Resource Data Type tag
1826 *
1827 * Returns the extracted Large Resource Data Type length.
1828 */
1829static inline u16 pci_vpd_lrdt_size(const u8 *lrdt)
1830{
1831 return (u16)lrdt[1] + ((u16)lrdt[2] << 8);
1832}
1833
Matt Carlson7ad506f2010-02-26 14:04:40 +00001834/**
1835 * pci_vpd_srdt_size - Extracts the Small Resource Data Type length
1836 * @lrdt: Pointer to the beginning of the Small Resource Data Type tag
1837 *
1838 * Returns the extracted Small Resource Data Type length.
1839 */
1840static inline u8 pci_vpd_srdt_size(const u8 *srdt)
1841{
1842 return (*srdt) & PCI_VPD_SRDT_LEN_MASK;
1843}
1844
Matt Carlsonb55ac1b2010-02-26 14:04:41 +00001845/**
Matt Carlsone1d5bda2010-02-26 14:04:42 +00001846 * pci_vpd_info_field_size - Extracts the information field length
1847 * @lrdt: Pointer to the beginning of an information field header
1848 *
1849 * Returns the extracted information field length.
1850 */
1851static inline u8 pci_vpd_info_field_size(const u8 *info_field)
1852{
1853 return info_field[2];
1854}
1855
1856/**
Matt Carlsonb55ac1b2010-02-26 14:04:41 +00001857 * pci_vpd_find_tag - Locates the Resource Data Type tag provided
1858 * @buf: Pointer to buffered vpd data
1859 * @off: The offset into the buffer at which to begin the search
1860 * @len: The length of the vpd buffer
1861 * @rdt: The Resource Data Type to search for
1862 *
1863 * Returns the index where the Resource Data Type was found or
1864 * -ENOENT otherwise.
1865 */
1866int pci_vpd_find_tag(const u8 *buf, unsigned int off, unsigned int len, u8 rdt);
1867
Matt Carlson4067a852010-02-26 14:04:43 +00001868/**
1869 * pci_vpd_find_info_keyword - Locates an information field keyword in the VPD
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 buffer area, relative to off, in which to search
1873 * @kw: The keyword to search for
1874 *
1875 * Returns the index where the information field keyword was found or
1876 * -ENOENT otherwise.
1877 */
1878int pci_vpd_find_info_keyword(const u8 *buf, unsigned int off,
1879 unsigned int len, const char *kw);
1880
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10001881/* PCI <-> OF binding helpers */
1882#ifdef CONFIG_OF
1883struct device_node;
Bjorn Helgaasf39d5b72013-04-12 12:02:59 -06001884void pci_set_of_node(struct pci_dev *dev);
1885void pci_release_of_node(struct pci_dev *dev);
1886void pci_set_bus_of_node(struct pci_bus *bus);
1887void pci_release_bus_of_node(struct pci_bus *bus);
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10001888
1889/* Arch may override this (weak) */
Bjorn Helgaas723ec4d2013-04-17 10:31:34 -06001890struct device_node *pcibios_get_phb_of_node(struct pci_bus *bus);
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10001891
John Crispin3df425f2012-04-12 17:33:07 +02001892static inline struct device_node *
1893pci_device_to_OF_node(const struct pci_dev *pdev)
Benjamin Herrenschmidt64099d92011-04-07 13:09:47 +10001894{
1895 return pdev ? pdev->dev.of_node : NULL;
1896}
1897
Benjamin Herrenschmidtef3b4f82011-04-11 11:34:33 +10001898static inline struct device_node *pci_bus_to_OF_node(struct pci_bus *bus)
1899{
1900 return bus ? bus->dev.of_node : NULL;
1901}
1902
Benjamin Herrenschmidt98d9f30c82011-04-11 11:37:07 +10001903#else /* CONFIG_OF */
1904static inline void pci_set_of_node(struct pci_dev *dev) { }
1905static inline void pci_release_of_node(struct pci_dev *dev) { }
1906static inline void pci_set_bus_of_node(struct pci_bus *bus) { }
1907static inline void pci_release_bus_of_node(struct pci_bus *bus) { }
1908#endif /* CONFIG_OF */
1909
Gavin Shaneb740b52012-02-27 20:04:04 +00001910#ifdef CONFIG_EEH
1911static inline struct eeh_dev *pci_dev_to_eeh_dev(struct pci_dev *pdev)
1912{
1913 return pdev->dev.archdata.edev;
1914}
1915#endif
1916
Ohad Ben-Cohen166e9272011-06-10 21:42:27 +03001917/**
1918 * pci_find_upstream_pcie_bridge - find upstream PCIe-to-PCI bridge of a device
1919 * @pdev: the PCI device
1920 *
1921 * if the device is PCIE, return NULL
1922 * if the device isn't connected to a PCIe bridge (that is its parent is a
1923 * legacy PCI bridge and the bridge is directly connected to bus 0), return its
1924 * parent
1925 */
1926struct pci_dev *pci_find_upstream_pcie_bridge(struct pci_dev *pdev);
1927
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928#endif /* LINUX_PCI_H */