paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2026-01-08 13:31:44 +01:00
Code Issues Packages Projects Releases Wiki Activity
762e335da1
fpc/packages/extra/palmunits/serialmgr.pp
peter e417e34496 * truncate log
2005-02-14 17:13:06 +00:00

559 lines
26 KiB
ObjectPascal
Raw Blame History

{$MACRO ON}
(******************************************************************************
*
* Copyright (c) 1995-2000 Palm, Inc. or its subsidiaries.
* All rights reserved.
*
* File: SerialMgr.h
*
* Release: Palm OS SDK 4.0 (63220)
*
* Description:
* Include file for Serial manager
*
* History:
* 1/14/98 SerialMgr.h created by Ben Manuto
*
*****************************************************************************)
unit serialmgr;
interface
uses palmos, coretraps, errorbase, systemresources, systemmgr, netmgr;
// New Serial manager feature numbers
const
sysFtrNewSerialPresent = 1;
sysFtrNewSerialVersion = 2;
serMgrVersion = 2;
(********************************************************************
* Serial Manager Errors
* the constant serErrorClass is defined in SystemMgr.h
********************************************************************)
serErrBadParam = serErrorClass or 1;
serErrBadPort = serErrorClass or 2;
serErrNoMem = serErrorClass or 3;
serErrBadConnID = serErrorClass or 4;
serErrTimeOut = serErrorClass or 5;
serErrLineErr = serErrorClass or 6;
serErrAlreadyOpen = serErrorClass or 7;
serErrStillOpen = serErrorClass or 8;
serErrNotOpen = serErrorClass or 9;
serErrNotSupported = serErrorClass or 10; // functionality not supported
serErrNoDevicesAvail = serErrorClass or 11; // No serial devices were loaded or are available.
// New error codes for USB support
serErrConfigurationFailed = serErrorClass or 12;
//
// mask values for the lineErrors from SerGetStatus
//
serLineErrorParity = $0001; // parity error
serLineErrorHWOverrun = $0002; // HW overrun
serLineErrorFraming = $0004; // framing error
serLineErrorBreak = $0008; // break signal asserted
serLineErrorHShake = $0010; // line hand-shake error
serLineErrorSWOverrun = $0020; // HW overrun
serLineErrorCarrierLost = $0040; // CD dropped
(********************************************************************
* Serial Port Definitions
********************************************************************)
const
serPortLocalHotSync = $8000; // Use physical HotSync port
serPortCradlePort = $8000; // Cradle port. (Auto detect cradle type)
serPortIrPort = $8001; // Use available IR port.
serPortConsolePort = $8002; // Console port
serPortCradleRS232Port = $8003; // Cradle RS232 Port
serPortCradleUSBPort = $8004; // Cradle USB Port
// This constant is used by the Serial Link Mgr only
serPortIDMask = $C000;
(********************************************************************
* Serial Settings Descriptor
********************************************************************)
srmSettingsFlagStopBitsM = $00000001; // mask for stop bits field
srmSettingsFlagStopBits1 = $00000000; // 1 stop bits
srmSettingsFlagStopBits2 = $00000001; // 2 stop bits
srmSettingsFlagParityOnM = $00000002; // mask for parity on
srmSettingsFlagParityEvenM = $00000004; // mask for parity even
srmSettingsFlagXonXoffM = $00000008; // (NOT IMPLEMENTED) mask for Xon/Xoff flow control
srmSettingsFlagRTSAutoM = $00000010; // mask to prevent UART input overflow using RTS (NOTE: this flag
// alone does not prevent software overruns from the serial input buffer)
srmSettingsFlagCTSAutoM = $00000020; // mask for CTS xmit flow control (see srmSettingsFlagFlowControlIn below)
srmSettingsFlagBitsPerCharM = $000000C0; // mask for bits/char
srmSettingsFlagBitsPerChar5 = $00000000; // 5 bits/char
srmSettingsFlagBitsPerChar6 = $00000040; // 6 bits/char
srmSettingsFlagBitsPerChar7 = $00000080; // 7 bits/char
srmSettingsFlagBitsPerChar8 = $000000C0; // 8 bits/char
srmSettingsFlagFlowControlIn = $00000100; // mask to prevent the serial input buffer overflow, using RTS. Use in
// conjunction with srmSettingsFlagRTSAutoM for a fully flow controlled input.
srmSettingsFlagRTSInactive = $00000200; // if set and srmSettingsFlagRTSAutoM==0, RTS is held in the inactive (flow off) state forever.
// Default settings
srmDefaultSettings = srmSettingsFlagBitsPerChar8 or srmSettingsFlagStopBits1 or srmSettingsFlagRTSAutoM or srmSettingsFlagRTSInactive;
srmDefaultCTSTimeout = 5 * sysTicksPerSecond_;
// Status bitfield constants
srmStatusCtsOn = $00000001;
srmStatusRtsOn = $00000002;
srmStatusDsrOn = $00000004;
srmStatusBreakSigOn = $00000008;
//
// Info fields describing serial HW capabilities.
//
serDevCradlePort = $00000001; // Serial HW controls RS-232 serial from cradle connector of handheld.
serDevRS232Serial = $00000002; // Serial HW has RS-232 line drivers
serDevIRDACapable = $00000004; // Serial Device has IR line drivers and generates IRDA mode serial.
serDevModemPort = $00000008; // Serial deivce drives modem connection.
serDevCncMgrVisible = $00000010; // Serial device port name string to be displayed in Connection Mgr panel.
serDevConsolePort = $00000020; // Serial device is the default console port.
serDevUSBCapable = $00000040; // USB driver for USB hardware connected to the cradle connector of the handheld.
type
DeviceInfoType = record
serDevCreator: UInt32; // Four Character creator type for serial driver ('sdrv')
serDevFtrInfo: UInt32; // Flags defining features of this serial hardware.
serDevMaxBaudRate: UInt32; // Maximum baud rate for this device.
serDevHandshakeBaud: UInt32; // HW Handshaking is reccomended for baud rates over this
serDevPortInfoStr: PChar; // Description of serial HW device or virtual device.
reserved: array [0..8-1] of UInt8; // Reserved.
end;
DeviceInfoPtr = ^DeviceInfoType;
// Function IDs
//
// Standard set of function ids for the SrmOpen. Out of convenience, function ids
// use the same namespace as creator ids. Custom functions can be defined by
// using your app's creator id. The driver must have knowledge of that creator
// id for it to be of any use. A driver should handle an unknown function id
// gracefully, either use default functionality or return a serErrBadParam error.
const
serFncUndefined = 0; // Undefined function
serFncPPPSession = netIFCreatorPPP; // NetLib PPP Interface
serFncSLIPSession = netIFCreatorSLIP; // NetLib SLIP Interface
serFncDebugger = sysFileCSystem; // PalmOS Debugger
serFncHotSync = sysFileCSync; // HotSync function
serFncConsole = sysFileCSystem; // PalmOS Console
serFncTelephony = sysFileCTelMgrLib; // Telephony Library
//
// Open Configuration Structure
//
type
SrmOpenConfigType = record
baud: UInt32; // Baud rate that the connection is to be opened at.
// Applications that use drivers that do not require
// baud rates can set this to zero or any other value.
// Drivers that do not require a baud rate should
// ignore this field
function_: UInt32; // Designates the function of the connection. A value
// of zero indictates default behavior for the protocol.
// Drivers that do not support multiple functions should
// ignore this field.
drvrDataP: MemPtr; // Pointer to driver specific data.
drvrDataSize: UInt16; // Size of the driver specific data block.
sysReserved1: UInt32; // System Reserved
sysReserved2: UInt32; // System Reserved
end;
SrmOpenConfigPtr = ^SrmOpenConfigType;
(********************************************************************
* Transfer modes for USB
********************************************************************)
type
SrmTransferModeType = Enum;
const
srmTransferFirstReserved = 0; // RESERVE 0
srmUSBInterruptMode = Succ(srmTransferFirstReserved);
srmUSBBulkMode = Succ(srmUSBInterruptMode);
srmUSBIsochronous = Succ(srmUSBBulkMode);
(********************************************************************
* Type of a wakeup handler procedure which can be installed through the
* SerSetWakeupHandler() call.
********************************************************************)
type
WakeupHandlerProcPtr = procedure(refCon: UInt32);
(********************************************************************
* Type of an emulator-mode only blocking hook routine installed via
* SerControl function serCtlEmuSetBlockingHook. This is supported only
* under emulation mode. The argument to the function is the value
* specified in the SerCallbackEntryType structure. The intention of the
* return value is to return false if serial manager should abort the
* current blocking action, such as when an app quit event has been received;
* otherwise, it should return true. However, in the current implementation,
* this return value is ignored. The callback can additionally process
* events to enable user interaction with the UI, such as interacting with the
* debugger.
********************************************************************)
BlockingHookProcPtr = function(userRef: UInt32): Boolean;
(********************************************************************
* Serial Library Control Enumerations (Pilot 2.0)
********************************************************************)
(********************************************************************
* Structure for specifying callback routines.
********************************************************************)
SrmCallbackEntryType = record
funcP: BlockingHookProcPtr; // function pointer
userRef: UInt32; // ref value to pass to callback
end;
SrmCallbackEntryPtr = ^SrmCallbackEntryType;
type
SrmCtlEnum = Enum;
const
srmCtlFirstReserved = 0; // RESERVE 0
srmCtlSetBaudRate = Succ(srmCtlFirstReserved); // Sets the current baud rate for the HW.
// valueP = Pointer to Int32, valueLenP = Pointer to sizeof(Int32)
srmCtlGetBaudRate = Succ(srmCtlSetBaudRate); // Gets the current baud rate for the HW.
srmCtlSetFlags = Succ(srmCtlGetBaudRate); // Sets the current flag settings for the serial HW.
srmCtlGetFlags = Succ(srmCtlSetFlags); // Gets the current flag settings the serial HW.
srmCtlSetCtsTimeout = Succ(srmCtlGetFlags); // Sets the current Cts timeout value.
srmCtlGetCtsTimeout = Succ(srmCtlSetCtsTimeout); // Gets the current Cts timeout value.
srmCtlStartBreak = Succ(srmCtlGetCtsTimeout); // turn RS232 break signal on:
// users are responsible for ensuring that the break is set
// long enough to genearate a valid BREAK!
// valueP = 0, valueLenP = 0
srmCtlStopBreak = Succ(srmCtlStartBreak); // turn RS232 break signal off:
// valueP = 0, valueLenP = 0
srmCtlStartLocalLoopback = Succ(srmCtlStopBreak); // Start local loopback test
// valueP = 0, valueLenP = 0
srmCtlStopLocalLoopback = Succ(srmCtlStartLocalLoopback); // Stop local loopback test
// valueP = 0, valueLenP = 0
srmCtlIrDAEnable = Succ(srmCtlStopLocalLoopback); // Enable IrDA connection on this serial port
// valueP = 0, valueLenP = 0
srmCtlIrDADisable = Succ(srmCtlIrDAEnable); // Disable IrDA connection on this serial port
// valueP = 0, valueLenP = 0
srmCtlRxEnable = Succ(srmCtlIrDADisable); // enable receiver ( for IrDA )
srmCtlRxDisable = Succ(srmCtlRxEnable); // disable receiver ( for IrDA )
srmCtlEmuSetBlockingHook = Succ(srmCtlRxDisable); // Set a blocking hook routine FOR EMULATION
// MODE ONLY - NOT SUPPORTED ON THE PILOT
//PASS:
// valueP = Pointer to SerCallbackEntryType
// *valueLenP = sizeof(SerCallbackEntryType)
//RETURNS:
// the old settings in the first argument
srmCtlUserDef = Succ(srmCtlEmuSetBlockingHook); // Specifying this opCode passes through a user-defined
// function to the DrvControl function. This is for use
// specifically by serial driver developers who need info
// from the serial driver that may not be available through the
// standard SrmMgr interface.
srmCtlGetOptimalTransmitSize = Succ(srmCtlUserDef); // This function will ask the port for the most efficient buffer size
// for transmitting data packets. This opCode returns serErrNotSupported
// if the physical or virtual device does not support this feature.
// The device can return a transmit size of 0, if send buffering is
// requested, but the actual size is up to the caller to choose.
// valueP = Pointer to UInt32 --> return optimal buf size
// ValueLenP = sizeof(UInt32)
srmCtlSetDTRAsserted = Succ(srmCtlGetOptimalTransmitSize); // Enable or disable DTR.
srmCtlGetDTRAsserted = Succ(srmCtlSetDTRAsserted); // Determine if DTR is enabled or disabled.
srmCtlSetYieldPortCallback = Succ(srmCtlGetDTRAsserted); // Set the yield port callback
srmCtlSetYieldPortRefCon = Succ(srmCtlSetYieldPortCallback); // Set the yield port refNum
// ***** ADD NEW ENTRIES BEFORE THIS ONE
srmCtlSystemReserved = $7000; // Reserve control op code space for system use.
srmCtlCustom = $8000; // Reserve control op code space for licensee use.
srmCtlLAST = Succ(srmCtlCustom);
const
srmCtlSystemStart = $7000; // Start poitn for system op codes.
srmCtlCustomStart = $8000; // Start point for custom op codes.
(********************************************************************
* Serial Hardware Library Routines
********************************************************************)
// *****************************************************************
// * New Serial Manager trap selectors
// *****************************************************************
type
sysSerialSelector = Enum; // The order of this enum *MUST* match the sysSerialSelector in SerialMgr.c
const
sysSerialInstall = 0;
sysSerialOpen = Succ(sysSerialInstall);
sysSerialOpenBkgnd = Succ(sysSerialOpen);
sysSerialClose = Succ(sysSerialOpenBkgnd);
sysSerialSleep = Succ(sysSerialClose);
sysSerialWake = Succ(sysSerialSleep);
sysSerialGetDeviceCount = Succ(sysSerialWake);
sysSerialGetDeviceInfo = Succ(sysSerialGetDeviceCount);
sysSerialGetStatus = Succ(sysSerialGetDeviceInfo);
sysSerialClearErr = Succ(sysSerialGetStatus);
sysSerialControl = Succ(sysSerialClearErr);
sysSerialSend = Succ(sysSerialControl);
sysSerialSendWait = Succ(sysSerialSend);
sysSerialSendCheck = Succ(sysSerialSendWait);
sysSerialSendFlush = Succ(sysSerialSendCheck);
sysSerialReceive = Succ(sysSerialSendFlush);
sysSerialReceiveWait = Succ(sysSerialReceive);
sysSerialReceiveCheck = Succ(sysSerialReceiveWait);
sysSerialReceiveFlush = Succ(sysSerialReceiveCheck);
sysSerialSetRcvBuffer = Succ(sysSerialReceiveFlush);
sysSerialRcvWindowOpen = Succ(sysSerialSetRcvBuffer);
sysSerialRcvWindowClose = Succ(sysSerialRcvWindowOpen);
sysSerialSetWakeupHandler = Succ(sysSerialRcvWindowClose);
sysSerialPrimeWakeupHandler = Succ(sysSerialSetWakeupHandler);
sysSerialOpenV4 = Succ(sysSerialPrimeWakeupHandler);
sysSerialOpenBkgndV4 = Succ(sysSerialOpenV4);
sysSerialCustomControl = Succ(sysSerialOpenBkgndV4);
// Used by SerialMgrDispatch.c
maxSerialSelector = sysSerialCustomControl;
function SerialMgrInstall: Err;
function SrmOpen(port, baud: UInt32; var newPortIdP: UInt16): Err;
function SrmExtOpen(port: UInt32; var configP: SrmOpenConfigType; configSize: UInt16; var newPortIdP: UInt16): Err;
function SrmExtOpenBackground(port: UInt32; var configP: SrmOpenConfigType; configSize: UInt16; var newPortIdP: UInt16): Err;
function SrmOpenBackground(port, baud: UInt32; var newPortIdP: UInt16): Err;
function SrmClose(portId: UInt16): Err;
function SrmSleep: Err;
function SrmWake: Err;
function SrmGetDeviceCount(var numOfDevicesP: UInt16): Err;
function SrmGetDeviceInfo(deviceID: UInt32; var deviceInfoP: DeviceInfoType): Err;
function SrmGetStatus(portId: UInt16; var statusFieldP: UInt32; var lineErrsP: UInt16): Err;
function SrmClearErr(portId: UInt16): Err;
function SrmControl(portId, op: UInt16; valueP: Pointer; var valueLenP: UInt16): Err;
function SrmCustomControl(portId, opCode: UInt16; creator: UInt32; valueP: Pointer; var valueLenP: UInt16): Err;
function SrmSend(portId: UInt16; const bufP: Pointer; count: UInt32; var errP: Err): UInt32;
function SrmSendWait(portId: UInt16): Err;
function SrmSendCheck(portId: UInt16; var numBytesP: UInt32): Err;
function SrmSendFlush(portId: UInt16): Err;
function SrmReceive(portId: UInt16; rcvBufP: Pointer; count: UInt32; timeout: Int32; var errP: Err): UInt32;
function SrmReceiveWait(portId: UInt16; bytes: UInt32; timeout: Int32): Err;
function SrmReceiveCheck(portId: UInt16; var numBytesP: UInt32): Err;
function SrmReceiveFlush(portId: UInt16; timeout: Int32): Err;
function SrmSetReceiveBuffer(portId: UInt16; bufP: Pointer; bufSize: UInt16): Err;
function SrmReceiveWindowOpen(portId: UInt16; var bufPP: UInt8Ptr; var sizeP: UInt32): Err;
function SrmReceiveWindowClose(portId: UInt16; bytesPulled: UInt32): Err;
function SrmSetWakeupHandler(portId: UInt16; procP: WakeupHandlerProcPtr; refCon: UInt32): Err;
function SrmPrimeWakeupHandler(portId: UInt16; minBytes: UInt16): Err;
//procedure SrmSelectorErrPrv(UInt16 serialSelector); // used only by SerialMgrDispatch.c
implementation
function __SerialMgrInstall: Err; syscall sysTrapSerialDispatch;
function __SrmOpen(port, baud: UInt32; var newPortIdP: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmExtOpen(port: UInt32; var configP: SrmOpenConfigType; configSize: UInt16; var newPortIdP: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmExtOpenBackground(port: UInt32; var configP: SrmOpenConfigType; configSize: UInt16; var newPortIdP: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmOpenBackground(port, baud: UInt32; var newPortIdP: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmClose(portId: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmSleep: Err; syscall sysTrapSerialDispatch;
function __SrmWake: Err; syscall sysTrapSerialDispatch;
function __SrmGetDeviceCount(var numOfDevicesP: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmGetDeviceInfo(deviceID: UInt32; var deviceInfoP: DeviceInfoType): Err; syscall sysTrapSerialDispatch;
function __SrmGetStatus(portId: UInt16; var statusFieldP: UInt32; var lineErrsP: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmClearErr(portId: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmControl(portId, op: UInt16; valueP: Pointer; var valueLenP: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmCustomControl(portId, opCode: UInt16; creator: UInt32; valueP: Pointer; var valueLenP: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmSend(portId: UInt16; const bufP: Pointer; count: UInt32; var errP: Err): UInt32; syscall sysTrapSerialDispatch;
function __SrmSendWait(portId: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmSendCheck(portId: UInt16; var numBytesP: UInt32): Err; syscall sysTrapSerialDispatch;
function __SrmSendFlush(portId: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmReceive(portId: UInt16; rcvBufP: Pointer; count: UInt32; timeout: Int32; var errP: Err): UInt32; syscall sysTrapSerialDispatch;
function __SrmReceiveWait(portId: UInt16; bytes: UInt32; timeout: Int32): Err; syscall sysTrapSerialDispatch;
function __SrmReceiveCheck(portId: UInt16; var numBytesP: UInt32): Err; syscall sysTrapSerialDispatch;
function __SrmReceiveFlush(portId: UInt16; timeout: Int32): Err; syscall sysTrapSerialDispatch;
function __SrmSetReceiveBuffer(portId: UInt16; bufP: Pointer; bufSize: UInt16): Err; syscall sysTrapSerialDispatch;
function __SrmReceiveWindowOpen(portId: UInt16; var bufPP: UInt8Ptr; var sizeP: UInt32): Err; syscall sysTrapSerialDispatch;
function __SrmReceiveWindowClose(portId: UInt16; bytesPulled: UInt32): Err; syscall sysTrapSerialDispatch;
function __SrmSetWakeupHandler(portId: UInt16; procP: WakeupHandlerProcPtr; refCon: UInt32): Err; syscall sysTrapSerialDispatch;
function __SrmPrimeWakeupHandler(portId: UInt16; minBytes: UInt16): Err; syscall sysTrapSerialDispatch;
function SerialMgrInstall: Err;
begin
asm
move.l #$sysSerialInstall,D2;
end;
SerialMgrInstall := __SerialMgrInstall;
end;
function SrmOpen(port, baud: UInt32; var newPortIdP: UInt16): Err;
begin
asm
move.l #$sysSerialOpen,D2;
end;
SrmOpen := __SrmOpen(port, baud, newPortIdP);
end;
function SrmExtOpen(port: UInt32; var configP: SrmOpenConfigType; configSize: UInt16; var newPortIdP: UInt16): Err;
begin
asm
move.l #$sysSerialOpenV4,D2;
end;
SrmExtOpen := __SrmExtOpen(port, configP, configSize, newPortIdP);
end;
function SrmExtOpenBackground(port: UInt32; var configP: SrmOpenConfigType; configSize: UInt16; var newPortIdP: UInt16): Err;
begin
asm
move.l #$sysSerialOpenBkgndV4,D2;
end;
SrmExtOpenBackground := __SrmExtOpenBackground(port, configP, configSize, newPortIdP);
end;
function SrmOpenBackground(port, baud: UInt32; var newPortIdP: UInt16): Err;
begin
asm
move.l #$sysSerialOpenBkgnd,D2;
end;
SrmOpenBackground := __SrmOpenBackground(port, baud, newPortIdP);
end;
function SrmClose(portId: UInt16): Err;
begin
asm
move.l #$sysSerialClose,D2;
end;
SrmClose := __SrmClose(portId);
end;
function SrmSleep: Err;
begin
asm
move.l #$sysSerialSleep,D2;
end;
SrmSleep := __SrmSleep;
end;
function SrmWake: Err;
begin
asm
move.l #$sysSerialWake,D2;
end;
SrmWake := __SrmWake;
end;
function SrmGetDeviceCount(var numOfDevicesP: UInt16): Err;
begin
asm
move.l #$sysSerialGetDeviceCount,D2;
end;
SrmGetDeviceCount := __SrmGetDeviceCount(numOfDevicesP);
end;
function SrmGetDeviceInfo(deviceID: UInt32; var deviceInfoP: DeviceInfoType): Err;
begin
asm
move.l #$sysSerialGetDeviceInfo,D2;
end;
SrmGetDeviceInfo := __SrmGetDeviceInfo(deviceID, deviceInfoP);
end;
function SrmGetStatus(portId: UInt16; var statusFieldP: UInt32; var lineErrsP: UInt16): Err;
begin
asm
move.l #$sysSerialGetStatus,D2;
end;
SrmGetStatus := __SrmGetStatus(portId, statusFieldP, lineErrsP);
end;
function SrmClearErr(portId: UInt16): Err;
begin
asm
move.l #$sysSerialClearErr,D2;
end;
SrmClearErr := __SrmClearErr(portId);
end;
function SrmControl(portId, op: UInt16; valueP: Pointer; var valueLenP: UInt16): Err;
begin
asm
move.l #$sysSerialControl,D2;
end;
SrmControl := __SrmControl(portId, op, valueP, valueLenP);
end;
function SrmCustomControl(portId, opCode: UInt16; creator: UInt32; valueP: Pointer; var valueLenP: UInt16): Err;
begin
asm
move.l #$sysSerialCustomControl,D2;
end;
SrmCustomControl := __SrmCustomControl(portId, opCode, creator, valueP, valueLenP);
end;
function SrmSend(portId: UInt16; const bufP: Pointer; count: UInt32; var errP: Err): UInt32;
begin
asm
move.l #$sysSerialSend,D2;
end;
SrmSend := __SrmSend(portId, bufP, count, errP);
end;
function SrmSendWait(portId: UInt16): Err;
begin
asm
move.l #$sysSerialSendWait,D2;
end;
SrmSendwait := __SrmSendwait(portId);
end;
function SrmSendCheck(portId: UInt16; var numBytesP: UInt32): Err;
begin
asm
move.l #$sysSerialSendCheck,D2;
end;
SrmSendCheck := __SrmSendCheck(portId, numBytesP);
end;
function SrmSendFlush(portId: UInt16): Err;
begin
asm
move.l #$sysSerialSendFlush,D2;
end;
SrmSendFlush := __SrmSendFlush(portId);
end;
function SrmReceive(portId: UInt16; rcvBufP: Pointer; count: UInt32; timeout: Int32; var errP: Err): UInt32;
begin
asm
move.l #$sysSerialReceive,D2;
end;
SrmReceive := __SrmReceive(portId, rcvBufP, count, timeout, errP);
end;
function SrmReceiveWait(portId: UInt16; bytes: UInt32; timeout: Int32): Err;
begin
asm
move.l #$sysSerialReceiveWait,D2;
end;
SrmReceiveWait := __SrmReceiveWait(portId, bytes, timeout);
end;
function SrmReceiveCheck(portId: UInt16; var numBytesP: UInt32): Err;
begin
asm
move.l #$sysSerialReceiveCheck,D2;
end;
SrmReceiveCheck := __SrmReceiveCheck(portId, numBytesP);
end;
function SrmReceiveFlush(portId: UInt16; timeout: Int32): Err;
begin
asm
move.l #$sysSerialReceiveFlush,D2;
end;
SrmReceiveFlush := __SrmReceiveFlush(portId, timeout);
end;
function SrmSetReceiveBuffer(portId: UInt16; bufP: Pointer; bufSize: UInt16): Err;
begin
asm
move.l #$sysSerialSetRcvBuffer,D2;
end;
SrmSetReceiveBuffer := __SrmSetReceiveBuffer(portId, bufP, bufSize);
end;
function SrmReceiveWindowOpen(portId: UInt16; var bufPP: UInt8Ptr; var sizeP: UInt32): Err;
begin
asm
move.l #$sysSerialRcvWindowOpen,D2;
end;
SrmReceiveWindowOpen := __SrmReceiveWindowOpen(portId, bufPP, sizeP);
end;
function SrmReceiveWindowClose(portId: UInt16; bytesPulled: UInt32): Err;
begin
asm
move.l #$sysSerialRcvWindowClose,D2;
end;
SrmReceiveWindowClose := __SrmReceiveWindowClose(portId, bytesPulled);
end;
function SrmSetWakeupHandler(portId: UInt16; procP: WakeupHandlerProcPtr; refCon: UInt32): Err;
begin
asm
move.l #$sysSerialSetWakeupHandler,D2;
end;
SrmSetWakeupHandler := __SrmSetWakeupHandler(portId, procP, refcon);
end;
function SrmPrimeWakeupHandler(portId: UInt16; minBytes: UInt16): Err;
begin
asm
move.l #$sysSerialPrimeWakeupHandler,D2;
end;
SrmPrimeWakeupHandler := __SrmPrimeWakeupHandler(portId, minBytes);
end;
end.
Reference in New Issue View Git Blame Copy Permalink