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

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

added IOCTL_CDROM_PLAY_AUDIO_MSF
File size: 33.0 KB
Line 
1/* $Id: hmdisk.cpp,v 1.15 2001-10-10 14:47:42 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 ParameterBlock.ucSignature = 0x43443031; // 'CD01'
554 ParameterBlock.ucAddressingMode = 1; // MSF format
555
556 // @@@PH unknown if this kind of MSF conversion is correct!
557 ParameterBlock.ulStartingMSF = pPlay->StartingM << 16 |
558 pPlay->StartingS << 8 |
559 pPlay->StartingF;
560 ParameterBlock.ulEndingMSF = pPlay->EndingM << 16 |
561 pPlay->EndingS << 8 |
562 pPlay->EndingF;
563
564 DWORD dwParameterSize = sizeof( ParameterBlock );
565 DWORD dwDataSize = 0;
566 DWORD ret;
567
568 if(lpBytesReturned)
569 *lpBytesReturned = 0;
570
571 ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle,
572 0x81, // IOCTL_CDROMAUDIO
573 0x50, // CDROMAUDIO_PLAYAUDIO
574 &ParameterBlock,
575 sizeof( ParameterBlock ),
576 &dwParameterSize,
577 NULL,
578 0,
579 &dwDataSize);
580 if(ret)
581 {
582 SetLastError(error2WinError(ret));
583 return FALSE;
584 }
585 SetLastError(ERROR_SUCCESS);
586 return TRUE;
587 }
588
589 case IOCTL_CDROM_SEEK_AUDIO_MSF:
590 break;
591
592 case IOCTL_CDROM_PAUSE_AUDIO:
593 // NO BREAK CASE
594 // Note: for OS/2, pause and stop seems to be the same!
595
596 case IOCTL_CDROM_STOP_AUDIO:
597 {
598 dprintf(("Stop / pause CDROM audio playback"));
599 return ioctlCDROMSimple(pHMHandleData,
600 0x81, // IOCTL_CDROMAUDIO
601 0x51, // CDROMAUDIO_STOPAUDIO
602 lpBytesReturned);
603 }
604
605 case IOCTL_CDROM_RESUME_AUDIO:
606 {
607 dprintf(("Resume CDROM audio playback"));
608 return ioctlCDROMSimple(pHMHandleData,
609 0x81, // IOCTL_CDROMAUDIO
610 0x52, // CDROMAUDIO_RESUMEAUDIO
611 lpBytesReturned);
612 }
613
614 case IOCTL_CDROM_GET_VOLUME:
615 {
616 PVOLUME_CONTROL pVol = (PVOLUME_CONTROL)lpOutBuffer;
617 char volbuf[8];
618 DWORD parsize, datasize, ret;
619
620 if(nOutBufferSize < sizeof(VOLUME_CONTROL) || !pVol) {
621 SetLastError(ERROR_INSUFFICIENT_BUFFER);
622 return FALSE;
623 }
624 if(lpBytesReturned) {
625 *lpBytesReturned = 0;
626 }
627 parsize = 4;
628 datasize = 8;
629 ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x60, "CD01", 4, &parsize,
630 volbuf, 8, &datasize);
631
632 if(ret) {
633 SetLastError(error2WinError(ret));
634 return FALSE;
635 }
636 if(lpBytesReturned) {
637 *lpBytesReturned = sizeof(VOLUME_CONTROL);
638 }
639 pVol->PortVolume[0] = volbuf[1];
640 pVol->PortVolume[1] = volbuf[3];
641 pVol->PortVolume[2] = volbuf[5];
642 pVol->PortVolume[3] = volbuf[7];
643 SetLastError(ERROR_SUCCESS);
644 return TRUE;
645 }
646
647 case IOCTL_CDROM_SET_VOLUME:
648 {
649 PVOLUME_CONTROL pVol = (PVOLUME_CONTROL)lpInBuffer;
650 char volbuf[8];
651 DWORD parsize, datasize, ret;
652
653 if(nInBufferSize < sizeof(VOLUME_CONTROL) || !pVol) {
654 SetLastError(ERROR_INSUFFICIENT_BUFFER);
655 return FALSE;
656 }
657 if(lpBytesReturned) {
658 *lpBytesReturned = 0;
659 }
660 parsize = 4;
661 datasize = 8;
662 volbuf[0] = 0;
663 volbuf[1] = pVol->PortVolume[0];
664 volbuf[2] = 1;
665 volbuf[3] = pVol->PortVolume[1];
666 volbuf[4] = 2;
667 volbuf[5] = pVol->PortVolume[2];
668 volbuf[6] = 3;
669 volbuf[7] = pVol->PortVolume[3];
670 dprintf(("Set CD volume (%d,%d)(%d,%d)", pVol->PortVolume[0], pVol->PortVolume[1], pVol->PortVolume[2], pVol->PortVolume[3]));
671 ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x40, "CD01", 4, &parsize,
672 volbuf, 8, &datasize);
673
674 if(ret) {
675 SetLastError(error2WinError(ret));
676 return FALSE;
677 }
678 SetLastError(ERROR_SUCCESS);
679 return TRUE;
680 }
681 case IOCTL_CDROM_READ_Q_CHANNEL:
682 case IOCTL_CDROM_GET_LAST_SESSION:
683 case IOCTL_CDROM_RAW_READ:
684 case IOCTL_CDROM_DISK_TYPE:
685 case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
686 case IOCTL_CDROM_CHECK_VERIFY:
687 case IOCTL_CDROM_MEDIA_REMOVAL:
688 break;
689
690 case IOCTL_CDROM_EJECT_MEDIA:
691 {
692 dprintf(("Eject CDROM media"));
693 return ioctlCDROMSimple(pHMHandleData,
694 0x80, // IOCTL_CDROM
695 0x44, // CDROMDISK_EJECTDISK
696 lpBytesReturned);
697 }
698
699 case IOCTL_CDROM_LOAD_MEDIA:
700 {
701 dprintf(("Loading CDROM media"));
702 return ioctlCDROMSimple(pHMHandleData,
703 0x80, // IOCTL_CDROM
704 0x45, // CDROMDISK_CLOSETRAY
705 lpBytesReturned);
706 }
707
708 case IOCTL_CDROM_RESERVE:
709 case IOCTL_CDROM_RELEASE:
710 case IOCTL_CDROM_FIND_NEW_DEVICES:
711 break;
712
713
714 // -------------
715 // STORAGE class
716 // -------------
717
718 case IOCTL_DISK_CHECK_VERIFY:
719 case IOCTL_STORAGE_CHECK_VERIFY:
720 dprintf(("IOCTL_STORAGE_CHECK_VERIFY incompletely implemented"));
721 if(lpBytesReturned) {
722 *lpBytesReturned = 0;
723 }
724 //TODO: check if disk has been inserted or removed
725 if(pHMHandleData->hHMHandle == 0) {
726 SetLastError(ERROR_NOT_READY);
727 return FALSE;
728 }
729 SetLastError(NO_ERROR);
730 return TRUE;
731
732 case IOCTL_DISK_EJECT_MEDIA:
733 case IOCTL_STORAGE_EJECT_MEDIA:
734 {
735 dprintf(("Ejecting storage media"));
736 return ioctlDISKUnlockEject(pHMHandleData,
737 0x02, // EJECT media
738 -1,
739 lpBytesReturned);
740 }
741
742 case IOCTL_STORAGE_GET_MEDIA_TYPES:
743 break;
744
745 case IOCTL_STORAGE_LOAD_MEDIA:
746 // case IOCTL_STORAGE_LOAD_MEDIA2:
747 {
748 dprintf(("Loading storage media"));
749 return ioctlDISKUnlockEject(pHMHandleData,
750 0x03, // LOAD media
751 -1,
752 lpBytesReturned);
753 }
754
755 // case IOCTL_STORAGE_EJECTION_CONTROL:
756 case IOCTL_STORAGE_MEDIA_REMOVAL:
757 break;
758
759
760 // -------------------
761 // SCSI passthru class
762 // -------------------
763
764 case IOCTL_SCSI_PASS_THROUGH:
765 case IOCTL_SCSI_MINIPORT:
766 case IOCTL_SCSI_GET_INQUIRY_DATA:
767 case IOCTL_SCSI_GET_CAPABILITIES:
768 break;
769
770 case IOCTL_SCSI_PASS_THROUGH_DIRECT:
771 {
772 PSCSI_PASS_THROUGH_DIRECT pPacket = (PSCSI_PASS_THROUGH_DIRECT)lpOutBuffer;
773 SRB_ExecSCSICmd *psrb;
774
775 if(drvInfo->hInstAspi == NULL) {
776 SetLastError(ERROR_ACCESS_DENIED);
777 return FALSE;
778 }
779
780 if(nOutBufferSize < sizeof(SCSI_PASS_THROUGH_DIRECT) ||
781 !pPacket || pPacket->Length < sizeof(SCSI_PASS_THROUGH_DIRECT))
782 {
783 SetLastError(ERROR_INSUFFICIENT_BUFFER);
784 return FALSE;
785 }
786 if(lpBytesReturned) {
787 *lpBytesReturned = 0;
788 }
789 psrb = (SRB_ExecSCSICmd *)alloca(sizeof(SRB_ExecSCSICmd)+pPacket->SenseInfoLength);
790 if(psrb == NULL) {
791 dprintf(("not enough memory!!"));
792 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
793 return FALSE;
794 }
795 memset(psrb, 0, sizeof(*psrb));
796 psrb->SRB_Cmd = SC_EXEC_SCSI_CMD;
797 psrb->SRB_Status = pPacket->ScsiStatus;
798 psrb->SRB_HaId = pPacket->PathId;
799 psrb->SRB_Target = pPacket->TargetId;
800 psrb->SRB_Lun = pPacket->Lun;
801 psrb->SRB_BufLen = pPacket->DataTransferLength;
802 psrb->SRB_SenseLen = pPacket->SenseInfoLength;
803 psrb->SRB_CDBLen = pPacket->CdbLength;
804 switch(pPacket->DataIn) {
805 case SCSI_IOCTL_DATA_OUT:
806 psrb->SRB_Flags = 0x2 << 3;
807 break;
808 case SCSI_IOCTL_DATA_IN:
809 psrb->SRB_Flags = 0x1 << 3;
810 break;
811 case SCSI_IOCTL_DATA_UNSPECIFIED:
812 psrb->SRB_Flags = 0x3 << 3;
813 break;
814 }
815 if(pPacket->CdbLength > 16) {
816 SetLastError(ERROR_INVALID_PARAMETER);
817 return FALSE;
818 }
819 psrb->SRB_BufPointer = (BYTE *)pPacket->DataBuffer;
820 memcpy(&psrb->CDBByte[0], &pPacket->Cdb[0], 16);
821 if(psrb->SRB_SenseLen) {
822 memcpy(&psrb->SenseArea[0], (char *)pPacket + pPacket->SenseInfoOffset, psrb->SRB_SenseLen);
823 }
824 //TODO: pPacket->TimeOutValue ignored
825 int rc = drvInfo->SendASPI32Command((LPSRB)psrb);
826 if(rc != SS_COMP) {
827 dprintf(("SendASPI32Command failed with error %d", rc));
828 if(rc == SS_ERR) {
829 SetLastError(ERROR_ADAP_HDW_ERR); //returned by NT4, SP6
830 }
831 else SetLastError(ERROR_GEN_FAILURE);
832 return FALSE;
833 }
834 pPacket->ScsiStatus = rc;
835 if(lpBytesReturned) {
836 *lpBytesReturned = 0;
837 }
838 pPacket->DataTransferLength = psrb->SRB_BufLen;
839 if(psrb->SRB_SenseLen) {
840 memcpy((char *)pPacket + pPacket->SenseInfoOffset, &psrb->SenseArea[0], psrb->SRB_SenseLen);
841 }
842 SetLastError(ERROR_SUCCESS);
843 return TRUE;
844 }
845 case IOCTL_SCSI_GET_ADDRESS:
846 {
847 DWORD numAdapters, rc;
848 SRB srb;
849 int i, j, k;
850
851 if(!lpOutBuffer || nOutBufferSize < 8) {
852 SetLastError(ERROR_INSUFFICIENT_BUFFER); //todo: right error?
853 return(FALSE);
854 }
855 SCSI_ADDRESS *addr = (SCSI_ADDRESS *)lpOutBuffer;
856 addr->Length = sizeof(SCSI_ADDRESS);
857 addr->PortNumber = 0;
858 addr->PathId = 0;
859 numAdapters = drvInfo->GetASPI32SupportInfo();
860 if(LOBYTE(numAdapters) == 0) goto failure;
861
862 memset(&srb, 0, sizeof(srb));
863 srb.common.SRB_Cmd = SC_HA_INQUIRY;
864 rc = drvInfo->SendASPI32Command(&srb);
865
866 char drivename[3];
867 drivename[0] = (char)drvInfo->driveLetter;
868 drivename[1] = ':';
869 drivename[2] = 0;
870
871 for(i=0;i<LOBYTE(numAdapters);i++) {
872 for(j=0;j<8;j++) {
873 for(k=0;k<16;k++) {
874 memset(&srb, 0, sizeof(srb));
875 srb.common.SRB_Cmd = SC_GET_DEV_TYPE;
876 srb.devtype.SRB_HaId = i;
877 srb.devtype.SRB_Target = j;
878 srb.devtype.SRB_Lun = k;
879 rc = drvInfo->SendASPI32Command(&srb);
880 if(rc == SS_COMP) {
881 if(srb.devtype.SRB_DeviceType == SS_DEVTYPE_CDROM &&
882 GetDriveTypeA(drivename) == DRIVE_CDROM)
883 {
884 goto done;
885 }
886 }
887 }
888 }
889 }
890done:
891 if(rc == SS_COMP) {
892 addr->TargetId = j;
893 addr->Lun = k;
894 SetLastError(ERROR_SUCCESS);
895 }
896 else SetLastError(ERROR_FILE_NOT_FOUND); //todo
897 return TRUE;
898failure:
899 SetLastError(ERROR_INVALID_PARAMETER); //todo
900 return FALSE;
901 }
902
903 case IOCTL_SCSI_RESCAN_BUS:
904 case IOCTL_SCSI_GET_DUMP_POINTERS:
905 case IOCTL_SCSI_FREE_DUMP_POINTERS:
906 case IOCTL_IDE_PASS_THROUGH:
907 break;
908
909 }
910 dprintf(("HMDeviceDiskClass::DeviceIoControl: unimplemented dwIoControlCode=%08lx\n", dwIoControlCode));
911 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
912 return FALSE;
913}
914/*****************************************************************************
915 * Name : BOOL HMDeviceDiskClass::ReadFile
916 * Purpose : read data from handle / device
917 * Parameters: PHMHANDLEDATA pHMHandleData,
918 * LPCVOID lpBuffer,
919 * DWORD nNumberOfBytesToRead,
920 * LPDWORD lpNumberOfBytesRead,
921 * LPOVERLAPPED lpOverlapped
922 * Variables :
923 * Result : Boolean
924 * Remark :
925 * Status :
926 *
927 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
928 *****************************************************************************/
929
930BOOL HMDeviceDiskClass::ReadFile(PHMHANDLEDATA pHMHandleData,
931 LPCVOID lpBuffer,
932 DWORD nNumberOfBytesToRead,
933 LPDWORD lpNumberOfBytesRead,
934 LPOVERLAPPED lpOverlapped)
935{
936 LPVOID lpRealBuf;
937 Win32MemMap *map;
938 DWORD offset, bytesread;
939 BOOL bRC;
940
941 dprintf2(("KERNEL32: HMDeviceDiskClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
942 lpHMDeviceName,
943 pHMHandleData,
944 lpBuffer,
945 nNumberOfBytesToRead,
946 lpNumberOfBytesRead,
947 lpOverlapped));
948
949 //SvL: It's legal for this pointer to be NULL
950 if(lpNumberOfBytesRead)
951 *lpNumberOfBytesRead = 0;
952 else
953 lpNumberOfBytesRead = &bytesread;
954
955 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
956 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
957 SetLastError(ERROR_INVALID_PARAMETER);
958 return FALSE;
959 }
960 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
961 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
962 }
963
964 //SvL: DosRead doesn't like writing to memory addresses returned by
965 // DosAliasMem -> search for original memory mapped pointer and use
966 // that one + commit pages if not already present
967 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_WRITE);
968 if(map) {
969 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
970 DWORD nrpages = nNumberOfBytesToRead/4096;
971 if(offset & 0xfff)
972 nrpages++;
973 if(nNumberOfBytesToRead & 0xfff)
974 nrpages++;
975
976 map->commitPage(offset & ~0xfff, TRUE, nrpages);
977 }
978 else lpRealBuf = (LPVOID)lpBuffer;
979
980 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
981 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
982 }
983// else {
984 bRC = OSLibDosRead(pHMHandleData->hHMHandle,
985 (PVOID)lpRealBuf,
986 nNumberOfBytesToRead,
987 lpNumberOfBytesRead);
988// }
989
990 if(bRC == 0) {
991 dprintf(("KERNEL32: HMDeviceDiskClass::ReadFile returned %08xh %x", bRC, GetLastError()));
992 dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
993 }
994
995 return bRC;
996}
997/*****************************************************************************
998 * Name : DWORD HMDeviceDiskClass::SetFilePointer
999 * Purpose : set file pointer
1000 * Parameters: PHMHANDLEDATA pHMHandleData
1001 * LONG lDistanceToMove
1002 * PLONG lpDistanceToMoveHigh
1003 * DWORD dwMoveMethod
1004 * Variables :
1005 * Result : API returncode
1006 * Remark :
1007 * Status :
1008 *
1009 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1010 *****************************************************************************/
1011
1012DWORD HMDeviceDiskClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
1013 LONG lDistanceToMove,
1014 PLONG lpDistanceToMoveHigh,
1015 DWORD dwMoveMethod)
1016{
1017 DWORD ret;
1018
1019 dprintf2(("KERNEL32: HMDeviceDiskClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
1020 lpHMDeviceName,
1021 pHMHandleData,
1022 lDistanceToMove,
1023 lpDistanceToMoveHigh,
1024 dwMoveMethod));
1025
1026 ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
1027 lDistanceToMove,
1028 (DWORD *)lpDistanceToMoveHigh,
1029 dwMoveMethod);
1030
1031 if(ret == -1) {
1032 dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
1033 }
1034 return ret;
1035}
1036//******************************************************************************
1037//******************************************************************************
Note: See TracBrowser for help on using the repository browser.