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(dm_pci_bus_find_bdf(PCI_BDF(1, 0x0c, 0), &swap)); 123 ut_asserteq(SWAP_CASE_DRV_DATA, swap->driver_data); 124 125 return 0; 126 } 127 DM_TEST(dm_test_pci_drvdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 128 129 /* Test that devices on PCI bus#2 can be accessed correctly */ 130 static int dm_test_pci_mixed(struct unit_test_state *uts) 131 { 132 /* PCI bus#2 has both statically and dynamic declared devices */ 133 struct udevice *bus, *swap; 134 u16 vendor, device; 135 ulong io_addr, mem_addr; 136 char *ptr; 137 138 ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 2, &bus)); 139 140 /* Test the dynamic device */ 141 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(2, 0x08, 0), &swap)); 142 vendor = 0; 143 ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor)); 144 ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor); 145 146 /* First test I/O */ 147 io_addr = dm_pci_read_bar32(swap, 0); 148 outb(2, io_addr); 149 ut_asserteq(2, inb(io_addr)); 150 151 /* 152 * Now test memory mapping - note we must unmap and remap to cause 153 * the swapcase emulation to see our data and response. 154 */ 155 mem_addr = dm_pci_read_bar32(swap, 1); 156 ptr = map_sysmem(mem_addr, 30); 157 strcpy(ptr, "This is a TesT oN dYNAMIc"); 158 unmap_sysmem(ptr); 159 160 ptr = map_sysmem(mem_addr, 30); 161 ut_asserteq_str("tHIS IS A tESt On DynamiC", ptr); 162 unmap_sysmem(ptr); 163 164 /* Test the static device */ 165 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(2, 0x1f, 0), &swap)); 166 device = 0; 167 ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device)); 168 ut_asserteq(SANDBOX_PCI_DEVICE_ID, device); 169 170 /* First test I/O */ 171 io_addr = dm_pci_read_bar32(swap, 0); 172 outb(2, io_addr); 173 ut_asserteq(2, inb(io_addr)); 174 175 /* 176 * Now test memory mapping - note we must unmap and remap to cause 177 * the swapcase emulation to see our data and response. 178 */ 179 mem_addr = dm_pci_read_bar32(swap, 1); 180 ptr = map_sysmem(mem_addr, 30); 181 strcpy(ptr, "This is a TesT oN sTATIc"); 182 unmap_sysmem(ptr); 183 184 ptr = map_sysmem(mem_addr, 30); 185 ut_asserteq_str("tHIS IS A tESt On StatiC", ptr); 186 unmap_sysmem(ptr); 187 188 return 0; 189 } 190 DM_TEST(dm_test_pci_mixed, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 191 192 /* Test looking up PCI capability and extended capability */ 193 static int dm_test_pci_cap(struct unit_test_state *uts) 194 { 195 struct udevice *bus, *swap; 196 int cap; 197 198 ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 0, &bus)); 199 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap)); 200 201 /* look up PCI_CAP_ID_EXP */ 202 cap = dm_pci_find_capability(swap, PCI_CAP_ID_EXP); 203 ut_asserteq(PCI_CAP_ID_EXP_OFFSET, cap); 204 205 /* look up PCI_CAP_ID_PCIX */ 206 cap = dm_pci_find_capability(swap, PCI_CAP_ID_PCIX); 207 ut_asserteq(0, cap); 208 209 ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus)); 210 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap)); 211 212 /* look up PCI_EXT_CAP_ID_DSN */ 213 cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_DSN); 214 ut_asserteq(PCI_EXT_CAP_ID_DSN_OFFSET, cap); 215 216 /* look up PCI_EXT_CAP_ID_SRIOV */ 217 cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_SRIOV); 218 ut_asserteq(0, cap); 219 220 return 0; 221 } 222 DM_TEST(dm_test_pci_cap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 223