xref: /kvm-unit-tests/lib/pci.c (revision cdccea7c980a44e120b33a9ef61d896cc68effe7)
1456c55bcSAndrew Jones /*
2456c55bcSAndrew Jones  * Copyright (C) 2013, Red Hat Inc, Michael S. Tsirkin <mst@redhat.com>
3456c55bcSAndrew Jones  *
4456c55bcSAndrew Jones  * This work is licensed under the terms of the GNU LGPL, version 2.
5456c55bcSAndrew Jones  */
64932b58aSMichael S. Tsirkin #include <linux/pci_regs.h>
74932b58aSMichael S. Tsirkin #include "pci.h"
8456c55bcSAndrew Jones #include "asm/pci.h"
94932b58aSMichael S. Tsirkin 
10*cdccea7cSAndrew Jones void pci_cap_walk(struct pci_dev *dev, pci_cap_handler_t handler)
11903b0516SPeter Xu {
12903b0516SPeter Xu 	uint8_t cap_offset;
13903b0516SPeter Xu 	uint8_t cap_id;
14903b0516SPeter Xu 	int count = 0;
15903b0516SPeter Xu 
16903b0516SPeter Xu 	cap_offset = pci_config_readb(dev->bdf, PCI_CAPABILITY_LIST);
17903b0516SPeter Xu 	while (cap_offset) {
18903b0516SPeter Xu 		cap_id = pci_config_readb(dev->bdf, cap_offset);
19903b0516SPeter Xu 		printf("PCI detected cap 0x%x\n", cap_id);
20903b0516SPeter Xu 		assert(cap_id < PCI_CAP_ID_MAX + 1);
21*cdccea7cSAndrew Jones 		handler(dev, cap_offset, cap_id);
22903b0516SPeter Xu 		cap_offset = pci_config_readb(dev->bdf, cap_offset + 1);
23903b0516SPeter Xu 		/* Avoid dead loop during cap walk */
24903b0516SPeter Xu 		assert(++count <= 255);
25903b0516SPeter Xu 	}
26903b0516SPeter Xu }
27903b0516SPeter Xu 
2819daf1c5SPeter Xu void pci_msi_set_enable(struct pci_dev *dev, bool enabled)
2919daf1c5SPeter Xu {
3019daf1c5SPeter Xu 	uint16_t msi_control;
3119daf1c5SPeter Xu 	uint16_t offset;
3219daf1c5SPeter Xu 
3319daf1c5SPeter Xu 	offset = dev->msi_offset;
3419daf1c5SPeter Xu 	msi_control = pci_config_readw(dev->bdf, offset + PCI_MSI_FLAGS);
3519daf1c5SPeter Xu 
3619daf1c5SPeter Xu 	if (enabled)
3719daf1c5SPeter Xu 		msi_control |= PCI_MSI_FLAGS_ENABLE;
3819daf1c5SPeter Xu 	else
3919daf1c5SPeter Xu 		msi_control &= ~PCI_MSI_FLAGS_ENABLE;
4019daf1c5SPeter Xu 
4119daf1c5SPeter Xu 	pci_config_writew(dev->bdf, offset + PCI_MSI_FLAGS, msi_control);
4219daf1c5SPeter Xu }
4319daf1c5SPeter Xu 
44903b0516SPeter Xu bool pci_setup_msi(struct pci_dev *dev, uint64_t msi_addr, uint32_t msi_data)
45903b0516SPeter Xu {
46903b0516SPeter Xu 	uint16_t msi_control;
47903b0516SPeter Xu 	uint16_t offset;
48903b0516SPeter Xu 	pcidevaddr_t addr;
49903b0516SPeter Xu 
50903b0516SPeter Xu 	assert(dev);
51903b0516SPeter Xu 
52903b0516SPeter Xu 	if (!dev->msi_offset) {
53903b0516SPeter Xu 		printf("MSI: dev 0x%x does not support MSI.\n", dev->bdf);
54903b0516SPeter Xu 		return false;
55903b0516SPeter Xu 	}
56903b0516SPeter Xu 
57903b0516SPeter Xu 	addr = dev->bdf;
58903b0516SPeter Xu 	offset = dev->msi_offset;
59903b0516SPeter Xu 	msi_control = pci_config_readw(addr, offset + PCI_MSI_FLAGS);
60903b0516SPeter Xu 	pci_config_writel(addr, offset + PCI_MSI_ADDRESS_LO,
61903b0516SPeter Xu 			  msi_addr & 0xffffffff);
62903b0516SPeter Xu 
63903b0516SPeter Xu 	if (msi_control & PCI_MSI_FLAGS_64BIT) {
64903b0516SPeter Xu 		pci_config_writel(addr, offset + PCI_MSI_ADDRESS_HI,
65903b0516SPeter Xu 				  (uint32_t)(msi_addr >> 32));
66903b0516SPeter Xu 		pci_config_writel(addr, offset + PCI_MSI_DATA_64, msi_data);
67903b0516SPeter Xu 		printf("MSI: dev 0x%x init 64bit address: ", addr);
68903b0516SPeter Xu 	} else {
69903b0516SPeter Xu 		pci_config_writel(addr, offset + PCI_MSI_DATA_32, msi_data);
70903b0516SPeter Xu 		printf("MSI: dev 0x%x init 32bit address: ", addr);
71903b0516SPeter Xu 	}
727c305137SAlex Bennée 	printf("addr=0x%" PRIx64 ", data=0x%x\n", msi_addr, msi_data);
73903b0516SPeter Xu 
7419daf1c5SPeter Xu 	pci_msi_set_enable(dev, true);
75903b0516SPeter Xu 
76903b0516SPeter Xu 	return true;
77903b0516SPeter Xu }
78903b0516SPeter Xu 
7966082ed6SPeter Xu void pci_cmd_set_clr(struct pci_dev *dev, uint16_t set, uint16_t clr)
8066082ed6SPeter Xu {
8166082ed6SPeter Xu 	uint16_t val = pci_config_readw(dev->bdf, PCI_COMMAND);
8266082ed6SPeter Xu 
8366082ed6SPeter Xu 	/* No overlap is allowed */
8466082ed6SPeter Xu 	assert((set & clr) == 0);
8566082ed6SPeter Xu 	val |= set;
8666082ed6SPeter Xu 	val &= ~clr;
8766082ed6SPeter Xu 
8866082ed6SPeter Xu 	pci_config_writew(dev->bdf, PCI_COMMAND, val);
8966082ed6SPeter Xu }
9066082ed6SPeter Xu 
91e1cad5c8SAlexander Gordeev bool pci_dev_exists(pcidevaddr_t dev)
92e1cad5c8SAlexander Gordeev {
93e1cad5c8SAlexander Gordeev 	return (pci_config_readw(dev, PCI_VENDOR_ID) != 0xffff &&
94e1cad5c8SAlexander Gordeev 		pci_config_readw(dev, PCI_DEVICE_ID) != 0xffff);
95e1cad5c8SAlexander Gordeev }
96e1cad5c8SAlexander Gordeev 
974d6cefa9SPeter Xu void pci_dev_init(struct pci_dev *dev, pcidevaddr_t bdf)
984d6cefa9SPeter Xu {
994d6cefa9SPeter Xu        memset(dev, 0, sizeof(*dev));
1004d6cefa9SPeter Xu        dev->bdf = bdf;
1014d6cefa9SPeter Xu }
1024d6cefa9SPeter Xu 
1034932b58aSMichael S. Tsirkin /* Scan bus look for a specific device. Only bus 0 scanned for now. */
1044932b58aSMichael S. Tsirkin pcidevaddr_t pci_find_dev(uint16_t vendor_id, uint16_t device_id)
1054932b58aSMichael S. Tsirkin {
106ebb58e7eSAlexander Gordeev 	pcidevaddr_t dev;
107ebb58e7eSAlexander Gordeev 
1084d6cefa9SPeter Xu 	for (dev = 0; dev < PCI_DEVFN_MAX; ++dev) {
109d8369c77SAlexander Gordeev 		if (pci_config_readw(dev, PCI_VENDOR_ID) == vendor_id &&
110d8369c77SAlexander Gordeev 		    pci_config_readw(dev, PCI_DEVICE_ID) == device_id)
1114932b58aSMichael S. Tsirkin 			return dev;
1124932b58aSMichael S. Tsirkin 	}
113ebb58e7eSAlexander Gordeev 
1144932b58aSMichael S. Tsirkin 	return PCIDEVADDR_INVALID;
1154932b58aSMichael S. Tsirkin }
1164932b58aSMichael S. Tsirkin 
11733d78b07SAlexander Gordeev uint32_t pci_bar_mask(uint32_t bar)
1182455ef20SAlexander Gordeev {
1192455ef20SAlexander Gordeev 	return (bar & PCI_BASE_ADDRESS_SPACE_IO) ?
1202455ef20SAlexander Gordeev 		PCI_BASE_ADDRESS_IO_MASK : PCI_BASE_ADDRESS_MEM_MASK;
1212455ef20SAlexander Gordeev }
1222455ef20SAlexander Gordeev 
1234d6cefa9SPeter Xu uint32_t pci_bar_get(struct pci_dev *dev, int bar_num)
1247aa83307SAlexander Gordeev {
1254d6cefa9SPeter Xu 	return pci_config_readl(dev->bdf, PCI_BASE_ADDRESS_0 +
1264d6cefa9SPeter Xu 				bar_num * 4);
1277aa83307SAlexander Gordeev }
1287aa83307SAlexander Gordeev 
1294d6cefa9SPeter Xu phys_addr_t pci_bar_get_addr(struct pci_dev *dev, int bar_num)
1304932b58aSMichael S. Tsirkin {
1317aa83307SAlexander Gordeev 	uint32_t bar = pci_bar_get(dev, bar_num);
1322455ef20SAlexander Gordeev 	uint32_t mask = pci_bar_mask(bar);
1332455ef20SAlexander Gordeev 	uint64_t addr = bar & mask;
134647d2ab7SAlexander Gordeev 	phys_addr_t phys_addr;
135ebb58e7eSAlexander Gordeev 
1362455ef20SAlexander Gordeev 	if (pci_bar_is64(dev, bar_num))
1372455ef20SAlexander Gordeev 		addr |= (uint64_t)pci_bar_get(dev, bar_num + 1) << 32;
1382455ef20SAlexander Gordeev 
1394d6cefa9SPeter Xu 	phys_addr = pci_translate_addr(dev->bdf, addr);
140647d2ab7SAlexander Gordeev 	assert(phys_addr != INVALID_PHYS_ADDR);
141647d2ab7SAlexander Gordeev 
142647d2ab7SAlexander Gordeev 	return phys_addr;
1432455ef20SAlexander Gordeev }
1442455ef20SAlexander Gordeev 
1454d6cefa9SPeter Xu void pci_bar_set_addr(struct pci_dev *dev, int bar_num, phys_addr_t addr)
146647f92c7SAlexander Gordeev {
147647f92c7SAlexander Gordeev 	int off = PCI_BASE_ADDRESS_0 + bar_num * 4;
148647f92c7SAlexander Gordeev 
1494d6cefa9SPeter Xu 	pci_config_writel(dev->bdf, off, (uint32_t)addr);
150647f92c7SAlexander Gordeev 
151647f92c7SAlexander Gordeev 	if (pci_bar_is64(dev, bar_num))
1524d6cefa9SPeter Xu 		pci_config_writel(dev->bdf, off + 4,
1534d6cefa9SPeter Xu 				  (uint32_t)(addr >> 32));
154647f92c7SAlexander Gordeev }
155647f92c7SAlexander Gordeev 
1562455ef20SAlexander Gordeev /*
1572455ef20SAlexander Gordeev  * To determine the amount of address space needed by a PCI device,
1582455ef20SAlexander Gordeev  * one must save the original value of the BAR, write a value of
1592455ef20SAlexander Gordeev  * all 1's to the register, and then read it back. The amount of
1602455ef20SAlexander Gordeev  * memory can be then determined by masking the information bits,
1612455ef20SAlexander Gordeev  * performing a bitwise NOT, and incrementing the value by 1.
1622455ef20SAlexander Gordeev  *
1632455ef20SAlexander Gordeev  * The following pci_bar_size_helper() and pci_bar_size() functions
1642455ef20SAlexander Gordeev  * implement the algorithm.
1652455ef20SAlexander Gordeev  */
1664d6cefa9SPeter Xu static uint32_t pci_bar_size_helper(struct pci_dev *dev, int bar_num)
1672455ef20SAlexander Gordeev {
1682455ef20SAlexander Gordeev 	int off = PCI_BASE_ADDRESS_0 + bar_num * 4;
1694d6cefa9SPeter Xu 	uint16_t bdf = dev->bdf;
1702455ef20SAlexander Gordeev 	uint32_t bar, val;
1712455ef20SAlexander Gordeev 
1724d6cefa9SPeter Xu 	bar = pci_config_readl(bdf, off);
1734d6cefa9SPeter Xu 	pci_config_writel(bdf, off, ~0u);
1744d6cefa9SPeter Xu 	val = pci_config_readl(bdf, off);
1754d6cefa9SPeter Xu 	pci_config_writel(bdf, off, bar);
1762455ef20SAlexander Gordeev 
1772455ef20SAlexander Gordeev 	return val;
1782455ef20SAlexander Gordeev }
1792455ef20SAlexander Gordeev 
1804d6cefa9SPeter Xu phys_addr_t pci_bar_size(struct pci_dev *dev, int bar_num)
1812455ef20SAlexander Gordeev {
1822455ef20SAlexander Gordeev 	uint32_t bar, size;
1832455ef20SAlexander Gordeev 
1842455ef20SAlexander Gordeev 	size = pci_bar_size_helper(dev, bar_num);
1852455ef20SAlexander Gordeev 	if (!size)
1862455ef20SAlexander Gordeev 		return 0;
1872455ef20SAlexander Gordeev 
1882455ef20SAlexander Gordeev 	bar = pci_bar_get(dev, bar_num);
1892455ef20SAlexander Gordeev 	size &= pci_bar_mask(bar);
1902455ef20SAlexander Gordeev 
1912455ef20SAlexander Gordeev 	if (pci_bar_is64(dev, bar_num)) {
1922455ef20SAlexander Gordeev 		phys_addr_t size64 = pci_bar_size_helper(dev, bar_num + 1);
1932455ef20SAlexander Gordeev 		size64 = (size64 << 32) | size;
1942455ef20SAlexander Gordeev 
1952455ef20SAlexander Gordeev 		return ~size64 + 1;
1962455ef20SAlexander Gordeev 	} else {
1972455ef20SAlexander Gordeev 		return ~size + 1;
1982455ef20SAlexander Gordeev 	}
1994932b58aSMichael S. Tsirkin }
2004932b58aSMichael S. Tsirkin 
2014d6cefa9SPeter Xu bool pci_bar_is_memory(struct pci_dev *dev, int bar_num)
2024932b58aSMichael S. Tsirkin {
2037aa83307SAlexander Gordeev 	uint32_t bar = pci_bar_get(dev, bar_num);
204ebb58e7eSAlexander Gordeev 
2054932b58aSMichael S. Tsirkin 	return !(bar & PCI_BASE_ADDRESS_SPACE_IO);
2064932b58aSMichael S. Tsirkin }
2074932b58aSMichael S. Tsirkin 
2084d6cefa9SPeter Xu bool pci_bar_is_valid(struct pci_dev *dev, int bar_num)
2094932b58aSMichael S. Tsirkin {
2107aa83307SAlexander Gordeev 	return pci_bar_get(dev, bar_num);
2114932b58aSMichael S. Tsirkin }
2122455ef20SAlexander Gordeev 
2134d6cefa9SPeter Xu bool pci_bar_is64(struct pci_dev *dev, int bar_num)
2142455ef20SAlexander Gordeev {
2152455ef20SAlexander Gordeev 	uint32_t bar = pci_bar_get(dev, bar_num);
2162455ef20SAlexander Gordeev 
2172455ef20SAlexander Gordeev 	if (bar & PCI_BASE_ADDRESS_SPACE_IO)
2182455ef20SAlexander Gordeev 		return false;
2192455ef20SAlexander Gordeev 
2202455ef20SAlexander Gordeev 	return (bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK) ==
2212455ef20SAlexander Gordeev 		      PCI_BASE_ADDRESS_MEM_TYPE_64;
2222455ef20SAlexander Gordeev }
223e4611520SAlexander Gordeev 
2244d6cefa9SPeter Xu void pci_bar_print(struct pci_dev *dev, int bar_num)
225e4611520SAlexander Gordeev {
226e4611520SAlexander Gordeev 	phys_addr_t size, start, end;
227e4611520SAlexander Gordeev 	uint32_t bar;
228e4611520SAlexander Gordeev 
229e4611520SAlexander Gordeev 	size = pci_bar_size(dev, bar_num);
230e4611520SAlexander Gordeev 	if (!size)
231e4611520SAlexander Gordeev 		return;
232e4611520SAlexander Gordeev 
233e4611520SAlexander Gordeev 	bar = pci_bar_get(dev, bar_num);
234e4611520SAlexander Gordeev 	start = pci_bar_get_addr(dev, bar_num);
235e4611520SAlexander Gordeev 	end = start + size - 1;
236e4611520SAlexander Gordeev 
237e4611520SAlexander Gordeev 	if (pci_bar_is64(dev, bar_num)) {
238e4611520SAlexander Gordeev 		printf("BAR#%d,%d [%" PRIx64 "-%" PRIx64 " ",
239e4611520SAlexander Gordeev 		       bar_num, bar_num + 1, start, end);
240e4611520SAlexander Gordeev 	} else {
241e4611520SAlexander Gordeev 		printf("BAR#%d [%02x-%02x ",
242e4611520SAlexander Gordeev 		       bar_num, (uint32_t)start, (uint32_t)end);
243e4611520SAlexander Gordeev 	}
244e4611520SAlexander Gordeev 
245e4611520SAlexander Gordeev 	if (bar & PCI_BASE_ADDRESS_SPACE_IO) {
246e4611520SAlexander Gordeev 		printf("PIO");
247e4611520SAlexander Gordeev 	} else {
248e4611520SAlexander Gordeev 		printf("MEM");
249e4611520SAlexander Gordeev 		switch (bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
250e4611520SAlexander Gordeev 		case PCI_BASE_ADDRESS_MEM_TYPE_32:
251e4611520SAlexander Gordeev 			printf("32");
252e4611520SAlexander Gordeev 			break;
253e4611520SAlexander Gordeev 		case PCI_BASE_ADDRESS_MEM_TYPE_1M:
254e4611520SAlexander Gordeev 			printf("1M");
255e4611520SAlexander Gordeev 			break;
256e4611520SAlexander Gordeev 		case PCI_BASE_ADDRESS_MEM_TYPE_64:
257e4611520SAlexander Gordeev 			printf("64");
258e4611520SAlexander Gordeev 			break;
259e4611520SAlexander Gordeev 		default:
260e4611520SAlexander Gordeev 			assert(0);
261e4611520SAlexander Gordeev 		}
262e4611520SAlexander Gordeev 	}
263e4611520SAlexander Gordeev 
264e4611520SAlexander Gordeev 	if (bar & PCI_BASE_ADDRESS_MEM_PREFETCH)
265e4611520SAlexander Gordeev 		printf("/p");
266e4611520SAlexander Gordeev 
267e4611520SAlexander Gordeev 	printf("]");
268e4611520SAlexander Gordeev }
269e4611520SAlexander Gordeev 
27033d78b07SAlexander Gordeev void pci_dev_print_id(pcidevaddr_t dev)
271e4611520SAlexander Gordeev {
272e4611520SAlexander Gordeev 	printf("00.%02x.%1x %04x:%04x", dev / 8, dev % 8,
273e4611520SAlexander Gordeev 		pci_config_readw(dev, PCI_VENDOR_ID),
274e4611520SAlexander Gordeev 		pci_config_readw(dev, PCI_DEVICE_ID));
275e4611520SAlexander Gordeev }
276e4611520SAlexander Gordeev 
277e4611520SAlexander Gordeev static void pci_dev_print(pcidevaddr_t dev)
278e4611520SAlexander Gordeev {
279e4611520SAlexander Gordeev 	uint8_t header = pci_config_readb(dev, PCI_HEADER_TYPE);
280e4611520SAlexander Gordeev 	uint8_t progif = pci_config_readb(dev, PCI_CLASS_PROG);
281e4611520SAlexander Gordeev 	uint8_t subclass = pci_config_readb(dev, PCI_CLASS_DEVICE);
282e4611520SAlexander Gordeev 	uint8_t class = pci_config_readb(dev, PCI_CLASS_DEVICE + 1);
2834d6cefa9SPeter Xu 	struct pci_dev pci_dev;
284e4611520SAlexander Gordeev 	int i;
285e4611520SAlexander Gordeev 
2864d6cefa9SPeter Xu 	pci_dev_init(&pci_dev, dev);
2874d6cefa9SPeter Xu 
288e4611520SAlexander Gordeev 	pci_dev_print_id(dev);
289e4611520SAlexander Gordeev 	printf(" type %02x progif %02x class %02x subclass %02x\n",
290e4611520SAlexander Gordeev 	       header, progif, class, subclass);
291e4611520SAlexander Gordeev 
292e4611520SAlexander Gordeev 	if ((header & PCI_HEADER_TYPE_MASK) != PCI_HEADER_TYPE_NORMAL)
293e4611520SAlexander Gordeev 		return;
294e4611520SAlexander Gordeev 
295e954ce23SPeter Xu 	for (i = 0; i < PCI_BAR_NUM; i++) {
2964d6cefa9SPeter Xu 		if (pci_bar_size(&pci_dev, i)) {
297e4611520SAlexander Gordeev 			printf("\t");
2984d6cefa9SPeter Xu 			pci_bar_print(&pci_dev, i);
299e4611520SAlexander Gordeev 			printf("\n");
300e4611520SAlexander Gordeev 		}
3014d6cefa9SPeter Xu 		if (pci_bar_is64(&pci_dev, i))
302e4611520SAlexander Gordeev 			i++;
303e4611520SAlexander Gordeev 	}
304e4611520SAlexander Gordeev }
305e4611520SAlexander Gordeev 
306e4611520SAlexander Gordeev void pci_print(void)
307e4611520SAlexander Gordeev {
308e4611520SAlexander Gordeev 	pcidevaddr_t dev;
309e4611520SAlexander Gordeev 
3104d6cefa9SPeter Xu 	for (dev = 0; dev < PCI_DEVFN_MAX; ++dev) {
311e4611520SAlexander Gordeev 		if (pci_dev_exists(dev))
312e4611520SAlexander Gordeev 			pci_dev_print(dev);
313e4611520SAlexander Gordeev 	}
314e4611520SAlexander Gordeev }
315e954ce23SPeter Xu 
316e954ce23SPeter Xu void pci_scan_bars(struct pci_dev *dev)
317e954ce23SPeter Xu {
318e954ce23SPeter Xu 	int i;
319e954ce23SPeter Xu 
320e954ce23SPeter Xu 	for (i = 0; i < PCI_BAR_NUM; i++) {
321e954ce23SPeter Xu 		if (!pci_bar_is_valid(dev, i))
322e954ce23SPeter Xu 			continue;
323e954ce23SPeter Xu 		dev->resource[i] = pci_bar_get_addr(dev, i);
324e954ce23SPeter Xu 		if (pci_bar_is64(dev, i)) {
325e954ce23SPeter Xu 			i++;
326e954ce23SPeter Xu 			dev->resource[i] = (phys_addr_t)0;
327e954ce23SPeter Xu 		}
328e954ce23SPeter Xu 	}
329e954ce23SPeter Xu }
33066082ed6SPeter Xu 
331352096c7SPeter Xu uint8_t pci_intx_line(struct pci_dev *dev)
332352096c7SPeter Xu {
333352096c7SPeter Xu 	return pci_config_readb(dev->bdf, PCI_INTERRUPT_LINE);
334352096c7SPeter Xu }
335352096c7SPeter Xu 
336*cdccea7cSAndrew Jones static void pci_cap_setup(struct pci_dev *dev, int cap_offset, int cap_id)
337*cdccea7cSAndrew Jones {
338*cdccea7cSAndrew Jones 	switch (cap_id) {
339*cdccea7cSAndrew Jones 	case PCI_CAP_ID_MSI:
340*cdccea7cSAndrew Jones 		printf("Detected MSI for device 0x%x offset 0x%x\n",
341*cdccea7cSAndrew Jones 			dev->bdf, cap_offset);
342*cdccea7cSAndrew Jones 		dev->msi_offset = cap_offset;
343*cdccea7cSAndrew Jones 		break;
344*cdccea7cSAndrew Jones 	}
345*cdccea7cSAndrew Jones }
346*cdccea7cSAndrew Jones 
34766082ed6SPeter Xu void pci_enable_defaults(struct pci_dev *dev)
34866082ed6SPeter Xu {
34966082ed6SPeter Xu 	pci_scan_bars(dev);
35066082ed6SPeter Xu 	/* Enable device DMA operations */
35166082ed6SPeter Xu 	pci_cmd_set_clr(dev, PCI_COMMAND_MASTER, 0);
352*cdccea7cSAndrew Jones 	pci_cap_walk(dev, pci_cap_setup);
35366082ed6SPeter Xu }
354