1 /* 2 * Copyright (C) 2013, Red Hat Inc, Michael S. Tsirkin <mst@redhat.com> 3 * 4 * This work is licensed under the terms of the GNU LGPL, version 2. 5 */ 6 #include <linux/pci_regs.h> 7 #include "pci.h" 8 #include "asm/pci.h" 9 10 bool pci_dev_exists(pcidevaddr_t dev) 11 { 12 return (pci_config_readw(dev, PCI_VENDOR_ID) != 0xffff && 13 pci_config_readw(dev, PCI_DEVICE_ID) != 0xffff); 14 } 15 16 void pci_dev_init(struct pci_dev *dev, pcidevaddr_t bdf) 17 { 18 memset(dev, 0, sizeof(*dev)); 19 dev->bdf = bdf; 20 } 21 22 /* Scan bus look for a specific device. Only bus 0 scanned for now. */ 23 pcidevaddr_t pci_find_dev(uint16_t vendor_id, uint16_t device_id) 24 { 25 pcidevaddr_t dev; 26 27 for (dev = 0; dev < PCI_DEVFN_MAX; ++dev) { 28 if (pci_config_readw(dev, PCI_VENDOR_ID) == vendor_id && 29 pci_config_readw(dev, PCI_DEVICE_ID) == device_id) 30 return dev; 31 } 32 33 return PCIDEVADDR_INVALID; 34 } 35 36 uint32_t pci_bar_mask(uint32_t bar) 37 { 38 return (bar & PCI_BASE_ADDRESS_SPACE_IO) ? 39 PCI_BASE_ADDRESS_IO_MASK : PCI_BASE_ADDRESS_MEM_MASK; 40 } 41 42 uint32_t pci_bar_get(struct pci_dev *dev, int bar_num) 43 { 44 return pci_config_readl(dev->bdf, PCI_BASE_ADDRESS_0 + 45 bar_num * 4); 46 } 47 48 phys_addr_t pci_bar_get_addr(struct pci_dev *dev, int bar_num) 49 { 50 uint32_t bar = pci_bar_get(dev, bar_num); 51 uint32_t mask = pci_bar_mask(bar); 52 uint64_t addr = bar & mask; 53 phys_addr_t phys_addr; 54 55 if (pci_bar_is64(dev, bar_num)) 56 addr |= (uint64_t)pci_bar_get(dev, bar_num + 1) << 32; 57 58 phys_addr = pci_translate_addr(dev->bdf, addr); 59 assert(phys_addr != INVALID_PHYS_ADDR); 60 61 return phys_addr; 62 } 63 64 void pci_bar_set_addr(struct pci_dev *dev, int bar_num, phys_addr_t addr) 65 { 66 int off = PCI_BASE_ADDRESS_0 + bar_num * 4; 67 68 pci_config_writel(dev->bdf, off, (uint32_t)addr); 69 70 if (pci_bar_is64(dev, bar_num)) 71 pci_config_writel(dev->bdf, off + 4, 72 (uint32_t)(addr >> 32)); 73 } 74 75 /* 76 * To determine the amount of address space needed by a PCI device, 77 * one must save the original value of the BAR, write a value of 78 * all 1's to the register, and then read it back. The amount of 79 * memory can be then determined by masking the information bits, 80 * performing a bitwise NOT, and incrementing the value by 1. 81 * 82 * The following pci_bar_size_helper() and pci_bar_size() functions 83 * implement the algorithm. 84 */ 85 static uint32_t pci_bar_size_helper(struct pci_dev *dev, int bar_num) 86 { 87 int off = PCI_BASE_ADDRESS_0 + bar_num * 4; 88 uint16_t bdf = dev->bdf; 89 uint32_t bar, val; 90 91 bar = pci_config_readl(bdf, off); 92 pci_config_writel(bdf, off, ~0u); 93 val = pci_config_readl(bdf, off); 94 pci_config_writel(bdf, off, bar); 95 96 return val; 97 } 98 99 phys_addr_t pci_bar_size(struct pci_dev *dev, int bar_num) 100 { 101 uint32_t bar, size; 102 103 size = pci_bar_size_helper(dev, bar_num); 104 if (!size) 105 return 0; 106 107 bar = pci_bar_get(dev, bar_num); 108 size &= pci_bar_mask(bar); 109 110 if (pci_bar_is64(dev, bar_num)) { 111 phys_addr_t size64 = pci_bar_size_helper(dev, bar_num + 1); 112 size64 = (size64 << 32) | size; 113 114 return ~size64 + 1; 115 } else { 116 return ~size + 1; 117 } 118 } 119 120 bool pci_bar_is_memory(struct pci_dev *dev, int bar_num) 121 { 122 uint32_t bar = pci_bar_get(dev, bar_num); 123 124 return !(bar & PCI_BASE_ADDRESS_SPACE_IO); 125 } 126 127 bool pci_bar_is_valid(struct pci_dev *dev, int bar_num) 128 { 129 return pci_bar_get(dev, bar_num); 130 } 131 132 bool pci_bar_is64(struct pci_dev *dev, int bar_num) 133 { 134 uint32_t bar = pci_bar_get(dev, bar_num); 135 136 if (bar & PCI_BASE_ADDRESS_SPACE_IO) 137 return false; 138 139 return (bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK) == 140 PCI_BASE_ADDRESS_MEM_TYPE_64; 141 } 142 143 void pci_bar_print(struct pci_dev *dev, int bar_num) 144 { 145 phys_addr_t size, start, end; 146 uint32_t bar; 147 148 size = pci_bar_size(dev, bar_num); 149 if (!size) 150 return; 151 152 bar = pci_bar_get(dev, bar_num); 153 start = pci_bar_get_addr(dev, bar_num); 154 end = start + size - 1; 155 156 if (pci_bar_is64(dev, bar_num)) { 157 printf("BAR#%d,%d [%" PRIx64 "-%" PRIx64 " ", 158 bar_num, bar_num + 1, start, end); 159 } else { 160 printf("BAR#%d [%02x-%02x ", 161 bar_num, (uint32_t)start, (uint32_t)end); 162 } 163 164 if (bar & PCI_BASE_ADDRESS_SPACE_IO) { 165 printf("PIO"); 166 } else { 167 printf("MEM"); 168 switch (bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK) { 169 case PCI_BASE_ADDRESS_MEM_TYPE_32: 170 printf("32"); 171 break; 172 case PCI_BASE_ADDRESS_MEM_TYPE_1M: 173 printf("1M"); 174 break; 175 case PCI_BASE_ADDRESS_MEM_TYPE_64: 176 printf("64"); 177 break; 178 default: 179 assert(0); 180 } 181 } 182 183 if (bar & PCI_BASE_ADDRESS_MEM_PREFETCH) 184 printf("/p"); 185 186 printf("]"); 187 } 188 189 void pci_dev_print_id(pcidevaddr_t dev) 190 { 191 printf("00.%02x.%1x %04x:%04x", dev / 8, dev % 8, 192 pci_config_readw(dev, PCI_VENDOR_ID), 193 pci_config_readw(dev, PCI_DEVICE_ID)); 194 } 195 196 static void pci_dev_print(pcidevaddr_t dev) 197 { 198 uint8_t header = pci_config_readb(dev, PCI_HEADER_TYPE); 199 uint8_t progif = pci_config_readb(dev, PCI_CLASS_PROG); 200 uint8_t subclass = pci_config_readb(dev, PCI_CLASS_DEVICE); 201 uint8_t class = pci_config_readb(dev, PCI_CLASS_DEVICE + 1); 202 struct pci_dev pci_dev; 203 int i; 204 205 pci_dev_init(&pci_dev, dev); 206 207 pci_dev_print_id(dev); 208 printf(" type %02x progif %02x class %02x subclass %02x\n", 209 header, progif, class, subclass); 210 211 if ((header & PCI_HEADER_TYPE_MASK) != PCI_HEADER_TYPE_NORMAL) 212 return; 213 214 for (i = 0; i < PCI_BAR_NUM; i++) { 215 if (pci_bar_size(&pci_dev, i)) { 216 printf("\t"); 217 pci_bar_print(&pci_dev, i); 218 printf("\n"); 219 } 220 if (pci_bar_is64(&pci_dev, i)) 221 i++; 222 } 223 } 224 225 void pci_print(void) 226 { 227 pcidevaddr_t dev; 228 229 for (dev = 0; dev < PCI_DEVFN_MAX; ++dev) { 230 if (pci_dev_exists(dev)) 231 pci_dev_print(dev); 232 } 233 } 234 235 void pci_scan_bars(struct pci_dev *dev) 236 { 237 int i; 238 239 for (i = 0; i < PCI_BAR_NUM; i++) { 240 if (!pci_bar_is_valid(dev, i)) 241 continue; 242 dev->resource[i] = pci_bar_get_addr(dev, i); 243 if (pci_bar_is64(dev, i)) { 244 i++; 245 dev->resource[i] = (phys_addr_t)0; 246 } 247 } 248 } 249