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/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, DM_TESTF_SCAN_PDATA | DM_TESTF_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_DEVICE_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_DEVICE_ID, device);
  54
  55         return 0;
  56 }
  57 DM_TEST(dm_test_pci_busdev, DM_TESTF_SCAN_PDATA | DM_TESTF_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, DM_TESTF_SCAN_PDATA | DM_TESTF_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_of_valid(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_of_valid(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_of_valid(swap));
 129
 130         return 0;
 131 }
 132 DM_TEST(dm_test_pci_drvdata, DM_TESTF_SCAN_PDATA | DM_TESTF_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_DEVICE_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, DM_TESTF_SCAN_PDATA | DM_TESTF_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         ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
 215         ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
 216
 217         /* look up PCI_EXT_CAP_ID_DSN */
 218         cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_DSN);
 219         ut_asserteq(PCI_EXT_CAP_ID_DSN_OFFSET, cap);
 220
 221         /* look up PCI_EXT_CAP_ID_SRIOV */
 222         cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_SRIOV);
 223         ut_asserteq(0, cap);
 224
 225         return 0;
 226 }
 227 DM_TEST(dm_test_pci_cap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);