source: trunk/src/kernel32/hmparport.cpp@ 7434

Last change on this file since 7434 was 7302, checked in by phaller, 24 years ago

.
File size: 23.3 KB
Line 
1/* $Id: hmparport.cpp,v 1.4 2001-11-08 16:00:17 phaller Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 *
6 * Win32 Parallel Port device access class
7 *
8 * 2001 Patrick Haller <patrick.haller@innotek.de>
9 *
10 */
11
12
13
14#include <os2win.h>
15#include <string.h>
16#include <handlemanager.h>
17#include <heapstring.h>
18#include "hmdevice.h"
19#include "hmparport.h"
20#include "oslibdos.h"
21
22#define DBG_LOCALLOG DBG_hmparport
23#include "dbglocal.h"
24
25
26#define MAGIC_PARPORT 0x4c505431
27
28#define IOCTL_PRINTER 0x0005
29#define PRT_QUERYJOBHANDLE 0x0021
30#define PRT_SETFRAMECTL 0x0042
31#define PRT_SETINFINITERETRY 0x0044
32#define PRT_INITPRINTER 0x0046
33#define PRT_ACTIVATEFONT 0x0048
34#define PRT_SETPRINTJOBTITLE 0x004D
35#define PRT_SETIRQTIMEOUT 0x004E
36#define PRT_SETCOMMMODE 0x0052
37#define PRT_SETDATAXFERMODE 0x0053
38#define PRT_GETFRAMECTL 0x0062
39#define PRT_GETINFINITERETRY 0x0064
40#define PRT_GETPRINTERSTATUS 0x0066
41#define PRT_QUERYACTIVEFONT 0x0069
42#define PRT_VERIFYFONT 0x006A
43#define PRT_QUERYIRQTIMEOUT 0x006E
44#define PRT_QUERYCOMMMODE 0x0072
45#define PRT_QUERYDATAXFERMODE 0x0073
46#define PRT_QUERDEVICEID 0x0074
47
48
49#if 0
50#pragma pack(1)
51typedef struct _DCBINFO
52{
53 USHORT usWriteTimeout; /* Time period used for Write Timeout processing. */
54 USHORT usReadTimeout; /* Time period used for Read Timeout processing. */
55 BYTE fbCtlHndShake; /* HandShake Control flag. */
56 BYTE fbFlowReplace; /* Flow Control flag. */
57 BYTE fbTimeOut; /* Timeout flag. */
58 BYTE bErrorReplacementChar; /* Error Replacement Character. */
59 BYTE bBreakReplacementChar; /* Break Replacement Character. */
60 BYTE bXONChar; /* Character XON. */
61 BYTE bXOFFChar; /* Character XOFF. */
62} DCBINFO;
63typedef DCBINFO *PDCBINFO;
64
65
66typedef struct _RXQUEUE
67{
68 USHORT cch; /* Number of characters in the queue. */
69 USHORT cb; /* Size of receive/transmit queue. */
70} RXQUEUE;
71
72typedef RXQUEUE *PRXQUEUE;
73
74
75typedef struct _MODEMSTATUS
76{
77 BYTE fbModemOn; /* Modem Control Signals ON Mask. */
78 BYTE fbModemOff; /* Modem Control Signals OFF Mask. */
79} MODEMSTATUS;
80
81typedef MODEMSTATUS *PMODEMSTATUS;
82
83
84#pragma pack()
85
86
87#endif
88
89
90typedef struct _HMDEVPARPORTDATA
91{
92 ULONG ulMagic;
93 // Win32 Device Control Block
94 COMMCONFIG CommCfg;
95 //OS/2 Device Control Block
96} HMDEVPARPORTDATA, *PHMDEVPARPORTDATA;
97
98static VOID *CreateDevData()
99{
100 PHMDEVPARPORTDATA pData;
101 pData = new HMDEVPARPORTDATA();
102 if(NULL!=pData)
103 {
104 memset(pData,0,sizeof(HMDEVPARPORTDATA));
105 pData->ulMagic = MAGIC_PARPORT;
106 pData->CommCfg.dwSize = sizeof(COMMCONFIG);
107 pData->CommCfg.wVersion = 1;
108 pData->CommCfg.dwProviderSubType = PST_PARALLELPORT;
109 }
110 return pData;
111}
112
113
114HMDeviceParPortClass::HMDeviceParPortClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName)
115{
116 dprintf(("HMDeviceParPortClass::HMDevParPortClass(%s)\n",
117 lpDeviceName));
118
119 VOID *pData;
120 dprintf(("HMDeviceParPortClass: Register LPT1 to LPT3 with Handle Manager\n"));
121
122 pData = CreateDevData();
123 if(pData!= NULL)
124 HMDeviceRegisterEx("LPT1", this, pData);
125}
126
127/*****************************************************************************
128 * Name : HMDeviceParPortClass::FindDevice
129 * Purpose : Checks if lpDeviceName belongs to this device class
130 * Parameters: LPCSTR lpClassDevName
131 * LPCSTR lpDeviceName
132 * int namelength
133 * Variables :
134 * Result : checks if name is COMx or COMx: (x=1..8)
135 * Remark :
136 * Status :
137 *
138 * Author : SvL
139 *****************************************************************************/
140BOOL HMDeviceParPortClass::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
141{
142 dprintf(("HMDeviceParPortClass::FindDevice(%s,%s)\n",
143 lpClassDevName,
144 lpDeviceName));
145
146 if(namelength > 5)
147 return FALSE; //can't be lpt name
148
149 //first 3 letters 'LPT'?
150 if(lstrncmpiA(lpDeviceName, lpClassDevName, 3) != 0) {
151 return FALSE;
152 }
153
154 if(namelength == 5 && lpDeviceName[4] != ':') {
155 return FALSE;
156 }
157 switch(lpDeviceName[3]) {
158 case '1':
159 case '2':
160 case '3':
161 return TRUE; //we support up to LPT3
162 }
163 return FALSE;
164}
165
166DWORD HMDeviceParPortClass::CreateFile(LPCSTR lpFileName,
167 PHMHANDLEDATA pHMHandleData,
168 PVOID lpSecurityAttributes,
169 PHMHANDLEDATA pHMHandleDataTemplate)
170{
171 dprintf(("HMDeviceParPortClass::CreateFile(%s,%08xh,%08xh,%08xh)\n",
172 lpFileName,
173 pHMHandleData,
174 lpSecurityAttributes,
175 pHMHandleDataTemplate));
176
177 char comname[6];
178
179 dprintf(("HMDeviceParPortClass: Parallel port %s open request\n", lpFileName));
180
181 if(strlen(lpFileName) > 5) {
182 return -1; //safety check (unnecessary..)
183 }
184 pHMHandleData->hHMHandle = 0;
185
186 strcpy(comname, lpFileName);
187 comname[4] = 0; //get rid of : (if present) (eg LPT1:)
188
189 //AH: TODO parse Win32 security handles
190 ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS);
191 pHMHandleData->hHMHandle = OSLibDosOpen(comname,
192 OSLIB_ACCESS_READWRITE |
193 OSLIB_ACCESS_SHAREDENYREAD |
194 OSLIB_ACCESS_SHAREDENYWRITE);
195 SetErrorMode(oldmode);
196
197#if 0
198 if (pHMHandleData->hHMHandle != 0)
199 {
200 ULONG ulLen;
201 APIRET rc;
202 pHMHandleData->lpHandlerData = new HMDEVPARPORTDATA();
203 // Init The handle instance with the default default device config
204 memcpy( pHMHandleData->lpHandlerData,
205 pHMHandleData->lpDeviceData,
206 sizeof(HMDEVPARPORTDATA));
207
208 ulLen = sizeof(DCBINFO);
209
210 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
211 IOCTL_ASYNC,
212 ASYNC_GETDCBINFO,
213 0,0,0,
214 &((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2,ulLen,&ulLen);
215 dprintf(("DCB Of %s :\n"
216 " WriteTimeout : %d\n"
217 " ReadTimeout : %d\n"
218 " CtlHandshake : 0x%x\n"
219 " FlowReplace : 0x%x\n"
220 " Timeout : 0x%x\n"
221 " Error replacement Char : 0x%x\n"
222 " Break replacement Char : 0x%x\n"
223 " XON Char : 0x%x\n"
224 " XOFF Char : 0x%x\n",
225 comname,
226 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.usWriteTimeout,
227 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.usReadTimeout,
228 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbCtlHndShake,
229 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbFlowReplace,
230 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbTimeOut,
231 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bErrorReplacementChar,
232 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bBreakReplacementChar,
233 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bXONChar,
234 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bXOFFChar));
235
236 if(rc)
237 {
238 return -1;
239 }
240 rc = SetBaud(pHMHandleData,9600);
241 dprintf(("Init Baud to 9600 rc = %d",rc));
242 rc = SetLine(pHMHandleData,8,0,0);
243 dprintf(("Set Line to 8/N/1 rc = %d",rc));
244 return 0;
245 }
246 else
247 return -1;
248#endif
249
250 return NO_ERROR;
251}
252
253
254 /* this is a handler method for calls to CloseHandle() */
255BOOL HMDeviceParPortClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
256{
257 dprintf(("HMDeviceParPortClass: Parallel port close request(%08xh)\n",
258 pHMHandleData));
259 delete pHMHandleData->lpHandlerData;
260 return OSLibDosClose(pHMHandleData->hHMHandle);
261}
262
263
264/*****************************************************************************
265 * Name : BOOL HMDeviceParPortClass::WriteFile
266 * Purpose : write data to handle / device
267 * Parameters: PHMHANDLEDATA pHMHandleData,
268 * LPCVOID lpBuffer,
269 * DWORD nNumberOfBytesToWrite,
270 * LPDWORD lpNumberOfBytesWritten,
271 * LPOVERLAPPED lpOverlapped
272 * Variables :
273 * Result : Boolean
274 * Remark :
275 * Status :
276 *
277 * Author : SvL
278 *****************************************************************************/
279
280BOOL HMDeviceParPortClass::WriteFile(PHMHANDLEDATA pHMHandleData,
281 LPCVOID lpBuffer,
282 DWORD nNumberOfBytesToWrite,
283 LPDWORD lpNumberOfBytesWritten,
284 LPOVERLAPPED lpOverlapped)
285{
286 dprintf(("KERNEL32:HMDeviceParPortClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
287 lpHMDeviceName,
288 pHMHandleData->hHMHandle,
289 lpBuffer,
290 nNumberOfBytesToWrite,
291 lpNumberOfBytesWritten,
292 lpOverlapped));
293
294 BOOL ret;
295 ULONG ulBytesWritten;
296
297 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
298 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
299 SetLastError(ERROR_INVALID_PARAMETER);
300 return FALSE;
301 }
302 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
303 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
304 }
305
306 ret = OSLibDosWrite(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToWrite,
307 &ulBytesWritten);
308
309 if(lpNumberOfBytesWritten) {
310 *lpNumberOfBytesWritten = (ret) ? ulBytesWritten : 0;
311 }
312 if(ret == FALSE) {
313 dprintf(("ERROR: WriteFile failed with rc %d", GetLastError()));
314 }
315
316 return ret;
317}
318
319/*****************************************************************************
320 * Name : BOOL WriteFileEx
321 * Purpose : The WriteFileEx function writes data to a file. It is designed
322 * solely for asynchronous operation, unlike WriteFile, which is
323 * designed for both synchronous and asynchronous operation.
324 * WriteFileEx reports its completion status asynchronously,
325 * calling a specified completion routine when writing is completed
326 * and the calling thread is in an alertable wait state.
327 * Parameters: HANDLE hFile handle of file to write
328 * LPVOID lpBuffer address of buffer
329 * DWORD nNumberOfBytesToRead number of bytes to write
330 * LPOVERLAPPED lpOverlapped address of offset
331 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
332 * Variables :
333 * Result : TRUE / FALSE
334 * Remark :
335 * Status : UNTESTED STUB
336 *
337 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
338 *****************************************************************************/
339
340BOOL HMDeviceParPortClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
341 LPVOID lpBuffer,
342 DWORD nNumberOfBytesToWrite,
343 LPOVERLAPPED lpOverlapped,
344 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
345{
346 dprintf(("ERROR: WriteFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
347 lpHMDeviceName,
348 pHMHandleData->hHMHandle,
349 lpBuffer,
350 nNumberOfBytesToWrite,
351 lpOverlapped,
352 lpCompletionRoutine));
353
354 SetLastError(ERROR_INVALID_FUNCTION);
355 return FALSE;
356}
357
358/*****************************************************************************
359 * Name : BOOL HMDeviceParPortClass::ReadFile
360 * Purpose : read data from handle / device
361 * Parameters: PHMHANDLEDATA pHMHandleData,
362 * LPCVOID lpBuffer,
363 * DWORD nNumberOfBytesToRead,
364 * LPDWORD lpNumberOfBytesRead,
365 * LPOVERLAPPED lpOverlapped
366 * Variables :
367 * Result : Boolean
368 * Remark :
369 * Status :
370 *
371 * Author : SvL
372 *****************************************************************************/
373
374BOOL HMDeviceParPortClass::ReadFile(PHMHANDLEDATA pHMHandleData,
375 LPCVOID lpBuffer,
376 DWORD nNumberOfBytesToRead,
377 LPDWORD lpNumberOfBytesRead,
378 LPOVERLAPPED lpOverlapped)
379{
380 dprintf(("KERNEL32:HMDeviceParPortClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
381 lpHMDeviceName,
382 pHMHandleData->hHMHandle,
383 lpBuffer,
384 nNumberOfBytesToRead,
385 lpNumberOfBytesRead,
386 lpOverlapped));
387
388 BOOL ret;
389 ULONG ulBytesRead;
390
391 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
392 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
393 SetLastError(ERROR_INVALID_PARAMETER);
394 return FALSE;
395 }
396 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
397 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
398 }
399
400 ret = OSLibDosRead(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToRead,
401 &ulBytesRead);
402
403 if(lpNumberOfBytesRead) {
404 *lpNumberOfBytesRead = (ret) ? ulBytesRead : 0;
405 }
406 if(ret == FALSE) {
407 dprintf(("ERROR: ReadFile failed with rc %d", GetLastError()));
408 }
409 return ret;
410}
411
412/*****************************************************************************
413 * Name : BOOL ReadFileEx
414 * Purpose : The ReadFileEx function reads data from a file asynchronously.
415 * It is designed solely for asynchronous operation, unlike the
416 * ReadFile function, which is designed for both synchronous and
417 * asynchronous operation. ReadFileEx lets an application perform
418 * other processing during a file read operation.
419 * The ReadFileEx function reports its completion status asynchronously,
420 * calling a specified completion routine when reading is completed
421 * and the calling thread is in an alertable wait state.
422 * Parameters: HANDLE hFile handle of file to read
423 * LPVOID lpBuffer address of buffer
424 * DWORD nNumberOfBytesToRead number of bytes to read
425 * LPOVERLAPPED lpOverlapped address of offset
426 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
427 * Variables :
428 * Result : TRUE / FALSE
429 * Remark :
430 * Status : UNTESTED STUB
431 *
432 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
433 *****************************************************************************/
434BOOL HMDeviceParPortClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
435 LPVOID lpBuffer,
436 DWORD nNumberOfBytesToRead,
437 LPOVERLAPPED lpOverlapped,
438 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
439{
440 dprintf(("ERROR: ReadFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
441 lpHMDeviceName,
442 pHMHandleData->hHMHandle,
443 lpBuffer,
444 nNumberOfBytesToRead,
445 lpOverlapped,
446 lpCompletionRoutine));
447
448 SetLastError(ERROR_INVALID_FUNCTION);
449 return FALSE;
450}
451
452BOOL HMDeviceParPortClass::GetCommProperties( PHMHANDLEDATA pHMHandleData,
453 LPCOMMPROP lpcmmp)
454{
455 dprintf(("HMDeviceParPortClass::GetCommProperties(%08xh, %08xh)\n",
456 pHMHandleData,
457 lpcmmp));
458
459 APIRET rc;
460 ULONG ulLen;
461 int i;
462
463#if 0
464 USHORT COMErr;
465 EXTBAUDGET BaudInfo;
466 ulLen = sizeof(EXTBAUDGET);
467 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
468 IOCTL_ASYNC,
469 ASYNC_EXTGETBAUDRATE,
470 0,0,0,
471 &BaudInfo,ulLen,&ulLen);
472#endif
473 rc = NO_ERROR;
474
475 memset(lpcmmp,0,sizeof(COMMPROP));
476 lpcmmp->wPacketLength = sizeof(COMMPROP);
477 lpcmmp->wPacketVersion = 1; //???
478 lpcmmp->dwProvSubType = PST_PARALLELPORT;
479
480#if 0
481 lpcmmp->dwServiceMask = SP_SERIALCOMM;
482 for(i=0;i<BaudTableSize && BaudInfo.ulMaxBaud <= BaudTable[i].dwBaudRate;i++);
483 lpcmmp->dwMaxBaud = BaudTable[i].dwBaudFlag;
484 lpcmmp->dwProvCapabilities = PCF_DTRDSR | PCF_PARITY_CHECK |
485 PCF_RTSCTS | PCF_SETXCHAR |
486 PCF_XONXOFF;
487 lpcmmp->dwSettableParams = SP_BAUD | SP_DATABITS |
488 SP_HANDSHAKEING | SP_PARITY |
489 SP_PARITY_CHECK | SP_STOPBIT;
490 lpcmmp->dwSettableBaud = 0;
491 for(i=0;i<BaudTableSize;i++)
492 {
493 if ( (BaudTable[i].dwBaudRate>=BaudInfo.ulMinBaud) &&
494 (BaudTable[i].dwBaudRate<=BaudInfo.ulMaxBaud) )
495 lpcmmp->dwSettableBaud |= BaudTable[i].dwBaudFlag;
496 }
497 lpcmmp->dwSettableBaud |= BAUD_USER;
498 lpcmmp->wSettableData = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8;
499 lpcmmp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
500 PARITY_NONE | PARITY_ODD | PARITY_EVEN |
501 PARITY_MARK | PARITY_SPACE;
502#endif
503
504 return(rc==0);
505}
506
507BOOL HMDeviceParPortClass::ClearCommError( PHMHANDLEDATA pHMHandleData,
508 LPDWORD lpdwErrors,
509 LPCOMSTAT lpcst)
510{
511 dprintf(("HMDeviceParPortClass::ClearCommError(%08xh,%08xh,%08xh)\n",
512 pHMHandleData,
513 lpdwErrors,
514 lpcst));
515
516 APIRET rc;
517 ULONG ulLen;
518 USHORT COMErr;
519
520 ulLen = sizeof(USHORT);
521
522 *lpdwErrors = 0;
523 rc = NO_ERROR;
524
525#if 0
526 // ParPort: CE_DNS, CE_OOP CE_PTO
527
528 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
529 IOCTL_ASYNC,
530 ASYNC_GETCOMMERROR,
531 0,0,0,
532 &COMErr,2,&ulLen);
533 *lpdwErrors |= (COMErr & 0x0001)?CE_OVERRUN:0;
534 *lpdwErrors |= (COMErr & 0x0002)?CE_RXOVER:0;
535 *lpdwErrors |= (COMErr & 0x0004)?CE_RXPARITY:0;
536 *lpdwErrors |= (COMErr & 0x0008)?CE_FRAME:0;
537
538 if(lpcst)
539 {
540 UCHAR ucStatus;
541 RXQUEUE qInfo;
542 ulLen = 1;
543 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
544 IOCTL_ASYNC,
545 ASYNC_GETCOMMSTATUS,
546 0,0,0,
547 &ucStatus,ulLen,&ulLen);
548 if(!rc)
549 {
550 lpcst->fCtsHold = ((ucStatus & 0x01)>0);
551 lpcst->fDsrHold = ((ucStatus & 0x02)>0);
552 lpcst->fRlsdHold = FALSE;//(ucStatus & 0x04)>0);
553 lpcst->fXoffHold = ((ucStatus & 0x08)>0);
554 lpcst->fXoffSend = ((ucStatus & 0x10)>0);
555 lpcst->fEof = ((ucStatus & 0x20)>0);// Is break = Eof ??
556 lpcst->fTxim = ((ucStatus & 0x40)>0);
557
558 ulLen = sizeof(qInfo);
559 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
560 IOCTL_ASYNC,
561 ASYNC_GETINQUECOUNT,
562 0,0,0,
563 &qInfo,ulLen,&ulLen);
564 if(!rc)
565 {
566 lpcst->cbInQue = qInfo.cch;
567 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
568 IOCTL_ASYNC,
569 ASYNC_GETOUTQUECOUNT,
570 0,0,0,
571 &qInfo,ulLen,&ulLen);
572 if(!rc)
573 lpcst->cbOutQue = qInfo.cch;
574 }
575 }
576 }
577#endif
578
579 return(rc==0);
580}
581
582
583BOOL HMDeviceParPortClass::DeviceIoControl(PHMHANDLEDATA pHMHandleData,
584 DWORD dwIoControlCode,
585 LPVOID lpInBuffer,
586 DWORD nInBufferSize,
587 LPVOID lpOutBuffer,
588 DWORD nOutBufferSize,
589 LPDWORD lpBytesReturned,
590 LPOVERLAPPED lpOverlapped)
591{
592#ifdef DEBUG
593 char *msg = NULL;
594
595 switch(dwIoControlCode)
596 {
597/**
598 case IOCTL_DISK_FORMAT_TRACKS:
599 msg = "IOCTL_DISK_FORMAT_TRACKS";
600 break;
601*/
602 }
603
604 if(msg) {
605 dprintf(("HMDeviceParPortClass::DeviceIoControl %s %x %d %x %d %x %x", msg, lpInBuffer, nInBufferSize,
606 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped));
607 }
608#endif
609
610 switch(dwIoControlCode)
611 {
612// case IOCTL_SCSI_RESCAN_BUS:
613// break;
614
615 }
616 dprintf(("HMDeviceParPortClass::DeviceIoControl: unimplemented dwIoControlCode=%08lx\n", dwIoControlCode));
617 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
618 return FALSE;
619}
620
621
622BOOL HMDeviceParPortClass::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
623 LPCOMMCONFIG lpCC,
624 DWORD dwSize)
625{
626 dprintf(("HMDeviceParPortClass::SetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
627 pHMHandleData,
628 lpCC,
629 dwSize));
630
631 PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpDeviceData;
632 if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
633 {
634 SetLastError(ERROR_INVALID_HANDLE);
635 return FALSE;
636 }
637 memset(&pDevData->CommCfg,0, sizeof(COMMCONFIG));
638 memcpy(&pDevData->CommCfg,lpCC,dwSize>sizeof(COMMCONFIG)?sizeof(COMMCONFIG):dwSize);
639
640 return(TRUE);
641}
642
643
644BOOL HMDeviceParPortClass::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
645 LPCOMMCONFIG lpCC,
646 LPDWORD lpdwSize)
647{
648 dprintf(("HMDeviceParPortClass::GetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
649 pHMHandleData,
650 lpCC,
651 lpdwSize));
652
653
654 PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpDeviceData;
655
656 if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
657 *lpdwSize< sizeof(COMMCONFIG) )
658 {
659 SetLastError(ERROR_INSUFFICIENT_BUFFER);
660 *lpdwSize= sizeof(COMMCONFIG);
661 return FALSE;
662 }
663
664 if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
665 {
666 SetLastError(ERROR_INVALID_HANDLE);
667 return FALSE;
668 }
669
670 memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
671 *lpdwSize = sizeof(COMMCONFIG);
672 return(TRUE);
673}
674
675
676BOOL HMDeviceParPortClass::SetCommConfig( PHMHANDLEDATA pHMHandleData,
677 LPCOMMCONFIG lpCC,
678 DWORD dwSize )
679{
680 dprintf(("HMDeviceParPortClass::SetCommConfig not implemented"));
681
682 return(TRUE);
683}
684
685
686BOOL HMDeviceParPortClass::GetCommConfig( PHMHANDLEDATA pHMHandleData,
687 LPCOMMCONFIG lpCC,
688 LPDWORD lpdwSize )
689{
690 PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpHandlerData;
691
692 dprintf(("HMDeviceParPortClass::GetCommConfig(%08xh,%08xh,%08xh)\n",
693 pHMHandleData,
694 lpCC,
695 lpdwSize));
696
697 if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
698 *lpdwSize< sizeof(COMMCONFIG) )
699 {
700 SetLastError(ERROR_INSUFFICIENT_BUFFER);
701 *lpdwSize= sizeof(COMMCONFIG);
702 return FALSE;
703 }
704
705 if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
706 {
707 SetLastError(ERROR_INVALID_HANDLE);
708 return FALSE;
709 }
710
711 memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
712 *lpdwSize = sizeof(COMMCONFIG);
713 return(TRUE);
714}
Note: See TracBrowser for help on using the repository browser.