ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/Frodo4/Src/1541d64.cpp
Revision: 1.2
Committed: 2003-07-01T17:51:17Z (19 years, 7 months ago) by cebix
Branch: MAIN
Changes since 1.1: +1 -1 lines
Log Message:
updated copyright date

File Contents

# Content
1 /*
2 * 1541d64.cpp - 1541 emulation in .d64 file
3 *
4 * Frodo (C) 1994-1997,2002-2003 Christian Bauer
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 /*
22 * Incompatibilities:
23 * ------------------
24 *
25 * - Only read accesses possible
26 * - Not all commands implemented
27 * - The .d64 error info is read, but unused
28 */
29
30 #include "sysdeps.h"
31
32 #include "1541d64.h"
33 #include "IEC.h"
34 #include "Prefs.h"
35
36
37 // Channel modes (IRC users listen up :-)
38 enum {
39 CHMOD_FREE, // Channel free
40 CHMOD_COMMAND, // Command/error channel
41 CHMOD_DIRECTORY, // Reading directory
42 CHMOD_FILE, // Sequential file open
43 CHMOD_DIRECT // Direct buffer access ('#')
44 };
45
46 // Access modes
47 enum {
48 FMODE_READ, FMODE_WRITE, FMODE_APPEND
49 };
50
51 // File types
52 enum {
53 FTYPE_PRG, FTYPE_SEQ, FTYPE_USR, FTYPE_REL
54 };
55
56 // Number of tracks/sectors
57 const int NUM_TRACKS = 35;
58 const int NUM_SECTORS = 683;
59
60 // Prototypes
61 static bool match(uint8 *p, uint8 *n);
62
63
64 /*
65 * Constructor: Prepare emulation, open .d64 file
66 */
67
68 D64Drive::D64Drive(IEC *iec, char *filepath) : Drive(iec)
69 {
70 the_file = NULL;
71 ram = NULL;
72
73 Ready = false;
74 strcpy(orig_d64_name, filepath);
75 for (int i=0; i<=14; i++) {
76 chan_mode[i] = CHMOD_FREE;
77 chan_buf[i] = NULL;
78 }
79 chan_mode[15] = CHMOD_COMMAND;
80
81 // Open .d64 file
82 open_close_d64_file(filepath);
83 if (the_file != NULL) {
84
85 // Allocate 1541 RAM
86 ram = new uint8[0x800];
87 bam = (BAM *)(ram + 0x700);
88
89 Reset();
90 Ready = true;
91 }
92 }
93
94
95 /*
96 * Destructor
97 */
98
99 D64Drive::~D64Drive()
100 {
101 // Close .d64 file
102 open_close_d64_file("");
103
104 delete[] ram;
105 Ready = false;
106 }
107
108
109 /*
110 * Open/close the .d64 file
111 */
112
113 void D64Drive::open_close_d64_file(char *d64name)
114 {
115 long size;
116 uint8 magic[4];
117
118 // Close old .d64, if open
119 if (the_file != NULL) {
120 close_all_channels();
121 fclose(the_file);
122 the_file = NULL;
123 }
124
125 // Open new .d64 file
126 if (d64name[0]) {
127 if ((the_file = fopen(d64name, "rb")) != NULL) {
128
129 // Check length
130 fseek(the_file, 0, SEEK_END);
131 if ((size = ftell(the_file)) < NUM_SECTORS * 256) {
132 fclose(the_file);
133 the_file = NULL;
134 return;
135 }
136
137 // x64 image?
138 rewind(the_file);
139 fread(&magic, 4, 1, the_file);
140 if (magic[0] == 0x43 && magic[1] == 0x15 && magic[2] == 0x41 && magic[3] == 0x64)
141 image_header = 64;
142 else
143 image_header = 0;
144
145 // Preset error info (all sectors no error)
146 memset(error_info, 1, NUM_SECTORS);
147
148 // Load sector error info from .d64 file, if present
149 if (!image_header && size == NUM_SECTORS * 257) {
150 fseek(the_file, NUM_SECTORS * 256, SEEK_SET);
151 fread(&error_info, NUM_SECTORS, 1, the_file);
152 }
153 }
154 }
155 }
156
157
158 /*
159 * Open channel
160 */
161
162 uint8 D64Drive::Open(int channel, char *filename)
163 {
164 set_error(ERR_OK);
165
166 // Channel 15: execute file name as command
167 if (channel == 15) {
168 execute_command(filename);
169 return ST_OK;
170 }
171
172 if (chan_mode[channel] != CHMOD_FREE) {
173 set_error(ERR_NOCHANNEL);
174 return ST_OK;
175 }
176
177 if (filename[0] == '$')
178 if (channel)
179 return open_file_ts(channel, 18, 0);
180 else
181 return open_directory(filename+1);
182
183 if (filename[0] == '#')
184 return open_direct(channel, filename);
185
186 return open_file(channel, filename);
187 }
188
189
190 /*
191 * Open file
192 */
193
194 uint8 D64Drive::open_file(int channel, char *filename)
195 {
196 char plainname[256];
197 int filemode = FMODE_READ;
198 int filetype = FTYPE_PRG;
199 int track, sector;
200
201 convert_filename(filename, plainname, &filemode, &filetype);
202
203 // Channel 0 is READ PRG, channel 1 is WRITE PRG
204 if (!channel) {
205 filemode = FMODE_READ;
206 filetype = FTYPE_PRG;
207 }
208 if (channel == 1) {
209 filemode = FMODE_WRITE;
210 filetype = FTYPE_PRG;
211 }
212
213 // Allow only read accesses
214 if (filemode != FMODE_READ) {
215 set_error(ERR_WRITEPROTECT);
216 return ST_OK;
217 }
218
219 // Find file in directory and open it
220 if (find_file(plainname, &track, &sector))
221 return open_file_ts(channel, track, sector);
222 else
223 set_error(ERR_FILENOTFOUND);
224
225 return ST_OK;
226 }
227
228
229 /*
230 * Analyze file name, get access mode and type
231 */
232
233 void D64Drive::convert_filename(char *srcname, char *destname, int *filemode, int *filetype)
234 {
235 char *p;
236
237 // Search for ':', p points to first character after ':'
238 if ((p = strchr(srcname, ':')) != NULL)
239 p++;
240 else
241 p = srcname;
242
243 // Remaining string -> destname
244 strncpy(destname, p, NAMEBUF_LENGTH);
245
246 // Search for ','
247 p = destname;
248 while (*p && (*p != ',')) p++;
249
250 // Look for mode parameters seperated by ','
251 p = destname;
252 while ((p = strchr(p, ',')) != NULL) {
253
254 // Cut string after the first ','
255 *p++ = 0;
256
257 switch (*p) {
258 case 'P':
259 *filetype = FTYPE_PRG;
260 break;
261 case 'S':
262 *filetype = FTYPE_SEQ;
263 break;
264 case 'U':
265 *filetype = FTYPE_USR;
266 break;
267 case 'L':
268 *filetype = FTYPE_REL;
269 break;
270 case 'R':
271 *filemode = FMODE_READ;
272 break;
273 case 'W':
274 *filemode = FMODE_WRITE;
275 break;
276 case 'A':
277 *filemode = FMODE_APPEND;
278 break;
279 }
280 }
281 }
282
283
284 /*
285 * Search file in directory, find first track and sector
286 * false: not found, true: found
287 */
288
289 bool D64Drive::find_file(char *filename, int *track, int *sector)
290 {
291 int i, j;
292 uint8 *p, *q;
293 DirEntry *de;
294
295 // Scan all directory blocks
296 dir.next_track = bam->dir_track;
297 dir.next_sector = bam->dir_sector;
298
299 while (dir.next_track) {
300 if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
301 return false;
302
303 // Scan all 8 entries of a block
304 for (j=0; j<8; j++) {
305 de = &dir.entry[j];
306 *track = de->track;
307 *sector = de->sector;
308
309 if (de->type) {
310 p = (uint8 *)filename;
311 q = de->name;
312 for (i=0; i<16 && *p; i++, p++, q++) {
313 if (*p == '*') // Wildcard '*' matches all following characters
314 return true;
315 if (*p != *q) {
316 if (*p != '?') goto next_entry; // Wildcard '?' matches single character
317 if (*q == 0xa0) goto next_entry;
318 }
319 }
320
321 if (i == 16 || *q == 0xa0)
322 return true;
323 }
324 next_entry: ;
325 }
326 }
327
328 return false;
329 }
330
331
332 /*
333 * Open file given track/sector of first block
334 */
335
336 uint8 D64Drive::open_file_ts(int channel, int track, int sector)
337 {
338 chan_buf[channel] = new uint8[256];
339 chan_mode[channel] = CHMOD_FILE;
340
341 // On the next call to Read, the first block will be read
342 chan_buf[channel][0] = track;
343 chan_buf[channel][1] = sector;
344 buf_len[channel] = 0;
345
346 return ST_OK;
347 }
348
349
350 /*
351 * Prepare directory as BASIC program (channel 0)
352 */
353
354 const char type_char_1[] = "DSPUREERSELQGRL?";
355 const char type_char_2[] = "EERSELQGRL??????";
356 const char type_char_3[] = "LQGRL???????????";
357
358 // Return true if name 'n' matches pattern 'p'
359 static bool match(uint8 *p, uint8 *n)
360 {
361 if (!*p) // Null pattern matches everything
362 return true;
363
364 do {
365 if (*p == '*') // Wildcard '*' matches all following characters
366 return true;
367 if ((*p != *n) && (*p != '?')) // Wildcard '?' matches single character
368 return false;
369 p++; n++;
370 } while (*p);
371
372 return *n == 0xa0;
373 }
374
375 uint8 D64Drive::open_directory(char *pattern)
376 {
377 int i, j, n, m;
378 uint8 *p, *q;
379 DirEntry *de;
380 uint8 c;
381 char *tmppat;
382
383 // Special treatment for "$0"
384 if (pattern[0] == '0' && pattern[1] == 0)
385 pattern += 1;
386
387 // Skip everything before the ':' in the pattern
388 if ((tmppat = strchr(pattern, ':')) != NULL)
389 pattern = tmppat + 1;
390
391 p = buf_ptr[0] = chan_buf[0] = new uint8[8192];
392 chan_mode[0] = CHMOD_DIRECTORY;
393
394 // Create directory title
395 *p++ = 0x01; // Load address $0401 (from PET days :-)
396 *p++ = 0x04;
397 *p++ = 0x01; // Dummy line link
398 *p++ = 0x01;
399 *p++ = 0; // Drive number (0) as line number
400 *p++ = 0;
401 *p++ = 0x12; // RVS ON
402 *p++ = '\"';
403
404 q = bam->disk_name;
405 for (i=0; i<23; i++) {
406 if ((c = *q++) == 0xa0)
407 *p++ = ' '; // Replace 0xa0 by space
408 else
409 *p++ = c;
410 }
411 *(p-7) = '\"';
412 *p++ = 0;
413
414 // Scan all directory blocks
415 dir.next_track = bam->dir_track;
416 dir.next_sector = bam->dir_sector;
417
418 while (dir.next_track) {
419 if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
420 return ST_OK;
421
422 // Scan all 8 entries of a block
423 for (j=0; j<8; j++) {
424 de = &dir.entry[j];
425
426 if (de->type && match((uint8 *)pattern, de->name)) {
427 *p++ = 0x01; // Dummy line link
428 *p++ = 0x01;
429
430 *p++ = de->num_blocks_l; // Line number
431 *p++ = de->num_blocks_h;
432
433 *p++ = ' ';
434 n = (de->num_blocks_h << 8) + de->num_blocks_l;
435 if (n<10) *p++ = ' ';
436 if (n<100) *p++ = ' ';
437
438 *p++ = '\"';
439 q = de->name;
440 m = 0;
441 for (i=0; i<16; i++) {
442 if ((c = *q++) == 0xa0) {
443 if (m)
444 *p++ = ' '; // Replace all 0xa0 by spaces
445 else
446 m = *p++ = '\"'; // But the first by a '"'
447 } else
448 *p++ = c;
449 }
450 if (m)
451 *p++ = ' ';
452 else
453 *p++ = '\"'; // No 0xa0, then append a space
454
455 if (de->type & 0x80)
456 *p++ = ' ';
457 else
458 *p++ = '*';
459
460 *p++ = type_char_1[de->type & 0x0f];
461 *p++ = type_char_2[de->type & 0x0f];
462 *p++ = type_char_3[de->type & 0x0f];
463
464 if (de->type & 0x40)
465 *p++ = '<';
466 else
467 *p++ = ' ';
468
469 *p++ = ' ';
470 if (n >= 10) *p++ = ' ';
471 if (n >= 100) *p++ = ' ';
472 *p++ = 0;
473 }
474 }
475 }
476
477 // Final line
478 q = p;
479 for (i=0; i<29; i++)
480 *q++ = ' ';
481
482 n = 0;
483 for (i=0; i<35; i++)
484 n += bam->bitmap[i*4];
485
486 *p++ = 0x01; // Dummy line link
487 *p++ = 0x01;
488 *p++ = n & 0xff; // Number of free blocks as line number
489 *p++ = (n >> 8) & 0xff;
490
491 *p++ = 'B';
492 *p++ = 'L';
493 *p++ = 'O';
494 *p++ = 'C';
495 *p++ = 'K';
496 *p++ = 'S';
497 *p++ = ' ';
498 *p++ = 'F';
499 *p++ = 'R';
500 *p++ = 'E';
501 *p++ = 'E';
502 *p++ = '.';
503
504 p = q;
505 *p++ = 0;
506 *p++ = 0;
507 *p++ = 0;
508
509 buf_len[0] = p - chan_buf[0];
510
511 return ST_OK;
512 }
513
514
515 /*
516 * Open channel for direct buffer access
517 */
518
519 uint8 D64Drive::open_direct(int channel, char *filename)
520 {
521 int buf = -1;
522
523 if (filename[1] == 0)
524 buf = alloc_buffer(-1);
525 else
526 if ((filename[1] >= '0') && (filename[1] <= '3') && (filename[2] == 0))
527 buf = alloc_buffer(filename[1] - '0');
528
529 if (buf == -1) {
530 set_error(ERR_NOCHANNEL);
531 return ST_OK;
532 }
533
534 // The buffers are in the 1541 RAM at $300 and are 256 bytes each
535 chan_buf[channel] = buf_ptr[channel] = ram + 0x300 + (buf << 8);
536 chan_mode[channel] = CHMOD_DIRECT;
537 chan_buf_num[channel] = buf;
538
539 // Store actual buffer number in buffer
540 *chan_buf[channel] = buf + '0';
541 buf_len[channel] = 1;
542
543 return ST_OK;
544 }
545
546
547 /*
548 * Close channel
549 */
550
551 uint8 D64Drive::Close(int channel)
552 {
553 if (channel == 15) {
554 close_all_channels();
555 return ST_OK;
556 }
557
558 switch (chan_mode[channel]) {
559 case CHMOD_FREE:
560 break;
561
562 case CHMOD_DIRECT:
563 free_buffer(chan_buf_num[channel]);
564 chan_buf[channel] = NULL;
565 chan_mode[channel] = CHMOD_FREE;
566 break;
567
568 default:
569 delete[] chan_buf[channel];
570 chan_buf[channel] = NULL;
571 chan_mode[channel] = CHMOD_FREE;
572 break;
573 }
574
575 return ST_OK;
576 }
577
578
579 /*
580 * Close all channels
581 */
582
583 void D64Drive::close_all_channels()
584 {
585 for (int i=0; i<15; i++)
586 Close(i);
587
588 cmd_len = 0;
589 }
590
591
592 /*
593 * Read from channel
594 */
595
596 uint8 D64Drive::Read(int channel, uint8 *byte)
597 {
598 switch (chan_mode[channel]) {
599 case CHMOD_COMMAND:
600 *byte = *error_ptr++;
601 if (--error_len)
602 return ST_OK;
603 else {
604 set_error(ERR_OK);
605 return ST_EOF;
606 }
607 break;
608
609 case CHMOD_FILE:
610 // Read next block if necessary
611 if (chan_buf[channel][0] && !buf_len[channel]) {
612 if (!read_sector(chan_buf[channel][0], chan_buf[channel][1], chan_buf[channel]))
613 return ST_READ_TIMEOUT;
614 buf_ptr[channel] = chan_buf[channel] + 2;
615
616 // Determine block length
617 buf_len[channel] = chan_buf[channel][0] ? 254 : (uint8)chan_buf[channel][1]-1;
618 }
619
620 if (buf_len[channel] > 0) {
621 *byte = *buf_ptr[channel]++;
622 if (!--buf_len[channel] && !chan_buf[channel][0])
623 return ST_EOF;
624 else
625 return ST_OK;
626 } else
627 return ST_READ_TIMEOUT;
628 break;
629
630 case CHMOD_DIRECTORY:
631 case CHMOD_DIRECT:
632 if (buf_len[channel] > 0) {
633 *byte = *buf_ptr[channel]++;
634 if (--buf_len[channel])
635 return ST_OK;
636 else
637 return ST_EOF;
638 } else
639 return ST_READ_TIMEOUT;
640 break;
641 }
642 return ST_READ_TIMEOUT;
643 }
644
645
646 /*
647 * Write byte to channel
648 */
649
650 uint8 D64Drive::Write(int channel, uint8 byte, bool eoi)
651 {
652 switch (chan_mode[channel]) {
653 case CHMOD_FREE:
654 set_error(ERR_FILENOTOPEN);
655 break;
656
657 case CHMOD_COMMAND:
658 // Collect characters and execute command on EOI
659 if (cmd_len >= 40)
660 return ST_TIMEOUT;
661
662 cmd_buffer[cmd_len++] = byte;
663
664 if (eoi) {
665 cmd_buffer[cmd_len++] = 0;
666 cmd_len = 0;
667 execute_command(cmd_buffer);
668 }
669 return ST_OK;
670
671 case CHMOD_DIRECTORY:
672 set_error(ERR_WRITEFILEOPEN);
673 break;
674 }
675 return ST_TIMEOUT;
676 }
677
678
679 /*
680 * Execute command string
681 */
682
683 void D64Drive::execute_command(char *command)
684 {
685 uint16 adr;
686 int len;
687
688 switch (command[0]) {
689 case 'B':
690 if (command[1] != '-')
691 set_error(ERR_SYNTAX30);
692 else
693 switch (command[2]) {
694 case 'R':
695 block_read_cmd(&command[3]);
696 break;
697
698 case 'P':
699 buffer_ptr_cmd(&command[3]);
700 break;
701
702 case 'A':
703 case 'F':
704 case 'W':
705 set_error(ERR_WRITEPROTECT);
706 break;
707
708 default:
709 set_error(ERR_SYNTAX30);
710 break;
711 }
712 break;
713
714 case 'M':
715 if (command[1] != '-')
716 set_error(ERR_SYNTAX30);
717 else
718 switch (command[2]) {
719 case 'R':
720 adr = ((uint8)command[4] << 8) | ((uint8)command[3]);
721 error_ptr = (char *)(ram + (adr & 0x07ff));
722 if (!(error_len = (uint8)command[5]))
723 error_len = 1;
724 break;
725
726 case 'W':
727 adr = ((uint8)command[4] << 8) | ((uint8)command[3]);
728 len = (uint8)command[5];
729 for (int i=0; i<len; i++)
730 ram[adr+i] = (uint8)command[i+6];
731 break;
732
733 default:
734 set_error(ERR_SYNTAX30);
735 }
736 break;
737
738 case 'I':
739 close_all_channels();
740 read_sector(18, 0, (uint8 *)bam);
741 set_error(ERR_OK);
742 break;
743
744 case 'U':
745 switch (command[1] & 0x0f) {
746 case 1: // U1/UA: Block-Read
747 block_read_cmd(&command[2]);
748 break;
749
750 case 2: // U2/UB: Block-Write
751 set_error(ERR_WRITEPROTECT);
752 break;
753
754 case 10: // U:/UJ: Reset
755 Reset();
756 break;
757
758 default:
759 set_error(ERR_SYNTAX30);
760 break;
761 }
762 break;
763
764 case 'G':
765 if (command[1] != ':')
766 set_error(ERR_SYNTAX30);
767 else
768 chd64_cmd(&command[2]);
769 break;
770
771 case 'C':
772 case 'N':
773 case 'R':
774 case 'S':
775 case 'V':
776 set_error(ERR_WRITEPROTECT);
777 break;
778
779 default:
780 set_error(ERR_SYNTAX30);
781 break;
782 }
783 }
784
785
786 /*
787 * Execute B-R command
788 */
789
790 void D64Drive::block_read_cmd(char *command)
791 {
792 int channel, drvnum, track, sector;
793
794 if (parse_bcmd(command, &channel, &drvnum, &track, &sector)) {
795 if (chan_mode[channel] == CHMOD_DIRECT) {
796 read_sector(track, sector, buf_ptr[channel] = chan_buf[channel]);
797 buf_len[channel] = 256;
798 set_error(ERR_OK);
799 } else
800 set_error(ERR_NOCHANNEL);
801 } else
802 set_error(ERR_SYNTAX30);
803 }
804
805
806 /*
807 * Execute B-P command
808 */
809
810 void D64Drive::buffer_ptr_cmd(char *command)
811 {
812 int channel, pointer, i;
813
814 if (parse_bcmd(command, &channel, &pointer, &i, &i)) {
815 if (chan_mode[channel] == CHMOD_DIRECT) {
816 buf_ptr[channel] = chan_buf[channel] + pointer;
817 buf_len[channel] = 256 - pointer;
818 set_error(ERR_OK);
819 } else
820 set_error(ERR_NOCHANNEL);
821 } else
822 set_error(ERR_SYNTAX30);
823 }
824
825
826 /*
827 * Parse block command parameters
828 * true: OK, false: error
829 */
830
831 bool D64Drive::parse_bcmd(char *cmd, int *arg1, int *arg2, int *arg3, int *arg4)
832 {
833 int i;
834
835 if (*cmd == ':') cmd++;
836
837 // Read four parameters separated by space, cursor right or comma
838 while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
839 if (!*cmd) return false;
840
841 i = 0;
842 while (*cmd >= 0x30 && *cmd < 0x40) {
843 i *= 10;
844 i += *cmd++ & 0x0f;
845 }
846 *arg1 = i & 0xff;
847
848 while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
849 if (!*cmd) return false;
850
851 i = 0;
852 while (*cmd >= 0x30 && *cmd < 0x40) {
853 i *= 10;
854 i += *cmd++ & 0x0f;
855 }
856 *arg2 = i & 0xff;
857
858 while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
859 if (!*cmd) return false;
860
861 i = 0;
862 while (*cmd >= 0x30 && *cmd < 0x40) {
863 i *= 10;
864 i += *cmd++ & 0x0f;
865 }
866 *arg3 = i & 0xff;
867
868 while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
869 if (!*cmd) return false;
870
871 i = 0;
872 while (*cmd >= 0x30 && *cmd < 0x40) {
873 i *= 10;
874 i += *cmd++ & 0x0f;
875 }
876 *arg4 = i & 0xff;
877
878 return true;
879 }
880
881
882 /*
883 * Execute 'G' command
884 */
885
886 void D64Drive::chd64_cmd(char *d64name)
887 {
888 char str[NAMEBUF_LENGTH];
889 char *p = str;
890
891 // Convert .d64 file name
892 for (int i=0; i<NAMEBUF_LENGTH && (*p++ = conv_from_64(*d64name++, false)); i++) ;
893
894 close_all_channels();
895
896 // G:. resets the .d64 file name to its original setting
897 if (str[0] == '.' && str[1] == 0)
898 open_close_d64_file(orig_d64_name);
899 else
900 open_close_d64_file(str);
901
902 // Read BAM
903 read_sector(18, 0, (uint8 *)bam);
904 }
905
906
907 /*
908 * Reset drive
909 */
910
911 void D64Drive::Reset(void)
912 {
913 close_all_channels();
914
915 read_sector(18, 0, (uint8 *)bam);
916
917 cmd_len = 0;
918 for (int i=0; i<4; i++)
919 buf_free[i] = true;
920
921 set_error(ERR_STARTUP);
922 }
923
924
925 /*
926 * Allocate floppy buffer
927 * -> Desired buffer number or -1
928 * <- Allocated buffer number or -1
929 */
930
931 int D64Drive::alloc_buffer(int want)
932 {
933 if (want == -1) {
934 for (want=3; want>=0; want--)
935 if (buf_free[want]) {
936 buf_free[want] = false;
937 return want;
938 }
939 return -1;
940 }
941
942 if (want < 4)
943 if (buf_free[want]) {
944 buf_free[want] = false;
945 return want;
946 } else
947 return -1;
948 else
949 return -1;
950 }
951
952
953 /*
954 * Free floppy buffer
955 */
956
957 void D64Drive::free_buffer(int buf)
958 {
959 buf_free[buf] = true;
960 }
961
962
963 /*
964 * Read sector (256 bytes)
965 * true: success, false: error
966 */
967
968 bool D64Drive::read_sector(int track, int sector, uint8 *buffer)
969 {
970 int offset;
971
972 // Convert track/sector to byte offset in file
973 if ((offset = offset_from_ts(track, sector)) < 0) {
974 set_error(ERR_ILLEGALTS);
975 return false;
976 }
977
978 if (the_file == NULL) {
979 set_error(ERR_NOTREADY);
980 return false;
981 }
982
983 #ifdef AMIGA
984 if (offset != ftell(the_file))
985 fseek(the_file, offset + image_header, SEEK_SET);
986 #else
987 fseek(the_file, offset + image_header, SEEK_SET);
988 #endif
989 fread(buffer, 256, 1, the_file);
990 return true;
991 }
992
993
994 /*
995 * Convert track/sector to offset
996 */
997
998 const int num_sectors[41] = {
999 0,
1000 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
1001 19,19,19,19,19,19,19,
1002 18,18,18,18,18,18,
1003 17,17,17,17,17,
1004 17,17,17,17,17 // Tracks 36..40
1005 };
1006
1007 const int sector_offset[41] = {
1008 0,
1009 0,21,42,63,84,105,126,147,168,189,210,231,252,273,294,315,336,
1010 357,376,395,414,433,452,471,
1011 490,508,526,544,562,580,
1012 598,615,632,649,666,
1013 683,700,717,734,751 // Tracks 36..40
1014 };
1015
1016 int D64Drive::offset_from_ts(int track, int sector)
1017 {
1018 if ((track < 1) || (track > NUM_TRACKS) ||
1019 (sector < 0) || (sector >= num_sectors[track]))
1020 return -1;
1021
1022 return (sector_offset[track] + sector) << 8;
1023 }
1024
1025
1026 /*
1027 * Conversion PETSCII->ASCII
1028 */
1029
1030 uint8 D64Drive::conv_from_64(uint8 c, bool map_slash)
1031 {
1032 if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
1033 return c ^ 0x20;
1034 if ((c >= 0xc1) && (c <= 0xda))
1035 return c ^ 0x80;
1036 if ((c == '/') && map_slash && ThePrefs.MapSlash)
1037 return '\\';
1038 return c;
1039 }