source: trunk/src/kernel32/hmdevio.cpp@ 7574

Last change on this file since 7574 was 7572, checked in by sandervl, 24 years ago

Added read & write functions to custom driver interface
File size: 24.5 KB
Line 
1/* $Id: hmdevio.cpp,v 1.20 2001-12-08 10:39:33 sandervl Exp $ */
2
3/*
4 * Win32 Device IOCTL API functions for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12#define INCL_DOSPROFILE
13#define INCL_DOSDEVICES
14#define INCL_DOSDEVIOCTL
15#define INCL_GPI
16#define INCL_DOSFILEMGR /* File Manager values */
17#define INCL_DOSERRORS /* DOS Error values */
18#define INCL_DOSPROCESS /* DOS Process values */
19#define INCL_DOSMISC /* DOS Miscellanous values */
20#include <os2wrap.h> //Odin32 OS/2 api wrappers
21#include <string.h>
22#include <stdio.h>
23
24#include <win32type.h>
25#include <win32api.h>
26#include <misc.h>
27#include <win\winioctl.h>
28#include "hmdevio.h"
29#include "cio.h"
30#include "map.h"
31#include "exceptutil.h"
32#include "oslibdos.h"
33
34#define DBG_LOCALLOG DBG_hmdevio
35#include "dbglocal.h"
36
37static BOOL fX86Init = FALSE;
38//SvL: Used in iccio.asm (how can you put these in the .asm data segment without messing things up?)
39ULONG ioentry = 0;
40USHORT gdt = 0;
41char devname[] = "/dev/fastio$";
42
43static BOOL GpdDevIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
44static BOOL MAPMEMIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
45static BOOL FXMEMMAPIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
46static BOOL VPCIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
47
48static WIN32DRV knownDriver[] =
49 {{"\\\\.\\GpdDev", "", TRUE, 666, GpdDevIOCtl},
50 { "\\\\.\\MAPMEM", "PMAP$", FALSE, 0, MAPMEMIOCtl},
51 { "FXMEMMAP.VXD", "PMAP$", FALSE, 0, FXMEMMAPIOCtl},
52#if 1
53 { "\\\\.\\VPCAppSv", "", TRUE, 667, VPCIOCtl}};
54#else
55 };
56#endif
57
58static int nrKnownDrivers = sizeof(knownDriver)/sizeof(WIN32DRV);
59BOOL fVirtualPC = FALSE;
60
61//******************************************************************************
62//******************************************************************************
63void RegisterDevices()
64{
65 HMDeviceDriver *driver;
66 DWORD rc;
67
68 for(int i=0;i<nrKnownDrivers;i++)
69 {
70 driver = new HMDeviceDriver(knownDriver[i].szWin32Name,
71 knownDriver[i].szOS2Name,
72 knownDriver[i].fCreateFile,
73 knownDriver[i].devIOCtl);
74
75 rc = HMDeviceRegister(knownDriver[i].szWin32Name, driver);
76 if (rc != NO_ERROR) /* check for errors */
77 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n",
78 knownDriver[i].szWin32Name, rc));
79 }
80
81 //check registry for Odin driver plugin dlls
82 HKEY hkDrivers, hkDrvDll;
83
84 rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
85 "System\\CurrentControlSet\\Services",
86 0, KEY_READ, &hkDrivers);
87
88 if(rc == 0) {
89 char szDllName[CCHMAXPATH];
90 char szKeyName[CCHMAXPATH];
91 char szDrvName[CCHMAXPATH];
92 DWORD dwType, dwSize;
93 int iSubKey = 0;
94
95 while(rc == 0) {
96 rc = RegEnumKeyA(hkDrivers, iSubKey++, szKeyName, sizeof(szKeyName));
97 if(rc) break;
98
99 rc = RegOpenKeyExA(hkDrivers, szKeyName,
100 0, KEY_READ, &hkDrvDll);
101 if(rc == 0) {
102 dwSize = sizeof(szDllName);
103 rc = RegQueryValueExA(hkDrvDll,
104 "DllName",
105 NULL,
106 &dwType,
107 (LPBYTE)szDllName,
108 &dwSize);
109
110 RegCloseKey(hkDrvDll);
111 if(rc == 0 && dwType == REG_SZ)
112 {
113 HINSTANCE hDrvDll = LoadLibraryA(szDllName);
114 if(hDrvDll)
115 {
116 sprintf(szDrvName, "\\\\.\\%s", szKeyName);
117 driver = new HMCustomDriver(hDrvDll, szDrvName);
118
119 rc = HMDeviceRegister(szDrvName, driver);
120 if (rc != NO_ERROR) /* check for errors */
121 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n", szDrvName, rc));
122
123 // @@@PH
124 // there should be an symbolic link:
125 // "\\.\drvname$" -> "drvname$"
126 }
127 }
128 rc = 0;
129 }
130 }
131 RegCloseKey(hkDrivers);
132 }
133
134 return;
135}
136//******************************************************************************
137//******************************************************************************
138BOOL WIN32API RegisterCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose,
139 PFNDRVIOCTL pfnDriverIOCtl, PFNDRVREAD pfnDriverRead,
140 PFNDRVWRITE pfnDriverWrite, LPCSTR lpDeviceName)
141{
142 HMDeviceDriver *driver;
143 DWORD rc;
144
145 driver = new HMCustomDriver(pfnDriverOpen, pfnDriverClose, pfnDriverIOCtl, pfnDriverRead, pfnDriverWrite, lpDeviceName);
146 if(driver == NULL) {
147 DebugInt3();
148 return FALSE;
149 }
150 rc = HMDeviceRegister((LPSTR)lpDeviceName, driver);
151 if (rc != NO_ERROR) { /* check for errors */
152 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n", lpDeviceName, rc));
153 return FALSE;
154 }
155 return TRUE;
156}
157//******************************************************************************
158//******************************************************************************
159HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName, LPSTR lpOS2DevName, BOOL fCreate,
160 WINIOCTL pDevIOCtl)
161 : HMDeviceKernelObjectClass(lpDeviceName)
162{
163 this->fCreateFile = fCreateFile;
164 this->szOS2Name = lpOS2DevName;
165 this->devIOCtl = pDevIOCtl;
166}
167//******************************************************************************
168//******************************************************************************
169HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName)
170 : HMDeviceKernelObjectClass(lpDeviceName)
171{
172}
173//******************************************************************************
174//******************************************************************************
175DWORD HMDeviceDriver::CreateFile (LPCSTR lpFileName,
176 PHMHANDLEDATA pHMHandleData,
177 PVOID lpSecurityAttributes,
178 PHMHANDLEDATA pHMHandleDataTemplate)
179{
180 APIRET rc;
181 HFILE hfFileHandle = 0L; /* Handle for file being manipulated */
182 ULONG ulAction = 0; /* Action taken by DosOpen */
183 ULONG sharetype = 0;
184
185 if(pHMHandleData->dwAccess & (GENERIC_READ | GENERIC_WRITE))
186 sharetype |= OPEN_ACCESS_READWRITE;
187 else
188 if(pHMHandleData->dwAccess & GENERIC_WRITE)
189 sharetype |= OPEN_ACCESS_WRITEONLY;
190
191 if(pHMHandleData->dwShare == 0)
192 sharetype |= OPEN_SHARE_DENYREADWRITE;
193 else
194 if(pHMHandleData->dwShare & (FILE_SHARE_READ | FILE_SHARE_WRITE))
195 sharetype |= OPEN_SHARE_DENYNONE;
196 else
197 if(pHMHandleData->dwShare & FILE_SHARE_WRITE)
198 sharetype |= OPEN_SHARE_DENYREAD;
199 else
200 if(pHMHandleData->dwShare & FILE_SHARE_READ)
201 sharetype |= OPEN_SHARE_DENYWRITE;
202
203 if(szOS2Name[0] == 0) {
204 pHMHandleData->hHMHandle = 0;
205 return (NO_ERROR);
206 }
207
208tryopen:
209 rc = DosOpen( szOS2Name, /* File path name */
210 &hfFileHandle, /* File handle */
211 &ulAction, /* Action taken */
212 0,
213 FILE_NORMAL,
214 FILE_OPEN,
215 sharetype,
216 0L); /* No extended attribute */
217
218 if(rc == ERROR_TOO_MANY_OPEN_FILES) {
219 ULONG CurMaxFH;
220 LONG ReqCount = 32;
221
222 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
223 if(rc) {
224 dprintf(("DosSetRelMaxFH returned %d", rc));
225 return error2WinError(rc);
226 }
227 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
228 goto tryopen;
229 }
230
231 dprintf(("DosOpen %s returned %d\n", szOS2Name, rc));
232
233 if(rc == NO_ERROR)
234 {
235 pHMHandleData->hHMHandle = hfFileHandle;
236 return (NO_ERROR);
237 }
238 else
239 return(error2WinError(rc));
240}
241//******************************************************************************
242//******************************************************************************
243BOOL HMDeviceDriver::CloseHandle(PHMHANDLEDATA pHMHandleData)
244{
245 DWORD rc = 0;
246
247 if(pHMHandleData->hHMHandle) {
248 rc = DosClose(pHMHandleData->hHMHandle);
249 }
250 pHMHandleData->hHMHandle = 0;
251 return rc;
252}
253//******************************************************************************
254//******************************************************************************
255BOOL HMDeviceDriver::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
256 LPVOID lpInBuffer, DWORD nInBufferSize,
257 LPVOID lpOutBuffer, DWORD nOutBufferSize,
258 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
259{
260 return devIOCtl(pHMHandleData->hHMHandle, dwIoControlCode, lpInBuffer, nInBufferSize,
261 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
262}
263//******************************************************************************
264//******************************************************************************
265static BOOL GpdDevIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
266{
267 ULONG port, val = 0;
268
269 if(fX86Init == FALSE) {
270 if(io_init() == 0)
271 fX86Init = TRUE;
272 else return(FALSE);
273 }
274
275 *lpBytesReturned = 0;
276
277 port = ((GENPORT_WRITE_INPUT *)lpInBuffer)->PortNumber;
278
279 switch((dwIoControlCode >> 2) & 0xFFF) {
280 case IOCTL_GPD_READ_PORT_UCHAR:
281 if(nOutBufferSize < sizeof(char))
282 return(FALSE);
283
284 val = c_inb(port);
285 *(char *)lpOutBuffer = val;
286 *lpBytesReturned = sizeof(char);
287 break;
288 case IOCTL_GPD_READ_PORT_USHORT:
289 if(nOutBufferSize < sizeof(USHORT))
290 return(FALSE);
291
292 val = c_inw(port);
293 *(USHORT *)lpOutBuffer = val;
294 *lpBytesReturned = sizeof(USHORT);
295 break;
296 case IOCTL_GPD_READ_PORT_ULONG:
297 if(nOutBufferSize < sizeof(ULONG))
298 return(FALSE);
299
300 val = c_inl(port);
301 *(ULONG *)lpOutBuffer = val;
302 *lpBytesReturned = sizeof(ULONG);
303 break;
304 case IOCTL_GPD_WRITE_PORT_UCHAR:
305 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->CharData;
306 c_outb(port, val);
307 break;
308 case IOCTL_GPD_WRITE_PORT_USHORT:
309 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->ShortData;
310 c_outw(port, val);
311 break;
312 case IOCTL_GPD_WRITE_PORT_ULONG:
313 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->LongData;
314 c_outl(port, val);
315 break;
316 default:
317 dprintf(("GpdDevIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
318 return(FALSE);
319 }
320
321 return(TRUE);
322}
323//******************************************************************************
324//******************************************************************************
325static BOOL MAPMEMIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
326{
327 PHYSICAL_MEMORY_INFO *meminfo = (PHYSICAL_MEMORY_INFO *)lpInBuffer;
328 struct map_ioctl memmap;
329
330 *lpBytesReturned = 0;
331
332 switch((dwIoControlCode >> 2) & 0xFFF) {
333 case IOCTL_MAPMEM_MAP_USER_PHYSICAL_MEMORY:
334 if(nInBufferSize != sizeof(PHYSICAL_MEMORY_INFO))
335 return(FALSE);
336
337 memmap.a.phys = meminfo->BusAddress.u.LowPart;
338 memmap.size = meminfo->Length;
339 dprintf(("DeviceIoControl map phys address %X length %X\n", memmap.a.phys, memmap.size));
340 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1) {
341 dprintf(("mpioctl failed!\n"));
342 return(FALSE);
343 }
344
345 dprintf(("DeviceIoControl map virt address = %X\n", memmap.a.user));
346 *(ULONG *)lpOutBuffer = (ULONG)memmap.a.user;
347 break;
348 case IOCTL_MAPMEM_UNMAP_USER_PHYSICAL_MEMORY:
349 dprintf(("Unmap mapping %X\n", *(ULONG *)lpInBuffer));
350 memmap.a.phys = *(ULONG *)lpInBuffer;
351 memmap.size = 0;
352 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1)
353 return(FALSE);
354 break;
355 default:
356 dprintf(("MAPMEMIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
357 return(FALSE);
358 }
359
360 return(TRUE);
361}
362//******************************************************************************
363//******************************************************************************
364static BOOL FXMEMMAPIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
365{
366 struct map_ioctl memmap;
367 MAPDEVREQUEST *vxdmem = (MAPDEVREQUEST *)lpInBuffer;
368
369 switch(dwIoControlCode) {
370 case 1:
371 break;
372 case 2:
373 memmap.a.phys = (DWORD)vxdmem->mdr_PhysicalAddress;
374 memmap.size = vxdmem->mdr_SizeInBytes;
375 dprintf(("DeviceIoControl map phys address %X length %X\n", memmap.a.phys, memmap.size));
376 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1) {
377 dprintf(("mpioctl failed!\n"));
378 return(FALSE);
379 }
380
381 dprintf(("DeviceIoControl map virt address = %X\n", memmap.a.user));
382 vxdmem->mdr_LinearAddress = (PVOID)memmap.a.user;
383 break;
384 default:
385 dprintf(("FXMEMMAPIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
386 return(FALSE);
387 }
388
389 return(TRUE);
390}
391//******************************************************************************
392//******************************************************************************
393static BOOL VPCIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
394{
395 APIRET rc;
396
397 dprintf(("VPCIOCtl func %x: %x %d %x %d %x %x", dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped));
398 switch(dwIoControlCode) {
399 case 0x9C402880: //0x00
400 if(nOutBufferSize < 4) {
401 SetLastError(ERROR_BAD_LENGTH);
402 return FALSE;
403 }
404 *(DWORD *)lpOutBuffer = 0x60001;
405 *lpBytesReturned = 4;
406 return TRUE;
407
408 case 0x9C402894: //0x14 (get IDT table)
409 {
410 DWORD *lpBuffer = (DWORD *)lpOutBuffer;
411 if(nOutBufferSize < 0x800) {
412 SetLastError(ERROR_BAD_LENGTH);
413 return FALSE;
414 }
415 memset(lpOutBuffer, 0, nOutBufferSize);
416 for(int i=0;i<32;i++) {
417 lpBuffer[i*2] = 0x0178c4c8;
418 lpBuffer[i*2+1] = 0xfff18F00;
419 }
420 for(i=0x50;i<0x57;i++) {
421 lpBuffer[i*2] = 0x0178c4c8;
422 lpBuffer[i*2+1] = 0xfff18E00;
423 }
424 for(i=0x70;i<0x77;i++) {
425 lpBuffer[i*2] = 0x0178c4c8;
426 lpBuffer[i*2+1] = 0xfff18E00;
427 }
428 lpBuffer[0x4F*2] = 0x0178c4c8;
429 lpBuffer[0x4F*2+1] = 0xfff18E00;
430 lpBuffer[0xEF*2] = 0x0178c4c8;
431 lpBuffer[0xEF*2+1] = 0xfff18E00;
432 *lpBytesReturned = 0xFF*8;
433 return TRUE;
434 }
435 case 0x9C40288C: //0x0C change IDT
436 if(nInBufferSize < 0x22) {
437 SetLastError(ERROR_BAD_LENGTH);
438 return FALSE;
439 }
440 fVirtualPC = TRUE;
441 return TRUE;
442
443 case 0x9C402884: //0x04 ExAllocatePoolWithTag
444 {
445 DWORD *lpBuffer = (DWORD *)lpInBuffer;
446 if(nInBufferSize < 0x08) {
447 SetLastError(ERROR_BAD_LENGTH);
448 return FALSE;
449 }
450 dprintf(("In: %x %x", lpBuffer[0], lpBuffer[1]));
451 return TRUE;
452 }
453
454 case 0x9C402898: //0x18 Remove IDT patch
455 if(nInBufferSize < 0x01) {
456 SetLastError(ERROR_BAD_LENGTH);
457 return FALSE;
458 }
459 fVirtualPC = FALSE;
460 return TRUE;
461 default:
462 dprintf(("VPCIOCtl unknown func %X\n", dwIoControlCode));
463 return FALSE;
464 }
465}
466//******************************************************************************
467//******************************************************************************
468HMCustomDriver::HMCustomDriver(HINSTANCE hInstance, LPCSTR lpDeviceName)
469 : HMDeviceDriver(lpDeviceName), hDrvDll(0)
470{
471 hDrvDll = hInstance ;
472 pfnDriverOpen = (PFNDRVOPEN) GetProcAddress(hDrvDll, "DrvOpen");
473 pfnDriverClose = (PFNDRVCLOSE)GetProcAddress(hDrvDll, "DrvClose");
474 pfnDriverRead = (PFNDRVREAD) GetProcAddress(hDrvDll, "DrvRead");
475 pfnDriverWrite = (PFNDRVWRITE)GetProcAddress(hDrvDll, "DrvWrite");
476 pfnDriverIOCtl = (PFNDRVIOCTL)GetProcAddress(hDrvDll, "DrvIOCtl");
477}
478//******************************************************************************
479//******************************************************************************
480HMCustomDriver::HMCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose,
481 PFNDRVIOCTL pfnDriverIOCtl, PFNDRVREAD pfnDriverRead,
482 PFNDRVWRITE pfnDriverWrite, LPCSTR lpDeviceName)
483 : HMDeviceDriver(lpDeviceName), hDrvDll(0)
484{
485 if(!pfnDriverOpen || !pfnDriverClose) {
486 DebugInt3();
487 }
488 this->pfnDriverOpen = pfnDriverOpen;
489 this->pfnDriverClose = pfnDriverClose;
490 this->pfnDriverIOCtl = pfnDriverIOCtl;
491 this->pfnDriverRead = pfnDriverRead;
492 this->pfnDriverWrite = pfnDriverWrite;
493}
494//******************************************************************************
495//******************************************************************************
496HMCustomDriver::~HMCustomDriver()
497{
498 if(hDrvDll) FreeLibrary(hDrvDll);
499}
500//******************************************************************************
501//******************************************************************************
502DWORD HMCustomDriver::CreateFile (LPCSTR lpFileName,
503 PHMHANDLEDATA pHMHandleData,
504 PVOID lpSecurityAttributes,
505 PHMHANDLEDATA pHMHandleDataTemplate)
506{
507 pHMHandleData->hHMHandle = pfnDriverOpen(pHMHandleData->dwAccess, pHMHandleData->dwShare);
508 if(pHMHandleData->hHMHandle == 0) {
509 return ERROR_FILE_NOT_FOUND_W;
510 }
511 return ERROR_SUCCESS_W;
512}
513//******************************************************************************
514//******************************************************************************
515BOOL HMCustomDriver::CloseHandle(PHMHANDLEDATA pHMHandleData)
516{
517 if(pHMHandleData->hHMHandle) {
518 pfnDriverClose(pHMHandleData->hHMHandle);
519 }
520 pHMHandleData->hHMHandle = 0;
521 return TRUE;
522}
523//******************************************************************************
524//******************************************************************************
525BOOL HMCustomDriver::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
526 LPVOID lpInBuffer, DWORD nInBufferSize,
527 LPVOID lpOutBuffer, DWORD nOutBufferSize,
528 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
529{
530 BOOL ret;
531
532 if(pfnDriverIOCtl == NULL) {
533 dprintf(("HMCustomDriver::DeviceIoControl: pfnDriverIOCtl == NULL"));
534 ::SetLastError(ERROR_INVALID_FUNCTION_W);
535 return FALSE;
536 }
537
538 ret = pfnDriverIOCtl(pHMHandleData->hHMHandle, dwIoControlCode, lpInBuffer, nInBufferSize,
539 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
540 dprintf(("DeviceIoControl %x returned %d", dwIoControlCode, ret));
541 return ret;
542}
543/*****************************************************************************
544 * Name : BOOL HMCustomDriver::ReadFile
545 * Purpose : read data from handle / device
546 * Parameters: PHMHANDLEDATA pHMHandleData,
547 * LPCVOID lpBuffer,
548 * DWORD nNumberOfBytesToRead,
549 * LPDWORD lpNumberOfBytesRead,
550 * LPOVERLAPPED lpOverlapped
551 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
552 * Variables :
553 * Result : Boolean
554 * Remark :
555 * Status :
556 *
557 * Author : SvL
558 *****************************************************************************/
559
560BOOL HMCustomDriver::ReadFile(PHMHANDLEDATA pHMHandleData,
561 LPCVOID lpBuffer,
562 DWORD nNumberOfBytesToRead,
563 LPDWORD lpNumberOfBytesRead,
564 LPOVERLAPPED lpOverlapped,
565 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
566{
567 BOOL ret;
568
569 if(pfnDriverRead == NULL) {
570 dprintf(("HMCustomDriver::ReadFile: pfnDriverRead == NULL"));
571 ::SetLastError(ERROR_INVALID_FUNCTION_W);
572 return FALSE;
573 }
574 ret = pfnDriverRead(pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToRead,
575 lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine);
576 dprintf(("pfnDriverRead %x %x %x %x %x %x returned %x", pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToRead,
577 lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine, ret));
578 return ret;
579}
580/*****************************************************************************
581 * Name : BOOL HMCustomDriver::WriteFile
582 * Purpose : write data to handle / device
583 * Parameters: PHMHANDLEDATA pHMHandleData,
584 * LPCVOID lpBuffer,
585 * DWORD nNumberOfBytesToWrite,
586 * LPDWORD lpNumberOfBytesWritten,
587 * LPOVERLAPPED lpOverlapped
588 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
589 * Variables :
590 * Result : Boolean
591 * Remark :
592 * Status :
593 *
594 * Author : SvL
595 *****************************************************************************/
596
597BOOL HMCustomDriver::WriteFile(PHMHANDLEDATA pHMHandleData,
598 LPCVOID lpBuffer,
599 DWORD nNumberOfBytesToWrite,
600 LPDWORD lpNumberOfBytesWritten,
601 LPOVERLAPPED lpOverlapped,
602 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
603{
604 BOOL ret;
605
606 if(pfnDriverWrite == NULL) {
607 dprintf(("HMCustomDriver::WriteFile: pfnDriverWrite == NULL"));
608 ::SetLastError(ERROR_INVALID_FUNCTION_W);
609 return FALSE;
610 }
611 ret = pfnDriverWrite(pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToWrite,
612 lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine);
613 dprintf(("pfnDriverWrite %x %x %x %x %x %x returned %x", pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToWrite,
614 lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine, ret));
615 return ret;
616}
617//******************************************************************************
618//******************************************************************************
619BOOL WIN32API QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
620{
621 QWORD time;
622 APIRET rc;
623
624 rc = DosTmrQueryTime(&time);
625 if(rc) {
626 dprintf(("DosTmrQueryTime returned %d\n", rc));
627 return(FALSE);
628 }
629 lpPerformanceCount->u.LowPart = time.ulLo;
630 lpPerformanceCount->u.HighPart = time.ulHi;
631 return(TRUE);
632}
633//******************************************************************************
634//******************************************************************************
635BOOL WIN32API QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)
636{
637 APIRET rc;
638 ULONG freq;
639
640 rc = DosTmrQueryFreq(&freq);
641 if(rc) {
642 dprintf(("DosTmrQueryFreq returned %d\n", rc));
643 return(FALSE);
644 }
645 lpFrequency->u.LowPart = freq;
646 lpFrequency->u.HighPart = 0;
647 dprintf2(("QueryPerformanceFrequency returned 0x%X%X\n", lpFrequency->u.HighPart, lpFrequency->u.LowPart));
648 return(TRUE);
649}
650//******************************************************************************
651//******************************************************************************
Note: See TracBrowser for help on using the repository browser.