]>
git.proxmox.com Git - mirror_qemu.git/blob - tests/i440fx-test.c
2 * qtest I440FX test case
4 * Copyright IBM, Corp. 2012-2013
5 * Copyright Red Hat, Inc. 2013
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Laszlo Ersek <lersek@redhat.com>
11 * This work is licensed under the terms of the GNU GPL, version 2 or later.
12 * See the COPYING file in the top-level directory.
15 #include "qemu/osdep.h"
25 #include "libqos/pci.h"
26 #include "libqos/pci-pc.h"
27 #include "hw/pci/pci_regs.h"
31 typedef struct TestData
36 typedef struct FirmwareTestFixture
{
37 /* decides whether we're testing -bios or -pflash */
39 } FirmwareTestFixture
;
41 static QPCIBus
*test_start_get_bus(const TestData
*s
)
45 cmdline
= g_strdup_printf("-smp %d", s
->num_cpus
);
48 return qpci_init_pc();
51 static void test_i440fx_defaults(gconstpointer opaque
)
53 const TestData
*s
= opaque
;
58 bus
= test_start_get_bus(s
);
59 dev
= qpci_device_find(bus
, QPCI_DEVFN(0, 0));
60 g_assert(dev
!= NULL
);
63 g_assert_cmpint(qpci_config_readw(dev
, PCI_VENDOR_ID
), ==, 0x8086);
65 g_assert_cmpint(qpci_config_readw(dev
, PCI_DEVICE_ID
), ==, 0x1237);
68 g_assert_cmpint(qpci_config_readw(dev
, PCI_COMMAND
), ==, 0x0006);
70 g_assert_cmpint(qpci_config_readw(dev
, PCI_STATUS
), ==, 0x0280);
73 g_assert_cmpint(qpci_config_readb(dev
, PCI_CLASS_PROG
), ==, 0x00);
74 g_assert_cmpint(qpci_config_readw(dev
, PCI_CLASS_DEVICE
), ==, 0x0600);
76 g_assert_cmpint(qpci_config_readb(dev
, PCI_LATENCY_TIMER
), ==, 0x00);
78 g_assert_cmpint(qpci_config_readb(dev
, PCI_HEADER_TYPE
), ==, 0x00);
80 g_assert_cmpint(qpci_config_readb(dev
, PCI_BIST
), ==, 0x00);
83 value
= qpci_config_readw(dev
, 0x50); /* PMCCFG */
84 if (s
->num_cpus
== 1) { /* WPE */
85 g_assert(!(value
& (1 << 15)));
87 g_assert((value
& (1 << 15)));
90 g_assert(!(value
& (1 << 6))); /* EPTE */
93 g_assert_cmpint(qpci_config_readb(dev
, 0x52), ==, 0x00); /* DETURBO */
96 g_assert_cmpint(qpci_config_readb(dev
, 0x53), ==, 0x80); /* DBC */
99 g_assert_cmpint(qpci_config_readb(dev
, 0x54), ==, 0x00); /* AXC */
101 g_assert_cmpint(qpci_config_readw(dev
, 0x55), ==, 0x0000); /* DRT */
104 g_assert_cmpint(qpci_config_readb(dev
, 0x57), ==, 0x01); /* DRAMC */
106 g_assert_cmpint(qpci_config_readb(dev
, 0x58), ==, 0x10); /* DRAMT */
109 g_assert_cmpint(qpci_config_readb(dev
, 0x59), ==, 0x00); /* PAM0 */
110 g_assert_cmpint(qpci_config_readb(dev
, 0x5A), ==, 0x00); /* PAM1 */
111 g_assert_cmpint(qpci_config_readb(dev
, 0x5B), ==, 0x00); /* PAM2 */
112 g_assert_cmpint(qpci_config_readb(dev
, 0x5C), ==, 0x00); /* PAM3 */
113 g_assert_cmpint(qpci_config_readb(dev
, 0x5D), ==, 0x00); /* PAM4 */
114 g_assert_cmpint(qpci_config_readb(dev
, 0x5E), ==, 0x00); /* PAM5 */
115 g_assert_cmpint(qpci_config_readb(dev
, 0x5F), ==, 0x00); /* PAM6 */
118 g_assert_cmpint(qpci_config_readb(dev
, 0x60), ==, 0x01); /* DRB0 */
119 g_assert_cmpint(qpci_config_readb(dev
, 0x61), ==, 0x01); /* DRB1 */
120 g_assert_cmpint(qpci_config_readb(dev
, 0x62), ==, 0x01); /* DRB2 */
121 g_assert_cmpint(qpci_config_readb(dev
, 0x63), ==, 0x01); /* DRB3 */
122 g_assert_cmpint(qpci_config_readb(dev
, 0x64), ==, 0x01); /* DRB4 */
123 g_assert_cmpint(qpci_config_readb(dev
, 0x65), ==, 0x01); /* DRB5 */
124 g_assert_cmpint(qpci_config_readb(dev
, 0x66), ==, 0x01); /* DRB6 */
125 g_assert_cmpint(qpci_config_readb(dev
, 0x67), ==, 0x01); /* DRB7 */
128 g_assert_cmpint(qpci_config_readb(dev
, 0x68), ==, 0x00); /* FDHC */
130 g_assert_cmpint(qpci_config_readb(dev
, 0x70), ==, 0x00); /* MTT */
133 g_assert_cmpint(qpci_config_readb(dev
, 0x71), ==, 0x10); /* CLT */
136 g_assert_cmpint(qpci_config_readb(dev
, 0x72), ==, 0x02); /* SMRAM */
138 g_assert_cmpint(qpci_config_readb(dev
, 0x90), ==, 0x00); /* ERRCMD */
140 g_assert_cmpint(qpci_config_readb(dev
, 0x91), ==, 0x00); /* ERRSTS */
142 g_assert_cmpint(qpci_config_readb(dev
, 0x93), ==, 0x00); /* TRC */
150 static void pam_set(QPCIDevice
*dev
, int index
, int flags
)
152 int regno
= 0x59 + (index
/ 2);
155 reg
= qpci_config_readb(dev
, regno
);
157 reg
= (reg
& 0x0F) | (flags
<< 4);
159 reg
= (reg
& 0xF0) | flags
;
161 qpci_config_writeb(dev
, regno
, reg
);
164 static gboolean
verify_area(uint32_t start
, uint32_t end
, uint8_t value
)
166 uint32_t size
= end
- start
+ 1;
171 data
= g_malloc0(size
);
172 memread(start
, data
, size
);
174 g_test_message("verify_area: data[0] = 0x%x", data
[0]);
176 for (i
= 0; i
< size
; i
++) {
177 if (data
[i
] != value
) {
188 static void write_area(uint32_t start
, uint32_t end
, uint8_t value
)
190 uint32_t size
= end
- start
+ 1;
193 data
= g_malloc(size
);
194 memset(data
, value
, size
);
195 memwrite(start
, data
, size
);
200 static void test_i440fx_pam(gconstpointer opaque
)
202 const TestData
*s
= opaque
;
210 { 0, 0 }, /* Reserved */
211 { 0xF0000, 0xFFFFF }, /* BIOS Area */
212 { 0xC0000, 0xC3FFF }, /* Option ROM */
213 { 0xC4000, 0xC7FFF }, /* Option ROM */
214 { 0xC8000, 0xCBFFF }, /* Option ROM */
215 { 0xCC000, 0xCFFFF }, /* Option ROM */
216 { 0xD0000, 0xD3FFF }, /* Option ROM */
217 { 0xD4000, 0xD7FFF }, /* Option ROM */
218 { 0xD8000, 0xDBFFF }, /* Option ROM */
219 { 0xDC000, 0xDFFFF }, /* Option ROM */
220 { 0xE0000, 0xE3FFF }, /* BIOS Extension */
221 { 0xE4000, 0xE7FFF }, /* BIOS Extension */
222 { 0xE8000, 0xEBFFF }, /* BIOS Extension */
223 { 0xEC000, 0xEFFFF }, /* BIOS Extension */
226 bus
= test_start_get_bus(s
);
227 dev
= qpci_device_find(bus
, QPCI_DEVFN(0, 0));
228 g_assert(dev
!= NULL
);
230 for (i
= 0; i
< ARRAY_SIZE(pam_area
); i
++) {
231 if (pam_area
[i
].start
== pam_area
[i
].end
) {
235 g_test_message("Checking area 0x%05x..0x%05x",
236 pam_area
[i
].start
, pam_area
[i
].end
);
237 /* Switch to RE for the area */
238 pam_set(dev
, i
, PAM_RE
);
239 /* Verify the RAM is all zeros */
240 g_assert(verify_area(pam_area
[i
].start
, pam_area
[i
].end
, 0));
242 /* Switch to WE for the area */
243 pam_set(dev
, i
, PAM_RE
| PAM_WE
);
244 /* Write out a non-zero mask to the full area */
245 write_area(pam_area
[i
].start
, pam_area
[i
].end
, 0x42);
248 /* QEMU only supports a limited form of PAM */
250 /* Switch to !RE for the area */
251 pam_set(dev
, i
, PAM_WE
);
252 /* Verify the area is not our mask */
253 g_assert(!verify_area(pam_area
[i
].start
, pam_area
[i
].end
, 0x42));
256 /* Verify the area is our new mask */
257 g_assert(verify_area(pam_area
[i
].start
, pam_area
[i
].end
, 0x42));
259 /* Write out a new mask */
260 write_area(pam_area
[i
].start
, pam_area
[i
].end
, 0x82);
263 /* QEMU only supports a limited form of PAM */
265 /* Verify the area is not our mask */
266 g_assert(!verify_area(pam_area
[i
].start
, pam_area
[i
].end
, 0x82));
268 /* Switch to RE for the area */
269 pam_set(dev
, i
, PAM_RE
| PAM_WE
);
271 /* Verify the area is our new mask */
272 g_assert(verify_area(pam_area
[i
].start
, pam_area
[i
].end
, 0x82));
277 /* Verify the area is not our new mask */
278 g_assert(!verify_area(pam_area
[i
].start
, pam_area
[i
].end
, 0x82));
283 #define BLOB_SIZE ((size_t)65536)
284 #define ISA_BIOS_MAXSZ ((size_t)(128 * 1024))
286 /* Create a blob file, and return its absolute pathname as a dynamically
288 * The file is closed before the function returns.
289 * In case of error, NULL is returned. The function prints the error message.
291 static char *create_blob_file(void)
295 GError
*error
= NULL
;
298 fd
= g_file_open_tmp("blob_XXXXXX", &pathname
, &error
);
300 fprintf(stderr
, "unable to create blob file: %s\n", error
->message
);
303 if (ftruncate(fd
, BLOB_SIZE
) == -1) {
304 fprintf(stderr
, "ftruncate(\"%s\", %zu): %s\n", pathname
,
305 BLOB_SIZE
, strerror(errno
));
309 buf
= mmap(NULL
, BLOB_SIZE
, PROT_WRITE
, MAP_SHARED
, fd
, 0);
310 if (buf
== MAP_FAILED
) {
311 fprintf(stderr
, "mmap(\"%s\", %zu): %s\n", pathname
, BLOB_SIZE
,
316 for (i
= 0; i
< BLOB_SIZE
; ++i
) {
317 ((uint8_t *)buf
)[i
] = i
;
319 munmap(buf
, BLOB_SIZE
);
330 return ret
== -1 ? NULL
: pathname
;
333 static void test_i440fx_firmware(FirmwareTestFixture
*fixture
,
334 gconstpointer user_data
)
336 char *fw_pathname
, *cmdline
;
338 size_t i
, isa_bios_size
;
340 fw_pathname
= create_blob_file();
341 g_assert(fw_pathname
!= NULL
);
343 /* Better hope the user didn't put metacharacters in TMPDIR and co. */
344 cmdline
= g_strdup_printf("-S %s%s", fixture
->is_bios
346 : "-drive if=pflash,format=raw,file=",
348 g_test_message("qemu cmdline: %s", cmdline
);
349 qtest_start(cmdline
);
352 /* QEMU has loaded the firmware (because qtest_start() only returns after
353 * the QMP handshake completes). We must unlink the firmware blob right
354 * here, because any assertion firing below would leak it in the
355 * filesystem. This is also the reason why we recreate the blob every time
356 * this function is invoked.
362 buf
= g_malloc0(BLOB_SIZE
);
363 memread(0x100000000ULL
- BLOB_SIZE
, buf
, BLOB_SIZE
);
364 for (i
= 0; i
< BLOB_SIZE
; ++i
) {
365 g_assert_cmphex(buf
[i
], ==, (uint8_t)i
);
368 /* check in ISA space too */
369 memset(buf
, 0, BLOB_SIZE
);
370 isa_bios_size
= ISA_BIOS_MAXSZ
< BLOB_SIZE
? ISA_BIOS_MAXSZ
: BLOB_SIZE
;
371 memread(0x100000 - isa_bios_size
, buf
, isa_bios_size
);
372 for (i
= 0; i
< isa_bios_size
; ++i
) {
373 g_assert_cmphex(buf
[i
], ==,
374 (uint8_t)((BLOB_SIZE
- isa_bios_size
) + i
));
381 static void add_firmware_test(const char *testpath
,
382 void (*setup_fixture
)(FirmwareTestFixture
*f
,
383 gconstpointer test_data
))
385 qtest_add(testpath
, FirmwareTestFixture
, NULL
, setup_fixture
,
386 test_i440fx_firmware
, NULL
);
389 static void request_bios(FirmwareTestFixture
*fixture
,
390 gconstpointer user_data
)
392 fixture
->is_bios
= true;
395 static void request_pflash(FirmwareTestFixture
*fixture
,
396 gconstpointer user_data
)
398 fixture
->is_bios
= false;
401 int main(int argc
, char **argv
)
406 g_test_init(&argc
, &argv
, NULL
);
410 qtest_add_data_func("i440fx/defaults", &data
, test_i440fx_defaults
);
411 qtest_add_data_func("i440fx/pam", &data
, test_i440fx_pam
);
412 add_firmware_test("i440fx/firmware/bios", request_bios
);
413 add_firmware_test("i440fx/firmware/pflash", request_pflash
);