source: buchla-emu/emu/fdd.c

0.1
Last change on this file was 9b204fa, checked in by Thomas Lopatic <thomas@…>, 6 years ago

Persist disk image.
  • Property mode set to 100644
File size: 7.4 KB
RevLine 
[a06aa8b]1/*
2 * Copyright (C) 2017 The Contributors
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or (at
7 * your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * A copy of the GNU General Public License can be found in the file
[2147e53]15 * "gpl.txt" in the top directory of this repository.
[a06aa8b]16 */
17
18#include <all.h>
19
[4c71d39]20#define ver(...) _ver(fdd_verbose, 0, __VA_ARGS__)
21#define ver2(...) _ver(fdd_verbose, 1, __VA_ARGS__)
22#define ver3(...) _ver(fdd_verbose, 2, __VA_ARGS__)
[a06aa8b]23
[4c71d39]24int32_t fdd_verbose = 0;
[a06aa8b]25
[1efc42c]26#define N_CYL 80
27#define N_SID 2
[c5b6c90]28#define N_SEC 9
[1efc42c]29#define SZ_SEC 512
30
31#define SZ_DISK (N_CYL * N_SID * N_SEC * SZ_SEC)
32
[c5b6c90]33#define REG_COM_STAT 0
34#define REG_TRA 1
35#define REG_SEC 2
36#define REG_DAT 3
37
38#define COM_REST 0x00
39#define COM_SEEK 0x10
40#define COM_SEEK_VER 0x14
41#define COM_RD_SEC 0x80
42#define COM_RD_SEC_MUL 0x90
43#define COM_WR_SEC_WP 0xa0
44#define COM_WR_SEC 0xa2
45#define COM_INT 0xd0
[9b204fa]46#define COM_WR_TRA_WP 0xf0
47#define COM_WR_TRA 0xf2
[c5b6c90]48
[1489228]49#define COM_LAT_CYC 5
50#define COM_EXE_CYC 5
[c5b6c90]51
52typedef enum {
53 STEP_IDLE,
54 STEP_PREP,
55 STEP_EXEC
56} step_t;
57
58typedef struct {
59 int32_t reg_tra;
60 int32_t reg_sec;
61 int32_t reg_dat;
62 int32_t sid;
63 step_t step;
64 int32_t com;
65 int32_t cyc;
66 uint8_t *dat;
67 bool tra_0;
68} state_t;
69
70static state_t state = {
71 .reg_tra = 0, .reg_sec = 0, .reg_dat = 0, .sid = 0,
72 .step = STEP_IDLE, .com = -1, .cyc = 0, .dat = NULL, .tra_0 = false
73};
74
[1efc42c]75static uint8_t image[SZ_DISK];
76
[c5b6c90]77static const char *com_string(int32_t com)
78{
79 switch (com) {
80 case COM_REST:
81 return "COM_REST";
82
83 case COM_SEEK:
84 return "COM_SEEK";
85
86 case COM_SEEK_VER:
87 return "COM_SEEK_VER";
88
89 case COM_RD_SEC:
90 return "COM_RD_SEC";
91
92 case COM_RD_SEC_MUL:
93 return "COM_RD_SEC_MUL";
94
95 case COM_WR_SEC_WP:
96 return "COM_WR_SEC_WP";
97
98 case COM_WR_SEC:
99 return "COM_WR_SEC";
100
[9b204fa]101 case COM_WR_TRA_WP:
102 return "COM_WR_TRA_WP";
103
[c5b6c90]104 case COM_WR_TRA:
105 return "COM_WR_TRA";
106
107 default:
108 fail("unknown command 0x%02x", com);
109 }
110}
111
112static void stat_string(int32_t stat, char *buff) {
113 buff[0] = 0;
114
115 if ((stat & 0x80) != 0) {
116 strcat(buff, " mot_on");
117 }
118
119 if ((stat & 0x04) != 0) {
120 strcat(buff, " zero");
121 }
122
123 if ((stat & 0x02) != 0) {
124 strcat(buff, " dat_req");
125 }
126
127 if ((stat & 0x01) != 0) {
128 strcat(buff, " busy");
129 }
130}
131
132void fdd_set_side(int32_t sid)
133{
134 ver2("sid <- %d", sid);
135 state.sid = sid;
136}
137
138void fdd_set_sel(int32_t sel)
139{
140 ver2("sel <- %d", sel);
141}
142
[a06aa8b]143void fdd_init(void)
144{
145 ver("fdd init");
[9b204fa]146 inf("reading disk image file %s", disk);
[1efc42c]147
148 SDL_RWops *ops = SDL_RWFromFile(disk, "rb");
149
150 if (ops == NULL) {
[9b204fa]151 fail("error while opening disk image file %s for reading", disk);
[1efc42c]152 }
153
154 size_t loaded = 0;
155
156 while (loaded < SZ_DISK) {
157 size_t n_rd = SDL_RWread(ops, image + loaded, 1, SZ_DISK - loaded);
158
159 if (n_rd == 0) {
160 fail("error while reading disk image file %s", disk);
161 }
162
163 loaded += n_rd;
164 }
165
166 SDL_RWclose(ops);
[a06aa8b]167}
168
169void fdd_quit(void)
170{
171 ver("fdd quit");
[9b204fa]172 inf("writing disk image file %s", disk);
173
174 SDL_RWops *ops = SDL_RWFromFile(disk, "wb");
175
176 if (ops == NULL) {
177 fail("error while opening disk image file %s for writing", disk);
178 }
179
180 size_t stored = 0;
181
182 while (stored < SZ_DISK) {
183 size_t n_wr = SDL_RWwrite(ops, image + stored, 1, SZ_DISK - stored);
184
185 if (n_wr == 0) {
186 fail("error while writing disk image file %s", disk);
187 }
188
189 stored += n_wr;
190 }
191
192 SDL_RWclose(ops);
[a06aa8b]193}
194
[3c30832]195bool fdd_exec(void)
[a06aa8b]196{
[4c71d39]197 ver3("fdd exec");
[c5b6c90]198
199 switch (state.step) {
200 case STEP_IDLE:
201 break;
202
203 case STEP_PREP:
204 ver3("prep %d", state.cyc);
205 --state.cyc;
206
207 if (state.cyc == 0) {
208 ver2("exec %s", com_string(state.com));
209 state.step = STEP_EXEC;
210 state.cyc = COM_EXE_CYC;
211 }
212
213 break;
214
215 case STEP_EXEC:
216 ver3("exec %d", state.cyc);
217 --state.cyc;
218
219 if (state.cyc == 0) {
220 ver2("idle %s", com_string(state.com));
221 state.step = STEP_IDLE;
222 }
223
224 break;
225 }
226
[3c30832]227 return false;
[a06aa8b]228}
229
230uint32_t fdd_read(uint32_t off, int32_t sz)
231{
[c5b6c90]232 ver3("fdd rd %u:%d", off, sz * 8);
233
234 if (sz != 1 || off > 3) {
235 fail("invalid fdd rd %u:%d", off, sz * 8);
236 }
237
238 uint32_t rv;
239
240 switch (off) {
241 case REG_COM_STAT:
242 rv = 0x80; // motor on
243
244 if (state.step == STEP_EXEC) {
245 rv |= 0x01; // busy
246
247 switch (state.com) {
248 case COM_RD_SEC:
249 case COM_RD_SEC_MUL:
250 case COM_WR_SEC:
251 case COM_WR_SEC_WP:
252 rv |= 0x02; // data request
253 break;
254 }
255 }
256
257 if (state.tra_0) {
258 rv |= 0x04; // track zero
259 }
260
261 char stat[100];
262 stat_string((int32_t)rv, stat);
263 ver3("stat -> 0x%02x%s", rv, stat);
264 break;
265
266 case REG_TRA:
267 rv = (uint32_t)state.reg_tra;
268 ver2("tra -> %u", rv);
269 break;
270
271 case REG_SEC:
272 rv = (uint32_t)state.reg_sec;
273 ver2("sec -> %u", rv);
274 break;
275
276 case REG_DAT:
277 if (state.step != STEP_EXEC ||
278 (state.com != COM_RD_SEC && state.com != COM_RD_SEC_MUL)) {
279 fail("unexpected data register read");
280 }
281
282 rv = *state.dat;
[1489228]283 int32_t addr = (int32_t)(state.dat - image);
[c5b6c90]284
285 if ((addr & (SZ_SEC - 1)) == 0) {
[1489228]286 ver2("addr 0x%06x -> 0x%02x", addr, rv);
[c5b6c90]287 }
288 else {
[1489228]289 ver3("addr 0x%06x -> 0x%02x", addr, rv);
[c5b6c90]290 }
291
292 ++state.dat;
[1489228]293 ++addr;
294
295 if ((addr & (SZ_SEC - 1)) == 0 && state.com == COM_RD_SEC) {
296 state.step = STEP_IDLE;
297 state.cyc = 0;
298 }
299 else {
300 state.cyc = COM_EXE_CYC;
301 }
302
[c5b6c90]303 break;
304
305 default:
306 rv = 0;
307 break;
308 }
309
310 return rv;
[a06aa8b]311}
312
313void fdd_write(uint32_t off, int32_t sz, uint32_t val)
314{
[c5b6c90]315 ver3("fdd wr %u:%d 0x%0*x", off, sz * 8, sz * 2, val);
316
317 if (sz != 1 || off > 3) {
318 fail("invalid fdd wr %u:%d", off, sz * 8);
319 }
320
321 switch (off) {
322 case REG_COM_STAT:
323 ver2("com <- 0x%02x, tra %d, sid %d, sec %d",
324 val, state.reg_tra, state.sid, state.reg_sec);
325
326 state.com = (int32_t)val;
327
328 ver2("prep %s", com_string(state.com));
329 state.step = STEP_PREP;
330 state.cyc = COM_LAT_CYC;
331
332 switch (val) {
333 case COM_REST:
334 state.reg_tra = 0;
335 state.tra_0 = true;
[8967dbc]336 state.dat = NULL;
[c5b6c90]337 break;
338
339 case COM_SEEK:
340 case COM_SEEK_VER:
341 state.reg_tra = state.reg_dat;
342 state.tra_0 = state.reg_tra == 0;
[8967dbc]343 state.dat = NULL;
[c5b6c90]344 break;
345
346 case COM_RD_SEC:
347 case COM_RD_SEC_MUL:
348 case COM_WR_SEC:
349 case COM_WR_SEC_WP: {
350 size_t sec_off = (size_t)(((state.reg_tra * N_SID + state.sid) * N_SEC +
351 state.reg_sec - 1) * SZ_SEC);
352 state.dat = image + sec_off;
353 state.tra_0 = false;
354 break;
355 }
356
357 case COM_INT:
358 state.step = STEP_IDLE;
359 state.cyc = 0;
360 state.dat = NULL;
361 state.tra_0 = false;
362 break;
363
364 case COM_WR_TRA:
[9b204fa]365 case COM_WR_TRA_WP:
[c5b6c90]366 state.tra_0 = false;
367 fail("format not yet supported");
368 break;
369 }
370
371 break;
372
373 case REG_TRA:
374 state.reg_tra = (int32_t)val;
375 ver2("tra <- %u", val);
376 break;
377
378 case REG_SEC:
379 state.reg_sec = (int32_t)val;
380 ver2("sec <- %u", val);
381 break;
382
383 case REG_DAT:
384 if (state.step == STEP_EXEC &&
385 (state.com == COM_WR_SEC || state.com == COM_WR_SEC_WP)) {
386 *state.dat = (uint8_t)val;
[1489228]387 int32_t addr = (int32_t)(state.dat - image);
[c5b6c90]388
389 if ((addr & (SZ_SEC - 1)) == 0) {
[1489228]390 ver2("addr 0x%06x <- 0x%02x", addr, val);
[c5b6c90]391 }
392 else {
[1489228]393 ver3("addr 0x%06x <- 0x%02x", addr, val);
[c5b6c90]394 }
395
396 ++state.dat;
[1489228]397 ++addr;
398
399 if ((addr & (SZ_SEC - 1)) == 0) {
400 state.step = STEP_IDLE;
401 state.cyc = 0;
402 }
403 else {
404 state.cyc = COM_EXE_CYC;
405 }
[c5b6c90]406 }
407 else {
408 state.reg_dat = (int32_t)val;
409 ver2("dat <- 0x%02x", val);
410 }
411
412 break;
413
414 default:
415 break;
416 }
[a06aa8b]417}
Note: See TracBrowser for help on using the repository browser.