1 // license:BSD-3-Clause
2 // copyright-holders:Dirk Best, Nigel Barnes
3 /***************************************************************************
4
5 Acorn - BBC Micro, Electron, Archimedes
6
7 Disk image formats
8
9 ***************************************************************************/
10
11 #include "acorn_dsk.h"
12
acorn_ssd_format()13 acorn_ssd_format::acorn_ssd_format() : wd177x_format(formats)
14 {
15 }
16
name() const17 const char *acorn_ssd_format::name() const
18 {
19 return "ssd";
20 }
21
description() const22 const char *acorn_ssd_format::description() const
23 {
24 return "Acorn SSD disk image";
25 }
26
extensions() const27 const char *acorn_ssd_format::extensions() const
28 {
29 return "ssd,bbc,img";
30 }
31
find_size(io_generic * io,uint32_t form_factor)32 int acorn_ssd_format::find_size(io_generic *io, uint32_t form_factor)
33 {
34 uint8_t cat[8];
35 uint32_t sectors0, sectors2;
36 uint64_t size = io_generic_size(io);
37
38 for(int i=0; formats[i].form_factor; i++) {
39 const format &f = formats[i];
40 if(form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
41 continue;
42
43 // test for Torch CPN - test pattern at sector &0018
44 io_generic_read(io, cat, 0x32800, 8);
45 if (memcmp(cat, "\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd", 4) == 0 && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
46 return i;
47
48 // test for HADFS - test pattern at sector 70
49 io_generic_read(io, cat, 0x04610, 8);
50 if (memcmp(cat, "\x00\x28\x43\x29\x4a\x47\x48\x00", 4) == 0 && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
51 return i;
52
53 // test for Kenda SD - offset &0962 = 0 SD/1 DD, offset &0963 = disk size blocks / 4 (block size = 1K, ie. 0x400 bytes), reserved tracks = 3, ie. 0x1e00 bytes, soft stagger = 2 sectors, ie. 0x200 bytes
54 io_generic_read(io, cat, 0x0960, 8);
55 if (cat[2] == 0 && ((uint64_t)cat[3] * 4 * 0x400 + 0x2000) == size && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
56 {
57 // valid blocks for single sided
58 if (f.head_count == 1 && (cat[3] == 0x17 || cat[3] == 0x30))
59 return i;
60 // valid blocks for double sided
61 if (f.head_count == 2 && (cat[3] == 0x2f || cat[3] == 0x62))
62 return i;
63 }
64
65 // read sector count from side 0 catalogue
66 io_generic_read(io, cat, 0x100, 8);
67 sectors0 = ((cat[6] & 3) << 8) + cat[7];
68 LOG_FORMATS("ssd: sector count 0: %d %s\n", sectors0, sectors0 % 10 != 0 ? "invalid" : "");
69
70 if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count)) {
71 if (f.head_count == 2)
72 {
73 // read sector count from side 2 catalogue
74 io_generic_read(io, cat, (uint64_t)compute_track_size(f) * f.track_count + 0x100, 8); // sequential
75 sectors2 = ((cat[6] & 3) << 8) + cat[7];
76
77 // exception case for Acorn CP/M System Disc 1
78 io_generic_read(io, cat, 0x367ec, 8);
79 if (memcmp(cat, "/M ", 4) == 0) sectors2 = ((cat[6] & 3) << 8) + cat[7];
80
81 LOG_FORMATS("ssd: sector count 2: %d %s\n", sectors2, sectors2 % 10 != 0 ? "invalid" : "");
82 }
83 else
84 {
85 sectors2 = sectors0;
86 }
87
88 if (sectors0 > 0 && sectors0 % 10 == 0 && sectors2 > 0 && sectors2 % 10 == 0 && size <= (sectors0 + sectors2) * 256)
89 return i;
90 }
91 }
92 LOG_FORMATS("ssd: no match\n");
93 return -1;
94 }
95
identify(io_generic * io,uint32_t form_factor)96 int acorn_ssd_format::identify(io_generic *io, uint32_t form_factor)
97 {
98 int type = find_size(io, form_factor);
99
100 if(type != -1)
101 return 90;
102 return 0;
103 }
104
get_image_offset(const format & f,int head,int track)105 int acorn_ssd_format::get_image_offset(const format &f, int head, int track)
106 {
107 if (f.sector_base_id == -1)
108 return (track * f.head_count + head) * compute_track_size(f);
109 else
110 return (f.track_count * head + track) * compute_track_size(f);
111 }
112
113 const acorn_ssd_format::format acorn_ssd_format::formats[] =
114 {
115 { // 100k 40 track single sided single density
116 floppy_image::FF_525, floppy_image::SSSD, floppy_image::FM,
117 4000, 10, 40, 1, 256, {}, 0, {}, 40, 10, 10
118 },
119 { // 200k 80 track single sided single density
120 floppy_image::FF_525, floppy_image::SSQD, floppy_image::FM,
121 4000, 10, 80, 1, 256, {}, 0, {}, 40, 10, 10
122 },
123 { // 200k 40 track double sided single density
124 floppy_image::FF_525, floppy_image::DSSD, floppy_image::FM,
125 4000, 10, 40, 2, 256, {}, 0, {}, 40, 10, 10
126 },
127 { // 400k 80 track double sided single density
128 floppy_image::FF_525, floppy_image::DSQD, floppy_image::FM,
129 4000, 10, 80, 2, 256, {}, 0, {}, 40, 10, 10
130 },
131 { // 100k 40 track single sided single density
132 floppy_image::FF_35, floppy_image::SSSD, floppy_image::FM,
133 4000, 10, 40, 1, 256,{}, 0,{}, 40, 10, 10
134 },
135 { // 200k 80 track single sided single density
136 floppy_image::FF_35, floppy_image::SSDD, floppy_image::FM,
137 4000, 10, 80, 1, 256,{}, 0,{}, 40, 10, 10
138 },
139 { // 200k 40 track double sided single density
140 floppy_image::FF_35, floppy_image::DSSD, floppy_image::FM,
141 4000, 10, 40, 2, 256,{}, 0,{}, 40, 10, 10
142 },
143 { // 400k 80 track double sided single density
144 floppy_image::FF_35, floppy_image::DSDD, floppy_image::FM,
145 4000, 10, 80, 2, 256,{}, 0,{}, 40, 10, 10
146 },
147 { // 100k 40 track single sided single density
148 floppy_image::FF_3, floppy_image::SSSD, floppy_image::FM,
149 4000, 10, 40, 1, 256,{}, 0,{}, 40, 10, 10
150 },
151 {}
152 };
153
154
acorn_dsd_format()155 acorn_dsd_format::acorn_dsd_format() : wd177x_format(formats)
156 {
157 }
158
name() const159 const char *acorn_dsd_format::name() const
160 {
161 return "dsd";
162 }
163
description() const164 const char *acorn_dsd_format::description() const
165 {
166 return "Acorn DSD disk image";
167 }
168
extensions() const169 const char *acorn_dsd_format::extensions() const
170 {
171 return "dsd";
172 }
173
find_size(io_generic * io,uint32_t form_factor)174 int acorn_dsd_format::find_size(io_generic *io, uint32_t form_factor)
175 {
176 uint8_t cat[8];
177 uint32_t sectors0, sectors2;
178 uint64_t size = io_generic_size(io);
179
180 for (int i = 0; formats[i].form_factor; i++) {
181 const format &f = formats[i];
182 if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
183 continue;
184
185 // test for Torch CPN - test pattern at sector &0018
186 io_generic_read(io, cat, 0x1200, 8);
187 if (memcmp(cat, "\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd", 4) == 0 && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
188 return i;
189
190 // test for HADFS - test pattern at sector 70
191 io_generic_read(io, cat, 0x08c10, 8);
192 if (memcmp(cat, "\x00\x28\x43\x29\x4a\x47\x48\x00", 4) == 0 && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
193 return i;
194
195 // read sector count from side 0 catalogue
196 io_generic_read(io, cat, 0x100, 8);
197 sectors0 = ((cat[6] & 3) << 8) + cat[7];
198 LOG_FORMATS("dsd: sector count 0: %d %s\n", sectors0, sectors0 % 10 != 0 ? "invalid" : "");
199
200 if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count)) {
201 // read sector count from side 2 catalogue
202 io_generic_read(io, cat, 0xb00, 8); // interleaved
203 sectors2 = ((cat[6] & 3) << 8) + cat[7];
204
205 // exception case for Acorn CP/M System Disc 1
206 io_generic_read(io, cat, 0x97ec, 8);
207 if (memcmp(cat, "/M ", 4) == 0) sectors2 = ((cat[6] & 3) << 8) + cat[7];
208
209 LOG_FORMATS("dsd: sector count 2: %d %s\n", sectors2, sectors2 % 10 != 0 ? "invalid" : "");
210
211 if (sectors0 > 0 && sectors0 % 10 == 0 && sectors2 > 0 && sectors2 % 10 == 0 && size <= (sectors0 + sectors2) * 256)
212 return i;
213 }
214 }
215 LOG_FORMATS("dsd: no match\n");
216 return -1;
217 }
218
identify(io_generic * io,uint32_t form_factor)219 int acorn_dsd_format::identify(io_generic *io, uint32_t form_factor)
220 {
221 int type = find_size(io, form_factor);
222
223 if (type != -1)
224 return 90;
225 return 0;
226 }
227
get_image_offset(const format & f,int head,int track)228 int acorn_dsd_format::get_image_offset(const format &f, int head, int track)
229 {
230 if (f.sector_base_id == -1)
231 return (track * f.head_count + head) * compute_track_size(f);
232 else
233 return (f.track_count * head + track) * compute_track_size(f);
234 }
235
236 const acorn_dsd_format::format acorn_dsd_format::formats[] =
237 {
238 { // 400k 80 track double sided single density (interleaved)
239 floppy_image::FF_525, floppy_image::DSQD, floppy_image::FM,
240 4000, 10, 80, 2, 256, {}, -1, { 0,1,2,3,4,5,6,7,8,9 }, 40, 10, 10
241 },
242 { // 200k 40 track double sided single density (interleaved)
243 floppy_image::FF_525, floppy_image::DSSD, floppy_image::FM,
244 4000, 10, 40, 2, 256, {}, -1, { 0,1,2,3,4,5,6,7,8,9 }, 40, 10, 10
245 },
246 { // 400k 80 track double sided single density (interleaved)
247 floppy_image::FF_35, floppy_image::DSDD, floppy_image::FM,
248 4000, 10, 80, 2, 256,{}, -1,{ 0,1,2,3,4,5,6,7,8,9 }, 40, 10, 10
249 },
250 { // 200k 40 track double sided single density (interleaved)
251 floppy_image::FF_35, floppy_image::DSSD, floppy_image::FM,
252 4000, 10, 40, 2, 256,{}, -1,{ 0,1,2,3,4,5,6,7,8,9 }, 40, 10, 10
253 },
254 {}
255 };
256
257
opus_ddos_format()258 opus_ddos_format::opus_ddos_format() : wd177x_format(formats)
259 {
260 }
261
name() const262 const char *opus_ddos_format::name() const
263 {
264 return "ddos";
265 }
266
description() const267 const char *opus_ddos_format::description() const
268 {
269 return "Opus DDOS disk image";
270 }
271
extensions() const272 const char *opus_ddos_format::extensions() const
273 {
274 return "dds";
275 }
276
find_size(io_generic * io,uint32_t form_factor)277 int opus_ddos_format::find_size(io_generic *io, uint32_t form_factor)
278 {
279 uint8_t cat[8];
280 uint32_t sectors0, sectors2;
281
282 // read sector count from side 0 catalogue
283 io_generic_read(io, cat, 0x1000, 8);
284 sectors0 = (cat[1] << 8) + cat[2];
285 LOG_FORMATS("ddos: sector count 0: %d %s\n", sectors0, sectors0 % 18 != 0 ? "invalid" : "");
286
287 uint64_t size = io_generic_size(io);
288 for (int i = 0; formats[i].form_factor; i++) {
289 const format &f = formats[i];
290 if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
291 continue;
292
293 if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count)) {
294 if (f.head_count == 2)
295 {
296 // read sector count from side 2 catalogue
297 io_generic_read(io, cat, (uint64_t)compute_track_size(f) * f.track_count + 0x1000, 8); // sequential
298 sectors2 = (cat[1] << 8) + cat[2];
299 LOG_FORMATS("ddos: sector count 2: %d %s\n", sectors2, sectors2 % 18 != 0 ? "invalid" : "");
300 }
301 else
302 {
303 sectors2 = sectors0;
304 }
305
306 if (sectors0 % 18 == 0 && sectors2 % 18 == 0)
307 return i;
308 }
309 }
310 LOG_FORMATS("ddos: no match\n");
311 return -1;
312 }
313
identify(io_generic * io,uint32_t form_factor)314 int opus_ddos_format::identify(io_generic *io, uint32_t form_factor)
315 {
316 int type = find_size(io, form_factor);
317
318 if (type != -1)
319 return 90;
320 return 0;
321 }
322
get_image_offset(const format & f,int head,int track)323 int opus_ddos_format::get_image_offset(const format &f, int head, int track)
324 {
325 if (f.sector_base_id == -1)
326 return (track * f.head_count + head) * compute_track_size(f);
327 else
328 return (f.track_count * head + track) * compute_track_size(f);
329 }
330
331 const opus_ddos_format::format opus_ddos_format::formats[] =
332 {
333 { // 180k 40 track single sided double density - gaps unverified
334 floppy_image::FF_525, floppy_image::SSSD, floppy_image::MFM,
335 4000, 18, 40, 1, 256, {}, 0, {}, 36, 22, 27
336 },
337 { // 360k 80 track single sided double density - gaps unverified
338 floppy_image::FF_525, floppy_image::SSDD, floppy_image::MFM,
339 4000, 18, 80, 1, 256, {}, 0, {}, 36, 22, 27
340 },
341 { // 360k 40 track double sided double density - gaps unverified
342 floppy_image::FF_525, floppy_image::DSSD, floppy_image::MFM,
343 4000, 18, 40, 2, 256, {}, 0, {}, 36, 22, 27
344 },
345 { // 720k 80 track double sided double density - gaps unverified
346 floppy_image::FF_525, floppy_image::DSDD, floppy_image::MFM,
347 4000, 18, 80, 2, 256, {}, 0, {}, 36, 22, 27
348 },
349 {}
350 };
351
352
acorn_adfs_old_format()353 acorn_adfs_old_format::acorn_adfs_old_format() : wd177x_format(formats)
354 {
355 }
356
name() const357 const char *acorn_adfs_old_format::name() const
358 {
359 return "adfs_o";
360 }
361
description() const362 const char *acorn_adfs_old_format::description() const
363 {
364 return "Acorn ADFS (OldMap) disk image";
365 }
366
extensions() const367 const char *acorn_adfs_old_format::extensions() const
368 {
369 return "adf,ads,adm,adl";
370 }
371
find_size(io_generic * io,uint32_t form_factor)372 int acorn_adfs_old_format::find_size(io_generic *io, uint32_t form_factor)
373 {
374 uint8_t map[3];
375 uint32_t sectors;
376 uint8_t oldmap[4];
377
378 // read sector count from free space map
379 io_generic_read(io, map, 0xfc, 3);
380 sectors = map[0] + (map[1] << 8) + (map[2] << 16);
381 LOG_FORMATS("adfs_o: sector count %d %s\n", sectors, sectors % 16 != 0 ? "invalid" : "");
382
383 // read map identifier
384 io_generic_read(io, oldmap, 0x201, 4);
385 LOG_FORMATS("adfs_o: map identifier %s %s\n", oldmap, memcmp(oldmap, "Hugo", 4) != 0 ? "invalid" : "");
386
387 uint64_t size = io_generic_size(io);
388 for(int i=0; formats[i].form_factor; i++) {
389 const format &f = formats[i];
390 if(form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
391 continue;
392
393 // valid images will have map identifier 'Hugo' and sector counts adfs-s = 0x280; adfs-m = 0x500; adfs-l = 0xa00; adfs-dos = 0xaa0; though many adfs-s images are incorrect
394 if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && memcmp(oldmap, "Hugo", 4) == 0 && (sectors == 0x280 || sectors == 0x500 || sectors == 0xa00 || sectors == 0xaa0 || size == 819200)) {
395 return i;
396 }
397 }
398 LOG_FORMATS("adfs_o: no match\n");
399 return -1;
400 }
401
identify(io_generic * io,uint32_t form_factor)402 int acorn_adfs_old_format::identify(io_generic *io, uint32_t form_factor)
403 {
404 int type = find_size(io, form_factor);
405
406 if(type != -1)
407 return 100;
408 return 0;
409 }
410
get_image_offset(const format & f,int head,int track)411 int acorn_adfs_old_format::get_image_offset(const format &f, int head, int track)
412 {
413 if (f.sector_base_id == -1)
414 return (track * f.head_count + head) * compute_track_size(f);
415 else
416 return (f.track_count * head + track) * compute_track_size(f);
417 }
418
419 const acorn_adfs_old_format::format acorn_adfs_old_format::formats[] =
420 {
421 { // M - 320K 5 1/4 inch 80 track single sided double density
422 floppy_image::FF_525, floppy_image::SSDD, floppy_image::MFM,
423 2000, 16, 80, 1, 256, {}, 0, {}, 60, 22, 43
424 },
425 { // S - 160K 5 1/4 inch 40 track single sided double density
426 floppy_image::FF_525, floppy_image::SSDD, floppy_image::MFM,
427 2000, 16, 40, 1, 256, {}, 0, {}, 60, 22, 43
428 },
429 { // L - 640K 5 1/4 inch 80 track double sided double density (interleaved)
430 floppy_image::FF_525, floppy_image::DSDD, floppy_image::MFM,
431 2000, 16, 80, 2, 256, {}, -1, { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 }, 42, 22, 57
432 },
433 { // M - 320K 3 1/2 inch 80 track single sided double density
434 floppy_image::FF_35, floppy_image::SSDD, floppy_image::MFM,
435 2000, 16, 80, 1, 256, {}, 0, {}, 60, 22, 43
436 },
437 { // S - 160K 3 1/2 inch 40 track single sided double density
438 floppy_image::FF_35, floppy_image::SSDD, floppy_image::MFM,
439 2000, 16, 40, 1, 256, {}, 0, {}, 60, 22, 43
440 },
441 { // L - 640K 3 1/2 inch 80 track double sided double density (interleaved)
442 floppy_image::FF_35, floppy_image::DSDD, floppy_image::MFM,
443 2000, 16, 80, 2, 256, {}, -1, { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 }, 42, 22, 57
444 },
445 {}
446 };
447
448
acorn_adfs_new_format()449 acorn_adfs_new_format::acorn_adfs_new_format() : wd177x_format(formats)
450 {
451 }
452
name() const453 const char *acorn_adfs_new_format::name() const
454 {
455 return "adfs_n";
456 }
457
description() const458 const char *acorn_adfs_new_format::description() const
459 {
460 return "Acorn ADFS (NewMap) disk image";
461 }
462
extensions() const463 const char *acorn_adfs_new_format::extensions() const
464 {
465 return "adf";
466 }
467
find_size(io_generic * io,uint32_t form_factor)468 int acorn_adfs_new_format::find_size(io_generic *io, uint32_t form_factor)
469 {
470 uint8_t dform[4];
471 uint8_t eform[4];
472
473 // read map identifiers for D and E formats
474 io_generic_read(io, dform, 0x401, 4);
475 LOG_FORMATS("adfs_n: map identifier (D format) %s %s\n", dform, (memcmp(dform, "Hugo", 4) != 0 && memcmp(dform, "Nick", 4) != 0) ? "invalid" : "");
476 io_generic_read(io, eform, 0x801, 4);
477 LOG_FORMATS("adfs_n: map identifier (E format) %s %s\n", eform, memcmp(eform, "Nick", 4) != 0 ? "invalid" : "");
478
479 uint64_t size = io_generic_size(io);
480 for (int i = 0; formats[i].form_factor; i++) {
481 const format &f = formats[i];
482 if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
483 continue;
484
485 // no further checks for 1600K images
486 if ((size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && size == 0x190000) {
487 return i;
488 }
489
490 // valid 800K images will have map identifier Nick, Arthur D format still use Hugo
491 if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (memcmp(dform, "Hugo", 4) == 0 || memcmp(dform, "Nick", 4) == 0 || memcmp(eform, "Nick", 4) == 0)) {
492 return i;
493 }
494 }
495 LOG_FORMATS("adfs_n: no match\n");
496 return -1;
497 }
498
identify(io_generic * io,uint32_t form_factor)499 int acorn_adfs_new_format::identify(io_generic *io, uint32_t form_factor)
500 {
501 int type = find_size(io, form_factor);
502
503 if (type != -1)
504 return 100;
505 return 0;
506 }
507
get_image_offset(const format & f,int head,int track)508 int acorn_adfs_new_format::get_image_offset(const format &f, int head, int track)
509 {
510 if (f.sector_base_id == -1)
511 return (track * f.head_count + head) * compute_track_size(f);
512 else
513 return (f.track_count * head + track) * compute_track_size(f);
514 }
515
516 const acorn_adfs_new_format::format acorn_adfs_new_format::formats[] =
517 {
518 { // D,E - 800K 3 1/2 inch 80 track double sided double density - gaps unverified
519 floppy_image::FF_35, floppy_image::DSDD, floppy_image::MFM,
520 2000, 5, 80, 2, 1024, {}, -1, { 0,1,2,3,4 }, 32, 22, 90
521 },
522 { // F - 1600K 3 1/2 inch 80 track double sided quad density
523 floppy_image::FF_35, floppy_image::DSHD, floppy_image::MFM,
524 2000, 10, 80, 2, 1024, {}, -1, { 0,1,2,3,4,5,6,7,8,9 }, 50, 22, 90
525 },
526 {}
527 };
528
529
acorn_dos_format()530 acorn_dos_format::acorn_dos_format() : wd177x_format(formats)
531 {
532 }
533
name() const534 const char *acorn_dos_format::name() const
535 {
536 return "dos";
537 }
538
description() const539 const char *acorn_dos_format::description() const
540 {
541 return "Acorn DOS disk image";
542 }
543
extensions() const544 const char *acorn_dos_format::extensions() const
545 {
546 return "img";
547 }
548
find_size(io_generic * io,uint32_t form_factor)549 int acorn_dos_format::find_size(io_generic *io, uint32_t form_factor)
550 {
551 uint8_t type;
552
553 uint64_t size = io_generic_size(io);
554 for(int i=0; formats[i].form_factor; i++) {
555 const format &f = formats[i];
556 if(form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
557 continue;
558
559 if (size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count) {
560 // read media type ID from FAT - Acorn DOS = 0xfd
561 io_generic_read(io, &type, 0, 1);
562 LOG_FORMATS("dos: 800k media type id %02X %s\n", type, type != 0xfd ? "invalid" : "");
563 if (type == 0xfd) return i;
564 }
565 }
566 LOG_FORMATS("dos: no match\n");
567 return -1;
568 }
569
identify(io_generic * io,uint32_t form_factor)570 int acorn_dos_format::identify(io_generic *io, uint32_t form_factor)
571 {
572 int type = find_size(io, form_factor);
573
574 if(type != -1)
575 return 90;
576 return 0;
577 }
578
get_image_offset(const format & f,int head,int track)579 int acorn_dos_format::get_image_offset(const format &f, int head, int track)
580 {
581 if (f.sector_base_id == -1)
582 return (track * f.head_count + head) * compute_track_size(f);
583 else
584 return (f.track_count * head + track) * compute_track_size(f);
585 }
586
587 const acorn_dos_format::format acorn_dos_format::formats[] =
588 {
589 { // 800K 5 1/4 inch 80 track double sided double density - gaps unverified
590 floppy_image::FF_525, floppy_image::DSQD, floppy_image::MFM,
591 2000, 5, 80, 2, 1024, {}, -1, { 1,2,3,4,5 }, 32, 22, 90
592 },
593 {}
594 };
595
596
opus_ddcpm_format()597 opus_ddcpm_format::opus_ddcpm_format()
598 {
599 }
600
name() const601 const char *opus_ddcpm_format::name() const
602 {
603 return "ddcpm";
604 }
605
description() const606 const char *opus_ddcpm_format::description() const
607 {
608 return "Opus DD CP/M disk image";
609 }
610
extensions() const611 const char *opus_ddcpm_format::extensions() const
612 {
613 return "ssd";
614 }
615
supports_save() const616 bool opus_ddcpm_format::supports_save() const
617 {
618 return false;
619 }
620
identify(io_generic * io,uint32_t form_factor)621 int opus_ddcpm_format::identify(io_generic *io, uint32_t form_factor)
622 {
623 uint8_t h[8];
624
625 io_generic_read(io, h, 0, 8);
626
627 if (io_generic_size(io) == 819200 && memcmp(h, "Slogger ", 8) == 0)
628 return 100;
629 LOG_FORMATS("ddcpm: no match\n");
630 return 0;
631 }
632
load(io_generic * io,uint32_t form_factor,floppy_image * image)633 bool opus_ddcpm_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
634 {
635 // Double density discs formatted with DDCPM :
636 //
637 // Tracks 0 - 2 formatted Single Density
638 // Tracks 3 - 159 formatted Double Density
639 //
640 // Single density tracks are 10 x 256 byte sectors per track
641 // Sector skew of 2
642 //
643 // Double Density tracks are 10 x 512 byte sectors per track
644 // Sector skew of 1
645 // Sector interleave of 2
646 //
647 int spt, bps;
648
649 for (int head = 0; head < 2; head++) {
650 for (int track = 0; track < 80; track++) {
651 bool mfm = track > 2 || head;
652 bps = mfm ? 512 : 256;
653 spt = 10;
654 desc_pc_sector sects[10];
655 uint8_t sectdata[10*512];
656
657 io_generic_read(io, sectdata, head * 80 * spt * 512 + track * spt * 512, spt * 512);
658
659 for (int i = 0; i < spt; i++) {
660 sects[i].track = track;
661 sects[i].head = head;
662 sects[i].sector = i;
663 sects[i].size = mfm ? 2 : 1;
664 sects[i].actual_size = bps;
665 sects[i].data = sectdata + i * 512;
666 sects[i].deleted = false;
667 sects[i].bad_crc = false;
668 }
669
670 if (mfm)
671 build_wd_track_mfm(track, head, image, 100000, 10, sects, 60, 43, 22);
672 else
673 build_wd_track_fm(track, head, image, 50000, 10, sects, 40, 10, 10);
674 }
675 }
676
677 return true;
678 }
679
save(io_generic * io,floppy_image * image)680 bool opus_ddcpm_format::save(io_generic *io, floppy_image *image)
681 {
682 return false;
683 }
684
685
686 const floppy_format_type FLOPPY_ACORN_SSD_FORMAT = &floppy_image_format_creator<acorn_ssd_format>;
687 const floppy_format_type FLOPPY_ACORN_DSD_FORMAT = &floppy_image_format_creator<acorn_dsd_format>;
688 const floppy_format_type FLOPPY_ACORN_DOS_FORMAT = &floppy_image_format_creator<acorn_dos_format>;
689 const floppy_format_type FLOPPY_ACORN_ADFS_OLD_FORMAT = &floppy_image_format_creator<acorn_adfs_old_format>;
690 const floppy_format_type FLOPPY_ACORN_ADFS_NEW_FORMAT = &floppy_image_format_creator<acorn_adfs_new_format>;
691 const floppy_format_type FLOPPY_OPUS_DDOS_FORMAT = &floppy_image_format_creator<opus_ddos_format>;
692 const floppy_format_type FLOPPY_OPUS_DDCPM_FORMAT = &floppy_image_format_creator<opus_ddcpm_format>;
693