dd6603.c

/*--------------------------------------------------------------------------
**
**  Copyright (c) 2003-2011, Tom Hunter
**
**  Name: dd6603.c
**
**  Description:
**      Perform emulation of CDC 6603 disk drives.
**
**  This program is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License version 3 as
**  published by the Free Software Foundation.
**
**  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 version 3 for more details.
**
**  You should have received a copy of the GNU General Public License
**  version 3 along with this program in file "license-gpl-3.0.txt".
**  If not, see <http://www.gnu.org/licenses/gpl-3.0.txt>.
**
**--------------------------------------------------------------------------
*/

#define DEBUG    0

/*
**  -------------
**  Include Files
**  -------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "const.h"
#include "types.h"
#include "proto.h"

/*
**  -----------------
**  Private Constants
**  -----------------
*/

/*
**  CDC 6603 disk drive function and status codes.
**
**  10xx    Read sector xx (00-77)
**  11xx    Read sector xx (100-177)
**  12xx    Write sector xx (00-77)
**  13xx    Write sector xx (100-177)
**  14xx    Select tracks xx (00-77)
**  15xx    Select tracks xx (100-177)
**  16xy    Select head group y (x is read sampling time - ignore)
**  1700    Status request
*/
#define Fc6603CodeMask           07600
#define Fc6603SectMask           0177
#define Fc6603TrackMask          0177
#define Fc6603HeadMask           07

#define Fc6603ReadSector         01000
#define Fc6603WriteSector        01200
#define Fc6603SelectTrack        01400
#define Fc6603SelectHead         01600
#define Fc6603StatusReq          01700

/*
**
**  Status Reply:
**
**  0xysSS
**  x=0     Ready
**  x=1     Not ready
**  y=0     No parity error
**  Y=1     Parity error
**  sSS     Sector number (bits 6-0)
*/
#define St6603StatusMask         07000
#define St6603StatusValue        00000
#define St6603SectMask           0177
#define St6603ParityErrorMask    0200
#define St6603ReadyMask          0400

/*
**  Physical dimensions of disk.
*/
#define MaxTracks                0200
#define MaxHeads                 8
#define MaxOuterSectors          128
#define MaxInnerSectors          100
#define SectorSize               (322 + 16)


/*
**  -----------------------
**  Private Macro Functions
**  -----------------------
*/

/*
**  -----------------------------------------
**  Private Typedef and Structure Definitions
**  -----------------------------------------
*/
typedef struct diskParam
    {
    /*
    **  Info for show_disk operator command.
    */
    struct diskParam *nextDisk;
    u8               channelNo;
    u8               eqNo;
    u8               unitNo;
    char             fileName[MaxFSPath];

    i32              sector;
    i32              track;
    i32              head;
    } DiskParam;

/*
**  ---------------------------
**  Private Function Prototypes
**  ---------------------------
*/
static FcStatus dd6603Func(PpWord funcCode);
static void dd6603Io(void);
static void dd6603Activate(void);
static void dd6603Disconnect(void);
static i32 dd6603Seek(i32 track, i32 head, i32 sector);
static char *dd6603Func2String(PpWord funcCode);

/*
**  ----------------
**  Public Variables
**  ----------------
*/

/*
**  -----------------
**  Private Variables
**  -----------------
*/
static u8 logColumn;

static DiskParam *firstDisk = NULL;
static DiskParam *lastDisk  = NULL;

#if DEBUG
static FILE *dd6603Log = NULL;
#endif

#if DEBUG
#define OctalColumn(x)    (5 * (x) + 1 + 5)
#define AsciiColumn(x)    (OctalColumn(5) + 2 + (2 * x))
#define LogLineLength    (AsciiColumn(5))
#endif

#if DEBUG
static void dd6603LogFlush(void);
static void dd6603LogByte(int b);

#endif

#if DEBUG
static char dd6603LogBuf[LogLineLength + 1];
static int  dd6603LogCol = 0;
#endif

#if DEBUG

/*--------------------------------------------------------------------------
**  Purpose:        Flush incomplete numeric/ascii data line
**
**  Parameters:     Name        Description.
**
**  Returns:        nothing
**
**------------------------------------------------------------------------*/
static void dd6603LogFlush(void)
    {
    if (dd6603LogCol != 0)
        {
        fputs(dd6603LogBuf, dd6603Log);
        }

    dd6603LogCol = 0;
    memset(dd6603LogBuf, ' ', LogLineLength);
    dd6603LogBuf[0]             = '\n';
    dd6603LogBuf[LogLineLength] = '\0';
    }

/*--------------------------------------------------------------------------
**  Purpose:        Log a byte in octal/ascii form
**
**  Parameters:     Name        Description.
**
**  Returns:        nothing
**
**------------------------------------------------------------------------*/
static void dd6603LogByte(int b)
    {
    char octal[10];
    int  col;

    col = OctalColumn(dd6603LogCol);
    sprintf(octal, "%04o ", b);
    memcpy(dd6603LogBuf + col, octal, 5);

    col = AsciiColumn(dd6603LogCol);
    dd6603LogBuf[col + 0] = cdcToAscii[(b >> 6) & Mask6];
    dd6603LogBuf[col + 1] = cdcToAscii[(b >> 0) & Mask6];
    if (++dd6603LogCol == 5)
        {
        dd6603LogFlush();
        }
    }

#endif

/*
 **--------------------------------------------------------------------------
 **
 **  Public Functions
 **
 **--------------------------------------------------------------------------
 */

/*--------------------------------------------------------------------------
**  Purpose:        Initialise 6603 disk drive.
**
**  Parameters:     Name        Description.
**                  eqNo        equipment number
**                  unitNo      unit number
**                  channelNo   channel number the device is attached to
**                  deviceName  optional device file name
**
**  Returns:        Nothing.
**
**------------------------------------------------------------------------*/
void dd6603Init(u8 eqNo, u8 unitNo, u8 channelNo, char *deviceName)
    {
    DevSlot   *dp;
    DiskParam *diskP;
    FILE      *fcb;
    char      fname[MaxFSPath];
    char      *opt;

#if DEBUG
    if (dd6603Log == NULL)
        {
        dd6603Log = fopen("dd6603log.txt", "wt");
        }
#endif

    dp = channelAttach(channelNo, eqNo, DtDd6603);

    dp->activate     = dd6603Activate;
    dp->disconnect   = dd6603Disconnect;
    dp->func         = dd6603Func;
    dp->io           = dd6603Io;
    dp->selectedUnit = unitNo;

    dp->context[unitNo] = calloc(1, sizeof(DiskParam));
    diskP = (DiskParam *)dp->context[unitNo];


    if (dp->context[unitNo] == NULL)
        {
        fprintf(stderr, "(dd6603 ) Failed to allocate context block\n");
        exit(1);
        }

    if (deviceName == NULL)
        {
        sprintf(fname, "DD6603_C%02oU%1o", channelNo, unitNo);
        }
    else
        {
        opt = strchr(deviceName, ',');
        if (opt != NULL) *opt++ = '\0';
        strcpy(fname, deviceName);
        }

    fcb = fopen(fname, "r+b");
    if (fcb == NULL)
        {
        fcb = fopen(fname, "w+b");
        if (fcb == NULL)
            {
            fprintf(stderr, "(dd6603 ) Failed to open '%s'\n", fname);
            exit(1);
            }
        }
    strcpy(diskP->fileName, fname);

    diskP->eqNo      = eqNo;
    diskP->channelNo = channelNo;
    diskP->unitNo    = unitNo;

    dp->fcb[unitNo] = fcb;

    /*
    **  Link into list of disk units.
    */
    if (lastDisk == NULL)
        {
        firstDisk = diskP;
        }
    else
        {
        lastDisk->nextDisk = diskP;
        }

    lastDisk = diskP;


    /*
    **  Print a friendly message.
    */
    printf("(dd6603 ) Initialised on channel %o unit %o\n", channelNo, unitNo);
    }

/*--------------------------------------------------------------------------
**  Purpose:        Execute function code on 6603 disk drive.
**
**  Parameters:     Name        Description.
**                  funcCode    function code
**
**  Returns:        FcStatus
**
**------------------------------------------------------------------------*/
static FcStatus dd6603Func(PpWord funcCode)
    {
    FILE      *fcb = activeDevice->fcb[activeDevice->selectedUnit];
    DiskParam *dp  = (DiskParam *)activeDevice->context[activeDevice->selectedUnit];
    i32       pos;

#if DEBUG
    dd6603LogFlush();
    fprintf(dd6603Log, "\n(dd6603 ) %06d PP:%02o CH:%02o f:%04o T:%-25s  >   ",
            traceSequenceNo,
            activePpu->id,
            activeDevice->channel->id,
            funcCode,
            dd6603Func2String(funcCode));
#endif

    switch (funcCode & Fc6603CodeMask)
        {
    default:
        return (FcDeclined);

    case Fc6603ReadSector:
        activeDevice->fcode = funcCode;
        dp->sector          = funcCode & Fc6603SectMask;
        pos = dd6603Seek(dp->track, dp->head, dp->sector);
        if (pos < 0)
            {
            return (FcDeclined);
            }
        fseek(fcb, pos, SEEK_SET);
        logColumn = 0;
        break;

    case Fc6603WriteSector:
        activeDevice->fcode = funcCode;
        dp->sector          = funcCode & Fc6603SectMask;
        pos = dd6603Seek(dp->track, dp->head, dp->sector);
        if (pos < 0)
            {
            return (FcDeclined);
            }
        fseek(fcb, pos, SEEK_SET);
        logColumn = 0;
        break;

    case Fc6603SelectTrack:
        dp->track = funcCode & Fc6603TrackMask;

        return (FcProcessed);

        break;

    case Fc6603SelectHead:
        if (funcCode == Fc6603StatusReq)
            {
            activeDevice->fcode   = funcCode;
            activeChannel->status = (u16)dp->sector;

            /*
            **  Simulate the moving disk - seems strange but is required.
            */
            dp->sector = (dp->sector + 1) & 0177;
            }
        else
            {
            /*
            **  Select head.
            */
            dp->head = funcCode & Fc6603HeadMask;

            return (FcProcessed);
            }
        break;
        }

    return (FcAccepted);
    }

/*--------------------------------------------------------------------------
**  Purpose:        Perform I/O on 6603 disk drive.
**
**  Parameters:     Name        Description.
**
**  Returns:        Nothing.
**
**------------------------------------------------------------------------*/
static void dd6603Io(void)
    {
    int ignore;

    FILE      *fcb = activeDevice->fcb[activeDevice->selectedUnit];
    DiskParam *dp  = (DiskParam *)activeDevice->context[activeDevice->selectedUnit];

    switch (activeDevice->fcode & Fc6603CodeMask)
        {
    default:
        logError(LogErrorLocation, "(dd6603 ) channel %02o - invalid function code: %4.4o", activeChannel->id, (u32)activeDevice->fcode);
        break;

    case 0:
        break;

    case Fc6603ReadSector:
        if (!activeChannel->full)
            {
            ignore = fread(&activeChannel->data, 2, 1, fcb);
            activeChannel->full = TRUE;

#if DEBUG
            dd6603LogByte(activeChannel->data);
#endif
            }
        break;

    case Fc6603WriteSector:
        if (activeChannel->full)
            {
            fwrite(&activeChannel->data, 2, 1, fcb);
            activeChannel->full = FALSE;

#if DEBUG
            dd6603LogByte(activeChannel->data);
#endif
            }
        break;

    case Fc6603SelectTrack:
        break;

    case Fc6603SelectHead:
        if (activeDevice->fcode == Fc6603StatusReq)
            {
            activeChannel->data = activeChannel->status;
            activeChannel->full = TRUE;

#if 0
            activeChannel->status = (u16)dp->sector;

            /*
            **  Simulate the moving disk - seems strange but is required.
            */
            dp->sector = (dp->sector + 1) & 0177;
#else
            activeChannel->status = 0;
            activeDevice->fcode   = 0;
#endif
            }
        break;
        }
    }

/*--------------------------------------------------------------------------
**  Purpose:        Handle channel activation.
**
**  Parameters:     Name        Description.
**
**  Returns:        Nothing.
**
**------------------------------------------------------------------------*/
static void dd6603Activate(void)
    {
    }

/*--------------------------------------------------------------------------
**  Purpose:        Handle disconnecting of channel.
**
**  Parameters:     Name        Description.
**
**  Returns:        Nothing.
**
**------------------------------------------------------------------------*/
static void dd6603Disconnect(void)
    {
    }

/*--------------------------------------------------------------------------
**  Purpose:        Work out seek offset.
**
**  Parameters:     Name        Description.
**                  track       Track number.
**                  head        Head group.
**                  sector      Sector number.
**
**  Returns:        Byte offset (not word!) or -1 when seek target
**                  is invalid.
**
**------------------------------------------------------------------------*/
static i32 dd6603Seek(i32 track, i32 head, i32 sector)
    {
    i32 result;
    i32 sectorsPerTrack = MaxOuterSectors;

    if (track >= MaxTracks)
        {
        logError(LogErrorLocation, "(dd6603 ) ch %o, track %o invalid", activeChannel->id, track);

        return (-1);
        }

    if (head >= MaxHeads)
        {
        logError(LogErrorLocation, "(dd6603 ) ch %o, head %o invalid", activeChannel->id, head);

        return (-1);
        }

    if (sector >= sectorsPerTrack)
        {
        logError(LogErrorLocation, "(dd6603 ) ch %o, sector %o invalid", activeChannel->id, sector);

        return (-1);
        }

    result  = track * MaxHeads * sectorsPerTrack;
    result += head * sectorsPerTrack;
    result += sector;
    result *= SectorSize * 2;

    return (result);
    }

/*--------------------------------------------------------------------------
**  Purpose:        Convert function code to string.
**
**  Parameters:     Name        Description.
**                  funcCode    function code
**
**  Returns:        String equivalent of function code.
**
**------------------------------------------------------------------------*/
static char *dd6603Func2String(PpWord funcCode)
    {
    static char buf[40];

#if DEBUG
    switch (funcCode & Fc6603CodeMask)
        {
    case Fc6603ReadSector:
        return "Fc6603ReadSector";

    case Fc6603WriteSector:
        return "Fc6603WriteSector";

    case Fc6603SelectTrack:
        return "Fc6603SelectTrack";

    case Fc6603SelectHead:
        return "Fc6603SelectHead";

    case Fc6603StatusReq:
        return "Fc6603StatusReq";
        }
#endif
    sprintf(buf, "(dd6603 ) Unknown Fundtion: %04o", funcCode);

    return (buf);
    }

/*--------------------------------------------------------------------------
**  Purpose:        Show disk status (operator interface).
**
**  Parameters:     Name        Description.
**
**
**  Returns:        Nothing.
**
**------------------------------------------------------------------------*/
void dd6603ShowDiskStatus()
    {
    DiskParam *dp = firstDisk;
    char      outBuf[MaxFSPath+128];

    if (dp == NULL)
        {
        return;
        }
    while (dp)
        {
        sprintf(outBuf, "    >   %-8s C%02o E%02o U%02o   %-20s (hd %02o sec 0x%06x trk 0x%06o)\n",
                "6603",
                dp->channelNo,
                dp->eqNo,
                dp->unitNo,
                dp->fileName,
                dp->head,
                dp->sector,
                dp->track);
        opDisplay(outBuf);
        dp = dp->nextDisk;
        }
    }

/*---------------------------  End Of File  ------------------------------*/