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 */
dm_test_pci_base(struct unit_test_state * uts)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 */
dm_test_pci_busdev(struct unit_test_state * uts)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 */
dm_test_pci_swapcase(struct unit_test_state * uts)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 */
dm_test_pci_drvdata(struct unit_test_state * uts)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 */
dm_test_pci_mixed(struct unit_test_state * uts)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 */
dm_test_pci_cap(struct unit_test_state * uts)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, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
248