Nugget
Bare-metal libraries and examples for the original PlayStation
Loading...
Searching...
No Matches
reading.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(simpleReading, test_instances,
30 int resetDone = resetCDRom();
31 if (!resetDone) {
32 cester_assert_true(resetDone);
33 return;
34 }
35
36 int setModeDone = setMode(0x80);
37 if (!setModeDone) {
38 cester_assert_true(setModeDone);
39 return;
40 }
41
42 int seekDone = seekLTo(0x20, 2, 0);
43
44 if (!seekDone) {
45 cester_assert_true(seekDone);
46 return;
47 }
48
49 CDROM_REG0 = 0;
50 CDROM_REG1 = CDL_READN;
51 uint8_t response[16];
52 waitCDRomIRQ();
53 uint8_t cause1 = ackCDRomCause();
54 readResponse(response);
55
56 uint32_t sectorData[100];
57 uint8_t causes[100];
58
59 __builtin_memset(sectorData, 0, sizeof(sectorData));
60 __builtin_memset(causes, 0, sizeof(causes));
61
62 for (unsigned i = 0; i < 100; i++) {
63 waitCDRomIRQ();
64 uint8_t cause = ackCDRomCause();
65 causes[i] = cause;
66 readResponse(response);
67 if (cause != 1) break;
68
69 uint8_t sector[2048];
70
71 CDROM_REG0 = 0;
72 CDROM_REG3 = 0x80;
73
74 uint32_t dicr = DICR;
75 dicr &= 0x00ffffff;
76 dicr |= 0x00880000;
77 DICR = dicr;
78 DPCR |= 0x8000;
79 DMA_CTRL[DMA_CDROM].MADR = (uintptr_t)sector;
80 DMA_CTRL[DMA_CDROM].BCR = (2048 >> 2) | 0x10000;
81 DMA_CTRL[DMA_CDROM].CHCR = 0x11000000;
82
83 while ((DMA_CTRL[DMA_CDROM].CHCR & 0x01000000) != 0);
84 dicr = DICR;
85 dicr &= 0x00ffffff;
86 dicr |= 0x88000000;
87 DICR = dicr;
88 CDROM_REG3 = 0;
89
90 uint32_t *sector32 = (uint32_t *)sector;
91 sectorData[i] = sector32[0];
92 }
93
94 CDROM_REG0 = 0;
95 CDROM_REG1 = CDL_PAUSE;
96 waitCDRomIRQ();
97 uint8_t cause2 = ackCDRomCause();
98 readResponse(response);
99 waitCDRomIRQ();
100 uint8_t cause3 = ackCDRomCause();
101 readResponse(response);
102
103 uint32_t start = 20 * 60 * 75;
104 for (unsigned i = 0; i < 100; i++) {
105 cester_assert_uint_eq(start + i, sectorData[i]);
106 cester_assert_uint_eq(1, causes[i]);
107 }
108 cester_assert_uint_eq(3, cause1);
109 cester_assert_uint_eq(3, cause2);
110 cester_assert_uint_eq(2, cause3);
111)
112
113CESTER_TEST(setLocDuringSimpleReading, test_instances,
114 int resetDone = resetCDRom();
115 if (!resetDone) {
116 cester_assert_true(resetDone);
117 return;
118 }
119
120 int setModeDone = setMode(0x80);
121 if (!setModeDone) {
122 cester_assert_true(setModeDone);
123 return;
124 }
125
126 int seekDone = seekLTo(0x20, 2, 0);
127 int setLocDone = 0;
128
129 if (!seekDone) {
130 cester_assert_true(seekDone);
131 return;
132 }
133
134 CDROM_REG0 = 0;
135 CDROM_REG1 = CDL_READN;
136 uint8_t response[16];
137 waitCDRomIRQ();
138 uint8_t cause1 = ackCDRomCause();
139 readResponse(response);
140
141 uint32_t sectorData[100];
142 uint8_t causes[100];
143
144 __builtin_memset(sectorData, 0, sizeof(sectorData));
145 __builtin_memset(causes, 0, sizeof(causes));
146
147 for (unsigned i = 0; i < 100; i++) {
148 waitCDRomIRQ();
149 uint8_t cause = ackCDRomCause();
150 causes[i] = cause;
151 readResponse(response);
152 if (cause != 1) break;
153
154 uint8_t sector[2048];
155
156 CDROM_REG0 = 0;
157 CDROM_REG3 = 0x80;
158
159 uint32_t dicr = DICR;
160 dicr &= 0x00ffffff;
161 dicr |= 0x00880000;
162 DICR = dicr;
163 DPCR |= 0x8000;
164 DMA_CTRL[DMA_CDROM].MADR = (uintptr_t)sector;
165 DMA_CTRL[DMA_CDROM].BCR = (2048 >> 2) | 0x10000;
166 DMA_CTRL[DMA_CDROM].CHCR = 0x11000000;
167
168 while ((DMA_CTRL[DMA_CDROM].CHCR & 0x01000000) != 0);
169 dicr = DICR;
170 dicr &= 0x00ffffff;
171 dicr |= 0x88000000;
172 DICR = dicr;
173 CDROM_REG3 = 0;
174
175 uint32_t *sector32 = (uint32_t *)sector;
176 sectorData[i] = sector32[0];
177
178 if (i == 50) setLocDone = setLoc(0x20, 2, 0);
179 }
180
181 CDROM_REG0 = 0;
182 CDROM_REG1 = CDL_PAUSE;
183 waitCDRomIRQ();
184 uint8_t cause2 = ackCDRomCause();
185 readResponse(response);
186 waitCDRomIRQ();
187 uint8_t cause3 = ackCDRomCause();
188 readResponse(response);
189
190 uint32_t start = 20 * 60 * 75;
191 for (unsigned i = 0; i < 100; i++) {
192 cester_assert_uint_eq(start + i, sectorData[i]);
193 cester_assert_uint_eq(1, causes[i]);
194 }
195 cester_assert_uint_eq(3, cause1);
196 cester_assert_uint_eq(3, cause2);
197 cester_assert_uint_eq(2, cause3);
198 cester_assert_true(seekDone);
199)
200
201CESTER_TEST(simpleReadingWithoutAck, test_instances,
202 int resetDone = resetCDRom();
203 if (!resetDone) {
204 cester_assert_true(resetDone);
205 return;
206 }
207
208 int setModeDone = setMode(0x80);
209 if (!setModeDone) {
210 cester_assert_true(setModeDone);
211 return;
212 }
213
214 int seekDone = seekLTo(0x20, 0, 0);
215 if (!seekDone) {
216 cester_assert_true(seekDone);
217 return;
218 }
219
220 CDROM_REG0 = 0;
221 CDROM_REG1 = CDL_READN;
222 waitCDRomIRQ();
223 ackCDRomCause();
224 uint8_t response[16];
225 readResponse(response);
226
227 initializeTime();
228 while (updateTime() <= 500000);
229
230 initializeTime();
231 uint32_t time1 = waitCDRomIRQ();
232 uint8_t cause1 = ackCDRomCause();
233 uint8_t ctrl1 = CDROM_REG0 & ~3;
234 uint8_t response1[16];
235 uint8_t responseSize1 = readResponse(response1);
236 uint8_t ctrl2 = CDROM_REG0 & ~3;
237 CDROM_REG0 = 1;
238 uint8_t cause1b = CDROM_REG3_UC;
239
240 initializeTime();
241 uint32_t time2 = waitCDRomIRQ();
242 uint8_t cause2 = ackCDRomCause();
243 uint8_t ctrl3 = CDROM_REG0 & ~3;
244 uint8_t response2[16];
245 uint8_t responseSize2 = readResponse(response2);
246 uint8_t ctrl4 = CDROM_REG0 & ~3;
247 CDROM_REG0 = 1;
248 uint8_t cause2b = CDROM_REG3_UC;
249
250 CDROM_REG0 = 0;
251 CDROM_REG1 = CDL_PAUSE;
252
253 initializeTime();
254 uint32_t time3 = waitCDRomIRQ();
255 uint8_t cause3 = ackCDRomCause();
256 uint8_t ctrl5 = CDROM_REG0 & ~3;
257 uint8_t response3[16];
258 uint8_t responseSize3 = readResponse(response3);
259 uint8_t ctrl6 = CDROM_REG0 & ~3;
260 CDROM_REG0 = 1;
261 uint8_t cause3b = CDROM_REG3_UC;
262
263 initializeTime();
264 uint32_t time4 = waitCDRomIRQ();
265 uint8_t cause4 = ackCDRomCause();
266 uint8_t ctrl7 = CDROM_REG0 & ~3;
267 uint8_t response4[16];
268 uint8_t responseSize4 = readResponse(response4);
269 uint8_t ctrl8 = CDROM_REG0 & ~3;
270 CDROM_REG0 = 1;
271 uint8_t cause4b = CDROM_REG3_UC;
272
273 cester_assert_uint_eq(1, cause1);
274 cester_assert_uint_eq(0xe0, cause1b);
275 cester_assert_uint_eq(1, cause2);
276 cester_assert_uint_eq(0xe0, cause2b);
277 cester_assert_uint_eq(3, cause3);
278 cester_assert_uint_eq(0xe0, cause3b);
279 cester_assert_uint_eq(2, cause4);
280 cester_assert_uint_eq(0xe0, cause4b);
281 cester_assert_uint_eq(0x38, ctrl1);
282 cester_assert_uint_eq(0x18, ctrl2);
283 cester_assert_uint_eq(0x38, ctrl3);
284 cester_assert_uint_eq(0x18, ctrl4);
285 cester_assert_uint_eq(0x38, ctrl5);
286 cester_assert_uint_eq(0x18, ctrl6);
287 cester_assert_uint_eq(0x38, ctrl7);
288 cester_assert_uint_eq(0x18, ctrl8);
289 cester_assert_uint_eq(0x22, response1[0]);
290 cester_assert_uint_eq(1, responseSize1);
291 cester_assert_uint_eq(0x22, response2[0]);
292 cester_assert_uint_eq(1, responseSize2);
293 cester_assert_uint_eq(0x22, response3[0]);
294 cester_assert_uint_eq(1, responseSize3);
295 cester_assert_uint_eq(2, response4[0]);
296 cester_assert_uint_eq(1, responseSize4);
297 ramsyscall_printf("Long read, ack then pause, ready1 in %ius, ready2 in %ius, ack in %ius, complete in %ius\n", time1, time2, time3, time4);
298)
299
300CESTER_TEST(simpleReadingWithoutAckNorResponseReadThenInit, test_instances,
301 int resetDone = resetCDRom();
302 if (!resetDone) {
303 cester_assert_true(resetDone);
304 return;
305 }
306
307 int setModeDone = setMode(0x80);
308 if (!setModeDone) {
309 cester_assert_true(setModeDone);
310 return;
311 }
312
313 int seekDone = seekLTo(0x20, 0, 0);
314 if (!seekDone) {
315 cester_assert_true(seekDone);
316 return;
317 }
318
319 CDROM_REG0 = 0;
320 CDROM_REG1 = CDL_READN;
321 waitCDRomIRQ();
322 ackCDRomCause();
323
324 initializeTime();
325 while (updateTime() <= 500000);
326
327 initializeTime();
328 uint32_t time1 = waitCDRomIRQ();
329 uint8_t cause1 = ackCDRomCause();
330 uint8_t ctrl1 = CDROM_REG0 & ~3;
331 uint8_t response1[16];
332 uint8_t responseSize1 = readResponse(response1);
333 uint8_t ctrl2 = CDROM_REG0 & ~3;
334 CDROM_REG0 = 1;
335 uint8_t cause1b = CDROM_REG3_UC;
336
337 initializeTime();
338 uint32_t time2 = waitCDRomIRQ();
339 uint8_t cause2 = ackCDRomCause();
340 uint8_t ctrl3 = CDROM_REG0 & ~3;
341 uint8_t response2[16];
342 uint8_t responseSize2 = readResponse(response2);
343 uint8_t ctrl4 = CDROM_REG0 & ~3;
344 CDROM_REG0 = 1;
345 uint8_t cause2b = CDROM_REG3_UC;
346
347 CDROM_REG0 = 0;
348 CDROM_REG1 = CDL_INIT;
349
350 initializeTime();
351 uint32_t time3 = waitCDRomIRQ();
352 uint8_t cause3 = ackCDRomCause();
353 uint8_t ctrl5 = CDROM_REG0 & ~3;
354 uint8_t response3[16];
355 uint8_t responseSize3 = readResponse(response3);
356 uint8_t ctrl6 = CDROM_REG0 & ~3;
357 CDROM_REG0 = 1;
358 uint8_t cause3b = CDROM_REG3_UC;
359
360 initializeTime();
361 uint32_t time4 = waitCDRomIRQ();
362 uint8_t cause4 = ackCDRomCause();
363 uint8_t ctrl7 = CDROM_REG0 & ~3;
364 uint8_t response4[16];
365 uint8_t responseSize4 = readResponse(response4);
366 uint8_t ctrl8 = CDROM_REG0 & ~3;
367 CDROM_REG0 = 1;
368 uint8_t cause4b = CDROM_REG3_UC;
369
370 cester_assert_uint_eq(1, cause1);
371 cester_assert_uint_eq(0xe0, cause1b);
372 cester_assert_uint_eq(1, cause2);
373 cester_assert_uint_eq(0xe0, cause2b);
374 cester_assert_uint_eq(3, cause3);
375 cester_assert_uint_eq(0xe0, cause3b);
376 cester_assert_uint_eq(2, cause4);
377 cester_assert_uint_eq(0xe0, cause4b);
378 cester_assert_uint_eq(0x38, ctrl1);
379 cester_assert_uint_eq(0x18, ctrl2);
380 cester_assert_uint_eq(0x38, ctrl3);
381 cester_assert_uint_eq(0x18, ctrl4);
382 cester_assert_uint_eq(0x38, ctrl5);
383 cester_assert_uint_eq(0x18, ctrl6);
384 cester_assert_uint_eq(0x38, ctrl7);
385 cester_assert_uint_eq(0x18, ctrl8);
386 cester_assert_uint_eq(0x22, response1[0]);
387 cester_assert_uint_eq(1, responseSize1);
388 cester_assert_uint_eq(0x22, response2[0]);
389 cester_assert_uint_eq(1, responseSize2);
390 cester_assert_uint_eq(0x22, response3[0]);
391 cester_assert_uint_eq(1, responseSize3);
392 cester_assert_uint_eq(2, response4[0]);
393 cester_assert_uint_eq(1, responseSize4);
394 ramsyscall_printf("Long read, no response read, ack then init, ready1 in %ius, ready2 in %ius, ack in %ius, complete in %ius\n", time1, time2, time3, time4);
395)
396
397CESTER_TEST(simpleReadingWithoutAckThenInit, test_instances,
398 int resetDone = resetCDRom();
399 if (!resetDone) {
400 cester_assert_true(resetDone);
401 return;
402 }
403
404 int setModeDone = setMode(0x80);
405 if (!setModeDone) {
406 cester_assert_true(setModeDone);
407 return;
408 }
409
410 int seekDone = seekLTo(0x20, 0, 0);
411 if (!seekDone) {
412 cester_assert_true(seekDone);
413 return;
414 }
415
416 CDROM_REG0 = 0;
417 CDROM_REG1 = CDL_READN;
418 waitCDRomIRQ();
419 ackCDRomCause();
420 uint8_t response[16];
421 readResponse(response);
422
423 initializeTime();
424 while (updateTime() <= 500000);
425
426 initializeTime();
427 uint32_t time1 = waitCDRomIRQ();
428 uint8_t cause1 = ackCDRomCause();
429 uint8_t ctrl1 = CDROM_REG0 & ~3;
430 uint8_t response1[16];
431 uint8_t responseSize1 = readResponse(response1);
432 uint8_t ctrl2 = CDROM_REG0 & ~3;
433 CDROM_REG0 = 1;
434 uint8_t cause1b = CDROM_REG3_UC;
435
436 initializeTime();
437 uint32_t time2 = waitCDRomIRQ();
438 uint8_t cause2 = ackCDRomCause();
439 uint8_t ctrl3 = CDROM_REG0 & ~3;
440 uint8_t response2[16];
441 uint8_t responseSize2 = readResponse(response2);
442 uint8_t ctrl4 = CDROM_REG0 & ~3;
443 CDROM_REG0 = 1;
444 uint8_t cause2b = CDROM_REG3_UC;
445
446 CDROM_REG0 = 0;
447 CDROM_REG1 = CDL_INIT;
448
449 initializeTime();
450 uint32_t time3 = waitCDRomIRQ();
451 uint8_t cause3 = ackCDRomCause();
452 uint8_t ctrl5 = CDROM_REG0 & ~3;
453 uint8_t response3[16];
454 uint8_t responseSize3 = readResponse(response3);
455 uint8_t ctrl6 = CDROM_REG0 & ~3;
456 CDROM_REG0 = 1;
457 uint8_t cause3b = CDROM_REG3_UC;
458
459 initializeTime();
460 uint32_t time4 = waitCDRomIRQ();
461 uint8_t cause4 = ackCDRomCause();
462 uint8_t ctrl7 = CDROM_REG0 & ~3;
463 uint8_t response4[16];
464 uint8_t responseSize4 = readResponse(response4);
465 uint8_t ctrl8 = CDROM_REG0 & ~3;
466 CDROM_REG0 = 1;
467 uint8_t cause4b = CDROM_REG3_UC;
468
469 cester_assert_uint_eq(1, cause1);
470 cester_assert_uint_eq(0xe0, cause1b);
471 cester_assert_uint_eq(1, cause2);
472 cester_assert_uint_eq(0xe0, cause2b);
473 cester_assert_uint_eq(3, cause3);
474 cester_assert_uint_eq(0xe0, cause3b);
475 cester_assert_uint_eq(2, cause4);
476 cester_assert_uint_eq(0xe0, cause4b);
477 cester_assert_uint_eq(0x38, ctrl1);
478 cester_assert_uint_eq(0x18, ctrl2);
479 cester_assert_uint_eq(0x38, ctrl3);
480 cester_assert_uint_eq(0x18, ctrl4);
481 cester_assert_uint_eq(0x38, ctrl5);
482 cester_assert_uint_eq(0x18, ctrl6);
483 cester_assert_uint_eq(0x38, ctrl7);
484 cester_assert_uint_eq(0x18, ctrl8);
485 cester_assert_uint_eq(0x22, response1[0]);
486 cester_assert_uint_eq(1, responseSize1);
487 cester_assert_uint_eq(0x22, response2[0]);
488 cester_assert_uint_eq(1, responseSize2);
489 cester_assert_uint_eq(0x22, response3[0]);
490 cester_assert_uint_eq(1, responseSize3);
491 cester_assert_uint_eq(2, response4[0]);
492 cester_assert_uint_eq(1, responseSize4);
493 ramsyscall_printf("Long read, ack then init, ready1 in %ius, ready2 in %ius, ack in %ius, complete in %ius\n", time1, time2, time3, time4);
494)
495
496CESTER_TEST(simpleReadingPauseWithoutAck, test_instances,
497 int resetDone = resetCDRom();
498 if (!resetDone) {
499 cester_assert_true(resetDone);
500 return;
501 }
502
503 int setModeDone = setMode(0x80);
504 if (!setModeDone) {
505 cester_assert_true(setModeDone);
506 return;
507 }
508
509 int seekDone = seekLTo(0x20, 0, 0);
510 if (!seekDone) {
511 cester_assert_true(seekDone);
512 return;
513 }
514
515 CDROM_REG0 = 0;
516 CDROM_REG1 = CDL_READN;
517 waitCDRomIRQ();
518 ackCDRomCause();
519 uint8_t response[16];
520 readResponse(response);
521
522 initializeTime();
523 while (updateTime() <= 500000);
524
525 CDROM_REG0 = 0;
526 CDROM_REG1 = CDL_PAUSE;
527
528 unsigned readyCount = 0;
529 uint32_t time1;
530 uint8_t cause1;
531 uint8_t ctrl1, ctrl2;
532 uint8_t response1[16];
533 uint8_t responseSize1;
534 while (1) {
535 initializeTime();
536 time1 = waitCDRomIRQ();
537 cause1 = ackCDRomCause();
538 ctrl1 = CDROM_REG0 & ~3;
539 responseSize1 = readResponse(response1);
540 ctrl2 = CDROM_REG0 & ~3;
541 if (cause1 == 1) {
542 readyCount++;
543 } else {
544 break;
545 }
546 }
547
548 initializeTime();
549 uint32_t time2 = waitCDRomIRQ();
550 uint8_t cause2 = ackCDRomCause();
551 uint8_t ctrl3 = CDROM_REG0 & ~3;
552 uint8_t response2[16];
553 uint8_t responseSize2 = readResponse(response2);
554 uint8_t ctrl4 = CDROM_REG0 & ~3;
555 CDROM_REG0 = 1;
556 uint8_t cause2b = CDROM_REG3_UC;
557
558 cester_assert_uint_eq(3, cause1);
559 cester_assert_uint_eq(2, cause2);
560 cester_assert_uint_eq(0xe0, cause2b);
561 cester_assert_uint_eq(0x38, ctrl1);
562 cester_assert_uint_eq(0x18, ctrl2);
563 cester_assert_uint_eq(0x38, ctrl3);
564 cester_assert_uint_eq(0x18, ctrl4);
565 cester_assert_uint_eq(0x22, response1[0]);
566 cester_assert_uint_eq(1, responseSize1);
567 cester_assert_uint_eq(2, response2[0]);
568 cester_assert_uint_eq(1, responseSize2);
569 cester_assert_uint_ge(readyCount, 1);
570 cester_assert_uint_le(readyCount, 2);
571 ramsyscall_printf("Long read, pause then ack, ack in %ius, complete in %ius\n", time1, time2);
572)
573
574CESTER_TEST(simpleReadingNopQuery, test_instances,
575 int resetDone = resetCDRom();
576 if (!resetDone) {
577 cester_assert_true(resetDone);
578 return;
579 }
580
581 int setModeDone = setMode(0x80);
582 if (!setModeDone) {
583 cester_assert_true(setModeDone);
584 return;
585 }
586
587 int seekDone = seekLTo(0x20, 0, 0);
588 if (!seekDone) {
589 cester_assert_true(seekDone);
590 return;
591 }
592
593 CDROM_REG0 = 0;
594 CDROM_REG1 = CDL_READN;
595 waitCDRomIRQ();
596 ackCDRomCause();
597 uint8_t response[16];
598 readResponse(response);
599
600 CDROM_REG0 = 0;
601 CDROM_REG1 = CDL_NOP;
602
603 initializeTime();
604 uint32_t time1 = waitCDRomIRQ();
605 uint8_t cause1 = ackCDRomCause();
606 uint8_t ctrl1 = CDROM_REG0 & ~3;
607 uint8_t response1[16];
608 uint8_t responseSize1 = readResponse(response1);
609 uint8_t ctrl2 = CDROM_REG0 & ~3;
610 CDROM_REG0 = 1;
611 uint8_t cause1b = CDROM_REG3_UC;
612
613 initializeTime();
614 uint32_t time2 = waitCDRomIRQ();
615 uint8_t cause2 = ackCDRomCause();
616 uint8_t ctrl3 = CDROM_REG0 & ~3;
617 uint8_t response2[16];
618 uint8_t responseSize2 = readResponse(response2);
619 uint8_t ctrl4 = CDROM_REG0 & ~3;
620 CDROM_REG0 = 1;
621 uint8_t cause2b = CDROM_REG3_UC;
622
623 CDROM_REG0 = 0;
624 CDROM_REG1 = CDL_PAUSE;
625
626 initializeTime();
627 uint32_t time3 = waitCDRomIRQ();
628 uint8_t cause3 = ackCDRomCause();
629 uint8_t ctrl5 = CDROM_REG0 & ~3;
630 uint8_t response3[16];
631 uint8_t responseSize3 = readResponse(response3);
632 uint8_t ctrl6 = CDROM_REG0 & ~3;
633 CDROM_REG0 = 1;
634 uint8_t cause3b = CDROM_REG3_UC;
635
636 initializeTime();
637 uint32_t time4 = waitCDRomIRQ();
638 uint8_t cause4 = ackCDRomCause();
639 uint8_t ctrl7 = CDROM_REG0 & ~3;
640 uint8_t response4[16];
641 uint8_t responseSize4 = readResponse(response4);
642 uint8_t ctrl8 = CDROM_REG0 & ~3;
643 CDROM_REG0 = 1;
644 uint8_t cause4b = CDROM_REG3_UC;
645
646 cester_assert_uint_eq(3, cause1);
647 cester_assert_uint_eq(0xe0, cause1b);
648 cester_assert_uint_eq(1, cause2);
649 cester_assert_uint_eq(0xe0, cause2b);
650 cester_assert_uint_eq(3, cause3);
651 cester_assert_uint_eq(0xe0, cause3b);
652 cester_assert_uint_eq(2, cause4);
653 cester_assert_uint_eq(0xe0, cause4b);
654 cester_assert_uint_eq(0x38, ctrl1);
655 cester_assert_uint_eq(0x18, ctrl2);
656 cester_assert_uint_eq(0x38, ctrl3);
657 cester_assert_uint_eq(0x18, ctrl4);
658 cester_assert_uint_eq(0x38, ctrl5);
659 cester_assert_uint_eq(0x18, ctrl6);
660 cester_assert_uint_eq(0x38, ctrl7);
661 cester_assert_uint_eq(0x18, ctrl8);
662 cester_assert_uint_eq(0x02, response1[0]);
663 cester_assert_uint_eq(1, responseSize1);
664 cester_assert_uint_eq(0x22, response2[0]);
665 cester_assert_uint_eq(1, responseSize2);
666 cester_assert_uint_eq(0x22, response3[0]);
667 cester_assert_uint_eq(1, responseSize3);
668 cester_assert_uint_eq(2, response4[0]);
669 cester_assert_uint_eq(1, responseSize4);
670 ramsyscall_printf("Long read, nop then pause, ack in %ius, ready in %ius, ack in %ius, complete in %ius\n", time1, time2, time3, time4);
671)
672
673CESTER_TEST(simpleReadingNopSeriesQuery, test_instances,
674 int resetDone = resetCDRom();
675 if (!resetDone) {
676 cester_assert_true(resetDone);
677 return;
678 }
679
680 int setModeDone = setMode(0x80);
681 if (!setModeDone) {
682 cester_assert_true(setModeDone);
683 return;
684 }
685
686 int seekDone = seekLTo(0x20, 0, 0);
687 if (!seekDone) {
688 cester_assert_true(seekDone);
689 return;
690 }
691
692 CDROM_REG0 = 0;
693 CDROM_REG1 = CDL_READN;
694 waitCDRomIRQ();
695 ackCDRomCause();
696 uint8_t response[16];
697 readResponse(response);
698
699 initializeTime();
700
701 unsigned countToRead = 0;
702 unsigned gotInt1 = 0;
703
704 do {
705 CDROM_REG0 = 0;
706 CDROM_REG1 = CDL_NOP;
707 uint8_t cause = 0;
708 do {
709 waitCDRomIRQ();
710 cause = ackCDRomCause();
711 readResponse(response);
712 if (cause == 1) {
713 gotInt1 = 1;
714 }
715 } while (cause == 1);
716 countToRead++;
717 } while (!gotInt1);
718
719 CDROM_REG0 = 0;
720 CDROM_REG1 = CDL_NOP;
721
722 initializeTime();
723 uint32_t time1 = waitCDRomIRQ();
724 uint8_t cause1 = ackCDRomCause();
725 uint8_t ctrl1 = CDROM_REG0 & ~3;
726 uint8_t response1[16];
727 uint8_t responseSize1 = readResponse(response1);
728 uint8_t ctrl2 = CDROM_REG0 & ~3;
729 CDROM_REG0 = 1;
730 uint8_t cause1b = CDROM_REG3_UC;
731
732 initializeTime();
733 uint32_t time2 = waitCDRomIRQ();
734 uint8_t cause2 = ackCDRomCause();
735 uint8_t ctrl3 = CDROM_REG0 & ~3;
736 uint8_t response2[16];
737 uint8_t responseSize2 = readResponse(response2);
738 uint8_t ctrl4 = CDROM_REG0 & ~3;
739 CDROM_REG0 = 1;
740 uint8_t cause2b = CDROM_REG3_UC;
741
742 CDROM_REG0 = 0;
743 CDROM_REG1 = CDL_PAUSE;
744
745 initializeTime();
746 uint32_t time3 = waitCDRomIRQ();
747 uint8_t cause3 = ackCDRomCause();
748 uint8_t ctrl5 = CDROM_REG0 & ~3;
749 uint8_t response3[16];
750 uint8_t responseSize3 = readResponse(response3);
751 uint8_t ctrl6 = CDROM_REG0 & ~3;
752 CDROM_REG0 = 1;
753 uint8_t cause3b = CDROM_REG3_UC;
754
755 initializeTime();
756 uint32_t time4 = waitCDRomIRQ();
757 uint8_t cause4 = ackCDRomCause();
758 uint8_t ctrl7 = CDROM_REG0 & ~3;
759 uint8_t response4[16];
760 uint8_t responseSize4 = readResponse(response4);
761 uint8_t ctrl8 = CDROM_REG0 & ~3;
762 CDROM_REG0 = 1;
763 uint8_t cause4b = CDROM_REG3_UC;
764
765 cester_assert_uint_lt(countToRead, 80);
766 cester_assert_uint_eq(3, cause1);
767 cester_assert_uint_eq(0xe0, cause1b);
768 cester_assert_uint_eq(1, cause2);
769 cester_assert_uint_eq(0xe0, cause2b);
770 cester_assert_uint_eq(3, cause3);
771 cester_assert_uint_eq(0xe0, cause3b);
772 cester_assert_uint_eq(2, cause4);
773 cester_assert_uint_eq(0xe0, cause4b);
774 cester_assert_uint_eq(0x38, ctrl1);
775 cester_assert_uint_eq(0x18, ctrl2);
776 cester_assert_uint_eq(0x38, ctrl3);
777 cester_assert_uint_eq(0x18, ctrl4);
778 cester_assert_uint_eq(0x38, ctrl5);
779 cester_assert_uint_eq(0x18, ctrl6);
780 cester_assert_uint_eq(0x38, ctrl7);
781 cester_assert_uint_eq(0x18, ctrl8);
782 cester_assert_uint_eq(0x22, response1[0]);
783 cester_assert_uint_eq(1, responseSize1);
784 cester_assert_uint_eq(0x22, response2[0]);
785 cester_assert_uint_eq(1, responseSize2);
786 cester_assert_uint_eq(0x22, response3[0]);
787 cester_assert_uint_eq(1, responseSize3);
788 cester_assert_uint_eq(0x02, response4[0]);
789 cester_assert_uint_eq(1, responseSize4);
790 ramsyscall_printf("Long read, nop series of %i then pause, ack in %ius, ready in %ius, ack in %ius, complete in %ius\n", countToRead, time1, time2, time3, time4);
791)
792
793CESTER_TEST(simpleReadingNoSeekNopQueries, test_instances,
794 int resetDone = resetCDRom();
795 if (!resetDone) {
796 cester_assert_true(resetDone);
797 return;
798 }
799
800 int setLocDone = setLoc(0x60, 0x02, 0x00);
801 if (!setLocDone) {
802 cester_assert_true(setLocDone);
803 return;
804 }
805
806 initializeTime();
807 CDROM_REG0 = 0;
808 CDROM_REG1 = CDL_READN;
809 uint32_t time1 = waitCDRomIRQ();
810 ackCDRomCause();
811 uint8_t response[16];
812 readResponse(response);
813
814 uint8_t runningCause;
815 uint8_t responses[32];
816 uint32_t times[32];
817 int32_t lastResponse = -1;
818 unsigned responseCount = 0;
819 __builtin_memset(times, 0, sizeof(times));
820
821 do {
822 CDROM_REG0 = 0;
823 CDROM_REG1 = CDL_NOP;
824 uint32_t time = waitCDRomIRQ();
825 runningCause = ackCDRomCause();
826 uint8_t runningResponse[16];
827 readResponse(runningResponse);
828 uint8_t r = runningResponse[0];
829 if (r != lastResponse) {
830 lastResponse = r;
831 if (responseCount < 32) {
832 responses[responseCount] = r;
833 times[responseCount] = time;
834 }
835 responseCount++;
836 }
837 } while(runningCause == 3);
838
839 uint32_t time2 = waitCDRomIRQ();
840 uint8_t cause = ackCDRomCause();
841 uint8_t response2[16];
842 readResponse(response2);
843
844 CDROM_REG0 = 0;
845 CDROM_REG1 = CDL_PAUSE;
846
847 uint32_t time3 = waitCDRomIRQ();
848 ackCDRomCause();
849 uint8_t response3[16];
850 readResponse(response3);
851
852 uint32_t time4 = waitCDRomIRQ();
853 ackCDRomCause();
854 uint8_t response4[16];
855 readResponse(response4);
856
857 uint32_t dtime1 = times[0];
858 uint32_t dtime2 = times[1] - times[0];
859 uint32_t dtime3 = times[2] - times[1];
860
861 cester_assert_uint_eq(3, cause);
862 cester_assert_uint_eq(3, responseCount);
863 cester_assert_uint_eq(0x02, responses[0]);
864 cester_assert_uint_eq(0x42, responses[1]);
865 cester_assert_uint_eq(0x22, responses[2]);
866 cester_assert_uint_ge(dtime1, 1500);
867 cester_assert_uint_le(dtime1, 4000);
868 cester_assert_uint_ge(dtime2, 15000);
869 cester_assert_uint_le(dtime2, 50000);
870 cester_assert_uint_ge(dtime3, 700000);
871 cester_assert_uint_le(dtime3, 2000000);
872 ramsyscall_printf("Reading without seeking first, different nop count = %i, response1 = 0x%02x, dtime1 = %ius, response2 = 0x%02x, dtime2 = %ius, response3 = 0x%02x, dtime3 = %ius, time1 = %ius, time2 = %ius, time3 = %ius, time4 = %ius\n", responseCount, responses[0], dtime1, responses[1], dtime2, responses[2], dtime3, time1, time2, time3, time4);
873)
CHCR
DMA_CTRL[DMA_CDROM] CHCR
Definition cdlreadn.c:185
dicr
uint32_t dicr
Definition cdlreadn.c:178
CDL_NOP
@ CDL_NOP
Definition cdrom.h:43
CDL_READN
@ CDL_READN
Definition cdrom.h:48
CDL_PAUSE
@ CDL_PAUSE
Definition cdrom.h:51
CDL_INIT
@ CDL_INIT
Definition cdrom.h:52
CDROM_REG3_UC
#define CDROM_REG3_UC
Definition cdrom.h:39
CDROM_REG3
#define CDROM_REG3
Definition cdrom.h:34
r
uint32_t r
Definition cpu.c:222
ramsyscall_printf
ramsyscall_printf("=== e01_kseg1_reads_no_fill ===\n")
DMA_CTRL
#define DMA_CTRL
Definition dma.h:36
DMA_CDROM
@ DMA_CDROM
Definition dma.h:42
i
int i
Definition gte-regio.c:297
DPCR
#define DPCR
Definition hwregs.h:49
DICR
#define DICR
Definition hwregs.h:50
time2
uint32_t time2
Definition reading.c:338
ctrl6
uint8_t ctrl6
Definition reading.c:356
cester_assert_uint_eq
cester_assert_uint_eq(3, cause1)
cester_assert_true
cester_assert_true(seekDone)
response4
uint8_t response4[16]
Definition reading.c:364
cause4
uint8_t cause4
Definition reading.c:362
CDROM_REG0
CDROM_REG0
Definition reading.c:134
sectorData
uint32_t sectorData[100]
Definition reading.c:141
setModeDone
int setModeDone
Definition reading.c:120
response2
uint8_t response2[16]
Definition reading.c:341
responseSize2
uint8_t responseSize2
Definition reading.c:342
countToRead
unsigned countToRead
Definition reading.c:701
responseSize1
uint8_t responseSize1
Definition reading.c:332
waitCDRomIRQ
waitCDRomIRQ()
CESTER_TEST
CESTER_TEST(simpleReading, test_instances, int resetDone=resetCDRom();if(!resetDone) { cester_assert_true(resetDone);return;} int setModeDone=setMode(0x80);if(!setModeDone) { cester_assert_true(setModeDone);return;} int seekDone=seekLTo(0x20, 2, 0);if(!seekDone) { cester_assert_true(seekDone);return;} CDROM_REG0=0;CDROM_REG1=CDL_READN;uint8_t response[16];waitCDRomIRQ();uint8_t cause1=ackCDRomCause();readResponse(response);uint32_t sectorData[100];uint8_t causes[100];__builtin_memset(sectorData, 0, sizeof(sectorData));__builtin_memset(causes, 0, sizeof(causes));for(unsigned i=0;i< 100;i++) { waitCDRomIRQ();uint8_t cause=ackCDRomCause();causes[i]=cause;readResponse(response);if(cause !=1) break;uint8_t sector[2048];CDROM_REG0=0;CDROM_REG3=0x80;uint32_t dicr=DICR;dicr &=0x00ffffff;dicr|=0x00880000;DICR=dicr;DPCR|=0x8000;DMA_CTRL[DMA_CDROM].MADR=(uintptr_t) sector;DMA_CTRL[DMA_CDROM].BCR=(2048 > > 2)|0x10000;DMA_CTRL[DMA_CDROM].CHCR=0x11000000;while((DMA_CTRL[DMA_CDROM].CHCR &0x01000000) !=0);dicr=DICR;dicr &=0x00ffffff;dicr|=0x88000000;DICR=dicr;CDROM_REG3=0;uint32_t *sector32=(uint32_t *) sector;sectorData[i]=sector32[0];} CDROM_REG0=0;CDROM_REG1=CDL_PAUSE;waitCDRomIRQ();uint8_t cause2=ackCDRomCause();readResponse(response);waitCDRomIRQ();uint8_t cause3=ackCDRomCause();readResponse(response);uint32_t start=20 *60 *75;for(unsigned i=0;i< 100;i++) { cester_assert_uint_eq(start+i, sectorData[i]);cester_assert_uint_eq(1, causes[i]);} cester_assert_uint_eq(3, cause1);cester_assert_uint_eq(3, cause2);cester_assert_uint_eq(2, cause3);) CESTER_TEST(setLocDuringSimpleReading
ctrl7
uint8_t ctrl7
Definition reading.c:363
time3
uint32_t time3
Definition reading.c:351
setLocDone
int setLocDone
Definition reading.c:127
cause4b
uint8_t cause4b
Definition reading.c:368
response
uint8_t response[16]
Definition reading.c:136
gotInt1
unsigned gotInt1
Definition reading.c:702
start
uint32_t start
Definition reading.c:190
resetDone
int resetDone
Definition reading.c:114
ctrl4
uint8_t ctrl4
Definition reading.c:343
response1
uint8_t response1[16]
Definition reading.c:331
time1
uint32_t time1
Definition reading.c:328
cester_assert_uint_ge
cester_assert_uint_ge(readyCount, 1)
cause
uint8_t cause
Definition reading.c:707
test_instances
test_instances
Definition reading.c:113
cause2b
uint8_t cause2b
Definition reading.c:345
ctrl5
uint8_t ctrl5
Definition reading.c:353
time4
uint32_t time4
Definition reading.c:361
causes
uint8_t causes[100]
Definition reading.c:142
__builtin_memset
__builtin_memset(sectorData, 0, sizeof(sectorData))
ctrl8
uint8_t ctrl8
Definition reading.c:366
ctrl2
uint8_t ctrl2
Definition reading.c:333
cause1
uint8_t cause1
Definition reading.c:138
readResponse
readResponse(response)
cause2
uint8_t cause2
Definition reading.c:184
response3
uint8_t response3[16]
Definition reading.c:354
cause1b
uint8_t cause1b
Definition reading.c:335
ctrl1
uint8_t ctrl1
Definition reading.c:330
responseSize3
uint8_t responseSize3
Definition reading.c:355
cause3b
uint8_t cause3b
Definition reading.c:358
cester_assert_uint_le
cester_assert_uint_le(readyCount, 2)
initializeTime
initializeTime()
CDROM_REG1
CDROM_REG1
Definition reading.c:135
cester_assert_uint_lt
cester_assert_uint_lt(countToRead, 80)
seekDone
int seekDone
Definition reading.c:126
readyCount
unsigned readyCount
Definition reading.c:528
ctrl3
uint8_t ctrl3
Definition reading.c:340
cause3
uint8_t cause3
Definition reading.c:187
ackCDRomCause
ackCDRomCause()
responseSize4
uint8_t responseSize4
Definition reading.c:365
sector
static int sector
Definition syscalls.h:468
uint32_t
void uint32_t(classId, spec)
Generated by doxygen 1.9.8