URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [utils/] [amd-udi/] [udi/] [dos386c.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/******************************************************************************
 * Copyright 1991 Advanced Micro Devices, Inc.
 *
 * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
 * specifically  grants the user the right to modify, use and distribute this
 * software provided this notice is not removed or altered.  All other rights
 * are reserved by AMD.
 *
 * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
 * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
 * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
 * USE OF THIS SOFTWARE.
 *
 * Comments about this software should be directed to udi@amd.com. If access
 * to electronic mail isn't available, send mail to:
 *
 * Advanced Micro Devices, Inc.
 * 29K Support Products
 * Mail Stop 573
 * 5900 E. Ben White Blvd.
 * Austin, TX 78741
 *****************************************************************************
 *       $Id: dos386c.c,v 1.1.1.1 2002-01-16 10:26:06 markom Exp $
 *       $Id: @(#)dos386c.c     1.9, AMD
 */
 
/* DOS386 specific constructs and functions.  These assume the use of
 * the 386|DOS-Extender from Pharlap.
 *
 * This file contains functions which serve as an intermediate between
 * protected mode UDI function calls made by the DFE and the possibly
 * real-mode function called in the TIP.  These functions assume that
 * the interface between the TIP and the DFE is real-mode and that the
 * DFE is protected mode, flat model (32 bit linear addresses).
 *
 * Note:
 * This code allocates a section of real-mode memory using
 * a call to _dx_real_alloc.  Protected mode far pointers (48-bit)
 * must be used to access this memory area.
 *
 * For every UDI function named UDIx..x, there is a function in this
 * module named UDIPx..x, where the "P" indicates that this is a protected
 * mode interface function.  A protected mode DFE needs to call the
 * UDIPx..x equivalent of the call to the TIP UDI function.  The call
 * parameters are the same as the UDI call except that the address of the
 * TIP UDI function is always the first parameter to the UDIPx..x
 * function.
 *
 * Each function follows the format outlined below:
 *
 * UDIError UDIPx..x(REALPTR function_address [, UDI function parameters])
 * {
 *      Allocate pointers into the conventional memory area used for
 *              parameter passing (PPM) for all parameters which are
 *              passed-by-reference.  Each of these pointers is given
 *              the same name as a parameter with "Ptr" appended to it.
 *
 *      Create a packed structure for parameter passing if there is more
 *              than one parameter to the function.  Each member of this
 *              structure (always named params) has the same name as the
 *              corresponding parameter to the UDIP... call.
 *
 *      Set the parameter pointers to the appropriate offsets in the PPM.
 *              The protected mode pointer to the first parameter is always
 *              rm_address (the real mode equivalent to this pointer is
 *              rm_buffer_addr).
 *
 *      Copy the data from protected mode (possibly extended) memory to
 *              the location indicated by the correct pointer
 *
 *      Copy the passed-by-value parameters directly into the params
 *              structure.  Convert the protected mode version of the
 *              pointers into the PPM area to real-mode pointers and
 *              assign them to their corresponding params data member.
 *
 *      Call the real-mode function, pushing the params structure onto
 *              the stack.  Generally this involves the use of the macro
 *              REALCALL, however functions with no parameters call
 *              _dx_call_real explicitly.  The size of the params structure
 *              is determined by the macro WORDSIZE.
 *
 *      Check for an error returned from _dx_call_real.  If there is one
 *              report it and die (how uncouth!).
 *
 *      Copy all "out" parameters into their local (non-conventional
 *              memory eqivalents.  In functions with "count" parameters,
 *              make sure that the count value makes sense and only
 *              copy as much as is allowed by the buffer size.
 *
 *      The return value of the UDI TIP function is in the ax register of
 *              the regs structure, return this as the value of the UDIP
 *              function.
 * }
 *
 *
 * UDIPRead, UDIPWrite, UDIPPutStdOut, UDIPGetStdOut,
 * UDIPGetStderr, UDIPPutTrans and UDIPGetTrans differ from the other
 * UDIP functions in that they allow looping within the UDIP layer
 * call to the TIP.  This looping is done so that the size of the
 * real mode buffer area does not limit the size of the data transfer
 * since all data passed by reference *must* be copied into the real
 * mode buffer area and the TIP can only return as much information
 * as can fit in this real mode buffer (unlike the situation for a
 * real mode DFE where the DFE and the TIP write to the same memory).
 *
 * The calls all use the same logic, outlined below:
 *
 *
 * Set the CurrentCount equal to the total number of items to
 * be transfered (CurrentCount = *Count).
 *
 * Set the total number of items transfered so far to zero (TotalDone = 0)
 *
 * Set up moving pointers into the From and To transfer areas to keep
 * track of where the current transfer should be read and/or written.
 * (CurrentTo = To; CurrentFrom = From)
 *
 * do
 *    Set a pointer to the end of the memory that would be required
 *    to do the complete transfer.
 *
 *    If the pointer is outside of the buffer area (determined by
 *    call the BufferSizeCheck), then we need to adjust the
 *    size of the requested transfer.
 *
 *       Set the pointer to the last item to the last valid location
 *       in the real mode buffer area.
 *
 *       Set the value of CurrentCount to the maximum number of data
 *       items that can be transfered, based on the Size parameter.
 *
 *    Call the TIP function with CurrentCount instead of *Count,
 *    CurrentTo instead of To and CurrentFrom instead of From.
 *
 *    Set the CurrentDone equal to the CountDone returned by the
 *    function call.
 *
 *    Update the pointers into the From and To transfer areas to the
 *    end of the just completed transfer (CurrentFrom += CurrentDone
 *    * Size, CurrentTo += CurrentDone * Size)
 *
 *    Increment the TotalDone by the number of items transfered in
 *    the last call (TotalDone += CurrentDone)
 *
 * while transfer is not complete (TotalDone < *Count)
 *
 */
 
 
 
#define _DOS386C_C
 
#include <dos.h>
#include <process.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <udiproc.h>
 
#include <pharlap.h>
#include <udidos.h>
#include <stdarg.h>
 
 
#include <dos386c.h>
 
 
#define REAL_BUFFER_SIZE 0x1000
#define PRINT_ON  1
#define PRINT_OFF 0
 
#define WORDSIZE(param) ((sizeof(param)/2) + (sizeof(param) %2))
 
#define REALCALL(x,y) _dx_call_real(x, &real_regs, WORDSIZE(y), y)
 
#define FUNC_VAL ((UDIError) real_regs.eax)
 
#define SIZE_ERROR(Done, Size, function_name) printf("Return size (%d) > Buffer size (%d) in function %s\n",Done,Size,function_name)
 
/*
 * 4/93 MDT
 * The following defines are used to allow UDI 1.2 functions to identify
 * themselves to the compiler and the user when UDI 1.3 is defined.  These
 * are needed to differentiate the 1.2 versions of some functions (UDIPConnect)
 * from their 1.3 versions.
 */
#if defined __STDC__ || defined _MSC_VER
#define XCAT(a,b) a##b
#else
#define XCAT(a,b) a/**/b
#endif
 
#ifdef UDI13 
 
#define UDI12FUNCVER _12
#define UDI12FUNCVERSTR " (1.2)"
#define CAT(a,b) XCAT(a,b)
 
#else /* not UDI 1.3 */
 
#define UDI12FUNCVER dummy      /* Have to pass two arguments to CAT */ 
#define UDI12FUNCVERSTR ""
#define CAT(a,b) a              /* Don't actually want to concatenate anything */
 
#endif /* UDI 1.3 */
 
 
/* Needed by call to _dx_real_call, but no values need to be set
 * since TIP is compiled assuming it doesn't know anything about the
 * values in the registers.
 */
RMC_BLK  real_regs;
 
 
 
/* Pointers to use for handling conventional memory buffer area.  This
 * area is used to pass parameters to and from real-mode procedures.
 */
REALPTR rm_buffer_addr;         /* real-mode pointer to parameter buffer area.     */
ULONG           rm_buffer_size;         /* size of paramter buffer area.                   */
 
USHORT _far     *rm_address;            /* pointer to paramter buffer area.                */
USHORT _far     *rm_end_address;        /* the last valid address of the parameter buffer  */
 
 
int             buffer_allocated=0;      /* used to denote that the status of the buffer    */
 
 
 
 
REALPTR PROT_TO_REAL(FARPTR p)          /* converts a PROT ptr to a REALPTR */
{
REALPTR  dummyrp;
FARPTR   dummyfp;
int   err;
 
        /* returns a real mode pointer given a prot mode pointer p */
 
//      FP_SET(dummyfp,p,data_selector);
        dummyfp = p;
        err = _dx_toreal(dummyfp, 0, &dummyrp);
        if (err) {
           printf("Fatal Error _dx_toreal (0x%lX)\n", (ULONG) p);
           exit(err);
        }
        return(dummyrp);
 
} /* PROT_TO_REAL */
 
 
 
FARPTR REAL_TO_PROT(REALPTR rp)  /* converts a REALPTR to a FARPTR */
{
FARPTR  dummyfp;
 
        FP_SET(dummyfp,LINEARIZE(rp),SS_DOSMEM);
        return (dummyfp);
 
} /* REAL_TO_PROT */
 
 
 
FARPTR NEARPTR_TO_FARPTR(void *ptr)
/* Convert a near (32 bit linear) pointer to a far (48 bit) pointer. */
{
        FARPTR dummyfptr;
 
        FP_SET(dummyfptr, ptr, data_selector);
 
        return(dummyfptr);
 
} /* NEARPTR_TO_FARPTR() */
 
 
long BufferSizeCheck(FARPTR ptr, char *function_name, int print_message)
/* Check passed ptr to make sure that it points to a valid location in
 * the real-mode parameter passing buffer.  If not, just report an
 * error for now.
 */
{
        if ((long)ptr < (long)rm_address) {
                printf("Invalid address for real mode parameters in function: %s\n",function_name);
                exit(1);
        }
        if ((long)ptr > (long)rm_end_address) {
                if (print_message) {
                        printf("Parameters too large for passing to real mode in function: %s\n",function_name);
                        printf("Value of ptr - rm_end_address:%ld\n",(long)(ptr - (FARPTR)rm_end_address));
                }
                return (long)((long)ptr - (long)rm_end_address);
        }
 
        return 0;        /* passed the size check */
 
} /* BufferSizeCheck() */
 
 
void CheckRealError(int Err, char *func_name) {
 
        if (Err) {
                printf("DOS386 real mode call error: %s\n",func_name);
                exit(1);
        } /* if */
 
} /* CheckRealError() */
 
 
 
 
UDIError CAT(UDIPConnect,UDI12FUNCVER)(
                        REALPTR UDIConnectAddr,
                        char *Configuration,            /* In  */
                        UDISessionId *Session,          /* Out */
                        DOSTerm _far *TermStruct)       /* In  */
{
        int                     err;
        UDISessionId _far       *SessionPtr;
        UDIError                ConnectErr;
        USHORT                  rm_seg,rm_size;
 
        _Packed struct {
                REALPTR         Configuration;
                REALPTR         Session;
                REALPTR         TermStruct;
        } params;
 
 
        if (!buffer_allocated) {
                /* Need to get address of conventional memory area for passing parameters.
                 * This will set it for future use everywhere, not just in this function.
                 * rm_address is the protected (32 bit) pointer to the real mode parameter.
                 * passing area.  rm_buffer_addr is the real mode pointer to the same buffer.
                 */
                err = _dx_real_alloc(REAL_BUFFER_SIZE,&rm_seg,&rm_size);
 
                if (err) {
                        printf("Unable to allocate real-mode parameter transfer area (_dx_real_alloc)\n");
                        exit(0);
                }
                /* rm_seg is the real mode paragraph (segment).
                 * Build rm_buffer_addr to be the full real mode pointer (seg:ofst)
                 */
                RP_SET(rm_buffer_addr, 0, rm_seg);
                /*
                 * rm_address will be the protected pointer to that same buffer
                 */
                rm_address       = (USHORT _far *)REAL_TO_PROT(rm_buffer_addr);
                rm_end_address   = (USHORT _far *) (((char _far *)rm_address) + REAL_BUFFER_SIZE*16);
                buffer_allocated = 1;
        }
 
 
        /* Get pointers to locations where passed by reference parameters
         * will be stored in the parameter passing buffer area.  The first
         * parameter is always at rm_buffer (= rm_buffer_addr in real mode).
         */
 
        /* NOTE: see comments under UDIPDisconnect for explanation of why
         * we don't copy TermStruct even though it's an in parameter.
         */
        SessionPtr = (UDISessionId _far *)((char _far *)rm_address + strlen(Configuration)+1);
 
        if (BufferSizeCheck((FARPTR)(SessionPtr + sizeof(UDISessionId)),"UDIPConnect" UDI12FUNCVERSTR,PRINT_ON)) {
                return UDIErrorIPCInternal;
        } /* if */
 
        /* Move input parameters which are passed by reference into paramter buffer area. */
        _fmemmove(rm_address,NEARPTR_TO_FARPTR(Configuration),strlen(Configuration)+1);
        _fmemmove(SessionPtr,NEARPTR_TO_FARPTR(Session),sizeof(UDISessionId));
 
 
        /* Put actual parameters into packed structure for passing to real
         * mode function.
         */
        params.Configuration = rm_buffer_addr;
        params.Session       = PROT_TO_REAL((FARPTR) SessionPtr);
        params.TermStruct    = PROT_TO_REAL((FARPTR)TermStruct);
 
 
        /* Call the real-mode function with the address of the function,
         * the number of bytes in the packed structure and the address of
         * the structure.
         */
 
        ConnectErr = REALCALL(UDIConnectAddr,params);
 
        CheckRealError(ConnectErr,"UDIConnect" UDI12FUNCVERSTR);
 
        /* Copy output parameters from parameter passing area back to protected space
         */
        _fmemmove(NEARPTR_TO_FARPTR(Session),SessionPtr,sizeof(UDISessionId));
 
 
        return FUNC_VAL;
 
 
} /* UDIPConnect (UDI 1.2) */
 
 
#ifdef UDI13
 
/* 4/93 MDT - This function is needed only for UDI 1.3 and greater
 *            implementations.  This code should be checked when the
 *            final specification for UDI 1.3 becomes available.
 */
 
UDIError UDIPConnect_13(
        REALPTR         UDIConnectAddr,
        char            *Configuration,         /* In  */
        UDISessionId    *Session,               /* Out */
        DOSTerm         *TermStruct,            /* In  */
        UDIUInt32       DFEIPCId,               /* In  1.3 */
        UDIUInt32       *TIPIPCId,              /* Out 1.3 */
        struct UDIDFEVecRec *DFEVecRec          /* In  1.3 */
        )
{
        int                     err;
        UDISessionId _far       *SessionPtr;
        UDIUInt32 _far          *TIPIPCIdPtr;
        UDIError                ConnectErr;
        USHORT                  rm_seg,rm_size;
 
        _Packed struct {
                REALPTR         Configuration;
                REALPTR         Session;
                REALPTR         TermStruct;
                UDIUInt32       DFEIPCId;
                REALPTR         TIPIPCId;
                REALPTR         DFEVecRec;
        } params;
 
 
        if (!buffer_allocated) {
                /* Need to get address of conventional memory area for passing parameters.
                 * This will set it for future use everywhere, not just in this function.
                 * rm_address is the protected (32 bit) pointer to the real mode parameter.
                 * passing area.  rm_buffer_addr is the real mode pointer to the same buffer.
                 */
                err = _dx_real_alloc(REAL_BUFFER_SIZE,&rm_seg,&rm_size);
                if (err) {
                        printf("Unable to allocate real-mode parameter transfer area (_dx_real_alloc)\n");
                        exit(0);
                }
                /* rm_seg is the real mode paragraph (segment).
                 * Build rm_buffer_addr to be the full real mode pointer (seg:ofst)
                 */
                RP_SET(rm_buffer_addr, 0, rm_seg);
                /*
                 * rm_address will be the protected pointer to that same buffer
                 */
                rm_address       = REAL_TO_PROT(rm_buffer_addr);
                rm_end_address   = (USHORT *) (((char *)rm_address) + REAL_BUFFER_SIZE*16);
                buffer_allocated = 1;
        }
 
 
        /* Get pointers to locations where passed by reference parameters
         * will be stored in the parameter passing buffer area.  The first
         * parameter is always at rm_buffer (= rm_buffer_addr in real mode).
         */
 
        /* NOTE: see comments under UDIPDisconnect for explanation of why
         * we don't copy TermStruct even though it's an in parameter.
         */
        SessionPtr = (UDISessionId _far *)((char _far *)rm_address + strlen(Configuration)+1);
        TIPIPCIdPtr = (UDIUInt32 _far *) (SessionPtr + sizeof(UDISessionId));
 
        if (BufferSizeCheck((FARPTR)(TIPIPCIdPtr + sizeof(UDIUInt32)),"UDIPConnect (1.3)")) {
                return UDIErrorIPCInternal;
        }
 
        /* Move input parameters which are passed by reference into paramter buffer area. */
        _fmemmove(rm_address,NEARPTR_TO_FARPTR(Configuration),strlen(Configuration)+1);
 
        /* Put actual parameters into packed structure for passing to real
         * mode function.
         */
        params.Configuration = rm_buffer_addr;
        params.Session       = PROT_TO_REAL((FARPTR)SessionPtr);
        params.TermStruct    = PROT_TO_REAL((FARPTR)TermStruct);
        params.DFEIPCId      = DFEIPCId;
        params.TIPIPCId      = PROT_TO_REAL(TIPIPCIdPtr);
        params.DFEVecRec     = PROT_TO_REAL((FARPTR)DFEVecRec);
 
 
        /* Call the real-mode function with the address of the function,
         * the number of bytes in the packed structure and the address of
         * the structure.
         */
 
        ConnectErr = REALCALL(UDIConnectAddr,params);
 
        CheckRealError(ConnectErr,"UDIConnect (1.3)");
 
        /* Copy output parameters from parameter passing area back to protected space
         */
        _fmemmove(NEARPTR_TO_FARPTR(Session),SessionPtr,sizeof(UDISessionId));
        _fmemmove(NEARPTR_TO_FARPTR(TIPIPCId),TIPIPCIdPtr,sizeof(UDIUInt32));
 
        return FUNC_VAL;
 
 
} /* UDIPConnect_13 */
 
#endif /* UDI13 */
 
 
#define TIPSTRLEN 80
 
 
UDIError CAT(UDIPCapabilities,UDI12FUNCVER) (
        REALPTR         UDICapabilitiesAddr,
        UDIUInt32       *TIPId,                 /* Out */
        UDIUInt32       *TargetId,              /* Out */
        UDIUInt32       DFEId,                  /* In */
        UDIUInt32       DFE,                    /* In */
        UDIUInt32       *TIP,                   /* Out */
        UDIUInt32       *DFEIPCId,              /* Out */
        UDIUInt32       *TIPIPCId,              /* Out */
        char            *TIPString              /* Out */
        )
{
        UDIUInt32 _far  *TargetIdPtr;
        UDIUInt32 _far  *TIPPtr;
        UDIUInt32 _far  *DFEIPCIdPtr;
        UDIUInt32 _far  *TIPIPCIdPtr;
        UDIUInt32 _far  *TIPStringPtr;
        UDIUInt32 _far  *endPtr;
        UDIError        Err;
 
        /* Structure for passing parameters to real mode function in TIP */
        _Packed struct {
                REALPTR         TIPId;
                REALPTR         TargetId;
                UDIUInt32       DFEId;
                UDIUInt32       DFE;
                REALPTR         TIP;
                REALPTR         DFEIPCId;
                REALPTR         TIPIPCId;
                REALPTR         TIPString;
        } params;
 
 
        /* Get pointers to locations where passed by reference parameters
         * will be stored in the parameter passing buffer area.  The first
         * parameter is always at rm_address.
         */
 
        TargetIdPtr = (UDIUInt32 _far *)((char _far *)rm_address + sizeof(UDIUInt32));
        TIPPtr = TargetIdPtr + sizeof(UDIUInt32);
        DFEIPCIdPtr = TIPPtr + sizeof(UDIUInt32);
        TIPIPCIdPtr = DFEIPCIdPtr + sizeof(UDIUInt32);
        TIPStringPtr = TIPIPCIdPtr + sizeof(UDIInt32);
        endPtr = TIPStringPtr + TIPSTRLEN;
 
        if (BufferSizeCheck((FARPTR)endPtr,"UDICapabilities" UDI12FUNCVERSTR,PRINT_ON)) {
                return UDIErrorIPCLimitation;
        } /* if */
 
        /* Move parameters into paramter buffer area. */
        _fmemmove(rm_address,NEARPTR_TO_FARPTR(TIPId),sizeof(UDIUInt32));
        _fmemmove(TargetIdPtr,NEARPTR_TO_FARPTR(TargetId),sizeof(UDIUInt32));
        _fmemmove(TIPPtr,NEARPTR_TO_FARPTR(TIP),sizeof(UDIUInt32));
        _fmemmove(DFEIPCIdPtr,NEARPTR_TO_FARPTR(DFEIPCId),sizeof(UDIUInt32));
        _fmemmove(TIPIPCIdPtr,NEARPTR_TO_FARPTR(TIPIPCId),sizeof(UDIInt32));
        _fmemmove(TIPStringPtr,NEARPTR_TO_FARPTR(TIPString),TIPSTRLEN);
 
 
        params.TIPId = rm_buffer_addr;
        params.TargetId = PROT_TO_REAL((FARPTR)TargetIdPtr);
        params.DFEId = DFEId;
        params.DFE = DFE;
        params.TIP = PROT_TO_REAL((FARPTR)TIPPtr);
        params.DFEIPCId = PROT_TO_REAL((FARPTR)DFEIPCIdPtr);
        params.TIPIPCId = PROT_TO_REAL((FARPTR)TIPIPCIdPtr);
        params.TIPString = PROT_TO_REAL((FARPTR)TIPStringPtr);
 
 
        Err = REALCALL(UDICapabilitiesAddr,params);
 
        CheckRealError(Err,"UDICapabilities" UDI12FUNCVERSTR);
 
        _fmemmove(NEARPTR_TO_FARPTR(TargetId),TargetIdPtr,sizeof(UDIUInt32));
        _fmemmove(NEARPTR_TO_FARPTR(TIP),TIPPtr,sizeof(UDIUInt32));
        _fmemmove(NEARPTR_TO_FARPTR(DFEIPCId),DFEIPCIdPtr,sizeof(UDIUInt32));
        _fmemmove(NEARPTR_TO_FARPTR(TIPIPCId),TIPIPCIdPtr,sizeof(UDIInt32));
        _fmemmove(NEARPTR_TO_FARPTR(TIPString),TIPStringPtr,TIPSTRLEN);
        _fmemmove(NEARPTR_TO_FARPTR(TIPId),(UDIUInt32 _far *)rm_address,sizeof(UDIUInt32));
 
        return FUNC_VAL;
 
}  /* UDIPCapabilities() */
 
 
 
#ifdef UDI13
 
/* UDI 1.3 version of UDIPCapabilities */
UDIError UDIPCapabilities_13 (
        REALPTR         UDICapabilitiesAddr,
        UDIUInt32       *TIPId,                 /* Out */
        UDIUInt32       *TargetId,              /* Out */
        UDIUInt32       DFEId,                  /* In */
        UDIUInt32       DFE,                    /* In */
        UDIUInt32       *TIP,                   /* Out */
        UDIUInt32       *DFEIPCId,              /* Out */
        UDIUInt32       *TIPIPCId,              /* Out */
        char            *TIPString,             /* Out */
        UDISizeT        BufSize,                /* In  1.3 */
        UDISizeT        *CountDone,             /* Out 1.3 */
        UDISessionId    connection_id
        )
{
        UDIUInt32 _far  *TargetIdPtr;
        UDIUInt32 _far  *TIPPtr;
        UDIUInt32 _far  *DFEIPCIdPtr;
        UDIUInt32 _far  *TIPIPCIdPtr;
        UDIUInt32 _far  *TIPStringPtr;
        UDIUInt32 _far  *endPtr;
        UDISizeT        *CountDonePtr;
        UDIError        ConnectErr;
 
        /* Structure for passing parameters to real mode function in TIP */
        _Packed struct {
                REALPTR         TIPId;
                REALPTR         TargetId;
                UDIUInt32       DFEId;
                UDIUInt32       DFE;
                REALPTR         TIP;
                REALPTR         DFEIPCId;
                REALPTR         TIPIPCId;
                REALPTR         TIPString;
                UDISizeT        BufSize;
                REALPTR         CountDone;
                UDISessionId    connection_id;
        } params;
 
 
        /* Get pointers to locations where passed by reference parameters
         * will be stored in the parameter passing buffer area.  The first
         * parameter is always at rm_address.
         */
 
        TargetIdPtr  = (UDIUInt32 _far *)((char _far *)rm_address + sizeof(UDIUInt32));
        TIPPtr       = TargetIdPtr + sizeof(UDIUInt32);
        DFEIPCIdPtr  = TIPPtr + sizeof(UDIUInt32);
        TIPIPCIdPtr  = DFEIPCIdPtr + sizeof(UDIUInt32);
        TIPStringPtr = TIPIPCIdPtr + sizeof(UDIInt32);
        CountDonePtr = (UDISizeT _far *) (TIPStringPtr + strlen(TIPString) + 1);
        endPtr       = (UDIUInt32 _far *) (CountDonePtr + sizeof(UDISizeT));
 
        if (BufferSizeCheck((FARPTR)endPtr,"UDICapabilities (1.3)",PRINT_ON) {
                return UDIErrorIPCLimitation;
        } /* if */
 
 
        /* Move parameters into paramter buffer area. */
        _fmemmove(rm_address,NEARPTR_TO_FARPTR(TIPId),sizeof(UDIUInt32));                       /* TIPId */
        _fmemmove(TargetIdPtr, NEARPTR_TO_FARPTR(TargetId),sizeof(UDIUInt32));
        _fmemmove(TIPPtr, NEARPTR_TO_FARPTR(TIP),sizeof(UDIUInt32));
        _fmemmove(DFEIPCIdPtr, NEARPTR_TO_FARPTR(DFEIPCId),sizeof(UDIUInt32));
        _fmemmove(TIPIPCIdPtr, NEARPTR_TO_FARPTR(TIPIPCId),sizeof(UDIInt32));
        _fmemmove(TIPStringPtr, NEARPTR_TO_FARPTR(TIPString),strlen(TIPString)+1);
        _fmemmove(CountDonePtr, NEARPTR_TO_FARPTR(CountDone),sizeof(UDISizeT));
 
 
        params.TIPId         = rm_buffer_addr;
        params.TargetId      = PROT_TO_REAL((FARPTR)TargetIdPtr);
        params.DFEId         = DFEId;
        params.DFE           = DFE;
        params.TIP           = PROT_TO_REAL((FARPTR)TIPPtr);
        params.DFEIPCId      = PROT_TO_REAL((FARPTR)DFEIPCIdPtr);
        params.TIPIPCId      = PROT_TO_REAL((FARPTR)TIPIPCIdPtr);
        params.TIPString     = PROT_TO_REAL((FARPTR)TIPStringPtr);
        params.BufSize       = BufSize;
        params.CountDone     = PROT_TO_REAL((FARPTR)CountDonePtr);
        params.connection_id = connection_id;
 
 
        ConnectErr = REALCALL(UDICapabilitiesAddr,params);
 
        CheckRealError(ConnectErr,"UDICapabilities (1.3)");
 
 
        _fmemmove(NEARPTR_TO_FARPTR(TIPId),     rm_address,   sizeof(UDIUInt32));
        _fmemmove(NEARPTR_TO_FARPTR(TargetId),  TargetIdPtr,  sizeof(UDIUInt32));
        _fmemmove(NEARPTR_TO_FARPTR(TIP),       TIPPtr,       sizeof(UDIUInt32));
        _fmemmove(NEARPTR_TO_FARPTR(DFEIPCId),  DFEIPCIdPtr,  sizeof(UDIUInt32));
        _fmemmove(NEARPTR_TO_FARPTR(TIPIPCId),  TIPIPCIdPtr,  sizeof(UDIInt32));
        _fmemmove(NEARPTR_TO_FARPTR(TIPString), TIPStringPtr, strlen(TIPString)+1);
        _fmemmove(NEARPTR_TO_FARPTR(CountDone), CountDonePtr, sizeof(CountDone));
 
        if (*CountDone <= BufSize)
                _fmemmove(NEARPTR_TO_FARPTR(TIPString),TIPStringPtr,*CountDone);
        else {
                _fmemmove(NEARPTR_TO_FARPTR(TIPString),TIPStringPtr,BufSize);
                SIZE_ERROR(*CountDone, BufSize, "UDIPCapabilities (1.3)");
        }
 
 
 
        return FUNC_VAL;
 
}  /* UDIPCapabilities_13() */
 
#endif /* UDI13 */
 
 
UDIError UDIPGetErrorMsg(
        REALPTR         UDIGetErrorMessageAddr,
        UDIError        ErrorCode,              /* In  */
        UDISizeT        MsgSize,                /* In  */
        char            *Msg,                   /* Out */
        UDISizeT        *CountDone              /* Out */
        )
{
        UDIError        Err;
        UDISizeT _far   *CountDonePtr;
        long            Buffer_Adjustment;
 
        _Packed struct {
                UDIError        ErrorCode;
                UDISizeT        MsgSize;
                REALPTR         Msg;
                REALPTR         CountDone;
        } params;
 
 
        CountDonePtr = (UDISizeT _far *)(rm_address + MsgSize);
 
        if ((Buffer_Adjustment = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPGetErrorMsg",PRINT_ON))) {
                if (MsgSize <= Buffer_Adjustment)
                        return UDIErrorIPCLimitation;
                MsgSize -= Buffer_Adjustment;
        } /* if */
 
        /* Don't need to copy anything into the real mode parameter
         * buffer area for this call since there are no pointer "in"
         * parameters.
         */
 
        params.ErrorCode = ErrorCode;
        params.MsgSize   = MsgSize;
        params.Msg       = rm_buffer_addr;
        params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);
 
        Err = REALCALL(UDIGetErrorMessageAddr,params);
 
        CheckRealError(Err,"UDIGetErrorMessage");
 
        _fmemmove(NEARPTR_TO_FARPTR(CountDone),CountDonePtr,sizeof(UDISizeT));
        if (*CountDone <= MsgSize)
                _fmemmove(NEARPTR_TO_FARPTR(Msg),rm_address,*CountDone);
        else {
                _fmemmove(NEARPTR_TO_FARPTR(Msg),rm_address,MsgSize);
                SIZE_ERROR(*CountDone, MsgSize, "UDIPGetErrorMessage");
        }
 
        return FUNC_VAL;
 
} /* UDIPGetErrorMessage */
 
 
 
UDIError UDIPSetCurrentConnection(
        REALPTR         UDISetCurrentConnectionAddr,
        UDISessionId    Session                 /* In  */
        )
{
        UDIError        Err;
 
        Err = REALCALL(UDISetCurrentConnectionAddr,Session);
 
        CheckRealError(Err,"UDISetCurrentConnection");
 
        return FUNC_VAL;
 
} /* UDIPSetCurrentConnection() */
 
 
 
UDIError UDIPDisconnect(
        REALPTR         UDIDisconnectAddr,
        UDISessionId    Session,                /* In  */
        UDIBool         Terminate,              /* In  */
        DOSTerm _far    *TermStruct     /* In  */
        )
{
        UDIError        Err;
        DOSTerm         t;
 
        _Packed struct {
                UDISessionId    Session;
                UDIBool         Terminate;
                REALPTR         Term;
        } params;
 
        _fmemmove(NEARPTR_TO_FARPTR(&t),TermStruct,sizeof(TermStruct));
 
        /* The only pointer to be passed is a pointer to TermStruct
         * but since TermStruct is already in real memory, we do
         * not want to copy it (The TIP must store its registers into
         * the original TermStruct, not the copy)
         */
 
        /* For this call just need to pack everything into a structure,
         * then do the call since there are no "out" parameters and no
         * pointers to "in" parameters.
         */
        params.Session   = Session;
        params.Terminate = Terminate;
        params.Term      = PROT_TO_REAL((FARPTR)TermStruct);    /* just convert to real */
 
        Err = REALCALL(UDIDisconnectAddr,params);
 
        CheckRealError(Err,"UDIDisconnect");
 
        return FUNC_VAL;
 
} /* UDIPDisconnect() */
 
 
 
UDIError UDIPGetTargetConfig(
        REALPTR         UDIGetTargetConfigAddr,
        UDIMemoryRange  KnownMemory[],          /* Out */
        UDIInt          *NumberOfRanges,        /* In/Out */
        UDIUInt32       ChipVersions[],         /* Out */
        UDIInt          *NumberOfChips          /* In/Out */
        )
{
        _Packed struct {
                REALPTR         KnownMemory;
                REALPTR         NumberOfRanges;
                REALPTR         ChipVersions;
                REALPTR         NumberOfChips;
        } params;
 
        UDIError                Err;
        UDIInt _far             *NumberOfRangesPtr;
        UDIUInt32 _far          *ChipVersionsPtr;
        UDIInt _far             *NumberOfChipsPtr;
 
        /* Get addresses in parameter passing buffer to store parameters
         * which are passed-by-reference.
         */
         NumberOfRangesPtr = (UDIInt _far *) (rm_address + *NumberOfRanges * sizeof(UDIMemoryRange));
         ChipVersionsPtr   = (UDIUInt32 _far *) (NumberOfRangesPtr + sizeof(UDIInt));
         NumberOfChipsPtr  = (UDIInt _far *) (ChipVersionsPtr + *NumberOfChips * sizeof(UDIUInt32));
 
 
 
        if (BufferSizeCheck((FARPTR)(NumberOfChipsPtr + sizeof(UDIInt)),"UDIPGetTargetConfig",PRINT_ON)) {
                return UDIErrorIPCLimitation;
        } /* if */
 
        /* Copy parameters which are passed-by-reference to parameter
         * passing buffer.  Only "In" data needs to be copied.
         */
         _fmemmove(NumberOfRangesPtr,NEARPTR_TO_FARPTR(NumberOfRanges),sizeof(UDIInt));
         _fmemmove(NumberOfChipsPtr,NEARPTR_TO_FARPTR(NumberOfChips),sizeof(UDIInt));
 
        /* Put data into packed structure. */
        params.KnownMemory    = rm_buffer_addr;
        params.NumberOfRanges = PROT_TO_REAL((FARPTR)NumberOfRangesPtr);
        params.ChipVersions   = PROT_TO_REAL((FARPTR)ChipVersionsPtr);
        params.NumberOfChips  = PROT_TO_REAL((FARPTR)NumberOfChipsPtr);
 
        Err = REALCALL(UDIGetTargetConfigAddr,params);
 
        CheckRealError(Err,"UDIGetTargetConfig");
 
        /* Put data back into protected mode program address. */
        _fmemmove(NEARPTR_TO_FARPTR(KnownMemory),rm_address,*NumberOfRanges * sizeof(UDIMemoryRange));
        _fmemmove(NEARPTR_TO_FARPTR(NumberOfRanges),NumberOfRangesPtr, sizeof(UDIInt));
        _fmemmove(NEARPTR_TO_FARPTR(ChipVersions), ChipVersionsPtr, *NumberOfChips * sizeof(UDIUInt32));
        _fmemmove(NEARPTR_TO_FARPTR(NumberOfChips), NumberOfChipsPtr, sizeof(UDIInt));
 
        return FUNC_VAL;
 
} /* UDIPGetTargetConfig() */
 
 
 
UDIError UDIPCreateProcess(
        REALPTR         UDICreateProcessAddr,
        UDIPId          *PId                    /* Out */
        )
{
        UDIError        Err;
 
 
        if (BufferSizeCheck((FARPTR)(rm_address + sizeof(UDIPId)),"UDIPCreateProcess",PRINT_ON)) {
                return UDIErrorIPCLimitation;
        } /* if */
 
        /* Copy passed-by-reference information to parameter passing buffer. */
        _fmemmove(rm_address,NEARPTR_TO_FARPTR(PId),sizeof(UDIPId));
 
        /* Don't need to create structure since there is only one parameter. */
        Err = REALCALL(UDICreateProcessAddr,rm_buffer_addr);
 
        CheckRealError(Err,"UDICreateProcess");
 
        /* Copy "out" data back to protected mode program address. */
        _fmemmove(NEARPTR_TO_FARPTR(PId),rm_address,sizeof(UDIPId));
 
        return FUNC_VAL;
 
} /* UDIPCreateProcess() */
 
 
 
UDIError UDIPSetCurrentProcess(
        REALPTR         UDISetCurrentProcessAddr,
        UDIPId          PId                     /* In  */
        )
{
        UDIError        Err;
 
 
        Err = REALCALL(UDISetCurrentProcessAddr,PId);
 
        CheckRealError(Err,"UDISetCurrentProcess");
 
        return FUNC_VAL;
 
} /* UDIPSetCurrentProcess() */
 
 
 
UDIError UDIPInitializeProcess(
        REALPTR         UDIInitializeProcessAddr,
        UDIMemoryRange  ProcessMemory[],        /* In  */
        UDIInt          NumberOfRanges,         /* In  */
        UDIResource     EntryPoint,             /* In  */
        CPUSizeT        *StackSizes,            /* In  */
        UDIInt          NumberOfStacks,         /* In  */
        char            *ArgString              /* In  */
        )
{
        _Packed struct {
                REALPTR         ProcessMemory;
                UDIInt          NumberOfRanges;
                UDIResource     EntryPoint;
                REALPTR         StackSizes;
                UDIInt          NumberOfStacks;
                REALPTR         ArgString;
        } params;
 
        /* Pointers to variables stored in the parameter passing buffer. */
        CPUSizeT _far   *StackSizesPtr;
        char _far       *ArgStringPtr;
        UDIError        Err;
 
 
        StackSizesPtr = (CPUSizeT _far *) (rm_address + NumberOfRanges*sizeof(UDIMemoryRange));
        ArgStringPtr  = (char _far *) (StackSizesPtr + NumberOfStacks * sizeof(CPUSizeT));
 
        if (BufferSizeCheck((FARPTR)(ArgStringPtr + strlen(ArgString) + 1),"UDIPInitializeProcess",PRINT_ON)) {
                return UDIErrorIPCLimitation;
        } /* if */
 
        /* Move things passed by reference into the parameter passing buffer. */
        _fmemmove(rm_address,NEARPTR_TO_FARPTR(ProcessMemory),NumberOfRanges*sizeof(UDIMemoryRange));
        _fmemmove(StackSizesPtr,NEARPTR_TO_FARPTR(StackSizes),NumberOfStacks * sizeof(CPUSizeT));
        _fmemmove(ArgStringPtr, NEARPTR_TO_FARPTR(ArgString), strlen(ArgString)+1);
 
        /* Fill the packed array for passing to the real mode function. */
        params.ProcessMemory  = rm_buffer_addr;
        params.NumberOfRanges = NumberOfRanges;
        params.EntryPoint     = EntryPoint;
        params.StackSizes     = PROT_TO_REAL((FARPTR)StackSizesPtr);
        params.NumberOfStacks = NumberOfStacks;
        params.ArgString      = PROT_TO_REAL((FARPTR)ArgStringPtr);
 
        /* Call the real mode function. */
        Err = REALCALL(UDIInitializeProcessAddr,params);
 
        CheckRealError(Err,"UDIInitializeProcess");
 
        /* Don't need to copy anything back since all of the parameters are
         * "in" only.
         */
 
        return FUNC_VAL;
 
} /* UDIPInitializeProcess() */
 
 
 
UDIError UDIPDestroyProcess(
        REALPTR         UDIDestroyProcessAddr,
        UDIPId          PId                     /* In  */
        )
{
 
        UDIError        Err;
 
        Err = REALCALL(UDIDestroyProcessAddr,PId);
 
        CheckRealError(Err,"UDIDestroyProcess");
 
        return FUNC_VAL;
 
} /* UDIPDestroyProcess() */
 
 
 
UDIError UDIPRead(
        REALPTR         UDIReadAddr,
        UDIResource     From,                   /* In  */
        UDIHostMemPtr   To,                     /* Out */
        UDICount        Count,                  /* In  */
        UDISizeT        Size,                   /* In  */
        UDICount        *CountDone,             /* Out */
        UDIBool         HostEndian              /* In  */
        )
{
        _Packed struct {
                UDIResource     From;
                REALPTR         To;
                UDICount        Count;
                UDISizeT        Size;
                REALPTR         CountDone;
                UDIBool         HostEndian;
        } params;
 
        UDIError        Err;
        UDICount _far   *CountDonePtr;
 
        /* Looping control variables */
        UDICount        TotalDone=0;     /* Total number of items xfered so far */
        UDICount        CurrentCount;   /* Number of items to be xfered this pass */
        UDIResource     CurrentFrom;    /* Current pointer into From area */
        char *          CurrentTo;      /* Current pointer into To area */
        UDICount        BufAdjust;      /* size of buffer overflow in bytes */
        UDICount        CurrentDone;    /* The actual number of items xfered this pass */
 
 
        CurrentTo    = (char *) To;
        CurrentFrom  = From;
        CurrentCount = Count;
        do {
                CountDonePtr = (UDICount _far *) (rm_address + CurrentCount * Size);
 
                /* Check to see if transfer needs to be broken into smaller pieces */
                BufAdjust = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDICount)),"UDIPRead",PRINT_OFF);
                if (BufAdjust)  {
                        CurrentCount = (rm_end_address - rm_address - sizeof(UDICount)) / Size ;
                        CountDonePtr = (UDICount _far *) (rm_end_address - sizeof(UDICount));
                }
 
                /* Copy parameters into packed structure. */
                params.From       = CurrentFrom;
                params.To         = rm_buffer_addr;
                params.Count      = CurrentCount;
                params.Size       = Size;
                params.CountDone  = PROT_TO_REAL((FARPTR)CountDonePtr);
                params.HostEndian = HostEndian;
 
                Err = REALCALL(UDIReadAddr,params);
 
                CheckRealError(Err,"UDIRead");
 
                _fmemmove(NEARPTR_TO_FARPTR(&CurrentDone),CountDonePtr,sizeof(UDICount));
 
                /* Increment the TotalDone by the actual number of items xfered as
                 * returned from the function.
                 */
                TotalDone += CurrentDone;
 
                if ((CurrentDone <= CurrentCount) && (CurrentDone >= 0))
                        _fmemmove(NEARPTR_TO_FARPTR(CurrentTo),rm_address,CurrentDone * Size);
                else {
                        _fmemmove(NEARPTR_TO_FARPTR(CurrentTo),rm_address, CurrentCount * Size);
                        SIZE_ERROR(CurrentDone, CurrentCount, "UDIPRead");
                }
 
                /* Update looping variables for possible next pass */
                CurrentFrom.Offset += CurrentCount * Size;
                CurrentTo += CurrentCount * Size;
                CurrentCount = Count - TotalDone;
 
        } while ((TotalDone < Count) & (FUNC_VAL == UDINoError));
 
        *CountDone = TotalDone;
 
        return FUNC_VAL;
 
} /* UDIPRead() */
 
 
UDIError UDIPWrite(
        REALPTR         UDIWriteAddr,
        UDIHostMemPtr   From,                   /* In  */
        UDIResource     To,                     /* In  */
        UDICount        Count,                  /* In  */
        UDISizeT        Size,                   /* In  */
        UDICount        *CountDone,             /* Out */
        UDIBool         HostEndian              /* In  */
        )
{
        _Packed struct {
                REALPTR         From;
                UDIResource     To;
                UDICount        Count;
                UDISizeT        Size;
                REALPTR         CountDone;
                UDIBool         HostEndian;
        } params;
 
        UDIError        Err;
        UDICount _far   *CountDonePtr;
 
        /* Looping control variables */
        UDICount        TotalDone=0;     /* Total number of items xfered so far */
        UDICount        CurrentCount;   /* Number of items to be xfered this pass */
        char *          CurrentFrom;    /* Current pointer into From area */
        UDIResource     CurrentTo;      /* Current pointer into To area */
        UDICount        BufAdjust;      /* size of buffer overflow in bytes */
        UDICount        CurrentDone;    /* The actual number of items xfered this pass */
 
 
        CurrentTo    = To;
        CurrentFrom  = (char *) From;
        CurrentCount = Count;
 
        do {
                CountDonePtr = (UDICount _far *) (rm_address + Size * Count);
 
                /* Check to see if transfer needs to be broken into smaller pieces. */
                BufAdjust = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDICount)),"UDIPWrite",PRINT_ON);
                if (BufAdjust) {
                        CurrentCount = (rm_end_address - rm_address - sizeof(UDICount)) / Size;
                        CountDonePtr = (UDICount _far *) (rm_end_address - sizeof(UDICount));
                } /* if */
 
                /* Move data passed by reference into the parameter passing buffer
                 * area in conventional memory.
                 */
                _fmemmove(rm_address, NEARPTR_TO_FARPTR(CurrentFrom), Size * CurrentCount);
 
                /* Move data to packed structure for passing to real mode function. */
                params.From       = rm_buffer_addr;
                params.To         = CurrentTo;
                params.Count      = CurrentCount;
                params.Size       = Size;
                params.CountDone  = PROT_TO_REAL((FARPTR)CountDonePtr);
                params.HostEndian = HostEndian;
 
                Err = REALCALL(UDIWriteAddr,params);
 
                CheckRealError(Err,"UDIWrite");
 
                /* Move "out" data back into protected mode memory area. */
                _fmemmove(NEARPTR_TO_FARPTR(&CurrentDone),CountDonePtr,sizeof(UDICount));
 
                /* Increment the ToralDone by the actual number of items xfered as
                 * returned from the function.
                 */
                TotalDone += CurrentDone;
 
                /* Update looping variables for possible next pass */
                CurrentFrom += CurrentCount * Size;
                CurrentTo.Offset += CurrentCount * Size;
                CurrentCount = Count - TotalDone;
 
        } while ((TotalDone < Count) & (FUNC_VAL == UDINoError));
 
        /* Return the total number of items xfered */
        *CountDone = TotalDone;
 
        return FUNC_VAL;
 
} /* UDIPWrite() */
 
 
UDIError UDIPCopy(
        REALPTR         UDICopyAddr,
        UDIResource     From,                   /* In  */
        UDIResource     To,                     /* In  */
        UDICount        Count,                  /* In  */
        UDISizeT        Size,                   /* In  */
        UDICount        *CountDone,             /* Out */
        UDIBool         Direction               /* In  */
        )
{
        _Packed struct {
                UDIResource     From;
                UDIResource     To;
                UDICount        Count;
                UDISizeT        Size;
                REALPTR         CountDone;
                UDIBool         Direction;
        } params;
 
        UDIError        Err;
 
        /* Copy data into packed structure for passing to real mode funciton. */
        params.From     = From;
        params.To       = To;
        params.Count    = Count;
        params.Size     = Size;
        params.CountDone= rm_buffer_addr;
        params.Direction= Direction;
 
        Err = REALCALL(UDICopyAddr,params);
 
        CheckRealError(Err,"UDICopy");
 
        _fmemmove(NEARPTR_TO_FARPTR(CountDone), rm_address, sizeof(UDICount));
 
        return FUNC_VAL;
 
} /* UDIPCopy() */
 
 
 
UDIError UDIPExecute(
        REALPTR         UDIExecuteAddr
        )
{
        UDIError        Err;
 
        Err = _dx_call_real(UDIExecuteAddr, &real_regs, 0);
 
        CheckRealError(Err,"UDIExecute");
 
        return FUNC_VAL;
 
} /* UDIPExecute() */
 
 
 
UDIError UDIPStep(
        REALPTR         UDIStepAddr,
        UDIUInt32       Steps,                  /* In  */
        UDIStepType     StepType,               /* In  */
        UDIRange        Range                   /* In  */
        )
{
        UDIError        Err;
 
        _Packed struct {
                UDIUInt32       Steps;
                UDIStepType     StepType;
                UDIRange        Range;
        } params;
 
        /* Since nothing is passed by reference, don't need to use
         * buffer transfer area.
         */
 
        /* Copy passed parameters into packed structure */
        params.Steps    = Steps;
        params.StepType = StepType;
        params.Range    = Range;
 
        Err = REALCALL(UDIStepAddr,params);
 
        CheckRealError(Err,"UDIStep");
 
        return FUNC_VAL;
 
} /* UDIPStep() */
 
 
 
UDIError UDIPStop(
        REALPTR         UDIStopAddr
        )
{
        UDIError        Err;
 
        Err = _dx_call_real(UDIStopAddr, &real_regs, 0);
 
        CheckRealError(Err,"UDIStop");
 
        return FUNC_VAL;
 
} /* UDIPStop() */
 
 
 
UDIError UDIPWait(
        REALPTR         UDIWaitAddr,
        UDIInt32        MaxTime,                /* In  */
        UDIPId          *PId,                   /* Out */
        UDIUInt32       *StopReason             /* Out */
        )
{
        UDIError        Err;
        UDIUInt32 _far  *StopReasonPtr;
 
        _Packed struct {
                UDIInt32        MaxTime;
                REALPTR         PId;
                REALPTR         StopReason;
        } params;
 
        /* Since only "out" parameters are passed by reference, don't
         * need to copy anything into the parameter passing buffer before
         * the call.  Do need to set up pointer for StopReason though.
         */
        StopReasonPtr = (UDIUInt32 _far *) (rm_address + sizeof(UDIPId));
 
        if (BufferSizeCheck((FARPTR)(StopReasonPtr + sizeof(UDIUInt32)),"UDIPWait",PRINT_ON)) {
                return UDIErrorIPCLimitation;
        } /* if */
 
        params.MaxTime    = MaxTime;
        params.PId        = rm_buffer_addr;
        params.StopReason = PROT_TO_REAL((FARPTR)StopReasonPtr);
 
        Err = REALCALL(UDIWaitAddr,params);
 
        CheckRealError(Err,"UDIWait");
 
        /* Need to copy "out" parameter data back into protected mode
         * address space.
         */
        _fmemmove(NEARPTR_TO_FARPTR(PId),rm_address,sizeof(UDIPId));
        _fmemmove(NEARPTR_TO_FARPTR(StopReason),StopReasonPtr,sizeof(UDIUInt32));
 
        return FUNC_VAL;
 
} /* UDIPWait() */
 
 
 
UDIError UDIPSetBreakpoint(
        REALPTR         UDISetBreakpointAddr,
        UDIResource     Addr,                   /* In  */
        UDIInt32        PassCount,              /* In  */
        UDIBreakType    Type,                   /* In  */
        UDIBreakId      *BreakId                /* Out */
        )
{
        UDIError        Err;
 
        _Packed struct {
                UDIResource     Addr;
                UDIInt32        PassCount;
                UDIBreakType    Type;
                REALPTR         BreakId;
        } params;
 
        if (BufferSizeCheck((FARPTR)(rm_address + sizeof(UDIBreakId)),"UDIPSetBreakpoint",PRINT_ON)) {
                return UDIErrorIPCLimitation;
        } /* if */
 
        /* Since only "out" parameters are passed by reference, don't
         * need to copy anything into the parameter passing buffer before
         * the call.
         */
        params.Addr      = Addr;
        params.PassCount = PassCount;
        params.Type      = Type;
        params.BreakId   = rm_buffer_addr;
 
        Err = REALCALL(UDISetBreakpointAddr,params);
 
        CheckRealError(Err,"UDISetBreakpoint");
 
        /* Need to copy "out" parameter data back into protected mode
         * address space.
         */
        _fmemmove(NEARPTR_TO_FARPTR(BreakId),rm_address,sizeof(UDIBreakId));
 
        return FUNC_VAL;
 
} /* UDIPSetBreakpoint() */
 
 
 
UDIError UDIPQueryBreakpoint(
        REALPTR         UDIQueryBreakpointAddr,
        UDIBreakId      BreakId,                /* In  */
        UDIResource     *Addr,                  /* Out */
        UDIInt32        *PassCount,             /* Out */
        UDIBreakType    *Type,                  /* Out */
        UDIInt32        *CurrentCount           /* Out */
        )
{
        UDIError                Err;
        UDIInt32 _far           *PassCountPtr;
        UDIBreakType _far       *TypePtr;
        UDIInt32 _far           *CurrentCountPtr;
 
        _Packed struct {
                UDIBreakId      BreakId;
                REALPTR         Addr;
                REALPTR         PassCount;
                REALPTR         Type;
                REALPTR         CurrentCount;
        } params;
 
        /* Since all passed-by-reference variables are "out", don't need
         * to copy data to parameter passing buffer.  Do need to set up
         * pointers for real-mode function to use though.
         */
        PassCountPtr    = (UDIInt32 _far *) (rm_address + sizeof(UDIResource));
        TypePtr         = (UDIBreakType _far *) (PassCountPtr + sizeof(UDIInt32));
        CurrentCountPtr = (UDIInt32 _far *) (TypePtr + sizeof(UDIBreakType));
 
        if (BufferSizeCheck((FARPTR)(CurrentCountPtr + sizeof(UDIBreakType)),"UDIPQueryBreakpoint",PRINT_ON)) {
                return UDIErrorIPCLimitation;
        } /* if */
 
        params.BreakId      = BreakId;
        params.Addr         = rm_buffer_addr;
        params.PassCount    = PROT_TO_REAL((FARPTR)PassCountPtr);
        params.Type         = PROT_TO_REAL((FARPTR)TypePtr);
        params.CurrentCount = PROT_TO_REAL((FARPTR)CurrentCountPtr);
 
        Err = REALCALL(UDIQueryBreakpointAddr,params);
 
        CheckRealError(Err,"UDIQueryBreakpoint");
 
        /* Copy returned values back into protected mode variables. */
        _fmemmove(NEARPTR_TO_FARPTR(Addr),rm_address,sizeof(UDIResource));
        _fmemmove(NEARPTR_TO_FARPTR(PassCount),PassCountPtr,sizeof(UDIInt32));
        _fmemmove(NEARPTR_TO_FARPTR(Type),TypePtr,sizeof(UDIBreakType));
        _fmemmove(NEARPTR_TO_FARPTR(CurrentCount),CurrentCountPtr,sizeof(UDIInt32));
 
        return FUNC_VAL;
 
} /* UDIPQueryBreakpoint() */
 
 
 
UDIError UDIPClearBreakpoint(
        REALPTR         UDIClearBreakpointAddr,
        UDIBreakId      BreakId                 /* In  */
        )
{
        UDIError        Err;
 
        /* Don't need packed structure since only one parameter is passed. */
 
        Err = REALCALL(UDIClearBreakpointAddr,BreakId);
 
        CheckRealError(Err,"UDIClearBreakpoint");
 
        return FUNC_VAL;
 
} /* UDIPClearBreakpoint() */
 
 
 
 
UDIError UDIPGetStdout(
        REALPTR         UDIGetStdoutAddr,
        UDIHostMemPtr   Buf,                    /* Out */
        UDISizeT        BufSize,                /* In  */
        UDISizeT        *CountDone              /* Out */
        )
{
        UDIError        Err;
        UDISizeT _far   *CountDonePtr;
 
        char *          CurrentTo;
        UDISizeT        TotalDone = 0;
        UDISizeT        CurrentCount;
        UDISizeT        CurrentDone = 0;
        long            BufAdjust;
 
        _Packed struct {
                REALPTR         Buf;
                UDISizeT        BufSize;
                REALPTR         CountDone;
        } params;
 
        CurrentCount = BufSize;
        CurrentTo    = (char *) Buf;
 
        do {
                CountDonePtr = (UDISizeT _far *) (rm_address + CurrentCount);
 
                BufAdjust = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPGetStdout",PRINT_ON);
                if (BufAdjust) {
                        CurrentCount = (rm_end_address - rm_address - sizeof(UDISizeT));
                        CountDonePtr = (UDISizeT _far * ) (rm_end_address - sizeof(UDISizeT));
                } /* if */
 
                params.Buf       = rm_buffer_addr;
                params.BufSize   = CurrentCount;
                params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);
 
                Err = REALCALL(UDIGetStdoutAddr,params);
 
                CheckRealError(Err,"UDIGetStdout");
 
                /* Copy returned values back into protected mode variables. */
                _fmemmove(NEARPTR_TO_FARPTR(&CurrentDone),CountDonePtr,sizeof(UDISizeT));
 
                TotalDone += CurrentDone;
 
                if (CurrentDone <= CurrentCount)
                        _fmemmove(NEARPTR_TO_FARPTR(CurrentTo),rm_address,CurrentDone);
                else {
                        _fmemmove(NEARPTR_TO_FARPTR(CurrentTo),rm_address,CurrentDone);
                        SIZE_ERROR(*CountDone, BufSize, "UDIPGetStdout");
                }
 
                /* Update looping variables for possible next pass */
                CurrentTo += CurrentDone;
 
 
        } while ((TotalDone < BufSize) & (CurrentDone == CurrentCount)
                & (FUNC_VAL == UDINoError));
 
        *CountDone = TotalDone;
 
        return FUNC_VAL;
 
} /* UDIPGetStdout() */
 
 
 
UDIError UDIPGetStderr(
        REALPTR         UDIGetStderrAddr,
        UDIHostMemPtr   Buf,                    /* Out */
        UDISizeT        BufSize,                /* In  */
        UDISizeT        *CountDone              /* Out */
        )
{
        UDIError        Err;
        UDISizeT _far   *CountDonePtr;
        long            Buffer_Adjustment;
 
        _Packed struct {
                REALPTR         Buf;
                UDISizeT        BufSize;
                REALPTR         CountDone;
        } params;
 
        /* Since all passed-by-reference variables are "out", don't need
         * to copy data to parameter passing buffer.  Do need to set up
         * pointers for real-mode function to use though.
         */
        CountDonePtr = (UDISizeT _far *) (rm_address + BufSize);
 
        if ((Buffer_Adjustment = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPGetStderr",PRINT_ON))) {
                if (BufSize <= Buffer_Adjustment)
                        return UDIErrorIPCLimitation;
                BufSize -= Buffer_Adjustment;
        } /* if */
 
        params.Buf       = rm_buffer_addr;
        params.BufSize   = BufSize;
        params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);
 
        Err = REALCALL(UDIGetStderrAddr,params);
 
        CheckRealError(Err,"UDIGetStderr");
 
        /* Copy returned values back into protected mode variables. */
        _fmemmove(NEARPTR_TO_FARPTR(CountDone),CountDonePtr,sizeof(UDISizeT));
        if (*CountDone <= BufSize)
                _fmemmove(NEARPTR_TO_FARPTR(Buf),rm_address,*CountDone);
        else {
                _fmemmove(NEARPTR_TO_FARPTR(Buf),rm_address,BufSize);
                SIZE_ERROR(*CountDone, BufSize, "UDIPGetStderr");
        }
 
        return FUNC_VAL;
 
} /* UDIPGetStderr() */
 
 
 
UDIError UDIPPutStdin(
        REALPTR         UDIPutStdinAddr,
        UDIHostMemPtr   Buf,                    /* In  */
        UDISizeT        Count,                  /* In  */
        UDISizeT        *CountDone              /* Out */
        )
{
        UDIError        Err;
        UDISizeT _far   *CountDonePtr;
        long            Buffer_Adjustment;
 
        _Packed struct {
                REALPTR         Buf;
                UDISizeT        Count;
                REALPTR         CountDone;
        } params;
 
        /* Get pointers to passed-by-reference variables in parameter
         * passing buffer.
         */
        CountDonePtr = (UDISizeT _far *) (rm_address + Count);
 
        if ((Buffer_Adjustment = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPPutStdin",PRINT_ON))) {
                if (Count <= Buffer_Adjustment)
                        return UDIErrorIPCLimitation;
                Count -= Buffer_Adjustment;
        } /* if */
 
        /* Copy "in" passed-by-reference variables to parameter passing
         * buffer.
         */
        _fmemmove(rm_address,NEARPTR_TO_FARPTR(Buf),Count);
 
        params.Buf       = rm_buffer_addr;
        params.Count     = Count;
        params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);
 
        Err = REALCALL(UDIPutStdinAddr,params);
 
        CheckRealError(Err,"UDIPutStdin");
 
        /* Copy returned values back into protected mode variables. */
        _fmemmove(NEARPTR_TO_FARPTR(CountDone),CountDonePtr,sizeof(UDISizeT));
 
        return FUNC_VAL;
 
 
} /* UDIPPutStdin() */
 
 
 
UDIError UDIPStdinMode(
        REALPTR         UDIStdinModeAddr,
        UDIMode         *Mode                   /* Out */
        )
{
        UDIError        Err;
 
        /* Don't need to copy anything in parameter passing area since there
         * are no "in", passed-by-reference parameters.
         * Since there is only a single parameter and that is "out", and
         * passed-by-reference, can just use the address of the parameter
         * passing buffer for this.
         */
        Err = REALCALL(UDIStdinModeAddr,rm_buffer_addr);
 
        CheckRealError(Err,"UDIStdinMode");
 
        _fmemmove(NEARPTR_TO_FARPTR(Mode),rm_address,sizeof(UDIMode));
 
        return FUNC_VAL;
 
} /* UDIPStdinMode() */
 
 
 
UDIError UDIPPutTrans(
        REALPTR         UDIPutTransAddr,
        UDIHostMemPtr   Buf,                    /* In  */
        UDISizeT        Count,                  /* In  */
        UDISizeT        *CountDone              /* Out */
        )
{
        UDIError        Err;
        UDISizeT _far   *CountDonePtr;
 
        char *          CurrentTo;
        UDISizeT        TotalDone=0;
        UDISizeT        CurrentCount;
        UDISizeT        CurrentDone=0;
        long            BufAdjust;
 
        _Packed struct {
                REALPTR         Buf;
                UDISizeT        Count;
                REALPTR         CountDone;
        } params;
 
        CurrentCount = Count;
        CurrentTo = Buf;
 
        do {
                CountDonePtr = (UDISizeT _far *) (rm_address + CurrentCount);
 
                BufAdjust = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPPutTrans",PRINT_OFF);
                if (BufAdjust) {
                        CurrentCount = (rm_end_address - rm_address - sizeof(UDISizeT));
                        CountDonePtr = (UDISizeT _far *) (rm_end_address - sizeof(UDISizeT));
                } /* if */
 
                _fmemmove(rm_address,NEARPTR_TO_FARPTR(Buf),Count);
 
                params.Buf       = rm_buffer_addr;
                params.Count     = CurrentCount;
                params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);
 
                Err = REALCALL(UDIPutTransAddr,params);
 
                CheckRealError(Err,"UDIPutTrans");
 
                /* Copy the contents of the "out" parameters back into their
                 * protected mode counterparts.
                 */
                _fmemmove(NEARPTR_TO_FARPTR(&CurrentDone),CountDonePtr,sizeof(UDISizeT));
 
                TotalDone += CurrentDone;
 
        } while ((TotalDone < Count) & (FUNC_VAL == UDINoError));
 
        *CountDone = TotalDone;
        return FUNC_VAL;
 
} /* UDIPPutTrans() */
 
 
 
UDIError UDIPGetTrans(
        REALPTR         UDIGetTransAddr,
        UDIHostMemPtr   Buf,                    /* Out */
        UDISizeT        BufSize,                /* In  */
        UDISizeT        *CountDone              /* Out */
        )
{
        UDIError        Err;
        UDISizeT _far   *CountDonePtr;
        long            BufAdjust;
 
        _Packed struct {
                REALPTR         Buf;
                UDISizeT        BufSize;
                REALPTR         CountDone;
        } params;
 
        /* Get pointers to passed-by-reference parameters. */
        CountDonePtr = (UDISizeT _far *) (rm_address + BufSize);
 
        if ((BufAdjust = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPGetTrans",PRINT_ON))) {
                if (BufSize <= BufAdjust)
                        return UDIErrorIPCLimitation;
                BufSize -= BufAdjust;
        } /* if */
 
        params.Buf       = rm_buffer_addr;
        params.BufSize   = BufSize;
        params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);
 
        Err = REALCALL(UDIGetTransAddr,params);
 
        CheckRealError(Err,"UDIGetTrans");
 
        /* Copy the contents of the "out" parameters back into their
         * protected mode counterparts.
         */
        _fmemmove(NEARPTR_TO_FARPTR(CountDone),CountDonePtr,sizeof(UDISizeT));
        if (*CountDone <= BufSize)
                _fmemmove(NEARPTR_TO_FARPTR(Buf),rm_address,*CountDone);
        else {
                _fmemmove(NEARPTR_TO_FARPTR(Buf),rm_address,BufSize);
                SIZE_ERROR(*CountDone, BufSize, "UDIPGetTrans");
        }
 
        return FUNC_VAL;
 
 
} /* UDIPGetTrans() */
 
 
UDIError UDIPTransMode(
        REALPTR         UDITransModeAddr,
        UDIMode         *Mode                   /* Out */
        )
{
        UDIError        Err;
 
        /* Don't need to copy anything in parameter passing area since there
         * are no "in", passed-by-reference parameters.
         * Since there is only a single parameter and that is "out", and
         * passed-by-reference, can just use the address of the parameter
         * passing buffer for this.
         */
 
        Err = REALCALL(UDITransModeAddr,rm_buffer_addr);
 
        CheckRealError(Err,"UDITransMode");
 
        _fmemmove(NEARPTR_TO_FARPTR(Mode),rm_address,sizeof(UDIMode));
 
        return FUNC_VAL;
 
} /* UDIPTransMode() */
 
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [utils/] [amd-udi/] [udi/] [dos386c.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	578	markom	`/******************************************************************************`
2			`* Copyright 1991 Advanced Micro Devices, Inc.`
3			`*`
4			`* This software is the property of Advanced Micro Devices, Inc (AMD) which`
5			`* specifically grants the user the right to modify, use and distribute this`
6			`* software provided this notice is not removed or altered. All other rights`
7			`* are reserved by AMD.`
8			`*`
9			`* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS`
10			`* SOFTWARE. IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL`
11			`* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR`
12			`* USE OF THIS SOFTWARE.`
13			`*`
14			`* Comments about this software should be directed to udi@amd.com. If access`
15			`* to electronic mail isn't available, send mail to:`
16			`*`
17			`* Advanced Micro Devices, Inc.`
18			`* 29K Support Products`
19			`* Mail Stop 573`
20			`* 5900 E. Ben White Blvd.`
21			`* Austin, TX 78741`
22			`*****************************************************************************`
23			`* $Id: dos386c.c,v 1.1.1.1 2002-01-16 10:26:06 markom Exp $`
24			`* $Id: @(#)dos386c.c 1.9, AMD`
25			`*/`
26
27			`/* DOS386 specific constructs and functions. These assume the use of`
28			`* the 386\|DOS-Extender from Pharlap.`
29			`*`
30			`* This file contains functions which serve as an intermediate between`
31			`* protected mode UDI function calls made by the DFE and the possibly`
32			`* real-mode function called in the TIP. These functions assume that`
33			`* the interface between the TIP and the DFE is real-mode and that the`
34			`* DFE is protected mode, flat model (32 bit linear addresses).`
35			`*`
36			`* Note:`
37			`* This code allocates a section of real-mode memory using`
38			`* a call to _dx_real_alloc. Protected mode far pointers (48-bit)`
39			`* must be used to access this memory area.`
40			`*`