Intravision
/
reactos
mirror of https://github.com/reactos/reactos.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
reactos/drivers/bus/pcix/pci/id.c

467 lines
15 KiB
C
Raw Blame History

/*
* PROJECT: ReactOS PCI Bus Driver
* LICENSE: BSD - See COPYING.ARM in the top level directory
* FILE: drivers/bus/pci/pci/id.c
* PURPOSE: PCI Device Identification
* PROGRAMMERS: ReactOS Portable Systems Group
*/
/* INCLUDES *******************************************************************/
#include <pci.h>
#include <stdio.h>
#define NDEBUG
#include <debug.h>
/* FUNCTIONS ******************************************************************/
PWCHAR
NTAPI
PciGetDescriptionMessage(IN ULONG Identifier,
OUT PULONG Length)
{
PMESSAGE_RESOURCE_ENTRY Entry;
ULONG TextLength;
PWCHAR Description, Buffer;
ANSI_STRING MessageString;
UNICODE_STRING UnicodeString;
NTSTATUS Status;
/* Find the message identifier in the message table */
MessageString.Buffer = NULL;
Status = RtlFindMessage(PciDriverObject->DriverStart,
11, // RT_MESSAGETABLE
LANG_NEUTRAL,
Identifier,
&Entry);
if (!NT_SUCCESS(Status)) return NULL;
/* Check if the resource data is Unicode or ANSI */
if (Entry->Flags & MESSAGE_RESOURCE_UNICODE)
{
/* Subtract one space for the end-of-message terminator */
TextLength = Entry->Length -
FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text) -
sizeof(WCHAR);
/* Grab the text */
Description = (PWCHAR)Entry->Text;
/* Validate valid message length, ending with a newline character */
ASSERT(TextLength > 1);
ASSERT(Description[TextLength / sizeof(WCHAR)] == L'\n');
/* Allocate the buffer to hold the message string */
Buffer = ExAllocatePoolWithTag(PagedPool, TextLength, 'BicP');
if (!Buffer) return NULL;
/* Copy the message, minus the newline character, and terminate it */
RtlCopyMemory(Buffer, Entry->Text, TextLength - 1);
Buffer[TextLength / sizeof(WCHAR)] = UNICODE_NULL;
/* Return the length to the caller, minus the terminating NULL */
if (Length) *Length = TextLength - 1;
}
else
{
/* Initialize the entry as a string */
RtlInitAnsiString(&MessageString, (PCHAR)Entry->Text);
/* Remove the newline character */
MessageString.Length -= sizeof(CHAR);
/* Convert it to Unicode */
RtlAnsiStringToUnicodeString(&UnicodeString, &MessageString, TRUE);
Buffer = UnicodeString.Buffer;
/* Return the length to the caller */
if (Length) *Length = UnicodeString.Length;
}
/* Return the message buffer to the caller */
return Buffer;
}
PWCHAR
NTAPI
PciGetDeviceDescriptionMessage(IN UCHAR BaseClass,
IN UCHAR SubClass)
{
PWCHAR Message;
ULONG Identifier;
/* The message identifier in the table is encoded based on the PCI class */
Identifier = (BaseClass << 8) | SubClass;
/* Go grab the description message for this device */
Message = PciGetDescriptionMessage(Identifier, NULL);
if (!Message)
{
/* It wasn't found, allocate a buffer for a generic description */
Message = ExAllocatePoolWithTag(PagedPool, sizeof(L"PCI Device"), 'bicP');
if (Message) RtlCopyMemory(Message, L"PCI Device", sizeof(L"PCI Device"));
}
/* Return the description message */
return Message;
}
VOID
NTAPI
PciInitIdBuffer(IN PPCI_ID_BUFFER IdBuffer)
{
/* Initialize the sizes to zero and the pointer to the start of the buffer */
IdBuffer->TotalLength = 0;
IdBuffer->Count = 0;
IdBuffer->CharBuffer = IdBuffer->BufferData;
}
ULONG
__cdecl
PciIdPrintf(IN PPCI_ID_BUFFER IdBuffer,
IN PCCH Format,
...)
{
ULONG Size, Length;
PANSI_STRING AnsiString;
va_list va;
ASSERT(IdBuffer->Count < MAX_ANSI_STRINGS);
/* Do the actual string formatting into the character buffer */
va_start(va, Format);
vsprintf(IdBuffer->CharBuffer, Format, va);
va_end(va);
/* Initialize the ANSI_STRING that will hold this string buffer */
AnsiString = &IdBuffer->Strings[IdBuffer->Count];
RtlInitAnsiString(AnsiString, IdBuffer->CharBuffer);
/* Calculate the final size of the string, in Unicode */
Size = RtlAnsiStringToUnicodeSize(AnsiString);
/* Update hte buffer with the size,and update the character pointer */
IdBuffer->StringSize[IdBuffer->Count] = Size;
IdBuffer->TotalLength += Size;
Length = AnsiString->Length + sizeof(ANSI_NULL);
IdBuffer->CharBuffer += Length;
/* Move to the next string for next time */
IdBuffer->Count++;
/* Return the length */
return Length;
}
ULONG
__cdecl
PciIdPrintfAppend(IN PPCI_ID_BUFFER IdBuffer,
IN PCCH Format,
...)
{
ULONG NextId, Size, Length, MaxLength;
PANSI_STRING AnsiString;
va_list va;
ASSERT(IdBuffer->Count);
/* Choose the next static ANSI_STRING to use */
NextId = IdBuffer->Count - 1;
/* Max length is from the end of the buffer up until the current pointer */
MaxLength = (PCHAR)(IdBuffer + 1) - IdBuffer->CharBuffer;
/* Do the actual append, and return the length this string took */
va_start(va, Format);
Length = vsprintf(IdBuffer->CharBuffer - 1, Format, va);
va_end(va);
ASSERT(Length < MaxLength);
/* Select the static ANSI_STRING, and update its length information */
AnsiString = &IdBuffer->Strings[NextId];
AnsiString->Length += Length;
AnsiString->MaximumLength += Length;
/* Calculate the final size of the string, in Unicode */
Size = RtlAnsiStringToUnicodeSize(AnsiString);
/* Update the buffer with the size, and update the character pointer */
IdBuffer->StringSize[NextId] = Size;
IdBuffer->TotalLength += Size;
IdBuffer->CharBuffer += Length;
/* Return the size */
return Size;
}
NTSTATUS
NTAPI
PciQueryId(IN PPCI_PDO_EXTENSION DeviceExtension,
IN BUS_QUERY_ID_TYPE QueryType,
OUT PWCHAR *Buffer)
{
ULONG SubsysId;
CHAR VendorString[22];
PPCI_PDO_EXTENSION PdoExtension;
PPCI_FDO_EXTENSION ParentExtension;
PWCHAR StringBuffer;
ULONG i, Size;
NTSTATUS Status;
PANSI_STRING NextString;
UNICODE_STRING DestinationString;
PCI_ID_BUFFER IdBuffer;
PAGED_CODE();
/* Assume failure */
Status = STATUS_SUCCESS;
*Buffer = NULL;
/* Start with the genric vendor string, which is the vendor ID + device ID */
sprintf(VendorString,
"PCI\\VEN_%04X&DEV_%04X",
DeviceExtension->VendorId,
DeviceExtension->DeviceId);
/* Initialize the PCI ID Buffer */
PciInitIdBuffer(&IdBuffer);
/* Build the subsystem ID as shown in PCI ID Strings */
SubsysId = DeviceExtension->SubsystemVendorId | (DeviceExtension->SubsystemId << 16);
/* Check what the caller is requesting */
switch (QueryType)
{
case BusQueryDeviceID:
/* A single ID, the vendor string + the revision ID */
PciIdPrintf(&IdBuffer,
"%s&SUBSYS_%08X&REV_%02X",
VendorString,
SubsysId,
DeviceExtension->RevisionId);
break;
case BusQueryHardwareIDs:
/* First the vendor string + the subsystem ID + the revision ID */
PciIdPrintf(&IdBuffer,
"%s&SUBSYS_%08X&REV_%02X",
VendorString,
SubsysId,
DeviceExtension->RevisionId);
/* Next, without the revision */
PciIdPrintf(&IdBuffer,
"%s&SUBSYS_%08X",
VendorString,
SubsysId);
/* Next, the vendor string + the base class + sub class + progif */
PciIdPrintf(&IdBuffer,
"%s&CC_%02X%02X%02X",
VendorString,
DeviceExtension->BaseClass,
DeviceExtension->SubClass,
DeviceExtension->ProgIf);
/* Next, without the progif */
PciIdPrintf(&IdBuffer,
"%s&CC_%02X%02X",
VendorString,
DeviceExtension->BaseClass,
DeviceExtension->SubClass);
/* And finally, a terminator */
PciIdPrintf(&IdBuffer, "\0");
break;
case BusQueryCompatibleIDs:
/* First, the vendor + revision ID only */
PciIdPrintf(&IdBuffer,
"%s&REV_%02X",
VendorString,
DeviceExtension->RevisionId);
/* Next, the vendor string alone */
PciIdPrintf(&IdBuffer, "%s", VendorString);
/* Next, the vendor ID + the base class + the sub class + progif */
PciIdPrintf(&IdBuffer,
"PCI\\VEN_%04X&CC_%02X%02X%02X",
DeviceExtension->VendorId,
DeviceExtension->BaseClass,
DeviceExtension->SubClass,
DeviceExtension->ProgIf);
/* Now without the progif */
PciIdPrintf(&IdBuffer,
"PCI\\VEN_%04X&CC_%02X%02X",
DeviceExtension->VendorId,
DeviceExtension->BaseClass,
DeviceExtension->SubClass);
/* And then just the vendor ID itself */
PciIdPrintf(&IdBuffer,
"PCI\\VEN_%04X",
DeviceExtension->VendorId);
/* Then the base class + subclass + progif, without any vendor */
PciIdPrintf(&IdBuffer,
"PCI\\CC_%02X%02X%02X",
DeviceExtension->BaseClass,
DeviceExtension->SubClass,
DeviceExtension->ProgIf);
/* Next, without the progif */
PciIdPrintf(&IdBuffer,
"PCI\\CC_%02X%02X",
DeviceExtension->BaseClass,
DeviceExtension->SubClass);
/* And finally, a terminator */
PciIdPrintf(&IdBuffer, "\0");
break;
case BusQueryInstanceID:
/* Start with a terminator */
PciIdPrintf(&IdBuffer, "\0");
/* And then encode the device and function number */
PciIdPrintfAppend(&IdBuffer,
"%02X",
(DeviceExtension->Slot.u.bits.DeviceNumber << 3) |
DeviceExtension->Slot.u.bits.FunctionNumber);
/* Loop every parent until the root */
ParentExtension = DeviceExtension->ParentFdoExtension;
while (!PCI_IS_ROOT_FDO(ParentExtension))
{
/* And encode the parent's device and function number as well */
PdoExtension = ParentExtension->PhysicalDeviceObject->DeviceExtension;
PciIdPrintfAppend(&IdBuffer,
"%02X",
(PdoExtension->Slot.u.bits.DeviceNumber << 3) |
PdoExtension->Slot.u.bits.FunctionNumber);
}
break;
default:
/* Unknown query type */
DPRINT1("PciQueryId expected ID type = %d\n", QueryType);
return STATUS_NOT_SUPPORTED;
}
/* Something should've been generated if this has been reached */
ASSERT(IdBuffer.Count > 0);
/* Allocate the final string buffer to hold the ID */
StringBuffer = ExAllocatePoolWithTag(PagedPool, IdBuffer.TotalLength, 'BicP');
if (!StringBuffer) return STATUS_INSUFFICIENT_RESOURCES;
/* Build the UNICODE_STRING structure for it */
DPRINT1("PciQueryId(%d)\n", QueryType);
DestinationString.Buffer = StringBuffer;
DestinationString.MaximumLength = IdBuffer.TotalLength;
/* Loop every ID in the buffer */
for (i = 0; i < IdBuffer.Count; i++)
{
/* Select the ANSI_STRING for the ID */
NextString = &IdBuffer.Strings[i];
DPRINT1(" <- \"%s\"\n", NextString->Buffer);
/* Convert it to a UNICODE_STRING */
Status = RtlAnsiStringToUnicodeString(&DestinationString, NextString, FALSE);
ASSERT(NT_SUCCESS(Status));
/* Add it into the final destination buffer */
Size = IdBuffer.StringSize[i];
DestinationString.MaximumLength -= Size;
DestinationString.Buffer += (Size / sizeof(WCHAR));
}
/* Return the buffer to the caller and return status (should be success) */
*Buffer = StringBuffer;
return Status;
}
NTSTATUS
NTAPI
PciQueryDeviceText(IN PPCI_PDO_EXTENSION PdoExtension,
IN DEVICE_TEXT_TYPE QueryType,
IN ULONG Locale,
OUT PWCHAR *Buffer)
{
PWCHAR MessageBuffer, LocationBuffer;
ULONG Length;
NTSTATUS Status;
UNREFERENCED_PARAMETER(Locale);
/* Check what the caller is requesting */
switch (QueryType)
{
case DeviceTextDescription:
/* Get the message from the resource section */
MessageBuffer = PciGetDeviceDescriptionMessage(PdoExtension->BaseClass,
PdoExtension->SubClass);
/* Return it to the caller, and select proper status code */
*Buffer = MessageBuffer;
Status = MessageBuffer ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED;
break;
case DeviceTextLocationInformation:
/* Get the message from the resource section */
MessageBuffer = PciGetDescriptionMessage(0x10000, &Length);
if (!MessageBuffer)
{
/* It should be there, but fail if it wasn't found for some reason */
Status = STATUS_NOT_SUPPORTED;
break;
}
/* Add space for a null-terminator, and allocate the buffer */
Length += 2 * sizeof(UNICODE_NULL);
LocationBuffer = ExAllocatePoolWithTag(PagedPool,
Length * sizeof(WCHAR),
'BicP');
*Buffer = LocationBuffer;
/* Check if the allocation succeeded */
if (LocationBuffer)
{
/* Build the location string based on bus, function, and device */
swprintf(LocationBuffer,
MessageBuffer,
PdoExtension->ParentFdoExtension->BaseBus,
PdoExtension->Slot.u.bits.FunctionNumber,
PdoExtension->Slot.u.bits.DeviceNumber);
}
/* Free the original string from the resource section */
ExFreePoolWithTag(MessageBuffer, 0);
/* Select the correct status */
Status = LocationBuffer ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
break;
default:
/* Anything else is unsupported */
Status = STATUS_NOT_SUPPORTED;
break;
}
/* Return whether or not a device text string was indeed found */
return Status;
}
/* EOF */
Reference in New Issue View Git Blame Copy Permalink