Nugget
Bare-metal libraries and examples for the original PlayStation
Loading...
Searching...
No Matches
race.c
Go to the documentation of this file.
1/*
2
3MIT License
4
5Copyright (c) 2022 PCSX-Redux authors
6
7Permission is hereby granted, free of charge, to any person obtaining a copy
8of this software and associated documentation files (the "Software"), to deal
9in the Software without restriction, including without limitation the rights
10to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11copies of the Software, and to permit persons to whom the Software is
12furnished to do so, subject to the following conditions:
13
14The above copyright notice and this permission notice shall be included in all
15copies or substantial portions of the Software.
16
17THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23SOFTWARE.
24
25*/
26
27// clang-format off
28
29CESTER_TEST(raceGetLocPAndNop, test_instances,
30 int resetDone = resetCDRom();
31 if (!resetDone) {
32 cester_assert_true(resetDone);
33 return;
34 }
35
36 int seekDone = seekPTo(0x70, 0x19, 0x73);
37 if (!seekDone) {
38 cester_assert_true(seekDone);
39 return;
40 }
41
42 initializeTime();
43 CDROM_REG0 = 0;
44 CDROM_REG1 = CDL_GETLOCP;
45 CDROM_REG1 = CDL_NOP;
46 uint8_t ctrl0 = CDROM_REG0 & ~3;
47
48 uint32_t ackTime = waitCDRomIRQ();
49 uint8_t cause1 = ackCDRomCause();
50 uint8_t ctrl1 = CDROM_REG0 & ~3;
51 uint8_t response1[16];
52 uint8_t responseSize1 = readResponse(response1);
53 uint8_t ctrl2 = CDROM_REG0 & ~3;
54 CDROM_REG0 = 1;
55 uint8_t cause1b = CDROM_REG3_UC;
56
57 initializeTime();
58 uint32_t timeout = 150000;
59 int gotIRQ = waitCDRomIRQWithTimeout(&timeout);
60
61 cester_assert_uint_eq(3, cause1);
62 cester_assert_uint_eq(0xe0, cause1b);
63 cester_assert_uint_eq(0x98, ctrl0);
64 cester_assert_uint_eq(0x38, ctrl1);
65 cester_assert_uint_eq(0x18, ctrl2);
66 cester_assert_uint_eq(2, response1[0]);
67 cester_assert_uint_eq(1, responseSize1);
68 cester_assert_false(gotIRQ);
69 cester_assert_uint_ge(ackTime, 500);
70 cester_assert_uint_lt(ackTime, 7000);
71 ramsyscall_printf("GetLocP followed by Nop, ack in %ius\n", ackTime);
72)
73
74CESTER_TEST(raceNopAndGetLocP, test_instances,
75 int resetDone = resetCDRom();
76 if (!resetDone) {
77 cester_assert_true(resetDone);
78 return;
79 }
80
81 int seekDone = seekPTo(0x70, 0x19, 0x73);
82 if (!seekDone) {
83 cester_assert_true(seekDone);
84 return;
85 }
86
87 initializeTime();
88 CDROM_REG0 = 0;
89 CDROM_REG1 = CDL_NOP;
90 CDROM_REG1 = CDL_GETLOCP;
91 uint8_t ctrl0 = CDROM_REG0 & ~3;
92
93 uint32_t ackTime = waitCDRomIRQ();
94 uint8_t cause1 = ackCDRomCause();
95 uint8_t ctrl1 = CDROM_REG0 & ~3;
96 uint8_t response1[16];
97 uint8_t responseSize1 = readResponse(response1);
98 uint8_t ctrl2 = CDROM_REG0 & ~3;
99 CDROM_REG0 = 1;
100 uint8_t cause1b = CDROM_REG3_UC;
101
102 initializeTime();
103 uint32_t timeout = 150000;
104 int gotIRQ = waitCDRomIRQWithTimeout(&timeout);
105
106 cester_assert_uint_eq(3, cause1);
107 cester_assert_uint_eq(0xe0, cause1b);
108 cester_assert_uint_eq(0x98, ctrl0);
109 cester_assert_uint_eq(0x38, ctrl1);
110 cester_assert_uint_eq(0x18, ctrl2);
111 cester_assert_uint_eq(5, response1[0]);
112 cester_assert_uint_eq(0, response1[1]);
113 cester_assert_uint_eq(8, responseSize1);
114 cester_assert_false(gotIRQ);
115 cester_assert_uint_ge(ackTime, 500);
116 cester_assert_uint_lt(ackTime, 7000);
117 ramsyscall_printf("Nop followed by GetLocP, ack in %ius\n", ackTime);
118)
119
120CESTER_TEST(raceNopAndGetTD1, test_instance,
121 int resetDone = resetCDRom();
122 if (!resetDone) {
123 cester_assert_true(resetDone);
124 return;
125 }
126
127 initializeTime();
128
129 CDROM_REG0 = 0;
130 CDROM_REG2 = 1;
131 CDROM_REG1 = CDL_NOP;
132 CDROM_REG1 = CDL_GETTD;
133 uint8_t ctrl0 = CDROM_REG0 & ~3;
134
135 uint32_t ackTime = waitCDRomIRQ();
136 uint8_t cause1 = ackCDRomCause();
137 uint8_t ctrl1 = CDROM_REG0 & ~3;
138 uint8_t response1[16];
139 uint8_t responseSize1 = readResponse(response1);
140 uint8_t ctrl2 = CDROM_REG0 & ~3;
141 CDROM_REG0 = 1;
142 uint8_t cause1b = CDROM_REG3_UC;
143
144 initializeTime();
145 uint32_t timeout = 150000;
146 int gotIRQ = waitCDRomIRQWithTimeout(&timeout);
147
148 cester_assert_uint_eq(3, cause1);
149 cester_assert_uint_eq(0xe0, cause1b);
150 cester_assert_uint_eq(2, response1[0]);
151 cester_assert_uint_eq(0, response1[1]);
152 cester_assert_uint_eq(2, response1[2]);
153 cester_assert_uint_eq(3, responseSize1);
154 cester_assert_uint_eq(0x90, ctrl0);
155 cester_assert_uint_eq(0x38, ctrl1);
156 cester_assert_uint_eq(0x18, ctrl2);
157 cester_assert_false(gotIRQ);
158 cester_assert_uint_ge(ackTime, 500);
159 cester_assert_uint_lt(ackTime, 7000);
160 ramsyscall_printf("Nop followed by GetTD1: ack in %ius\n", ackTime);
161)
162
163CESTER_TEST(raceGetTD1AndNop, test_instance,
164 int resetDone = resetCDRom();
165 if (!resetDone) {
166 cester_assert_true(resetDone);
167 return;
168 }
169
170 initializeTime();
171
172 CDROM_REG0 = 0;
173 CDROM_REG2 = 1;
174 CDROM_REG1 = CDL_GETTD;
175 CDROM_REG1 = CDL_NOP;
176 uint8_t ctrl0 = CDROM_REG0 & ~3;
177
178 uint32_t ackTime = waitCDRomIRQ();
179 uint8_t cause1 = ackCDRomCause();
180 uint8_t ctrl1 = CDROM_REG0 & ~3;
181 uint8_t response1[16];
182 uint8_t responseSize1 = readResponse(response1);
183 uint8_t ctrl2 = CDROM_REG0 & ~3;
184 CDROM_REG0 = 1;
185 uint8_t cause1b = CDROM_REG3_UC;
186
187 initializeTime();
188 uint32_t timeout = 150000;
189 int gotIRQ = waitCDRomIRQWithTimeout(&timeout);
190
191 cester_assert_uint_eq(5, cause1);
192 cester_assert_uint_eq(0xe0, cause1b);
193 cester_assert_uint_eq(3, response1[0]);
194 cester_assert_uint_eq(0x20, response1[1]);
195 cester_assert_uint_eq(2, responseSize1);
196 cester_assert_uint_eq(0x90, ctrl0);
197 cester_assert_uint_eq(0x38, ctrl1);
198 cester_assert_uint_eq(0x18, ctrl2);
199 cester_assert_false(gotIRQ);
200 cester_assert_uint_ge(ackTime, 500);
201 cester_assert_uint_lt(ackTime, 7000);
202 ramsyscall_printf("GetTD1 followed by Nop: ack in %ius\n", ackTime);
203)
204
205CESTER_TEST(raceSeekP2to85AckWaitAndNop, test_instance,
206 int resetDone = resetCDRom();
207 if (!resetDone) {
208 cester_assert_true(resetDone);
209 return;
210 }
211
212 int seekDone = seekPTo(0, 2, 0);
213 if (!seekDone) {
214 cester_assert_true(seekDone);
215 return;
216 }
217
218 int setLocDone = setLoc(0x85, 0, 0);
219 if (!setLocDone) {
220 cester_assert_true(setLocDone);
221 return;
222 }
223
224 initializeTime();
225 // wait 50ms for things to settle
226 while (updateTime() < 50000);
227 initializeTime();
228
229 CDROM_REG0 = 0;
230 CDROM_REG1 = CDL_SEEKP;
231 uint8_t ctrl0 = CDROM_REG0 & ~3;
232
233 uint32_t ackTime = waitCDRomIRQ();
234 uint8_t cause1 = ackCDRomCause();
235 uint8_t ctrl1 = CDROM_REG0 & ~3;
236 uint8_t response1[16];
237 uint8_t responseSize1 = readResponse(response1);
238 uint8_t ctrl2 = CDROM_REG0 & ~3;
239 CDROM_REG0 = 1;
240 uint8_t cause1b = CDROM_REG3_UC;
241
242 CDROM_REG0 = 0;
243 CDROM_REG1 = CDL_NOP;
244 uint8_t ctrl2b = CDROM_REG0 & ~3;
245
246 initializeTime();
247 uint32_t ackTime2 = waitCDRomIRQ();
248 uint8_t cause2 = ackCDRomCause();
249 uint8_t ctrl3 = CDROM_REG0 & ~3;
250 uint8_t response2[16];
251 uint8_t responseSize2 = readResponse(response2);
252 uint8_t ctrl4 = CDROM_REG0 & ~3;
253 CDROM_REG0 = 1;
254 uint8_t cause2b = CDROM_REG3_UC;
255
256 initializeTime();
257 uint32_t errorTime = waitCDRomIRQ();
258 uint8_t cause3 = ackCDRomCause();
259 uint8_t ctrl5 = CDROM_REG0 & ~3;
260 uint8_t response3[16];
261 uint8_t responseSize3 = readResponse(response3);
262 uint8_t ctrl6 = CDROM_REG0 & ~3;
263 CDROM_REG0 = 1;
264 uint8_t cause3b = CDROM_REG3_UC;
265
266 cester_assert_uint_eq(3, cause1);
267 cester_assert_uint_eq(3, cause2);
268 cester_assert_uint_eq(5, cause3);
269 cester_assert_uint_eq(0xe0, cause1b);
270 cester_assert_uint_eq(0xe0, cause2b);
271 cester_assert_uint_eq(2, response1[0]);
272 cester_assert_uint_eq(1, responseSize1);
273 cester_assert_uint_eq(2, response2[0]);
274 cester_assert_uint_eq(1, responseSize2);
275 cester_assert_uint_eq(6, response3[0]);
276 cester_assert_uint_eq(0x10, response3[1]);
277 cester_assert_uint_eq(2, responseSize3);
278 cester_assert_uint_eq(0x98, ctrl0);
279 cester_assert_uint_eq(0x38, ctrl1);
280 cester_assert_uint_eq(0x18, ctrl2);
281 cester_assert_uint_eq(0x98, ctrl2b);
282 cester_assert_uint_eq(0x38, ctrl3);
283 cester_assert_uint_eq(0x18, ctrl4);
284 cester_assert_uint_eq(0x38, ctrl5);
285 cester_assert_uint_eq(0x18, ctrl6);
286 cester_assert_uint_ge(ackTime, 500);
287 cester_assert_uint_lt(ackTime, 7000);
288 cester_assert_uint_ge(ackTime2, 500);
289 cester_assert_uint_lt(ackTime2, 7000);
290 ramsyscall_printf("SeekP from 00:02:00 to 85:00:00 with Nop in between: ack in %ius, ack2 in %ius, errored in %ius\n", ackTime, ackTime2, errorTime);
291)
292
293CESTER_TEST(raceSeekL2to71WaitAckAndNop, test_instance,
294 int resetDone = resetCDRom();
295 if (!resetDone) {
296 cester_assert_true(resetDone);
297 return;
298 }
299
300 int seekDone = seekPTo(0, 2, 0);
301 if (!seekDone) {
302 cester_assert_true(seekDone);
303 return;
304 }
305
306 int setLocDone = setLoc(0x71, 0, 0);
307 if (!setLocDone) {
308 cester_assert_true(setLocDone);
309 return;
310 }
311
312 initializeTime();
313 // wait 50ms for things to settle
314 while (updateTime() < 50000);
315 initializeTime();
316
317 CDROM_REG0 = 0;
318 CDROM_REG1 = CDL_SEEKL;
319 uint8_t ctrl0 = CDROM_REG0 & ~3;
320
321 while (CDROM_REG0 & 0x80);
322
323 CDROM_REG1 = CDL_NOP;
324 uint8_t ctrl0b = CDROM_REG0 & ~3;
325
326 initializeTime();
327 // Wait 2s...
328 ramsyscall_printf("Waiting 2s...\n");
329 while (updateTime() < 2000000);
330 ramsyscall_printf("Done...\n");
331
332 initializeTime();
333 uint32_t ackTime = waitCDRomIRQ();
334 uint8_t cause1 = ackCDRomCause();
335 uint8_t ctrl1 = CDROM_REG0 & ~3;
336 uint8_t response1[16];
337 uint8_t responseSize1 = readResponse(response1);
338 uint8_t ctrl2 = CDROM_REG0 & ~3;
339 CDROM_REG0 = 1;
340 uint8_t cause1b = CDROM_REG3_UC;
341
342 initializeTime();
343 uint32_t ackTime2 = waitCDRomIRQ();
344 uint8_t cause2 = ackCDRomCause();
345 uint8_t ctrl3 = CDROM_REG0 & ~3;
346 uint8_t response2[16];
347 uint8_t responseSize2 = readResponse(response2);
348 uint8_t ctrl4 = CDROM_REG0 & ~3;
349 CDROM_REG0 = 1;
350 uint8_t cause2b = CDROM_REG3_UC;
351
352 uint32_t timeout = 1500000;
353 int gotIRQ = waitCDRomIRQWithTimeout(&timeout);
354
355 cester_assert_uint_eq(3, cause1);
356 cester_assert_uint_eq(3, cause2);
357 cester_assert_uint_eq(0xe0, cause1b);
358 cester_assert_uint_eq(0xe0, cause2b);
359 cester_assert_uint_eq(2, response1[0]);
360 cester_assert_uint_eq(1, responseSize1);
361 cester_assert_uint_eq(0x42, response2[0]);
362 cester_assert_uint_eq(1, responseSize2);
363 cester_assert_uint_eq(0x98, ctrl0);
364 cester_assert_uint_eq(0xb8, ctrl0b);
365 cester_assert_uint_eq(0xb8, ctrl1);
366 cester_assert_uint_eq(0x98, ctrl2);
367 cester_assert_uint_eq(0x38, ctrl3);
368 cester_assert_uint_eq(0x18, ctrl4);
369 cester_assert_false(gotIRQ);
370 // This one really should be 0, but just in case.
371 cester_assert_uint_lt(ackTime, 150);
372 cester_assert_uint_ge(ackTime2, 500);
373 cester_assert_uint_lt(ackTime2, 7000);
374 ramsyscall_printf("SeekL from 00:02:00 to 71:00:00 then stall with Nop: ack in %ius, ack2 in %ius\n", ackTime, ackTime2);
375)
376
377CESTER_TEST(raceNopWaitAndNop, test_instances,
378 int resetDone = resetCDRom();
379 if (!resetDone) {
380 cester_assert_true(resetDone);
381 return;
382 }
383
384 initializeTime();
385 CDROM_REG0 = 0;
386 CDROM_REG1 = CDL_NOP;
387 uint8_t ctrl0 = CDROM_REG0 & ~3;
388
389 while (updateTime() < 50000);
390 uint8_t ctrl0b = CDROM_REG0 & ~3;
391 CDROM_REG1 = CDL_NOP;
392
393 initializeTime();
394 uint32_t ackTime = waitCDRomIRQ();
395 uint8_t cause1 = ackCDRomCause();
396 uint8_t ctrl1 = CDROM_REG0 & ~3;
397 uint8_t response1[16];
398 uint8_t responseSize1 = readResponse(response1);
399 uint8_t ctrl2 = CDROM_REG0 & ~3;
400 CDROM_REG0 = 1;
401 uint8_t cause1b = CDROM_REG3_UC;
402
403 initializeTime();
404 uint32_t ackTime2 = waitCDRomIRQ();
405 uint8_t cause2 = ackCDRomCause();
406 uint8_t ctrl3 = CDROM_REG0 & ~3;
407 uint8_t response2[16];
408 uint8_t responseSize2 = readResponse(response2);
409 uint8_t ctrl4 = CDROM_REG0 & ~3;
410 CDROM_REG0 = 1;
411 uint8_t cause2b = CDROM_REG3_UC;
412
413 cester_assert_uint_eq(3, cause1);
414 cester_assert_uint_eq(3, cause2);
415 cester_assert_uint_eq(0xe0, cause1b);
416 cester_assert_uint_eq(0x98, ctrl0);
417 cester_assert_uint_eq(0x38, ctrl0b);
418 cester_assert_uint_eq(0xb8, ctrl1);
419 cester_assert_uint_eq(0x98, ctrl2);
420 cester_assert_uint_eq(0x38, ctrl3);
421 cester_assert_uint_eq(0x18, ctrl4);
422 cester_assert_uint_eq(2, response1[0]);
423 cester_assert_uint_eq(1, responseSize1);
424 cester_assert_uint_eq(2, response2[0]);
425 cester_assert_uint_eq(1, responseSize2);
426 // This one really ought to be 0, but let's give some slack anyway.
427 cester_assert_uint_lt(ackTime, 150);
428 // The second ack's timing will be affected by the first ack's timing,
429 // so we can't really test it.
430 ramsyscall_printf("Nop followed by Nop, ack in %ius, ack2 in %ius\n", ackTime, ackTime2);
431)
432
433CESTER_TEST(nopQueue, test_instances,
434 int resetDone = resetCDRom();
435 if (!resetDone) {
436 cester_assert_true(resetDone);
437 return;
438 }
439
440 CDROM_REG0 = 0;
441 for (unsigned i = 0; i < 4; i++) {
442 initializeTime();
443 CDROM_REG1 = CDL_NOP;
444 while (updateTime() < 50000);
445 }
446
447 int gotIRQ = 0;
448 unsigned count = 0;
449 do {
450 initializeTime();
451 uint32_t timeout = 50000;
452 gotIRQ = waitCDRomIRQWithTimeout(&timeout);
453 ackCDRomCause();
454 uint8_t response[16];
455 uint8_t responseSize = readResponse(response);
456 } while (gotIRQ && ++count);
457
458 cester_assert_uint_eq(2, count);
459 ramsyscall_printf("Nop command queue of %i\n", count);
460)
461
462CESTER_TEST(nopQueueBusy, test_instances,
463 int resetDone = resetCDRom();
464 if (!resetDone) {
465 cester_assert_true(resetDone);
466 return;
467 }
468
469 uint8_t ctrl[2];
470 CDROM_REG0 = 0;
471 for (unsigned i = 0; i < 2; i++) {
472 initializeTime();
473 CDROM_REG1 = CDL_NOP;
474 while (updateTime() < 50000);
475 ctrl[i] = CDROM_REG0 & ~3;
476 }
477
478 for (unsigned i = 0; i < 2; i++) {
479 waitCDRomIRQ();
480 ackCDRomCause();
481 uint8_t response[16];
482 readResponse(response);
483 }
484
485 cester_assert_uint_eq(0x38, ctrl[0]);
486 cester_assert_uint_eq(0xb8, ctrl[1]);
487)
488
489CESTER_TEST(readResponseBeforeAck, test_instances,
490 int resetDone = resetCDRom();
491 if (!resetDone) {
492 cester_assert_true(resetDone);
493 return;
494 }
495
496 int seekDone = seekPTo(0x70, 0x19, 0x73);
497 if (!seekDone) {
498 cester_assert_true(seekDone);
499 return;
500 }
501
502 initializeTime();
503 CDROM_REG0 = 0;
504 CDROM_REG1 = CDL_GETLOCP;
505
506 while (CDROM_REG0 & 0x80);
507 CDROM_REG1 = CDL_NOP;
508
509 while (updateTime() < 50000);
510
511 waitCDRomIRQ();
512 uint8_t response1[16];
513 uint8_t responseSize1 = readResponse(response1);
514 uint8_t cause1 = ackCDRomCause();
515 CDROM_REG0 = 1;
516 uint8_t cause1b = CDROM_REG3_UC;
517 waitCDRomIRQ();
518 uint8_t response2[16];
519 uint8_t responseSize2 = readResponse(response2);
520 uint8_t cause2 = ackCDRomCause();
521 CDROM_REG0 = 1;
522 uint8_t cause2b = CDROM_REG3_UC;
523
524 cester_assert_uint_eq(3, cause1);
525 cester_assert_uint_eq(0xe0, cause1b);
526 cester_assert_uint_eq(5, response1[0]);
527 cester_assert_uint_eq(8, responseSize1);
528 cester_assert_uint_eq(3, cause2);
529 cester_assert_uint_eq(0xe0, cause2b);
530 cester_assert_uint_eq(2, response2[0]);
531 cester_assert_uint_eq(1, responseSize2);
532
533)
534
535CESTER_TEST(ackBeforeReadResponse, test_instances,
536 int resetDone = resetCDRom();
537 if (!resetDone) {
538 cester_assert_true(resetDone);
539 return;
540 }
541
542 int seekDone = seekPTo(0x70, 0x19, 0x73);
543 if (!seekDone) {
544 cester_assert_true(seekDone);
545 return;
546 }
547
548 initializeTime();
549 CDROM_REG0 = 0;
550 CDROM_REG1 = CDL_GETLOCP;
551
552 while (CDROM_REG0 & 0x80);
553 CDROM_REG1 = CDL_NOP;
554
555 while (updateTime() < 50000);
556
557 waitCDRomIRQ();
558 uint8_t cause1 = ackCDRomCause();
559 CDROM_REG0 = 1;
560 uint8_t cause1b = CDROM_REG3_UC;
561 uint8_t response1[16];
562 uint8_t responseSize1 = readResponse(response1);
563 waitCDRomIRQ();
564 uint8_t cause2 = ackCDRomCause();
565 CDROM_REG0 = 1;
566 uint8_t cause2b = CDROM_REG3_UC;
567 uint8_t response2[16];
568 uint8_t responseSize2 = readResponse(response2);
569
570 cester_assert_uint_eq(3, cause1);
571 cester_assert_uint_eq(0xe0, cause1b);
572 cester_assert_uint_eq(5, response1[0]);
573 cester_assert_uint_eq(8, responseSize1);
574 cester_assert_uint_eq(3, cause2);
575 cester_assert_uint_eq(0xe0, cause2b);
576 cester_assert_uint_eq(2, response2[0]);
577 cester_assert_uint_eq(1, responseSize2);
578
579)
580
581CESTER_TEST(mixedReadAndAck1, test_instances,
582 int resetDone = resetCDRom();
583 if (!resetDone) {
584 cester_assert_true(resetDone);
585 return;
586 }
587
588 int seekDone = seekPTo(0x70, 0x19, 0x73);
589 if (!seekDone) {
590 cester_assert_true(seekDone);
591 return;
592 }
593
594 initializeTime();
595 CDROM_REG0 = 0;
596 CDROM_REG1 = CDL_GETLOCP;
597
598 while (CDROM_REG0 & 0x80);
599 CDROM_REG1 = CDL_NOP;
600
601 while (updateTime() < 50000);
602
603 waitCDRomIRQ();
604 uint8_t cause1 = ackCDRomCause();
605 CDROM_REG0 = 1;
606 uint8_t cause1b = CDROM_REG3_UC;
607 uint8_t response1[16];
608 uint8_t responseSize1 = readResponse(response1);
609 waitCDRomIRQ();
610 uint8_t response2[16];
611 uint8_t responseSize2 = readResponse(response2);
612 uint8_t cause2 = ackCDRomCause();
613 CDROM_REG0 = 1;
614 uint8_t cause2b = CDROM_REG3_UC;
615
616 cester_assert_uint_eq(3, cause1);
617 cester_assert_uint_eq(0xe0, cause1b);
618 cester_assert_uint_eq(5, response1[0]);
619 cester_assert_uint_eq(8, responseSize1);
620 cester_assert_uint_eq(3, cause2);
621 cester_assert_uint_eq(0xe0, cause2b);
622 cester_assert_uint_eq(2, response2[0]);
623 cester_assert_uint_eq(1, responseSize2);
624
625)
626
627CESTER_TEST(mixedReadAndAck2, test_instances,
628 int resetDone = resetCDRom();
629 if (!resetDone) {
630 cester_assert_true(resetDone);
631 return;
632 }
633
634 int seekDone = seekPTo(0x70, 0x19, 0x73);
635 if (!seekDone) {
636 cester_assert_true(seekDone);
637 return;
638 }
639
640 initializeTime();
641 CDROM_REG0 = 0;
642 CDROM_REG1 = CDL_GETLOCP;
643
644 while (CDROM_REG0 & 0x80);
645 CDROM_REG1 = CDL_NOP;
646
647 while (updateTime() < 50000);
648
649 waitCDRomIRQ();
650 uint8_t response1[16];
651 uint8_t responseSize1 = readResponse(response1);
652 uint8_t cause1 = ackCDRomCause();
653 CDROM_REG0 = 1;
654 uint8_t cause1b = CDROM_REG3_UC;
655 waitCDRomIRQ();
656 uint8_t cause2 = ackCDRomCause();
657 CDROM_REG0 = 1;
658 uint8_t cause2b = CDROM_REG3_UC;
659 uint8_t response2[16];
660 uint8_t responseSize2 = readResponse(response2);
661
662 cester_assert_uint_eq(3, cause1);
663 cester_assert_uint_eq(0xe0, cause1b);
664 cester_assert_uint_eq(5, response1[0]);
665 cester_assert_uint_eq(8, responseSize1);
666 cester_assert_uint_eq(3, cause2);
667 cester_assert_uint_eq(0xe0, cause2b);
668 cester_assert_uint_eq(2, response2[0]);
669 cester_assert_uint_eq(1, responseSize2);
670)
errorTime
uint32_t errorTime
Definition cdlgetlocl.c:81
ctrl5
uint8_t ctrl5
Definition cdlid.c:219
responseSize3
uint8_t responseSize3
Definition cdlid.c:218
cause3b
uint8_t cause3b
Definition cdlid.c:221
cause3
uint8_t cause3
Definition cdlid.c:216
response3
uint8_t response3[16]
Definition cdlid.c:217
ctrl6
uint8_t ctrl6
Definition cdlreadn.c:203
ctrl2b
uint8_t ctrl2b
Definition cdlreads.c:760
CDL_GETTD
@ CDL_GETTD
Definition cdrom.h:62
CDL_NOP
@ CDL_NOP
Definition cdrom.h:43
CDL_SEEKL
@ CDL_SEEKL
Definition cdrom.h:63
CDL_SEEKP
@ CDL_SEEKP
Definition cdrom.h:64
CDL_GETLOCP
@ CDL_GETLOCP
Definition cdrom.h:59
CDROM_REG3_UC
#define CDROM_REG3_UC
Definition cdrom.h:39
ramsyscall_printf
ramsyscall_printf("=== e01_kseg1_reads_no_fill ===\n")
i
int i
Definition gte-regio.c:297
cester_assert_uint_eq
cester_assert_uint_eq(3, cause1)
CDROM_REG0
CDROM_REG0
Definition race.c:88
responseSize
uint8_t responseSize
Definition race.c:455
ackTime
uint32_t ackTime
Definition race.c:93
response2
uint8_t response2[16]
Definition race.c:346
responseSize2
uint8_t responseSize2
Definition race.c:347
responseSize1
uint8_t responseSize1
Definition race.c:97
waitCDRomIRQ
waitCDRomIRQ()
CESTER_TEST
CESTER_TEST(raceGetLocPAndNop, test_instances, int resetDone=resetCDRom();if(!resetDone) { cester_assert_true(resetDone);return;} int seekDone=seekPTo(0x70, 0x19, 0x73);if(!seekDone) { cester_assert_true(seekDone);return;} initializeTime();CDROM_REG0=0;CDROM_REG1=CDL_GETLOCP;CDROM_REG1=CDL_NOP;uint8_t ctrl0=CDROM_REG0 &~3;uint32_t ackTime=waitCDRomIRQ();uint8_t cause1=ackCDRomCause();uint8_t ctrl1=CDROM_REG0 &~3;uint8_t response1[16];uint8_t responseSize1=readResponse(response1);uint8_t ctrl2=CDROM_REG0 &~3;CDROM_REG0=1;uint8_t cause1b=CDROM_REG3_UC;initializeTime();uint32_t timeout=150000;int gotIRQ=waitCDRomIRQWithTimeout(&timeout);cester_assert_uint_eq(3, cause1);cester_assert_uint_eq(0xe0, cause1b);cester_assert_uint_eq(0x98, ctrl0);cester_assert_uint_eq(0x38, ctrl1);cester_assert_uint_eq(0x18, ctrl2);cester_assert_uint_eq(2, response1[0]);cester_assert_uint_eq(1, responseSize1);cester_assert_false(gotIRQ);cester_assert_uint_ge(ackTime, 500);cester_assert_uint_lt(ackTime, 7000);ramsyscall_printf("GetLocP followed by Nop, ack in %ius\n", ackTime);) CESTER_TEST(raceNopAndGetLocP
setLocDone
int setLocDone
Definition race.c:306
response
uint8_t response[16]
Definition race.c:454
resetDone
int resetDone
Definition race.c:75
ctrl4
uint8_t ctrl4
Definition race.c:348
count
unsigned count
Definition race.c:448
ctrl0b
uint8_t ctrl0b
Definition race.c:324
response1
uint8_t response1[16]
Definition race.c:96
timeout
uint32_t timeout
Definition race.c:103
test_instance
test_instance
Definition race.c:163
test_instances
test_instances
Definition race.c:74
cause2b
uint8_t cause2b
Definition race.c:350
ctrl0
uint8_t ctrl0
Definition race.c:91
gotIRQ
int gotIRQ
Definition race.c:104
ctrl2
uint8_t ctrl2
Definition race.c:98
cause1
uint8_t cause1
Definition race.c:94
cester_assert_false
cester_assert_false(gotIRQ)
cause2
uint8_t cause2
Definition race.c:344
ackTime2
uint32_t ackTime2
Definition race.c:343
cester_assert_uint_ge
cester_assert_uint_ge(ackTime, 500)
cester_assert_uint_lt
cester_assert_uint_lt(ackTime, 7000)
cause1b
uint8_t cause1b
Definition race.c:100
ctrl1
uint8_t ctrl1
Definition race.c:95
CDROM_REG2
CDROM_REG2
Definition race.c:173
initializeTime
initializeTime()
CDROM_REG1
CDROM_REG1
Definition race.c:89
seekDone
int seekDone
Definition race.c:81
ctrl3
uint8_t ctrl3
Definition race.c:345
ackCDRomCause
ackCDRomCause()
cester_assert_true
cester_assert_true(seekDone)
readResponse
readResponse(response)
uint32_t
void uint32_t(classId, spec)
Generated by doxygen 1.9.8