test/dm/pci.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Google, Inc
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <asm/io.h>
   9 #include <asm/test.h>
  10 #include <dm/test.h>
  11 #include <test/test.h>
  12 #include <test/ut.h>
  13
  14 /* Test that sandbox PCI works correctly */
  15 static int dm_test_pci_base(struct unit_test_state *uts)
  16 {
  17         struct udevice *bus;
  18
  19         ut_assertok(uclass_get_device(UCLASS_PCI, 0, &bus));
  20
  21         return 0;
  22 }
  23 DM_TEST(dm_test_pci_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  24
  25 /* Test that sandbox PCI bus numbering and device works correctly */
  26 static int dm_test_pci_busdev(struct unit_test_state *uts)
  27 {
  28         struct udevice *bus;
  29         struct udevice *swap;
  30         u16 vendor, device;
  31
  32         /* Test bus#0 and its devices */
  33         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 0, &bus));
  34
  35         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x00, 0), &swap));
  36         vendor = 0;
  37         ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor));
  38         ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor);
  39         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap));
  40         device = 0;
  41         ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device));
  42         ut_asserteq(SANDBOX_PCI_SWAP_CASE_EMUL_ID, device);
  43
  44         /* Test bus#1 and its devices */
  45         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
  46
  47         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
  48         vendor = 0;
  49         ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor));
  50         ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor);
  51         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x0c, 0), &swap));
  52         device = 0;
  53         ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device));
  54         ut_asserteq(SANDBOX_PCI_SWAP_CASE_EMUL_ID, device);
  55
  56         return 0;
  57 }
  58 DM_TEST(dm_test_pci_busdev, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  59
  60 /* Test that we can use the swapcase device correctly */
  61 static int dm_test_pci_swapcase(struct unit_test_state *uts)
  62 {
  63         struct udevice *swap;
  64         ulong io_addr, mem_addr;
  65         char *ptr;
  66
  67         /* Check that asking for the device 0 automatically fires up PCI */
  68         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x00, 0), &swap));
  69
  70         /* First test I/O */
  71         io_addr = dm_pci_read_bar32(swap, 0);
  72         outb(2, io_addr);
  73         ut_asserteq(2, inb(io_addr));
  74
  75         /*
  76          * Now test memory mapping - note we must unmap and remap to cause
  77          * the swapcase emulation to see our data and response.
  78          */
  79         mem_addr = dm_pci_read_bar32(swap, 1);
  80         ptr = map_sysmem(mem_addr, 20);
  81         strcpy(ptr, "This is a TesT");
  82         unmap_sysmem(ptr);
  83
  84         ptr = map_sysmem(mem_addr, 20);
  85         ut_asserteq_str("tHIS IS A tESt", ptr);
  86         unmap_sysmem(ptr);
  87
  88         /* Check that asking for the device 1 automatically fires up PCI */
  89         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap));
  90
  91         /* First test I/O */
  92         io_addr = dm_pci_read_bar32(swap, 0);
  93         outb(2, io_addr);
  94         ut_asserteq(2, inb(io_addr));
  95
  96         /*
  97          * Now test memory mapping - note we must unmap and remap to cause
  98          * the swapcase emulation to see our data and response.
  99          */
 100         mem_addr = dm_pci_read_bar32(swap, 1);
 101         ptr = map_sysmem(mem_addr, 20);
 102         strcpy(ptr, "This is a TesT");
 103         unmap_sysmem(ptr);
 104
 105         ptr = map_sysmem(mem_addr, 20);
 106         ut_asserteq_str("tHIS IS A tESt", ptr);
 107         unmap_sysmem(ptr);
 108
 109         return 0;
 110 }
 111 DM_TEST(dm_test_pci_swapcase, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 112
 113 /* Test that we can dynamically bind the device driver correctly */
 114 static int dm_test_pci_drvdata(struct unit_test_state *uts)
 115 {
 116         struct udevice *bus, *swap;
 117
 118         /* Check that asking for the device automatically fires up PCI */
 119         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
 120
 121         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
 122         ut_asserteq(SWAP_CASE_DRV_DATA, swap->driver_data);
 123         ut_assertok(dev_has_ofnode(swap));
 124         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x0c, 0), &swap));
 125         ut_asserteq(SWAP_CASE_DRV_DATA, swap->driver_data);
 126         ut_assertok(dev_has_ofnode(swap));
 127         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x10, 0), &swap));
 128         ut_asserteq(SWAP_CASE_DRV_DATA, swap->driver_data);
 129         ut_assertok(!dev_has_ofnode(swap));
 130
 131         return 0;
 132 }
 133 DM_TEST(dm_test_pci_drvdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 134
 135 /* Test that devices on PCI bus#2 can be accessed correctly */
 136 static int dm_test_pci_mixed(struct unit_test_state *uts)
 137 {
 138         /* PCI bus#2 has both statically and dynamic declared devices */
 139         struct udevice *bus, *swap;
 140         u16 vendor, device;
 141         ulong io_addr, mem_addr;
 142         char *ptr;
 143
 144         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 2, &bus));
 145
 146         /* Test the dynamic device */
 147         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(2, 0x08, 0), &swap));
 148         vendor = 0;
 149         ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor));
 150         ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor);
 151
 152         /* First test I/O */
 153         io_addr = dm_pci_read_bar32(swap, 0);
 154         outb(2, io_addr);
 155         ut_asserteq(2, inb(io_addr));
 156
 157         /*
 158          * Now test memory mapping - note we must unmap and remap to cause
 159          * the swapcase emulation to see our data and response.
 160          */
 161         mem_addr = dm_pci_read_bar32(swap, 1);
 162         ptr = map_sysmem(mem_addr, 30);
 163         strcpy(ptr, "This is a TesT oN dYNAMIc");
 164         unmap_sysmem(ptr);
 165
 166         ptr = map_sysmem(mem_addr, 30);
 167         ut_asserteq_str("tHIS IS A tESt On DynamiC", ptr);
 168         unmap_sysmem(ptr);
 169
 170         /* Test the static device */
 171         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(2, 0x1f, 0), &swap));
 172         device = 0;
 173         ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device));
 174         ut_asserteq(SANDBOX_PCI_SWAP_CASE_EMUL_ID, device);
 175
 176         /* First test I/O */
 177         io_addr = dm_pci_read_bar32(swap, 0);
 178         outb(2, io_addr);
 179         ut_asserteq(2, inb(io_addr));
 180
 181         /*
 182          * Now test memory mapping - note we must unmap and remap to cause
 183          * the swapcase emulation to see our data and response.
 184          */
 185         mem_addr = dm_pci_read_bar32(swap, 1);
 186         ptr = map_sysmem(mem_addr, 30);
 187         strcpy(ptr, "This is a TesT oN sTATIc");
 188         unmap_sysmem(ptr);
 189
 190         ptr = map_sysmem(mem_addr, 30);
 191         ut_asserteq_str("tHIS IS A tESt On StatiC", ptr);
 192         unmap_sysmem(ptr);
 193
 194         return 0;
 195 }
 196 DM_TEST(dm_test_pci_mixed, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 197
 198 /* Test looking up PCI capability and extended capability */
 199 static int dm_test_pci_cap(struct unit_test_state *uts)
 200 {
 201         struct udevice *bus, *swap;
 202         int cap;
 203
 204         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 0, &bus));
 205         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap));
 206
 207         /* look up PCI_CAP_ID_EXP */
 208         cap = dm_pci_find_capability(swap, PCI_CAP_ID_EXP);
 209         ut_asserteq(PCI_CAP_ID_EXP_OFFSET, cap);
 210
 211         /* look up PCI_CAP_ID_PCIX */
 212         cap = dm_pci_find_capability(swap, PCI_CAP_ID_PCIX);
 213         ut_asserteq(0, cap);
 214
 215         /* look up PCI_CAP_ID_MSIX starting from PCI_CAP_ID_PM_OFFSET */
 216         cap = dm_pci_find_next_capability(swap, PCI_CAP_ID_PM_OFFSET,
 217                                           PCI_CAP_ID_MSIX);
 218         ut_asserteq(PCI_CAP_ID_MSIX_OFFSET, cap);
 219
 220         /* look up PCI_CAP_ID_VNDR starting from PCI_CAP_ID_EXP_OFFSET */
 221         cap = dm_pci_find_next_capability(swap, PCI_CAP_ID_EXP_OFFSET,
 222                                           PCI_CAP_ID_VNDR);
 223         ut_asserteq(0, cap);
 224
 225         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
 226         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
 227
 228         /* look up PCI_EXT_CAP_ID_DSN */
 229         cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_DSN);
 230         ut_asserteq(PCI_EXT_CAP_ID_DSN_OFFSET, cap);
 231
 232         /* look up PCI_EXT_CAP_ID_SRIOV */
 233         cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_SRIOV);
 234         ut_asserteq(0, cap);
 235
 236         /* look up PCI_EXT_CAP_ID_DSN starting from PCI_EXT_CAP_ID_ERR_OFFSET */
 237         cap = dm_pci_find_next_ext_capability(swap, PCI_EXT_CAP_ID_ERR_OFFSET,
 238                                               PCI_EXT_CAP_ID_DSN);
 239         ut_asserteq(PCI_EXT_CAP_ID_DSN_OFFSET, cap);
 240
 241         /* look up PCI_EXT_CAP_ID_RCRB starting from PCI_EXT_CAP_ID_VC_OFFSET */
 242         cap = dm_pci_find_next_ext_capability(swap, PCI_EXT_CAP_ID_VC_OFFSET,
 243                                               PCI_EXT_CAP_ID_RCRB);
 244         ut_asserteq(0, cap);
 245
 246         return 0;
 247 }
 248 DM_TEST(dm_test_pci_cap, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 249
 250 /* Test looking up BARs in EA capability structure */
 251 static int dm_test_pci_ea(struct unit_test_state *uts)
 252 {
 253         struct udevice *bus, *swap;
 254         void *bar;
 255         int cap;
 256
 257         /*
 258          * use emulated device mapping function, we're not using real physical
 259          * addresses in this test
 260          */
 261         sandbox_set_enable_pci_map(true);
 262
 263         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 0, &bus));
 264         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x01, 0), &swap));
 265
 266         /* look up PCI_CAP_ID_EA */
 267         cap = dm_pci_find_capability(swap, PCI_CAP_ID_EA);
 268         ut_asserteq(PCI_CAP_ID_EA_OFFSET, cap);
 269
 270         /* test swap case in BAR 1 */
 271         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_0, 0);
 272         ut_assertnonnull(bar);
 273         *(int *)bar = 2; /* swap upper/lower */
 274
 275         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_1, 0);
 276         ut_assertnonnull(bar);
 277         strcpy(bar, "ea TEST");
 278         unmap_sysmem(bar);
 279         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_1, 0);
 280         ut_assertnonnull(bar);
 281         ut_asserteq_str("EA test", bar);
 282
 283         /* test magic values in BARs2, 4;  BAR 3 is n/a */
 284         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_2, 0);
 285         ut_assertnonnull(bar);
 286         ut_asserteq(PCI_EA_BAR2_MAGIC, *(u32 *)bar);
 287
 288         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_3, 0);
 289         ut_assertnull(bar);
 290
 291         bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_4, 0);
 292         ut_assertnonnull(bar);
 293         ut_asserteq(PCI_EA_BAR4_MAGIC, *(u32 *)bar);
 294
 295         return 0;
 296 }
 297 DM_TEST(dm_test_pci_ea, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 298
 299 /* Test the dev_read_addr_pci() function */
 300 static int dm_test_pci_addr_flat(struct unit_test_state *uts)
 301 {
 302         struct udevice *swap1f, *swap1;
 303         ulong io_addr, mem_addr;
 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));
 308
 309         /*
 310          * This device has both I/O and MEM spaces but the MEM space appears
 311          * first
 312          */
 313         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1, 0), &swap1));
 314         mem_addr = dm_pci_read_bar32(swap1, 1);
 315         ut_asserteq(mem_addr, dev_read_addr_pci(swap1));
 316
 317         return 0;
 318 }
 319 DM_TEST(dm_test_pci_addr_flat, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT |
 320                 UT_TESTF_FLAT_TREE);
 321
 322 /*
 323  * Test the dev_read_addr_pci() function with livetree. That function is
 324  * not currently fully implemented, in that it fails to return the BAR address.
 325  * Once that is implemented this test can be removed and dm_test_pci_addr_flat()
 326  * can be used for both flattree and livetree by removing the UT_TESTF_FLAT_TREE
 327  * flag above.
 328  */
 329 static int dm_test_pci_addr_live(struct unit_test_state *uts)
 330 {
 331         struct udevice *swap1f, *swap1;
 332
 333         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap1f));
 334         ut_asserteq(FDT_ADDR_T_NONE, dev_read_addr_pci(swap1f));
 335
 336         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1, 0), &swap1));
 337         ut_asserteq(FDT_ADDR_T_NONE, dev_read_addr_pci(swap1));
 338
 339         return 0;
 340 }
 341 DM_TEST(dm_test_pci_addr_live, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT |
 342                 UT_TESTF_LIVE_TREE);
 343
 344 /* Test device_is_on_pci_bus() */
 345 static int dm_test_pci_on_bus(struct unit_test_state *uts)
 346 {
 347         struct udevice *dev;
 348
 349         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &dev));
 350         ut_asserteq(true, device_is_on_pci_bus(dev));
 351         ut_asserteq(false, device_is_on_pci_bus(dev_get_parent(dev)));
 352         ut_asserteq(true, device_is_on_pci_bus(dev));
 353
 354         return 0;
 355 }
 356 DM_TEST(dm_test_pci_on_bus, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 357
 358 /*
 359  * Test support for multiple memory regions enabled via
 360  * CONFIG_PCI_REGION_MULTI_ENTRY. When this feature is not enabled,
 361  * only the last region of one type is stored. In this test-case,
 362  * we have 2 memory regions, the first at 0x3000.0000 and the 2nd
 363  * at 0x3100.0000. A correct test results now in BAR1 located at
 364  * 0x3000.0000.
 365  */
 366 static int dm_test_pci_region_multi(struct unit_test_state *uts)
 367 {
 368         struct udevice *dev;
 369         ulong mem_addr;
 370
 371         /* Test memory BAR1 on bus#1 */
 372         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &dev));
 373         mem_addr = dm_pci_read_bar32(dev, 1);
 374         ut_asserteq(mem_addr, 0x30000000);
 375
 376         return 0;
 377 }
 378 DM_TEST(dm_test_pci_region_multi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);