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); 228