test/dm/pci.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Google, Inc
   4  */
   5
   6 #include <dm.h>
   7 #include <asm/io.h>
   8 #include <asm/test.h>
   9 #include <dm/test.h>
  10 #include <test/test.h>
  11 #include <test/ut.h>
  12
  13 /* Test that sandbox PCI works correctly */
  14 static int dm_test_pci_base(struct unit_test_state *uts)
  15 {
  16         struct udevice *bus;
  17
  18         ut_assertok(uclass_get_device(UCLASS_PCI, 0, &bus));
  19
  20         return 0;
  21 }
  22 DM_TEST(dm_test_pci_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
  23
  24 /* Test that sandbox PCI bus numbering and device works correctly */
  25 static int dm_test_pci_busdev(struct unit_test_state *uts)
  26 {
  27         struct udevice *bus;
  28         struct udevice *swap;
  29         u16 vendor, device;
  30
  31         /* Test bus#0 and its devices */
  32         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 0, &bus));
  33
  34         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x00, 0), &swap));
  35         vendor = 0;
  36         ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor));
  37         ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor);
  38         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap));
  39         device = 0;
  40         ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device));
  41         ut_asserteq(SANDBOX_PCI_SWAP_CASE_EMUL_ID, device);
  42
  43         /* Test bus#1 and its devices */
  44         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
  45
  46         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
  47         vendor = 0;
  48         ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor));
  49         ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor);
  50         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x0c, 0), &swap));
  51         device = 0;
  52         ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device));
  53         ut_asserteq(SANDBOX_PCI_SWAP_CASE_EMUL_ID, device);
  54
  55         return 0;
  56 }
  57 DM_TEST(dm_test_pci_busdev, UTF_SCAN_PDATA | UTF_SCAN_FDT);
  58
  59 /* Test that we can use the swapcase device correctly */
  60 static int dm_test_pci_swapcase(struct unit_test_state *uts)
  61 {
  62         struct udevice *swap;
  63         ulong io_addr, mem_addr;
  64         char *ptr;
  65
  66         /* Check that asking for the device 0 automatically fires up PCI */
  67         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x00, 0), &swap));
  68
  69         /* First test I/O */
  70         io_addr = dm_pci_read_bar32(swap, 0);
  71         outb(2, io_addr);
  72         ut_asserteq(2, inb(io_addr));
  73
  74         /*
  75          * Now test memory mapping - note we must unmap and remap to cause
  76          * the swapcase emulation to see our data and response.
  77          */
  78         mem_addr = dm_pci_read_bar32(swap, 1);
  79         ptr = map_sysmem(mem_addr, 20);
  80         strcpy(ptr, "This is a TesT");
  81         unmap_sysmem(ptr);
  82
  83         ptr = map_sysmem(mem_addr, 20);
  84         ut_asserteq_str("tHIS IS A tESt", ptr);
  85         unmap_sysmem(ptr);
  86
  87         /* Check that asking for the device 1 automatically fires up PCI */
  88         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap));
  89
  90         /* First test I/O */
  91         io_addr = dm_pci_read_bar32(swap, 0);
  92         outb(2, io_addr);
  93         ut_asserteq(2, inb(io_addr));
  94
  95         /*
  96          * Now test memory mapping - note we must unmap and remap to cause
  97          * the swapcase emulation to see our data and response.
  98          */
  99         mem_addr = dm_pci_read_bar32(swap, 1);
 100         ptr = map_sysmem(mem_addr, 20);
 101         strcpy(ptr, "This is a TesT");
 102         unmap_sysmem(ptr);
 103
 104         ptr = map_sysmem(mem_addr, 20);
 105         ut_asserteq_str("tHIS IS A tESt", ptr);
 106         unmap_sysmem(ptr);
 107
 108         return 0;
 109 }
 110 DM_TEST(dm_test_pci_swapcase, UTF_SCAN_PDATA | UTF_SCAN_FDT);
 111
 112 /* Test that we can dynamically bind the device driver correctly */
 113 static int dm_test_pci_drvdata(struct unit_test_state *uts)
 114 {
 115         struct udevice *bus, *swap;
 116
 117         /* Check that asking for the device automatically fires up PCI */
 118         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
 119
 120         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
 121         ut_asserteq(SWAP_CASE_DRV_DATA, swap->driver_data);
 122         ut_assertok(dev_has_ofnode(swap));
 123         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x0c, 0), &swap));
 124         ut_asserteq(SWAP_CASE_DRV_DATA, swap->driver_data);
 125         ut_assertok(dev_has_ofnode(swap));
 126         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x10, 0), &swap));
 127         ut_asserteq(SWAP_CASE_DRV_DATA, swap->driver_data);
 128         ut_assertok(!dev_has_ofnode(swap));
 129
 130         return 0;
 131 }
 132 DM_TEST(dm_test_pci_drvdata, UTF_SCAN_PDATA | UTF_SCAN_FDT);
 133
 134 /* Test that devices on PCI bus#2 can be accessed correctly */
 135 static int dm_test_pci_mixed(struct unit_test_state *uts)
 136 {
 137         /* PCI bus#2 has both statically and dynamic declared devices */
 138         struct udevice *bus, *swap;
 139         u16 vendor, device;
 140         ulong io_addr, mem_addr;
 141         char *ptr;
 142
 143         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 2, &bus));
 144
 145         /* Test the dynamic device */
 146         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(2, 0x08, 0), &swap));
 147         vendor = 0;
 148         ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor));
 149         ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor);
 150
 151         /* First test I/O */
 152         io_addr = dm_pci_read_bar32(swap, 0);
 153         outb(2, io_addr);
 154         ut_asserteq(2, inb(io_addr));
 155
 156         /*
 157          * Now test memory mapping - note we must unmap and remap to cause
 158          * the swapcase emulation to see our data and response.
 159          */
 160         mem_addr = dm_pci_read_bar32(swap, 1);
 161         ptr = map_sysmem(mem_addr, 30);
 162         strcpy(ptr, "This is a TesT oN dYNAMIc");
 163         unmap_sysmem(ptr);
 164
 165         ptr = map_sysmem(mem_addr, 30);
 166         ut_asserteq_str("tHIS IS A tESt On DynamiC", ptr);
 167         unmap_sysmem(ptr);
 168
 169         /* Test the static device */
 170         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(2, 0x1f, 0), &swap));
 171         device = 0;
 172         ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device));
 173         ut_asserteq(SANDBOX_PCI_SWAP_CASE_EMUL_ID, device);
 174
 175         /* First test I/O */
 176         io_addr = dm_pci_read_bar32(swap, 0);
 177         outb(2, io_addr);
 178         ut_asserteq(2, inb(io_addr));
 179
 180         /*
 181          * Now test memory mapping - note we must unmap and remap to cause
 182          * the swapcase emulation to see our data and response.
 183          */
 184         mem_addr = dm_pci_read_bar32(swap, 1);
 185         ptr = map_sysmem(mem_addr, 30);
 186         strcpy(ptr, "This is a TesT oN sTATIc");
 187         unmap_sysmem(ptr);
 188
 189         ptr = map_sysmem(mem_addr, 30);
 190         ut_asserteq_str("tHIS IS A tESt On StatiC", ptr);
 191         unmap_sysmem(ptr);
 192
 193         return 0;
 194 }
 195 DM_TEST(dm_test_pci_mixed, UTF_SCAN_PDATA | UTF_SCAN_FDT);
 196
 197 /* Test looking up PCI capability and extended capability */
 198 static int dm_test_pci_cap(struct unit_test_state *uts)
 199 {
 200         struct udevice *bus, *swap;
 201         int cap;
 202
 203         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 0, &bus));
 204         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap));
 205
 206         /* look up PCI_CAP_ID_EXP */
 207         cap = dm_pci_find_capability(swap, PCI_CAP_ID_EXP);
 208         ut_asserteq(PCI_CAP_ID_EXP_OFFSET, cap);
 209
 210         /* look up PCI_CAP_ID_PCIX */
 211         cap = dm_pci_find_capability(swap, PCI_CAP_ID_PCIX);
 212         ut_asserteq(0, cap);
 213
 214         /* look up PCI_CAP_ID_MSIX starting from PCI_CAP_ID_PM_OFFSET */
 215         cap = dm_pci_find_next_capability(swap, PCI_CAP_ID_PM_OFFSET,
 216                                           PCI_CAP_ID_MSIX);
 217         ut_asserteq(PCI_CAP_ID_MSIX_OFFSET, cap);
 218
 219         /* look up PCI_CAP_ID_VNDR starting from PCI_CAP_ID_EXP_OFFSET */
 220         cap = dm_pci_find_next_capability(swap, PCI_CAP_ID_EXP_OFFSET,
 221                                           PCI_CAP_ID_VNDR);
 222         ut_asserteq(0, cap);
 223
 224         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
 225         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
 226
 227         /* look up PCI_EXT_CAP_ID_DSN */
 228         cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_DSN);
 229         ut_asserteq(PCI_EXT_CAP_ID_DSN_OFFSET, cap);
 230
 231         /* look up PCI_EXT_CAP_ID_SRIOV */
 232         cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_SRIOV);
 233         ut_asserteq(0, cap);
 234
 235         /* look up PCI_EXT_CAP_ID_DSN starting from PCI_EXT_CAP_ID_ERR_OFFSET */
 236         cap = dm_pci_find_next_ext_capability(swap, PCI_EXT_CAP_ID_ERR_OFFSET,
 237                                               PCI_EXT_CAP_ID_DSN);
 238         ut_asserteq(PCI_EXT_CAP_ID_DSN_OFFSET, cap);
 239
 240         /* look up PCI_EXT_CAP_ID_RCRB starting from PCI_EXT_CAP_ID_VC_OFFSET */
 241         cap = dm_pci_find_next_ext_capability(swap, PCI_EXT_CAP_ID_VC_OFFSET,
 242                                               PCI_EXT_CAP_ID_RCRB);
 243         ut_asserteq(0, cap);
 244
 245         return 0;
 246 }
 247 DM_TEST(dm_test_pci_cap, UTF_SCAN_PDATA | UTF_SCAN_FDT);
 248
 249 /* Test looking up BARs in EA capability structure */
 250 static int dm_test_pci_ea(struct unit_test_state *uts)
 251 {
 252         struct udevice *bus, *swap;
 253         void *bar;
 254         int cap;
 255
 256         /*
 257          * use emulated device mapping function, we're not using real physical
 258          * addresses in this test
 259          */
 260         sandbox_set_enable_pci_map(true);
 261
 262         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 0, &bus));
 263         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x01, 0), &swap));
 264
 265         /* look up PCI_CAP_ID_EA */
 266         cap = dm_pci_find_capability(swap, PCI_CAP_ID_EA);
 267         ut_asserteq(PCI_CAP_ID_EA_OFFSET, cap);
 268
 269         /* test swap case in BAR 1 */
 270         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_TYPE, 0);
 271         ut_assertnonnull(bar);
 272         *(int *)bar = 2; /* swap upper/lower */
 273
 274         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_1, 0, 0, PCI_REGION_TYPE, 0);
 275         ut_assertnonnull(bar);
 276         strcpy(bar, "ea TEST");
 277         unmap_sysmem(bar);
 278         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_1, 0, 0, PCI_REGION_TYPE, 0);
 279         ut_assertnonnull(bar);
 280         ut_asserteq_str("EA test", bar);
 281
 282         /* test magic values in BARs2, 4;  BAR 3 is n/a */
 283         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_2, 0, 0, PCI_REGION_TYPE, 0);
 284         ut_assertnonnull(bar);
 285         ut_asserteq(PCI_EA_BAR2_MAGIC, *(u32 *)bar);
 286
 287         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_3, 0, 0, PCI_REGION_TYPE, 0);
 288         ut_assertnull(bar);
 289
 290         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_4, 0, 0, PCI_REGION_TYPE, 0);
 291         ut_assertnonnull(bar);
 292         ut_asserteq(PCI_EA_BAR4_MAGIC, *(u32 *)bar);
 293
 294         return 0;
 295 }
 296 DM_TEST(dm_test_pci_ea, UTF_SCAN_PDATA | UTF_SCAN_FDT);
 297
 298 /* Test the dev_read_addr_pci() function */
 299 static int dm_test_pci_addr_flat(struct unit_test_state *uts)
 300 {
 301         struct udevice *swap1f, *swap1;
 302         ulong io_addr, mem_addr;
 303         fdt_addr_t size;
 304
 305         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap1f));
 306         io_addr = dm_pci_read_bar32(swap1f, 0);
 307         ut_asserteq(io_addr, dev_read_addr_pci(swap1f, &size));
 308         ut_asserteq(0, size);
 309
 310         /*
 311          * This device has both I/O and MEM spaces but the MEM space appears
 312          * first
 313          */
 314         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1, 0), &swap1));
 315         mem_addr = dm_pci_read_bar32(swap1, 1);
 316         ut_asserteq(mem_addr, dev_read_addr_pci(swap1, &size));
 317         ut_asserteq(0, size);
 318
 319         return 0;
 320 }
 321 DM_TEST(dm_test_pci_addr_flat, UTF_SCAN_PDATA | UTF_SCAN_FDT |
 322                 UTF_FLAT_TREE);
 323
 324 /*
 325  * Test the dev_read_addr_pci() function with livetree. That function is
 326  * not currently fully implemented, in that it fails to return the BAR address.
 327  * Once that is implemented this test can be removed and dm_test_pci_addr_flat()
 328  * can be used for both flattree and livetree by removing the UTF_FLAT_TREE
 329  * flag above.
 330  */
 331 static int dm_test_pci_addr_live(struct unit_test_state *uts)
 332 {
 333         struct udevice *swap1f, *swap1;
 334         fdt_size_t size;
 335
 336         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap1f));
 337         ut_asserteq_64(FDT_ADDR_T_NONE, dev_read_addr_pci(swap1f, &size));
 338         ut_asserteq(0, size);
 339
 340         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1, 0), &swap1));
 341         ut_asserteq_64(FDT_ADDR_T_NONE, dev_read_addr_pci(swap1, &size));
 342         ut_asserteq(0, size);
 343
 344         return 0;
 345 }
 346 DM_TEST(dm_test_pci_addr_live, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_LIVE_TREE);
 347
 348 /* Test device_is_on_pci_bus() */
 349 static int dm_test_pci_on_bus(struct unit_test_state *uts)
 350 {
 351         struct udevice *dev;
 352
 353         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &dev));
 354         ut_asserteq(true, device_is_on_pci_bus(dev));
 355         ut_asserteq(false, device_is_on_pci_bus(dev_get_parent(dev)));
 356         ut_asserteq(true, device_is_on_pci_bus(dev));
 357
 358         return 0;
 359 }
 360 DM_TEST(dm_test_pci_on_bus, UTF_SCAN_PDATA | UTF_SCAN_FDT);
 361
 362 /*
 363  * Test support for multiple memory regions enabled via
 364  * CONFIG_PCI_REGION_MULTI_ENTRY. When this feature is not enabled,
 365  * only the last region of one type is stored. In this test-case,
 366  * we have 2 memory regions, the first at 0x3000.0000 and the 2nd
 367  * at 0x3100.0000. A correct test results now in BAR1 located at
 368  * 0x3000.0000.
 369  */
 370 static int dm_test_pci_region_multi(struct unit_test_state *uts)
 371 {
 372         struct udevice *dev;
 373         ulong mem_addr;
 374
 375         /* Test memory BAR1 on bus#1 */
 376         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &dev));
 377         mem_addr = dm_pci_read_bar32(dev, 1);
 378         ut_asserteq(mem_addr, 0x30000000);
 379
 380         return 0;
 381 }
 382 DM_TEST(dm_test_pci_region_multi, UTF_SCAN_PDATA | UTF_SCAN_FDT);
 383
 384 /*
 385  * Test the translation of PCI bus addresses to physical addresses using the
 386  * ranges from bus#1.
 387  */
 388 static int dm_test_pci_bus_to_phys(struct unit_test_state *uts)
 389 {
 390         unsigned long mask = PCI_REGION_TYPE;
 391         unsigned long flags = PCI_REGION_MEM;
 392         struct udevice *dev;
 393         phys_addr_t phys_addr;
 394
 395         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &dev));
 396
 397         /* Before any of the ranges. */
 398         phys_addr = dm_pci_bus_to_phys(dev, 0x20000000, 0x400, mask, flags);
 399         ut_asserteq(0, phys_addr);
 400
 401         /* Identity range: whole, start, mid, end */
 402         phys_addr = dm_pci_bus_to_phys(dev, 0x2ffff000, 0x2000, mask, flags);
 403         ut_asserteq(0, phys_addr);
 404         phys_addr = dm_pci_bus_to_phys(dev, 0x30000000, 0x2000, mask, flags);
 405         ut_asserteq(0x30000000, phys_addr);
 406         phys_addr = dm_pci_bus_to_phys(dev, 0x30000000, 0x1000, mask, flags);
 407         ut_asserteq(0x30000000, phys_addr);
 408         phys_addr = dm_pci_bus_to_phys(dev, 0x30000abc, 0x12, mask, flags);
 409         ut_asserteq(0x30000abc, phys_addr);
 410         phys_addr = dm_pci_bus_to_phys(dev, 0x30000800, 0x1800, mask, flags);
 411         ut_asserteq(0x30000800, phys_addr);
 412         phys_addr = dm_pci_bus_to_phys(dev, 0x30008000, 0x1801, mask, flags);
 413         ut_asserteq(0, phys_addr);
 414
 415         /* Translated range: whole, start, mid, end */
 416         phys_addr = dm_pci_bus_to_phys(dev, 0x30fff000, 0x2000, mask, flags);
 417         ut_asserteq(0, phys_addr);
 418         phys_addr = dm_pci_bus_to_phys(dev, 0x31000000, 0x2000, mask, flags);
 419         ut_asserteq(0x3e000000, phys_addr);
 420         phys_addr = dm_pci_bus_to_phys(dev, 0x31000000, 0x1000, mask, flags);
 421         ut_asserteq(0x3e000000, phys_addr);
 422         phys_addr = dm_pci_bus_to_phys(dev, 0x31000abc, 0x12, mask, flags);
 423         ut_asserteq(0x3e000abc, phys_addr);
 424         phys_addr = dm_pci_bus_to_phys(dev, 0x31000800, 0x1800, mask, flags);
 425         ut_asserteq(0x3e000800, phys_addr);
 426         phys_addr = dm_pci_bus_to_phys(dev, 0x31008000, 0x1801, mask, flags);
 427         ut_asserteq(0, phys_addr);
 428
 429         /* Beyond all of the ranges. */
 430         phys_addr = dm_pci_bus_to_phys(dev, 0x32000000, 0x400, mask, flags);
 431         ut_asserteq(0, phys_addr);
 432
 433         return 0;
 434 }
 435 DM_TEST(dm_test_pci_bus_to_phys, UTF_SCAN_PDATA | UTF_SCAN_FDT);
 436
 437 /*
 438  * Test the translation of physical addresses to PCI bus addresses using the
 439  * ranges from bus#1.
 440  */
 441 static int dm_test_pci_phys_to_bus(struct unit_test_state *uts)
 442 {
 443         unsigned long mask = PCI_REGION_TYPE;
 444         unsigned long flags = PCI_REGION_MEM;
 445         struct udevice *dev;
 446         pci_addr_t pci_addr;
 447
 448         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &dev));
 449
 450         /* Before any of the ranges. */
 451         pci_addr = dm_pci_phys_to_bus(dev, 0x20000000, 0x400, mask, flags);
 452         ut_asserteq(0, pci_addr);
 453
 454         /* Identity range: partial overlap, whole, start, mid, end */
 455         pci_addr = dm_pci_phys_to_bus(dev, 0x2ffff000, 0x2000, mask, flags);
 456         ut_asserteq(0, pci_addr);
 457         pci_addr = dm_pci_phys_to_bus(dev, 0x30000000, 0x2000, mask, flags);
 458         ut_asserteq(0x30000000, pci_addr);
 459         pci_addr = dm_pci_phys_to_bus(dev, 0x30000000, 0x1000, mask, flags);
 460         ut_asserteq(0x30000000, pci_addr);
 461         pci_addr = dm_pci_phys_to_bus(dev, 0x30000abc, 0x12, mask, flags);
 462         ut_asserteq(0x30000abc, pci_addr);
 463         pci_addr = dm_pci_phys_to_bus(dev, 0x30000800, 0x1800, mask, flags);
 464         ut_asserteq(0x30000800, pci_addr);
 465         pci_addr = dm_pci_phys_to_bus(dev, 0x30008000, 0x1801, mask, flags);
 466         ut_asserteq(0, pci_addr);
 467
 468         /* Translated range: partial overlap, whole, start, mid, end */
 469         pci_addr = dm_pci_phys_to_bus(dev, 0x3dfff000, 0x2000, mask, flags);
 470         ut_asserteq(0, pci_addr);
 471         pci_addr = dm_pci_phys_to_bus(dev, 0x3e000000, 0x2000, mask, flags);
 472         ut_asserteq(0x31000000, pci_addr);
 473         pci_addr = dm_pci_phys_to_bus(dev, 0x3e000000, 0x1000, mask, flags);
 474         ut_asserteq(0x31000000, pci_addr);
 475         pci_addr = dm_pci_phys_to_bus(dev, 0x3e000abc, 0x12, mask, flags);
 476         ut_asserteq(0x31000abc, pci_addr);
 477         pci_addr = dm_pci_phys_to_bus(dev, 0x3e000800, 0x1800, mask, flags);
 478         ut_asserteq(0x31000800, pci_addr);
 479         pci_addr = dm_pci_phys_to_bus(dev, 0x3e008000, 0x1801, mask, flags);
 480         ut_asserteq(0, pci_addr);
 481
 482         /* Beyond all of the ranges. */
 483         pci_addr = dm_pci_phys_to_bus(dev, 0x3f000000, 0x400, mask, flags);
 484         ut_asserteq(0, pci_addr);
 485
 486         return 0;
 487 }
 488 DM_TEST(dm_test_pci_phys_to_bus, UTF_SCAN_PDATA | UTF_SCAN_FDT);