JailDoctor/z80
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

- Afegit lagueirtofile pa compilar FASTuosament

Browse Source 
- [NEW] [zx_disk] funcions de debug
- [FIX] current_byte era un uint8_t i tenia que ser al menys uint16_t, per això fallava el READ DATA.
This commit is contained in:
Raimon Zamora
2025-08-07 16:06:42 +02:00
parent 884e509d67
commit b69da56526
5 changed files with 129 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -1,2 +1,3 @@
z80 z80
.vscode/* .vscode/*
build/*

51
curses_test.c
View File

@@ -1,51 +0,0 @@
#include <ncurses.h>
#include <stdlib.h>
int main()
{
initscr();
if (has_colors() == FALSE) {
endwin();
printf("Your terminal does not support color\n");
exit(1);
}
int w, h;
getmaxyx(stdscr, h, w);
start_color();
//init_pair(1, COLOR_WHITE, COLOR_BLACK);
init_pair(1, COLOR_YELLOW, COLOR_BLUE);
WINDOW *win_regs = newwin(10,20,0,0);
WINDOW *win_mem = newwin(10,w-20,0,20);
WINDOW *win_code = newwin(h-10,w,10,0);
refresh();
box(win_mem,0,0);
mvwprintw(win_mem, 0, 2, " MEMORY: ");
mvwprintw(win_mem, 1, 2, "%ix%i", w, h);
wrefresh(win_mem);
box(win_regs,0,0);
mvwprintw(win_regs, 0, 2, " REGISTERS: ");
mvwprintw(win_regs, 1, 2, "AF: 00");
mvwprintw(win_regs, 2, 2, "BC: 00");
mvwprintw(win_regs, 3, 2, "DE: 00");
mvwprintw(win_regs, 4, 2, "HL: 00");
wrefresh(win_regs);
box(win_code,0,0);
wattron(win_code, COLOR_PAIR(1));
mvwprintw(win_code, 1, 1, "Hello world %s !!!", "hola");
wattroff(win_code, COLOR_PAIR(1));
wrefresh(win_code);
refresh();
getch();
endwin();
return 0;
}

5
lagueirtofile Normal file
View File

@@ -0,0 +1,5 @@
libs = -lSDL2
cppflags = -g
executable = z80
sourcepath = .
buildpath = build

158
zx_disk.cpp
View File

@@ -72,7 +72,7 @@ namespace zx_disk
uint8_t current_drive = 0; uint8_t current_drive = 0;
uint8_t current_track = 0; uint8_t current_track = 0;
uint8_t current_sector = 0; uint8_t current_sector = 0;
uint8_t current_byte = 0; uint16_t current_byte = 0;
uint16_t bytes_to_read = 0; uint16_t bytes_to_read = 0;
uint8_t eot = 0; uint8_t eot = 0;
@@ -137,15 +137,15 @@ namespace zx_disk
sector.size = buffer[pos+0x03]; sector.size = buffer[pos+0x03];
sector.st1 = buffer[pos+0x04]; sector.st1 = buffer[pos+0x04];
sector.st2 = buffer[pos+0x05]; sector.st2 = buffer[pos+0x05];
sector.data_length = buffer[pos+0x06] + (buffer[pos+0x07]<<8); sector.data_length = buffer[pos+0x06] + uint16_t((buffer[pos+0x07])<<8);
if (sector.data_length==0) sector.data_length = sector.size<<8; if (sector.data_length==0) sector.data_length = uint16_t(sector.size)<<8;
pos += 8; pos += 8;
} }
if (pos&0xff) pos = (pos & 0xffffff00) + 0x100; if (pos&0xff) pos = (pos & 0xffffff00) + 0x100;
for (int j=0; j<track.num_sectors; ++j) for (int j=0; j<track.num_sectors; ++j)
{ {
sector_t &sector = track.sectors[j]; sector_t &sector = track.sectors[j];
const int size = sector.size<<8; const uint16_t size = uint16_t(sector.size)<<8;
sector.data = (uint8_t*)malloc(size); sector.data = (uint8_t*)malloc(size);
for (int k=0; k<size; ++k) sector.data[k] = buffer[pos++]; for (int k=0; k<size; ++k) sector.data[k] = buffer[pos++];
} }
@@ -165,7 +165,7 @@ namespace zx_disk
int zx_fdc_main_status_port_in(int port) int zx_fdc_main_status_port_in(int port)
{ {
if (mode != ZX_FDC_MODE_EXECUTION) printf("FDC port 0x2ffd IN\n"); //if (mode != ZX_FDC_MODE_EXECUTION) printf("FDC port 0x2ffd IN\n");
return main_status_register(); return main_status_register();
} }
@@ -178,7 +178,7 @@ namespace zx_disk
{ {
const bool ready = (current_head==0) && (current_drive==0); const bool ready = (current_head==0) && (current_drive==0);
return current_drive | (current_head<<2) | ((current_track==0)?0x10:0) | return current_drive | (current_head<<2) | ((current_track==0)?0x10:0) |
(ready?0x20:0) | 0x08; // TS (ready?0x20:0) | 0x00; // TS
} }
void start_command(uint8_t command); void start_command(uint8_t command);
@@ -195,7 +195,7 @@ namespace zx_disk
int zx_fdc_data_port_in(int port) int zx_fdc_data_port_in(int port)
{ {
if (mode != ZX_FDC_MODE_EXECUTION) printf("FDC port 0x3ffd IN\n"); //if (mode != ZX_FDC_MODE_EXECUTION) printf("FDC port 0x3ffd IN\n");
if (mode == ZX_FDC_MODE_COMMAND) { if (mode == ZX_FDC_MODE_COMMAND) {
printf("IGNORED!\n"); printf("IGNORED!\n");
return 0; return 0;
@@ -206,7 +206,7 @@ namespace zx_disk
void zx_fdc_data_port_out(int port, int val) void zx_fdc_data_port_out(int port, int val)
{ {
printf("FDC port 0x3ffd OUT: 0x%02x\n", val); //printf("FDC port 0x3ffd OUT: 0x%02x\n", val);
if (mode == ZX_FDC_MODE_RESULT) { if (mode == ZX_FDC_MODE_RESULT) {
printf("IGNORED!\n"); printf("IGNORED!\n");
return; return;
@@ -214,16 +214,17 @@ namespace zx_disk
if (process_current_command) if (process_current_command)
process_current_command(val); process_current_command(val);
else else
start_command(val & ZX_FDC_COMMAND_MASK); start_command(val);
} }
void start_command(uint8_t command) void start_command(uint8_t command)
{ {
if ((fdd0busy) && (command != ZX_FDC_COMMAND_SENSE_INTERRUPT_STATUS)) return; if ((fdd0busy) && ((command & ZX_FDC_COMMAND_MASK) != ZX_FDC_COMMAND_SENSE_INTERRUPT_STATUS)) return;
mode = ZX_FDC_MODE_COMMAND; mode = ZX_FDC_MODE_COMMAND;
call_count = 1; call_count = 1;
switch(command) debug::composeCommand(command);
switch(command & ZX_FDC_COMMAND_MASK)
{ {
case ZX_FDC_COMMAND_SPECIFY: case ZX_FDC_COMMAND_SPECIFY:
process_current_command = process_command_specify; process_current_command = process_command_specify;
@@ -253,6 +254,7 @@ namespace zx_disk
break; break;
default: default:
{ {
debug::printCommand();
process_current_command = process_command_unknown; process_current_command = process_command_unknown;
mode = ZX_FDC_MODE_RESULT; mode = ZX_FDC_MODE_RESULT;
call_count = 0; call_count = 0;
@@ -269,7 +271,9 @@ namespace zx_disk
process_current_command = nullptr; process_current_command = nullptr;
mode = ZX_FDC_MODE_IDLE; mode = ZX_FDC_MODE_IDLE;
const uint8_t val = ST0(); const uint8_t val = ST0();
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
debug::printResult();
return val; return val;
} }
@@ -278,6 +282,7 @@ namespace zx_disk
// =================================================================== // ===================================================================
uint8_t process_command_specify(uint8_t command) uint8_t process_command_specify(uint8_t command)
{ {
debug::composeCommand(command);
switch (call_count) { switch (call_count) {
case 1: case 1:
srt = (command & 0xf0) >> 4; srt = (command & 0xf0) >> 4;
@@ -290,6 +295,7 @@ namespace zx_disk
call_count=0; call_count=0;
process_current_command = nullptr; process_current_command = nullptr;
mode = ZX_FDC_MODE_IDLE; mode = ZX_FDC_MODE_IDLE;
debug::printCommand();
break; break;
} }
return 0; return 0;
@@ -307,13 +313,17 @@ namespace zx_disk
current_drive = command & 0x3; current_drive = command & 0x3;
call_count = 0; call_count = 0;
mode = ZX_FDC_MODE_RESULT; mode = ZX_FDC_MODE_RESULT;
debug::composeCommand(command);
debug::printCommand();
break; break;
case ZX_FDC_MODE_RESULT: case ZX_FDC_MODE_RESULT:
{ {
process_current_command = nullptr; process_current_command = nullptr;
mode = ZX_FDC_MODE_IDLE; mode = ZX_FDC_MODE_IDLE;
const uint8_t val = ST3(); const uint8_t val = ST3();
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
debug::printResult();
return val; return val;
} }
} }
@@ -334,6 +344,8 @@ namespace zx_disk
seeking = true; seeking = true;
process_current_command = nullptr; process_current_command = nullptr;
mode = ZX_FDC_MODE_IDLE; mode = ZX_FDC_MODE_IDLE;
debug::composeCommand(command);
debug::printCommand();
break; break;
} }
return 0; return 0;
@@ -348,9 +360,11 @@ namespace zx_disk
{ {
case 0: case 0:
{ {
debug::printCommand();
call_count++; call_count++;
const uint8_t val = ST0(); const uint8_t val = ST0();
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 1: case 1:
@@ -359,7 +373,9 @@ namespace zx_disk
seeking = false; seeking = false;
call_count = 0; call_count = 0;
mode = ZX_FDC_MODE_IDLE; mode = ZX_FDC_MODE_IDLE;
printf("--> (returning 0x%02x)\n", current_track); //printf("--> (returning 0x%02x)\n", current_track);
debug::composeResult(current_track);
debug::printResult();
return current_track; return current_track;
} }
return 0; return 0;
@@ -370,6 +386,7 @@ namespace zx_disk
// =================================================================== // ===================================================================
uint8_t process_command_seek(uint8_t command) uint8_t process_command_seek(uint8_t command)
{ {
debug::composeCommand(command);
switch (call_count) switch (call_count)
{ {
case 1: case 1:
@@ -384,6 +401,7 @@ namespace zx_disk
process_current_command = nullptr; process_current_command = nullptr;
call_count = 0; call_count = 0;
mode = ZX_FDC_MODE_IDLE; mode = ZX_FDC_MODE_IDLE;
debug::printCommand();
break; break;
} }
return 0; return 0;
@@ -402,6 +420,8 @@ namespace zx_disk
call_count = 0; call_count = 0;
current_sector = 0; current_sector = 0;
mode = ZX_FDC_MODE_RESULT; mode = ZX_FDC_MODE_RESULT;
debug::composeCommand(command);
debug::printCommand();
break; break;
case ZX_FDC_MODE_RESULT: case ZX_FDC_MODE_RESULT:
{ {
@@ -413,42 +433,48 @@ namespace zx_disk
fdd0busy = 1; fdd0busy = 1;
const uint8_t val = ST0(); const uint8_t val = ST0();
fdd0busy = 0; fdd0busy = 0;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 1: case 1:
{ {
call_count++; call_count++;
const uint8_t val = 0x00; // ST1 const uint8_t val = 0x00; // ST1
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 2: case 2:
{ {
call_count++; call_count++;
const uint8_t val = 0x00; // ST2 const uint8_t val = 0x00; // ST2
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 3: case 3:
{ {
call_count++; call_count++;
const uint8_t val = current_track; const uint8_t val = current_track;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 4: case 4:
{ {
call_count++; call_count++;
const uint8_t val = current_head; const uint8_t val = current_head;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 5: case 5:
{ {
call_count++; call_count++;
const uint8_t val = current_sector+1; const uint8_t val = current_sector+1;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 6: case 6:
@@ -457,7 +483,9 @@ namespace zx_disk
process_current_command = nullptr; process_current_command = nullptr;
mode = ZX_FDC_MODE_IDLE; mode = ZX_FDC_MODE_IDLE;
const uint8_t val = disk.tracks[current_track].sectors[current_sector].size; const uint8_t val = disk.tracks[current_track].sectors[current_sector].size;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
debug::printResult();
return val; return val;
} }
} }
@@ -474,6 +502,7 @@ namespace zx_disk
switch (mode) switch (mode)
{ {
case ZX_FDC_MODE_COMMAND: case ZX_FDC_MODE_COMMAND:
debug::composeCommand(command);
switch (call_count) switch (call_count)
{ {
case 1: case 1:
@@ -503,15 +532,14 @@ namespace zx_disk
break; break;
case 7: case 7:
call_count++; call_count++;
// GPL;
break; break;
case 8: case 8:
call_count++;
if ( (bytes_to_read==0) && (command != 0xff) ) bytes_to_read = command; if ( (bytes_to_read==0) && (command != 0xff) ) bytes_to_read = command;
bytes_to_read = bytes_to_read << 8; bytes_to_read = bytes_to_read << 8;
current_byte = 0; current_byte = 0;
call_count = 0; call_count = 0;
mode = ZX_FDC_MODE_EXECUTION; mode = ZX_FDC_MODE_EXECUTION;
debug::printCommand();
break; break;
} }
break; break;
@@ -519,26 +547,24 @@ namespace zx_disk
case ZX_FDC_MODE_EXECUTION: case ZX_FDC_MODE_EXECUTION:
{ {
const uint8_t val = disk.tracks[current_track].sectors[current_sector].data[current_byte]; const uint8_t val = disk.tracks[current_track].sectors[current_sector].data[current_byte];
bytes_to_read--;
if (bytes_to_read==0) {
st1 = disk.tracks[current_track].sectors[current_sector].st1;
st2 = disk.tracks[current_track].sectors[current_sector].st2;
if (current_sector+1 == disk.tracks[current_track].num_sectors) {
current_track++;
current_sector = 0;
} else {
current_sector++;
}
current_byte = 0;
mode = ZX_FDC_MODE_RESULT;
} else {
current_byte++; current_byte++;
if (current_byte == disk.tracks[current_track].sectors[current_sector].data_length) { if (current_byte == disk.tracks[current_track].sectors[current_sector].data_length) {
current_byte = 0; current_byte = 0;
current_sector++; current_sector++;
// [TODO] Detectar si s'ha acabat la pista if (current_sector == disk.tracks[current_track].num_sectors) {
current_track++;
current_sector = 0;
} }
} }
bytes_to_read--;
if (bytes_to_read==0) {
st1 = disk.tracks[current_track].sectors[current_sector].st1;
st2 = disk.tracks[current_track].sectors[current_sector].st2;
mode = ZX_FDC_MODE_RESULT;
}
return val; return val;
break; break;
} }
@@ -553,42 +579,48 @@ namespace zx_disk
fdd0busy = 1; fdd0busy = 1;
const uint8_t val = ST0(); const uint8_t val = ST0();
fdd0busy = 0; fdd0busy = 0;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 1: case 1:
{ {
call_count++; call_count++;
const uint8_t val = st1; const uint8_t val = st1;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 2: case 2:
{ {
call_count++; call_count++;
const uint8_t val = st2; const uint8_t val = st2;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 3: case 3:
{ {
call_count++; call_count++;
const uint8_t val = current_track; const uint8_t val = current_track;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 4: case 4:
{ {
call_count++; call_count++;
const uint8_t val = current_head; const uint8_t val = current_head;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 5: case 5:
{ {
call_count++; call_count++;
const uint8_t val = current_sector+1; const uint8_t val = current_sector+1;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
return val; return val;
} }
case 6: case 6:
@@ -597,7 +629,9 @@ namespace zx_disk
process_current_command = nullptr; process_current_command = nullptr;
mode = ZX_FDC_MODE_IDLE; mode = ZX_FDC_MODE_IDLE;
const uint8_t val = disk.tracks[current_track].sectors[current_sector].size; const uint8_t val = disk.tracks[current_track].sectors[current_sector].size;
printf("--> (returning 0x%02x)\n", val); //printf("--> (returning 0x%02x)\n", val);
debug::composeResult(val);
debug::printResult();
return val; return val;
} }
} }
@@ -607,4 +641,38 @@ namespace zx_disk
return 0; return 0;
} }
namespace debug
{
uint8_t values[9];
uint8_t num_values = 0;
void composeCommand(const uint8_t value)
{
values[num_values++] = value;
}
void composeResult(const uint8_t value)
{
values[num_values++] = value;
}
void printCommand()
{
printf("FDC COMMAND %02x: ( ", values[0] & 0x1f);
for (int i=0; i<num_values; ++i) printf("%02x ", values[i]);
printf(")\n");
num_values = 0;
}
void printResult()
{
printf("FDC RESULT: ( ");
for (int i=0; i<num_values; ++i) printf("%02x ", values[i]);
printf(")\n");
num_values = 0;
}
}
} }

10
zx_disk.h
View File

@@ -1,8 +1,18 @@
#pragma once #pragma once
#include <stdint.h>
namespace zx_disk namespace zx_disk
{ {
void init(); void init();
void reset(); void reset();
void load(const char *filename); void load(const char *filename);
namespace debug
{
void composeCommand(const uint8_t value);
void composeResult(const uint8_t value);
void printCommand();
void printResult();
}
} }