able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/pnp/cfgmgr32/resdes.c

1905 lines
54 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995-2001 Microsoft Corporation
Module Name:
resdes.c
Abstract:
This module contains the API routines that operate directly on resource
descriptions.
CM_Add_Res_Des
CM_Free_Res_Des
CM_Get_Next_Res_Des
CM_Get_Res_Des_Data
CM_Get_Res_Des_Data_Size
CM_Modify_Res_Des
CM_Detect_Resource_Conflict
CM_Free_Res_Des_Handle
Author:
Paula Tomlinson (paulat) 9-26-1995
Environment:
User mode only.
Revision History:
26-Sept-1995 paulat
Creation and initial implementation.
--*/
//
// includes
//
#include "precomp.h"
#include "cfgi.h"
#include "setupapi.h"
#include "spapip.h"
//
// Private prototypes
//
CONFIGRET
CreateResDesHandle(
PRES_DES prdResDes,
DEVINST dnDevInst,
ULONG ulLogType,
ULONG ulLogTag,
ULONG ulResType,
ULONG ulResTag
);
BOOL
ValidateResDesHandle(
PPrivate_Res_Des_Handle pResDes
);
CONFIGRET
Get32bitResDesFrom64bitResDes(
IN RESOURCEID ResourceID,
IN PCVOID ResData64,
IN ULONG ResLen64,
OUT PVOID * ResData32,
OUT ULONG * ResLen32
);
CONFIGRET
Convert32bitResDesTo64bitResDes(
IN RESOURCEID ResourceID,
IN OUT PVOID ResData,
IN ULONG ResLen
);
CONFIGRET
Convert32bitResDesSizeTo64bitResDesSize(
IN RESOURCEID ResourceID,
IN OUT PULONG ResLen
);
//
// private prototypes from logconf.c
//
CONFIGRET
CreateLogConfHandle(
PLOG_CONF plcLogConf,
DEVINST dnDevInst,
ULONG ulLogType,
ULONG ulLogTag
);
BOOL
ValidateLogConfHandle(
PPrivate_Log_Conf_Handle pLogConf
);
CONFIGRET
CM_Add_Res_Des_Ex(
OUT PRES_DES prdResDes,
IN LOG_CONF lcLogConf,
IN RESOURCEID ResourceID,
IN PCVOID ResourceData,
IN ULONG ResourceLen,
IN ULONG ulFlags,
IN HMACHINE hMachine
)
/*++
Routine Description:
This routine adds a resource descriptor to a logical configuration.
Parameters:
prdResDes Address of a variable that receives a handle for the new
resource descriptor.
lcLogConf Supplies the handle of the logical configuration to which
the resource descriptor is added.
ResourceID Specifies the type of the resource. Can be one of the
ResType values defined in Section 2.1..
ResourceData Supplies the address of an IO_DES, MEM_DES, DMA_DES, or
IRQ_DES structure, depending on the given resource type.
ResourceLen Supplies the size, in bytes, of the structure pointed to
by ResourceData.
ulFlags Specifies the width of certain variable-size resource
descriptor structure fields, where applicable.
Currently, the following flags are defined:
CM_RESDES_WIDTH_32 or
CM_RESDES_WIDTH_64
If no flags are specified, the width of the variable-sized
resource data supplied is assumed to be that native to the
platform of the caller.
hMachine Machine handle returned from CM_Connect_Machine or NULL.
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
If the function fails, the return value is one of the following:
CR_INVALID_LOG_CONF,
CR_INVALID_FLAG,
CR_INVALID_POINTER,
CR_INVALID_RESOURCE_ID,
CR_OUT_OF_MEMORY.
--*/
{
CONFIGRET Status = CR_SUCCESS;
DEVINST dnDevInst;
WCHAR pDeviceID [MAX_DEVICE_ID_LEN];
ULONG ulResTag, ulLogTag, ulLogType,ulLen = MAX_DEVICE_ID_LEN;
PVOID hStringTable = NULL;
handle_t hBinding = NULL;
BOOL Success;
PVOID ResourceData32 = NULL;
ULONG ResourceLen32 = 0;
try {
//
// validate parameters
//
if (!ValidateLogConfHandle((PPrivate_Log_Conf_Handle)lcLogConf)) {
Status = CR_INVALID_LOG_CONF;
goto Clean0;
}
if (INVALID_FLAGS(ulFlags, CM_RESDES_WIDTH_BITS)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
if ((ulFlags & CM_RESDES_WIDTH_32) && (ulFlags & CM_RESDES_WIDTH_64)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
#ifdef _WIN64
if ((ulFlags & CM_RESDES_WIDTH_BITS) == CM_RESDES_WIDTH_DEFAULT) {
ulFlags |= CM_RESDES_WIDTH_64;
}
#endif // _WIN64
if (ulFlags & CM_RESDES_WIDTH_32) {
ulFlags &= ~CM_RESDES_WIDTH_BITS;
}
if (ResourceData == NULL || ResourceLen == 0) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
#if 0
if (ResourceID > ResType_MAX && ResourceID != ResType_ClassSpecific) {
Status = CR_INVALID_RESOURCEID;
goto Clean0;
}
#endif
if (ResourceID == ResType_All) {
Status = CR_INVALID_RESOURCEID; // can't specify All on an add
}
//
// Initialize parameters
//
if (prdResDes != NULL) { // prdResDes is optional param
*prdResDes = 0;
}
//
// extract info from the log conf handle
//
dnDevInst = ((PPrivate_Log_Conf_Handle)lcLogConf)->LC_DevInst;
ulLogType = ((PPrivate_Log_Conf_Handle)lcLogConf)->LC_LogConfType;
ulLogTag = ((PPrivate_Log_Conf_Handle)lcLogConf)->LC_LogConfTag;
//
// setup rpc binding handle and string table handle
//
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
Status = CR_FAILURE;
goto Clean0;
}
//
// Make sure the server can support the client's 64-bit resdes request.
// Only server versions 0x0501 and greater support CM_RESDES_WIDTH_64.
//
if (ulFlags & CM_RESDES_WIDTH_64) {
if (!CM_Is_Version_Available_Ex((WORD)0x0501,
hMachine)) {
//
// Server can only support 32-bit resdes. Have the client
// convert the caller's 64-bit resdes to a 32-bit resdes for the
// server.
//
ulFlags &= ~CM_RESDES_WIDTH_BITS;
Status = Get32bitResDesFrom64bitResDes(ResourceID,ResourceData,ResourceLen,&ResourceData32,&ResourceLen32);
if(Status != CR_SUCCESS) {
goto Clean0;
}
if(ResourceData32) {
ResourceData = ResourceData32;
ResourceLen = ResourceLen32;
}
}
}
//
// retreive device instance string that corresponds to dnDevInst
//
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
Status = CR_INVALID_LOG_CONF;
goto Clean0;
}
RpcTryExcept {
//
// call rpc service entry point
//
Status = PNP_AddResDes(
hBinding, // rpc binding handle
pDeviceID, // device id string
ulLogTag, // log conf tag
ulLogType, // log conf type
ResourceID, // resource type
&ulResTag, // resource tag
(LPBYTE)ResourceData, // actual res des data
ResourceLen, // size in bytes of ResourceData
ulFlags); // currently zero
}
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
KdPrintEx((DPFLTR_PNPMGR_ID,
DBGF_ERRORS,
"PNP_AddResDes caused an exception (%d)\n",
RpcExceptionCode()));
Status = MapRpcExceptionToCR(RpcExceptionCode());
}
RpcEndExcept
if (Status == CR_SUCCESS && prdResDes != NULL) {
Status = CreateResDesHandle(prdResDes,
dnDevInst,
ulLogType,
ulLogTag,
ResourceID,
ulResTag);
}
Clean0:
NOTHING;
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = CR_FAILURE;
}
if(ResourceData32) {
pSetupFree(ResourceData32);
}
return Status;
} // CM_Add_Res_Des_Ex
CONFIGRET
CM_Free_Res_Des_Ex(
OUT PRES_DES prdResDes,
IN RES_DES rdResDes,
IN ULONG ulFlags,
IN HMACHINE hMachine
)
/*++
Routine Description:
This routine destroys a resource descriptor. This API returns
CR_NO_MORE_RES_DES if rdResDes specifies the last resource descriptor.
Parameters:
prdResDes Supplies the address of the variable that receives the
handle of the previous resource descriptor. If rdResDes
is the handle of the first resource descriptor, this
address receives the handle of the logical configuration.
rdResDes Supplies the handle of the resource descriptor to be destroyed.
ulFlags Must be zero.
hMachine Machine handle returned from CM_Connect_Machine or NULL.
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
If the function fails, the return value is one of the following:
CR_INVALID_FLAG,
CR_INVALID_POINTER,
CR_INVALID_RES_DES,
CR_NO_MORE_RES_DES.
--*/
{
CONFIGRET Status = CR_SUCCESS;
DEVINST dnDevInst;
WCHAR pDeviceID[MAX_DEVICE_ID_LEN];
ULONG ulLogType, ulLogTag, ulResType, ulResTag,ulLen=MAX_DEVICE_ID_LEN;
ULONG ulPreviousResType = 0, ulPreviousResTag = 0;
PVOID hStringTable = NULL;
handle_t hBinding = NULL;
BOOL Success;
try {
//
// validate parameters
//
if (!ValidateResDesHandle((PPrivate_Res_Des_Handle)rdResDes)) {
Status = CR_INVALID_RES_DES;
goto Clean0;
}
if (INVALID_FLAGS(ulFlags, 0)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
//
// Initialize parameters
//
if (prdResDes != NULL) { // optional parameter
*prdResDes = 0;
}
//
// extract info from the res des handle
//
dnDevInst = ((PPrivate_Res_Des_Handle)rdResDes)->RD_DevInst;
ulLogType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfType;
ulLogTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfTag;
ulResType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResourceType;
ulResTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResDesTag;
//
// setup rpc binding handle and string table handle
//
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
Status = CR_FAILURE;
goto Clean0;
}
//
// retreive device instance string that corresponds to dnDevInst
//
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
Status = CR_INVALID_RES_DES;
goto Clean0;
}
RpcTryExcept {
//
// call rpc service entry point
//
Status = PNP_FreeResDes(
hBinding, // rpc binding handle
pDeviceID, // device id string
ulLogTag, // log conf tag
ulLogType, // log conf type
ulResType, // resource type
ulResTag, // resource tag
&ulPreviousResType, // resource type of previous res des
&ulPreviousResTag, // tag of previous res des
ulFlags); // currently zero
}
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
KdPrintEx((DPFLTR_PNPMGR_ID,
DBGF_ERRORS,
"PNP_FreeResDes caused an exception (%d)\n",
RpcExceptionCode()));
Status = MapRpcExceptionToCR(RpcExceptionCode());
}
RpcEndExcept
if (Status != CR_SUCCESS && Status != CR_NO_MORE_RES_DES) {
goto Clean0; // quit for any other error
}
//
// if prdResDes supplied, fill in with previous res des or
// the log conf info
//
if (prdResDes != NULL) {
//
// if the previous tag value is set to 0xFFFFFFFF, then
// there are no previous tages so return the log conf
// info instead
//
if (Status == CR_NO_MORE_RES_DES) {
CONFIGRET Status1;
Status1 = CreateLogConfHandle(prdResDes, dnDevInst,
ulLogType, ulLogTag);
if (Status1 != CR_SUCCESS) {
Status = Status1;
}
}
else {
//
// allocate a res des handle
//
Status = CreateResDesHandle(prdResDes, dnDevInst,
ulLogType, ulLogTag,
ulPreviousResType,
ulPreviousResTag);
}
}
Clean0:
NOTHING;
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = CR_FAILURE;
}
return Status;
} // CM_Free_Res_Des_Ex
CONFIGRET
CM_Get_Next_Res_Des_Ex(
OUT PRES_DES prdResDes,
IN RES_DES rdResDes,
IN RESOURCEID ForResource,
OUT PRESOURCEID pResourceID,
IN ULONG ulFlags,
IN HMACHINE hMachine
)
/*++
Routine Description:
This routine returns the handle of the next resource descriptor in
a logical configuration.
Parameters:
prdResDes Supplies the address of the variable that receives the
handle of the next resource descriptor.
rdResDes Supplies the handle of the current resource
descriptor or the handle of a logical configuration.
(Both are 32-bit numbers--Configuration Manager must can
distinguish between them.)
ForResource Specifies the type of the resource to retrieve. Can be
one of the ResType values listed in Section 2.1..
pResourceID Supplies the address of the variable that receives the
resource type, when ForResource specifies ResType_All.
(When ForResource is not ResType_All, this parameter can
be NULL.)
ulFlags Must be zero.
hMachine Machine handle returned from CM_Connect_Machine or NULL.
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
If the function fails, the return value is one of the following:
CR_INVALID_LOG_CONF,
CR_INVALID_FLAG,
CR_INVALID_POINTER,
CR_INVALID_RES_DES,
CR_NO_MORE_RES_DES.
--*/
{
CONFIGRET Status = CR_SUCCESS;
DEVINST dnDevInst;
WCHAR pDeviceID [MAX_DEVICE_ID_LEN];
ULONG ulLogTag, ulLogType, ulResTag,ulLen = MAX_DEVICE_ID_LEN;
ULONG ulNextResType = 0, ulNextResTag = 0;
PVOID hStringTable = NULL;
handle_t hBinding = NULL;
BOOL Success;
try {
//
// validate parameters
//
if (prdResDes == NULL) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
#if 0
if (ForResource > ResType_MAX &&
ForResource != ResType_ClassSpecific) {
Status = CR_INVALID_RESOURCEID;
goto Clean0;
}
#endif
if (ForResource == ResType_All && pResourceID == NULL) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
if (INVALID_FLAGS(ulFlags, 0)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
//
// this handle could be a res des or a log conf, determine
// which and extract info handle
//
if (ValidateResDesHandle((PPrivate_Res_Des_Handle)rdResDes)) {
//
// it was a valid res des handle
//
dnDevInst = ((PPrivate_Res_Des_Handle)rdResDes)->RD_DevInst;
ulLogType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfType;
ulLogTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfTag;
ulResTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResDesTag;
}
else if (ValidateLogConfHandle((PPrivate_Log_Conf_Handle)rdResDes)) {
//
// it was a valid log conf handle, so assume it's the first
// res des we want
//
dnDevInst = ((PPrivate_Log_Conf_Handle)rdResDes)->LC_DevInst;
ulLogType = ((PPrivate_Log_Conf_Handle)rdResDes)->LC_LogConfType;
ulLogTag = ((PPrivate_Log_Conf_Handle)rdResDes)->LC_LogConfTag;
ulResTag = MAX_RESDES_TAG;
}
else {
//
// it was neither a valid log conf nor a valid res des handle
//
Status = CR_INVALID_RES_DES;
goto Clean0;
}
//
// setup rpc binding handle and string table handle
//
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
Status = CR_FAILURE;
goto Clean0;
}
//
// retreive device instance string that corresponds to dnDevInst
//
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
Status = CR_INVALID_LOG_CONF;
goto Clean0;
}
RpcTryExcept {
//
// call rpc service entry point
//
Status = PNP_GetNextResDes(
hBinding, // rpc binding handle
pDeviceID, // device id string
ulLogTag, // log conf tag
ulLogType, // log conf type
ForResource, // resource type
ulResTag, // resource tag
&ulNextResTag, // next res des of type ForResource
&ulNextResType, // type of next res des
ulFlags); // 32/64 bit data
}
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
KdPrintEx((DPFLTR_PNPMGR_ID,
DBGF_ERRORS,
"PNP_GetNextResDes caused an exception (%d)\n",
RpcExceptionCode()));
Status = MapRpcExceptionToCR(RpcExceptionCode());
}
RpcEndExcept
if (Status != CR_SUCCESS) {
goto Clean0;
}
if (ForResource == ResType_All) {
*pResourceID = ulNextResType;
}
Status = CreateResDesHandle(prdResDes,
dnDevInst,
ulLogType,
ulLogTag,
ulNextResType,
ulNextResTag);
Clean0:
NOTHING;
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = CR_FAILURE;
}
return Status;
} // CM_Get_Next_Res_Des_Ex
CONFIGRET
CM_Get_Res_Des_Data_Ex(
IN RES_DES rdResDes,
OUT PVOID Buffer,
IN ULONG BufferLen,
IN ULONG ulFlags,
IN HMACHINE hMachine
)
/*++
Routine Description:
This routine copies the data from a specified resource descriptor
into a buffer. Use the CM_Get_Res_Des_Data_Size API to determine
the buffer size needed to receive the data. Alternately, set a
size that is at least as large as the maximum possible size of the
resource. If the size given is too small, the data is truncated and
the API returns CR_BUFFER_SMALL.
Parameters:
rdResDes Supplies the handle of the resource descriptor from which
data is to be copied.
Buffer Supplies the address of the buffer that receives the data.
BufferLen Supplies the size of the buffer, in bytes.
ulFlags Specifies the width of certain variable-size resource
descriptor structure fields, where applicable.
Currently, the following flags are defined:
CM_RESDES_WIDTH_32 or
CM_RESDES_WIDTH_64
If no flags are specified, the width of the variable-sized
resource data expected is assumed to be that native to the
platform of the caller.
hMachine Machine handle returned from CM_Connect_Machine or NULL.
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
If the function fails, the return value is one of the following:
CR_INVALID_FLAG,
CR_INVALID_POINTER,
CR_INVALID_RES_DES,
CR_BUFFER_SMALL.
--*/
{
CONFIGRET Status = CR_SUCCESS;
DEVINST dnDevInst;
WCHAR pDeviceID [MAX_DEVICE_ID_LEN];
ULONG ulLogType, ulLogTag, ulResType, ulResTag,ulLen = MAX_DEVICE_ID_LEN;
PVOID hStringTable = NULL;
handle_t hBinding = NULL;
BOOL Success;
BOOL ConvertResDes = FALSE;
try {
//
// validate parameters
//
if (!ValidateResDesHandle((PPrivate_Res_Des_Handle)rdResDes)) {
Status = CR_INVALID_RES_DES;
goto Clean0;
}
if (Buffer == NULL || BufferLen == 0) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
if (INVALID_FLAGS(ulFlags, CM_RESDES_WIDTH_BITS)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
if ((ulFlags & CM_RESDES_WIDTH_32) && (ulFlags & CM_RESDES_WIDTH_64)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
#ifdef _WIN64
if ((ulFlags & CM_RESDES_WIDTH_BITS) == CM_RESDES_WIDTH_DEFAULT) {
ulFlags |= CM_RESDES_WIDTH_64;
}
#endif // _WIN64
if (ulFlags & CM_RESDES_WIDTH_32) {
ulFlags &= ~CM_RESDES_WIDTH_BITS;
}
//
// extract info from the res des handle
//
dnDevInst = ((PPrivate_Res_Des_Handle)rdResDes)->RD_DevInst;
ulLogType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfType;
ulLogTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfTag;
ulResType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResourceType;
ulResTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResDesTag;
//
// setup rpc binding handle and string table handle
//
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
Status = CR_FAILURE;
goto Clean0;
}
//
// Make sure the server can support the client's 64-bit resdes request.
// Only server versions 0x0501 and greater support CM_RESDES_WIDTH_64.
//
if (ulFlags & CM_RESDES_WIDTH_64) {
if (!CM_Is_Version_Available_Ex((WORD)0x0501,
hMachine)) {
//
// Client will only give us 32-bit resdes. Request a 32-bit
// resdes from the server, and we'll convert it to 64-bit here
// on the client.
//
ulFlags &= ~CM_RESDES_WIDTH_BITS;
ConvertResDes = TRUE;
}
}
//
// retreive device instance string that corresponds to dnDevInst
//
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
Status = CR_INVALID_RES_DES;
goto Clean0;
}
RpcTryExcept {
//
// call rpc service entry point
//
Status = PNP_GetResDesData(
hBinding, // rpc binding handle
pDeviceID, // device id string
ulLogTag, // log conf tag
ulLogType, // log conf type
ulResType, // resource type
ulResTag, // resource tag
Buffer, // return res des data
BufferLen, // size in bytes of Buffer
ulFlags); // 32/64 bit data
}
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
KdPrintEx((DPFLTR_PNPMGR_ID,
DBGF_ERRORS,
"PNP_GetResDesData caused an exception (%d)\n",
RpcExceptionCode()));
Status = MapRpcExceptionToCR(RpcExceptionCode());
}
RpcEndExcept
if((Status == CR_SUCCESS) && ConvertResDes) {
Status = Convert32bitResDesTo64bitResDes(ulResType,Buffer,BufferLen);
}
Clean0:
NOTHING;
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = CR_FAILURE;
}
return Status;
} // CM_Get_Res_Des_Data_Ex
CONFIGRET
CM_Get_Res_Des_Data_Size_Ex(
OUT PULONG pulSize,
IN RES_DES rdResDes,
IN ULONG ulFlags,
IN HMACHINE hMachine
)
/*++
Routine Description:
This routine retrieves the size of a resource descriptor, not
including the resource descriptor header.
Parameters:
pulSize Supplies the address of the variable that receives the
size, in bytes, of the resource descriptor data.
rdResDes Supplies the handle of the resource descriptor for which
to retrieve the size.
ulFlags Specifies the width of certain variable-size resource
descriptor structure fields, where applicable.
Currently, the following flags are defined:
CM_RESDES_WIDTH_32 or
CM_RESDES_WIDTH_64
If no flags are specified, the width of the variable-sized
resource data expected is assumed to be that native to the
platform of the caller.
hMachine Machine handle returned from CM_Connect_Machine or NULL.
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
If the function fails, the return value is one of the following:
CR_INVALID_RES_DES,
CR_INVALID_FLAG,
CR_INVALID_POINTER.
--*/
{
CONFIGRET Status = CR_SUCCESS;
DEVINST dnDevInst;
WCHAR pDeviceID [MAX_DEVICE_ID_LEN];
ULONG ulLogType, ulLogTag, ulResType, ulResTag,ulLen = MAX_DEVICE_ID_LEN;
PVOID hStringTable = NULL;
handle_t hBinding = NULL;
BOOL Success;
BOOL ConvertResDesSize = FALSE;
try {
//
// validate parameters
//
if (!ValidateResDesHandle((PPrivate_Res_Des_Handle)rdResDes)) {
Status = CR_INVALID_RES_DES;
goto Clean0;
}
if (pulSize == NULL) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
if (INVALID_FLAGS(ulFlags, CM_RESDES_WIDTH_BITS)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
if ((ulFlags & CM_RESDES_WIDTH_32) && (ulFlags & CM_RESDES_WIDTH_64)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
#ifdef _WIN64
if ((ulFlags & CM_RESDES_WIDTH_BITS) == CM_RESDES_WIDTH_DEFAULT) {
ulFlags |= CM_RESDES_WIDTH_64;
}
#endif // _WIN64
if (ulFlags & CM_RESDES_WIDTH_32) {
ulFlags &= ~CM_RESDES_WIDTH_BITS;
}
//
// Initialize output parameters
//
*pulSize = 0;
//
// extract info from the res des handle
//
dnDevInst = ((PPrivate_Res_Des_Handle)rdResDes)->RD_DevInst;
ulLogType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfType;
ulLogTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfTag;
ulResType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResourceType;
ulResTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResDesTag;
//
// setup rpc binding handle and string table handle
//
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
Status = CR_FAILURE;
goto Clean0;
}
//
// Make sure the server can support the client's 64-bit resdes request.
// Only server versions 0x0501 and greater support CM_RESDES_WIDTH_64.
//
if (ulFlags & CM_RESDES_WIDTH_64) {
if (!CM_Is_Version_Available_Ex((WORD)0x0501,
hMachine)) {
//
// Server only supports 32-bit resdes. Request a 32-bit
// resdes size from the server, and we'll convert it to 64-bit here
// on the client.
//
ulFlags &= ~CM_RESDES_WIDTH_BITS;
ConvertResDesSize = TRUE;
}
}
//
// retreive device instance string that corresponds to dnDevInst
//
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
Status = CR_INVALID_RES_DES;
goto Clean0;
}
RpcTryExcept {
//
// call rpc service entry point
//
Status = PNP_GetResDesDataSize(
hBinding, // rpc binding handle
pDeviceID, // device id string
ulLogTag, // log conf tag
ulLogType, // log conf type
ulResType, // resource type
ulResTag, // resource tag
pulSize, // returns size of res des data
ulFlags); // currently zero
}
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
KdPrintEx((DPFLTR_PNPMGR_ID,
DBGF_ERRORS,
"PNP_GetResDesDataSize caused an exception (%d)\n",
RpcExceptionCode()));
Status = MapRpcExceptionToCR(RpcExceptionCode());
}
RpcEndExcept
if(Status == CR_SUCCESS) {
Status = Convert32bitResDesSizeTo64bitResDesSize(ulResType,pulSize);
}
Clean0:
NOTHING;
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = CR_FAILURE;
}
return Status;
} // CM_Get_Res_Des_Data_Size_Ex
CONFIGRET
CM_Modify_Res_Des_Ex(
OUT PRES_DES prdResDes,
IN RES_DES rdResDes,
IN RESOURCEID ResourceID,
IN PCVOID ResourceData,
IN ULONG ResourceLen,
IN ULONG ulFlags,
IN HMACHINE hMachine
)
/*++
Routine Description:
This routine modifies a resource descriptor. This API retrieves a
handle to the new resource descriptor. This may or may not be the
handle of the original resource descriptor. The original resource
descriptor handle is invalid after calling this API.
Parameters:
prdResDes Supplies the address of the variable that receives the
handle of the modified resource descriptor.
rdResDes Supplies the handle of the resource descriptor to be
modified.
ResourceID Specifies the type of resource to modify. Can be one
of the ResType values described in Section 2.1..
ResourceData Supplies the address of a resource data structure.
ResourceLen Supplies the size, in bytes, of the new resource data
structure. This size can be different from the size of
the original resource data.
ulFlags Specifies the width of certain variable-size resource
descriptor structure fields, where applicable.
Currently, the following flags are defined:
CM_RESDES_WIDTH_32 or
CM_RESDES_WIDTH_64
If no flags are specified, the width of the variable-sized
resource data supplied is assumed to be that native to the
platform of the caller.
hMachine Machine handle returned from CM_Connect_Machine or NULL.
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
If the function fails, the return value is one of the following:
CR_INVALID_RES_DES,
CR_INVALID_FLAG,
CR_INVALID_POINTER,
CR_OUT_OF_MEMORY.
--*/
{
CONFIGRET Status = CR_SUCCESS;
DEVINST dnDevInst;
WCHAR pDeviceID [MAX_DEVICE_ID_LEN];
ULONG ulLogType, ulLogTag, ulResType, ulResTag,ulLen = MAX_DEVICE_ID_LEN;
PVOID hStringTable = NULL;
handle_t hBinding = NULL;
BOOL Success;
PVOID ResourceData32 = NULL;
ULONG ResourceLen32 = 0;
try {
//
// validate parameters
//
if (!ValidateResDesHandle((PPrivate_Res_Des_Handle)rdResDes)) {
Status = CR_INVALID_RES_DES;
goto Clean0;
}
if (prdResDes == NULL) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
#if 0
if (ResourceID > ResType_MAX && ResourceID != ResType_ClassSpecific) {
Status = CR_INVALID_RESOURCEID;
goto Clean0;
}
#endif
if (ResourceData == NULL || ResourceLen == 0) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
if (INVALID_FLAGS(ulFlags, CM_RESDES_WIDTH_BITS)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
if ((ulFlags & CM_RESDES_WIDTH_32) && (ulFlags & CM_RESDES_WIDTH_64)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
#ifdef _WIN64
if ((ulFlags & CM_RESDES_WIDTH_BITS) == CM_RESDES_WIDTH_DEFAULT) {
ulFlags |= CM_RESDES_WIDTH_64;
}
#endif // _WIN64
if (ulFlags & CM_RESDES_WIDTH_32) {
ulFlags &= ~CM_RESDES_WIDTH_BITS;
}
//
// initialize output parameters
//
*prdResDes = 0;
//
// extract info from the res des handle
//
dnDevInst = ((PPrivate_Res_Des_Handle)rdResDes)->RD_DevInst;
ulLogType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfType;
ulLogTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_LogConfTag;
ulResType = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResourceType;
ulResTag = ((PPrivate_Res_Des_Handle)rdResDes)->RD_ResDesTag;
//
// setup rpc binding handle and string table handle
//
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
Status = CR_FAILURE;
goto Clean0;
}
//
// Make sure the server can support the client's 64-bit resdes request.
// Only server versions 0x0501 and greater support CM_RESDES_WIDTH_64.
//
if (ulFlags & CM_RESDES_WIDTH_64) {
if (!CM_Is_Version_Available_Ex((WORD)0x0501,
hMachine)) {
//
// Server can only support 32-bit resdes. Have the client
// convert the caller's 64-bit resdes to a 32-bit resdes for the
// server.
//
ulFlags &= ~CM_RESDES_WIDTH_BITS;
Status = Get32bitResDesFrom64bitResDes(ResourceID,ResourceData,ResourceLen,&ResourceData32,&ResourceLen32);
if(Status != CR_SUCCESS) {
goto Clean0;
}
if(ResourceData32) {
ResourceData = ResourceData32;
ResourceLen = ResourceLen32;
}
}
}
//
// retreive device instance string that corresponds to dnDevInst
//
Success = pSetupStringTableStringFromIdEx(hStringTable, dnDevInst,pDeviceID,&ulLen);
if (Success == FALSE || INVALID_DEVINST(pDeviceID)) {
Status = CR_INVALID_LOG_CONF;
goto Clean0;
}
RpcTryExcept {
//
// call rpc service entry point
//
Status = PNP_ModifyResDes(
hBinding, // rpc binding handle
pDeviceID, // device id string
ulLogTag, // log conf tag
ulLogType, // log conf type
ulResType, // current resource type
ResourceID, // new resource type
ulResTag, // resource tag
(LPBYTE)ResourceData, // actual res des data
ResourceLen, // size in bytes of ResourceData
ulFlags); // currently zero
}
RpcExcept (I_RpcExceptionFilter(RpcExceptionCode())) {
KdPrintEx((DPFLTR_PNPMGR_ID,
DBGF_ERRORS,
"PNP_ModifyResDes caused an exception (%d)\n",
RpcExceptionCode()));
Status = MapRpcExceptionToCR(RpcExceptionCode());
}
RpcEndExcept
if (Status == CR_SUCCESS) {
//
// The resource type may change so a new handle is required and
// returned to caller.
//
Status = CreateResDesHandle(prdResDes,
dnDevInst,
ulLogType,
ulLogTag,
ResourceID,
ulResTag);
}
Clean0:
NOTHING;
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = CR_FAILURE;
}
if(ResourceData32) {
pSetupFree(ResourceData32);
}
return Status;
} // CM_Modify_Res_Des_Ex
CMAPI
CONFIGRET
WINAPI
CM_Detect_Resource_Conflict_Ex(
IN DEVINST dnDevInst,
IN RESOURCEID ResourceID, OPTIONAL
IN PCVOID ResourceData, OPTIONAL
IN ULONG ResourceLen, OPTIONAL
OUT PBOOL pbConflictDetected,
IN ULONG ulFlags,
IN HMACHINE hMachine
)
/*++
Routine Description:
This depreciated routine calls CM_Query_Resource_Conflict_List to see if
dnDevInst is conflicting with any other devices. It is used for a simple
"has a conflict" check. CM_Query_Resource_Conflict_List returns more
details of the conflicts.
Parameters:
dnDevInst DEVINST we're doing the test for (ie, that resource belongs to)
ResourceID,ResourceData,ResourceLen
See if this resource conflicts with a device other than dnDevInst
pbConflictDetected
Set to TRUE on conflict, FALSE if no conflict
ulFlags Specifies the width of certain variable-size resource
descriptor structure fields, where applicable.
Currently, the following flags are defined:
CM_RESDES_WIDTH_32 or
CM_RESDES_WIDTH_64
If no flags are specified, the width of the variable-sized
resource data supplied is assumed to be that native to the
platform of the caller.
hMachine Machine handle returned from CM_Connect_Machine or NULL.
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
If the function fails, the return value is one of the following:
CR_INVALID_RES_DES,
CR_INVALID_FLAG,
CR_INVALID_POINTER,
CR_OUT_OF_MEMORY.
--*/
{
CONFIGRET Status = CR_SUCCESS;
CONFLICT_LIST ConflictList = 0;
ULONG ConflictCount = 0;
WCHAR pDeviceID [MAX_DEVICE_ID_LEN]; // )
PVOID hStringTable = NULL; // > for validation only
handle_t hBinding = NULL; // )
ULONG ulLen = MAX_DEVICE_ID_LEN; // )
try {
//
// validate parameters - must maintain compatability with original implementation
// even though some of the error codes don't make sense
// don't change any of the parameters here, as they are needed for
// CM_Query_Resource_Conflict_List
//
if (dnDevInst == 0) {
Status = CR_INVALID_DEVINST;
goto Clean0;
}
if (INVALID_FLAGS(ulFlags, CM_RESDES_WIDTH_BITS)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
if ((ulFlags & CM_RESDES_WIDTH_32) && (ulFlags & CM_RESDES_WIDTH_64)) {
Status = CR_INVALID_FLAG;
goto Clean0;
}
if (pbConflictDetected == NULL) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
if (ResourceData == NULL || ResourceLen == 0) {
Status = CR_INVALID_POINTER;
goto Clean0;
}
if (ResourceID == ResType_All) {
Status = CR_INVALID_RESOURCEID; // can't specify All on a detect
goto Clean0;
}
//
// setup rpc binding handle and string table handle - for validation only
//
if (!PnPGetGlobalHandles(hMachine, &hStringTable, &hBinding)) {
Status = CR_FAILURE;
goto Clean0;
}
//
// retreive device instance string that corresponds to dnDevInst
// stupid status code for this check, but someone may rely on it
//
if ((pSetupStringTableStringFromIdEx(hStringTable,dnDevInst,pDeviceID,&ulLen) == FALSE)
|| INVALID_DEVINST(pDeviceID)) {
Status = CR_INVALID_LOG_CONF;
goto Clean0;
}
//
// now implement via CM_Query_Resource_Conflict_List
// the only difference here is that this new implementation should return
// only valid conflicts
//
Status = CM_Query_Resource_Conflict_List(&ConflictList,
dnDevInst,
ResourceID,
ResourceData,
ResourceLen,
ulFlags,
hMachine);
if (Status != CR_SUCCESS) {
goto Clean0;
}
Status = CM_Get_Resource_Conflict_Count(ConflictList,&ConflictCount);
if (Status != CR_SUCCESS) {
goto Clean0;
}
*pbConflictDetected = ConflictCount ? TRUE : FALSE;
Clean0:
NOTHING;
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = CR_FAILURE;
}
if (ConflictList) {
CM_Free_Resource_Conflict_Handle(ConflictList);
}
return Status;
} // CM_Detect_Resource_Conflict
CONFIGRET
CM_Free_Res_Des_Handle(
IN RES_DES rdResDes
)
/*++
Routine Description:
This routine frees the handle to the specified res des and frees and
memory associated with that res des handle.
Parameters:
rdResDes Supplies the handle of the resource descriptor.
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
If the function fails, the return value is one of the following:
CR_INVALID_RES_DES.
--*/
{
CONFIGRET Status = CR_SUCCESS;
try {
//
// Validate parameters
//
if (!ValidateResDesHandle((PPrivate_Res_Des_Handle)rdResDes)) {
Status = CR_INVALID_RES_DES;
goto Clean0;
}
//
// It's a valid log conf handle, which is a pointer to memory
// allocated when the log conf was created or retrieved using
// the first/next routines. Free the associated memory.
//
((PPrivate_Res_Des_Handle)rdResDes)->RD_Signature = 0;
pSetupFree((PPrivate_Res_Des_Handle)rdResDes);
Clean0:
NOTHING;
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = CR_FAILURE;
}
return Status;
} // CM_Free_Res_Des_Handle
//-------------------------------------------------------------------
// Local Stubs
//-------------------------------------------------------------------
CONFIGRET
CM_Add_Res_Des(
OUT PRES_DES prdResDes,
IN LOG_CONF lcLogConf,
IN RESOURCEID ResourceID,
IN PCVOID ResourceData,
IN ULONG ResourceLen,
IN ULONG ulFlags
)
{
return CM_Add_Res_Des_Ex(prdResDes, lcLogConf, ResourceID, ResourceData,
ResourceLen, ulFlags, NULL);
}
CONFIGRET
CM_Free_Res_Des(
OUT PRES_DES prdResDes,
IN RES_DES rdResDes,
IN ULONG ulFlags
)
{
return CM_Free_Res_Des_Ex(prdResDes, rdResDes, ulFlags, NULL);
}
CONFIGRET
CM_Get_Next_Res_Des(
OUT PRES_DES prdResDes,
IN RES_DES rdResDes,
IN RESOURCEID ForResource,
OUT PRESOURCEID pResourceID,
IN ULONG ulFlags
)
{
return CM_Get_Next_Res_Des_Ex(prdResDes, rdResDes, ForResource,
pResourceID, ulFlags, NULL);
}
CONFIGRET
CM_Get_Res_Des_Data(
IN RES_DES rdResDes,
OUT PVOID Buffer,
IN ULONG BufferLen,
IN ULONG ulFlags
)
{
return CM_Get_Res_Des_Data_Ex(rdResDes, Buffer, BufferLen, ulFlags, NULL);
}
CONFIGRET
CM_Get_Res_Des_Data_Size(
OUT PULONG pulSize,
IN RES_DES rdResDes,
IN ULONG ulFlags
)
{
return CM_Get_Res_Des_Data_Size_Ex(pulSize, rdResDes, ulFlags, NULL);
}
CONFIGRET
CM_Modify_Res_Des(
OUT PRES_DES prdResDes,
IN RES_DES rdResDes,
IN RESOURCEID ResourceID,
IN PCVOID ResourceData,
IN ULONG ResourceLen,
IN ULONG ulFlags
)
{
return CM_Modify_Res_Des_Ex(prdResDes, rdResDes, ResourceID, ResourceData,
ResourceLen, ulFlags, NULL);
}
CONFIGRET
WINAPI
CM_Detect_Resource_Conflict(
IN DEVINST dnDevInst,
IN RESOURCEID ResourceID, OPTIONAL
IN PCVOID ResourceData, OPTIONAL
IN ULONG ResourceLen, OPTIONAL
OUT PBOOL pbConflictDetected,
IN ULONG ulFlags
)
{
return CM_Detect_Resource_Conflict_Ex(dnDevInst, ResourceID, ResourceData,
ResourceLen, pbConflictDetected,
ulFlags, NULL);
}
//-------------------------------------------------------------------
// Local Utility Routines
//-------------------------------------------------------------------
CONFIGRET
CreateResDesHandle(
PRES_DES prdResDes,
DEVINST dnDevInst,
ULONG ulLogType,
ULONG ulLogTag,
ULONG ulResType,
ULONG ulResTag
)
{
PPrivate_Res_Des_Handle pResDesHandle;
//
// allocate memory for the res des handle data
//
pResDesHandle = (PPrivate_Res_Des_Handle)pSetupMalloc(
sizeof(Private_Res_Des_Handle));
if (pResDesHandle == NULL) {
return CR_OUT_OF_MEMORY;
}
//
// fill in the private res des info and return as handle
//
pResDesHandle->RD_Signature = CM_PRIVATE_RESDES_SIGNATURE;
pResDesHandle->RD_DevInst = dnDevInst;
pResDesHandle->RD_LogConfType = ulLogType;
pResDesHandle->RD_LogConfTag = ulLogTag;
pResDesHandle->RD_ResourceType = ulResType;
pResDesHandle->RD_ResDesTag = ulResTag;
*prdResDes = (RES_DES)pResDesHandle;
return CR_SUCCESS;
} // CreateResDesHandle
BOOL
ValidateResDesHandle(
PPrivate_Res_Des_Handle pResDes
)
{
//
// validate parameters
//
if (pResDes == NULL || pResDes == 0) {
return FALSE;
}
//
// check for the private log conf signature
//
if (pResDes->RD_Signature != CM_PRIVATE_RESDES_SIGNATURE) {
return FALSE;
}
return TRUE;
} // ValidateResDesHandle
CONFIGRET
Convert32bitResDesSizeTo64bitResDesSize(
IN RESOURCEID ResourceID,
IN OUT PULONG ResLen
)
/*++
Routine Description:
This routine resizes ResLen for ResourceID
old structure: [DES32][RANGE32][RANGE32]...
new structure: [DES64 ][RANGE64 ][RANGE 64]...
#elements = (len-sizeof(DES32))/sizeof(RANGE32)
new len = sizeof(DES64)+#elements*sizeof(RANGE64)
(+ allow for alignment issues)
Parameters:
ResourceID - type of resource to adjust
ResLen - adjusted resource length
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
--*/
{
switch(ResourceID) {
case ResType_All:
case ResType_Mem:
case ResType_IO:
case ResType_DMA:
case ResType_BusNumber:
//
// no change in resource size
//
return CR_SUCCESS;
case ResType_IRQ:
//
// header only
// use offsetof to handle non-obvious structure alignment padding
//
*ResLen += offsetof(IRQ_RESOURCE_64,IRQ_Data)-offsetof(IRQ_RESOURCE_32,IRQ_Data);
return CR_SUCCESS;
default:
//
// unknown resource
// shouldn't be a problem as this is for downlevel platforms
//
ASSERT(ResourceID & ResType_Ignored_Bit);
return CR_SUCCESS;
}
}
CONFIGRET
Get32bitResDesFrom64bitResDes(
IN RESOURCEID ResourceID,
IN PCVOID ResData64,
IN ULONG ResLen64,
OUT PVOID * ResData32,
OUT ULONG * ResLen32
)
/*++
Routine Description:
This routine allocates ResData32 and converts ResData64 into ResData32 if needed
In the cases where no conversion is required, CR_SUCCESS is returned and
ResData32 is NULL.
In the cases where conversion is required, ResData32 holds new data
old structure: [DES64 ][RANGE64 ][RANGE 64]...
new structure: [DES32][RANGE32][RANGE32]...
#elements from 64-bit structure
new len = sizeof(DES32)+#elements*sizeof(RANGE32)
(+ allow for alignment issues)
Parameters:
ResourceID - type of resource to adjust
ResData64 - incoming data to convert (constant buffer)
ResLen64 - incoming length of data
ResData32 - converted data (if non-NULL)
ResLen32 - converted length
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
--*/
{
*ResData32 = NULL;
*ResLen32 = ResLen64;
switch(ResourceID) {
case ResType_All:
case ResType_Mem:
case ResType_IO:
case ResType_DMA:
case ResType_BusNumber:
//
// no change in resource structure
//
return CR_SUCCESS;
case ResType_IRQ:
{
PIRQ_RESOURCE_64 pIrq64 = (PIRQ_RESOURCE_64)ResData64;
ULONG HdrDiff = offsetof(IRQ_RESOURCE_64,IRQ_Data) - offsetof(IRQ_RESOURCE_32,IRQ_Data);
ULONG DataSize = ResLen64-offsetof(IRQ_RESOURCE_64,IRQ_Data);
ULONG NewResSize = DataSize+offsetof(IRQ_RESOURCE_32,IRQ_Data);
PVOID NewResData = pSetupMalloc(NewResSize);
PIRQ_RESOURCE_32 pIrq32 = (PIRQ_RESOURCE_32)NewResData;
if(NewResData == NULL) {
return CR_OUT_OF_MEMORY;
}
//
// copy header
//
MoveMemory(pIrq32,pIrq64,offsetof(IRQ_RESOURCE_32,IRQ_Data));
//
// copy/truncate Affinity (to ensure it's correct)
//
pIrq32->IRQ_Header.IRQD_Affinity = (ULONG32)pIrq64->IRQ_Header.IRQD_Affinity;
//
// copy data (trivial in this case)
//
MoveMemory(pIrq32->IRQ_Data,pIrq64->IRQ_Data,DataSize);
*ResLen32 = NewResSize;
*ResData32 = NewResData;
}
return CR_SUCCESS;
default:
//
// unknown resource
// shouldn't be a problem as this is for downlevel platforms
//
ASSERT(ResourceID & ResType_Ignored_Bit);
return CR_SUCCESS;
}
}
CONFIGRET
Convert32bitResDesTo64bitResDes(
IN RESOURCEID ResourceID,
IN OUT PVOID ResData,
IN ULONG ResLen
)
/*++
Routine Description:
This routine reuses ResData and ResLen converting the 32-bit data provided
into 64-bit. Return error if buffer (reslen) isn't big enough
old structure: [DES32][RANGE32][RANGE32]...
new structure: [DES64 ][RANGE64 ][RANGE 64]...
#elements from 32-bit structure
(+ allow for alignment issues)
Parameters:
ResourceID - type of resource to adjust
ResData - in, 32-bit, out, 64-bit
ResData32 - size of ResData buffer
Return Value:
If the function succeeds, the return value is CR_SUCCESS.
--*/
{
switch(ResourceID) {
case ResType_All:
case ResType_Mem:
case ResType_IO:
case ResType_DMA:
case ResType_BusNumber:
//
// no change in resource structure
//
return CR_SUCCESS;
case ResType_IRQ:
{
PIRQ_RESOURCE_64 pIrq64 = (PIRQ_RESOURCE_64)ResData;
PIRQ_RESOURCE_32 pIrq32 = (PIRQ_RESOURCE_32)ResData;
ULONG HdrDiff = offsetof(IRQ_RESOURCE_64,IRQ_Data) - offsetof(IRQ_RESOURCE_32,IRQ_Data);
ULONG DataSize = pIrq32->IRQ_Header.IRQD_Count * sizeof(IRQ_RANGE);
ULONG NewResSize = DataSize+offsetof(IRQ_RESOURCE_64,IRQ_Data);
if(NewResSize > ResLen) {
return CR_BUFFER_SMALL;
}
//
// work top to bottom
// copy data (trivial in this case)
// MoveMemory handles overlap
//
MoveMemory(pIrq64->IRQ_Data,pIrq32->IRQ_Data,DataSize);
//
// header is in correct position
// but we need to deal with affinity... copy only low 32-bits
//
pIrq64->IRQ_Header.IRQD_Affinity = pIrq32->IRQ_Header.IRQD_Affinity;
}
return CR_SUCCESS;
default:
//
// unknown resource
// shouldn't be a problem as this is for downlevel platforms
//
ASSERT(ResourceID & ResType_Ignored_Bit);
return CR_SUCCESS;
}
}
Reference in a new issue Copy permalink