Frodo4/Src/1541d64.cpp

/*
 *  1541d64.cpp - 1541 emulation in .d64 file
 *
 *  Frodo (C) 1994-1997,2002 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * Incompatibilities:
 * ------------------
 *
 *  - Only read accesses possible
 *  - Not all commands implemented
 *  - The .d64 error info is read, but unused
 */

#include "sysdeps.h"

#include "1541d64.h"
#include "IEC.h"
#include "Prefs.h"


// Channel modes (IRC users listen up :-)
enum {
        CHMOD_FREE,                     // Channel free
        CHMOD_COMMAND,          // Command/error channel
        CHMOD_DIRECTORY,        // Reading directory
        CHMOD_FILE,                     // Sequential file open
        CHMOD_DIRECT            // Direct buffer access ('#')
};

// Access modes
enum {
        FMODE_READ, FMODE_WRITE, FMODE_APPEND
};

// File types
enum {
        FTYPE_PRG, FTYPE_SEQ, FTYPE_USR, FTYPE_REL
};

// Number of tracks/sectors
const int NUM_TRACKS = 35;
const int NUM_SECTORS = 683;

// Prototypes
static bool match(uint8 *p, uint8 *n);


/*
 *  Constructor: Prepare emulation, open .d64 file
 */

D64Drive::D64Drive(IEC *iec, char *filepath) : Drive(iec)
{
        the_file = NULL;
        ram = NULL;

        Ready = false;
        strcpy(orig_d64_name, filepath);
        for (int i=0; i<=14; i++) {
                chan_mode[i] = CHMOD_FREE;
                chan_buf[i] = NULL;
        }
        chan_mode[15] = CHMOD_COMMAND;

        // Open .d64 file
        open_close_d64_file(filepath);
        if (the_file != NULL) {

                // Allocate 1541 RAM
                ram = new uint8[0x800];
                bam = (BAM *)(ram + 0x700);

                Reset();
                Ready = true;
        }
}


/*
 *  Destructor
 */

D64Drive::~D64Drive()
{
        // Close .d64 file
        open_close_d64_file("");

        delete[] ram;
        Ready = false;
}


/*
 *  Open/close the .d64 file
 */

void D64Drive::open_close_d64_file(char *d64name)
{
        long size;
        uint8 magic[4];

        // Close old .d64, if open
        if (the_file != NULL) {
                close_all_channels();
                fclose(the_file);
                the_file = NULL;
        }

        // Open new .d64 file
        if (d64name[0]) {
                if ((the_file = fopen(d64name, "rb")) != NULL) {

                        // Check length
                        fseek(the_file, 0, SEEK_END);
                        if ((size = ftell(the_file)) < NUM_SECTORS * 256) {
                                fclose(the_file);
                                the_file = NULL;
                                return;
                        }

                        // x64 image?
                        rewind(the_file);
                        fread(&magic, 4, 1, the_file);
                        if (magic[0] == 0x43 && magic[1] == 0x15 && magic[2] == 0x41 && magic[3] == 0x64)
                                image_header = 64;
                        else
                                image_header = 0;

                        // Preset error info (all sectors no error)
                        memset(error_info, 1, NUM_SECTORS);

                        // Load sector error info from .d64 file, if present
                        if (!image_header && size == NUM_SECTORS * 257) {
                                fseek(the_file, NUM_SECTORS * 256, SEEK_SET);
                                fread(&error_info, NUM_SECTORS, 1, the_file);
                        }
                }
        }
}


/*
 *  Open channel
 */

uint8 D64Drive::Open(int channel, char *filename)
{
        set_error(ERR_OK);

        // Channel 15: execute file name as command
        if (channel == 15) {
                execute_command(filename);
                return ST_OK;
        }

        if (chan_mode[channel] != CHMOD_FREE) {
                set_error(ERR_NOCHANNEL);
                return ST_OK;
        }

        if (filename[0] == '$')
                if (channel)
                        return open_file_ts(channel, 18, 0);
                else
                        return open_directory(filename+1);

        if (filename[0] == '#')
                return open_direct(channel, filename);

        return open_file(channel, filename);
}


/*
 *  Open file
 */

uint8 D64Drive::open_file(int channel, char *filename)
{
        char plainname[256];
        int filemode = FMODE_READ;
        int filetype = FTYPE_PRG;
        int track, sector;

        convert_filename(filename, plainname, &filemode, &filetype);

        // Channel 0 is READ PRG, channel 1 is WRITE PRG
        if (!channel) {
                filemode = FMODE_READ;
                filetype = FTYPE_PRG;
        }
        if (channel == 1) {
                filemode = FMODE_WRITE;
                filetype = FTYPE_PRG;
        }

        // Allow only read accesses
        if (filemode != FMODE_READ) {
                set_error(ERR_WRITEPROTECT);
                return ST_OK;
        }

        // Find file in directory and open it
        if (find_file(plainname, &track, &sector))
                return open_file_ts(channel, track, sector);
        else
                set_error(ERR_FILENOTFOUND);

        return ST_OK;
}


/*
 *  Analyze file name, get access mode and type
 */

void D64Drive::convert_filename(char *srcname, char *destname, int *filemode, int *filetype)
{
        char *p;

        // Search for ':', p points to first character after ':'
        if ((p = strchr(srcname, ':')) != NULL)
                p++;
        else
                p = srcname;

        // Remaining string -> destname
        strncpy(destname, p, NAMEBUF_LENGTH);

        // Search for ','
        p = destname;
        while (*p && (*p != ',')) p++;

        // Look for mode parameters seperated by ','
        p = destname;
        while ((p = strchr(p, ',')) != NULL) {

                // Cut string after the first ','
                *p++ = 0;

                switch (*p) {
                        case 'P':
                                *filetype = FTYPE_PRG;
                                break;
                        case 'S':
                                *filetype = FTYPE_SEQ;
                                break;
                        case 'U':
                                *filetype = FTYPE_USR;
                                break;
                        case 'L':
                                *filetype = FTYPE_REL;
                                break;
                        case 'R':
                                *filemode = FMODE_READ;
                                break;
                        case 'W':
                                *filemode = FMODE_WRITE;
                                break;
                        case 'A':
                                *filemode = FMODE_APPEND;
                                break;
                }
        }
}


/*
 *  Search file in directory, find first track and sector
 *  false: not found, true: found
 */

bool D64Drive::find_file(char *filename, int *track, int *sector)
{
        int i, j;
        uint8 *p, *q;
        DirEntry *de;

        // Scan all directory blocks
        dir.next_track = bam->dir_track;
        dir.next_sector = bam->dir_sector;

        while (dir.next_track) {
                if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
                        return false;

                // Scan all 8 entries of a block
                for (j=0; j<8; j++) {
                        de = &dir.entry[j];
                        *track = de->track;
                        *sector = de->sector;

                        if (de->type) {
                                p = (uint8 *)filename;
                                q = de->name;
                                for (i=0; i<16 && *p; i++, p++, q++) {
                                        if (*p == '*')  // Wildcard '*' matches all following characters
                                                return true;
                                        if (*p != *q) {
                                                if (*p != '?') goto next_entry; // Wildcard '?' matches single character
                                                if (*q == 0xa0) goto next_entry;
                                        }
                                }

                                if (i == 16 || *q == 0xa0)
                                        return true;
                        }
next_entry: ;
                }
        }

        return false;
}


/*
 *  Open file given track/sector of first block
 */

uint8 D64Drive::open_file_ts(int channel, int track, int sector)
{
        chan_buf[channel] = new uint8[256];
        chan_mode[channel] = CHMOD_FILE;

        // On the next call to Read, the first block will be read
        chan_buf[channel][0] = track;
        chan_buf[channel][1] = sector;
        buf_len[channel] = 0;

        return ST_OK;
}


/*
 *  Prepare directory as BASIC program (channel 0)
 */

const char type_char_1[] = "DSPUREERSELQGRL?";
const char type_char_2[] = "EERSELQGRL??????";
const char type_char_3[] = "LQGRL???????????";

// Return true if name 'n' matches pattern 'p'
static bool match(uint8 *p, uint8 *n)
{
        if (!*p)                // Null pattern matches everything
                return true;

        do {
                if (*p == '*')  // Wildcard '*' matches all following characters
                        return true;
                if ((*p != *n) && (*p != '?'))  // Wildcard '?' matches single character
                        return false;
                p++; n++;
        } while (*p);

        return *n == 0xa0;
}

uint8 D64Drive::open_directory(char *pattern)
{
        int i, j, n, m;
        uint8 *p, *q;
        DirEntry *de;
        uint8 c;
        char *tmppat;

        // Special treatment for "$0"
        if (pattern[0] == '0' && pattern[1] == 0)
                pattern += 1;

        // Skip everything before the ':' in the pattern
        if ((tmppat = strchr(pattern, ':')) != NULL)
                pattern = tmppat + 1;

        p = buf_ptr[0] = chan_buf[0] = new uint8[8192];
        chan_mode[0] = CHMOD_DIRECTORY;

        // Create directory title
        *p++ = 0x01;    // Load address $0401 (from PET days :-)
        *p++ = 0x04;
        *p++ = 0x01;    // Dummy line link
        *p++ = 0x01;
        *p++ = 0;               // Drive number (0) as line number
        *p++ = 0;
        *p++ = 0x12;    // RVS ON
        *p++ = '\"';

        q = bam->disk_name;
        for (i=0; i<23; i++) {
                if ((c = *q++) == 0xa0)
                        *p++ = ' ';             // Replace 0xa0 by space
                else
                        *p++ = c;
        }
        *(p-7) = '\"';
        *p++ = 0;

        // Scan all directory blocks
        dir.next_track = bam->dir_track;
        dir.next_sector = bam->dir_sector;

        while (dir.next_track) {
                if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
                        return ST_OK;

                // Scan all 8 entries of a block
                for (j=0; j<8; j++) {
                        de = &dir.entry[j];

                        if (de->type && match((uint8 *)pattern, de->name)) {
                                *p++ = 0x01; // Dummy line link
                                *p++ = 0x01;

                                *p++ = de->num_blocks_l; // Line number
                                *p++ = de->num_blocks_h;

                                *p++ = ' ';
                                n = (de->num_blocks_h << 8) + de->num_blocks_l;
                                if (n<10) *p++ = ' ';
                                if (n<100) *p++ = ' ';

                                *p++ = '\"';
                                q = de->name;
                                m = 0;
                                for (i=0; i<16; i++) {
                                        if ((c = *q++) == 0xa0) {
                                                if (m)
                                                        *p++ = ' ';             // Replace all 0xa0 by spaces
                                                else
                                                        m = *p++ = '\"';        // But the first by a '"'
                                        } else
                                                *p++ = c;
                                }
                                if (m)
                                        *p++ = ' ';
                                else
                                        *p++ = '\"';                    // No 0xa0, then append a space

                                if (de->type & 0x80)
                                        *p++ = ' ';
                                else
                                        *p++ = '*';

                                *p++ = type_char_1[de->type & 0x0f];
                                *p++ = type_char_2[de->type & 0x0f];
                                *p++ = type_char_3[de->type & 0x0f];

                                if (de->type & 0x40)
                                        *p++ = '<';
                                else
                                        *p++ = ' ';

                                *p++ = ' ';
                                if (n >= 10) *p++ = ' ';
                                if (n >= 100) *p++ = ' ';
                                *p++ = 0;
                        }
                }
        }

        // Final line
        q = p;
        for (i=0; i<29; i++)
                *q++ = ' ';

        n = 0;
        for (i=0; i<35; i++)
                n += bam->bitmap[i*4];

        *p++ = 0x01;            // Dummy line link
        *p++ = 0x01;
        *p++ = n & 0xff;        // Number of free blocks as line number
        *p++ = (n >> 8) & 0xff;

        *p++ = 'B';
        *p++ = 'L';
        *p++ = 'O';
        *p++ = 'C';
        *p++ = 'K';
        *p++ = 'S';
        *p++ = ' ';
        *p++ = 'F';
        *p++ = 'R';
        *p++ = 'E';
        *p++ = 'E';
        *p++ = '.';

        p = q;
        *p++ = 0;
        *p++ = 0;
        *p++ = 0;

        buf_len[0] = p - chan_buf[0];

        return ST_OK;
}


/*
 *  Open channel for direct buffer access
 */

uint8 D64Drive::open_direct(int channel, char *filename)
{
        int buf = -1;

        if (filename[1] == 0)
                buf = alloc_buffer(-1);
        else
                if ((filename[1] >= '0') && (filename[1] <= '3') && (filename[2] == 0))
                        buf = alloc_buffer(filename[1] - '0');

        if (buf == -1) {
                set_error(ERR_NOCHANNEL);
                return ST_OK;
        }

        // The buffers are in the 1541 RAM at $300 and are 256 bytes each
        chan_buf[channel] = buf_ptr[channel] = ram + 0x300 + (buf << 8);
        chan_mode[channel] = CHMOD_DIRECT;
        chan_buf_num[channel] = buf;

        // Store actual buffer number in buffer
        *chan_buf[channel] = buf + '0';
        buf_len[channel] = 1;

        return ST_OK;
}


/*
 *  Close channel
 */

uint8 D64Drive::Close(int channel)
{
        if (channel == 15) {
                close_all_channels();
                return ST_OK;
        }

        switch (chan_mode[channel]) {
                case CHMOD_FREE:
                        break;
 
                case CHMOD_DIRECT:
                        free_buffer(chan_buf_num[channel]);
                        chan_buf[channel] = NULL;
                        chan_mode[channel] = CHMOD_FREE;
                        break;

                default:
                        delete[] chan_buf[channel];
                        chan_buf[channel] = NULL;
                        chan_mode[channel] = CHMOD_FREE;
                        break;
        }

        return ST_OK;
}


/*
 *  Close all channels
 */

void D64Drive::close_all_channels()
{
        for (int i=0; i<15; i++)
                Close(i);

        cmd_len = 0;
}


/*
 *  Read from channel
 */

uint8 D64Drive::Read(int channel, uint8 *byte)
{
        switch (chan_mode[channel]) {
                case CHMOD_COMMAND:
                        *byte = *error_ptr++;
                        if (--error_len)
                                return ST_OK;
                        else {
                                set_error(ERR_OK);
                                return ST_EOF;
                        }
                        break;

                case CHMOD_FILE:
                        // Read next block if necessary
                        if (chan_buf[channel][0] && !buf_len[channel]) {
                                if (!read_sector(chan_buf[channel][0], chan_buf[channel][1], chan_buf[channel]))
                                        return ST_READ_TIMEOUT;
                                buf_ptr[channel] = chan_buf[channel] + 2;

                                // Determine block length
                                buf_len[channel] = chan_buf[channel][0] ? 254 : (uint8)chan_buf[channel][1]-1;
                        }

                        if (buf_len[channel] > 0) {
                                *byte = *buf_ptr[channel]++;
                                if (!--buf_len[channel] && !chan_buf[channel][0])
                                        return ST_EOF;
                                else
                                        return ST_OK;
                        } else
                                return ST_READ_TIMEOUT;
                        break;

                case CHMOD_DIRECTORY:
                case CHMOD_DIRECT:
                        if (buf_len[channel] > 0) {
                                *byte = *buf_ptr[channel]++;
                                if (--buf_len[channel])
                                        return ST_OK;
                                else
                                        return ST_EOF;
                        } else
                                return ST_READ_TIMEOUT;
                        break;
        }
        return ST_READ_TIMEOUT;
}


/*
 *  Write byte to channel
 */

uint8 D64Drive::Write(int channel, uint8 byte, bool eoi)
{
        switch (chan_mode[channel]) {
                case CHMOD_FREE:
                        set_error(ERR_FILENOTOPEN);
                        break;

                case CHMOD_COMMAND:
                        // Collect characters and execute command on EOI
                        if (cmd_len >= 40)
                                return ST_TIMEOUT;

                        cmd_buffer[cmd_len++] = byte;

                        if (eoi) {
                                cmd_buffer[cmd_len++] = 0;
                                cmd_len = 0;
                                execute_command(cmd_buffer);
                        }
                        return ST_OK;

                case CHMOD_DIRECTORY:
                        set_error(ERR_WRITEFILEOPEN);
                        break;
        }
        return ST_TIMEOUT;
}


/*
 *  Execute command string
 */

void D64Drive::execute_command(char *command)
{
        uint16 adr;
        int len;

        switch (command[0]) {
                case 'B':
                        if (command[1] != '-')
                                set_error(ERR_SYNTAX30);
                        else
                                switch (command[2]) {
                                        case 'R':
                                                block_read_cmd(&command[3]);
                                                break;

                                        case 'P':
                                                buffer_ptr_cmd(&command[3]);
                                                break;

                                        case 'A':
                                        case 'F':
                                        case 'W':
                                                set_error(ERR_WRITEPROTECT);
                                                break;

                                        default:
                                                set_error(ERR_SYNTAX30);
                                                break;
                                }
                        break;

                case 'M':
                        if (command[1] != '-')
                                set_error(ERR_SYNTAX30);
                        else
                                switch (command[2]) {
                                        case 'R':
                                                adr = ((uint8)command[4] << 8) | ((uint8)command[3]);
                                                error_ptr = (char *)(ram + (adr & 0x07ff));
                                                if (!(error_len = (uint8)command[5]))
                                                        error_len = 1;
                                                break;

                                        case 'W':
                                                adr = ((uint8)command[4] << 8) | ((uint8)command[3]);
                                                len = (uint8)command[5];
                                                for (int i=0; i<len; i++)
                                                        ram[adr+i] = (uint8)command[i+6];
                                                break;

                                        default:
                                                set_error(ERR_SYNTAX30);
                                }
                        break;

                case 'I':
                        close_all_channels();
                        read_sector(18, 0, (uint8 *)bam);
                        set_error(ERR_OK);
                        break;

                case 'U':
                        switch (command[1] & 0x0f) {
                                case 1:         // U1/UA: Block-Read
                                        block_read_cmd(&command[2]);
                                        break;

                                case 2:         // U2/UB: Block-Write
                                        set_error(ERR_WRITEPROTECT);
                                        break;

                                case 10:        // U:/UJ: Reset
                                        Reset();
                                        break;

                                default:
                                        set_error(ERR_SYNTAX30);
                                        break;
                        }
                        break;

                case 'G':
                        if (command[1] != ':')
                                set_error(ERR_SYNTAX30);
                        else
                                chd64_cmd(&command[2]);
                        break;

                case 'C':
                case 'N':
                case 'R':
                case 'S':
                case 'V':
                        set_error(ERR_WRITEPROTECT);
                        break;

                default:
                        set_error(ERR_SYNTAX30);
                        break;
        }
}


/*
 *  Execute B-R command
 */

void D64Drive::block_read_cmd(char *command)
{
        int channel, drvnum, track, sector;

        if (parse_bcmd(command, &channel, &drvnum, &track, &sector)) {
                if (chan_mode[channel] == CHMOD_DIRECT) {
                        read_sector(track, sector, buf_ptr[channel] = chan_buf[channel]);
                        buf_len[channel] = 256;
                        set_error(ERR_OK);
                } else
                        set_error(ERR_NOCHANNEL);
        } else
                set_error(ERR_SYNTAX30);
}


/*
 *  Execute B-P command
 */

void D64Drive::buffer_ptr_cmd(char *command)
{
        int channel, pointer, i;

        if (parse_bcmd(command, &channel, &pointer, &i, &i)) {
                if (chan_mode[channel] == CHMOD_DIRECT) {
                        buf_ptr[channel] = chan_buf[channel] + pointer;
                        buf_len[channel] = 256 - pointer;
                        set_error(ERR_OK);
                } else
                        set_error(ERR_NOCHANNEL);
        } else
                set_error(ERR_SYNTAX30);
}


/*
 *  Parse block command parameters
 *  true: OK, false: error
 */

bool D64Drive::parse_bcmd(char *cmd, int *arg1, int *arg2, int *arg3, int *arg4)
{
        int i;

        if (*cmd == ':') cmd++;

        // Read four parameters separated by space, cursor right or comma
        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
        if (!*cmd) return false;

        i = 0;
        while (*cmd >= 0x30 && *cmd < 0x40) {
                i *= 10;
                i += *cmd++ & 0x0f;
        }
        *arg1 = i & 0xff;

        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
        if (!*cmd) return false;

        i = 0;
        while (*cmd >= 0x30 && *cmd < 0x40) {
                i *= 10;
                i += *cmd++ & 0x0f;
        }
        *arg2 = i & 0xff;

        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
        if (!*cmd) return false;

        i = 0;
        while (*cmd >= 0x30 && *cmd < 0x40) {
                i *= 10;
                i += *cmd++ & 0x0f;
        }
        *arg3 = i & 0xff;

        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
        if (!*cmd) return false;

        i = 0;
        while (*cmd >= 0x30 && *cmd < 0x40) {
                i *= 10;
                i += *cmd++ & 0x0f;
        }
        *arg4 = i & 0xff;

        return true;
}


/*
 *  Execute 'G' command
 */

void D64Drive::chd64_cmd(char *d64name)
{
        char str[NAMEBUF_LENGTH];
        char *p = str;

        // Convert .d64 file name
        for (int i=0; i<NAMEBUF_LENGTH && (*p++ = conv_from_64(*d64name++, false)); i++) ;

        close_all_channels();

        // G:. resets the .d64 file name to its original setting
        if (str[0] == '.' && str[1] == 0)
                open_close_d64_file(orig_d64_name);
        else
                open_close_d64_file(str);

        // Read BAM
        read_sector(18, 0, (uint8 *)bam);
}


/*
 *  Reset drive
 */

void D64Drive::Reset(void)
{
        close_all_channels();

        read_sector(18, 0, (uint8 *)bam);

        cmd_len = 0;
        for (int i=0; i<4; i++)
                buf_free[i] = true;

        set_error(ERR_STARTUP);
}


/*
 *  Allocate floppy buffer
 *   -> Desired buffer number or -1
 *   <- Allocated buffer number or -1
 */

int D64Drive::alloc_buffer(int want)
{
        if (want == -1) {
                for (want=3; want>=0; want--)
                        if (buf_free[want]) {
                                buf_free[want] = false;
                                return want;
                        }
                return -1;
        }

        if (want < 4)
                if (buf_free[want]) {
                        buf_free[want] = false;
                        return want;
                } else
                        return -1;
        else
                return -1;
}


/*
 *  Free floppy buffer
 */

void D64Drive::free_buffer(int buf)
{
        buf_free[buf] = true;
}


/*
 *  Read sector (256 bytes)
 *  true: success, false: error
 */

bool D64Drive::read_sector(int track, int sector, uint8 *buffer)
{
        int offset;

        // Convert track/sector to byte offset in file
        if ((offset = offset_from_ts(track, sector)) < 0) {
                set_error(ERR_ILLEGALTS);
                return false;
        }

        if (the_file == NULL) {
                set_error(ERR_NOTREADY);
                return false;
        }

#ifdef AMIGA
        if (offset != ftell(the_file))
                fseek(the_file, offset + image_header, SEEK_SET);
#else
        fseek(the_file, offset + image_header, SEEK_SET);
#endif
        fread(buffer, 256, 1, the_file);
        return true;
}


/*
 *  Convert track/sector to offset
 */

const int num_sectors[41] = {
        0,
        21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
        19,19,19,19,19,19,19,
        18,18,18,18,18,18,
        17,17,17,17,17,
        17,17,17,17,17          // Tracks 36..40
};

const int sector_offset[41] = {
        0,
        0,21,42,63,84,105,126,147,168,189,210,231,252,273,294,315,336,
        357,376,395,414,433,452,471,
        490,508,526,544,562,580,
        598,615,632,649,666,
        683,700,717,734,751     // Tracks 36..40
};

int D64Drive::offset_from_ts(int track, int sector)
{
        if ((track < 1) || (track > NUM_TRACKS) ||
                (sector < 0) || (sector >= num_sectors[track]))
                return -1;

        return (sector_offset[track] + sector) << 8;
}


/*
 *  Conversion PETSCII->ASCII
 */

uint8 D64Drive::conv_from_64(uint8 c, bool map_slash)
{
        if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
                return c ^ 0x20;
        if ((c >= 0xc1) && (c <= 0xda))
                return c ^ 0x80;
        if ((c == '/') && map_slash && ThePrefs.MapSlash)
                return '\\';
        return c;
}
Revision:	1.1
Committed:	2003-07-01T17:09:43Z (21 years, 5 months ago) by cebix
Branch:	MAIN
Log Message:	imported files
#	User	Rev	Content
1	cebix	1.1	/*
2			* 1541d64.cpp - 1541 emulation in .d64 file
3			*
4			* Frodo (C) 1994-1997,2002 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			}