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

Last change on this file since 4285 was 4285, checked in by hugh, 25 years ago

Implemented Serial APIs
File size: 11.9 KB
Line 
1/* $Id: hmdevio.cpp,v 1.5 2000-09-20 21:32:52 hugh 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
23#include <win32type.h>
24#include <misc.h>
25#include "hmdevio.h"
26#include "cio.h"
27#include "map.h"
28#include "exceptutil.h"
29
30#define DBG_LOCALLOG DBG_hmdevio
31#include "dbglocal.h"
32
33static fX86Init = FALSE;
34//SvL: Used in iccio.asm (how can you put these in the .asm data segment without messing things up?)
35//ULONG ioentry = 0;
36//USHORT gdt = 0;
37char devname[] = "/dev/fastio$";
38
39static BOOL GpdDevIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
40static BOOL MAPMEMIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
41static BOOL FXMEMMAPIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
42
43static WIN32DRV knownDriver[] =
44 {{"\\\\.\\GpdDev", "/dev/fastio$", TRUE, 666, GpdDevIOCtl},
45 { "\\\\.\\MAPMEM", "PMAP$", FALSE, 0, MAPMEMIOCtl},
46 { "FXMEMMAP.VXD", "PMAP$", FALSE, 0, FXMEMMAPIOCtl}};
47
48static int nrKnownDrivers = sizeof(knownDriver)/sizeof(WIN32DRV);
49
50//******************************************************************************
51//******************************************************************************
52void RegisterDevices()
53{
54 HMDeviceDriver *driver;
55 DWORD rc;
56
57 for(int i=0;i<nrKnownDrivers;i++)
58 {
59 driver = new HMDeviceDriver(knownDriver[i].szWin32Name,
60 knownDriver[i].szOS2Name,
61 knownDriver[i].fCreateFile,
62 knownDriver[i].devIOCtl);
63
64 rc = HMDeviceRegister(knownDriver[i].szWin32Name, driver);
65 if (rc != NO_ERROR) /* check for errors */
66 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n",
67 knownDriver[i].szWin32Name, rc));
68 }
69 return;
70}
71//******************************************************************************
72//******************************************************************************
73HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName, LPSTR lpOS2DevName, BOOL fCreate,
74 WINIOCTL pDevIOCtl)
75 : HMDeviceKernelObjectClass(lpDeviceName)
76{
77 this->fCreateFile = fCreateFile;
78 this->szOS2Name = lpOS2DevName;
79 this->devIOCtl = pDevIOCtl;
80}
81//******************************************************************************
82//******************************************************************************
83DWORD HMDeviceDriver::CreateFile (LPCSTR lpFileName,
84 PHMHANDLEDATA pHMHandleData,
85 PVOID lpSecurityAttributes,
86 PHMHANDLEDATA pHMHandleDataTemplate)
87{
88 APIRET rc;
89 HFILE hfFileHandle = 0L; /* Handle for file being manipulated */
90 ULONG ulAction = 0; /* Action taken by DosOpen */
91 ULONG sharetype = 0;
92
93 if(pHMHandleData->dwAccess & (GENERIC_READ | GENERIC_WRITE))
94 sharetype |= OPEN_ACCESS_READWRITE;
95 else
96 if(pHMHandleData->dwAccess & GENERIC_WRITE)
97 sharetype |= OPEN_ACCESS_WRITEONLY;
98
99 if(pHMHandleData->dwShare == 0)
100 sharetype |= OPEN_SHARE_DENYREADWRITE;
101 else
102 if(pHMHandleData->dwShare & (FILE_SHARE_READ | FILE_SHARE_WRITE))
103 sharetype |= OPEN_SHARE_DENYNONE;
104 else
105 if(pHMHandleData->dwShare & FILE_SHARE_WRITE)
106 sharetype |= OPEN_SHARE_DENYREAD;
107 else
108 if(pHMHandleData->dwShare & FILE_SHARE_READ)
109 sharetype |= OPEN_SHARE_DENYWRITE;
110
111 if(szOS2Name[0] == 0) {
112 pHMHandleData->hHMHandle = 0;
113 return (NO_ERROR);
114 }
115
116tryopen:
117 rc = DosOpen( szOS2Name, /* File path name */
118 &hfFileHandle, /* File handle */
119 &ulAction, /* Action taken */
120 0,
121 FILE_NORMAL,
122 FILE_OPEN,
123 sharetype,
124 0L); /* No extended attribute */
125
126 if(rc == ERROR_TOO_MANY_OPEN_FILES) {
127 ULONG CurMaxFH;
128 LONG ReqCount = 32;
129
130 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
131 if(rc) {
132 dprintf(("DosSetRelMaxFH returned %d", rc));
133 return rc;
134 }
135 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
136 goto tryopen;
137 }
138
139 dprintf(("DosOpen %s returned %d\n", szOS2Name, rc));
140
141 if(rc == NO_ERROR)
142 {
143 pHMHandleData->hHMHandle = hfFileHandle;
144 return (NO_ERROR);
145 }
146 else
147 return(rc);
148}
149//******************************************************************************
150//******************************************************************************
151DWORD HMDeviceDriver::CloseHandle(PHMHANDLEDATA pHMHandleData)
152{
153 return DosClose(pHMHandleData->hHMHandle);
154}
155//******************************************************************************
156//******************************************************************************
157BOOL HMDeviceDriver::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
158 LPVOID lpInBuffer, DWORD nInBufferSize,
159 LPVOID lpOutBuffer, DWORD nOutBufferSize,
160 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
161{
162 return devIOCtl(pHMHandleData->hHMHandle, dwIoControlCode, lpInBuffer, nInBufferSize,
163 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
164}
165//******************************************************************************
166//******************************************************************************
167static BOOL GpdDevIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
168{
169 ULONG port, val = 0;
170 WORD gdt;
171 HRESULT rc;
172 ULONG ulAction;
173
174 if(fX86Init == FALSE)
175 {
176 rc = DosDevIOCtl( hDevice, 118, 100, 0,0,0,&gdt,2,&ulAction);
177
178 if(rc)
179 return FALSE;
180
181 io_init2(gdt);
182
183 fX86Init = TRUE;
184 }
185
186 *lpBytesReturned = 0;
187
188 port = ((GENPORT_WRITE_INPUT *)lpInBuffer)->PortNumber;
189
190 switch((dwIoControlCode >> 2) & 0xFFF) {
191 case IOCTL_GPD_READ_PORT_UCHAR:
192 if(nOutBufferSize < sizeof(char))
193 return(FALSE);
194
195 val = c_inb(port);
196 *(char *)lpOutBuffer = val;
197 *lpBytesReturned = sizeof(char);
198 break;
199 case IOCTL_GPD_READ_PORT_USHORT:
200 if(nOutBufferSize < sizeof(USHORT))
201 return(FALSE);
202
203 val = c_inw(port);
204 *(USHORT *)lpOutBuffer = val;
205 *lpBytesReturned = sizeof(USHORT);
206 break;
207 case IOCTL_GPD_READ_PORT_ULONG:
208 if(nOutBufferSize < sizeof(ULONG))
209 return(FALSE);
210
211 val = c_inl(port);
212 *(ULONG *)lpOutBuffer = val;
213 *lpBytesReturned = sizeof(ULONG);
214 break;
215 case IOCTL_GPD_WRITE_PORT_UCHAR:
216 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->CharData;
217 c_outb(port, val);
218 break;
219 case IOCTL_GPD_WRITE_PORT_USHORT:
220 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->ShortData;
221 c_outw(port, val);
222 break;
223 case IOCTL_GPD_WRITE_PORT_ULONG:
224 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->LongData;
225 c_outl(port, val);
226 break;
227 default:
228 dprintf(("GpdDevIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
229 return(FALSE);
230 }
231
232 return(TRUE);
233}
234//******************************************************************************
235//******************************************************************************
236static BOOL MAPMEMIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
237{
238 PHYSICAL_MEMORY_INFO *meminfo = (PHYSICAL_MEMORY_INFO *)lpInBuffer;
239 struct map_ioctl memmap;
240
241 *lpBytesReturned = 0;
242
243 switch((dwIoControlCode >> 2) & 0xFFF) {
244 case IOCTL_MAPMEM_MAP_USER_PHYSICAL_MEMORY:
245 if(nInBufferSize != sizeof(PHYSICAL_MEMORY_INFO))
246 return(FALSE);
247
248 memmap.a.phys = meminfo->BusAddress.u.LowPart;
249 memmap.size = meminfo->Length;
250 dprintf(("DeviceIoControl map phys address %X length %X\n", memmap.a.phys, memmap.size));
251 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1) {
252 dprintf(("mpioctl failed!\n"));
253 return(FALSE);
254 }
255
256 dprintf(("DeviceIoControl map virt address = %X\n", memmap.a.user));
257 *(ULONG *)lpOutBuffer = (ULONG)memmap.a.user;
258 break;
259 case IOCTL_MAPMEM_UNMAP_USER_PHYSICAL_MEMORY:
260 dprintf(("Unmap mapping %X\n", *(ULONG *)lpInBuffer));
261 memmap.a.phys = *(ULONG *)lpInBuffer;
262 memmap.size = 0;
263 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1)
264 return(FALSE);
265 break;
266 default:
267 dprintf(("MAPMEMIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
268 return(FALSE);
269 }
270
271 return(TRUE);
272}
273//******************************************************************************
274//******************************************************************************
275static BOOL FXMEMMAPIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
276{
277 struct map_ioctl memmap;
278 MAPDEVREQUEST *vxdmem = (MAPDEVREQUEST *)lpInBuffer;
279
280 switch(dwIoControlCode) {
281 case 1:
282 break;
283 case 2:
284 memmap.a.phys = (DWORD)vxdmem->mdr_PhysicalAddress;
285 memmap.size = vxdmem->mdr_SizeInBytes;
286 dprintf(("DeviceIoControl map phys address %X length %X\n", memmap.a.phys, memmap.size));
287 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1) {
288 dprintf(("mpioctl failed!\n"));
289 return(FALSE);
290 }
291
292 dprintf(("DeviceIoControl map virt address = %X\n", memmap.a.user));
293 vxdmem->mdr_LinearAddress = (PVOID)memmap.a.user;
294 break;
295 default:
296 dprintf(("FXMEMMAPIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
297 return(FALSE);
298 }
299
300 return(TRUE);
301}
302//******************************************************************************
303//******************************************************************************
304BOOL WIN32API QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
305{
306 QWORD time;
307 APIRET rc;
308
309 rc = DosTmrQueryTime(&time);
310 if(rc) {
311 dprintf(("DosTmrQueryTime returned %d\n", rc));
312 return(FALSE);
313 }
314 lpPerformanceCount->u.LowPart = time.ulLo;
315 lpPerformanceCount->u.HighPart = time.ulHi;
316 return(TRUE);
317}
318//******************************************************************************
319//******************************************************************************
320BOOL WIN32API QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)
321{
322 APIRET rc;
323 ULONG freq;
324
325 rc = DosTmrQueryFreq(&freq);
326 if(rc) {
327 dprintf(("DosTmrQueryFreq returned %d\n", rc));
328 return(FALSE);
329 }
330 lpFrequency->u.LowPart = freq;
331 lpFrequency->u.HighPart = 0;
332 dprintf2(("QueryPerformanceFrequency returned 0x%X%X\n", lpFrequency->u.HighPart, lpFrequency->u.LowPart));
333 return(TRUE);
334}
335//******************************************************************************
336//******************************************************************************
Note: See TracBrowser for help on using the repository browser.