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

Last change on this file since 7757 was 7756, checked in by sandervl, 24 years ago

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