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

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

.
File size: 22.1 KB
Line 
1/* $Id: hmparport.cpp,v 1.3 2001-11-08 15:38:43 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 VOID *pData;
117 dprintf(("HMDeviceParPortClass: Register LPT1 to LPT3 with Handle Manager\n"));
118
119 pData = CreateDevData();
120 if(pData!= NULL)
121 HMDeviceRegisterEx("LPT1", this, pData);
122}
123
124/*****************************************************************************
125 * Name : HMDeviceParPortClass::FindDevice
126 * Purpose : Checks if lpDeviceName belongs to this device class
127 * Parameters: LPCSTR lpClassDevName
128 * LPCSTR lpDeviceName
129 * int namelength
130 * Variables :
131 * Result : checks if name is COMx or COMx: (x=1..8)
132 * Remark :
133 * Status :
134 *
135 * Author : SvL
136 *****************************************************************************/
137BOOL HMDeviceParPortClass::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
138{
139 if(namelength > 5)
140 return FALSE; //can't be lpt name
141
142 //first 3 letters 'LPT'?
143 if(lstrncmpiA(lpDeviceName, lpClassDevName, 3) != 0) {
144 return FALSE;
145 }
146
147 if(namelength == 5 && lpDeviceName[4] != ':') {
148 return FALSE;
149 }
150 switch(lpDeviceName[3]) {
151 case '1':
152 case '2':
153 case '3':
154 return TRUE; //we support up to LPT3
155 }
156 return FALSE;
157}
158
159DWORD HMDeviceParPortClass::CreateFile(LPCSTR lpFileName,
160 PHMHANDLEDATA pHMHandleData,
161 PVOID lpSecurityAttributes,
162 PHMHANDLEDATA pHMHandleDataTemplate)
163{
164 char comname[6];
165
166 dprintf(("HMDeviceParPortClass: Parallel port %s open request\n", lpFileName));
167
168 if(strlen(lpFileName) > 5) {
169 return -1; //safety check (unnecessary..)
170 }
171 pHMHandleData->hHMHandle = 0;
172
173 strcpy(comname, lpFileName);
174 comname[4] = 0; //get rid of : (if present) (eg LPT1:)
175
176 //AH: TODO parse Win32 security handles
177 ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS);
178 pHMHandleData->hHMHandle = OSLibDosOpen(comname,
179 OSLIB_ACCESS_READWRITE |
180 OSLIB_ACCESS_SHAREDENYREAD |
181 OSLIB_ACCESS_SHAREDENYWRITE);
182 SetErrorMode(oldmode);
183
184#if 0
185 if (pHMHandleData->hHMHandle != 0)
186 {
187 ULONG ulLen;
188 APIRET rc;
189 pHMHandleData->lpHandlerData = new HMDEVPARPORTDATA();
190 // Init The handle instance with the default default device config
191 memcpy( pHMHandleData->lpHandlerData,
192 pHMHandleData->lpDeviceData,
193 sizeof(HMDEVPARPORTDATA));
194
195 ulLen = sizeof(DCBINFO);
196
197 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
198 IOCTL_ASYNC,
199 ASYNC_GETDCBINFO,
200 0,0,0,
201 &((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2,ulLen,&ulLen);
202 dprintf(("DCB Of %s :\n"
203 " WriteTimeout : %d\n"
204 " ReadTimeout : %d\n"
205 " CtlHandshake : 0x%x\n"
206 " FlowReplace : 0x%x\n"
207 " Timeout : 0x%x\n"
208 " Error replacement Char : 0x%x\n"
209 " Break replacement Char : 0x%x\n"
210 " XON Char : 0x%x\n"
211 " XOFF Char : 0x%x\n",
212 comname,
213 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.usWriteTimeout,
214 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.usReadTimeout,
215 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbCtlHndShake,
216 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbFlowReplace,
217 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbTimeOut,
218 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bErrorReplacementChar,
219 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bBreakReplacementChar,
220 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bXONChar,
221 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bXOFFChar));
222
223 if(rc)
224 {
225 return -1;
226 }
227 rc = SetBaud(pHMHandleData,9600);
228 dprintf(("Init Baud to 9600 rc = %d",rc));
229 rc = SetLine(pHMHandleData,8,0,0);
230 dprintf(("Set Line to 8/N/1 rc = %d",rc));
231 return 0;
232 }
233 else
234 return -1;
235#endif
236
237 return NO_ERROR;
238}
239
240
241 /* this is a handler method for calls to CloseHandle() */
242BOOL HMDeviceParPortClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
243{
244 dprintf(("HMDeviceParPortClass: Parallel port close request\n"));
245 delete pHMHandleData->lpHandlerData;
246 return OSLibDosClose(pHMHandleData->hHMHandle);
247}
248
249
250/*****************************************************************************
251 * Name : BOOL HMDeviceParPortClass::WriteFile
252 * Purpose : write data to handle / device
253 * Parameters: PHMHANDLEDATA pHMHandleData,
254 * LPCVOID lpBuffer,
255 * DWORD nNumberOfBytesToWrite,
256 * LPDWORD lpNumberOfBytesWritten,
257 * LPOVERLAPPED lpOverlapped
258 * Variables :
259 * Result : Boolean
260 * Remark :
261 * Status :
262 *
263 * Author : SvL
264 *****************************************************************************/
265
266BOOL HMDeviceParPortClass::WriteFile(PHMHANDLEDATA pHMHandleData,
267 LPCVOID lpBuffer,
268 DWORD nNumberOfBytesToWrite,
269 LPDWORD lpNumberOfBytesWritten,
270 LPOVERLAPPED lpOverlapped)
271{
272 dprintf(("KERNEL32:HMDeviceParPortClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
273 lpHMDeviceName,
274 pHMHandleData->hHMHandle,
275 lpBuffer,
276 nNumberOfBytesToWrite,
277 lpNumberOfBytesWritten,
278 lpOverlapped));
279
280 BOOL ret;
281 ULONG ulBytesWritten;
282
283 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
284 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
285 SetLastError(ERROR_INVALID_PARAMETER);
286 return FALSE;
287 }
288 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
289 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
290 }
291
292 ret = OSLibDosWrite(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToWrite,
293 &ulBytesWritten);
294
295 if(lpNumberOfBytesWritten) {
296 *lpNumberOfBytesWritten = (ret) ? ulBytesWritten : 0;
297 }
298 if(ret == FALSE) {
299 dprintf(("ERROR: WriteFile failed with rc %d", GetLastError()));
300 }
301
302 return ret;
303}
304
305/*****************************************************************************
306 * Name : BOOL WriteFileEx
307 * Purpose : The WriteFileEx function writes data to a file. It is designed
308 * solely for asynchronous operation, unlike WriteFile, which is
309 * designed for both synchronous and asynchronous operation.
310 * WriteFileEx reports its completion status asynchronously,
311 * calling a specified completion routine when writing is completed
312 * and the calling thread is in an alertable wait state.
313 * Parameters: HANDLE hFile handle of file to write
314 * LPVOID lpBuffer address of buffer
315 * DWORD nNumberOfBytesToRead number of bytes to write
316 * LPOVERLAPPED lpOverlapped address of offset
317 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
318 * Variables :
319 * Result : TRUE / FALSE
320 * Remark :
321 * Status : UNTESTED STUB
322 *
323 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
324 *****************************************************************************/
325
326BOOL HMDeviceParPortClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
327 LPVOID lpBuffer,
328 DWORD nNumberOfBytesToWrite,
329 LPOVERLAPPED lpOverlapped,
330 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
331{
332 dprintf(("ERROR: WriteFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
333 lpHMDeviceName,
334 pHMHandleData->hHMHandle,
335 lpBuffer,
336 nNumberOfBytesToWrite,
337 lpOverlapped,
338 lpCompletionRoutine));
339
340 SetLastError(ERROR_INVALID_FUNCTION);
341 return FALSE;
342}
343
344/*****************************************************************************
345 * Name : BOOL HMDeviceParPortClass::ReadFile
346 * Purpose : read data from handle / device
347 * Parameters: PHMHANDLEDATA pHMHandleData,
348 * LPCVOID lpBuffer,
349 * DWORD nNumberOfBytesToRead,
350 * LPDWORD lpNumberOfBytesRead,
351 * LPOVERLAPPED lpOverlapped
352 * Variables :
353 * Result : Boolean
354 * Remark :
355 * Status :
356 *
357 * Author : SvL
358 *****************************************************************************/
359
360BOOL HMDeviceParPortClass::ReadFile(PHMHANDLEDATA pHMHandleData,
361 LPCVOID lpBuffer,
362 DWORD nNumberOfBytesToRead,
363 LPDWORD lpNumberOfBytesRead,
364 LPOVERLAPPED lpOverlapped)
365{
366 dprintf(("KERNEL32:HMDeviceParPortClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
367 lpHMDeviceName,
368 pHMHandleData->hHMHandle,
369 lpBuffer,
370 nNumberOfBytesToRead,
371 lpNumberOfBytesRead,
372 lpOverlapped));
373
374 BOOL ret;
375 ULONG ulBytesRead;
376
377 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
378 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
379 SetLastError(ERROR_INVALID_PARAMETER);
380 return FALSE;
381 }
382 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
383 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
384 }
385
386 ret = OSLibDosRead(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToRead,
387 &ulBytesRead);
388
389 if(lpNumberOfBytesRead) {
390 *lpNumberOfBytesRead = (ret) ? ulBytesRead : 0;
391 }
392 if(ret == FALSE) {
393 dprintf(("ERROR: ReadFile failed with rc %d", GetLastError()));
394 }
395 return ret;
396}
397
398/*****************************************************************************
399 * Name : BOOL ReadFileEx
400 * Purpose : The ReadFileEx function reads data from a file asynchronously.
401 * It is designed solely for asynchronous operation, unlike the
402 * ReadFile function, which is designed for both synchronous and
403 * asynchronous operation. ReadFileEx lets an application perform
404 * other processing during a file read operation.
405 * The ReadFileEx function reports its completion status asynchronously,
406 * calling a specified completion routine when reading is completed
407 * and the calling thread is in an alertable wait state.
408 * Parameters: HANDLE hFile handle of file to read
409 * LPVOID lpBuffer address of buffer
410 * DWORD nNumberOfBytesToRead number of bytes to read
411 * LPOVERLAPPED lpOverlapped address of offset
412 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
413 * Variables :
414 * Result : TRUE / FALSE
415 * Remark :
416 * Status : UNTESTED STUB
417 *
418 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
419 *****************************************************************************/
420BOOL HMDeviceParPortClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
421 LPVOID lpBuffer,
422 DWORD nNumberOfBytesToRead,
423 LPOVERLAPPED lpOverlapped,
424 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
425{
426 dprintf(("ERROR: ReadFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
427 lpHMDeviceName,
428 pHMHandleData->hHMHandle,
429 lpBuffer,
430 nNumberOfBytesToRead,
431 lpOverlapped,
432 lpCompletionRoutine));
433
434 SetLastError(ERROR_INVALID_FUNCTION);
435 return FALSE;
436}
437
438BOOL HMDeviceParPortClass::GetCommProperties( PHMHANDLEDATA pHMHandleData,
439 LPCOMMPROP lpcmmp)
440{
441 APIRET rc;
442 ULONG ulLen;
443 int i;
444 dprintf(("HMDeviceParPortClass::GetCommProperties"));
445
446#if 0
447 USHORT COMErr;
448 EXTBAUDGET BaudInfo;
449 ulLen = sizeof(EXTBAUDGET);
450 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
451 IOCTL_ASYNC,
452 ASYNC_EXTGETBAUDRATE,
453 0,0,0,
454 &BaudInfo,ulLen,&ulLen);
455#endif
456 rc = NO_ERROR;
457
458 memset(lpcmmp,0,sizeof(COMMPROP));
459 lpcmmp->wPacketLength = sizeof(COMMPROP);
460 lpcmmp->wPacketVersion = 1; //???
461 lpcmmp->dwProvSubType = PST_PARALLELPORT;
462
463#if 0
464 lpcmmp->dwServiceMask = SP_SERIALCOMM;
465 for(i=0;i<BaudTableSize && BaudInfo.ulMaxBaud <= BaudTable[i].dwBaudRate;i++);
466 lpcmmp->dwMaxBaud = BaudTable[i].dwBaudFlag;
467 lpcmmp->dwProvCapabilities = PCF_DTRDSR | PCF_PARITY_CHECK |
468 PCF_RTSCTS | PCF_SETXCHAR |
469 PCF_XONXOFF;
470 lpcmmp->dwSettableParams = SP_BAUD | SP_DATABITS |
471 SP_HANDSHAKEING | SP_PARITY |
472 SP_PARITY_CHECK | SP_STOPBIT;
473 lpcmmp->dwSettableBaud = 0;
474 for(i=0;i<BaudTableSize;i++)
475 {
476 if ( (BaudTable[i].dwBaudRate>=BaudInfo.ulMinBaud) &&
477 (BaudTable[i].dwBaudRate<=BaudInfo.ulMaxBaud) )
478 lpcmmp->dwSettableBaud |= BaudTable[i].dwBaudFlag;
479 }
480 lpcmmp->dwSettableBaud |= BAUD_USER;
481 lpcmmp->wSettableData = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8;
482 lpcmmp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
483 PARITY_NONE | PARITY_ODD | PARITY_EVEN |
484 PARITY_MARK | PARITY_SPACE;
485#endif
486
487 return(rc==0);
488}
489
490BOOL HMDeviceParPortClass::ClearCommError( PHMHANDLEDATA pHMHandleData,
491 LPDWORD lpdwErrors,
492 LPCOMSTAT lpcst)
493{
494 APIRET rc;
495 ULONG ulLen;
496 USHORT COMErr;
497
498 dprintf(("HMDeviceParPortClass::ClearCommError"));
499 ulLen = sizeof(USHORT);
500
501 *lpdwErrors = 0;
502 rc = NO_ERROR;
503
504#if 0
505 // ParPort: CE_DNS, CE_OOP CE_PTO
506
507 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
508 IOCTL_ASYNC,
509 ASYNC_GETCOMMERROR,
510 0,0,0,
511 &COMErr,2,&ulLen);
512 *lpdwErrors |= (COMErr & 0x0001)?CE_OVERRUN:0;
513 *lpdwErrors |= (COMErr & 0x0002)?CE_RXOVER:0;
514 *lpdwErrors |= (COMErr & 0x0004)?CE_RXPARITY:0;
515 *lpdwErrors |= (COMErr & 0x0008)?CE_FRAME:0;
516
517 if(lpcst)
518 {
519 UCHAR ucStatus;
520 RXQUEUE qInfo;
521 ulLen = 1;
522 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
523 IOCTL_ASYNC,
524 ASYNC_GETCOMMSTATUS,
525 0,0,0,
526 &ucStatus,ulLen,&ulLen);
527 if(!rc)
528 {
529 lpcst->fCtsHold = ((ucStatus & 0x01)>0);
530 lpcst->fDsrHold = ((ucStatus & 0x02)>0);
531 lpcst->fRlsdHold = FALSE;//(ucStatus & 0x04)>0);
532 lpcst->fXoffHold = ((ucStatus & 0x08)>0);
533 lpcst->fXoffSend = ((ucStatus & 0x10)>0);
534 lpcst->fEof = ((ucStatus & 0x20)>0);// Is break = Eof ??
535 lpcst->fTxim = ((ucStatus & 0x40)>0);
536
537 ulLen = sizeof(qInfo);
538 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
539 IOCTL_ASYNC,
540 ASYNC_GETINQUECOUNT,
541 0,0,0,
542 &qInfo,ulLen,&ulLen);
543 if(!rc)
544 {
545 lpcst->cbInQue = qInfo.cch;
546 rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
547 IOCTL_ASYNC,
548 ASYNC_GETOUTQUECOUNT,
549 0,0,0,
550 &qInfo,ulLen,&ulLen);
551 if(!rc)
552 lpcst->cbOutQue = qInfo.cch;
553 }
554 }
555 }
556#endif
557
558 return(rc==0);
559}
560
561
562BOOL HMDeviceParPortClass::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
563 LPVOID lpInBuffer, DWORD nInBufferSize,
564 LPVOID lpOutBuffer, DWORD nOutBufferSize,
565 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
566{
567#ifdef DEBUG
568 char *msg = NULL;
569
570 switch(dwIoControlCode)
571 {
572/**
573 case IOCTL_DISK_FORMAT_TRACKS:
574 msg = "IOCTL_DISK_FORMAT_TRACKS";
575 break;
576*/
577 }
578
579 if(msg) {
580 dprintf(("HMDeviceParPortClass::DeviceIoControl %s %x %d %x %d %x %x", msg, lpInBuffer, nInBufferSize,
581 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped));
582 }
583#endif
584
585 switch(dwIoControlCode)
586 {
587// case IOCTL_SCSI_RESCAN_BUS:
588// break;
589
590 }
591 dprintf(("HMDeviceParPortClass::DeviceIoControl: unimplemented dwIoControlCode=%08lx\n", dwIoControlCode));
592 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
593 return FALSE;
594}
595
596
597BOOL HMDeviceParPortClass::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
598 LPCOMMCONFIG lpCC,
599 DWORD dwSize)
600{
601 PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpDeviceData;
602 if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
603 {
604 SetLastError(ERROR_INVALID_HANDLE);
605 return FALSE;
606 }
607 memset(&pDevData->CommCfg,0, sizeof(COMMCONFIG));
608 memcpy(&pDevData->CommCfg,lpCC,dwSize>sizeof(COMMCONFIG)?sizeof(COMMCONFIG):dwSize);
609
610 return(TRUE);
611}
612
613
614BOOL HMDeviceParPortClass::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
615 LPCOMMCONFIG lpCC,
616 LPDWORD lpdwSize)
617{
618 PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpDeviceData;
619
620 if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
621 *lpdwSize< sizeof(COMMCONFIG) )
622 {
623 SetLastError(ERROR_INSUFFICIENT_BUFFER);
624 *lpdwSize= sizeof(COMMCONFIG);
625 return FALSE;
626 }
627
628 if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
629 {
630 SetLastError(ERROR_INVALID_HANDLE);
631 return FALSE;
632 }
633
634 memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
635 *lpdwSize = sizeof(COMMCONFIG);
636 return(TRUE);
637}
638
639
640BOOL HMDeviceParPortClass::SetCommConfig( PHMHANDLEDATA pHMHandleData,
641 LPCOMMCONFIG lpCC,
642 DWORD dwSize )
643{
644 dprintf(("HMDeviceParPortClass::SetCommConfig not implemented"));
645
646
647 return(TRUE);
648}
649
650
651BOOL HMDeviceParPortClass::GetCommConfig( PHMHANDLEDATA pHMHandleData,
652 LPCOMMCONFIG lpCC,
653 LPDWORD lpdwSize )
654{
655 PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpHandlerData;
656
657 dprintf(("HMDeviceParPortClass::GetCommConfig"));
658
659 if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
660 *lpdwSize< sizeof(COMMCONFIG) )
661 {
662 SetLastError(ERROR_INSUFFICIENT_BUFFER);
663 *lpdwSize= sizeof(COMMCONFIG);
664 return FALSE;
665 }
666
667 if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
668 {
669 SetLastError(ERROR_INVALID_HANDLE);
670 return FALSE;
671 }
672
673 memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
674 *lpdwSize = sizeof(COMMCONFIG);
675 return(TRUE);
676}
Note: See TracBrowser for help on using the repository browser.