blob: 869970072d5cec31bc645dbf205d157a6302b4d5 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glassd3b7ff12015-03-05 12:25:34 -07002/*
3 * Copyright (C) 2015 Google, Inc
Simon Glassd3b7ff12015-03-05 12:25:34 -07004 */
5
6#include <common.h>
7#include <dm.h>
8#include <asm/io.h>
Bin Meng3839b4e2018-08-03 01:14:42 -07009#include <asm/test.h>
Simon Glassd3b7ff12015-03-05 12:25:34 -070010#include <dm/test.h>
Joe Hershbergere721b882015-05-20 14:27:27 -050011#include <test/ut.h>
Simon Glassd3b7ff12015-03-05 12:25:34 -070012
13/* Test that sandbox PCI works correctly */
Joe Hershbergere721b882015-05-20 14:27:27 -050014static int dm_test_pci_base(struct unit_test_state *uts)
Simon Glassd3b7ff12015-03-05 12:25:34 -070015{
16 struct udevice *bus;
17
18 ut_assertok(uclass_get_device(UCLASS_PCI, 0, &bus));
19
20 return 0;
21}
22DM_TEST(dm_test_pci_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
23
Bin Meng2db7f2b2018-08-03 01:14:39 -070024/* Test that sandbox PCI bus numbering and device works correctly */
25static int dm_test_pci_busdev(struct unit_test_state *uts)
Simon Glass2bb02e42015-05-10 21:08:06 -060026{
27 struct udevice *bus;
Bin Meng3839b4e2018-08-03 01:14:42 -070028 struct udevice *swap;
29 u16 vendor, device;
Simon Glass2bb02e42015-05-10 21:08:06 -060030
Bin Mengdee4d752018-08-03 01:14:41 -070031 /* Test bus#0 and its devices */
Simon Glass2bb02e42015-05-10 21:08:06 -060032 ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 0, &bus));
33
Bin Meng2db7f2b2018-08-03 01:14:39 -070034 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x00, 0), &swap));
Bin Meng3839b4e2018-08-03 01:14:42 -070035 vendor = 0;
36 ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor));
37 ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor);
Bin Meng2db7f2b2018-08-03 01:14:39 -070038 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap));
Bin Meng3839b4e2018-08-03 01:14:42 -070039 device = 0;
40 ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device));
41 ut_asserteq(SANDBOX_PCI_DEVICE_ID, device);
Bin Meng2db7f2b2018-08-03 01:14:39 -070042
Bin Mengdee4d752018-08-03 01:14:41 -070043 /* Test bus#1 and its devices */
44 ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
45
Bin Mengdee4d752018-08-03 01:14:41 -070046 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
Bin Meng3839b4e2018-08-03 01:14:42 -070047 vendor = 0;
48 ut_assertok(dm_pci_read_config16(swap, PCI_VENDOR_ID, &vendor));
49 ut_asserteq(SANDBOX_PCI_VENDOR_ID, vendor);
Bin Mengdee4d752018-08-03 01:14:41 -070050 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x0c, 0), &swap));
Bin Meng3839b4e2018-08-03 01:14:42 -070051 device = 0;
52 ut_assertok(dm_pci_read_config16(swap, PCI_DEVICE_ID, &device));
53 ut_asserteq(SANDBOX_PCI_DEVICE_ID, device);
Bin Mengdee4d752018-08-03 01:14:41 -070054
Simon Glass2bb02e42015-05-10 21:08:06 -060055 return 0;
56}
Bin Meng2db7f2b2018-08-03 01:14:39 -070057DM_TEST(dm_test_pci_busdev, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Simon Glass2bb02e42015-05-10 21:08:06 -060058
Simon Glassd3b7ff12015-03-05 12:25:34 -070059/* Test that we can use the swapcase device correctly */
Joe Hershbergere721b882015-05-20 14:27:27 -050060static int dm_test_pci_swapcase(struct unit_test_state *uts)
Simon Glassd3b7ff12015-03-05 12:25:34 -070061{
Bin Mengdd4808f2018-08-03 01:14:38 -070062 struct udevice *swap;
Simon Glassd3b7ff12015-03-05 12:25:34 -070063 ulong io_addr, mem_addr;
64 char *ptr;
65
Bin Meng2db7f2b2018-08-03 01:14:39 -070066 /* 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 */
Simon Glassc0322412015-11-29 13:18:02 -070088 ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(0, 0x1f, 0), &swap));
Simon Glassd3b7ff12015-03-05 12:25:34 -070089
90 /* First test I/O */
Simon Glassc0322412015-11-29 13:18:02 -070091 io_addr = dm_pci_read_bar32(swap, 0);
Simon Glassd3b7ff12015-03-05 12:25:34 -070092 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 */
Simon Glassc0322412015-11-29 13:18:02 -070099 mem_addr = dm_pci_read_bar32(swap, 1);
Simon Glassd3b7ff12015-03-05 12:25:34 -0700100 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}
110DM_TEST(dm_test_pci_swapcase, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Bin Meng82b31042018-08-03 01:14:48 -0700111
112/* Test that we can dynamically bind the device driver correctly */
113static 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}
127DM_TEST(dm_test_pci_drvdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Bin Meng3ed214a2018-08-03 01:14:50 -0700128
129/* Test that devices on PCI bus#2 can be accessed correctly */
130static 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}
190DM_TEST(dm_test_pci_mixed, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Bin Meng95e11062018-08-03 01:14:53 -0700191
192/* Test looking up PCI capability and extended capability */
193static 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}
222DM_TEST(dm_test_pci_cap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);