/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
control.c
Abstract:
Author:
Shie-Lin Tzong (shielint) Apr-23-1995
Most of the code is adapted from PCI bus extender.
Environment:
Kernel mode only.
Revision History:
--*/
#include "busp.h"
VOID
MbpiCompleteDeviceControl (
NTSTATUS Status,
PHAL_DEVICE_CONTROL_CONTEXT Context,
PDEVICE_DATA DeviceData,
PBOOLEAN Sync
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE,MbpControlWorker)
#pragma alloc_text(PAGE,MbpCompleteDeviceControl)
#endif
VOID
MbpStartWorker (
VOID
)
/*++
Routine Description:
This function is used to start a worker thread.
Arguments:
None.
Return Value:
None.
--*/
{
ULONG workerQueued;
if (!MbpWorkerQueued) {
workerQueued = ExInterlockedExchangeUlong (
&MbpWorkerQueued,
1,
MbpSpinLock
);
if (!workerQueued) {
ExQueueWorkItem (&MbpWorkItem, DelayedWorkQueue);
}
}
}
VOID
MbpQueueCheckBus (
IN PBUS_HANDLER BusHandler
)
/*++
Routine Description:
This function enqueues Bus check request to buscheck list.
Arguments:
BusHandler - supplies a pointer to the bus handler of the bus to be checked.
Return Value:
None.
--*/
{
ExInterlockedInsertTailList (
&MbpCheckBusList,
&((PMB_BUS_EXTENSION)BusHandler->BusData)->CheckBus,
&MbpSpinlock
);
MbpStartWorker();
}
VOID
MbpControlWorker (
IN PVOID WorkerContext
)
/*++
Routine Description:
This function is called by a system worker thread.
The worker thread dequeues any SlotControls which need to be
processed and dispatches them.
It then checks for any check bus request.
Arguments:
WorkerContext - supplies a pointer to a context for the worker. Here
it is always NULL.
Return Value:
None.
--*/
{
PLIST_ENTRY entry;
PMB_BUS_EXTENSION busExtension;
PHAL_DEVICE_CONTROL_CONTEXT context;
PAGED_CODE ();
//
// process check bus
//
for (; ;) {
entry = ExInterlockedRemoveHeadList (
&MbpCheckBusList,
&MbpSpinlock
);
if (!entry) {
break;
}
busExtension = CONTAINING_RECORD (
entry,
MB_BUS_EXTENSION,
CheckBus
);
MbpCheckBus (busExtension->BusHandler);
}
//
// Reset worker item for next time
//
ExInitializeWorkItem (&MbpWorkItem, MbpControlWorker, NULL);
ExInterlockedExchangeUlong (&MbpWorkerQueued, 0, MbpSpinLock);
//
// Dispatch pending device controls
//
for (; ;) {
entry = ExInterlockedRemoveHeadList (
&MbpControlWorkerList,
&MbpSpinlock
);
if (!entry) {
//
// All done, exit the loop.
//
break;
}
context = CONTAINING_RECORD (
entry,
HAL_DEVICE_CONTROL_CONTEXT,
ContextWorkQueue,
);
MbpDispatchControl (context);
}
}
VOID
MbpDispatchControl (
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function dispatches a DeviceControl to the appropiate handler.
If the slot is busy, the DeviceControl may be queued for dispatching at
a later time
Arguments:
Context - The DeviceControl context to dispatch
Return Value:
None.
--*/
{
PDEVICE_CONTROL_HANDLER deviceControlHandler;
PMB_BUS_EXTENSION busExtension;
PDEVICE_DATA deviceData;
KIRQL oldIrql;
BOOLEAN enqueueIt;
PLIST_ENTRY link;
deviceControlHandler = (PDEVICE_CONTROL_HANDLER) Context->ContextControlHandler;
deviceData = DeviceHandler2DeviceData (Context->DeviceControl.DeviceHandler);
busExtension = (PMB_BUS_EXTENSION)Context->Handler->BusData;
//
// Get access to the slot specific data.
//
ExAcquireFastMutex(&MbpMutex);
//
// Verify the device data is still valid
//
if (!deviceData->Flags & DEVICE_FLAGS_VALID) {
//
// Caller has invalid handle, or handle to a different device
//
DebugPrint ((DEBUG_MESSAGE, "PnpBios: DeviceControl has invalid device handler \n" ));
Context->DeviceControl.Status = STATUS_NO_SUCH_DEVICE;
ExReleaseFastMutex(&MbpMutex);
HalCompleteDeviceControl (Context);
return ;
}
//
// Check to see if this request can be begun now
//
link = (PLIST_ENTRY) &Context->ContextWorkQueue;
enqueueIt = deviceControlHandler->BeginDeviceControl (deviceData, Context);
if (enqueueIt) {
//
// Enqueue this command to be handled when the slot is no longer busy.
//
KeAcquireSpinLock (&MbpSpinlock, &oldIrql);
InsertTailList (&busExtension->DeviceControl, link);
KeReleaseSpinLock (&MbpSpinlock, oldIrql);
ExReleaseFastMutex(&MbpMutex);
return ;
}
//
// Dispatch the function to it's handler
//
ExReleaseFastMutex(&MbpMutex);
deviceControlHandler->ControlHandler (deviceData, Context);
}
VOID
MbpiCompleteDeviceControl (
NTSTATUS Status,
PHAL_DEVICE_CONTROL_CONTEXT Context,
PDEVICE_DATA DeviceData,
PBOOLEAN Sync
)
/*++
Routine Description:
This function is used to complete a SlotControl. If another SlotControl
was delayed on this device, this function will dispatch them
Arguments:
Status - supplies a NTSTATUS code for the completion.
Context - supplies a pointer to the original device control context.
DeviceData - supplies a pointer to the device data to be completed.
Sync - supplies a BOOLEAN variable to indicate
Return Value:
--*/
{
KIRQL oldIrql;
PLIST_ENTRY link;
PBOOLEAN busyFlag;
BOOLEAN startWorker = FALSE;
PMB_BUS_EXTENSION busExtension;
PDEVICE_HANDLER_OBJECT deviceHandler;
busyFlag = (PBOOLEAN) Context->ContextBusyFlag;
deviceHandler = DeviceData2DeviceHandler(DeviceData);
busExtension = (PMB_BUS_EXTENSION)Context->Handler->BusData;
//
// Pass it to the hal for completion
//
Context->DeviceControl.Status = Status;
HalCompleteDeviceControl (Context);
//
// Get access to the slot specific data.
//
KeAcquireSpinLock (&MbpSpinlock, &oldIrql);
//
// Clear appropiate busy flag
//
*busyFlag = FALSE;
//
// Check to see if there are any pending device controls for
// this device. If so, requeue them to the worker thread
//
for (link = busExtension->DeviceControl.Flink;
link != &busExtension->DeviceControl;
link = link->Flink) {
Context = CONTAINING_RECORD (link, HAL_DEVICE_CONTROL_CONTEXT, ContextWorkQueue);
if (Context->DeviceControl.DeviceHandler == deviceHandler) {
RemoveEntryList (link);
InsertTailList (&MbpControlWorkerList, link);
startWorker = TRUE;
break;
}
}
KeReleaseSpinLock (&MbpSpinlock, oldIrql);
if (startWorker) {
MbpStartWorker ();
}
}
VOID
MbpCompleteDeviceControl (
NTSTATUS Status,
PHAL_DEVICE_CONTROL_CONTEXT Context,
PDEVICE_DATA DeviceData
)
/*++
Routine Description:
This function is used to complete a DeviceControl. If another DeviceControl
was delayed on this device, this function will dispatch them
Arguments:
Return Value:
--*/
{
PAGED_CODE();
MbpiCompleteDeviceControl (
Status,
Context,
DeviceData,
&DeviceData->SyncBusy
);
}
BOOLEAN
FASTCALL
MbBCtlNone (
PDEVICE_DATA DeviceData,
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function is used to indicate there is no synchronization for this
device control function.
Arguments:
Context - supplies a pointer to the device control context.
DeviceData - supplies a pointer to the device data to be completed.
Return Value:
A boolean value to indicate if the request needs to be enqueued for later
processing.
--*/
{
//
// No synchronization needed for this SlotControl
//
Context->ContextBusyFlag = (ULONG) &MbpNoBusyFlag;
return FALSE;
}
BOOLEAN
FASTCALL
MbBCtlSync (
PDEVICE_DATA DeviceData,
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function is used to synchronize device control request. it checks the
state (busy/not busy) of the slot and returns a boolean flag to indicate
whether the request can be serviced immediately or it needs to be enqueued for
later processing.
Arguments:
DeviceData - supplies a pointer to the device data to be completed.
Context - supplies a pointer to the device control context.
Return Value:
A boolean value to indicate if the request needs to be enqueued for later
processing.
--*/
{
//
// This is a sync command, verify the slot is not busy with a different
// command.
//
if (DeviceData->SyncBusy) {
//
// Enqueue this command to be handled when the slot is no longer busy.
//
return TRUE;
}
//
// Don't enqueue, dispatch it now
//
DeviceData->SyncBusy = TRUE;
Context->ContextBusyFlag = (ULONG) &DeviceData->SyncBusy;
return FALSE;
}
BOOLEAN
FASTCALL
MbBCtlEject (
PDEVICE_DATA DeviceData,
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function is used to synchronize Eject device control request. it checks the
state (busy/not busy) of the device and returns a boolean flag to indicate
whether the request can be serviced immediately or it needs to be enqueued for
later processing.
Arguments:
DeviceData - supplies a pointer to the device data to be completed.
Context - supplies a pointer to the slot control context.
Return Value:
A boolean value to indicate if the request needs to be enqueued for later
processing.
--*/
{
BOOLEAN busy;
//
// If Slot is busy, then wait
//
busy = MbBCtlSync (DeviceData, Context);
if (!busy) {
//
// Set no device in the slot
//
DeviceData->Flags &= ~DEVICE_FLAGS_VALID;
DebugPrint ((DEBUG_MESSAGE, "PnpBios: set handle invalid - slot %x for Eject request.\n",
DeviceDataSlot(DeviceData)));
}
return busy;
}
BOOLEAN
FASTCALL
MbBCtlLock (
PDEVICE_DATA DeviceData,
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function is used to synchronize LOCK device control request. it checks the
state (busy/not busy) of the device and returns a boolean flag to indicate
whether the request can be serviced immediately or it needs to be enqueued for
later processing.
Arguments:
DeviceData - supplies a pointer to the device data to be completed.
Context - supplies a pointer to the device control context.
Return Value:
A boolean value to indicate if the request needs to be enqueued for later
processing.
--*/
{
BOOLEAN busy;
//
// If Slot is busy, then wait
//
busy = MbBCtlSync (DeviceData, Context);
#if 0
if (!busy) {
lock = ((PBCTL_SET_CONTROL) Context->DeviceControl.Buffer)->Control;
if (!lock) {
//
// Set no device in the slot
//
DeviceData->Flags &= ~DEVICE_FLAGS_VALID;
}
}
#endif
return busy;
}
VOID
MbCtlEject (
PDEVICE_DATA DeviceData,
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function is used to eject the docking station in the docking station
slot.
Arguments:
Context - supplies a pointer to the device control context.
DeviceData - supplies a pointer to the device data to be completed.
Return Value:
None.
--*/
{
NTSTATUS status = STATUS_INVALID_PARAMETER;
if (DeviceData->Flags & DEVICE_FLAGS_DOCKING_STATION) {
status = MbpReplyEjectEvent(DeviceDataSlot(DeviceData), TRUE);
}
MbpCompleteDeviceControl (status, Context, DeviceData);
}
VOID
MbCtlLock (
PDEVICE_DATA DeviceData,
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function is used to reject the Pnp Bios About-to-undock event.
To accept the about-to-undock event, the EJECT device control function
should be used. If lock = TRUE, it will be handled as a reject eject
request. If lock = FALSE, it will be handled as an accept reject rquest.
Arguments:
DeviceData - supplies a pointer to the device data to be completed.
Context - supplies a pointer to the device control context.
Return Value:
None.
--*/
{
BOOLEAN lock;
NTSTATUS status = STATUS_INVALID_PARAMETER;
lock = ((PBCTL_SET_CONTROL) Context->DeviceControl.Buffer)->Control;
if (DeviceData->Flags & DEVICE_FLAGS_DOCKING_STATION) {
status = MbpReplyEjectEvent(DeviceDataSlot(DeviceData), (BOOLEAN)!lock);
}
MbpCompleteDeviceControl (status, Context, DeviceData);
}
VOID
MbCtlQueryEject (
PDEVICE_DATA DeviceData,
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function returns a referenced pointer to a callback object which
the bus extender will notify whenever a given device's eject botton is
pressed.
Arguments:
DeviceData - supplies a pointer to the device data to be completed.
Context - supplies a pointer to the device control context.
Return Value:
None.
--*/
{
NTSTATUS status = STATUS_INVALID_PARAMETER;
PULONG callback;
callback =(PULONG)((PBCTL_SET_CONTROL) Context->DeviceControl.Buffer);
if (DeviceData->Flags == DEVICE_FLAGS_DOCKING_STATION) {
if (MbpEjectCallbackObject) {
status = STATUS_SUCCESS;
*callback = (ULONG)MbpEjectCallbackObject;
} else {
status = STATUS_UNSUCCESSFUL;
}
}
MbpCompleteDeviceControl (status, Context, DeviceData);
}
VOID
MbCtlQueryDeviceCapabilities (
PDEVICE_DATA DeviceData,
PHAL_DEVICE_CONTROL_CONTEXT Context
)
/*++
Routine Description:
This function returns the BCTL_DEVICE_CAPABILITIES structure to the caller
specified buffer.
Arguments:
DeviceData - supplies a pointer to the device data to be completed.
Context - supplies a pointer to the device control context.
Return Value:
None.
--*/
{
PBCTL_DEVICE_CAPABILITIES capabilities;
capabilities = (PBCTL_DEVICE_CAPABILITIES) Context->DeviceControl.Buffer;
capabilities->PowerSupported = FALSE;
capabilities->ResumeSupported = FALSE;
capabilities->LockSupported = FALSE;
if (DeviceData->Flags && DEVICE_FLAGS_EJECT_SUPPORTED) {
capabilities->EjectSupported = TRUE;
} else {
capabilities->EjectSupported = FALSE;
}
MbpCompleteDeviceControl (STATUS_SUCCESS, Context, DeviceData);
}
