#include <apitest.h>
#include <ndk/rtlfuncs.h>
#include <acpi.h>
#include <acpiioct.h>
#include <ntintsafe.h>
#include <initguid.h>
#include <pshpack1.h>
#include <poppack.h>
#include "../../../../drivers/bus/acpi/eval.c"

Include dependency graph for Bus_PDO_EvalMethod.c:

Classes
struct	_EVAL_TEST_ENTRY

struct	_IO_STACK_LOCATION

struct	_IRP

struct	_IDE_ACPI_TIMING_MODE_BLOCK

struct	_PDO_DEVICE_DATA

struct	_GTM_OBJECT_BUFFER

struct	_BIF_OBJECT_BUFFER

struct	_PCL_OBJECT_BUFFER

struct	_PRT_OBJECT_BUFFER

Macros
#define	WIN32_NO_STATUS

#define	UNIT_TEST

#define	ok_eq_str_ex(entry, value, expected)

#define	ok_eq_print_ex(entry, value, expected, spec)

#define	ok_not_print_ex(entry, value, expected, spec)

#define	ok_eq_hex_ex(entry, value, expected) ok_eq_print_ex(entry, value, expected, "0x%08lx")

#define	ok_eq_pointer_ex(entry, value, expected) ok_eq_print_ex(entry, value, expected, "%p")

#define	ok_eq_int_ex(entry, value, expected) ok_eq_print_ex(entry, value, expected, "%d")

#define	ok_eq_uint_ex(entry, value, expected) ok_eq_print_ex(entry, value, expected, "%u")

#define	ok_eq_ulong_ex(entry, value, expected) ok_eq_print_ex(entry, value, expected, "%lu")

#define	ok_eq_ulonglong_ex(entry, value, expected) ok_eq_print_ex(entry, value, expected, "%I64u")

#define	ok_not_pointer_ex(entry, value, expected) ok_not_print_ex(entry, value, expected, "%p")

#define	STM_TEST_FLAG_INVALID_ARG_3_1 (1 << 0 )

#define	STM_TEST_FLAG_INVALID_ARG_3_2 (1 << 1 )

#define	STM_TEST_FLAG_INVALID_ARG_3_4 (1 << 2 )

#define	STM_TEST_FLAG_INVALID_ARG_3_5 (1 << 3 )

#define	STM_TEST_FLAG_INVALID_SIZE_1 (1 << 4 )

#define	STM_TEST_FLAG_LARGE_ARG_BUFFER (1 << 5 )

#define	STM_TEST_FLAG_CHANGE_ARG_COUNT (1 << 6 )

#define	STM_TEST_FLAG_SUB_IN_BUFFER (1 << 7 )

#define	STM_TEST_FLAG_SUB_IRP_BUFFER (1 << 8 )

#define	STM_TEST_FLAG_SET_IN_BUFFER (1 << 9 )

#define	STM_TEST_FLAG_SET_IRP_BUFFER (1 << 10)

#define	STM_TEST_FLAG_BAD_ARG_TYPE (1 << 11)

#define	STM_TEST_FLAG_IS_TODO (1 << 12)

#define	GTM_TEST_FLAG_BAD_SIGNARUTE (1 << 0)

#define	GTM_TEST_FLAG_BUFFER_HAS_SIGNARUTE (1 << 1)

#define	GTM_TEST_FLAG_BUFFER_HAS_COUNT (1 << 2)

#define	GTM_TEST_FLAG_BUFFER_HAS_LENGTH (1 << 3)

#define	GTM_TEST_FLAG_ARG_HAS_BUFFER_TYPE (1 << 4)

#define	GTM_TEST_FLAG_ARG_HAS_DATA_LENGTH (1 << 5)

#define	GTM_TEST_FLAG_INC_OUT_BUFFER (1 << 6)

#define	GTM_TEST_FLAG_DEC_OUT_BUFFER (1 << 7)

#define	GTM_TEST_FLAG_SET_OUT_BUFFER (1 << 8)

#define	GTM_TEST_FLAG_IS_TODO (1 << 9)

#define	GTM_TEST_FLAG_METHOD_SUCCESS

#define	DSM_TEST_FLAG_EMPTY_PACKAGE (1 << 0)

#define	DSM_TEST_FLAG_LARGE_SUB_PACKAGE_BUFFER (1 << 1)

#define	PAGED_CODE()

#define	CODE_SEG(...)

#define	DPRINT(...) do { if (0) DbgPrint(__VA_ARGS__); } while (0)

#define	DPRINT1(...) do { if (0) DbgPrint(__VA_ARGS__); } while (0)

#define	ExAllocatePoolUninitialized ExAllocatePoolWithTag

#define	NonPagedPool 1

#define	STM_ID_BLOCK_SIZE 512

#define	FAKE_SB_NAMESPACE_ACPI_HANDLE 0xFF0F0001

#define	FAKE_INTB_ACPI_HANDLE 0xFF0F0002

#define	FAKE_INTC_ACPI_HANDLE 0xFF0F0003

#define	STM_MAX_BUFFER_SIZE

#define	GTM_MAX_BUFFER_SIZE

#define	PRT_PACKAGE_ENTRY_SIZE

#define	MY_DSM_SUB_PACKAGE_ENTRY_SIZE (ACPI_METHOD_ARGUMENT_LENGTH(sizeof("1_TESTDATATESTDATA_2")))

#define	MY_DSM_PACKAGE_ENTRY_SIZE

#define	MY_DSM_BUFFER_SIZE

Typedefs
typedef struct _EVAL_TEST_ENTRY	EVAL_TEST_ENTRY

typedef struct _IO_STACK_LOCATION	IO_STACK_LOCATION

typedef struct _IO_STACK_LOCATION *	PIO_STACK_LOCATION

typedef struct _IRP	IRP

typedef struct _IRP *	PIRP

typedef struct _IDE_ACPI_TIMING_MODE_BLOCK	IDE_ACPI_TIMING_MODE_BLOCK

typedef struct _IDE_ACPI_TIMING_MODE_BLOCK *	PIDE_ACPI_TIMING_MODE_BLOCK

typedef struct _PDO_DEVICE_DATA	PDO_DEVICE_DATA

typedef struct _PDO_DEVICE_DATA *	PPDO_DEVICE_DATA

typedef struct _GTM_OBJECT_BUFFER	GTM_OBJECT_BUFFER

typedef struct _GTM_OBJECT_BUFFER *	PGTM_OBJECT_BUFFER

typedef struct _BIF_OBJECT_BUFFER	BIF_OBJECT_BUFFER

typedef struct _BIF_OBJECT_BUFFER *	PBIF_OBJECT_BUFFER

typedef struct _PCL_OBJECT_BUFFER	PCL_OBJECT_BUFFER

typedef struct _PCL_OBJECT_BUFFER *	PPCL_OBJECT_BUFFER

typedef struct _PRT_OBJECT_BUFFER	PRT_OBJECT_BUFFER

typedef struct _PRT_OBJECT_BUFFER *	PPRT_OBJECT_BUFFER

Functions
static PVOID	ExAllocatePoolWithTag (ULONG PoolType, SIZE_T NumberOfBytes, ULONG Tag)

static VOID	ExFreePoolWithTag (PVOID MemPtr, ULONG Tag)

static PIO_STACK_LOCATION	IoGetCurrentIrpStackLocation (PIRP Irp)

	DEFINE_GUID (MY_DSM_GUID, 0xB76E0B40, 0x3EC6, 0x4DBD, 0x8A, 0xCB, 0x8B, 0xCA, 0x65, 0xB8, 0xBC, 0x70)

void *	AcpiOsAllocate (ACPI_SIZE Size)

void	AcpiOsFree (void *Memory)

ACPI_STATUS	AcpiGetName (ACPI_HANDLE Handle, UINT32 NameType, ACPI_BUFFER *Buffer)

ACPI_STATUS	AcpiEvaluateObject (ACPI_HANDLE Object, ACPI_STRING Pathname, ACPI_OBJECT_LIST ParameterObjects, ACPI_BUFFER ReturnObjectBuffer)

static NTSTATUS	DrvCallAcpiDriver (_In_ PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_opt_ PACPI_EVAL_OUTPUT_BUFFER OutputBuffer, _In_ ULONG OutputBufferLength)

static VOID	DrvEvaluateStmObject (_In_ const EVAL_TEST_ENTRY *TestEntry, _In_ PIDE_ACPI_TIMING_MODE_BLOCK TimingMode, _In_ PUCHAR IdBlock, _In_ PACPI_EVAL_INPUT_BUFFER_COMPLEX InputBuffer)

static VOID	DrvTestComplexBuffer (VOID)

static VOID	DrvEvaluateGtmObject (_In_ const EVAL_TEST_ENTRY *TestEntry, _In_ PACPI_EVAL_OUTPUT_BUFFER OutputBuffer)

static VOID	DrvTestInputBuffer (VOID)

static VOID	DrvEvaluateBifObject (_In_ const EVAL_TEST_ENTRY *TestEntry, _In_ PACPI_EVAL_OUTPUT_BUFFER OutputBuffer)

static VOID	DrvTestPackageReturnValueAndStringData (VOID)

static VOID	DrvEvaluatePclObject (_In_ const EVAL_TEST_ENTRY *TestEntry, _In_ PACPI_EVAL_OUTPUT_BUFFER OutputBuffer)

static VOID	DrvTestReferenceReturnValue (VOID)

static VOID	DrvEvaluatePrtObject (_In_ const EVAL_TEST_ENTRY *TestEntry, _In_ PACPI_EVAL_OUTPUT_BUFFER OutputBuffer)

static VOID	DrvTestNestedPackageReturnValue (VOID)

static VOID	DrvEvaluateDsmObject (_In_ const EVAL_TEST_ENTRY *TestEntry)

static VOID	DrvTestPackageInputValue (VOID)

static VOID	DrvTestUnknownMethod (VOID)

	START_TEST (Bus_PDO_EvalMethod)

Variables
static LONG	DrvpBlocksAllocated = 0

static const ULONG	DrvpBifIntegerFields [9]

static const ULONG	DrvpMyDsmIntegerFields [3]

static const EVAL_TEST_ENTRY *	DrvpEvalTestEntry

static const EVAL_TEST_ENTRY	DrvpSmtTests []

static const EVAL_TEST_ENTRY	DrvpGtmTests []

static const EVAL_TEST_ENTRY	DrvpBifTests []

static const EVAL_TEST_ENTRY	DrvpPclTests []

static const EVAL_TEST_ENTRY	DrvpPrtTests []

static const EVAL_TEST_ENTRY	DrvpDsmTests []

Macro Definition Documentation

◆ CODE_SEG

#define CODE_SEG ( ... )

Definition at line 90 of file Bus_PDO_EvalMethod.c.

◆ DPRINT

#define DPRINT ( ... ) do { if (0) DbgPrint(__VA_ARGS__); } while (0)

Definition at line 91 of file Bus_PDO_EvalMethod.c.

◆ DPRINT1

#define DPRINT1 ( ... ) do { if (0) DbgPrint(__VA_ARGS__); } while (0)

Definition at line 92 of file Bus_PDO_EvalMethod.c.

◆ DSM_TEST_FLAG_EMPTY_PACKAGE

#define DSM_TEST_FLAG_EMPTY_PACKAGE (1 << 0)

Definition at line 80 of file Bus_PDO_EvalMethod.c.

◆ DSM_TEST_FLAG_LARGE_SUB_PACKAGE_BUFFER

#define DSM_TEST_FLAG_LARGE_SUB_PACKAGE_BUFFER (1 << 1)

Definition at line 81 of file Bus_PDO_EvalMethod.c.

◆ ExAllocatePoolUninitialized

#define ExAllocatePoolUninitialized ExAllocatePoolWithTag

Definition at line 120 of file Bus_PDO_EvalMethod.c.

◆ FAKE_INTB_ACPI_HANDLE

#define FAKE_INTB_ACPI_HANDLE 0xFF0F0002

Definition at line 177 of file Bus_PDO_EvalMethod.c.

◆ FAKE_INTC_ACPI_HANDLE

#define FAKE_INTC_ACPI_HANDLE 0xFF0F0003

Definition at line 178 of file Bus_PDO_EvalMethod.c.

◆ FAKE_SB_NAMESPACE_ACPI_HANDLE

#define FAKE_SB_NAMESPACE_ACPI_HANDLE 0xFF0F0001

Definition at line 176 of file Bus_PDO_EvalMethod.c.

◆ GTM_MAX_BUFFER_SIZE

#define GTM_MAX_BUFFER_SIZE

Value:

(FIELD_OFFSET(ACPI_EVAL_OUTPUT_BUFFER, Argument) + \

ACPI_METHOD_ARGUMENT_LENGTH(sizeof(IDE_ACPI_TIMING_MODE_BLOCK)) + 0x50)

_ACPI_EVAL_OUTPUT_BUFFER

Definition: acpiioct.h:84

_IDE_ACPI_TIMING_MODE_BLOCK

Definition: Bus_PDO_EvalMethod.c:161

FIELD_OFFSET

#define FIELD_OFFSET(t, f)

Definition: typedefs.h:255

Definition at line 616 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_ARG_HAS_BUFFER_TYPE

#define GTM_TEST_FLAG_ARG_HAS_BUFFER_TYPE (1 << 4)

Definition at line 68 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_ARG_HAS_DATA_LENGTH

#define GTM_TEST_FLAG_ARG_HAS_DATA_LENGTH (1 << 5)

Definition at line 69 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_BAD_SIGNARUTE

#define GTM_TEST_FLAG_BAD_SIGNARUTE (1 << 0)

Definition at line 64 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_BUFFER_HAS_COUNT

#define GTM_TEST_FLAG_BUFFER_HAS_COUNT (1 << 2)

Definition at line 66 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_BUFFER_HAS_LENGTH

#define GTM_TEST_FLAG_BUFFER_HAS_LENGTH (1 << 3)

Definition at line 67 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_BUFFER_HAS_SIGNARUTE

#define GTM_TEST_FLAG_BUFFER_HAS_SIGNARUTE (1 << 1)

Definition at line 65 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_DEC_OUT_BUFFER

#define GTM_TEST_FLAG_DEC_OUT_BUFFER (1 << 7)

Definition at line 71 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_INC_OUT_BUFFER

#define GTM_TEST_FLAG_INC_OUT_BUFFER (1 << 6)

Definition at line 70 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_IS_TODO

#define GTM_TEST_FLAG_IS_TODO (1 << 9)

Definition at line 73 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_METHOD_SUCCESS

#define GTM_TEST_FLAG_METHOD_SUCCESS

Value:

    (GTM_TEST_FLAG_BUFFER_HAS_SIGNARUTE | \
     GTM_TEST_FLAG_BUFFER_HAS_COUNT | GTM_TEST_FLAG_BUFFER_HAS_LENGTH | \
     GTM_TEST_FLAG_ARG_HAS_BUFFER_TYPE | GTM_TEST_FLAG_ARG_HAS_DATA_LENGTH)

Definition at line 75 of file Bus_PDO_EvalMethod.c.

◆ GTM_TEST_FLAG_SET_OUT_BUFFER

#define GTM_TEST_FLAG_SET_OUT_BUFFER (1 << 8)

Definition at line 72 of file Bus_PDO_EvalMethod.c.

◆ MY_DSM_BUFFER_SIZE

#define MY_DSM_BUFFER_SIZE

Value:

    (FIELD_OFFSET(ACPI_EVAL_INPUT_BUFFER_COMPLEX, Argument) + \
     ACPI_METHOD_ARGUMENT_LENGTH(sizeof(GUID)) + \
     ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) + \
     ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) + \
     ACPI_METHOD_ARGUMENT_LENGTH(MY_DSM_PACKAGE_ENTRY_SIZE))

◆ MY_DSM_PACKAGE_ENTRY_SIZE

#define MY_DSM_PACKAGE_ENTRY_SIZE

Value:

(ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) * 3 + \

ACPI_METHOD_ARGUMENT_LENGTH(MY_DSM_SUB_PACKAGE_ENTRY_SIZE))

MY_DSM_SUB_PACKAGE_ENTRY_SIZE

#define MY_DSM_SUB_PACKAGE_ENTRY_SIZE

ACPI_METHOD_ARGUMENT_LENGTH

#define ACPI_METHOD_ARGUMENT_LENGTH(DataLength)

Definition: acpiioct.h:144

◆ MY_DSM_SUB_PACKAGE_ENTRY_SIZE

#define MY_DSM_SUB_PACKAGE_ENTRY_SIZE (ACPI_METHOD_ARGUMENT_LENGTH(sizeof("1_TESTDATATESTDATA_2")))

◆ NonPagedPool

#define NonPagedPool 1

Definition at line 121 of file Bus_PDO_EvalMethod.c.

◆ ok_eq_hex_ex

#define ok_eq_hex_ex	(	entry,
		value,
		expected
	)	ok_eq_print_ex(entry, value, expected, "0x%08lx")

Definition at line 36 of file Bus_PDO_EvalMethod.c.

◆ ok_eq_int_ex

#define ok_eq_int_ex	(	entry,
		value,
		expected
	)	ok_eq_print_ex(entry, value, expected, "%d")

Definition at line 38 of file Bus_PDO_EvalMethod.c.

◆ ok_eq_pointer_ex

#define ok_eq_pointer_ex	(	entry,
		value,
		expected
	)	ok_eq_print_ex(entry, value, expected, "%p")

Definition at line 37 of file Bus_PDO_EvalMethod.c.

◆ ok_eq_print_ex

#define ok_eq_print_ex	(	entry,
		value,
		expected,
		spec
	)

Value:

ok((value) == (expected), \

"Line %lu: " #value " = " spec ", expected " spec "\n", (entry)->Line, value, expected)

ok

#define ok(value,...)

Definition: atltest.h:57

entry

uint32_t entry

Definition: isohybrid.c:63

expected

BOOL expected

Definition: store.c:2000

Line

Definition: ncftp.h:79

value

Definition: pdh_main.c:96

Definition at line 28 of file Bus_PDO_EvalMethod.c.

◆ ok_eq_str_ex

#define ok_eq_str_ex	(	entry,
		value,
		expected
	)

Value:

ok(!strcmp(value, expected), \

"Line %lu: " #value " = \"%s\", expected \"%s\"\n", (entry)->Line, value, expected)

strcmp

int strcmp(const char *String1, const char *String2)

Definition: utclib.c:469

Definition at line 24 of file Bus_PDO_EvalMethod.c.

◆ ok_eq_uint_ex

#define ok_eq_uint_ex	(	entry,
		value,
		expected
	)	ok_eq_print_ex(entry, value, expected, "%u")

Definition at line 39 of file Bus_PDO_EvalMethod.c.

◆ ok_eq_ulong_ex

#define ok_eq_ulong_ex	(	entry,
		value,
		expected
	)	ok_eq_print_ex(entry, value, expected, "%lu")

Definition at line 40 of file Bus_PDO_EvalMethod.c.

◆ ok_eq_ulonglong_ex

#define ok_eq_ulonglong_ex	(	entry,
		value,
		expected
	)	ok_eq_print_ex(entry, value, expected, "%I64u")

Definition at line 41 of file Bus_PDO_EvalMethod.c.

◆ ok_not_pointer_ex

#define ok_not_pointer_ex	(	entry,
		value,
		expected
	)	ok_not_print_ex(entry, value, expected, "%p")

Definition at line 43 of file Bus_PDO_EvalMethod.c.

◆ ok_not_print_ex

#define ok_not_print_ex	(	entry,
		value,
		expected,
		spec
	)

Value:

ok((value) != (expected), \

"Line %lu: " #value " = " spec ", expected " spec "\n", (entry)->Line, value, expected)

Definition at line 32 of file Bus_PDO_EvalMethod.c.

◆ PAGED_CODE

PAGED_CODE ( )

Definition at line 89 of file Bus_PDO_EvalMethod.c.

◆ PRT_PACKAGE_ENTRY_SIZE

#define PRT_PACKAGE_ENTRY_SIZE

Value:

(ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) * 3 + \

ACPI_METHOD_ARGUMENT_LENGTH(sizeof("LNKB")))

◆ STM_ID_BLOCK_SIZE

#define STM_ID_BLOCK_SIZE 512

Definition at line 172 of file Bus_PDO_EvalMethod.c.

◆ STM_MAX_BUFFER_SIZE

#define STM_MAX_BUFFER_SIZE

Value:

(FIELD_OFFSET(ACPI_EVAL_INPUT_BUFFER_COMPLEX, Argument) + \

2 * STM_ID_BLOCK_SIZE + sizeof(IDE_ACPI_TIMING_MODE_BLOCK) + 0x100)

IDE_ACPI_TIMING_MODE_BLOCK

struct _IDE_ACPI_TIMING_MODE_BLOCK IDE_ACPI_TIMING_MODE_BLOCK

STM_ID_BLOCK_SIZE

#define STM_ID_BLOCK_SIZE

Definition: Bus_PDO_EvalMethod.c:172

Definition at line 612 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_BAD_ARG_TYPE

#define STM_TEST_FLAG_BAD_ARG_TYPE (1 << 11)

Definition at line 61 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_CHANGE_ARG_COUNT

#define STM_TEST_FLAG_CHANGE_ARG_COUNT (1 << 6 )

Definition at line 56 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_INVALID_ARG_3_1

#define STM_TEST_FLAG_INVALID_ARG_3_1 (1 << 0 )

Definition at line 50 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_INVALID_ARG_3_2

#define STM_TEST_FLAG_INVALID_ARG_3_2 (1 << 1 )

Definition at line 51 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_INVALID_ARG_3_4

#define STM_TEST_FLAG_INVALID_ARG_3_4 (1 << 2 )

Definition at line 52 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_INVALID_ARG_3_5

#define STM_TEST_FLAG_INVALID_ARG_3_5 (1 << 3 )

Definition at line 53 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_INVALID_SIZE_1

#define STM_TEST_FLAG_INVALID_SIZE_1 (1 << 4 )

Definition at line 54 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_IS_TODO

#define STM_TEST_FLAG_IS_TODO (1 << 12)

Definition at line 62 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_LARGE_ARG_BUFFER

#define STM_TEST_FLAG_LARGE_ARG_BUFFER (1 << 5 )

Definition at line 55 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_SET_IN_BUFFER

#define STM_TEST_FLAG_SET_IN_BUFFER (1 << 9 )

Definition at line 59 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_SET_IRP_BUFFER

#define STM_TEST_FLAG_SET_IRP_BUFFER (1 << 10)

Definition at line 60 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_SUB_IN_BUFFER

#define STM_TEST_FLAG_SUB_IN_BUFFER (1 << 7 )

Definition at line 57 of file Bus_PDO_EvalMethod.c.

◆ STM_TEST_FLAG_SUB_IRP_BUFFER

#define STM_TEST_FLAG_SUB_IRP_BUFFER (1 << 8 )

Definition at line 58 of file Bus_PDO_EvalMethod.c.

◆ UNIT_TEST

#define UNIT_TEST

Definition at line 15 of file Bus_PDO_EvalMethod.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 12 of file Bus_PDO_EvalMethod.c.

Typedef Documentation

◆ BIF_OBJECT_BUFFER

typedef struct _BIF_OBJECT_BUFFER BIF_OBJECT_BUFFER

◆ EVAL_TEST_ENTRY

typedef struct _EVAL_TEST_ENTRY EVAL_TEST_ENTRY

◆ GTM_OBJECT_BUFFER

typedef struct _GTM_OBJECT_BUFFER GTM_OBJECT_BUFFER

◆ IDE_ACPI_TIMING_MODE_BLOCK

typedef struct _IDE_ACPI_TIMING_MODE_BLOCK IDE_ACPI_TIMING_MODE_BLOCK

◆ IO_STACK_LOCATION

typedef struct _IO_STACK_LOCATION IO_STACK_LOCATION

◆ IRP

typedef struct _IRP IRP

◆ PBIF_OBJECT_BUFFER

typedef struct _BIF_OBJECT_BUFFER * PBIF_OBJECT_BUFFER

◆ PCL_OBJECT_BUFFER

typedef struct _PCL_OBJECT_BUFFER PCL_OBJECT_BUFFER

◆ PDO_DEVICE_DATA

typedef struct _PDO_DEVICE_DATA PDO_DEVICE_DATA

◆ PGTM_OBJECT_BUFFER

typedef struct _GTM_OBJECT_BUFFER * PGTM_OBJECT_BUFFER

◆ PIDE_ACPI_TIMING_MODE_BLOCK

typedef struct _IDE_ACPI_TIMING_MODE_BLOCK * PIDE_ACPI_TIMING_MODE_BLOCK

◆ PIO_STACK_LOCATION

typedef struct _IO_STACK_LOCATION * PIO_STACK_LOCATION

◆ PIRP

typedef struct _IRP * PIRP

◆ PPCL_OBJECT_BUFFER

typedef struct _PCL_OBJECT_BUFFER * PPCL_OBJECT_BUFFER

◆ PPDO_DEVICE_DATA

typedef struct _PDO_DEVICE_DATA * PPDO_DEVICE_DATA

◆ PPRT_OBJECT_BUFFER

typedef struct _PRT_OBJECT_BUFFER * PPRT_OBJECT_BUFFER

◆ PRT_OBJECT_BUFFER

typedef struct _PRT_OBJECT_BUFFER PRT_OBJECT_BUFFER

Function Documentation

◆ AcpiEvaluateObject()

ACPI_STATUS AcpiEvaluateObject	(	ACPI_HANDLE	Object,
		ACPI_STRING	Pathname,
		ACPI_OBJECT_LIST *	ParameterObjects,
		ACPI_BUFFER *	ReturnObjectBuffer
	)

Definition at line 278 of file Bus_PDO_EvalMethod.c.

{
    UNREFERENCED_PARAMETER(Object);
 
    /* We don't support anything else */
    ok(ReturnObjectBuffer->Length == ACPI_ALLOCATE_BUFFER,
       "Unexpected call to %s\n", __FUNCTION__);
 
    if (strcmp(Pathname, "_STM") == 0)
    {
        ACPI_OBJECT* Arg;
        PIDE_ACPI_TIMING_MODE_BLOCK TimingMode;
 
        if (ParameterObjects->Count > 3)
            return AE_AML_UNINITIALIZED_ARG;
 
        if (ParameterObjects->Count != 3)
            return AE_OK;
 
        /* Argument 1 */
        {
            Arg = ParameterObjects->Pointer;
 
            ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Type, ACPI_TYPE_BUFFER);
            ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Buffer.Length, sizeof(*TimingMode));
 
            TimingMode = (PIDE_ACPI_TIMING_MODE_BLOCK)Arg->Buffer.Pointer;
 
            ok_eq_ulong_ex(DrvpEvalTestEntry, TimingMode->Drive[0].PioSpeed, 508LU);
            ok_eq_ulong_ex(DrvpEvalTestEntry, TimingMode->Drive[0].DmaSpeed, 120LU);
            ok_eq_ulong_ex(DrvpEvalTestEntry, TimingMode->Drive[1].PioSpeed, 240LU);
            ok_eq_ulong_ex(DrvpEvalTestEntry, TimingMode->Drive[1].DmaSpeed, 180LU);
            ok_eq_hex_ex(DrvpEvalTestEntry, TimingMode->ModeFlags, 0x10LU);
        }
        /* Argument 2 */
        {
            ++Arg;
 
            ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Type, ACPI_TYPE_BUFFER);
            ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Buffer.Length, STM_ID_BLOCK_SIZE);
        }
        /* Argument 3 */
        {
            ++Arg;
 
            ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Type, ACPI_TYPE_BUFFER);
            ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Buffer.Length, STM_ID_BLOCK_SIZE);
        }
 
        return AE_OK;
    }
    else if (strcmp(Pathname, "_GTM") == 0)
    {
        PGTM_OBJECT_BUFFER ReturnObject;
        PIDE_ACPI_TIMING_MODE_BLOCK TimingMode;
 
        ReturnObject = AcpiOsAllocate(sizeof(*ReturnObject));
        if (!ReturnObject)
            return AE_NO_MEMORY;
 
        /*
         * VPC 2007 output
         * AcpiGetHandle(NULL, "\\_SB.PCI0.IDE0.CHN1", &ObjHandle);
         * AcpiEvaluateObject(ObjHandle, "_GTM", NULL, &ReturnObj);
         */
        TimingMode = &ReturnObject->TimingMode;
        TimingMode->Drive[0].PioSpeed = 900;
        TimingMode->Drive[0].DmaSpeed = 900;
        TimingMode->Drive[1].PioSpeed = 120;
        TimingMode->Drive[1].DmaSpeed = 120;
        TimingMode->ModeFlags = 0x12;
 
        ReturnObject->Obj.Type = ACPI_TYPE_BUFFER;
        ReturnObject->Obj.Buffer.Length = sizeof(*TimingMode);
        ReturnObject->Obj.Buffer.Pointer = (PUCHAR)TimingMode;
 
        ReturnObjectBuffer->Pointer = ReturnObject;
        ReturnObjectBuffer->Length = sizeof(*ReturnObject);
        return AE_OK;
    }
    else if (strcmp(Pathname, "_BIF") == 0)
    {
        PBIF_OBJECT_BUFFER ReturnObject;
        ACPI_OBJECT* BatteryInformation;
        ULONG i;
 
        ReturnObject = AcpiOsAllocate(sizeof(*ReturnObject));
        if (!ReturnObject)
            return AE_NO_MEMORY;
 
        /*
         * Vbox 7.0 output
         * AcpiGetHandle(NULL, "\\_SB.PCI0.BAT0", &ObjHandle);
         * AcpiEvaluateObject(ObjHandle, "_BIF", NULL, &ReturnObj);
         */
        BatteryInformation = &ReturnObject->BatteryInformation[0];
        for (i = 0; i < RTL_NUMBER_OF(DrvpBifIntegerFields); ++i)
        {
            BatteryInformation[i].Integer.Type = ACPI_TYPE_INTEGER;
            BatteryInformation[i].Integer.Value = DrvpBifIntegerFields[i];
        }
        BatteryInformation[i].String.Type = ACPI_TYPE_STRING;
        BatteryInformation[i].String.Length = 1; /* Excluding the trailing null */
        BatteryInformation[i].String.Pointer = &ReturnObject->Buffer1[0];
        RtlCopyMemory(BatteryInformation[i].String.Pointer, "1", sizeof("1"));
        ++i;
        BatteryInformation[i].String.Type = ACPI_TYPE_STRING;
        BatteryInformation[i].String.Length = 1;
        BatteryInformation[i].String.Pointer = &ReturnObject->Buffer2[0];
        RtlCopyMemory(BatteryInformation[i].String.Pointer, "0", sizeof("0"));
        ++i;
        BatteryInformation[i].String.Type = ACPI_TYPE_STRING;
        BatteryInformation[i].String.Length = 4;
        BatteryInformation[i].String.Pointer = &ReturnObject->Buffer3[0];
        RtlCopyMemory(BatteryInformation[i].String.Pointer, "VBOX", sizeof("VBOX"));
        ++i;
        BatteryInformation[i].String.Type = ACPI_TYPE_STRING;
        BatteryInformation[i].String.Length = 7;
        BatteryInformation[i].String.Pointer = &ReturnObject->Buffer4[0];
        RtlCopyMemory(BatteryInformation[i].String.Pointer, "innotek", sizeof("innotek"));
 
        ReturnObject->Obj.Type = ACPI_TYPE_PACKAGE;
        ReturnObject->Obj.Package.Count = 13;
        ReturnObject->Obj.Package.Elements = BatteryInformation;
 
        ReturnObjectBuffer->Pointer = ReturnObject;
        ReturnObjectBuffer->Length = sizeof(*ReturnObject);
        return AE_OK;
    }
    else if (strcmp(Pathname, "_PCL") == 0)
    {
        PPCL_OBJECT_BUFFER ReturnObject;
 
        ReturnObject = AcpiOsAllocate(sizeof(*ReturnObject));
        if (!ReturnObject)
            return AE_NO_MEMORY;
 
        /*
         * Vbox 7.0 output
         * AcpiGetHandle(NULL, "\\_SB.PCI0.AC", &ObjHandle);
         * AcpiEvaluateObject(ObjHandle, "_PCL", NULL, &ReturnObj);
         */
        ReturnObject->Obj.Reference.Type = ACPI_TYPE_LOCAL_REFERENCE;
        ReturnObject->Obj.Reference.ActualType = ACPI_TYPE_DEVICE;
        ReturnObject->Obj.Reference.Handle = (ACPI_HANDLE)(ULONG_PTR)FAKE_SB_NAMESPACE_ACPI_HANDLE;
 
        ReturnObjectBuffer->Pointer = ReturnObject;
        ReturnObjectBuffer->Length = sizeof(*ReturnObject);
        return AE_OK;
    }
    else if (strcmp(Pathname, "_PRT") == 0)
    {
        PPRT_OBJECT_BUFFER ReturnObject;
        ULONG i;
 
        ReturnObject = AcpiOsAllocate(sizeof(*ReturnObject));
        if (!ReturnObject)
            return AE_NO_MEMORY;
 
        /*
         * Vbox 7.0 output
         * AcpiGetHandle(NULL, "\\_SB.PCI0", &ObjHandle);
         * AcpiEvaluateObject(ObjHandle, "_PRT", NULL, &ReturnObj);
         *
         * NOTE: To avoid similar copies of code executed and tested over and over again
         * we return 2 packages. The original method returns 120 packages.
         */
        ReturnObject->Obj.Type = ACPI_TYPE_PACKAGE;
        ReturnObject->Obj.Package.Count = 2;
        ReturnObject->Obj.Package.Elements = &ReturnObject->PackageContainer[0];
 
        i = 0;
        ReturnObject->PackageContainer[i].Type = ACPI_TYPE_PACKAGE;
        ReturnObject->PackageContainer[i].Package.Count = 4;
        ReturnObject->PackageContainer[i].Package.Elements = &ReturnObject->Package1[0];
        ++i;
        ReturnObject->PackageContainer[i].Type = ACPI_TYPE_PACKAGE;
        ReturnObject->PackageContainer[i].Package.Count = 4;
        ReturnObject->PackageContainer[i].Package.Elements = &ReturnObject->Package2[0];
 
        /* Package 1 */
        i = 0;
        ReturnObject->Package1[i].Integer.Type = ACPI_TYPE_INTEGER;
        ReturnObject->Package1[i].Integer.Value = 0x0002FFFF;
        ++i;
        ReturnObject->Package1[i].Integer.Type = ACPI_TYPE_INTEGER;
        ReturnObject->Package1[i].Integer.Value = 0x00000000;
        ++i;
        ReturnObject->Package1[i].Reference.Type = ACPI_TYPE_LOCAL_REFERENCE;
        ReturnObject->Package1[i].Reference.ActualType = ACPI_TYPE_DEVICE;
        ReturnObject->Package1[i].Reference.Handle = (ACPI_HANDLE)(ULONG_PTR)FAKE_INTB_ACPI_HANDLE;
        ++i;
        ReturnObject->Package1[i].Integer.Type = ACPI_TYPE_INTEGER;
        ReturnObject->Package1[i].Integer.Value = 0x00000000;
 
        /* Package 2 */
        i = 0;
        ReturnObject->Package2[i].Integer.Type = ACPI_TYPE_INTEGER;
        ReturnObject->Package2[i].Integer.Value = 0x0002FFFF;
        ++i;
        ReturnObject->Package2[i].Integer.Type = ACPI_TYPE_INTEGER;
        ReturnObject->Package2[i].Integer.Value = 0x00000001;
        ++i;
        ReturnObject->Package2[i].Reference.Type = ACPI_TYPE_LOCAL_REFERENCE;
        ReturnObject->Package2[i].Reference.ActualType = ACPI_TYPE_DEVICE;
        ReturnObject->Package2[i].Reference.Handle = (ACPI_HANDLE)(ULONG_PTR)FAKE_INTC_ACPI_HANDLE;
        ++i;
        ReturnObject->Package2[i].Integer.Type = ACPI_TYPE_INTEGER;
        ReturnObject->Package2[i].Integer.Value = 0x00000000;
 
        ReturnObjectBuffer->Pointer = ReturnObject;
        ReturnObjectBuffer->Length = sizeof(*ReturnObject);
        return AE_OK;
    }
    else if (strcmp(Pathname, "_DSM") == 0)
    {
        ACPI_OBJECT* Arg;
 
        /* Assumed object count per the spec */
        ok_eq_uint(ParameterObjects->Count, 4);
 
        if (ParameterObjects->Count != 4)
            return AE_AML_UNINITIALIZED_ARG;
 
        /* Argument 1 */
        {
            Arg = ParameterObjects->Pointer;
 
            ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Type, ACPI_TYPE_BUFFER);
            ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Buffer.Length, sizeof(GUID));
        }
 
        /* NOTE: This UUID doesn't exist, for testing purposes only */
        if (IsEqualGUID(Arg->Buffer.Pointer, &MY_DSM_GUID))
        {
            /* Argument 2 */
            {
                ++Arg;
 
                ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Type, ACPI_TYPE_INTEGER);
                ok_eq_ulonglong_ex(DrvpEvalTestEntry, Arg->Integer.Value, 1ULL);
            }
            /* Argument 3 */
            {
                ++Arg;
 
                ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Type, ACPI_TYPE_INTEGER);
                ok_eq_ulonglong_ex(DrvpEvalTestEntry, Arg->Integer.Value, 2ULL);
            }
            /* Argument 4 */
            {
                ++Arg;
 
                ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Type, ACPI_TYPE_PACKAGE);
 
                if (DrvpEvalTestEntry->Flags & DSM_TEST_FLAG_EMPTY_PACKAGE)
                {
                    ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Package.Count, 0);
                    ok_eq_pointer_ex(DrvpEvalTestEntry, Arg->Package.Elements, NULL);
                }
                else
                {
                    ACPI_OBJECT* PackageArg;
                    ACPI_OBJECT* PackageArg2;
                    ULONG i;
 
                    ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Package.Count, 4);
                    ok_not_pointer_ex(DrvpEvalTestEntry, Arg->Package.Elements, NULL);
 
                    if (!Arg->Package.Elements)
                        return AE_AML_UNINITIALIZED_ARG;
 
                    /* Package 1 Arguments 1-2 */
                    PackageArg = Arg->Package.Elements;
                    for (i = 0; i < RTL_NUMBER_OF(DrvpMyDsmIntegerFields) - 1; i++)
                    {
                        ok_eq_uint_ex(DrvpEvalTestEntry, PackageArg->Type, ACPI_TYPE_INTEGER);
                        ok_eq_ulonglong_ex(DrvpEvalTestEntry,
                                           PackageArg->Integer.Value,
                                           (ULONG64)DrvpMyDsmIntegerFields[i]);
 
                        ++PackageArg;
                    }
 
                    /* Package 1 Argument 3 */
                    {
                        Arg = PackageArg;
 
                        ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Type, ACPI_TYPE_PACKAGE);
                        ok_eq_uint_ex(DrvpEvalTestEntry, Arg->Package.Count, 1);
 
                        /* Package 2 Argument 1 */
                        PackageArg2 = Arg->Package.Elements;
 
                        ok_eq_uint_ex(DrvpEvalTestEntry, PackageArg2->Type, ACPI_TYPE_STRING);
 
                        /* Excluding the trailing null */
                        ok_eq_uint_ex(DrvpEvalTestEntry,
                                      PackageArg2->String.Length,
                                      (sizeof("1_TESTDATATESTDATA_2") - 1));
                        ok_eq_int_ex(DrvpEvalTestEntry,
                                     memcmp(PackageArg2->String.Pointer,
                                            "1_TESTDATATESTDATA_2",
                                            sizeof("1_TESTDATATESTDATA_2") - 1),
                                     0);
                    }
                    /* Package 1 Argument 4 */
                    {
                        ++PackageArg;
 
                        ok_eq_uint_ex(DrvpEvalTestEntry, PackageArg->Type, ACPI_TYPE_INTEGER);
                        ok_eq_ulonglong_ex(DrvpEvalTestEntry,
                                           PackageArg->Integer.Value,
                                           (ULONG64)DrvpMyDsmIntegerFields[2]);
                    }
                }
            }
 
            return AE_OK;
        }
    }
 
    return AE_NOT_FOUND;
}

◆ AcpiGetName()

ACPI_STATUS AcpiGetName	(	ACPI_HANDLE	Handle,
		UINT32	NameType,
		ACPI_BUFFER *	Buffer
	)

Definition at line 244 of file Bus_PDO_EvalMethod.c.

{
    /* We don't support anything else */
    ok(NameType == ACPI_SINGLE_NAME, "Unexpected call to %s\n", __FUNCTION__);
 
    /* Return a NULL-terminated string */
    if (Buffer->Length < (4 + 1))
        return AE_BUFFER_OVERFLOW;
 
    switch ((ULONG_PTR)Handle)
    {
        case FAKE_SB_NAMESPACE_ACPI_HANDLE:
            RtlCopyMemory(Buffer->Pointer, "_SB_", sizeof("_SB_"));
            break;
 
        case FAKE_INTB_ACPI_HANDLE:
            RtlCopyMemory(Buffer->Pointer, "LNKB", sizeof("LNKB"));
            break;
 
        case FAKE_INTC_ACPI_HANDLE:
            RtlCopyMemory(Buffer->Pointer, "LNKC", sizeof("LNKC"));
            break;
 
        default:
            return AE_BAD_PARAMETER;
    }
 
    return AE_OK;
}

◆ AcpiOsAllocate()

void * AcpiOsAllocate ( ACPI_SIZE Size )

Definition at line 230 of file Bus_PDO_EvalMethod.c.

{
    return ExAllocatePoolWithTag(NonPagedPool, Size, 'FFUB');
}

Referenced by AcpiEvaluateObject(), AcpiOsAllocateZeroed(), and AcpiUtInitializeBuffer().

◆ AcpiOsFree()

void AcpiOsFree ( void * Memory )

Definition at line 237 of file Bus_PDO_EvalMethod.c.

{
    ExFreePoolWithTag(Memory, 'FFUB');
}

Referenced by acpi_evaluate_reference(), AcpiEvaluateObjectTyped(), AcpiUtDeleteCaches(), and Bus_PDO_EvalMethod().

◆ DEFINE_GUID()

DEFINE_GUID	(	MY_DSM_GUID	,
		0xB76E0B40	,
		0x3EC6	,
		0x4DBD	,
		0x8A	,
		0xCB	,
		0x8B	,
		0xCA	,
		0x65	,
		0xB8	,
		0xBC	,
		0x70
	)

◆ DrvCallAcpiDriver()

static NTSTATUS DrvCallAcpiDriver	(	_In_ PVOID	InputBuffer,
		_In_ ULONG	InputBufferLength,
		_Out_opt_ PACPI_EVAL_OUTPUT_BUFFER	OutputBuffer,
		_In_ ULONG	OutputBufferLength
	)

static

Definition at line 732 of file Bus_PDO_EvalMethod.c.

{
    PDO_DEVICE_DATA DeviceData;
    IRP Irp;
 
    DeviceData.AcpiHandle = NULL;
 
    Irp.AssociatedIrp.SystemBuffer = InputBuffer;
    Irp.OutputBuffer = OutputBuffer;
 
    Irp.MyStack.Parameters.DeviceIoControl.InputBufferLength = InputBufferLength;
    Irp.MyStack.Parameters.DeviceIoControl.OutputBufferLength = OutputBufferLength;
 
    return Bus_PDO_EvalMethod(&DeviceData, &Irp);
}

Referenced by DrvEvaluateBifObject(), DrvEvaluateDsmObject(), DrvEvaluateGtmObject(), DrvEvaluatePclObject(), DrvEvaluatePrtObject(), DrvEvaluateStmObject(), and DrvTestUnknownMethod().

◆ DrvEvaluateBifObject()

static VOID DrvEvaluateBifObject	(	_In_ const EVAL_TEST_ENTRY *	TestEntry,
		_In_ PACPI_EVAL_OUTPUT_BUFFER	OutputBuffer
	)

static

Definition at line 994 of file Bus_PDO_EvalMethod.c.

{
    ACPI_EVAL_INPUT_BUFFER InputBuffer;
    ULONG i, OutputBufferSize;
    NTSTATUS Status;
    PACPI_METHOD_ARGUMENT Argument;
 
    InputBuffer.MethodNameAsUlong = 'FIB_'; // _BIF
    InputBuffer.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
 
    OutputBufferSize = FIELD_OFFSET(ACPI_EVAL_OUTPUT_BUFFER, Argument) +
                       ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) * 9 +
                       ACPI_METHOD_ARGUMENT_LENGTH(sizeof("1")) +
                       ACPI_METHOD_ARGUMENT_LENGTH(sizeof("0")) +
                       ACPI_METHOD_ARGUMENT_LENGTH(sizeof("VBOX")) +
                       ACPI_METHOD_ARGUMENT_LENGTH(sizeof("innotek"));
 
    /* Evaluate the _BIF method */
    Status = DrvCallAcpiDriver(&InputBuffer, sizeof(InputBuffer), OutputBuffer, OutputBufferSize);
 
    ok_eq_hex_ex(TestEntry, Status, TestEntry->Status);
    ok_eq_hex_ex(TestEntry, OutputBuffer->Signature, (ULONG)ACPI_EVAL_OUTPUT_BUFFER_SIGNATURE);
    ok_eq_ulong_ex(TestEntry, OutputBuffer->Count, 13LU);
    ok_eq_ulong_ex(TestEntry, OutputBuffer->Length, OutputBufferSize);
 
    /* Arguments 1-9 */
    Argument = OutputBuffer->Argument;
    for (i = 0; i < RTL_NUMBER_OF(DrvpBifIntegerFields); ++i)
    {
        ok_eq_uint_ex(TestEntry, Argument->Type, ACPI_METHOD_ARGUMENT_INTEGER);
        ok_eq_uint_ex(TestEntry, Argument->DataLength, sizeof(ULONG));
        ok_eq_ulong_ex(TestEntry, Argument->Argument, DrvpBifIntegerFields[i]);
 
        Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
    }
    /* Argument 10 */
    {
        ok_eq_uint_ex(TestEntry, Argument->Type, ACPI_METHOD_ARGUMENT_STRING);
        ok_eq_uint_ex(TestEntry, Argument->DataLength, sizeof("1")); // Including the trailing null
        ok_eq_str_ex(TestEntry, (PCSTR)Argument->Data, "1");
    }
    /* Argument 11 */
    {
        Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
 
        ok_eq_uint_ex(TestEntry, Argument->Type, ACPI_METHOD_ARGUMENT_STRING);
        ok_eq_uint_ex(TestEntry, Argument->DataLength, sizeof("0"));
        ok_eq_str_ex(TestEntry, (PCSTR)Argument->Data, "0");
    }
    /* Argument 12 */
    {
        Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
 
        ok_eq_uint_ex(TestEntry, Argument->Type, ACPI_METHOD_ARGUMENT_STRING);
        ok_eq_uint_ex(TestEntry, Argument->DataLength, sizeof("VBOX"));
        ok_eq_str_ex(TestEntry, (PCSTR)Argument->Data, "VBOX");
    }
    /* Argument 13 */
    {
        Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
 
        ok_eq_uint_ex(TestEntry, Argument->Type, ACPI_METHOD_ARGUMENT_STRING);
        ok_eq_uint_ex(TestEntry, Argument->DataLength, sizeof("innotek"));
        ok_eq_str_ex(TestEntry, (PCSTR)Argument->Data, "innotek");
    }
}

Referenced by DrvTestPackageReturnValueAndStringData().

◆ DrvEvaluateDsmObject()

static VOID DrvEvaluateDsmObject ( _In_ const EVAL_TEST_ENTRY * TestEntry )

static

Definition at line 1218 of file Bus_PDO_EvalMethod.c.

{
#define MY_DSM_SUB_PACKAGE_ENTRY_SIZE \
    (ACPI_METHOD_ARGUMENT_LENGTH(sizeof("1_TESTDATATESTDATA_2")))
 
#define MY_DSM_PACKAGE_ENTRY_SIZE \
    (ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) * 3 + \
     ACPI_METHOD_ARGUMENT_LENGTH(MY_DSM_SUB_PACKAGE_ENTRY_SIZE))
 
#define MY_DSM_BUFFER_SIZE \
    (FIELD_OFFSET(ACPI_EVAL_INPUT_BUFFER_COMPLEX, Argument) + \
     ACPI_METHOD_ARGUMENT_LENGTH(sizeof(GUID)) + \
     ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) + \
     ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) + \
     ACPI_METHOD_ARGUMENT_LENGTH(MY_DSM_PACKAGE_ENTRY_SIZE))
 
    UCHAR Buffer[MY_DSM_BUFFER_SIZE];
    ULONG InputSize;
    NTSTATUS Status;
    PACPI_METHOD_ARGUMENT Argument, PackageArgument, PackageArgument2;
    PACPI_EVAL_INPUT_BUFFER_COMPLEX InputBuffer = (PACPI_EVAL_INPUT_BUFFER_COMPLEX)Buffer;
 
    RtlZeroMemory(Buffer, sizeof(Buffer));
 
    InputSize = MY_DSM_BUFFER_SIZE;
    if (TestEntry->Flags & DSM_TEST_FLAG_EMPTY_PACKAGE)
    {
        InputSize -= ACPI_METHOD_ARGUMENT_LENGTH(MY_DSM_PACKAGE_ENTRY_SIZE);
        InputSize += ACPI_METHOD_ARGUMENT_LENGTH(ACPI_METHOD_ARGUMENT_LENGTH(0));
    }
 
    InputBuffer->MethodNameAsUlong = 'MSD_'; // _DSM
    InputBuffer->Signature = ACPI_EVAL_INPUT_BUFFER_COMPLEX_SIGNATURE;
    InputBuffer->ArgumentCount = 4;
    InputBuffer->Size = InputSize;
 
    /* Argument 1: The UUID */
    Argument = InputBuffer->Argument;
    ACPI_METHOD_SET_ARGUMENT_BUFFER(Argument, &MY_DSM_GUID, sizeof(GUID));
 
    /* Argument 2: The Revision ID */
    Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
    ACPI_METHOD_SET_ARGUMENT_INTEGER(Argument, 1);
 
    /* Argument 3: The Function Index */
    Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
    ACPI_METHOD_SET_ARGUMENT_INTEGER(Argument, 2);
 
    /* Argument 4: The device-specific package */
    Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
    Argument->Type = ACPI_METHOD_ARGUMENT_PACKAGE;
    if (TestEntry->Flags & DSM_TEST_FLAG_EMPTY_PACKAGE)
    {
        /* Empty package */
        Argument->DataLength = ACPI_METHOD_ARGUMENT_LENGTH(0);
        Argument->Argument = 0;
    }
    else
    {
        Argument->DataLength = MY_DSM_PACKAGE_ENTRY_SIZE;
 
        /* Package 1 Argument 1: Some test data */
        PackageArgument = (PACPI_METHOD_ARGUMENT)Argument->Data;
        ACPI_METHOD_SET_ARGUMENT_INTEGER(PackageArgument, DrvpMyDsmIntegerFields[0]);
 
        /* Package 1 Argument 2: Some test data */
        PackageArgument = ACPI_METHOD_NEXT_ARGUMENT(PackageArgument);
        ACPI_METHOD_SET_ARGUMENT_INTEGER(PackageArgument, DrvpMyDsmIntegerFields[1]);
 
        /* Package 1 Argument 3: Start a new subpackage */
        PackageArgument = ACPI_METHOD_NEXT_ARGUMENT(PackageArgument);
        PackageArgument->Type = ACPI_METHOD_ARGUMENT_PACKAGE;
        PackageArgument->DataLength = MY_DSM_SUB_PACKAGE_ENTRY_SIZE;
 
        /* Package 2 Argument 1: Some test data */
        PackageArgument2 = (PACPI_METHOD_ARGUMENT)PackageArgument->Data;
        ACPI_METHOD_SET_ARGUMENT_STRING(PackageArgument2, "1_TESTDATATESTDATA_2");
 
        if (TestEntry->Flags & DSM_TEST_FLAG_LARGE_SUB_PACKAGE_BUFFER)
        {
            PackageArgument2->DataLength = 32768;
        }
        else
        {
            /* Package 1 Argument 4: Some test data */
            PackageArgument = ACPI_METHOD_NEXT_ARGUMENT(PackageArgument);
            ACPI_METHOD_SET_ARGUMENT_INTEGER(PackageArgument, DrvpMyDsmIntegerFields[2]);
        }
    }
 
    /* Evaluate the _DSM method */
    DrvpEvalTestEntry = TestEntry;
    Status = DrvCallAcpiDriver(InputBuffer, InputSize, NULL, 0);
 
    ok_eq_hex_ex(TestEntry, Status, TestEntry->Status);
}

Referenced by DrvTestPackageInputValue().

◆ DrvEvaluateGtmObject()

static VOID DrvEvaluateGtmObject	(	_In_ const EVAL_TEST_ENTRY *	TestEntry,
		_In_ PACPI_EVAL_OUTPUT_BUFFER	OutputBuffer
	)

static

Definition at line 886 of file Bus_PDO_EvalMethod.c.

{
    ACPI_EVAL_INPUT_BUFFER InputBuffer;
    ULONG OutputBufferSize;
    NTSTATUS Status;
    PACPI_METHOD_ARGUMENT Argument;
    ULONG Signature, Count, Length;
    USHORT Type, DataLength;
    PIDE_ACPI_TIMING_MODE_BLOCK TimingMode;
 
    InputBuffer.MethodNameAsUlong = 'MTG_'; // _GTM
    if (TestEntry->Flags & GTM_TEST_FLAG_BAD_SIGNARUTE)
        InputBuffer.Signature = 'BAD0';
    else
        InputBuffer.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
 
    OutputBufferSize = FIELD_OFFSET(ACPI_EVAL_OUTPUT_BUFFER, Argument) +
                       ACPI_METHOD_ARGUMENT_LENGTH(sizeof(*TimingMode));
 
    if (TestEntry->Flags & GTM_TEST_FLAG_INC_OUT_BUFFER)
    {
        OutputBufferSize += TestEntry->Value;
    }
    else if (TestEntry->Flags & GTM_TEST_FLAG_DEC_OUT_BUFFER)
    {
        OutputBufferSize -= TestEntry->Value;
    }
    else if (TestEntry->Flags & GTM_TEST_FLAG_SET_OUT_BUFFER)
    {
        OutputBufferSize = TestEntry->Value;
    }
 
    /* Evaluate the _GTM method */
    Status = DrvCallAcpiDriver(&InputBuffer, sizeof(InputBuffer), OutputBuffer, OutputBufferSize);
 
    todo_if(!is_reactos() && (TestEntry->Flags & GTM_TEST_FLAG_IS_TODO) && (Status != TestEntry->Status))
        ok_eq_hex_ex(TestEntry, Status, TestEntry->Status);
 
    if (TestEntry->Flags & GTM_TEST_FLAG_BUFFER_HAS_SIGNARUTE)
        Signature = ACPI_EVAL_OUTPUT_BUFFER_SIGNATURE;
    else
        Signature = 0;
    ok_eq_hex_ex(TestEntry, OutputBuffer->Signature, Signature);
 
    if (TestEntry->Flags & GTM_TEST_FLAG_BUFFER_HAS_COUNT)
        Count = 1;
    else
        Count = 0;
    ok_eq_ulong_ex(TestEntry, OutputBuffer->Count, Count);
 
    if (TestEntry->Flags & GTM_TEST_FLAG_BUFFER_HAS_LENGTH)
    {
        Length = FIELD_OFFSET(ACPI_EVAL_OUTPUT_BUFFER, Argument) +
                 ACPI_METHOD_ARGUMENT_LENGTH(sizeof(*TimingMode));
    }
    else
    {
        Length = 0;
    }
    ok_eq_ulong_ex(TestEntry, OutputBuffer->Length, Length);
 
    Argument = OutputBuffer->Argument;
    if (TestEntry->Flags & GTM_TEST_FLAG_ARG_HAS_BUFFER_TYPE)
        Type = ACPI_METHOD_ARGUMENT_BUFFER;
    else
        Type = ACPI_METHOD_ARGUMENT_INTEGER;
    todo_if(!is_reactos() && (TestEntry->Flags & GTM_TEST_FLAG_IS_TODO) && (Type != Argument->Type))
        ok_eq_uint_ex(TestEntry, Argument->Type, Type);
 
    if (TestEntry->Flags & GTM_TEST_FLAG_ARG_HAS_DATA_LENGTH)
        DataLength = sizeof(ACPI_EVAL_OUTPUT_BUFFER);
    else
        DataLength = 0;
    todo_if(!is_reactos() && (TestEntry->Flags & GTM_TEST_FLAG_IS_TODO) && (DataLength != Argument->DataLength))
        ok_eq_uint_ex(TestEntry, Argument->DataLength, DataLength);
 
    if ((TestEntry->Flags & GTM_TEST_FLAG_ARG_HAS_BUFFER_TYPE) && NT_SUCCESS(TestEntry->Status))
    {
        TimingMode = (PIDE_ACPI_TIMING_MODE_BLOCK)Argument->Data;
 
        ok_eq_ulong_ex(TestEntry, TimingMode->Drive[0].PioSpeed, 900LU);
        ok_eq_ulong_ex(TestEntry, TimingMode->Drive[0].DmaSpeed, 900LU);
        ok_eq_ulong_ex(TestEntry, TimingMode->Drive[1].PioSpeed, 120LU);
        ok_eq_ulong_ex(TestEntry, TimingMode->Drive[1].DmaSpeed, 120LU);
        ok_eq_hex_ex(TestEntry, TimingMode->ModeFlags, 0x12LU);
    }
}

Referenced by DrvTestInputBuffer().

◆ DrvEvaluatePclObject()

static VOID DrvEvaluatePclObject	(	_In_ const EVAL_TEST_ENTRY *	TestEntry,
		_In_ PACPI_EVAL_OUTPUT_BUFFER	OutputBuffer
	)

static

Definition at line 1081 of file Bus_PDO_EvalMethod.c.

{
    ACPI_EVAL_INPUT_BUFFER InputBuffer;
    ULONG OutputBufferSize;
    NTSTATUS Status;
    PACPI_METHOD_ARGUMENT Argument;
 
    InputBuffer.MethodNameAsUlong = 'LCP_'; // _PCL
    InputBuffer.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
 
    OutputBufferSize = FIELD_OFFSET(ACPI_EVAL_OUTPUT_BUFFER, Argument) +
                       ACPI_METHOD_ARGUMENT_LENGTH(sizeof("ABCD")); // ACPI name for the object
 
    /* Evaluate the _PCL method */
    Status = DrvCallAcpiDriver(&InputBuffer, sizeof(InputBuffer), OutputBuffer, OutputBufferSize);
 
    ok_eq_hex_ex(TestEntry, Status, TestEntry->Status);
    ok_eq_hex_ex(TestEntry, OutputBuffer->Signature, (ULONG)ACPI_EVAL_OUTPUT_BUFFER_SIGNATURE);
    ok_eq_ulong_ex(TestEntry, OutputBuffer->Count, 1LU);
    ok_eq_ulong_ex(TestEntry, OutputBuffer->Length, OutputBufferSize);
 
    Argument = OutputBuffer->Argument;
 
    ok_eq_uint_ex(TestEntry, Argument->Type, ACPI_METHOD_ARGUMENT_STRING);
    ok_eq_uint_ex(TestEntry, Argument->DataLength, sizeof("ABCD"));
    ok_eq_str_ex(TestEntry, (PCSTR)Argument->Data, "_SB_");
}

Referenced by DrvTestReferenceReturnValue().

◆ DrvEvaluatePrtObject()

static VOID DrvEvaluatePrtObject	(	_In_ const EVAL_TEST_ENTRY *	TestEntry,
		_In_ PACPI_EVAL_OUTPUT_BUFFER	OutputBuffer
	)

static

Definition at line 1129 of file Bus_PDO_EvalMethod.c.

{
    ACPI_EVAL_INPUT_BUFFER InputBuffer;
    ULONG PackageNum, ArgNum, OutputBufferSize;
    NTSTATUS Status;
    PACPI_METHOD_ARGUMENT Argument, PackageArgument;
 
    InputBuffer.MethodNameAsUlong = 'TRP_'; // _PRT
    InputBuffer.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
 
#define PRT_PACKAGE_ENTRY_SIZE \
    (ACPI_METHOD_ARGUMENT_LENGTH(sizeof(ULONG)) * 3 + \
     ACPI_METHOD_ARGUMENT_LENGTH(sizeof("LNKB")))
 
    OutputBufferSize = FIELD_OFFSET(ACPI_EVAL_OUTPUT_BUFFER, Argument) +
                       ACPI_METHOD_ARGUMENT_LENGTH(PRT_PACKAGE_ENTRY_SIZE) * 2;
 
    /* Evaluate the _PRT method */
    Status = DrvCallAcpiDriver(&InputBuffer, sizeof(InputBuffer), OutputBuffer, OutputBufferSize);
 
    ok_eq_hex_ex(TestEntry, Status, TestEntry->Status);
    ok_eq_hex_ex(TestEntry, OutputBuffer->Signature, (ULONG)ACPI_EVAL_OUTPUT_BUFFER_SIGNATURE);
    ok_eq_ulong_ex(TestEntry, OutputBuffer->Count, 2LU);
    ok_eq_ulong_ex(TestEntry, OutputBuffer->Length, OutputBufferSize);
 
    Argument = OutputBuffer->Argument;
    for (PackageNum = 0; PackageNum < 2; PackageNum++)
    {
        ok_eq_uint_ex(TestEntry, Argument->Type, ACPI_METHOD_ARGUMENT_PACKAGE);
        ok_eq_uint_ex(TestEntry, Argument->DataLength, (USHORT)PRT_PACKAGE_ENTRY_SIZE);
 
        PackageArgument = (PACPI_METHOD_ARGUMENT)Argument->Data;
        for (ArgNum = 0; ArgNum < 4; ArgNum++)
        {
            if (ArgNum != 2)
            {
                ULONG ExpectedValue;
 
                ok_eq_uint_ex(TestEntry, PackageArgument->Type, ACPI_METHOD_ARGUMENT_INTEGER);
                ok_eq_uint_ex(TestEntry, PackageArgument->DataLength, sizeof(ULONG));
 
                if (ArgNum == 0)
                {
                    ExpectedValue = 0x0002FFFF;
                }
                else
                {
                    if ((PackageNum == 1) && (ArgNum == 1))
                        ExpectedValue = 0x00000001;
                    else
                        ExpectedValue = 0x00000000;
                }
                ok_eq_ulong_ex(TestEntry, PackageArgument->Argument, ExpectedValue);
            }
            else
            {
                ok_eq_uint_ex(TestEntry, PackageArgument->Type, ACPI_METHOD_ARGUMENT_STRING);
                ok_eq_uint_ex(TestEntry, PackageArgument->DataLength, sizeof("ABCD"));
                ok_eq_str_ex(TestEntry, (PCSTR)PackageArgument->Data,
                             (PackageNum == 0) ? "LNKB" : "LNKC");
            }
 
            PackageArgument = ACPI_METHOD_NEXT_ARGUMENT(PackageArgument);
        }
 
        Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
    }
}

Referenced by DrvTestNestedPackageReturnValue().

◆ DrvEvaluateStmObject()

static VOID DrvEvaluateStmObject	(	_In_ const EVAL_TEST_ENTRY *	TestEntry,
		_In_ PIDE_ACPI_TIMING_MODE_BLOCK	TimingMode,
		_In_ PUCHAR	IdBlock,
		_In_ PACPI_EVAL_INPUT_BUFFER_COMPLEX	InputBuffer
	)

static

Definition at line 754 of file Bus_PDO_EvalMethod.c.

{
    PACPI_METHOD_ARGUMENT Argument, Argument2, Argument3;
    NTSTATUS Status;
    ULONG InputBufferSize, IrpBufferSize;
 
    InputBufferSize = FIELD_OFFSET(ACPI_EVAL_INPUT_BUFFER_COMPLEX, Argument) +
                      ACPI_METHOD_ARGUMENT_LENGTH(sizeof(*TimingMode)) +
                      ACPI_METHOD_ARGUMENT_LENGTH(STM_ID_BLOCK_SIZE) +
                      ACPI_METHOD_ARGUMENT_LENGTH(STM_ID_BLOCK_SIZE);
 
    if (TestEntry->Flags & STM_TEST_FLAG_INVALID_SIZE_1)
    {
        InputBufferSize -= ACPI_METHOD_ARGUMENT_LENGTH(STM_ID_BLOCK_SIZE) +
                           ACPI_METHOD_ARGUMENT_LENGTH(STM_ID_BLOCK_SIZE);
    }
 
    InputBuffer->MethodNameAsUlong = 'MTS_'; // _STM
    InputBuffer->Signature = ACPI_EVAL_INPUT_BUFFER_COMPLEX_SIGNATURE;
    if (TestEntry->Flags & STM_TEST_FLAG_SUB_IN_BUFFER)
    {
        InputBuffer->Size = InputBufferSize - TestEntry->Value;
    }
    else if (TestEntry->Flags & STM_TEST_FLAG_SET_IN_BUFFER)
    {
        InputBuffer->Size = TestEntry->Value;
    }
    else
    {
        InputBuffer->Size = InputBufferSize;
    }
 
    if (TestEntry->Flags & STM_TEST_FLAG_CHANGE_ARG_COUNT)
    {
        InputBuffer->ArgumentCount = TestEntry->Value;
    }
    else
    {
        InputBuffer->ArgumentCount = 3;
    }
 
    /* Argument 1: The channel timing information block */
    Argument = InputBuffer->Argument;
    ACPI_METHOD_SET_ARGUMENT_BUFFER(Argument, TimingMode, sizeof(*TimingMode));
 
    /* Argument 2: The ATA drive ID block */
    Argument2 = ACPI_METHOD_NEXT_ARGUMENT(Argument);
    ACPI_METHOD_SET_ARGUMENT_BUFFER(Argument2, IdBlock, STM_ID_BLOCK_SIZE);
 
    /* Argument 3: The ATA drive ID block */
    Argument3 = ACPI_METHOD_NEXT_ARGUMENT(Argument2);
    ACPI_METHOD_SET_ARGUMENT_BUFFER(Argument3, IdBlock, STM_ID_BLOCK_SIZE);
 
    if (TestEntry->Flags & STM_TEST_FLAG_BAD_ARG_TYPE)
    {
        Argument3->Type = 0xFFFF;
    }
 
    if (TestEntry->Flags & STM_TEST_FLAG_LARGE_ARG_BUFFER)
    {
        Argument2->DataLength = STM_ID_BLOCK_SIZE * 2;
        Argument3->DataLength = STM_ID_BLOCK_SIZE * 2;
    }
 
    if (TestEntry->Flags & STM_TEST_FLAG_INVALID_ARG_3_1)
    {
        ACPI_METHOD_SET_ARGUMENT_STRING(Argument3, IdBlock);
    }
    else if (TestEntry->Flags & STM_TEST_FLAG_INVALID_ARG_3_2)
    {
        ACPI_METHOD_SET_ARGUMENT_INTEGER(Argument3, 0xDEADBEEF);
    }
    else if (TestEntry->Flags & STM_TEST_FLAG_INVALID_ARG_3_4)
    {
        Argument3->DataLength += 5;
    }
    else if (TestEntry->Flags & STM_TEST_FLAG_INVALID_ARG_3_5)
    {
        Argument3->DataLength -= 5;
    }
 
    if (TestEntry->Flags & STM_TEST_FLAG_SUB_IRP_BUFFER)
    {
        IrpBufferSize = InputBufferSize - TestEntry->Value;
    }
    else if (TestEntry->Flags & STM_TEST_FLAG_SET_IRP_BUFFER)
    {
        IrpBufferSize = TestEntry->Value;
    }
    else
    {
        IrpBufferSize = InputBufferSize;
    }
 
    /* Evaluate the _STM method */
    DrvpEvalTestEntry = TestEntry;
    Status = DrvCallAcpiDriver(InputBuffer, IrpBufferSize, NULL, 0);
 
    todo_if(!is_reactos() && (TestEntry->Flags & STM_TEST_FLAG_IS_TODO))
        ok_eq_hex_ex(TestEntry, Status, TestEntry->Status);
}

Referenced by DrvTestComplexBuffer().

◆ DrvTestComplexBuffer()

static VOID DrvTestComplexBuffer ( VOID )

static

Definition at line 862 of file Bus_PDO_EvalMethod.c.

{
    IDE_ACPI_TIMING_MODE_BLOCK TimingMode;
    UCHAR IdBlock[STM_ID_BLOCK_SIZE];
    ULONG i;
    UCHAR Buffer[STM_MAX_BUFFER_SIZE];
    PACPI_EVAL_INPUT_BUFFER_COMPLEX InputBuffer = (PACPI_EVAL_INPUT_BUFFER_COMPLEX)Buffer;
 
    /* Initialize method arguments */
    RtlZeroMemory(IdBlock, sizeof(IdBlock));
    TimingMode.Drive[0].PioSpeed = 508;
    TimingMode.Drive[0].DmaSpeed = 120;
    TimingMode.Drive[1].PioSpeed = 240;
    TimingMode.Drive[1].DmaSpeed = 180;
    TimingMode.ModeFlags = 0x10;
 
    for (i = 0; i < RTL_NUMBER_OF(DrvpSmtTests); ++i)
    {
        DrvEvaluateStmObject(&DrvpSmtTests[i], &TimingMode, IdBlock, InputBuffer);
    }
}

Referenced by START_TEST().

◆ DrvTestInputBuffer()

static VOID DrvTestInputBuffer ( VOID )

static

Definition at line 978 of file Bus_PDO_EvalMethod.c.

{
    UCHAR Buffer[GTM_MAX_BUFFER_SIZE];
    ULONG i;
    PACPI_EVAL_OUTPUT_BUFFER OutputBuffer = (PACPI_EVAL_OUTPUT_BUFFER)Buffer;
 
    for (i = 0; i < RTL_NUMBER_OF(DrvpGtmTests); ++i)
    {
        RtlZeroMemory(Buffer, sizeof(Buffer));
 
        DrvEvaluateGtmObject(&DrvpGtmTests[i], OutputBuffer);
    }
}

Referenced by START_TEST().

◆ DrvTestNestedPackageReturnValue()

static VOID DrvTestNestedPackageReturnValue ( VOID )

static

Definition at line 1202 of file Bus_PDO_EvalMethod.c.

{
    UCHAR Buffer[0x100];
    ULONG i;
    PACPI_EVAL_OUTPUT_BUFFER OutputBuffer = (PACPI_EVAL_OUTPUT_BUFFER)Buffer;
 
    for (i = 0; i < RTL_NUMBER_OF(DrvpPclTests); ++i)
    {
        RtlZeroMemory(Buffer, sizeof(Buffer));
 
        DrvEvaluatePrtObject(&DrvpPrtTests[i], OutputBuffer);
    }
}

Referenced by START_TEST().

◆ DrvTestPackageInputValue()

static VOID DrvTestPackageInputValue ( VOID )

static

Definition at line 1318 of file Bus_PDO_EvalMethod.c.

{
    ULONG i;
 
    for (i = 0; i < RTL_NUMBER_OF(DrvpDsmTests); ++i)
    {
        DrvEvaluateDsmObject(&DrvpDsmTests[i]);
    }
}

Referenced by START_TEST().

◆ DrvTestPackageReturnValueAndStringData()

static VOID DrvTestPackageReturnValueAndStringData ( VOID )

static

Definition at line 1065 of file Bus_PDO_EvalMethod.c.

{
    UCHAR Buffer[0x100];
    ULONG i;
    PACPI_EVAL_OUTPUT_BUFFER OutputBuffer = (PACPI_EVAL_OUTPUT_BUFFER)Buffer;
 
    for (i = 0; i < RTL_NUMBER_OF(DrvpBifTests); ++i)
    {
        RtlZeroMemory(Buffer, sizeof(Buffer));
 
        DrvEvaluateBifObject(&DrvpBifTests[i], OutputBuffer);
    }
}

Referenced by START_TEST().

◆ DrvTestReferenceReturnValue()

static VOID DrvTestReferenceReturnValue ( VOID )

static

Definition at line 1113 of file Bus_PDO_EvalMethod.c.

{
    UCHAR Buffer[0x100];
    ULONG i;
    PACPI_EVAL_OUTPUT_BUFFER OutputBuffer = (PACPI_EVAL_OUTPUT_BUFFER)Buffer;
 
    for (i = 0; i < RTL_NUMBER_OF(DrvpPclTests); ++i)
    {
        RtlZeroMemory(Buffer, sizeof(Buffer));
 
        DrvEvaluatePclObject(&DrvpPclTests[i], OutputBuffer);
    }
}

Referenced by START_TEST().

◆ DrvTestUnknownMethod()

static VOID DrvTestUnknownMethod ( VOID )

static

Definition at line 1330 of file Bus_PDO_EvalMethod.c.

{
    NTSTATUS Status;
    ACPI_EVAL_INPUT_BUFFER InputBuffer;
 
    InputBuffer.MethodNameAsUlong = 'FFF_'; // _FFF
    InputBuffer.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
 
    /* Try to evaluate some unsupported control method */
    Status = DrvCallAcpiDriver(&InputBuffer, sizeof(InputBuffer), NULL, 0);
 
    ok_eq_hex(Status, STATUS_OBJECT_NAME_NOT_FOUND);
}

Referenced by START_TEST().

◆ ExAllocatePoolWithTag()

static PVOID ExAllocatePoolWithTag	(	ULONG	PoolType,
		SIZE_T	NumberOfBytes,
		ULONG	Tag
	)

static

Definition at line 124 of file Bus_PDO_EvalMethod.c.

{
    PULONG_PTR Mem;
 
    Mem = HeapAlloc(GetProcessHeap(), 0, NumberOfBytes + 2 * sizeof(PVOID));
    Mem[0] = NumberOfBytes;
    Mem[1] = Tag;
 
    ++DrvpBlocksAllocated;
 
    return (PVOID)(Mem + 2);
}

◆ ExFreePoolWithTag()

static VOID ExFreePoolWithTag	(	PVOID	MemPtr,
		ULONG	Tag
	)

static

Definition at line 139 of file Bus_PDO_EvalMethod.c.

{
    PULONG_PTR Mem = MemPtr;
 
    Mem -= 2;
    ok(Mem[1] == Tag, "Tag is %lx, expected %lx\n", Tag, Mem[1]);
    HeapFree(GetProcessHeap(), 0, Mem);
 
    --DrvpBlocksAllocated;
}

◆ IoGetCurrentIrpStackLocation()

static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation ( PIRP Irp )

static

Definition at line 152 of file Bus_PDO_EvalMethod.c.

{
    return &Irp->MyStack;
}

◆ START_TEST()

START_TEST ( Bus_PDO_EvalMethod )

Definition at line 1344 of file Bus_PDO_EvalMethod.c.

{
    DrvTestComplexBuffer();
    DrvTestInputBuffer();
    DrvTestPackageReturnValueAndStringData();
    DrvTestReferenceReturnValue();
    DrvTestNestedPackageReturnValue();
    DrvTestPackageInputValue();
    DrvTestUnknownMethod();
 
    ok(DrvpBlocksAllocated == 0, "Leaking memory %ld blocks\n", DrvpBlocksAllocated);
}

Variable Documentation

◆ DrvpBifIntegerFields

const ULONG DrvpBifIntegerFields[9]

static

Initial value:

=
{
    0, 50000, 50000, 1, 10000, 100, 50, 1, 1
}

Definition at line 217 of file Bus_PDO_EvalMethod.c.

Referenced by AcpiEvaluateObject(), and DrvEvaluateBifObject().

◆ DrvpBifTests

const EVAL_TEST_ENTRY DrvpBifTests[]

static

Initial value:

=
{
    { __LINE__, 0, STATUS_SUCCESS },
}

Definition at line 706 of file Bus_PDO_EvalMethod.c.

Referenced by DrvTestPackageReturnValueAndStringData().

◆ DrvpBlocksAllocated

LONG DrvpBlocksAllocated = 0

static

Definition at line 118 of file Bus_PDO_EvalMethod.c.

Referenced by ExAllocatePoolWithTag(), ExFreePoolWithTag(), and START_TEST().

◆ DrvpDsmTests

const EVAL_TEST_ENTRY DrvpDsmTests[]

static

Initial value:

=
{
    { __LINE__, 0, STATUS_SUCCESS },
    { __LINE__, DSM_TEST_FLAG_EMPTY_PACKAGE, STATUS_SUCCESS },
    { __LINE__, DSM_TEST_FLAG_LARGE_SUB_PACKAGE_BUFFER, STATUS_ACPI_INVALID_ARGTYPE },
}

Definition at line 721 of file Bus_PDO_EvalMethod.c.

Referenced by DrvTestPackageInputValue().

◆ DrvpEvalTestEntry

const EVAL_TEST_ENTRY* DrvpEvalTestEntry

static

Definition at line 227 of file Bus_PDO_EvalMethod.c.

Referenced by AcpiEvaluateObject(), DrvEvaluateDsmObject(), and DrvEvaluateStmObject().

◆ DrvpGtmTests

const EVAL_TEST_ENTRY DrvpGtmTests[]

static

Definition at line 664 of file Bus_PDO_EvalMethod.c.

Referenced by DrvTestInputBuffer().

◆ DrvpMyDsmIntegerFields

const ULONG DrvpMyDsmIntegerFields[3]

static

Initial value:

=
{
    0xAAAAAAAA, 0xBBBBBBBB, 0xDDDDDDDD
}

Definition at line 222 of file Bus_PDO_EvalMethod.c.

Referenced by AcpiEvaluateObject(), and DrvEvaluateDsmObject().

◆ DrvpPclTests

const EVAL_TEST_ENTRY DrvpPclTests[]

static

Initial value:

=
{
    { __LINE__, 0, STATUS_SUCCESS },
}

Definition at line 711 of file Bus_PDO_EvalMethod.c.

Referenced by DrvTestNestedPackageReturnValue(), and DrvTestReferenceReturnValue().

◆ DrvpPrtTests

const EVAL_TEST_ENTRY DrvpPrtTests[]

static

Initial value:

=
{
    { __LINE__, 0, STATUS_SUCCESS },
}

Definition at line 716 of file Bus_PDO_EvalMethod.c.

Referenced by DrvTestNestedPackageReturnValue().

◆ DrvpSmtTests

const EVAL_TEST_ENTRY DrvpSmtTests[]

static

Definition at line 620 of file Bus_PDO_EvalMethod.c.

Referenced by DrvTestComplexBuffer().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ CODE_SEG

◆ DPRINT

◆ DPRINT1

◆ DSM_TEST_FLAG_EMPTY_PACKAGE

◆ DSM_TEST_FLAG_LARGE_SUB_PACKAGE_BUFFER

◆ ExAllocatePoolUninitialized

◆ FAKE_INTB_ACPI_HANDLE

◆ FAKE_INTC_ACPI_HANDLE

◆ FAKE_SB_NAMESPACE_ACPI_HANDLE

◆ GTM_MAX_BUFFER_SIZE

◆ GTM_TEST_FLAG_ARG_HAS_BUFFER_TYPE

◆ GTM_TEST_FLAG_ARG_HAS_DATA_LENGTH

◆ GTM_TEST_FLAG_BAD_SIGNARUTE

◆ GTM_TEST_FLAG_BUFFER_HAS_COUNT

◆ GTM_TEST_FLAG_BUFFER_HAS_LENGTH

◆ GTM_TEST_FLAG_BUFFER_HAS_SIGNARUTE

◆ GTM_TEST_FLAG_DEC_OUT_BUFFER

◆ GTM_TEST_FLAG_INC_OUT_BUFFER

◆ GTM_TEST_FLAG_IS_TODO

◆ GTM_TEST_FLAG_METHOD_SUCCESS

◆ GTM_TEST_FLAG_SET_OUT_BUFFER

◆ MY_DSM_BUFFER_SIZE

◆ MY_DSM_PACKAGE_ENTRY_SIZE

◆ MY_DSM_SUB_PACKAGE_ENTRY_SIZE

◆ NonPagedPool

◆ ok_eq_hex_ex

◆ ok_eq_int_ex

◆ ok_eq_pointer_ex

◆ ok_eq_print_ex

◆ ok_eq_str_ex

◆ ok_eq_uint_ex

◆ ok_eq_ulong_ex

◆ ok_eq_ulonglong_ex

◆ ok_not_pointer_ex

◆ ok_not_print_ex

◆ PAGED_CODE

◆ PRT_PACKAGE_ENTRY_SIZE

◆ STM_ID_BLOCK_SIZE

◆ STM_MAX_BUFFER_SIZE

◆ STM_TEST_FLAG_BAD_ARG_TYPE

◆ STM_TEST_FLAG_CHANGE_ARG_COUNT

◆ STM_TEST_FLAG_INVALID_ARG_3_1

◆ STM_TEST_FLAG_INVALID_ARG_3_2

◆ STM_TEST_FLAG_INVALID_ARG_3_4

◆ STM_TEST_FLAG_INVALID_ARG_3_5

◆ STM_TEST_FLAG_INVALID_SIZE_1

◆ STM_TEST_FLAG_IS_TODO

◆ STM_TEST_FLAG_LARGE_ARG_BUFFER

◆ STM_TEST_FLAG_SET_IN_BUFFER

◆ STM_TEST_FLAG_SET_IRP_BUFFER

◆ STM_TEST_FLAG_SUB_IN_BUFFER

◆ STM_TEST_FLAG_SUB_IRP_BUFFER

◆ UNIT_TEST

◆ WIN32_NO_STATUS

Typedef Documentation

◆ BIF_OBJECT_BUFFER

◆ EVAL_TEST_ENTRY

◆ GTM_OBJECT_BUFFER

◆ IDE_ACPI_TIMING_MODE_BLOCK

◆ IO_STACK_LOCATION

◆ IRP

◆ PBIF_OBJECT_BUFFER

◆ PCL_OBJECT_BUFFER

◆ PDO_DEVICE_DATA

◆ PGTM_OBJECT_BUFFER

◆ PIDE_ACPI_TIMING_MODE_BLOCK

◆ PIO_STACK_LOCATION

◆ PIRP

◆ PPCL_OBJECT_BUFFER

◆ PPDO_DEVICE_DATA

◆ PPRT_OBJECT_BUFFER

◆ PRT_OBJECT_BUFFER

Function Documentation

◆ AcpiEvaluateObject()