cbm.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-2005           Michael Klein <michael(dot)klein(at)puffin(dot)lb(dot)shuttle(dot)de>
 *  Copyright 2001-2005,2007-2009, 2011 Spiro Trikaliotis
 *  Copyright 2009,2011           Arnd Menge <arnd(at)jonnz(dot)de>
 *
*/

#define DBG_USERMODE

#define DBG_PROGNAME "OPENCBM.DLL"

#include "debug.h"

#include <stdlib.h>
#include <string.h>

#include "libmisc.h"

#define DLL
#include "opencbm.h"
#include "archlib.h"

#include "opencbm-plugin.h"

#include "getpluginaddress.h"

#include "configuration.h"

#include "arch.h"

int plugin_is_active(opencbm_configuration_handle Handle, const char PluginName[])
{
    char * active = NULL;
    unsigned int active_number = 1;

    FUNC_ENTER();

    do {
        char * next;

        opencbm_configuration_get_data(Handle, PluginName, "Active", &active);

        if ( ! active ) {
            break;
        }

        active_number = strtoul(active, &next, 10);
        if (next && (next[0] != 0) ) {
            DBG_WARN((DBG_PREFIX "Entry 'Active' for plugin '%' "
                "is set to the non-numerical value '%s'",
                PluginName, active));
            active_number = 1;
            break;
        }

    } while (0);

    cbmlibmisc_strfree(active);

    FUNC_LEAVE_INT(active_number);
}

int plugin_set_active(const char PluginName[])
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(0);
}


int plugin_set_inactive(const char PluginName[])
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(0);
}


struct plugin_information_s {
    SHARED_OBJECT_HANDLE Library; 
    opencbm_plugin_t     Plugin;  
};

typedef struct plugin_information_s plugin_information_t;

static
struct plugin_information_s Plugin_information = { 0 };

struct plugin_read_pointer
{
    UINT_PTR offset;
    const char * name;
};

#define OFFSETOF(_type, _element) \
    ((UINT_PTR) (void *) &((_type *)0)->_element)

#define GETELEMENT(_type, _structpointer, _elementoffset) \
    ((_type *)(((char*)(_structpointer)) + (_elementoffset)))

#define PLUGIN_POINTER_DEF(_xxx) \
    { OFFSETOF(plugin_information_t, Plugin._xxx), #_xxx }

#define PLUGIN_POINTER_GET(_what, _element) \
    GEELEMENT(void, _what, _element)

#define PLUGIN_POINTER_END() \
    { 0, NULL }

static struct plugin_read_pointer plugin_pointer_to_read_mandatory[] =
{
        PLUGIN_POINTER_DEF(opencbm_plugin_get_driver_name),
        PLUGIN_POINTER_DEF(opencbm_plugin_driver_open),
        PLUGIN_POINTER_DEF(opencbm_plugin_driver_close),
        PLUGIN_POINTER_DEF(opencbm_plugin_raw_write),
        PLUGIN_POINTER_DEF(opencbm_plugin_raw_read),
        PLUGIN_POINTER_DEF(opencbm_plugin_open),
        PLUGIN_POINTER_DEF(opencbm_plugin_close),
        PLUGIN_POINTER_DEF(opencbm_plugin_listen),
        PLUGIN_POINTER_DEF(opencbm_plugin_talk),
        PLUGIN_POINTER_DEF(opencbm_plugin_unlisten),
        PLUGIN_POINTER_DEF(opencbm_plugin_untalk),
        PLUGIN_POINTER_DEF(opencbm_plugin_get_eoi),
        PLUGIN_POINTER_DEF(opencbm_plugin_clear_eoi),
        PLUGIN_POINTER_DEF(opencbm_plugin_reset),
        PLUGIN_POINTER_DEF(opencbm_plugin_iec_poll),
        PLUGIN_POINTER_DEF(opencbm_plugin_iec_setrelease),
        PLUGIN_POINTER_DEF(opencbm_plugin_iec_wait),
    PLUGIN_POINTER_END()
}; 

static struct plugin_read_pointer plugin_pointer_to_read_optional[] =
{
    PLUGIN_POINTER_DEF(opencbm_plugin_init),
    PLUGIN_POINTER_DEF(opencbm_plugin_uninit),
        PLUGIN_POINTER_DEF(opencbm_plugin_lock),
        PLUGIN_POINTER_DEF(opencbm_plugin_unlock),
        PLUGIN_POINTER_DEF(opencbm_plugin_iec_set),
        PLUGIN_POINTER_DEF(opencbm_plugin_iec_release),
        PLUGIN_POINTER_DEF(opencbm_plugin_parallel_burst_read),
        PLUGIN_POINTER_DEF(opencbm_plugin_parallel_burst_write),
        PLUGIN_POINTER_DEF(opencbm_plugin_parallel_burst_read_track),
        PLUGIN_POINTER_DEF(opencbm_plugin_parallel_burst_write_track),
        PLUGIN_POINTER_DEF(opencbm_plugin_pp_read),
        PLUGIN_POINTER_DEF(opencbm_plugin_pp_write),
    PLUGIN_POINTER_END()
};

static struct plugin_read_pointer plugin_pointer_to_read_parallel_burst[] =
{
        PLUGIN_POINTER_DEF(opencbm_plugin_parallel_burst_read),
        PLUGIN_POINTER_DEF(opencbm_plugin_parallel_burst_write),
        PLUGIN_POINTER_DEF(opencbm_plugin_parallel_burst_read_track),
        PLUGIN_POINTER_DEF(opencbm_plugin_parallel_burst_write_track),
    PLUGIN_POINTER_END()
};

static struct plugin_read_pointer plugin_pointer_to_read_pp_readwrite[] =
{
        PLUGIN_POINTER_DEF(opencbm_plugin_pp_read),
        PLUGIN_POINTER_DEF(opencbm_plugin_pp_write),
    PLUGIN_POINTER_END()
};

static struct plugin_read_pointer plugin_pointer_to_read_srq_burst[] =
{
        PLUGIN_POINTER_DEF(opencbm_plugin_srq_burst_read ),
        PLUGIN_POINTER_DEF(opencbm_plugin_srq_burst_write),
        PLUGIN_POINTER_DEF(opencbm_plugin_srq_burst_read_track),
        PLUGIN_POINTER_DEF(opencbm_plugin_srq_burst_write_track),
    PLUGIN_POINTER_END()
};

static struct plugin_read_pointer plugin_pointer_to_read_tape[] =
{
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_prepare_capture),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_prepare_write),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_get_sense),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_wait_for_stop_sense),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_wait_for_play_sense),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_motor_on),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_motor_off),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_start_capture),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_start_write),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_get_ver),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_download_config),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_upload_config),
        PLUGIN_POINTER_DEF(opencbm_plugin_tap_break),
    PLUGIN_POINTER_END()
};


struct plugin_read_pointer_group
{
    struct plugin_read_pointer * read_pointer;
    enum {
        PRP_MANDATORY,
        PRP_OPTIONAL,
        PRP_OPTIONAL_ALL_OR_NOTHING
    } type;
};

static struct plugin_read_pointer_group read_pointer_group[] =
{
    { plugin_pointer_to_read_mandatory, PRP_MANDATORY },
    { plugin_pointer_to_read_optional, PRP_OPTIONAL },
    { plugin_pointer_to_read_parallel_burst, PRP_OPTIONAL_ALL_OR_NOTHING },
    { plugin_pointer_to_read_pp_readwrite, PRP_OPTIONAL_ALL_OR_NOTHING },
    { plugin_pointer_to_read_srq_burst, PRP_OPTIONAL_ALL_OR_NOTHING },
    { plugin_pointer_to_read_tape, PRP_OPTIONAL_ALL_OR_NOTHING },
    { NULL, PRP_OPTIONAL }
};

static void
read_plugin_pointer(
        plugin_information_t * Plugin_information,
        struct plugin_read_pointer pointer_to_read[]
)
{
    while (pointer_to_read->name) {
        void * ptr_read = plugin_get_address(Plugin_information->Library, pointer_to_read->name);
        void ** ptr_to_save = GETELEMENT(void *, Plugin_information, pointer_to_read->offset);
        *ptr_to_save = ptr_read;
        DBGDO(
            if (ptr_read == NULL) {
               DBG_PRINT((DBG_PREFIX "Plugin entry point %s not found!", pointer_to_read->name));
            }
        )
        ++pointer_to_read;
    }
}

static int check_plugin_pointer(
        plugin_information_t * Plugin_information,
        struct plugin_read_pointer pointer_to_check[]
)
{
    while (pointer_to_check->name) {
        void ** ptr_to_check = GETELEMENT(void *, Plugin_information, pointer_to_check->offset);
        DBGDO(
            if (ptr_to_check == NULL) {
               DBG_PRINT((DBG_PREFIX "Plugin entry point %s not found!", pointer_to_check->name));
            }
        )
        if (ptr_to_check == NULL) return 1;
        ++pointer_to_check;
    }
    return 0;
}

static int check_plugin_pointer_all_or_nothing(
        plugin_information_t * Plugin_information,
        struct plugin_read_pointer pointer_to_check[]
)
{
    int error;

    // first, check if all pointers are available
    error = check_plugin_pointer(Plugin_information, pointer_to_check);
    if (!error) return 0;

    // if not, check if all pointers are *not* available
    while (pointer_to_check->name) {
        void ** ptr_to_check = GETELEMENT(void *, Plugin_information, pointer_to_check->offset);
        DBGDO(
            if (ptr_to_check != NULL) {
               DBG_PRINT((DBG_PREFIX "Plugin entry point %s found, but it should not be available!", pointer_to_check->name));
            }
        )
        if (ptr_to_check != NULL) return 1;
        ++pointer_to_check;
    }
    return 0;
}

static int
read_plugin_pointer_groups(
        plugin_information_t * Plugin_information,
        struct plugin_read_pointer_group pointer_to_read_group[]
)
{
    int error = 0;

    while (pointer_to_read_group->read_pointer) {
        read_plugin_pointer(Plugin_information, pointer_to_read_group->read_pointer);

        switch (pointer_to_read_group->type) {
        case PRP_MANDATORY:
            error = error || check_plugin_pointer(Plugin_information, pointer_to_read_group->read_pointer);
            break;

        case PRP_OPTIONAL:
            break;
        case PRP_OPTIONAL_ALL_OR_NOTHING:
            error = error || check_plugin_pointer_all_or_nothing(Plugin_information, pointer_to_read_group->read_pointer);
            break;
        };

        ++pointer_to_read_group;
    }

    return error;
}

static int
initialize_plugin_pointer(plugin_information_t *Plugin_information, const char * const Adapter)
{
    int error = 1;

    const char * configurationFilename = configuration_get_default_filename();

    char * plugin_name = NULL;
    char * plugin_location = NULL;

    do {

        opencbm_configuration_handle handle_configuration;

        if (configurationFilename == NULL) {
            DBG_ERROR((DBG_PREFIX "Do not know where the plugin information is stored!\n"));
            break;
        }

        handle_configuration = opencbm_configuration_open(configurationFilename);

        if (handle_configuration)
        {
            int error = 0;

            if (Adapter == NULL)
            {
                //
                // get the name of the default plugin
                //

                error = opencbm_configuration_get_data(handle_configuration, 
                           "plugins", "default", &plugin_name);
            }
            else
            {
                //
                // Use the given plugin name
                //
                plugin_name = cbmlibmisc_strdup(Adapter);
            }

            //
            // check if the plugin has been disabled
            //

            if ( ! plugin_is_active(handle_configuration, plugin_name) ) {
                error = 1;
                break;
            }

            //
            // get the location of the plugin
            //
            if (!error)
            {
                error = opencbm_configuration_get_data(handle_configuration,
                           plugin_name, "location", &plugin_location);
            }

            //
            // if an error occurred, make sure that no plugin will be loaded!
            //
            if (error)
            {
                cbmlibmisc_strfree(plugin_location);
                plugin_location = NULL;
            }

            opencbm_configuration_close(handle_configuration);
        }
        else
        {
            DBG_ERROR((DBG_PREFIX "Cannot open config file '%s'.\n", configurationFilename));
            break;
        }
        DBG_PRINT((DBG_PREFIX "Using plugin at '%s'", plugin_location ? plugin_location : "(none)"));

        memset(&Plugin_information->Plugin, 0, sizeof(Plugin_information->Plugin));

        Plugin_information->Library = plugin_load(plugin_location);

        DBG_PRINT((DBG_PREFIX "plugin_load() returned %p", Plugin_information->Library));

        if (!Plugin_information->Library) {
            DBG_ERROR((DBG_PREFIX "Could not open plugin driver at '%s'.\n", plugin_location));
            break;
        }

        error = read_plugin_pointer_groups(Plugin_information, read_pointer_group);
        if (error) {
            DBG_ERROR((DBG_PREFIX "The entry points of plugin %s do not validate correctly.\n",
                                  plugin_location));
            break;
        }

        if (Plugin_information->Plugin.opencbm_plugin_init) {
            error = Plugin_information->Plugin.opencbm_plugin_init();
            if (error) {
                DBG_ERROR((DBG_PREFIX "Plugin %s fails to initialize itself.\n",
                            plugin_location));
                if (Plugin_information->Plugin.opencbm_plugin_uninit) {
                    Plugin_information->Plugin.opencbm_plugin_uninit();
                }
                break;
            }
        }

    } while (0);

    cbmlibmisc_strfree(plugin_name);
    cbmlibmisc_strfree(plugin_location);
    cbmlibmisc_strfree(configurationFilename);

    return error;
}

static void
uninitialize_plugin(void)
{
    if (Plugin_information.Library != NULL)
    {
        if (Plugin_information.Plugin.opencbm_plugin_uninit) {
            Plugin_information.Plugin.opencbm_plugin_uninit();
        }

        plugin_unload(Plugin_information.Library);

        Plugin_information.Library = NULL;
    }
}

static int
initialize_plugin(const char * const Adapter)
{
    /* if library is already opened and initialized correctly then 
       this function returns OK */
    int error = 0;

    /* init pointers if library was not yet opened */
    if (Plugin_information.Library == NULL)
    {
        /* if pointer init failed then close library and make Library NULL */
        error = initialize_plugin_pointer(&Plugin_information, Adapter);
        if(error != 0)
        {
            uninitialize_plugin();
        }
    }

    return error;
}

// #define DBG_DUMP_RAW_READ
// #define DBG_DUMP_RAW_WRITE

static char *
cbm_split_adapter_in_name_and_port(char * Adapter, char ** Port)
{
    char * adapter_stripped = NULL;

    *Port = NULL;

    if (Adapter) 
    {
        char *p = strchr(Adapter, ':');

        if (p)
        {
            // there was some colon (:), thus, extract portNumber and name

            adapter_stripped = cbmlibmisc_strndup(Adapter, p - Adapter);

            if (adapter_stripped != NULL) {
                if (p[1] != 0)
                {
                    *Port = cbmlibmisc_strdup(p+1);
                }
            }
        }
        else
        {
            adapter_stripped = cbmlibmisc_strdup(Adapter);
        }
    }

    if (adapter_stripped && adapter_stripped[0] == 0) {
        cbmlibmisc_strfree(adapter_stripped);
        adapter_stripped = NULL;
    }

    return adapter_stripped;
}

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

const char * CBMAPIDECL
cbm_get_driver_name_ex(char * Adapter)
{
    const char *ret = NULL;

    static const char * buffer = NULL;
    char *adapter_stripped = NULL;
    char *port = NULL;

    int error;

    FUNC_ENTER();

    if ( buffer ) {
        cbmlibmisc_strfree(buffer);
        buffer = NULL;
    }

    if (Adapter != NULL)
    {
        adapter_stripped = cbm_split_adapter_in_name_and_port(Adapter, &port);

        DBG_PRINT((DBG_PREFIX 
            (adapter_stripped == NULL 
              ? "Using default adapter"
              : "Using adapter '%s', that is, adapter '%s' with port '%s'"),
            Adapter, adapter_stripped, port));
    }

    error = initialize_plugin(adapter_stripped);

    if (error == 0) {
        ret = Plugin_information.Plugin.opencbm_plugin_get_driver_name(port);
    }
    else {
        ret = "NO PLUGIN DRIVER!";
    }

    buffer = cbmlibmisc_strdup(ret);

    cbmlibmisc_strfree(adapter_stripped);
    cbmlibmisc_strfree(port);

    FUNC_LEAVE_STRING(buffer);
}

const char * CBMAPIDECL
cbm_get_driver_name(int PortNumber)
{
    char number[] = ":0";

    FUNC_ENTER();

    if (PortNumber >= 0 && PortNumber < 10) {
        number[1] = PortNumber + '0';
    }

    FUNC_LEAVE_STRING(cbm_get_driver_name_ex(number));
}

int CBMAPIDECL 
cbm_driver_open_ex(CBM_FILE *HandleDevice, char * Adapter)
{
    int error;
    char * port = NULL;
    char * adapter_stripped = NULL;

    FUNC_ENTER();

    DBG_PRINT((DBG_PREFIX "cbm_driver_open_ex() called"));

    if (Adapter != NULL)
    {
        adapter_stripped = cbm_split_adapter_in_name_and_port(Adapter, &port);

        DBG_PRINT((DBG_PREFIX "Using adapter '%s', that is, adapter '%s' with port '%s'",
            Adapter, adapter_stripped, port));
    }

    error = initialize_plugin(adapter_stripped);

    cbmlibmisc_strfree(adapter_stripped);

    if (error == 0) {
        error = Plugin_information.Plugin.opencbm_plugin_driver_open(HandleDevice, port);
    }

    cbmlibmisc_strfree(port);

    FUNC_LEAVE_INT(error);
}

int CBMAPIDECL 
cbm_driver_open(CBM_FILE *HandleDevice, int PortNumber)
{
    char number[] = ":0";

    FUNC_ENTER();

    if (PortNumber >= 0 && PortNumber < 10) {
        number[1] = PortNumber + '0';
    }

    FUNC_LEAVE_INT(cbm_driver_open_ex(HandleDevice, number));
}

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

    Plugin_information.Plugin.opencbm_plugin_driver_close(HandleDevice);

    uninitialize_plugin();

    FUNC_LEAVE();
}

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

    if (Plugin_information.Plugin.opencbm_plugin_lock)
        Plugin_information.Plugin.opencbm_plugin_lock(HandleDevice);

    FUNC_LEAVE();
}

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

    if (Plugin_information.Plugin.opencbm_plugin_unlock)
        Plugin_information.Plugin.opencbm_plugin_unlock(HandleDevice);

    FUNC_LEAVE();
}

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

int CBMAPIDECL 
cbm_raw_write(CBM_FILE HandleDevice, const void *Buffer, size_t Count)
{
    FUNC_ENTER();

#ifdef DBG_DUMP_RAW_WRITE
    DBG_MEMDUMP("cbm_raw_write", Buffer, Count);
#endif

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_raw_write(HandleDevice,Buffer, Count));
}


int CBMAPIDECL 
cbm_raw_read(CBM_FILE HandleDevice, void *Buffer, size_t Count)
{
    int bytesRead = 0;

    FUNC_ENTER();

    bytesRead = Plugin_information.Plugin.opencbm_plugin_raw_read(HandleDevice, Buffer, Count);

#ifdef DBG_DUMP_RAW_READ
    DBG_MEMDUMP("cbm_raw_read", Buffer, bytesRead);
#endif

    FUNC_LEAVE_INT(bytesRead);
}

int CBMAPIDECL 
cbm_listen(CBM_FILE HandleDevice, unsigned char DeviceAddress, unsigned char SecondaryAddress)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_listen(HandleDevice, DeviceAddress, SecondaryAddress));
}

int CBMAPIDECL 
cbm_talk(CBM_FILE HandleDevice, unsigned char DeviceAddress, unsigned char SecondaryAddress)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_talk(HandleDevice, DeviceAddress, SecondaryAddress));
}

int CBMAPIDECL 
cbm_open(CBM_FILE HandleDevice, unsigned char DeviceAddress, unsigned char SecondaryAddress, 
         const void *Filename, size_t FilenameLength)
{
    int returnValue;

    FUNC_ENTER();

    returnValue = Plugin_information.Plugin.opencbm_plugin_open(HandleDevice, DeviceAddress, SecondaryAddress);

    if (returnValue == 0)
    {
        returnValue = 0;

        if(Filename != NULL)
        {
            if (FilenameLength == 0)
            {
                DBG_WARN((DBG_PREFIX "*** FilenameLength of 0 encountered!"));
                FilenameLength = strlen(Filename);
            }

            if (FilenameLength > 0)
            {
                returnValue = 
                    (size_t) (cbm_raw_write(HandleDevice, Filename, FilenameLength))
                    != FilenameLength;
            }
            cbm_unlisten(HandleDevice);
        }
    }
    else
    {
        returnValue = -1;
    }

    FUNC_LEAVE_INT(returnValue);
}

int CBMAPIDECL
cbm_close(CBM_FILE HandleDevice, unsigned char DeviceAddress, unsigned char SecondaryAddress)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_close(HandleDevice, DeviceAddress, SecondaryAddress));
}

int CBMAPIDECL
cbm_unlisten(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_unlisten(HandleDevice));
}

int CBMAPIDECL
cbm_untalk(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_untalk(HandleDevice));
}


int CBMAPIDECL 
cbm_get_eoi(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_get_eoi(HandleDevice));
}

int CBMAPIDECL 
cbm_clear_eoi(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_clear_eoi(HandleDevice));
}

int CBMAPIDECL
cbm_reset(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_reset(HandleDevice));
}


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

unsigned char CBMAPIDECL 
cbm_pp_read(CBM_FILE HandleDevice)
{
    unsigned char ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_pp_read)
        ret = Plugin_information.Plugin.opencbm_plugin_pp_read(HandleDevice);

    FUNC_LEAVE_UCHAR(ret);
}

void CBMAPIDECL 
cbm_pp_write(CBM_FILE HandleDevice, unsigned char Byte)
{
    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_pp_write)
        Plugin_information.Plugin.opencbm_plugin_pp_write(HandleDevice, Byte);

    FUNC_LEAVE();
}

int CBMAPIDECL
cbm_iec_poll(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_iec_poll(HandleDevice));
}


void CBMAPIDECL
cbm_iec_set(CBM_FILE HandleDevice, int Line)
{
    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_iec_set)
        Plugin_information.Plugin.opencbm_plugin_iec_set(HandleDevice, Line);
    else
        Plugin_information.Plugin.opencbm_plugin_iec_setrelease(HandleDevice, Line, 0);

    FUNC_LEAVE();
}

void CBMAPIDECL
cbm_iec_release(CBM_FILE HandleDevice, int Line)
{
    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_iec_release)
        Plugin_information.Plugin.opencbm_plugin_iec_release(HandleDevice, Line);
    else
        Plugin_information.Plugin.opencbm_plugin_iec_setrelease(HandleDevice, 0, Line);

    FUNC_LEAVE();
}

void CBMAPIDECL
cbm_iec_setrelease(CBM_FILE HandleDevice, int Set, int Release)
{
    FUNC_ENTER();

    Plugin_information.Plugin.opencbm_plugin_iec_setrelease(HandleDevice, Set, Release);

    FUNC_LEAVE();
}

int CBMAPIDECL
cbm_iec_wait(CBM_FILE HandleDevice, int Line, int State)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT(Plugin_information.Plugin.opencbm_plugin_iec_wait(HandleDevice, Line, State));
}

int CBMAPIDECL
cbm_iec_get(CBM_FILE HandleDevice, int Line)
{
    FUNC_ENTER();

    FUNC_LEAVE_INT((Plugin_information.Plugin.opencbm_plugin_iec_poll(HandleDevice)&Line) != 0 ? 1 : 0);
}


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


int CBMAPIDECL
cbm_device_status(CBM_FILE HandleDevice, unsigned char DeviceAddress, 
                  void *Buffer, size_t BufferLength)
{
    int retValue;

    FUNC_ENTER();

    DBG_ASSERT(Buffer && (BufferLength > 0));

    // Pre-occupy return value

    retValue = 99;

    if (Buffer && (BufferLength > 0))
    {
        char *bufferToWrite = Buffer;

        // make sure we have a trailing zero at the end of the buffer:

        bufferToWrite[--BufferLength] = '\0';

        // pre-occupy buffer with the error value

        strncpy(bufferToWrite, "99, DRIVER ERROR,00,00\r", BufferLength);

        // Now, ask the drive for its error status:

        if (cbm_talk(HandleDevice, DeviceAddress, 15) == 0)
        {
            unsigned int bytesRead;
            
            bytesRead = cbm_raw_read(HandleDevice, bufferToWrite, BufferLength - 1);

            DBG_ASSERT(bytesRead <= BufferLength);

            // make sure we have a trailing zero at the end of the status:

            bufferToWrite[bytesRead] = '\0';

            cbm_untalk(HandleDevice);
        }

        retValue = atoi(bufferToWrite);
    }

    FUNC_LEAVE_INT(retValue);
}

int CBMAPIDECL
cbm_exec_command(CBM_FILE HandleDevice, unsigned char DeviceAddress, 
                 const void *Command, size_t Size)
{
    int rv;

    FUNC_ENTER();
    rv = cbm_listen(HandleDevice, DeviceAddress, 15);
    if(rv == 0) {
        if(Size == 0) {
            Size = (size_t) strlen(Command);
        }
        rv = (size_t) cbm_raw_write(HandleDevice, Command, Size) != Size;
        cbm_unlisten(HandleDevice);
    }

    FUNC_LEAVE_INT(rv);
}

unsigned char CBMAPIDECL
cbm_parallel_burst_read(CBM_FILE HandleDevice)
{
    unsigned char ret = 0;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_parallel_burst_read)
        ret = Plugin_information.Plugin.opencbm_plugin_parallel_burst_read(HandleDevice);

    FUNC_LEAVE_UCHAR(ret);
}

void CBMAPIDECL
cbm_parallel_burst_write(CBM_FILE HandleDevice, unsigned char Value)
{
    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_parallel_burst_write)
        Plugin_information.Plugin.opencbm_plugin_parallel_burst_write(HandleDevice, Value);

    FUNC_LEAVE();
}

int CBMAPIDECL
cbm_parallel_burst_read_n(CBM_FILE HandleDevice, unsigned char *Buffer,
    unsigned int Length)
{
    unsigned int i;
    int rv;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_parallel_burst_read_n) {
        rv = Plugin_information.Plugin.opencbm_plugin_parallel_burst_read_n(
            HandleDevice, Buffer, Length);
    } else {
        for (i = 0; i < Length; i++) {
            Buffer[i] = Plugin_information.Plugin
                .opencbm_plugin_parallel_burst_read(HandleDevice);
        }
        rv = Length;
    }

    FUNC_LEAVE_INT(rv);
}

int CBMAPIDECL
cbm_parallel_burst_write_n(CBM_FILE HandleDevice, unsigned char *Buffer,
    unsigned int Length)
{
    unsigned int i;
    int rv;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_parallel_burst_write_n) {
        rv = Plugin_information.Plugin.opencbm_plugin_parallel_burst_write_n(
            HandleDevice, Buffer, Length);
    } else {
        for (i = 0; i < Length; i++) {
            Plugin_information.Plugin.opencbm_plugin_parallel_burst_write(
                HandleDevice, Buffer[i]);
        }
        rv = Length;
    }

    FUNC_LEAVE_INT(rv);
}

int CBMAPIDECL
cbm_parallel_burst_read_track(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Length)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_parallel_burst_read_track)
        ret = Plugin_information.Plugin.opencbm_plugin_parallel_burst_read_track(HandleDevice, Buffer, Length);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_parallel_burst_read_track_var(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Length)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_parallel_burst_read_track)
        ret = Plugin_information.Plugin.opencbm_plugin_parallel_burst_read_track_var(HandleDevice, Buffer, Length);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_parallel_burst_write_track(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Length)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_parallel_burst_write_track)
        ret = Plugin_information.Plugin.opencbm_plugin_parallel_burst_write_track(HandleDevice, Buffer, Length);

    FUNC_LEAVE_INT(ret);
}

unsigned char CBMAPIDECL
cbm_srq_burst_read(CBM_FILE HandleDevice)
{
    unsigned char ret = 0;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_srq_burst_read)
        ret = Plugin_information.Plugin.opencbm_plugin_srq_burst_read(HandleDevice);

    FUNC_LEAVE_UCHAR(ret);
}

void CBMAPIDECL
cbm_srq_burst_write(CBM_FILE HandleDevice, unsigned char Value)
{
    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_srq_burst_write)
        Plugin_information.Plugin.opencbm_plugin_srq_burst_write(HandleDevice, Value);

    FUNC_LEAVE();
}

int CBMAPIDECL
cbm_srq_burst_read_n(CBM_FILE HandleDevice, unsigned char *Buffer,
    unsigned int Length)
{
    unsigned int i;
    int rv;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_srq_burst_read_n) {
        rv = Plugin_information.Plugin.opencbm_plugin_srq_burst_read_n(
            HandleDevice, Buffer, Length);
    } else {
        for (i = 0; i < Length; i++) {
            Buffer[i] = Plugin_information.Plugin
                .opencbm_plugin_srq_burst_read(HandleDevice);
        }
        rv = Length;
    }

    FUNC_LEAVE_INT(rv);
}

int CBMAPIDECL
cbm_srq_burst_write_n(CBM_FILE HandleDevice, unsigned char *Buffer,
    unsigned int Length)
{
    unsigned int i;
    int rv;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_srq_burst_write_n) {
        rv = Plugin_information.Plugin.opencbm_plugin_srq_burst_write_n(
            HandleDevice, Buffer, Length);
    } else {
        for (i = 0; i < Length; i++) {
            Plugin_information.Plugin.opencbm_plugin_srq_burst_write(
                HandleDevice, Buffer[i]);
        }
        rv = Length;
    }

    FUNC_LEAVE_INT(rv);
}

int CBMAPIDECL
cbm_srq_burst_read_track(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Length)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_srq_burst_read_track)
        ret = Plugin_information.Plugin.opencbm_plugin_srq_burst_read_track(HandleDevice, Buffer, Length);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_srq_burst_write_track(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Length)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_srq_burst_write_track)
        ret = Plugin_information.Plugin.opencbm_plugin_srq_burst_write_track(HandleDevice, Buffer, Length);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_prepare_capture(CBM_FILE HandleDevice, int *Status)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_prepare_capture)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_prepare_capture(HandleDevice, Status);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_prepare_write(CBM_FILE HandleDevice, int *Status)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_prepare_write)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_prepare_write(HandleDevice, Status);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_get_sense(CBM_FILE HandleDevice, int *Status)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_get_sense)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_get_sense(HandleDevice, Status);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_wait_for_stop_sense(CBM_FILE HandleDevice, int *Status)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_wait_for_stop_sense)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_wait_for_stop_sense(HandleDevice, Status);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_wait_for_play_sense(CBM_FILE HandleDevice, int *Status)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_wait_for_play_sense)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_wait_for_play_sense(HandleDevice, Status);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_motor_on(CBM_FILE HandleDevice, int *Status)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_motor_on)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_motor_on(HandleDevice, Status);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_motor_off(CBM_FILE HandleDevice, int *Status)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_motor_off)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_motor_off(HandleDevice, Status);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_start_capture(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Buffer_Length, int *Status, int *BytesRead)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_start_capture)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_start_capture(HandleDevice, Buffer, Buffer_Length, Status, BytesRead);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_start_write(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Length, int *Status, int *BytesWritten)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_start_write)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_start_write(HandleDevice, Buffer, Length, Status, BytesWritten);

    FUNC_LEAVE_INT(ret);
}


int CBMAPIDECL
cbm_tap_get_ver(CBM_FILE HandleDevice, int *Status)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_get_ver)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_get_ver(HandleDevice, Status);

    FUNC_LEAVE_INT(ret);
}


int CBMAPIDECL
cbm_tap_break(CBM_FILE HandleDevice)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_break)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_break(HandleDevice);

    FUNC_LEAVE_INT(ret);
}


int CBMAPIDECL
cbm_tap_download_config(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Buffer_Length, int *Status, int *BytesRead)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_download_config)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_download_config(HandleDevice, Buffer, Buffer_Length, Status, BytesRead);

    FUNC_LEAVE_INT(ret);
}

int CBMAPIDECL
cbm_tap_upload_config(CBM_FILE HandleDevice, unsigned char *Buffer, unsigned int Length, int *Status, int *BytesWritten)
{
    int ret = -1;

    FUNC_ENTER();

    if (Plugin_information.Plugin.opencbm_plugin_tap_upload_config)
        ret = Plugin_information.Plugin.opencbm_plugin_tap_upload_config(HandleDevice, Buffer, Length, Status, BytesWritten);

    FUNC_LEAVE_INT(ret);
}


void * CBMAPIDECL
cbm_get_plugin_function_address(const char * Functionname)
{
    void * pointer = NULL;

    FUNC_ENTER();

    if (Plugin_information.Library)
        pointer = plugin_get_address(Plugin_information.Library, Functionname);

    FUNC_LEAVE_PTR(pointer, void*);
}

int CBMAPIDECL
cbm_iec_dbg_read(CBM_FILE HandleDevice)
{
    int returnValue = -1;

    FUNC_ENTER();

    if ( Plugin_information.Plugin.opencbm_plugin_iec_dbg_read ) {
        returnValue = Plugin_information.Plugin.opencbm_plugin_iec_dbg_read(HandleDevice);
    }

    FUNC_LEAVE_INT(returnValue);
}

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

    FUNC_ENTER();

    if ( Plugin_information.Plugin.opencbm_plugin_iec_dbg_write ) {
        returnValue = Plugin_information.Plugin.opencbm_plugin_iec_dbg_write(HandleDevice, Value);
    }

    FUNC_LEAVE_INT(returnValue);
}