Subversion Repositories pentevo

Rev

Rev 796 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
796 DimkaM 1
#pragma once
2
 
3
struct SECHDR
4
{
5
    unsigned char c, s, n, l;
6
    unsigned short crc; // CRC ��������� �������
7
 
8
    // ����� crc ���� ������ � ������:
9
    // ��� ��������������:
10
    //   0 - ������������ ���������� �������� crc
11
    //   1 - ������ crc �� crc(��� ������)/crcd(��� ������)
12
    //   2 - ��������� crc (������������ ��������� ����������� crc))
13
    // ��� ������ (������� seek ������������� ���� c1 � c2):
14
    //   0 - ������������ crc �� ��������� � ��������� � ��������� (������������ crc error)
15
    //   1 - ������������ crc ��������� � ��������� � ���������
16
    unsigned char c1, c2;
17
 
18
    // ��������� �� ������ ������� ������ �����
19
    // ��� �������������� ����������� ��������:
20
    //   1 -��������� ������ ������
21
    u8 *data;
22
    u8 *id; // ��������� �� ��������� ������� ������ �����
23
    u8 *wp; // ��������� �� ������� ����� ������� ������ ������� ������ ����� (������������ ������ ��� ��������)
24
    unsigned wp_start; // ����� ������� ���� � ����� ������� ������ (������������ ������ �����) ��� ������� �������
25
 
26
    // ������ ������� � ������
27
    // ��� ��������������:
28
    //   0 - ������ ������� ������� ��� (128 << n) & SectorSizeMask
29
    unsigned datlen;
30
    unsigned crcd;        // used to load specific CRC from FDI-file
31
 
32
    // ������������ ��� .dsk �������
33
    static constexpr u8 FL_DDAM{ 0b00000001 };
34
    u8 Flags = 0;
35
};
36
 
37
enum SEEK_MODE
38
{
39
    JUST_SEEK = 0, LOAD_SECTORS = 1
40
};
41
 
42
static inline bool test_bit(const u8 *data, unsigned bit)
43
{
44
    return (data[bit >> 3] & (1U << (bit & 7))) != 0;
45
}
46
 
47
static inline void set_bit(u8 *data, unsigned bit)
48
{
49
    data[bit >> 3] |= (1U << (bit & 7));
50
}
51
 
52
static inline void clr_bit(u8 *data, unsigned bit)
53
{
54
    data[bit >> 3] &= ~(1U << (bit & 7));
55
}
56
 
57
 
58
struct TRKCACHE
59
{
60
    // cached track position
61
    struct FDD *drive;
62
    unsigned cyl, side; // ���������� ���������
63
 
64
    // generic track data
65
    unsigned trklen;
66
    // pointer to data inside UDI
67
    u8 *trkd; // ������ (����� ���� NULL, ���� ���� ��� ������)
68
    u8 *trki; // ������� ����� ���������������
69
    u8 *trkwp; // ������� ����� ������� ������
70
    unsigned ts_byte;                 // cpu.t per byte
71
    SEEK_MODE sf;                     // flag: is sectors filled
72
    unsigned s;                       // no. of sectors
73
    // sectors on track
74
    SECHDR hdr[MAX_SEC];
75
 
76
    void set_i(unsigned pos)
77
    {
78
        set_bit(trki, pos);
79
    }
80
    void clr_i(unsigned pos)
81
    {
82
        clr_bit(trki, pos);
83
    }
84
    bool test_i(unsigned pos)
85
    {
86
        return test_bit(trki, pos);
87
    }
88
 
89
    void set_wp(unsigned pos)
90
    {
91
        set_bit(trkwp, pos);
92
    }
93
    bool test_wp(unsigned pos)
94
    {
95
        return test_bit(trkwp, pos);
96
    }
97
 
98
    void write(unsigned pos, unsigned char byte, u8 index)
99
    {
100
        if(!trkd)
101
            return;
102
 
103
        trkd[pos] = byte;
104
        if(index)
105
            set_i(pos);
106
        else
107
            clr_i(pos);
108
    }
109
 
110
    void seek(FDD *d, unsigned cyl, unsigned side, SEEK_MODE fs);
111
    void format(); // before use, call seek(d,c,s,JUST_SEEK), set s and hdr[]
112
    unsigned write_sector(unsigned sec, unsigned l, unsigned char *data); // call seek(d,c,s,LOAD_SECTORS)
113
    const SECHDR *get_sector(unsigned sec, unsigned l) const; // before use, call fill(d,c,s,LOAD_SECTORS)
114
 
115
    void dump();
116
    void clear()
117
    {
118
        drive = nullptr;
119
        trkd = nullptr;
120
        ts_byte = Z80FQ / (MAX_TRACK_LEN * FDD_RPS);
121
    }
122
    TRKCACHE()
123
    {
124
        clear();
125
    }
126
};
127
 
128
struct FDD
129
{
130
    u8 Id;
131
    // drive data
132
 
133
    __int64 motor;       // 0 - not spinning, >0 - time when it'll stop
134
    unsigned char track; // head position
135
 
136
    // disk data
137
 
138
    unsigned char *rawdata;              // used in VirtualAlloc/VirtualFree
139
    unsigned rawsize;
140
 
141
    // ��������� ����� ������� (��� �������� ������ ��� ��� �������� ������� �����), ����� ���� ��������� �� MAX_CYLS
142
    // ����� ������������� �������������� ������� ��������� ���� ADS � ��������
143
    unsigned cyls;
144
    unsigned sides;
145
    unsigned trklen[MAX_CYLS][2];
146
    u8 *trkd[MAX_CYLS][2]; // ������
147
    u8 *trki[MAX_CYLS][2]; // ������� ����� ���������������
148
    u8 *trkwp[MAX_CYLS][2]; // ������� ����� ������� ������
149
    unsigned char optype; // bits: 0-not modified, 1-write sector, 2-format track
150
    unsigned char snaptype;
151
 
152
    TRKCACHE t; // used in read/write image
153
    char name[0x200];
154
    char dsc[0x200];
155
 
156
    char test();
157
    void free();
158
    int index();
159
 
160
    void format_trd(unsigned CylCnt); // ������������ ������ ��� wldr_trd
161
    void emptydisk(unsigned FreeSecCnt); // ������������ ������ ��� wldr_trd
162
    int addfile(unsigned char *hdr, unsigned char *data); // ������������ ������ ��� wldr_trd
163
    void addboot(); // ������������ ������ ��� wldr_trd
164
 
165
    void set_i(unsigned c, unsigned s, unsigned pos)
166
    {
167
        set_bit(trki[c][s], pos);
168
    }
169
 
170
    void newdisk(unsigned cyls, unsigned sides);
171
 
172
    int read(unsigned char snType);
173
 
174
    int read_scl();
175
    int read_hob();
176
    int read_trd();
177
    int write_trd(FILE *ff);
178
    int read_fdi();
179
    int write_fdi(FILE *ff);
180
    int read_td0();
181
    int write_td0(FILE *ff);
182
    int read_udi();
183
    int write_udi(FILE *ff);
184
 
185
    void format_isd();
186
    int read_isd();
187
    int write_isd(FILE *ff);
188
 
189
    void format_pro();
190
    int read_pro();
191
    int write_pro(FILE *ff);
192
 
193
    int read_dsk();
194
    int read_ipf();
195
 
196
    ~FDD()
197
    {
198
        free();
199
    }
200
};
201
 
202
bool done_fdd(bool Cancelable);