]>
Commit | Line | Data |
---|---|---|
93e9eb68 KW |
1 | /* |
2 | * Floppy test cases. | |
3 | * | |
4 | * Copyright (c) 2012 Kevin Wolf <kwolf@redhat.com> | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | ||
25 | #include <stdint.h> | |
26 | #include <string.h> | |
27 | #include <stdio.h> | |
28 | ||
29 | #include <glib.h> | |
30 | ||
31 | #include "libqtest.h" | |
32 | #include "qemu-common.h" | |
33 | ||
34 | #define TEST_IMAGE_SIZE 1440 * 1024 | |
35 | ||
36 | #define FLOPPY_BASE 0x3f0 | |
37 | #define FLOPPY_IRQ 6 | |
38 | ||
39 | enum { | |
40 | reg_sra = 0x0, | |
41 | reg_srb = 0x1, | |
42 | reg_dor = 0x2, | |
43 | reg_msr = 0x4, | |
44 | reg_dsr = 0x4, | |
45 | reg_fifo = 0x5, | |
46 | reg_dir = 0x7, | |
47 | }; | |
48 | ||
49 | enum { | |
50 | CMD_SENSE_INT = 0x08, | |
51 | CMD_SEEK = 0x0f, | |
8b9ef60d | 52 | CMD_READ = 0xe6, |
93e9eb68 KW |
53 | }; |
54 | ||
55 | enum { | |
56 | RQM = 0x80, | |
57 | DIO = 0x40, | |
58 | ||
59 | DSKCHG = 0x80, | |
60 | }; | |
61 | ||
62 | char test_image[] = "/tmp/qtest.XXXXXX"; | |
63 | ||
64 | #define assert_bit_set(data, mask) g_assert_cmphex((data) & (mask), ==, (mask)) | |
65 | #define assert_bit_clear(data, mask) g_assert_cmphex((data) & (mask), ==, 0) | |
66 | ||
7cd33161 PH |
67 | static uint8_t base = 0x70; |
68 | ||
69 | enum { | |
70 | CMOS_FLOPPY = 0x10, | |
71 | }; | |
72 | ||
93e9eb68 KW |
73 | static void floppy_send(uint8_t byte) |
74 | { | |
75 | uint8_t msr; | |
76 | ||
77 | msr = inb(FLOPPY_BASE + reg_msr); | |
78 | assert_bit_set(msr, RQM); | |
79 | assert_bit_clear(msr, DIO); | |
80 | ||
81 | outb(FLOPPY_BASE + reg_fifo, byte); | |
82 | } | |
83 | ||
84 | static uint8_t floppy_recv(void) | |
85 | { | |
86 | uint8_t msr; | |
87 | ||
88 | msr = inb(FLOPPY_BASE + reg_msr); | |
89 | assert_bit_set(msr, RQM | DIO); | |
90 | ||
91 | return inb(FLOPPY_BASE + reg_fifo); | |
92 | } | |
93 | ||
94 | static void ack_irq(void) | |
95 | { | |
96 | g_assert(get_irq(FLOPPY_IRQ)); | |
97 | floppy_send(CMD_SENSE_INT); | |
98 | floppy_recv(); | |
99 | floppy_recv(); | |
100 | g_assert(!get_irq(FLOPPY_IRQ)); | |
101 | } | |
102 | ||
8b9ef60d PH |
103 | static uint8_t send_read_command(void) |
104 | { | |
105 | uint8_t drive = 0; | |
106 | uint8_t head = 0; | |
107 | uint8_t cyl = 0; | |
108 | uint8_t sect_addr = 1; | |
109 | uint8_t sect_size = 2; | |
110 | uint8_t eot = 1; | |
111 | uint8_t gap = 0x1b; | |
112 | uint8_t gpl = 0xff; | |
113 | ||
114 | uint8_t msr = 0; | |
115 | uint8_t st0; | |
116 | ||
117 | uint8_t ret = 0; | |
118 | ||
119 | floppy_send(CMD_READ); | |
120 | floppy_send(head << 2 | drive); | |
121 | g_assert(!get_irq(FLOPPY_IRQ)); | |
122 | floppy_send(cyl); | |
123 | floppy_send(head); | |
124 | floppy_send(sect_addr); | |
125 | floppy_send(sect_size); | |
126 | floppy_send(eot); | |
127 | floppy_send(gap); | |
128 | floppy_send(gpl); | |
129 | ||
130 | uint8_t i = 0; | |
131 | uint8_t n = 2; | |
132 | for (; i < n; i++) { | |
133 | msr = inb(FLOPPY_BASE + reg_msr); | |
134 | if (msr == 0xd0) { | |
135 | break; | |
136 | } | |
137 | sleep(1); | |
138 | } | |
139 | ||
140 | if (i >= n) { | |
141 | return 1; | |
142 | } | |
143 | ||
144 | st0 = floppy_recv(); | |
145 | if (st0 != 0x40) { | |
146 | ret = 1; | |
147 | } | |
148 | ||
149 | floppy_recv(); | |
150 | floppy_recv(); | |
151 | floppy_recv(); | |
152 | floppy_recv(); | |
153 | floppy_recv(); | |
154 | floppy_recv(); | |
155 | ||
156 | return ret; | |
157 | } | |
158 | ||
59240c34 | 159 | static void send_step_pulse(int cyl) |
93e9eb68 KW |
160 | { |
161 | int drive = 0; | |
162 | int head = 0; | |
93e9eb68 KW |
163 | |
164 | floppy_send(CMD_SEEK); | |
165 | floppy_send(head << 2 | drive); | |
166 | g_assert(!get_irq(FLOPPY_IRQ)); | |
167 | floppy_send(cyl); | |
168 | ack_irq(); | |
93e9eb68 KW |
169 | } |
170 | ||
7cd33161 | 171 | static uint8_t cmos_read(uint8_t reg) |
93e9eb68 | 172 | { |
7cd33161 PH |
173 | outb(base + 0, reg); |
174 | return inb(base + 1); | |
175 | } | |
93e9eb68 | 176 | |
7cd33161 PH |
177 | static void test_cmos(void) |
178 | { | |
179 | uint8_t cmos; | |
93e9eb68 | 180 | |
7cd33161 PH |
181 | cmos = cmos_read(CMOS_FLOPPY); |
182 | g_assert(cmos == 0x40); | |
183 | } | |
93e9eb68 | 184 | |
7cd33161 PH |
185 | static void test_no_media_on_start(void) |
186 | { | |
187 | uint8_t dir; | |
188 | ||
189 | /* Media changed bit must be set all time after start if there is | |
190 | * no media in drive. */ | |
93e9eb68 KW |
191 | dir = inb(FLOPPY_BASE + reg_dir); |
192 | assert_bit_set(dir, DSKCHG); | |
193 | dir = inb(FLOPPY_BASE + reg_dir); | |
194 | assert_bit_set(dir, DSKCHG); | |
59240c34 | 195 | send_step_pulse(1); |
93e9eb68 KW |
196 | dir = inb(FLOPPY_BASE + reg_dir); |
197 | assert_bit_set(dir, DSKCHG); | |
198 | dir = inb(FLOPPY_BASE + reg_dir); | |
199 | assert_bit_set(dir, DSKCHG); | |
7cd33161 PH |
200 | } |
201 | ||
8b9ef60d PH |
202 | static void test_read_without_media(void) |
203 | { | |
204 | uint8_t ret; | |
205 | ||
206 | ret = send_read_command(); | |
207 | g_assert(ret == 0); | |
208 | } | |
209 | ||
7cd33161 PH |
210 | static void test_media_change(void) |
211 | { | |
212 | uint8_t dir; | |
93e9eb68 | 213 | |
7cd33161 | 214 | /* Insert media in drive. DSKCHK should not be reset until a step pulse |
93e9eb68 KW |
215 | * is sent. */ |
216 | qmp("{'execute':'change', 'arguments':{ 'device':'floppy0', " | |
217 | "'target': '%s' }}", test_image); | |
218 | qmp(""); /* ignore event (FIXME open -> open transition?!) */ | |
219 | qmp(""); /* ignore event */ | |
220 | ||
221 | dir = inb(FLOPPY_BASE + reg_dir); | |
222 | assert_bit_set(dir, DSKCHG); | |
223 | dir = inb(FLOPPY_BASE + reg_dir); | |
224 | assert_bit_set(dir, DSKCHG); | |
225 | ||
59240c34 PH |
226 | send_step_pulse(0); |
227 | dir = inb(FLOPPY_BASE + reg_dir); | |
228 | assert_bit_set(dir, DSKCHG); | |
229 | dir = inb(FLOPPY_BASE + reg_dir); | |
230 | assert_bit_set(dir, DSKCHG); | |
231 | ||
232 | /* Step to next track should clear DSKCHG bit. */ | |
233 | send_step_pulse(1); | |
93e9eb68 KW |
234 | dir = inb(FLOPPY_BASE + reg_dir); |
235 | assert_bit_clear(dir, DSKCHG); | |
236 | dir = inb(FLOPPY_BASE + reg_dir); | |
237 | assert_bit_clear(dir, DSKCHG); | |
7cd33161 PH |
238 | |
239 | /* Eject the floppy and check that DSKCHG is set. Reading it out doesn't | |
240 | * reset the bit. */ | |
241 | qmp("{'execute':'eject', 'arguments':{ 'device':'floppy0' }}"); | |
242 | qmp(""); /* ignore event */ | |
243 | ||
244 | dir = inb(FLOPPY_BASE + reg_dir); | |
245 | assert_bit_set(dir, DSKCHG); | |
246 | dir = inb(FLOPPY_BASE + reg_dir); | |
247 | assert_bit_set(dir, DSKCHG); | |
248 | ||
59240c34 PH |
249 | send_step_pulse(0); |
250 | dir = inb(FLOPPY_BASE + reg_dir); | |
251 | assert_bit_set(dir, DSKCHG); | |
252 | dir = inb(FLOPPY_BASE + reg_dir); | |
253 | assert_bit_set(dir, DSKCHG); | |
254 | ||
255 | send_step_pulse(1); | |
7cd33161 PH |
256 | dir = inb(FLOPPY_BASE + reg_dir); |
257 | assert_bit_set(dir, DSKCHG); | |
258 | dir = inb(FLOPPY_BASE + reg_dir); | |
259 | assert_bit_set(dir, DSKCHG); | |
93e9eb68 KW |
260 | } |
261 | ||
3359847e BS |
262 | /* success if no crash or abort */ |
263 | static void fuzz_registers(void) | |
264 | { | |
265 | unsigned int i; | |
266 | ||
267 | for (i = 0; i < 1000; i++) { | |
268 | uint8_t reg, val; | |
269 | ||
270 | reg = (uint8_t)g_test_rand_int_range(0, 8); | |
271 | val = (uint8_t)g_test_rand_int_range(0, 256); | |
272 | ||
273 | outb(FLOPPY_BASE + reg, val); | |
274 | inb(FLOPPY_BASE + reg); | |
275 | } | |
276 | } | |
277 | ||
93e9eb68 KW |
278 | int main(int argc, char **argv) |
279 | { | |
280 | const char *arch = qtest_get_arch(); | |
281 | char *cmdline; | |
282 | int fd; | |
283 | int ret; | |
284 | ||
285 | /* Check architecture */ | |
286 | if (strcmp(arch, "i386") && strcmp(arch, "x86_64")) { | |
287 | g_test_message("Skipping test for non-x86\n"); | |
288 | return 0; | |
289 | } | |
290 | ||
291 | /* Create a temporary raw image */ | |
292 | fd = mkstemp(test_image); | |
293 | g_assert(fd >= 0); | |
294 | ret = ftruncate(fd, TEST_IMAGE_SIZE); | |
295 | g_assert(ret == 0); | |
296 | close(fd); | |
297 | ||
298 | /* Run the tests */ | |
299 | g_test_init(&argc, &argv, NULL); | |
300 | ||
7cd33161 | 301 | cmdline = g_strdup_printf("-vnc none "); |
93e9eb68 KW |
302 | |
303 | qtest_start(cmdline); | |
304 | qtest_irq_intercept_in(global_qtest, "ioapic"); | |
7cd33161 PH |
305 | qtest_add_func("/fdc/cmos", test_cmos); |
306 | qtest_add_func("/fdc/no_media_on_start", test_no_media_on_start); | |
8b9ef60d | 307 | qtest_add_func("/fdc/read_without_media", test_read_without_media); |
93e9eb68 | 308 | qtest_add_func("/fdc/media_change", test_media_change); |
3359847e | 309 | qtest_add_func("/fdc/fuzz-registers", fuzz_registers); |
93e9eb68 KW |
310 | |
311 | ret = g_test_run(); | |
312 | ||
313 | /* Cleanup */ | |
314 | qtest_quit(global_qtest); | |
315 | unlink(test_image); | |
316 | ||
317 | return ret; | |
318 | } |