execute.c

Go to the documentation of this file.

/*
 *      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.
 *
 *  Copyright 2004 Spiro Trikaliotis
*/

#include "config.h"

#include <windows.h>
#include <vddsvc.h>

#include "arch.h"

#define DBG_USERMODE

#define DBG_PROGNAME "OPENCBMVDD.DLL"

#include "debug.h"

#include "vdd.h"
#include "opencbm.h"


#define NEW_IMPLEMENTATION_WITH_SETRELEASE

/*-------------------------------------------------------------------*/
/*--------- HELPER FUNCTIONS ----------------------------------------*/

static PVOID
get_vdm_address(WORD Offset, WORD Length)
{
    PBYTE buffer;

    buffer = VdmMapFlat(getES(), Offset, getMODE());

    return buffer;
}

static VOID
release_vdm_address(WORD Offset, WORD Length, PVOID Buffer)
{
    VdmUnmapFlat(getES(), Offset, Buffer, getMODE());
}


#define retAX( _x_ )  setAX((WORD) _x_)

#define FUNC_CHECKEDBUFFERACCESS(_offset_, _length_) \
\
    BOOLEAN error; \
    PVOID buffer; \
    WORD length; \
    WORD offset; \
\
    FUNC_ENTER(); \
\
    offset = _offset_; \
    length = _length_;

#define CHECKEDBUFFERACCESS_PROLOG()  \
\
    buffer = get_vdm_address(offset, length); \
\
    if (!buffer) \
    { \
        error = TRUE; \
    } \
    else \
    { \
        int ret; \
\
        error = FALSE;

#define CHECKEDBUFFERACCESS_EPILOG() \
        release_vdm_address(offset, length, buffer); \
\
        retAX(ret); \
    } \
    FUNC_LEAVE_BOOLEAN(error);

#define CHECKEDBUFFERACCESS(_func_) \
        CHECKEDBUFFERACCESS_PROLOG(); \
        ret = _func_; \
        CHECKEDBUFFERACCESS_EPILOG();


/*-------------------------------------------------------------------*/
/*--------- DRIVER HANDLING -----------------------------------------*/

BOOLEAN
vdd_driver_open(VOID)
{
    CBM_FILE cbmfile;
    USHORT translatedhandle;
    int retValue;
 
    FUNC_ENTER();

    retValue = cbm_driver_open(&cbmfile, getDH());

    if (retValue == 0)
    {
        translatedhandle = vdd_cbmfile_store(cbmfile);
        if (translatedhandle == (WORD) -1)
        {
            cbm_driver_close(cbmfile);
            translatedhandle = -1;
        }
    }
    else
    {
        translatedhandle = -1;
    }

    setBX(translatedhandle);
    retAX(retValue ? 1 : 0);

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_driver_close(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    cbm_driver_close(HandleDevice);

    FUNC_LEAVE_BOOLEAN(FALSE);
}


BOOLEAN
vdd_get_driver_name(VOID)
{
    const char *returned_string;

    FUNC_CHECKEDBUFFERACCESS(getSI(), getCX());

    CHECKEDBUFFERACCESS_PROLOG();
    
    returned_string = cbm_get_driver_name(getDH());

    strncpy(buffer, returned_string, length);

    ret = FALSE;

    CHECKEDBUFFERACCESS_EPILOG();
}


/*-------------------------------------------------------------------*/
/*--------- BASIC I/O -----------------------------------------------*/

BOOLEAN
vdd_raw_write(CBM_FILE HandleDevice)
{
    FUNC_CHECKEDBUFFERACCESS(getSI(), getCX());

    CHECKEDBUFFERACCESS(cbm_raw_write(HandleDevice, buffer, length));
}


BOOLEAN
vdd_raw_read(CBM_FILE HandleDevice)
{
    FUNC_CHECKEDBUFFERACCESS(getSI(), getCX());

    CHECKEDBUFFERACCESS(cbm_raw_read(HandleDevice, buffer, length));
}

BOOLEAN
vdd_listen(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_listen(HandleDevice, getCH(), getCL()));

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_talk(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_talk(HandleDevice, getCH(), getCL()));

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_open(CBM_FILE HandleDevice)
{
    FUNC_CHECKEDBUFFERACCESS(getSI(), getDI());

    CHECKEDBUFFERACCESS(cbm_open(HandleDevice, getCH(), getCL(), buffer, length));
}

BOOLEAN
vdd_close(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_close(HandleDevice, getCH(), getCL()));

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_unlisten(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_unlisten(HandleDevice));

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_untalk(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_untalk(HandleDevice));

    FUNC_LEAVE_BOOLEAN(FALSE);
}


BOOLEAN
vdd_get_eoi(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_get_eoi(HandleDevice));

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_clear_eoi(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_clear_eoi(HandleDevice));

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_reset(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_reset(HandleDevice));

    FUNC_LEAVE_BOOLEAN(FALSE);
}


/*-------------------------------------------------------------------*/
/*--------- LOW-LEVEL PORT ACCESS -----------------------------------*/

BOOLEAN
vdd_pp_read(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    setAX(cbm_pp_read(HandleDevice));

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_pp_write(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    cbm_pp_write(HandleDevice, getCL());

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_iec_poll(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_iec_poll(HandleDevice));

    FUNC_LEAVE_BOOLEAN(FALSE);
}


BOOLEAN
vdd_iec_set(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    cbm_iec_set(HandleDevice, getCL());

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_iec_release(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    cbm_iec_release(HandleDevice, getCL());

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_iec_setrelease(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    cbm_iec_setrelease(HandleDevice, getCH(), getCL());

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_iec_wait(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_iec_wait(HandleDevice, getCL(), getCH()));

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_iec_get(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    retAX(cbm_iec_get(HandleDevice, getCL()));

    FUNC_LEAVE_BOOLEAN(FALSE);
}


/*-------------------------------------------------------------------*/
/*--------- HELPER FUNCTIONS ----------------------------------------*/


BOOLEAN
vdd_upload(CBM_FILE HandleDevice)
{
    FUNC_CHECKEDBUFFERACCESS(getSI(), getCX());

    CHECKEDBUFFERACCESS(cbm_upload(HandleDevice, getDH(), getDI(), buffer, length));
}

BOOLEAN
vdd_device_status(CBM_FILE HandleDevice)
{
    FUNC_CHECKEDBUFFERACCESS(getSI(), getCX());

    CHECKEDBUFFERACCESS(cbm_device_status(HandleDevice, getDH(), buffer, length));
}

BOOLEAN
vdd_exec_command(CBM_FILE HandleDevice)
{
    FUNC_CHECKEDBUFFERACCESS(getSI(), getCX());

    CHECKEDBUFFERACCESS(cbm_exec_command(HandleDevice, getDH(), buffer, length));
}

BOOLEAN
vdd_identify(CBM_FILE HandleDevice)
{
    enum cbm_devicetype_e devicetype;
    char *string;

    FUNC_CHECKEDBUFFERACCESS(getSI(), getCX());

    CHECKEDBUFFERACCESS_PROLOG();
    
    ret = cbm_identify(HandleDevice, getDH(), &devicetype, &string);

    setDI(devicetype);
    strncpy(buffer, string, length);

    CHECKEDBUFFERACCESS_EPILOG();
}

BOOLEAN
vdd_identify_xp1541(CBM_FILE HandleDevice)
{
    BOOLEAN error;
    enum cbm_devicetype_e devicetype = getDI();
    enum cbm_cabletype_e cabletype;

    FUNC_ENTER();

    devicetype = getDI();
    error = cbm_identify_xp1541(HandleDevice, getDH(),
        devicetype >= 0 ? &devicetype : NULL,
        &cabletype) ? TRUE : FALSE;

    setDI(devicetype);
    retAX(error);

    FUNC_LEAVE_BOOLEAN(error); 
}

/*-------------------------------------------------------------------*/
/*--------- FUNCTIONS FOR ACCESS IN THE I/O ADDRESS SPACE -----------*/

static CBM_FILE VddCbmFileForIoHook;

static BOOLEAN VddIoHookInstalled = FALSE;
static VDD_IO_PORTRANGE VddIoPortRange;
static VDD_IO_HANDLERS VddIoPortHandlers;

static BYTE vdd_iohook_lastwrittencontrolregister = 0xFF;


/* lpt output lines for XE cables */
#define PP_XE_ATN_OUT    0x01 
#define PP_XE_CLK_OUT    0x02 
#define PP_XE_RESET_OUT  0x04 
#define PP_XE_DATA_OUT   0x08 
#define PP_XE_OUTEOR     0x00 

/* lpt input lines for XE cables */
#define PP_XE_ATN_IN     0x10 
#define PP_XE_CLK_IN     0x20 
#define PP_XE_RESET_IN   0x40 
#define PP_XE_DATA_IN    0x80 


/* lpt output lines for XM cables */
#define PP_XM_ATN_OUT    PP_XE_ATN_OUT   
#define PP_XM_CLK_OUT    PP_XE_CLK_OUT   
#define PP_XM_DATA_OUT   PP_XE_RESET_OUT 
#define PP_XM_RESET_OUT  PP_XE_DATA_OUT  
#define PP_XM_OUTEOR     0x00            

/* lpt input lines for XM cables */
#define PP_XM_ATN_IN     PP_XE_ATN_IN   
#define PP_XM_CLK_IN     PP_XE_CLK_IN   
#define PP_XM_DATA_IN    PP_XE_RESET_IN 
#define PP_XM_RESET_IN   PP_XE_DATA_IN  


/* lpt output lines for XM cables */
#define PP_XA_ATN_OUT    PP_XM_ATN_OUT   
#define PP_XA_CLK_OUT    PP_XM_CLK_OUT   
#define PP_XA_DATA_OUT   PP_XM_DATA_OUT  
#define PP_XA_RESET_OUT  PP_XM_RESET_OUT 
#define PP_XA_OUTEOR     0x0F            

/* lpt input lines for XM cables */
#define PP_XA_ATN_IN     PP_XM_ATN_IN   
#define PP_XA_CLK_IN     PP_XM_CLK_IN   
#define PP_XA_DATA_IN    PP_XM_DATA_IN  
#define PP_XA_RESET_IN   PP_XM_RESET_IN 


static unsigned char pp_atn_out;
static unsigned char pp_clk_out;
static unsigned char pp_data_out;
static unsigned char pp_reset_out;
static unsigned char pp_outeor;

static unsigned char pp_atn_in;
static unsigned char pp_clk_in;
static unsigned char pp_data_in;
static unsigned char pp_reset_in;

/*
 The following accesses are supported:
 - +0: Data register (read and write)
 - +1: STATUS register (read only, for input)
 - +2: Control register (write only, for output)
*/

static VOID
vdd_iohook_inb(WORD iport,BYTE *data)
{
    if (iport == VddIoPortRange.First)
    {
        // read the data port (XP15x1 part)
        *data = cbm_pp_read(VddCbmFileForIoHook);
    }
    else if (iport == VddIoPortRange.First + 1)
    {
        UINT value;
        BYTE ret;

        // read the status register (for Input)
        value = cbm_iec_poll(VddCbmFileForIoHook);

        ret = 0;

        if (value & IEC_DATA)
        {
            ret |= pp_data_in;
        }
        if (value & IEC_CLOCK)
        {
            ret |= pp_clk_in;
        }
        if (value & IEC_ATN)
        {
            ret |= pp_atn_in;
        }

        // as the one line is inverted by the parallel port, behave the same
        *data = ret ^ 0x04;
    }
    else if (iport == VddIoPortRange.First + 2)
    {
        // reading the control register: Gives the last written state
        *data = vdd_iohook_lastwrittencontrolregister & 0xDF | 0xC0;
    }
    else DBG_ERROR((DBG_PREFIX "Access to unknown address %08x", iport));
}

static VOID
vdd_iohook_outb(WORD iport,BYTE data)
{
    if (iport == VddIoPortRange.First)
    {
        // write the data port (XP15x1 part)
        cbm_pp_write(VddCbmFileForIoHook, data);
    }
    else if (iport == VddIoPortRange.First + 1)
    {
        DBG_ERROR((DBG_PREFIX "Writing the status register: UNSUPPORTED!"));
    }
    else if (iport == VddIoPortRange.First + 2)
    {
        // writing the control register

#ifdef NEW_IMPLEMENTATION_WITH_SETRELEASE

        BYTE release = IEC_ATN | IEC_CLOCK | IEC_DATA | IEC_RESET;
        BYTE set = 0;

        vdd_iohook_lastwrittencontrolregister = data;

        data ^= 0x04 ^ pp_outeor;

        if (data & pp_atn_out)   { set |= IEC_ATN;   release &= ~IEC_ATN;   }
        if (data & pp_data_out)  { set |= IEC_DATA;  release &= ~IEC_DATA;  }
        if (data & pp_clk_out)   { set |= IEC_CLOCK; release &= ~IEC_CLOCK; }
        if (data & pp_reset_out) { set |= IEC_RESET; release &= ~IEC_RESET; }

 #ifdef TEST_BIDIR

        if (data & 0x10)
        {
            set |= 0x10;
        }
        else
        {
            release |= 0x10;
        }

 #endif // #ifdef TEST_BIDIR

        cbm_iec_setrelease(VddCbmFileForIoHook, set, release);

#else // #ifdef NEW_IMPLEMENTATION_WITH_SETRELEASE

        BYTE ret = data ^ vdd_iohook_lastwrittencontrolregister;

        vdd_iohook_lastwrittencontrolregister = data;

        data ^= 0x04 ^ pp_outeor;

        if (ret & pp_atn_out)
        {
            // ATN was changed
            ((data & pp_atn_out) ? cbm_iec_set : cbm_iec_release)
                (VddCbmFileForIoHook, IEC_ATN);
        }
        if (ret & pp_clk_out)
        {
            // CLOCK was changed
            ((data & pp_clk_out) ? cbm_iec_set : cbm_iec_release)
                (VddCbmFileForIoHook, IEC_CLOCK);
        }
        if (ret & pp_data_out)
        {
            // DATA was changed
            ((data & pp_data_out) ? cbm_iec_set : cbm_iec_release)
                (VddCbmFileForIoHook, IEC_DATA);
        }
        if (ret & pp_reset_out)
        {
            // RESET was changed: Only process it if it was set
            if (data & pp_reset_out)
            {
                cbm_reset(VddCbmFileForIoHook);
            }
        }

#endif // #ifdef NEW_IMPLEMENTATION_WITH_SETRELEASE

    }
    else DBG_ERROR((DBG_PREFIX "Access to unknown address %08x", iport));
}


BOOLEAN
vdd_install_iohook(CBM_FILE HandleDevice)
{
    BOOLEAN error;

    FUNC_ENTER();

    error = FALSE;

    /* assume that the hook is already installed, thus,
     * we cannot install the hook again
     */
    setAX(0);

    if (!VddIoHookInstalled)
    {
        VddIoPortRange.First = getCX();
        VddIoPortRange.Last = VddIoPortRange.First + 2;

        RtlZeroMemory(&VddIoPortHandlers, sizeof(VddIoPortHandlers));
        VddIoPortHandlers.inb_handler = vdd_iohook_inb;
        VddIoPortHandlers.outb_handler = vdd_iohook_outb;

        if (VDDInstallIOHook(vdd_handle, 1, &VddIoPortRange, &VddIoPortHandlers))
        {
            // we had success
            VddIoHookInstalled = TRUE;
            setAX(VddIoPortRange.First);

            VddCbmFileForIoHook = HandleDevice;

            // pre-occupy the variables for the cable type

            switch (getDH())
            {
            case 1: // XE cable
                pp_atn_out   = PP_XE_ATN_OUT;
                pp_clk_out   = PP_XE_CLK_OUT;
                pp_data_out  = PP_XE_DATA_OUT;
                pp_reset_out = PP_XE_RESET_OUT;
                pp_outeor    = PP_XE_OUTEOR;
                pp_atn_in    = PP_XE_ATN_IN;
                pp_clk_in    = PP_XE_CLK_IN;
                pp_data_in   = PP_XE_DATA_IN;
                pp_reset_in  = PP_XE_RESET_IN;
                break;

            case 2: // XM cable
                pp_atn_out   = PP_XM_ATN_OUT;
                pp_clk_out   = PP_XM_CLK_OUT;
                pp_data_out  = PP_XM_DATA_OUT;
                pp_reset_out = PP_XM_RESET_OUT;
                pp_outeor    = PP_XM_OUTEOR;
                pp_atn_in    = PP_XM_ATN_IN;
                pp_clk_in    = PP_XM_CLK_IN;
                pp_data_in   = PP_XM_DATA_IN;
                pp_reset_in  = PP_XM_RESET_IN;
                break;

            case 3: // XA cable
                pp_atn_out   = PP_XA_ATN_OUT;
                pp_clk_out   = PP_XA_CLK_OUT;
                pp_data_out  = PP_XA_DATA_OUT;
                pp_reset_out = PP_XA_RESET_OUT;
                pp_outeor    = PP_XA_OUTEOR;
                pp_atn_in    = PP_XA_ATN_IN;
                pp_clk_in    = PP_XA_CLK_IN;
                pp_data_in   = PP_XA_DATA_IN;
                pp_reset_in  = PP_XA_RESET_IN;
                break;

            default:
                error = TRUE;
                break;
            }
        }
    }

    FUNC_LEAVE_BOOLEAN(error);
}

USHORT
vdd_uninstall_iohook_internal(VOID)
{
    USHORT ret;

    FUNC_ENTER();

    if (VddIoHookInstalled)
    {
        VDDDeInstallIOHook(vdd_handle, 1, &VddIoPortRange);

        VddIoHookInstalled = FALSE;
        ret = VddIoPortRange.First;
    }
    else
    {
        ret = 0;
    }

    FUNC_LEAVE_USHORT(ret);
}

BOOLEAN
vdd_uninstall_iohook(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    DBG_PRINT((DBG_PREFIX "Entering vdd_uninstall_iohook"));

    setAX(vdd_uninstall_iohook_internal());

    FUNC_LEAVE_BOOLEAN(FALSE);
}

BOOLEAN
vdd_usleep(VOID)
{
    FUNC_ENTER();

    arch_usleep(getCX());

    FUNC_LEAVE_BOOLEAN(FALSE);
}