summaryrefslogtreecommitdiffstats
path: root/src/VBox/HostDrivers/VBoxUSB/os2
diff options
context:
space:
mode:
Diffstat (limited to 'src/VBox/HostDrivers/VBoxUSB/os2')
-rw-r--r--src/VBox/HostDrivers/VBoxUSB/os2/Makefile.kup0
-rw-r--r--src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.c1278
-rw-r--r--src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.h242
3 files changed, 1520 insertions, 0 deletions
diff --git a/src/VBox/HostDrivers/VBoxUSB/os2/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/os2/Makefile.kup
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/VBox/HostDrivers/VBoxUSB/os2/Makefile.kup
diff --git a/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.c b/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.c
new file mode 100644
index 00000000..5950cc6f
--- /dev/null
+++ b/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.c
@@ -0,0 +1,1278 @@
+#define INCL_DOSERRORS
+#define INCL_DOSMEMMGR
+#define INCL_DOSSEMAPHORES
+#define INCL_DOSDEVICES
+#define INCL_DOSDEVIOCTL
+#define INCL_DOSMODULEMGR
+#include <os2.h>
+
+#if !defined(__GNUC__) || defined(STATIC_USBCALLS)
+#include <string.h>
+#else
+#define memcpy __builtin_memcpy
+#endif
+#include <stdlib.h>
+#include <stdio.h>
+
+#define LOG_GROUP LOG_GROUP_DRV_USBPROXY
+#include <VBox/log.h>
+
+#ifdef __GNUC__
+# define APIEXPORT __declspec(dllexport)
+#else
+# define APIEXPORT
+#endif
+
+#ifndef ERROR_USER_DEFINED_BASE
+/*#define ERROR_USER_DEFINED_BASE 0xFF00 */
+
+#define ERROR_I24_WRITE_PROTECT 0
+#define ERROR_I24_BAD_UNIT 1
+#define ERROR_I24_NOT_READY 2
+#define ERROR_I24_BAD_COMMAND 3
+#define ERROR_I24_CRC 4
+#define ERROR_I24_BAD_LENGTH 5
+#define ERROR_I24_SEEK 6
+#define ERROR_I24_NOT_DOS_DISK 7
+#define ERROR_I24_SECTOR_NOT_FOUND 8
+#define ERROR_I24_OUT_OF_PAPER 9
+#define ERROR_I24_WRITE_FAULT 10
+#define ERROR_I24_READ_FAULT 11
+#define ERROR_I24_GEN_FAILURE 12
+#define ERROR_I24_DISK_CHANGE 13
+#define ERROR_I24_WRONG_DISK 15
+#define ERROR_I24_UNCERTAIN_MEDIA 16
+#define ERROR_I24_CHAR_CALL_INTERRUPTED 17
+#define ERROR_I24_NO_MONITOR_SUPPORT 18
+#define ERROR_I24_INVALID_PARAMETER 19
+#define ERROR_I24_DEVICE_IN_USE 20
+#define ERROR_I24_QUIET_INIT_FAIL 21
+#endif
+
+#include "usbcalls.h"
+
+#define IOCAT_USBRES 0x000000A0 /* USB Resource device control */
+#define IOCTLF_NUMDEVICE 0x00000031 /* Get Number of plugged in Devices */
+#define IOCTLF_GETINFO 0x00000032 /* Get Info About a device */
+#define IOCTLF_AQUIREDEVICE 0x00000033
+#define IOCTLF_RELEASEDEVICE 0x00000034
+#define IOCTLF_GETSTRING 0x00000035
+#define IOCTLF_SENDCONTROLURB 0x00000036
+#define IOCTLF_SENDBULKURB 0x00000037 /* Send */
+#define IOCTLF_START_IRQ_PROC 0x00000038 /* Start IRQ polling in a buffer */
+#define IOCTLF_GETDEVINFO 0x00000039 /* Get information about device */
+#define IOCTLF_STOP_IRQ_PROC 0x0000003A /* Stop IRQ Polling */
+#define IOCTLF_START_ISO_PROC 0x0000003B /* Start ISO buffering in a Ringbuffer */
+#define IOCTLF_STOP_ISO_PROC 0x0000003C /* Stop ISO buffering */
+#define IOCTLF_CANCEL_IORB 0x0000003D /* Abort an IORB; */
+#define IOCTLF_SELECT_BULKPIPE 0x0000003E /* Select which Bulk endpoints can be used via Read/Write */
+#define IOCTLF_SENDIRQURB 0x0000003F /* Start IRQ polling in a buffer */
+#define IOCTLF_FIXUPDEVUCE 0x00000040 /* Fixup USB device configuration data */
+#define IOCTLF_REG_STATUSSEM 0x00000041 /* Register Semaphore for general Statuschange */
+#define IOCTLF_DEREG_STATUSSEM 0x00000042 /* Deregister Semaphore */
+#define IOCTLF_REG_DEVICESEM 0x00000043 /* Register Semaphore for a vendor&deviceID */
+#define IOCTLF_DEREG_DEVICESEM 0x00000044 /* Deregister Semaphore */
+
+
+#define NOTIFY_FREE 0
+#define NOTIFY_CHANGE 1
+#define NOTIFY_DEVICE 2
+#define MAX_NOTIFICATIONS 256
+
+#pragma pack(1)
+
+typedef struct
+{
+ HEV hDeviceAdded;
+ HEV hDeviceRemoved;
+ USHORT usFlags;
+ USHORT usVendor;
+ USHORT usProduct;
+ USHORT usBCDDevice;
+} NOTIFYENTRY, *PNOTIFYENTRY;
+
+#define DEV_SEM_ADD 0x00000001
+#define DEV_SEM_REMOVE 0x00000002
+#define DEV_SEM_MASK 0x00000003
+#define DEV_SEM_VENDORID 0x00000004
+#define DEV_SEM_PRODUCTID 0x00000008
+#define DEV_SEM_BCDDEVICE 0x00000010
+
+typedef struct{
+ ULONG ulSize;
+ ULONG ulCaps;
+ ULONG ulSemDeviceAdd;
+ ULONG ulSemDeviceRemove;
+} STATUSEVENTSET, * PSTATUSEVENTSET;
+
+
+typedef struct{
+ ULONG ulSize;
+ ULONG ulCaps;
+ ULONG ulSemDeviceAdd;
+ ULONG ulSemDeviceRemove;
+ USHORT usVendorID;
+ USHORT usProductID;
+ USHORT usBCDDevice;
+ USHORT usStatus;
+} DEVEVENTSET, * PDEVEVENTSET;
+
+typedef struct
+{
+ USHORT usVendorID;
+ USHORT usProductID;
+ USHORT usBCDDevice;
+ USHORT usDeviceNumber; /* Get the usDeviceNumber device in the system fi. if 2 acquire the 2nd device
+ 0 means first not acquired device. */
+} AQUIREDEV, *PAQUIREDEV;
+
+typedef struct
+{
+ UCHAR bRequestType;
+ UCHAR bRequest;
+ USHORT wValue;
+ USHORT wIndex;
+ USHORT wLength;
+ ULONG ulTimeout; /* in milliseconds */
+} SETUPPACKET, *PSETUPPACKET;
+
+typedef struct
+{
+ ULONG ulHandle;
+ UCHAR bRequestType;
+ UCHAR bRequest;
+ USHORT wValue;
+ USHORT wIndex;
+ USHORT wLength;
+ ULONG ulTimeout; /* in milliseconds */
+ USHORT usStatus;
+} USBCALLS_CTRL_REQ, *PUSBCALLS_CTRL_REQ;
+
+typedef struct
+{
+ ULONG ulDevHandle;
+ UCHAR ucEndpoint;
+ UCHAR ucAltInterface;
+ USHORT usStatus;
+ ULONG ulEvent;
+ ULONG ulID;
+} USBCALLS_ISO_START, *NPUSBCALLS_ISO_START, FAR *PUSBCALLS_ISO_START,
+ USBCALLS_IRQ_START, *NPUSBCALLS_IRQ_START, FAR *PUSBCALLS_IRQ_START,
+ USBCALLS_CANCEL_REQ, *NPUSBCALLS_CANCEL_REQ, FAR *PUSBCALLS_CANCEL_REQ;
+
+#define ISO_DIRMASK 0x80
+typedef struct
+{
+ ULONG hSemAccess; /* Synchronise access to the Pos values */
+ ULONG hDevice;
+ USHORT usPosWrite;
+ USHORT usPosRead;
+ USHORT usBufSize;
+ UCHAR ucEndpoint;
+ UCHAR ucAltInterface;
+ UCHAR ucBuffer[16*1023];
+} ISORINGBUFFER, *PISORINGBUFFER;
+
+typedef USBCALLS_ISO_START USBCALLS_ISO_STOP, * NPUSBCALLS_ISO_STOP, FAR *PUSBCALLS_ISO_STOP;
+typedef USBCALLS_ISO_START USBCALLS_IRQ_STOP, * NPUSBCALLS_IRQ_STOP, FAR *PUSBCALLS_IRQ_STOP;
+
+#define USB_TRANSFER_FULL_SIZE 0x01
+
+typedef struct
+{
+ ULONG ulDevHandle;
+ UCHAR ucEndpoint;
+ UCHAR ucAltInterface;
+ USHORT usStatus;
+ ULONG ulEvent;
+/* ULONG ulID; - yeah, right */
+ ULONG ulTimeout;
+ USHORT usDataProcessed;
+ USHORT usDataRemain;
+ USHORT usFlags;
+} USBCALLS_BULK_REQ, *PUSBCALLS_BULK_REQ;
+
+typedef struct
+{
+ ULONG ulDevHandle;
+ UCHAR ucEndpoint;
+ UCHAR ucAltInterface;
+ USHORT usStatus;
+ ULONG ulEvent;
+ ULONG ulID;
+ ULONG ulTimeout;
+ USHORT usDataLen;
+} LIBUSB_IRQ_REQ, *NPLIBUSB_IRQ_REQ, FAR *PLIBUSB_IRQ_REQ;
+
+typedef struct
+{
+ ULONG ulDevHandle;
+ UCHAR ucConfiguration;
+ UCHAR ucAltInterface;
+ USHORT usStatus;
+} LIBUSB_FIXUP, *NPLIBUSB_FIXUP, FAR *PLIBUSB_FIXUP;
+
+#pragma pack()
+
+/******************************************************************************/
+
+HFILE g_hUSBDrv;
+ULONG g_cInit;
+ULONG g_ulFreeNotifys;
+HMTX g_hSemNotifytable;
+NOTIFYENTRY g_Notifications[MAX_NOTIFICATIONS];
+
+HMTX g_hSemRingBuffers;
+PISORINGBUFFER g_pIsoRingBuffers;
+ULONG g_ulNumIsoRingBuffers;
+
+APIEXPORT APIRET APIENTRY
+InitUsbCalls(void)
+{
+ int i;
+ ULONG ulAction;
+ APIRET rc;
+
+ if (++g_cInit > 1)
+ return NO_ERROR;
+
+ rc = DosOpen( (PCSZ)"USBRESM$",
+ &g_hUSBDrv,
+ &ulAction,
+ 0,
+ FILE_NORMAL,
+ OPEN_ACTION_OPEN_IF_EXISTS,
+ OPEN_ACCESS_READWRITE |
+ OPEN_FLAGS_NOINHERIT |
+ OPEN_SHARE_DENYNONE,
+ 0 );
+ if(rc)
+ {
+ g_hUSBDrv = 0;
+ g_cInit = 0;
+
+ }
+ else
+ {
+ /* @@ToDO Add EnvVar or INI for dynamically setting the number */
+ g_ulNumIsoRingBuffers = 8;
+ for(i=0;i<MAX_NOTIFICATIONS;i++)
+ {
+ g_Notifications[i].usFlags = NOTIFY_FREE;
+ g_Notifications[i].hDeviceAdded = 0;
+ g_Notifications[i].hDeviceRemoved = 0;
+ g_Notifications[i].usVendor = 0;
+ g_Notifications[i].usProduct = 0;
+ g_Notifications[i].usBCDDevice = 0;
+ }
+ rc = DosAllocMem( (PPVOID)&g_pIsoRingBuffers,
+ g_ulNumIsoRingBuffers * sizeof(ISORINGBUFFER),
+ PAG_WRITE | PAG_COMMIT | OBJ_TILE);
+ if(!rc)
+ {
+ PISORINGBUFFER pIter = g_pIsoRingBuffers;
+ for(i=0;i< g_ulNumIsoRingBuffers;i++,pIter++)
+ {
+ pIter->hDevice = 0;
+ pIter->hSemAccess = 0; /* Synchronise access to the Pos values */
+ pIter->usPosWrite = 0;
+ pIter->usPosRead = 0;
+ pIter->usBufSize = 16*1023;
+ pIter->ucEndpoint = 0;
+ pIter->ucAltInterface = 0;
+ /*pIter->ucBuffer */
+ }
+ rc=DosCreateMutexSem(NULL,&g_hSemRingBuffers,DC_SEM_SHARED,FALSE);
+ if(!rc)
+ {
+ rc=DosCreateMutexSem(NULL,&g_hSemNotifytable,DC_SEM_SHARED,FALSE);
+ if(rc)
+ {
+ DosCloseMutexSem(g_hSemRingBuffers);
+ DosFreeMem(g_pIsoRingBuffers);
+ }
+ }
+ else
+ {
+ DosFreeMem(g_pIsoRingBuffers);
+ }
+ }
+
+ if(rc)
+ {
+ DosClose(g_hUSBDrv);
+ g_hUSBDrv = 0;
+ g_cInit = 0;
+ }
+ }
+ return g_cInit ? NO_ERROR : rc ? rc : ERROR_GEN_FAILURE;
+}
+
+APIEXPORT APIRET APIENTRY
+TermUsbCalls(void)
+{
+ if (!g_cInit)
+ return ERROR_GEN_FAILURE;
+ if(!--g_cInit)
+ {
+ int i;
+ for(i=0;i<MAX_NOTIFICATIONS;i++)
+ if( g_Notifications[i].usFlags != NOTIFY_FREE);
+ UsbDeregisterNotification((USBNOTIFY)(&g_Notifications[i]));
+
+ DosClose(g_hUSBDrv);
+ g_hUSBDrv = NULLHANDLE;
+
+ if (g_pIsoRingBuffers)
+ DosFreeMem(g_pIsoRingBuffers);
+
+ DosCloseMutexSem(g_hSemRingBuffers);
+ g_hSemRingBuffers = NULLHANDLE;
+ DosCloseMutexSem(g_hSemNotifytable);
+ g_hSemNotifytable = NULLHANDLE;
+ }
+ return NO_ERROR;
+}
+
+
+#ifdef VBOX /* complete wast of time */
+# define IsBadReadPointer(pBase, ulSize) (FALSE)
+# define IsBadWritePointer(pBase, ulSize) (FALSE)
+#else
+static BOOL IsBadReadPointer(PVOID pBase, ULONG ulSize)
+{
+ APIRET rc;
+ ULONG ulFlags;
+ rc = DosQueryMem(pBase, &ulSize, &ulFlags);
+
+ return rc!=0?TRUE:(ulFlags&PAG_READ)&&(ulFlags&PAG_COMMIT)?FALSE:TRUE;
+}
+
+static BOOL IsBadWritePointer(PVOID pBase, ULONG ulSize)
+{
+ APIRET rc;
+ ULONG ulFlags;
+ rc = DosQueryMem(pBase, &ulSize, &ulFlags);
+
+ return rc!=0?TRUE:((ulFlags&PAG_WRITE)==PAG_WRITE&&(ulFlags&PAG_COMMIT)==PAG_COMMIT)?FALSE:TRUE;
+}
+#endif
+
+APIEXPORT APIRET APIENTRY
+UsbQueryNumberDevices(ULONG *pulNumDev)
+{
+ APIRET rc;
+ ULONG ulLength;
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ if( IsBadWritePointer(pulNumDev,sizeof(ULONG)) )
+ return ERROR_INVALID_PARAMETER;
+ ulLength=sizeof(ULONG);
+ *pulNumDev = 0;
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_NUMDEVICE,
+ NULL, 0, NULL,
+ pulNumDev, ulLength, &ulLength);
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbQueryDeviceReport(ULONG ulDevNumber, ULONG *pulBufLen, PVOID pData)
+{
+ APIRET rc;
+ ULONG ulParmLen;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ if( IsBadWritePointer(pulBufLen, sizeof(ULONG)) )
+ return ERROR_INVALID_PARAMETER;
+
+ if( pData!=NULL && IsBadWritePointer(pData,*pulBufLen) )
+ return ERROR_INVALID_PARAMETER;
+ if(pData==NULL)
+ *pulBufLen = 0;
+ ulParmLen = sizeof(ulDevNumber);
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_GETINFO,
+ (PVOID)&ulDevNumber, ulParmLen, &ulParmLen,
+ pData, *pulBufLen, pulBufLen);
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbRegisterChangeNotification( PUSBNOTIFY pNotifyID,
+ HEV hDeviceAdded,
+ HEV hDeviceRemoved)
+{
+ APIRET rc;
+ int i;
+ STATUSEVENTSET EventSet;
+ ULONG ulSize;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ if( IsBadWritePointer(pNotifyID, sizeof(ULONG)) ||
+ (hDeviceAdded==0 && hDeviceRemoved==0) )
+ return ERROR_INVALID_PARAMETER;
+
+ ulSize = sizeof(EventSet);
+ EventSet.ulSize = ulSize;
+ EventSet.ulCaps = 0;
+
+ if(hDeviceAdded!=0)
+ {
+ ULONG ulCnt;
+ rc = DosQueryEventSem(hDeviceAdded,&ulCnt);
+ if(rc)
+ return rc;
+ EventSet.ulCaps |= DEV_SEM_ADD;
+ EventSet.ulSemDeviceAdd = hDeviceAdded;
+ }
+
+ if(hDeviceRemoved!=0)
+ {
+ ULONG ulCnt;
+ rc = DosQueryEventSem(hDeviceRemoved,&ulCnt);
+ if(rc)
+ return rc;
+ EventSet.ulCaps |= DEV_SEM_REMOVE;
+ EventSet.ulSemDeviceRemove = hDeviceRemoved;
+ }
+
+ rc = DosRequestMutexSem(g_hSemNotifytable,SEM_INDEFINITE_WAIT);
+ if(rc)
+ return rc;
+
+ for(i=0;i<MAX_NOTIFICATIONS;i++)
+ {
+ if( g_Notifications[i].usFlags == NOTIFY_FREE)
+ {
+ g_Notifications[i].usFlags = NOTIFY_CHANGE;
+ g_Notifications[i].hDeviceAdded = hDeviceAdded;
+ g_Notifications[i].hDeviceRemoved = hDeviceRemoved;
+ g_Notifications[i].usVendor = 0;
+ g_Notifications[i].usProduct = 0;
+ g_Notifications[i].usBCDDevice = 0;
+ break;
+ }
+ }
+ DosReleaseMutexSem(g_hSemNotifytable);
+ if(i==MAX_NOTIFICATIONS)
+ return USB_ERROR_NO_MORE_NOTIFICATIONS;
+
+ /* @@ToDo come up with a better way to generate IDs */
+ *pNotifyID = (USBNOTIFY) (&g_Notifications[i]);
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_REG_STATUSSEM,
+ NULL, 0, NULL,
+ &EventSet,ulSize, &ulSize);
+ if(rc)
+ {
+ g_Notifications[i].usFlags = NOTIFY_FREE;
+ *pNotifyID = 0;
+ }
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbRegisterDeviceNotification( PUSBNOTIFY pNotifyID,
+ HEV hDeviceAdded,
+ HEV hDeviceRemoved,
+ USHORT usVendor,
+ USHORT usProduct,
+ USHORT usBCDVersion)
+{
+ DEVEVENTSET EventSet;
+ ULONG ulCnt,ulSize;
+ int i;
+ APIRET rc;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ if( IsBadWritePointer(pNotifyID, sizeof(ULONG)) ||
+ hDeviceAdded==0 || hDeviceRemoved==0 ||
+ usVendor == 0 || usVendor == 0xFFFF ||
+ usProduct == 0 || usProduct == 0xFFFF )
+ return ERROR_INVALID_PARAMETER;
+
+
+ rc = DosQueryEventSem(hDeviceAdded,&ulCnt);
+ if(rc)
+ return rc;
+ rc = DosQueryEventSem(hDeviceRemoved,&ulCnt);
+ if(rc)
+ return rc;
+
+ ulSize = sizeof(EventSet);
+ EventSet.ulSize = ulSize;
+ EventSet.ulCaps = DEV_SEM_ADD | DEV_SEM_REMOVE |
+ DEV_SEM_VENDORID | DEV_SEM_PRODUCTID |
+ DEV_SEM_BCDDEVICE ;
+ EventSet.ulSemDeviceAdd = hDeviceAdded;
+ EventSet.ulSemDeviceRemove = hDeviceRemoved;
+ EventSet.usVendorID = usVendor;
+ EventSet.usProductID = usProduct;
+ EventSet.usBCDDevice = usBCDVersion;
+ EventSet.usStatus = 0;
+
+ rc = DosRequestMutexSem(g_hSemNotifytable,SEM_INDEFINITE_WAIT);
+
+ if(rc)
+ return rc;
+
+ for(i=0;i<MAX_NOTIFICATIONS;i++)
+ {
+ if( g_Notifications[i].usFlags == NOTIFY_FREE)
+ {
+ g_Notifications[i].usFlags = NOTIFY_DEVICE;
+ g_Notifications[i].hDeviceAdded = hDeviceAdded;
+ g_Notifications[i].hDeviceRemoved = hDeviceRemoved;
+ g_Notifications[i].usVendor = usVendor;
+ g_Notifications[i].usProduct = usProduct;
+ g_Notifications[i].usBCDDevice = usBCDVersion;
+ break;
+ }
+ }
+ DosReleaseMutexSem(g_hSemNotifytable);
+ if(i==MAX_NOTIFICATIONS)
+ return USB_ERROR_NO_MORE_NOTIFICATIONS;
+
+ /* @@ToDo come up with a better way to generate IDs */
+ *pNotifyID = (USBNOTIFY) (&g_Notifications[i]);
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_REG_DEVICESEM,
+ NULL, 0, NULL,
+ &EventSet,ulSize, &ulSize);
+ if(rc)
+ {
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) )
+ rc= ERROR_INVALID_PARAMETER;
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) )
+ rc= EventSet.usStatus;
+
+ g_Notifications[i].usFlags = NOTIFY_FREE;
+ *pNotifyID = 0;
+ }
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbDeregisterNotification( USBNOTIFY NotifyID )
+{
+ DEVEVENTSET EventSet;
+ USBNOTIFY MinID,MaxID;
+ ULONG Index, ulFunction, ulSize;
+ APIRET rc;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ MinID = (USBNOTIFY) (&g_Notifications[0]);
+ MaxID = (USBNOTIFY) (&g_Notifications[MAX_NOTIFICATIONS-1]);
+
+ if(NotifyID<MinID || NotifyID>MaxID)
+ return ERROR_INVALID_PARAMETER;
+
+ Index = NotifyID - MinID;
+
+ if(Index % sizeof(NOTIFYENTRY))
+ return ERROR_INVALID_PARAMETER;
+
+ Index /= sizeof(NOTIFYENTRY);
+
+ rc = DosRequestMutexSem(g_hSemNotifytable,SEM_INDEFINITE_WAIT);
+
+ switch(g_Notifications[Index].usFlags)
+ {
+ case NOTIFY_FREE:
+ DosReleaseMutexSem(g_hSemNotifytable);
+ return ERROR_INVALID_PARAMETER;
+ case NOTIFY_CHANGE:
+ ulFunction = IOCTLF_DEREG_STATUSSEM;
+ ulSize = sizeof(STATUSEVENTSET);
+ EventSet.ulSize = ulSize;
+ EventSet.ulCaps = DEV_SEM_ADD | DEV_SEM_REMOVE;
+ EventSet.ulSemDeviceAdd = g_Notifications[Index].hDeviceAdded;
+ EventSet.ulSemDeviceRemove = g_Notifications[Index].hDeviceRemoved;
+ break;
+ case NOTIFY_DEVICE:
+ ulFunction = IOCTLF_DEREG_DEVICESEM;
+ ulSize = sizeof(DEVEVENTSET);
+ EventSet.ulSize = ulSize;
+ EventSet.ulCaps = DEV_SEM_ADD | DEV_SEM_REMOVE |
+ DEV_SEM_VENDORID | DEV_SEM_PRODUCTID |
+ DEV_SEM_BCDDEVICE ;
+ EventSet.ulSemDeviceAdd = g_Notifications[Index].hDeviceAdded;
+ EventSet.ulSemDeviceRemove = g_Notifications[Index].hDeviceRemoved;
+ EventSet.usVendorID = g_Notifications[Index].usVendor;
+ EventSet.usProductID = g_Notifications[Index].usProduct;
+ EventSet.usBCDDevice = g_Notifications[Index].usBCDDevice;
+ EventSet.usStatus = 0;
+ break;
+ default:
+ DosReleaseMutexSem(g_hSemNotifytable);
+ return ERROR_GEN_FAILURE;
+ }
+
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, ulFunction,
+ NULL, 0, NULL,
+ &EventSet,ulSize, &ulSize);
+ if(0==rc)
+ {
+ g_Notifications[Index].usFlags = NOTIFY_FREE;
+ g_Notifications[Index].hDeviceAdded = 0;
+ g_Notifications[Index].hDeviceRemoved = 0;
+ g_Notifications[Index].usVendor = 0;
+ g_Notifications[Index].usProduct = 0;
+ g_Notifications[Index].usBCDDevice = 0;
+ } else
+ {
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) )
+ rc= ERROR_INVALID_PARAMETER;
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) )
+ rc= EventSet.usStatus;
+ }
+ DosReleaseMutexSem(g_hSemNotifytable);
+
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbOpen( PUSBHANDLE pHandle,
+ USHORT usVendor,
+ USHORT usProduct,
+ USHORT usBCDDevice,
+ USHORT usEnumDevice)
+{
+ ULONG ulCat, ulFunc;
+ ULONG ulParmLen, ulDataLen;
+ AQUIREDEV Aquire;
+ APIRET rc;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+ if(IsBadWritePointer(pHandle,sizeof(USBHANDLE)) )
+ return ERROR_INVALID_PARAMETER;
+
+ Aquire.usVendorID = usVendor;
+ Aquire.usProductID = usProduct;
+ Aquire.usBCDDevice = usBCDDevice;
+ Aquire.usDeviceNumber = usEnumDevice;
+ ulCat = 0xA0;
+ ulFunc = 0x33;
+ ulParmLen = sizeof(Aquire);
+ ulDataLen = sizeof(USBHANDLE);
+ rc = DosDevIOCtl( g_hUSBDrv,
+ ulCat,ulFunc, /*IOCAT_USBRES, IOCTLF_AQUIREDEVICE, */
+ &Aquire, ulParmLen, &ulParmLen,
+ pHandle, ulDataLen, &ulDataLen);
+
+ /* @@ ToDO maybe gether some info about device here (endpoints etc for safety checks) */
+ return rc;
+
+}
+
+APIEXPORT APIRET APIENTRY
+UsbClose( USBHANDLE Handle)
+{
+ APIRET rc;
+ ULONG ulDataLen,ulParmLen;
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ ulParmLen = sizeof(USBHANDLE);
+ ulDataLen = 0;
+
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_RELEASEDEVICE,
+ (PVOID)&Handle, ulParmLen, &ulParmLen,
+ NULL, ulDataLen, &ulDataLen);
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbCtrlMessage( USBHANDLE Handle,
+ UCHAR ucRequestType,
+ UCHAR ucRequest,
+ USHORT usValue,
+ USHORT usIndex,
+ USHORT usLength,
+ PVOID pData,
+ ULONG ulTimeout)
+{
+ APIRET rc;
+ USBCALLS_CTRL_REQ CtrlRequest;
+ ULONG ulParmLen, ulDataLen;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ ulParmLen = sizeof(USBCALLS_CTRL_REQ);
+ CtrlRequest.ulHandle = Handle;
+ CtrlRequest.bRequestType = ucRequestType;
+ CtrlRequest.bRequest = ucRequest;
+ CtrlRequest.wValue = usValue;
+ CtrlRequest.wIndex = usIndex;
+ CtrlRequest.wLength = usLength;
+ CtrlRequest.ulTimeout = ulTimeout;
+ ulDataLen = usLength;
+
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_SENDCONTROLURB,
+ (PVOID)&CtrlRequest, ulParmLen, &ulParmLen,
+ ulDataLen>0?(PVOID)pData:NULL,
+ ulDataLen,
+ ulDataLen>0?&ulDataLen:NULL);
+ if( rc != NO_ERROR )
+ {
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) )
+ rc= ERROR_INVALID_PARAMETER;
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) )
+ rc= CtrlRequest.usStatus;
+ }
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbBulkRead( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR AltInterface,
+ ULONG *ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout)
+{
+ return UsbBulkRead2(Handle, Endpoint, AltInterface, TRUE /* fShortOk */, ulNumBytes, pvData, ulTimeout);
+}
+
+APIEXPORT APIRET APIENTRY
+UsbBulkRead2( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR AltInterface,
+ BOOL fShortOk,
+ ULONG *ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout)
+{
+ APIRET rc;
+ ULONG ulParmLen, ulDataLen, ulToProcess, ulTotalProcessed;
+ USBCALLS_BULK_REQ BulkRequest;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ if(*ulNumBytes==0)
+ return 0;
+
+ /* just require this */
+ if ((ULONG)pvData & 0xfff)
+ return ERROR_INVALID_ADDRESS;
+ if ((ULONG)pvData >= 0x20000000)
+ return ERROR_INVALID_ADDRESS;
+
+ ulToProcess = *ulNumBytes;
+ ulTotalProcessed = 0;
+
+ do
+ {
+ /* Process up to 64k, making sure we're working on segments. */
+ ulDataLen = 0x10000 - ((ULONG)pvData & 0xffff);
+ if (ulDataLen > ulToProcess)
+ ulDataLen = ulToProcess;
+
+ ulParmLen = sizeof(USBCALLS_BULK_REQ);
+
+ memset(&BulkRequest, 0, sizeof(BulkRequest));
+ BulkRequest.ulDevHandle = Handle;
+ BulkRequest.ucEndpoint = Endpoint;
+ BulkRequest.ucAltInterface = AltInterface;
+ BulkRequest.usStatus = 0;
+ BulkRequest.ulEvent = 0;
+ //BulkRequest.ulID = (ULONG)pvData;
+ BulkRequest.ulTimeout = ulTimeout;
+ BulkRequest.usDataProcessed = 0;
+ BulkRequest.usDataRemain = ulDataLen;
+ BulkRequest.usFlags = fShortOk && ulDataLen == ulToProcess ? 0 : USB_TRANSFER_FULL_SIZE;
+
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_SENDBULKURB,
+ (PVOID)&BulkRequest, ulParmLen, &ulParmLen,
+ pvData, ulDataLen, &ulDataLen);
+ Log(("BulkRead: usStatus=%d rc=%ld usDataProcessed=%d usDataRemain=%d ulDataLen=%ld\n",
+ BulkRequest.usStatus, rc, BulkRequest.usDataProcessed, BulkRequest.usDataRemain, ulDataLen));
+
+ if (rc != NO_ERROR)
+ {
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) )
+ rc= ERROR_INVALID_PARAMETER;
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) )
+ rc= BulkRequest.usStatus;
+ break;
+ }
+
+ /* Adjust count and source pointer */
+ ulToProcess -= ulDataLen;
+ pvData = (PBYTE)pvData + ulDataLen;
+ ulTotalProcessed += BulkRequest.usDataProcessed;
+
+ if (BulkRequest.usDataProcessed != ulDataLen)
+ {
+ /* Transferred less than we wanted? so something is wrong,
+ or device doesn't wish to send more, exit loop */
+ rc = USB_ERROR_LESSTRANSFERED;
+ break;
+ }
+ } while( ulToProcess>0 );
+
+ *ulNumBytes = ulTotalProcessed;
+
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbBulkWrite( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR AltInterface,
+ ULONG ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout)
+{
+ return UsbBulkWrite2(Handle, Endpoint, AltInterface, FALSE /* fShortOk */, ulNumBytes, pvData, ulTimeout);
+}
+
+APIEXPORT APIRET APIENTRY
+UsbBulkWrite2( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR AltInterface,
+ BOOL fShortOk,
+ ULONG ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout)
+{
+ APIRET rc;
+ ULONG ulParmLen, ulDataLen;
+ USBCALLS_BULK_REQ BulkRequest;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ /* just require this */
+ if ((ULONG)pvData & 0xfff)
+ return ERROR_INVALID_ADDRESS;
+ if ((ULONG)pvData >= 0x20000000)
+ return ERROR_INVALID_ADDRESS;
+
+ do
+ {
+ /* Process up to 64k, making sure we're working on segments. */
+ ulDataLen = 0x10000 - ((ULONG)pvData & 0xffff);
+ if (ulDataLen > ulNumBytes)
+ ulDataLen = ulNumBytes;
+
+ ulParmLen = sizeof(USBCALLS_BULK_REQ);
+
+ memset(&BulkRequest, 0, sizeof(BulkRequest));
+ BulkRequest.ulDevHandle = Handle;
+ BulkRequest.ucEndpoint = Endpoint;
+ BulkRequest.ucAltInterface = AltInterface;
+ BulkRequest.usStatus = 0;
+ BulkRequest.ulEvent = 0;
+ //BulkRequest.ulID = (ULONG)pvData;
+ BulkRequest.ulTimeout = ulTimeout;
+ BulkRequest.usDataProcessed = 0;
+ BulkRequest.usDataRemain = ulDataLen;
+ BulkRequest.usFlags = fShortOk && ulDataLen == ulNumBytes ? 0 : USB_TRANSFER_FULL_SIZE;
+
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_SENDBULKURB,
+ &BulkRequest, ulParmLen, &ulParmLen,
+ pvData, ulDataLen, &ulDataLen );
+ Log(("BulkWrite: usStatus=%d rc=%ld usDataProcessed=%d usDataRemain=%d ulDataLen=%ld\n",
+ BulkRequest.usStatus, rc, BulkRequest.usDataProcessed, BulkRequest.usDataRemain, ulDataLen));
+ if (rc != NO_ERROR)
+ {
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) )
+ rc= ERROR_INVALID_PARAMETER;
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) )
+ rc= BulkRequest.usStatus;
+ break;
+ }
+ /* Adjust count and source pointer */
+ ulNumBytes -= ulDataLen;
+ pvData = (PBYTE)pvData + ulDataLen;
+ } while( ulNumBytes > 0 );
+
+ return rc;
+}
+
+APIRET APIENTRY
+UsbIrqStart( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR AltInterface,
+ USHORT ulNumBytes,
+ PVOID pData,
+ PHEV pHevModified)
+{
+ APIRET rc;
+ ULONG ulParmLen, ulDataLen;
+ USBCALLS_IRQ_START IrqStart;
+ HEV hEvent;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ if(0==ulNumBytes || IsBadWritePointer(pData, ulNumBytes))
+ return ERROR_INVALID_PARAMETER;
+
+ rc = DosCreateEventSem( NULL,
+ &hEvent,
+ DC_SEM_SHARED,
+ FALSE);
+ if(rc)
+ return rc;
+
+ IrqStart.ulDevHandle = Handle;
+ IrqStart.ucEndpoint = Endpoint;
+ IrqStart.ucAltInterface = AltInterface;
+ IrqStart.usStatus = 0;
+ IrqStart.ulEvent = hEvent;
+ ulParmLen = sizeof(IrqStart);
+ ulDataLen = ulNumBytes;
+
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_START_IRQ_PROC,
+ (PVOID)&IrqStart, ulParmLen, &ulParmLen,
+ pData, ulDataLen,&ulDataLen);
+ if(rc)
+ DosCloseEventSem(hEvent);
+ else
+ *pHevModified = hEvent;
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbIrqStop( USBHANDLE Handle,
+ HEV HevModified)
+{
+ APIRET rc;
+ ULONG ulParmLen, ulDataLen;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ ulParmLen = sizeof(Handle);
+ ulDataLen = sizeof(HevModified);
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_STOP_IRQ_PROC,
+ (PVOID)&Handle, ulParmLen, &ulParmLen,
+ &HevModified, ulDataLen, &ulDataLen);
+ if(!rc)
+ DosCloseEventSem(HevModified);
+
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbIsoStart( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR AltInterface,
+ ISOHANDLE *phIso)
+{
+ APIRET rc;
+ PISORINGBUFFER pIter = g_pIsoRingBuffers;
+ USBCALLS_ISO_START IsoStart;
+ ULONG ulParmLen, ulDataLen;
+ int i;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ rc = DosRequestMutexSem(g_hSemRingBuffers,SEM_INDEFINITE_WAIT);
+ if(rc)
+ return rc;
+
+ for(i=0;i< g_ulNumIsoRingBuffers;i++,pIter++)
+ {
+ if (pIter->hDevice==0)
+ {
+ pIter->hDevice = Handle;
+ break;
+ }
+ }
+ DosReleaseMutexSem(g_hSemRingBuffers);
+
+ if(i==g_ulNumIsoRingBuffers)
+ return USB_ERROR_OUTOF_RESOURCES;
+
+ IsoStart.ulDevHandle = Handle;
+ IsoStart.ucEndpoint = Endpoint;
+ IsoStart.ucAltInterface = AltInterface;
+ ulParmLen = sizeof(IsoStart);
+ ulDataLen = sizeof(ISORINGBUFFER);
+
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_STOP_IRQ_PROC,
+ (PVOID)&IsoStart, ulParmLen, &ulParmLen,
+ pIter, ulDataLen, &ulDataLen);
+ if(rc)
+ {
+ pIter->hDevice = 0;
+ *phIso = 0;
+ }
+ else
+ {
+ pIter->ucEndpoint = Endpoint;
+ pIter->ucAltInterface = AltInterface;
+ }
+ return rc;
+}
+
+static APIRET IsInvalidIsoHandle(const ISOHANDLE hIso)
+{
+ PISORINGBUFFER pIter;
+ ULONG i;
+ pIter = g_pIsoRingBuffers;
+
+ for(i=0;i<g_ulNumIsoRingBuffers;i++,pIter++)
+ {
+ if(pIter==(PISORINGBUFFER)hIso && pIter->hDevice)
+ return 0;
+ }
+ return ERROR_INVALID_PARAMETER;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbIsoStop( ISOHANDLE hIso)
+{
+
+ APIRET rc = NO_ERROR;
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+/* rc = DosDevIOCtl( g_hUSBDrv, */
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbIsoDequeue( ISOHANDLE hIso,
+ PVOID pBuffer,
+ ULONG ulNumBytes)
+{
+ APIRET rc;
+ PISORINGBUFFER pRB = (PISORINGBUFFER)hIso;
+
+ rc = IsInvalidIsoHandle(hIso);
+ if(rc)
+ return rc;
+ if(!(pRB->ucEndpoint & ISO_DIRMASK))
+ return ERROR_INVALID_PARAMETER;
+
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbIsoPeekQueue( ISOHANDLE hIso,
+ UCHAR * pByte,
+ ULONG ulOffset)
+{
+ APIRET rc;
+ PISORINGBUFFER pRB = (PISORINGBUFFER)hIso;
+
+ rc = IsInvalidIsoHandle(hIso);
+ if(rc)
+ return rc;
+ if(!(pRB->ucEndpoint & ISO_DIRMASK))
+ return ERROR_INVALID_PARAMETER;
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbIsoEnqueue( ISOHANDLE hIso,
+ const UCHAR * pBuffer,
+ ULONG ulNumBytes)
+{
+ APIRET rc;
+ PISORINGBUFFER pRB = (PISORINGBUFFER)hIso;
+
+ rc = IsInvalidIsoHandle(hIso);
+ if(rc)
+ return rc;
+ if(pRB->ucEndpoint & ISO_DIRMASK)
+ return ERROR_INVALID_PARAMETER;
+
+ return rc;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbIsoGetLength( ISOHANDLE hIso,
+ ULONG *pulLength)
+{
+ APIRET rc;
+ PISORINGBUFFER pRB = (PISORINGBUFFER) hIso;
+ USHORT ri,wi;
+
+ rc = IsInvalidIsoHandle(hIso);
+ if(rc)
+ return rc;
+ wi = pRB->usPosWrite;
+ ri = pRB->usPosRead;
+
+ if (ri == wi)
+ *pulLength = 0;
+ else if (ri < wi)
+ *pulLength = wi - ri;
+ else
+ *pulLength = wi + (pRB->usBufSize - ri);
+
+ return 0;
+}
+
+APIEXPORT APIRET APIENTRY
+UsbIrqRead( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR AltInterface,
+ ULONG *ulNumBytes,
+ PVOID pData,
+ ULONG ulTimeout)
+{
+ APIRET rc;
+ ULONG ulParmLen, ulDataLen;
+ LIBUSB_IRQ_REQ IrqRequest;
+
+ if(!g_cInit)
+ return USB_NOT_INIT;
+
+ /* 10 01 2003 - KIEWITZ -> Still @@ToDo Add Endpoint check based on descriptors
+ We currently only allow Endpoint-addresses 80h->8Fh here */
+ if ((Endpoint<0x80) || (Endpoint>0x8F))
+ return USB_ERROR_INVALID_ENDPOINT;
+
+ if(*ulNumBytes==0)
+ return 0;
+
+ IrqRequest.ulDevHandle = Handle;
+ IrqRequest.ucEndpoint = Endpoint;
+ IrqRequest.ucAltInterface = AltInterface;
+ IrqRequest.usStatus = 0;
+ IrqRequest.ulEvent = 0;
+ IrqRequest.ulTimeout = ulTimeout;
+ ulParmLen = sizeof(LIBUSB_IRQ_REQ);
+ ulDataLen = *ulNumBytes;
+
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_SENDIRQURB,
+ (PVOID)&IrqRequest, ulParmLen, &ulParmLen,
+ pData, ulDataLen, &ulDataLen);
+
+ if( rc == NO_ERROR )
+ {
+ *ulNumBytes = IrqRequest.usDataLen;
+ } else
+ {
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) )
+ rc= ERROR_INVALID_PARAMETER;
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) )
+ rc= IrqRequest.usStatus;
+ }
+ return rc;
+}
+
+
+APIEXPORT APIRET APIENTRY
+UsbFixupDevice( USBHANDLE Handle,
+ UCHAR ucConfiguration,
+ UCHAR *pucConfigurationData,
+ ULONG ulConfigurationLen )
+{
+ LIBUSB_FIXUP request;
+ ULONG ulParmLen;
+ APIRET rc;
+
+ request.ulDevHandle= Handle;
+ request.ucConfiguration= ucConfiguration;
+ request.usStatus= 0;
+ ulParmLen= sizeof(LIBUSB_FIXUP);
+ rc = DosDevIOCtl( g_hUSBDrv,
+ IOCAT_USBRES, IOCTLF_FIXUPDEVUCE,
+ (PVOID)&request, ulParmLen, &ulParmLen,
+ pucConfigurationData, ulConfigurationLen, &ulConfigurationLen);
+ if( rc != NO_ERROR )
+ {
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) )
+ rc= ERROR_INVALID_PARAMETER;
+ if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) )
+ rc= request.usStatus;
+ }
+ return rc;
+}
+
+#ifndef STATIC_USBCALLS
+ /*+-------------------------------------------------------------------+*/
+ /*| _CRT_init is the C run-time environment initialization function. |*/
+ /*|It will return 0 to indicate success and -1 to indicate failure. |*/
+ /*+-------------------------------------------------------------------+*/
+
+/* int _CRT_init (void); */
+
+ /*+-------------------------------------------------------------------+*/
+ /*| _CRT_term is the C run-time environment termination function. |*/
+ /*+-------------------------------------------------------------------+*/
+
+/* void _CRT_term (unsigned long);*/
+
+ /*+-------------------------------------------------------------------+*/
+ /*| _DLL_InitTerm is the function that gets called by the operating |*/
+ /*| system loader when it loads and frees this DLL for each process |*/
+ /*| that accesses this DLL. However, it only gets called the first |*/
+ /*| time the DLL is loaded and the last time it is freed for a |*/
+ /*| particular process. The system linkage convention must be used |*/
+ /*| because the operating system loader is calling this function. |*/
+ /*+-------------------------------------------------------------------+*/
+
+#ifdef STATIC_LINK
+int _CRT_init (void);
+void _CRT_term(0UL);
+#endif
+
+unsigned long _System _DLL_InitTerm (unsigned long modhandle, unsigned long flag)
+{
+
+ /* If flag is zero then the DLL is being loaded so initialization */
+ /* should be performed. If flag is 1 then the DLL is being freed */
+ /* so termination should be performed. */
+
+ switch (flag)
+ {
+ case 0:
+ /* The C run-time environment initialization function must */
+ /* be called before any calls to C run-time functions that */
+ /* are not inlined. */
+
+#ifdef STATIC_LINK
+ if (_CRT_init () == -1)
+ return 0UL;
+#endif
+ InitUsbCalls();
+ break;
+
+ case 1:
+ TermUsbCalls();
+#ifdef STATIC_LINK
+ _CRT_term(0UL);
+#endif
+ break;
+
+ default:
+ return 0UL;
+
+ }
+
+ /* A nonzero value must be returned to indicate success. */
+ return 1UL;
+}
+#endif /* !STATIC_USBCALLS */
+
diff --git a/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.h b/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.h
new file mode 100644
index 00000000..151a5bc1
--- /dev/null
+++ b/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.h
@@ -0,0 +1,242 @@
+
+#ifndef VBOX_INCLUDED_SRC_VBoxUSB_os2_usbcalls_h
+#define VBOX_INCLUDED_SRC_VBoxUSB_os2_usbcalls_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+typedef ULONG USBHANDLE, *PUSBHANDLE;
+typedef ULONG USBNOTIFY, *PUSBNOTIFY;
+typedef ULONG ISOHANDLE, *PISOHANDLE;
+
+#define USB_NOT_INIT 7000
+#define USB_ERROR_NO_MORE_NOTIFICATIONS 7001
+#define USB_ERROR_OUTOF_RESOURCES 7002
+#define USB_ERROR_INVALID_ENDPOINT 7003
+#define USB_ERROR_LESSTRANSFERED 7004
+
+/* IORB status codes */
+#define USB_IORB_DONE 0x0000
+#define USB_IORB_FAILED 0x8000
+
+#define USB_ANY_PRODUCTVERSION 0xFFFF
+#define USB_OPEN_FIRST_UNUSED 0
+
+#ifdef USB_BIND_DYNAMIC
+ typedef APIRET APIENTRY USBREGISTERDEVICENOTIFICATION( PUSBNOTIFY pNotifyID,
+ HEV hDeviceAdded,
+ HEV hDeviceRemoved,
+ USHORT usVendor,
+ USHORT usProduct,
+ USHORT usBCDVersion);
+ typedef USBREGISTERDEVICENOTIFICATION *PUSBREGISTERDEVICENOTIFICATION;
+
+ typedef APIRET APIENTRY USBDEREGISTERNOTIFICATION( USBNOTIFY NotifyID);
+
+ typedef USBDEREGISTERNOTIFICATION *PUSBDEREGISTERNOTIFICATION;
+
+ typedef APIRET APIENTRY USBOPEN( PUSBHANDLE pHandle,
+ USHORT usVendor,
+ USHORT usProduct,
+ USHORT usBCDDevice,
+ USHORT usEnumDevice);
+ typedef USBOPEN *PUSBOPEN;
+ typedef APIRET APIENTRY USBCLOSE( USBHANDLE Handle);
+ typedef USBCLOSE *PUSBCLOSE;
+
+ typedef APIRET APIENTRY USBCTRLMESSAGE( USBHANDLE Handle,
+ UCHAR ucRequestType,
+ UCHAR ucRequest,
+ USHORT usValue,
+ USHORT usIndex,
+ USHORT usLength,
+ PVOID pvData,
+ ULONG ulTimeout);
+ typedef USBCTRLMESSAGE *PUSBCTRLMESSAGE;
+#else
+ APIRET APIENTRY UsbQueryNumberDevices( ULONG *pulNumDev);
+
+ APIRET APIENTRY UsbQueryDeviceReport( ULONG ulDevNumber,
+ ULONG *ulBufLen,
+ PVOID pvData);
+ APIRET APIENTRY UsbRegisterChangeNotification( PUSBNOTIFY pNotifyID,
+ HEV hDeviceAdded,
+ HEV hDeviceRemoved);
+
+ APIRET APIENTRY UsbRegisterDeviceNotification( PUSBNOTIFY pNotifyID,
+ HEV hDeviceAdded,
+ HEV hDeviceRemoved,
+ USHORT usVendor,
+ USHORT usProduct,
+ USHORT usBCDVersion);
+
+ APIRET APIENTRY UsbDeregisterNotification( USBNOTIFY NotifyID);
+
+ APIRET APIENTRY UsbOpen( PUSBHANDLE pHandle,
+ USHORT usVendor,
+ USHORT usProduct,
+ USHORT usBCDDevice,
+ USHORT usEnumDevice);
+
+ APIRET APIENTRY UsbClose( USBHANDLE Handle);
+
+ APIRET APIENTRY UsbCtrlMessage( USBHANDLE Handle,
+ UCHAR ucRequestType,
+ UCHAR ucRequest,
+ USHORT usValue,
+ USHORT usIndex,
+ USHORT usLength,
+ PVOID pvData,
+ ULONG ulTimeout);
+
+ APIRET APIENTRY UsbBulkRead( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR Interface,
+ ULONG *ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout);
+
+ APIRET APIENTRY UsbBulkRead2( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR Interface,
+ BOOL fShortOk,
+ ULONG *ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout);
+
+ APIRET APIENTRY UsbBulkWrite( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR Interface,
+ ULONG ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout);
+
+ APIRET APIENTRY UsbBulkWrite2( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR AltInterface,
+ BOOL fShortOk,
+ ULONG ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout);
+
+ APIRET APIENTRY UsbIrqStart( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR Interface,
+ USHORT usNumBytes,
+ PVOID pvData,
+ PHEV pHevModified);
+ APIRET APIENTRY UsbIrqStop( USBHANDLE Handle,
+ HEV HevModified);
+
+ APIRET APIENTRY UsbIsoStart( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR Interface,
+ ISOHANDLE *phIso);
+ APIRET APIENTRY UsbIsoStop( ISOHANDLE hIso);
+
+ APIRET APIENTRY UsbIsoDequeue( ISOHANDLE hIso,
+ PVOID pBuffer,
+ ULONG ulNumBytes);
+ APIRET APIENTRY UsbIsoEnqueue( ISOHANDLE hIso,
+ const UCHAR * pBuffer,
+ ULONG ulNumBytes);
+ APIRET APIENTRY UsbIsoPeekQueue( ISOHANDLE hIso,
+ UCHAR * pByte,
+ ULONG ulOffset);
+ APIRET APIENTRY UsbIsoGetLength( ISOHANDLE hIso,
+ ULONG *pulLength);
+
+ APIRET APIENTRY UsbIrqRead( USBHANDLE Handle,
+ UCHAR Endpoint,
+ UCHAR Interface,
+ ULONG *ulNumBytes,
+ PVOID pvData,
+ ULONG ulTimeout);
+
+ APIRET APIENTRY UsbFixupDevice( USBHANDLE Handle,
+ UCHAR ucConfiguration,
+ UCHAR *pucConfigurationData,
+ ULONG ulConfigurationLen );
+
+ APIRET APIENTRY InitUsbCalls(void);
+ APIRET APIENTRY TermUsbCalls(void);
+
+ /* Standard USB Requests See 9.4. in USB 1.1. spec. */
+
+ /* 09 01 2003 - KIEWITZ */
+ #define UsbDeviceClearFeature(HANDLE, FEAT) \
+ UsbCtrlMessage(HANDLE, 0x00, 0x01, FEAT, 0, 0, NULL, 0)
+ #define UsbDeviceSetFeature(HANDLE, FEAT) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x03, FEAT, 0, 0, NULL, 0)
+ #define UsbInterfaceClearFeature(HANDLE, IFACE, FEAT) \
+ UsbCtrlMessage(HANDLE, 0x01, 0x01, FEAT, IFACE, 0, NULL, 0)
+ #define UsbInterfaceSetFeature(HANDLE, IFACE, FEAT) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x03, FEAT, IFACE, 0, NULL, 0)
+ #define UsbEndpointClearFeature(HANDLE, ENDPOINT, FEAT) \
+ UsbCtrlMessage(HANDLE, 0x02, 0x01, FEAT, ENDPOINT, 0, NULL, 0)
+ #define UsbEndpointSetFeature(HANDLE, ENDPOINT, FEAT) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x03, FEAT, ENDPOINT, 0, NULL, 0)
+ #define FEATURE_DEVICE_REMOTE_WAKEUP 1
+ #define FEATURE_ENDPOINT_HALT 0
+ #define UsbEndpointClearHalt(HANDLE, ENDPOINT) \
+ UsbEndpointClearFeature(HANDLE, ENDPOINT, FEATURE_ENDPOINT_HALT)
+
+ #define UsbDeviceGetConfiguration(HANDLE, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x08, 0, 0, 1, DATA, 0)
+ #define UsbDeviceSetConfiguration(HANDLE, CONFIG) \
+ UsbCtrlMessage(HANDLE, 0x00, 0x09, CONFIG, 0, 0, NULL, 0)
+
+ #define UsbDeviceGetStatus(HANDLE, STATUS) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x00, 0, 0, 2, STATUS, 0)
+ #define UsbInterfaceGetStatus(HANDLE, IFACE, STATUS) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x00, 0, IFACE, 2, STATUS, 0)
+ #define UsbEndpointGetStatus(HANDLE, ENDPOINT, STATUS) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x00, 0, ENDPOINT, 2, STATUS, 0)
+
+ #define STATUS_ENDPOINT_HALT 0x0001
+ #define STATUS_DEVICE_SELFPOWERD 0x0001
+ #define STATUS_DEVICE_REMOTEWAKEUP 0x0002
+
+ #define UsbDeviceSetAddress(HANDLE, ADDRESS) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x05, ADDRESS, 0, 0, NULL, 0)
+
+ #define UsbDeviceGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0100|INDEX), LID, LEN, DATA, 0)
+ #define UsbDeviceSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0100|INDEX), LID, LEN, DATA, 0)
+ #define UsbConfigurationGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0200|INDEX), LID, LEN, DATA, 0)
+ #define UsbConfigurationSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0200|INDEX), LID, LEN, DATA, 0)
+ #define UsbStringGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0300|INDEX), LID, LEN, DATA, 0)
+ #define UsbStringSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0300|INDEX), LID, LEN, DATA, 0)
+ #define UsbInterfaceGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0400|INDEX), LID, LEN, DATA, 0)
+ #define UsbInterfaceSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0400|INDEX), LID, LEN, DATA, 0)
+ #define UsbEndpointGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0500|INDEX), LID, LEN, DATA, 0)
+ #define UsbEndpointSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \
+ UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0500|INDEX), LID, LEN, DATA, 0)
+
+ #define UsbInterfaceGetAltSetting(HANDLE, IFACE, SETTING) \
+ UsbCtrlMessage(HANDLE, 0x81, 0x0A, 0, IFACE, 1, SETTING, 0)
+ #define UsbInterfaceSetAltSetting(HANDLE, IFACE, ALTSET) \
+ UsbCtrlMessage(HANDLE, 0x01, 0x0B, ALTSET, IFACE, 0, NULL, 0)
+
+ #define UsbEndpointSynchFrame(HANDLE, ENDPOINT, FRAMENUM) \
+ UsbCtrlMessage(HANDLE, 0x82, 0x0B, 0, ENDPOINT, 2, FRAMENUM, 0)
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_os2_usbcalls_h */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-30 00:07:22 +0000