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 <unistd.h>
  28 #include <fcntl.h>
  29 #include <sys/ioctl.h>
  30 #include "ntddk.h"
  31 #include "winioctl.h"
  32 #include "ntddstor.h"
  33 #include "ntddcdrm.h"
  34 #include "drive.h"
  35 #include "file.h"
  36 #include "wine/debug.h"
  37
  38 #ifdef HAVE_LINUX_CDROM_H
  39 # include <linux/cdrom.h>
  40 #endif
  41 #ifdef HAVE_LINUX_UCDROM_H
  42 # include <linux/ucdrom.h>
  43 #endif
  44 #ifdef HAVE_SYS_CDIO_H
  45 # include <sys/cdio.h>
  46 #endif
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(cdrom);
  49
  50 /* FIXME: this is needed because we can't open simultaneously several times /dev/cdrom
  51  * this should be removed when a proper device interface is implemented
  52  */
  53 struct cdrom_cache {
  54     int fd;
  55     int count;
  56 };
  57 static struct cdrom_cache cdrom_cache[26];
  58
  59 /******************************************************************
  60  *              CDROM_Open
  61  *
  62  *
  63  */
  64 static int CDROM_Open(HANDLE hDevice, DWORD clientID)
  65 {
  66     int dev = LOWORD(clientID);
  67
  68     if (dev >= 26) return -1;
  69
  70     if (!cdrom_cache[dev].count)
  71     {
  72         char root[4];
  73
  74         strcpy(root, "A:\\");
  75         root[0] += dev;
  76         if (GetDriveTypeA(root) != DRIVE_CDROM) return -1;
  77         cdrom_cache[dev].fd = open(DRIVE_GetDevice(dev), O_RDONLY|O_NONBLOCK);
  78         if (cdrom_cache[dev].fd == -1)
  79         {
  80             FIXME("Can't open %s: %s\n", root, strerror(errno));
  81             return -1;
  82         }
  83     }
  84     cdrom_cache[dev].count++;
  85     return cdrom_cache[dev].fd;
  86 }
  87
  88 /******************************************************************
  89  *              CDROM_Close
  90  *
  91  *
  92  */
  93 static void CDROM_Close(DWORD clientID, int fd)
  94 {
  95     int dev = LOWORD(clientID);
  96
  97     if (dev >= 26 || fd != cdrom_cache[dev].fd) FIXME("how come\n");
  98     if (--cdrom_cache[dev].count == 0)
  99         close(cdrom_cache[dev].fd);
 100 }
 101
 102 /******************************************************************
 103  *              CDROM_GetStatusCode
 104  *
 105  *
 106  */
 107 static DWORD CDROM_GetStatusCode(int io)
 108 {
 109     if (io == 0) return 0;
 110     switch (errno)
 111     {
 112     case EIO:
 113     case ENOMEDIUM:
 114             return STATUS_NO_MEDIA_IN_DEVICE;
 115     }
 116     FIXME("Unmapped error code %d: %s\n", errno, strerror(errno));
 117     return STATUS_IO_DEVICE_ERROR;
 118 }
 119
 120 static DWORD CDROM_GetControl(int dev, CDROM_AUDIO_CONTROL* cac)
 121 {
 122     cac->LbaFormat = 0; /* FIXME */
 123     cac->LogicalBlocksPerSecond = 1; /* FIXME */
 124     return  STATUS_NOT_SUPPORTED;
 125 }
 126
 127 static DWORD CDROM_GetDeviceNumber(int dev, STORAGE_DEVICE_NUMBER* devnum)
 128 {
 129     return STATUS_NOT_SUPPORTED;
 130 }
 131
 132 static DWORD CDROM_GetDriveGeometry(int dev, DISK_GEOMETRY* dg)
 133 {
 134 #if 0
 135     dg->Cylinders.s.LowPart = 1; /* FIXME */
 136     dg->Cylinders.s.HighPart = 0; /* FIXME */
 137     dg->MediaType = 1; /* FIXME */
 138     dg->TracksPerCylinder = 1; /* FIXME */
 139     dg->SectorsPerTrack = 1; /* FIXME */
 140     dg->BytesPerSector= 1; /* FIXME */
 141 #endif
 142     return STATUS_NOT_SUPPORTED;
 143 }
 144
 145 /**************************************************************************
 146  *                              CDROM_Reset                     [internal]
 147  */
 148 static DWORD CDROM_ResetAudio(int dev)
 149 {
 150 #if defined(linux)
 151     return CDROM_GetStatusCode(ioctl(dev, CDROMRESET));
 152 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 153     return CDROM_GetStatusCode(ioctl(dev, CDIOCRESET, NULL));
 154 #else
 155     return STATUS_NOT_SUPPORTED;
 156 #endif
 157 }
 158
 159 /******************************************************************
 160  *              CDROM_SetTray
 161  *
 162  *
 163  */
 164 static DWORD CDROM_SetTray(int dev, BOOL doEject)
 165 {
 166 #if defined(linux)
 167     return CDROM_GetStatusCode(ioctl(dev, doEject ? CDROMEJECT : CDROMCLOSETRAY));
 168 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 169     return CDROM_GetStatusCode((ioctl(dev, CDIOCALLOW, NULL)) ||
 170                                (ioctl(dev, doEject ? CDIOCEJECT : CDIOCCLOSE, NULL)) ||
 171                                (ioctl(dev, CDIOCPREVENT, NULL)));
 172 #else
 173     return STATUS_NOT_SUPPORTED;
 174 #endif
 175 }
 176
 177 /******************************************************************
 178  *              CDROM_ControlEjection
 179  *
 180  *
 181  */
 182 static DWORD CDROM_ControlEjection(int dev, const PREVENT_MEDIA_REMOVAL* rmv)
 183 {
 184     int val = rmv->PreventMediaRemoval;
 185 #if defined(linux)
 186     return CDROM_GetStatusCode(ioctl(dev, CDROM_LOCKDOOR, val));
 187 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 188     return CDROM_GetStatusCode(ioctl(dev, (val) ? CDIOCPREVENT : CDIOCALLOW, NULL));
 189 #else
 190     return STATUS_NOT_SUPPORTED;
 191 #endif
 192 }
 193
 194 /******************************************************************
 195  *              CDROM_ReadTOC
 196  *
 197  *
 198  */
 199 static DWORD CDROM_ReadTOC(int dev, CDROM_TOC* toc)
 200 {
 201     DWORD       ret = STATUS_NOT_SUPPORTED;
 202
 203 #if defined(linux)
 204     int                         i, io = -1;
 205     struct cdrom_tochdr         hdr;
 206     struct cdrom_tocentry       entry;
 207
 208     io = ioctl(dev, CDROMREADTOCHDR, &hdr);
 209     if (io == -1)
 210     {
 211         WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
 212         goto end;
 213     }
 214     toc->FirstTrack = hdr.cdth_trk0;
 215     toc->LastTrack  = hdr.cdth_trk1;
 216
 217     TRACE("from=%d to=%d\n", toc->FirstTrack, toc->LastTrack);
 218
 219     for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
 220     {
 221         if (i == toc->LastTrack + 1)
 222         {
 223             entry.cdte_track = CDROM_LEADOUT;
 224         } else {
 225             entry.cdte_track = i;
 226         }
 227         entry.cdte_format = CDROM_MSF;
 228         io = ioctl(dev, CDROMREADTOCENTRY, &entry);
 229         if (io == -1) {
 230             WARN("error read entry (%s)\n", strerror(errno));
 231             goto end;
 232         }
 233         toc->TrackData[i - toc->FirstTrack].Control = entry.cdte_ctrl;
 234         toc->TrackData[i - toc->FirstTrack].Adr = entry.cdte_adr;
 235         /* marking last track with leadout value as index */
 236         toc->TrackData[i - toc->FirstTrack].TrackNumber = entry.cdte_track;
 237         toc->TrackData[i - toc->FirstTrack].Address[0] = 0;
 238         toc->TrackData[i - toc->FirstTrack].Address[1] = entry.cdte_addr.msf.minute;
 239         toc->TrackData[i - toc->FirstTrack].Address[2] = entry.cdte_addr.msf.second;
 240         toc->TrackData[i - toc->FirstTrack].Address[3] = entry.cdte_addr.msf.frame;
 241     }
 242 end:
 243     ret = CDROM_GetStatusCode(io);
 244 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 245     int                         i, io = -1;
 246     struct ioc_toc_header       hdr;
 247     struct ioc_read_toc_entry   entry;
 248     struct cd_toc_entry         toc_buffer;
 249
 250     io = ioctl(dev, CDIOREADTOCHEADER, &hdr);
 251     if (io == -1)
 252     {
 253         WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
 254         goto end;
 255     }
 256     toc->FirstTrack = hdr.starting_track;
 257     toc->LastTrack  = hdr.ending_track;
 258
 259     TRACE("from=%d to=%d\n", toc->FirstTrack, toc->LastTrack);
 260
 261     for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
 262     {
 263         if (i == toc->LastTrack + 1)
 264         {
 265 #define LEADOUT 0xaa
 266             entry.starting_track = LEADOUT;
 267         } else {
 268             entry.starting_track = i;
 269         }
 270         memset((char *)&toc_buffer, 0, sizeof(toc_buffer));
 271         entry.address_format = CD_MSF_FORMAT;
 272         entry.data_len = sizeof(toc_buffer);
 273         entry.data = &toc_buffer;
 274         io = ioctl(dev, CDIOREADTOCENTRYS, &entry);
 275         if (io == -1) {
 276             WARN("error read entry (%s)\n", strerror(errno));
 277             goto end;
 278         }
 279         toc->TrackData[i - toc->FirstTrack].Control = toc_buffer.control;
 280         toc->TrackData[i - toc->FirstTrack].Adr = toc_buffer.addr_type;
 281         /* marking last track with leadout value as index */
 282         toc->TrackData[i - toc->FirstTrack].TrackNumber = entry.starting_track;
 283         toc->TrackData[i - toc->FirstTrack].Address[0] = 0;
 284         toc->TrackData[i - toc->FirstTrack].Address[1] = toc_buffer.addr.msf.minute;
 285         toc->TrackData[i - toc->FirstTrack].Address[2] = toc_buffer.addr.msf.second;
 286         toc->TrackData[i - toc->FirstTrack].Address[3] = toc_buffer.addr.msf.frame;
 287     }
 288 end:
 289     ret = CDROM_GetStatusCode(io);
 290 #else
 291     ret = STATUS_NOT_SUPPORTED;
 292 #endif
 293     return ret;
 294 }
 295
 296 /******************************************************************
 297  *              CDROM_GetDiskData
 298  *
 299  *
 300  */
 301 static DWORD CDROM_GetDiskData(int dev, CDROM_DISK_DATA* data)
 302 {
 303     CDROM_TOC   toc;
 304     DWORD       ret;
 305     int         i;
 306
 307     if ((ret = CDROM_ReadTOC(dev, &toc)) != 0) return ret;
 308     data->DiskData = 0;
 309     for (i = toc.FirstTrack; i <= toc.LastTrack; i++) {
 310         if (toc.TrackData[i].Control & 0x04)
 311             data->DiskData |= CDROM_DISK_DATA_TRACK;
 312         else
 313             data->DiskData |= CDROM_DISK_AUDIO_TRACK;
 314     }
 315     return 0;
 316 }
 317
 318 /******************************************************************
 319  *              CDROM_ReadQChannel
 320  *
 321  *
 322  */
 323 static DWORD CDROM_ReadQChannel(int dev, const CDROM_SUB_Q_DATA_FORMAT* fmt,
 324                                 SUB_Q_CHANNEL_DATA* data)
 325 {
 326     DWORD               ret = STATUS_NOT_SUPPORTED;
 327     unsigned            size;
 328     SUB_Q_HEADER*       hdr = (SUB_Q_HEADER*)data;
 329     int                 io;
 330
 331 #ifdef linux
 332     struct cdrom_subchnl        sc;
 333     sc.cdsc_format = CDROM_MSF;
 334
 335     io = ioctl(dev, CDROMSUBCHNL, &sc);
 336     if (io == -1)
 337     {
 338         TRACE("opened or no_media (%s)!\n", strerror(errno));
 339         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 340         goto end;
 341     }
 342
 343     hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 344
 345     switch (sc.cdsc_audiostatus) {
 346     case CDROM_AUDIO_INVALID:
 347         hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 348         break;
 349     case CDROM_AUDIO_NO_STATUS:
 350         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 351         break;
 352     case CDROM_AUDIO_PLAY:
 353         hdr->AudioStatus = AUDIO_STATUS_IN_PROGRESS;
 354         break;
 355     case CDROM_AUDIO_PAUSED:
 356         hdr->AudioStatus = AUDIO_STATUS_PAUSED;
 357         break;
 358     case CDROM_AUDIO_COMPLETED:
 359         hdr->AudioStatus = AUDIO_STATUS_PLAY_COMPLETE;
 360         break;
 361     case CDROM_AUDIO_ERROR:
 362         hdr->AudioStatus = AUDIO_STATUS_PLAY_ERROR;
 363         break;
 364     default:
 365         TRACE("status=%02X !\n", sc.cdsc_audiostatus);
 366         break;
 367     }
 368     switch (fmt->Format)
 369     {
 370     case IOCTL_CDROM_CURRENT_POSITION:
 371         size = sizeof(SUB_Q_CURRENT_POSITION);
 372         data->CurrentPosition.FormatCode = sc.cdsc_format;
 373         data->CurrentPosition.Control = sc.cdsc_ctrl;
 374         data->CurrentPosition.ADR = sc.cdsc_adr;
 375         data->CurrentPosition.TrackNumber = sc.cdsc_trk;
 376         data->CurrentPosition.IndexNumber = sc.cdsc_ind;
 377
 378         data->CurrentPosition.AbsoluteAddress[0] = 0;
 379         data->CurrentPosition.AbsoluteAddress[1] = sc.cdsc_absaddr.msf.minute;
 380         data->CurrentPosition.AbsoluteAddress[2] = sc.cdsc_absaddr.msf.second;
 381         data->CurrentPosition.AbsoluteAddress[3] = sc.cdsc_absaddr.msf.frame;
 382
 383         data->CurrentPosition.TrackRelativeAddress[0] = 0;
 384         data->CurrentPosition.TrackRelativeAddress[1] = sc.cdsc_reladdr.msf.minute;
 385         data->CurrentPosition.TrackRelativeAddress[2] = sc.cdsc_reladdr.msf.second;
 386         data->CurrentPosition.TrackRelativeAddress[3] = sc.cdsc_reladdr.msf.frame;
 387         break;
 388     case IOCTL_CDROM_MEDIA_CATALOG:
 389         size = sizeof(SUB_Q_MEDIA_CATALOG_NUMBER);
 390         data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
 391         {
 392             struct cdrom_mcn mcn;
 393             if ((io = ioctl(dev, CDROM_GET_MCN, &mcn)) == -1) goto end;
 394
 395             data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
 396             data->MediaCatalog.Mcval = 0; /* FIXME */
 397             memcpy(data->MediaCatalog.MediaCatalog, mcn.medium_catalog_number, 14);
 398             data->MediaCatalog.MediaCatalog[14] = 0;
 399         }
 400         break;
 401     case IOCTL_CDROM_TRACK_ISRC:
 402         size = sizeof(SUB_Q_CURRENT_POSITION);
 403         FIXME("TrackIsrc: NIY on linux");
 404         data->TrackIsrc.FormatCode = IOCTL_CDROM_TRACK_ISRC;
 405         data->TrackIsrc.Tcval = 0;
 406         io = 0;
 407         break;
 408     }
 409
 410  end:
 411     ret = CDROM_GetStatusCode(io);
 412 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 413     struct ioc_read_subchannel  read_sc;
 414     struct cd_sub_channel_info  sc;
 415
 416     read_sc.address_format = CD_MSF_FORMAT;
 417     read_sc.track          = 0;
 418     read_sc.data_len       = sizeof(sc);
 419     read_sc.data           = &sc;
 420     switch (fmt->Format)
 421     {
 422     case IOCTL_CDROM_CURRENT_POSITION:
 423         read_sc.data_format    = CD_CURRENT_POSITION;
 424         break;
 425     case IOCTL_CDROM_MEDIA_CATALOG:
 426         read_sc.data_format    = CD_MEDIA_CATALOG;
 427         break;
 428     case IOCTL_CDROM_TRACK_ISRC:
 429         read_sc.data_format    = CD_TRACK_INFO;
 430         sc.what.track_info.track_number = data->TrackIsrc.Track;
 431         break;
 432     }
 433     io = ioctl(dev, CDIOCREADSUBCHANNEL, &read_sc);
 434     if (io == -1)
 435     {
 436         TRACE("opened or no_media (%s)!\n", strerror(errno));
 437         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 438         goto end;
 439     }
 440
 441     hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 442
 443     switch (sc.header.audio_status) {
 444     case CD_AS_AUDIO_INVALID:
 445         hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 446         break;
 447     case CD_AS_NO_STATUS:
 448         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 449         break;
 450     case CD_AS_PLAY_IN_PROGRESS:
 451         hdr->AudioStatus = AUDIO_STATUS_IN_PROGRESS;
 452         break;
 453     case CD_AS_PLAY_PAUSED:
 454         hdr->AudioStatus = AUDIO_STATUS_PAUSED;
 455         break;
 456     case CD_AS_PLAY_COMPLETED:
 457         hdr->AudioStatus = AUDIO_STATUS_PLAY_COMPLETE;
 458         break;
 459     case CD_AS_PLAY_ERROR:
 460         hdr->AudioStatus = AUDIO_STATUS_PLAY_ERROR;
 461         break;
 462     default:
 463         TRACE("status=%02X !\n", sc.header.audio_status);
 464     }
 465     switch (fmt->Format)
 466     {
 467     case IOCTL_CDROM_CURRENT_POSITION:
 468         size = sizeof(SUB_Q_CURRENT_POSITION);
 469         data->CurrentPosition.FormatCode = sc.what.position.data_format;
 470         data->CurrentPosition.Control = sc.what.position.control;
 471         data->CurrentPosition.ADR = sc.what.position.addr_type;
 472         data->CurrentPosition.TrackNumber = sc.what.position.track_number;
 473         data->CurrentPosition.IndexNumber = sc.what.position.index_number;
 474
 475         data->CurrentPosition.AbsoluteAddress[0] = 0;
 476         data->CurrentPosition.AbsoluteAddress[1] = sc.what.position.absaddr.msf.minute;
 477         data->CurrentPosition.AbsoluteAddress[2] = sc.what.position.absaddr.msf.second;
 478         data->CurrentPosition.AbsoluteAddress[3] = sc.what.position.absaddr.msf.frame;
 479         data->CurrentPosition.TrackRelativeAddress[0] = 0;
 480         data->CurrentPosition.TrackRelativeAddress[1] = sc.what.position.reladdr.msf.minute;
 481         data->CurrentPosition.TrackRelativeAddress[2] = sc.what.position.reladdr.msf.second;
 482         data->CurrentPosition.TrackRelativeAddress[3] = sc.what.position.reladdr.msf.frame;
 483         break;
 484     case IOCTL_CDROM_MEDIA_CATALOG:
 485         size = sizeof(SUB_Q_MEDIA_CATALOG_NUMBER);
 486         data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
 487         data->MediaCatalog.FormatCode = sc.what.media_catalog.data_format;
 488         data->MediaCatalog.Mcval = sc.what.media_catalog.mc_valid;
 489         memcpy(data->MediaCatalog.MediaCatalog, sc.what.media_catalog.mc_number, 15);
 490         break;
 491     case IOCTL_CDROM_TRACK_ISRC:
 492         size = sizeof(SUB_Q_CURRENT_POSITION);
 493         data->TrackIsrc.Tcval = sc.what.track_info.ti_valid;
 494         memcpy(data->TrackIsrc.TrackIsrc, sc.what.track_info.ti_number, 15);
 495         break;
 496     }
 497
 498  end:
 499     ret = CDROM_GetStatusCode(io);
 500 #endif
 501     return ret;
 502 }
 503
 504 /******************************************************************
 505  *              CDROM_Verify
 506  *
 507  *
 508  */
 509 static DWORD CDROM_Verify(int dev)
 510 {
 511     /* quick implementation */
 512     CDROM_SUB_Q_DATA_FORMAT     fmt;
 513     SUB_Q_CHANNEL_DATA          data;
 514
 515     fmt.Format = IOCTL_CDROM_CURRENT_POSITION;
 516     return CDROM_ReadQChannel(dev, &fmt, &data) ? 0 : 1;
 517 }
 518
 519 /******************************************************************
 520  *              CDROM_PlayAudioMSF
 521  *
 522  *
 523  */
 524 static DWORD CDROM_PlayAudioMSF(int dev, const CDROM_PLAY_AUDIO_MSF* audio_msf)
 525 {
 526     DWORD       ret = STATUS_NOT_SUPPORTED;
 527 #ifdef linux
 528     struct      cdrom_msf       msf;
 529     int         io;
 530
 531     msf.cdmsf_min0   = audio_msf->StartingM;
 532     msf.cdmsf_sec0   = audio_msf->StartingS;
 533     msf.cdmsf_frame0 = audio_msf->StartingF;
 534     msf.cdmsf_min1   = audio_msf->EndingM;
 535     msf.cdmsf_sec1   = audio_msf->EndingS;
 536     msf.cdmsf_frame1 = audio_msf->EndingF;
 537
 538     io = ioctl(dev, CDROMSTART);
 539     if (io == -1)
 540     {
 541         WARN("motor doesn't start !\n");
 542         goto end;
 543     }
 544     io = ioctl(dev, CDROMPLAYMSF, &msf);
 545     if (io == -1)
 546     {
 547         WARN("device doesn't play !\n");
 548         goto end;
 549     }
 550     TRACE("msf = %d:%d:%d %d:%d:%d\n",
 551           msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0,
 552           msf.cdmsf_min1, msf.cdmsf_sec1, msf.cdmsf_frame1);
 553  end:
 554     ret = CDROM_GetStatusCode(io);
 555 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 556     struct      ioc_play_msf    msf;
 557     int         io;
 558
 559     msf.start_m      = audio_msf->StartingM;
 560     msf.start_s      = audio_msf->StartingS;
 561     msf.start_f      = audio_msf->StartingF;
 562     msf.end_m        = audio_msf->EndingM;
 563     msf.end_s        = audio_msf->EndingS;
 564     msf.end_f        = audio_msf->EndingF;
 565
 566     io = ioctl(dev, CDIOCSTART, NULL);
 567     if (io == -1)
 568     {
 569         WARN("motor doesn't start !\n");
 570         goto end;
 571     }
 572     io = ioctl(dev, CDIOCPLAYMSF, &msf);
 573     if (io == -1)
 574     {
 575         WARN("device doesn't play !\n");
 576         goto end;
 577     }
 578     TRACE("msf = %d:%d:%d %d:%d:%d\n",
 579           msf.start_m, msf.start_s, msf.start_f,
 580           msf.end_m,   msf.end_s,   msf.end_f);
 581 end:
 582     ret = CDROM_GetStatusCode(io);
 583 #endif
 584     return ret;
 585 }
 586
 587 /******************************************************************
 588  *              CDROM_SeekAudioMSF
 589  *
 590  *
 591  */
 592 static DWORD CDROM_SeekAudioMSF(int dev, const CDROM_SEEK_AUDIO_MSF* audio_msf)
 593 {
 594 #if defined(linux)
 595     struct cdrom_msf0   msf;
 596     msf.minute = audio_msf->M;
 597     msf.second = audio_msf->S;
 598     msf.frame  = audio_msf->F;
 599
 600     return CDROM_GetStatusCode(ioctl(dev, CDROMSEEK, &msf));
 601 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 602     FIXME("Could a BSD expert implement the seek function ?\n");
 603     return STATUS_NOT_SUPPORTED;
 604 #else
 605     return STATUS_NOT_SUPPORTED;
 606 #endif
 607 }
 608
 609 /******************************************************************
 610  *              CDROM_PauseAudio
 611  *
 612  *
 613  */
 614 static DWORD CDROM_PauseAudio(int dev)
 615 {
 616 #if defined(linux)
 617     return CDROM_GetStatusCode(ioctl(dev, CDROMPAUSE));
 618 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 619     return CDROM_GetStatusCode(ioctl(dev, CDIOCPAUSE, NULL));
 620 #else
 621     return STATUS_NOT_SUPPORTED;
 622 #endif
 623 }
 624
 625 /******************************************************************
 626  *              CDROM_ResumeAudio
 627  *
 628  *
 629  */
 630 static DWORD CDROM_ResumeAudio(int dev)
 631 {
 632 #if defined(linux)
 633     return CDROM_GetStatusCode(ioctl(dev, CDROMRESUME));
 634 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 635     return CDROM_GetStatusCode(ioctl(dev, CDIOCRESUME, NULL));
 636 #else
 637     return STATUS_NOT_SUPPORTED;
 638 #endif
 639 }
 640
 641 /******************************************************************
 642  *              CDROM_StopAudio
 643  *
 644  *
 645  */
 646 static DWORD CDROM_StopAudio(int dev)
 647 {
 648 #if defined(linux)
 649     return CDROM_GetStatusCode(ioctl(dev, CDROMSTOP));
 650 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 651     return CDROM_GetStatusCode(ioctl(dev, CDIOCSTOP, NULL));
 652 #else
 653     return STATUS_NOT_SUPPORTED;
 654 #endif
 655 }
 656
 657 /******************************************************************
 658  *              CDROM_GetVolume
 659  *
 660  *
 661  */
 662 static DWORD CDROM_GetVolume(int dev, VOLUME_CONTROL* vc)
 663 {
 664 #if defined(linux)
 665     struct cdrom_volctrl volc;
 666     int io;
 667
 668     io = ioctl(dev, CDROMVOLREAD, &volc);
 669     if (io != -1)
 670     {
 671         vc->PortVolume[0] = volc.channel0;
 672         vc->PortVolume[1] = volc.channel1;
 673         vc->PortVolume[2] = volc.channel2;
 674         vc->PortVolume[3] = volc.channel3;
 675     }
 676     return CDROM_GetStatusCode(io);
 677 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 678     struct  ioc_vol     volc;
 679     int io;
 680
 681     io = ioctl(dev, CDIOCGETVOL, &volc);
 682     if (io != -1)
 683     {
 684         vc->PortVolume[0] = volc.vol[0];
 685         vc->PortVolume[1] = volc.vol[1];
 686         vc->PortVolume[2] = volc.vol[2];
 687         vc->PortVolume[3] = volc.vol[3];
 688     }
 689     return CDROM_GetStatusCode(io);
 690 #else
 691     return STATUS_NOT_SUPPORTED;
 692 #endif
 693 }
 694
 695 /******************************************************************
 696  *              CDROM_SetVolume
 697  *
 698  *
 699  */
 700 static DWORD CDROM_SetVolume(int dev, const VOLUME_CONTROL* vc)
 701 {
 702 #if defined(linux)
 703     struct cdrom_volctrl volc;
 704
 705     volc.channel0 = vc->PortVolume[0];
 706     volc.channel1 = vc->PortVolume[1];
 707     volc.channel2 = vc->PortVolume[2];
 708     volc.channel3 = vc->PortVolume[3];
 709
 710     return CDROM_GetStatusCode(ioctl(dev, CDROMVOLCTRL, &volc));
 711 #elif defined(__FreeBSD__) || defined(__NetBSD__)
 712     struct  ioc_vol     volc;
 713
 714     volc.vol[0] = vc->PortVolume[0];
 715     volc.vol[1] = vc->PortVolume[1];
 716     volc.vol[2] = vc->PortVolume[2];
 717     volc.vol[3] = vc->PortVolume[3];
 718
 719     return CDROM_GetStatusCode(ioctl(dev, CDIOCSETVOL, &volc));
 720 #else
 721     return STATUS_NOT_SUPPORTED;
 722 #endif
 723 }
 724
 725 /******************************************************************
 726  *              CDROM_RawRead
 727  *
 728  *
 729  */
 730 static DWORD CDROM_RawRead(int dev, const RAW_READ_INFO* raw, void* buffer, DWORD len, DWORD* sz)
 731 {
 732     int         ret = STATUS_NOT_SUPPORTED;
 733     int         io = -1;
 734     DWORD       sectSize;
 735
 736     switch (raw->TrackMode)
 737     {
 738     case YellowMode2:   sectSize = 2336;        break;
 739     case XAForm2:       sectSize = 2328;        break;
 740     case CDDA:          sectSize = 2352;        break;
 741     default:    return STATUS_INVALID_PARAMETER;
 742     }
 743     if (len < raw->SectorCount * sectSize) return STATUS_BUFFER_TOO_SMALL;
 744     /* strangely enough, it seems that sector offsets are always indicated with a size of 2048,
 745      * even if a larger size if read...
 746      */
 747 #if defined(linux)
 748     {
 749         struct cdrom_read       cdr;
 750         struct cdrom_read_audio cdra;
 751
 752         switch (raw->TrackMode)
 753         {
 754         case YellowMode2:
 755             if (raw->DiskOffset.s.HighPart) FIXME("Unsupported value\n");
 756             cdr.cdread_lba = raw->DiskOffset.s.LowPart; /* FIXME ? */
 757             cdr.cdread_bufaddr = buffer;
 758             cdr.cdread_buflen = raw->SectorCount * sectSize;
 759             io = ioctl(dev, CDROMREADMODE2, &cdr);
 760             break;
 761         case XAForm2:
 762             FIXME("XAForm2: NIY\n");
 763             return ret;
 764         case CDDA:
 765             /* FIXME: the output doesn't seem 100% correct... in fact output is shifted
 766              * between by NT2K box and this... should check on the same drive...
 767              * otherwise, I fear a 2352/2368 mismatch somewhere in one of the drivers
 768              * (linux/NT).
 769              * Anyway, that's not critical at all. We're talking of 16/32 bytes, we're
 770              * talking of 0.2 ms of sound
 771              */
 772             /* 2048 = 2 ** 11 */
 773             if (raw->DiskOffset.s.HighPart & ~2047) FIXME("Unsupported value\n");
 774             cdra.addr.lba = ((raw->DiskOffset.s.LowPart >> 11) |
 775                 (raw->DiskOffset.s.HighPart << (32 - 11))) - 1;
 776             FIXME("reading at %u\n", cdra.addr.lba);
 777             cdra.addr_format = CDROM_LBA;
 778             cdra.nframes = raw->SectorCount;
 779             cdra.buf = buffer;
 780             io = ioctl(dev, CDROMREADAUDIO, &cdra);
 781             break;
 782         }
 783     }
 784 #elif defined(__FreeBSD__)
 785     {
 786         struct ioc_read_audio   ira;
 787
 788         switch (raw->TrackMode)
 789         {
 790         case YellowMode2:
 791             FIXME("YellowMode2: NIY\n");
 792             return ret;
 793         case XAForm2:
 794             FIXME("XAForm2: NIY\n");
 795             return ret;
 796         case CDDA:
 797             /* 2048 = 2 ** 11 */
 798             if (raw->DiskOffset.s.HighPart & ~2047) FIXME("Unsupported value\n");
 799             ira.address.lba = ((raw->DiskOffset.s.LowPart >> 11) |
 800                 raw->DiskOffset.s.HighPart << (32 - 11)) - 1;
 801             ira.address_format = CD_LBA_FORMAT;
 802             ira.nframes = raw->SectorCount;
 803             ira.buffer = buffer;
 804             io = ioctl(dev, CDIOCREADAUDIO, &ira);
 805             break;
 806         }
 807     }
 808 #elif defined(__NetBSD__)
 809     {
 810         switch (raw->TrackMode)
 811         {
 812         case YellowMode2:
 813             FIXME("YellowMode2: NIY\n");
 814             return ret;
 815         case XAForm2:
 816             FIXME("XAForm2: NIY\n");
 817             return ret;
 818         case CDDA:
 819             FIXME("CDDA: NIY\n");
 820             return ret;
 821         }
 822     }
 823 #endif
 824     *sz = sectSize * raw->SectorCount;
 825     ret = CDROM_GetStatusCode(io);
 826     return ret;
 827 }
 828
 829 /******************************************************************
 830  *              CDROM_DeviceIoControl
 831  *
 832  *
 833  */
 834 BOOL CDROM_DeviceIoControl(DWORD clientID, HANDLE hDevice, DWORD dwIoControlCode,
 835                            LPVOID lpInBuffer, DWORD nInBufferSize,
 836                            LPVOID lpOutBuffer, DWORD nOutBufferSize,
 837                            LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
 838 {
 839     DWORD       sz;
 840     DWORD       error = 0;
 841     int         dev;
 842
 843     TRACE("%lx[%c] %lx %lx %ld %lx %ld %lx %lx\n",
 844           (DWORD)hDevice, 'A' + LOWORD(clientID), dwIoControlCode, (DWORD)lpInBuffer, nInBufferSize,
 845           (DWORD)lpOutBuffer, nOutBufferSize, (DWORD)lpBytesReturned, (DWORD)lpOverlapped);
 846
 847     if (lpBytesReturned) *lpBytesReturned = 0;
 848     if (lpOverlapped)
 849     {
 850         FIXME("Overlapped isn't implemented yet\n");
 851         SetLastError(STATUS_NOT_SUPPORTED);
 852         return FALSE;
 853     }
 854
 855     SetLastError(0);
 856     dev = CDROM_Open(hDevice, clientID);
 857     if (dev == -1)
 858     {
 859         CDROM_GetStatusCode(-1);
 860         return FALSE;
 861     }
 862
 863     switch (dwIoControlCode)
 864     {
 865     case IOCTL_STORAGE_CHECK_VERIFY:
 866     case IOCTL_CDROM_CHECK_VERIFY:
 867         sz = 0;
 868         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
 869             error = STATUS_INVALID_PARAMETER;
 870         else error = CDROM_Verify(dev);
 871         break;
 872
 873 /* EPP     case IOCTL_STORAGE_CHECK_VERIFY2: */
 874
 875 /* EPP     case IOCTL_STORAGE_FIND_NEW_DEVICES: */
 876 /* EPP     case IOCTL_CDROM_FIND_NEW_DEVICES: */
 877
 878     case IOCTL_STORAGE_LOAD_MEDIA:
 879     case IOCTL_CDROM_LOAD_MEDIA:
 880         sz = 0;
 881         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
 882             error = STATUS_INVALID_PARAMETER;
 883         else error = CDROM_SetTray(dev, FALSE);
 884         break;
 885      case IOCTL_STORAGE_EJECT_MEDIA:
 886         sz = 0;
 887         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
 888             error = STATUS_INVALID_PARAMETER;
 889         else error = CDROM_SetTray(dev, TRUE);
 890         break;
 891
 892     case IOCTL_DISK_MEDIA_REMOVAL:
 893     case IOCTL_STORAGE_MEDIA_REMOVAL:
 894     case IOCTL_STORAGE_EJECTION_CONTROL:
 895         /* FIXME the last ioctl:s is not the same as the two others...
 896          * lockcount/owner should be handled */
 897         sz = 0;
 898         if (lpOutBuffer != NULL || nOutBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 899         else if (nInBufferSize < sizeof(PREVENT_MEDIA_REMOVAL)) error = STATUS_BUFFER_TOO_SMALL;
 900         else error = CDROM_ControlEjection(dev, (const PREVENT_MEDIA_REMOVAL*)lpInBuffer);
 901         break;
 902
 903 /* EPP     case IOCTL_STORAGE_GET_MEDIA_TYPES: */
 904
 905     case IOCTL_STORAGE_GET_DEVICE_NUMBER:
 906         sz = sizeof(STORAGE_DEVICE_NUMBER);
 907         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 908         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
 909         else error = CDROM_GetDeviceNumber(dev, (STORAGE_DEVICE_NUMBER*)lpOutBuffer);
 910         break;
 911
 912     case IOCTL_STORAGE_RESET_DEVICE:
 913         sz = 0;
 914         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
 915             error = STATUS_INVALID_PARAMETER;
 916         else error = CDROM_ResetAudio(dev);
 917         break;
 918
 919     case IOCTL_CDROM_GET_CONTROL:
 920         sz = sizeof(CDROM_AUDIO_CONTROL);
 921         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 922         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
 923         else error = CDROM_GetControl(dev, (CDROM_AUDIO_CONTROL*)lpOutBuffer);
 924         break;
 925
 926     case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
 927         sz = sizeof(DISK_GEOMETRY);
 928         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 929         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
 930         else error = CDROM_GetDriveGeometry(dev, (DISK_GEOMETRY*)lpOutBuffer);
 931         break;
 932
 933     case IOCTL_CDROM_DISK_TYPE:
 934         sz = sizeof(CDROM_DISK_DATA);
 935         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 936         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
 937         else error = CDROM_GetDiskData(dev, (CDROM_DISK_DATA*)lpOutBuffer);
 938         break;
 939
 940 /* EPP     case IOCTL_CDROM_GET_LAST_SESSION: */
 941
 942     case IOCTL_CDROM_READ_Q_CHANNEL:
 943         sz = sizeof(SUB_Q_CHANNEL_DATA);
 944         if (lpInBuffer == NULL || nInBufferSize < sizeof(CDROM_SUB_Q_DATA_FORMAT))
 945             error = STATUS_INVALID_PARAMETER;
 946         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
 947         else error = CDROM_ReadQChannel(dev, (const CDROM_SUB_Q_DATA_FORMAT*)lpInBuffer,
 948                                         (SUB_Q_CHANNEL_DATA*)lpOutBuffer);
 949         break;
 950
 951     case IOCTL_CDROM_READ_TOC:
 952         sz = sizeof(CDROM_TOC);
 953         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 954         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
 955         else error = CDROM_ReadTOC(dev, (CDROM_TOC*)lpOutBuffer);
 956         break;
 957
 958 /* EPP     case IOCTL_CDROM_READ_TOC_EX: */
 959
 960     case IOCTL_CDROM_PAUSE_AUDIO:
 961         sz = 0;
 962         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
 963             error = STATUS_INVALID_PARAMETER;
 964         else error = CDROM_PauseAudio(dev);
 965         break;
 966     case IOCTL_CDROM_PLAY_AUDIO_MSF:
 967         sz = 0;
 968         if (lpOutBuffer != NULL || nOutBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 969         else if (nInBufferSize < sizeof(CDROM_PLAY_AUDIO_MSF)) error = STATUS_BUFFER_TOO_SMALL;
 970         else error = CDROM_PlayAudioMSF(dev, (const CDROM_PLAY_AUDIO_MSF*)lpInBuffer);
 971         break;
 972     case IOCTL_CDROM_RESUME_AUDIO:
 973         sz = 0;
 974         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
 975             error = STATUS_INVALID_PARAMETER;
 976         else error = CDROM_ResumeAudio(dev);
 977         break;
 978     case IOCTL_CDROM_SEEK_AUDIO_MSF:
 979         sz = 0;
 980         if (lpOutBuffer != NULL || nOutBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 981         else if (nInBufferSize < sizeof(CDROM_SEEK_AUDIO_MSF)) error = STATUS_BUFFER_TOO_SMALL;
 982         else error = CDROM_SeekAudioMSF(dev, (const CDROM_SEEK_AUDIO_MSF*)lpInBuffer);
 983         break;
 984     case IOCTL_CDROM_STOP_AUDIO:
 985         sz = 0;
 986         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
 987             error = STATUS_INVALID_PARAMETER;
 988         else error = CDROM_StopAudio(dev);
 989         break;
 990     case IOCTL_CDROM_GET_VOLUME:
 991         sz = sizeof(VOLUME_CONTROL);
 992         if (lpInBuffer != NULL || nInBufferSize != 0) error = STATUS_INVALID_PARAMETER;
 993         else if (nOutBufferSize < sz) error = STATUS_BUFFER_TOO_SMALL;
 994         else error = CDROM_GetVolume(dev, (VOLUME_CONTROL*)lpOutBuffer);
 995         break;
 996     case IOCTL_CDROM_SET_VOLUME:
 997         sz = 0;
 998         if (lpInBuffer == NULL || nInBufferSize < sizeof(VOLUME_CONTROL) || lpOutBuffer != NULL)
 999             error = STATUS_INVALID_PARAMETER;
1000         else error = CDROM_SetVolume(dev, (const VOLUME_CONTROL*)lpInBuffer);
1001         break;
1002     case IOCTL_CDROM_RAW_READ:
1003         sz = 0;
1004         if (nInBufferSize < sizeof(RAW_READ_INFO)) error = STATUS_INVALID_PARAMETER;
1005         else if (lpOutBuffer == NULL) error = STATUS_BUFFER_TOO_SMALL;
1006         else error = CDROM_RawRead(dev, (const RAW_READ_INFO*)lpInBuffer,
1007                                    lpOutBuffer, nOutBufferSize, &sz);
1008         break;
1009     default:
1010         FIXME("Unsupported IOCTL %lx\n", dwIoControlCode);
1011         sz = 0;
1012         error = STATUS_INVALID_PARAMETER;
1013         break;
1014     }
1015
1016     if (lpBytesReturned) *lpBytesReturned = sz;
1017     if (error)
1018     {
1019         SetLastError(error);
1020         return FALSE;
1021     }
1022     CDROM_Close(clientID, dev);
1023     return TRUE;
1024 }
1025