1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /* Main file for CD-ROM support
4 * Copyright 1994 Martin Ayotte
5 * Copyright 1999, 2001, 2003 Eric Pouech
6 * Copyright 2000 Andreas Mohr
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "wine/port.h"
38 #include <sys/types.h>
40 #ifdef HAVE_SYS_IOCTL_H
41 #include <sys/ioctl.h>
46 #ifdef HAVE_SCSI_SCSI_H
47 # include <scsi/scsi.h>
48 # undef REASSIGN_BLOCKS /* avoid conflict with winioctl.h */
50 #ifdef HAVE_SCSI_SCSI_IOCTL_H
51 # include <scsi/scsi_ioctl.h>
53 #ifdef HAVE_LINUX_MAJOR_H
54 # include <linux/major.h>
56 #ifdef HAVE_LINUX_HDREG_H
57 # include <linux/hdreg.h>
59 #ifdef HAVE_LINUX_PARAM_H
60 # include <linux/param.h>
62 #ifdef HAVE_LINUX_CDROM_H
63 # include <linux/cdrom.h>
65 #ifdef HAVE_LINUX_UCDROM_H
66 # include <linux/ucdrom.h>
68 #ifdef HAVE_SYS_CDIO_H
69 # include <sys/cdio.h>
71 #ifdef HAVE_SYS_SCSIIO_H
72 # include <sys/scsiio.h>
75 #define NONAMELESSUNION
76 #define NONAMELESSSTRUCT
86 #include "ntdll_misc.h"
87 #include "wine/server.h"
88 #include "wine/library.h"
89 #include "wine/debug.h"
91 /* Non-Linux systems do not have linux/cdrom.h and the like, and thus
92 lack the following constants. */
95 #define CD_SECS 60 /* seconds per minute */
98 #define CD_FRAMES 75 /* frames per second */
101 static const struct iocodexs
106 {IOCTL_CDROM_UNLOAD_DRIVER
, "IOCTL_CDROM_UNLOAD_DRIVER"},
107 {IOCTL_CDROM_READ_TOC
, "IOCTL_CDROM_READ_TOC"},
108 {IOCTL_CDROM_GET_CONTROL
, "IOCTL_CDROM_GET_CONTROL"},
109 {IOCTL_CDROM_PLAY_AUDIO_MSF
, "IOCTL_CDROM_PLAY_AUDIO_MSF"},
110 {IOCTL_CDROM_SEEK_AUDIO_MSF
, "IOCTL_CDROM_SEEK_AUDIO_MSF"},
111 {IOCTL_CDROM_STOP_AUDIO
, "IOCTL_CDROM_STOP_AUDIO"},
112 {IOCTL_CDROM_PAUSE_AUDIO
, "IOCTL_CDROM_PAUSE_AUDIO"},
113 {IOCTL_CDROM_RESUME_AUDIO
, "IOCTL_CDROM_RESUME_AUDIO"},
114 {IOCTL_CDROM_GET_VOLUME
, "IOCTL_CDROM_GET_VOLUME"},
115 {IOCTL_CDROM_SET_VOLUME
, "IOCTL_CDROM_SET_VOLUME"},
116 {IOCTL_CDROM_READ_Q_CHANNEL
, "IOCTL_CDROM_READ_Q_CHANNEL"},
117 {IOCTL_CDROM_GET_LAST_SESSION
, "IOCTL_CDROM_GET_LAST_SESSION"},
118 {IOCTL_CDROM_RAW_READ
, "IOCTL_CDROM_RAW_READ"},
119 {IOCTL_CDROM_DISK_TYPE
, "IOCTL_CDROM_DISK_TYPE"},
120 {IOCTL_CDROM_GET_DRIVE_GEOMETRY
, "IOCTL_CDROM_GET_DRIVE_GEOMETRY"},
121 {IOCTL_CDROM_CHECK_VERIFY
, "IOCTL_CDROM_CHECK_VERIFY"},
122 {IOCTL_CDROM_MEDIA_REMOVAL
, "IOCTL_CDROM_MEDIA_REMOVAL"},
123 {IOCTL_CDROM_EJECT_MEDIA
, "IOCTL_CDROM_EJECT_MEDIA"},
124 {IOCTL_CDROM_LOAD_MEDIA
, "IOCTL_CDROM_LOAD_MEDIA"},
125 {IOCTL_CDROM_RESERVE
, "IOCTL_CDROM_RESERVE"},
126 {IOCTL_CDROM_RELEASE
, "IOCTL_CDROM_RELEASE"},
127 {IOCTL_CDROM_FIND_NEW_DEVICES
, "IOCTL_CDROM_FIND_NEW_DEVICES"}
129 static const char *iocodex(DWORD code
)
132 static char buffer
[25];
133 for(i
=0; i
<sizeof(iocodextable
)/sizeof(struct iocodexs
); i
++)
134 if (code
==iocodextable
[i
].code
)
135 return iocodextable
[i
].codex
;
136 sprintf(buffer
, "IOCTL_CODE_%x", (int)code
);
140 WINE_DEFAULT_DEBUG_CHANNEL(cdrom
);
142 #define FRAME_OF_ADDR(a) (((int)(a)[1] * CD_SECS + (a)[2]) * CD_FRAMES + (a)[3])
143 #define FRAME_OF_MSF(a) (((int)(a).M * CD_SECS + (a).S) * CD_FRAMES + (a).F)
144 #define FRAME_OF_TOC(toc, idx) FRAME_OF_ADDR((toc).TrackData[idx - (toc).FirstTrack].Address)
145 #define MSF_OF_FRAME(m,fr) {int f=(fr); ((UCHAR *)&(m))[2]=f%CD_FRAMES;f/=CD_FRAMES;((UCHAR *)&(m))[1]=f%CD_SECS;((UCHAR *)&(m))[0]=f/CD_SECS;}
147 static NTSTATUS
CDROM_ReadTOC(int, int, CDROM_TOC
*);
148 static NTSTATUS
CDROM_GetStatusCode(int);
154 # define IDE6_MAJOR 88
157 # define IDE7_MAJOR 89
160 # ifdef CDROM_SEND_PACKET
161 /* structure for CDROM_PACKET_COMMAND ioctl */
162 /* not all Linux versions have all the fields, so we define the
163 * structure ourselves to make sure */
164 struct linux_cdrom_generic_command
166 unsigned char cmd
[CDROM_PACKET_SIZE
];
167 unsigned char *buffer
;
170 struct request_sense
*sense
;
171 unsigned char data_direction
;
176 # endif /* CDROM_SEND_PACKET */
180 /* FIXME: this is needed because we can't open simultaneously several times /dev/cdrom
181 * this should be removed when a proper device interface is implemented
183 * (WS) We need this to keep track of current position and to safely
184 * detect media changes. Besides this should provide a great speed up
190 char toc_good
; /* if false, will reread TOC from disk */
192 SUB_Q_CURRENT_POSITION CurrentPosition
;
194 /* who has more than 5 cdroms on his/her machine ?? */
195 /* FIXME: this should grow depending on the number of cdroms we install/configure
198 #define MAX_CACHE_ENTRIES 5
199 static struct cdrom_cache cdrom_cache
[MAX_CACHE_ENTRIES
];
201 static CRITICAL_SECTION cache_section
;
202 static CRITICAL_SECTION_DEBUG critsect_debug
=
204 0, 0, &cache_section
,
205 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
206 0, 0, { 0, (DWORD
)(__FILE__
": cache_section") }
208 static CRITICAL_SECTION cache_section
= { &critsect_debug
, -1, 0, 0, 0, 0 };
210 /* Proposed media change function: not really needed at this time */
211 /* This is a 1 or 0 type of function */
213 static int CDROM_MediaChanged(int dev
)
217 struct cdrom_tochdr hdr
;
218 struct cdrom_tocentry entry
;
220 if (dev
< 0 || dev
>= MAX_CACHE_ENTRIES
)
222 if ( ioctl(cdrom_cache
[dev
].fd
, CDROMREADTOCHDR
, &hdr
) == -1 )
225 if ( memcmp(&hdr
, &cdrom_cache
[dev
].hdr
, sizeof(struct cdrom_tochdr
)) )
228 for (i
=hdr
.cdth_trk0
; i
<=hdr
.cdth_trk1
+1; i
++)
230 if (i
== hdr
.cdth_trk1
+ 1)
232 entry
.cdte_track
= CDROM_LEADOUT
;
234 entry
.cdte_track
= i
;
236 entry
.cdte_format
= CDROM_MSF
;
237 if ( ioctl(cdrom_cache
[dev
].fd
, CDROMREADTOCENTRY
, &entry
) == -1)
239 if ( memcmp(&entry
, cdrom_cache
[dev
].entry
+i
-hdr
.cdth_trk0
,
240 sizeof(struct cdrom_tocentry
)) )
247 /******************************************************************
248 * CDROM_SyncCache [internal]
250 * Read the TOC in and store it in the cdrom_cache structure.
251 * Further requests for the TOC will be copied from the cache
252 * unless certain events like disk ejection is detected, in which
253 * case the cache will be cleared, causing it to be resynced.
254 * The cache section must be held by caller.
256 static int CDROM_SyncCache(int dev
, int fd
)
260 struct cdrom_tochdr hdr
;
261 struct cdrom_tocentry entry
;
262 #elif defined(__FreeBSD__) || defined(__NetBSD__)
263 struct ioc_toc_header hdr
;
264 struct ioc_read_toc_entry entry
;
265 struct cd_toc_entry toc_buffer
;
267 CDROM_TOC
*toc
= &cdrom_cache
[dev
].toc
;
268 cdrom_cache
[dev
].toc_good
= 0;
272 io
= ioctl(fd
, CDROMREADTOCHDR
, &hdr
);
275 WARN("(%d) -- Error occurred (%s)!\n", dev
, strerror(errno
));
279 TRACE("caching toc from=%d to=%d\n", toc
->FirstTrack
, toc
->LastTrack
);
281 toc
->FirstTrack
= hdr
.cdth_trk0
;
282 toc
->LastTrack
= hdr
.cdth_trk1
;
283 tsz
= sizeof(toc
->FirstTrack
) + sizeof(toc
->LastTrack
)
284 + sizeof(TRACK_DATA
) * (toc
->LastTrack
-toc
->FirstTrack
+2);
285 toc
->Length
[0] = tsz
>> 8;
286 toc
->Length
[1] = tsz
;
288 for (i
= toc
->FirstTrack
; i
<= toc
->LastTrack
+ 1; i
++)
290 if (i
== toc
->LastTrack
+ 1)
291 entry
.cdte_track
= CDROM_LEADOUT
;
293 entry
.cdte_track
= i
;
294 entry
.cdte_format
= CDROM_MSF
;
295 io
= ioctl(fd
, CDROMREADTOCENTRY
, &entry
);
297 WARN("error read entry (%s)\n", strerror(errno
));
300 toc
->TrackData
[i
- toc
->FirstTrack
].Control
= entry
.cdte_ctrl
;
301 toc
->TrackData
[i
- toc
->FirstTrack
].Adr
= entry
.cdte_adr
;
302 /* marking last track with leadout value as index */
303 toc
->TrackData
[i
- toc
->FirstTrack
].TrackNumber
= entry
.cdte_track
;
304 toc
->TrackData
[i
- toc
->FirstTrack
].Address
[0] = 0;
305 toc
->TrackData
[i
- toc
->FirstTrack
].Address
[1] = entry
.cdte_addr
.msf
.minute
;
306 toc
->TrackData
[i
- toc
->FirstTrack
].Address
[2] = entry
.cdte_addr
.msf
.second
;
307 toc
->TrackData
[i
- toc
->FirstTrack
].Address
[3] = entry
.cdte_addr
.msf
.frame
;
309 cdrom_cache
[dev
].toc_good
= 1;
311 #elif defined(__FreeBSD__) || defined(__NetBSD__)
313 io
= ioctl(fd
, CDIOREADTOCHEADER
, &hdr
);
316 WARN("(%d) -- Error occurred (%s)!\n", dev
, strerror(errno
));
319 toc
->FirstTrack
= hdr
.starting_track
;
320 toc
->LastTrack
= hdr
.ending_track
;
321 tsz
= sizeof(toc
->FirstTrack
) + sizeof(toc
->LastTrack
)
322 + sizeof(TRACK_DATA
) * (toc
->LastTrack
-toc
->FirstTrack
+2);
323 toc
->Length
[0] = tsz
>> 8;
324 toc
->Length
[1] = tsz
;
326 TRACE("caching toc from=%d to=%d\n", toc
->FirstTrack
, toc
->LastTrack
);
328 for (i
= toc
->FirstTrack
; i
<= toc
->LastTrack
+ 1; i
++)
330 if (i
== toc
->LastTrack
+ 1)
333 entry
.starting_track
= LEADOUT
;
335 entry
.starting_track
= i
;
337 memset((char *)&toc_buffer
, 0, sizeof(toc_buffer
));
338 entry
.address_format
= CD_MSF_FORMAT
;
339 entry
.data_len
= sizeof(toc_buffer
);
340 entry
.data
= &toc_buffer
;
341 io
= ioctl(fd
, CDIOREADTOCENTRYS
, &entry
);
343 WARN("error read entry (%s)\n", strerror(errno
));
346 toc
->TrackData
[i
- toc
->FirstTrack
].Control
= toc_buffer
.control
;
347 toc
->TrackData
[i
- toc
->FirstTrack
].Adr
= toc_buffer
.addr_type
;
348 /* marking last track with leadout value as index */
349 toc
->TrackData
[i
- toc
->FirstTrack
].TrackNumber
= entry
.starting_track
;
350 toc
->TrackData
[i
- toc
->FirstTrack
].Address
[0] = 0;
351 toc
->TrackData
[i
- toc
->FirstTrack
].Address
[1] = toc_buffer
.addr
.msf
.minute
;
352 toc
->TrackData
[i
- toc
->FirstTrack
].Address
[2] = toc_buffer
.addr
.msf
.second
;
353 toc
->TrackData
[i
- toc
->FirstTrack
].Address
[3] = toc_buffer
.addr
.msf
.frame
;
355 cdrom_cache
[dev
].toc_good
= 1;
358 return STATUS_NOT_SUPPORTED
;
361 return CDROM_GetStatusCode(io
);
364 static void CDROM_ClearCacheEntry(int dev
)
366 RtlEnterCriticalSection( &cache_section
);
367 cdrom_cache
[dev
].toc_good
= 0;
368 RtlLeaveCriticalSection( &cache_section
);
373 /******************************************************************
374 * CDROM_GetInterfaceInfo
376 * Determines the ide interface (the number after the ide), and the
377 * number of the device on that interface for ide cdroms (*port == 0).
378 * Determines the scsi information for scsi cdroms (*port >= 1).
379 * Returns false if the info cannot not be obtained.
381 static int CDROM_GetInterfaceInfo(int fd
, int* port
, int* iface
, int* device
,int* lun
)
385 if ( fstat(fd
, &st
) == -1 || ! S_ISBLK(st
.st_mode
)) return 0;
390 switch (major(st
.st_rdev
)) {
391 case IDE0_MAJOR
: *iface
= 0; break;
392 case IDE1_MAJOR
: *iface
= 1; break;
393 case IDE2_MAJOR
: *iface
= 2; break;
394 case IDE3_MAJOR
: *iface
= 3; break;
395 case IDE4_MAJOR
: *iface
= 4; break;
396 case IDE5_MAJOR
: *iface
= 5; break;
397 case IDE6_MAJOR
: *iface
= 6; break;
398 case IDE7_MAJOR
: *iface
= 7; break;
399 default: *port
= 1; break;
403 *device
= (minor(st
.st_rdev
) >> 6);
406 #ifdef SCSI_IOCTL_GET_IDLUN
408 if (ioctl(fd
, SCSI_IOCTL_GET_IDLUN
, &idlun
) != -1)
410 *port
= ((idlun
[0] >> 24) & 0xff) + 1;
411 *iface
= (idlun
[0] >> 16) & 0xff;
412 *device
= idlun
[0] & 0xff;
413 *lun
= (idlun
[0] >> 8) & 0xff;
418 WARN("CD-ROM device (%d, %d) not supported\n", major(st
.st_rdev
), minor(st
.st_rdev
));
423 #elif defined(__NetBSD__)
424 struct scsi_addr addr
;
425 if (ioctl(fd
, SCIOCIDENTIFY
, &addr
) != -1)
429 case TYPE_SCSI
: *port
= 1;
430 *iface
= addr
.addr
.scsi
.scbus
;
431 *device
= addr
.addr
.scsi
.target
;
432 *lun
= addr
.addr
.scsi
.lun
;
434 case TYPE_ATAPI
: *port
= 0;
435 *iface
= addr
.addr
.atapi
.atbus
;
436 *device
= addr
.addr
.atapi
.drive
;
443 #elif defined(__FreeBSD__)
444 FIXME("not implemented for BSD\n");
447 FIXME("not implemented for nonlinux\n");
453 /******************************************************************
457 static NTSTATUS
CDROM_Open(int fd
, int* dev
)
460 NTSTATUS ret
= STATUS_SUCCESS
;
465 RtlEnterCriticalSection( &cache_section
);
466 for (*dev
= 0; *dev
< MAX_CACHE_ENTRIES
; (*dev
)++)
469 cdrom_cache
[*dev
].device
== 0 &&
470 cdrom_cache
[*dev
].inode
== 0)
472 else if (cdrom_cache
[*dev
].device
== st
.st_dev
&&
473 cdrom_cache
[*dev
].inode
== st
.st_ino
)
476 if (*dev
== MAX_CACHE_ENTRIES
)
478 if (empty
== -1) ret
= STATUS_NOT_IMPLEMENTED
;
482 cdrom_cache
[*dev
].device
= st
.st_dev
;
483 cdrom_cache
[*dev
].inode
= st
.st_ino
;
486 RtlLeaveCriticalSection( &cache_section
);
488 TRACE("%d, %d\n", *dev
, fd
);
492 /******************************************************************
493 * CDROM_GetStatusCode
497 static NTSTATUS
CDROM_GetStatusCode(int io
)
499 if (io
== 0) return STATUS_SUCCESS
;
500 return FILE_GetNtStatus();
503 /******************************************************************
507 static NTSTATUS
CDROM_GetControl(int dev
, CDROM_AUDIO_CONTROL
* cac
)
509 cac
->LbaFormat
= 0; /* FIXME */
510 cac
->LogicalBlocksPerSecond
= 1; /* FIXME */
511 return STATUS_NOT_SUPPORTED
;
514 /******************************************************************
515 * CDROM_GetDeviceNumber
518 static NTSTATUS
CDROM_GetDeviceNumber(int dev
, STORAGE_DEVICE_NUMBER
* devnum
)
520 return STATUS_NOT_SUPPORTED
;
523 /******************************************************************
524 * CDROM_GetDriveGeometry
527 static NTSTATUS
CDROM_GetDriveGeometry(int dev
, int fd
, DISK_GEOMETRY
* dg
)
533 if ((ret
= CDROM_ReadTOC(dev
, fd
, &toc
)) != 0) return ret
;
535 fsize
= FRAME_OF_TOC(toc
, toc
.LastTrack
+1)
536 - FRAME_OF_TOC(toc
, 1); /* Total size in frames */
538 dg
->Cylinders
.u
.LowPart
= fsize
/ (64 * 32);
539 dg
->Cylinders
.u
.HighPart
= 0;
540 dg
->MediaType
= RemovableMedia
;
541 dg
->TracksPerCylinder
= 64;
542 dg
->SectorsPerTrack
= 32;
543 dg
->BytesPerSector
= 2048;
547 /**************************************************************************
548 * CDROM_Reset [internal]
550 static NTSTATUS
CDROM_ResetAudio(int fd
)
553 return CDROM_GetStatusCode(ioctl(fd
, CDROMRESET
));
554 #elif defined(__FreeBSD__) || defined(__NetBSD__)
555 return CDROM_GetStatusCode(ioctl(fd
, CDIOCRESET
, NULL
));
557 return STATUS_NOT_SUPPORTED
;
561 /******************************************************************
566 static NTSTATUS
CDROM_SetTray(int fd
, BOOL doEject
)
569 return CDROM_GetStatusCode(ioctl(fd
, doEject
? CDROMEJECT
: CDROMCLOSETRAY
));
570 #elif defined(__FreeBSD__) || defined(__NetBSD__)
571 return CDROM_GetStatusCode((ioctl(fd
, CDIOCALLOW
, NULL
)) ||
572 (ioctl(fd
, doEject
? CDIOCEJECT
: CDIOCCLOSE
, NULL
)) ||
573 (ioctl(fd
, CDIOCPREVENT
, NULL
)));
575 return STATUS_NOT_SUPPORTED
;
579 /******************************************************************
580 * CDROM_ControlEjection
584 static NTSTATUS
CDROM_ControlEjection(int fd
, const PREVENT_MEDIA_REMOVAL
* rmv
)
587 return CDROM_GetStatusCode(ioctl(fd
, CDROM_LOCKDOOR
, rmv
->PreventMediaRemoval
));
588 #elif defined(__FreeBSD__) || defined(__NetBSD__)
589 return CDROM_GetStatusCode(ioctl(fd
, (rmv
->PreventMediaRemoval
) ? CDIOCPREVENT
: CDIOCALLOW
, NULL
));
591 return STATUS_NOT_SUPPORTED
;
595 /******************************************************************
600 static NTSTATUS
CDROM_ReadTOC(int dev
, int fd
, CDROM_TOC
* toc
)
602 NTSTATUS ret
= STATUS_NOT_SUPPORTED
;
604 if (dev
< 0 || dev
>= MAX_CACHE_ENTRIES
)
605 return STATUS_INVALID_PARAMETER
;
607 RtlEnterCriticalSection( &cache_section
);
608 if (cdrom_cache
[dev
].toc_good
|| !(ret
= CDROM_SyncCache(dev
, fd
)))
610 *toc
= cdrom_cache
[dev
].toc
;
611 ret
= STATUS_SUCCESS
;
613 RtlLeaveCriticalSection( &cache_section
);
617 /******************************************************************
622 static NTSTATUS
CDROM_GetDiskData(int dev
, int fd
, CDROM_DISK_DATA
* data
)
628 if ((ret
= CDROM_ReadTOC(dev
, fd
, &toc
)) != 0) return ret
;
630 for (i
= toc
.FirstTrack
; i
<= toc
.LastTrack
; i
++) {
631 if (toc
.TrackData
[i
-toc
.FirstTrack
].Control
& 0x04)
632 data
->DiskData
|= CDROM_DISK_DATA_TRACK
;
634 data
->DiskData
|= CDROM_DISK_AUDIO_TRACK
;
636 return STATUS_SUCCESS
;
639 /******************************************************************
644 static NTSTATUS
CDROM_ReadQChannel(int dev
, int fd
, const CDROM_SUB_Q_DATA_FORMAT
* fmt
,
645 SUB_Q_CHANNEL_DATA
* data
)
647 NTSTATUS ret
= STATUS_NOT_SUPPORTED
;
650 SUB_Q_HEADER
* hdr
= (SUB_Q_HEADER
*)data
;
652 struct cdrom_subchnl sc
;
653 sc
.cdsc_format
= CDROM_MSF
;
655 io
= ioctl(fd
, CDROMSUBCHNL
, &sc
);
658 TRACE("opened or no_media (%s)!\n", strerror(errno
));
659 hdr
->AudioStatus
= AUDIO_STATUS_NO_STATUS
;
660 CDROM_ClearCacheEntry(dev
);
664 hdr
->AudioStatus
= AUDIO_STATUS_NOT_SUPPORTED
;
666 switch (sc
.cdsc_audiostatus
) {
667 case CDROM_AUDIO_INVALID
:
668 CDROM_ClearCacheEntry(dev
);
669 hdr
->AudioStatus
= AUDIO_STATUS_NOT_SUPPORTED
;
671 case CDROM_AUDIO_NO_STATUS
:
672 CDROM_ClearCacheEntry(dev
);
673 hdr
->AudioStatus
= AUDIO_STATUS_NO_STATUS
;
675 case CDROM_AUDIO_PLAY
:
676 hdr
->AudioStatus
= AUDIO_STATUS_IN_PROGRESS
;
678 case CDROM_AUDIO_PAUSED
:
679 hdr
->AudioStatus
= AUDIO_STATUS_PAUSED
;
681 case CDROM_AUDIO_COMPLETED
:
682 hdr
->AudioStatus
= AUDIO_STATUS_PLAY_COMPLETE
;
684 case CDROM_AUDIO_ERROR
:
685 hdr
->AudioStatus
= AUDIO_STATUS_PLAY_ERROR
;
688 TRACE("status=%02X !\n", sc
.cdsc_audiostatus
);
693 case IOCTL_CDROM_CURRENT_POSITION
:
694 size
= sizeof(SUB_Q_CURRENT_POSITION
);
695 RtlEnterCriticalSection( &cache_section
);
696 if (hdr
->AudioStatus
==AUDIO_STATUS_IN_PROGRESS
) {
697 data
->CurrentPosition
.FormatCode
= IOCTL_CDROM_CURRENT_POSITION
;
698 data
->CurrentPosition
.Control
= sc
.cdsc_ctrl
;
699 data
->CurrentPosition
.ADR
= sc
.cdsc_adr
;
700 data
->CurrentPosition
.TrackNumber
= sc
.cdsc_trk
;
701 data
->CurrentPosition
.IndexNumber
= sc
.cdsc_ind
;
703 data
->CurrentPosition
.AbsoluteAddress
[0] = 0;
704 data
->CurrentPosition
.AbsoluteAddress
[1] = sc
.cdsc_absaddr
.msf
.minute
;
705 data
->CurrentPosition
.AbsoluteAddress
[2] = sc
.cdsc_absaddr
.msf
.second
;
706 data
->CurrentPosition
.AbsoluteAddress
[3] = sc
.cdsc_absaddr
.msf
.frame
;
708 data
->CurrentPosition
.TrackRelativeAddress
[0] = 0;
709 data
->CurrentPosition
.TrackRelativeAddress
[1] = sc
.cdsc_reladdr
.msf
.minute
;
710 data
->CurrentPosition
.TrackRelativeAddress
[2] = sc
.cdsc_reladdr
.msf
.second
;
711 data
->CurrentPosition
.TrackRelativeAddress
[3] = sc
.cdsc_reladdr
.msf
.frame
;
713 cdrom_cache
[dev
].CurrentPosition
= data
->CurrentPosition
;
715 else /* not playing */
717 cdrom_cache
[dev
].CurrentPosition
.Header
= *hdr
; /* Preserve header info */
718 data
->CurrentPosition
= cdrom_cache
[dev
].CurrentPosition
;
720 RtlLeaveCriticalSection( &cache_section
);
722 case IOCTL_CDROM_MEDIA_CATALOG
:
723 size
= sizeof(SUB_Q_MEDIA_CATALOG_NUMBER
);
724 data
->MediaCatalog
.FormatCode
= IOCTL_CDROM_MEDIA_CATALOG
;
726 struct cdrom_mcn mcn
;
727 if ((io
= ioctl(fd
, CDROM_GET_MCN
, &mcn
)) == -1) goto end
;
729 data
->MediaCatalog
.FormatCode
= IOCTL_CDROM_MEDIA_CATALOG
;
730 data
->MediaCatalog
.Mcval
= 0; /* FIXME */
731 memcpy(data
->MediaCatalog
.MediaCatalog
, mcn
.medium_catalog_number
, 14);
732 data
->MediaCatalog
.MediaCatalog
[14] = 0;
735 case IOCTL_CDROM_TRACK_ISRC
:
736 size
= sizeof(SUB_Q_CURRENT_POSITION
);
737 FIXME("TrackIsrc: NIY on linux\n");
738 data
->TrackIsrc
.FormatCode
= IOCTL_CDROM_TRACK_ISRC
;
739 data
->TrackIsrc
.Tcval
= 0;
745 ret
= CDROM_GetStatusCode(io
);
746 #elif defined(__FreeBSD__) || defined(__NetBSD__)
748 SUB_Q_HEADER
* hdr
= (SUB_Q_HEADER
*)data
;
750 struct ioc_read_subchannel read_sc
;
751 struct cd_sub_channel_info sc
;
753 read_sc
.address_format
= CD_MSF_FORMAT
;
755 read_sc
.data_len
= sizeof(sc
);
759 case IOCTL_CDROM_CURRENT_POSITION
:
760 read_sc
.data_format
= CD_CURRENT_POSITION
;
762 case IOCTL_CDROM_MEDIA_CATALOG
:
763 read_sc
.data_format
= CD_MEDIA_CATALOG
;
765 case IOCTL_CDROM_TRACK_ISRC
:
766 read_sc
.data_format
= CD_TRACK_INFO
;
767 sc
.what
.track_info
.track_number
= data
->TrackIsrc
.Track
;
770 io
= ioctl(fd
, CDIOCREADSUBCHANNEL
, &read_sc
);
773 TRACE("opened or no_media (%s)!\n", strerror(errno
));
774 CDROM_ClearCacheEntry(dev
);
775 hdr
->AudioStatus
= AUDIO_STATUS_NO_STATUS
;
779 hdr
->AudioStatus
= AUDIO_STATUS_NOT_SUPPORTED
;
781 switch (sc
.header
.audio_status
) {
782 case CD_AS_AUDIO_INVALID
:
783 CDROM_ClearCacheEntry(dev
);
784 hdr
->AudioStatus
= AUDIO_STATUS_NOT_SUPPORTED
;
786 case CD_AS_NO_STATUS
:
787 CDROM_ClearCacheEntry(dev
);
788 hdr
->AudioStatus
= AUDIO_STATUS_NO_STATUS
;
790 case CD_AS_PLAY_IN_PROGRESS
:
791 hdr
->AudioStatus
= AUDIO_STATUS_IN_PROGRESS
;
793 case CD_AS_PLAY_PAUSED
:
794 hdr
->AudioStatus
= AUDIO_STATUS_PAUSED
;
796 case CD_AS_PLAY_COMPLETED
:
797 hdr
->AudioStatus
= AUDIO_STATUS_PLAY_COMPLETE
;
799 case CD_AS_PLAY_ERROR
:
800 hdr
->AudioStatus
= AUDIO_STATUS_PLAY_ERROR
;
803 TRACE("status=%02X !\n", sc
.header
.audio_status
);
807 case IOCTL_CDROM_CURRENT_POSITION
:
808 size
= sizeof(SUB_Q_CURRENT_POSITION
);
809 RtlEnterCriticalSection( &cache_section
);
810 if (hdr
->AudioStatus
==AUDIO_STATUS_IN_PROGRESS
) {
811 data
->CurrentPosition
.FormatCode
= IOCTL_CDROM_CURRENT_POSITION
;
812 data
->CurrentPosition
.Control
= sc
.what
.position
.control
;
813 data
->CurrentPosition
.ADR
= sc
.what
.position
.addr_type
;
814 data
->CurrentPosition
.TrackNumber
= sc
.what
.position
.track_number
;
815 data
->CurrentPosition
.IndexNumber
= sc
.what
.position
.index_number
;
817 data
->CurrentPosition
.AbsoluteAddress
[0] = 0;
818 data
->CurrentPosition
.AbsoluteAddress
[1] = sc
.what
.position
.absaddr
.msf
.minute
;
819 data
->CurrentPosition
.AbsoluteAddress
[2] = sc
.what
.position
.absaddr
.msf
.second
;
820 data
->CurrentPosition
.AbsoluteAddress
[3] = sc
.what
.position
.absaddr
.msf
.frame
;
821 data
->CurrentPosition
.TrackRelativeAddress
[0] = 0;
822 data
->CurrentPosition
.TrackRelativeAddress
[1] = sc
.what
.position
.reladdr
.msf
.minute
;
823 data
->CurrentPosition
.TrackRelativeAddress
[2] = sc
.what
.position
.reladdr
.msf
.second
;
824 data
->CurrentPosition
.TrackRelativeAddress
[3] = sc
.what
.position
.reladdr
.msf
.frame
;
825 cdrom_cache
[dev
].CurrentPosition
= data
->CurrentPosition
;
827 else { /* not playing */
828 cdrom_cache
[dev
].CurrentPosition
.Header
= *hdr
; /* Preserve header info */
829 data
->CurrentPosition
= cdrom_cache
[dev
].CurrentPosition
;
831 RtlLeaveCriticalSection( &cache_section
);
833 case IOCTL_CDROM_MEDIA_CATALOG
:
834 size
= sizeof(SUB_Q_MEDIA_CATALOG_NUMBER
);
835 data
->MediaCatalog
.FormatCode
= IOCTL_CDROM_MEDIA_CATALOG
;
836 data
->MediaCatalog
.Mcval
= sc
.what
.media_catalog
.mc_valid
;
837 memcpy(data
->MediaCatalog
.MediaCatalog
, sc
.what
.media_catalog
.mc_number
, 15);
839 case IOCTL_CDROM_TRACK_ISRC
:
840 size
= sizeof(SUB_Q_CURRENT_POSITION
);
841 data
->TrackIsrc
.FormatCode
= IOCTL_CDROM_TRACK_ISRC
;
842 data
->TrackIsrc
.Tcval
= sc
.what
.track_info
.ti_valid
;
843 memcpy(data
->TrackIsrc
.TrackIsrc
, sc
.what
.track_info
.ti_number
, 15);
848 ret
= CDROM_GetStatusCode(io
);
853 /******************************************************************
858 static NTSTATUS
CDROM_Verify(int dev
, int fd
)
860 /* quick implementation */
861 CDROM_SUB_Q_DATA_FORMAT fmt
;
862 SUB_Q_CHANNEL_DATA data
;
864 fmt
.Format
= IOCTL_CDROM_CURRENT_POSITION
;
865 return CDROM_ReadQChannel(dev
, fd
, &fmt
, &data
) ? 1 : 0;
868 /******************************************************************
873 static NTSTATUS
CDROM_PlayAudioMSF(int fd
, const CDROM_PLAY_AUDIO_MSF
* audio_msf
)
875 NTSTATUS ret
= STATUS_NOT_SUPPORTED
;
877 struct cdrom_msf msf
;
880 msf
.cdmsf_min0
= audio_msf
->StartingM
;
881 msf
.cdmsf_sec0
= audio_msf
->StartingS
;
882 msf
.cdmsf_frame0
= audio_msf
->StartingF
;
883 msf
.cdmsf_min1
= audio_msf
->EndingM
;
884 msf
.cdmsf_sec1
= audio_msf
->EndingS
;
885 msf
.cdmsf_frame1
= audio_msf
->EndingF
;
887 io
= ioctl(fd
, CDROMSTART
);
890 WARN("motor doesn't start !\n");
893 io
= ioctl(fd
, CDROMPLAYMSF
, &msf
);
896 WARN("device doesn't play !\n");
899 TRACE("msf = %d:%d:%d %d:%d:%d\n",
900 msf
.cdmsf_min0
, msf
.cdmsf_sec0
, msf
.cdmsf_frame0
,
901 msf
.cdmsf_min1
, msf
.cdmsf_sec1
, msf
.cdmsf_frame1
);
903 ret
= CDROM_GetStatusCode(io
);
904 #elif defined(__FreeBSD__) || defined(__NetBSD__)
905 struct ioc_play_msf msf
;
908 msf
.start_m
= audio_msf
->StartingM
;
909 msf
.start_s
= audio_msf
->StartingS
;
910 msf
.start_f
= audio_msf
->StartingF
;
911 msf
.end_m
= audio_msf
->EndingM
;
912 msf
.end_s
= audio_msf
->EndingS
;
913 msf
.end_f
= audio_msf
->EndingF
;
915 io
= ioctl(fd
, CDIOCSTART
, NULL
);
918 WARN("motor doesn't start !\n");
921 io
= ioctl(fd
, CDIOCPLAYMSF
, &msf
);
924 WARN("device doesn't play !\n");
927 TRACE("msf = %d:%d:%d %d:%d:%d\n",
928 msf
.start_m
, msf
.start_s
, msf
.start_f
,
929 msf
.end_m
, msf
.end_s
, msf
.end_f
);
931 ret
= CDROM_GetStatusCode(io
);
936 /******************************************************************
941 static NTSTATUS
CDROM_SeekAudioMSF(int dev
, int fd
, const CDROM_SEEK_AUDIO_MSF
* audio_msf
)
945 SUB_Q_CURRENT_POSITION
*cp
;
947 struct cdrom_msf0 msf
;
948 struct cdrom_subchnl sc
;
949 #elif defined(__FreeBSD__) || defined(__NetBSD__)
950 struct ioc_play_msf msf
;
951 struct ioc_read_subchannel read_sc
;
952 struct cd_sub_channel_info sc
;
956 /* Use the information on the TOC to compute the new current
957 * position, which is shadowed on the cache. [Portable]. */
958 frame
= FRAME_OF_MSF(*audio_msf
);
960 if ((io
= CDROM_ReadTOC(dev
, fd
, &toc
)) != 0) return io
;
962 for(i
=toc
.FirstTrack
;i
<=toc
.LastTrack
+1;i
++)
963 if (FRAME_OF_TOC(toc
,i
)>frame
) break;
964 if (i
<= toc
.FirstTrack
|| i
> toc
.LastTrack
+1)
965 return STATUS_INVALID_PARAMETER
;
967 RtlEnterCriticalSection( &cache_section
);
968 cp
= &cdrom_cache
[dev
].CurrentPosition
;
969 cp
->FormatCode
= IOCTL_CDROM_CURRENT_POSITION
;
970 cp
->Control
= toc
.TrackData
[i
-toc
.FirstTrack
].Control
;
971 cp
->ADR
= toc
.TrackData
[i
-toc
.FirstTrack
].Adr
;
972 cp
->TrackNumber
= toc
.TrackData
[i
-toc
.FirstTrack
].TrackNumber
;
973 cp
->IndexNumber
= 0; /* FIXME: where do they keep these? */
974 cp
->AbsoluteAddress
[0] = 0;
975 cp
->AbsoluteAddress
[1] = toc
.TrackData
[i
-toc
.FirstTrack
].Address
[1];
976 cp
->AbsoluteAddress
[2] = toc
.TrackData
[i
-toc
.FirstTrack
].Address
[2];
977 cp
->AbsoluteAddress
[3] = toc
.TrackData
[i
-toc
.FirstTrack
].Address
[3];
978 frame
-= FRAME_OF_TOC(toc
,i
);
979 cp
->TrackRelativeAddress
[0] = 0;
980 MSF_OF_FRAME(cp
->TrackRelativeAddress
[1], frame
);
981 RtlLeaveCriticalSection( &cache_section
);
983 /* If playing, then issue a seek command, otherwise do nothing */
985 sc
.cdsc_format
= CDROM_MSF
;
987 io
= ioctl(fd
, CDROMSUBCHNL
, &sc
);
990 TRACE("opened or no_media (%s)!\n", strerror(errno
));
991 CDROM_ClearCacheEntry(dev
);
992 return CDROM_GetStatusCode(io
);
994 if (sc
.cdsc_audiostatus
==CDROM_AUDIO_PLAY
)
996 msf
.minute
= audio_msf
->M
;
997 msf
.second
= audio_msf
->S
;
998 msf
.frame
= audio_msf
->F
;
999 return CDROM_GetStatusCode(ioctl(fd
, CDROMSEEK
, &msf
));
1001 return STATUS_SUCCESS
;
1002 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1003 read_sc
.address_format
= CD_MSF_FORMAT
;
1005 read_sc
.data_len
= sizeof(sc
);
1007 read_sc
.data_format
= CD_CURRENT_POSITION
;
1009 io
= ioctl(fd
, CDIOCREADSUBCHANNEL
, &read_sc
);
1012 TRACE("opened or no_media (%s)!\n", strerror(errno
));
1013 CDROM_ClearCacheEntry(dev
);
1014 return CDROM_GetStatusCode(io
);
1016 if (sc
.header
.audio_status
==CD_AS_PLAY_IN_PROGRESS
)
1019 msf
.start_m
= audio_msf
->M
;
1020 msf
.start_s
= audio_msf
->S
;
1021 msf
.start_f
= audio_msf
->F
;
1022 final_frame
= FRAME_OF_TOC(toc
,toc
.LastTrack
+1)-1;
1023 MSF_OF_FRAME(msf
.end_m
, final_frame
);
1025 return CDROM_GetStatusCode(ioctl(fd
, CDIOCPLAYMSF
, &msf
));
1027 return STATUS_SUCCESS
;
1029 return STATUS_NOT_SUPPORTED
;
1033 /******************************************************************
1038 static NTSTATUS
CDROM_PauseAudio(int fd
)
1041 return CDROM_GetStatusCode(ioctl(fd
, CDROMPAUSE
));
1042 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1043 return CDROM_GetStatusCode(ioctl(fd
, CDIOCPAUSE
, NULL
));
1045 return STATUS_NOT_SUPPORTED
;
1049 /******************************************************************
1054 static NTSTATUS
CDROM_ResumeAudio(int fd
)
1057 return CDROM_GetStatusCode(ioctl(fd
, CDROMRESUME
));
1058 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1059 return CDROM_GetStatusCode(ioctl(fd
, CDIOCRESUME
, NULL
));
1061 return STATUS_NOT_SUPPORTED
;
1065 /******************************************************************
1070 static NTSTATUS
CDROM_StopAudio(int fd
)
1073 return CDROM_GetStatusCode(ioctl(fd
, CDROMSTOP
));
1074 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1075 return CDROM_GetStatusCode(ioctl(fd
, CDIOCSTOP
, NULL
));
1077 return STATUS_NOT_SUPPORTED
;
1081 /******************************************************************
1086 static NTSTATUS
CDROM_GetVolume(int fd
, VOLUME_CONTROL
* vc
)
1089 struct cdrom_volctrl volc
;
1092 io
= ioctl(fd
, CDROMVOLREAD
, &volc
);
1095 vc
->PortVolume
[0] = volc
.channel0
;
1096 vc
->PortVolume
[1] = volc
.channel1
;
1097 vc
->PortVolume
[2] = volc
.channel2
;
1098 vc
->PortVolume
[3] = volc
.channel3
;
1100 return CDROM_GetStatusCode(io
);
1101 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1102 struct ioc_vol volc
;
1105 io
= ioctl(fd
, CDIOCGETVOL
, &volc
);
1108 vc
->PortVolume
[0] = volc
.vol
[0];
1109 vc
->PortVolume
[1] = volc
.vol
[1];
1110 vc
->PortVolume
[2] = volc
.vol
[2];
1111 vc
->PortVolume
[3] = volc
.vol
[3];
1113 return CDROM_GetStatusCode(io
);
1115 return STATUS_NOT_SUPPORTED
;
1119 /******************************************************************
1124 static NTSTATUS
CDROM_SetVolume(int fd
, const VOLUME_CONTROL
* vc
)
1127 struct cdrom_volctrl volc
;
1129 volc
.channel0
= vc
->PortVolume
[0];
1130 volc
.channel1
= vc
->PortVolume
[1];
1131 volc
.channel2
= vc
->PortVolume
[2];
1132 volc
.channel3
= vc
->PortVolume
[3];
1134 return CDROM_GetStatusCode(ioctl(fd
, CDROMVOLCTRL
, &volc
));
1135 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1136 struct ioc_vol volc
;
1138 volc
.vol
[0] = vc
->PortVolume
[0];
1139 volc
.vol
[1] = vc
->PortVolume
[1];
1140 volc
.vol
[2] = vc
->PortVolume
[2];
1141 volc
.vol
[3] = vc
->PortVolume
[3];
1143 return CDROM_GetStatusCode(ioctl(fd
, CDIOCSETVOL
, &volc
));
1145 return STATUS_NOT_SUPPORTED
;
1149 /******************************************************************
1154 static NTSTATUS
CDROM_RawRead(int fd
, const RAW_READ_INFO
* raw
, void* buffer
, DWORD len
, DWORD
* sz
)
1156 int ret
= STATUS_NOT_SUPPORTED
;
1160 switch (raw
->TrackMode
)
1162 case YellowMode2
: sectSize
= 2336; break;
1163 case XAForm2
: sectSize
= 2328; break;
1164 case CDDA
: sectSize
= 2352; break;
1165 default: return STATUS_INVALID_PARAMETER
;
1167 if (len
< raw
->SectorCount
* sectSize
) return STATUS_BUFFER_TOO_SMALL
;
1168 /* strangely enough, it seems that sector offsets are always indicated with a size of 2048,
1169 * even if a larger size if read...
1173 struct cdrom_read cdr
;
1174 struct cdrom_read_audio cdra
;
1176 switch (raw
->TrackMode
)
1179 if (raw
->DiskOffset
.u
.HighPart
) FIXME("Unsupported value\n");
1180 cdr
.cdread_lba
= raw
->DiskOffset
.u
.LowPart
; /* FIXME ? */
1181 cdr
.cdread_bufaddr
= buffer
;
1182 cdr
.cdread_buflen
= raw
->SectorCount
* sectSize
;
1183 io
= ioctl(fd
, CDROMREADMODE2
, &cdr
);
1186 FIXME("XAForm2: NIY\n");
1189 /* FIXME: the output doesn't seem 100% correct... in fact output is shifted
1190 * between by NT2K box and this... should check on the same drive...
1191 * otherwise, I fear a 2352/2368 mismatch somewhere in one of the drivers
1193 * Anyway, that's not critical at all. We're talking of 16/32 bytes, we're
1194 * talking of 0.2 ms of sound
1196 /* 2048 = 2 ** 11 */
1197 if (raw
->DiskOffset
.u
.HighPart
& ~2047) FIXME("Unsupported value\n");
1198 cdra
.addr
.lba
= ((raw
->DiskOffset
.u
.LowPart
>> 11) |
1199 (raw
->DiskOffset
.u
.HighPart
<< (32 - 11))) - 1;
1200 FIXME("reading at %u\n", cdra
.addr
.lba
);
1201 cdra
.addr_format
= CDROM_LBA
;
1202 cdra
.nframes
= raw
->SectorCount
;
1204 io
= ioctl(fd
, CDROMREADAUDIO
, &cdra
);
1207 FIXME("NIY: %d\n", raw
->TrackMode
);
1213 switch (raw
->TrackMode
)
1216 FIXME("YellowMode2: NIY\n");
1219 FIXME("XAForm2: NIY\n");
1222 FIXME("CDDA: NIY\n");
1228 *sz
= sectSize
* raw
->SectorCount
;
1229 ret
= CDROM_GetStatusCode(io
);
1233 /******************************************************************
1234 * CDROM_ScsiPassThroughDirect
1238 static NTSTATUS
CDROM_ScsiPassThroughDirect(int fd
, PSCSI_PASS_THROUGH_DIRECT pPacket
)
1240 int ret
= STATUS_NOT_SUPPORTED
;
1241 #if defined(linux) && defined(CDROM_SEND_PACKET)
1242 struct linux_cdrom_generic_command cmd
;
1243 struct request_sense sense
;
1246 if (pPacket
->Length
< sizeof(SCSI_PASS_THROUGH_DIRECT
))
1247 return STATUS_BUFFER_TOO_SMALL
;
1249 if (pPacket
->CdbLength
> 12)
1250 return STATUS_INVALID_PARAMETER
;
1252 if (pPacket
->SenseInfoLength
> sizeof(sense
))
1253 return STATUS_INVALID_PARAMETER
;
1255 memset(&cmd
, 0, sizeof(cmd
));
1256 memset(&sense
, 0, sizeof(sense
));
1258 memcpy(&(cmd
.cmd
), &(pPacket
->Cdb
), pPacket
->CdbLength
);
1260 cmd
.buffer
= pPacket
->DataBuffer
;
1261 cmd
.buflen
= pPacket
->DataTransferLength
;
1264 cmd
.timeout
= pPacket
->TimeOutValue
*HZ
;
1266 switch (pPacket
->DataIn
)
1268 case SCSI_IOCTL_DATA_OUT
:
1269 cmd
.data_direction
= CGC_DATA_WRITE
;
1271 case SCSI_IOCTL_DATA_IN
:
1272 cmd
.data_direction
= CGC_DATA_READ
;
1274 case SCSI_IOCTL_DATA_UNSPECIFIED
:
1275 cmd
.data_direction
= CGC_DATA_NONE
;
1278 return STATUS_INVALID_PARAMETER
;
1281 io
= ioctl(fd
, CDROM_SEND_PACKET
, &cmd
);
1283 if (pPacket
->SenseInfoLength
!= 0)
1285 memcpy((char*)pPacket
+ pPacket
->SenseInfoOffset
,
1286 &sense
, pPacket
->SenseInfoLength
);
1289 pPacket
->ScsiStatus
= cmd
.stat
;
1291 ret
= CDROM_GetStatusCode(io
);
1293 #elif defined(__NetBSD__)
1297 if (pPacket
->Length
< sizeof(SCSI_PASS_THROUGH_DIRECT
))
1298 return STATUS_BUFFER_TOO_SMALL
;
1300 if (pPacket
->CdbLength
> 12)
1301 return STATUS_INVALID_PARAMETER
;
1303 if (pPacket
->SenseInfoLength
> SENSEBUFLEN
)
1304 return STATUS_INVALID_PARAMETER
;
1306 memset(&cmd
, 0, sizeof(cmd
));
1307 memcpy(&(cmd
.cmd
), &(pPacket
->Cdb
), pPacket
->CdbLength
);
1309 cmd
.cmdlen
= pPacket
->CdbLength
;
1310 cmd
.databuf
= pPacket
->DataBuffer
;
1311 cmd
.datalen
= pPacket
->DataTransferLength
;
1312 cmd
.senselen
= pPacket
->SenseInfoLength
;
1313 cmd
.timeout
= pPacket
->TimeOutValue
*1000; /* in milliseconds */
1315 switch (pPacket
->DataIn
)
1317 case SCSI_IOCTL_DATA_OUT
:
1318 cmd
.flags
|= SCCMD_WRITE
;
1320 case SCSI_IOCTL_DATA_IN
:
1321 cmd
.flags
|= SCCMD_READ
;
1323 case SCSI_IOCTL_DATA_UNSPECIFIED
:
1327 return STATUS_INVALID_PARAMETER
;
1330 io
= ioctl(fd
, SCIOCCOMMAND
, &cmd
);
1334 case SCCMD_OK
: break;
1335 case SCCMD_TIMEOUT
: return STATUS_TIMEOUT
;
1337 case SCCMD_BUSY
: return STATUS_DEVICE_BUSY
;
1339 case SCCMD_SENSE
: break;
1340 case SCCMD_UNKNOWN
: return STATUS_UNSUCCESSFUL
;
1344 if (pPacket
->SenseInfoLength
!= 0)
1346 memcpy((char*)pPacket
+ pPacket
->SenseInfoOffset
,
1347 cmd
.sense
, pPacket
->SenseInfoLength
);
1350 pPacket
->ScsiStatus
= cmd
.status
;
1352 ret
= CDROM_GetStatusCode(io
);
1357 /******************************************************************
1358 * CDROM_ScsiPassThrough
1362 static NTSTATUS
CDROM_ScsiPassThrough(int fd
, PSCSI_PASS_THROUGH pPacket
)
1364 int ret
= STATUS_NOT_SUPPORTED
;
1365 #if defined(linux) && defined(CDROM_SEND_PACKET)
1366 struct linux_cdrom_generic_command cmd
;
1367 struct request_sense sense
;
1370 if (pPacket
->Length
< sizeof(SCSI_PASS_THROUGH
))
1371 return STATUS_BUFFER_TOO_SMALL
;
1373 if (pPacket
->CdbLength
> 12)
1374 return STATUS_INVALID_PARAMETER
;
1376 if (pPacket
->SenseInfoLength
> sizeof(sense
))
1377 return STATUS_INVALID_PARAMETER
;
1379 memset(&cmd
, 0, sizeof(cmd
));
1380 memset(&sense
, 0, sizeof(sense
));
1382 memcpy(&(cmd
.cmd
), &(pPacket
->Cdb
), pPacket
->CdbLength
);
1384 if ( pPacket
->DataBufferOffset
> 0x1000 )
1386 cmd
.buffer
= (void*)pPacket
->DataBufferOffset
;
1390 cmd
.buffer
= (char*)pPacket
+ pPacket
->DataBufferOffset
;
1392 cmd
.buflen
= pPacket
->DataTransferLength
;
1395 cmd
.timeout
= pPacket
->TimeOutValue
*HZ
;
1397 switch (pPacket
->DataIn
)
1399 case SCSI_IOCTL_DATA_OUT
:
1400 cmd
.data_direction
= CGC_DATA_WRITE
;
1402 case SCSI_IOCTL_DATA_IN
:
1403 cmd
.data_direction
= CGC_DATA_READ
;
1405 case SCSI_IOCTL_DATA_UNSPECIFIED
:
1406 cmd
.data_direction
= CGC_DATA_NONE
;
1409 return STATUS_INVALID_PARAMETER
;
1412 io
= ioctl(fd
, CDROM_SEND_PACKET
, &cmd
);
1414 if (pPacket
->SenseInfoLength
!= 0)
1416 memcpy((char*)pPacket
+ pPacket
->SenseInfoOffset
,
1417 &sense
, pPacket
->SenseInfoLength
);
1420 pPacket
->ScsiStatus
= cmd
.stat
;
1422 ret
= CDROM_GetStatusCode(io
);
1424 #elif defined(__NetBSD__)
1428 if (pPacket
->Length
< sizeof(SCSI_PASS_THROUGH
))
1429 return STATUS_BUFFER_TOO_SMALL
;
1431 if (pPacket
->CdbLength
> 12)
1432 return STATUS_INVALID_PARAMETER
;
1434 if (pPacket
->SenseInfoLength
> SENSEBUFLEN
)
1435 return STATUS_INVALID_PARAMETER
;
1437 memset(&cmd
, 0, sizeof(cmd
));
1438 memcpy(&(cmd
.cmd
), &(pPacket
->Cdb
), pPacket
->CdbLength
);
1440 if ( pPacket
->DataBufferOffset
> 0x1000 )
1442 cmd
.databuf
= (void*)pPacket
->DataBufferOffset
;
1446 cmd
.databuf
= (char*)pPacket
+ pPacket
->DataBufferOffset
;
1449 cmd
.cmdlen
= pPacket
->CdbLength
;
1450 cmd
.datalen
= pPacket
->DataTransferLength
;
1451 cmd
.senselen
= pPacket
->SenseInfoLength
;
1452 cmd
.timeout
= pPacket
->TimeOutValue
*1000; /* in milliseconds */
1454 switch (pPacket
->DataIn
)
1456 case SCSI_IOCTL_DATA_OUT
:
1457 cmd
.flags
|= SCCMD_WRITE
;
1459 case SCSI_IOCTL_DATA_IN
:
1460 cmd
.flags
|= SCCMD_READ
;
1462 case SCSI_IOCTL_DATA_UNSPECIFIED
:
1466 return STATUS_INVALID_PARAMETER
;
1469 io
= ioctl(fd
, SCIOCCOMMAND
, &cmd
);
1473 case SCCMD_OK
: break;
1474 case SCCMD_TIMEOUT
: return STATUS_TIMEOUT
;
1476 case SCCMD_BUSY
: return STATUS_DEVICE_BUSY
;
1478 case SCCMD_SENSE
: break;
1479 case SCCMD_UNKNOWN
: return STATUS_UNSUCCESSFUL
;
1483 if (pPacket
->SenseInfoLength
!= 0)
1485 memcpy((char*)pPacket
+ pPacket
->SenseInfoOffset
,
1486 cmd
.sense
, pPacket
->SenseInfoLength
);
1489 pPacket
->ScsiStatus
= cmd
.status
;
1491 ret
= CDROM_GetStatusCode(io
);
1496 /******************************************************************
1501 static NTSTATUS
CDROM_ScsiGetCaps(PIO_SCSI_CAPABILITIES caps
)
1503 NTSTATUS ret
= STATUS_NOT_IMPLEMENTED
;
1505 caps
->Length
= sizeof(*caps
);
1507 caps
->MaximumTransferLength
= SG_SCATTER_SZ
; /* FIXME */
1508 caps
->MaximumPhysicalPages
= SG_SCATTER_SZ
/ getpagesize();
1509 caps
->SupportedAsynchronousEvents
= TRUE
;
1510 caps
->AlignmentMask
= getpagesize();
1511 caps
->TaggedQueuing
= FALSE
; /* we could check that it works and answer TRUE */
1512 caps
->AdapterScansDown
= FALSE
; /* FIXME ? */
1513 caps
->AdapterUsesPio
= FALSE
; /* FIXME ? */
1514 ret
= STATUS_SUCCESS
;
1516 FIXME("Unimplemented\n");
1521 /******************************************************************
1524 * implements IOCTL_SCSI_GET_ADDRESS
1526 static NTSTATUS
CDROM_GetAddress(int fd
, SCSI_ADDRESS
* address
)
1528 int portnum
, busid
, targetid
, lun
;
1530 address
->Length
= sizeof(SCSI_ADDRESS
);
1531 if ( ! CDROM_GetInterfaceInfo(fd
, &portnum
, &busid
, &targetid
, &lun
))
1532 return STATUS_NOT_SUPPORTED
;
1534 address
->PortNumber
= portnum
;
1535 address
->PathId
= busid
; /* bus number */
1536 address
->TargetId
= targetid
;
1538 return STATUS_SUCCESS
;
1541 /******************************************************************
1542 * CDROM_DeviceIoControl
1546 NTSTATUS
CDROM_DeviceIoControl(HANDLE hDevice
,
1547 HANDLE hEvent
, PIO_APC_ROUTINE UserApcRoutine
,
1548 PVOID UserApcContext
,
1549 PIO_STATUS_BLOCK piosb
,
1550 ULONG dwIoControlCode
,
1551 LPVOID lpInBuffer
, DWORD nInBufferSize
,
1552 LPVOID lpOutBuffer
, DWORD nOutBufferSize
)
1555 NTSTATUS status
= STATUS_SUCCESS
;
1558 TRACE("%lx %s %lx %ld %lx %ld %p\n",
1559 (DWORD
)hDevice
, iocodex(dwIoControlCode
), (DWORD
)lpInBuffer
, nInBufferSize
,
1560 (DWORD
)lpOutBuffer
, nOutBufferSize
, piosb
);
1562 piosb
->Information
= 0;
1564 if ((status
= wine_server_handle_to_fd( hDevice
, 0, &fd
, NULL
, NULL
))) goto error
;
1565 if ((status
= CDROM_Open(fd
, &dev
)))
1567 wine_server_release_fd( hDevice
, fd
);
1571 switch (dwIoControlCode
)
1573 case IOCTL_STORAGE_CHECK_VERIFY
:
1574 case IOCTL_CDROM_CHECK_VERIFY
:
1576 CDROM_ClearCacheEntry(dev
);
1577 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0 || lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0)
1578 status
= STATUS_INVALID_PARAMETER
;
1579 else status
= CDROM_Verify(dev
, fd
);
1582 /* EPP case IOCTL_STORAGE_CHECK_VERIFY2: */
1584 /* EPP case IOCTL_STORAGE_FIND_NEW_DEVICES: */
1585 /* EPP case IOCTL_CDROM_FIND_NEW_DEVICES: */
1587 case IOCTL_STORAGE_LOAD_MEDIA
:
1588 case IOCTL_CDROM_LOAD_MEDIA
:
1590 CDROM_ClearCacheEntry(dev
);
1591 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0 || lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0)
1592 status
= STATUS_INVALID_PARAMETER
;
1593 else status
= CDROM_SetTray(fd
, FALSE
);
1595 case IOCTL_STORAGE_EJECT_MEDIA
:
1597 CDROM_ClearCacheEntry(dev
);
1598 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0 || lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0)
1599 status
= STATUS_INVALID_PARAMETER
;
1600 else status
= CDROM_SetTray(fd
, TRUE
);
1603 case IOCTL_CDROM_MEDIA_REMOVAL
:
1604 case IOCTL_DISK_MEDIA_REMOVAL
:
1605 case IOCTL_STORAGE_MEDIA_REMOVAL
:
1606 case IOCTL_STORAGE_EJECTION_CONTROL
:
1607 /* FIXME the last ioctl:s is not the same as the two others...
1608 * lockcount/owner should be handled */
1610 CDROM_ClearCacheEntry(dev
);
1611 if (lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1612 else if (nInBufferSize
< sizeof(PREVENT_MEDIA_REMOVAL
)) status
= STATUS_BUFFER_TOO_SMALL
;
1613 else status
= CDROM_ControlEjection(fd
, (const PREVENT_MEDIA_REMOVAL
*)lpInBuffer
);
1616 /* EPP case IOCTL_STORAGE_GET_MEDIA_TYPES: */
1618 case IOCTL_STORAGE_GET_DEVICE_NUMBER
:
1619 sz
= sizeof(STORAGE_DEVICE_NUMBER
);
1620 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1621 else if (nOutBufferSize
< sz
) status
= STATUS_BUFFER_TOO_SMALL
;
1622 else status
= CDROM_GetDeviceNumber(dev
, (STORAGE_DEVICE_NUMBER
*)lpOutBuffer
);
1625 case IOCTL_STORAGE_RESET_DEVICE
:
1627 CDROM_ClearCacheEntry(dev
);
1628 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0 || lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0)
1629 status
= STATUS_INVALID_PARAMETER
;
1630 else status
= CDROM_ResetAudio(fd
);
1633 case IOCTL_CDROM_GET_CONTROL
:
1634 sz
= sizeof(CDROM_AUDIO_CONTROL
);
1635 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1636 else if (nOutBufferSize
< sz
) status
= STATUS_BUFFER_TOO_SMALL
;
1637 else status
= CDROM_GetControl(dev
, (CDROM_AUDIO_CONTROL
*)lpOutBuffer
);
1640 case IOCTL_CDROM_GET_DRIVE_GEOMETRY
:
1641 sz
= sizeof(DISK_GEOMETRY
);
1642 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1643 else if (nOutBufferSize
< sz
) status
= STATUS_BUFFER_TOO_SMALL
;
1644 else status
= CDROM_GetDriveGeometry(dev
, fd
, (DISK_GEOMETRY
*)lpOutBuffer
);
1647 case IOCTL_CDROM_DISK_TYPE
:
1648 sz
= sizeof(CDROM_DISK_DATA
);
1649 /* CDROM_ClearCacheEntry(dev); */
1650 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1651 else if (nOutBufferSize
< sz
) status
= STATUS_BUFFER_TOO_SMALL
;
1652 else status
= CDROM_GetDiskData(dev
, fd
, (CDROM_DISK_DATA
*)lpOutBuffer
);
1655 /* EPP case IOCTL_CDROM_GET_LAST_SESSION: */
1657 case IOCTL_CDROM_READ_Q_CHANNEL
:
1658 sz
= sizeof(SUB_Q_CHANNEL_DATA
);
1659 if (lpInBuffer
== NULL
|| nInBufferSize
< sizeof(CDROM_SUB_Q_DATA_FORMAT
))
1660 status
= STATUS_INVALID_PARAMETER
;
1661 else if (nOutBufferSize
< sz
) status
= STATUS_BUFFER_TOO_SMALL
;
1662 else status
= CDROM_ReadQChannel(dev
, fd
, (const CDROM_SUB_Q_DATA_FORMAT
*)lpInBuffer
,
1663 (SUB_Q_CHANNEL_DATA
*)lpOutBuffer
);
1666 case IOCTL_CDROM_READ_TOC
:
1667 sz
= sizeof(CDROM_TOC
);
1668 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1669 else if (nOutBufferSize
< sz
) status
= STATUS_BUFFER_TOO_SMALL
;
1670 else status
= CDROM_ReadTOC(dev
, fd
, (CDROM_TOC
*)lpOutBuffer
);
1673 /* EPP case IOCTL_CDROM_READ_TOC_EX: */
1675 case IOCTL_CDROM_PAUSE_AUDIO
:
1677 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0 || lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0)
1678 status
= STATUS_INVALID_PARAMETER
;
1679 else status
= CDROM_PauseAudio(fd
);
1681 case IOCTL_CDROM_PLAY_AUDIO_MSF
:
1683 if (lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1684 else if (nInBufferSize
< sizeof(CDROM_PLAY_AUDIO_MSF
)) status
= STATUS_BUFFER_TOO_SMALL
;
1685 else status
= CDROM_PlayAudioMSF(fd
, (const CDROM_PLAY_AUDIO_MSF
*)lpInBuffer
);
1687 case IOCTL_CDROM_RESUME_AUDIO
:
1689 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0 || lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0)
1690 status
= STATUS_INVALID_PARAMETER
;
1691 else status
= CDROM_ResumeAudio(fd
);
1693 case IOCTL_CDROM_SEEK_AUDIO_MSF
:
1695 if (lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1696 else if (nInBufferSize
< sizeof(CDROM_SEEK_AUDIO_MSF
)) status
= STATUS_BUFFER_TOO_SMALL
;
1697 else status
= CDROM_SeekAudioMSF(dev
, fd
, (const CDROM_SEEK_AUDIO_MSF
*)lpInBuffer
);
1699 case IOCTL_CDROM_STOP_AUDIO
:
1701 CDROM_ClearCacheEntry(dev
); /* Maybe intention is to change media */
1702 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0 || lpOutBuffer
!= NULL
|| nOutBufferSize
!= 0)
1703 status
= STATUS_INVALID_PARAMETER
;
1704 else status
= CDROM_StopAudio(fd
);
1706 case IOCTL_CDROM_GET_VOLUME
:
1707 sz
= sizeof(VOLUME_CONTROL
);
1708 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1709 else if (nOutBufferSize
< sz
) status
= STATUS_BUFFER_TOO_SMALL
;
1710 else status
= CDROM_GetVolume(fd
, (VOLUME_CONTROL
*)lpOutBuffer
);
1712 case IOCTL_CDROM_SET_VOLUME
:
1714 CDROM_ClearCacheEntry(dev
);
1715 if (lpInBuffer
== NULL
|| nInBufferSize
< sizeof(VOLUME_CONTROL
) || lpOutBuffer
!= NULL
)
1716 status
= STATUS_INVALID_PARAMETER
;
1717 else status
= CDROM_SetVolume(fd
, (const VOLUME_CONTROL
*)lpInBuffer
);
1719 case IOCTL_CDROM_RAW_READ
:
1721 if (nInBufferSize
< sizeof(RAW_READ_INFO
)) status
= STATUS_INVALID_PARAMETER
;
1722 else if (lpOutBuffer
== NULL
) status
= STATUS_BUFFER_TOO_SMALL
;
1723 else status
= CDROM_RawRead(fd
, (const RAW_READ_INFO
*)lpInBuffer
,
1724 lpOutBuffer
, nOutBufferSize
, &sz
);
1726 case IOCTL_SCSI_GET_ADDRESS
:
1727 sz
= sizeof(SCSI_ADDRESS
);
1728 if (lpInBuffer
!= NULL
|| nInBufferSize
!= 0) status
= STATUS_INVALID_PARAMETER
;
1729 else if (nOutBufferSize
< sz
) status
= STATUS_BUFFER_TOO_SMALL
;
1730 else status
= CDROM_GetAddress(fd
, (SCSI_ADDRESS
*)lpOutBuffer
);
1732 case IOCTL_SCSI_PASS_THROUGH_DIRECT
:
1733 sz
= sizeof(SCSI_PASS_THROUGH_DIRECT
);
1734 if (lpOutBuffer
== NULL
) status
= STATUS_INVALID_PARAMETER
;
1735 else if (nOutBufferSize
< sizeof(SCSI_PASS_THROUGH_DIRECT
)) status
= STATUS_BUFFER_TOO_SMALL
;
1736 else status
= CDROM_ScsiPassThroughDirect(fd
, (PSCSI_PASS_THROUGH_DIRECT
)lpOutBuffer
);
1738 case IOCTL_SCSI_PASS_THROUGH
:
1739 sz
= sizeof(SCSI_PASS_THROUGH
);
1740 if (lpOutBuffer
== NULL
) status
= STATUS_INVALID_PARAMETER
;
1741 else if (nOutBufferSize
< sizeof(SCSI_PASS_THROUGH
)) status
= STATUS_BUFFER_TOO_SMALL
;
1742 else status
= CDROM_ScsiPassThrough(fd
, (PSCSI_PASS_THROUGH
)lpOutBuffer
);
1744 case IOCTL_SCSI_GET_CAPABILITIES
:
1745 sz
= sizeof(IO_SCSI_CAPABILITIES
);
1746 if (lpOutBuffer
== NULL
) status
= STATUS_INVALID_PARAMETER
;
1747 else if (nOutBufferSize
< sizeof(IO_SCSI_CAPABILITIES
)) status
= STATUS_BUFFER_TOO_SMALL
;
1748 else status
= CDROM_ScsiGetCaps((PIO_SCSI_CAPABILITIES
)lpOutBuffer
);
1751 FIXME("Unsupported IOCTL %lx (type=%lx access=%lx func=%lx meth=%lx)\n",
1752 dwIoControlCode
, dwIoControlCode
>> 16, (dwIoControlCode
>> 14) & 3,
1753 (dwIoControlCode
>> 2) & 0xFFF, dwIoControlCode
& 3);
1755 status
= STATUS_INVALID_PARAMETER
;
1758 wine_server_release_fd( hDevice
, fd
);
1760 piosb
->u
.Status
= status
;
1761 piosb
->Information
= sz
;
1762 if (hEvent
) NtSetEvent(hEvent
, NULL
);