1 files changed, 3365 insertions, 0 deletions

diff --git a/private/ntos/miniport/mitsumi/mitsumi.c b/private/ntos/miniport/mitsumi/mitsumi.c
new file mode 100644
index 000000000..3429a15b4
--- /dev/null
+++ b/private/ntos/miniport/mitsumi/mitsumi.c
@@ -0,0 +1,3365 @@
+/*++
+
+Copyright (c) 1994  Microsoft Corporation
+
+Module Name:
+
+    Mitsumi.c
+
+Abstract:
+
+    This is the miniport driver for the Panasonic MKE CR5xx Proprietary CDROM drive.
+
+Author:
+
+    Chuck Park (chuckp)
+
+
+Environment:
+
+    kernel mode only
+
+Notes:
+
+Revision History:
+
+--*/
+
+#include "miniport.h"
+#include "Mitsumi.h"
+
+#if DBG
+#define GATHER_STATS 1
+#endif
+
+//
+// Device extension
+//
+
+typedef struct _HW_DEVICE_EXTENSION {
+
+    //
+    // I/O port base address.
+    //
+
+    PREGISTERS           BaseIoAddress;
+
+    //
+    // Srb being currently serviced.
+    //
+
+    PSCSI_REQUEST_BLOCK  CurrentSrb;
+
+    //
+    // Pointer to data buffer
+    //
+
+    PUCHAR               DataBuffer;
+
+    //
+    // Bytes left to transfer for current request.
+    //
+
+    ULONG                ByteCount;
+
+    //
+    // Identifies the model.
+    //
+
+    DRIVE_TYPE           DriveType;
+
+    //
+    // Current status of audio
+    //
+
+    ULONG                AudioStatus;
+
+    //
+    // Saved position after pausing play.
+    //
+
+    ULONG                SavedPosition;
+
+    //
+    // Ending LBA from last audio play.
+    //
+
+    ULONG                EndPosition;
+
+    //
+    // Number of retries to get valid status.
+    //
+
+    ULONG               StatusRetries;
+
+    //
+    // Number of microseconds to go away on CallBack requests
+    //
+
+    ULONG                PollRate;
+    ULONG                PollRateMultiplier;
+
+#ifdef GATHER_STATS
+
+    //
+    // Used to determine hit rate for various polling increments
+    //
+
+    ULONG                Hits[4];
+    ULONG                Misses[4];
+    ULONG                Requests;
+    BOOLEAN              FirstCall;
+    BOOLEAN              FirstStatusTry;
+#endif
+
+    //
+    // Status from last NoOp
+    //
+
+    UCHAR                DriveStatus;
+
+    //
+    // Determines whether MSF addressing is used.
+    //
+
+    BOOLEAN              MSFAddress;
+
+} HW_DEVICE_EXTENSION, *PHW_DEVICE_EXTENSION;
+
+
+#define MAX_STATUS_RETRIES 512
+
+
+//
+// Function declarations
+//
+//
+
+ULONG
+DriverEntry(
+    IN PVOID DriverObject,
+    IN PVOID Argument2
+    );
+
+
+ULONG
+MitsumiFindAdapter(
+    IN PVOID HwDeviceExtension,
+    IN PVOID Context,
+    IN PVOID BusInformation,
+    IN PCHAR ArgumentString,
+    IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
+    OUT PBOOLEAN Again
+    );
+
+BOOLEAN
+MitsumiHwInitialize(
+    IN PVOID DeviceExtension
+    );
+
+BOOLEAN
+MitsumiStartIo(
+    IN PVOID DeviceExtension,
+    IN PSCSI_REQUEST_BLOCK Srb
+    );
+
+VOID
+MitsumiCallBack(
+    IN PVOID HwDeviceExtension
+    );
+
+BOOLEAN
+MitsumiReset(
+    IN PVOID HwDeviceExtension,
+    IN ULONG PathId
+    );
+
+BOOLEAN
+FindMitsumi(
+    IN PHW_DEVICE_EXTENSION HwDeviceExtension
+    );
+
+BOOLEAN
+ReadAndMapError(
+    IN PHW_DEVICE_EXTENSION DeviceExtension,
+    IN PSCSI_REQUEST_BLOCK  Srb
+    );
+
+BOOLEAN
+CheckStatus(
+    IN PVOID HwDeviceExtension
+    );
+
+BOOLEAN
+MitsumiBuildCommand(
+    IN PHW_DEVICE_EXTENSION DeviceExtension,
+    IN PSCSI_REQUEST_BLOCK  Srb
+    );
+
+BOOLEAN
+MitsumiSendCommand(
+    IN PHW_DEVICE_EXTENSION DeviceExtension,
+    IN PSCSI_REQUEST_BLOCK  Srb
+    );
+
+UCHAR
+WaitForSTEN(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    );
+
+BOOLEAN
+UpdateCurrentPosition(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    );
+
+
+
+ULONG
+DriverEntry(
+    IN PVOID DriverObject,
+    IN PVOID Argument2
+    )
+
+/*++
+
+Routine Description:
+
+    Installable driver initialization entry point for system.
+
+Arguments:
+
+    Driver Object
+
+Return Value:
+
+    Status from ScsiPortInitialize()
+
+--*/
+
+{
+    HW_INITIALIZATION_DATA hwInitializationData;
+    ULONG                  i;
+    ULONG                  adapterCount;
+
+    DebugPrint((1,"\n\nMitsumi Proprietary CDROM Driver\n"));
+
+    //
+    // Zero out structure.
+    //
+
+    for (i = 0; i < sizeof(HW_INITIALIZATION_DATA); i++) {
+        ((PUCHAR)&hwInitializationData)[i] = 0;
+    }
+
+    //
+    // Set size of hwInitializationData.
+    //
+
+    hwInitializationData.HwInitializationDataSize = sizeof(HW_INITIALIZATION_DATA);
+
+    //
+    // Set entry points.
+    //
+
+    hwInitializationData.HwInitialize  = MitsumiHwInitialize;
+    hwInitializationData.HwResetBus    = MitsumiReset;
+    hwInitializationData.HwStartIo     = MitsumiStartIo;
+    hwInitializationData.HwFindAdapter = MitsumiFindAdapter;
+
+    //
+    // Specify size of extensions.
+    //
+
+    hwInitializationData.DeviceExtensionSize = sizeof(HW_DEVICE_EXTENSION);
+    hwInitializationData.SrbExtensionSize = sizeof(CMD_PACKET);
+
+    //
+    // Specifiy the bus type and access ranges.
+    //
+
+    hwInitializationData.AdapterInterfaceType = Isa;
+    hwInitializationData.NumberOfAccessRanges = 1;
+
+    //
+    // Indicate PIO device.
+    //
+
+    hwInitializationData.MapBuffers = TRUE;
+
+    adapterCount = 0;
+
+    return (ScsiPortInitialize(DriverObject, Argument2, &hwInitializationData, &adapterCount));
+
+} // end MitsumiEntry()
+
+
+ULONG
+MitsumiFindAdapter(
+    IN PVOID HwDeviceExtension,
+    IN PVOID Context,
+    IN PVOID BusInformation,
+    IN PCHAR ArgumentString,
+    IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
+    OUT PBOOLEAN Again
+    )
+/*++
+
+Routine Description:
+
+    This function is called by the OS-specific port driver after
+    the necessary storage has been allocated, to gather information
+    about the adapter's configuration.
+
+Arguments:
+
+    HwDeviceExtension - HBA miniport driver's adapter data storage
+    Context - Register base address
+    ConfigInfo - Configuration information structure describing HBA
+    This structure is defined in PORT.H.
+
+Return Value:
+
+    ULONG
+
+--*/
+
+{
+    PHW_DEVICE_EXTENSION deviceExtension      = HwDeviceExtension;
+    PULONG               AdapterCount         = Context;
+
+    CONST ULONG          AdapterAddresses[] = {0x230, 0x250,0x300, 0x310, 0x320, 0x330, 0x340, 0x350, 0x360, 0x370, 0x380,
+                                                 0x390, 0x3A0, 0x3B0, 0x3C0, 0x3D0, 0x3E0, 0x3F0, 0};
+
+
+    while (AdapterAddresses[*AdapterCount] != 0) {
+
+        //
+        // Map I/O space.
+        //
+
+        deviceExtension->BaseIoAddress = (PREGISTERS)ScsiPortGetDeviceBase(HwDeviceExtension,
+                                                              ConfigInfo->AdapterInterfaceType,
+                                                              ConfigInfo->SystemIoBusNumber,
+                                                              ScsiPortConvertUlongToPhysicalAddress(
+                                                                  AdapterAddresses[*AdapterCount]),
+                                                              0x4,
+                                                              TRUE
+                                                              );
+        if (!deviceExtension->BaseIoAddress) {
+            return SP_RETURN_ERROR;
+        }
+
+        (*AdapterCount)++;
+
+        if (!FindMitsumi(deviceExtension)) {
+
+            //
+            // CD is not at this address.
+            //
+
+            ScsiPortFreeDeviceBase(HwDeviceExtension,
+                                   deviceExtension->BaseIoAddress
+                                   );
+
+            continue;
+
+        } else {
+
+            //
+            // Indicate further searches are to be attempted.
+            // Why anyone would want more than one of these drives...
+            //
+
+            *Again = TRUE;
+
+            //
+            // Fill in the access ranges.
+            //
+
+            (*ConfigInfo->AccessRanges)[0].RangeStart =
+                ScsiPortConvertUlongToPhysicalAddress(AdapterAddresses[*AdapterCount - 1]);
+            (*ConfigInfo->AccessRanges)[0].RangeLength = 4;
+            (*ConfigInfo->AccessRanges)[0].RangeInMemory = FALSE;
+
+            ConfigInfo->NumberOfBuses = 1;
+            ConfigInfo->InitiatorBusId[0] = 1;
+
+            ConfigInfo->MaximumTransferLength = 0x8000;
+
+            deviceExtension->AudioStatus = AUDIO_STATUS_NO_STATUS;
+            return SP_RETURN_FOUND;
+
+        }
+
+    }
+
+    *Again = FALSE;
+    *AdapterCount = 0;
+
+    return SP_RETURN_NOT_FOUND;
+
+} // end MitsumiFindAdapter()
+
+
+BOOLEAN
+FindMitsumi(
+    IN PHW_DEVICE_EXTENSION HwDeviceExtension
+    )
+
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    HwDeviceExtension - HBA miniport driver's adapter data storage
+
+Return Value:
+
+    TRUE if device found.
+
+--*/
+
+{
+
+    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
+    PREGISTERS           baseIoAddress   = deviceExtension->BaseIoAddress;
+    ULONG                i;
+    UCHAR                status;
+    UCHAR                driveId[2];
+
+    //
+    // If status is not 0xFF, something else is living at this location.
+    //
+
+    status = ScsiPortReadPortUchar(&baseIoAddress->Reset);
+    if (status != 0xFF) {
+        DebugPrint((1,
+                    "FindMitsumi: Something else is living at %x\n",
+                    baseIoAddress));
+
+        return FALSE;
+    }
+    status = ScsiPortReadPortUchar(&baseIoAddress->Data);
+    if (status != 0xFF) {
+        DebugPrint((1,
+                    "FindMitsumi: Something else is living at %x\n",
+                    baseIoAddress));
+
+        return FALSE;
+    }
+
+    //
+    // Reset the device.
+    //
+
+    ScsiPortWritePortUchar(&baseIoAddress->Reset,0);
+    ScsiPortStallExecution(10);
+    ScsiPortWritePortUchar(&baseIoAddress->Status, 0);
+    ScsiPortStallExecution (10);
+
+    ScsiPortStallExecution(10000);
+    ReadStatus(deviceExtension,baseIoAddress,status);
+
+    //
+    // Issue read drive Id command.
+    //
+
+    ScsiPortWritePortUchar(&baseIoAddress->Data,OP_READ_DRIVE_ID);
+
+    ReadStatus(deviceExtension,baseIoAddress,status);
+
+    if (!(status & STATUS_CMD_ERROR)) {
+
+        //
+        // Read the drive id and version #.
+        //
+
+        for (i = 0; i < 2; i++) {
+            ReadStatus(deviceExtension,baseIoAddress,driveId[i]);
+            if (driveId[i] == 0xFF) {
+                return FALSE;
+            }
+        }
+
+        //
+        // Check the id for validity and drive type.
+        //
+
+        switch (driveId[0]) {
+            case 'M':
+
+                DebugPrint((1,
+                            "FindMitsumi: Found LU005 at %x\n",
+                            baseIoAddress));
+
+                deviceExtension->DriveType = LU005;
+                break;
+
+            case 'D':
+
+                DebugPrint((1,
+                            "FindMitsumi: Found FX001D at %x\n",
+                            baseIoAddress));
+
+                deviceExtension->DriveType = FX001D;
+                break;
+
+            case 'F':
+
+                DebugPrint((1,
+                            "FindMitsumi: Found FX001 at %x\n",
+                            baseIoAddress));
+
+                deviceExtension->DriveType = FX001;
+                break;
+
+            default:
+                DebugPrint((1,
+                            "FindMitsumi: No drive found at %x\n",
+                            baseIoAddress));
+
+                return FALSE;
+
+        }
+
+    } else {
+
+        DebugPrint((1,
+                    "FindMitsumi: No drive found at %x\n",
+                    baseIoAddress));
+
+        return FALSE;
+    }
+
+    return TRUE;
+
+} // end FindMitsumi
+
+
+BOOLEAN
+MitsumiHwInitialize(
+    IN PVOID HwDeviceExtension
+    )
+
+/*++
+
+Routine Description:
+
+    This routine is called from ScsiPortInitialize
+    to set up the adapter so that it is ready to service requests.
+
+Arguments:
+
+    HwDeviceExtension - HBA miniport driver's adapter data storage
+
+Return Value:
+
+    TRUE - if initialization successful.
+    FALSE - if initialization unsuccessful.
+
+--*/
+
+{
+    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
+
+    deviceExtension->PollRate = 1500;
+    deviceExtension->PollRateMultiplier = 15;
+    return TRUE;
+
+} // end MitsumiHwInitialize()
+
+
+BOOLEAN
+MitsumiStartIo(
+    IN PVOID HwDeviceExtension,
+    IN PSCSI_REQUEST_BLOCK Srb
+    )
+
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    HwDeviceExtension - HBA miniport driver's adapter data storage
+    Srb - IO request packet
+
+Return Value:
+
+    TRUE
+
+--*/
+
+{
+    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
+    PREGISTERS           baseIoAddress   = deviceExtension->BaseIoAddress;
+    UCHAR                status;
+
+    //
+    // Determine which function.
+    //
+
+    switch (Srb->Function) {
+
+    case SRB_FUNCTION_EXECUTE_SCSI:
+
+        //
+        // Indicate that a request is active on the controller.
+        //
+
+        deviceExtension->CurrentSrb = Srb;
+
+        //
+        // Build the command packet.
+        //
+
+        if (!MitsumiBuildCommand(deviceExtension,Srb)) {
+            status = Srb->SrbStatus;
+            break;
+        }
+
+        //
+        // Send command to device.
+        //
+
+        if (MitsumiSendCommand(deviceExtension,Srb)) {
+
+            if ( Srb->SrbStatus == SRB_STATUS_PENDING) {
+
+                //
+                // Request a timer callback to finish request.
+                //
+
+                ScsiPortNotification(RequestTimerCall,
+                                     HwDeviceExtension,
+                                     MitsumiCallBack,
+                                     deviceExtension->PollRate * deviceExtension->PollRateMultiplier);
+                return TRUE;
+            }
+        }
+
+        status = Srb->SrbStatus;
+
+        break;
+
+    case SRB_FUNCTION_ABORT_COMMAND:
+
+        //
+        // Verify that SRB to abort is still outstanding.
+        //
+
+        if (!deviceExtension->CurrentSrb) {
+
+            //
+            // Complete abort SRB.
+            //
+
+            status = SRB_STATUS_ABORT_FAILED;
+
+            break;
+        }
+
+        //
+        // Fall through to reset
+        //
+
+    case SRB_FUNCTION_RESET_BUS:
+
+
+        //
+        // Reset the device.
+        //
+
+        ScsiPortWritePortUchar(&baseIoAddress->Reset,0);
+        ScsiPortStallExecution(10);
+        ScsiPortWritePortUchar(&baseIoAddress->Status, 0);
+        ScsiPortStallExecution (10);
+
+        //
+        // Update drive status in device ext.
+        //
+
+        ReadStatus(deviceExtension,baseIoAddress,status);
+
+        //
+        // Port driver will give 5 sec. to recover.
+        //
+
+        status = SRB_STATUS_BUS_RESET;
+
+        break;
+
+    default:
+
+        //
+        // Indicate unsupported command.
+        //
+
+        status = SRB_STATUS_INVALID_REQUEST;
+
+        break;
+
+    } // end switch
+
+
+    if (status != SRB_STATUS_PENDING) {
+
+        //
+        // Clear current SRB.
+        //
+
+        deviceExtension->CurrentSrb = NULL;
+
+        //
+        // Map status to Srb status
+        //
+
+        Srb->SrbStatus = (UCHAR)status;
+
+        //
+        // Indicate command complete.
+        //
+
+        ScsiPortNotification(RequestComplete,
+                             deviceExtension,
+                             Srb);
+
+        //
+        // Indicate ready for next request.
+        //
+
+        ScsiPortNotification(NextRequest,
+                             deviceExtension,
+                             NULL);
+
+        return TRUE;
+    }
+
+    return TRUE;
+
+} // end MitsumiStartIo()
+
+
+BOOLEAN
+MitsumiReadCapacity(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    )
+
+/*++
+
+Routine Description:
+
+    Extracts the 'TOC' data and manipulates it to determine
+    the size of the disc.
+
+Arguments:
+
+    DeviceExtension - HBA miniport driver's adapter data storage
+
+Return Value:
+
+    TRUE - if command was successful.
+
+--*/
+
+{
+
+    PREGISTERS           baseIoAddress   = DeviceExtension->BaseIoAddress;
+    PSCSI_REQUEST_BLOCK  Srb             = DeviceExtension->CurrentSrb;
+    PUCHAR               data            = DeviceExtension->DataBuffer;
+    ULONG                dataLength,lba,i;
+    UCHAR                minutes,seconds,frames;
+    UCHAR                status;
+
+
+    dataLength = 8;
+
+    ReadStatus(DeviceExtension,baseIoAddress,status);
+
+    if (!(status & STATUS_DISC_IN) || (status & STATUS_DOOR_OPEN) ) {
+
+        Srb->SrbStatus = SRB_STATUS_ERROR;
+        Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+
+        if (Srb->SenseInfoBufferLength) {
+
+            PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
+
+            senseBuffer->ErrorCode = 0x70;
+            senseBuffer->Valid     = 1;
+            senseBuffer->AdditionalSenseLength = 0xb;
+            senseBuffer->SenseKey =  SCSI_SENSE_NOT_READY;
+            senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_NO_MEDIA_IN_DEVICE;
+            senseBuffer->AdditionalSenseCodeQualifier = 0;
+
+            Srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
+        }
+
+        return FALSE;
+    }
+
+    if (!(status & STATUS_CMD_ERROR)) {
+
+        //
+        // Read the Toc data
+        //
+
+        for (i = 0; i < dataLength; i++) {
+            ReadStatus(DeviceExtension,baseIoAddress,*data);
+            if (*data == 0xFF) {
+
+                //
+                // Timeout occurred.
+                //
+
+                DebugPrint((1,
+                            "MitsumiReadCapacity: Error occurred on data read.\n"));
+
+                Srb->SrbStatus = SRB_STATUS_ERROR;
+                Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                return FALSE;
+            }
+            data++;
+        }
+
+        //
+        // All of the Toc data has been read. Now munge it into a form that is useable.
+        //
+
+        DeviceExtension->ByteCount = 0;
+
+        data = &DeviceExtension->DataBuffer[2];
+        minutes = *data++;
+        seconds = *data++;
+        frames  = *data;
+
+        BCD_TO_DEC(minutes);
+        BCD_TO_DEC(seconds);
+        BCD_TO_DEC(frames);
+
+        lba = MSF_TO_LBA(minutes,seconds,frames);
+
+        DeviceExtension->DataBuffer[0] = ((PFOUR_BYTE)&lba)->Byte3;
+        DeviceExtension->DataBuffer[1] = ((PFOUR_BYTE)&lba)->Byte2;
+        DeviceExtension->DataBuffer[2] = ((PFOUR_BYTE)&lba)->Byte1;
+        DeviceExtension->DataBuffer[3] = ((PFOUR_BYTE)&lba)->Byte0;
+
+
+        *((ULONG *) &(DeviceExtension->DataBuffer[4])) = 0x00080000;
+
+    } else {
+
+        DebugPrint((1,
+                    "MitsumiReadCapacity: Status %x\n",
+                    status));
+
+        Srb->SrbStatus = SRB_STATUS_ERROR;
+        Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+        return FALSE;
+    }
+
+    return TRUE;
+
+} //End MitsumiReadCapacity
+
+
+
+BOOLEAN
+MitsumiRead(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    )
+
+/*++
+
+Routine Description:
+
+    Carries out the read command. Each sector will be transferred to the
+    Srb's data buffer individually. Afterwards, a new timer call-back will
+    be requested.
+
+Arguments:
+
+    DeviceExtension - HBA miniport driver's adapter data storage
+
+Return Value:
+
+    TRUE - if data transfer is complete.
+
+--*/
+
+{
+
+    PREGISTERS           baseIoAddress   = DeviceExtension->BaseIoAddress;
+    ULONG                dataLength      = DeviceExtension->ByteCount;
+    PSCSI_REQUEST_BLOCK  Srb             = DeviceExtension->CurrentSrb;
+    PCMD_PACKET          packet          = (PCMD_PACKET)Srb->SrbExtension;
+    ULONG                i,j;
+    UCHAR                status;
+
+
+    while (DeviceExtension->ByteCount) {
+
+        //
+        // Check whether ready to transfer.
+        //
+
+        for (i = 0; i < 400; i++) {
+            status = ScsiPortReadPortUchar(&baseIoAddress->Status);
+            if (!(status & DTEN)) {
+
+                break;
+
+            } else if (!(status & STEN)){
+
+                ScsiPortWritePortUchar(&baseIoAddress->Control, 0x04);
+                status = ScsiPortReadPortUchar(&baseIoAddress->Data);
+                DeviceExtension->DriveStatus = status;
+                ScsiPortWritePortUchar(&baseIoAddress->Control, 0x0C);
+
+                if (status & STATUS_READ_ERROR) {
+
+                    DebugPrint((1,
+                                "MitsumiRead: Read error %x\n",
+                                status));
+
+                    Srb->SrbStatus = SRB_STATUS_ERROR;
+                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                    return FALSE;
+
+                }
+            }
+            ScsiPortStallExecution(10);
+        }
+
+        if (i == 400) {
+
+
+#ifdef GATHER_STATS
+            if (DeviceExtension->ByteCount == Srb->DataTransferLength) {
+                DeviceExtension->FirstCall = FALSE;
+                DeviceExtension->Misses[0]++;
+            } else {
+                DeviceExtension->Misses[1]++;
+            }
+#endif
+            if (DeviceExtension->StatusRetries >= MAX_STATUS_RETRIES) {
+
+                DebugPrint((1,
+                            "MitsumiRead: Resetting due to timeout waiting for DTEN\n"));
+
+                DeviceExtension->StatusRetries = 0;
+
+                //
+                // Clear state fields.
+                //
+
+                DeviceExtension->CurrentSrb = NULL;
+                DeviceExtension->ByteCount  = 0;
+                DeviceExtension->DataBuffer = NULL;
+
+                //
+                // Reset the device.
+                //
+
+                MitsumiReset((PVOID)DeviceExtension, Srb->PathId);
+
+                ScsiPortNotification(ResetDetected,
+                                     DeviceExtension,
+                                     NULL);
+
+                Srb->SrbStatus = SRB_STATUS_BUS_RESET;
+
+                return FALSE;
+
+            } else {
+
+                DeviceExtension->StatusRetries++;
+
+                //
+                // Schedule another callback.
+                //
+
+                DebugPrint((2,
+                            "MitsumiRead: DTEN timed out waiting for seek. Scheduling another callback %x\n",
+                            status));
+
+                ScsiPortNotification(RequestTimerCall,
+                                     (PVOID)DeviceExtension,
+                                     MitsumiCallBack,
+                                     DeviceExtension->PollRate);
+
+                return FALSE;
+            }
+        }
+#ifdef GATHER_STATS
+        else {
+            if (DeviceExtension->ByteCount == Srb->DataTransferLength) {
+                if (DeviceExtension->FirstCall) {
+                    DeviceExtension->Hits[0]++;
+                    DeviceExtension->FirstCall = FALSE;
+                }
+            } else {
+                DeviceExtension->Hits[1]++;
+            }
+        }
+#endif
+
+        //
+        // Some unknown check that seems to be essential.
+        //
+
+        if (DeviceExtension->DriveType != LU005) {
+
+            //
+            // TODO: Fix this loop. Don't want to spin forever.
+            //
+
+            while (TRUE) {
+                status = ScsiPortReadPortUchar(&baseIoAddress->Status);
+                if (status & 0x01) {
+                    break;
+                } else {
+                    ScsiPortStallExecution(20);
+                }
+            }
+        }
+
+        //
+        // Ready to transfer. Set the drive in 'data' mode.
+        //
+
+        ScsiPortWritePortUchar(&baseIoAddress->Control, 0x04);
+
+        ScsiPortReadPortBufferUchar(&baseIoAddress->Data,
+                                    DeviceExtension->DataBuffer,
+                                    2048);
+
+
+        //
+        // Set the drive back to 'status' mode.
+        //
+
+        ScsiPortWritePortUchar(&baseIoAddress->Control, 0x0C);
+
+        //
+        // Adjust Bytes left and Buffer pointer
+        //
+
+        DeviceExtension->DataBuffer += 2048;
+        DeviceExtension->ByteCount -= 2048;
+        DeviceExtension->StatusRetries = 0;
+
+        if (DeviceExtension->ByteCount) {
+
+            //
+            // If ready to transfer another sector quick enough, go and
+            // do so.
+            //
+
+            for (j = 0; j < 20; j++) {
+                status = ScsiPortReadPortUchar(&baseIoAddress->Status);
+                if ((status & DTEN)) {
+                    if (!(status & STEN)) {
+                        ScsiPortWritePortUchar(&baseIoAddress->Control, 0x04);
+                        status = ScsiPortReadPortUchar(&baseIoAddress->Data);
+                        DeviceExtension->DriveStatus = status;
+                        ScsiPortWritePortUchar(&baseIoAddress->Control, 0x0C);
+
+                        if (status & STATUS_READ_ERROR) {
+
+                            DebugPrint((1,
+                                        "MitsumiRead: Read error %x\n",
+                                        status));
+
+                            Srb->SrbStatus = SRB_STATUS_ERROR;
+                            Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                            return FALSE;
+
+                        }
+                    }
+                } else {
+                    break;
+                }
+
+                ScsiPortStallExecution(100);
+            }
+            if (j == 20) {
+
+#ifdef GATHER_STATS
+                DeviceExtension->Misses[2]++;
+#endif
+                DebugPrint((2,
+                            "MitsumiRead: Request another timer\n"));
+
+                ScsiPortNotification(RequestTimerCall,
+                                     (PVOID)DeviceExtension,
+                                     MitsumiCallBack,
+                                     DeviceExtension->PollRate);
+
+                return FALSE;
+            }
+#ifdef GATHER_STATS
+            else {
+                DeviceExtension->Hits[2]++;
+            }
+#endif
+            //
+            // Update dataLength and try for another sector.
+            //
+
+            dataLength = DeviceExtension->ByteCount / 2048;
+
+        } else {
+
+            //
+            // Prepare to try for status.
+            //
+
+            DeviceExtension->StatusRetries = 0;
+#ifdef GATHER_STATS
+            DeviceExtension->FirstStatusTry = TRUE;
+#endif
+
+            ScsiPortNotification(RequestTimerCall,
+                                 (PVOID)DeviceExtension,
+                                 MitsumiCallBack,
+                                 DeviceExtension->PollRate / 2);
+            return FALSE;
+        }
+    }
+
+    //
+    // Read final status.
+    //
+
+    for (i = 0; i < 200; i++) {
+        status = ScsiPortReadPortUchar(&baseIoAddress->Status);
+        if (status & STEN) {
+            ScsiPortStallExecution(10);
+        } else {
+            break;
+        }
+    }
+
+    if (i == 200) {
+
+#ifdef GATHER_STATS
+        DeviceExtension->FirstStatusTry = FALSE;
+        DeviceExtension->Misses[3]++;
+#endif
+        if (DeviceExtension->StatusRetries >= MAX_STATUS_RETRIES) {
+
+                DebugPrint((1,
+                            "MitsumiRead: Resetting due to timeout waiting for status\n"));
+
+            DeviceExtension->StatusRetries = 0;
+
+            //
+            // Clear state fields.
+            //
+
+            DeviceExtension->CurrentSrb = NULL;
+            DeviceExtension->ByteCount  = 0;
+            DeviceExtension->DataBuffer = NULL;
+
+            //
+            // Reset the device.
+            //
+
+            MitsumiReset((PVOID)DeviceExtension, Srb->PathId);
+
+            ScsiPortNotification(ResetDetected,
+                                 DeviceExtension,
+                                 NULL);
+
+            Srb->SrbStatus = SRB_STATUS_BUS_RESET;
+
+            return FALSE;
+        }  else {
+
+            DebugPrint((2,
+                        "MitsumiRead: Status Retries for Status %x\n",
+                        DeviceExtension->StatusRetries));
+
+            DeviceExtension->StatusRetries++;
+
+            //
+            // Request another callback to pick up the status
+            //
+
+            ScsiPortNotification(RequestTimerCall,
+                                 (PVOID)DeviceExtension,
+                                 MitsumiCallBack,
+                                 DeviceExtension->PollRate);
+            return FALSE;
+        }
+    }
+
+
+#ifdef GATHER_STATS
+    if (DeviceExtension->StatusRetries == 0) {
+        if (DeviceExtension->FirstStatusTry) {
+            DeviceExtension->Hits[3]++;
+        } else {
+            DebugPrint((1,"StatusRetries = 0, FirstStatusTry = FALSE\n"));
+        }
+    }
+#endif
+    ScsiPortWritePortUchar(&baseIoAddress->Control, 0x04);
+    status = ScsiPortReadPortUchar(&baseIoAddress->Data);
+    DeviceExtension->DriveStatus = status;
+    ScsiPortWritePortUchar(&baseIoAddress->Control, 0x0C);
+
+    if (status & STATUS_READ_ERROR) {
+
+        DebugPrint((1,
+                    "MitsumiRead: Read error %x\n",
+                    status));
+
+        Srb->SrbStatus = SRB_STATUS_ERROR;
+        Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+        return FALSE;
+
+    }
+
+    return TRUE;
+
+} //End MitsumiRead
+
+
+
+BOOLEAN
+GetTrackData(
+    IN PHW_DEVICE_EXTENSION DeviceExtension,
+    IN ULONG                NumberTracks
+    )
+
+/*++
+
+Routine Description:
+
+    Puts the drive in 'TOC' mode so the TOC info. can be extracted for the
+    Subchannel Q.
+
+Arguments:
+
+    DeviceExtension - HBA miniport driver's adapter data storage
+    NumberTracks    - The number of tracks determined to be on the disc.
+
+Return Value:
+
+    TRUE - if successful.
+
+--*/
+
+{
+    PREGISTERS           baseIoAddress = DeviceExtension->BaseIoAddress;
+    PSCSI_REQUEST_BLOCK  Srb           = DeviceExtension->CurrentSrb;
+    PCMD_PACKET          packet        = (PCMD_PACKET)Srb->SrbExtension;
+    PUCHAR               data          = DeviceExtension->DataBuffer;
+    UCHAR                mask[100];
+    ULONG                tracksFound   = 0;
+    ULONG                i,lba;
+    ULONG                dataLength;
+    UCHAR                status,minutes,seconds,frames,control,track,index;
+    UCHAR                controlLow, controlHigh;
+    UCHAR                dataBuffer[10];
+    ULONG                zeroCount = 0,retry = 20000;
+
+    for (i = 0; i < 100; i++) {
+        mask[i] = 0;
+    }
+
+    //
+    // Seek to start of disk
+    //
+
+    ScsiPortWritePortUchar(&baseIoAddress->Data, OP_READ_PLAY);
+    ScsiPortWritePortUchar(&baseIoAddress->Data, 0);
+    ScsiPortWritePortUchar(&baseIoAddress->Data, 2);
+    ScsiPortWritePortUchar(&baseIoAddress->Data, 0);
+    ScsiPortWritePortUchar(&baseIoAddress->Data, 0);
+    ScsiPortWritePortUchar(&baseIoAddress->Data, 0);
+    ScsiPortWritePortUchar(&baseIoAddress->Data, 0);
+
+    //
+    // Wait for seek to complete
+    //
+
+    for (i = 0; i < 40000; i++) {
+        status = ScsiPortReadPortUchar(&baseIoAddress->Status);
+        if (!(status & STEN)) {
+            break;
+        } else if (!(status & DTEN)){
+
+            DebugPrint((1,
+                        "GetTrackData: DTEN active %x\n",
+                        status));
+
+            Srb->SrbStatus = SRB_STATUS_ERROR;
+            Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+            return FALSE;
+
+        } else {
+
+            ScsiPortStallExecution(10);
+        }
+    }
+    if (i == 40000) {
+
+        DebugPrint((1,
+                    "GetTrackData: STEN timed out %x\n",
+                    status));
+
+        Srb->SrbStatus = SRB_STATUS_ERROR;
+        Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+        return FALSE;
+    }
+
+    ReadStatus(DeviceExtension,baseIoAddress,status);
+
+    if (status & (STATUS_CMD_ERROR | STATUS_READ_ERROR)) {
+
+        DebugPrint((1,
+                    "GetTrackData: Status %x\n",
+                    status));
+
+        Srb->SrbStatus = SRB_STATUS_ERROR;
+        Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+        return FALSE;
+    }
+
+    //
+    // Switch drive into "TOC DATA"
+    //
+
+    ScsiPortWritePortUchar(&baseIoAddress->Data, OP_SET_DRV_MODE);
+    ScsiPortWritePortUchar(&baseIoAddress->Data, 0x5);
+    ScsiPortStallExecution(1500);
+    ReadStatus(DeviceExtension,baseIoAddress,status);
+
+    DebugPrint((2,
+                "GetTrackData: Status after SET_DRV_MODE %x\n",
+                status));
+
+    //
+    // Set buffer pointer to start of track descriptors.
+    //
+
+    dataLength = 10;
+
+    while (tracksFound < NumberTracks) {
+
+        //
+        // Read sub-q to extract the embedded TOC data. This isn't pretty.
+        // So for the faint at heart - goto line 1245.
+        //
+
+        ScsiPortWritePortUchar(&baseIoAddress->Data, OP_READ_SUB_CHANNEL);
+        ScsiPortStallExecution(500);
+
+        ReadStatus(DeviceExtension,baseIoAddress,status);
+
+        if (!(status & STATUS_CMD_ERROR)) {
+
+            //
+            // Read the Toc data
+            //
+
+            for (i = 0; i < dataLength; i++) {
+                ReadStatus(DeviceExtension,baseIoAddress,dataBuffer[i]);
+                if (dataBuffer[i] == 0xFF) {
+
+                    //
+                    // Timeout occurred.
+                    //
+
+                    DebugPrint((1,
+                                "GetTrackData: Error occurred on data read.\n"));
+
+                    Srb->SrbStatus = SRB_STATUS_ERROR;
+                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+
+                    ScsiPortWritePortUchar(&baseIoAddress->Data, OP_SET_DRV_MODE);
+                    ScsiPortWritePortUchar(&baseIoAddress->Data, 0x1);
+                    ScsiPortStallExecution(1500);
+                    ReadStatus(DeviceExtension,baseIoAddress,status);
+
+                    return FALSE;
+                }
+            }
+        } else {
+
+            //
+            // Bogus packet.
+            //
+
+            ScsiPortWritePortUchar(&baseIoAddress->Data, OP_SET_DRV_MODE);
+            ScsiPortWritePortUchar(&baseIoAddress->Data, 0x1);
+            ScsiPortStallExecution(1500);
+            ReadStatus(DeviceExtension,baseIoAddress,status);
+
+            DebugPrint((1,
+                        "GetTrackData: Error occurred sending command.\n"));
+
+            Srb->SrbStatus = SRB_STATUS_ERROR;
+            Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+            return FALSE;
+        }
+
+        //
+        // Update bitmask of tracks found, including dealing with First, last, and multisession.
+        //
+
+        track =  BCD_TO_DEC(dataBuffer[1]);
+        index = BCD_TO_DEC(dataBuffer[2]);
+
+        if (track == 0 && retry--) {
+
+            switch (index) {
+
+                case 0xA0:
+
+                    //
+                    // First track
+                    //
+
+                    DebugPrint((2,"First track\n"));
+                    break;
+
+                case 0xA1:
+
+                    //
+                    // Last track
+                    //
+
+                    DebugPrint((2,"Last track\n"));
+                    break;
+
+                case 0xB0:
+
+                    //
+                    // Multi-session. Through it away.
+                    //
+
+                    break;
+
+                default:
+
+                    //
+                    // Normal tracks
+                    //
+
+                    if ( (!(mask[index])) && (index < 100)) {
+
+                        DebugPrint((2,"Track %d\n",index));
+
+                        //
+                        // Set the appropriate bit.
+                        //
+
+                        mask[index] = 1;
+
+                        //
+                        // Munge data into buffer
+                        //
+
+                        DebugPrint((2,"GetTrackData: track %x raw control %x\n",
+                                       index,
+                                       dataBuffer[0]));
+
+                        //
+                        // These fines drives have ADR and CONTROL flipped. Have to
+                        // swizzle the nibbles.
+                        //
+
+                        control = dataBuffer[0];
+                        controlHigh = (control & 0xF0) >> 4;
+                        controlLow = control & 0x0F;
+                        control = controlHigh | (controlLow << 4);
+
+                        DebugPrint((2,"GetTrackData: track %x munged control %x\n",
+                                       index,
+                                       control));
+
+                        minutes = BCD_TO_DEC(dataBuffer[7]);
+                        seconds = BCD_TO_DEC(dataBuffer[8]);
+                        frames  = BCD_TO_DEC(dataBuffer[9]);
+
+                        DebugPrint((2,"GetTrackData: control %x, msf %x %x %x\n",
+                                       control,
+                                       minutes,
+                                       seconds,
+                                       frames));
+
+
+                        if (!DeviceExtension->MSFAddress) {
+
+                            lba = MSF_TO_LBA(minutes,seconds,frames);
+
+                            //
+                            // Swizzle the block address.
+                            //
+
+                            data[7+(8*(index-1))] = ((PFOUR_BYTE)&lba)->Byte3;
+                            data[6+(8*(index-1))] = ((PFOUR_BYTE)&lba)->Byte2;
+                            data[5+(8*(index-1))] = ((PFOUR_BYTE)&lba)->Byte1;
+                            data[4+(8*(index-1))] = ((PFOUR_BYTE)&lba)->Byte0;
+
+                        } else {
+
+                            data[7+(8*(index-1))] = frames;
+                            data[6+(8*(index-1))] = seconds;
+                            data[5+(8*(index-1))] = minutes;
+                            data[4+(8*(index-1))] = 0;
+                        }
+
+                        data[3+(8*(index-1))] = 0;
+                        data[2+(8*(index-1))] = index;
+                        data[1+(8*(index-1))] = control;
+                        data[0+(8*(index-1))] = 0;
+
+                        //
+                        // Update number of tracks found.
+                        //
+
+                        tracksFound++;
+
+                    }
+
+                    break;
+
+            } // switch
+
+        } else {
+
+            if (zeroCount++ >= 2000) {
+
+                //
+                // A little defensive work. It's possible that this thing
+                // could spin forever.
+                //
+
+                DebugPrint((1,"Too many zeros\n"));
+
+                ScsiPortWritePortUchar(&baseIoAddress->Data, OP_SET_DRV_MODE);
+                ScsiPortWritePortUchar(&baseIoAddress->Data, 0x1);
+                ScsiPortStallExecution(1500);
+                ReadStatus(DeviceExtension,baseIoAddress,status);
+                Srb->SrbStatus = SRB_STATUS_ERROR;
+                Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                return FALSE;
+            }
+        }
+    } // while
+
+    DebugPrint((2,"Retry = %d\n",retry));
+
+    ScsiPortWritePortUchar(&baseIoAddress->Data, OP_SET_DRV_MODE);
+    ScsiPortWritePortUchar(&baseIoAddress->Data, 0x1);
+
+    return TRUE;
+
+} // End ReadToc
+
+
+BOOLEAN
+MitsumiReadToc(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    )
+
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    DeviceExtension - HBA miniport driver's adapter data storage
+
+Return Value:
+
+    TRUE - if successful.
+
+--*/
+{
+
+    PREGISTERS           baseIoAddress   = DeviceExtension->BaseIoAddress;
+    PSCSI_REQUEST_BLOCK  Srb             = DeviceExtension->CurrentSrb;
+    PUCHAR               data            = DeviceExtension->DataBuffer;
+    PCDB                 cdb             = (PCDB)Srb->Cdb;
+    ULONG                dataLength;
+    ULONG                i,j,lba;
+    UCHAR                status,leadOutM,leadOutS,leadOutF;
+
+
+    if (cdb->READ_TOC.Format == 0) {
+
+        dataLength = 8;
+
+        //
+        // Ensure that the drive is ready for this.
+        //
+
+        ReadStatus(DeviceExtension,baseIoAddress,status);
+
+        if (!(status & STATUS_DISC_IN) || (status & STATUS_DOOR_OPEN) ) {
+
+            Srb->SrbStatus = SRB_STATUS_ERROR;
+            Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+
+            if (Srb->SenseInfoBufferLength) {
+
+                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
+
+                senseBuffer->ErrorCode = 0x70;
+                senseBuffer->Valid     = 1;
+                senseBuffer->AdditionalSenseLength = 0xb;
+                senseBuffer->SenseKey =  SCSI_SENSE_NOT_READY;
+                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_NO_MEDIA_IN_DEVICE;
+                senseBuffer->AdditionalSenseCodeQualifier = 0;
+
+                Srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
+            }
+
+            return FALSE;
+        }
+
+        if (!(status & STATUS_CMD_ERROR)) {
+
+            //
+            // Read the Toc data
+            //
+
+            for (i = 0; i < dataLength; i++) {
+                ReadStatus(DeviceExtension,baseIoAddress,*data);
+                if (*data == 0xFF) {
+
+                    //
+                    // Timeout occurred.
+                    //
+
+                    DebugPrint((1,
+                                "MitsumiReadToc: Error occurred on data read.\n"));
+
+                    Srb->SrbStatus = SRB_STATUS_ERROR;
+                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                    return FALSE;
+                }
+                data++;
+            }
+
+            //
+            // All of the 'Toc' data has been read. Now munge it into a form that is useable.
+            // The Mitsumi TOC data is abbreviated at best. The exciting GetTrackData routine
+            // gets the actual stuff in which we are interested.
+            //
+
+            DeviceExtension->ByteCount = 0;
+            data = DeviceExtension->DataBuffer;
+
+            leadOutM = BCD_TO_DEC(data[2]);
+            leadOutS = BCD_TO_DEC(data[3]);
+            leadOutF = BCD_TO_DEC(data[4]);
+
+            //
+            // Set First and Last track.
+            //
+
+            data[2] = BCD_TO_DEC(data[0]);
+            data[3] = BCD_TO_DEC(data[1]);
+
+            //
+            // Set sizeof TOC data
+            //
+
+            data[0] = ((( data[3] - data[2]) * 8) + 2) >> 8;
+            data[1] = ((( data[3] - data[2]) * 8) + 2) & 0xFF;
+
+            DeviceExtension->DataBuffer += 4;
+
+            if (!GetTrackData(DeviceExtension,(data[3] - data[2] + 1))) {
+
+                Srb->SrbStatus = SRB_STATUS_ERROR;
+                Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                return FALSE;
+
+            }
+
+            //
+            // Push buffer pointer to end of TOC data
+            //
+
+            DeviceExtension->DataBuffer += 8*(data[3]-data[2] + 1);
+
+            //
+            // Lead out area
+            //
+
+            DeviceExtension->DataBuffer[0] = 0;
+            DeviceExtension->DataBuffer[1] = 0x10;
+            DeviceExtension->DataBuffer[3] = 0;
+
+            DeviceExtension->DataBuffer[2] = 0xAA;
+
+            if (!DeviceExtension->MSFAddress) {
+
+                lba = MSF_TO_LBA(leadOutM,leadOutS,leadOutF);
+
+                DeviceExtension->DataBuffer[4] = ((PFOUR_BYTE)&lba)->Byte3;
+                DeviceExtension->DataBuffer[5] = ((PFOUR_BYTE)&lba)->Byte2;
+                DeviceExtension->DataBuffer[6] = ((PFOUR_BYTE)&lba)->Byte1;
+                DeviceExtension->DataBuffer[7] = ((PFOUR_BYTE)&lba)->Byte0;
+
+            } else {
+
+                DeviceExtension->DataBuffer[4] = 0;
+                DeviceExtension->DataBuffer[5] = leadOutM;
+                DeviceExtension->DataBuffer[6] = leadOutS;
+                DeviceExtension->DataBuffer[7] = leadOutF;
+            }
+
+        } else {
+
+            Srb->SrbStatus = SRB_STATUS_ERROR;
+            Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+            return FALSE;
+        }
+
+    } else {
+
+        //
+        // Session info.
+        //
+
+        dataLength = 4;
+
+        ReadStatus(DeviceExtension,baseIoAddress,status);
+
+        if (!(status & STATUS_DISC_IN) || (status & STATUS_DOOR_OPEN) ) {
+
+            Srb->SrbStatus = SRB_STATUS_ERROR;
+            Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+
+            if (Srb->SenseInfoBufferLength) {
+
+                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
+
+                senseBuffer->ErrorCode = 0x70;
+                senseBuffer->Valid     = 1;
+                senseBuffer->AdditionalSenseLength = 0xb;
+                senseBuffer->SenseKey =  SCSI_SENSE_NOT_READY;
+                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_NO_MEDIA_IN_DEVICE;
+                senseBuffer->AdditionalSenseCodeQualifier = 0;
+
+                Srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
+            }
+
+            return FALSE;
+        }
+
+        if (!(status & STATUS_CMD_ERROR)) {
+
+            //
+            // Read the 'session info' data
+            //
+
+            for (i = 0; i < dataLength; i++) {
+                ReadStatus(DeviceExtension,baseIoAddress,*data);
+                if (*data == 0xFF) {
+
+                    //
+                    // Timeout occurred.
+                    //
+
+                    DebugPrint((1,
+                                "MitsumiReadToc: Error occurred on data read.\n"));
+
+                    Srb->SrbStatus = SRB_STATUS_ERROR;
+                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                    return FALSE;
+                }
+                data++;
+            }
+
+            DeviceExtension->ByteCount = 0;
+            data = DeviceExtension->DataBuffer;
+
+            leadOutM = BCD_TO_DEC(data[1]);
+            leadOutS = BCD_TO_DEC(data[2]);
+            leadOutF = BCD_TO_DEC(data[3]);
+
+            if (!DeviceExtension->MSFAddress) {
+
+                lba = MSF_TO_LBA(leadOutM,leadOutS,leadOutF);
+
+                //
+                // Check for non-multi session disk. The data will
+                // be bogus if it is.
+                //
+
+                if ((LONG)lba < 0) {
+                    lba = 0;
+                }
+
+                DeviceExtension->DataBuffer[8] = ((PFOUR_BYTE)&lba)->Byte3;
+                DeviceExtension->DataBuffer[9] = ((PFOUR_BYTE)&lba)->Byte2;
+                DeviceExtension->DataBuffer[10] = ((PFOUR_BYTE)&lba)->Byte1;
+                DeviceExtension->DataBuffer[11] = ((PFOUR_BYTE)&lba)->Byte0;
+
+            } else {
+
+                data[11] = leadOutF;
+                data[10] = leadOutS;
+                data[9] =  leadOutM;
+                data[8] =  0;
+            }
+
+            //
+            // Stuff the rest of the buffer with meaningful data.(Look in the spec.)
+            //
+
+            data[7] =  0;
+            data[6] =  0;
+            data[5] =  0;
+            data[4] =  0;
+            data[3] =  0x1;
+            data[2] =  0x1;
+            data[1] =  0xA;
+            data[0] =  0;
+
+        } else {
+
+            Srb->SrbStatus = SRB_STATUS_ERROR;
+            Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+            return FALSE;
+
+        }
+    }
+
+    return TRUE;
+}
+
+BOOLEAN
+MitsumiReadSubQ(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    )
+{
+
+    PREGISTERS           baseIoAddress   = DeviceExtension->BaseIoAddress;
+    ULONG                dataLength      = DeviceExtension->ByteCount;
+    PSCSI_REQUEST_BLOCK  Srb             = DeviceExtension->CurrentSrb;
+    PUCHAR               dataBuffer      = DeviceExtension->DataBuffer;
+    PCDB                 cdb = (PCDB)Srb->Cdb;
+    ULONG                i,j;
+    ULONG                lba;
+    UCHAR                status,minutes,seconds,frames;
+    UCHAR                format = cdb->SUBCHANNEL.Format;
+
+    if (format == 1) {
+
+        ReadStatus(DeviceExtension,baseIoAddress,status);
+
+        if (!(status & STATUS_CMD_ERROR)) {
+
+            //
+            // Read the position data
+            //
+
+            for (i = 0; i < 9; i++) {
+                ReadStatus(DeviceExtension,baseIoAddress,dataBuffer[i]);
+                if (dataBuffer[i] == 0xFF) {
+
+                    //
+                    // Timeout occurred.
+                    //
+
+                    DebugPrint((1,
+                                "GetTrackData: Error occurred on data read.\n"));
+
+                    Srb->SrbStatus = SRB_STATUS_ERROR;
+                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+
+                    return FALSE;
+                }
+            }
+        } else {
+
+            //
+            // Bogus packet.
+            //
+
+            ScsiPortWritePortUchar(&baseIoAddress->Data, OP_SET_DRV_MODE);
+            ScsiPortWritePortUchar(&baseIoAddress->Data, 0x1);
+            ScsiPortStallExecution(1500);
+            ReadStatus(DeviceExtension,baseIoAddress,status);
+
+            DebugPrint((1,
+                        "GetTrackData: Error occurred sending command.\n"));
+
+            Srb->SrbStatus = SRB_STATUS_ERROR;
+            Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+            return FALSE;
+        }
+
+        //
+        // Format the data correctly. Refer to the scsi spec.
+        //
+
+        if (DeviceExtension->MSFAddress) {
+
+            dataBuffer[15] = BCD_TO_DEC(dataBuffer[5]);
+            dataBuffer[14] = BCD_TO_DEC(dataBuffer[4]);
+            dataBuffer[13] = BCD_TO_DEC(dataBuffer[3]);
+            dataBuffer[12] = 0;
+            dataBuffer[11] = BCD_TO_DEC(dataBuffer[9]);
+            dataBuffer[10] = BCD_TO_DEC(dataBuffer[8]);
+            dataBuffer[9]  = BCD_TO_DEC(dataBuffer[7]);
+            dataBuffer[8]  = 0;
+
+            DebugPrint((3,"MitsumiSubQ: Current MSF %x %x %x\n",
+                           dataBuffer[9],
+                           dataBuffer[10],
+                           dataBuffer[11]));
+
+        } else {
+
+            minutes = BCD_TO_DEC(dataBuffer[3]);
+            seconds = BCD_TO_DEC(dataBuffer[4]);
+            frames  = BCD_TO_DEC(dataBuffer[5]);
+
+            lba = MSF_TO_LBA(minutes,seconds,frames);
+
+            dataBuffer[15] = ((PFOUR_BYTE)&lba)->Byte0;
+            dataBuffer[14] = ((PFOUR_BYTE)&lba)->Byte1;
+            dataBuffer[13] = ((PFOUR_BYTE)&lba)->Byte2;
+            dataBuffer[12] = ((PFOUR_BYTE)&lba)->Byte3;
+
+            minutes = BCD_TO_DEC(dataBuffer[7]);
+            seconds = BCD_TO_DEC(dataBuffer[8]);
+            frames  = BCD_TO_DEC(dataBuffer[9]);
+
+            lba = MSF_TO_LBA(minutes,seconds,frames);
+
+            dataBuffer[11] = ((PFOUR_BYTE)&lba)->Byte0;
+            dataBuffer[10] = ((PFOUR_BYTE)&lba)->Byte1;
+            dataBuffer[9] =  ((PFOUR_BYTE)&lba)->Byte2;
+            dataBuffer[8] =  ((PFOUR_BYTE)&lba)->Byte3;
+
+            DebugPrint((3,"MitsumiSubQ: Current LBA %x\n",
+                           lba));
+        }
+
+
+        dataBuffer[7] = BCD_TO_DEC(dataBuffer[2]);
+        dataBuffer[6] = BCD_TO_DEC(dataBuffer[1]);
+        dataBuffer[5] = BCD_TO_DEC(dataBuffer[0]);
+        dataBuffer[4] = format;
+
+        DebugPrint((3,"MitsumiSubQ: Track %x, index %x\n",
+                       dataBuffer[6],
+                       dataBuffer[7]));
+
+        dataBuffer[3] = 12;
+        dataBuffer[2] = 0;
+
+        if (status & STATUS_AUDIO) {
+            dataBuffer[1] = AUDIO_STATUS_PLAYING;
+        } else {
+            dataBuffer[1] = (UCHAR)DeviceExtension->AudioStatus;
+            DeviceExtension->AudioStatus = AUDIO_STATUS_NO_STATUS;
+        }
+
+        DebugPrint((3,"MitsumiSubQ: Audio Status %x\n",
+                       dataBuffer[1]));
+
+        dataBuffer[0] = 0;
+
+        DeviceExtension->ByteCount = 0;
+
+    } else {
+
+        //
+        // Not supported right now.
+        //
+
+        Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
+        return FALSE;
+    }
+    return TRUE;
+
+}
+
+
+VOID
+MitsumiCallBack(
+    IN PVOID HwDeviceExtension
+    )
+/*++
+
+Routine Description:
+
+    Timer call-back routine which functions as the ISR for this polling driver.
+
+Arguments:
+
+    HwDeviceExtension - HBA miniport driver's adapter data storage
+
+Return Value:
+
+    None
+
+--*/
+{
+    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
+    PREGISTERS           baseIoAddress   = deviceExtension->BaseIoAddress;
+    ULONG                dataLength      = deviceExtension->ByteCount;
+    PSCSI_REQUEST_BLOCK  Srb             = deviceExtension->CurrentSrb;
+    PCMD_PACKET          packet;
+    PCDB                 cdb;
+    BOOLEAN              requestSuccess  = FALSE;
+    UCHAR                scsiOp;
+    UCHAR                status;
+
+    if (!Srb) {
+
+        //
+        // Something is hosed, just return.
+        //
+
+        DebugPrint((1,
+                    "MitsumiCallBack: Null Srb.\n"));
+        return;
+    }
+
+    cdb    = (PCDB)Srb->Cdb;
+    packet = (PCMD_PACKET)Srb->SrbExtension;
+    scsiOp = Srb->Cdb[0];
+
+    switch (scsiOp) {
+        case SCSIOP_READ_CAPACITY:
+
+            if (MitsumiReadCapacity(deviceExtension)) {
+                requestSuccess = TRUE;
+            }
+            break;
+
+        case SCSIOP_READ:
+
+            if (MitsumiRead(deviceExtension)) {
+
+                //
+                // Read was successful
+                //
+
+                requestSuccess = TRUE;
+
+            } else if (Srb->SrbStatus == SRB_STATUS_PENDING) {
+
+                //
+                // We have more data to transfer. Go away while the lightning fast
+                // mechanism does its work.
+                //
+
+                return;
+            }
+
+            break;
+
+        case SCSIOP_READ_TOC:
+
+            if (MitsumiReadToc(deviceExtension)) {
+                requestSuccess = TRUE;
+            }
+            break;
+
+        case SCSIOP_READ_SUB_CHANNEL:
+
+            if (MitsumiReadSubQ(deviceExtension)) {
+                requestSuccess = TRUE;
+            }
+            break;
+
+        case SCSIOP_PLAY_AUDIO_MSF:
+
+            ReadStatus(deviceExtension,baseIoAddress,status);
+            if (SUCCESS(status)) {
+
+                deviceExtension->AudioStatus = AUDIO_STATUS_SUCCESS;
+                requestSuccess = TRUE;
+
+            } else {
+
+                deviceExtension->AudioStatus = AUDIO_STATUS_ERROR;
+
+                Srb->SrbStatus = SRB_STATUS_ERROR;
+                Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+            }
+
+            break;
+
+        case SCSIOP_PAUSE_RESUME:
+
+            if(cdb->PAUSE_RESUME.Action) {
+
+                ULONG i;
+                UCHAR minutes,seconds,frames;
+
+                //
+                // We did a seek to the saved position. Now issue a play from here
+                // to the saved ending MSF.
+                //
+
+                ReadStatus(deviceExtension,baseIoAddress,status);
+                if (SUCCESS(status)) {
+
+                    deviceExtension->AudioStatus = AUDIO_STATUS_SUCCESS;
+                    requestSuccess = TRUE;
+
+                } else {
+
+                    deviceExtension->AudioStatus = AUDIO_STATUS_ERROR;
+
+                    Srb->SrbStatus = SRB_STATUS_ERROR;
+                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                }
+
+                minutes = (UCHAR)(deviceExtension->EndPosition  / (60 * 75));
+                seconds = (UCHAR)((deviceExtension->EndPosition  % (60 * 75)) / 75);
+                frames  = (UCHAR)((deviceExtension->EndPosition  % (60 * 75)) % 75);
+
+                DebugPrint((2,
+                            "MitsumiBuildCommand: resume: lba %x, m %x, s %x, f%x\n",
+                            deviceExtension->SavedPosition,
+                            minutes,
+                            seconds,
+                            frames));
+
+                //
+                // Convert MSF to BCD. Don't need to setup start address and opcode since they are
+                // already there.
+                //
+
+                packet->Parameters[3] = DEC_TO_BCD(minutes);
+                packet->Parameters[4] = DEC_TO_BCD(seconds);
+                packet->Parameters[5] = DEC_TO_BCD(frames);
+
+
+                //
+                // Send the packet.
+                //
+
+                ScsiPortWritePortUchar(&baseIoAddress->Data,packet->OperationCode);
+                for (i = 0; i < 6; i++) {
+                    ScsiPortWritePortUchar(&baseIoAddress->Data,packet->Parameters[i]);
+                }
+
+                //
+                // Wait for completion, and update status.
+                //
+
+                ScsiPortStallExecution(4000);
+
+                ReadStatus(deviceExtension,baseIoAddress,status);
+                if (SUCCESS(status)) {
+
+                    deviceExtension->AudioStatus = AUDIO_STATUS_SUCCESS;
+                    requestSuccess = TRUE;
+
+                } else {
+
+                    deviceExtension->AudioStatus = AUDIO_STATUS_ERROR;
+
+                    Srb->SrbStatus = SRB_STATUS_ERROR;
+                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                }
+
+            } else {
+
+                ReadStatus(deviceExtension,baseIoAddress,status);
+                if (SUCCESS(status)) {
+                    deviceExtension->AudioStatus = AUDIO_STATUS_PAUSED;
+
+                    UpdateCurrentPosition(deviceExtension);
+
+                    requestSuccess = TRUE;
+                } else {
+
+                    DebugPrint((1,"MitsumiCallBack: Error on pause %x\n",
+                                   status));
+
+                    deviceExtension->AudioStatus = AUDIO_STATUS_ERROR;
+                    Srb->SrbStatus = SRB_STATUS_ERROR;
+                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+                }
+            }
+
+            break;
+
+        case SCSIOP_START_STOP_UNIT:
+
+            ReadStatus(deviceExtension,baseIoAddress,status);
+            if (SUCCESS(status)) {
+                requestSuccess = TRUE;
+            } else {
+
+                DebugPrint((1,"MitsumiCallBack: Error on start/stop %x\n",
+                               status));
+
+                Srb->SrbStatus = SRB_STATUS_ERROR;
+                Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+            }
+
+            break;
+
+        default:
+            Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
+            break;
+
+    } //switch scsiOp
+
+
+    if (requestSuccess) {
+
+        //
+        // Update srb and scsi status.
+        //
+
+        if (deviceExtension->ByteCount) {
+            Srb->SrbStatus = SRB_STATUS_DATA_OVERRUN;
+        } else {
+            Srb->SrbStatus = SRB_STATUS_SUCCESS;
+        }
+
+        Srb->ScsiStatus = SCSISTAT_GOOD;
+    }
+
+    //
+    // Indicate command complete.
+    //
+
+    ScsiPortNotification(RequestComplete,
+                         deviceExtension,
+                         Srb);
+
+    //
+    // Indicate ready for next request.
+    //
+
+    ScsiPortNotification(NextRequest,
+                         deviceExtension,
+                         NULL);
+
+    return;
+}
+
+
+BOOLEAN
+MitsumiReset(
+    IN PVOID HwDeviceExtension,
+    IN ULONG PathId
+    )
+
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    HwDeviceExtension - HBA miniport driver's adapter data storage
+
+Return Value:
+
+    Nothing.
+
+
+--*/
+
+{
+    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
+    PREGISTERS           baseIoAddress   = deviceExtension->BaseIoAddress;
+    UCHAR                status;
+
+    //
+    // Clean out device extension and complete outstanding commands.
+    //
+
+    if (deviceExtension->CurrentSrb) {
+
+        //
+        // Complete outstanding request with SRB_STATUS_BUS_RESET.
+        //
+
+        ScsiPortCompleteRequest(deviceExtension,
+                                0xFF,
+                                0xFF,
+                                0xFF,
+                                (ULONG)SRB_STATUS_BUS_RESET);
+
+    }
+
+    //
+    // Clear state fields.
+    //
+
+    deviceExtension->CurrentSrb = NULL;
+    deviceExtension->ByteCount  = 0;
+    deviceExtension->DataBuffer = NULL;
+
+    //
+    // Reset the device.
+    //
+
+    ScsiPortWritePortUchar(&baseIoAddress->Reset,0);
+    ScsiPortStallExecution(10);
+    ScsiPortWritePortUchar(&baseIoAddress->Status, 0);
+    ScsiPortStallExecution (10);
+
+    ReadStatus(deviceExtension,baseIoAddress,status);
+
+    //
+    // Wait 1 second for unit to recover.
+    //
+
+    ScsiPortStallExecution (1000 * 1000);
+
+    //
+    // Indicate ready for next request.
+    //
+
+    ScsiPortNotification(NextRequest,
+                         deviceExtension,
+                         NULL);
+
+    return TRUE;
+
+} // end MitsumiReset()
+
+BOOLEAN
+MitsumiBuildCommand(
+    IN PHW_DEVICE_EXTENSION DeviceExtension,
+    IN PSCSI_REQUEST_BLOCK  Srb
+    )
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    HwDeviceExtension - The hardware device extension.
+
+    Srb - The current Srb.
+
+Return Value:
+
+    status
+
+--*/
+
+{
+    PCMD_PACKET packet = (PCMD_PACKET)Srb->SrbExtension;
+    PCDB        cdb    = (PCDB)Srb->Cdb;
+    PREGISTERS  baseIoAddress = DeviceExtension->BaseIoAddress;
+    ULONG       i;
+    UCHAR       minutes,seconds,frames;
+
+    //
+    // Zero the packet.
+    //
+
+    packet->OperationCode = 0;
+    for (i = 0; i < 6; i++) {
+        packet->Parameters[i] = 0;
+    }
+
+    DeviceExtension->DataBuffer = (PUCHAR)Srb->DataBuffer;
+    DeviceExtension->ByteCount  = Srb->DataTransferLength;
+    DeviceExtension->MSFAddress = FALSE;
+
+    Srb->SrbStatus = SRB_STATUS_PENDING;
+
+    //
+    // Map CDB to Panasonic packet command
+    //
+
+    switch (Srb->Cdb[0]) {
+
+        case SCSIOP_READ:
+
+            DeviceExtension->StatusRetries = 0;
+
+#ifdef GATHER_STATS
+            DeviceExtension->Requests++;
+            DeviceExtension->FirstCall = TRUE;
+#endif
+            packet->OperationCode = (DeviceExtension->DriveType == FX001D) ? OP_READ_PLAY_DBL : OP_READ_PLAY;
+
+            //
+            // Convert starting LBA to MSF
+            //
+
+            LBA_TO_MSF(cdb,minutes,seconds,frames);
+
+            //
+            // Convert MSF to BCD
+            //
+
+            packet->Parameters[0] = DEC_TO_BCD(minutes);
+            packet->Parameters[1] = DEC_TO_BCD(seconds);
+            packet->Parameters[2] = DEC_TO_BCD(frames);
+
+            //
+            // Convert blocks to transfer to BCD
+            //
+
+            packet->Parameters[3] = 0;
+            packet->Parameters[4] = cdb->CDB10.TransferBlocksMsb;
+            packet->Parameters[5] = cdb->CDB10.TransferBlocksLsb;
+
+            packet->ParameterLength = 6;
+
+            break;
+
+        case SCSIOP_START_STOP_UNIT:
+
+            if (cdb->START_STOP.Start) {
+
+                if (cdb->START_STOP.LoadEject) {
+
+                    //
+                    // Load an ejected disk and spin up.
+                    //
+
+                    packet->OperationCode = OP_LOAD;
+                    packet->ParameterLength = 0;
+
+
+                } else {
+
+                    //
+                    // Spin up the device by issuing a seek to start of disk.
+                    //
+
+                    packet->OperationCode = (DeviceExtension->DriveType == FX001D) ? OP_READ_PLAY_DBL : OP_READ_PLAY;
+                    packet->Parameters[0] = 0;
+                    packet->Parameters[1] = 2;
+                    packet->Parameters[2] = 0;
+                    packet->Parameters[3] = 0;
+                    packet->Parameters[4] = 0;
+                    packet->Parameters[5] = 0;
+
+                    packet->ParameterLength = 6;
+
+
+                }
+            } else {
+
+                if (cdb->START_STOP.LoadEject) {
+
+                    //
+                    // Eject the disk
+                    //
+
+                    packet->OperationCode = OP_EJECT;
+                    packet->ParameterLength = 0;
+
+                } else {
+
+                    //
+                    // Seek to start and hold.
+                    //
+
+                    packet->OperationCode = OP_READ_PLAY;
+                    packet->Parameters[0] = 0;
+                    packet->Parameters[1] = 2;
+                    packet->Parameters[2] = 0;
+                    packet->Parameters[3] = 0;
+                    packet->Parameters[4] = 0;
+                    packet->Parameters[5] = 0;
+
+                    packet->ParameterLength = 6;
+                }
+            }
+
+            break;
+
+        case SCSIOP_PAUSE_RESUME:
+
+            //
+            // Issue pause/resume.
+            //
+
+
+            if(cdb->PAUSE_RESUME.Action) {
+
+                //
+                // Resume - issue a zero length play to the "saved" MSF.
+                //
+
+                packet->OperationCode = OP_READ_PLAY;
+
+                //
+                // Convert starting LBA to MSF
+                //
+
+                minutes = (UCHAR)(DeviceExtension->SavedPosition  / (60 * 75));
+                seconds = (UCHAR)((DeviceExtension->SavedPosition  % (60 * 75)) / 75);
+                frames  = (UCHAR)((DeviceExtension->SavedPosition  % (60 * 75)) % 75);
+
+                DebugPrint((2,
+                            "MitsumiBuildCommand: resume: lba %x, m %x, s %x, f%x\n",
+                            DeviceExtension->SavedPosition,
+                            minutes,
+                            seconds,
+                            frames));
+
+                //
+                // Convert MSF to BCD
+                //
+
+                packet->Parameters[0] = DEC_TO_BCD(minutes);
+                packet->Parameters[1] = DEC_TO_BCD(seconds);
+                packet->Parameters[2] = DEC_TO_BCD(frames);
+
+                //
+                // Setup a 'play' of zero length.
+                //
+
+                packet->Parameters[3] = 0;
+                packet->Parameters[4] = 0;
+                packet->Parameters[5] = 0;
+
+                packet->ParameterLength = 6;
+
+
+            } else {
+
+                //
+                // Pause - issue Hold command.
+                //
+
+                packet->OperationCode = OP_PAUSE;
+                packet->ParameterLength = 0;
+
+            }
+
+
+            break;
+
+        case SCSIOP_PLAY_AUDIO_MSF:
+
+            //
+            // Update the status to ensure that a current audio play
+            // is not in progress.
+            //
+
+            CheckStatus(DeviceExtension);
+
+            if (DeviceExtension->DriveStatus & STATUS_AUDIO) {
+
+                //
+                // stop the current play by issuing hold command.
+                //
+
+                ScsiPortWritePortUchar(&baseIoAddress->Data, OP_PAUSE);
+
+                ScsiPortStallExecution(1000);
+
+                CheckStatus(DeviceExtension);
+                if (DeviceExtension->DriveStatus & STATUS_AUDIO) {
+                    DebugPrint((1,"MitsumiBuildcommand: Audio still not paused. %x\n",
+                                 DeviceExtension->DriveStatus));
+                }
+
+
+            }
+
+            packet->OperationCode = OP_READ_PLAY;
+
+            //
+            // Convert MSF to BCD
+            //
+
+            packet->Parameters[0] = DEC_TO_BCD(cdb->PLAY_AUDIO_MSF.StartingM);
+            packet->Parameters[1] = DEC_TO_BCD(cdb->PLAY_AUDIO_MSF.StartingS);
+            packet->Parameters[2] = DEC_TO_BCD(cdb->PLAY_AUDIO_MSF.StartingF);
+
+            //
+            // Convert end address to BCD
+            //
+
+            packet->Parameters[3] = DEC_TO_BCD(cdb->PLAY_AUDIO_MSF.EndingM);
+            packet->Parameters[4] = DEC_TO_BCD(cdb->PLAY_AUDIO_MSF.EndingS);
+            packet->Parameters[5] = DEC_TO_BCD(cdb->PLAY_AUDIO_MSF.EndingF);
+
+            //
+            // Setup EndPosition in DevExt. since we may get a pause/resume.
+            //
+
+            DeviceExtension->EndPosition = MSF_TO_LBA(cdb->PLAY_AUDIO_MSF.EndingM,
+                                                      cdb->PLAY_AUDIO_MSF.EndingS,
+                                                      cdb->PLAY_AUDIO_MSF.EndingF);
+
+            //
+            // Determine is this is a seek. If so, zero the ending address fields to indicate
+            // a play of zero length.
+            //
+
+            if (packet->Parameters[0] == packet->Parameters[3] &&
+                packet->Parameters[1] == packet->Parameters[4] &&
+                packet->Parameters[2] == packet->Parameters[5] ) {
+
+                packet->Parameters[3] = 0;
+                packet->Parameters[4] = 0;
+                packet->Parameters[5] = 0;
+
+            }
+            packet->ParameterLength = 6;
+
+            break;
+
+
+        case SCSIOP_READ_TOC:
+
+            //
+            // See if MSF addresses are enabled.
+            //
+
+            if ( cdb->READ_TOC.Msf) {
+                DeviceExtension->MSFAddress = TRUE;
+            }
+
+            //
+            // Setup the appropriate command - full read toc or session info.
+            //
+
+            if (cdb->READ_TOC.Format == 0) {
+
+                packet->OperationCode = OP_READ_TOC;
+                packet->ParameterLength = 0;
+
+            } else {
+
+                packet->OperationCode = OP_READ_SESSION;
+                packet->ParameterLength = 0;
+            }
+
+            break;
+
+
+        case SCSIOP_INQUIRY: {
+
+            PINQUIRYDATA inquiryData = Srb->DataBuffer;
+
+            //
+            // For now, support only one drive at drive select 0 on this controller.
+            // Actually, I have no idea if more can be supported.
+            //
+
+            if (Srb->Lun > 0 || Srb->TargetId > 0) {
+
+                Srb->SrbStatus = SRB_STATUS_SELECTION_TIMEOUT;
+                return FALSE;
+
+            }
+
+            //
+            // Zero inquiry buffer.
+            //
+
+            for (i = 0; i < INQUIRYDATABUFFERSIZE; i++) {
+                ((PUCHAR)inquiryData)[i] = 0;
+            }
+
+            //
+            // Fill in the necessary fields of inquiry data.
+            //
+
+            inquiryData->DeviceType = READ_ONLY_DIRECT_ACCESS_DEVICE;
+            inquiryData->RemovableMedia = 1;
+
+            inquiryData->VendorId[0] = 'M';
+            inquiryData->VendorId[1] = 'I';
+            inquiryData->VendorId[2] = 'T';
+            inquiryData->VendorId[3] = 'S';
+            inquiryData->VendorId[4] = 'U';
+            inquiryData->VendorId[5] = 'M';
+            inquiryData->VendorId[6] = 'I';
+            inquiryData->VendorId[7] = ' ';
+
+            inquiryData->ProductId[0]  = 'C';
+            inquiryData->ProductId[1]  = 'R';
+            inquiryData->ProductId[2]  = 'M';
+            inquiryData->ProductId[3]  = 'C';
+            inquiryData->ProductId[4]  = '-';
+
+            if (DeviceExtension->DriveType == LU005) {
+
+                inquiryData->ProductId[5]  = 'L';
+                inquiryData->ProductId[6]  = 'U';
+                inquiryData->ProductId[9]  = '5';
+                inquiryData->ProductId[10] = 'S';
+
+            } else if (DeviceExtension->DriveType == FX001) {
+
+                inquiryData->ProductId[5]  = 'F';
+                inquiryData->ProductId[6]  = 'X';
+                inquiryData->ProductId[9]  = '1';
+                inquiryData->ProductId[10] = ' ';
+
+            } else {
+
+                inquiryData->ProductId[5]  = 'F';
+                inquiryData->ProductId[6]  = 'X';
+                inquiryData->ProductId[9]  = '1';
+                inquiryData->ProductId[10] = 'D';
+
+            }
+
+            inquiryData->ProductId[7]  = '0';
+            inquiryData->ProductId[8]  = '0';
+            inquiryData->ProductId[11] = ' ';
+            inquiryData->ProductId[12] = ' ';
+            inquiryData->ProductId[13] = ' ';
+            inquiryData->ProductId[14] = ' ';
+            inquiryData->ProductId[15] = ' ';
+
+            Srb->SrbStatus = SRB_STATUS_SUCCESS;
+            Srb->ScsiStatus = SCSISTAT_GOOD;
+
+            break;
+        }
+
+        case SCSIOP_READ_CAPACITY:
+
+            //
+            // Create the READ_TOC_DATA packet. The returned values will be munged
+            // into a usable form.
+            //
+
+            packet->OperationCode = OP_READ_TOC;
+            packet->ParameterLength = 0;
+
+            break;
+
+        case SCSIOP_READ_SUB_CHANNEL:
+
+
+            if ( cdb->SUBCHANNEL.Msf) {
+                DeviceExtension->MSFAddress = TRUE;
+            }
+
+            //
+            // determine what sub-channel data format is required, since this device has 3 different commands
+            // for the SCSI READ_SUB_CHANNEL Opcode. In the callback routine, the remaining calls, if any, will
+            // be issued.
+            //
+
+            switch (cdb->SUBCHANNEL.Format) {
+
+                case 1:
+
+                    //
+                    // Current position.
+                    //
+
+                    packet->OperationCode = OP_READ_SUB_CHANNEL;
+                    packet->ParameterLength = 0;
+
+                    break;
+
+                case 2:
+
+                    //
+                    // Media catalogue number. TODO: support the rest of these.
+                    //
+
+                    Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
+                    break;
+
+                case 3:
+
+                    //
+                    // Track ISRC
+                    //
+
+                    Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
+                    break;
+
+                default:
+
+                    //
+                    // Bogus value.
+                    //
+
+                    Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
+                    return FALSE;
+            }
+
+            break;
+
+        case SCSIOP_TEST_UNIT_READY:
+        case SCSIOP_REQUEST_SENSE:
+
+            break;
+
+        case SCSIOP_MODE_SENSE:
+        case SCSIOP_MODE_SELECT:
+        case SCSIOP_MEDIUM_REMOVAL:
+        case SCSIOP_READ_HEADER:
+
+            //
+            // Dont support this for now. Fall through to default.
+            //
+
+    default:
+
+        DebugPrint((1,
+                   "MitsumiBuildCommand: Unsupported command %x\n",
+                   Srb->Cdb[0]));
+
+        Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
+
+        return FALSE;
+
+    } // end switch
+
+    return TRUE;
+
+}
+
+BOOLEAN
+MitsumiSendCommand(
+    IN PHW_DEVICE_EXTENSION DeviceExtension,
+    IN PSCSI_REQUEST_BLOCK  Srb
+    )
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    HwDeviceExtension - The hardware device extension.
+
+    Srb - The current Srb.
+
+Return Value:
+
+    TRUE if command sent successfully.
+
+--*/
+
+{
+
+    PREGISTERS  baseIoAddress = DeviceExtension->BaseIoAddress;
+    PCDB        cdb = (PCDB)Srb->Cdb;
+    PCMD_PACKET packet = (PCMD_PACKET)Srb->SrbExtension;
+    PSENSE_DATA senseBuffer     = (PSENSE_DATA)Srb->SenseInfoBuffer;
+    ULONG       i;
+    UCHAR       sessionData[6];
+    UCHAR       minutes,seconds,frames,frameData;
+    UCHAR       status = DeviceExtension->DriveStatus;
+
+
+    //
+    // Map CDB to Mitsumi packet command
+    //
+
+    switch (Srb->Cdb[0]) {
+
+        case SCSIOP_READ:
+
+
+            break;
+
+        case SCSIOP_INQUIRY:
+
+            //
+            // Data buffer filled in during MitsumiBuildCommand.
+            //
+
+            return TRUE;
+
+        case SCSIOP_READ_TOC:
+        case SCSIOP_PAUSE_RESUME:
+        case SCSIOP_PLAY_AUDIO_MSF:
+        case SCSIOP_READ_CAPACITY:
+        case SCSIOP_READ_SUB_CHANNEL:
+        case SCSIOP_START_STOP_UNIT:
+
+            //
+            // Nothing to do here. Everything setup in BuildCommand.
+            //
+
+            break;
+
+        case SCSIOP_TEST_UNIT_READY:
+
+
+            if (!CheckStatus(DeviceExtension)) {
+
+                Srb->SrbStatus = SRB_STATUS_ERROR;
+                Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+
+                return FALSE;
+            }
+
+            Srb->SrbStatus = SRB_STATUS_SUCCESS;
+            Srb->ScsiStatus = SCSISTAT_GOOD;
+
+            return TRUE;
+
+        case SCSIOP_REQUEST_SENSE:
+
+            //
+            // Issue the ReadAndMapError command, which will create a request sense packet.
+            //
+
+            if (ReadAndMapError(DeviceExtension,Srb)) {
+
+                Srb->SrbStatus = SRB_STATUS_SUCCESS;
+                Srb->ScsiStatus = SCSISTAT_GOOD;
+
+            } else {
+
+                Srb->SrbStatus = SRB_STATUS_ERROR;
+                Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
+
+            }
+
+            //
+            // Update the drive status.
+            //
+
+            CheckStatus(DeviceExtension);
+
+            return TRUE;
+
+        case SCSIOP_MODE_SENSE:
+        case SCSIOP_MODE_SELECT:
+        case SCSIOP_READ_HEADER:
+        case SCSIOP_MEDIUM_REMOVAL:
+
+            //
+            // Dont support this for now. Fall through.
+            //
+
+    default:
+
+        DebugPrint((1,
+                   "MitsumiSendCommand: Unsupported command %x\n",
+                   Srb->Cdb[0]));
+
+        Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
+
+    } // end switch
+
+    if (Srb->SrbStatus == SRB_STATUS_PENDING) {
+
+        //
+        // Write the packet
+        //
+
+        ScsiPortWritePortUchar(&baseIoAddress->Data,packet->OperationCode);
+        for (i = 0; i < packet->ParameterLength; i++) {
+            ScsiPortWritePortUchar(&baseIoAddress->Data,packet->Parameters[i]);
+        }
+
+        return TRUE;
+
+    } else {
+
+        return FALSE;
+    }
+
+} // End MitsumiSendCommand()
+
+
+UCHAR
+WaitForSTEN(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    )
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    DeviceExtension - The device extension.
+
+
+Return Value:
+
+    TRUE if STEN signal asserted within timeout period.
+
+--*/
+
+{
+    PREGISTERS           baseIoAddress = DeviceExtension->BaseIoAddress;
+    ULONG i;
+    UCHAR status;
+
+    for (i = 0; i < 40 * 1000; i++) {
+        status = ScsiPortReadPortUchar(&baseIoAddress->Status);
+        if (status & STEN) {
+            ScsiPortStallExecution(10);
+        } else {
+            break;
+        }
+    }
+    if (i == 1000 * 40) {
+        return 0xFF;
+    }
+    return status;
+}
+
+BOOLEAN
+CheckStatus(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    )
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    DeviceExtension - The device extension.
+
+
+Return Value:
+
+    Drive status.
+
+--*/
+
+{
+    PREGISTERS    baseIoAddress = DeviceExtension->BaseIoAddress;
+    CMD_PACKET    packet;
+    ULONG         i;
+    UCHAR         status;
+
+    ScsiPortWritePortUchar(&baseIoAddress->Data,OP_READ_STATUS);
+    do {
+
+        ReadStatus(DeviceExtension,baseIoAddress,status);
+    } while (status == 0xFF);
+
+    DeviceExtension->DriveStatus = status;
+    // TODO: Change to SUCCESS macro
+
+    if ( (status & (STATUS_DOOR_OPEN | STATUS_CMD_ERROR | STATUS_MEDIA_CHANGE | STATUS_READ_ERROR)) ||
+         (!(status & (STATUS_SPIN_UP | STATUS_DISC_IN))) ) {
+
+       return FALSE;
+    }
+
+    return TRUE;
+
+}
+
+
+BOOLEAN
+UpdateCurrentPosition(
+    IN PHW_DEVICE_EXTENSION DeviceExtension
+    )
+/*++
+
+Routine Description:
+
+    Determines the current MSF and stores it in the deviceExtension in LBA form.
+
+Arguments:
+
+    HwDeviceExtension - The hardware device extension.
+
+Return Value:
+
+    TRUE - If command succeeded.
+
+--*/
+{
+    PREGISTERS           baseIoAddress   = DeviceExtension->BaseIoAddress;
+    ULONG                i,
+                         lba;
+    UCHAR                status;
+    UCHAR                dataBuffer[10];
+
+    //
+    // Issue SubQ command.
+    //
+
+    ScsiPortWritePortUchar(&baseIoAddress->Data, OP_READ_SUB_CHANNEL);
+
+    ScsiPortStallExecution(1000);
+
+    ReadStatus(DeviceExtension,baseIoAddress,status);
+
+    if (!(status & STATUS_CMD_ERROR)) {
+
+        //
+        // Read the position data
+        //
+
+        for (i = 0; i < 9; i++) {
+            ReadStatus(DeviceExtension,baseIoAddress,dataBuffer[i]);
+            if (dataBuffer[i] == 0xFF) {
+
+                //
+                // Timeout occurred.
+                //
+
+                DebugPrint((1,
+                            "UpdateCurrentPosition: Error occurred on data read. %x\n",
+                            status));
+
+                return FALSE;
+            }
+        }
+    } else {
+
+        DebugPrint((1,
+                    "UpdateCurrentPosition: Error occurred sending command. %x\n",
+                    status));
+
+        return FALSE;
+    }
+
+    //
+    // Convert the MSF to LBA and store in devExt.
+    //
+
+    BCD_TO_DEC(dataBuffer[7]);
+    BCD_TO_DEC(dataBuffer[8]);
+    BCD_TO_DEC(dataBuffer[9]);
+
+    lba = MSF_TO_LBA(dataBuffer[7],dataBuffer[8],dataBuffer[9]);
+
+    DebugPrint((2,
+                "UpdateCurrentPosition: M %x, S %x, F %x LBA %x\n",
+                dataBuffer[7],
+                dataBuffer[8],
+                dataBuffer[9],
+                lba));
+
+    DeviceExtension->SavedPosition = lba;
+
+    return TRUE;
+}
+
+
+
+BOOLEAN
+ReadAndMapError(
+    IN PHW_DEVICE_EXTENSION DeviceExtension,
+    IN PSCSI_REQUEST_BLOCK  Srb
+    )
+
+/*++
+
+Routine Description:
+
+
+Arguments:
+
+    HwDeviceExtension - The hardware device extension.
+
+    Srb - The failing Srb.
+
+
+Return Value:
+
+    SRB Error
+
+--*/
+
+{
+    PREGISTERS           baseIoAddress   = DeviceExtension->BaseIoAddress;
+    PSENSE_DATA          senseBuffer     = (PSENSE_DATA)Srb->DataBuffer;
+    UCHAR                status          = DeviceExtension->DriveStatus;
+    ULONG                i;
+    UCHAR                errorData;
+
+    //
+    // Check drive status. It may have been updated at the point of error.
+    //
+
+    if ( (status & STATUS_DOOR_OPEN) ||
+        !(status & STATUS_DISC_IN)) {
+
+        senseBuffer->ErrorCode = 0x70;
+        senseBuffer->Valid     = 1;
+        senseBuffer->AdditionalSenseLength = 0xb;
+        senseBuffer->SenseKey =  SCSI_SENSE_NOT_READY;
+        senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_NO_MEDIA_IN_DEVICE;
+        senseBuffer->AdditionalSenseCodeQualifier = 0;
+        return TRUE;
+    }
+
+
+    if (status & STATUS_CMD_ERROR ) {
+
+        senseBuffer->ErrorCode = 0x70;
+        senseBuffer->Valid     = 1;
+        senseBuffer->AdditionalSenseLength = 0xb;
+        senseBuffer->SenseKey = SCSI_SENSE_ILLEGAL_REQUEST;
+        senseBuffer->AdditionalSenseCode = 0x24;
+        senseBuffer->AdditionalSenseCodeQualifier = 0;
+        return TRUE;
+    }
+
+    if (status & STATUS_MEDIA_CHANGE) {
+
+        senseBuffer->ErrorCode = 0x70;
+        senseBuffer->Valid     = 1;
+        senseBuffer->AdditionalSenseLength = 0xb;
+        senseBuffer->SenseKey =  SCSI_SENSE_UNIT_ATTENTION;
+        senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_MEDIUM_CHANGED;
+        senseBuffer->AdditionalSenseCodeQualifier = 0x0;
+        return TRUE;
+
+    }
+
+    if (!(status & STATUS_SPIN_UP)) {
+
+        senseBuffer->ErrorCode = 0x70;
+        senseBuffer->Valid     = 1;
+        senseBuffer->AdditionalSenseLength = 0xb;
+        senseBuffer->SenseKey =  SCSI_SENSE_NOT_READY;
+        senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_LUN_NOT_READY;
+        senseBuffer->AdditionalSenseCodeQualifier = 0;
+        return TRUE;
+    }
+
+
+    //
+    // Setup sense buffer common values.
+    //
+
+    senseBuffer->ErrorCode = 0x70;
+    senseBuffer->Valid     = 1;
+    senseBuffer->AdditionalSenseLength = 0xb;
+    senseBuffer->IncorrectLength = FALSE;
+    senseBuffer->SenseKey = 0;
+    senseBuffer->AdditionalSenseCode = 0;
+    senseBuffer->AdditionalSenseCodeQualifier = 0;
+
+    if (status & STATUS_READ_ERROR ) {
+
+        //
+        // Issue the request sense command.
+        //
+
+        ScsiPortWritePortUchar(&baseIoAddress->Data,OP_REQUEST_SENSE);
+
+
+        ReadStatus(DeviceExtension,baseIoAddress,status);
+
+        if (!(status & STATUS_CMD_ERROR)) {
+
+            //
+            // Read the sense data
+            //
+
+            ReadStatus(DeviceExtension,baseIoAddress,errorData);
+            if (errorData == 0xFF) {
+
+                //
+                // Timeout occurred.
+                //
+
+                DebugPrint((1,
+                            "ReadAndMapError: Error occurred on data read.\n"));
+                return FALSE;
+            }
+
+        } else {
+
+            DebugPrint((1,
+                        "ReadAndMapError: Error reading sense data\n"));
+            return FALSE;
+        }
+
+
+
+        //
+        // Map Mitsumi error code to Srb status
+        //
+
+        switch (errorData) {
+            case 0:
+
+                //
+                // No error.
+                //
+
+                senseBuffer->SenseKey =  0x00;
+                senseBuffer->AdditionalSenseCode = 0x00;
+                senseBuffer->AdditionalSenseCodeQualifier = 0x0;
+
+                break;
+
+            case 1:
+
+                //
+                // Mode error.
+                //
+
+                senseBuffer->SenseKey =  0x02;
+                senseBuffer->AdditionalSenseCode = 0x30;
+                senseBuffer->AdditionalSenseCodeQualifier = 0x02;
+
+                break;
+
+            case 2:
+
+                //
+                // Address error.
+                //
+
+                senseBuffer->SenseKey = SCSI_SENSE_ILLEGAL_REQUEST;
+                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_ILLEGAL_BLOCK;
+                break;
+
+            case 3:
+
+                //
+                // Fatal error.
+                //
+
+                senseBuffer->SenseKey = SCSI_SENSE_HARDWARE_ERROR;
+
+                break;
+
+            case 4:
+
+                //
+                // Seek error.
+                //
+
+                senseBuffer->SenseKey = SCSI_SENSE_MEDIUM_ERROR;
+                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_SEEK_ERROR;
+
+                break;
+
+            default:
+
+                senseBuffer->SenseKey =  0x00;
+                senseBuffer->AdditionalSenseCode = 0x00;
+                senseBuffer->AdditionalSenseCodeQualifier = 0x0;
+
+        }
+    }
+
+    return TRUE;
+
+} // end ReadAndMapError()
+
+