WINDOWS/iec.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 1999-2001 Michael Klein <michael(dot)klein(at)puffin(dot)lb(dot)shuttle(dot)de>
 *  Copyright 2001-2005,2007-2010 Spiro Trikaliotis
 *
*/

#include <windows.h>
#include <windowsx.h>

#include <mmsystem.h>

#define DBG_USERMODE

#define DBG_DLL

#define DBG_PROGNAME "OPENCBM.DLL"

#define DBG_IS_DEBUG_C

#include "debug.h"

#include <winioctl.h>
#include "cbmioctl.h"

#include <stdlib.h>

#define DLL
#include "i_opencbm.h"

#define OPENCBM_PLUGIN
#include "archlib.h"


static void
fastschedule_start(void)
{
    FUNC_ENTER();

    if (timeBeginPeriod(1) != TIMERR_NOERROR)
    {
        DBG_WARN((DBG_PREFIX "Unable to decrease scheduling period."));
    }

    FUNC_LEAVE();
}

static void
fastschedule_stop(void)
{
    FUNC_ENTER();

    if (timeEndPeriod(1) != TIMERR_NOERROR)
    {
        DBG_WARN((DBG_PREFIX "Unable to restore scheduling period."));
    }

    FUNC_LEAVE();
}


BOOL WINAPI
DllMain(IN HANDLE Module, IN DWORD Reason, IN LPVOID Reserved)
{
    static BOOL bIsOpen = FALSE;
    BOOLEAN Status = TRUE;

    FUNC_ENTER();

#if DBG

    if (Reason == DLL_PROCESS_ATTACH)
    {
        // Read the debugging flags from the registry

        cbm_get_debugging_flags("xa1541");
    }

#endif

    /* make sure the definitions in opencbm.h and cbmioctl.h
     * match each other! 
     * Since we are the only instance which includes both files,
     * we are the only one which can ensure this.
     */

    DBG_ASSERT(IEC_LINE_CLOCK == IEC_CLOCK);
    DBG_ASSERT(IEC_LINE_RESET == IEC_RESET);
    DBG_ASSERT(IEC_LINE_DATA == IEC_DATA);
    DBG_ASSERT(IEC_LINE_ATN == IEC_ATN);

    switch (Reason) 
    {
        case DLL_PROCESS_ATTACH:

            if (IsDriverStartedAutomatically())
            {
                // the driver is started automatically, do not try
                // to start it

                Status = TRUE;
            }
            else
            {
                if (bIsOpen)
                {
                    DBG_ERROR((DBG_PREFIX "No multiple instances are allowed!"));
                    Status = FALSE;
                }
                else
                {
                    Status  = TRUE;
                    bIsOpen = cbm_driver_start();
                }
            }

            WaitForIoCompletionInit();

            /* If the DLL loaded successfully, ask for fast scheduling */
            if (Status)
            {
                fastschedule_start();
            }
            break;

        case DLL_PROCESS_DETACH:

            if (IsDriverStartedAutomatically())
            {
                // the driver is started automatically, do not try
                // to stop it

                Status = TRUE;
            }
            else
            {
                if (!bIsOpen)
                {
                    DBG_ERROR((DBG_PREFIX "Driver is not running!"));
                    Status = FALSE;
                }
                else
                {
                    // it is arguable if the driver should be stopped
                    // whenever the DLL is unloaded.

                    cbm_driver_stop();
                    bIsOpen = FALSE;
                }
            }

            /* If the DLL unloaded successfully, we do not need fast scheduling anymore. */
            if (Status)
            {
                fastschedule_stop();
            }

            WaitForIoCompletionDeinit();
            break;

        default:
            break;

    }

    FUNC_LEAVE_BOOL(Status);
}

void CBMAPIDECL
opencbm_plugin_lock(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    cbm_ioctl(HandleDevice, CBMCTRL(PARPORT_LOCK), NULL, 0, NULL, 0);

    FUNC_LEAVE();
}

void CBMAPIDECL
opencbm_plugin_unlock(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    cbm_ioctl(HandleDevice, CBMCTRL(PARPORT_UNLOCK), NULL, 0, NULL, 0);

    FUNC_LEAVE();
}

int CBMAPIDECL
opencbm_plugin_raw_write(CBM_FILE HandleDevice, const void *Buffer, size_t Count)
{
    DWORD BytesWritten;
    OVERLAPPED overlapped;
    BOOL result;

    FUNC_ENTER();

    WaitForIoCompletionConstruct(&overlapped);

    result = WriteFile(
        HandleDevice,
        Buffer,
        Count,
        &BytesWritten,
        &overlapped
        );

    WaitForIoCompletion(result, HandleDevice, &overlapped, &BytesWritten);

    FUNC_LEAVE_INT(BytesWritten);
}

int CBMAPIDECL
opencbm_plugin_raw_read(CBM_FILE HandleDevice, void *Buffer, size_t Count)
{
    DWORD bytesToRead = Count;
    DWORD bytesRead;

    OVERLAPPED overlapped;
    BOOL result;

    FUNC_ENTER();

    WaitForIoCompletionConstruct(&overlapped);

    result = ReadFile(
        HandleDevice,
        Buffer,
        bytesToRead,
        &bytesRead,
        &overlapped
        );

    WaitForIoCompletion(result, HandleDevice, &overlapped, &bytesRead);

    FUNC_LEAVE_INT(bytesRead);
}



int CBMAPIDECL
opencbm_plugin_listen(CBM_FILE HandleDevice, unsigned char DeviceAddress, unsigned char SecondaryAddress)
{
    CBMT_LISTEN_IN parameter;
    int returnValue;

    FUNC_ENTER();

    parameter.PrimaryAddress = DeviceAddress;
    parameter.SecondaryAddress = SecondaryAddress;

    returnValue = cbm_ioctl(HandleDevice, CBMCTRL(LISTEN), &parameter, sizeof(parameter), NULL, 0)
        ? 0 : 1;

    FUNC_LEAVE_INT(returnValue);
}

int CBMAPIDECL
opencbm_plugin_talk(CBM_FILE HandleDevice, unsigned char DeviceAddress, unsigned char SecondaryAddress)
{
    CBMT_TALK_IN parameter;
    int returnValue;

    FUNC_ENTER();

    parameter.PrimaryAddress = DeviceAddress;
    parameter.SecondaryAddress = SecondaryAddress;

    returnValue = cbm_ioctl(HandleDevice, CBMCTRL(TALK), &parameter, sizeof(parameter), NULL, 0)
        ? 0 : 1;

    FUNC_LEAVE_INT(returnValue);
}

int CBMAPIDECL
opencbm_plugin_open(CBM_FILE HandleDevice, unsigned char DeviceAddress, unsigned char SecondaryAddress)
{
    CBMT_OPEN_IN parameter;
    int returnValue;

    FUNC_ENTER();

    parameter.PrimaryAddress = DeviceAddress;
    parameter.SecondaryAddress = SecondaryAddress;

    if (cbm_ioctl(HandleDevice, CBMCTRL(OPEN), &parameter, sizeof(parameter), NULL, 0))
    {
        returnValue = 0;
    }
    else
    {
        returnValue = -1;
    }

    FUNC_LEAVE_INT(returnValue);
}

int CBMAPIDECL
opencbm_plugin_close(CBM_FILE HandleDevice, unsigned char DeviceAddress, unsigned char SecondaryAddress)
{
    CBMT_CLOSE_IN parameter;
    int returnValue;

    FUNC_ENTER();

    parameter.PrimaryAddress = DeviceAddress;
    parameter.SecondaryAddress = SecondaryAddress;

    returnValue = 
        cbm_ioctl(HandleDevice, CBMCTRL(CLOSE), &parameter, sizeof(parameter), NULL, 0)
        ? 0 : 1;

    FUNC_LEAVE_INT(returnValue);
}

int CBMAPIDECL
opencbm_plugin_unlisten(CBM_FILE HandleDevice)
{
    int returnValue;

    FUNC_ENTER();

    returnValue = cbm_ioctl(HandleDevice, CBMCTRL(UNLISTEN), NULL, 0, NULL, 0) ? 0 : 1;

    FUNC_LEAVE_INT(returnValue);
}

int CBMAPIDECL
opencbm_plugin_untalk(CBM_FILE HandleDevice)
{
    int returnValue;

    FUNC_ENTER();

    returnValue = cbm_ioctl(HandleDevice, CBMCTRL(UNTALK), NULL, 0, NULL, 0) ? 0 : 1;

    FUNC_LEAVE_INT(returnValue);
}


int CBMAPIDECL
opencbm_plugin_get_eoi(CBM_FILE HandleDevice)
{
    CBMT_GET_EOI_OUT result;

    FUNC_ENTER();

    cbm_ioctl(HandleDevice, CBMCTRL(GET_EOI), NULL, 0, &result, sizeof(result));

    FUNC_LEAVE_INT(result.Decision);
}

int CBMAPIDECL
opencbm_plugin_clear_eoi(CBM_FILE HandleDevice)
{
    int returnValue;

    FUNC_ENTER();

    returnValue = cbm_ioctl(HandleDevice, CBMCTRL(CLEAR_EOI), NULL, 0, NULL, 0);

    FUNC_LEAVE_INT(returnValue);
}

int CBMAPIDECL
opencbm_plugin_reset(CBM_FILE HandleDevice)
{
    USHORT returnValue;

    FUNC_ENTER();

    //
    // try to cancel any pending io operations.
    //
    WaitForIoCompletionCancelAll();

    returnValue = cbm_ioctl(HandleDevice, CBMCTRL(RESET), NULL, 0, NULL, 0) ? 0 : 1;

    FUNC_LEAVE_INT(returnValue);
}


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

unsigned char CBMAPIDECL
opencbm_plugin_pp_read(CBM_FILE HandleDevice)
{
    CBMT_PP_READ_OUT result;

    FUNC_ENTER();

    cbm_ioctl(HandleDevice, CBMCTRL(PP_READ), NULL, 0, &result, sizeof(result));

    FUNC_LEAVE_UCHAR(result.Byte);
}

void CBMAPIDECL
opencbm_plugin_pp_write(CBM_FILE HandleDevice, unsigned char Byte)
{
    CBMT_PP_WRITE_IN parameter;

    FUNC_ENTER();

    parameter.Byte = Byte;

    cbm_ioctl(HandleDevice, CBMCTRL(PP_WRITE), &parameter, sizeof(parameter), NULL, 0);

    FUNC_LEAVE();
}

int CBMAPIDECL
opencbm_plugin_iec_poll(CBM_FILE HandleDevice)
{
    CBMT_IEC_POLL_OUT result;

    FUNC_ENTER();

    cbm_ioctl(HandleDevice, CBMCTRL(IEC_POLL), NULL, 0, &result, sizeof(result));

    FUNC_LEAVE_INT(result.Line);
}


void CBMAPIDECL
opencbm_plugin_iec_set(CBM_FILE HandleDevice, int Line)
{
    CBMT_IEC_SET_IN parameter;

    FUNC_ENTER();
 
    parameter.Line = (UCHAR) Line;

    cbm_ioctl(HandleDevice, CBMCTRL(IEC_SET), &parameter, sizeof(parameter), NULL, 0);

    FUNC_LEAVE();
}

void CBMAPIDECL
opencbm_plugin_iec_release(CBM_FILE HandleDevice, int Line)
{
    CBMT_IEC_RELEASE_IN parameter;

    FUNC_ENTER();

    parameter.Line = (UCHAR) Line;

    cbm_ioctl(HandleDevice, CBMCTRL(IEC_RELEASE), &parameter, sizeof(parameter), NULL, 0);

    FUNC_LEAVE();
}

void CBMAPIDECL
opencbm_plugin_iec_setrelease(CBM_FILE HandleDevice, int Set, int Release)
{
    CBMT_IEC_SETRELEASE_IN parameter;

    FUNC_ENTER();
 
    parameter.State = (UCHAR) Set;
    parameter.Line = (UCHAR) Release;

    cbm_ioctl(HandleDevice, CBMCTRL(IEC_SETRELEASE), &parameter, sizeof(parameter), NULL, 0);

    FUNC_LEAVE();
}

int CBMAPIDECL
opencbm_plugin_iec_wait(CBM_FILE HandleDevice, int Line, int State)
{
    CBMT_IEC_WAIT_IN parameter;
    CBMT_IEC_WAIT_OUT result;

    FUNC_ENTER();

    parameter.Line = (UCHAR) Line;
    parameter.State = (UCHAR) State;

    cbm_ioctl(HandleDevice, CBMCTRL(IEC_WAIT), 
        &parameter, sizeof(parameter), 
        &result, sizeof(result));

    FUNC_LEAVE_INT(result.Line);
}

#if DBG

int CBMAPIDECL
cbm_get_debugging_buffer(CBM_FILE HandleDevice, char *buffer, size_t len)
{
    FUNC_ENTER();

    cbm_ioctl(HandleDevice, CBMCTRL(I_READDBG), NULL, 0, buffer, len);

    FUNC_LEAVE_INT(0);
}

#endif // #if DBG

int CBMAPIDECL
opencbm_plugin_iec_dbg_read(CBM_FILE HandleDevice)
{
    CBMT_IEC_DBG_READ result;
    int returnValue = -1;

    FUNC_ENTER();

    if ( cbm_ioctl(HandleDevice, CBMCTRL(IEC_DBG_READ), NULL, 0, &result, sizeof(result)) ) {
        returnValue = result.Value;
    }

    FUNC_LEAVE_INT(returnValue);
}

int CBMAPIDECL
opencbm_plugin_iec_dbg_write(CBM_FILE HandleDevice, unsigned char Value)
{
    CBMT_IEC_DBG_WRITE parameter;
    int returnValue = -1;

    FUNC_ENTER();

    parameter.Value = Value;

    if ( cbm_ioctl(HandleDevice, CBMCTRL(IEC_DBG_WRITE), &parameter, sizeof(parameter), NULL, 0) ) {
        returnValue = 0;
    }

    FUNC_LEAVE_INT(returnValue);
}