xref: /openbmc/u-boot/test/dm/pci.c (revision 6ee7bb52)
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