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

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