?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Add a test for NtNotifyChangeDirectoryFile.
[wine/multimedia.git] / dlls / ntdll / cdrom.c
blobbeb2962c79f7338dba34d3c35bd981bea1d433b6
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /* Main file for CD-ROM support
3 *
4 * Copyright 1994 Martin Ayotte
5 * Copyright 1999, 2001, 2003 Eric Pouech
6 * Copyright 2000 Andreas Mohr
7 * Copyright 2005 Ivan Leo Puoti
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <errno.h>
28 #include <string.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #ifdef HAVE_IO_H
32 # include <io.h>
33 #endif
34 #ifdef HAVE_UNISTD_H
35 # include <unistd.h>
36 #endif
37 #include <fcntl.h>
38 #ifdef HAVE_SYS_STAT_H
39 # include <sys/stat.h>
40 #endif
41 #include <sys/types.h>
42
43 #ifdef HAVE_SYS_IOCTL_H
44 #include <sys/ioctl.h>
45 #endif
46 #ifdef HAVE_SCSI_SG_H
47 # include <scsi/sg.h>
48 #endif
49 #ifdef HAVE_SCSI_SCSI_H
50 # include <scsi/scsi.h>
51 # undef REASSIGN_BLOCKS /* avoid conflict with winioctl.h */
52 #endif
53 #ifdef HAVE_SCSI_SCSI_IOCTL_H
54 # include <scsi/scsi_ioctl.h>
55 #endif
56 #ifdef HAVE_LINUX_MAJOR_H
57 # include <linux/major.h>
58 #endif
59 #ifdef HAVE_LINUX_HDREG_H
60 # include <linux/hdreg.h>
61 #endif
62 #ifdef HAVE_LINUX_PARAM_H
63 # include <linux/param.h>
64 #endif
65 #ifdef HAVE_LINUX_CDROM_H
66 # include <linux/cdrom.h>
67 #endif
68 #ifdef HAVE_LINUX_UCDROM_H
69 # include <linux/ucdrom.h>
70 #endif
71 #ifdef HAVE_SYS_CDIO_H
72 # include <sys/cdio.h>
73 #endif
74 #ifdef HAVE_SYS_SCSIIO_H
75 # include <sys/scsiio.h>
76 #endif
77
78 #ifdef HAVE_IOKIT_IOKITLIB_H
79 # ifndef SENSEBUFLEN
80 # include <IOKit/IOKitLib.h>
81 # include <IOKit/scsi/SCSICmds_REQUEST_SENSE_Defs.h>
82 # define SENSEBUFLEN kSenseDefaultSize
83 # endif
84 #endif
85
86 #define NONAMELESSUNION
87 #define NONAMELESSSTRUCT
88 #include "ntstatus.h"
89 #define WIN32_NO_STATUS
90 #include "windef.h"
91 #include "winternl.h"
92 #include "winioctl.h"
93 #include "ntddstor.h"
94 #include "ntddcdrm.h"
95 #include "ntddscsi.h"
96 #include "ntdll_misc.h"
97 #include "wine/server.h"
98 #include "wine/library.h"
99 #include "wine/debug.h"
100
101 WINE_DEFAULT_DEBUG_CHANNEL(cdrom);
102
103 /* Non-Linux systems do not have linux/cdrom.h and the like, and thus
104 lack the following constants. */
105
106 #ifndef CD_SECS
107 # define CD_SECS 60 /* seconds per minute */
108 #endif
109 #ifndef CD_FRAMES
110 # define CD_FRAMES 75 /* frames per second */
111 #endif
112
113 /* definitions taken from libdvdcss */
114
115 #define IOCTL_DVD_BASE FILE_DEVICE_DVD
116
117 #define IOCTL_DVD_START_SESSION CTL_CODE(IOCTL_DVD_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS)
118 #define IOCTL_DVD_READ_KEY CTL_CODE(IOCTL_DVD_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS)
119 #define IOCTL_DVD_SEND_KEY CTL_CODE(IOCTL_DVD_BASE, 0x0402, METHOD_BUFFERED, FILE_READ_ACCESS)
120 #define IOCTL_DVD_END_SESSION CTL_CODE(IOCTL_DVD_BASE, 0x0403, METHOD_BUFFERED, FILE_READ_ACCESS)
121 #define IOCTL_DVD_SET_READ_AHEAD CTL_CODE(IOCTL_DVD_BASE, 0x0404, METHOD_BUFFERED, FILE_READ_ACCESS)
122 #define IOCTL_DVD_GET_REGION CTL_CODE(IOCTL_DVD_BASE, 0x0405, METHOD_BUFFERED, FILE_READ_ACCESS)
123 #define IOCTL_DVD_SEND_KEY2 CTL_CODE(IOCTL_DVD_BASE, 0x0406, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
124
125 #define IOCTL_DVD_READ_STRUCTURE CTL_CODE(IOCTL_DVD_BASE, 0x0450, METHOD_BUFFERED, FILE_READ_ACCESS)
126
127 typedef enum {
128 DvdChallengeKey = 0x01,
129 DvdBusKey1,
130 DvdBusKey2,
131 DvdTitleKey,
132 DvdAsf,
133 DvdSetRpcKey = 0x6,
134 DvdGetRpcKey = 0x8,
135 DvdDiskKey = 0x80,
136 DvdInvalidateAGID = 0x3f
137 } DVD_KEY_TYPE;
138
139 typedef ULONG DVD_SESSION_ID, *PDVD_SESSION_ID;
140
141 typedef struct _DVD_COPY_PROTECT_KEY {
142 ULONG KeyLength;
143 DVD_SESSION_ID SessionId;
144 DVD_KEY_TYPE KeyType;
145 ULONG KeyFlags;
146 union {
147 struct {
148 ULONG FileHandle;
149 ULONG Reserved; /* used for NT alignment */
150 } s;
151 LARGE_INTEGER TitleOffset;
152 } Parameters;
153 UCHAR KeyData[1];
154 } DVD_COPY_PROTECT_KEY, *PDVD_COPY_PROTECT_KEY;
155
156 typedef struct _DVD_RPC_KEY {
157 UCHAR UserResetsAvailable:3;
158 UCHAR ManufacturerResetsAvailable:3;
159 UCHAR TypeCode:2;
160 UCHAR RegionMask;
161 UCHAR RpcScheme;
162 UCHAR Reserved2[1];
163 } DVD_RPC_KEY, * PDVD_RPC_KEY;
164
165 typedef struct _DVD_ASF {
166 UCHAR Reserved0[3];
167 UCHAR SuccessFlag:1;
168 UCHAR Reserved1:7;
169 } DVD_ASF, * PDVD_ASF;
170
171 typedef struct _DVD_REGION
172 {
173 unsigned char copy_system;
174 unsigned char region_data; /* current media region (not playable when set) */
175 unsigned char system_region; /* current drive region (playable when set) */
176 unsigned char reset_count; /* number of resets available */
177 } DVD_REGION, * PDVD_REGION;
178
179 typedef struct _DVD_READ_STRUCTURE {
180 /* Contains an offset to the logical block address of the descriptor to be retrieved. */
181 LARGE_INTEGER block_byte_offset;
182
183 /* 0:Physical descriptor, 1:Copyright descriptor, 2:Disk key descriptor
184 3:BCA descriptor, 4:Manufacturer descriptor, 5:Max descriptor
185 */
186 long format;
187
188 /* Session ID, that is obtained by IOCTL_DVD_START_SESSION */
189 long session;
190
191 /* From 0 to 4 */
192 unsigned char layer_no;
193 }DVD_READ_STRUCTURE, * PDVD_READ_STRUCTURE;
194
195 typedef struct _DVD_LAYER_DESCRIPTOR
196 {
197 unsigned short length;
198
199 unsigned char book_version : 4;
200
201 /* 0:DVD-ROM, 1:DVD-RAM, 2:DVD-R, 3:DVD-RW, 9:DVD-RW */
202 unsigned char book_type : 4;
203
204 unsigned char minimum_rate : 4;
205
206 /* The physical size of the media. 0:120 mm, 1:80 mm. */
207 unsigned char disk_size : 4;
208
209 /* 1:Read-only layer, 2:Recordable layer, 4:Rewritable layer */
210 unsigned char layer_type : 4;
211
212 /* 0:parallel track path, 1:opposite track path */
213 unsigned char track_path : 1;
214
215 /* 0:one layers, 1:two layers, and so on */
216 unsigned char num_of_layers : 2;
217
218 unsigned char reserved1 : 1;
219
220 /* 0:0.74 µm/track, 1:0.80 µm/track, 2:0.615 µm/track */
221 unsigned char track_density : 4;
222
223 /* 0:0.267 µm/bit, 1:0.293 µm/bit, 2:0.409 to 0.435 µm/bit, 4:0.280 to 0.291 µm/bit, 8:0.353 µm/bit */
224 unsigned char linear_density : 4;
225
226 /* Must be either 0x30000:DVD-ROM or DVD-R/-RW or 0x31000:DVD-RAM or DVD+RW */
227 unsigned long starting_data_sector;
228
229 unsigned long end_data_sector;
230 unsigned long end_layer_zero_sector;
231 unsigned char reserved5 : 7;
232
233 /* 0 indicates no BCA data */
234 unsigned char BCA_flag : 1;
235
236 unsigned char reserved6;
237 }DVD_LAYER_DESCRIPTOR, * PDVD_LAYER_DESCRIPTOR;
238
239 typedef struct _DVD_COPYRIGHT_DESCRIPTOR
240 {
241 unsigned char protection;
242 unsigned char region;
243 unsigned short reserved;
244 }DVD_COPYRIGHT_DESCRIPTOR, * PDVD_COPYRIGHT_DESCRIPTOR;
245
246 typedef struct _DVD_MANUFACTURER_DESCRIPTOR
247 {
248 unsigned char manufacturing[2048];
249 }DVD_MANUFACTURER_DESCRIPTOR, * PDVD_MANUFACTURER_DESCRIPTOR;
250
251 #define DVD_CHALLENGE_KEY_LENGTH (12 + sizeof(DVD_COPY_PROTECT_KEY) - sizeof(UCHAR))
252
253 #define DVD_DISK_KEY_LENGTH (2048 + sizeof(DVD_COPY_PROTECT_KEY) - sizeof(UCHAR))
254
255 #define DVD_KEY_SIZE 5
256 #define DVD_CHALLENGE_SIZE 10
257 #define DVD_DISCKEY_SIZE 2048
258 #define DVD_SECTOR_PROTECTED 0x00000020
259
260 static const struct iocodexs
261 {
262 DWORD code;
263 const char *codex;
264 } iocodextable[] = {
265 #define X(x) { x, #x },
266 X(IOCTL_CDROM_CHECK_VERIFY)
267 X(IOCTL_CDROM_CURRENT_POSITION)
268 X(IOCTL_CDROM_DISK_TYPE)
269 X(IOCTL_CDROM_GET_CONTROL)
270 X(IOCTL_CDROM_GET_DRIVE_GEOMETRY)
271 X(IOCTL_CDROM_GET_VOLUME)
272 X(IOCTL_CDROM_LOAD_MEDIA)
273 X(IOCTL_CDROM_MEDIA_CATALOG)
274 X(IOCTL_CDROM_MEDIA_REMOVAL)
275 X(IOCTL_CDROM_PAUSE_AUDIO)
276 X(IOCTL_CDROM_PLAY_AUDIO_MSF)
277 X(IOCTL_CDROM_RAW_READ)
278 X(IOCTL_CDROM_READ_Q_CHANNEL)
279 X(IOCTL_CDROM_READ_TOC)
280 X(IOCTL_CDROM_RESUME_AUDIO)
281 X(IOCTL_CDROM_SEEK_AUDIO_MSF)
282 X(IOCTL_CDROM_SET_VOLUME)
283 X(IOCTL_CDROM_STOP_AUDIO)
284 X(IOCTL_CDROM_TRACK_ISRC)
285 X(IOCTL_DISK_MEDIA_REMOVAL)
286 X(IOCTL_DVD_END_SESSION)
287 X(IOCTL_DVD_GET_REGION)
288 X(IOCTL_DVD_READ_KEY)
289 X(IOCTL_DVD_READ_STRUCTURE)
290 X(IOCTL_DVD_SEND_KEY)
291 X(IOCTL_DVD_START_SESSION)
292 X(IOCTL_SCSI_GET_ADDRESS)
293 X(IOCTL_SCSI_GET_CAPABILITIES)
294 X(IOCTL_SCSI_GET_INQUIRY_DATA)
295 X(IOCTL_SCSI_PASS_THROUGH)
296 X(IOCTL_SCSI_PASS_THROUGH_DIRECT)
297 X(IOCTL_STORAGE_CHECK_VERIFY)
298 X(IOCTL_STORAGE_EJECTION_CONTROL)
299 X(IOCTL_STORAGE_EJECT_MEDIA)
300 X(IOCTL_STORAGE_GET_DEVICE_NUMBER)
301 X(IOCTL_STORAGE_LOAD_MEDIA)
302 X(IOCTL_STORAGE_MEDIA_REMOVAL)
303 X(IOCTL_STORAGE_RESET_DEVICE)
304 #undef X
305 };
306 static const char *iocodex(DWORD code)
307 {
308 unsigned int i;
309 static char buffer[25];
310 for(i=0; i<sizeof(iocodextable)/sizeof(struct iocodexs); i++)
311 if (code==iocodextable[i].code)
312 return iocodextable[i].codex;
313 sprintf(buffer, "IOCTL_CODE_%x", (int)code);
314 return buffer;
315 }
316
317 #define INQ_REPLY_LEN 36
318 #define INQ_CMD_LEN 6
319
320 #define FRAME_OF_ADDR(a) (((int)(a)[1] * CD_SECS + (a)[2]) * CD_FRAMES + (a)[3])
321 #define FRAME_OF_MSF(a) (((int)(a).M * CD_SECS + (a).S) * CD_FRAMES + (a).F)
322 #define FRAME_OF_TOC(toc, idx) FRAME_OF_ADDR((toc).TrackData[idx - (toc).FirstTrack].Address)
323 #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;}
324
325 static NTSTATUS CDROM_ReadTOC(int, int, CDROM_TOC*);
326 static NTSTATUS CDROM_GetStatusCode(int);
327
328
329 #ifdef linux
330
331 # ifndef IDE6_MAJOR
332 # define IDE6_MAJOR 88
333 # endif
334 # ifndef IDE7_MAJOR
335 # define IDE7_MAJOR 89
336 # endif
337
338 # ifdef CDROM_SEND_PACKET
339 /* structure for CDROM_PACKET_COMMAND ioctl */
340 /* not all Linux versions have all the fields, so we define the
341 * structure ourselves to make sure */
342 struct linux_cdrom_generic_command
343 {
344 unsigned char cmd[CDROM_PACKET_SIZE];
345 unsigned char *buffer;
346 unsigned int buflen;
347 int stat;
348 struct request_sense *sense;
349 unsigned char data_direction;
350 int quiet;
351 int timeout;
352 void *reserved[1];
353 };
354 # endif /* CDROM_SEND_PACKET */
355
356 #endif /* linux */
357
358 /* FIXME: this is needed because we can't open simultaneously several times /dev/cdrom
359 * this should be removed when a proper device interface is implemented
360 *
361 * (WS) We need this to keep track of current position and to safely
362 * detect media changes. Besides this should provide a great speed up
363 * for toc inquiries.
364 */
365 struct cdrom_cache {
366 dev_t device;
367 ino_t inode;
368 char toc_good; /* if false, will reread TOC from disk */
369 CDROM_TOC toc;
370 SUB_Q_CURRENT_POSITION CurrentPosition;
371 };
372 /* who has more than 5 cdroms on his/her machine ?? */
373 /* FIXME: this should grow depending on the number of cdroms we install/configure
374 * at startup
375 */
376 #define MAX_CACHE_ENTRIES 5
377 static struct cdrom_cache cdrom_cache[MAX_CACHE_ENTRIES];
378
379 static RTL_CRITICAL_SECTION cache_section;
380 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
381 {
382 0, 0, &cache_section,
383 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
384 0, 0, { (DWORD_PTR)(__FILE__ ": cache_section") }
385 };
386 static RTL_CRITICAL_SECTION cache_section = { &critsect_debug, -1, 0, 0, 0, 0 };
387
388 /* Proposed media change function: not really needed at this time */
389 /* This is a 1 or 0 type of function */
390 #if 0
391 static int CDROM_MediaChanged(int dev)
392 {
393 int i;
394
395 struct cdrom_tochdr hdr;
396 struct cdrom_tocentry entry;
397
398 if (dev < 0 || dev >= MAX_CACHE_ENTRIES)
399 return 0;
400 if ( ioctl(cdrom_cache[dev].fd, CDROMREADTOCHDR, &hdr) == -1 )
401 return 0;
402
403 if ( memcmp(&hdr, &cdrom_cache[dev].hdr, sizeof(struct cdrom_tochdr)) )
404 return 1;
405
406 for (i=hdr.cdth_trk0; i<=hdr.cdth_trk1+1; i++)
407 {
408 if (i == hdr.cdth_trk1 + 1)
409 {
410 entry.cdte_track = CDROM_LEADOUT;
411 } else {
412 entry.cdte_track = i;
413 }
414 entry.cdte_format = CDROM_MSF;
415 if ( ioctl(cdrom_cache[dev].fd, CDROMREADTOCENTRY, &entry) == -1)
416 return 0;
417 if ( memcmp(&entry, cdrom_cache[dev].entry+i-hdr.cdth_trk0,
418 sizeof(struct cdrom_tocentry)) )
419 return 1;
420 }
421 return 0;
422 }
423 #endif
424
425 /******************************************************************
426 * CDROM_SyncCache [internal]
427 *
428 * Read the TOC in and store it in the cdrom_cache structure.
429 * Further requests for the TOC will be copied from the cache
430 * unless certain events like disk ejection is detected, in which
431 * case the cache will be cleared, causing it to be resynced.
432 * The cache section must be held by caller.
433 */
434 static NTSTATUS CDROM_SyncCache(int dev, int fd)
435 {
436 #ifdef linux
437 int i, tsz;
438 struct cdrom_tochdr hdr;
439 struct cdrom_tocentry entry;
440
441 CDROM_TOC *toc = &cdrom_cache[dev].toc;
442 cdrom_cache[dev].toc_good = 0;
443
444 if (ioctl(fd, CDROMREADTOCHDR, &hdr) == -1)
445 {
446 WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
447 return FILE_GetNtStatus();
448 }
449
450 toc->FirstTrack = hdr.cdth_trk0;
451 toc->LastTrack = hdr.cdth_trk1;
452 tsz = sizeof(toc->FirstTrack) + sizeof(toc->LastTrack)
453 + sizeof(TRACK_DATA) * (toc->LastTrack-toc->FirstTrack+2);
454 toc->Length[0] = tsz >> 8;
455 toc->Length[1] = tsz;
456
457 TRACE("caching toc from=%d to=%d\n", toc->FirstTrack, toc->LastTrack );
458
459 for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
460 {
461 if (i == toc->LastTrack + 1)
462 entry.cdte_track = CDROM_LEADOUT;
463 else
464 entry.cdte_track = i;
465 entry.cdte_format = CDROM_MSF;
466 if (ioctl(fd, CDROMREADTOCENTRY, &entry) == -1)
467 {
468 WARN("error read entry (%s)\n", strerror(errno));
469 return FILE_GetNtStatus();
470 }
471 toc->TrackData[i - toc->FirstTrack].Control = entry.cdte_ctrl;
472 toc->TrackData[i - toc->FirstTrack].Adr = entry.cdte_adr;
473 /* marking last track with leadout value as index */
474 toc->TrackData[i - toc->FirstTrack].TrackNumber = entry.cdte_track;
475 toc->TrackData[i - toc->FirstTrack].Address[0] = 0;
476 toc->TrackData[i - toc->FirstTrack].Address[1] = entry.cdte_addr.msf.minute;
477 toc->TrackData[i - toc->FirstTrack].Address[2] = entry.cdte_addr.msf.second;
478 toc->TrackData[i - toc->FirstTrack].Address[3] = entry.cdte_addr.msf.frame;
479 }
480 cdrom_cache[dev].toc_good = 1;
481 return STATUS_SUCCESS;
482
483 #elif defined(__FreeBSD__) || defined(__NetBSD__)
484
485 int i, tsz;
486 struct ioc_toc_header hdr;
487 struct ioc_read_toc_entry entry;
488 struct cd_toc_entry toc_buffer;
489
490 CDROM_TOC *toc = &cdrom_cache[dev].toc;
491 cdrom_cache[dev].toc_good = 0;
492
493 if (ioctl(fd, CDIOREADTOCHEADER, &hdr) == -1)
494 {
495 WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
496 return FILE_GetNtStatus();
497 }
498 toc->FirstTrack = hdr.starting_track;
499 toc->LastTrack = hdr.ending_track;
500 tsz = sizeof(toc->FirstTrack) + sizeof(toc->LastTrack)
501 + sizeof(TRACK_DATA) * (toc->LastTrack-toc->FirstTrack+2);
502 toc->Length[0] = tsz >> 8;
503 toc->Length[1] = tsz;
504
505 TRACE("caching toc from=%d to=%d\n", toc->FirstTrack, toc->LastTrack );
506
507 for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
508 {
509 if (i == toc->LastTrack + 1)
510 {
511 #define LEADOUT 0xaa
512 entry.starting_track = LEADOUT;
513 } else {
514 entry.starting_track = i;
515 }
516 memset((char *)&toc_buffer, 0, sizeof(toc_buffer));
517 entry.address_format = CD_MSF_FORMAT;
518 entry.data_len = sizeof(toc_buffer);
519 entry.data = &toc_buffer;
520 if (ioctl(fd, CDIOREADTOCENTRYS, &entry) == -1)
521 {
522 WARN("error read entry (%s)\n", strerror(errno));
523 return FILE_GetNtStatus();
524 }
525 toc->TrackData[i - toc->FirstTrack].Control = toc_buffer.control;
526 toc->TrackData[i - toc->FirstTrack].Adr = toc_buffer.addr_type;
527 /* marking last track with leadout value as index */
528 toc->TrackData[i - toc->FirstTrack].TrackNumber = entry.starting_track;
529 toc->TrackData[i - toc->FirstTrack].Address[0] = 0;
530 toc->TrackData[i - toc->FirstTrack].Address[1] = toc_buffer.addr.msf.minute;
531 toc->TrackData[i - toc->FirstTrack].Address[2] = toc_buffer.addr.msf.second;
532 toc->TrackData[i - toc->FirstTrack].Address[3] = toc_buffer.addr.msf.frame;
533 }
534 cdrom_cache[dev].toc_good = 1;
535 return STATUS_SUCCESS;
536 #else
537 return STATUS_NOT_SUPPORTED;
538 #endif
539 }
540
541 static void CDROM_ClearCacheEntry(int dev)
542 {
543 RtlEnterCriticalSection( &cache_section );
544 cdrom_cache[dev].toc_good = 0;
545 RtlLeaveCriticalSection( &cache_section );
546 }
547
548
549
550 /******************************************************************
551 * CDROM_GetInterfaceInfo
552 *
553 * Determines the ide interface (the number after the ide), and the
554 * number of the device on that interface for ide cdroms (*iface <= 1).
555 * Determines the scsi information for scsi cdroms (*iface >= 2).
556 * Returns false if the info cannot not be obtained.
557 */
558 static int CDROM_GetInterfaceInfo(int fd, UCHAR* iface, UCHAR* port, UCHAR* device, UCHAR* lun)
559 {
560 #if defined(linux)
561 struct stat st;
562 if ( fstat(fd, &st) == -1 || ! S_ISBLK(st.st_mode)) return 0;
563 *port = 0;
564 *iface = 0;
565 *device = 0;
566 *lun = 0;
567 switch (major(st.st_rdev)) {
568 case IDE0_MAJOR: *iface = 0; break;
569 case IDE1_MAJOR: *iface = 1; break;
570 case IDE2_MAJOR: *iface = 2; break;
571 case IDE3_MAJOR: *iface = 3; break;
572 case IDE4_MAJOR: *iface = 4; break;
573 case IDE5_MAJOR: *iface = 5; break;
574 case IDE6_MAJOR: *iface = 6; break;
575 case IDE7_MAJOR: *iface = 7; break;
576 default: *port = 1; break;
577 }
578
579 if (*port == 0)
580 *device = (minor(st.st_rdev) >> 6);
581 else
582 {
583 #ifdef SCSI_IOCTL_GET_IDLUN
584 UINT32 idlun[2];
585 if (ioctl(fd, SCSI_IOCTL_GET_IDLUN, &idlun) != -1)
586 {
587 *port = (idlun[0] >> 24) & 0xff;
588 *iface = ((idlun[0] >> 16) & 0xff) + 2;
589 *device = idlun[0] & 0xff;
590 *lun = (idlun[0] >> 8) & 0xff;
591 }
592 else
593 #endif
594 {
595 WARN("CD-ROM device (%d, %d) not supported\n", major(st.st_rdev), minor(st.st_rdev));
596 return 0;
597 }
598 }
599 return 1;
600 #elif defined(__NetBSD__)
601 struct scsi_addr addr;
602 if (ioctl(fd, SCIOCIDENTIFY, &addr) != -1)
603 {
604 switch (addr.type)
605 {
606 case TYPE_SCSI: *port = 1;
607 *iface = addr.addr.scsi.scbus;
608 *device = addr.addr.scsi.target;
609 *lun = addr.addr.scsi.lun;
610 break;
611 case TYPE_ATAPI: *port = 0;
612 *iface = addr.addr.atapi.atbus;
613 *device = addr.addr.atapi.drive;
614 *lun = 0;
615 break;
616 }
617 return 1;
618 }
619 return 0;
620 #elif defined(__FreeBSD__)
621 FIXME("not implemented for BSD\n");
622 return 0;
623 #else
624 FIXME("not implemented for nonlinux\n");
625 return 0;
626 #endif
627 }
628
629
630 /******************************************************************
631 * CDROM_Open
632 *
633 */
634 static NTSTATUS CDROM_Open(int fd, int* dev)
635 {
636 struct stat st;
637 NTSTATUS ret = STATUS_SUCCESS;
638 int empty = -1;
639
640 fstat(fd, &st);
641
642 RtlEnterCriticalSection( &cache_section );
643 for (*dev = 0; *dev < MAX_CACHE_ENTRIES; (*dev)++)
644 {
645 if (empty == -1 &&
646 cdrom_cache[*dev].device == 0 &&
647 cdrom_cache[*dev].inode == 0)
648 empty = *dev;
649 else if (cdrom_cache[*dev].device == st.st_dev &&
650 cdrom_cache[*dev].inode == st.st_ino)
651 break;
652 }
653 if (*dev == MAX_CACHE_ENTRIES)
654 {
655 if (empty == -1) ret = STATUS_NOT_IMPLEMENTED;
656 else
657 {
658 *dev = empty;
659 cdrom_cache[*dev].device = st.st_dev;
660 cdrom_cache[*dev].inode = st.st_ino;
661 }
662 }
663 RtlLeaveCriticalSection( &cache_section );
664
665 TRACE("%d, %d\n", *dev, fd);
666 return ret;
667 }
668
669 /******************************************************************
670 * CDROM_GetStatusCode
671 *
672 *
673 */
674 static NTSTATUS CDROM_GetStatusCode(int io)
675 {
676 if (io == 0) return STATUS_SUCCESS;
677 return FILE_GetNtStatus();
678 }
679
680 /******************************************************************
681 * CDROM_GetControl
682 *
683 */
684 static NTSTATUS CDROM_GetControl(int dev, CDROM_AUDIO_CONTROL* cac)
685 {
686 cac->LbaFormat = 0; /* FIXME */
687 cac->LogicalBlocksPerSecond = 1; /* FIXME */
688 return STATUS_NOT_SUPPORTED;
689 }
690
691 /******************************************************************
692 * CDROM_GetDeviceNumber
693 *
694 */
695 static NTSTATUS CDROM_GetDeviceNumber(int dev, STORAGE_DEVICE_NUMBER* devnum)
696 {
697 return STATUS_NOT_SUPPORTED;
698 }
699
700 /******************************************************************
701 * CDROM_GetDriveGeometry
702 *
703 */
704 static NTSTATUS CDROM_GetDriveGeometry(int dev, int fd, DISK_GEOMETRY* dg)
705 {
706 CDROM_TOC toc;
707 NTSTATUS ret = 0;
708 int fsize = 0;
709
710 if ((ret = CDROM_ReadTOC(dev, fd, &toc)) != 0) return ret;
711
712 fsize = FRAME_OF_TOC(toc, toc.LastTrack+1)
713 - FRAME_OF_TOC(toc, 1); /* Total size in frames */
714
715 dg->Cylinders.u.LowPart = fsize / (64 * 32);
716 dg->Cylinders.u.HighPart = 0;
717 dg->MediaType = RemovableMedia;
718 dg->TracksPerCylinder = 64;
719 dg->SectorsPerTrack = 32;
720 dg->BytesPerSector= 2048;
721 return ret;
722 }
723
724 /**************************************************************************
725 * CDROM_Reset [internal]
726 */
727 static NTSTATUS CDROM_ResetAudio(int fd)
728 {
729 #if defined(linux)
730 return CDROM_GetStatusCode(ioctl(fd, CDROMRESET));
731 #elif defined(__FreeBSD__) || defined(__NetBSD__)
732 return CDROM_GetStatusCode(ioctl(fd, CDIOCRESET, NULL));
733 #else
734 return STATUS_NOT_SUPPORTED;
735 #endif
736 }
737
738 /******************************************************************
739 * CDROM_SetTray
740 *
741 *
742 */
743 static NTSTATUS CDROM_SetTray(int fd, BOOL doEject)
744 {
745 #if defined(linux)
746 return CDROM_GetStatusCode(ioctl(fd, doEject ? CDROMEJECT : CDROMCLOSETRAY));
747 #elif defined(__FreeBSD__) || defined(__NetBSD__)
748 return CDROM_GetStatusCode((ioctl(fd, CDIOCALLOW, NULL)) ||
749 (ioctl(fd, doEject ? CDIOCEJECT : CDIOCCLOSE, NULL)) ||
750 (ioctl(fd, CDIOCPREVENT, NULL)));
751 #else
752 return STATUS_NOT_SUPPORTED;
753 #endif
754 }
755
756 /******************************************************************
757 * CDROM_ControlEjection
758 *
759 *
760 */
761 static NTSTATUS CDROM_ControlEjection(int fd, const PREVENT_MEDIA_REMOVAL* rmv)
762 {
763 #if defined(linux)
764 return CDROM_GetStatusCode(ioctl(fd, CDROM_LOCKDOOR, rmv->PreventMediaRemoval));
765 #elif defined(__FreeBSD__) || defined(__NetBSD__)
766 return CDROM_GetStatusCode(ioctl(fd, (rmv->PreventMediaRemoval) ? CDIOCPREVENT : CDIOCALLOW, NULL));
767 #else
768 return STATUS_NOT_SUPPORTED;
769 #endif
770 }
771
772 /******************************************************************
773 * CDROM_ReadTOC
774 *
775 *
776 */
777 static NTSTATUS CDROM_ReadTOC(int dev, int fd, CDROM_TOC* toc)
778 {
779 NTSTATUS ret = STATUS_NOT_SUPPORTED;
780
781 if (dev < 0 || dev >= MAX_CACHE_ENTRIES)
782 return STATUS_INVALID_PARAMETER;
783
784 RtlEnterCriticalSection( &cache_section );
785 if (cdrom_cache[dev].toc_good || !(ret = CDROM_SyncCache(dev, fd)))
786 {
787 *toc = cdrom_cache[dev].toc;
788 ret = STATUS_SUCCESS;
789 }
790 RtlLeaveCriticalSection( &cache_section );
791 return ret;
792 }
793
794 /******************************************************************
795 * CDROM_GetDiskData
796 *
797 *
798 */
799 static NTSTATUS CDROM_GetDiskData(int dev, int fd, CDROM_DISK_DATA* data)
800 {
801 CDROM_TOC toc;
802 NTSTATUS ret;
803 int i;
804
805 if ((ret = CDROM_ReadTOC(dev, fd, &toc)) != 0) return ret;
806 data->DiskData = 0;
807 for (i = toc.FirstTrack; i <= toc.LastTrack; i++) {
808 if (toc.TrackData[i-toc.FirstTrack].Control & 0x04)
809 data->DiskData |= CDROM_DISK_DATA_TRACK;
810 else
811 data->DiskData |= CDROM_DISK_AUDIO_TRACK;
812 }
813 return STATUS_SUCCESS;
814 }
815
816 /******************************************************************
817 * CDROM_ReadQChannel
818 *
819 *
820 */
821 static NTSTATUS CDROM_ReadQChannel(int dev, int fd, const CDROM_SUB_Q_DATA_FORMAT* fmt,
822 SUB_Q_CHANNEL_DATA* data)
823 {
824 NTSTATUS ret = STATUS_NOT_SUPPORTED;
825 #ifdef linux
826 unsigned size;
827 SUB_Q_HEADER* hdr = (SUB_Q_HEADER*)data;
828 int io;
829 struct cdrom_subchnl sc;
830 sc.cdsc_format = CDROM_MSF;
831
832 io = ioctl(fd, CDROMSUBCHNL, &sc);
833 if (io == -1)
834 {
835 TRACE("opened or no_media (%s)!\n", strerror(errno));
836 hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
837 CDROM_ClearCacheEntry(dev);
838 goto end;
839 }
840
841 hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
842
843 switch (sc.cdsc_audiostatus) {
844 case CDROM_AUDIO_INVALID:
845 CDROM_ClearCacheEntry(dev);
846 hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
847 break;
848 case CDROM_AUDIO_NO_STATUS:
849 CDROM_ClearCacheEntry(dev);
850 hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
851 break;
852 case CDROM_AUDIO_PLAY:
853 hdr->AudioStatus = AUDIO_STATUS_IN_PROGRESS;
854 break;
855 case CDROM_AUDIO_PAUSED:
856 hdr->AudioStatus = AUDIO_STATUS_PAUSED;
857 break;
858 case CDROM_AUDIO_COMPLETED:
859 hdr->AudioStatus = AUDIO_STATUS_PLAY_COMPLETE;
860 break;
861 case CDROM_AUDIO_ERROR:
862 hdr->AudioStatus = AUDIO_STATUS_PLAY_ERROR;
863 break;
864 default:
865 TRACE("status=%02X !\n", sc.cdsc_audiostatus);
866 break;
867 }
868 switch (fmt->Format)
869 {
870 case IOCTL_CDROM_CURRENT_POSITION:
871 size = sizeof(SUB_Q_CURRENT_POSITION);
872 RtlEnterCriticalSection( &cache_section );
873 if (hdr->AudioStatus==AUDIO_STATUS_IN_PROGRESS) {
874 data->CurrentPosition.FormatCode = IOCTL_CDROM_CURRENT_POSITION;
875 data->CurrentPosition.Control = sc.cdsc_ctrl;
876 data->CurrentPosition.ADR = sc.cdsc_adr;
877 data->CurrentPosition.TrackNumber = sc.cdsc_trk;
878 data->CurrentPosition.IndexNumber = sc.cdsc_ind;
879
880 data->CurrentPosition.AbsoluteAddress[0] = 0;
881 data->CurrentPosition.AbsoluteAddress[1] = sc.cdsc_absaddr.msf.minute;
882 data->CurrentPosition.AbsoluteAddress[2] = sc.cdsc_absaddr.msf.second;
883 data->CurrentPosition.AbsoluteAddress[3] = sc.cdsc_absaddr.msf.frame;
884
885 data->CurrentPosition.TrackRelativeAddress[0] = 0;
886 data->CurrentPosition.TrackRelativeAddress[1] = sc.cdsc_reladdr.msf.minute;
887 data->CurrentPosition.TrackRelativeAddress[2] = sc.cdsc_reladdr.msf.second;
888 data->CurrentPosition.TrackRelativeAddress[3] = sc.cdsc_reladdr.msf.frame;
889
890 cdrom_cache[dev].CurrentPosition = data->CurrentPosition;
891 }
892 else /* not playing */
893 {
894 cdrom_cache[dev].CurrentPosition.Header = *hdr; /* Preserve header info */
895 data->CurrentPosition = cdrom_cache[dev].CurrentPosition;
896 }
897 RtlLeaveCriticalSection( &cache_section );
898 break;
899 case IOCTL_CDROM_MEDIA_CATALOG:
900 size = sizeof(SUB_Q_MEDIA_CATALOG_NUMBER);
901 data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
902 {
903 struct cdrom_mcn mcn;
904 if ((io = ioctl(fd, CDROM_GET_MCN, &mcn)) == -1) goto end;
905
906 data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
907 data->MediaCatalog.Mcval = 0; /* FIXME */
908 memcpy(data->MediaCatalog.MediaCatalog, mcn.medium_catalog_number, 14);
909 data->MediaCatalog.MediaCatalog[14] = 0;
910 }
911 break;
912 case IOCTL_CDROM_TRACK_ISRC:
913 size = sizeof(SUB_Q_CURRENT_POSITION);
914 FIXME("TrackIsrc: NIY on linux\n");
915 data->TrackIsrc.FormatCode = IOCTL_CDROM_TRACK_ISRC;
916 data->TrackIsrc.Tcval = 0;
917 io = 0;
918 break;
919 }
920
921 end:
922 ret = CDROM_GetStatusCode(io);
923 #elif defined(__FreeBSD__) || defined(__NetBSD__)
924 unsigned size;
925 SUB_Q_HEADER* hdr = (SUB_Q_HEADER*)data;
926 int io;
927 struct ioc_read_subchannel read_sc;
928 struct cd_sub_channel_info sc;
929
930 read_sc.address_format = CD_MSF_FORMAT;
931 read_sc.track = 0;
932 read_sc.data_len = sizeof(sc);
933 read_sc.data = &sc;
934 switch (fmt->Format)
935 {
936 case IOCTL_CDROM_CURRENT_POSITION:
937 read_sc.data_format = CD_CURRENT_POSITION;
938 break;
939 case IOCTL_CDROM_MEDIA_CATALOG:
940 read_sc.data_format = CD_MEDIA_CATALOG;
941 break;
942 case IOCTL_CDROM_TRACK_ISRC:
943 read_sc.data_format = CD_TRACK_INFO;
944 sc.what.track_info.track_number = data->TrackIsrc.Track;
945 break;
946 }
947 io = ioctl(fd, CDIOCREADSUBCHANNEL, &read_sc);
948 if (io == -1)
949 {
950 TRACE("opened or no_media (%s)!\n", strerror(errno));
951 CDROM_ClearCacheEntry(dev);
952 hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
953 goto end;
954 }
955
956 hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
957
958 switch (sc.header.audio_status) {
959 case CD_AS_AUDIO_INVALID:
960 CDROM_ClearCacheEntry(dev);
961 hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
962 break;
963 case CD_AS_NO_STATUS:
964 CDROM_ClearCacheEntry(dev);
965 hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
966 break;
967 case CD_AS_PLAY_IN_PROGRESS:
968 hdr->AudioStatus = AUDIO_STATUS_IN_PROGRESS;
969 break;
970 case CD_AS_PLAY_PAUSED:
971 hdr->AudioStatus = AUDIO_STATUS_PAUSED;
972 break;
973 case CD_AS_PLAY_COMPLETED:
974 hdr->AudioStatus = AUDIO_STATUS_PLAY_COMPLETE;
975 break;
976 case CD_AS_PLAY_ERROR:
977 hdr->AudioStatus = AUDIO_STATUS_PLAY_ERROR;
978 break;
979 default:
980 TRACE("status=%02X !\n", sc.header.audio_status);
981 }
982 switch (fmt->Format)
983 {
984 case IOCTL_CDROM_CURRENT_POSITION:
985 size = sizeof(SUB_Q_CURRENT_POSITION);
986 RtlEnterCriticalSection( &cache_section );
987 if (hdr->AudioStatus==AUDIO_STATUS_IN_PROGRESS) {
988 data->CurrentPosition.FormatCode = IOCTL_CDROM_CURRENT_POSITION;
989 data->CurrentPosition.Control = sc.what.position.control;
990 data->CurrentPosition.ADR = sc.what.position.addr_type;
991 data->CurrentPosition.TrackNumber = sc.what.position.track_number;
992 data->CurrentPosition.IndexNumber = sc.what.position.index_number;
993
994 data->CurrentPosition.AbsoluteAddress[0] = 0;
995 data->CurrentPosition.AbsoluteAddress[1] = sc.what.position.absaddr.msf.minute;
996 data->CurrentPosition.AbsoluteAddress[2] = sc.what.position.absaddr.msf.second;
997 data->CurrentPosition.AbsoluteAddress[3] = sc.what.position.absaddr.msf.frame;
998 data->CurrentPosition.TrackRelativeAddress[0] = 0;
999 data->CurrentPosition.TrackRelativeAddress[1] = sc.what.position.reladdr.msf.minute;
1000 data->CurrentPosition.TrackRelativeAddress[2] = sc.what.position.reladdr.msf.second;
1001 data->CurrentPosition.TrackRelativeAddress[3] = sc.what.position.reladdr.msf.frame;
1002 cdrom_cache[dev].CurrentPosition = data->CurrentPosition;
1003 }
1004 else { /* not playing */
1005 cdrom_cache[dev].CurrentPosition.Header = *hdr; /* Preserve header info */
1006 data->CurrentPosition = cdrom_cache[dev].CurrentPosition;
1007 }
1008 RtlLeaveCriticalSection( &cache_section );
1009 break;
1010 case IOCTL_CDROM_MEDIA_CATALOG:
1011 size = sizeof(SUB_Q_MEDIA_CATALOG_NUMBER);
1012 data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
1013 data->MediaCatalog.Mcval = sc.what.media_catalog.mc_valid;
1014 memcpy(data->MediaCatalog.MediaCatalog, sc.what.media_catalog.mc_number, 15);
1015 break;
1016 case IOCTL_CDROM_TRACK_ISRC:
1017 size = sizeof(SUB_Q_CURRENT_POSITION);
1018 data->TrackIsrc.FormatCode = IOCTL_CDROM_TRACK_ISRC;
1019 data->TrackIsrc.Tcval = sc.what.track_info.ti_valid;
1020 memcpy(data->TrackIsrc.TrackIsrc, sc.what.track_info.ti_number, 15);
1021 break;
1022 }
1023
1024 end:
1025 ret = CDROM_GetStatusCode(io);
1026 #endif
1027 return ret;
1028 }
1029
1030 /******************************************************************
1031 * CDROM_Verify
1032 * Implements: IOCTL_STORAGE_CHECK_VERIFY
1033 * IOCTL_CDROM_CHECK_VERIFY
1034 * IOCTL_DISK_CHECK_VERIFY
1035 *
1036 */
1037 static NTSTATUS CDROM_Verify(int dev, int fd)
1038 {
1039 #if defined(linux)
1040 int ret;
1041
1042 ret = ioctl(fd, CDROM_DRIVE_STATUS, NULL);
1043 if(ret == -1) {
1044 TRACE("ioctl CDROM_DRIVE_STATUS failed(%s)!\n", strerror(errno));
1045 return CDROM_GetStatusCode(ret);
1046 }
1047
1048 if(ret == CDS_DISC_OK)
1049 return STATUS_SUCCESS;
1050 else
1051 return STATUS_NO_MEDIA_IN_DEVICE;
1052 #endif
1053 FIXME("not implemented for non-linux\n");
1054 return STATUS_NOT_SUPPORTED;
1055 }
1056
1057 /******************************************************************
1058 * CDROM_PlayAudioMSF
1059 *
1060 *
1061 */
1062 static NTSTATUS CDROM_PlayAudioMSF(int fd, const CDROM_PLAY_AUDIO_MSF* audio_msf)
1063 {
1064 NTSTATUS ret = STATUS_NOT_SUPPORTED;
1065 #ifdef linux
1066 struct cdrom_msf msf;
1067 int io;
1068
1069 msf.cdmsf_min0 = audio_msf->StartingM;
1070 msf.cdmsf_sec0 = audio_msf->StartingS;
1071 msf.cdmsf_frame0 = audio_msf->StartingF;
1072 msf.cdmsf_min1 = audio_msf->EndingM;
1073 msf.cdmsf_sec1 = audio_msf->EndingS;
1074 msf.cdmsf_frame1 = audio_msf->EndingF;
1075
1076 io = ioctl(fd, CDROMSTART);
1077 if (io == -1)
1078 {
1079 WARN("motor doesn't start !\n");
1080 goto end;
1081 }
1082 io = ioctl(fd, CDROMPLAYMSF, &msf);
1083 if (io == -1)
1084 {
1085 WARN("device doesn't play !\n");
1086 goto end;
1087 }
1088 TRACE("msf = %d:%d:%d %d:%d:%d\n",
1089 msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0,
1090 msf.cdmsf_min1, msf.cdmsf_sec1, msf.cdmsf_frame1);
1091 end:
1092 ret = CDROM_GetStatusCode(io);
1093 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1094 struct ioc_play_msf msf;
1095 int io;
1096
1097 msf.start_m = audio_msf->StartingM;
1098 msf.start_s = audio_msf->StartingS;
1099 msf.start_f = audio_msf->StartingF;
1100 msf.end_m = audio_msf->EndingM;
1101 msf.end_s = audio_msf->EndingS;
1102 msf.end_f = audio_msf->EndingF;
1103
1104 io = ioctl(fd, CDIOCSTART, NULL);
1105 if (io == -1)
1106 {
1107 WARN("motor doesn't start !\n");
1108 goto end;
1109 }
1110 io = ioctl(fd, CDIOCPLAYMSF, &msf);
1111 if (io == -1)
1112 {
1113 WARN("device doesn't play !\n");
1114 goto end;
1115 }
1116 TRACE("msf = %d:%d:%d %d:%d:%d\n",
1117 msf.start_m, msf.start_s, msf.start_f,
1118 msf.end_m, msf.end_s, msf.end_f);
1119 end:
1120 ret = CDROM_GetStatusCode(io);
1121 #endif
1122 return ret;
1123 }
1124
1125 /******************************************************************
1126 * CDROM_SeekAudioMSF
1127 *
1128 *
1129 */
1130 static NTSTATUS CDROM_SeekAudioMSF(int dev, int fd, const CDROM_SEEK_AUDIO_MSF* audio_msf)
1131 {
1132 CDROM_TOC toc;
1133 int i, io, frame;
1134 SUB_Q_CURRENT_POSITION *cp;
1135 #if defined(linux)
1136 struct cdrom_msf0 msf;
1137 struct cdrom_subchnl sc;
1138 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1139 struct ioc_play_msf msf;
1140 struct ioc_read_subchannel read_sc;
1141 struct cd_sub_channel_info sc;
1142 int final_frame;
1143 #endif
1144
1145 /* Use the information on the TOC to compute the new current
1146 * position, which is shadowed on the cache. [Portable]. */
1147 frame = FRAME_OF_MSF(*audio_msf);
1148
1149 if ((io = CDROM_ReadTOC(dev, fd, &toc)) != 0) return io;
1150
1151 for(i=toc.FirstTrack;i<=toc.LastTrack+1;i++)
1152 if (FRAME_OF_TOC(toc,i)>frame) break;
1153 if (i <= toc.FirstTrack || i > toc.LastTrack+1)
1154 return STATUS_INVALID_PARAMETER;
1155 i--;
1156 RtlEnterCriticalSection( &cache_section );
1157 cp = &cdrom_cache[dev].CurrentPosition;
1158 cp->FormatCode = IOCTL_CDROM_CURRENT_POSITION;
1159 cp->Control = toc.TrackData[i-toc.FirstTrack].Control;
1160 cp->ADR = toc.TrackData[i-toc.FirstTrack].Adr;
1161 cp->TrackNumber = toc.TrackData[i-toc.FirstTrack].TrackNumber;
1162 cp->IndexNumber = 0; /* FIXME: where do they keep these? */
1163 cp->AbsoluteAddress[0] = 0;
1164 cp->AbsoluteAddress[1] = toc.TrackData[i-toc.FirstTrack].Address[1];
1165 cp->AbsoluteAddress[2] = toc.TrackData[i-toc.FirstTrack].Address[2];
1166 cp->AbsoluteAddress[3] = toc.TrackData[i-toc.FirstTrack].Address[3];
1167 frame -= FRAME_OF_TOC(toc,i);
1168 cp->TrackRelativeAddress[0] = 0;
1169 MSF_OF_FRAME(cp->TrackRelativeAddress[1], frame);
1170 RtlLeaveCriticalSection( &cache_section );
1171
1172 /* If playing, then issue a seek command, otherwise do nothing */
1173 #ifdef linux
1174 sc.cdsc_format = CDROM_MSF;
1175
1176 io = ioctl(fd, CDROMSUBCHNL, &sc);
1177 if (io == -1)
1178 {
1179 TRACE("opened or no_media (%s)!\n", strerror(errno));
1180 CDROM_ClearCacheEntry(dev);
1181 return CDROM_GetStatusCode(io);
1182 }
1183 if (sc.cdsc_audiostatus==CDROM_AUDIO_PLAY)
1184 {
1185 msf.minute = audio_msf->M;
1186 msf.second = audio_msf->S;
1187 msf.frame = audio_msf->F;
1188 return CDROM_GetStatusCode(ioctl(fd, CDROMSEEK, &msf));
1189 }
1190 return STATUS_SUCCESS;
1191 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1192 read_sc.address_format = CD_MSF_FORMAT;
1193 read_sc.track = 0;
1194 read_sc.data_len = sizeof(sc);
1195 read_sc.data = &sc;
1196 read_sc.data_format = CD_CURRENT_POSITION;
1197
1198 io = ioctl(fd, CDIOCREADSUBCHANNEL, &read_sc);
1199 if (io == -1)
1200 {
1201 TRACE("opened or no_media (%s)!\n", strerror(errno));
1202 CDROM_ClearCacheEntry(dev);
1203 return CDROM_GetStatusCode(io);
1204 }
1205 if (sc.header.audio_status==CD_AS_PLAY_IN_PROGRESS)
1206 {
1207
1208 msf.start_m = audio_msf->M;
1209 msf.start_s = audio_msf->S;
1210 msf.start_f = audio_msf->F;
1211 final_frame = FRAME_OF_TOC(toc,toc.LastTrack+1)-1;
1212 MSF_OF_FRAME(msf.end_m, final_frame);
1213
1214 return CDROM_GetStatusCode(ioctl(fd, CDIOCPLAYMSF, &msf));
1215 }
1216 return STATUS_SUCCESS;
1217 #else
1218 return STATUS_NOT_SUPPORTED;
1219 #endif
1220 }
1221
1222 /******************************************************************
1223 * CDROM_PauseAudio
1224 *
1225 *
1226 */
1227 static NTSTATUS CDROM_PauseAudio(int fd)
1228 {
1229 #if defined(linux)
1230 return CDROM_GetStatusCode(ioctl(fd, CDROMPAUSE));
1231 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1232 return CDROM_GetStatusCode(ioctl(fd, CDIOCPAUSE, NULL));
1233 #else
1234 return STATUS_NOT_SUPPORTED;
1235 #endif
1236 }
1237
1238 /******************************************************************
1239 * CDROM_ResumeAudio
1240 *
1241 *
1242 */
1243 static NTSTATUS CDROM_ResumeAudio(int fd)
1244 {
1245 #if defined(linux)
1246 return CDROM_GetStatusCode(ioctl(fd, CDROMRESUME));
1247 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1248 return CDROM_GetStatusCode(ioctl(fd, CDIOCRESUME, NULL));
1249 #else
1250 return STATUS_NOT_SUPPORTED;
1251 #endif
1252 }
1253
1254 /******************************************************************
1255 * CDROM_StopAudio
1256 *
1257 *
1258 */
1259 static NTSTATUS CDROM_StopAudio(int fd)
1260 {
1261 #if defined(linux)
1262 return CDROM_GetStatusCode(ioctl(fd, CDROMSTOP));
1263 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1264 return CDROM_GetStatusCode(ioctl(fd, CDIOCSTOP, NULL));
1265 #else
1266 return STATUS_NOT_SUPPORTED;
1267 #endif
1268 }
1269
1270 /******************************************************************
1271 * CDROM_GetVolume
1272 *
1273 *
1274 */
1275 static NTSTATUS CDROM_GetVolume(int fd, VOLUME_CONTROL* vc)
1276 {
1277 #if defined(linux)
1278 struct cdrom_volctrl volc;
1279 int io;
1280
1281 io = ioctl(fd, CDROMVOLREAD, &volc);
1282 if (io != -1)
1283 {
1284 vc->PortVolume[0] = volc.channel0;
1285 vc->PortVolume[1] = volc.channel1;
1286 vc->PortVolume[2] = volc.channel2;
1287 vc->PortVolume[3] = volc.channel3;
1288 }
1289 return CDROM_GetStatusCode(io);
1290 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1291 struct ioc_vol volc;
1292 int io;
1293
1294 io = ioctl(fd, CDIOCGETVOL, &volc);
1295 if (io != -1)
1296 {
1297 vc->PortVolume[0] = volc.vol[0];
1298 vc->PortVolume[1] = volc.vol[1];
1299 vc->PortVolume[2] = volc.vol[2];
1300 vc->PortVolume[3] = volc.vol[3];
1301 }
1302 return CDROM_GetStatusCode(io);
1303 #else
1304 return STATUS_NOT_SUPPORTED;
1305 #endif
1306 }
1307
1308 /******************************************************************
1309 * CDROM_SetVolume
1310 *
1311 *
1312 */
1313 static NTSTATUS CDROM_SetVolume(int fd, const VOLUME_CONTROL* vc)
1314 {
1315 #if defined(linux)
1316 struct cdrom_volctrl volc;
1317
1318 volc.channel0 = vc->PortVolume[0];
1319 volc.channel1 = vc->PortVolume[1];
1320 volc.channel2 = vc->PortVolume[2];
1321 volc.channel3 = vc->PortVolume[3];
1322
1323 return CDROM_GetStatusCode(ioctl(fd, CDROMVOLCTRL, &volc));
1324 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1325 struct ioc_vol volc;
1326
1327 volc.vol[0] = vc->PortVolume[0];
1328 volc.vol[1] = vc->PortVolume[1];
1329 volc.vol[2] = vc->PortVolume[2];
1330 volc.vol[3] = vc->PortVolume[3];
1331
1332 return CDROM_GetStatusCode(ioctl(fd, CDIOCSETVOL, &volc));
1333 #else
1334 return STATUS_NOT_SUPPORTED;
1335 #endif
1336 }
1337
1338 /******************************************************************
1339 * CDROM_RawRead
1340 *
1341 *
1342 */
1343 static NTSTATUS CDROM_RawRead(int fd, const RAW_READ_INFO* raw, void* buffer, DWORD len, DWORD* sz)
1344 {
1345 int ret = STATUS_NOT_SUPPORTED;
1346 int io = -1;
1347 DWORD sectSize;
1348
1349 TRACE("RAW_READ_INFO: DiskOffset=%li,%li SectorCount=%li TrackMode=%i\n buffer=%p len=%li sz=%p\n",
1350 raw->DiskOffset.u.HighPart, raw->DiskOffset.u.LowPart, raw->SectorCount, raw->TrackMode, buffer, len, sz);
1351
1352 switch (raw->TrackMode)
1353 {
1354 case YellowMode2: sectSize = 2336; break;
1355 case XAForm2: sectSize = 2328; break;
1356 case CDDA: sectSize = 2352; break;
1357 default: return STATUS_INVALID_PARAMETER;
1358 }
1359 if (len < raw->SectorCount * sectSize) return STATUS_BUFFER_TOO_SMALL;
1360 /* strangely enough, it seems that sector offsets are always indicated with a size of 2048,
1361 * even if a larger size if read...
1362 */
1363 #if defined(linux)
1364 {
1365 struct cdrom_read_audio cdra;
1366 struct cdrom_msf* msf;
1367 int i;
1368 LONGLONG t = ((LONGLONG)raw->DiskOffset.u.HighPart << 32) +
1369 raw->DiskOffset.u.LowPart + CD_MSF_OFFSET;
1370
1371 switch (raw->TrackMode)
1372 {
1373 case YellowMode2:
1374 /* Linux reads only one sector at a time.
1375 * ioctl CDROMREADMODE2 takes struct cdrom_msf as an argument
1376 * on the contrary to what header comments state.
1377 */
1378 for (i = 0; i < raw->SectorCount; i++, t += sectSize)
1379 {
1380 msf = (struct cdrom_msf*)buffer + i * sectSize;
1381 msf->cdmsf_min0 = t / CD_FRAMES / CD_SECS;
1382 msf->cdmsf_sec0 = t / CD_FRAMES % CD_SECS;
1383 msf->cdmsf_frame0 = t % CD_FRAMES;
1384 io = ioctl(fd, CDROMREADMODE2, msf);
1385 if (io != 0)
1386 {
1387 *sz = sectSize * i;
1388 return CDROM_GetStatusCode(io);
1389 }
1390 }
1391 break;
1392 case XAForm2:
1393 FIXME("XAForm2: NIY\n");
1394 return ret;
1395 case CDDA:
1396 /* FIXME: the output doesn't seem 100% correct... in fact output is shifted
1397 * between by NT2K box and this... should check on the same drive...
1398 * otherwise, I fear a 2352/2368 mismatch somewhere in one of the drivers
1399 * (linux/NT).
1400 * Anyway, that's not critical at all. We're talking of 16/32 bytes, we're
1401 * talking of 0.2 ms of sound
1402 */
1403 /* 2048 = 2 ** 11 */
1404 if (raw->DiskOffset.u.HighPart & ~2047) FIXME("Unsupported value\n");
1405 cdra.addr.lba = ((raw->DiskOffset.u.LowPart >> 11) |
1406 (raw->DiskOffset.u.HighPart << (32 - 11))) - 1;
1407 FIXME("reading at %u\n", cdra.addr.lba);
1408 cdra.addr_format = CDROM_LBA;
1409 cdra.nframes = raw->SectorCount;
1410 cdra.buf = buffer;
1411 io = ioctl(fd, CDROMREADAUDIO, &cdra);
1412 break;
1413 default:
1414 FIXME("NIY: %d\n", raw->TrackMode);
1415 return ret;
1416 }
1417 }
1418 #else
1419 {
1420 switch (raw->TrackMode)
1421 {
1422 case YellowMode2:
1423 FIXME("YellowMode2: NIY\n");
1424 return ret;
1425 case XAForm2:
1426 FIXME("XAForm2: NIY\n");
1427 return ret;
1428 case CDDA:
1429 FIXME("CDDA: NIY\n");
1430 return ret;
1431 }
1432 }
1433 #endif
1434
1435 *sz = sectSize * raw->SectorCount;
1436 ret = CDROM_GetStatusCode(io);
1437 return ret;
1438 }
1439
1440 /******************************************************************
1441 * CDROM_ScsiPassThroughDirect
1442 * Implements IOCTL_SCSI_PASS_THROUGH_DIRECT
1443 *
1444 */
1445 static NTSTATUS CDROM_ScsiPassThroughDirect(int fd, PSCSI_PASS_THROUGH_DIRECT pPacket)
1446 {
1447 int ret = STATUS_NOT_SUPPORTED;
1448 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1449 sg_io_hdr_t cmd;
1450 int io;
1451 #elif defined HAVE_SCSIREQ_T_CMD
1452 scsireq_t cmd;
1453 int io;
1454 #endif
1455
1456 if (pPacket->Length < sizeof(SCSI_PASS_THROUGH_DIRECT))
1457 return STATUS_BUFFER_TOO_SMALL;
1458
1459 if (pPacket->CdbLength > 16)
1460 return STATUS_INVALID_PARAMETER;
1461
1462 #ifdef SENSEBUFLEN
1463 if (pPacket->SenseInfoLength > SENSEBUFLEN)
1464 return STATUS_INVALID_PARAMETER;
1465 #elif defined HAVE_REQUEST_SENSE
1466 if (pPacket->SenseInfoLength > sizeof(struct request_sense))
1467 return STATUS_INVALID_PARAMETER;
1468 #endif
1469
1470 if (pPacket->DataTransferLength > 0 && !pPacket->DataBuffer)
1471 return STATUS_INVALID_PARAMETER;
1472
1473 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1474 RtlZeroMemory(&cmd, sizeof(cmd));
1475
1476 cmd.interface_id = 'S';
1477 cmd.cmd_len = pPacket->CdbLength;
1478 cmd.mx_sb_len = pPacket->SenseInfoLength;
1479 cmd.dxfer_len = pPacket->DataTransferLength;
1480 cmd.dxferp = pPacket->DataBuffer;
1481 cmd.cmdp = pPacket->Cdb;
1482 cmd.sbp = (unsigned char*)pPacket + pPacket->SenseInfoOffset;
1483 cmd.timeout = pPacket->TimeOutValue*1000;
1484
1485 switch (pPacket->DataIn)
1486 {
1487 case SCSI_IOCTL_DATA_IN:
1488 cmd.dxfer_direction = SG_DXFER_FROM_DEV;
1489 break;
1490 case SCSI_IOCTL_DATA_OUT:
1491 cmd.dxfer_direction = SG_DXFER_TO_DEV;
1492 break;
1493 case SCSI_IOCTL_DATA_UNSPECIFIED:
1494 cmd.dxfer_direction = SG_DXFER_NONE;
1495 break;
1496 default:
1497 return STATUS_INVALID_PARAMETER;
1498 }
1499
1500 io = ioctl(fd, SG_IO, &cmd);
1501
1502 pPacket->ScsiStatus = cmd.status;
1503 pPacket->DataTransferLength = cmd.resid;
1504 pPacket->SenseInfoLength = cmd.sb_len_wr;
1505
1506 ret = CDROM_GetStatusCode(io);
1507
1508 #elif defined HAVE_SCSIREQ_T_CMD
1509
1510 memset(&cmd, 0, sizeof(cmd));
1511 memcpy(&(cmd.cmd), &(pPacket->Cdb), pPacket->CdbLength);
1512
1513 cmd.cmdlen = pPacket->CdbLength;
1514 cmd.databuf = pPacket->DataBuffer;
1515 cmd.datalen = pPacket->DataTransferLength;
1516 cmd.senselen = pPacket->SenseInfoLength;
1517 cmd.timeout = pPacket->TimeOutValue*1000; /* in milliseconds */
1518
1519 switch (pPacket->DataIn)
1520 {
1521 case SCSI_IOCTL_DATA_OUT:
1522 cmd.flags |= SCCMD_WRITE;
1523 break;
1524 case SCSI_IOCTL_DATA_IN:
1525 cmd.flags |= SCCMD_READ;
1526 break;
1527 case SCSI_IOCTL_DATA_UNSPECIFIED:
1528 cmd.flags = 0;
1529 break;
1530 default:
1531 return STATUS_INVALID_PARAMETER;
1532 }
1533
1534 io = ioctl(fd, SCIOCCOMMAND, &cmd);
1535
1536 switch (cmd.retsts)
1537 {
1538 case SCCMD_OK: break;
1539 case SCCMD_TIMEOUT: return STATUS_TIMEOUT;
1540 break;
1541 case SCCMD_BUSY: return STATUS_DEVICE_BUSY;
1542 break;
1543 case SCCMD_SENSE: break;
1544 case SCCMD_UNKNOWN: return STATUS_UNSUCCESSFUL;
1545 break;
1546 }
1547
1548 if (pPacket->SenseInfoLength != 0)
1549 {
1550 memcpy((char*)pPacket + pPacket->SenseInfoOffset,
1551 cmd.sense, pPacket->SenseInfoLength);
1552 }
1553
1554 pPacket->ScsiStatus = cmd.status;
1555
1556 ret = CDROM_GetStatusCode(io);
1557 #endif
1558 return ret;
1559 }
1560
1561 /******************************************************************
1562 * CDROM_ScsiPassThrough
1563 * Implements IOCTL_SCSI_PASS_THROUGH
1564 *
1565 */
1566 static NTSTATUS CDROM_ScsiPassThrough(int fd, PSCSI_PASS_THROUGH pPacket)
1567 {
1568 int ret = STATUS_NOT_SUPPORTED;
1569 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1570 sg_io_hdr_t cmd;
1571 int io;
1572 #elif defined HAVE_SCSIREQ_T_CMD
1573 scsireq_t cmd;
1574 int io;
1575 #endif
1576
1577 if (pPacket->Length < sizeof(SCSI_PASS_THROUGH))
1578 return STATUS_BUFFER_TOO_SMALL;
1579
1580 if (pPacket->CdbLength > 16)
1581 return STATUS_INVALID_PARAMETER;
1582
1583 #ifdef SENSEBUFLEN
1584 if (pPacket->SenseInfoLength > SENSEBUFLEN)
1585 return STATUS_INVALID_PARAMETER;
1586 #elif defined HAVE_REQUEST_SENSE
1587 if (pPacket->SenseInfoLength > sizeof(struct request_sense))
1588 return STATUS_INVALID_PARAMETER;
1589 #endif
1590
1591 if (pPacket->DataTransferLength > 0 && pPacket->DataBufferOffset < sizeof(SCSI_PASS_THROUGH))
1592 return STATUS_INVALID_PARAMETER;
1593
1594 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1595 RtlZeroMemory(&cmd, sizeof(cmd));
1596
1597 cmd.interface_id = 'S';
1598 cmd.dxfer_len = pPacket->DataTransferLength;
1599 cmd.dxferp = (char*)pPacket + pPacket->DataBufferOffset;
1600 cmd.cmd_len = pPacket->CdbLength;
1601 cmd.cmdp = pPacket->Cdb;
1602 cmd.mx_sb_len = pPacket->SenseInfoLength;
1603 cmd.timeout = pPacket->TimeOutValue*1000;
1604
1605 if(cmd.mx_sb_len > 0)
1606 cmd.sbp = (unsigned char*)pPacket + pPacket->SenseInfoOffset;
1607
1608 switch (pPacket->DataIn)
1609 {
1610 case SCSI_IOCTL_DATA_IN:
1611 cmd.dxfer_direction = SG_DXFER_FROM_DEV;
1612 break;
1613 case SCSI_IOCTL_DATA_OUT:
1614 cmd.dxfer_direction = SG_DXFER_TO_DEV;
1615 break;
1616 case SCSI_IOCTL_DATA_UNSPECIFIED:
1617 cmd.dxfer_direction = SG_DXFER_NONE;
1618 break;
1619 default:
1620 return STATUS_INVALID_PARAMETER;
1621 }
1622
1623 io = ioctl(fd, SG_IO, &cmd);
1624
1625 pPacket->ScsiStatus = cmd.status;
1626 pPacket->DataTransferLength = cmd.resid;
1627 pPacket->SenseInfoLength = cmd.sb_len_wr;
1628
1629 ret = CDROM_GetStatusCode(io);
1630
1631 #elif defined HAVE_SCSIREQ_T_CMD
1632
1633 memset(&cmd, 0, sizeof(cmd));
1634 memcpy(&(cmd.cmd), &(pPacket->Cdb), pPacket->CdbLength);
1635
1636 if ( pPacket->DataBufferOffset > 0x1000 )
1637 {
1638 cmd.databuf = (void*)pPacket->DataBufferOffset;
1639 }
1640 else
1641 {
1642 cmd.databuf = (char*)pPacket + pPacket->DataBufferOffset;
1643 }
1644
1645 cmd.cmdlen = pPacket->CdbLength;
1646 cmd.datalen = pPacket->DataTransferLength;
1647 cmd.senselen = pPacket->SenseInfoLength;
1648 cmd.timeout = pPacket->TimeOutValue*1000; /* in milliseconds */
1649
1650 switch (pPacket->DataIn)
1651 {
1652 case SCSI_IOCTL_DATA_OUT:
1653 cmd.flags |= SCCMD_WRITE;
1654 break;
1655 case SCSI_IOCTL_DATA_IN:
1656 cmd.flags |= SCCMD_READ;
1657 break;
1658 case SCSI_IOCTL_DATA_UNSPECIFIED:
1659 cmd.flags = 0;
1660 break;
1661 default:
1662 return STATUS_INVALID_PARAMETER;
1663 }
1664
1665 io = ioctl(fd, SCIOCCOMMAND, &cmd);
1666
1667 switch (cmd.retsts)
1668 {
1669 case SCCMD_OK: break;
1670 case SCCMD_TIMEOUT: return STATUS_TIMEOUT;
1671 break;
1672 case SCCMD_BUSY: return STATUS_DEVICE_BUSY;
1673 break;
1674 case SCCMD_SENSE: break;
1675 case SCCMD_UNKNOWN: return STATUS_UNSUCCESSFUL;
1676 break;
1677 }
1678
1679 if (pPacket->SenseInfoLength != 0)
1680 {
1681 memcpy((char*)pPacket + pPacket->SenseInfoOffset,
1682 cmd.sense, pPacket->SenseInfoLength);
1683 }
1684
1685 pPacket->ScsiStatus = cmd.status;
1686
1687 ret = CDROM_GetStatusCode(io);
1688 #endif
1689 return ret;
1690 }
1691
1692 /******************************************************************
1693 * CDROM_ScsiGetCaps
1694 *
1695 *
1696 */
1697 static NTSTATUS CDROM_ScsiGetCaps(PIO_SCSI_CAPABILITIES caps)
1698 {
1699 NTSTATUS ret = STATUS_NOT_IMPLEMENTED;
1700
1701 caps->Length = sizeof(*caps);
1702 #ifdef SG_SCATTER_SZ
1703 caps->MaximumTransferLength = SG_SCATTER_SZ; /* FIXME */
1704 caps->MaximumPhysicalPages = SG_SCATTER_SZ / getpagesize();
1705 caps->SupportedAsynchronousEvents = TRUE;
1706 caps->AlignmentMask = getpagesize();
1707 caps->TaggedQueuing = FALSE; /* we could check that it works and answer TRUE */
1708 caps->AdapterScansDown = FALSE; /* FIXME ? */
1709 caps->AdapterUsesPio = FALSE; /* FIXME ? */
1710 ret = STATUS_SUCCESS;
1711 #else
1712 FIXME("Unimplemented\n");
1713 #endif
1714 return ret;
1715 }
1716
1717 /******************************************************************
1718 * CDROM_GetAddress
1719 *
1720 * implements IOCTL_SCSI_GET_ADDRESS
1721 */
1722 static NTSTATUS CDROM_GetAddress(int fd, SCSI_ADDRESS* address)
1723 {
1724 UCHAR portnum, busid, targetid, lun;
1725
1726 address->Length = sizeof(SCSI_ADDRESS);
1727 if ( ! CDROM_GetInterfaceInfo(fd, &portnum, &busid, &targetid, &lun))
1728 return STATUS_NOT_SUPPORTED;
1729
1730 address->PortNumber = portnum; /* primary=0 secondary=1 for ide */
1731 address->PathId = busid; /* always 0 for ide */
1732 address->TargetId = targetid; /* master=0 slave=1 for ide */
1733 address->Lun = lun;
1734 return STATUS_SUCCESS;
1735 }
1736
1737 /******************************************************************
1738 * DVD_StartSession
1739 *
1740 *
1741 */
1742 static NTSTATUS DVD_StartSession(int fd, PDVD_SESSION_ID sid_in, PDVD_SESSION_ID sid_out)
1743 {
1744 #if defined(linux)
1745 NTSTATUS ret = STATUS_NOT_SUPPORTED;
1746 dvd_authinfo auth_info;
1747
1748 memset( &auth_info, 0, sizeof( auth_info ) );
1749 auth_info.type = DVD_LU_SEND_AGID;
1750 if (sid_in) auth_info.lsa.agid = *(int*)sid_in; /* ?*/
1751
1752 TRACE("fd 0x%08x\n",fd);
1753 ret =CDROM_GetStatusCode(ioctl(fd, DVD_AUTH, &auth_info));
1754 *sid_out = auth_info.lsa.agid;
1755 return ret;
1756 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1757 return STATUS_NOT_SUPPORTED;
1758 #else
1759 return STATUS_NOT_SUPPORTED;
1760 #endif
1761 }
1762
1763 /******************************************************************
1764 * DVD_EndSession
1765 *
1766 *
1767 */
1768 static NTSTATUS DVD_EndSession(int fd, PDVD_SESSION_ID sid)
1769 {
1770 #if defined(linux)
1771 dvd_authinfo auth_info;
1772
1773 memset( &auth_info, 0, sizeof( auth_info ) );
1774 auth_info.type = DVD_INVALIDATE_AGID;
1775 auth_info.lsa.agid = *(int*)sid;
1776
1777 TRACE("\n");
1778 return CDROM_GetStatusCode(ioctl(fd, DVD_AUTH, &auth_info));
1779 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1780 return STATUS_NOT_SUPPORTED;
1781 #else
1782 return STATUS_NOT_SUPPORTED;
1783 #endif
1784 }
1785
1786 /******************************************************************
1787 * DVD_SendKey
1788 *
1789 *
1790 */
1791 static NTSTATUS DVD_SendKey(int fd, PDVD_COPY_PROTECT_KEY key)
1792 {
1793 #if defined(linux)
1794 NTSTATUS ret = STATUS_NOT_SUPPORTED;
1795 dvd_authinfo auth_info;
1796
1797 memset( &auth_info, 0, sizeof( auth_info ) );
1798 switch (key->KeyType)
1799 {
1800 case DvdChallengeKey:
1801 auth_info.type = DVD_HOST_SEND_CHALLENGE;
1802 auth_info.hsc.agid = (int)key->SessionId;
1803 TRACE("DvdChallengeKey ioc 0x%x\n", DVD_AUTH );
1804 memcpy( auth_info.hsc.chal, key->KeyData, DVD_CHALLENGE_SIZE );
1805 ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
1806 break;
1807 case DvdBusKey2:
1808 auth_info.type = DVD_HOST_SEND_KEY2;
1809 auth_info.hsk.agid = (int)key->SessionId;
1810
1811 memcpy( auth_info.hsk.key, key->KeyData, DVD_KEY_SIZE );
1812
1813 TRACE("DvdBusKey2\n");
1814 ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
1815 break;
1816
1817 default:
1818 FIXME("Unknown Keytype 0x%x\n",key->KeyType);
1819 }
1820 return ret;
1821 #else
1822 FIXME("unsupported on this platform\n");
1823 return STATUS_NOT_SUPPORTED;
1824 #endif
1825 }
1826
1827 /******************************************************************
1828 * DVD_ReadKey
1829 *
1830 *
1831 */
1832 static NTSTATUS DVD_ReadKey(int fd, PDVD_COPY_PROTECT_KEY key)
1833 {
1834 #if defined(linux)
1835 NTSTATUS ret = STATUS_NOT_SUPPORTED;
1836 dvd_struct dvd;
1837 dvd_authinfo auth_info;
1838
1839 memset( &dvd, 0, sizeof( dvd_struct ) );
1840 memset( &auth_info, 0, sizeof( auth_info ) );
1841 switch (key->KeyType)
1842 {
1843 case DvdDiskKey:
1844
1845 dvd.type = DVD_STRUCT_DISCKEY;
1846 dvd.disckey.agid = (int)key->SessionId;
1847 memset( dvd.disckey.value, 0, DVD_DISCKEY_SIZE );
1848
1849 TRACE("DvdDiskKey\n");
1850 ret = CDROM_GetStatusCode(ioctl( fd, DVD_READ_STRUCT, &dvd ));
1851 if (ret == STATUS_SUCCESS)
1852 memcpy(key->KeyData,dvd.disckey.value,DVD_DISCKEY_SIZE);
1853 break;
1854 case DvdTitleKey:
1855 auth_info.type = DVD_LU_SEND_TITLE_KEY;
1856 auth_info.lstk.agid = (int)key->SessionId;
1857 auth_info.lstk.lba = (int)(key->Parameters.TitleOffset.QuadPart>>11);
1858 TRACE("DvdTitleKey session %d Quadpart 0x%08lx offset 0x%08x\n",
1859 (int)key->SessionId, (long)key->Parameters.TitleOffset.QuadPart,
1860 auth_info.lstk.lba);
1861 ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
1862 if (ret == STATUS_SUCCESS)
1863 memcpy(key->KeyData, auth_info.lstk.title_key, DVD_KEY_SIZE );
1864 break;
1865 case DvdChallengeKey:
1866
1867 auth_info.type = DVD_LU_SEND_CHALLENGE;
1868 auth_info.lsc.agid = (int)key->SessionId;
1869
1870 TRACE("DvdChallengeKey\n");
1871 ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
1872 if (ret == STATUS_SUCCESS)
1873 memcpy( key->KeyData, auth_info.lsc.chal, DVD_CHALLENGE_SIZE );
1874 break;
1875 case DvdAsf:
1876 auth_info.type = DVD_LU_SEND_ASF;
1877 TRACE("DvdAsf\n");
1878 auth_info.lsasf.asf=((PDVD_ASF)key->KeyData)->SuccessFlag;
1879 ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
1880 ((PDVD_ASF)key->KeyData)->SuccessFlag = auth_info.lsasf.asf;
1881 break;
1882 case DvdBusKey1:
1883 auth_info.type = DVD_LU_SEND_KEY1;
1884 auth_info.lsk.agid = (int)key->SessionId;
1885
1886 TRACE("DvdBusKey1\n");
1887 ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
1888
1889 if (ret == STATUS_SUCCESS)
1890 memcpy( key->KeyData, auth_info.lsk.key, DVD_KEY_SIZE );
1891 break;
1892 case DvdGetRpcKey:
1893 auth_info.type = DVD_LU_SEND_RPC_STATE;
1894
1895 TRACE("DvdGetRpcKey\n");
1896 ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
1897
1898 if (ret == STATUS_SUCCESS)
1899 {
1900 ((PDVD_RPC_KEY)key->KeyData)->TypeCode = auth_info.lrpcs.type;
1901 ((PDVD_RPC_KEY)key->KeyData)->RegionMask = auth_info.lrpcs.region_mask;
1902 ((PDVD_RPC_KEY)key->KeyData)->RpcScheme = auth_info.lrpcs.rpc_scheme;
1903 }
1904 break;
1905 default:
1906 FIXME("Unknown keytype 0x%x\n",key->KeyType);
1907 }
1908 return ret;
1909 #elif defined(__FreeBSD__) || defined(__NetBSD__)
1910 TRACE("bsd\n");
1911 return STATUS_NOT_SUPPORTED;
1912 #else
1913 TRACE("outside\n");
1914 return STATUS_NOT_SUPPORTED;
1915 #endif
1916 }
1917
1918 /******************************************************************
1919 * DVD_GetRegion
1920 *
1921 *
1922 */
1923 static NTSTATUS DVD_GetRegion(int dev, PDVD_REGION region)
1924 {
1925 FIXME("\n");
1926 return STATUS_SUCCESS;
1927
1928 }
1929
1930 /******************************************************************
1931 * DVD_GetRegion
1932 *
1933 *
1934 */
1935 static NTSTATUS DVD_ReadStructure(int dev, PDVD_READ_STRUCTURE structure, PDVD_LAYER_DESCRIPTOR layer)
1936 {
1937 FIXME("\n");
1938 return STATUS_SUCCESS;
1939
1940 }
1941
1942 /******************************************************************
1943 * GetInquiryData
1944 * Implements the IOCTL_GET_INQUIRY_DATA ioctl.
1945 * Returns Inquiry data for all devices on the specified scsi bus
1946 * Returns STATUS_BUFFER_TOO_SMALL if the output buffer is too small,
1947 * STATUS_INVALID_DEVICE_REQUEST if the given handle isn't to a SCSI device,
1948 * or STATUS_NOT_SUPPORTED if the OS driver is too old
1949 */
1950 static NTSTATUS GetInquiryData(int fd, PSCSI_ADAPTER_BUS_INFO BufferOut, DWORD OutBufferSize)
1951 {
1952 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1953 PSCSI_INQUIRY_DATA pInquiryData = NULL;
1954 UCHAR sense_buffer[32];
1955 int iochk, version;
1956 sg_io_hdr_t iocmd;
1957 UCHAR inquiry[INQ_CMD_LEN] = {INQUIRY, 0, 0, 0, INQ_REPLY_LEN, 0};
1958
1959 /* Check we have a SCSI device and a supported driver */
1960 if(ioctl(fd, SG_GET_VERSION_NUM, &version) != 0)
1961 {
1962 WARN("IOCTL_SCSI_GET_INQUIRY_DATA sg driver is not loaded\n");
1963 return STATUS_INVALID_DEVICE_REQUEST;
1964 }
1965 if(version < 30000 )
1966 return STATUS_NOT_SUPPORTED;
1967
1968 /* FIXME: Enumerate devices on the bus */
1969 BufferOut->NumberOfBuses = 1;
1970 BufferOut->BusData[0].NumberOfLogicalUnits = 1;
1971 BufferOut->BusData[0].InquiryDataOffset = sizeof(SCSI_ADAPTER_BUS_INFO);
1972
1973 pInquiryData = (PSCSI_INQUIRY_DATA)(BufferOut + 1);
1974
1975 RtlZeroMemory(&iocmd, sizeof(iocmd));
1976 iocmd.interface_id = 'S';
1977 iocmd.cmd_len = sizeof(inquiry);
1978 iocmd.mx_sb_len = sizeof(sense_buffer);
1979 iocmd.dxfer_direction = SG_DXFER_FROM_DEV;
1980 iocmd.dxfer_len = INQ_REPLY_LEN;
1981 iocmd.dxferp = pInquiryData->InquiryData;
1982 iocmd.cmdp = inquiry;
1983 iocmd.sbp = sense_buffer;
1984 iocmd.timeout = 1000;
1985
1986 iochk = ioctl(fd, SG_IO, &iocmd);
1987 if(iochk != 0)
1988 WARN("ioctl SG_IO returned %d, error (%s)\n", iochk, strerror(errno));
1989
1990 CDROM_GetInterfaceInfo(fd, &BufferOut->BusData[0].InitiatorBusId, &pInquiryData->PathId, &pInquiryData->TargetId, &pInquiryData->Lun);
1991 pInquiryData->DeviceClaimed = TRUE;
1992 pInquiryData->InquiryDataLength = INQ_REPLY_LEN;
1993 pInquiryData->NextInquiryDataOffset = 0;
1994 return STATUS_SUCCESS;
1995 #else
1996 FIXME("not implemented for nonlinux\n");
1997 return STATUS_NOT_SUPPORTED;
1998 #endif
1999 }
2000
2001 /******************************************************************
2002 * CDROM_DeviceIoControl
2003 *
2004 *
2005 */
2006 NTSTATUS CDROM_DeviceIoControl(HANDLE hDevice,
2007 HANDLE hEvent, PIO_APC_ROUTINE UserApcRoutine,
2008 PVOID UserApcContext,
2009 PIO_STATUS_BLOCK piosb,
2010 ULONG dwIoControlCode,
2011 LPVOID lpInBuffer, DWORD nInBufferSize,
2012 LPVOID lpOutBuffer, DWORD nOutBufferSize)
2013 {
2014 DWORD sz = 0;
2015 NTSTATUS status = STATUS_SUCCESS;
2016 int fd, dev;
2017
2018 TRACE("%p %s %p %ld %p %ld %p\n",
2019 hDevice, iocodex(dwIoControlCode), lpInBuffer, nInBufferSize,
2020 lpOutBuffer, nOutBufferSize, piosb);
2021
2022 piosb->Information = 0;
2023
2024 if ((status = wine_server_handle_to_fd( hDevice, 0, &fd, NULL ))) goto error;
2025 if ((status = CDROM_Open(fd, &dev)))
2026 {
2027 wine_server_release_fd( hDevice, fd );
2028 goto error;
2029 }
2030
2031 switch (dwIoControlCode)
2032 {
2033 case IOCTL_STORAGE_CHECK_VERIFY:
2034 case IOCTL_CDROM_CHECK_VERIFY:
2035 case IOCTL_DISK_CHECK_VERIFY:
2036 sz = 0;
2037 CDROM_ClearCacheEntry(dev);
2038 if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2039 status = STATUS_INVALID_PARAMETER;
2040 else status = CDROM_Verify(dev, fd);
2041 break;
2042
2043 /* EPP case IOCTL_STORAGE_CHECK_VERIFY2: */
2044
2045 /* EPP case IOCTL_STORAGE_FIND_NEW_DEVICES: */
2046 /* EPP case IOCTL_CDROM_FIND_NEW_DEVICES: */
2047
2048 case IOCTL_STORAGE_LOAD_MEDIA:
2049 case IOCTL_CDROM_LOAD_MEDIA:
2050 sz = 0;
2051 CDROM_ClearCacheEntry(dev);
2052 if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2053 status = STATUS_INVALID_PARAMETER;
2054 else status = CDROM_SetTray(fd, FALSE);
2055 break;
2056 case IOCTL_STORAGE_EJECT_MEDIA:
2057 sz = 0;
2058 CDROM_ClearCacheEntry(dev);
2059 if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2060 status = STATUS_INVALID_PARAMETER;
2061 else status = CDROM_SetTray(fd, TRUE);
2062 break;
2063
2064 case IOCTL_CDROM_MEDIA_REMOVAL:
2065 case IOCTL_DISK_MEDIA_REMOVAL:
2066 case IOCTL_STORAGE_MEDIA_REMOVAL:
2067 case IOCTL_STORAGE_EJECTION_CONTROL:
2068 /* FIXME the last ioctl:s is not the same as the two others...
2069 * lockcount/owner should be handled */
2070 sz = 0;
2071 CDROM_ClearCacheEntry(dev);
2072 if (lpOutBuffer != NULL || nOutBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2073 else if (nInBufferSize < sizeof(PREVENT_MEDIA_REMOVAL)) status = STATUS_BUFFER_TOO_SMALL;
2074 else status = CDROM_ControlEjection(fd, (const PREVENT_MEDIA_REMOVAL*)lpInBuffer);
2075 break;
2076
2077 /* EPP case IOCTL_STORAGE_GET_MEDIA_TYPES: */
2078
2079 case IOCTL_STORAGE_GET_DEVICE_NUMBER:
2080 sz = sizeof(STORAGE_DEVICE_NUMBER);
2081 if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2082 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2083 else status = CDROM_GetDeviceNumber(dev, (STORAGE_DEVICE_NUMBER*)lpOutBuffer);
2084 break;
2085
2086 case IOCTL_STORAGE_RESET_DEVICE:
2087 sz = 0;
2088 CDROM_ClearCacheEntry(dev);
2089 if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2090 status = STATUS_INVALID_PARAMETER;
2091 else status = CDROM_ResetAudio(fd);
2092 break;
2093
2094 case IOCTL_CDROM_GET_CONTROL:
2095 sz = sizeof(CDROM_AUDIO_CONTROL);
2096 if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2097 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2098 else status = CDROM_GetControl(dev, (CDROM_AUDIO_CONTROL*)lpOutBuffer);
2099 break;
2100
2101 case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
2102 sz = sizeof(DISK_GEOMETRY);
2103 if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2104 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2105 else status = CDROM_GetDriveGeometry(dev, fd, (DISK_GEOMETRY*)lpOutBuffer);
2106 break;
2107
2108 case IOCTL_CDROM_DISK_TYPE:
2109 sz = sizeof(CDROM_DISK_DATA);
2110 /* CDROM_ClearCacheEntry(dev); */
2111 if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2112 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2113 else status = CDROM_GetDiskData(dev, fd, (CDROM_DISK_DATA*)lpOutBuffer);
2114 break;
2115
2116 /* EPP case IOCTL_CDROM_GET_LAST_SESSION: */
2117
2118 case IOCTL_CDROM_READ_Q_CHANNEL:
2119 sz = sizeof(SUB_Q_CHANNEL_DATA);
2120 if (lpInBuffer == NULL || nInBufferSize < sizeof(CDROM_SUB_Q_DATA_FORMAT))
2121 status = STATUS_INVALID_PARAMETER;
2122 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2123 else status = CDROM_ReadQChannel(dev, fd, (const CDROM_SUB_Q_DATA_FORMAT*)lpInBuffer,
2124 (SUB_Q_CHANNEL_DATA*)lpOutBuffer);
2125 break;
2126
2127 case IOCTL_CDROM_READ_TOC:
2128 sz = sizeof(CDROM_TOC);
2129 if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2130 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2131 else status = CDROM_ReadTOC(dev, fd, (CDROM_TOC*)lpOutBuffer);
2132 break;
2133
2134 /* EPP case IOCTL_CDROM_READ_TOC_EX: */
2135
2136 case IOCTL_CDROM_PAUSE_AUDIO:
2137 sz = 0;
2138 if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2139 status = STATUS_INVALID_PARAMETER;
2140 else status = CDROM_PauseAudio(fd);
2141 break;
2142 case IOCTL_CDROM_PLAY_AUDIO_MSF:
2143 sz = 0;
2144 if (lpOutBuffer != NULL || nOutBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2145 else if (nInBufferSize < sizeof(CDROM_PLAY_AUDIO_MSF)) status = STATUS_BUFFER_TOO_SMALL;
2146 else status = CDROM_PlayAudioMSF(fd, (const CDROM_PLAY_AUDIO_MSF*)lpInBuffer);
2147 break;
2148 case IOCTL_CDROM_RESUME_AUDIO:
2149 sz = 0;
2150 if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2151 status = STATUS_INVALID_PARAMETER;
2152 else status = CDROM_ResumeAudio(fd);
2153 break;
2154 case IOCTL_CDROM_SEEK_AUDIO_MSF:
2155 sz = 0;
2156 if (lpOutBuffer != NULL || nOutBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2157 else if (nInBufferSize < sizeof(CDROM_SEEK_AUDIO_MSF)) status = STATUS_BUFFER_TOO_SMALL;
2158 else status = CDROM_SeekAudioMSF(dev, fd, (const CDROM_SEEK_AUDIO_MSF*)lpInBuffer);
2159 break;
2160 case IOCTL_CDROM_STOP_AUDIO:
2161 sz = 0;
2162 CDROM_ClearCacheEntry(dev); /* Maybe intention is to change media */
2163 if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2164 status = STATUS_INVALID_PARAMETER;
2165 else status = CDROM_StopAudio(fd);
2166 break;
2167 case IOCTL_CDROM_GET_VOLUME:
2168 sz = sizeof(VOLUME_CONTROL);
2169 if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2170 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2171 else status = CDROM_GetVolume(fd, (VOLUME_CONTROL*)lpOutBuffer);
2172 break;
2173 case IOCTL_CDROM_SET_VOLUME:
2174 sz = 0;
2175 CDROM_ClearCacheEntry(dev);
2176 if (lpInBuffer == NULL || nInBufferSize < sizeof(VOLUME_CONTROL) || lpOutBuffer != NULL)
2177 status = STATUS_INVALID_PARAMETER;
2178 else status = CDROM_SetVolume(fd, (const VOLUME_CONTROL*)lpInBuffer);
2179 break;
2180 case IOCTL_CDROM_RAW_READ:
2181 sz = 0;
2182 if (nInBufferSize < sizeof(RAW_READ_INFO)) status = STATUS_INVALID_PARAMETER;
2183 else if (lpOutBuffer == NULL) status = STATUS_BUFFER_TOO_SMALL;
2184 else status = CDROM_RawRead(fd, (const RAW_READ_INFO*)lpInBuffer,
2185 lpOutBuffer, nOutBufferSize, &sz);
2186 break;
2187 case IOCTL_SCSI_GET_ADDRESS:
2188 sz = sizeof(SCSI_ADDRESS);
2189 if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2190 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2191 else status = CDROM_GetAddress(fd, (SCSI_ADDRESS*)lpOutBuffer);
2192 break;
2193 case IOCTL_SCSI_PASS_THROUGH_DIRECT:
2194 sz = sizeof(SCSI_PASS_THROUGH_DIRECT);
2195 if (lpOutBuffer == NULL) status = STATUS_INVALID_PARAMETER;
2196 else if (nOutBufferSize < sizeof(SCSI_PASS_THROUGH_DIRECT)) status = STATUS_BUFFER_TOO_SMALL;
2197 else status = CDROM_ScsiPassThroughDirect(fd, (PSCSI_PASS_THROUGH_DIRECT)lpOutBuffer);
2198 break;
2199 case IOCTL_SCSI_PASS_THROUGH:
2200 sz = sizeof(SCSI_PASS_THROUGH);
2201 if (lpOutBuffer == NULL) status = STATUS_INVALID_PARAMETER;
2202 else if (nOutBufferSize < sizeof(SCSI_PASS_THROUGH)) status = STATUS_BUFFER_TOO_SMALL;
2203 else status = CDROM_ScsiPassThrough(fd, (PSCSI_PASS_THROUGH)lpOutBuffer);
2204 break;
2205 case IOCTL_SCSI_GET_CAPABILITIES:
2206 sz = sizeof(IO_SCSI_CAPABILITIES);
2207 if (lpOutBuffer == NULL) status = STATUS_INVALID_PARAMETER;
2208 else if (nOutBufferSize < sizeof(IO_SCSI_CAPABILITIES)) status = STATUS_BUFFER_TOO_SMALL;
2209 else status = CDROM_ScsiGetCaps((PIO_SCSI_CAPABILITIES)lpOutBuffer);
2210 break;
2211 case IOCTL_DVD_START_SESSION:
2212 sz = sizeof(DVD_SESSION_ID);
2213 if (lpOutBuffer == NULL) status = STATUS_INVALID_PARAMETER;
2214 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2215 else
2216 {
2217 TRACE("before in 0x%08lx out 0x%08lx\n",(lpInBuffer)?*(PDVD_SESSION_ID)lpInBuffer:0,
2218 *(PDVD_SESSION_ID)lpOutBuffer);
2219 status = DVD_StartSession(fd, (PDVD_SESSION_ID)lpInBuffer, (PDVD_SESSION_ID)lpOutBuffer);
2220 TRACE("before in 0x%08lx out 0x%08lx\n",(lpInBuffer)?*(PDVD_SESSION_ID)lpInBuffer:0,
2221 *(PDVD_SESSION_ID)lpOutBuffer);
2222 }
2223 break;
2224 case IOCTL_DVD_END_SESSION:
2225 sz = sizeof(DVD_SESSION_ID);
2226 if ((lpInBuffer == NULL) || (nInBufferSize < sz))status = STATUS_INVALID_PARAMETER;
2227 else status = DVD_EndSession(fd, (PDVD_SESSION_ID)lpInBuffer);
2228 break;
2229 case IOCTL_DVD_SEND_KEY:
2230 sz = 0;
2231 if (!lpInBuffer ||
2232 (((PDVD_COPY_PROTECT_KEY)lpInBuffer)->KeyLength != nInBufferSize))
2233 status = STATUS_INVALID_PARAMETER;
2234 else
2235 {
2236 TRACE("doing DVD_SendKey\n");
2237 status = DVD_SendKey(fd, (PDVD_COPY_PROTECT_KEY)lpInBuffer);
2238 }
2239 break;
2240 case IOCTL_DVD_READ_KEY:
2241 if (!lpInBuffer ||
2242 (((PDVD_COPY_PROTECT_KEY)lpInBuffer)->KeyLength != nInBufferSize))
2243 status = STATUS_INVALID_PARAMETER;
2244 else if (lpInBuffer !=lpOutBuffer) status = STATUS_BUFFER_TOO_SMALL;
2245 else
2246 {
2247 TRACE("doing DVD_READ_KEY\n");
2248 sz = ((PDVD_COPY_PROTECT_KEY)lpInBuffer)->KeyLength;
2249 status = DVD_ReadKey(fd, (PDVD_COPY_PROTECT_KEY)lpInBuffer);
2250 }
2251 break;
2252 case IOCTL_DVD_GET_REGION:
2253 sz = sizeof(DVD_REGION);
2254 if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2255 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2256 TRACE("doing DVD_Get_REGION\n");
2257 status = DVD_GetRegion(fd, (PDVD_REGION)lpOutBuffer);
2258 break;
2259 case IOCTL_DVD_READ_STRUCTURE:
2260 sz = sizeof(DVD_LAYER_DESCRIPTOR);
2261 if (lpInBuffer == NULL || nInBufferSize != sizeof(DVD_READ_STRUCTURE)) status = STATUS_INVALID_PARAMETER;
2262 else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2263 TRACE("doing DVD_READ_STRUCTURE\n");
2264 status = DVD_ReadStructure(fd, (PDVD_READ_STRUCTURE)lpInBuffer, (PDVD_LAYER_DESCRIPTOR)lpOutBuffer);
2265 break;
2266
2267 case IOCTL_SCSI_GET_INQUIRY_DATA:
2268 sz = INQ_REPLY_LEN;
2269 status = GetInquiryData(fd, (PSCSI_ADAPTER_BUS_INFO)lpOutBuffer, nOutBufferSize);
2270 break;
2271
2272 default:
2273 FIXME("Unsupported IOCTL %lx (type=%lx access=%lx func=%lx meth=%lx)\n",
2274 dwIoControlCode, dwIoControlCode >> 16, (dwIoControlCode >> 14) & 3,
2275 (dwIoControlCode >> 2) & 0xFFF, dwIoControlCode & 3);
2276 sz = 0;
2277 status = STATUS_INVALID_PARAMETER;
2278 break;
2279 }
2280 wine_server_release_fd( hDevice, fd );
2281 error:
2282 piosb->u.Status = status;
2283 piosb->Information = sz;
2284 if (hEvent) NtSetEvent(hEvent, NULL);
2285 return status;
2286 }
Maarten's multimedia branch