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