windows-server-2003/drivers/storage/redbook/redbook.h

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1998 - 1999
//
//  File:       redbook.h
//
//--------------------------------------------------------------------------

//////////////////////////////////////////////////////////

#ifndef __REDBOOK_H__
#define __REDBOOK_H__

//
// these two includes required for stuctures
// used in device extension for kernel streaming
//

#include <ntddk.h>
#include <ntddscsi.h>
#include <ntddcdrm.h>
#include <ntdddisk.h>  // IOCTL_DISK_CHECK_VERIFY
#include <ntddredb.h>  // wmi structure and ids

#include <stdio.h>     // vsprintf()
#include <wmistr.h>    // WMIREG_FLAG_INSTANCE_PDO
#include <wmilib.h>    // WMILIB_CONTEXT
#include <windef.h>    // for ks.h
#include <ks.h>        // for mmsystem.h
#include <mmsystem.h>  // for ksmedia.h
#include <ksmediap.h>  // required.
#include "errlog.h"

#include "trace.h"   // ETW enabling

#ifndef POOL_TAGGING
    #ifdef ExAllocatePoolWithTag
        #undef ExAllocatePoolWithTag
    #endif
    #define ExAllocatePoolWithTag(a,b,c) ExAllocatePool(a,b)

    #ifdef ExAllocatePoolWithTagPriority
        #undef ExAllocatePoolWithTagPriority
    #endif
    #define ExAllocatePoolWithTagPriority(a,b,c,d) ExAllocatePool(a,b)
#endif // endif POOL_TAGGING

#define MOFRESOURCENAME L"Redbook"

// static alloc's
#define TAG_GET_DESC   'edBR' // storage descriptor (returned to caller)
#define TAG_GET_DESC1  '1dBR' // getting storage descriptor
#define TAG_GET_DESC2  '2dBR' // getting storage descriptor
#define TAG_MODE_PAGE  'apBR' // mode pages (returned to caller)
#define TAG_MODE_PAGE1 '1pBR' // getting mode pages
#define TAG_MODE_PAGE2 '2pBR' // getting mode pages

#define TAG_EVENTS     'veBR' // extension->Thread.Events[]
#define TAG_REGPATH    'grBR' // driverExtensionObject->RegistryPath
#define TAG_REMLOCK    'lrBR' // Remove lock

#define TAG_T_IOCTL    'itBR' // THREAD_IOCTL   struct
#define TAG_T_WMI      'wtBR' // THREAD_WMI     struct
#define TAG_T_DIGITAL  'dtBR' // THREAD_DIGITAL struct

// allocs when playing
#define TAG_BUFFER     'uBBR' // Buffer->SkipBuffer
#define TAG_CC         'cCBR' // Buffer->StreamContext
#define TAG_READX      'xRBR' // Buffer->ReadOk_X
#define TAG_STREAMX    'xSBR' // Buffer->StreamOk_X

#define TAG_TOC        'oTBR' // deviceExtension->Cached.Toc
#define TAG_CV_BUFFER  'vCBR' // deviceExtension->Thread.CheckVerifyIrp->AssociatedIrp.SystemBuffer

#define CD_STOPPED         0x00000001
#define CD_PAUSED          0x00000002
#define CD_PLAYING         0x00000004
#define CD_STOPPING        0x00000010 // temp states
#define CD_PAUSING         0x00000020 // temp states

// NOTE: CD_MASK_STATE must have exactly one bit set.
// NOTE: CD_MASK_TEMP  may have zero or one bit set.
#define CD_MASK_TEMP       0x00000030 // mask of bits for transition states
#define CD_MASK_STATE      0x00000007 // mask of bits for non-temp state
#define CD_MASK_ALL        0x00000037 // mask of currently used bits

#define REMOVE_LOCK_MAX_MINUTES 10    // ten minutes max time per io
#define REMOVE_LOCK_HIGH_MARK   10000 // ten thousand concurrent ios?

#define REDBOOK_REG_SUBKEY_NAME             (L"DigitalAudio")
#define REDBOOK_REG_CDDA_ACCURATE_KEY_NAME  (L"CDDAAccurate")
#define REDBOOK_REG_CDDA_SUPPORTED_KEY_NAME (L"CDDASupported")
#define REDBOOK_REG_SECTORS_MASK_KEY_NAME   (L"SectorsPerReadMask")
#define REDBOOK_REG_SECTORS_KEY_NAME        (L"SectorsPerRead")
#define REDBOOK_REG_BUFFERS_KEY_NAME        (L"NumberOfBuffers")
#define REDBOOK_REG_VERSION_KEY_NAME        (L"RegistryVersion")

#define REDBOOK_MAX_CONSECUTIVE_ERRORS 10

#define REDBOOK_WMI_BUFFERS_MAX        30 // must be at least 3 due to
#define REDBOOK_WMI_BUFFERS_MIN         4 // method used to reduce stuttering

#define REDBOOK_WMI_SECTORS_MAX        27 // 64k per read -- 1/3 sec.
#define REDBOOK_WMI_SECTORS_MIN         1 // most processor-intensive

#define REDBOOK_REG_VERSION             1

//
// A single sector from a CD is 2352 bytes
//

#define RAW_SECTOR_SIZE            2352
#define COOKED_SECTOR_SIZE         2048

//
// these events are initialized to false, and are waited
// upon by the system thread. synchronization events all
//
// order is important, as the thread will wait on either
// events 0-3  _OR_  1-4 to allow easy processing of
// ioctls that require multiple state changes.
//

#define EVENT_IOCTL        0  // an ioctl, possibly state change
#define EVENT_WMI          1  // a wmi request, possibly buffer size changes
#define EVENT_DIGITAL      2  // digital reads/digital play
#define EVENT_KILL_THREAD  3  // thread is about to die
#define EVENT_COMPLETE     4  // complete processing of an ioctl
#define EVENT_MAXIMUM      5  // how many events we have



typedef struct _REDBOOK_STREAM_DATA
    *PREDBOOK_STREAM_DATA;
typedef struct _REDBOOK_BUFFER_DATA
    *PREDBOOK_BUFFER_DATA;
typedef struct _REDBOOK_CDROM_INFO
    *PREDBOOK_CDROM_INFO;
typedef struct _REDBOOK_DEVICE_EXTENSION
    *PREDBOOK_DEVICE_EXTENSION;
typedef struct _REDBOOK_COMPLETION_CONTEXT
    *PREDBOOK_COMPLETION_CONTEXT;

//
// Device Extension
//

typedef struct _REDBOOK_ERROR_LOG_DATA {
    LONG  Count;                       // how many errors messages sent
    ULONG RCount[REDBOOK_ERR_MAXIMUM]; // count of each error
} REDBOOK_ERROR_LOG_DATA, *PREDBOOK_ERROR_LOG_DATA;

typedef struct _REDBOOK_STREAM_DATA {

    PFILE_OBJECT    PinFileObject;  // FileObject for pin
    PDEVICE_OBJECT  PinDeviceObject;// DeviceObject for pin
    ULONG           VolumeNodeId;   // where is the device for this though?
    ULONG           MixerPinId;     // Pin of the mixer in sysaudio
    PFILE_OBJECT    MixerFileObject;// keeps a reference to the object

    ULONG           UpdateMixerPin; // PnpNotification arrived
    PVOID           SysAudioReg;    // For SysAudio PnpNotification

    //
    // the next two are win98's 'MY_PIN'
    // THESE TWO STRUCTS MUST BE KEPT CONTIGUOUS
    //
    struct {
        KSPIN_CONNECT  Connect;
        KSDATAFORMAT_WAVEFORMATEX Format;
    };

} REDBOOK_STREAM_DATA, *PREDBOOK_STREAM_DATA;

//
// move this struct's parts into REDBOOK_THREAD_DATA,
// since nothing here should be accessed outside the thread
//

typedef struct _REDBOOK_CDROM_INFO {

    //
    // cache both Table of Contents and
    // number of times disc was changed
    // (CheckVerifyStatus)
    //

    PCDROM_TOC Toc;
    ULONG StateNow;          // interlocked state, support routines to access
    ULONG CheckVerify;

    ULONG NextToRead;        // next sector to read upon getting a free buffer
    ULONG NextToStream;      // next sector to play when KS ready
    ULONG FinishedStreaming; // last to go through ks

    ULONG EndPlay;           // last sector to read/play
    ULONG ReadErrors;        // stop on errors
    ULONG StreamErrors;      // stop on errors

    //
    // CDRom State
    //

    VOLUME_CONTROL Volume;   // sizeof(char)*4

} REDBOOK_CDROM_INFO, *PREDBOOK_CDROM_INFO;

typedef struct _REDBOOK_BUFFER_DATA {

    PUCHAR  SkipBuffer;             // circular buffer
    PREDBOOK_COMPLETION_CONTEXT Contexts;
    PULONG  ReadOk_X;               //  + inuse flag for completion routines
    PULONG  StreamOk_X;             //  + to guarantee data integrity

    PUCHAR  SilentBuffer;           // when need to send silence
    PMDL    SilentMdl;              // when need to send silence

    ULONG   IndexToRead;
    ULONG   IndexToStream;

    union {
        struct {
            UCHAR   MaxIrpStack;    // allows cleaner IoInitializeIrp
            UCHAR   Paused;         // essentially a boolean
            UCHAR   FirstPause;     // so don't log pauses too often
        };
        ULONG   Reserved1;          // force alignment to ulong
    };

} REDBOOK_BUFFER_DATA, *PREDBOOK_BUFFER_DATA;

//
// Read/Stream completion routine context(s)
//

#define REDBOOK_CC_READ              1
#define REDBOOK_CC_STREAM            2
#define REDBOOK_CC_READ_COMPLETE     3
#define REDBOOK_CC_STREAM_COMPLETE   4

typedef struct _REDBOOK_COMPLETION_CONTEXT {
    LIST_ENTRY ListEntry;          // for queueing
    PREDBOOK_DEVICE_EXTENSION DeviceExtension;
    ULONG  Reason;                 // REDBOOK_CC_*

    ULONG  Index;                   // buffer index
    PUCHAR Buffer;                 // Buffer
    PMDL   Mdl;                    // Mdl for buffer
    PIRP   Irp;                    // Irp for buffer

    LARGE_INTEGER TimeReadReady;   // time the buffer was ready to read into
    LARGE_INTEGER TimeReadSent;    // time buffer was sent to read
    LARGE_INTEGER TimeStreamReady; // time the buffer was ready to stream
    LARGE_INTEGER TimeStreamSent;  // time buffer was sent to stream

    KSSTREAM_HEADER Header;        // have to be allocated, keep w/buffer
} REDBOOK_COMPLETION_CONTEXT, *PREDBOOK_COMPLETION_CONTEXT;

typedef struct _REDBOOK_THREAD_DATA {

    //
    // Handle to the thread
    //

    HANDLE SelfHandle;

    //
    // pointer to thread
    //

    PETHREAD SelfPointer;

    //
    // object pointer we referenced so we can safely wait for thread to exit
    //

    PKTHREAD ThreadReference;

    //
    // irp used to verify media hasn't changed
    //

    PIRP CheckVerifyIrp;

    //
    // Three queues: Ioctl, Wmi, Kill
    // Currently Processing is LIST_ENTRY pointer
    //

    LIST_ENTRY IoctlList;   // dump ioctls here
    LIST_ENTRY WmiList;     // dump wmi requests here
    LIST_ENTRY DigitalList; // dump rawread/stream requests here

    //
    // Three spinlocks: one for each queue
    //

    KSPIN_LOCK IoctlLock;
    KSPIN_LOCK WmiLock;
    KSPIN_LOCK DigitalLock;

    //
    // may need to wait for digital to complete for this
    //

    PLIST_ENTRY IoctlCurrent;

    //
    // keep count of pending io
    //
    ULONG PendingRead;
    ULONG PendingStream;

    //
    // Events for the thread
    //

    PKEVENT Events[EVENT_MAXIMUM];
    KWAIT_BLOCK EventBlock[EVENT_MAXIMUM];


} REDBOOK_THREAD_DATA, *PREDBOOK_THREAD_DATA;

// the kill event is just a list_entry

typedef struct _REDBOOK_THREAD_IOCTL_DATA {
    LIST_ENTRY ListEntry;
    PIRP Irp;
} REDBOOK_THREAD_IOCTL_DATA, *PREDBOOK_THREAD_IOCTL_DATA;

typedef struct _REDBOOK_THREAD_WMI_DATA {
    LIST_ENTRY ListEntry;
    PIRP Irp;
} REDBOOK_THREAD_WMI_DATA, *PREDBOOK_THREAD_WMI_DATA;

#define SAVED_IO_MAX (1)        // increase this for thread ioctl history
typedef struct _SAVED_IO {
    union {
        struct {
            PIRP              OriginalIrp;     // see where it finished
            IRP               IrpWithoutStack;
            IO_STACK_LOCATION Stack[8];
        };
        UCHAR Reserved[0x200];  // to make my tracing easier (real size: 0x194)
    };
} SAVED_IO, *PSAVED_IO;



//
// Device Extension
//

typedef struct _REDBOOK_DEVICE_EXTENSION {

    //
    // Driver Object
    //

    PDRIVER_OBJECT DriverObject;

    //
    // Target Device Object
    //

    PDEVICE_OBJECT TargetDeviceObject;

    //
    // Target Physical Device Object
    //

    PDEVICE_OBJECT TargetPdo;

    //
    // Back pointer to device object
    //

    PDEVICE_OBJECT SelfDeviceObject;

    //
    // PagingPath Count
    //

    ULONG PagingPathCount;
    KEVENT PagingPathEvent;

    //
    // Pnp State
    //

    struct {
        UCHAR CurrentState;
        UCHAR PreviousState;
        BOOLEAN RemovePending;
        BOOLEAN Initialized;
    } Pnp;

    REDBOOK_ERROR_LOG_DATA ErrorLog;
    REDBOOK_CDROM_INFO  CDRom;
    REDBOOK_BUFFER_DATA Buffer;
    REDBOOK_STREAM_DATA Stream;
    REDBOOK_THREAD_DATA Thread;

    //
    // WMI Information
    //

    REDBOOK_WMI_STD_DATA WmiData;
    REDBOOK_WMI_PERF_DATA WmiPerf;
    KSPIN_LOCK WmiPerfLock;
    WMILIB_CONTEXT WmiLibInfo;
    BOOLEAN WmiLibInitialized;

    //
    // Remove Lock -- Important while playing audio
    //

    IO_REMOVE_LOCK RemoveLock;

    /*
     *  The WmiData.NumberOfBuffers and WmiData.SectorsPerRead fields can be changed during play,
     *  which would throw off our buffers and could cause an exception.
     *  So we save new WMI settings here and only apply them on the next play.
     */
    ULONG NextWmiSectorsPerRead;
    ULONG NextWmiNumberOfBuffers;
    
    #if DBG
        ULONG    SavedIoCurrentIndex;
        SAVED_IO SavedIo[SAVED_IO_MAX];
    #endif
    
} REDBOOK_DEVICE_EXTENSION, *PREDBOOK_DEVICE_EXTENSION;


//
// Driver Extension
//

typedef struct _REDBOOK_DRIVER_EXTENSION {
    UNICODE_STRING RegistryPath;
} REDBOOK_DRIVER_EXTENSION, *PREDBOOK_DRIVER_EXTENSION;

#define REDBOOK_DRIVER_EXTENSION_ID DriverEntry

//
// Macros to make life easy
//

#define LBA_TO_RELATIVE_MSF(Lba,Minutes,Seconds,Frames)      \
{                                                            \
    (Minutes) = (UCHAR)( ((Lba)+  0) / (60 * 75)      );     \
    (Seconds) = (UCHAR)((((Lba)+  0) % (60 * 75)) / 75);     \
    (Frames)  = (UCHAR)((((Lba)+  0) % (60 * 75)) % 75);     \
}

#define LBA_TO_MSF(Lba,Minutes,Seconds,Frames)               \
{                                                            \
    (Minutes) = (UCHAR)( ((Lba)+150) / (60 * 75)      );     \
    (Seconds) = (UCHAR)((((Lba)+150) % (60 * 75)) / 75);     \
    (Frames)  = (UCHAR)((((Lba)+150) % (60 * 75)) % 75);     \
}

#define MSF_TO_LBA(Minutes,Seconds,Frames)                   \
    (ULONG)(75*((60*(Minutes))+(Seconds))+(Frames) - 150)

//
// Algebraically equal to:
//      75*60*Minutes +
//      75*Seconds    +
//      Frames        - 150
//


#define MIN(_a,_b) (((_a) <= (_b)) ? (_a) : (_b))
#define MAX(_a,_b) (((_a) >= (_b)) ? (_a) : (_b))

//
// neat little hacks to count number of bits set
//
__inline ULONG CountOfSetBits(ULONG _X)
{ ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }
__inline ULONG CountOfSetBits32(ULONG32 _X)
{ ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }
__inline ULONG CountOfSetBits64(ULONG64 _X)
{ ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }

#define SET_FLAG(Flags, Bit)    ((Flags) |= (Bit))
#define CLEAR_FLAG(Flags, Bit)  ((Flags) &= ~(Bit))
#define TEST_FLAG(Flags, Bit)   (((Flags) & (Bit)) != 0)

#ifdef TRY
    #undef TRY
#endif
#ifdef LEAVE
    #undef LEAVE
#endif
#ifdef FINALLY
    #undef FINALLY
#endif

#define TRY
#define LEAVE   goto __label;
#define FINALLY __label:


#endif // __REDBOOK_H__