source: trunk/src/kernel32/hmdisk.cpp@ 7159

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

corrected endianness in CDROM_PLAY_AUDIO_MSF
File size: 33.0 KB
Line 
1/* $Id: hmdisk.cpp,v 1.17 2001-10-10 15:06:06 phaller Exp $ */
2
3/*
4 * Win32 Disk API functions for OS/2
5 *
6 * Copyright 2000 Sander van Leeuwen
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12#include <os2win.h>
13#include <string.h>
14
15#include <misc.h>
16#include "hmdisk.h"
17#include "mmap.h"
18#include "oslibdos.h"
19#include <win\winioctl.h>
20#include <win\ntddscsi.h>
21#include <win\wnaspi32.h>
22#include <win\aspi.h>
23
24#define DBG_LOCALLOG DBG_hmdisk
25#include "dbglocal.h"
26
27typedef struct
28{
29 HINSTANCE hInstAspi;
30 DWORD (WIN32API *GetASPI32SupportInfo)();
31 DWORD (CDECL *SendASPI32Command)(LPSRB lpSRB);
32 ULONG driveLetter;
33 CHAR signature[8];
34} DRIVE_INFO;
35
36HMDeviceDiskClass::HMDeviceDiskClass(LPCSTR lpDeviceName) : HMDeviceKernelObjectClass(lpDeviceName)
37{
38 HMDeviceRegisterEx("\\\\.\\PHYSICALDRIVE", this, NULL);
39}
40
41/*****************************************************************************
42 * Name : HMDeviceDiskClass::FindDevice
43 * Purpose : Checks if lpDeviceName belongs to this device class
44 * Parameters: LPCSTR lpClassDevName
45 * LPCSTR lpDeviceName
46 * int namelength
47 * Variables :
48 * Result : checks if name is for a drive of physical disk
49 * Remark :
50 * Status :
51 *
52 * Author : SvL
53 *****************************************************************************/
54BOOL HMDeviceDiskClass::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
55{
56 //\\.\x: -> length 6
57 //\\.\PHYSICALDRIVEn -> length 18
58 if(namelength != 6 && namelength != 18) {
59 return FALSE;
60 }
61
62 //SvL: \\.\x: -> drive x (i.e. \\.\C:)
63 // \\.\PHYSICALDRIVEn -> drive n (n>=0)
64 if((strncmp(lpDeviceName, "\\\\.\\", 4) == 0) &&
65 namelength == 6 && lpDeviceName[5] == ':')
66 {
67 return TRUE;
68 }
69 if((strncmp(lpDeviceName, "\\\\.\\PHYSICALDRIVE", 17) == 0) && namelength == 18) {
70 return TRUE;
71 }
72 return FALSE;
73}
74//******************************************************************************
75//TODO: PHYSICALDRIVEn!!
76//******************************************************************************
77DWORD HMDeviceDiskClass::CreateFile (LPCSTR lpFileName,
78 PHMHANDLEDATA pHMHandleData,
79 PVOID lpSecurityAttributes,
80 PHMHANDLEDATA pHMHandleDataTemplate)
81{
82 HFILE hFile;
83 HFILE hTemplate;
84
85 dprintf2(("KERNEL32: HMDeviceDiskClass::CreateFile %s(%s,%08x,%08x,%08x)\n",
86 lpHMDeviceName,
87 lpFileName,
88 pHMHandleData,
89 lpSecurityAttributes,
90 pHMHandleDataTemplate));
91
92 //TODO: check in NT if CREATE_ALWAYS is allowed!!
93 if(pHMHandleData->dwCreation != OPEN_EXISTING) {
94 dprintf(("Invalid creation flags %x!!", pHMHandleData->dwCreation));
95 return ERROR_INVALID_PARAMETER;
96 }
97 if(strncmp(lpFileName, // "support" for local unc names
98 "\\\\.\\",
99 4) == 0)
100 {
101 lpFileName+=4;
102 }
103
104 //Disable error popus. NT allows an app to open a cdrom/dvd drive without a disk inside
105 //OS/2 fails in that case with error ERROR_NOT_READY
106 OSLibDosDisableHardError(TRUE);
107 hFile = OSLibDosCreateFile((LPSTR)lpFileName,
108 pHMHandleData->dwAccess,
109 pHMHandleData->dwShare,
110 (LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
111 pHMHandleData->dwCreation,
112 pHMHandleData->dwFlags,
113 hTemplate);
114 OSLibDosDisableHardError(FALSE);
115
116 if (hFile != INVALID_HANDLE_ERROR || GetLastError() == ERROR_NOT_READY)
117 {
118 if(hFile == INVALID_HANDLE_ERROR) {
119 SetLastError(NO_ERROR);
120 pHMHandleData->hHMHandle = 0; //handle lookup fails if this is set to -1
121 }
122 else pHMHandleData->hHMHandle = hFile;
123
124 DRIVE_INFO *drvInfo = (DRIVE_INFO *)malloc(sizeof(DRIVE_INFO));
125 if(drvInfo == NULL) {
126 if(pHMHandleData->hHMHandle) OSLibDosClose(pHMHandleData->hHMHandle);
127 return ERROR_OUTOFMEMORY;
128 }
129 pHMHandleData->dwUserData = (DWORD)drvInfo;
130
131 memset(drvInfo, 0, sizeof(DRIVE_INFO));
132 drvInfo->driveLetter = *lpFileName; //save drive letter
133 if(drvInfo->driveLetter >= 'a') {
134 drvInfo->driveLetter = drvInfo->driveLetter - ((int)'a' - (int)'A');
135 }
136
137 if(GetDriveTypeA(lpFileName) == DRIVE_CDROM) {
138 drvInfo->hInstAspi = LoadLibraryA("WNASPI32.DLL");
139 if(drvInfo->hInstAspi == NULL) {
140 if(pHMHandleData->hHMHandle) OSLibDosClose(pHMHandleData->hHMHandle);
141 free(drvInfo);
142 return ERROR_INVALID_PARAMETER;
143 }
144 *(FARPROC *)&drvInfo->GetASPI32SupportInfo = GetProcAddress(drvInfo->hInstAspi, "GetASPI32SupportInfo");
145 *(FARPROC *)&drvInfo->SendASPI32Command = GetProcAddress(drvInfo->hInstAspi, "SendASPI32Command");
146
147 //get cdrom signature (TODO: why doesn't this work???)
148 DWORD parsize = 4;
149 DWORD datasize = 4;
150 strcpy(drvInfo->signature, "CD01");
151 OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x60, &drvInfo->signature[0], 4, &parsize,
152 &drvInfo->signature[0], 4, &datasize);
153 }
154 return (NO_ERROR);
155 }
156 else {
157 dprintf(("CreateFile failed; error %d", GetLastError()));
158 return(GetLastError());
159 }
160}
161//******************************************************************************
162//******************************************************************************
163BOOL HMDeviceDiskClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
164{
165 BOOL ret = TRUE;
166
167 if(pHMHandleData->hHMHandle) {
168 ret = OSLibDosClose(pHMHandleData->hHMHandle);
169 }
170 if(pHMHandleData->dwUserData) {
171 DRIVE_INFO *drvInfo = (DRIVE_INFO*)pHMHandleData->dwUserData;
172 if(drvInfo->hInstAspi) FreeLibrary(drvInfo->hInstAspi);
173 free(drvInfo);
174 }
175 return ret;
176}
177//******************************************************************************
178//******************************************************************************
179
180
181// this helper function just calls the specified
182// ioctl function for the CDROM manager with no
183// parameter packet other than the CD01 signature
184// and no data packet.
185static BOOL ioctlCDROMSimple(PHMHANDLEDATA pHMHandleData,
186 DWORD dwCategory,
187 DWORD dwFunction,
188 LPDWORD lpBytesReturned)
189{
190 DWORD dwParameterSize = 4;
191 DWORD dwDataSize = 0;
192 DWORD ret;
193
194 if(lpBytesReturned)
195 *lpBytesReturned = 0;
196
197 ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle,
198 dwCategory,
199 dwFunction,
200 "CD01",
201 4,
202 &dwParameterSize,
203 NULL,
204 0,
205 &dwDataSize);
206 if(ret)
207 {
208 SetLastError(error2WinError(ret));
209 return FALSE;
210 }
211 SetLastError(ERROR_SUCCESS);
212 return TRUE;
213}
214
215
216// this helper function just calls the specified
217// ioctl function for the DISK manager with the
218// specified function codes
219static BOOL ioctlDISKUnlockEject(PHMHANDLEDATA pHMHandleData,
220 DWORD dwCommand,
221 DWORD dwDiskHandle,
222 LPDWORD lpBytesReturned)
223{
224#pragma pack(1)
225 struct
226 {
227 BYTE ucCommand;
228 BYTE ucHandle;
229 } ParameterBlock;
230#pragma pack()
231
232 DWORD dwParameterSize = sizeof( ParameterBlock );
233 DWORD dwDataSize = 0;
234 DWORD ret;
235
236 ParameterBlock.ucCommand = dwCommand;
237 ParameterBlock.ucHandle = dwDiskHandle;
238
239 if(lpBytesReturned)
240 *lpBytesReturned = 0;
241
242 ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle,
243 0x08, // IOCTL_DISK
244 0x40, // DSK_UNLOCKEJECTMEDIA
245 &ParameterBlock,
246 sizeof( ParameterBlock ),
247 &dwParameterSize,
248 NULL,
249 0,
250 &dwDataSize);
251 if(ret)
252 {
253 SetLastError(error2WinError(ret));
254 return FALSE;
255 }
256 SetLastError(ERROR_SUCCESS);
257 return TRUE;
258}
259
260
261
262BOOL HMDeviceDiskClass::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
263 LPVOID lpInBuffer, DWORD nInBufferSize,
264 LPVOID lpOutBuffer, DWORD nOutBufferSize,
265 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
266{
267#ifdef DEBUG
268 char *msg = NULL;
269
270 switch(dwIoControlCode)
271 {
272 case FSCTL_DELETE_REPARSE_POINT:
273 msg = "FSCTL_DELETE_REPARSE_POINT";
274 break;
275 case FSCTL_DISMOUNT_VOLUME:
276 msg = "FSCTL_DISMOUNT_VOLUME";
277 break;
278 case FSCTL_GET_COMPRESSION:
279 msg = "FSCTL_GET_COMPRESSION";
280 break;
281 case FSCTL_GET_REPARSE_POINT:
282 msg = "FSCTL_GET_REPARSE_POINT";
283 break;
284 case FSCTL_LOCK_VOLUME:
285 msg = "FSCTL_LOCK_VOLUME";
286 break;
287 case FSCTL_QUERY_ALLOCATED_RANGES:
288 msg = "FSCTL_QUERY_ALLOCATED_RANGES";
289 break;
290 case FSCTL_SET_COMPRESSION:
291 msg = "FSCTL_SET_COMPRESSION";
292 break;
293 case FSCTL_SET_REPARSE_POINT:
294 msg = "FSCTL_SET_REPARSE_POINT";
295 break;
296 case FSCTL_SET_SPARSE:
297 msg = "FSCTL_SET_SPARSE";
298 break;
299 case FSCTL_SET_ZERO_DATA:
300 msg = "FSCTL_SET_ZERO_DATA";
301 break;
302 case FSCTL_UNLOCK_VOLUME:
303 msg = "FSCTL_UNLOCK_VOLUME";
304 break;
305 case IOCTL_DISK_CHECK_VERIFY:
306 msg = "IOCTL_DISK_CHECK_VERIFY";
307 break;
308 case IOCTL_DISK_EJECT_MEDIA:
309 msg = "IOCTL_DISK_EJECT_MEDIA";
310 break;
311 case IOCTL_DISK_FORMAT_TRACKS:
312 msg = "IOCTL_DISK_FORMAT_TRACKS";
313 break;
314 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
315 msg = "IOCTL_DISK_GET_DRIVE_GEOMETRY";
316 break;
317 case IOCTL_DISK_GET_DRIVE_LAYOUT:
318 msg = "IOCTL_DISK_GET_DRIVE_LAYOUT";
319 break;
320 case IOCTL_DISK_GET_MEDIA_TYPES:
321 msg = "IOCTL_DISK_GET_MEDIA_TYPES";
322 break;
323 case IOCTL_DISK_GET_PARTITION_INFO:
324 msg = "IOCTL_DISK_GET_PARTITION_INFO";
325 break;
326 case IOCTL_DISK_LOAD_MEDIA:
327 msg = "IOCTL_DISK_LOAD_MEDIA";
328 break;
329 case IOCTL_DISK_MEDIA_REMOVAL:
330 msg = "IOCTL_DISK_MEDIA_REMOVAL";
331 break;
332 case IOCTL_DISK_PERFORMANCE:
333 msg = "IOCTL_DISK_PERFORMANCE";
334 break;
335 case IOCTL_DISK_REASSIGN_BLOCKS:
336 msg = "IOCTL_DISK_REASSIGN_BLOCKS";
337 break;
338 case IOCTL_DISK_SET_DRIVE_LAYOUT:
339 msg = "IOCTL_DISK_SET_DRIVE_LAYOUT";
340 break;
341 case IOCTL_DISK_SET_PARTITION_INFO:
342 msg = "IOCTL_DISK_SET_PARTITION_INFO";
343 break;
344 case IOCTL_DISK_VERIFY:
345 msg = "IOCTL_DISK_VERIFY";
346 break;
347 case IOCTL_SERIAL_LSRMST_INSERT:
348 msg = "IOCTL_SERIAL_LSRMST_INSERT";
349 break;
350 case IOCTL_STORAGE_CHECK_VERIFY:
351 msg = "IOCTL_STORAGE_CHECK_VERIFY";
352 break;
353 case IOCTL_STORAGE_EJECT_MEDIA:
354 msg = "IOCTL_STORAGE_EJECT_MEDIA";
355 break;
356 case IOCTL_STORAGE_GET_MEDIA_TYPES:
357 msg = "IOCTL_STORAGE_GET_MEDIA_TYPES";
358 break;
359 case IOCTL_STORAGE_LOAD_MEDIA:
360 msg = "IOCTL_STORAGE_LOAD_MEDIA";
361 break;
362 case IOCTL_STORAGE_MEDIA_REMOVAL:
363 msg = "IOCTL_STORAGE_MEDIA_REMOVAL";
364 break;
365 case IOCTL_SCSI_PASS_THROUGH:
366 msg = "IOCTL_SCSI_PASS_THROUGH";
367 break;
368 case IOCTL_SCSI_MINIPORT:
369 msg = "IOCTL_SCSI_MINIPORT";
370 break;
371 case IOCTL_SCSI_GET_INQUIRY_DATA:
372 msg = "IOCTL_SCSI_GET_INQUIRY_DATA";
373 break;
374 case IOCTL_SCSI_GET_CAPABILITIES:
375 msg = "IOCTL_SCSI_GET_CAPABILITIES";
376 break;
377 case IOCTL_SCSI_PASS_THROUGH_DIRECT:
378 msg = "IOCTL_SCSI_PASS_THROUGH_DIRECT";
379 break;
380 case IOCTL_SCSI_GET_ADDRESS:
381 msg = "IOCTL_SCSI_GET_ADDRESS";
382 break;
383 case IOCTL_SCSI_RESCAN_BUS:
384 msg = "IOCTL_SCSI_RESCAN_BUS";
385 break;
386 case IOCTL_SCSI_GET_DUMP_POINTERS:
387 msg = "IOCTL_SCSI_GET_DUMP_POINTERS";
388 break;
389 case IOCTL_SCSI_FREE_DUMP_POINTERS:
390 msg = "IOCTL_SCSI_FREE_DUMP_POINTERS";
391 break;
392 case IOCTL_IDE_PASS_THROUGH:
393 msg = "IOCTL_IDE_PASS_THROUGH";
394 break;
395 case IOCTL_CDROM_UNLOAD_DRIVER:
396 msg = "IOCTL_CDROM_UNLOAD_DRIVER";
397 break;
398 case IOCTL_CDROM_READ_TOC:
399 msg = "IOCTL_CDROM_READ_TOC";
400 break;
401 case IOCTL_CDROM_GET_CONTROL:
402 msg = "IOCTL_CDROM_GET_CONTROL";
403 break;
404 case IOCTL_CDROM_PLAY_AUDIO_MSF:
405 msg = "IOCTL_CDROM_PLAY_AUDIO_MSF";
406 break;
407 case IOCTL_CDROM_SEEK_AUDIO_MSF:
408 msg = "IOCTL_CDROM_SEEK_AUDIO_MSF";
409 break;
410 case IOCTL_CDROM_STOP_AUDIO:
411 msg = "IOCTL_CDROM_STOP_AUDIO";
412 break;
413 case IOCTL_CDROM_PAUSE_AUDIO:
414 msg = "IOCTL_CDROM_PAUSE_AUDIO";
415 break;
416 case IOCTL_CDROM_RESUME_AUDIO:
417 msg = "IOCTL_CDROM_RESUME_AUDIO";
418 break;
419 case IOCTL_CDROM_GET_VOLUME:
420 msg = "IOCTL_CDROM_GET_VOLUME";
421 break;
422 case IOCTL_CDROM_SET_VOLUME:
423 msg = "IOCTL_CDROM_SET_VOLUME";
424 break;
425 case IOCTL_CDROM_READ_Q_CHANNEL:
426 msg = "IOCTL_CDROM_READ_Q_CHANNEL";
427 break;
428 case IOCTL_CDROM_GET_LAST_SESSION:
429 msg = "IOCTL_CDROM_GET_LAST_SESSION";
430 break;
431 case IOCTL_CDROM_RAW_READ:
432 msg = "IOCTL_CDROM_RAW_READ";
433 break;
434 case IOCTL_CDROM_DISK_TYPE:
435 msg = "IOCTL_CDROM_DISK_TYPE";
436 break;
437 case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
438 msg = "IOCTL_CDROM_GET_DRIVE_GEOMETRY";
439 break;
440 case IOCTL_CDROM_CHECK_VERIFY:
441 msg = "IOCTL_CDROM_CHECK_VERIFY";
442 break;
443 case IOCTL_CDROM_MEDIA_REMOVAL:
444 msg = "IOCTL_CDROM_MEDIA_REMOVAL";
445 break;
446 case IOCTL_CDROM_EJECT_MEDIA:
447 msg = "IOCTL_CDROM_EJECT_MEDIA";
448 break;
449 case IOCTL_CDROM_LOAD_MEDIA:
450 msg = "IOCTL_CDROM_LOAD_MEDIA";
451 break;
452 case IOCTL_CDROM_RESERVE:
453 msg = "IOCTL_CDROM_RESERVE";
454 break;
455 case IOCTL_CDROM_RELEASE:
456 msg = "IOCTL_CDROM_RELEASE";
457 break;
458 case IOCTL_CDROM_FIND_NEW_DEVICES:
459 msg = "IOCTL_CDROM_FIND_NEW_DEVICES";
460 break;
461 }
462 if(msg) {
463 dprintf(("HMDeviceDiskClass::DeviceIoControl %s %x %d %x %d %x %x", msg, lpInBuffer, nInBufferSize,
464 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped));
465 }
466#endif
467
468 DRIVE_INFO *drvInfo = (DRIVE_INFO*)pHMHandleData->dwUserData;
469 if(drvInfo == NULL) {
470 dprintf(("ERROR: DeviceIoControl: drvInfo == NULL!!!"));
471 DebugInt3();
472 SetLastError(ERROR_INVALID_HANDLE);
473 return FALSE;
474 }
475 switch(dwIoControlCode)
476 {
477 case FSCTL_DELETE_REPARSE_POINT:
478 case FSCTL_DISMOUNT_VOLUME:
479 case FSCTL_GET_COMPRESSION:
480 case FSCTL_GET_REPARSE_POINT:
481 case FSCTL_LOCK_VOLUME:
482 case FSCTL_QUERY_ALLOCATED_RANGES:
483 case FSCTL_SET_COMPRESSION:
484 case FSCTL_SET_REPARSE_POINT:
485 case FSCTL_SET_SPARSE:
486 case FSCTL_SET_ZERO_DATA:
487 case FSCTL_UNLOCK_VOLUME:
488 break;
489
490 case IOCTL_DISK_FORMAT_TRACKS:
491 case IOCTL_DISK_GET_DRIVE_LAYOUT:
492 break;
493
494 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
495 case IOCTL_DISK_GET_MEDIA_TYPES:
496 {
497 PDISK_GEOMETRY pGeom = (PDISK_GEOMETRY)lpOutBuffer;
498 if(nOutBufferSize < sizeof(DISK_GEOMETRY) || !pGeom) {
499 SetLastError(ERROR_INSUFFICIENT_BUFFER);
500 return FALSE;
501 }
502 if(lpBytesReturned) {
503 *lpBytesReturned = 0;
504 }
505 if(OSLibDosGetDiskGeometry(pHMHandleData->hHMHandle, drvInfo->driveLetter, pGeom) == FALSE) {
506 return FALSE;
507 }
508 if(lpBytesReturned) {
509 *lpBytesReturned = sizeof(DISK_GEOMETRY);
510 }
511 SetLastError(ERROR_SUCCESS);
512 return TRUE;
513 }
514
515 case IOCTL_DISK_GET_PARTITION_INFO:
516 case IOCTL_DISK_LOAD_MEDIA:
517 case IOCTL_DISK_MEDIA_REMOVAL:
518 case IOCTL_DISK_PERFORMANCE:
519 case IOCTL_DISK_REASSIGN_BLOCKS:
520 case IOCTL_DISK_SET_DRIVE_LAYOUT:
521 case IOCTL_DISK_SET_PARTITION_INFO:
522 case IOCTL_DISK_VERIFY:
523 case IOCTL_SERIAL_LSRMST_INSERT:
524 break;
525
526
527 // -----------
528 // CDROM class
529 // -----------
530
531 case IOCTL_CDROM_UNLOAD_DRIVER:
532 case IOCTL_CDROM_READ_TOC:
533 case IOCTL_CDROM_GET_CONTROL:
534 break;
535
536 case IOCTL_CDROM_PLAY_AUDIO_MSF:
537 {
538 dprintf(("Play CDROM audio playback"));
539
540#pragma pack(1)
541 struct
542 {
543 DWORD ucSignature;
544 BYTE ucAddressingMode;
545 DWORD ulStartingMSF;
546 DWORD ulEndingMSF;
547 } ParameterBlock;
548#pragma pack()
549
550 PCDROM_PLAY_AUDIO_MSF pPlay = (PCDROM_PLAY_AUDIO_MSF)lpInBuffer;
551
552 // setup the parameter block
553
554 ParameterBlock.ucSignature = 0x31304443; // 'CD01'
555 ParameterBlock.ucAddressingMode = 1; // MSF format
556
557 // @@@PH unknown if this kind of MSF conversion is correct!
558 ParameterBlock.ulStartingMSF = pPlay->StartingM << 16 |
559 pPlay->StartingS << 8 |
560 pPlay->StartingF;
561 ParameterBlock.ulEndingMSF = pPlay->EndingM << 16 |
562 pPlay->EndingS << 8 |
563 pPlay->EndingF;
564
565 DWORD dwParameterSize = sizeof( ParameterBlock );
566 DWORD dwDataSize = 0;
567 DWORD ret;
568
569 if(lpBytesReturned)
570 *lpBytesReturned = 0;
571
572 ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle,
573 0x81, // IOCTL_CDROMAUDIO
574 0x50, // CDROMAUDIO_PLAYAUDIO
575 &ParameterBlock,
576 sizeof( ParameterBlock ),
577 &dwParameterSize,
578 NULL,
579 0,
580 &dwDataSize);
581 if(ret)
582 {
583 SetLastError(error2WinError(ret));
584 return FALSE;
585 }
586 SetLastError(ERROR_SUCCESS);
587 return TRUE;
588 }
589
590 case IOCTL_CDROM_SEEK_AUDIO_MSF:
591 break;
592
593 case IOCTL_CDROM_PAUSE_AUDIO:
594 // NO BREAK CASE
595 // Note: for OS/2, pause and stop seems to be the same!
596
597 case IOCTL_CDROM_STOP_AUDIO:
598 {
599 dprintf(("Stop / pause CDROM audio playback"));
600 return ioctlCDROMSimple(pHMHandleData,
601 0x81, // IOCTL_CDROMAUDIO
602 0x51, // CDROMAUDIO_STOPAUDIO
603 lpBytesReturned);
604 }
605
606 case IOCTL_CDROM_RESUME_AUDIO:
607 {
608 dprintf(("Resume CDROM audio playback"));
609 return ioctlCDROMSimple(pHMHandleData,
610 0x81, // IOCTL_CDROMAUDIO
611 0x52, // CDROMAUDIO_RESUMEAUDIO
612 lpBytesReturned);
613 }
614
615 case IOCTL_CDROM_GET_VOLUME:
616 {
617 PVOLUME_CONTROL pVol = (PVOLUME_CONTROL)lpOutBuffer;
618 char volbuf[8];
619 DWORD parsize, datasize, ret;
620
621 if(nOutBufferSize < sizeof(VOLUME_CONTROL) || !pVol) {
622 SetLastError(ERROR_INSUFFICIENT_BUFFER);
623 return FALSE;
624 }
625 if(lpBytesReturned) {
626 *lpBytesReturned = 0;
627 }
628 parsize = 4;
629 datasize = 8;
630 ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x60, "CD01", 4, &parsize,
631 volbuf, 8, &datasize);
632
633 if(ret) {
634 SetLastError(error2WinError(ret));
635 return FALSE;
636 }
637 if(lpBytesReturned) {
638 *lpBytesReturned = sizeof(VOLUME_CONTROL);
639 }
640 pVol->PortVolume[0] = volbuf[1];
641 pVol->PortVolume[1] = volbuf[3];
642 pVol->PortVolume[2] = volbuf[5];
643 pVol->PortVolume[3] = volbuf[7];
644 SetLastError(ERROR_SUCCESS);
645 return TRUE;
646 }
647
648 case IOCTL_CDROM_SET_VOLUME:
649 {
650 PVOLUME_CONTROL pVol = (PVOLUME_CONTROL)lpInBuffer;
651 char volbuf[8];
652 DWORD parsize, datasize, ret;
653
654 if(nInBufferSize < sizeof(VOLUME_CONTROL) || !pVol) {
655 SetLastError(ERROR_INSUFFICIENT_BUFFER);
656 return FALSE;
657 }
658 if(lpBytesReturned) {
659 *lpBytesReturned = 0;
660 }
661 parsize = 4;
662 datasize = 8;
663 volbuf[0] = 0;
664 volbuf[1] = pVol->PortVolume[0];
665 volbuf[2] = 1;
666 volbuf[3] = pVol->PortVolume[1];
667 volbuf[4] = 2;
668 volbuf[5] = pVol->PortVolume[2];
669 volbuf[6] = 3;
670 volbuf[7] = pVol->PortVolume[3];
671 dprintf(("Set CD volume (%d,%d)(%d,%d)", pVol->PortVolume[0], pVol->PortVolume[1], pVol->PortVolume[2], pVol->PortVolume[3]));
672 ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x40, "CD01", 4, &parsize,
673 volbuf, 8, &datasize);
674
675 if(ret) {
676 SetLastError(error2WinError(ret));
677 return FALSE;
678 }
679 SetLastError(ERROR_SUCCESS);
680 return TRUE;
681 }
682 case IOCTL_CDROM_READ_Q_CHANNEL:
683 case IOCTL_CDROM_GET_LAST_SESSION:
684 case IOCTL_CDROM_RAW_READ:
685 case IOCTL_CDROM_DISK_TYPE:
686 case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
687 case IOCTL_CDROM_CHECK_VERIFY:
688 case IOCTL_CDROM_MEDIA_REMOVAL:
689 break;
690
691 case IOCTL_CDROM_EJECT_MEDIA:
692 {
693 dprintf(("Eject CDROM media"));
694 return ioctlCDROMSimple(pHMHandleData,
695 0x80, // IOCTL_CDROM
696 0x44, // CDROMDISK_EJECTDISK
697 lpBytesReturned);
698 }
699
700 case IOCTL_CDROM_LOAD_MEDIA:
701 {
702 dprintf(("Loading CDROM media"));
703 return ioctlCDROMSimple(pHMHandleData,
704 0x80, // IOCTL_CDROM
705 0x45, // CDROMDISK_CLOSETRAY
706 lpBytesReturned);
707 }
708
709 case IOCTL_CDROM_RESERVE:
710 case IOCTL_CDROM_RELEASE:
711 case IOCTL_CDROM_FIND_NEW_DEVICES:
712 break;
713
714
715 // -------------
716 // STORAGE class
717 // -------------
718
719 case IOCTL_DISK_CHECK_VERIFY:
720 case IOCTL_STORAGE_CHECK_VERIFY:
721 dprintf(("IOCTL_STORAGE_CHECK_VERIFY incompletely implemented"));
722 if(lpBytesReturned) {
723 *lpBytesReturned = 0;
724 }
725 //TODO: check if disk has been inserted or removed
726 if(pHMHandleData->hHMHandle == 0) {
727 SetLastError(ERROR_NOT_READY);
728 return FALSE;
729 }
730 SetLastError(NO_ERROR);
731 return TRUE;
732
733 case IOCTL_DISK_EJECT_MEDIA:
734 case IOCTL_STORAGE_EJECT_MEDIA:
735 {
736 dprintf(("Ejecting storage media"));
737 return ioctlDISKUnlockEject(pHMHandleData,
738 0x02, // EJECT media
739 -1,
740 lpBytesReturned);
741 }
742
743 case IOCTL_STORAGE_GET_MEDIA_TYPES:
744 break;
745
746 case IOCTL_STORAGE_LOAD_MEDIA:
747 // case IOCTL_STORAGE_LOAD_MEDIA2:
748 {
749 dprintf(("Loading storage media"));
750 return ioctlDISKUnlockEject(pHMHandleData,
751 0x03, // LOAD media
752 -1,
753 lpBytesReturned);
754 }
755
756 // case IOCTL_STORAGE_EJECTION_CONTROL:
757 case IOCTL_STORAGE_MEDIA_REMOVAL:
758 break;
759
760
761 // -------------------
762 // SCSI passthru class
763 // -------------------
764
765 case IOCTL_SCSI_PASS_THROUGH:
766 case IOCTL_SCSI_MINIPORT:
767 case IOCTL_SCSI_GET_INQUIRY_DATA:
768 case IOCTL_SCSI_GET_CAPABILITIES:
769 break;
770
771 case IOCTL_SCSI_PASS_THROUGH_DIRECT:
772 {
773 PSCSI_PASS_THROUGH_DIRECT pPacket = (PSCSI_PASS_THROUGH_DIRECT)lpOutBuffer;
774 SRB_ExecSCSICmd *psrb;
775
776 if(drvInfo->hInstAspi == NULL) {
777 SetLastError(ERROR_ACCESS_DENIED);
778 return FALSE;
779 }
780
781 if(nOutBufferSize < sizeof(SCSI_PASS_THROUGH_DIRECT) ||
782 !pPacket || pPacket->Length < sizeof(SCSI_PASS_THROUGH_DIRECT))
783 {
784 SetLastError(ERROR_INSUFFICIENT_BUFFER);
785 return FALSE;
786 }
787 if(lpBytesReturned) {
788 *lpBytesReturned = 0;
789 }
790 psrb = (SRB_ExecSCSICmd *)alloca(sizeof(SRB_ExecSCSICmd)+pPacket->SenseInfoLength);
791 if(psrb == NULL) {
792 dprintf(("not enough memory!!"));
793 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
794 return FALSE;
795 }
796 memset(psrb, 0, sizeof(*psrb));
797 psrb->SRB_Cmd = SC_EXEC_SCSI_CMD;
798 psrb->SRB_Status = pPacket->ScsiStatus;
799 psrb->SRB_HaId = pPacket->PathId;
800 psrb->SRB_Target = pPacket->TargetId;
801 psrb->SRB_Lun = pPacket->Lun;
802 psrb->SRB_BufLen = pPacket->DataTransferLength;
803 psrb->SRB_SenseLen = pPacket->SenseInfoLength;
804 psrb->SRB_CDBLen = pPacket->CdbLength;
805 switch(pPacket->DataIn) {
806 case SCSI_IOCTL_DATA_OUT:
807 psrb->SRB_Flags = 0x2 << 3;
808 break;
809 case SCSI_IOCTL_DATA_IN:
810 psrb->SRB_Flags = 0x1 << 3;
811 break;
812 case SCSI_IOCTL_DATA_UNSPECIFIED:
813 psrb->SRB_Flags = 0x3 << 3;
814 break;
815 }
816 if(pPacket->CdbLength > 16) {
817 SetLastError(ERROR_INVALID_PARAMETER);
818 return FALSE;
819 }
820 psrb->SRB_BufPointer = (BYTE *)pPacket->DataBuffer;
821 memcpy(&psrb->CDBByte[0], &pPacket->Cdb[0], 16);
822 if(psrb->SRB_SenseLen) {
823 memcpy(&psrb->SenseArea[0], (char *)pPacket + pPacket->SenseInfoOffset, psrb->SRB_SenseLen);
824 }
825 //TODO: pPacket->TimeOutValue ignored
826 int rc = drvInfo->SendASPI32Command((LPSRB)psrb);
827 if(rc != SS_COMP) {
828 dprintf(("SendASPI32Command failed with error %d", rc));
829 if(rc == SS_ERR) {
830 SetLastError(ERROR_ADAP_HDW_ERR); //returned by NT4, SP6
831 }
832 else SetLastError(ERROR_GEN_FAILURE);
833 return FALSE;
834 }
835 pPacket->ScsiStatus = rc;
836 if(lpBytesReturned) {
837 *lpBytesReturned = 0;
838 }
839 pPacket->DataTransferLength = psrb->SRB_BufLen;
840 if(psrb->SRB_SenseLen) {
841 memcpy((char *)pPacket + pPacket->SenseInfoOffset, &psrb->SenseArea[0], psrb->SRB_SenseLen);
842 }
843 SetLastError(ERROR_SUCCESS);
844 return TRUE;
845 }
846 case IOCTL_SCSI_GET_ADDRESS:
847 {
848 DWORD numAdapters, rc;
849 SRB srb;
850 int i, j, k;
851
852 if(!lpOutBuffer || nOutBufferSize < 8) {
853 SetLastError(ERROR_INSUFFICIENT_BUFFER); //todo: right error?
854 return(FALSE);
855 }
856 SCSI_ADDRESS *addr = (SCSI_ADDRESS *)lpOutBuffer;
857 addr->Length = sizeof(SCSI_ADDRESS);
858 addr->PortNumber = 0;
859 addr->PathId = 0;
860 numAdapters = drvInfo->GetASPI32SupportInfo();
861 if(LOBYTE(numAdapters) == 0) goto failure;
862
863 memset(&srb, 0, sizeof(srb));
864 srb.common.SRB_Cmd = SC_HA_INQUIRY;
865 rc = drvInfo->SendASPI32Command(&srb);
866
867 char drivename[3];
868 drivename[0] = (char)drvInfo->driveLetter;
869 drivename[1] = ':';
870 drivename[2] = 0;
871
872 for(i=0;i<LOBYTE(numAdapters);i++) {
873 for(j=0;j<8;j++) {
874 for(k=0;k<16;k++) {
875 memset(&srb, 0, sizeof(srb));
876 srb.common.SRB_Cmd = SC_GET_DEV_TYPE;
877 srb.devtype.SRB_HaId = i;
878 srb.devtype.SRB_Target = j;
879 srb.devtype.SRB_Lun = k;
880 rc = drvInfo->SendASPI32Command(&srb);
881 if(rc == SS_COMP) {
882 if(srb.devtype.SRB_DeviceType == SS_DEVTYPE_CDROM &&
883 GetDriveTypeA(drivename) == DRIVE_CDROM)
884 {
885 goto done;
886 }
887 }
888 }
889 }
890 }
891done:
892 if(rc == SS_COMP) {
893 addr->TargetId = j;
894 addr->Lun = k;
895 SetLastError(ERROR_SUCCESS);
896 }
897 else SetLastError(ERROR_FILE_NOT_FOUND); //todo
898 return TRUE;
899failure:
900 SetLastError(ERROR_INVALID_PARAMETER); //todo
901 return FALSE;
902 }
903
904 case IOCTL_SCSI_RESCAN_BUS:
905 case IOCTL_SCSI_GET_DUMP_POINTERS:
906 case IOCTL_SCSI_FREE_DUMP_POINTERS:
907 case IOCTL_IDE_PASS_THROUGH:
908 break;
909
910 }
911 dprintf(("HMDeviceDiskClass::DeviceIoControl: unimplemented dwIoControlCode=%08lx\n", dwIoControlCode));
912 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
913 return FALSE;
914}
915/*****************************************************************************
916 * Name : BOOL HMDeviceDiskClass::ReadFile
917 * Purpose : read data from handle / device
918 * Parameters: PHMHANDLEDATA pHMHandleData,
919 * LPCVOID lpBuffer,
920 * DWORD nNumberOfBytesToRead,
921 * LPDWORD lpNumberOfBytesRead,
922 * LPOVERLAPPED lpOverlapped
923 * Variables :
924 * Result : Boolean
925 * Remark :
926 * Status :
927 *
928 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
929 *****************************************************************************/
930
931BOOL HMDeviceDiskClass::ReadFile(PHMHANDLEDATA pHMHandleData,
932 LPCVOID lpBuffer,
933 DWORD nNumberOfBytesToRead,
934 LPDWORD lpNumberOfBytesRead,
935 LPOVERLAPPED lpOverlapped)
936{
937 LPVOID lpRealBuf;
938 Win32MemMap *map;
939 DWORD offset, bytesread;
940 BOOL bRC;
941
942 dprintf2(("KERNEL32: HMDeviceDiskClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
943 lpHMDeviceName,
944 pHMHandleData,
945 lpBuffer,
946 nNumberOfBytesToRead,
947 lpNumberOfBytesRead,
948 lpOverlapped));
949
950 //SvL: It's legal for this pointer to be NULL
951 if(lpNumberOfBytesRead)
952 *lpNumberOfBytesRead = 0;
953 else
954 lpNumberOfBytesRead = &bytesread;
955
956 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
957 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
958 SetLastError(ERROR_INVALID_PARAMETER);
959 return FALSE;
960 }
961 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
962 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
963 }
964
965 //SvL: DosRead doesn't like writing to memory addresses returned by
966 // DosAliasMem -> search for original memory mapped pointer and use
967 // that one + commit pages if not already present
968 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_WRITE);
969 if(map) {
970 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
971 DWORD nrpages = nNumberOfBytesToRead/4096;
972 if(offset & 0xfff)
973 nrpages++;
974 if(nNumberOfBytesToRead & 0xfff)
975 nrpages++;
976
977 map->commitPage(offset & ~0xfff, TRUE, nrpages);
978 }
979 else lpRealBuf = (LPVOID)lpBuffer;
980
981 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
982 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
983 }
984// else {
985 bRC = OSLibDosRead(pHMHandleData->hHMHandle,
986 (PVOID)lpRealBuf,
987 nNumberOfBytesToRead,
988 lpNumberOfBytesRead);
989// }
990
991 if(bRC == 0) {
992 dprintf(("KERNEL32: HMDeviceDiskClass::ReadFile returned %08xh %x", bRC, GetLastError()));
993 dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
994 }
995
996 return bRC;
997}
998/*****************************************************************************
999 * Name : DWORD HMDeviceDiskClass::SetFilePointer
1000 * Purpose : set file pointer
1001 * Parameters: PHMHANDLEDATA pHMHandleData
1002 * LONG lDistanceToMove
1003 * PLONG lpDistanceToMoveHigh
1004 * DWORD dwMoveMethod
1005 * Variables :
1006 * Result : API returncode
1007 * Remark :
1008 * Status :
1009 *
1010 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1011 *****************************************************************************/
1012
1013DWORD HMDeviceDiskClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
1014 LONG lDistanceToMove,
1015 PLONG lpDistanceToMoveHigh,
1016 DWORD dwMoveMethod)
1017{
1018 DWORD ret;
1019
1020 dprintf2(("KERNEL32: HMDeviceDiskClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
1021 lpHMDeviceName,
1022 pHMHandleData,
1023 lDistanceToMove,
1024 lpDistanceToMoveHigh,
1025 dwMoveMethod));
1026
1027 ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
1028 lDistanceToMove,
1029 (DWORD *)lpDistanceToMoveHigh,
1030 dwMoveMethod);
1031
1032 if(ret == -1) {
1033 dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
1034 }
1035 return ret;
1036}
1037//******************************************************************************
1038//******************************************************************************
Note: See TracBrowser for help on using the repository browser.