git.oblomov.eu Git - wine/blob - dlls/ntdll/cdrom.c

   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 Eric Pouech
   6  * Copyright 2000 Andreas Mohr
   7  *
   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.
  12  *
  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.
  17  *
  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
  21  */
  22
  23 #include "config.h"
  24
  25 #include <errno.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32
  33 #ifdef HAVE_SYS_IOCTL_H
  34 #include <sys/ioctl.h>
  35 #endif
  36 #ifdef HAVE_SCSI_SG_H
  37 # include <scsi/sg.h>
  38 #endif
  39 #ifdef HAVE_LINUX_MAJOR_H
  40 # include <linux/major.h>
  41 #endif
  42 #ifdef HAVE_LINUX_HDREG_H
  43 # include <linux/hdreg.h>
  44 #endif
  45 #ifdef HAVE_LINUX_PARAM_H
  46 # include <linux/param.h>
  47 #endif
  48 #ifdef HAVE_LINUX_CDROM_H
  49 # include <linux/cdrom.h>
  50 #endif
  51 #ifdef HAVE_LINUX_UCDROM_H
  52 # include <linux/ucdrom.h>
  53 #endif
  54 #ifdef HAVE_SYS_CDIO_H
  55 # include <sys/cdio.h>
  56 #endif
  57
  58 #include "ntddk.h"
  59 #include "winioctl.h"
  60 #include "ntddstor.h"
  61 #include "ntddcdrm.h"
  62 #include "ntddscsi.h"
  63 #include "drive.h"
  64 #include "file.h"
  65 #include "wine/debug.h"
  66
  67 WINE_DEFAULT_DEBUG_CHANNEL(cdrom);
  68
  69 #ifdef linux
  70
  71 # ifndef IDE6_MAJOR
  72 #  define IDE6_MAJOR 88
  73 # endif
  74 # ifndef IDE7_MAJOR
  75 #  define IDE7_MAJOR 89
  76 # endif
  77
  78 /* structure for CDROM_PACKET_COMMAND ioctl */
  79 /* not all Linux versions have all the fields, so we define the
  80  * structure ourselves to make sure */
  81 struct linux_cdrom_generic_command
  82 {
  83     unsigned char          cmd[CDROM_PACKET_SIZE];
  84     unsigned char         *buffer;
  85     unsigned int           buflen;
  86     int                    stat;
  87     struct request_sense  *sense;
  88     unsigned char          data_direction;
  89     int                    quiet;
  90     int                    timeout;
  91     void                  *reserved[1];
  92 };
  93
  94 #endif  /* linux */
  95
  96 /* FIXME: this is needed because we can't open simultaneously several times /dev/cdrom
  97  * this should be removed when a proper device interface is implemented
  98  */
  99 struct cdrom_cache {
 100     int fd;
 101     int count;
 102 };
 103 static struct cdrom_cache cdrom_cache[26];
 104
 105 /******************************************************************
 106  *              CDROM_GetIdeInterface
 107  *
 108  * Determines the ide interface (the number after the ide), and the
 109  * number of the device on that interface for ide cdroms.
 110  * Returns false if the info could not be get
 111  *
 112  * NOTE: this function is used in CDROM_InitRegistry and CDROM_GetAddress
 113  */
 114 static int CDROM_GetIdeInterface(int dev, int* iface, int* device)
 115 {
 116 #if defined(linux)
 117     {
 118         struct stat st;
 119         if (ioctl(dev, SG_EMULATED_HOST) != -1) {
 120             FIXME("not implemented for true scsi drives\n");
 121             return 0;
 122         }
 123         if ( fstat(dev, &st) == -1 || ! S_ISBLK(st.st_mode)) {
 124             FIXME("cdrom not a block device!!!\n");
 125             return 0;
 126         }
 127         switch (major(st.st_rdev)) {
 128             case IDE0_MAJOR: *iface = 0; break;
 129             case IDE1_MAJOR: *iface = 1; break;
 130             case IDE2_MAJOR: *iface = 2; break;
 131             case IDE3_MAJOR: *iface = 3; break;
 132             case IDE4_MAJOR: *iface = 4; break;
 133             case IDE5_MAJOR: *iface = 5; break;
 134             case IDE6_MAJOR: *iface = 6; break;
 135             case IDE7_MAJOR: *iface = 7; break;
 136             default:
 137                              FIXME("CD-ROM device with major ID %d not supported\n", major(st.st_rdev));
 138         }
 139         *device = (minor(st.st_rdev) == 63 ? 1 : 0);
 140         return 1;
 141     }
 142 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 143     FIXME("not implemented for BSD\n");
 144     return 0;
 145 #else
 146     FIXME("not implemented for nonlinux\n");
 147     return 0;
 148 #endif
 149 }
 150
 151
 152 /******************************************************************
 153  *              CDROM_InitRegistry
 154  *
 155  * Initializes registry to contain scsi info about the cdrom in NT.
 156  * All devices (even not real scsi ones) have this info in NT.
 157  * TODO: for now it only works for non scsi devices
 158  * NOTE: programs usually read these registry entries after sending the
 159  *       IOCTL_SCSI_GET_ADDRESS ioctl to the cdrom
 160  */
 161 void CDROM_InitRegistry(int dev)
 162 {
 163     int portnum, targetid;
 164     int dma;
 165     OBJECT_ATTRIBUTES attr;
 166     UNICODE_STRING nameW;
 167     WCHAR dataW[50];
 168     DWORD lenW;
 169     char buffer[40];
 170     DWORD value;
 171     const char *data;
 172     HKEY scsiKey;
 173     HKEY portKey;
 174     HKEY busKey;
 175     HKEY targetKey;
 176     DWORD disp;
 177
 178     attr.Length = sizeof(attr);
 179     attr.RootDirectory = HKEY_LOCAL_MACHINE;
 180     attr.ObjectName = &nameW;
 181     attr.Attributes = 0;
 182     attr.SecurityDescriptor = NULL;
 183     attr.SecurityQualityOfService = NULL;
 184
 185     if ( ! CDROM_GetIdeInterface(dev, &portnum, &targetid))
 186         return;
 187
 188     /* Ensure there is Scsi key */
 189     if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "HARDWARE\\DEVICEMAP\\Scsi" ) ||
 190         NtCreateKey( &scsiKey, KEY_ALL_ACCESS, &attr, 0,
 191                      NULL, REG_OPTION_VOLATILE, &disp ))
 192     {
 193         ERR("Cannot create DEVICEMAP\\Scsi registry key\n" );
 194         return;
 195     }
 196     RtlFreeUnicodeString( &nameW );
 197
 198     snprintf(buffer,40,"Scsi Port %d",portnum);
 199     attr.RootDirectory = scsiKey;
 200     if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||
 201         NtCreateKey( &portKey, KEY_ALL_ACCESS, &attr, 0,
 202                      NULL, REG_OPTION_VOLATILE, &disp ))
 203     {
 204         ERR("Cannot create DEVICEMAP\\Scsi Port registry key\n" );
 205         return;
 206     }
 207     RtlFreeUnicodeString( &nameW );
 208
 209     RtlCreateUnicodeStringFromAsciiz( &nameW, "Driver" );
 210     data = "atapi";
 211     RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
 212     NtSetValueKey( portKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
 213     RtlFreeUnicodeString( &nameW );
 214     value = 10;
 215     RtlCreateUnicodeStringFromAsciiz( &nameW, "FirstBusTimeScanInMs" );
 216     NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));
 217     RtlFreeUnicodeString( &nameW );
 218     value = 0;
 219 #ifdef HDIO_GET_DMA
 220     if (ioctl(dev,HDIO_GET_DMA, &dma) != -1) {
 221         value = dma;
 222         TRACE("setting dma to %lx\n", value);
 223     }
 224 #endif
 225     RtlCreateUnicodeStringFromAsciiz( &nameW, "DMAEnabled" );
 226     NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));
 227     RtlFreeUnicodeString( &nameW );
 228
 229     attr.RootDirectory = portKey;
 230     if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Scsi Bus 0" ) ||
 231         NtCreateKey( &busKey, KEY_ALL_ACCESS, &attr, 0,
 232                      NULL, REG_OPTION_VOLATILE, &disp ))
 233     {
 234         ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus registry key\n" );
 235         return;
 236     }
 237     RtlFreeUnicodeString( &nameW );
 238
 239     attr.RootDirectory = busKey;
 240     if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Initiator Id 255" ) ||
 241         NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,
 242                      NULL, REG_OPTION_VOLATILE, &disp ))
 243     {
 244         ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus\\Initiator Id 255 registry key\n" );
 245         return;
 246     }
 247     RtlFreeUnicodeString( &nameW );
 248     NtClose( targetKey );
 249
 250     snprintf(buffer,40,"Target Id %d", targetid);
 251     attr.RootDirectory = busKey;
 252     if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||
 253         NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,
 254                      NULL, REG_OPTION_VOLATILE, &disp ))
 255     {
 256         ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus 0\\Target Id registry key\n" );
 257         return;
 258     }
 259     RtlFreeUnicodeString( &nameW );
 260
 261     RtlCreateUnicodeStringFromAsciiz( &nameW, "Type" );
 262     data = "CdRomPeripheral";
 263     RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
 264     NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
 265     RtlFreeUnicodeString( &nameW );
 266     /* FIXME - maybe read the real identifier?? */
 267     RtlCreateUnicodeStringFromAsciiz( &nameW, "Identifier" );
 268     data = "Wine CDROM";
 269     RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
 270     NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
 271     RtlFreeUnicodeString( &nameW );
 272     /* FIXME - we always use Cdrom0 - do not know about the nt behaviour */
 273     RtlCreateUnicodeStringFromAsciiz( &nameW, "DeviceName" );
 274     data = "Cdrom0";
 275     RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
 276     NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
 277     RtlFreeUnicodeString( &nameW );
 278
 279     NtClose( targetKey );
 280     NtClose( busKey );
 281     NtClose( portKey );
 282     NtClose( scsiKey );
 283 }
 284
 285
 286 /******************************************************************
 287  *              CDROM_Open
 288  *
 289  *
 290  */
 291 static int CDROM_Open(HANDLE hDevice, DWORD clientID)
 292 {
 293     int dev = LOWORD(clientID);
 294
 295     if (dev >= 26) return -1;
 296
 297     if (!cdrom_cache[dev].count)
 298     {
 299         char root[4];
 300
 301         strcpy(root, "A:\\");
 302         root[0] += dev;
 303         if (GetDriveTypeA(root) != DRIVE_CDROM) return -1;
 304         cdrom_cache[dev].fd = open(DRIVE_GetDevice(dev), O_RDONLY|O_NONBLOCK);
 305         if (cdrom_cache[dev].fd == -1)
 306         {
 307             FIXME("Can't open configured CD-ROM drive at %s (device %s): %s\n", root, DRIVE_GetDevice(dev), strerror(errno));
 308             return -1;
 309         }
 310     }
 311     cdrom_cache[dev].count++;
 312     return cdrom_cache[dev].fd;
 313 }
 314
 315 /******************************************************************
 316  *              CDROM_Close
 317  *
 318  *
 319  */
 320 static void CDROM_Close(DWORD clientID, int fd)
 321 {
 322     int dev = LOWORD(clientID);
 323
 324     if (dev >= 26 || fd != cdrom_cache[dev].fd) FIXME("how come\n");
 325     if (--cdrom_cache[dev].count == 0)
 326         close(cdrom_cache[dev].fd);
 327 }
 328
 329 /******************************************************************
 330  *              CDROM_GetStatusCode
 331  *
 332  *
 333  */
 334 static DWORD CDROM_GetStatusCode(int io)
 335 {
 336     if (io == 0) return 0;
 337     switch (errno)
 338     {
 339     case EIO:
 340 #ifdef ENOMEDIUM
 341     case ENOMEDIUM:
 342 #endif
 343             return STATUS_NO_MEDIA_IN_DEVICE;
 344     case EPERM:
 345             return STATUS_ACCESS_DENIED;
 346     }
 347     FIXME("Unmapped error code %d: %s\n", errno, strerror(errno));
 348     return STATUS_IO_DEVICE_ERROR;
 349 }
 350
 351 static DWORD CDROM_GetControl(int dev, CDROM_AUDIO_CONTROL* cac)
 352 {
 353     cac->LbaFormat = 0; /* FIXME */
 354     cac->LogicalBlocksPerSecond = 1; /* FIXME */
 355     return  STATUS_NOT_SUPPORTED;
 356 }
 357
 358 static DWORD CDROM_GetDeviceNumber(int dev, STORAGE_DEVICE_NUMBER* devnum)
 359 {
 360     return STATUS_NOT_SUPPORTED;
 361 }
 362
 363 static DWORD CDROM_GetDriveGeometry(int dev, DISK_GEOMETRY* dg)
 364 {
 365 #if 0
 366     dg->Cylinders.s.LowPart = 1; /* FIXME */
 367     dg->Cylinders.s.HighPart = 0; /* FIXME */
 368     dg->MediaType = 1; /* FIXME */
 369     dg->TracksPerCylinder = 1; /* FIXME */
 370     dg->SectorsPerTrack = 1; /* FIXME */
 371     dg->BytesPerSector= 1; /* FIXME */
 372 #endif
 373     return STATUS_NOT_SUPPORTED;
 374 }
 375
 376 /**************************************************************************
 377  *                              CDROM_Reset                     [internal]
 378  */
 379 static DWORD CDROM_ResetAudio(int dev)
 380 {
 381 #if defined(linux)
 382     return CDROM_GetStatusCode(ioctl(dev, CDROMRESET));
 383 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 384     return CDROM_GetStatusCode(ioctl(dev, CDIOCRESET, NULL));
 385 #else
 386     return STATUS_NOT_SUPPORTED;
 387 #endif
 388 }
 389
 390 /******************************************************************
 391  *              CDROM_SetTray
 392  *
 393  *
 394  */
 395 static DWORD CDROM_SetTray(int dev, BOOL doEject)
 396 {
 397 #if defined(linux)
 398     return CDROM_GetStatusCode(ioctl(dev, doEject ? CDROMEJECT : CDROMCLOSETRAY));
 399 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 400     return CDROM_GetStatusCode((ioctl(dev, CDIOCALLOW, NULL)) ||
 401                                (ioctl(dev, doEject ? CDIOCEJECT : CDIOCCLOSE, NULL)) ||
 402                                (ioctl(dev, CDIOCPREVENT, NULL)));
 403 #else
 404     return STATUS_NOT_SUPPORTED;
 405 #endif
 406 }
 407
 408 /******************************************************************
 409  *              CDROM_ControlEjection
 410  *
 411  *
 412  */
 413 static DWORD CDROM_ControlEjection(int dev, const PREVENT_MEDIA_REMOVAL* rmv)
 414 {
 415 #if defined(linux)
 416     return CDROM_GetStatusCode(ioctl(dev, CDROM_LOCKDOOR, rmv->PreventMediaRemoval));
 417 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 418     return CDROM_GetStatusCode(ioctl(dev, (rmv->PreventMediaRemoval) ? CDIOCPREVENT : CDIOCALLOW, NULL));
 419 #else
 420     return STATUS_NOT_SUPPORTED;
 421 #endif
 422 }
 423
 424 /******************************************************************
 425  *              CDROM_ReadTOC
 426  *
 427  *
 428  */
 429 static DWORD CDROM_ReadTOC(int dev, CDROM_TOC* toc)
 430 {
 431     DWORD       ret = STATUS_NOT_SUPPORTED;
 432
 433 #if defined(linux)
 434     int                         i, io = -1;
 435     struct cdrom_tochdr         hdr;
 436     struct cdrom_tocentry       entry;
 437
 438     io = ioctl(dev, CDROMREADTOCHDR, &hdr);
 439     if (io == -1)
 440     {
 441         WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
 442         goto end;
 443     }
 444     toc->FirstTrack = hdr.cdth_trk0;
 445     toc->LastTrack  = hdr.cdth_trk1;
 446
 447     TRACE("from=%d to=%d\n", toc->FirstTrack, toc->LastTrack);
 448
 449     for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
 450     {
 451         if (i == toc->LastTrack + 1)
 452         {
 453             entry.cdte_track = CDROM_LEADOUT;
 454         } else {
 455             entry.cdte_track = i;
 456         }
 457         entry.cdte_format = CDROM_MSF;
 458         io = ioctl(dev, CDROMREADTOCENTRY, &entry);
 459         if (io == -1) {
 460             WARN("error read entry (%s)\n", strerror(errno));
 461             goto end;
 462         }
 463         toc->TrackData[i - toc->FirstTrack].Control = entry.cdte_ctrl;
 464         toc->TrackData[i - toc->FirstTrack].Adr = entry.cdte_adr;
 465         /* marking last track with leadout value as index */
 466         toc->TrackData[i - toc->FirstTrack].TrackNumber = entry.cdte_track;
 467         toc->TrackData[i - toc->FirstTrack].Address[0] = 0;
 468         toc->TrackData[i - toc->FirstTrack].Address[1] = entry.cdte_addr.msf.minute;
 469         toc->TrackData[i - toc->FirstTrack].Address[2] = entry.cdte_addr.msf.second;
 470         toc->TrackData[i - toc->FirstTrack].Address[3] = entry.cdte_addr.msf.frame;
 471     }
 472 end:
 473     ret = CDROM_GetStatusCode(io);
 474 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 475     int                         i, io = -1;
 476     struct ioc_toc_header       hdr;
 477     struct ioc_read_toc_entry   entry;
 478     struct cd_toc_entry         toc_buffer;
 479
 480     io = ioctl(dev, CDIOREADTOCHEADER, &hdr);
 481     if (io == -1)
 482     {
 483         WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
 484         goto end;
 485     }
 486     toc->FirstTrack = hdr.starting_track;
 487     toc->LastTrack  = hdr.ending_track;
 488
 489     TRACE("from=%d to=%d\n", toc->FirstTrack, toc->LastTrack);
 490
 491     for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
 492     {
 493         if (i == toc->LastTrack + 1)
 494         {
 495 #define LEADOUT 0xaa
 496             entry.starting_track = LEADOUT;
 497         } else {
 498             entry.starting_track = i;
 499         }
 500         memset((char *)&toc_buffer, 0, sizeof(toc_buffer));
 501         entry.address_format = CD_MSF_FORMAT;
 502         entry.data_len = sizeof(toc_buffer);
 503         entry.data = &toc_buffer;
 504         io = ioctl(dev, CDIOREADTOCENTRYS, &entry);
 505         if (io == -1) {
 506             WARN("error read entry (%s)\n", strerror(errno));
 507             goto end;
 508         }
 509         toc->TrackData[i - toc->FirstTrack].Control = toc_buffer.control;
 510         toc->TrackData[i - toc->FirstTrack].Adr = toc_buffer.addr_type;
 511         /* marking last track with leadout value as index */
 512         toc->TrackData[i - toc->FirstTrack].TrackNumber = entry.starting_track;
 513         toc->TrackData[i - toc->FirstTrack].Address[0] = 0;
 514         toc->TrackData[i - toc->FirstTrack].Address[1] = toc_buffer.addr.msf.minute;
 515         toc->TrackData[i - toc->FirstTrack].Address[2] = toc_buffer.addr.msf.second;
 516         toc->TrackData[i - toc->FirstTrack].Address[3] = toc_buffer.addr.msf.frame;
 517     }
 518 end:
 519     ret = CDROM_GetStatusCode(io);
 520 #else
 521     ret = STATUS_NOT_SUPPORTED;
 522 #endif
 523     return ret;
 524 }
 525
 526 /******************************************************************
 527  *              CDROM_GetDiskData
 528  *
 529  *
 530  */
 531 static DWORD CDROM_GetDiskData(int dev, CDROM_DISK_DATA* data)
 532 {
 533     CDROM_TOC   toc;
 534     DWORD       ret;
 535     int         i;
 536
 537     if ((ret = CDROM_ReadTOC(dev, &toc)) != 0) return ret;
 538     data->DiskData = 0;
 539     for (i = toc.FirstTrack; i <= toc.LastTrack; i++) {
 540         if (toc.TrackData[i].Control & 0x04)
 541             data->DiskData |= CDROM_DISK_DATA_TRACK;
 542         else
 543             data->DiskData |= CDROM_DISK_AUDIO_TRACK;
 544     }
 545     return 0;
 546 }
 547
 548 /******************************************************************
 549  *              CDROM_ReadQChannel
 550  *
 551  *
 552  */
 553 static DWORD CDROM_ReadQChannel(int dev, const CDROM_SUB_Q_DATA_FORMAT* fmt,
 554                                 SUB_Q_CHANNEL_DATA* data)
 555 {
 556     DWORD               ret = STATUS_NOT_SUPPORTED;
 557 #ifdef linux
 558     unsigned            size;
 559     SUB_Q_HEADER*       hdr = (SUB_Q_HEADER*)data;
 560     int                 io;
 561     struct cdrom_subchnl        sc;
 562     sc.cdsc_format = CDROM_MSF;
 563
 564     io = ioctl(dev, CDROMSUBCHNL, &sc);
 565     if (io == -1)
 566     {
 567         TRACE("opened or no_media (%s)!\n", strerror(errno));
 568         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 569         goto end;
 570     }
 571
 572     hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 573
 574     switch (sc.cdsc_audiostatus) {
 575     case CDROM_AUDIO_INVALID:
 576         hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 577         break;
 578     case CDROM_AUDIO_NO_STATUS:
 579         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 580         break;
 581     case CDROM_AUDIO_PLAY:
 582         hdr->AudioStatus = AUDIO_STATUS_IN_PROGRESS;
 583         break;
 584     case CDROM_AUDIO_PAUSED:
 585         hdr->AudioStatus = AUDIO_STATUS_PAUSED;
 586         break;
 587     case CDROM_AUDIO_COMPLETED:
 588         hdr->AudioStatus = AUDIO_STATUS_PLAY_COMPLETE;
 589         break;
 590     case CDROM_AUDIO_ERROR:
 591         hdr->AudioStatus = AUDIO_STATUS_PLAY_ERROR;
 592         break;
 593     default:
 594         TRACE("status=%02X !\n", sc.cdsc_audiostatus);
 595         break;
 596     }
 597     switch (fmt->Format)
 598     {
 599     case IOCTL_CDROM_CURRENT_POSITION:
 600         size = sizeof(SUB_Q_CURRENT_POSITION);
 601         data->CurrentPosition.FormatCode = sc.cdsc_format;
 602         data->CurrentPosition.Control = sc.cdsc_ctrl;
 603         data->CurrentPosition.ADR = sc.cdsc_adr;
 604         data->CurrentPosition.TrackNumber = sc.cdsc_trk;
 605         data->CurrentPosition.IndexNumber = sc.cdsc_ind;
 606
 607         data->CurrentPosition.AbsoluteAddress[0] = 0;
 608         data->CurrentPosition.AbsoluteAddress[1] = sc.cdsc_absaddr.msf.minute;
 609         data->CurrentPosition.AbsoluteAddress[2] = sc.cdsc_absaddr.msf.second;
 610         data->CurrentPosition.AbsoluteAddress[3] = sc.cdsc_absaddr.msf.frame;
 611
 612         data->CurrentPosition.TrackRelativeAddress[0] = 0;
 613         data->CurrentPosition.TrackRelativeAddress[1] = sc.cdsc_reladdr.msf.minute;
 614         data->CurrentPosition.TrackRelativeAddress[2] = sc.cdsc_reladdr.msf.second;
 615         data->CurrentPosition.TrackRelativeAddress[3] = sc.cdsc_reladdr.msf.frame;
 616         break;
 617     case IOCTL_CDROM_MEDIA_CATALOG:
 618         size = sizeof(SUB_Q_MEDIA_CATALOG_NUMBER);
 619         data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
 620         {
 621             struct cdrom_mcn mcn;
 622             if ((io = ioctl(dev, CDROM_GET_MCN, &mcn)) == -1) goto end;
 623
 624             data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
 625             data->MediaCatalog.Mcval = 0; /* FIXME */
 626             memcpy(data->MediaCatalog.MediaCatalog, mcn.medium_catalog_number, 14);
 627             data->MediaCatalog.MediaCatalog[14] = 0;
 628         }
 629         break;
 630     case IOCTL_CDROM_TRACK_ISRC:
 631         size = sizeof(SUB_Q_CURRENT_POSITION);
 632         FIXME("TrackIsrc: NIY on linux");
 633         data->TrackIsrc.FormatCode = IOCTL_CDROM_TRACK_ISRC;
 634         data->TrackIsrc.Tcval = 0;
 635         io = 0;
 636         break;
 637     }
 638
 639  end:
 640     ret = CDROM_GetStatusCode(io);
 641 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 642     unsigned            size;
 643     SUB_Q_HEADER*       hdr = (SUB_Q_HEADER*)data;
 644     int                 io;
 645     struct ioc_read_subchannel  read_sc;
 646     struct cd_sub_channel_info  sc;
 647
 648     read_sc.address_format = CD_MSF_FORMAT;
 649     read_sc.track          = 0;
 650     read_sc.data_len       = sizeof(sc);
 651     read_sc.data           = &sc;
 652     switch (fmt->Format)
 653     {
 654     case IOCTL_CDROM_CURRENT_POSITION:
 655         read_sc.data_format    = CD_CURRENT_POSITION;
 656         break;
 657     case IOCTL_CDROM_MEDIA_CATALOG:
 658         read_sc.data_format    = CD_MEDIA_CATALOG;
 659         break;
 660     case IOCTL_CDROM_TRACK_ISRC:
 661         read_sc.data_format    = CD_TRACK_INFO;
 662         sc.what.track_info.track_number = data->TrackIsrc.Track;
 663         break;
 664     }
 665     io = ioctl(dev, CDIOCREADSUBCHANNEL, &read_sc);
 666     if (io == -1)
 667     {
 668         TRACE("opened or no_media (%s)!\n", strerror(errno));
 669         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 670         goto end;
 671     }
 672
 673     hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 674
 675     switch (sc.header.audio_status) {
 676     case CD_AS_AUDIO_INVALID:
 677         hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 678         break;
 679     case CD_AS_NO_STATUS:
 680         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 681         break;
 682     case CD_AS_PLAY_IN_PROGRESS:
 683         hdr->AudioStatus = AUDIO_STATUS_IN_PROGRESS;
 684         break;
 685     case CD_AS_PLAY_PAUSED:
 686         hdr->AudioStatus = AUDIO_STATUS_PAUSED;
 687         break;
 688     case CD_AS_PLAY_COMPLETED:
 689         hdr->AudioStatus = AUDIO_STATUS_PLAY_COMPLETE;
 690         break;
 691     case CD_AS_PLAY_ERROR:
 692         hdr->AudioStatus = AUDIO_STATUS_PLAY_ERROR;
 693         break;
 694     default:
 695         TRACE("status=%02X !\n", sc.header.audio_status);
 696     }
 697     switch (fmt->Format)
 698     {
 699     case IOCTL_CDROM_CURRENT_POSITION:
 700         size = sizeof(SUB_Q_CURRENT_POSITION);
 701         data->CurrentPosition.FormatCode = sc.what.position.data_format;
 702         data->CurrentPosition.Control = sc.what.position.control;
 703         data->CurrentPosition.ADR = sc.what.position.addr_type;
 704         data->CurrentPosition.TrackNumber = sc.what.position.track_number;
 705         data->CurrentPosition.IndexNumber = sc.what.position.index_number;
 706
 707         data->CurrentPosition.AbsoluteAddress[0] = 0;
 708         data->CurrentPosition.AbsoluteAddress[1] = sc.what.position.absaddr.msf.minute;
 709         data->CurrentPosition.AbsoluteAddress[2] = sc.what.position.absaddr.msf.second;
 710         data->CurrentPosition.AbsoluteAddress[3] = sc.what.position.absaddr.msf.frame;
 711         data->CurrentPosition.TrackRelativeAddress[0] = 0;
 712         data->CurrentPosition.TrackRelativeAddress[1] = sc.what.position.reladdr.msf.minute;
 713         data->CurrentPosition.TrackRelativeAddress[2] = sc.what.position.reladdr.msf.second;
 714         data->CurrentPosition.TrackRelativeAddress[3] = sc.what.position.reladdr.msf.frame;
 715         break;
 716     case IOCTL_CDROM_MEDIA_CATALOG:
 717         size = sizeof(SUB_Q_MEDIA_CATALOG_NUMBER);
 718         data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
 719         data->MediaCatalog.FormatCode = sc.what.media_catalog.data_format;
 720         data->MediaCatalog.Mcval = sc.what.media_catalog.mc_valid;
 721         memcpy(data->MediaCatalog.MediaCatalog, sc.what.media_catalog.mc_number, 15);
 722         break;
 723     case IOCTL_CDROM_TRACK_ISRC:
 724         size = sizeof(SUB_Q_CURRENT_POSITION);
 725         data->TrackIsrc.Tcval = sc.what.track_info.ti_valid;
 726         memcpy(data->TrackIsrc.TrackIsrc, sc.what.track_info.ti_number, 15);
 727         break;
 728     }
 729
 730  end:
 731     ret = CDROM_GetStatusCode(io);
 732 #endif
 733     return ret;
 734 }
 735
 736 /******************************************************************
 737  *              CDROM_Verify
 738  *
 739  *
 740  */
 741 static DWORD CDROM_Verify(int dev)
 742 {
 743     /* quick implementation */
 744     CDROM_SUB_Q_DATA_FORMAT     fmt;
 745     SUB_Q_CHANNEL_DATA          data;
 746
 747     fmt.Format = IOCTL_CDROM_CURRENT_POSITION;
 748     return CDROM_ReadQChannel(dev, &fmt, &data) ? 0 : 1;
 749 }
 750
 751 /******************************************************************
 752  *              CDROM_PlayAudioMSF
 753  *
 754  *
 755  */
 756 static DWORD CDROM_PlayAudioMSF(int dev, const CDROM_PLAY_AUDIO_MSF* audio_msf)
 757 {
 758     DWORD       ret = STATUS_NOT_SUPPORTED;
 759 #ifdef linux
 760     struct      cdrom_msf       msf;
 761     int         io;
 762
 763     msf.cdmsf_min0   = audio_msf->StartingM;
 764     msf.cdmsf_sec0   = audio_msf->StartingS;
 765     msf.cdmsf_frame0 = audio_msf->StartingF;
 766     msf.cdmsf_min1   = audio_msf->EndingM;
 767     msf.cdmsf_sec1   = audio_msf->EndingS;
 768     msf.cdmsf_frame1 = audio_msf->EndingF;
 769
 770     io = ioctl(dev, CDROMSTART);
 771     if (io == -1)
 772     {
 773         WARN("motor doesn't start !\n");
 774         goto end;
 775     }
 776     io = ioctl(dev, CDROMPLAYMSF, &msf);
 777     if (io == -1)
 778     {
 779         WARN("device doesn't play !\n");
 780         goto end;
 781     }
 782     TRACE("msf = %d:%d:%d %d:%d:%d\n",
 783           msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0,
 784           msf.cdmsf_min1, msf.cdmsf_sec1, msf.cdmsf_frame1);
 785  end:
 786     ret = CDROM_GetStatusCode(io);
 787 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 788     struct      ioc_play_msf    msf;
 789     int         io;
 790
 791     msf.start_m      = audio_msf->StartingM;
 792     msf.start_s      = audio_msf->StartingS;
 793     msf.start_f      = audio_msf->StartingF;
 794     msf.end_m        = audio_msf->EndingM;
 795     msf.end_s        = audio_msf->EndingS;
 796     msf.end_f        = audio_msf->EndingF;
 797
 798     io = ioctl(dev, CDIOCSTART, NULL);
 799     if (io == -1)
 800     {
 801         WARN("motor doesn't start !\n");
 802         goto end;
 803     }
 804     io = ioctl(dev, CDIOCPLAYMSF, &msf);
 805     if (io == -1)
 806     {
 807         WARN("device doesn't play !\n");
 808         goto end;
 809     }
 810     TRACE("msf = %d:%d:%d %d:%d:%d\n",
 811           msf.start_m, msf.start_s, msf.start_f,
 812           msf.end_m,   msf.end_s,   msf.end_f);
 813 end:
 814     ret = CDROM_GetStatusCode(io);
 815 #endif
 816     return ret;
 817 }
 818
 819 /******************************************************************
 820  *              CDROM_SeekAudioMSF
 821  *
 822  *
 823  */
 824 static DWORD CDROM_SeekAudioMSF(int dev, const CDROM_SEEK_AUDIO_MSF* audio_msf)
 825 {
 826 #if defined(linux)
 827     struct cdrom_msf0   msf;
 828     msf.minute = audio_msf->M;
 829     msf.second = audio_msf->S;
 830     msf.frame  = audio_msf->F;
 831
 832     return CDROM_GetStatusCode(ioctl(dev, CDROMSEEK, &msf));
 833 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 834     FIXME("Could a BSD expert implement the seek function ?\n");
 835     return STATUS_NOT_SUPPORTED;
 836 #else
 837     return STATUS_NOT_SUPPORTED;
 838 #endif
 839 }
 840
 841 /******************************************************************
 842  *              CDROM_PauseAudio
 843  *
 844  *
 845  */
 846 static DWORD CDROM_PauseAudio(int dev)
 847 {
 848 #if defined(linux)
 849     return CDROM_GetStatusCode(ioctl(dev, CDROMPAUSE));
 850 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 851     return CDROM_GetStatusCode(ioctl(dev, CDIOCPAUSE, NULL));
 852 #else
 853     return STATUS_NOT_SUPPORTED;
 854 #endif
 855 }
 856
 857 /******************************************************************
 858  *              CDROM_ResumeAudio
 859  *
 860  *
 861  */
 862 static DWORD CDROM_ResumeAudio(int dev)
 863 {
 864 #if defined(linux)
 865     return CDROM_GetStatusCode(ioctl(dev, CDROMRESUME));
 866 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 867     return CDROM_GetStatusCode(ioctl(dev, CDIOCRESUME, NULL));
 868 #else
 869     return STATUS_NOT_SUPPORTED;
 870 #endif
 871 }
 872
 873 /******************************************************************
 874  *              CDROM_StopAudio
 875  *
 876  *
 877  */
 878 static DWORD CDROM_StopAudio(int dev)
 879 {
 880 #if defined(linux)
 881     return CDROM_GetStatusCode(ioctl(dev, CDROMSTOP));
 882 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 883     return CDROM_GetStatusCode(ioctl(dev, CDIOCSTOP, NULL));
 884 #else
 885     return STATUS_NOT_SUPPORTED;
 886 #endif
 887 }
 888
 889 /******************************************************************
 890  *              CDROM_GetVolume
 891  *
 892  *
 893  */
 894 static DWORD CDROM_GetVolume(int dev, VOLUME_CONTROL* vc)
 895 {
 896 #if defined(linux)
 897     struct cdrom_volctrl volc;
 898     int io;
 899
 900     io = ioctl(dev, CDROMVOLREAD, &volc);
 901     if (io != -1)
 902     {
 903         vc->PortVolume[0] = volc.channel0;
 904         vc->PortVolume[1] = volc.channel1;
 905         vc->PortVolume[2] = volc.channel2;
 906         vc->PortVolume[3] = volc.channel3;
 907     }
 908     return CDROM_GetStatusCode(io);
 909 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 910     struct  ioc_vol     volc;
 911     int io;
 912
 913     io = ioctl(dev, CDIOCGETVOL, &volc);
 914     if (io != -1)
 915     {
 916         vc->PortVolume[0] = volc.vol[0];
 917         vc->PortVolume[1] = volc.vol[1];
 918         vc->PortVolume[2] = volc.vol[2];
 919         vc->PortVolume[3] = volc.vol[3];
 920     }
 921     return CDROM_GetStatusCode(io);
 922 #else
 923     return STATUS_NOT_SUPPORTED;
 924 #endif
 925 }
 926
 927 /******************************************************************
 928  *              CDROM_SetVolume
 929  *
 930  *
 931  */
 932 static DWORD CDROM_SetVolume(int dev, const VOLUME_CONTROL* vc)
 933 {
 934 #if defined(linux)
 935     struct cdrom_volctrl volc;
 936
 937     volc.channel0 = vc->PortVolume[0];
 938     volc.channel1 = vc->PortVolume[1];
 939     volc.channel2 = vc->PortVolume[2];
 940     volc.channel3 = vc->PortVolume[3];
 941
 942     return CDROM_GetStatusCode(ioctl(dev, CDROMVOLCTRL, &volc));
 943 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 944     struct  ioc_vol     volc;
 945
 946     volc.vol[0] = vc->PortVolume[0];
 947     volc.vol[1] = vc->PortVolume[1];
 948     volc.vol[2] = vc->PortVolume[2];
 949     volc.vol[3] = vc->PortVolume[3];
 950
 951     return CDROM_GetStatusCode(ioctl(dev, CDIOCSETVOL, &volc));
 952 #else
 953     return STATUS_NOT_SUPPORTED;
 954 #endif
 955 }
 956
 957 /******************************************************************
 958  *              CDROM_RawRead
 959  *
 960  *
 961  */
 962 static DWORD CDROM_RawRead(int dev, const RAW_READ_INFO* raw, void* buffer, DWORD len, DWORD* sz)
 963 {
 964     int         ret = STATUS_NOT_SUPPORTED;
 965     int         io = -1;
 966     DWORD       sectSize;
 967
 968     switch (raw->TrackMode)
 969     {
 970     case YellowMode2:   sectSize = 2336;        break;
 971     case XAForm2:       sectSize = 2328;        break;
 972     case CDDA:          sectSize = 2352;        break;
 973     default:    return STATUS_INVALID_PARAMETER;
 974     }
 975     if (len < raw->SectorCount * sectSize) return STATUS_BUFFER_TOO_SMALL;
 976     /* strangely enough, it seems that sector offsets are always indicated with a size of 2048,
 977      * even if a larger size if read...
 978      */
 979 #if defined(linux)
 980     {
 981         struct cdrom_read       cdr;
 982         struct cdrom_read_audio cdra;
 983
 984         switch (raw->TrackMode)
 985         {
 986         case YellowMode2:
 987             if (raw->DiskOffset.s.HighPart) FIXME("Unsupported value\n");
 988             cdr.cdread_lba = raw->DiskOffset.s.LowPart; /* FIXME ? */
 989             cdr.cdread_bufaddr = buffer;
 990             cdr.cdread_buflen = raw->SectorCount * sectSize;
 991             io = ioctl(dev, CDROMREADMODE2, &cdr);
 992             break;
 993         case XAForm2:
 994             FIXME("XAForm2: NIY\n");
 995             return ret;
 996         case CDDA:
 997             /* FIXME: the output doesn't seem 100% correct... in fact output is shifted
 998              * between by NT2K box and this... should check on the same drive...
 999              * otherwise, I fear a 2352/2368 mismatch somewhere in one of the drivers
1000              * (linux/NT).
1001              * Anyway, that's not critical at all. We're talking of 16/32 bytes, we're
1002              * talking of 0.2 ms of sound
1003              */
1004             /* 2048 = 2 ** 11 */
1005             if (raw->DiskOffset.s.HighPart & ~2047) FIXME("Unsupported value\n");
1006             cdra.addr.lba = ((raw->DiskOffset.s.LowPart >> 11) |
1007                 (raw->DiskOffset.s.HighPart << (32 - 11))) - 1;
1008             FIXME("reading at %u\n", cdra.addr.lba);
1009             cdra.addr_format = CDROM_LBA;
1010             cdra.nframes = raw->SectorCount;
1011             cdra.buf = buffer;
1012             io = ioctl(dev, CDROMREADAUDIO, &cdra);
1013             break;
1014         }
1015     }
1016 #elif defined(__FreeBSD__)
1017     {
1018         struct ioc_read_audio   ira;
1019
1020         switch (raw->TrackMode)
1021         {
1022         case YellowMode2:
1023             FIXME("YellowMode2: NIY\n");
1024             return ret;
1025         case XAForm2:
1026             FIXME("XAForm2: NIY\n");
1027             return ret;
1028         case CDDA:
1029             /* 2048 = 2 ** 11 */
1030             if (raw->DiskOffset.s.HighPart & ~2047) FIXME("Unsupported value\n");
1031             ira.address.lba = ((raw->DiskOffset.s.LowPart >> 11) |
1032                 raw->DiskOffset.s.HighPart << (32 - 11)) - 1;
1033             ira.address_format = CD_LBA_FORMAT;
1034             ira.nframes = raw->SectorCount;
1035             ira.buffer = buffer;
1036             io = ioctl(dev, CDIOCREADAUDIO, &ira);
1037             break;
1038         }
1039     }
1040 #elif defined(__NetBSD__)
1041     {
1042         switch (raw->TrackMode)
1043         {
1044         case YellowMode2:
1045             FIXME("YellowMode2: NIY\n");
1046             return ret;
1047         case XAForm2:
1048             FIXME("XAForm2: NIY\n");
1049             return ret;
1050         case CDDA:
1051             FIXME("CDDA: NIY\n");
1052             return ret;
1053         }
1054     }
1055 #endif
1056     *sz = sectSize * raw->SectorCount;
1057     ret = CDROM_GetStatusCode(io);
1058     return ret;
1059 }
1060
1061 /******************************************************************
1062  *              CDROM_ScsiPassThroughDirect
1063  *
1064  *
1065  */
1066 static DWORD CDROM_ScsiPassThroughDirect(int dev, PSCSI_PASS_THROUGH_DIRECT pPacket)
1067 {
1068     int ret = STATUS_NOT_SUPPORTED;
1069 #if defined(linux)
1070     struct linux_cdrom_generic_command cmd;
1071     struct request_sense sense;
1072     int io;
1073
1074     if (pPacket->Length < sizeof(SCSI_PASS_THROUGH_DIRECT))
1075         return STATUS_BUFFER_TOO_SMALL;
1076
1077     if (pPacket->CdbLength > 12)
1078         return STATUS_INVALID_PARAMETER;
1079
1080     if (pPacket->SenseInfoLength > sizeof(sense))
1081         return STATUS_INVALID_PARAMETER;
1082
1083     memset(&cmd, 0, sizeof(cmd));
1084     memset(&sense, 0, sizeof(sense));
1085
1086     memcpy(&(cmd.cmd), &(pPacket->Cdb), pPacket->CdbLength);
1087
1088     cmd.buffer         = pPacket->DataBuffer;
1089     cmd.buflen         = pPacket->DataTransferLength;
1090     cmd.sense          = &sense;
1091     cmd.quiet          = 0;
1092     cmd.timeout        = pPacket->TimeOutValue*HZ;
1093
1094     switch (pPacket->DataIn)
1095     {
1096     case SCSI_IOCTL_DATA_OUT:
1097         cmd.data_direction = CGC_DATA_WRITE;
1098         break;
1099     case SCSI_IOCTL_DATA_IN:
1100         cmd.data_direction = CGC_DATA_READ;
1101         break;
1102     case SCSI_IOCTL_DATA_UNSPECIFIED:
1103         cmd.data_direction = CGC_DATA_NONE;
1104         break;
1105     default:
1106        return STATUS_INVALID_PARAMETER;
1107     }
1108
1109     io = ioctl(dev, CDROM_SEND_PACKET, &cmd);
1110
1111     if (pPacket->SenseInfoLength != 0)
1112     {
1113         memcpy((char*)pPacket + pPacket->SenseInfoOffset,
1114                &sense, pPacket->SenseInfoLength);
1115     }
1116
1117     pPacket->ScsiStatus = cmd.stat;
1118
1119     ret = CDROM_GetStatusCode(io);
1120 #endif
1121     return ret;
1122 }
1123
1124 /******************************************************************
1125  *              CDROM_ScsiPassThrough
1126  *
1127  *
1128  */
1129 static DWORD CDROM_ScsiPassThrough(int dev, PSCSI_PASS_THROUGH pPacket)
1130 {
1131     int ret = STATUS_NOT_SUPPORTED;
1132 #if defined(linux)
1133     struct linux_cdrom_generic_command cmd;
1134     struct request_sense sense;
1135     int io;
1136
1137     if (pPacket->Length < sizeof(SCSI_PASS_THROUGH))
1138         return STATUS_BUFFER_TOO_SMALL;
1139
1140     if (pPacket->CdbLength > 12)
1141         return STATUS_INVALID_PARAMETER;
1142
1143     if (pPacket->SenseInfoLength > sizeof(sense))
1144         return STATUS_INVALID_PARAMETER;
1145
1146     memset(&cmd, 0, sizeof(cmd));
1147     memset(&sense, 0, sizeof(sense));
1148
1149     memcpy(&(cmd.cmd), &(pPacket->Cdb), pPacket->CdbLength);
1150
1151     if ( pPacket->DataBufferOffset > 0x1000 )
1152     {
1153         cmd.buffer     = (void*)pPacket->DataBufferOffset;
1154     }
1155     else
1156     {
1157         cmd.buffer     = ((void*)pPacket) + pPacket->DataBufferOffset;
1158     }
1159     cmd.buflen         = pPacket->DataTransferLength;
1160     cmd.sense          = &sense;
1161     cmd.quiet          = 0;
1162     cmd.timeout        = pPacket->TimeOutValue*HZ;
1163
1164     switch (pPacket->DataIn)
1165     {
1166     case SCSI_IOCTL_DATA_OUT:
1167         cmd.data_direction = CGC_DATA_WRITE;
1168         break;
1169     case SCSI_IOCTL_DATA_IN:
1170         cmd.data_direction = CGC_DATA_READ;
1171         break;
1172     case SCSI_IOCTL_DATA_UNSPECIFIED:
1173         cmd.data_direction = CGC_DATA_NONE;
1174         break;
1175     default:
1176        return STATUS_INVALID_PARAMETER;
1177     }
1178
1179     io = ioctl(dev, CDROM_SEND_PACKET, &cmd);
1180
1181     if (pPacket->SenseInfoLength != 0)
1182     {
1183         memcpy((char*)pPacket + pPacket->SenseInfoOffset,
1184                &sense, pPacket->SenseInfoLength);
1185     }
1186
1187     pPacket->ScsiStatus = cmd.stat;
1188
1189     ret = CDROM_GetStatusCode(io);
1190 #endif
1191     return ret;
1192 }
1193
1194 /******************************************************************
1195  *              CDROM_GetAddress
1196  *
1197  * implements IOCTL_SCSI_GET_ADDRESS
1198  */
1199 static DWORD CDROM_GetAddress(int dev, SCSI_ADDRESS* address)
1200 {
1201     int portnum, targetid;
1202
1203     address->Length = sizeof(SCSI_ADDRESS);
1204     address->PathId = 0; /* bus number */
1205     address->Lun = 0;
1206     if ( ! CDROM_GetIdeInterface(dev, &portnum, &targetid))
1207         return STATUS_NOT_SUPPORTED;
1208
1209     address->PortNumber = portnum;
1210     address->TargetId = targetid;
1211     return 0;
1212 }
1213
1214 /******************************************************************
1215  *              CDROM_DeviceIoControl
1216  *
1217  *
1218  */
1219 BOOL CDROM_DeviceIoControl(DWORD clientID, HANDLE hDevice, DWORD dwIoControlCode,
1220                            LPVOID lpInBuffer, DWORD nInBufferSize,
1221                            LPVOID lpOutBuffer, DWORD nOutBufferSize,
1222                            LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
1223 {
1224     DWORD       sz;
1225     DWORD       error = 0;
1226     int         dev;
1227
1228     TRACE("%lx[%c] %lx %lx %ld %lx %ld %lx %lx\n",
1229           (DWORD)hDevice, 'A' + LOWORD(clientID), dwIoControlCode, (DWORD)lpInBuffer, nInBufferSize,
1230           (DWORD)lpOutBuffer, nOutBufferSize, (DWORD)lpBytesReturned, (DWORD)lpOverlapped);
1231
1232     if (lpBytesReturned) *lpBytesReturned = 0;
1233     if (lpOverlapped)
1234     {
1235         FIXME("Overlapped isn't implemented yet\n");
1236         SetLastError(STATUS_NOT_SUPPORTED);
1237         return FALSE;
1238     }
1239
1240     SetLastError(0);
1241     dev = CDROM_Open(hDevice, clientID);
1242     if (dev == -1)
1243     {
1244         CDROM_GetStatusCode(-1);
1245         return FALSE;
1246     }
1247
1248     switch (dwIoControlCode)
1249     {
1250     case IOCTL_STORAGE_CHECK_VERIFY:
1251     case IOCTL_CDROM_CHECK_VERIFY:
1252         sz = 0;
1253         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
1254             error = STATUS_INVALID_PARAMETER;
1255         else error = CDROM_Verify(dev);
1256         break;
1257
1258 /* EPP     case IOCTL_STORAGE_CHECK_VERIFY2: */
1259
1260 /* EPP     case IOCTL_STORAGE_FIND_NEW_DEVICES: */
1261 /* EPP     case IOCTL_CDROM_FIND_NEW_DEVICES: */
1262
1263     case IOCTL_STORAGE_LOAD_MEDIA:
1264     case IOCTL_CDROM_LOAD_MEDIA:
1265         sz = 0;
1266         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
1267             error = STATUS_INVALID_PARAMETER;
1268         else error = CDROM_SetTray(dev, FALSE);
1269         break;
1270      case IOCTL_STORAGE_EJECT_MEDIA:
1271         sz = 0;
1272         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
1273             error = STATUS_INVALID_PARAMETER;
1274         else error = CDROM_SetTray(dev, TRUE);
1275         break;
1276
1277     case IOCTL_CDROM_MEDIA_REMOVAL:
1278     case IOCTL_DISK_MEDIA_REMOVAL:
1279     case IOCTL_STORAGE_MEDIA_REMOVAL:
1280     case IOCTL_STORAGE_EJECTION_CONTROL:
1281         /* FIXME the last ioctl:s is not the same as the two others...
1282          * lockcount/owner should be handled */
1283         sz = 0;
1284         if (lpOutBuffer != NULL || nOutBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1285         else if (nInBufferSize < sizeof(PREVENT_MEDIA_REMOVAL)) error = STATUS_BUFFER_TOO_SMALL;
1286         else error = CDROM_ControlEjection(dev, (const PREVENT_MEDIA_REMOVAL*)lpInBuffer);
1287         break;
1288
1289 /* EPP     case IOCTL_STORAGE_GET_MEDIA_TYPES: */
1290
1291     case IOCTL_STORAGE_GET_DEVICE_NUMBER:
1292         sz = sizeof(STORAGE_DEVICE_NUMBER);
1293         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1294         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
1295         else error = CDROM_GetDeviceNumber(dev, (STORAGE_DEVICE_NUMBER*)lpOutBuffer);
1296         break;
1297
1298     case IOCTL_STORAGE_RESET_DEVICE:
1299         sz = 0;
1300         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
1301             error = STATUS_INVALID_PARAMETER;
1302         else error = CDROM_ResetAudio(dev);
1303         break;
1304
1305     case IOCTL_CDROM_GET_CONTROL:
1306         sz = sizeof(CDROM_AUDIO_CONTROL);
1307         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1308         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
1309         else error = CDROM_GetControl(dev, (CDROM_AUDIO_CONTROL*)lpOutBuffer);
1310         break;
1311
1312     case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
1313         sz = sizeof(DISK_GEOMETRY);
1314         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1315         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
1316         else error = CDROM_GetDriveGeometry(dev, (DISK_GEOMETRY*)lpOutBuffer);
1317         break;
1318
1319     case IOCTL_CDROM_DISK_TYPE:
1320         sz = sizeof(CDROM_DISK_DATA);
1321         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1322         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
1323         else error = CDROM_GetDiskData(dev, (CDROM_DISK_DATA*)lpOutBuffer);
1324         break;
1325
1326 /* EPP     case IOCTL_CDROM_GET_LAST_SESSION: */
1327
1328     case IOCTL_CDROM_READ_Q_CHANNEL:
1329         sz = sizeof(SUB_Q_CHANNEL_DATA);
1330         if (lpInBuffer == NULL || nInBufferSize < sizeof(CDROM_SUB_Q_DATA_FORMAT))
1331             error = STATUS_INVALID_PARAMETER;
1332         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
1333         else error = CDROM_ReadQChannel(dev, (const CDROM_SUB_Q_DATA_FORMAT*)lpInBuffer,
1334                                         (SUB_Q_CHANNEL_DATA*)lpOutBuffer);
1335         break;
1336
1337     case IOCTL_CDROM_READ_TOC:
1338         sz = sizeof(CDROM_TOC);
1339         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1340         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
1341         else error = CDROM_ReadTOC(dev, (CDROM_TOC*)lpOutBuffer);
1342         break;
1343
1344 /* EPP     case IOCTL_CDROM_READ_TOC_EX: */
1345
1346     case IOCTL_CDROM_PAUSE_AUDIO:
1347         sz = 0;
1348         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
1349             error = STATUS_INVALID_PARAMETER;
1350         else error = CDROM_PauseAudio(dev);
1351         break;
1352     case IOCTL_CDROM_PLAY_AUDIO_MSF:
1353         sz = 0;
1354         if (lpOutBuffer != NULL || nOutBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1355         else if (nInBufferSize < sizeof(CDROM_PLAY_AUDIO_MSF)) error = STATUS_BUFFER_TOO_SMALL;
1356         else error = CDROM_PlayAudioMSF(dev, (const CDROM_PLAY_AUDIO_MSF*)lpInBuffer);
1357         break;
1358     case IOCTL_CDROM_RESUME_AUDIO:
1359         sz = 0;
1360         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
1361             error = STATUS_INVALID_PARAMETER;
1362         else error = CDROM_ResumeAudio(dev);
1363         break;
1364     case IOCTL_CDROM_SEEK_AUDIO_MSF:
1365         sz = 0;
1366         if (lpOutBuffer != NULL || nOutBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1367         else if (nInBufferSize < sizeof(CDROM_SEEK_AUDIO_MSF)) error = STATUS_BUFFER_TOO_SMALL;
1368         else error = CDROM_SeekAudioMSF(dev, (const CDROM_SEEK_AUDIO_MSF*)lpInBuffer);
1369         break;
1370     case IOCTL_CDROM_STOP_AUDIO:
1371         sz = 0;
1372         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
1373             error = STATUS_INVALID_PARAMETER;
1374         else error = CDROM_StopAudio(dev);
1375         break;
1376     case IOCTL_CDROM_GET_VOLUME:
1377         sz = sizeof(VOLUME_CONTROL);
1378         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1379         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
1380         else error = CDROM_GetVolume(dev, (VOLUME_CONTROL*)lpOutBuffer);
1381         break;
1382     case IOCTL_CDROM_SET_VOLUME:
1383         sz = 0;
1384         if (lpInBuffer == NULL || nInBufferSize < sizeof(VOLUME_CONTROL) || lpOutBuffer != NULL)
1385             error = STATUS_INVALID_PARAMETER;
1386         else error = CDROM_SetVolume(dev, (const VOLUME_CONTROL*)lpInBuffer);
1387         break;
1388     case IOCTL_CDROM_RAW_READ:
1389         sz = 0;
1390         if (nInBufferSize < sizeof(RAW_READ_INFO)) error = STATUS_INVALID_PARAMETER;
1391         else if (lpOutBuffer == NULL) error = STATUS_BUFFER_TOO_SMALL;
1392         else error = CDROM_RawRead(dev, (const RAW_READ_INFO*)lpInBuffer,
1393                                    lpOutBuffer, nOutBufferSize, &sz);
1394         break;
1395     case IOCTL_SCSI_GET_ADDRESS:
1396         sz = sizeof(SCSI_ADDRESS);
1397         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
1398         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
1399         else error = CDROM_GetAddress(dev, (SCSI_ADDRESS*)lpOutBuffer);
1400         break;
1401     case IOCTL_SCSI_PASS_THROUGH_DIRECT:
1402         sz = sizeof(SCSI_PASS_THROUGH_DIRECT);
1403         if (lpOutBuffer == NULL) error = STATUS_INVALID_PARAMETER;
1404         else if (nOutBufferSize < sizeof(SCSI_PASS_THROUGH_DIRECT)) error = STATUS_BUFFER_TOO_SMALL;
1405         else error = CDROM_ScsiPassThroughDirect(dev, (PSCSI_PASS_THROUGH_DIRECT)lpOutBuffer);
1406         break;
1407     case IOCTL_SCSI_PASS_THROUGH:
1408         sz = sizeof(SCSI_PASS_THROUGH);
1409         if (lpOutBuffer == NULL) error = STATUS_INVALID_PARAMETER;
1410         else if (nOutBufferSize < sizeof(SCSI_PASS_THROUGH)) error = STATUS_BUFFER_TOO_SMALL;
1411         else error = CDROM_ScsiPassThrough(dev, (PSCSI_PASS_THROUGH)lpOutBuffer);
1412         break;
1413
1414     default:
1415         FIXME("Unsupported IOCTL %lx\n", dwIoControlCode);
1416         sz = 0;
1417         error = STATUS_INVALID_PARAMETER;
1418         break;
1419     }
1420
1421     if (lpBytesReturned) *lpBytesReturned = sz;
1422     if (error)
1423     {
1424         SetLastError(error);
1425         return FALSE;
1426     }
1427     CDROM_Close(clientID, dev);
1428     return TRUE;
1429 }