probe.c 48.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11
/*
 * probe.c - PCI detection and setup code
 */

#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/cpumask.h>
12
#include <linux/pci-aspm.h>
13
#include <asm-generic/pci-bridge.h>
14
#include "pci.h"
Linus Torvalds's avatar
Linus Torvalds committed
15 16 17 18

#define CARDBUS_LATENCY_TIMER	176	/* secondary latency timer */
#define CARDBUS_RESERVE_BUSNR	3

Yinghai Lu's avatar
Yinghai Lu committed
19 20 21 22 23 24 25
struct resource busn_resource = {
	.name	= "PCI busn",
	.start	= 0,
	.end	= 255,
	.flags	= IORESOURCE_BUS,
};

Linus Torvalds's avatar
Linus Torvalds committed
26 27 28 29
/* Ugh.  Need to stop exporting this to modules. */
LIST_HEAD(pci_root_buses);
EXPORT_SYMBOL(pci_root_buses);

30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
static LIST_HEAD(pci_domain_busn_res_list);

struct pci_domain_busn_res {
	struct list_head list;
	struct resource res;
	int domain_nr;
};

static struct resource *get_pci_domain_busn_res(int domain_nr)
{
	struct pci_domain_busn_res *r;

	list_for_each_entry(r, &pci_domain_busn_res_list, list)
		if (r->domain_nr == domain_nr)
			return &r->res;

	r = kzalloc(sizeof(*r), GFP_KERNEL);
	if (!r)
		return NULL;

	r->domain_nr = domain_nr;
	r->res.start = 0;
	r->res.end = 0xff;
	r->res.flags = IORESOURCE_BUS | IORESOURCE_PCI_FIXED;

	list_add_tail(&r->list, &pci_domain_busn_res_list);

	return &r->res;
}

60 61 62 63
static int find_anything(struct device *dev, void *data)
{
	return 1;
}
Linus Torvalds's avatar
Linus Torvalds committed
64

Zhang, Yanmin's avatar
Zhang, Yanmin committed
65 66 67
/*
 * Some device drivers need know if pci is initiated.
 * Basically, we think pci is not initiated when there
68
 * is no device to be found on the pci_bus_type.
Zhang, Yanmin's avatar
Zhang, Yanmin committed
69 70 71
 */
int no_pci_devices(void)
{
72 73
	struct device *dev;
	int no_devices;
Zhang, Yanmin's avatar
Zhang, Yanmin committed
74

75 76 77 78 79
	dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
	no_devices = (dev == NULL);
	put_device(dev);
	return no_devices;
}
Zhang, Yanmin's avatar
Zhang, Yanmin committed
80 81
EXPORT_SYMBOL(no_pci_devices);

Linus Torvalds's avatar
Linus Torvalds committed
82 83 84
/*
 * PCI Bus Class
 */
85
static void release_pcibus_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
86
{
87
	struct pci_bus *pci_bus = to_pci_bus(dev);
Linus Torvalds's avatar
Linus Torvalds committed
88 89 90

	if (pci_bus->bridge)
		put_device(pci_bus->bridge);
91
	pci_bus_remove_resources(pci_bus);
92
	pci_release_bus_of_node(pci_bus);
Linus Torvalds's avatar
Linus Torvalds committed
93 94 95 96 97
	kfree(pci_bus);
}

static struct class pcibus_class = {
	.name		= "pci_bus",
98
	.dev_release	= &release_pcibus_dev,
99
	.dev_attrs	= pcibus_dev_attrs,
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103 104 105 106 107
};

static int __init pcibus_class_init(void)
{
	return class_register(&pcibus_class);
}
postcore_initcall(pcibus_class_init);

108
static u64 pci_size(u64 base, u64 maxbase, u64 mask)
Linus Torvalds's avatar
Linus Torvalds committed
109
{
110
	u64 size = mask & maxbase;	/* Find the significant bits */
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
	if (!size)
		return 0;

	/* Get the lowest of them to find the decode size, and
	   from that the extent.  */
	size = (size & ~(size-1)) - 1;

	/* base == maxbase can be valid only if the BAR has
	   already been programmed with all 1s.  */
	if (base == maxbase && ((base | size) & mask) != mask)
		return 0;

	return size;
}

126
static inline unsigned long decode_bar(struct pci_dev *dev, u32 bar)
127
{
128
	u32 mem_type;
129
	unsigned long flags;
130

131
	if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
132 133 134
		flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
		flags |= IORESOURCE_IO;
		return flags;
135
	}
136

137 138 139 140
	flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
	flags |= IORESOURCE_MEM;
	if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
		flags |= IORESOURCE_PREFETCH;
141

142 143 144 145 146 147 148 149
	mem_type = bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
	switch (mem_type) {
	case PCI_BASE_ADDRESS_MEM_TYPE_32:
		break;
	case PCI_BASE_ADDRESS_MEM_TYPE_1M:
		dev_info(&dev->dev, "1M mem BAR treated as 32-bit BAR\n");
		break;
	case PCI_BASE_ADDRESS_MEM_TYPE_64:
150 151
		flags |= IORESOURCE_MEM_64;
		break;
152 153 154 155 156 157
	default:
		dev_warn(&dev->dev,
			 "mem unknown type %x treated as 32-bit BAR\n",
			 mem_type);
		break;
	}
158
	return flags;
159 160
}

Yu Zhao's avatar
Yu Zhao committed
161 162 163 164 165 166 167 168
/**
 * pci_read_base - read a PCI BAR
 * @dev: the PCI device
 * @type: type of the BAR
 * @res: resource buffer to be filled in
 * @pos: BAR position in the config space
 *
 * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
169
 */
Yu Zhao's avatar
Yu Zhao committed
170
int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
171
			struct resource *res, unsigned int pos)
172
{
173
	u32 l, sz, mask;
174
	u16 orig_cmd;
175
	struct pci_bus_region region;
176

177
	mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
178

179 180 181 182 183 184
	if (!dev->mmio_always_on) {
		pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
		pci_write_config_word(dev, PCI_COMMAND,
			orig_cmd & ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO));
	}

185 186 187
	res->name = pci_name(dev);

	pci_read_config_dword(dev, pos, &l);
188
	pci_write_config_dword(dev, pos, l | mask);
189 190 191 192 193
	pci_read_config_dword(dev, pos, &sz);
	pci_write_config_dword(dev, pos, l);

	/*
	 * All bits set in sz means the device isn't working properly.
194 195 196
	 * If the BAR isn't implemented, all bits must be 0.  If it's a
	 * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
	 * 1 must be clear.
197
	 */
198
	if (!sz || sz == 0xffffffff)
199 200 201 202 203 204 205 206 207 208
		goto fail;

	/*
	 * I don't know how l can have all bits set.  Copied from old code.
	 * Maybe it fixes a bug on some ancient platform.
	 */
	if (l == 0xffffffff)
		l = 0;

	if (type == pci_bar_unknown) {
209 210 211
		res->flags = decode_bar(dev, l);
		res->flags |= IORESOURCE_SIZEALIGN;
		if (res->flags & IORESOURCE_IO) {
212
			l &= PCI_BASE_ADDRESS_IO_MASK;
213
			mask = PCI_BASE_ADDRESS_IO_MASK & (u32) IO_SPACE_LIMIT;
214 215 216 217 218 219 220 221 222 223
		} else {
			l &= PCI_BASE_ADDRESS_MEM_MASK;
			mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
		}
	} else {
		res->flags |= (l & IORESOURCE_ROM_ENABLE);
		l &= PCI_ROM_ADDRESS_MASK;
		mask = (u32)PCI_ROM_ADDRESS_MASK;
	}

224
	if (res->flags & IORESOURCE_MEM_64) {
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
		u64 l64 = l;
		u64 sz64 = sz;
		u64 mask64 = mask | (u64)~0 << 32;

		pci_read_config_dword(dev, pos + 4, &l);
		pci_write_config_dword(dev, pos + 4, ~0);
		pci_read_config_dword(dev, pos + 4, &sz);
		pci_write_config_dword(dev, pos + 4, l);

		l64 |= ((u64)l << 32);
		sz64 |= ((u64)sz << 32);

		sz64 = pci_size(l64, sz64, mask64);

		if (!sz64)
			goto fail;

242
		if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
243 244
			dev_err(&dev->dev, "reg %x: can't handle 64-bit BAR\n",
				pos);
245
			goto fail;
246 247 248
		}

		if ((sizeof(resource_size_t) < 8) && l) {
249 250 251
			/* Address above 32-bit boundary; disable the BAR */
			pci_write_config_dword(dev, pos, 0);
			pci_write_config_dword(dev, pos + 4, 0);
252 253
			region.start = 0;
			region.end = sz64;
254
			pcibios_bus_to_resource(dev, res, &region);
255
		} else {
256 257
			region.start = l64;
			region.end = l64 + sz64;
258
			pcibios_bus_to_resource(dev, res, &region);
259
			dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n",
260
				   pos, res);
261 262
		}
	} else {
263
		sz = pci_size(l, sz, mask);
264

265
		if (!sz)
266 267
			goto fail;

268 269
		region.start = l;
		region.end = l + sz;
270
		pcibios_bus_to_resource(dev, res, &region);
271

272
		dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
273 274 275
	}

 out:
276 277 278
	if (!dev->mmio_always_on)
		pci_write_config_word(dev, PCI_COMMAND, orig_cmd);

279
	return (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
280 281 282
 fail:
	res->flags = 0;
	goto out;
283 284
}

Linus Torvalds's avatar
Linus Torvalds committed
285 286
static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
{
287
	unsigned int pos, reg;
288

289 290
	for (pos = 0; pos < howmany; pos++) {
		struct resource *res = &dev->resource[pos];
Linus Torvalds's avatar
Linus Torvalds committed
291
		reg = PCI_BASE_ADDRESS_0 + (pos << 2);
292
		pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
Linus Torvalds's avatar
Linus Torvalds committed
293
	}
294

Linus Torvalds's avatar
Linus Torvalds committed
295
	if (rom) {
296
		struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
Linus Torvalds's avatar
Linus Torvalds committed
297
		dev->rom_base_reg = rom;
298 299 300 301
		res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
				IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
				IORESOURCE_SIZEALIGN;
		__pci_read_base(dev, pci_bar_mem32, res, rom);
Linus Torvalds's avatar
Linus Torvalds committed
302 303 304
	}
}

305
static void __devinit pci_read_bridge_io(struct pci_bus *child)
Linus Torvalds's avatar
Linus Torvalds committed
306 307 308
{
	struct pci_dev *dev = child->self;
	u8 io_base_lo, io_limit_lo;
309
	unsigned long io_mask, io_granularity, base, limit;
310
	struct pci_bus_region region;
311 312 313 314 315 316 317 318 319
	struct resource *res;

	io_mask = PCI_IO_RANGE_MASK;
	io_granularity = 0x1000;
	if (dev->io_window_1k) {
		/* Support 1K I/O space granularity */
		io_mask = PCI_IO_1K_RANGE_MASK;
		io_granularity = 0x400;
	}
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322 323

	res = child->resource[0];
	pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
	pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
324 325
	base = (io_base_lo & io_mask) << 8;
	limit = (io_limit_lo & io_mask) << 8;
Linus Torvalds's avatar
Linus Torvalds committed
326 327 328

	if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
		u16 io_base_hi, io_limit_hi;
329

Linus Torvalds's avatar
Linus Torvalds committed
330 331
		pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
		pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
332 333
		base |= ((unsigned long) io_base_hi << 16);
		limit |= ((unsigned long) io_limit_hi << 16);
Linus Torvalds's avatar
Linus Torvalds committed
334 335
	}

336
	if (base <= limit) {
Linus Torvalds's avatar
Linus Torvalds committed
337
		res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
338
		region.start = base;
339 340
		region.end = limit + io_granularity - 1;
		pcibios_bus_to_resource(dev, res, &region);
341
		dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
Linus Torvalds's avatar
Linus Torvalds committed
342
	}
343 344 345 346 347 348 349
}

static void __devinit pci_read_bridge_mmio(struct pci_bus *child)
{
	struct pci_dev *dev = child->self;
	u16 mem_base_lo, mem_limit_lo;
	unsigned long base, limit;
350
	struct pci_bus_region region;
351
	struct resource *res;
Linus Torvalds's avatar
Linus Torvalds committed
352 353 354 355

	res = child->resource[1];
	pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
	pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
356 357
	base = ((unsigned long) mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
	limit = ((unsigned long) mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
358
	if (base <= limit) {
Linus Torvalds's avatar
Linus Torvalds committed
359
		res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
360 361
		region.start = base;
		region.end = limit + 0xfffff;
362
		pcibios_bus_to_resource(dev, res, &region);
363
		dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
Linus Torvalds's avatar
Linus Torvalds committed
364
	}
365 366 367 368 369 370 371
}

static void __devinit pci_read_bridge_mmio_pref(struct pci_bus *child)
{
	struct pci_dev *dev = child->self;
	u16 mem_base_lo, mem_limit_lo;
	unsigned long base, limit;
372
	struct pci_bus_region region;
373
	struct resource *res;
Linus Torvalds's avatar
Linus Torvalds committed
374 375 376 377

	res = child->resource[2];
	pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
	pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
378 379
	base = ((unsigned long) mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
	limit = ((unsigned long) mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
Linus Torvalds's avatar
Linus Torvalds committed
380 381 382

	if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
		u32 mem_base_hi, mem_limit_hi;
383

Linus Torvalds's avatar
Linus Torvalds committed
384 385 386 387 388 389 390 391 392 393
		pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
		pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);

		/*
		 * Some bridges set the base > limit by default, and some
		 * (broken) BIOSes do not initialize them.  If we find
		 * this, just assume they are not being used.
		 */
		if (mem_base_hi <= mem_limit_hi) {
#if BITS_PER_LONG == 64
394 395
			base |= ((unsigned long) mem_base_hi) << 32;
			limit |= ((unsigned long) mem_limit_hi) << 32;
Linus Torvalds's avatar
Linus Torvalds committed
396 397
#else
			if (mem_base_hi || mem_limit_hi) {
398 399
				dev_err(&dev->dev, "can't handle 64-bit "
					"address space for bridge\n");
Linus Torvalds's avatar
Linus Torvalds committed
400 401 402 403 404
				return;
			}
#endif
		}
	}
405
	if (base <= limit) {
406 407 408 409
		res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
					 IORESOURCE_MEM | IORESOURCE_PREFETCH;
		if (res->flags & PCI_PREF_RANGE_TYPE_64)
			res->flags |= IORESOURCE_MEM_64;
410 411
		region.start = base;
		region.end = limit + 0xfffff;
412
		pcibios_bus_to_resource(dev, res, &region);
413
		dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
Linus Torvalds's avatar
Linus Torvalds committed
414 415 416
	}
}

417 418 419
void __devinit pci_read_bridge_bases(struct pci_bus *child)
{
	struct pci_dev *dev = child->self;
420
	struct resource *res;
421 422 423 424 425
	int i;

	if (pci_is_root_bus(child))	/* It's a host bus, nothing to read */
		return;

426 427
	dev_info(&dev->dev, "PCI bridge to %pR%s\n",
		 &child->busn_res,
428 429
		 dev->transparent ? " (subtractive decode)" : "");

430 431 432 433
	pci_bus_remove_resources(child);
	for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
		child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];

434 435 436
	pci_read_bridge_io(child);
	pci_read_bridge_mmio(child);
	pci_read_bridge_mmio_pref(child);
437 438

	if (dev->transparent) {
439 440 441 442
		pci_bus_for_each_resource(child->parent, res, i) {
			if (res) {
				pci_bus_add_resource(child, res,
						     PCI_SUBTRACTIVE_DECODE);
443 444
				dev_printk(KERN_DEBUG, &dev->dev,
					   "  bridge window %pR (subtractive decode)\n",
445 446
					   res);
			}
447 448
		}
	}
449 450
}

451
static struct pci_bus * pci_alloc_bus(void)
Linus Torvalds's avatar
Linus Torvalds committed
452 453 454
{
	struct pci_bus *b;

455
	b = kzalloc(sizeof(*b), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459
	if (b) {
		INIT_LIST_HEAD(&b->node);
		INIT_LIST_HEAD(&b->children);
		INIT_LIST_HEAD(&b->devices);
Alex Chiang's avatar
Alex Chiang committed
460
		INIT_LIST_HEAD(&b->slots);
461
		INIT_LIST_HEAD(&b->resources);
462 463
		b->max_bus_speed = PCI_SPEED_UNKNOWN;
		b->cur_bus_speed = PCI_SPEED_UNKNOWN;
Linus Torvalds's avatar
Linus Torvalds committed
464 465 466 467
	}
	return b;
}

468 469 470 471 472 473 474 475 476 477 478 479 480
static struct pci_host_bridge *pci_alloc_host_bridge(struct pci_bus *b)
{
	struct pci_host_bridge *bridge;

	bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
	if (bridge) {
		INIT_LIST_HEAD(&bridge->windows);
		bridge->bus = b;
	}

	return bridge;
}

481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
static unsigned char pcix_bus_speed[] = {
	PCI_SPEED_UNKNOWN,		/* 0 */
	PCI_SPEED_66MHz_PCIX,		/* 1 */
	PCI_SPEED_100MHz_PCIX,		/* 2 */
	PCI_SPEED_133MHz_PCIX,		/* 3 */
	PCI_SPEED_UNKNOWN,		/* 4 */
	PCI_SPEED_66MHz_PCIX_ECC,	/* 5 */
	PCI_SPEED_100MHz_PCIX_ECC,	/* 6 */
	PCI_SPEED_133MHz_PCIX_ECC,	/* 7 */
	PCI_SPEED_UNKNOWN,		/* 8 */
	PCI_SPEED_66MHz_PCIX_266,	/* 9 */
	PCI_SPEED_100MHz_PCIX_266,	/* A */
	PCI_SPEED_133MHz_PCIX_266,	/* B */
	PCI_SPEED_UNKNOWN,		/* C */
	PCI_SPEED_66MHz_PCIX_533,	/* D */
	PCI_SPEED_100MHz_PCIX_533,	/* E */
	PCI_SPEED_133MHz_PCIX_533	/* F */
};

500 501 502 503
static unsigned char pcie_link_speed[] = {
	PCI_SPEED_UNKNOWN,		/* 0 */
	PCIE_SPEED_2_5GT,		/* 1 */
	PCIE_SPEED_5_0GT,		/* 2 */
504
	PCIE_SPEED_8_0GT,		/* 3 */
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
	PCI_SPEED_UNKNOWN,		/* 4 */
	PCI_SPEED_UNKNOWN,		/* 5 */
	PCI_SPEED_UNKNOWN,		/* 6 */
	PCI_SPEED_UNKNOWN,		/* 7 */
	PCI_SPEED_UNKNOWN,		/* 8 */
	PCI_SPEED_UNKNOWN,		/* 9 */
	PCI_SPEED_UNKNOWN,		/* A */
	PCI_SPEED_UNKNOWN,		/* B */
	PCI_SPEED_UNKNOWN,		/* C */
	PCI_SPEED_UNKNOWN,		/* D */
	PCI_SPEED_UNKNOWN,		/* E */
	PCI_SPEED_UNKNOWN		/* F */
};

void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
{
	bus->cur_bus_speed = pcie_link_speed[linksta & 0xf];
}
EXPORT_SYMBOL_GPL(pcie_update_link_speed);

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
static unsigned char agp_speeds[] = {
	AGP_UNKNOWN,
	AGP_1X,
	AGP_2X,
	AGP_4X,
	AGP_8X
};

static enum pci_bus_speed agp_speed(int agp3, int agpstat)
{
	int index = 0;

	if (agpstat & 4)
		index = 3;
	else if (agpstat & 2)
		index = 2;
	else if (agpstat & 1)
		index = 1;
	else
		goto out;
	
	if (agp3) {
		index += 2;
		if (index == 5)
			index = 0;
	}

 out:
	return agp_speeds[index];
}


557 558 559 560 561
static void pci_set_bus_speed(struct pci_bus *bus)
{
	struct pci_dev *bridge = bus->self;
	int pos;

562 563 564 565 566 567 568 569 570 571 572 573 574
	pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
	if (!pos)
		pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
	if (pos) {
		u32 agpstat, agpcmd;

		pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
		bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);

		pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
		bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
	}

575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
	pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
	if (pos) {
		u16 status;
		enum pci_bus_speed max;
		pci_read_config_word(bridge, pos + 2, &status);

		if (status & 0x8000) {
			max = PCI_SPEED_133MHz_PCIX_533;
		} else if (status & 0x4000) {
			max = PCI_SPEED_133MHz_PCIX_266;
		} else if (status & 0x0002) {
			if (((status >> 12) & 0x3) == 2) {
				max = PCI_SPEED_133MHz_PCIX_ECC;
			} else {
				max = PCI_SPEED_133MHz_PCIX;
			}
		} else {
			max = PCI_SPEED_66MHz_PCIX;
		}

		bus->max_bus_speed = max;
		bus->cur_bus_speed = pcix_bus_speed[(status >> 6) & 0xf];

		return;
	}

	pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
	if (pos) {
		u32 linkcap;
		u16 linksta;

		pci_read_config_dword(bridge, pos + PCI_EXP_LNKCAP, &linkcap);
		bus->max_bus_speed = pcie_link_speed[linkcap & 0xf];

		pci_read_config_word(bridge, pos + PCI_EXP_LNKSTA, &linksta);
		pcie_update_link_speed(bus, linksta);
	}
}


615 616
static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
					   struct pci_dev *bridge, int busnr)
Linus Torvalds's avatar
Linus Torvalds committed
617 618 619 620 621 622 623 624 625 626 627 628 629 630
{
	struct pci_bus *child;
	int i;

	/*
	 * Allocate a new bus, and inherit stuff from the parent..
	 */
	child = pci_alloc_bus();
	if (!child)
		return NULL;

	child->parent = parent;
	child->ops = parent->ops;
	child->sysdata = parent->sysdata;
631
	child->bus_flags = parent->bus_flags;
Linus Torvalds's avatar
Linus Torvalds committed
632

633 634 635 636 637
	/* initialize some portions of the bus device, but don't register it
	 * now as the parent is not properly set up yet.  This device will get
	 * registered later in pci_bus_add_devices()
	 */
	child->dev.class = &pcibus_class;
638
	dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
Linus Torvalds's avatar
Linus Torvalds committed
639 640 641 642 643

	/*
	 * Set up the primary, secondary and subordinate
	 * bus numbers.
	 */
644 645 646
	child->number = child->busn_res.start = busnr;
	child->primary = parent->busn_res.start;
	child->busn_res.end = 0xff;
Linus Torvalds's avatar
Linus Torvalds committed
647

648 649 650 651 652
	if (!bridge)
		return child;

	child->self = bridge;
	child->bridge = get_device(&bridge->dev);
653
	pci_set_bus_of_node(child);
654 655
	pci_set_bus_speed(child);

Linus Torvalds's avatar
Linus Torvalds committed
656
	/* Set up default resource pointers and names.. */
657
	for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
658 659 660 661 662 663 664 665
		child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
		child->resource[i]->name = child->name;
	}
	bridge->subordinate = child;

	return child;
}

666
struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
Linus Torvalds's avatar
Linus Torvalds committed
667 668 669 670
{
	struct pci_bus *child;

	child = pci_alloc_child_bus(parent, dev, busnr);
671
	if (child) {
672
		down_write(&pci_bus_sem);
Linus Torvalds's avatar
Linus Torvalds committed
673
		list_add_tail(&child->node, &parent->children);
674
		up_write(&pci_bus_sem);
675
	}
Linus Torvalds's avatar
Linus Torvalds committed
676 677 678
	return child;
}

679
static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
680 681
{
	struct pci_bus *parent = child->parent;
682 683 684 685 686 687

	/* Attempts to fix that up are really dangerous unless
	   we're going to re-assign all bus numbers. */
	if (!pcibios_assign_all_busses())
		return;

688 689
	while (parent->parent && parent->busn_res.end < max) {
		parent->busn_res.end = max;
690 691 692 693 694
		pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
		parent = parent->parent;
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
695 696 697 698 699 700 701 702 703 704
/*
 * If it's a bridge, configure it and scan the bus behind it.
 * For CardBus bridges, we don't scan behind as the devices will
 * be handled by the bridge driver itself.
 *
 * We need to process bridges in two passes -- first we scan those
 * already configured by the BIOS and after we are done with all of
 * them, we proceed to assigning numbers to the remaining buses in
 * order to avoid overlaps between old and new bus numbers.
 */
705
int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
Linus Torvalds's avatar
Linus Torvalds committed
706 707 708
{
	struct pci_bus *child;
	int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
709
	u32 buses, i, j = 0;
Linus Torvalds's avatar
Linus Torvalds committed
710
	u16 bctl;
711
	u8 primary, secondary, subordinate;
712
	int broken = 0;
Linus Torvalds's avatar
Linus Torvalds committed
713 714

	pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
715 716 717
	primary = buses & 0xFF;
	secondary = (buses >> 8) & 0xFF;
	subordinate = (buses >> 16) & 0xFF;
Linus Torvalds's avatar
Linus Torvalds committed
718

719 720
	dev_dbg(&dev->dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
		secondary, subordinate, pass);
Linus Torvalds's avatar
Linus Torvalds committed
721

722 723 724 725 726
	if (!primary && (primary != bus->number) && secondary && subordinate) {
		dev_warn(&dev->dev, "Primary bus is hard wired to 0\n");
		primary = bus->number;
	}

727 728
	/* Check if setup is sensible at all */
	if (!pass &&
729
	    (primary != bus->number || secondary <= bus->number)) {
730 731 732 733
		dev_dbg(&dev->dev, "bus configuration invalid, reconfiguring\n");
		broken = 1;
	}

Linus Torvalds's avatar
Linus Torvalds committed
734 735 736 737 738 739
	/* Disable MasterAbortMode during probing to avoid reporting
	   of bus errors (in some architectures) */ 
	pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
	pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
			      bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);

740 741 742
	if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
	    !is_cardbus && !broken) {
		unsigned int cmax;
Linus Torvalds's avatar
Linus Torvalds committed
743 744 745 746 747
		/*
		 * Bus already configured by firmware, process it in the first
		 * pass and just note the configuration.
		 */
		if (pass)
748
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
749 750 751

		/*
		 * If we already got to this bus through a different bridge,
Alex Chiang's avatar
Alex Chiang committed
752 753 754 755
		 * don't re-add it. This can happen with the i450NX chipset.
		 *
		 * However, we continue to descend down the hierarchy and
		 * scan remaining child buses.
Linus Torvalds's avatar
Linus Torvalds committed
756
		 */
757
		child = pci_find_bus(pci_domain_nr(bus), secondary);
Alex Chiang's avatar
Alex Chiang committed
758
		if (!child) {
759
			child = pci_add_new_bus(bus, dev, secondary);
Alex Chiang's avatar
Alex Chiang committed
760 761
			if (!child)
				goto out;
762
			child->primary = primary;
763
			pci_bus_insert_busn_res(child, secondary, subordinate);
Alex Chiang's avatar
Alex Chiang committed
764
			child->bridge_ctl = bctl;
Linus Torvalds's avatar
Linus Torvalds committed
765 766 767 768 769
		}

		cmax = pci_scan_child_bus(child);
		if (cmax > max)
			max = cmax;
770 771
		if (child->busn_res.end > max)
			max = child->busn_res.end;
Linus Torvalds's avatar
Linus Torvalds committed
772 773 774 775 776
	} else {
		/*
		 * We need to assign a number to this bus which we always
		 * do in the second pass.
		 */
777
		if (!pass) {
778
			if (pcibios_assign_all_busses() || broken)
779 780 781 782 783 784 785 786
				/* Temporarily disable forwarding of the
				   configuration cycles on all bridges in
				   this bus segment to avoid possible
				   conflicts in the second pass between two
				   bridges programmed with overlapping
				   bus ranges. */
				pci_write_config_dword(dev, PCI_PRIMARY_BUS,
						       buses & ~0xffffff);
787
			goto out;
788
		}
Linus Torvalds's avatar
Linus Torvalds committed
789 790 791 792

		/* Clear errors */
		pci_write_config_word(dev, PCI_STATUS, 0xffff);

793
		/* Prevent assigning a bus number that already exists.
794 795 796 797 798 799 800
		 * This can happen when a bridge is hot-plugged, so in
		 * this case we only re-scan this bus. */
		child = pci_find_bus(pci_domain_nr(bus), max+1);
		if (!child) {
			child = pci_add_new_bus(bus, dev, ++max);
			if (!child)
				goto out;
801
			pci_bus_insert_busn_res(child, max, 0xff);
802
		}
Linus Torvalds's avatar
Linus Torvalds committed
803 804
		buses = (buses & 0xff000000)
		      | ((unsigned int)(child->primary)     <<  0)
805 806
		      | ((unsigned int)(child->busn_res.start)   <<  8)
		      | ((unsigned int)(child->busn_res.end) << 16);
Linus Torvalds's avatar
Linus Torvalds committed
807 808 809 810 811 812 813 814 815

		/*
		 * yenta.c forces a secondary latency timer of 176.
		 * Copy that behaviour here.
		 */
		if (is_cardbus) {
			buses &= ~0xff000000;
			buses |= CARDBUS_LATENCY_TIMER << 24;
		}
816

Linus Torvalds's avatar
Linus Torvalds committed
817 818 819 820 821 822
		/*
		 * We need to blast all three values with a single write.
		 */
		pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);

		if (!is_cardbus) {
823
			child->bridge_ctl = bctl;
824 825 826 827 828 829 830
			/*
			 * Adjust subordinate busnr in parent buses.
			 * We do this before scanning for children because
			 * some devices may not be detected if the bios
			 * was lazy.
			 */
			pci_fixup_parent_subordinate_busnr(child, max);
Linus Torvalds's avatar
Linus Torvalds committed
831 832
			/* Now we can scan all subordinate buses... */
			max = pci_scan_child_bus(child);
833 834 835 836 837
			/*
			 * now fix it up again since we have found
			 * the real value of max.
			 */
			pci_fixup_parent_subordinate_busnr(child, max);
Linus Torvalds's avatar
Linus Torvalds committed
838 839 840 841 842 843
		} else {
			/*
			 * For CardBus bridges, we leave 4 bus numbers
			 * as cards with a PCI-to-PCI bridge can be
			 * inserted later.
			 */
844 845
			for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
				struct pci_bus *parent = bus;
846 847 848
				if (pci_find_bus(pci_domain_nr(bus),
							max+i+1))
					break;
849 850
				while (parent->parent) {
					if ((!pcibios_assign_all_busses()) &&
851 852
					    (parent->busn_res.end > max) &&
					    (parent->busn_res.end <= max+i)) {
853 854 855 856 857 858 859 860 861 862 863 864 865 866
						j = 1;
					}
					parent = parent->parent;
				}
				if (j) {
					/*
					 * Often, there are two cardbus bridges
					 * -- try to leave one valid bus number
					 * for each one.
					 */
					i /= 2;
					break;
				}
			}
867
			max += i;
868
			pci_fixup_parent_subordinate_busnr(child, max);
Linus Torvalds's avatar
Linus Torvalds committed
869 870 871 872
		}
		/*
		 * Set the subordinate bus number to its real value.
		 */
873
		pci_bus_update_busn_res_end(child, max);
Linus Torvalds's avatar
Linus Torvalds committed
874 875 876
		pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
	}

877 878 879
	sprintf(child->name,
		(is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
		pci_domain_nr(bus), child->number);
Linus Torvalds's avatar
Linus Torvalds committed
880

881
	/* Has only triggered on CardBus, fixup is in yenta_socket */
882
	while (bus->parent) {
883 884
		if ((child->busn_res.end > bus->busn_res.end) ||
		    (child->number > bus->busn_res.end) ||
885
		    (child->number < bus->number) ||
886 887 888 889 890 891
		    (child->busn_res.end < bus->number)) {
			dev_info(&child->dev, "%pR %s "
				"hidden behind%s bridge %s %pR\n",
				&child->busn_res,
				(bus->number > child->busn_res.end &&
				 bus->busn_res.end < child->number) ?
892 893
					"wholly" : "partially",
				bus->self->transparent ? " transparent" : "",
894
				dev_name(&bus->dev),
895
				&bus->busn_res);
896 897 898 899
		}
		bus = bus->parent;
	}

900 901 902
out:
	pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);

Linus Torvalds's avatar
Linus Torvalds committed
903 904 905 906 907 908 909 910 911 912 913 914
	return max;
}

/*
 * Read interrupt line and base address registers.
 * The architecture-dependent code can tweak these, of course.
 */
static void pci_read_irq(struct pci_dev *dev)
{
	unsigned char irq;

	pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
915
	dev->pin = irq;
Linus Torvalds's avatar
Linus Torvalds committed
916 917 918 919 920
	if (irq)
		pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
	dev->irq = irq;
}

921
void set_pcie_port_type(struct pci_dev *pdev)
Yu Zhao's avatar
Yu Zhao committed
922 923 924 925 926 927 928 929
{
	int pos;
	u16 reg16;

	pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
	if (!pos)
		return;
	pdev->is_pcie = 1;
930
	pdev->pcie_cap = pos;
Yu Zhao's avatar
Yu Zhao committed
931 932
	pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
	pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
933 934
	pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, &reg16);
	pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
Yu Zhao's avatar
Yu Zhao committed
935 936
}

937
void set_pcie_hotplug_bridge(struct pci_dev *pdev)
938 939 940 941 942
{
	int pos;
	u16 reg16;
	u32 reg32;

943
	pos = pci_pcie_cap(pdev);
944 945 946 947 948 949 950 951 952 953
	if (!pos)
		return;
	pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
	if (!(reg16 & PCI_EXP_FLAGS_SLOT))
		return;
	pci_read_config_dword(pdev, pos + PCI_EXP_SLTCAP, &reg32);
	if (reg32 & PCI_EXP_SLTCAP_HPC)
		pdev->is_hotplug_bridge = 1;
}

954
#define LEGACY_IO_RESOURCE	(IORESOURCE_IO | IORESOURCE_PCI_FIXED)
955

Linus Torvalds's avatar
Linus Torvalds committed
956 957 958 959 960 961 962
/**
 * pci_setup_device - fill in class and map information of a device
 * @dev: the device structure to fill
 *
 * Initialize the device structure with information about the device's 
 * vendor,class,memory and IO-space addresses,IRQ lines etc.
 * Called at initialisation of the PCI subsystem and by CardBus services.
Yu Zhao's avatar
Yu Zhao committed
963 964
 * Returns 0 on success and negative if unknown type of device (not normal,
 * bridge or CardBus).
Linus Torvalds's avatar
Linus Torvalds committed
965
 */
Yu Zhao's avatar
Yu Zhao committed
966
int pci_setup_device(struct pci_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
967 968
{
	u32 class;
Yu Zhao's avatar
Yu Zhao committed
969 970
	u8 hdr_type;
	struct pci_slot *slot;
971
	int pos = 0;
972 973
	struct pci_bus_region region;
	struct resource *res;
Yu Zhao's avatar
Yu Zhao committed
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992

	if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
		return -EIO;

	dev->sysdata = dev->bus->sysdata;
	dev->dev.parent = dev->bus->bridge;
	dev->dev.bus = &pci_bus_type;
	dev->hdr_type = hdr_type & 0x7f;
	dev->multifunction = !!(hdr_type & 0x80);
	dev->error_state = pci_channel_io_normal;
	set_pcie_port_type(dev);

	list_for_each_entry(slot, &dev->bus->slots, list)
		if (PCI_SLOT(dev->devfn) == slot->number)
			dev->slot = slot;

	/* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
	   set this higher, assuming the system even supports it.  */
	dev->dma_mask = 0xffffffff;
Linus Torvalds's avatar
Linus Torvalds committed
993

994 995 996
	dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
		     dev->bus->number, PCI_SLOT(dev->devfn),
		     PCI_FUNC(dev->devfn));
Linus Torvalds's avatar
Linus Torvalds committed
997 998

	pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
Auke Kok's avatar
Auke Kok committed
999
	dev->revision = class & 0xff;
Yinghai Lu's avatar
Yinghai Lu committed
1000
	dev->class = class >> 8;		    /* upper 3 bytes */
Linus Torvalds's avatar
Linus Torvalds committed
1001

Yinghai Lu's avatar
Yinghai Lu committed
1002 1003
	dev_printk(KERN_DEBUG, &dev->dev, "[%04x:%04x] type %02x class %#08x\n",
		   dev->vendor, dev->device, dev->hdr_type, dev->class);
Linus Torvalds's avatar
Linus Torvalds committed
1004

1005 1006 1007
	/* need to have dev->class ready */
	dev->cfg_size = pci_cfg_space_size(dev);

Linus Torvalds's avatar
Linus Torvalds committed
1008
	/* "Unknown power state" */
1009
	dev->current_state = PCI_UNKNOWN;
Linus Torvalds's avatar
Linus Torvalds committed
1010 1011 1012

	/* Early fixups, before probing the BARs */
	pci_fixup_device(pci_fixup_early, dev);
1013 1014
	/* device class may be changed after fixup */
	class = dev->class >> 8;
Linus Torvalds's avatar
Linus Torvalds committed
1015 1016 1017 1018 1019 1020 1021 1022 1023

	switch (dev->hdr_type) {		    /* header type */
	case PCI_HEADER_TYPE_NORMAL:		    /* standard header */
		if (class == PCI_CLASS_BRIDGE_PCI)
			goto bad;
		pci_read_irq(dev);
		pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
		pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
		pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034

		/*
		 *	Do the ugly legacy mode stuff here rather than broken chip
		 *	quirk code. Legacy mode ATA controllers have fixed
		 *	addresses. These are not always echoed in BAR0-3, and
		 *	BAR0-3 in a few cases contain junk!
		 */
		if (class == PCI_CLASS_STORAGE_IDE) {
			u8 progif;
			pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
			if ((progif & 1) == 0) {
1035 1036 1037 1038
				region.start = 0x1F0;
				region.end = 0x1F7;
				res = &dev->resource[0];
				res->flags = LEGACY_IO_RESOURCE;
1039
				pcibios_bus_to_resource(dev, res, &region);
1040 1041 1042 1043
				region.start = 0x3F6;
				region.end = 0x3F6;
				res = &dev->resource[1];
				res->flags = LEGACY_IO_RESOURCE;
1044
				pcibios_bus_to_resource(dev, res, &region);
1045 1046
			}
			if ((progif & 4) == 0) {
1047 1048 1049 1050
				region.start = 0x170;
				region.end = 0x177;
				res = &dev->resource[2];
				res->flags = LEGACY_IO_RESOURCE;
1051
				pcibios_bus_to_resource(dev, res, &region);
1052 1053 1054 1055
				region.start = 0x376;
				region.end = 0x376;
				res = &dev->resource[3];
				res->flags = LEGACY_IO_RESOURCE;
1056
				pcibios_bus_to_resource(dev, res, &region);
1057 1058
			}
		}
Linus Torvalds's avatar
Linus Torvalds committed
1059 1060 1061 1062 1063 1064 1065 1066
		break;

	case PCI_HEADER_TYPE_BRIDGE:		    /* bridge header */
		if (class != PCI_CLASS_BRIDGE_PCI)
			goto bad;
		/* The PCI-to-PCI bridge spec requires that subtractive
		   decoding (i.e. transparent) bridge must have programming
		   interface code of 0x01. */ 
1067
		pci_read_irq(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1068 1069
		dev->transparent = ((dev->class & 0xff) == 1);
		pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
1070
		set_pcie_hotplug_bridge(dev);
1071 1072 1073 1074 1075
		pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
		if (pos) {
			pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
			pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
		}
Linus Torvalds's avatar
Linus Torvalds committed
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
		break;

	case PCI_HEADER_TYPE_CARDBUS:		    /* CardBus bridge header */
		if (class != PCI_CLASS_BRIDGE_CARDBUS)
			goto bad;
		pci_read_irq(dev);
		pci_read_bases(dev, 1, 0);
		pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
		pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
		break;

	default:				    /* unknown header */
1088 1089
		dev_err(&dev->dev, "unknown header type %02x, "
			"ignoring device\n", dev->hdr_type);
Yu Zhao's avatar
Yu Zhao committed
1090
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
1091 1092

	bad:
Yinghai Lu's avatar
Yinghai Lu committed
1093 1094
		dev_err(&dev->dev, "ignoring class %#08x (doesn't match header "
			"type %02x)\n", dev->class, dev->hdr_type);
Linus Torvalds's avatar
Linus Torvalds committed
1095 1096 1097 1098 1099 1100 1101
		dev->class = PCI_CLASS_NOT_DEFINED;
	}

	/* We found a fine healthy device, go go go... */
	return 0;
}

1102 1103 1104
static void pci_release_capabilities(struct pci_dev *dev)
{
	pci_vpd_release(dev);
1105
	pci_iov_release(dev);
1106
	pci_free_cap_save_buffers(dev);
1107 1108
}

Linus Torvalds's avatar
Linus Torvalds committed
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
/**
 * pci_release_dev - free a pci device structure when all users of it are finished.
 * @dev: device that's been disconnected
 *
 * Will be called only by the device core when all users of this pci device are
 * done.
 */
static void pci_release_dev(struct device *dev)
{
	struct pci_dev *pci_dev;

	pci_dev = to_pci_dev(dev);
1121
	pci_release_capabilities(pci_dev);
1122
	pci_release_of_node(pci_dev);
Linus Torvalds's avatar
Linus Torvalds committed
1123 1124 1125 1126 1127
	kfree(pci_dev);
}

/**
 * pci_cfg_space_size - get the configuration space size of the PCI device.
Randy Dunlap's avatar
Randy Dunlap committed
1128
 * @dev: PCI device
Linus Torvalds's avatar
Linus Torvalds committed
1129 1130 1131 1132 1133 1134 1135 1136
 *
 * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
 * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
 * access it.  Maybe we don't have a way to generate extended config space
 * accesses, or the device is behind a reverse Express bridge.  So we try
 * reading the dword at 0x100 which must either be 0 or a valid extended
 * capability header.
 */
1137
int pci_cfg_space_size_ext(struct pci_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1138 1139
{
	u32 status;
1140
	int pos = PCI_CFG_SPACE_SIZE;
Linus Torvalds's avatar
Linus Torvalds committed
1141

1142
	if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
		goto fail;
	if (status == 0xffffffff)
		goto fail;

	return PCI_CFG_SPACE_EXP_SIZE;

 fail:
	return PCI_CFG_SPACE_SIZE;
}

int pci_cfg_space_size(struct pci_dev *dev)
{
	int pos;
	u32 status;
1157 1158 1159 1160 1161
	u16 class;

	class = dev->class >> 8;
	if (class == PCI_CLASS_BRIDGE_HOST)
		return pci_cfg_space_size_ext(dev);
1162

1163
	pos = pci_pcie_cap(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
	if (!pos) {
		pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
		if (!pos)
			goto fail;

		pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
		if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
			goto fail;
	}

1174
	return pci_cfg_space_size_ext(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1175 1176 1177 1178 1179 1180 1181

 fail:
	return PCI_CFG_SPACE_SIZE;
}

static void pci_release_bus_bridge_dev(struct device *dev)
{
1182 1183
	struct pci_host_bridge *bridge = to_pci_host_bridge(dev);

1184 1185
	if (bridge->release_fn)
		bridge->release_fn(bridge);
1186 1187 1188 1189

	pci_free_resource_list(&bridge->windows);

	kfree(bridge);
Linus Torvalds's avatar
Linus Torvalds committed
1190 1191
}

1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
struct pci_dev *alloc_pci_dev(void)
{
	struct pci_dev *dev;

	dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
	if (!dev)
		return NULL;

	INIT_LIST_HEAD(&dev->bus_list);

	return dev;
}
EXPORT_SYMBOL(alloc_pci_dev);

1206 1207
bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *l,
				 int crs_timeout)
Linus Torvalds's avatar
Linus Torvalds committed
1208 1209 1210
{
	int delay = 1;

1211 1212
	if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
		return false;
Linus Torvalds's avatar
Linus Torvalds committed
1213 1214

	/* some broken boards return 0 or ~0 if a slot is empty: */
1215 1216 1217
	if (*l == 0xffffffff || *l == 0x00000000 ||
	    *l == 0x0000ffff || *l == 0xffff0000)
		return false;
Linus Torvalds's avatar
Linus Torvalds committed
1218 1219

	/* Configuration request Retry Status */
1220 1221 1222 1223
	while (*l == 0xffff0001) {
		if (!crs_timeout)
			return false;

Linus Torvalds's avatar
Linus Torvalds committed
1224 1225
		msleep(delay);
		delay *= 2;
1226 1227
		if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
			return false;
Linus Torvalds's avatar
Linus Torvalds committed
1228
		/* Card hasn't responded in 60 seconds?  Must be stuck. */
1229
		if (delay > crs_timeout) {
1230
			printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
Linus Torvalds's avatar
Linus Torvalds committed
1231 1232 1233
					"responding\n", pci_domain_nr(bus),
					bus->number, PCI_SLOT(devfn),
					PCI_FUNC(devfn));
1234
			return false;
Linus Torvalds's avatar
Linus Torvalds committed
1235 1236 1237
		}
	}

1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
	return true;
}
EXPORT_SYMBOL(pci_bus_read_dev_vendor_id);

/*
 * Read the config data for a PCI device, sanity-check it
 * and fill in the dev structure...
 */
static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
{
	struct pci_dev *dev;
	u32 l;

	if (!pci_bus_read_dev_vendor_id(bus, devfn, &l, 60*1000))
		return NULL;

1254
	dev = alloc_pci_dev();
Linus Torvalds's avatar
Linus Torvalds committed
1255 1256 1257 1258 1259 1260 1261
	if (!dev)
		return NULL;

	dev->bus = bus;
	dev->devfn = devfn;
	dev->vendor = l & 0xffff;
	dev->device = (l >> 16) & 0xffff;
1262

1263 1264
	pci_set_of_node(dev);

Yu Zhao's avatar
Yu Zhao committed
1265
	if (pci_setup_device(dev)) {
Linus Torvalds's avatar
Linus Torvalds committed
1266 1267 1268 1269 1270 1271 1272
		kfree(dev);
		return NULL;
	}

	return dev;
}

1273 1274 1275 1276 1277
static void pci_init_capabilities(struct pci_dev *dev)
{
	/* MSI/MSI-X list */
	pci_msi_init_pci_dev(dev);

1278 1279 1280
	/* Buffers for saving PCIe and PCI-X capabilities */
	pci_allocate_cap_save_buffers(dev);

1281 1282
	/* Power Management */
	pci_pm_init(dev);
1283
	platform_pci_wakeup_init(dev);
1284 1285 1286

	/* Vital Product Data */
	pci_vpd_pci22_init(dev);
Yu Zhao's avatar
Yu Zhao committed
1287 1288 1289

	/* Alternative Routing-ID Forwarding */
	pci_enable_ari(dev);
1290 1291 1292

	/* Single Root I/O Virtualization */
	pci_iov_init(dev);
1293 1294

	/* Enable ACS P2P upstream forwarding */
Chris Wright's avatar
Chris Wright committed
1295
	pci_enable_acs(dev);
1296 1297
}

1298
void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
Linus Torvalds's avatar
Linus Torvalds committed
1299
{
1300 1301 1302
	device_initialize(&dev->dev);
	dev->dev.release = pci_release_dev;
	pci_dev_get(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1303

1304
	dev->dev.dma_mask = &dev->dma_mask;
1305
	dev->dev.dma_parms = &dev->dma_parms;
1306
	dev->dev.coherent_dma_mask = 0xffffffffull;
Linus Torvalds's avatar
Linus Torvalds committed
1307

1308
	pci_set_dma_max_seg_size(dev, 65536);
1309
	pci_set_dma_seg_boundary(dev, 0xffffffff);
1310

Linus Torvalds's avatar
Linus Torvalds committed
1311 1312 1313
	/* Fix up broken headers */
	pci_fixup_device(pci_fixup_header, dev);

1314 1315 1316
	/* moved out from quirk header fixup code */
	pci_reassigndev_resource_alignment(dev);

1317 1318 1319
	/* Clear the state_saved flag. */
	dev->state_saved = false;

1320 1321
	/* Initialize various capabilities */
	pci_init_capabilities(dev);
1322

Linus Torvalds's avatar
Linus Torvalds committed
1323 1324 1325 1326
	/*
	 * Add the device to our list of discovered devices
	 * and the bus list for fixup functions, etc.
	 */
1327
	down_write(&pci_bus_sem);
Linus Torvalds's avatar
Linus Torvalds committed
1328
	list_add_tail(&dev->bus_list, &bus->devices);
1329
	up_write(&pci_bus_sem);
1330 1331
}

1332
struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1333 1334 1335
{
	struct pci_dev *dev;

1336 1337 1338 1339 1340 1341
	dev = pci_get_slot(bus, devfn);
	if (dev) {
		pci_dev_put(dev);
		return dev;
	}

1342 1343 1344 1345 1346
	dev = pci_scan_device(bus, devfn);
	if (!dev)
		return NULL;

	pci_device_add(dev, bus);
Linus Torvalds's avatar
Linus Torvalds committed
1347 1348 1349

	return dev;
}
1350
EXPORT_SYMBOL(pci_scan_single_device);
Linus Torvalds's avatar
Linus Torvalds committed
1351

Matthew Wilcox's avatar
Matthew Wilcox committed
1352 1353 1354
static unsigned next_ari_fn(struct pci_dev *dev, unsigned fn)
{
	u16 cap;
1355 1356 1357 1358 1359 1360
	unsigned pos, next_fn;

	if (!dev)
		return 0;

	pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
Matthew Wilcox's avatar
Matthew Wilcox committed
1361 1362 1363
	if (!pos)
		return 0;
	pci_read_config_word(dev, pos + 4, &cap);
1364 1365 1366 1367
	next_fn = cap >> 8;
	if (next_fn <= fn)
		return 0;
	return next_fn;
Matthew Wilcox's avatar
Matthew Wilcox committed
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
}

static unsigned next_trad_fn(struct pci_dev *dev, unsigned fn)
{
	return (fn + 1) % 8;
}

static unsigned no_next_fn(struct pci_dev *dev, unsigned fn)
{
	return 0;
}

static int only_one_child(struct pci_bus *bus)
{
	struct pci_dev *parent = bus->self;
1383

Matthew Wilcox's avatar
Matthew Wilcox committed
1384 1385
	if (!parent || !pci_is_pcie(parent))
		return 0;
1386 1387 1388 1389
	if (parent->pcie_type == PCI_EXP_TYPE_ROOT_PORT)
		return 1;
	if (parent->pcie_type == PCI_EXP_TYPE_DOWNSTREAM &&
	    !pci_has_flag(PCI_SCAN_ALL_PCIE_DEVS))
Matthew Wilcox's avatar
Matthew Wilcox committed
1390 1391 1392 1393
		return 1;
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1394 1395 1396 1397 1398 1399 1400
/**
 * pci_scan_slot - scan a PCI slot on a bus for devices.
 * @bus: PCI bus to scan
 * @devfn: slot number to scan (must have zero function.)
 *
 * Scan a PCI slot on the specified PCI bus for devices, adding
 * discovered devices to the @bus->devices list.  New devices
1401
 * will not have is_added set.
1402 1403
 *
 * Returns the number of new devices found.
Linus Torvalds's avatar
Linus Torvalds committed
1404
 */
1405
int pci_scan_slot(struct pci_bus *bus, int devfn)
Linus Torvalds's avatar
Linus Torvalds committed
1406
{
Matthew Wilcox's avatar
Matthew Wilcox committed
1407
	unsigned fn, nr = 0;
1408
	struct pci_dev *dev;
Matthew Wilcox's avatar
Matthew Wilcox committed
1409 1410 1411 1412
	unsigned (*next_fn)(struct pci_dev *, unsigned) = no_next_fn;

	if (only_one_child(bus) && (devfn > 0))
		return 0; /* Already scanned the entire slot */
Linus Torvalds's avatar
Linus Torvalds committed
1413

1414
	dev = pci_scan_single_device(bus, devfn);
1415 1416 1417
	if (!dev)
		return 0;
	if (!dev->is_added)
1418 1419
		nr++;

Matthew Wilcox's avatar
Matthew Wilcox committed
1420 1421
	if (pci_ari_enabled(bus))
		next_fn = next_ari_fn;
1422
	else if (dev->multifunction)
Matthew Wilcox's avatar
Matthew Wilcox committed
1423 1424 1425 1426 1427 1428 1429 1430
		next_fn = next_trad_fn;

	for (fn = next_fn(dev, 0); fn > 0; fn = next_fn(dev, fn)) {
		dev = pci_scan_single_device(bus, devfn + fn);
		if (dev) {
			if (!dev->is_added)
				nr++;
			dev->multifunction = 1;
Linus Torvalds's avatar
Linus Torvalds committed
1431 1432
		}
	}
1433

1434 1435
	/* only one slot has pcie device */
	if (bus->self && nr)
1436 1437
		pcie_aspm_init_link_state(bus->self);

Linus Torvalds's avatar
Linus Torvalds committed
1438 1439 1440
	return nr;
}

1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
static int pcie_find_smpss(struct pci_dev *dev, void *data)
{
	u8 *smpss = data;

	if (!pci_is_pcie(dev))
		return 0;

	/* For PCIE hotplug enabled slots not connected directly to a
	 * PCI-E root port, there can be problems when hotplugging
	 * devices.  This is due to the possibility of hotplugging a
	 * device into the fabric with a smaller MPS that the devices
	 * currently running have configured.  Modifying the MPS on the
	 * running devices could cause a fatal bus error due to an
	 * incoming frame being larger than the newly configured MPS.
	 * To work around this, the MPS for the entire fabric must be
	 * set to the minimum size.  Any devices hotplugged into this
	 * fabric will have the minimum MPS set.  If the PCI hotplug
	 * slot is directly connected to the root port and there are not
	 * other devices on the fabric (which seems to be the most
	 * common case), then this is not an issue and MPS discovery
	 * will occur as normal.
	 */
	if (dev->is_hotplug_bridge && (!list_is_singular(&dev->bus->devices) ||
1464 1465
	     (dev->bus->self &&
	      dev->bus->self->pcie_type != PCI_EXP_TYPE_ROOT_PORT)))
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
		*smpss = 0;

	if (*smpss > dev->pcie_mpss)
		*smpss = dev->pcie_mpss;

	return 0;
}

static void pcie_write_mps(struct pci_dev *dev, int mps)
{
1476
	int rc;
1477 1478

	if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
1479
		mps = 128 << dev->pcie_mpss;
1480

1481 1482
		if (dev->pcie_type != PCI_EXP_TYPE_ROOT_PORT && dev->bus->self)
			/* For "Performance", the assumption is made that
1483 1484 1485 1486 1487
			 * downstream communication will never be larger than
			 * the MRRS.  So, the MPS only needs to be configured
			 * for the upstream communication.  This being the case,
			 * walk from the top down and set the MPS of the child
			 * to that of the parent bus.
1488 1489 1490 1491 1492
			 *
			 * Configure the device MPS with the smaller of the
			 * device MPSS or the bridge MPS (which is assumed to be
			 * properly configured at this point to the largest
			 * allowable MPS based on its parent bus).
1493
			 */
1494
			mps = min(mps, pcie_get_mps(dev->bus->self));
1495 1496 1497 1498 1499 1500 1501
	}

	rc = pcie_set_mps(dev, mps);
	if (rc)
		dev_err(&dev->dev, "Failed attempting to set the MPS\n");
}

1502
static void pcie_write_mrrs(struct pci_dev *dev)
1503
{
1504
	int rc, mrrs;
1505

1506 1507 1508 1509 1510 1511 1512 1513
	/* In the "safe" case, do not configure the MRRS.  There appear to be
	 * issues with setting MRRS to 0 on a number of devices.
	 */
	if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
		return;

	/* For Max performance, the MRRS must be set to the largest supported
	 * value.  However, it cannot be configured larger than the MPS the
1514 1515
	 * device or the bus can support.  This should already be properly
	 * configured by a prior call to pcie_write_mps.
1516
	 */
1517
	mrrs = pcie_get_mps(dev);
1518 1519

	/* MRRS is a R/W register.  Invalid values can be written, but a
1520
	 * subsequent read will verify if the value is acceptable or not.
1521 1522 1523 1524 1525
	 * If the MRRS value provided is not acceptable (e.g., too large),
	 * shrink the value until it is acceptable to the HW.
 	 */
	while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
		rc = pcie_set_readrq(dev, mrrs);
1526 1527
		if (!rc)
			break;
1528

1529
		dev_warn(&dev->dev, "Failed attempting to set the MRRS\n");
1530 1531
		mrrs /= 2;
	}
1532 1533 1534 1535 1536

	if (mrrs < 128)
		dev_err(&dev->dev, "MRRS was unable to be configured with a "
			"safe value.  If problems are experienced, try running "
			"with pci=pcie_bus_safe.\n");
1537 1538 1539 1540
}

static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
{
Jon Mason's avatar
Jon Mason committed
1541
	int mps, orig_mps;
1542 1543 1544 1545

	if (!pci_is_pcie(dev))
		return 0;

Jon Mason's avatar
Jon Mason committed
1546 1547
	mps = 128 << *(u8 *)data;
	orig_mps = pcie_get_mps(dev);
1548 1549

	pcie_write_mps(dev, mps);
1550
	pcie_write_mrrs(dev);
1551

Jon Mason's avatar
Jon Mason committed
1552 1553 1554
	dev_info(&dev->dev, "PCI-E Max Payload Size set to %4d/%4d (was %4d), "
		 "Max Read Rq %4d\n", pcie_get_mps(dev), 128 << dev->pcie_mpss,
		 orig_mps, pcie_get_readrq(dev));
1555 1556 1557 1558

	return 0;
}

Jon Mason's avatar
Jon Mason committed
1559
/* pcie_bus_configure_settings requires that pci_walk_bus work in a top-down,
1560 1561 1562 1563 1564
 * parents then children fashion.  If this changes, then this code will not
 * work as designed.
 */
void pcie_bus_configure_settings(struct pci_bus *bus, u8 mpss)
{
1565
	u8 smpss;
1566 1567 1568 1569

	if (!pci_is_pcie(bus->self))
		return;

1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
	if (pcie_bus_config == PCIE_BUS_TUNE_OFF)
		return;

	/* FIXME - Peer to peer DMA is possible, though the endpoint would need
	 * to be aware to the MPS of the destination.  To work around this,
	 * simply force the MPS of the entire system to the smallest possible.
	 */
	if (pcie_bus_config == PCIE_BUS_PEER2PEER)
		smpss = 0;

1580
	if (pcie_bus_config == PCIE_BUS_SAFE) {
1581 1582
		smpss = mpss;

1583 1584 1585 1586 1587 1588 1589
		pcie_find_smpss(bus->self, &smpss);
		pci_walk_bus(bus, pcie_find_smpss, &smpss);
	}

	pcie_bus_configure_set(bus->self, &smpss);
	pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
}
1590
EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
1591

1592
unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
Linus Torvalds's avatar
Linus Torvalds committed
1593
{
1594
	unsigned int devfn, pass, max = bus->busn_res.start;
Linus Torvalds's avatar
Linus Torvalds committed
1595 1596
	struct pci_dev *dev;

1597
	dev_dbg(&bus->dev, "scanning bus\n");
Linus Torvalds's avatar
Linus Torvalds committed
1598 1599 1600 1601 1602

	/* Go find them, Rover! */
	for (devfn = 0; devfn < 0x100; devfn += 8)
		pci_scan_slot(bus, devfn);

1603 1604 1605
	/* Reserve buses for SR-IOV capability. */
	max += pci_iov_bus_range(bus);

Linus Torvalds's avatar
Linus Torvalds committed
1606 1607 1608 1609
	/*
	 * After performing arch-dependent fixup of the bus, look behind
	 * all PCI-to-PCI bridges on this bus.
	 */
Alex Chiang's avatar
Alex Chiang committed
1610
	if (!bus->is_added) {
1611
		dev_dbg(&bus->dev, "fixups for bus\n");
Alex Chiang's avatar
Alex Chiang committed
1612 1613 1614 1615 1616
		pcibios_fixup_bus(bus);
		if (pci_is_root_bus(bus))
			bus->is_added = 1;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
	for (pass=0; pass < 2; pass++)
		list_for_each_entry(dev, &bus->devices, bus_list) {
			if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
			    dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
				max = pci_scan_bridge(bus, dev, max, pass);
		}

	/*
	 * We've scanned the bus and so we know all about what's on
	 * the other side of any bridges that may be on this bus plus
	 * any devices.
	 *
	 * Return how far we've got finding sub-buses.
	 */
1631
	dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
Linus Torvalds's avatar
Linus Torvalds committed
1632 1633 1634
	return max;
}

1635 1636
struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
		struct pci_ops *ops, void *sysdata, struct list_head *resources)
Linus Torvalds's avatar
Linus Torvalds committed
1637
{
1638
	int error;
1639
	struct pci_host_bridge *bridge;
1640
	struct pci_bus *b, *b2;
1641
	struct pci_host_bridge_window *window, *n;
1642
	struct resource *res;
1643 1644 1645
	resource_size_t offset;
	char bus_addr[64];
	char *fmt;
Linus Torvalds's avatar
Linus Torvalds committed
1646

1647

Linus Torvalds's avatar
Linus Torvalds committed
1648 1649
	b = pci_alloc_bus();
	if (!b)
1650
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1651 1652 1653

	b->sysdata = sysdata;
	b->ops = ops;
1654 1655
	b2 = pci_find_bus(pci_domain_nr(b), bus);
	if (b2) {
Linus Torvalds's avatar
Linus Torvalds committed
1656
		/* If we already got to this bus through a different bridge, ignore it */
1657
		dev_dbg(&b2->dev, "bus already known\n");
Linus Torvalds's avatar
Linus Torvalds committed
1658 1659
		goto err_out;
	}
1660

1661 1662 1663 1664 1665 1666 1667 1668
	bridge = pci_alloc_host_bridge(b);
	if (!bridge)
		goto err_out;

	bridge->dev.parent = parent;
	bridge->dev.release = pci_release_bus_bridge_dev;
	dev_set_name(&bridge->dev, "pci%04x:%02x", pci_domain_nr(b), bus);
	error = device_register(&bridge->dev);
Linus Torvalds's avatar
Linus Torvalds committed
1669
	if (error)
1670 1671
		goto bridge_dev_reg_err;
	b->bridge = get_device(&bridge->dev);
1672
	device_enable_async_suspend(b->bridge);
1673
	pci_set_bus_of_node(b);
Linus Torvalds's avatar
Linus Torvalds committed
1674

1675 1676 1677
	if (!parent)
		set_dev_node(b->bridge, pcibus_to_node(b));

1678 1679
	b->dev.class = &pcibus_class;
	b->dev.parent = b->bridge;
1680
	dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1681
	error = device_register(&b->dev);
Linus Torvalds's avatar
Linus Torvalds committed
1682 1683 1684 1685 1686 1687
	if (error)
		goto class_dev_reg_err;

	/* Create legacy_io and legacy_mem files for this bus */
	pci_create_legacy_files(b);

1688
	b->number = b->busn_res.start = bus;
1689

1690 1691 1692 1693 1694
	if (parent)
		dev_info(parent, "PCI host bridge to bus %s\n", dev_name(&b->dev));
	else
		printk(KERN_INFO "PCI host bridge to bus %s\n", dev_name(&b->dev));

1695 1696 1697 1698 1699
	/* Add initial resources to the bus */
	list_for_each_entry_safe(window, n, resources, list) {
		list_move_tail(&window->list, &bridge->windows);
		res = window->res;
		offset = window->offset;
1700 1701 1702 1703
		if (res->flags & IORESOURCE_BUS)
			pci_bus_insert_busn_res(b, bus, res->end);
		else
			pci_bus_add_resource(b, res, 0);
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
		if (offset) {
			if (resource_type(res) == IORESOURCE_IO)
				fmt = " (bus address [%#06llx-%#06llx])";
			else
				fmt = " (bus address [%#010llx-%#010llx])";
			snprintf(bus_addr, sizeof(bus_addr), fmt,
				 (unsigned long long) (res->start - offset),
				 (unsigned long long) (res->end - offset));
		} else
			bus_addr[0] = '\0';
		dev_info(&b->dev, "root bus resource %pR%s\n", res, bus_addr);
1715 1716
	}

1717 1718 1719 1720
	down_write(&pci_bus_sem);
	list_add_tail(&b->node, &pci_root_buses);
	up_write(&pci_bus_sem);

Linus Torvalds's avatar
Linus Torvalds committed
1721 1722 1723
	return b;

class_dev_reg_err:
1724 1725 1726 1727
	put_device(&bridge->dev);
	device_unregister(&bridge->dev);
bridge_dev_reg_err:
	kfree(bridge);
Linus Torvalds's avatar
Linus Torvalds committed
1728 1729 1730 1731
err_out:
	kfree(b);
	return NULL;
}
1732

1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int bus_max)
{
	struct resource *res = &b->busn_res;
	struct resource *parent_res, *conflict;

	res->start = bus;
	res->end = bus_max;
	res->flags = IORESOURCE_BUS;

	if (!pci_is_root_bus(b))
		parent_res = &b->parent->busn_res;
	else {
		parent_res = get_pci_domain_busn_res(pci_domain_nr(b));
		res->flags |= IORESOURCE_PCI_FIXED;
	}

	conflict = insert_resource_conflict(parent_res, res);

	if (conflict)
		dev_printk(KERN_DEBUG, &b->dev,
			   "busn_res: can not insert %pR under %s%pR (conflicts with %s %pR)\n",
			    res, pci_is_root_bus(b) ? "domain " : "",
			    parent_res, conflict->name, conflict);

	return conflict == NULL;
}

int pci_bus_update_busn_res_end(struct pci_bus *b, int bus_max)
{
	struct resource *res = &b->busn_res;
	struct resource old_res = *res;
	resource_size_t size;
	int ret;

	if (res->start > bus_max)
		return -EINVAL;

	size = bus_max - res->start + 1;
	ret = adjust_resource(res, res->start, size);
	dev_printk(KERN_DEBUG, &b->dev,
			"busn_res: %pR end %s updated to %02x\n",
			&old_res, ret ? "can not be" : "is", bus_max);

	if (!ret && !res->parent)
		pci_bus_insert_busn_res(b, res->start, res->end);

	return ret;
}

void pci_bus_release_busn_res(struct pci_bus *b)
{
	struct resource *res = &b->busn_res;
	int ret;

	if (!res->flags || !res->parent)
		return;

	ret = release_resource(res);
	dev_printk(KERN_DEBUG, &b->dev,
			"busn_res: %pR %s released\n",
			res, ret ? "can not be" : "is");
}

1796 1797 1798
struct pci_bus * __devinit pci_scan_root_bus(struct device *parent, int bus,
		struct pci_ops *ops, void *sysdata, struct list_head *resources)
{
1799 1800
	struct pci_host_bridge_window *window;
	bool found = false;
1801
	struct pci_bus *b;
1802 1803 1804 1805 1806 1807 1808
	int max;

	list_for_each_entry(window, resources, list)
		if (window->res->flags & IORESOURCE_BUS) {
			found = true;
			break;
		}
1809 1810 1811 1812 1813

	b = pci_create_root_bus(parent, bus, ops, sysdata, resources);
	if (!b)
		return NULL;

1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
	if (!found) {
		dev_info(&b->dev,
		 "No busn resource found for root bus, will use [bus %02x-ff]\n",
			bus);
		pci_bus_insert_busn_res(b, bus, 255);
	}

	max = pci_scan_child_bus(b);

	if (!found)
		pci_bus_update_busn_res_end(b, max);

1826 1827 1828 1829 1830
	pci_bus_add_devices(b);
	return b;
}
EXPORT_SYMBOL(pci_scan_root_bus);

1831
/* Deprecated; use pci_scan_root_bus() instead */
1832
struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1833 1834
		int bus, struct pci_ops *ops, void *sysdata)
{
1835
	LIST_HEAD(resources);
1836 1837
	struct pci_bus *b;

1838 1839
	pci_add_resource(&resources, &ioport_resource);
	pci_add_resource(&resources, &iomem_resource);
1840
	pci_add_resource(&resources, &busn_resource);
1841
	b = pci_create_root_bus(parent, bus, ops, sysdata, &resources);
1842
	if (b)
1843
		pci_scan_child_bus(b);
1844 1845
	else
		pci_free_resource_list(&resources);
1846 1847
	return b;
}
Linus Torvalds's avatar
Linus Torvalds committed
1848 1849
EXPORT_SYMBOL(pci_scan_bus_parented);

1850 1851 1852 1853 1854 1855 1856 1857
struct pci_bus * __devinit pci_scan_bus(int bus, struct pci_ops *ops,
					void *sysdata)
{
	LIST_HEAD(resources);
	struct pci_bus *b;

	pci_add_resource(&resources, &ioport_resource);
	pci_add_resource(&resources, &iomem_resource);
1858
	pci_add_resource(&resources, &busn_resource);
1859 1860
	b = pci_create_root_bus(NULL, bus, ops, sysdata, &resources);
	if (b) {
1861
		pci_scan_child_bus(b);
1862 1863 1864 1865 1866 1867 1868 1869
		pci_bus_add_devices(b);
	} else {
		pci_free_resource_list(&resources);
	}
	return b;
}
EXPORT_SYMBOL(pci_scan_bus);

Linus Torvalds's avatar
Linus Torvalds committed
1870
#ifdef CONFIG_HOTPLUG
1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
/**
 * pci_rescan_bus_bridge_resize - scan a PCI bus for devices.
 * @bridge: PCI bridge for the bus to scan
 *
 * Scan a PCI bus and child buses for new devices, add them,
 * and enable them, resizing bridge mmio/io resource if necessary
 * and possible.  The caller must ensure the child devices are already
 * removed for resizing to occur.
 *
 * Returns the max number of subordinate bus discovered.
 */
unsigned int __ref pci_rescan_bus_bridge_resize(struct pci_dev *bridge)
{
	unsigned int max;
	struct pci_bus *bus = bridge->subordinate;

	max = pci_scan_child_bus(bus);

	pci_assign_unassigned_bridge_resources(bridge);

	pci_bus_add_devices(bus);

	return max;
}

Linus Torvalds's avatar
Linus Torvalds committed
1896 1897 1898 1899 1900
EXPORT_SYMBOL(pci_add_new_bus);
EXPORT_SYMBOL(pci_scan_slot);
EXPORT_SYMBOL(pci_scan_bridge);
EXPORT_SYMBOL_GPL(pci_scan_child_bus);
#endif
1901

1902
static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1903
{
1904 1905 1906
	const struct pci_dev *a = to_pci_dev(d_a);
	const struct pci_dev *b = to_pci_dev(d_b);

1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
	if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
	else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;

	if      (a->bus->number < b->bus->number) return -1;
	else if (a->bus->number > b->bus->number) return  1;

	if      (a->devfn < b->devfn) return -1;
	else if (a->devfn > b->devfn) return  1;

	return 0;
}

1919
void __init pci_sort_breadthfirst(void)
1920
{
1921
	bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
1922
}