pci.h 82.7 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0 */
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 *	pci.h
 *
 *	PCI defines and function prototypes
 *	Copyright 1994, Drew Eckhardt
 *	Copyright 1997--1999 Martin Mares <mj@ucw.cz>
 *
 *	For more information, please consult the following manuals (look at
 *	http://www.pcisig.com/ for how to get them):
 *
 *	PCI BIOS Specification
 *	PCI Local Bus Specification
 *	PCI to PCI Bridge Specification
 *	PCI System Design Guide
 */
#ifndef LINUX_PCI_H
#define LINUX_PCI_H


21 22
#include <linux/mod_devicetable.h>

Linus Torvalds's avatar
Linus Torvalds committed
23
#include <linux/types.h>
24
#include <linux/init.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26
#include <linux/ioport.h>
#include <linux/list.h>
27
#include <linux/compiler.h>
Linus Torvalds's avatar
Linus Torvalds committed
28
#include <linux/errno.h>
Alex Chiang's avatar
Alex Chiang committed
29
#include <linux/kobject.h>
30
#include <linux/atomic.h>
Linus Torvalds's avatar
Linus Torvalds committed
31
#include <linux/device.h>
32
#include <linux/interrupt.h>
33
#include <linux/io.h>
34
#include <linux/resource_ext.h>
35
#include <uapi/linux/pci.h>
Linus Torvalds's avatar
Linus Torvalds committed
36

37 38
#include <linux/pci_ids.h>

39 40 41 42 43 44 45
/*
 * The PCI interface treats multi-function devices as independent
 * devices.  The slot/function address of each device is encoded
 * in a single byte as follows:
 *
 *	7:3 = slot
 *	2:0 = function
46 47
 *
 * PCI_DEVFN(), PCI_SLOT(), and PCI_FUNC() are defined in uapi/linux/pci.h.
48
 * In the interest of not exposing interfaces to user-space unnecessarily,
49
 * the following kernel-only defines are being added here.
50
 */
51
#define PCI_DEVID(bus, devfn)	((((u16)(bus)) << 8) | (devfn))
52 53 54
/* return bus from PCI devid = ((u16)bus_number) << 8) | devfn */
#define PCI_BUS_NUM(x) (((x) >> 8) & 0xff)

Alex Chiang's avatar
Alex Chiang committed
55 56
/* pci_slot represents a physical slot */
struct pci_slot {
57 58 59 60 61
	struct pci_bus		*bus;		/* Bus this slot is on */
	struct list_head	list;		/* Node in list of slots */
	struct hotplug_slot	*hotplug;	/* Hotplug info (move here) */
	unsigned char		number;		/* PCI_SLOT(pci_dev->devfn) */
	struct kobject		kobj;
Alex Chiang's avatar
Alex Chiang committed
62 63
};

64 65 66 67 68
static inline const char *pci_slot_name(const struct pci_slot *slot)
{
	return kobject_name(&slot->kobj);
}

Linus Torvalds's avatar
Linus Torvalds committed
69 70 71 72 73 74
/* File state for mmap()s on /proc/bus/pci/X/Y */
enum pci_mmap_state {
	pci_mmap_io,
	pci_mmap_mem
};

75
/* For PCI devices, the region numbers are assigned this way: */
76 77 78 79 80 81 82 83
enum {
	/* #0-5: standard PCI resources */
	PCI_STD_RESOURCES,
	PCI_STD_RESOURCE_END = 5,

	/* #6: expansion ROM resource */
	PCI_ROM_RESOURCE,

84
	/* Device-specific resources */
85 86 87 88 89
#ifdef CONFIG_PCI_IOV
	PCI_IOV_RESOURCES,
	PCI_IOV_RESOURCE_END = PCI_IOV_RESOURCES + PCI_SRIOV_NUM_BARS - 1,
#endif

90
	/* Resources assigned to buses behind the bridge */
91 92 93 94 95 96
#define PCI_BRIDGE_RESOURCE_NUM 4

	PCI_BRIDGE_RESOURCES,
	PCI_BRIDGE_RESOURCE_END = PCI_BRIDGE_RESOURCES +
				  PCI_BRIDGE_RESOURCE_NUM - 1,

97
	/* Total resources associated with a PCI device */
98 99
	PCI_NUM_RESOURCES,

100
	/* Preserve this for compatibility */
101
	DEVICE_COUNT_RESOURCE = PCI_NUM_RESOURCES,
102
};
Linus Torvalds's avatar
Linus Torvalds committed
103

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
/**
 * enum pci_interrupt_pin - PCI INTx interrupt values
 * @PCI_INTERRUPT_UNKNOWN: Unknown or unassigned interrupt
 * @PCI_INTERRUPT_INTA: PCI INTA pin
 * @PCI_INTERRUPT_INTB: PCI INTB pin
 * @PCI_INTERRUPT_INTC: PCI INTC pin
 * @PCI_INTERRUPT_INTD: PCI INTD pin
 *
 * Corresponds to values for legacy PCI INTx interrupts, as can be found in the
 * PCI_INTERRUPT_PIN register.
 */
enum pci_interrupt_pin {
	PCI_INTERRUPT_UNKNOWN,
	PCI_INTERRUPT_INTA,
	PCI_INTERRUPT_INTB,
	PCI_INTERRUPT_INTC,
	PCI_INTERRUPT_INTD,
};

/* The number of legacy PCI INTx interrupts */
#define PCI_NUM_INTX	4

126 127 128 129
/*
 * pci_power_t values must match the bits in the Capabilities PME_Support
 * and Control/Status PowerState fields in the Power Management capability.
 */
Linus Torvalds's avatar
Linus Torvalds committed
130 131
typedef int __bitwise pci_power_t;

132 133 134
#define PCI_D0		((pci_power_t __force) 0)
#define PCI_D1		((pci_power_t __force) 1)
#define PCI_D2		((pci_power_t __force) 2)
Linus Torvalds's avatar
Linus Torvalds committed
135 136
#define PCI_D3hot	((pci_power_t __force) 3)
#define PCI_D3cold	((pci_power_t __force) 4)
137
#define PCI_UNKNOWN	((pci_power_t __force) 5)
138
#define PCI_POWER_ERROR	((pci_power_t __force) -1)
Linus Torvalds's avatar
Linus Torvalds committed
139

140 141 142 143 144
/* Remember to update this when the list above changes! */
extern const char *pci_power_names[];

static inline const char *pci_power_name(pci_power_t state)
{
145
	return pci_power_names[1 + (__force int) state];
146 147
}

148 149 150 151
#define PCI_PM_D2_DELAY		200
#define PCI_PM_D3_WAIT		10
#define PCI_PM_D3COLD_WAIT	100
#define PCI_PM_BUS_WAIT		50
152

153 154 155 156
/**
 * The pci_channel state describes connectivity between the CPU and
 * the PCI device.  If some PCI bus between here and the PCI device
 * has crashed or locked up, this info is reflected here.
157 158 159 160 161 162 163 164 165 166 167 168 169 170
 */
typedef unsigned int __bitwise pci_channel_state_t;

enum pci_channel_state {
	/* I/O channel is in normal state */
	pci_channel_io_normal = (__force pci_channel_state_t) 1,

	/* I/O to channel is blocked */
	pci_channel_io_frozen = (__force pci_channel_state_t) 2,

	/* PCI card is dead */
	pci_channel_io_perm_failure = (__force pci_channel_state_t) 3,
};

Brian King's avatar
Brian King committed
171 172 173 174 175 176
typedef unsigned int __bitwise pcie_reset_state_t;

enum pcie_reset_state {
	/* Reset is NOT asserted (Use to deassert reset) */
	pcie_deassert_reset = (__force pcie_reset_state_t) 1,

177
	/* Use #PERST to reset PCIe device */
Brian King's avatar
Brian King committed
178 179
	pcie_warm_reset = (__force pcie_reset_state_t) 2,

180
	/* Use PCIe Hot Reset to reset device */
Brian King's avatar
Brian King committed
181 182 183
	pcie_hot_reset = (__force pcie_reset_state_t) 3
};

184 185
typedef unsigned short __bitwise pci_dev_flags_t;
enum pci_dev_flags {
186
	/* INTX_DISABLE in PCI_COMMAND register disables MSI too */
187
	PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG = (__force pci_dev_flags_t) (1 << 0),
188
	/* Device configuration is irrevocably lost if disabled into D3 */
189
	PCI_DEV_FLAGS_NO_D3 = (__force pci_dev_flags_t) (1 << 1),
190
	/* Provide indication device is assigned by a Virtual Machine Manager */
191
	PCI_DEV_FLAGS_ASSIGNED = (__force pci_dev_flags_t) (1 << 2),
192
	/* Flag for quirk use to store if quirk-specific ACS is enabled */
193
	PCI_DEV_FLAGS_ACS_ENABLED_QUIRK = (__force pci_dev_flags_t) (1 << 3),
194 195
	/* Use a PCIe-to-PCI bridge alias even if !pci_is_pcie */
	PCI_DEV_FLAG_PCIE_BRIDGE_ALIAS = (__force pci_dev_flags_t) (1 << 5),
196 197
	/* Do not use bus resets for device */
	PCI_DEV_FLAGS_NO_BUS_RESET = (__force pci_dev_flags_t) (1 << 6),
198 199
	/* Do not use PM reset even if device advertises NoSoftRst- */
	PCI_DEV_FLAGS_NO_PM_RESET = (__force pci_dev_flags_t) (1 << 7),
200 201
	/* Get VPD from function 0 VPD */
	PCI_DEV_FLAGS_VPD_REF_F0 = (__force pci_dev_flags_t) (1 << 8),
202
	/* A non-root bridge where translation occurs, stop alias search here */
203
	PCI_DEV_FLAGS_BRIDGE_XLATE_ROOT = (__force pci_dev_flags_t) (1 << 9),
204 205
	/* Do not use FLR even if device advertises PCI_AF_CAP */
	PCI_DEV_FLAGS_NO_FLR_RESET = (__force pci_dev_flags_t) (1 << 10),
206
	/* Don't use Relaxed Ordering for TLPs directed at this device */
207
	PCI_DEV_FLAGS_NO_RELAXED_ORDERING = (__force pci_dev_flags_t) (1 << 11),
208 209
};

210 211 212 213 214
enum pci_irq_reroute_variant {
	INTEL_IRQ_REROUTE_VARIANT = 1,
	MAX_IRQ_REROUTE_VARIANTS = 3
};

215 216
typedef unsigned short __bitwise pci_bus_flags_t;
enum pci_bus_flags {
217 218 219
	PCI_BUS_FLAGS_NO_MSI	= (__force pci_bus_flags_t) 1,
	PCI_BUS_FLAGS_NO_MMRBC	= (__force pci_bus_flags_t) 2,
	PCI_BUS_FLAGS_NO_AERSID	= (__force pci_bus_flags_t) 4,
220
	PCI_BUS_FLAGS_NO_EXTCFG	= (__force pci_bus_flags_t) 8,
221 222
};

223
/* Values from Link Status register, PCIe r3.1, sec 7.8.8 */
224 225 226 227 228 229
enum pcie_link_width {
	PCIE_LNK_WIDTH_RESRV	= 0x00,
	PCIE_LNK_X1		= 0x01,
	PCIE_LNK_X2		= 0x02,
	PCIE_LNK_X4		= 0x04,
	PCIE_LNK_X8		= 0x08,
230
	PCIE_LNK_X12		= 0x0c,
231 232
	PCIE_LNK_X16		= 0x10,
	PCIE_LNK_X32		= 0x20,
233
	PCIE_LNK_WIDTH_UNKNOWN	= 0xff,
234 235
};

236 237 238 239 240 241 242 243 244 245 246 247 248
/* Based on the PCI Hotplug Spec, but some values are made up by us */
enum pci_bus_speed {
	PCI_SPEED_33MHz			= 0x00,
	PCI_SPEED_66MHz			= 0x01,
	PCI_SPEED_66MHz_PCIX		= 0x02,
	PCI_SPEED_100MHz_PCIX		= 0x03,
	PCI_SPEED_133MHz_PCIX		= 0x04,
	PCI_SPEED_66MHz_PCIX_ECC	= 0x05,
	PCI_SPEED_100MHz_PCIX_ECC	= 0x06,
	PCI_SPEED_133MHz_PCIX_ECC	= 0x07,
	PCI_SPEED_66MHz_PCIX_266	= 0x09,
	PCI_SPEED_100MHz_PCIX_266	= 0x0a,
	PCI_SPEED_133MHz_PCIX_266	= 0x0b,
249 250 251 252 253
	AGP_UNKNOWN			= 0x0c,
	AGP_1X				= 0x0d,
	AGP_2X				= 0x0e,
	AGP_4X				= 0x0f,
	AGP_8X				= 0x10,
254 255 256 257 258
	PCI_SPEED_66MHz_PCIX_533	= 0x11,
	PCI_SPEED_100MHz_PCIX_533	= 0x12,
	PCI_SPEED_133MHz_PCIX_533	= 0x13,
	PCIE_SPEED_2_5GT		= 0x14,
	PCIE_SPEED_5_0GT		= 0x15,
259
	PCIE_SPEED_8_0GT		= 0x16,
260
	PCIE_SPEED_16_0GT		= 0x17,
261 262 263
	PCI_SPEED_UNKNOWN		= 0xff,
};

264 265 266
enum pci_bus_speed pcie_get_speed_cap(struct pci_dev *dev);
enum pcie_link_width pcie_get_width_cap(struct pci_dev *dev);

267
struct pci_cap_saved_data {
268 269 270 271
	u16		cap_nr;
	bool		cap_extended;
	unsigned int	size;
	u32		data[0];
272 273
};

274
struct pci_cap_saved_state {
275 276
	struct hlist_node		next;
	struct pci_cap_saved_data	cap;
277 278
};

279
struct irq_affinity;
280
struct pcie_link_state;
281
struct pci_vpd;
282
struct pci_sriov;
283
struct pci_ats;
284
struct pci_p2pdma;
285

286
/* The pci_dev structure describes PCI devices */
Linus Torvalds's avatar
Linus Torvalds committed
287
struct pci_dev {
288 289 290
	struct list_head bus_list;	/* Node in per-bus list */
	struct pci_bus	*bus;		/* Bus this device is on */
	struct pci_bus	*subordinate;	/* Bus this device bridges to */
Linus Torvalds's avatar
Linus Torvalds committed
291

292 293
	void		*sysdata;	/* Hook for sys-specific extension */
	struct proc_dir_entry *procent;	/* Device entry in /proc/bus/pci */
Alex Chiang's avatar
Alex Chiang committed
294
	struct pci_slot	*slot;		/* Physical slot this device is in */
Linus Torvalds's avatar
Linus Torvalds committed
295

296
	unsigned int	devfn;		/* Encoded device & function index */
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299 300 301
	unsigned short	vendor;
	unsigned short	device;
	unsigned short	subsystem_vendor;
	unsigned short	subsystem_device;
	unsigned int	class;		/* 3 bytes: (base,sub,prog-if) */
302
	u8		revision;	/* PCI revision, low byte of class word */
Linus Torvalds's avatar
Linus Torvalds committed
303
	u8		hdr_type;	/* PCI header type (`multi' flag masked out) */
304 305
#ifdef CONFIG_PCIEAER
	u16		aer_cap;	/* AER capability offset */
306
	struct aer_stats *aer_stats;	/* AER stats for this device */
307
#endif
308
	u8		pcie_cap;	/* PCIe capability offset */
309 310
	u8		msi_cap;	/* MSI capability offset */
	u8		msix_cap;	/* MSI-X capability offset */
311
	u8		pcie_mpss:3;	/* PCIe Max Payload Size Supported */
312 313 314 315
	u8		rom_base_reg;	/* Config register controlling ROM */
	u8		pin;		/* Interrupt pin this device uses */
	u16		pcie_flags_reg;	/* Cached PCIe Capabilities Register */
	unsigned long	*dma_alias_mask;/* Mask of enabled devfn aliases */
Linus Torvalds's avatar
Linus Torvalds committed
316

317
	struct pci_driver *driver;	/* Driver bound to this device */
Linus Torvalds's avatar
Linus Torvalds committed
318 319 320 321 322 323
	u64		dma_mask;	/* Mask of the bits of bus address this
					   device implements.  Normally this is
					   0xffffffff.  You only need to change
					   this if your device has broken DMA
					   or supports 64-bit transfers.  */

324 325
	struct device_dma_parameters dma_parms;

326 327 328
	pci_power_t	current_state;	/* Current operating state. In ACPI,
					   this is D0-D3, D0 being fully
					   functional, and D3 being off. */
329
	unsigned int	imm_ready:1;	/* Supports Immediate Readiness */
330
	u8		pm_cap;		/* PM capability offset */
331 332
	unsigned int	pme_support:5;	/* Bitmask of states from which PME#
					   can be generated */
333
	unsigned int	pme_poll:1;	/* Poll device's PME status bit */
334 335
	unsigned int	d1_support:1;	/* Low power state D1 is supported */
	unsigned int	d2_support:1;	/* Low power state D2 is supported */
336 337
	unsigned int	no_d1d2:1;	/* D1 and D2 are forbidden */
	unsigned int	no_d3cold:1;	/* D3cold is forbidden */
338
	unsigned int	bridge_d3:1;	/* Allow D3 for bridge */
339
	unsigned int	d3cold_allowed:1;	/* D3cold is allowed by user */
340 341
	unsigned int	mmio_always_on:1;	/* Disallow turning off io/mem
						   decoding during BAR sizing */
342
	unsigned int	wakeup_prepared:1;
343
	unsigned int	runtime_d3cold:1;	/* Whether go through runtime
344 345 346
						   D3cold, not set for devices
						   powered on/off by the
						   corresponding bridge */
347
	unsigned int	ignore_hotplug:1;	/* Ignore hotplug events */
348 349 350
	unsigned int	hotplug_user_indicators:1; /* SlotCtl indicators
						      controlled exclusively by
						      user sysfs */
351
	unsigned int	d3_delay;	/* D3->D0 transition time in ms */
352
	unsigned int	d3cold_delay;	/* D3cold->D0 transition time in ms */
Linus Torvalds's avatar
Linus Torvalds committed
353

354
#ifdef CONFIG_PCIEASPM
355
	struct pcie_link_state	*link_state;	/* ASPM link state */
356 357
	unsigned int	ltr_path:1;	/* Latency Tolerance Reporting
					   supported from root to here */
358
#endif
359
	unsigned int	eetlp_prefix_path:1;	/* End-to-End TLP Prefix */
360

361 362
	pci_channel_state_t error_state;	/* Current connectivity state */
	struct device	dev;			/* Generic device interface */
Linus Torvalds's avatar
Linus Torvalds committed
363

364
	int		cfg_size;		/* Size of config space */
Linus Torvalds's avatar
Linus Torvalds committed
365 366 367 368 369 370 371 372

	/*
	 * Instead of touching interrupt line and base address registers
	 * directly, use the values stored here. They might be different!
	 */
	unsigned int	irq;
	struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */

373 374 375 376 377 378 379 380 381 382 383
	bool		match_driver;		/* Skip attaching driver */

	unsigned int	transparent:1;		/* Subtractive decode bridge */
	unsigned int	multifunction:1;	/* Multi-function device */

	unsigned int	is_busmaster:1;		/* Is busmaster */
	unsigned int	no_msi:1;		/* May not use MSI */
	unsigned int	no_64bit_msi:1; 	/* May only use 32-bit MSIs */
	unsigned int	block_cfg_access:1;	/* Config space access blocked */
	unsigned int	broken_parity_status:1;	/* Generates false positive parity */
	unsigned int	irq_reroute_variant:2;	/* Needs IRQ rerouting variant */
384
	unsigned int	msi_enabled:1;
385
	unsigned int	msix_enabled:1;
386 387
	unsigned int	ari_enabled:1;		/* ARI forwarding */
	unsigned int	ats_enabled:1;		/* Address Translation Svc */
388 389
	unsigned int	pasid_enabled:1;	/* Process Address Space ID */
	unsigned int	pri_enabled:1;		/* Page Request Interface */
390
	unsigned int	is_managed:1;
391
	unsigned int	needs_freset:1;		/* Requires fundamental reset */
392
	unsigned int	state_saved:1;
393
	unsigned int	is_physfn:1;
394
	unsigned int	is_virtfn:1;
395
	unsigned int	reset_fn:1;
396
	unsigned int	is_hotplug_bridge:1;
397
	unsigned int	shpc_managed:1;		/* SHPC owned by shpchp */
398 399
	unsigned int	is_thunderbolt:1;	/* Thunderbolt controller */
	unsigned int	__aer_firmware_first_valid:1;
400
	unsigned int	__aer_firmware_first:1;
401 402
	unsigned int	broken_intx_masking:1;	/* INTx masking can't be used */
	unsigned int	io_window_1k:1;		/* Intel bridge 1K I/O windows */
403
	unsigned int	irq_managed:1;
404
	unsigned int	has_secondary_link:1;
405 406
	unsigned int	non_compliant_bars:1;	/* Broken BARs; ignore them */
	unsigned int	is_probed:1;		/* Device probing in progress */
407
	unsigned int	link_active_reporting:1;/* Device capable of reporting link active */
408
	pci_dev_flags_t dev_flags;
409
	atomic_t	enable_cnt;	/* pci_enable_device has been called */
410

411
	u32		saved_config_space[16]; /* Config space saved at suspend time */
412
	struct hlist_head saved_cap_space;
413 414
	struct bin_attribute *rom_attr;		/* Attribute descriptor for sysfs ROM entry */
	int		rom_attr_enabled;	/* Display of ROM attribute enabled? */
Linus Torvalds's avatar
Linus Torvalds committed
415
	struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */
416
	struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE]; /* sysfs file for WC mapping of resources */
417

418 419 420
#ifdef CONFIG_HOTPLUG_PCI_PCIE
	unsigned int	broken_cmd_compl:1;	/* No compl for some cmds */
#endif
421 422 423
#ifdef CONFIG_PCIE_PTM
	unsigned int	ptm_root:1;
	unsigned int	ptm_enabled:1;
424
	u8		ptm_granularity;
425
#endif
426
#ifdef CONFIG_PCI_MSI
427
	const struct attribute_group **msi_irq_groups;
428
#endif
429
	struct pci_vpd *vpd;
430
#ifdef CONFIG_PCI_ATS
431
	union {
432 433
		struct pci_sriov	*sriov;		/* PF: SR-IOV info */
		struct pci_dev		*physfn;	/* VF: related PF */
434
	};
435 436
	u16		ats_cap;	/* ATS Capability offset */
	u8		ats_stu;	/* ATS Smallest Translation Unit */
437
	atomic_t	ats_ref_cnt;	/* Number of VFs with ATS enabled */
438 439 440 441 442 443
#endif
#ifdef CONFIG_PCI_PRI
	u32		pri_reqs_alloc; /* Number of PRI requests allocated */
#endif
#ifdef CONFIG_PCI_PASID
	u16		pasid_features;
444 445 446
#endif
#ifdef CONFIG_PCI_P2PDMA
	struct pci_p2pdma *p2pdma;
447
#endif
448 449 450
	phys_addr_t	rom;		/* Physical address if not from BAR */
	size_t		romlen;		/* Length if not from BAR */
	char		*driver_override; /* Driver name to force a match */
451

452
	unsigned long	priv_flags;	/* Private flags for the PCI driver */
Linus Torvalds's avatar
Linus Torvalds committed
453 454
};

455 456 457 458 459 460 461 462 463
static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
{
#ifdef CONFIG_PCI_IOV
	if (dev->is_virtfn)
		dev = dev->physfn;
#endif
	return dev;
}

464
struct pci_dev *pci_alloc_dev(struct pci_bus *bus);
465

Linus Torvalds's avatar
Linus Torvalds committed
466 467 468
#define	to_pci_dev(n) container_of(n, struct pci_dev, dev)
#define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)

469 470 471 472 473
static inline int pci_channel_offline(struct pci_dev *pdev)
{
	return (pdev->error_state != pci_channel_io_normal);
}

474
struct pci_host_bridge {
475 476 477 478 479
	struct device	dev;
	struct pci_bus	*bus;		/* Root bus */
	struct pci_ops	*ops;
	void		*sysdata;
	int		busnr;
480
	struct list_head windows;	/* resource_entry */
481
	u8 (*swizzle_irq)(struct pci_dev *, u8 *); /* Platform IRQ swizzler */
482
	int (*map_irq)(const struct pci_dev *, u8, u8);
483
	void (*release_fn)(struct pci_host_bridge *);
484
	void		*release_data;
485
	struct msi_controller *msi;
486 487
	unsigned int	ignore_reset_delay:1;	/* For entire hierarchy */
	unsigned int	no_ext_tags:1;		/* No Extended Tags */
488
	unsigned int	native_aer:1;		/* OS may use PCIe AER */
489
	unsigned int	native_pcie_hotplug:1;	/* OS may use PCIe hotplug */
490
	unsigned int	native_shpc_hotplug:1;	/* OS may use SHPC hotplug */
491
	unsigned int	native_pme:1;		/* OS may use PCIe PME */
492
	unsigned int	native_ltr:1;		/* OS may use PCIe LTR */
493 494 495 496 497 498
	/* Resource alignment requirements */
	resource_size_t (*align_resource)(struct pci_dev *dev,
			const struct resource *res,
			resource_size_t start,
			resource_size_t size,
			resource_size_t align);
499
	unsigned long	private[0] ____cacheline_aligned;
500
};
501

502
#define	to_pci_host_bridge(n) container_of(n, struct pci_host_bridge, dev)
503

504 505 506 507 508 509 510 511 512 513
static inline void *pci_host_bridge_priv(struct pci_host_bridge *bridge)
{
	return (void *)bridge->private;
}

static inline struct pci_host_bridge *pci_host_bridge_from_priv(void *priv)
{
	return container_of(priv, struct pci_host_bridge, private);
}

514
struct pci_host_bridge *pci_alloc_host_bridge(size_t priv);
515 516
struct pci_host_bridge *devm_pci_alloc_host_bridge(struct device *dev,
						   size_t priv);
517
void pci_free_host_bridge(struct pci_host_bridge *bridge);
518 519
struct pci_host_bridge *pci_find_host_bridge(struct pci_bus *bus);

520
void pci_set_host_bridge_release(struct pci_host_bridge *bridge,
521 522
				 void (*release_fn)(struct pci_host_bridge *),
				 void *release_data);
523

524 525
int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge);

526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
/*
 * The first PCI_BRIDGE_RESOURCE_NUM PCI bus resources (those that correspond
 * to P2P or CardBus bridge windows) go in a table.  Additional ones (for
 * buses below host bridges or subtractive decode bridges) go in the list.
 * Use pci_bus_for_each_resource() to iterate through all the resources.
 */

/*
 * PCI_SUBTRACTIVE_DECODE means the bridge forwards the window implicitly
 * and there's no way to program the bridge with the details of the window.
 * This does not apply to ACPI _CRS windows, even with the _DEC subtractive-
 * decode bit set, because they are explicit and can be programmed with _SRS.
 */
#define PCI_SUBTRACTIVE_DECODE	0x1

struct pci_bus_resource {
542 543 544
	struct list_head	list;
	struct resource		*res;
	unsigned int		flags;
545
};
546 547

#define PCI_REGION_FLAG_MASK	0x0fU	/* These bits of resource flags tell us the PCI region flags */
Linus Torvalds's avatar
Linus Torvalds committed
548 549

struct pci_bus {
550 551 552 553 554 555
	struct list_head node;		/* Node in list of buses */
	struct pci_bus	*parent;	/* Parent bus this bridge is on */
	struct list_head children;	/* List of child buses */
	struct list_head devices;	/* List of devices on this bus */
	struct pci_dev	*self;		/* Bridge device as seen by parent */
	struct list_head slots;		/* List of slots on this bus;
556
					   protected by pci_slot_mutex */
557
	struct resource *resource[PCI_BRIDGE_RESOURCE_NUM];
558 559
	struct list_head resources;	/* Address space routed to this bus */
	struct resource busn_res;	/* Bus numbers routed to this bus */
Linus Torvalds's avatar
Linus Torvalds committed
560

561
	struct pci_ops	*ops;		/* Configuration access functions */
562
	struct msi_controller *msi;	/* MSI controller */
563 564
	void		*sysdata;	/* Hook for sys-specific extension */
	struct proc_dir_entry *procdir;	/* Directory entry in /proc/bus/pci */
Linus Torvalds's avatar
Linus Torvalds committed
565

566 567
	unsigned char	number;		/* Bus number */
	unsigned char	primary;	/* Number of primary bridge */
568 569
	unsigned char	max_bus_speed;	/* enum pci_bus_speed */
	unsigned char	cur_bus_speed;	/* enum pci_bus_speed */
570 571 572
#ifdef CONFIG_PCI_DOMAINS_GENERIC
	int		domain_nr;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
573 574 575

	char		name[48];

576 577
	unsigned short	bridge_ctl;	/* Manage NO_ISA/FBB/et al behaviors */
	pci_bus_flags_t bus_flags;	/* Inherited by child buses */
Linus Torvalds's avatar
Linus Torvalds committed
578
	struct device		*bridge;
579
	struct device		dev;
580 581
	struct bin_attribute	*legacy_io;	/* Legacy I/O for this bus */
	struct bin_attribute	*legacy_mem;	/* Legacy mem */
582
	unsigned int		is_added:1;
Linus Torvalds's avatar
Linus Torvalds committed
583 584
};

585
#define to_pci_bus(n)	container_of(n, struct pci_bus, dev)
Linus Torvalds's avatar
Linus Torvalds committed
586

587
/*
588
 * Returns true if the PCI bus is root (behind host-PCI bridge),
589
 * false otherwise
590 591 592 593
 *
 * Some code assumes that "bus->self == NULL" means that bus is a root bus.
 * This is incorrect because "virtual" buses added for SR-IOV (via
 * virtfn_add_bus()) have "bus->self == NULL" but are not root buses.
594 595 596 597 598 599
 */
static inline bool pci_is_root_bus(struct pci_bus *pbus)
{
	return !(pbus->parent);
}

600 601 602 603 604 605 606 607 608 609 610 611 612
/**
 * pci_is_bridge - check if the PCI device is a bridge
 * @dev: PCI device
 *
 * Return true if the PCI device is bridge whether it has subordinate
 * or not.
 */
static inline bool pci_is_bridge(struct pci_dev *dev)
{
	return dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
		dev->hdr_type == PCI_HEADER_TYPE_CARDBUS;
}

613 614 615 616
#define for_each_pci_bridge(dev, bus)				\
	list_for_each_entry(dev, &bus->devices, bus_list)	\
		if (!pci_is_bridge(dev)) {} else

617 618 619 620 621 622 623 624 625
static inline struct pci_dev *pci_upstream_bridge(struct pci_dev *dev)
{
	dev = pci_physfn(dev);
	if (pci_is_root_bus(dev->bus))
		return NULL;

	return dev->bus->self;
}

626 627 628
struct device *pci_get_host_bridge_device(struct pci_dev *dev);
void pci_put_host_bridge_device(struct device *dev);

629 630 631 632 633 634 635 636 637
#ifdef CONFIG_PCI_MSI
static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev)
{
	return pci_dev->msi_enabled || pci_dev->msix_enabled;
}
#else
static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev) { return false; }
#endif

638
/* Error values that may be returned by PCI functions */
Linus Torvalds's avatar
Linus Torvalds committed
639 640 641 642 643 644 645 646
#define PCIBIOS_SUCCESSFUL		0x00
#define PCIBIOS_FUNC_NOT_SUPPORTED	0x81
#define PCIBIOS_BAD_VENDOR_ID		0x83
#define PCIBIOS_DEVICE_NOT_FOUND	0x86
#define PCIBIOS_BAD_REGISTER_NUMBER	0x87
#define PCIBIOS_SET_FAILED		0x88
#define PCIBIOS_BUFFER_TOO_SMALL	0x89

647
/* Translate above to generic errno for passing back through non-PCI code */
648 649 650 651 652 653 654 655 656
static inline int pcibios_err_to_errno(int err)
{
	if (err <= PCIBIOS_SUCCESSFUL)
		return err; /* Assume already errno */

	switch (err) {
	case PCIBIOS_FUNC_NOT_SUPPORTED:
		return -ENOENT;
	case PCIBIOS_BAD_VENDOR_ID:
657
		return -ENOTTY;
658 659 660 661 662 663 664 665 666 667
	case PCIBIOS_DEVICE_NOT_FOUND:
		return -ENODEV;
	case PCIBIOS_BAD_REGISTER_NUMBER:
		return -EFAULT;
	case PCIBIOS_SET_FAILED:
		return -EIO;
	case PCIBIOS_BUFFER_TOO_SMALL:
		return -ENOSPC;
	}

668
	return -ERANGE;
669 670
}

Linus Torvalds's avatar
Linus Torvalds committed
671 672 673
/* Low-level architecture-dependent routines */

struct pci_ops {
674 675
	int (*add_bus)(struct pci_bus *bus);
	void (*remove_bus)(struct pci_bus *bus);
676
	void __iomem *(*map_bus)(struct pci_bus *bus, unsigned int devfn, int where);
Linus Torvalds's avatar
Linus Torvalds committed
677 678 679 680
	int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
	int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
};

681 682 683 684
/*
 * ACPI needs to be able to access PCI config space before we've done a
 * PCI bus scan and created pci_bus structures.
 */
685 686 687 688
int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
		 int reg, int len, u32 *val);
int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
		  int reg, int len, u32 val);
Linus Torvalds's avatar
Linus Torvalds committed
689

690
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
Yinghai Lu's avatar
Yinghai Lu committed
691 692 693 694 695
typedef u64 pci_bus_addr_t;
#else
typedef u32 pci_bus_addr_t;
#endif

Linus Torvalds's avatar
Linus Torvalds committed
696
struct pci_bus_region {
697 698
	pci_bus_addr_t	start;
	pci_bus_addr_t	end;
Linus Torvalds's avatar
Linus Torvalds committed
699 700 701
};

struct pci_dynids {
702 703
	spinlock_t		lock;	/* Protects list, index */
	struct list_head	list;	/* For IDs added at runtime */
Linus Torvalds's avatar
Linus Torvalds committed
704 705
};

706 707 708 709 710 711

/*
 * PCI Error Recovery System (PCI-ERS).  If a PCI device driver provides
 * a set of callbacks in struct pci_error_handlers, that device driver
 * will be notified of PCI bus errors, and will be driven to recovery
 * when an error occurs.
712 713 714 715 716
 */

typedef unsigned int __bitwise pci_ers_result_t;

enum pci_ers_result {
717
	/* No result/none/not supported in device driver */
718 719 720 721 722
	PCI_ERS_RESULT_NONE = (__force pci_ers_result_t) 1,

	/* Device driver can recover without slot reset */
	PCI_ERS_RESULT_CAN_RECOVER = (__force pci_ers_result_t) 2,

723
	/* Device driver wants slot to be reset */
724 725 726 727 728 729 730
	PCI_ERS_RESULT_NEED_RESET = (__force pci_ers_result_t) 3,

	/* Device has completely failed, is unrecoverable */
	PCI_ERS_RESULT_DISCONNECT = (__force pci_ers_result_t) 4,

	/* Device driver is fully recovered and operational */
	PCI_ERS_RESULT_RECOVERED = (__force pci_ers_result_t) 5,
731 732 733

	/* No AER capabilities registered for the driver */
	PCI_ERS_RESULT_NO_AER_DRIVER = (__force pci_ers_result_t) 6,
734 735 736
};

/* PCI bus error event callbacks */
737
struct pci_error_handlers {
738 739
	/* PCI bus error detected on this device */
	pci_ers_result_t (*error_detected)(struct pci_dev *dev,
740
					   enum pci_channel_state error);
741 742 743 744 745 746 747

	/* MMIO has been re-enabled, but not DMA */
	pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);

	/* PCI slot has been reset */
	pci_ers_result_t (*slot_reset)(struct pci_dev *dev);

748
	/* PCI function reset prepare or completed */
749 750
	void (*reset_prepare)(struct pci_dev *dev);
	void (*reset_done)(struct pci_dev *dev);
751

752 753 754 755 756
	/* Device driver may resume normal operations */
	void (*resume)(struct pci_dev *dev);
};


Linus Torvalds's avatar
Linus Torvalds committed
757 758
struct module;
struct pci_driver {
759 760 761 762 763 764 765 766 767
	struct list_head	node;
	const char		*name;
	const struct pci_device_id *id_table;	/* Must be non-NULL for probe to be called */
	int  (*probe)(struct pci_dev *dev, const struct pci_device_id *id);	/* New device inserted */
	void (*remove)(struct pci_dev *dev);	/* Device removed (NULL if not a hot-plug capable driver) */
	int  (*suspend)(struct pci_dev *dev, pm_message_t state);	/* Device suspended */
	int  (*suspend_late)(struct pci_dev *dev, pm_message_t state);
	int  (*resume_early)(struct pci_dev *dev);
	int  (*resume) (struct pci_dev *dev);	/* Device woken up */
768
	void (*shutdown) (struct pci_dev *dev);
769
	int  (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* On PF */
770
	const struct pci_error_handlers *err_handler;
771
	const struct attribute_group **groups;
Linus Torvalds's avatar
Linus Torvalds committed
772
	struct device_driver	driver;
773
	struct pci_dynids	dynids;
Linus Torvalds's avatar
Linus Torvalds committed
774 775
};

776
#define	to_pci_driver(drv) container_of(drv, struct pci_driver, driver)
Linus Torvalds's avatar
Linus Torvalds committed
777 778

/**
779
 * PCI_DEVICE - macro used to describe a specific PCI device
Linus Torvalds's avatar
Linus Torvalds committed
780 781 782 783 784 785 786 787 788 789 790
 * @vend: the 16 bit PCI Vendor ID
 * @dev: the 16 bit PCI Device ID
 *
 * This macro is used to create a struct pci_device_id that matches a
 * specific device.  The subvendor and subdevice fields will be set to
 * PCI_ANY_ID.
 */
#define PCI_DEVICE(vend,dev) \
	.vendor = (vend), .device = (dev), \
	.subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID

791
/**
792
 * PCI_DEVICE_SUB - macro used to describe a specific PCI device with subsystem
793 794 795 796 797 798 799 800 801 802 803 804
 * @vend: the 16 bit PCI Vendor ID
 * @dev: the 16 bit PCI Device ID
 * @subvend: the 16 bit PCI Subvendor ID
 * @subdev: the 16 bit PCI Subdevice ID
 *
 * This macro is used to create a struct pci_device_id that matches a
 * specific device with subsystem information.
 */
#define PCI_DEVICE_SUB(vend, dev, subvend, subdev) \
	.vendor = (vend), .device = (dev), \
	.subvendor = (subvend), .subdevice = (subdev)

Linus Torvalds's avatar
Linus Torvalds committed
805
/**
806
 * PCI_DEVICE_CLASS - macro used to describe a specific PCI device class
Linus Torvalds's avatar
Linus Torvalds committed
807 808 809 810
 * @dev_class: the class, subclass, prog-if triple for this device
 * @dev_class_mask: the class mask for this device
 *
 * This macro is used to create a struct pci_device_id that matches a
811
 * specific PCI class.  The vendor, device, subvendor, and subdevice
Linus Torvalds's avatar
Linus Torvalds committed
812 813 814 815 816 817 818
 * fields will be set to PCI_ANY_ID.
 */
#define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
	.class = (dev_class), .class_mask = (dev_class_mask), \
	.vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
	.subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID

819
/**
820
 * PCI_VDEVICE - macro used to describe a specific PCI device in short form
821 822
 * @vend: the vendor name
 * @dev: the 16 bit PCI Device ID
823 824 825 826 827 828
 *
 * This macro is used to create a struct pci_device_id that matches a
 * specific PCI device.  The subvendor, and subdevice fields will be set
 * to PCI_ANY_ID. The macro allows the next field to follow as the device
 * private data.
 */
829 830 831
#define PCI_VDEVICE(vend, dev) \
	.vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
	.subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
832

833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
/**
 * PCI_DEVICE_DATA - macro used to describe a specific PCI device in very short form
 * @vend: the vendor name (without PCI_VENDOR_ID_ prefix)
 * @dev: the device name (without PCI_DEVICE_ID_<vend>_ prefix)
 * @data: the driver data to be filled
 *
 * This macro is used to create a struct pci_device_id that matches a
 * specific PCI device.  The subvendor, and subdevice fields will be set
 * to PCI_ANY_ID.
 */
#define PCI_DEVICE_DATA(vend, dev, data) \
	.vendor = PCI_VENDOR_ID_##vend, .device = PCI_DEVICE_ID_##vend##_##dev, \
	.subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0, \
	.driver_data = (kernel_ulong_t)(data)

848
enum {
849 850 851 852 853
	PCI_REASSIGN_ALL_RSRC	= 0x00000001,	/* Ignore firmware setup */
	PCI_REASSIGN_ALL_BUS	= 0x00000002,	/* Reassign all bus numbers */
	PCI_PROBE_ONLY		= 0x00000004,	/* Use existing setup */
	PCI_CAN_SKIP_ISA_ALIGN	= 0x00000008,	/* Don't do ISA alignment */
	PCI_ENABLE_PROC_DOMAINS	= 0x00000010,	/* Enable domains in /proc */
854
	PCI_COMPAT_DOMAIN_0	= 0x00000020,	/* ... except domain 0 */
855
	PCI_SCAN_ALL_PCIE_DEVS	= 0x00000040,	/* Scan all, not just dev 0 */
856 857
};

858
/* These external functions are only available when PCI support is enabled */
Linus Torvalds's avatar
Linus Torvalds committed
859 860
#ifdef CONFIG_PCI

861 862 863 864 865 866 867
extern unsigned int pci_flags;

static inline void pci_set_flags(int flags) { pci_flags = flags; }
static inline void pci_add_flags(int flags) { pci_flags |= flags; }
static inline void pci_clear_flags(int flags) { pci_flags &= ~flags; }
static inline int pci_has_flag(int flag) { return pci_flags & flag; }

868
void pcie_bus_configure_settings(struct pci_bus *bus);
869 870

enum pcie_bus_config_types {
871 872 873 874 875
	PCIE_BUS_TUNE_OFF,	/* Don't touch MPS at all */
	PCIE_BUS_DEFAULT,	/* Ensure MPS matches upstream bridge */
	PCIE_BUS_SAFE,		/* Use largest MPS boot-time devices support */
	PCIE_BUS_PERFORMANCE,	/* Use MPS and MRRS for best performance */
	PCIE_BUS_PEER2PEER,	/* Set MPS = 128 for all devices */
876 877 878 879
};

extern enum pcie_bus_config_types pcie_bus_config;

Linus Torvalds's avatar
Linus Torvalds committed
880 881
extern struct bus_type pci_bus_type;

882 883
/* Do NOT directly access these two variables, unless you are arch-specific PCI
 * code, or PCI core code. */
884
extern struct list_head pci_root_buses;	/* List of all known PCI buses */
885
/* Some device drivers need know if PCI is initiated */
886
int no_pci_devices(void);
Linus Torvalds's avatar
Linus Torvalds committed
887

888
void pcibios_resource_survey_bus(struct pci_bus *bus);
889
void pcibios_bus_add_device(struct pci_dev *pdev);
890 891
void pcibios_add_bus(struct pci_bus *bus);
void pcibios_remove_bus(struct pci_bus *bus);
Linus Torvalds's avatar
Linus Torvalds committed
892
void pcibios_fixup_bus(struct pci_bus *);
893
int __must_check pcibios_enable_device(struct pci_dev *, int mask);
894
/* Architecture-specific versions may override this (weak) */
895
char *pcibios_setup(char *str);
Linus Torvalds's avatar
Linus Torvalds committed
896 897

/* Used only when drivers/pci/setup.c is used */
898
resource_size_t pcibios_align_resource(void *, const struct resource *,
899
				resource_size_t,
900
				resource_size_t);
Linus Torvalds's avatar
Linus Torvalds committed
901

902 903 904
/* Weak but can be overriden by arch */
void pci_fixup_cardbus(struct pci_bus *);

Linus Torvalds's avatar
Linus Torvalds committed
905 906
/* Generic PCI functions used internally */

907
void pcibios_resource_to_bus(struct pci_bus *bus, struct pci_bus_region *region,
908
			     struct resource *res);
909
void pcibios_bus_to_resource(struct pci_bus *bus, struct resource *res,
910
			     struct pci_bus_region *region);
911
void pcibios_scan_specific_bus(int busn);
912
struct pci_bus *pci_find_bus(int domain, int busnr);
913
void pci_bus_add_devices(const struct pci_bus *bus);
914
struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata);
915 916 917
struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
				    struct pci_ops *ops, void *sysdata,
				    struct list_head *resources);
918
int pci_host_probe(struct pci_host_bridge *bridge);
919 920 921
int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int busmax);
int pci_bus_update_busn_res_end(struct pci_bus *b, int busmax);
void pci_bus_release_busn_res(struct pci_bus *b);
922
struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
923 924
				  struct pci_ops *ops, void *sysdata,
				  struct list_head *resources);
925
int pci_scan_root_bus_bridge(struct pci_host_bridge *bridge);
926 927
struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
				int busnr);
928
void pcie_update_link_speed(struct pci_bus *bus, u16 link_status);
Alex Chiang's avatar
Alex Chiang committed
929
struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
930 931
				 const char *name,
				 struct hotplug_slot *hotplug);
Alex Chiang's avatar
Alex Chiang committed
932
void pci_destroy_slot(struct pci_slot *slot);
933 934 935 936 937
#ifdef CONFIG_SYSFS
void pci_dev_assign_slot(struct pci_dev *dev);
#else
static inline void pci_dev_assign_slot(struct pci_dev *dev) { }
#endif
Linus Torvalds's avatar
Linus Torvalds committed
938
int pci_scan_slot(struct pci_bus *bus, int devfn);
939
struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn);
940
void pci_device_add(struct pci_dev *dev, struct pci_bus *bus);
Linus Torvalds's avatar
Linus Torvalds committed
941
unsigned int pci_scan_child_bus(struct pci_bus *bus);
942
void pci_bus_add_device(struct pci_dev *dev);
Linus Torvalds's avatar
Linus Torvalds committed
943
void pci_read_bridge_bases(struct pci_bus *child);
944 945
struct resource *pci_find_parent_resource(const struct pci_dev *dev,
					  struct resource *res);
946
struct pci_dev *pci_find_pcie_root_port(struct pci_dev *dev);
947
u8 pci_swizzle_interrupt_pin(const struct pci_dev *dev, u8 pin);
Linus Torvalds's avatar
Linus Torvalds committed
948
int pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge);
949
u8 pci_common_swizzle(struct pci_dev *dev, u8 *pinp);
950 951 952 953
struct pci_dev *pci_dev_get(struct pci_dev *dev);
void pci_dev_put(struct pci_dev *dev);
void pci_remove_bus(struct pci_bus *b);
void pci_stop_and_remove_bus_device(struct pci_dev *dev);
954
void pci_stop_and_remove_bus_device_locked(struct pci_dev *dev);
955 956
void pci_stop_root_bus(struct pci_bus *bus);
void pci_remove_root_bus(struct pci_bus *bus);
957
void pci_setup_cardbus(struct pci_bus *bus);
958
void pcibios_setup_bridge(struct pci_bus *bus, unsigned long type);
959
void pci_sort_breadthfirst(void);
960 961
#define dev_is_pci(d) ((d)->bus == &pci_bus_type)
#define dev_is_pf(d) ((dev_is_pci(d) ? to_pci_dev(d)->is_physfn : false))
Linus Torvalds's avatar
Linus Torvalds committed
962 963 964

/* Generic PCI functions exported to card drivers */

965 966 967 968 969 970 971
enum pci_lost_interrupt_reason {
	PCI_LOST_IRQ_NO_INFORMATION = 0,
	PCI_LOST_IRQ_DISABLE_MSI,
	PCI_LOST_IRQ_DISABLE_MSIX,
	PCI_LOST_IRQ_DISABLE_ACPI,
};
enum pci_lost_interrupt_reason pci_lost_interrupt(struct pci_dev *dev);
972 973 974
int pci_find_capability(struct pci_dev *dev, int cap);
int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap);
int pci_find_ext_capability(struct pci_dev *dev, int cap);
975
int pci_find_next_ext_capability(struct pci_dev *dev, int pos, int cap);
976 977
int pci_find_ht_capability(struct pci_dev *dev, int ht_cap);
int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap);
978
struct pci_bus *pci_find_next_bus(const struct pci_bus *from);
Linus Torvalds's avatar
Linus Torvalds committed
979

980
struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device,
981
			       struct pci_dev *from);
982
struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
983 984
			       unsigned int ss_vendor, unsigned int ss_device,
			       struct pci_dev *from);
985
struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);
986 987
struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
					    unsigned int devfn);
988
struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from);
Linus Torvalds's avatar
Linus Torvalds committed
989 990
int pci_dev_present(const struct pci_device_id *ids);

991 992 993 994 995 996 997 998 999 1000 1001 1002
int pci_bus_read_config_byte(struct pci_bus *bus, unsigned int devfn,
			     int where, u8 *val);
int pci_bus_read_config_word(struct pci_bus *bus, unsigned int devfn,
			     int where, u16 *val);
int pci_bus_read_config_dword(struct pci_bus *bus, unsigned int devfn,
			      int where, u32 *val);
int pci_bus_write_config_byte(struct pci_bus *bus, unsigned int devfn,
			      int where, u8 val);
int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn,
			      int where, u16 val);
int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
			       int where, u32 val);
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012

int pci_generic_config_read(struct pci_bus *bus, unsigned int devfn,
			    int where, int size, u32 *val);
int pci_generic_config_write(struct pci_bus *bus, unsigned int devfn,
			    int where, int size, u32 val);
int pci_generic_config_read32(struct pci_bus *bus, unsigned int devfn,
			      int where, int size, u32 *val);
int pci_generic_config_write32(struct pci_bus *bus, unsigned int devfn,
			       int where, int size, u32 val);

Huang Ying's avatar
Huang Ying committed
1013
struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops);
Linus Torvalds's avatar
Linus Torvalds committed
1014

1015 1016 1017 1018 1019 1020
int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val);
int pci_read_config_word(const struct pci_dev *dev, int where, u16 *val);
int pci_read_config_dword(const struct pci_dev *dev, int where, u32 *val);
int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val);
int pci_write_config_word(const struct pci_dev *dev, int where, u16 val);
int pci_write_config_dword(const struct pci_dev *dev, int where, u32 val);
Linus Torvalds's avatar
Linus Torvalds committed
1021

1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val);
int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val);
int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val);
int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val);
int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos,
				       u16 clear, u16 set);
int pcie_capability_clear_and_set_dword(struct pci_dev *dev, int pos,
					u32 clear, u32 set);

static inline int pcie_capability_set_word(struct pci_dev *dev, int pos,
					   u16 set)
{
	return pcie_capability_clear_and_set_word(dev, pos, 0, set);
}

static inline int pcie_capability_set_dword(struct pci_dev *dev, int pos,
					    u32 set)
{
	return pcie_capability_clear_and_set_dword(dev, pos, 0, set);
}

static inline int pcie_capability_clear_word(struct pci_dev *dev, int pos,
					     u16 clear)
{
	return pcie_capability_clear_and_set_word(dev, pos, clear, 0);
}

static inline int pcie_capability_clear_dword(struct pci_dev *dev, int pos,
					      u32 clear)
{
	return pcie_capability_clear_and_set_dword(dev, pos, clear, 0);
}

1055
/* User-space driven config access */
1056 1057 1058 1059 1060 1061 1062
int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
int pci_user_read_config_dword(struct pci_dev *dev, int where, u32 *val);
int pci_user_write_config_byte(struct pci_dev *dev, int where, u8 val);
int pci_user_write_config_word(struct pci_dev *dev, int where, u16 val);
int pci_user_write_config_dword(struct pci_dev *dev, int where, u32 val);

1063
int __must_check pci_enable_device(struct pci_dev *dev);
1064 1065
int __must_check pci_enable_device_io(struct pci_dev *dev);
int __must_check pci_enable_device_mem(struct pci_dev *dev);
1066
int __must_check pci_reenable_device(struct pci_dev *);
1067 1068 1069
int __must_check pcim_enable_device(struct pci_dev *pdev);
void pcim_pin_device(struct pci_dev *pdev);

1070 1071 1072 1073 1074 1075 1076 1077 1078
static inline bool pci_intx_mask_supported(struct pci_dev *pdev)
{
	/*
	 * INTx masking is supported if PCI_COMMAND_INTX_DISABLE is
	 * writable and no quirk has marked the feature broken.
	 */
	return !pdev->broken_intx_masking;
}

1079 1080 1081 1082 1083
static inline int pci_is_enabled(struct pci_dev *pdev)
{
	return (atomic_read(&pdev->enable_cnt) > 0);
}

1084 1085 1086 1087 1088
static inline int pci_is_managed(struct pci_dev *pdev)
{
	return pdev->is_managed;
}

Linus Torvalds's avatar
Linus Torvalds committed
1089
void pci_disable_device(struct pci_dev *dev);
1090 1091

extern unsigned int pcibios_max_latency;
Linus Torvalds's avatar
Linus Torvalds committed
1092
void pci_set_master(struct pci_dev *dev);
1093
void pci_clear_master(struct pci_dev *dev);
1094

Brian King's avatar
Brian King committed
1095
int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
1096
int pci_set_cacheline_size(struct pci_dev *dev);
Linus Torvalds's avatar
Linus Torvalds committed
1097
#define HAVE_PCI_SET_MWI
1098
int __must_check pci_set_mwi(struct pci_dev *dev);
1099
int __must_check pcim_set_mwi(struct pci_dev *dev);
Randy Dunlap's avatar
Randy Dunlap committed
1100
int pci_try_set_mwi(struct pci_dev *dev);
Linus Torvalds's avatar
Linus Torvalds committed
1101
void pci_clear_mwi(struct pci_dev *dev);
1102
void pci_intx(struct pci_dev *dev, int enable);
1103 1104
bool pci_check_and_mask_intx(struct pci_dev *dev);
bool pci_check_and_unmask_intx(struct pci_dev *dev);
1105
int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask);
1106
int pci_wait_for_pending_transaction(struct pci_dev *dev);
1107 1108 1109
int pcix_get_max_mmrbc(struct pci_dev *dev);
int pcix_get_mmrbc(struct pci_dev *dev);
int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
1110
int pcie_get_readrq(struct pci_dev *dev);
1111
int pcie_set_readrq(struct pci_dev *dev, int rq);
1112 1113
int pcie_get_mps(struct pci_dev *dev);
int pcie_set_mps(struct pci_dev *dev, int mps);
1114 1115 1116
u32 pcie_bandwidth_available(struct pci_dev *dev, struct pci_dev **limiting_dev,
			     enum pci_bus_speed *speed,
			     enum pcie_link_width *width);
1117
void pcie_print_link_status(struct pci_dev *dev);
1118
bool pcie_has_flr(struct pci_dev *dev);
1119
int pcie_flr(struct pci_dev *dev);
1120
int __pci_reset_function_locked(struct pci_dev *dev);
1121
int pci_reset_function(struct pci_dev *dev);
1122
int pci_reset_function_locked(struct pci_dev *dev);
1123
int pci_try_reset_function(struct pci_dev *dev);
1124 1125
int pci_probe_reset_slot(struct pci_slot *slot);
int pci_probe_reset_bus(struct pci_bus *bus);
1126
int pci_reset_bus(struct pci_dev *dev);
1127 1128
void pci_reset_secondary_bus(struct pci_dev *dev);
void pcibios_reset_secondary_bus(struct pci_dev *dev);
1129
void pci_update_resource(struct pci_dev *dev, int resno);
1130
int __must_check pci_assign_resource(struct pci_dev *dev, int i);
1131
int __must_check pci_reassign_resource(struct pci_dev *dev, int i, resource_size_t add_size, resource_size_t align);
1132 1133
void pci_release_resource(struct pci_dev *dev, int resno);
int __must_check pci_resize_resource(struct pci_dev *dev, int i, int size);
1134
int pci_select_bars(struct pci_dev *dev, unsigned long flags);
1135
bool pci_device_is_present(struct pci_dev *pdev);
1136
void pci_ignore_hotplug(struct pci_dev *dev);
Linus Torvalds's avatar
Linus Torvalds committed
1137

1138 1139 1140 1141 1142
int __printf(6, 7) pci_request_irq(struct pci_dev *dev, unsigned int nr,
		irq_handler_t handler, irq_handler_t thread_fn, void *dev_id,
		const char *fmt, ...);
void pci_free_irq(struct pci_dev *dev, unsigned int nr, void *dev_id);

Linus Torvalds's avatar
Linus Torvalds committed
1143
/* ROM control related routines */
1144 1145
int pci_enable_rom(struct pci_dev *pdev);
void pci_disable_rom(struct pci_dev *pdev);
1146
void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
Linus Torvalds's avatar
Linus Torvalds committed
1147
void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
1148
void __iomem __must_check *pci_platform_rom(struct pci_dev *pdev, size_t *size);
Linus Torvalds's avatar
Linus Torvalds committed
1149 1150 1151

/* Power management related routines */
int pci_save_state(struct pci_dev *dev);
1152
void pci_restore_state(struct pci_dev *dev);
1153
struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
1154 1155
int pci_load_saved_state(struct pci_dev *dev,
			 struct pci_saved_state *state);
1156 1157
int pci_load_and_free_saved_state(struct pci_dev *dev,
				  struct pci_saved_state **state);
1158 1159 1160 1161 1162 1163
struct pci_cap_saved_state *pci_find_saved_cap(struct pci_dev *dev, char cap);
struct pci_cap_saved_state *pci_find_saved_ext_cap(struct pci_dev *dev,
						   u16 cap);
int pci_add_cap_save_buffer(struct pci_dev *dev, char cap, unsigned int size);
int pci_add_ext_cap_save_buffer(struct pci_dev *dev,
				u16 cap, unsigned int size);
1164
int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state);
1165 1166
int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
1167
bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
1168
void pci_pme_active(struct pci_dev *dev, bool enable);
1169
int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable);
1170
int pci_wake_from_d3(struct pci_dev *dev, bool enable);
1171 1172
int pci_prepare_to_sleep(struct pci_dev *dev);
int pci_back_from_sleep(struct pci_dev *dev);
1173
bool pci_dev_run_wake(struct pci_dev *dev);
1174 1175
bool pci_check_pme_status(struct pci_dev *dev);
void pci_pme_wakeup_bus(struct pci_bus *bus);
1176 1177
void pci_d3cold_enable(struct pci_dev *dev);
void pci_d3cold_disable(struct pci_dev *dev);
1178
bool pcie_relaxed_ordering_enabled(struct pci_dev *dev);
1179 1180
void pci_wakeup_bus(struct pci_bus *bus);
void pci_bus_set_current_state(struct pci_bus *bus, pci_power_t state);
Linus Torvalds's avatar
Linus Torvalds committed
1181

1182 1183 1184 1185
/* PCI Virtual Channel */
int pci_save_vc_state(struct pci_dev *dev);
void pci_restore_vc_state(struct pci_dev *dev);
void pci_allocate_vc_save_buffers(struct pci_dev *dev);
1186

1187 1188 1189 1190
/* For use by arch with custom probe code */
void set_pcie_port_type(struct pci_dev *pdev);
void set_pcie_hotplug_bridge(struct pci_dev *pdev);

1191
/* Functions for PCI Hotplug drivers to use */
1192
int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
1193
unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge);
1194
unsigned int pci_rescan_bus(struct pci_bus *bus);
1195 1196
void pci_lock_rescan_remove(void);
void pci_unlock_rescan_remove(void);
1197

1198
/* Vital Product Data routines */
1199 1200
ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void *buf);
1201
int pci_set_vpd_size(struct pci_dev *dev, size_t len);
1202