/*++ 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")); }