You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
681 lines
21 KiB
681 lines
21 KiB
#include "pch.h"
|
|
#include "cmdata.h"
|
|
|
|
BOOL
|
|
SoftPCI_GetNextResourceDescriptorData(
|
|
IN OUT PRES_DES ResourceDescriptor,
|
|
OUT PCM_RES_DATA CmResData
|
|
);
|
|
|
|
VOID
|
|
SoftPCI_FreeResourceDescriptorData(
|
|
IN PCM_RES_DATA CmResData
|
|
);
|
|
|
|
VOID
|
|
SoftPCI_DumpCmResData(
|
|
IN PCM_RES_DATA CmResData,
|
|
OUT PWCHAR Buffer
|
|
);
|
|
|
|
VOID
|
|
SoftPCI_EnableDisableDeviceNode(
|
|
IN DEVNODE DeviceNode,
|
|
IN BOOL EnableDevice
|
|
)
|
|
{
|
|
|
|
if (EnableDevice) {
|
|
|
|
CM_Enable_DevNode(DeviceNode, 0);
|
|
|
|
}else{
|
|
|
|
if ((MessageBox(g_SoftPCIMainWnd,
|
|
L"This option will disable and unloaded the driver for this device. HW remains physically present.",
|
|
L"WARNING", MB_OKCANCEL)) == IDOK){
|
|
|
|
CM_Disable_DevNode(DeviceNode, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
SoftPCI_GetDeviceNodeProblem(
|
|
IN DEVNODE DeviceNode,
|
|
OUT PULONG DeviceProblem
|
|
)
|
|
{
|
|
CONFIGRET cr;
|
|
ULONG dnStatus;
|
|
|
|
cr = CM_Get_DevNode_Status(&dnStatus, DeviceProblem, DeviceNode, 0);
|
|
|
|
if (cr == CR_SUCCESS &&
|
|
((dnStatus & DN_HAS_PROBLEM) != 0)) {
|
|
//
|
|
// We have a problem, if it that we are disabled then return TRUE
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
SoftPCI_GetBusDevFuncFromDevnode(
|
|
IN DEVNODE Dn,
|
|
OUT PULONG Bus,
|
|
OUT PSOFTPCI_SLOT Slot
|
|
)
|
|
/*--
|
|
Routine Description:
|
|
|
|
This function takes a devnode and works out the devices Bus, Device, and Function
|
|
numbers.
|
|
|
|
Arguments:
|
|
|
|
Dn - DeviceNode to get location info for
|
|
Bus - retrieved bus number
|
|
Dev - retrieved device number
|
|
Func - retrieved function number
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful, FALSE otherwise
|
|
--*/
|
|
|
|
{
|
|
|
|
WCHAR locationinfo[MAX_PATH];
|
|
ULONG length = MAX_PATH;
|
|
ULONG device = 0, function = 0;
|
|
|
|
//
|
|
// Get the Location info of the device via the registry api
|
|
//
|
|
if ((CM_Get_DevNode_Registry_Property(Dn,
|
|
CM_DRP_LOCATION_INFORMATION,
|
|
NULL,
|
|
&locationinfo,
|
|
&length,
|
|
0
|
|
))==CR_SUCCESS){
|
|
|
|
//
|
|
// Now scan the returned information for the numbers we are after.
|
|
//
|
|
// Note: This is dependant on the format of the loaction information
|
|
// taken from the registry and if it should ever change this will break.
|
|
// Should probably look into better solution.
|
|
//
|
|
|
|
if (swscanf(locationinfo,
|
|
L"PCI bus %d, device %d, function %d",
|
|
Bus, &device, &function)) {
|
|
|
|
Slot->Device = (UCHAR)device;
|
|
Slot->Function = (UCHAR)function;
|
|
|
|
SoftPCI_Debug(SoftPciDevice,
|
|
L"Bus 0x%02x, Device 0x%02x, Function 0x%02x\n",
|
|
*Bus, device, function);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
SoftPCI_Debug(SoftPciDevice, L"Failed to get Bus Dev Func for devnode 0x%x\n", Dn);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
SoftPCI_GetFriendlyNameFromDevNode(
|
|
IN DEVNODE Dn,
|
|
IN PWCHAR Buffer
|
|
)
|
|
{
|
|
|
|
ULONG length = MAX_PATH;
|
|
|
|
//
|
|
// Get the FriendlyName of the device
|
|
//
|
|
if ((CM_Get_DevNode_Registry_Property(Dn,
|
|
CM_DRP_DEVICEDESC,
|
|
NULL,
|
|
Buffer,
|
|
&length,
|
|
0
|
|
)) != CR_SUCCESS){
|
|
|
|
SoftPCI_Debug(SoftPciDevice, L"Failed to get friendly name for devnode 0x%x\n", Dn);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
SoftPCI_GetPciRootBusNumber(
|
|
IN DEVNODE Dn,
|
|
OUT PULONG Bus
|
|
)
|
|
{
|
|
|
|
DEVNODE child = 0;
|
|
ULONG length = sizeof(ULONG);
|
|
|
|
|
|
*Bus = 0xFFFFFFFF;
|
|
|
|
if ((CM_Get_Child(&child, Dn, 0)==CR_SUCCESS)){
|
|
|
|
if ((CM_Get_DevNode_Registry_Property(child,
|
|
CM_DRP_BUSNUMBER,
|
|
NULL,
|
|
Bus,
|
|
&length,
|
|
0
|
|
))!=CR_SUCCESS){
|
|
|
|
SoftPCI_Debug(SoftPciDevice, L"Failed to get bus number from child 0x%x for devnode 0x%x\n",
|
|
child, Dn);
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
SoftPCI_GetNextResourceDescriptorData(
|
|
IN OUT PRES_DES ResourceDescriptor,
|
|
OUT PCM_RES_DATA CmResData
|
|
)
|
|
{
|
|
|
|
RES_DES resDes;
|
|
ULONG resSize = 0;
|
|
PULONG resBuf = NULL;
|
|
RESOURCEID resID;
|
|
CONFIGRET cr = CR_SUCCESS;
|
|
|
|
|
|
if (CmResData->ResourceDescriptor) {
|
|
free(CmResData->ResourceDescriptor);
|
|
CmResData->ResourceDescriptor = NULL;
|
|
}
|
|
|
|
|
|
//
|
|
// Stash away the current RES_DES handle so we dont lose it and leak mem
|
|
//
|
|
resDes = *ResourceDescriptor;
|
|
|
|
if ((CM_Get_Next_Res_Des(ResourceDescriptor,
|
|
*ResourceDescriptor,
|
|
ResType_All,
|
|
&resID,
|
|
0
|
|
)==CR_SUCCESS)){
|
|
|
|
if ((CM_Get_Res_Des_Data_Size(&resSize, *ResourceDescriptor, 0)) == CR_SUCCESS){
|
|
|
|
resBuf = (PULONG) calloc(1, resSize);
|
|
|
|
if (resBuf == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
CmResData->ResourceId = resID;
|
|
CmResData->DescriptorSize = resSize;
|
|
CmResData->ResourceDescriptor = resBuf;
|
|
|
|
SoftPCI_Debug(SoftPciCmData, L"GetNextResourceDescriptorData - ResourceId = 0x%x\n", resID);
|
|
SoftPCI_Debug(SoftPciCmData, L"GetNextResourceDescriptorData - DescriptorSize = 0x%x\n", resSize);
|
|
|
|
if ((cr = CM_Get_Res_Des_Data(*ResourceDescriptor, resBuf, resSize, 0)) == CR_SUCCESS){
|
|
|
|
SoftPCI_Debug(SoftPciCmData, L"GetNextResourceDescriptorData - ResourceDescriptor = 0x%x\n", resBuf);
|
|
//
|
|
// Free out last handle
|
|
//
|
|
CM_Free_Res_Des_Handle(resDes);
|
|
return TRUE;
|
|
|
|
}else{
|
|
SoftPCI_Debug(SoftPciCmData, L"GetNextResourceDescriptorData - failed to get ResData. (%s)\n", SoftPCI_CmResultTable[cr]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (CmResData->ResourceDescriptor) {
|
|
free(CmResData->ResourceDescriptor);
|
|
CmResData->ResourceDescriptor = NULL;
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
VOID
|
|
SoftPCI_FreeResourceDescriptorData(
|
|
IN PCM_RES_DATA CmResData
|
|
)
|
|
{
|
|
|
|
if (CmResData->ResourceDescriptor) {
|
|
free(CmResData->ResourceDescriptor);
|
|
CmResData->ResourceDescriptor = NULL;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
SoftPCI_GetResources(
|
|
PPCI_DN Pdn,
|
|
PWCHAR Buffer,
|
|
ULONG ConfigType
|
|
)
|
|
{
|
|
|
|
BOOL result = FALSE;
|
|
LOG_CONF logConf;
|
|
RES_DES resDes;
|
|
CM_RES_DATA cmResData;
|
|
|
|
|
|
RtlZeroMemory(&cmResData, sizeof(CM_RES_DATA));
|
|
|
|
//
|
|
// First get the logconf.
|
|
// Next get the first resource descrpitor.
|
|
//
|
|
if ((CM_Get_First_Log_Conf(&logConf, Pdn->DevNode, ConfigType)) == CR_SUCCESS){
|
|
|
|
resDes = (RES_DES)logConf;
|
|
|
|
while (SoftPCI_GetNextResourceDescriptorData((PRES_DES)&resDes,
|
|
&cmResData)) {
|
|
|
|
SoftPCI_Debug(SoftPciCmData, L"GetCurrentResources - Success!\n");
|
|
|
|
SoftPCI_DumpCmResData(&cmResData, Buffer);
|
|
|
|
SoftPCI_FreeResourceDescriptorData(&cmResData);
|
|
result = TRUE;
|
|
}
|
|
|
|
//
|
|
// Free out remaining RES_DES handle and then release the logconf handle
|
|
//
|
|
CM_Free_Res_Des_Handle(resDes);
|
|
|
|
CM_Free_Log_Conf_Handle(logConf);
|
|
|
|
|
|
}
|
|
return result;
|
|
|
|
}
|
|
|
|
VOID
|
|
SoftPCI_DumpCmResData(
|
|
IN PCM_RES_DATA CmResData,
|
|
OUT PWCHAR Buffer
|
|
)
|
|
{
|
|
|
|
PMEM_DES memDes;
|
|
PIO_DES ioDes;
|
|
PDMA_DES dmaDes;
|
|
PIRQ_DES irqDes;
|
|
PBUSNUMBER_DES busDes;
|
|
|
|
//PMEM_RANGE memRange;
|
|
//PIO_RANGE ioRange;
|
|
//PDMA_RANGE dmaRange;
|
|
//PIRQ_RANGE irqRange;
|
|
|
|
INT i = 0;
|
|
UCHAR busNum;
|
|
|
|
switch (CmResData->ResourceId){
|
|
|
|
case ResType_Mem:
|
|
|
|
memDes = (PMEM_DES) CmResData->ResourceDescriptor;
|
|
|
|
if (CmResData->DescriptorSize < sizeof(MEM_DES)) {
|
|
|
|
SoftPCI_Debug(SoftPciCmData, L"MEM No information available\n");
|
|
break;
|
|
}
|
|
|
|
wsprintf(Buffer + wcslen(Buffer),
|
|
L" MEM \tStart: 0x%08X\tEnd: 0x%08X\r\n",
|
|
//L"\tMEM \t0x%08x - 0x%08x\r\n",
|
|
(DWORD)memDes->MD_Alloc_Base,
|
|
(DWORD)memDes->MD_Alloc_End
|
|
);
|
|
|
|
SoftPCI_Debug(SoftPciCmData,
|
|
L"MEM Count:%08x Type: %08x Bas:%08x End:%08x Flags:%04x\n",
|
|
memDes->MD_Count,
|
|
memDes->MD_Type,
|
|
(DWORD)memDes->MD_Alloc_Base,
|
|
(DWORD)memDes->MD_Alloc_End,
|
|
memDes->MD_Flags
|
|
);
|
|
#if 0
|
|
memRange = (PMEM_RANGE)((LPBYTE)memDes + sizeof(MEM_DES));
|
|
|
|
for (i = 0; i < (INT)(memDes->MD_Count); i++){
|
|
|
|
SoftPCI_Debug(SoftPciCmData,
|
|
L" Align:%08lx Bytes:%08lx Min:%08lx Max:%08lx Flags:%04x\n",
|
|
(DWORD)memRange->MR_Align,
|
|
memRange->MR_nBytes,
|
|
(DWORD)memRange->MR_Min,
|
|
(DWORD)memRange->MR_Max,
|
|
memRange->MR_Flags
|
|
);
|
|
|
|
memRange++;
|
|
}
|
|
#endif
|
|
break;
|
|
|
|
case ResType_IO:
|
|
|
|
ioDes = (PIO_DES) CmResData->ResourceDescriptor;
|
|
|
|
if (CmResData->DescriptorSize < sizeof(IO_DES)) {
|
|
|
|
SoftPCI_Debug(SoftPciCmData, L"IO No information available\n");
|
|
|
|
break;
|
|
}
|
|
|
|
wsprintf(Buffer + wcslen(Buffer),
|
|
L" IO \tStart: 0x%08X\tEnd: 0x%08X\r\n",
|
|
//L"\tIO \t0x%08x - 0x%08x\r\n",
|
|
(DWORD)ioDes->IOD_Alloc_Base,
|
|
(DWORD)ioDes->IOD_Alloc_End
|
|
);
|
|
|
|
|
|
SoftPCI_Debug(SoftPciCmData,
|
|
L"IO Count:%08x Type: %08x Bas:%08x End:%08x Flags:%04x %s\n",
|
|
ioDes->IOD_Count,
|
|
ioDes->IOD_Type,
|
|
(DWORD)ioDes->IOD_Alloc_Base,
|
|
(DWORD)ioDes->IOD_Alloc_End,
|
|
ioDes->IOD_DesFlags,
|
|
((ioDes->IOD_DesFlags & fIOD_PortType)==fIOD_Memory) ? L"(memory)" : L""
|
|
);
|
|
break;
|
|
|
|
case ResType_IRQ:
|
|
|
|
irqDes = (PIRQ_DES) CmResData->ResourceDescriptor;
|
|
|
|
if (CmResData->DescriptorSize < sizeof(IRQ_DES)) {
|
|
|
|
SoftPCI_Debug(SoftPciCmData, L"IRQ No information available\n");
|
|
break;
|
|
}
|
|
|
|
wsprintf(Buffer + wcslen(Buffer),
|
|
L" IRQ \tStart: 0x%08X\tEnd: 0x%08X\r\n",
|
|
//L"\tIRQ \t0x%08\r\n",
|
|
irqDes->IRQD_Alloc_Num,
|
|
|
|
irqDes->IRQD_Alloc_Num
|
|
);
|
|
|
|
SoftPCI_Debug(SoftPciCmData,
|
|
L"IRQ Count:%04X Type:%04X Channel:%04X Affinity:%0Xx Flags:%04x\n",
|
|
irqDes->IRQD_Count,
|
|
irqDes->IRQD_Type,
|
|
irqDes->IRQD_Alloc_Num,
|
|
irqDes->IRQD_Affinity,
|
|
irqDes->IRQD_Flags);
|
|
|
|
break;
|
|
|
|
case ResType_BusNumber:
|
|
|
|
busDes = (PBUSNUMBER_DES) CmResData->ResourceDescriptor;
|
|
|
|
if (CmResData->DescriptorSize < sizeof(BUSNUMBER_DES)) {
|
|
|
|
SoftPCI_Debug(SoftPciCmData, L"BUS No information available\n");
|
|
break;
|
|
}
|
|
|
|
wsprintf(Buffer + wcslen(Buffer),
|
|
L" BUS \tStart: 0x%08X\tEnd: 0x%08X\r\n",
|
|
busDes->BUSD_Alloc_Base,
|
|
busDes->BUSD_Alloc_End
|
|
);
|
|
|
|
|
|
|
|
break;
|
|
|
|
case ResType_DMA:
|
|
|
|
dmaDes = (PDMA_DES) CmResData->ResourceDescriptor;
|
|
|
|
if (CmResData->DescriptorSize < sizeof(DMA_DES)) {
|
|
|
|
SoftPCI_Debug(SoftPciCmData, L"DMA No information available\n");
|
|
break;
|
|
}
|
|
|
|
wsprintf(Buffer + wcslen(Buffer),
|
|
L" DMA \tStart: 0x%08X\t End: 0x%08X\r\n",
|
|
dmaDes->DD_Alloc_Chan,
|
|
dmaDes->DD_Alloc_Chan
|
|
);
|
|
|
|
|
|
SoftPCI_Debug(SoftPciCmData,
|
|
L"DMA Count:%04x Type:%04x Channel:%04x Flags:%04x\n",
|
|
dmaDes->DD_Count,
|
|
dmaDes->DD_Type,
|
|
dmaDes->DD_Alloc_Chan,
|
|
dmaDes->DD_Flags
|
|
);
|
|
break;
|
|
|
|
|
|
default:
|
|
SoftPCI_Debug(SoftPciCmData, L"ResourceId 0x%x not handled!\n", CmResData->ResourceId);
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
#if 0
|
|
// Display the header information on one line.
|
|
wsprintf(szBuf, TEXT("MEM Count:%08x Type: %08x Bas:%08x End:%08x Flags:%04x ("),
|
|
lpMemDes->MD_Count,
|
|
lpMemDes->MD_Type,
|
|
(DWORD)lpMemDes->MD_Alloc_Base,
|
|
(DWORD)lpMemDes->MD_Alloc_End,
|
|
lpMemDes->MD_Flags );
|
|
PrintMemFlags(lpMemDes->MD_Flags, szBuf+lstrlen(szBuf)) ;
|
|
lstrcat(szBuf, TEXT(")\r\n")) ;
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
|
|
lpMemRange = (MEM_RANGE *)((LPBYTE)lpMemDes+sizeof(MEM_DES));
|
|
for (iX = 0; iX < (int)(lpMemDes->MD_Count); iX++ )
|
|
{
|
|
wsprintf(szBuf, TEXT(" Align:%08lx Bytes:%08lx Min:%08lx Max:%08lx Flags:%04x ("),
|
|
(DWORD)lpMemRange->MR_Align,
|
|
lpMemRange->MR_nBytes,
|
|
(DWORD)lpMemRange->MR_Min,
|
|
(DWORD)lpMemRange->MR_Max,
|
|
lpMemRange->MR_Flags
|
|
);
|
|
|
|
PrintMemFlags(lpMemRange->MR_Flags, szBuf+lstrlen(szBuf)) ;
|
|
lstrcat(szBuf, TEXT(")\r\n")) ;
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
lpMemRange++;
|
|
}
|
|
break;
|
|
|
|
case ResType_IO:
|
|
lpIODes = (IO_DES *) lpbConfig;
|
|
|
|
if (dwSize<sizeof(IO_DES)) {
|
|
wsprintf(szBuf, TEXT("IO No information available\r\n"));
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
break;
|
|
}
|
|
|
|
wsprintf(szBuf, TEXT("IO Count:%08x Type: %08x Bas:%08x End:%08x Flags:%04x %s\r\n"),
|
|
lpIODes->IOD_Count,
|
|
lpIODes->IOD_Type,
|
|
(DWORD)lpIODes->IOD_Alloc_Base,
|
|
(DWORD)lpIODes->IOD_Alloc_End,
|
|
lpIODes->IOD_DesFlags,
|
|
((lpIODes->IOD_DesFlags&fIOD_PortType)==fIOD_Memory) ? TEXT("(memory)") : TEXT("")
|
|
);
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
|
|
lpIORange = (IO_RANGE *)((LPBYTE)lpIODes+sizeof(IO_DES));
|
|
|
|
for (iX = 0; iX < (int)(lpIODes->IOD_Count); iX++ )
|
|
{
|
|
nAliasType=GetAliasType((DWORD)lpIORange->IOR_Alias) ;
|
|
wsprintf(szBuf, TEXT(" Align:%08x Ports:%08x Min:%08x Max:%08x Flags:%04x %sAls:%02x (%s)\r\n"),
|
|
(DWORD)lpIORange->IOR_Align,
|
|
lpIORange->IOR_nPorts,
|
|
(DWORD)lpIORange->IOR_Min,
|
|
(DWORD)lpIORange->IOR_Max,
|
|
lpIORange->IOR_RangeFlags,
|
|
((lpIORange->IOR_RangeFlags&fIOD_PortType)==fIOD_Memory) ? TEXT("(memory) ") : TEXT(""),
|
|
(DWORD)lpIORange->IOR_Alias,
|
|
lpszAliasNames[nAliasType]);
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
lpIORange++;
|
|
}
|
|
|
|
break;
|
|
|
|
case ResType_DMA:
|
|
lpDMADes = (DMA_DES *) lpbConfig;
|
|
|
|
if (dwSize<sizeof(DMA_DES)) {
|
|
wsprintf(szBuf, TEXT("DMA No information available\r\n"));
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
break;
|
|
}
|
|
|
|
wsprintf(szBuf, TEXT("DMA Count:%04x Type:%04x Channel:%04x Flags:%04x ("),
|
|
lpDMADes->DD_Count,
|
|
lpDMADes->DD_Type,
|
|
lpDMADes->DD_Alloc_Chan,
|
|
lpDMADes->DD_Flags);
|
|
|
|
PrintDmaFlags(lpDMADes->DD_Flags, szBuf+lstrlen(szBuf)) ;
|
|
lstrcat(szBuf, TEXT(")\r\n")) ;
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
|
|
lpDMARange = (DMA_RANGE *)((LPBYTE)lpDMADes+sizeof(DMA_DES));
|
|
|
|
for (iX = 0; iX < (int)(lpDMADes->DD_Count); iX++)
|
|
{
|
|
wsprintf(szBuf, TEXT(" Min:%04x Max:%04x Flags:%04x ("),
|
|
lpDMARange->DR_Min,
|
|
lpDMARange->DR_Max,
|
|
lpDMARange->DR_Flags);
|
|
|
|
PrintDmaFlags(lpDMARange->DR_Flags, szBuf+lstrlen(szBuf)) ;
|
|
lstrcat(szBuf, TEXT(")\r\n")) ;
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
lpDMARange++;
|
|
}
|
|
|
|
break;
|
|
|
|
case ResType_IRQ:
|
|
lpIRQDes = (IRQ_DES *) lpbConfig;
|
|
|
|
if (dwSize<sizeof(IRQ_DES)) {
|
|
wsprintf(szBuf, TEXT("IRQ No information available\r\n"));
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
break;
|
|
}
|
|
|
|
wsprintf(szBuf, TEXT("IRQ Count:%04x Type:%04x Channel:%04x Affinity:%08x Flags:%04x ("),
|
|
lpIRQDes->IRQD_Count,
|
|
lpIRQDes->IRQD_Type,
|
|
lpIRQDes->IRQD_Alloc_Num,
|
|
lpIRQDes->IRQD_Affinity,
|
|
lpIRQDes->IRQD_Flags);
|
|
|
|
PrintIrqFlags(lpIRQDes->IRQD_Flags, szBuf+lstrlen(szBuf)) ;
|
|
lstrcat(szBuf, TEXT(")\r\n")) ;
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
|
|
lpIRQRange = (IRQ_RANGE *)((LPBYTE)lpIRQDes+sizeof(IRQ_DES));
|
|
|
|
for (iX = 0; iX < (int)(lpIRQDes->IRQD_Count); iX++)
|
|
{
|
|
wsprintf(szBuf, TEXT(" Min:%04x Max:%04x Flags:%04x ("),
|
|
lpIRQRange->IRQR_Min,
|
|
lpIRQRange->IRQR_Max,
|
|
lpIRQRange->IRQR_Flags);
|
|
|
|
PrintIrqFlags(lpIRQRange->IRQR_Flags, szBuf+lstrlen(szBuf)) ;
|
|
lstrcat(szBuf, TEXT(")\r\n")) ;
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
lpIRQRange++;
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x43:
|
|
bBus = *lpbConfig;
|
|
|
|
if (dwSize<sizeof(*lpbConfig)) {
|
|
wsprintf(szBuf, TEXT("BUS No information available\r\n"));
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
break;
|
|
}
|
|
|
|
wsprintf(szBuf, TEXT("BUS %02x\r\n"), bBus);
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
|
|
break;
|
|
|
|
default:
|
|
wsprintf(szBuf, TEXT("UKN Unknown resource %04x\r\n"), ridCurResType);
|
|
|
|
lstrcat(lpszBuf+lstrlen(lpszBuf), szBuf);
|
|
|
|
break;
|
|
}
|
|
|
|
lpbConfig+=dwSize;
|
|
}
|
|
}
|
|
#endif
|