windows-server-2003/base/busdrv/acpi/smbus/smbhc/smbsrv.c

/*++

Copyright (c) 1990  Microsoft Corporation

Module Name:

    service.c

Abstract:

    ACPI Embedded Controller Driver

Author:

    Ken Reneris

Environment:

Notes:


Revision History:

--*/

#include "smbhcp.h"

//
// Transfer information based on protocol
//

struct {
    UCHAR       SetupSize;
    UCHAR       ReturnSize;
    UCHAR       Protocol;
} SmbTransfer[] = {
    0,      0,      SMB_HC_WRITE_QUICK,     // 0
    0,      0,      SMB_HC_READ_QUICK,      // 1
    2,      0,      SMB_HC_SEND_BYTE,       // 2
    1,      1,      SMB_HC_RECEIVE_BYTE,    // 3
    3,      0,      SMB_HC_WRITE_BYTE,      // 4
    2,      1,      SMB_HC_READ_BYTE,       // 5
    4,      0,      SMB_HC_WRITE_WORD,      // 6
    2,      2,      SMB_HC_READ_WORD,       // 7
    35,     0,      SMB_HC_WRITE_BLOCK,     // 8
    2,     33,      SMB_HC_READ_BLOCK,      // 9
    4,      2,      SMB_HC_PROCESS_CALL     // A
} ;

VOID
SmbHcStartIo (
    IN PSMB_CLASS   SmbClass,
    IN PVOID        SmbMiniport
    )
/*++

Routine Description:

    This routine is called by the class driver when a new request has been
    given to the device.   If the device is not being processed, then IO is
    started; else, nothing is done as the context processing the device will
    handle it

Arguments:

    SmbClass    - SMB class data

    SmbMiniport - Miniport context

Return Value:

    None

--*/
{
    PSMB_DATA   SmbData;


    SmbData = (PSMB_DATA) SmbMiniport;
    switch (SmbData->IoState) {
        case SMB_IO_IDLE:
            //
            // Device is idle, go check it
            //

            SmbData->IoState = SMB_IO_CHECK_IDLE;
            SmbHcServiceIoLoop (SmbClass, SmbData);
            break;

        case SMB_IO_CHECK_IDLE:
        case SMB_IO_CHECK_ALARM:
        case SMB_IO_WAITING_FOR_HC_REG_IO:
        case SMB_IO_WAITING_FOR_STATUS:
            //
            // Device i/o is in process which will check for a CurrentIrp
            //

            break;

        default:
            SmbPrint (SMB_ERROR, ("SmbHcStartIo: Unexpected state\n"));
            break;
    }
}



VOID
SmbHcQueryEvent (
    IN ULONG        QueryVector,
    IN PSMB_DATA    SmbData
    )
/*++

Routine Description:

    This routine is called by the embedded controller driver when the
    smb controller has signalled for servicing.  This function sets
    the miniport state to ensure the STATUS register is read and checked
    and if needed starts the device processing to check it

--*/
{
    PSMB_CLASS          SmbClass;

    SmbPrint (SMB_STATE, ("SmbHcQueryEvent\n"));

    //
    // Check status of device.
    //

    SmbClass = SmbData->Class;
    SmbClassLockDevice (SmbClass);

    switch (SmbData->IoState) {
        case SMB_IO_CHECK_IDLE:
        case SMB_IO_IDLE:
            //
            // Device is idle.  Read status and check for an alarm
            //

            SmbData->IoState = SMB_IO_READ_STATUS;
            SmbData->IoStatusState = SMB_IO_CHECK_IDLE;
            SmbHcServiceIoLoop (SmbClass, SmbData);
            break;

        case SMB_IO_WAITING_FOR_STATUS:
            //
            // Waiting for completion status, read status now to see if alarm is set
            //

            SmbData->IoState = SMB_IO_READ_STATUS;
            SmbData->IoStatusState = SMB_IO_WAITING_FOR_STATUS;
            SmbHcServiceIoLoop (SmbClass, SmbData);
            break;

        case SMB_IO_CHECK_ALARM:
            //
            // Status is read after alarm is processed so state is OK
            //

            break;

        case SMB_IO_WAITING_FOR_HC_REG_IO:

            //
            // Waiting for register transfer to/from host controller interface,
            // check the waiting state
            //

            switch (SmbData->IoWaitingState) {
                case SMB_IO_CHECK_ALARM:
                case SMB_IO_START_PROTOCOL:
                case SMB_IO_READ_STATUS:
                    //
                    // Status will be read, so state is OK
                    //

                    break;

                case SMB_IO_CHECK_STATUS:
                    //
                    // Back check status up and re-read the status before
                    // the check status
                    //

                    SmbData->IoWaitingState = SMB_IO_READ_STATUS;
                    break;

                case SMB_IO_WAITING_FOR_STATUS:
                    //
                    // Going to wait for completion status, read status once
                    // hc i/o has completed
                    //

                    SmbData->IoWaitingState = SMB_IO_READ_STATUS;
                    SmbData->IoStatusState = SMB_IO_WAITING_FOR_STATUS;
                    break;

                default:
                    SmbPrint (SMB_ERROR, ("SmbHcQuery: Unknown IoWaitingState %d\n", SmbData->IoWaitingState));
                    break;
            }
            break;

        default:
            SmbPrint (SMB_ERROR, ("SmbHcQuery: Unknown IoState %d\n", SmbData->IoState));
            break;
    }

    SmbClassUnlockDevice (SmbClass);
}

NTSTATUS
SmbHcRegIoComplete (
    IN PDEVICE_OBJECT       DeviceObject,
    IN PIRP                 Irp,
    IN PVOID                Context
    )
/*++

Routine Description:

    Completion function for IRPs sent to the embedded control for EC io.

--*/
{
    PSMB_DATA   SmbData;
    PSMB_CLASS  SmbClass;

    SmbPrint (SMB_STATE, ("SmbHcRegIoComplete: Enter.  Irp %x\n", Irp));

    SmbData = (PSMB_DATA) Context;
    SmbClass = SmbData->Class;
    SmbClassLockDevice (SmbClass);

    //
    // Move state to IoWaitingState and continue
    //

    ASSERT (SmbData->IoState == SMB_IO_WAITING_FOR_HC_REG_IO);
    SmbData->IoState = SMB_IO_COMPLETE_REG_IO;
    SmbHcServiceIoLoop (SmbClass, SmbData);

    SmbClassUnlockDevice (SmbClass);
    return STATUS_MORE_PROCESSING_REQUIRED;
}



VOID
SmbHcServiceIoLoop (
    IN PSMB_CLASS   SmbClass,
    IN PSMB_DATA    SmbData
    )
/*++

Routine Description:

    Main host controller interface service loop.

    N.B. device lock is held by caller.
    N.B. device lock may be released and re-acquired during call

--*/
{
    PIRP                Irp;
    PUCHAR              IoBuffer;
    UCHAR               IoWaitingState;
    UCHAR               ErrorCode;
    BOOLEAN             IoWrite;
    ULONG               IoLength;
    PSMB_REQUEST        SmbReq;
    PIO_STACK_LOCATION  IrpSp;
    NTSTATUS            Status;

    IoWrite = FALSE;
    IoBuffer = NULL;
    IoWaitingState = SMB_IO_IDLE;

    SmbPrint (SMB_STATE, ("SmbService: Enter - SmbData %x\n", SmbData));

    do {
        switch (SmbData->IoState) {

            case SMB_IO_CHECK_IDLE:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_CHECK_IDLE\n"));

                //
                // Fallthrough to SMB_IO_IDLE.
                //

                SmbData->IoState = SMB_IO_IDLE;
            case SMB_IO_IDLE:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_IDLE\n"));

                //
                // If there's an alarm pending, read and clear it
                //

                if (SmbData->HcState.Status & SMB_ALRM) {
                    IoBuffer = &SmbData->HcState.AlarmAddress;
                    IoLength = 3;
                    IoWaitingState = SMB_IO_CHECK_ALARM;
                    break;
                }

                //
                // If there's an IRP, lets start it
                //

                if (SmbClass->CurrentIrp) {
                    SmbData->IoState = SMB_IO_START_TRANSFER;
                    break;
                }
                break;

            case SMB_IO_START_TRANSFER:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_START_TRANSFER\n"));

                //
                // Begin CurrentIrp transfer
                //

                Irp = SmbClass->CurrentIrp;
                SmbReq = SmbClass->CurrentSmb;
                SmbData->HcState.Protocol = SmbTransfer[SmbReq->Protocol].Protocol;
                SmbData->HcState.Address  = SmbReq->Address << 1;
                SmbData->HcState.Command  = SmbReq->Command;
                SmbData->HcState.BlockLength = SmbReq->BlockLength;

                //
                // Write HC registers
                //

                IoWrite  = TRUE;
                IoBuffer = &SmbData->HcState.Address;
                IoLength = SmbTransfer[SmbReq->Protocol].SetupSize;
                IoBuffer = &SmbData->HcState.Address;
                IoWaitingState = SMB_IO_START_PROTOCOL;

                //
                // Move data bytes (after address & command byte)
                //

                if (IoLength > 2) {
                   memcpy (SmbData->HcState.Data, SmbReq->Data, IoLength-2);
                }

                //
                // Setup for result length once command completes
                //

                SmbData->IoReadData = SmbTransfer[SmbReq->Protocol].ReturnSize;

                //
                // Handle HC specific protocol mappings
                //

                switch (SmbData->HcState.Protocol) {
                    case SMB_HC_WRITE_QUICK:
                    case SMB_HC_READ_QUICK:
                        //
                        // Host controller wants quick data bit in bit 0
                        // of address
                        //

                        SmbData->HcState.Address |=
                            (SmbData->HcState.Protocol & 1);
                        break;

                    case SMB_HC_SEND_BYTE:
                        //
                        // Host controller wants SEND_BYTE byte in the command
                        // register
                        //

                        SmbData->HcState.Command = SmbReq->Data[0];
                        break;
                }
                break;

            case SMB_IO_START_PROTOCOL:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_START_PROTOCOL\n"));

                //
                // Transfer registers have been setup.  Initiate the protocol
                //

                IoWrite  = TRUE;
                IoBuffer = &SmbData->HcState.Protocol;
                IoLength = 1;
                IoWaitingState = SMB_IO_WAITING_FOR_STATUS;
                break;

            case SMB_IO_WAITING_FOR_STATUS:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_WAITING_FOR_STATUS\n"));

                //
                // Transfer is in progress, just waiting for a status to
                // indicate its complete
                //

                SmbData->IoState = SMB_IO_READ_STATUS;
                SmbData->IoStatusState = SMB_IO_WAITING_FOR_STATUS;
                break;

            case SMB_IO_READ_STATUS:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_READ_STATUS\n"));

                //
                // Read status+protocol and then check it (IoStatusState already set)
                //

                IoBuffer = &SmbData->HcState.Protocol;
                IoLength = 2;   // read protocol & status bytes
                IoWaitingState = SMB_IO_CHECK_STATUS;
                break;

            case SMB_IO_CHECK_STATUS:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_CHECK_STATUS\n"));

                Irp = SmbClass->CurrentIrp;

                //
                // If there's an Irp
                //

                if (SmbData->IoStatusState == SMB_IO_WAITING_FOR_STATUS  &&
                    SmbData->HcState.Protocol == 0) {

                    SmbReq = SmbClass->CurrentSmb;

                    //
                    // If there's an error set handle it
                    //

                    if (SmbData->HcState.Status & SMB_STATUS_MASK) {
                        ErrorCode = SmbData->HcState.Status & SMB_STATUS_MASK;

                        //
                        // Complete/abort the IO with the error
                        //

                        SmbReq->Status = ErrorCode;
                        SmbData->IoState = SMB_IO_COMPLETE_REQUEST;
                        break;
                    }



                    //
                    // If the done is set continue the IO
                    //

                    if (SmbData->HcState.Status & SMB_DONE) {
                        //
                        // Get any return data registers then complete it
                        //

                        SmbReq->Status = SMB_STATUS_OK;
                        IoBuffer = SmbData->HcState.Data;
                        IoLength = SmbData->IoReadData;
                        IoWaitingState = SMB_IO_COMPLETE_REQUEST;
                        break;
                    }
                }

                //
                // Current status didn't have any effect
                //

                SmbData->IoState = SmbData->IoStatusState;
                break;

            case SMB_IO_COMPLETE_REQUEST:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_COMPLETE_REQUEST\n"));

                Irp = SmbClass->CurrentIrp;
                SmbReq = SmbClass->CurrentSmb;

                SmbData->IoState = SMB_IO_CHECK_IDLE;
                SmbData->IoStatusState = SMB_IO_INVALID;

                //
                // Return any read data if needed
                //

                memcpy (SmbReq->Data, SmbData->HcState.Data, SMB_MAX_DATA_SIZE);
                SmbReq->BlockLength = SmbData->HcState.BlockLength;
                Irp->IoStatus.Status = STATUS_SUCCESS;
                Irp->IoStatus.Information = sizeof(SMB_REQUEST);

                //
                // Note SmbClass driver will drop the lock during this call
                //

                SmbClassCompleteRequest (SmbClass);
                break;

            case SMB_IO_CHECK_ALARM:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_CHECK_ALARM\n"));

                //
                // HC alarm values read, check them
                //

                SmbPrint (SMB_NOTE, ("SmbHcService: Process Alarm Data %x %x %x\n",
                    SmbData->HcState.AlarmAddress,
                    SmbData->HcState.AlarmData[0],
                    SmbData->HcState.AlarmData[1]
                    ));

                //
                // Inform the class driver of the event.
                //

                SmbClassAlarm (
                    SmbClass,
                    (UCHAR)  (SmbData->HcState.AlarmAddress >> 1),
                    (USHORT) (SmbData->HcState.AlarmData[0] | (SmbData->HcState.AlarmData[1] << 8))
                    );

                //
                // Clear the alarm bit in the status value, and then check
                // for idle state
                //

                SmbData->HcState.Status = 0;
                IoBuffer = &SmbData->HcState.Status;
                IoLength = 1;
                IoWrite  = TRUE;
                IoWaitingState = SMB_IO_READ_STATUS;
                SmbData->IoStatusState = SMB_IO_CHECK_IDLE;
                break;

            case SMB_IO_COMPLETE_REG_IO:
                SmbPrint (SMB_STATE, ("SmbService: SMB_IO_COMPLETE_REQ_IO\n"));

                //
                // Irp for HC reg IO is complete, check it
                //

                Irp = SmbClass->CurrentIrp;

                if (!Irp) {
                    //
                    // No current irp - check for status irp
                    //

                    Irp = SmbData->StatusIrp;

                    if (Irp) {
                        // just reading status
                        IoFreeIrp (Irp);
                        SmbData->StatusIrp = NULL;
                    } else {
                        SmbPrint (SMB_WARN, ("SmbHcServiceIoLoop: HC Reg Io for what?\n"));
                    }

                } else {

                    //
                    // Check for error on register access
                    //

                    if (!NT_SUCCESS(Irp->IoStatus.Status)) {
                        SmbPrint (SMB_WARN, ("SmbHcServiceIoLoop: HC Reg Io request failed\n"));

                        //
                        // Condition is likely fatal, give it up
                        //

                        SmbData->HcState.Protocol = 0;
                        SmbData->HcState.Status = SMB_UNKNOWN_ERROR;
                    }
                }

                //
                // Continue to next state
                //

                SmbData->IoState = SmbData->IoWaitingState;
                SmbPrint (SMB_STATE, ("SmbService: Next state: %x\n", SmbData->IoState));
                break;

            default:
                SmbPrint (SMB_ERROR, ("SmbHcServiceIoLoop: Invalid state: %x\n", SmbData->IoState));
                SmbData->IoState = SMB_IO_CHECK_IDLE;
                break;
        }

        //
        // If there's an IO operation to the HC registers required, dispatch it
        //

        if (IoWaitingState != SMB_IO_IDLE) {
            SmbPrint (SMB_STATE, ("SmbService: IoWaitingState %d\n", IoWaitingState));

            if (IoLength) {
                //
                // There's an Io operation dispatch. Set status as REG IO pending,
                // and drop the device lock
                //

                SmbData->IoWaitingState = IoWaitingState;
                SmbData->IoState = SMB_IO_WAITING_FOR_HC_REG_IO;
                SmbClassUnlockDevice(SmbClass);

                //
                // Setup IRP to perform the register IO to the HC
                //

                Status = STATUS_INSUFFICIENT_RESOURCES;
                Irp = SmbClass->CurrentIrp;
                if (!Irp) {
                    Irp = IoAllocateIrp (SmbClass->DeviceObject->StackSize, FALSE);
                    SmbData->StatusIrp = Irp;
                }

                if (Irp) {

                    //
                    // Fill in register transfer request
                    //

                    IrpSp = IoGetNextIrpStackLocation (Irp);
                    IrpSp->MajorFunction = IoWrite ? IRP_MJ_WRITE : IRP_MJ_READ;
                    IrpSp->Parameters.Read.Length = IoLength;
                    IrpSp->Parameters.Read.Key    = 0;
                    IrpSp->Parameters.Read.ByteOffset.HighPart = 0;
                    IrpSp->Parameters.Read.ByteOffset.LowPart =
                            (ULONG) ((PUCHAR) IoBuffer - (PUCHAR) &SmbData->HcState) +
                            SmbData->EcBase;

                    Irp->AssociatedIrp.SystemBuffer = IoBuffer;

                    //
                    // Setup completion routine
                    //

                    IoSetCompletionRoutine (
                        Irp,
                        SmbHcRegIoComplete,
                        SmbData,
                        TRUE,
                        TRUE,
                        TRUE
                        );

                    SmbPrint (SMB_STATE, ("SmbService: IRP=%x, IrpSp=%x\n", Irp, IrpSp));
                    SmbPrint (SMB_STATE, ("SmbService: %s Off=%x, Len=%x, Buffer=%x\n",
                        IoWrite ? "write" : "read",
                        IrpSp->Parameters.Read.ByteOffset.LowPart,
                        IoLength,
                        IoBuffer
                        ));


                    //
                    // Call lower FDO to perform the IO
                    //

                    Status = IoCallDriver (SmbData->LowerDeviceObject, Irp);
                }

                //
                // If the request is not pending, complete it
                //

                SmbClassLockDevice(SmbClass);
                if (Status != STATUS_PENDING) {
                    SmbData->IoState = SMB_IO_COMPLETE_REG_IO;
                }

            } else {
                // no data to transfer continue with next state
                SmbData->IoState = IoWaitingState;
            }

            IoWaitingState = SMB_IO_IDLE;       // was: SMB_IO_CHEC_IDLE
            IoBuffer = NULL;
            IoWrite  = FALSE;
        }


        //
        // Loop unless state requires some asynchronous to exit
        //

    } while (SmbData->IoState != SMB_IO_IDLE   &&
             SmbData->IoState != SMB_IO_WAITING_FOR_HC_REG_IO   &&
             SmbData->IoState != SMB_IO_WAITING_FOR_STATUS) ;


    SmbPrint (SMB_STATE, ("SmbService: Exit\n"));
}