commit f1674c21a34812806b5a0d873b143b5e54eb88cd Author: Ryan Malloy Date: Wed Feb 11 04:22:13 2026 -0700 Initial commit: Genpix SkyWalker-1 DVB-S driver source and DiSEqC docs Includes original BDA driver source (headers, C++ implementation, INF installer files), DiSEqC implementation PDF with extracted markdown and SVG vector graphics. diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..bac1a7a --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +# Empty extraction directories +docs/diseqc/images/ diff --git a/docs/diseqc/DiSEqC for the Skywalker-1.pdf b/docs/diseqc/DiSEqC for the Skywalker-1.pdf new file mode 100644 index 0000000..575bcc0 Binary files /dev/null and b/docs/diseqc/DiSEqC for the Skywalker-1.pdf differ diff --git a/docs/diseqc/diseqc-skywalker-1.md b/docs/diseqc/diseqc-skywalker-1.md new file mode 100644 index 0000000..9bb74c1 --- /dev/null +++ b/docs/diseqc/diseqc-skywalker-1.md @@ -0,0 +1,79 @@ +# DiSEqC for the GenPix Skywalker-1 BDA Driver (Extended) + +**Implementation Guidelines for Applications** + +*Author: Devendra | Created: 2009-07-09 | Source: Microsoft Office Word 2007* + +--- + +## I. GUID for the SkyWalker1 Extended property + +```c +//Used to extend the feature of the BDA +//{0B5221EB-F4C4-4976-B959-EF74427464D9} +#define STATIC_KSPROPSETID_BdaExtendedProperty \ + 0x0B5221EB, 0xF4C4, 0x4976, 0xB9, 0x59, 0xEF, 0x74, 0x42, 0x74, 0x64, 0xD9 + +DEFINE_GUIDSTRUCT("0B5221EB-F4C4-4976-B959-EF74427464D9", KSPROPSETID_BdaExtendedProperty); +#define KSPROPSETID_BdaExtendedProperty DEFINE_GUIDNAMED(KSPROPSETID_BdaExtendedProperty) +``` + +## II. Extended Property List (Only DiSEqC support is extended) + +```c +//Extended Property List +typedef enum __KSPROPERTY_EXTENDED +{ + /* DiSEqC Command */ + //Used to send the Digital Satellite Equipment Control (DiSEqC) + //Commands by application + KSPROPERTY_BDA_DISEQC = 0, //Extension Property 1 +} KSPROPERTY_EXTENDED; +``` + +## III. Enumeration for the Simple Tone Burst + +```c +typedef enum enSimpleToneBurst +{ + SEC_MINI_A, + SEC_MINI_B +} SIMPLE_TONE_BURST; +``` + +## IV. DiSEqC Command Structure + +```c +typedef struct __DISEQC_COMMAND +{ + UCHAR ucMessage[MAX_DISEQC_COMMAND_LENGTH]; + /* Byte - 0 : Framing, + Byte - 1 : Address, + Byte - 2 : Command, + Byte - 3 : Data[0], + Byte - 4 : Data[1], + Byte - 5 : Data[2] */ + + UCHAR ucMessageLength; + /* The Valid values for DiSEqC Command are 3...6 + If this value is 1 then Byte 0 is taken as Simple "Tone Burst" + Control Command */ +} DISEQC_COMMAND, *PDISEQC_COMMAND; +``` + +## V. Operation + +### i. To send the Simple Burst command + +1. Create the `DISEQC_COMMAND` Structure +2. Set `ucMessage[0]` to either `SEC_MINI_A` or `SEC_MINI_B` +3. Set `ucMessageLength` as `1` + +### ii. To send DiSEqC commands + +1. Create the `DISEQC_COMMAND` Structure +2. Set the Framing value to `ucMessage[0]` (e.g. `0xE0`) +3. Set the Device Address to `ucMessage[1]` (e.g. `0x01`) +4. Send the Command for the Device to `ucMessage[2]` +5. If required, set the Data bytes `ucMessage[3]`, `ucMessage[4]`, `ucMessage[5]` +6. Set `ucMessageLength` accordingly. Valid values are 3 to 6. diff --git a/docs/diseqc/vectors/DiSEqC for the Skywalker-1_page_1.svg b/docs/diseqc/vectors/DiSEqC for the Skywalker-1_page_1.svg new file mode 100644 index 0000000..142a674 --- /dev/null +++ b/docs/diseqc/vectors/DiSEqC for the Skywalker-1_page_1.svg @@ -0,0 +1,323 @@ + + + + + + + + + + + + + + + + + + + +DiSEqC for SkyWalker +- +1 + + + + + + + + + + + + + + + + + + +1 + + + + + + +DiSEqC +for the GenPix Skywalker +- +1 BDA Driver + +(Extended) + + +Implementation Guidelines + +for Applications + + +I. + +GUID for the SkyWalker1 +Extended + +property + + +//Used to extend the feature of the BDA + +//{0B5221EB +- +F4C4 +- +4976 +- +B959 +- +EF74427464D9} + +#define + +STATIC_KSPROPSETID_BdaExtendedProperty +\ + + +0x0B5221EB, 0xF4C4, 0x4976, 0xB9, 0x59, 0xEF, 0x74, 0x42, 0x74, 0x64, 0xD9 + +DEFINE_GUIDSTRUCT( +"0B5221EB +- +F4C4 +- +4976 +- +B959 +- +EF74427464D9" +, KSPROPSETID_BdaExtendedProperty); + +#define + +KSPROPSETID_BdaExtendedProperty DEFINE_GUIDNAMED(KSPROPSETID_BdaExtendedProperty) + + +II. + +Extended Prope +rty List + +(Only DiSEqC +support is extended +) + + +//Extended Property List + +typedef + +enum + +__KSPROPERTY_EXTENDED + +{ + +/* DiSEqC Co +mmand */ + +//Used to send the Digital Sattelite Equipment Control (DiSEqC) + +//Commands by application + +KSPROPERTY_BDA_DISEQC = 0, +//Extension Property 1 + +}KSPROPERTY_EXTENDED; + +III. + +Enumeration for the Simple Tone Burst + + +typedef + +enum + +enSimpleToneBurst + +{ + +SEC_MINI_A, + +SEC_MINI_B + +}SIMPLE_TONE_BURST; + +IV. + +DiSEqC Command Structure + + +typedef + +struct + +__DISEQC_COMMAND + +{ + + +UCHAR ucMessage[MAX_DISEQC_COMMAND_LENGTH]; + +/* +Byte +- + +0 : Framing, + + + + + + + + +Byte +- + +1 : Address, + + + + + + + + +Byte +- + +2 : Command, + + + + + + + + +Byte +- + +3 : Data[0], + + + + + + + + +Byte +- + +4 : Data[1], + + + + + + + + +Byte +- + +5 : Data[2] + + + + + + + + +*/ + + +UCHAR ucMessageLength; +/* The Valid values for DiSEqC Command are 3...6 + +If this value is 1 then the Byte 0 is taken as Simple "Tone Burst" +Control + +Command */ + + +}DISEQC_COMMAND,*PDISEQC_COMMAND; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/diseqc/vectors/DiSEqC for the Skywalker-1_page_2.svg b/docs/diseqc/vectors/DiSEqC for the Skywalker-1_page_2.svg new file mode 100644 index 0000000..62544f2 --- /dev/null +++ b/docs/diseqc/vectors/DiSEqC for the Skywalker-1_page_2.svg @@ -0,0 +1,186 @@ + + + + + + + + + + + + + + + + + + + +DiSEqC for SkyWalker +- +1 + + + + + + + + + + + + + + + + + + +2 + + + + + +V. + +Operation: + + +I. + +To send +the +Simple burst comman +d + +a. + +Create the DISEQC_COMMAND Structure + +b. + +Set the ucMessage[0] to either SEC_MINI_A or SEC_MINI_B + +c. + +Set the ucMessageLength as 1 + + +II. + +To send +the DiSEqC +comman +d +s + +a. + +Create the DISEQC_COMMAND Structure + +b. + +Set the +Framing value to +ucMessage[0] +e.g. E0 + +c. + +Set the +Device +Address +to ucMessage[1] e.g. 01 + +d. + +Send the Command for the Device +to ucMessage[2] + +e. + +I +f +require set the Data bytes ucMessage[3], + +ucMessage[ +4 +] +, + +ucMessage[ +5 +] + +f. + +Set the ucMessageLength accordingly.Valid ucMessageLength values are 3 to 6. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/firmware-driver/SkyWalker1_Final_Release/DiSEqC for the Skywalker-1.pdf b/firmware-driver/SkyWalker1_Final_Release/DiSEqC for the Skywalker-1.pdf new file mode 100644 index 0000000..575bcc0 Binary files /dev/null and b/firmware-driver/SkyWalker1_Final_Release/DiSEqC for the Skywalker-1.pdf differ diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1AntennaPin.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1AntennaPin.h new file mode 100644 index 0000000..fa36639 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1AntennaPin.h @@ -0,0 +1,102 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1AntennaPin.h + Author : + Date : + Purpose : This File Holds the Antenna Pin related declarations + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef __SKYWALKER1_ANTENNA_PIN_H +#define __SKYWALKER1_ANTENNA_PIN_H + +/* Include the Library and Other header file */ +#include "SkyWalker1TunerPin.h" +#include "SkyWalker1Extended.h" //For the Extended BDA +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Global & Static variables Declaration */ + +//Antenna Pin class. +class CAntennaPin : public CTunerPin +{ +public: + + static NTSTATUS PinSetDeviceState( + IN PKSPIN Pin, + IN KSSTATE ToState, + IN KSSTATE FromState + ); + + static NTSTATUS IntersectDataFormat( + IN PVOID pContext, + IN PIRP pIoRequestPacket, + IN PKSP_PIN Pin, + IN PKSDATARANGE DataRange, + IN PKSDATARANGE MatchingDataRange, + IN ULONG DataBufferSize, + OUT PVOID Data OPTIONAL, + OUT PULONG DataSize + ); + + //Network provider and AVStream use these functions + //to set and get properties of nodes that are controlled + //by the input pin. + + static NTSTATUS GetTunerProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ); + + static NTSTATUS SetTunerProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ); + + + + //Network provider and AVStream use these functions + //to set and get properties of nodes that are controlled + //by the input pin. + static NTSTATUS GetTunerLnbProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ); + + static NTSTATUS SetTunerLnbProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ); + +private: + + KSSTATE m_KsState; +}; + + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif /*__SKYWALKER1_TRANSPORT_PIN_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CaptureFilter.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CaptureFilter.h new file mode 100644 index 0000000..bbe9723 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CaptureFilter.h @@ -0,0 +1,72 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1CaptureFilter.h + Author : + Date : + Purpose : This file contains the filter level header for + the capture filter. + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef SKYWALKER1_CAPTURE_FILTER_H +#define SKYWALKER1_CAPTURE_FILTER_H + +/* Include the Library and Other header file */ +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Global & Static variables Declaration */ + +//The Capture filter class. +class CCaptureFilter +{ +public: + + //The capture filter object constructor. Since the new operator will + //have zeroed the memory, do not bother initializing any NULL or 0 + //fields. Only initialize non-NULL, non-0 fields. + CCaptureFilter (IN PKSFILTER Filter); + + //The capture filter destructor. + ~CCaptureFilter (); + + //This is the filter creation dispatch for the capture filter. It + //creates the CCaptureFilter object, associates it with the AVStream + //object, and bags it for easy cleanup later. + static NTSTATUS Create( IN OUT PKSFILTER pKSFilter, + IN PIRP pIoRequestPacket); + + +private: + + //The AVStream filter object associated with this CCaptureFilter. + PKSFILTER m_Filter; + + //This is the bag cleanup callback for the CCaptureFilter. Not providing + //one would cause ExFreePool to be used. This is not good for C++ + //constructed objects. We simply delete the object here. + static void Cleanup ( IN CCaptureFilter *CapFilter ); + +}; + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif /*SKYWALKER1_CAPTURE_FILTER_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CapturePin.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CapturePin.h new file mode 100644 index 0000000..28d06f5 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CapturePin.h @@ -0,0 +1,161 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1CapturePin.h + Author : + Date : + Purpose : This file contains header for the video capture pin on the capture + filter. + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +/* Include the Library and Other header file */ +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Global & Static variables Declaration */ + +//This Structure can be used in future for the +//better stream management +typedef struct _STREAM_POINTER_CONTEXT +{ + ULONG ulFrameIndex; + +} STREAM_POINTER_CONTEXT, *PSTREAM_POINTER_CONTEXT; + + +//The video capture pin class. +class CCapturePin : public ICaptureSink +{ + +private: + + //The AVStream pin we're associated with. + PKSPIN m_Pin; + + //Pointer to the internal device object for our capture device. + //We access the Device through this object. + CSkyWalker1Device *m_Device; + + //The state we've put the hardware into. This allows us to keep track + //of whether to do things like unpausing or restarting. + HARDWARE_STATE m_HardwareState; + + //The clock we've been assigned. As with other capture filters, we do + //not expose a clock. If one has been assigned, we will use it to + //time stamp packets (plus a reasonable delta to work the capture stream + //in a preview graph). + PIKSREFERENCECLOCK m_Clock; + + //The transport information for this capture pin. The settings for device will be + //programmed for this transport info. + PBDA_TRANSPORT_INFO m_TransportInfo; + + //This Variable is used to keep the count of the Streams sent for the + //Data read + ULONG m_CurrentFrameIndex; + + //An indication of whether or not this pin has acquired the necessary + //hardware resources to operate. When the pin reaches KSSTATE_ACQUIRE, + //we attempt to acquire the hardware. This flag will be set based on + //our success / failure. + BOOLEAN m_AcquiredResources; + + //Clean up any references we hold on frames in the queue. This is called + //when we abruptly stop the fake hardware. + NTSTATUS CleanupReferences (); + + //This is the state transition handler for the capture pin. It attempts + //to acquire resources for the capture pin (or releasing them if + //necessary) and starts and stops the hardware as required. + NTSTATUS SetState ( IN KSSTATE ToState,IN KSSTATE FromState); + + //This is the processing dispatch for the capture pin. It handles + //sending the Streams to the Device. + NTSTATUS Process(); + + //This routine is not required as the Transport Information is already + //provided into the CCapturePin but still using it to make the + //settings flexible + PBDA_TRANSPORT_INFO CaptureBdaTransportInfo (); + + //This is the free callback from the bagged item (CCapturePin). If we + //do not provide a callback when we bag the CCapturePin, ExFreePool + //would be called. This is not desirable for C++ constructed objects. + //We merely delete the object here. + static void Cleanup (IN CCapturePin *Pin) + { + delete Pin; + } + +public: + + + //The capture pin's constructor. Initialize any non-0, non-NULL fields + //(since new will have zero'ed the memory anyway) and set up our + //device level pointers for access during capture routines. + CCapturePin (IN PKSPIN Pin); + + //The capture pin's destructor. + ~CCapturePin (); + + CSkyWalker1Device* GetDevice() + { + return m_Device; + } + + //This is the capture sink notification mechanism for mapping completion. + //When the device DPC detects that a given number of mappings have been + //completed by the fake hardware, it signals the capture sink of this + //through this method. + virtual void ReleaseStream(IN ULONG ulStreamIndex); + + //This is the creation dispatch for the capture pin. It creates + //the CCapturePin object and associates it with the AVStream object + //bagging it in the process. + static NTSTATUS PinCreate( IN OUT PKSPIN pKSPin, + IN PIRP pIoRequestPacket + ); + + //This is the set device state dispatch for the pin. The routine bridges + //to SetState() in the context of the CCapturePin. + static NTSTATUS DispatchSetState ( + IN PKSPIN Pin, + IN KSSTATE ToState, + IN KSSTATE FromState + ) + { + return + (reinterpret_cast(Pin->Context))-> + SetState(ToState, FromState); + } + + //This is the processing dispatch for the capture pin. The routine + //bridges to Process() in the context of the CCapturePin. + static NTSTATUS DispatchProcess (IN PKSPIN Pin) + { + return + (reinterpret_cast(Pin->Context))->Process(); + } +}; + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + + diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CommonDef.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CommonDef.h new file mode 100644 index 0000000..bf9ec7d --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1CommonDef.h @@ -0,0 +1,149 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1CommonDef.h + Author : + Date : + Purpose : File to hold the common definitions for the Driver + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +#ifndef __SKYWALKER1_COMMON_DEF_H +#define __SKYWALKER1_COMMON_DEF_H + +/* Include the Library and Other header file */ +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +#define TUNER_MEM_TAG 'MNUT' +#define CAPTURE_MEM_TAG 'MPAC' + +// Implementation GUID for SkyWalker1 Tuner and Capture +// Must match the KSSTRING used in the installation INFs interface sections +//Tuner Filter GUID {5C4E764F-AB43-46A9-B21E-8529C70F0A23} +#define GUID_SKYWALKER_TUNER_FILTER\ + 0x5C4E764F, 0xAB43, 0x46A9, 0xB2, 0x1E, 0x85, 0x29, 0xC7, 0x0F, 0x0A, 0x23 +DEFINE_GUIDSTRUCT("5C4E764F-AB43-46A9-B21E-8529C70F0A23", SKYWALKER_TUNER_FILTER); +#define SKYWALKER_TUNER_FILTER DEFINE_GUIDNAMED(SKYWALKER_TUNER_FILTER) + +//Capture Filter GUID {0F8F74D9-E524-4D05-BB60-F0C69ACB1756} +#define GUID_SKYWALKER_CAPTURE_FILTER\ + 0x0F8F74D9, 0xE524, 0x4D05, 0xBB, 0x60, 0xF0, 0xC6, 0x9A, 0xCB, 0x17, 0x56 +DEFINE_GUIDSTRUCT("0F8F74D9-E524-4D05-BB60-F0C69ACB1756", SKYWALKER_CAPTURE_FILTER); +// Defines the SKYWALKER_CAPTURE_FILTER as a GUID. +#define SKYWALKER_CAPTURE_FILTER DEFINE_GUIDNAMED(SKYWALKER_CAPTURE_FILTER) + +//Medium GUID {2AEB4A94-FBB7-4FB1-8D74-243B91886EAB} +#define GUID_SKYWALKER_TUNER_OUT_MEDIUM\ + 0x2AEB4A94, 0xFBB7, 0x4FB1, 0x8D, 0x74, 0x24, 0x3B, 0x91, 0x88, 0x6E, 0xAB +DEFINE_GUIDSTRUCT("2AEB4A94-FBB7-4FB1-8D74-243B91886EAB", SKYWALKER_TUNER_OUT_MEDIUM); +// Defines the SKYWALKER_TUNER_OUT_MEDIUM as a GUID. +#define SKYWALKER_TUNER_OUT_MEDIUM DEFINE_GUIDNAMED(SKYWALKER_TUNER_OUT_MEDIUM) + +#define TRANSPORT_PACKET_SIZE 128 //188 +#define TRANSPORT_PACKET_COUNT 64 //512 +#define NUMBER_OF_FRAMES 8 +#define PACKET_PER_FRAME 2 + +#define SYMBOL_RATE_MIN 1000 +#define SYMBOL_RATE_MAX 45000 + +#define TUNER_FREQ_MIN 800000 +#define TUNER_FREQ_MAX 2250000 + +#define IS_VALID(X) (((X)!=NULL)?true:false) + +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ + +// Structure for the Tuner Parameters + +typedef struct _BDATUNER_DEVICE_PARAMETER +{ + //Tuner Properties + ULONG ulCarrierFrequency; + ULONG ulFrequencyMultiplier; + ULONG ulBandWidth; + Polarisation Polarity; + ULONG ulRange; + ULONG ulTransponder; + + //LNB Parameters + ULONG ulLnbLowLOFrequency; + ULONG ulLnbHighLOFrequency; + ULONG ulLnbSwitchFrequency; + + //Demodulator Properties + ULONG ulInnerFecType; + BinaryConvolutionCodeRate InnerFecRate; + ULONG ulOuterFecType; + BinaryConvolutionCodeRate OuterFecRate; + ModulationType CurrentModulationType; + TransmissionMode CurrentTransmissionMode; + GuardInterval CurrentGuardInterval; + SpectralInversion CurrentSpectralInversion; + ULONG ulSymbolRate; + +} BDATUNER_DEVICE_PARAMETER, * PBDATUNER_DEVICE_PARAMETER; + + +// Define a structure that represents the underlying device status. +// +typedef struct _BDATUNER_DEVICE_STATUS +{ + //Tuner Status + DWORD dwSignalStrength; + DWORD dwSignalQuality; + BOOLEAN fCarrierPresent; + + //Demodulator Status + BOOLEAN fSignalLocked; +} BDATUNER_DEVICE_STATUS, * PBDATUNER_DEVICE_STATUS; + +// ICaptureSink: +// +// This is a capture sink interface. The device level calls back the +// CompleteMappings method passing the number of completed mappings for +// the capture pin. This method is called during the device DPC. + +class ICaptureSink +{ +public: + + virtual void ReleaseStream (IN ULONG ulStreamIndex) = 0; +}; + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +extern const BDA_FILTER_TEMPLATE TunerFilterTemplate; +extern const BDA_FILTER_TEMPLATE SkyWalker1CaptureTemplate; +extern const KSFILTER_DESCRIPTOR SkyWalker1TunerFilterDescriptor; +extern const KSFILTER_DESCRIPTOR SkyWalker1CaptureFilterDescriptor; + +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +typedef enum _HARDWARE_STATE { + + HardwareStopped = 0, + HardwarePaused, + HardwareRunning + +} HARDWARE_STATE, *PHARDWARE_STATE; + +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif // __SKYWALKER1_COMMON_DEF_H + + + diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Control.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Control.h new file mode 100644 index 0000000..d1f9093 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Control.h @@ -0,0 +1,127 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Control.cpp + Author : + Date : + Purpose : This File Holds the Device Control related declarations + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef __SKYWALKER1_CONTROL_H +#define __SKYWALKER1_CONTROL_H + +/* Include the Library and Other header file */ +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ + +/* gp8psk commands */ + +/* Twinhan Vendor requests */ +#define TH_COMMAND_IN 0xC0 +#define TH_COMMAND_OUT 0xC1 + +/* gp8psk commands */ + +#define GET_8PSK_CONFIG 0x80 /* in */ +#define SET_8PSK_CONFIG 0x81 +#define I2C_WRITE 0x83 +#define I2C_READ 0x84 +#define ARM_TRANSFER 0x85 +#define TUNE_8PSK 0x86 +#define GET_SIGNAL_STRENGTH 0x87 /* in */ +#define LOAD_BCM4500 0x88 +#define BOOT_8PSK 0x89 /* in */ +#define START_INTERSIL 0x8A /* in */ +#define SET_LNB_VOLTAGE 0x8B +#define SET_22KHZ_TONE 0x8C +#define SEND_DISEQC_COMMAND 0x8D +#define SET_DVB_MODE 0x8E +#define SET_DN_SWITCH 0x8F +#define GET_SIGNAL_LOCK 0x90 /* in */ +#define GET_SERIAL_NUMBER 0x93 /* in */ +#define USE_EXTRA_VOLT 0x94 +#define CW3K_INIT 0x9d + +/* PSK_configuration bits */ +#define bm8pskStarted 0x01 +#define bm8pskFW_Loaded 0x02 +#define bmIntersilOn 0x04 +#define bmDVBmode 0x08 +#define bm22kHz 0x10 +#define bmSEL18V 0x20 +#define bmDCtuned 0x40 +#define bmArmed 0x80 + +/* Satellite modulation modes */ +#define ADV_MOD_DVB_QPSK 0 /* DVB-S QPSK */ +#define ADV_MOD_TURBO_QPSK 1 /* Turbo QPSK */ +#define ADV_MOD_TURBO_8PSK 2 /* Turbo 8PSK (also used for Trellis 8PSK) */ +#define ADV_MOD_TURBO_16QAM 3 /* Turbo 16QAM (also used for Trellis 8PSK) */ + +#define ADV_MOD_DCII_C_QPSK 4 /* Digicipher II Combo */ +#define ADV_MOD_DCII_I_QPSK 5 /* Digicipher II I-stream */ +#define ADV_MOD_DCII_Q_QPSK 6 /* Digicipher II Q-stream */ +#define ADV_MOD_DCII_C_OQPSK 7 /* Digicipher II offset QPSK */ +#define ADV_MOD_DSS_QPSK 8 /* DSS (DIRECTV) QPSK */ +#define ADV_MOD_DVB_BPSK 9 /* DVB-S BPSK */ + +#define GET_USB_SPEED 0x07 +#define USB_SPEED_LOW 0 +#define USB_SPEED_FULL 1 +#define USB_SPEED_HIGH 2 + +#define RESET_FX2 0x13 + +#define FW_VERSION_READ 0x0B +#define VENDOR_STRING_READ 0x0C +#define PRODUCT_STRING_READ 0x0D +#define FW_BCD_VERSION_READ 0x14 + +#define SEC_VOLTAGE_13 0 +#define SEC_VOLTAGE_18 1 + +#define SEC_TONE_ON 0 +#define SEC_TONE_OFF 1 + +#define SWITCH_ON_TUNER 1 +#define SWITCH_OFF_TUNER 0 +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +NTSTATUS GetSignalStatus( IN PKSDEVICE pKSDeviceObject, + OUT PBOOLEAN pbSignalLockStatus + ); +NTSTATUS ReadTunerSignalStrength( IN PKSDEVICE pKSDeviceObject, + OUT PULONG pulSigStrength + ); +NTSTATUS SetLnbVoltage(IN PKSDEVICE pKSDeviceObject, + IN UCHAR ucVoltage); +NTSTATUS TuneDevice(IN PKSDEVICE pKSDeviceObject, + IN PBDATUNER_DEVICE_PARAMETER pDeviceParameter); +NTSTATUS SetupTunerPower( IN PKSDEVICE pKSDeviceObject, + IN BOOLEAN bOnOff); +NTSTATUS SetStreamingControl( IN PKSDEVICE pKSDeviceObject, + IN UCHAR ucOnOff); +NTSTATUS SetTunerTone( IN PKSDEVICE pKSDeviceObject, + IN UCHAR ucTone); +NTSTATUS ConfigureTuner(IN PKSDEVICE pKSDeviceObject, + IN PBDATUNER_DEVICE_PARAMETER pNewConfiguration); +NTSTATUS DiseqcCommand( IN PKSDEVICE pKSDeviceObject, + IN PDISEQC_COMMAND pCommand); +/* End of Function prototype definitions */ + +#endif /*__SKYWALKER1_CONTROL_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Device.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Device.h new file mode 100644 index 0000000..e53f9f7 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Device.h @@ -0,0 +1,187 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Device.h + Author : + Date : + Purpose : Main Skywalker Device level Implementation + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + 01 Initial Version + +*****************************************************************************/ + +#ifndef SKYWALKER1_TUNER_DEVICE_H +#define SKYWALKER1_TUNER_DEVICE_H + +/* Include the Library and Other header file */ +#include "SkyWalker1USB.h" +#include "SkyWalker1Extended.h" +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ + +//The SkyWalker1 Device class. +class CSkyWalker1Device +{ +public: + + //Device Initialization and Dispatch Related definitions + NTSTATUS Create(IN PKSDEVICE pKSDeviceObject); + NTSTATUS Start( + IN PKSDEVICE pKSDeviceObject, + IN PIRP pIrp, + IN PCM_RESOURCE_LIST pResourceList OPTIONAL, + IN PCM_RESOURCE_LIST pTranslatedResourceList OPTIONAL + ); + + NTSTATUS Stop( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); + + NTSTATUS Close( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); + NTSTATUS SetPower( + IN PKSDEVICE pKSDeviceObject, //Pointer to the device object + //provided by the system. + IN PIRP pIoRequestPacket,//Pointer to the IRP related to this request. + IN DEVICE_POWER_STATE To, //Requested power state. + IN DEVICE_POWER_STATE From //Current power state. + ); + + NTSTATUS InitializeTuner( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); + + // Device access related Function definitions + // An instance of the filter uses these functions + // to manage resources on the device. + + NTSTATUS Acquire(IN PBDATUNER_DEVICE_PARAMETER pNewResource, + OUT PULONG pulAcquiredResourceID); + + NTSTATUS Update( IN PBDATUNER_DEVICE_PARAMETER pNewResource, + IN ULONG ulResourceID); + + NTSTATUS SendDiseqcCommand( + IN PDISEQC_COMMAND pDiseqcCommand, + IN ULONG ulResourceID + ); + + NTSTATUS Release(IN ULONG ulResourceID); + + NTSTATUS GetStatus(PBDATUNER_DEVICE_STATUS pDeviceStatus); + + //DMA Adapter related Functions + NTSTATUS InitializeAdapterStream(IN PKSDEVICE pKSDeviceObject); + + //Stream Capture Related Fuctions + NTSTATUS SetupCaptureSink ( + IN ICaptureSink * pCapturePin, + IN PBDA_TRANSPORT_INFO TransportInfo + ); + void RemoveCaptureSink (); + + NTSTATUS StartStream (); + NTSTATUS PauseStream (IN BOOLEAN Pausing); + NTSTATUS StopStream (); + NTSTATUS ReadStream(IN ULONG ulStreamIndex); + void ProcessStream(IN ULONG ulStreamIndex); + + BOOLEAN TimeToReadSignalStatus(void); + + PKSDEVICE m_pKSDevice; + + //USB Related definitions + USB_DEVICE_DESCRIPTOR USBDeviceDescriptor; + USBD_PIPE_INFORMATION ReadPipe; + USBD_PIPE_INFORMATION WritePipe; + USBSTATE UsbDeviceState; + USBSTATE PreviousUsbDeviceState; + //Pending I/O queue state + QUEUE_STATE QueueState; + + //obtain and hold this lock while changing the device state, + //the queue state and while processing the queue. + KSPIN_LOCK DeviceStateLock; + //Current Usb Irp + PIRP pUsbStreamIrp[PACKET_PER_FRAME * NUMBER_OF_FRAMES]; + //Device Stop Event + KEVENT EvDeviceStopOk; + //Device Remove Event + KEVENT EvDeviceRemoveOk; + //Outstanding IO Count for the Driver + ULONG ulOutStandingIoCount; + //Outstanding IO Count Lock + KSPIN_LOCK kIoCountLock; + + PDMA_ADAPTER m_pDMAAdapter; + + ULONG m_SampleSize; + + //Temporary Bytes Read Counter + ULONG m_NumberOfBytesRead[NUMBER_OF_FRAMES]; + + PUCHAR GetSynthBuffer(ULONG ulStreamIndex) + { + return m_SynthesisBuffer[ulStreamIndex]; + } + +private: + + ULONG m_ulDeviceInstance; + BDATUNER_DEVICE_PARAMETER m_CurResource; + BDATUNER_DEVICE_STATUS m_TunerStatus; + ULONG m_ulCurResourceID; + ULONG m_ulcResourceUsers; + LARGE_INTEGER m_PreviousStatusReadTime; + + //The synthesis buffer. This is a private buffer we use to store the + //references of the Streaming Data.It is used for the Reading data + //from the device and also Copying Data to the Stream Buffer sent + //by the application + PUCHAR m_SynthesisBuffer[NUMBER_OF_FRAMES]; + + //Key information regarding the frames we generate. + LONGLONG m_TimePerFrame; + ULONG m_PacketSize; + ULONG m_PacketsPerSample; + + //The current state of the Device + HARDWARE_STATE m_HardwareState; + + //The pause / stop hardware flag and event. + BOOLEAN m_StopHardware; + KEVENT m_HardwareEvent; + + //Number of pins with resources acquired. This is used as a locking + //mechanism for resource acquisition on the device. + LONG m_PinsWithResources; + + //The capture sink. When we complete stream reading, we + //notify the capture sink. + ICaptureSink *m_CaptureSink; + + //The video info header we're basing hardware settings on. The pin + //provides this to us when acquiring resources and must guarantee its + //stability until resources are released. + PBDA_TRANSPORT_INFO m_TransportInfo; +}; + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif /*SKYWALKER1_TUNER_DEVICE_H*/ + diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Extended.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Extended.h new file mode 100644 index 0000000..047d686 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Extended.h @@ -0,0 +1,109 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1AntennaPin.h + Author : + Date : + Purpose : This File Holds the Extended BDA Definitions + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef __SKYWALKER1_EXTENDED_H +#define __SKYWALKER1_EXTENDED_H + +/* Include the Library and Other header file */ +#if !defined(_KSMEDIA_) +#error KSMEDIA.H must be included before BDAMEDIA.H +#endif // !defined(_KSMEDIA_) + +#if !defined(_BDATYPES_) +#error BDATYPES.H must be included before BDAMEDIA.H +#endif // !defined(_BDATYPES_) + +#if !defined(_BDAMEDIA_) +#define _BDAMEDIA_ +#endif // !defined(_BDAMEDIA_) + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ + +#define MAX_DISEQC_COMMAND_LENGTH 6 + +/* Extended Property*/ + +//Used to extend the feature of the BDA +//{0B5221EB-F4C4-4976-B959-EF74427464D9} +#define STATIC_KSPROPSETID_BdaExtendedProperty \ + 0x0B5221EB, 0xF4C4, 0x4976, 0xB9, 0x59, 0xEF, 0x74, 0x42, 0x74, 0x64, 0xD9 +DEFINE_GUIDSTRUCT("0B5221EB-F4C4-4976-B959-EF74427464D9", KSPROPSETID_BdaExtendedProperty); +#define KSPROPSETID_BdaExtendedProperty DEFINE_GUIDNAMED(KSPROPSETID_BdaExtendedProperty) + +/* End of Macro Definitions */ + +/* Declare Enumerations here */ +//Extended Property List +typedef enum __KSPROPERTY_EXTENDED +{ + /* DiSEqC Command */ + //Used to send the Digital Sattelite Equipment Control (DiSEqC) + //Commands by application + KSPROPERTY_BDA_DISEQC = 0, //Extension Property 1 + + //Add New Extended Commands Here + +}KSPROPERTY_EXTENDED; + +//Enumeration can be used during Simple Tone Burst Command +typedef enum enSimpleToneBurst +{ + SEC_MINI_A, + SEC_MINI_B +}SIMPLE_TONE_BURST; + +/* End of Enumeration declaration */ + +/* Global & Static variables Declaration */ + +//DiSEqC Command related Structure definitions +typedef struct __DISEQC_COMMAND +{ + UCHAR ucMessage[MAX_DISEQC_COMMAND_LENGTH]; /* + Byte - 0 : Framing, + Byte - 1 : Address, + Byte - 2 : Command, + Byte - 3 : Data[0], + Byte - 4 : Data[1], + Byte - 5 : Data[2] + */ + UCHAR ucMessageLength;/* The Valid values for DiSEqC Command are 3...6 + If this value is 1 then the Byte 0 is taken as Simple "Tone Burst" Control + Command */ + +}DISEQC_COMMAND,*PDISEQC_COMMAND; + +//Property that will be used to send the Diseqc command by the application +#define DEFINE_KSPROPERTY_ITEM_BDA_DISEQC(GetHandler, SetHandler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_BDA_DISEQC,\ + (GetHandler),\ + sizeof(KSP_NODE),\ + sizeof(DISEQC_COMMAND),\ + (SetHandler),\ + NULL, 0, NULL, NULL, 0) + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif /*__SKYWALKER1_EXTENDED_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Main.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Main.h new file mode 100644 index 0000000..a072e07 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Main.h @@ -0,0 +1,69 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Main.h + Author : + Date : + Purpose : Entry point for the Driver + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef __SKYWALKER1_MAIN_H +#define __SKYWALKER1_MAIN_H + +/* Include the Library and Other header file */ +#include +#include +#include //Kernel Streaming Driver +#include +#include +#include +#include +#include + +#include +#include +#include "SkyWalker1AntennaPin.h" +#include "SkyWalker1CaptureFilter.h" +#include "SkyWalker1CapturePin.h" +#include "SkyWalker1CommonDef.h" +#include "SkyWalker1Control.h" +#include "SkyWalker1Device.h" +#include "SkyWalker1TransportPin.h" +#include "SkyWalker1TunerFilter.h" +#include "SkyWalker1TunerPin.h" +#include "SkyWalker1Extended.h" + +extern "C" +{ +#include //For the Mutex +#include //For the WCHAR and swprintf +#include //For sprintf() function + +#include "SkyWalker1PnP.h" //Header for the PnP related definitions +#include "SkyWalker1USB.h" +#include "SkyWalker1Utility.h" + +} + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif /*__SKYWALKER1_MAIN_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1PnP.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1PnP.h new file mode 100644 index 0000000..1b54c69 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1PnP.h @@ -0,0 +1,56 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1PnP.h + Author : + Date : + Purpose : PnP IRP Message Handler + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +#ifndef __SKYWALKER1_PNP_H +#define __SKYWALKER1_PNP_H + +/* Include the Library and Other header file */ +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +NTSTATUS SkyWalker1AddDevice(IN PKSDEVICE pKSDeviceObject); +VOID SkyWalker1Remove( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +NTSTATUS SkyWalker1Start(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket, + IN PCM_RESOURCE_LIST pResourceList, + IN PCM_RESOURCE_LIST pCIResourceListTranslated); +VOID SkyWalker1Stop(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +NTSTATUS SkyWalker1QueryStop( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +VOID SkyWalker1SetPower +( + IN PKSDEVICE pKSDeviceObject, //Pointer to the device object + //provided by the system. + IN PIRP pIoRequestPacket, //Pointer to the IRP related to this request. + IN DEVICE_POWER_STATE To, //Requested power state. + IN DEVICE_POWER_STATE From //Current power state. +); +/* End of Function prototype definitions */ + +#endif // __SKYWALKER1_PNP_H diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TransportPin.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TransportPin.h new file mode 100644 index 0000000..5a4ab97 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TransportPin.h @@ -0,0 +1,84 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1TransportPin.h + Author : + Date : + Purpose : This file contains header for the Transport pin on the Tuner + filter. + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef __SKYWALKER1_TRANSPORT_PIN_H +#define __SKYWALKER1_TRANSPORT_PIN_H + +/* Include the Library and Other header file */ +//#include "SkyWalker1CommonDef.h" +#include "SkyWalker1TunerPin.h" +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Global & Static variables Declaration */ + +//The Trasport Pin class. +class CTransportPin : public CTunerPin +{ +public: + + + //Define a data intersection handler function for the + //pin (KSPIN_DESCRIPTOR_EX structure). + //Network provider and AVStream use this function + //to connect the output pin with a downstream filter. + static NTSTATUS IntersectDataFormat( + IN PVOID pContext, + IN PIRP pIoRequestPacket, + IN PKSP_PIN Pin, + IN PKSDATARANGE DataRange, + IN PKSDATARANGE MatchingDataRange, + IN ULONG DataBufferSize, + OUT PVOID Data OPTIONAL, + OUT PULONG DataSize + ); + + static NTSTATUS GetDigitalDemodProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ); + + static NTSTATUS SetDigitalDemodProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ); + + //Function to send the Extended BDA Commands to the Tuner + static NTSTATUS SetExtendedProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ); +}; + + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif /*__SKYWALKER1_TRANSPORT_PIN_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TunerFilter.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TunerFilter.h new file mode 100644 index 0000000..2993d68 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TunerFilter.h @@ -0,0 +1,140 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1TunerFilter.h + Author : + Date : + Purpose : Tuner Filter Class Definition + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef SKYWALKER1_TUNER_FILTER_H +#define SKYWALKER1_TUNER_FILTER_H + +/* Include the Library and Other header file */ +#include "SkyWalker1CommonDef.h" +#include "SkyWalker1Device.h" +#include "SkyWalker1Extended.h" +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Global & Static variables Declaration */ + +//The Tuner Filter class. +class CTunerFilter +{ +public: + + //Functions to Create and Close Filter + static NTSTATUS Create( IN OUT PKSFILTER pKSFilter, + IN PIRP pIoRequestPacket); + + static NTSTATUS FilterClose( IN OUT PKSFILTER pKSFilter, + IN PIRP pIoRequestPacket); + + //KSMETHODSETID_BdaChangeSync pKSFilter change sync methods + static NTSTATUS StartChanges( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OPTIONAL PVOID pvIgnored); + + static NTSTATUS CheckChanges( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OPTIONAL PVOID pvIgnored); + + static NTSTATUS CommitChanges( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OPTIONAL PVOID pvIgnored); + + static NTSTATUS GetChangeState( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OUT PULONG pulChangeState); + + + //KSMETHODSETID_BdaDeviceConfiguration Method to modify filter topology. + static NTSTATUS CreateTopology( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OPTIONAL PVOID pvIgnored); + + + //pKSFilter Implementation Methods + (class CSkyWalker1Device *) GetDevice() + { + return m_pDevice; + }; + + NTSTATUS SetDeviceState(KSSTATE NewKsState) + { + m_KsState = NewKsState; + return STATUS_SUCCESS; + }; + + + //Tuner Node Properties + NTSTATUS GetTunerProperty(OUT PBDATUNER_DEVICE_PARAMETER pTunerParameter); + NTSTATUS SetFrequency(IN ULONG ulBdaParameter); + NTSTATUS SetMultiplier(IN ULONG ulBdaParameter); + NTSTATUS SetBandwidth(IN ULONG ulBdaParameter); + NTSTATUS SetPolarity(IN Polarisation NewPolarity); + NTSTATUS SetRange(IN ULONG ulBdaParameter); + NTSTATUS SetTransponder(IN ULONG ulBdaParameter); + NTSTATUS SetLowLOFrequency(IN ULONG ulBdaParameter); + NTSTATUS SetHighLOFrequency(IN ULONG ulBdaParameter); + NTSTATUS SetSwitchFrequency(IN ULONG ulBdaParameter); + + //Demodulator Node Properties + NTSTATUS GetDemodProperty(OUT PBDATUNER_DEVICE_PARAMETER pDemodParameter); + NTSTATUS SetModulatorType(IN ModulationType NewModulatorType); + NTSTATUS SetInnerFecType(IN ULONG ulNewInnerFecType); + NTSTATUS SetInnerFecRate(IN BinaryConvolutionCodeRate NewFecRate); + NTSTATUS SetOuterFecType(IN ULONG ulNewOuterFecType); + NTSTATUS SetOuterFecRate(IN BinaryConvolutionCodeRate NewFecRate); + NTSTATUS SetSymbolRate(IN ULONG ulNewSymbolRate); + NTSTATUS SetSpectralInversion(IN SpectralInversion SpecInv); + NTSTATUS SetGuardInterval(IN GuardInterval GuardInt); + NTSTATUS SetTransmissionMode(IN TransmissionMode TransMode); + + //Extended Property + NTSTATUS SendDiseqcCommand(IN PDISEQC_COMMAND pDiseqcCommand); + + //Function to retrive the Device Status. + NTSTATUS GetStatus(PBDATUNER_DEVICE_STATUS pDeviceStatus); + + //Functions to get and release device access + NTSTATUS AcquireResources(); + NTSTATUS ReleaseResources(); + + +private: + class CSkyWalker1Device * m_pDevice; + + //Filter Resources + KSSTATE m_KsState; + BDA_CHANGE_STATE m_BdaChangeState; + BDATUNER_DEVICE_PARAMETER m_CurResource; + BDATUNER_DEVICE_PARAMETER m_NewResource; + ULONG m_ulResourceID; + BOOLEAN m_fResourceAcquired; + CTunerFilter(); + ~CTunerFilter(); +}; + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif /*SKYWALKER1_TUNER_FILTER_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TunerPin.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TunerPin.h new file mode 100644 index 0000000..b815d67 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1TunerPin.h @@ -0,0 +1,82 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1TunerPin.h + Author : + Date : + Purpose : This File Holds the Generic Tuner Pin related declarations + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef __SKYWALKER1_TUNER_PIN_H +#define __SKYWALKER1_TUNER_PIN_H + +/* Include the Library and Other header file */ +#include "SkyWalker1CommonDef.h" +#include "SkyWalker1TunerFilter.h" +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Global & Static variables Declaration */ + +// The Tuner Pin class. +class CTunerPin +{ +public: + + + //Creates the Pin + static NTSTATUS PinCreate( IN OUT PKSPIN pKSPin, + IN PIRP pIoRequestPacket + ); + + //Closes the Opened Pin + static NTSTATUS PinClose( IN OUT PKSPIN pKSPin, + IN PIRP pIoRequestPacket + ); + + //Member Function to get the Various Signal attributes + static NTSTATUS GetSignalStatus( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ); + + + (class CTunerFilter *) GetFilter(void) + { + return m_pFilter; + }; + + void SetFilter(class CTunerFilter * pFilter) + { + m_pFilter = pFilter; + }; + +protected: + + class CTunerFilter* m_pFilter; + +}; + + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +#endif /*__SKYWALKER1_TUNER_PIN_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1USB.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1USB.h new file mode 100644 index 0000000..1f41a30 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1USB.h @@ -0,0 +1,126 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Usb.h + Author : + Date : + Purpose : This File Holds all the USB Device access related declarations + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +#ifndef __SKYWALKER1_USB_H +#define __SKYWALKER1_USB_H + +/* Include the Library and Other header file */ +extern "C" +{ +//USB Related Headers +#include +#pragma warning(disable:4200) +#include +#include +#include +#include +#include "SkyWalker1Device.h" + +} +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +#define MAX_BULK_PACKET_SIZE 8 * 512 +#define MAX_BULK_TRANSFER_SIZE (TRANSPORT_PACKET_COUNT * TRANSPORT_PACKET_SIZE) //Suppoting max Frame Size +/* End of Macro Definitions */ + +/* Declare Enumerations here */ +typedef enum __USBSTATE { + + NotStarted, // not started + Stopped, // device stopped + Working, // started and working + PendingStop, // stop pending + PendingRemove, // remove pending + SurpriseRemoved, // removed by surprise + Removed // removed + +}USBSTATE; + +typedef enum _QUEUE_STATE { + + HoldRequests, // device is not started yet + AllowRequests, // device is ready to process + FailRequests // fail both existing and queued up requests + +} QUEUE_STATE; + +#define INITIALIZE_PNP_STATE(_Data_) \ + (_Data_)->UsbDeviceState = NotStarted;\ + (_Data_)->PreviousUsbDeviceState = NotStarted; + +#define SET_NEW_PNP_STATE(_Data_, _state_) \ + (_Data_)->PreviousUsbDeviceState = (_Data_)->UsbDeviceState;\ + (_Data_)->UsbDeviceState = (_state_); + +#define RESTORE_PREVIOUS_PNP_STATE(_Data_) \ + (_Data_)->UsbDeviceState = (_Data_)->PreviousUsbDeviceState; + +/* End of Enumeration declaration */ + +/* Global & Static variables Declaration */ +//BulkUsb Read Write Context +typedef struct _BULKUSB_RW_CONTEXT { + + PURB pUSBRequestBlock; + PUCHAR pTransferBuffer; + ULONG ulRemainingByteTransfer; // remaining to xfer + ULONG ulCompletedByteTransfer; // cumulate xfer + ULONG ulStreamIndex; + class CSkyWalker1Device * pDevice; + +} BULKUSB_RW_CONTEXT, * PBULKUSB_RW_CONTEXT; +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Function Prototypes */ +//Usb Access functions +NTSTATUS InitializeUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoReqestPacket); +NTSTATUS DeconfigureUsbDevice(IN PKSDEVICE pKSDeviceObject); +NTSTATUS StopUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +NTSTATUS ReadWriteUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN ULONG ulStreamIndex, + IN ULONG ulPacketIndex, + IN PUCHAR pucTransferBuffer, + IN ULONG ulTransferLength, + IN BOOLEAN bRead); +NTSTATUS ControlUsbDevice( IN PKSDEVICE pKSDeviceObject, + IN UCHAR ucRequest, + IN USHORT usValue, + IN USHORT usIndex, + IN PUCHAR pucTransferBuffer, + IN ULONG ulTransferLength, + IN BOOLEAN bRead); +NTSTATUS RemoveUsbDevice( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +NTSTATUS SurpriseUsbDeviceRemoval(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +NTSTATUS CancelRemoveUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +NTSTATUS QueryRemoveUsbDevice( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +NTSTATUS QueryStopUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); +NTSTATUS CancelStopUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket); + +/* End of Function prototype definitions */ + +#endif /*__SKYWALKER1_USB_H*/ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Utility.h b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Utility.h new file mode 100644 index 0000000..f018fbc --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Include/SkyWalker1Utility.h @@ -0,0 +1,91 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Utility.h + Author : + Date : + Purpose : This file basically holds the Utility related Common Declarations + used in the SkyWalker Driver Module + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +#ifndef SKYWALKER1_UTILITY_H +#define SKYWALKER1_UTILITY_H + +/* Include the Library and Other header file */ +#include +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +#define SKYWALKER1_DRIVER_NAME "SkyWalker1TVTuner" + +extern int nCurrentDebugLevel; + +#define DEBUG_ON +#ifdef DEBUG_ON + +#define SkyWalkerDebugPrint(DebugLevel,_ARGUMENTS_) \ + if((DebugLevel) <= nCurrentDebugLevel) \ + { \ + DbgPrint _ARGUMENTS_; \ + } + +#else + +#define SkyWalkerDebugPrint(DebugLevel,__ARGUMENTS__) + +#endif + +#define TRUE 1 +#define FALSE 0 + +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ + +/* ENUM : enDebugLevels */ +/* PURPOSE : To Define Different Debug Levels */ +enum enDebugLevels +{ + DISABLE_DEBUG = 0, + ENTRY_LEVEL, + INTERMEDIATE_LEVEL, + EXTREME_LEVEL, +}; +/* End of Enumeration declaration */ + +/* Function Prototypes */ +void PrintFunctionEntry(IN char * pcFunctionName); +void PrintFunctionExit(IN char * pcFunctionName, IN NTSTATUS ntReturnCode); +char * GetCurrentIrqlString(void); +VOID Delay(IN ULONG ulDelayInMicroSeconds); //To Delay the Execution Thread + +NTSTATUS LowerDeviceCompletedIrp(IN PDEVICE_OBJECT pDeviceObject, + IN PIRP pIoRequestPacket, + IN PVOID pContext); +NTSTATUS PassDownIRPAndWaitForCompletion(IN PDEVICE_OBJECT pLowerDeviceObject, + IN PIRP pIoRequestPacket, + IN BOOLEAN bCopyStackLocation); +NTSTATUS PassDownIRPAndForget(IN PDEVICE_OBJECT pLowerDeviceObject, + IN PIRP pIoRequestPacket); +VOID CompleteIrpInDispatch(IN PDEVICE_OBJECT pDeviceObject, + IN PIRP pIoRequestPacket); +PUCHAR NTStatusToString(NTSTATUS Status) ; +VOID PrintDeviceChangeState(IN KSSTATE ToState,IN KSSTATE FromState); +/* End of Function prototype definitions */ + + + +#endif /*SKYWALKER1_UTILITY_H*/ + diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/MakeFile b/firmware-driver/SkyWalker1_Final_Release/Source/MakeFile new file mode 100644 index 0000000..7a3ac54 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/MakeFile @@ -0,0 +1,2 @@ +USER_INCLUDES=..\Include;..\.. +!INCLUDE $(NTMAKEENV)\makefile.def \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1AntennaPin.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1AntennaPin.cpp new file mode 100644 index 0000000..589edca --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1AntennaPin.cpp @@ -0,0 +1,546 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1AntennaPin.cpp + Author : + Date : + Purpose : This File Holds the Antenna Pin related declarations + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Common For all the Definitions, + //Declarations and Library Routines + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +PCHAR GetTunerPropertyString(ULONG ulTunerProperty); +PCHAR GetTunerLnbPropertyString(ULONG ulTunerLnbProperty); +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : CAntennaPin::IntersectDataFormat + Description : Enables connection of the input pin with a upstream filter. + IN PARAM : + OUT PARAM : Status of the IntersectDataFormat + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CAntennaPin::IntersectDataFormat( + IN PVOID pContext, + IN PIRP pIoRequestPacket, + IN PKSP_PIN Pin, + IN PKSDATARANGE pDataRange, + IN PKSDATARANGE pMatchingDataRange, + IN ULONG ulDataBufferSize, + OUT PVOID pData OPTIONAL, + OUT PULONG pulDataSize + ) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if ( ulDataBufferSize < sizeof(KS_DATARANGE_BDA_ANTENNA) ) + { + *pulDataSize = sizeof( KS_DATARANGE_BDA_ANTENNA ); + ntStatus = STATUS_BUFFER_OVERFLOW; + goto ExitDataFormat; + } + else if (pDataRange->FormatSize < sizeof (KS_DATARANGE_BDA_ANTENNA)) + { + ntStatus = STATUS_NO_MATCH; + goto ExitDataFormat; + } + else + { + *pulDataSize = sizeof( KS_DATARANGE_BDA_ANTENNA ); + RtlCopyMemory( pData, (PVOID)pDataRange, sizeof(KS_DATARANGE_BDA_ANTENNA)); + ntStatus = STATUS_SUCCESS; + } + +ExitDataFormat: + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; + +} + +/***************************************************************************** + Function : CAntennaPin::PinSetDeviceState + Description : An AVStream minidriver's AVStrMiniPinSetDeviceState + routine is called when the state of a KSPIN structure is + changed due to the arrival of a connection state property + 'set' IOCTL. Typically, this will be provided by minidrivers + that need to change the state of hardware. + + The KSSTATE enumeration lists possible states of a kernel + streaming object. + typedef enum { + KSSTATE_STOP; + KSSTATE_ACQUIRE; + KSSTATE_PAUSE; + KSSTATE_RUN; + } KSSTATE; + + Enumerators + KSSTATE_STOP + Indicates that the object is in minimum resource consumption mode. + KSSTATE_ACQUIRE + Indicates that the object is acquiring resources. + KSSTATE_PAUSE + Indicates that the object is preparing to make instant transition to Run state. + KSSTATE_RUN + Indicates that the object is actively streaming. + + Because the most upstream pin (input pin) is the last + to transition, use this pin's state to set the state + of the filter. + Also, release filter resouces if the pin's state + transitions to stop, and acquire resources if the pin's + state transitions from stop. + IN PARAM : Pointer to the KSPIN structure for which state is changing. + The target KSSTATE after receipt of the IOCTL. + The previous KSSTATE. + OUT PARAM : Status of the PinSetDeviceState + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CAntennaPin::PinSetDeviceState( + IN PKSPIN pKSPin, + IN KSSTATE ToState, + IN KSSTATE FromState + ) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + PKSDEVICE pKSDevice = NULL; + CAntennaPin * pPin = NULL; + CSkyWalker1Device * pDevice = NULL; + + PrintFunctionEntry(__FUNCTION__); + + //Obtain a pointer to the device object from + //the passed in pointer to the KSPIN structure. + pKSDevice = KsPinGetDevice( pKSPin); + + //Obtain a pointer to the pin object from context member of + //the passed in pointer to the KSPIN structure. + pPin = reinterpret_cast(pKSPin->Context); + + //Obtain a pointer to the device object from context member of + //the retrieved pointer to the KSDEVICE structure. + pDevice = reinterpret_cast(pKSDevice->Context); + + pPin->m_pFilter->SetDeviceState( pPin->m_KsState); + + if ((ToState == KSSTATE_STOP) && (FromState != KSSTATE_STOP)) + { + //Because the driver allocates resources on a filter wide basis, + //inform the filter to release resources when the last pin + //(that is, the most upstream pin) transitions to the stop state. + // + //The input pin is the last pin to transition to the stop state, + //therefore inform the filter to release its resources. + // + ntSetStatus = pPin->m_pFilter->ReleaseResources(); + pPin->m_KsState = ToState; + } + else if ((ToState == KSSTATE_ACQUIRE) && (FromState == KSSTATE_STOP)) + { + //Because the driver allocates resources on a filter wide basis, + //inform the filter to acquire resources when the last pin + //(that is, the most upstream pin) transitions from the stop state. + // + //The input pin is the last pin to transition from the stop state, + //therefore inform the filter to acquire its resources. + // + ntSetStatus = pPin->m_pFilter->AcquireResources(); + if (NT_SUCCESS( ntSetStatus)) + { + pPin->m_KsState = ToState; + } + } + else if (ToState > KSSTATE_RUN) + { + + SkyWalkerDebugPrint(EXTREME_LEVEL, + ("Invalid Device State. ToState 0x%08x. FromState 0x%08x.", + ToState, FromState)); + ntSetStatus = STATUS_INVALID_PARAMETER; + } + else + { + pPin->m_KsState = ToState; + } + + PrintDeviceChangeState(ToState,FromState); + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + + + +/***************************************************************************** + Function : CAntennaPin::GetTunerProperty + Description : Retrieves the value of the Tuner node Properties + IN PARAM : IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + OUT PULONG pulProperty + OUT PARAM : Status SUCCESS in case Valid Property request + STATUS_INVALID_PARAMETER in case of Invalid property request + Else error from the lower device + PreCondition : None + PostCondtion : Tuner propery read in case of successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CAntennaPin::GetTunerProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + OUT PULONG pulProperty + ) +{ + NTSTATUS ntGetStatus = STATUS_SUCCESS; + CAntennaPin * pPin = NULL; + CTunerFilter* pFilter = NULL; + BDATUNER_DEVICE_PARAMETER TunerProperty; + + PrintFunctionEntry(__FUNCTION__); + //Call the BDA support library to + //validate that the node type is associated with the pin. + + //The BdaValidateNodeProperty function validates that a node property + //request is associated with a specific pin. + ntGetStatus = BdaValidateNodeProperty( pIoRequestPacket, pKSProperty); + if (NT_SUCCESS( ntGetStatus)) + { + //Obtain a pointer to the pin object. + + //Because the property dispatch table calls the CAntennaPin::GetTunerProperty() + //method directly, the method must retrieve a pointer to the underlying pin object. + pPin = reinterpret_cast(KsGetPinFromIrp(pIoRequestPacket)->Context); + + //Retrieve the filter context from the pin context. + pFilter = pPin->GetFilter(); + + ntGetStatus = pFilter->GetTunerProperty(&TunerProperty); + //Retrieve the actual filter parameter. + switch (pKSProperty->Id) + { + case KSPROPERTY_BDA_RF_TUNER_FREQUENCY: + *pulProperty = TunerProperty.ulCarrierFrequency; + break; + case KSPROPERTY_BDA_RF_TUNER_FREQUENCY_MULTIPLIER: + *pulProperty = TunerProperty.ulFrequencyMultiplier; + break; + case KSPROPERTY_BDA_RF_TUNER_BANDWIDTH: + *pulProperty = TunerProperty.ulBandWidth; + break; + case KSPROPERTY_BDA_RF_TUNER_POLARITY: + *pulProperty = TunerProperty.Polarity; + break; + case KSPROPERTY_BDA_RF_TUNER_RANGE: + *pulProperty = TunerProperty.ulRange; + break; + case KSPROPERTY_BDA_RF_TUNER_TRANSPONDER: + *pulProperty = TunerProperty.ulTransponder; + break; + default: + ntGetStatus = STATUS_INVALID_PARAMETER; + break; + } + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Get : %s : %ul",GetTunerPropertyString(pKSProperty->Id),*pulProperty)); + + PrintFunctionExit(__FUNCTION__,ntGetStatus); + return ntGetStatus; +} + +/***************************************************************************** + Function : CAntennaPin::SetTunerProperty + Description : Sets the value of the Tuner node Freq. Properties + IN PARAM : IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + OUT PULONG pulProperty + OUT PARAM : Status SUCCESS in case Valid Property request + STATUS_INVALID_PARAMETER in case of Invalid property request + Else error from the lower device + PreCondition : None + PostCondtion : Tuner Freq. property read in case of successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CAntennaPin::SetTunerProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + CAntennaPin * pPin; + CTunerFilter* pFilter; + + PrintFunctionEntry(__FUNCTION__); + //Call the BDA support library to + //validate that the node type is associated with the pin. + + //The BdaValidateNodeProperty function validates that a node property + //request is associated with a specific pin. + ntSetStatus = BdaValidateNodeProperty( pIoRequestPacket, pKSProperty); + if (NT_SUCCESS( ntSetStatus)) + { + //Obtain a pointer to the pin object. + + //Because the property dispatch table calls the CAntennaPin::SetTunerProperty() + //method directly, the method must retrieve a pointer to the underlying pin object. + pPin = reinterpret_cast(KsGetPinFromIrp(pIoRequestPacket)->Context); + + //Retrieve the filter context from the pin context. + pFilter = pPin->GetFilter(); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Set : %s : %lu\n", + GetTunerPropertyString(pKSProperty->Id), + *pulProperty)); + //Retrieve the actual filter parameter. + switch (pKSProperty->Id) + { + case KSPROPERTY_BDA_RF_TUNER_FREQUENCY: + ntSetStatus = pFilter->SetFrequency(*pulProperty); + break; + case KSPROPERTY_BDA_RF_TUNER_FREQUENCY_MULTIPLIER: + ntSetStatus = pFilter->SetMultiplier(*pulProperty); + break; + case KSPROPERTY_BDA_RF_TUNER_BANDWIDTH: + ntSetStatus = pFilter->SetBandwidth(*pulProperty); + break; + case KSPROPERTY_BDA_RF_TUNER_POLARITY: + ntSetStatus = pFilter->SetPolarity((Polarisation) *pulProperty); + break; + case KSPROPERTY_BDA_RF_TUNER_RANGE: + ntSetStatus = pFilter->SetRange(*pulProperty); + break; + case KSPROPERTY_BDA_RF_TUNER_TRANSPONDER: + ntSetStatus = pFilter->SetTransponder(*pulProperty); + break; + default: + ntSetStatus = STATUS_INVALID_PARAMETER; + break; + } + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CAntennaPin::GetTunerLnbProperty + Description : Retrieves the value of the Tuner Lnb node Properties + IN PARAM : IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + OUT PULONG pulProperty + OUT PARAM : Status SUCCESS in case Valid Property request + STATUS_INVALID_PARAMETER in case of Invalid property request + Else error from the lower device + PreCondition : None + PostCondtion : Tuner lnb propery read in case of successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CAntennaPin::GetTunerLnbProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + OUT PULONG pulProperty + ) +{ + NTSTATUS ntGetStatus = STATUS_SUCCESS; + CAntennaPin * pPin; + CTunerFilter* pFilter; + BDATUNER_DEVICE_PARAMETER LnbProperty; + + PrintFunctionEntry(__FUNCTION__); + //Call the BDA support library to + //validate that the node type is associated with the pin. + + //The BdaValidateNodeProperty function validates that a node property + //request is associated with a specific pin. + ntGetStatus = BdaValidateNodeProperty( pIoRequestPacket, pKSProperty); + if (NT_SUCCESS( ntGetStatus)) + { + //Obtain a pointer to the pin object. + + //Because the property dispatch table calls the CAntennaPin::GetTunerProperty() + //method directly, the method must retrieve a pointer to the underlying pin object. + pPin = reinterpret_cast(KsGetPinFromIrp(pIoRequestPacket)->Context); + + //Retrieve the filter context from the pin context. + pFilter = pPin->GetFilter(); + + ntGetStatus = pFilter->GetTunerProperty(&LnbProperty); + + //Retrieve the actual filter parameter. + switch (pKSProperty->Id) + { + case KSPROPERTY_BDA_LNB_LOF_LOW_BAND: + *pulProperty = LnbProperty.ulLnbLowLOFrequency; + break; + case KSPROPERTY_BDA_LNB_LOF_HIGH_BAND: + *pulProperty = LnbProperty.ulLnbHighLOFrequency; + break; + case KSPROPERTY_BDA_LNB_SWITCH_FREQUENCY: + *pulProperty = LnbProperty.ulLnbSwitchFrequency; + break; + default: + ntGetStatus = STATUS_INVALID_PARAMETER; + break; + } + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Get : %s : %ul",GetTunerLnbPropertyString(pKSProperty->Id),*pulProperty)); + + PrintFunctionExit(__FUNCTION__,ntGetStatus); + return ntGetStatus; +} + +/***************************************************************************** + Function : CAntennaPin::SetTunerLnbProperty + Description : Sets the value of the Tuner Lnb node Properties + IN PARAM : IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + OUT PARAM : Status SUCCESS in case Valid Property request + STATUS_INVALID_PARAMETER in case of Invalid property request + Else error from the lower device + PreCondition : None + PostCondtion : Tuner propery Set in case of successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CAntennaPin::SetTunerLnbProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + CAntennaPin * pPin; + CTunerFilter* pFilter; + + PrintFunctionEntry(__FUNCTION__); + //Call the BDA support library to + //validate that the node type is associated with the pin. + + //The BdaValidateNodeProperty function validates that a node property + //request is associated with a specific pin. + ntSetStatus = BdaValidateNodeProperty( pIoRequestPacket, pKSProperty); + if (NT_SUCCESS( ntSetStatus)) + { + //Obtain a pointer to the pin object. + + //Because the property dispatch table calls the CAntennaPin::SetTunerProperty() + //method directly, the method must retrieve a pointer to the underlying pin object. + + pPin = reinterpret_cast(KsGetPinFromIrp(pIoRequestPacket)->Context); + + //Retrieve the filter context from the pin context. + pFilter = pPin->GetFilter(); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Set : %s : %lu(%l)", + GetTunerLnbPropertyString(pKSProperty->Id), + *pulProperty, + *((LONG*)(pulProperty)))); + //Retrieve the actual filter parameter. + switch (pKSProperty->Id) + { + case KSPROPERTY_BDA_LNB_LOF_LOW_BAND: + ntSetStatus = pFilter->SetLowLOFrequency(*pulProperty); + break; + case KSPROPERTY_BDA_LNB_LOF_HIGH_BAND: + ntSetStatus = pFilter->SetHighLOFrequency(*pulProperty); + break; + case KSPROPERTY_BDA_LNB_SWITCH_FREQUENCY: + ntSetStatus = pFilter->SetSwitchFrequency(*pulProperty); + break; + default: + ntSetStatus = STATUS_INVALID_PARAMETER; + break; + } + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + + + + +PCHAR GetTunerPropertyString(ULONG ulTunerProperty) +{ + switch(ulTunerProperty) + { + case KSPROPERTY_BDA_RF_TUNER_FREQUENCY: + return "KSPROPERTY_BDA_RF_TUNER_FREQUENCY"; + case KSPROPERTY_BDA_RF_TUNER_POLARITY: + return "KSPROPERTY_BDA_RF_TUNER_POLARITY"; + case KSPROPERTY_BDA_RF_TUNER_RANGE: + return "KSPROPERTY_BDA_RF_TUNER_RANGE"; + case KSPROPERTY_BDA_RF_TUNER_TRANSPONDER: + return "KSPROPERTY_BDA_RF_TUNER_TRANSPONDER"; + case KSPROPERTY_BDA_RF_TUNER_BANDWIDTH: + return "KSPROPERTY_BDA_RF_TUNER_BANDWIDTH"; + case KSPROPERTY_BDA_RF_TUNER_FREQUENCY_MULTIPLIER: + return "KSPROPERTY_BDA_RF_TUNER_FREQUENCY_MULTIPLIER"; + default: + return "KSPROPERTY_BDA_INVALID_PROPERTY"; + } +} + +PCHAR GetTunerLnbPropertyString(ULONG ulTunerLnbProperty) +{ + switch(ulTunerLnbProperty) + { + case KSPROPERTY_BDA_LNB_LOF_LOW_BAND: + return "KSPROPERTY_BDA_LNB_LOF_LOW_BAND"; + case KSPROPERTY_BDA_LNB_LOF_HIGH_BAND: + return "KSPROPERTY_BDA_LNB_LOF_HIGH_BAND"; + case KSPROPERTY_BDA_LNB_SWITCH_FREQUENCY: + return "KSPROPERTY_BDA_LNB_SWITCH_FREQUENCY"; + default: + return "KSPROPERTY_BDA_INVALID_PROPERTY"; + } +} diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CaptureFilter.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CaptureFilter.cpp new file mode 100644 index 0000000..304d258 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CaptureFilter.cpp @@ -0,0 +1,165 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1CaptureFilter.cpp + Author : + Date : + Purpose : This file contains the filter level header for the + capture filter. + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Main Header file + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : CCaptureFilter + Description : Constructor of the CCaptureFilter Class + The capture filter object constructor. Since the new operator will + have zeroed the memory, do not bother initializing any NULL or 0 + fields.Only initialize non-NULL, non-0 fields. + IN PARAM : Filter + OUT PARAM : NONE + PreCondition : Filter Object is not created + PostCondtion : Filter Object is created and Initialzed on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +CCaptureFilter::CCaptureFilter(IN PKSFILTER pKSFilter) : + m_Filter (pKSFilter) +{ + +} + +/***************************************************************************** + Function : CCaptureFilter + Description : Destructor of the CCaptureFilter Class + Destroys the filter object + IN PARAM : NONE + OUT PARAM : NONE + PreCondition : Filter Object is created + PostCondtion : Filter Object is Removed and Memory freed + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +CCaptureFilter::~CCaptureFilter() +{ + +} + +/***************************************************************************** + Function : CCaptureFilter::Cleanup() + Description : This is the bag cleanup callback for the CCaptureFilter. + Destroys the filter object + IN PARAM : Reference to the current Object + OUT PARAM : NONE + PreCondition : Filter Object is created + PostCondtion : Filter Object is Removed and Memory freed + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +void CCaptureFilter::Cleanup (IN CCaptureFilter *pFilter) +{ + delete pFilter; +} + + +/***************************************************************************** + Function : CCaptureFilter::Create() + Description : It creates the CCaptureFilter object, associates it with + the AVStream filter object, and bag the CCaptureFilter + for later cleanup. + IN PARAM : Pointer to KSFILTER that just created + Pointer to IRP_MJ_CREATE for Filter + OUT PARAM : Status of the Filter Create routine + STATUS_SUCCESS on Routine success + Else Error code from the attempt to create the Filter + PreCondition : Filter is not created + PostCondtion : Filter is created and Initialzed on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +STDMETHODIMP_(NTSTATUS) CCaptureFilter::Create( IN OUT PKSFILTER pKSFilter, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntFilterCreationStatus = STATUS_SUCCESS; + ULONG ulPinId; // just useful when no network provider is present + PKSDEVICE pKSDeviceObject = NULL; + CSkyWalker1Device * pDevice = NULL; + + PrintFunctionEntry(__FUNCTION__); + + //Create a filter object for the filter instance. + CCaptureFilter* pFilter = new(NonPagedPool,CAPTURE_MEM_TAG) CCaptureFilter(pKSFilter); // Tags the allocated memory + if (!IS_VALID(pFilter)) + { + //Exit if the Filter Memory could not be allocated + ntFilterCreationStatus = STATUS_INSUFFICIENT_RESOURCES; + goto ErrorFilterCreate; + } + else + { + // Add the item to the object bag if we we were successful. + // Whenever the filter closes, the bag is cleaned up and we will be + // freed. + // + ntFilterCreationStatus = KsAddItemToObjectBag ( + pKSFilter -> Bag, + reinterpret_cast (pFilter), + reinterpret_cast (CCaptureFilter::Cleanup) + ); + + if (!NT_SUCCESS (ntFilterCreationStatus)) + { + goto ErrorFilterCreate; + } + else + { + pKSFilter->Context = reinterpret_cast (pFilter); + } + } + +CompleteFilterCreate : + + PrintFunctionExit(__FUNCTION__,ntFilterCreationStatus); + return ntFilterCreationStatus; + +ErrorFilterCreate: + if (IS_VALID(pFilter)) + { + delete pFilter; + } + + goto CompleteFilterCreate; +} \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CaptureFilterDefinitions.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CaptureFilterDefinitions.cpp new file mode 100644 index 0000000..91f7ad2 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CaptureFilterDefinitions.cpp @@ -0,0 +1,336 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1CaptureFilterDefinitions.cpp + Author : + Date : + Purpose : Capture Filter Definition + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Main Header file + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ + +const KSPIN_DISPATCH CaptureInputPinDispatch={ + /* Create */ CCapturePin::PinCreate, + /* Close */ NULL, + /* Process */ NULL, + /* Reset */ NULL, + /* SetDataFormat */ NULL, + /* SetDeviceState */ NULL, + /* Connect */ NULL, + /* Disconnect */ NULL, + /* Allocator */ NULL +}; + +DEFINE_KSAUTOMATION_TABLE(NullAutomation) { + DEFINE_KSAUTOMATION_PROPERTIES_NULL, + DEFINE_KSAUTOMATION_METHODS_NULL, + DEFINE_KSAUTOMATION_EVENTS_NULL +}; + +//The list of category GUIDs for the capture filter. +const GUID SkyWalker1CaptureCatagories [] = { + STATICGUIDOF (KSCATEGORY_BDA_RECEIVER_COMPONENT) +}; + +//Medium GUIDs for the Transport Output Pin. +// +//Pin Medium descriptor containing all medium accepted to be connected to +//the tuner output pin.This insures contection to the correct Capture Filter pin. +// +//{2AEB4A94-FBB7-4FB1-8D74-243B91886EAB} + +const KSPIN_MEDIUM TransportPinMediums[] = +{ + { + GUID_SKYWALKER_TUNER_OUT_MEDIUM, + 0, + 0 + } +}; + +// +//This is the data range description of the capture input pin. +//This is same as the Outpin of the Tuner i.e. The Transport Pin +//The Output of the Tuner is given to the Capture thus it has to +//be same +// +const KS_DATARANGE_BDA_TRANSPORT FormatCaptureIn = +{ + //insert the KSDATARANGE and KSDATAFORMAT here + { + sizeof( KS_DATARANGE_BDA_TRANSPORT), //FormatSize + 0, //Flags - (N/A) + 0, //SampleSize - (N/A) + 0, //Reserved + { STATIC_KSDATAFORMAT_TYPE_STREAM }, //MajorFormat + { STATIC_KSDATAFORMAT_TYPE_MPEG2_TRANSPORT }, //SubFormat + { STATIC_KSDATAFORMAT_SPECIFIER_BDA_TRANSPORT } //Specifier + }, + //insert the BDA_TRANSPORT_INFO here + { + TRANSPORT_PACKET_SIZE, //ulcbPhyiscalPacket + TRANSPORT_PACKET_COUNT*TRANSPORT_PACKET_SIZE, //ulcbPhyiscalFrame + 0, //ulcbPhyiscalFrameAlignment (no requirement) + 0 //AvgTimePerFrame (not known) + } +}; + +const PKSDATARANGE CaptureInPinDataRanges[]={ + (PKSDATARANGE)&FormatCaptureIn, +}; + +//Capture Outout Pin Definitions +const KSPIN_DISPATCH CaptureOutputPinDispatch={ + /* Create */ CCapturePin::PinCreate, + /* Close */ NULL, + /* Process */ CCapturePin::DispatchProcess, + /* Reset */ NULL, + /* SetDataFormat */ NULL, + /* SetDeviceState */ CCapturePin::DispatchSetState, + /* Connect */ NULL, + /* Disconnect */ NULL, + /* Allocator */ NULL +}; + + +// +//This is the data range description of the capture output pin. +// +const KSDATARANGE FormatCaptureOut = +{ + //insert the KSDATARANGE and KSDATAFORMAT here + { + sizeof( KSDATARANGE), //FormatSize + 0, //Flags - (N/A) + TRANSPORT_PACKET_COUNT*TRANSPORT_PACKET_SIZE, //SampleSize + 0, //Reserved + { STATIC_KSDATAFORMAT_TYPE_STREAM }, //MajorFormat + { STATIC_KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT },//SubFormat + { STATIC_KSDATAFORMAT_SPECIFIER_NONE } //Specifier + } +}; + +const PKSDATARANGE CaptureOutPinDataRanges[]={ + (PKSDATARANGE)&FormatCaptureOut, +}; + +// +//CapturePinAllocatorFraming: +// +//This is the simple framing structure for the capture pin. Note that this +//will be modified via KsEdit when the actual capture format is determined. +// +DECLARE_SIMPLE_FRAMING_EX ( + CapturePinAllocatorFraming, //FramingExName + STATICGUIDOF (KSMEMORY_TYPE_KERNEL_NONPAGED), //MemoryType + KSALLOCATOR_REQUIREMENTF_SYSTEM_MEMORY | + KSALLOCATOR_REQUIREMENTF_PREFERENCES_ONLY, //Flags + NUMBER_OF_FRAMES, //Frames + 0, //Alignment + TRANSPORT_PACKET_COUNT*TRANSPORT_PACKET_SIZE, //MinFrameSize + TRANSPORT_PACKET_COUNT*TRANSPORT_PACKET_SIZE //MaxFrameSize + ); + +/**********************************************************************************/ + +//Not Supporting Filter Methods,Properties and Events +DEFINE_KSAUTOMATION_TABLE(SkyWalker1CaptureAutomationTable) +{ + DEFINE_KSAUTOMATION_PROPERTIES_NULL, + DEFINE_KSAUTOMATION_METHODS_NULL, + DEFINE_KSAUTOMATION_EVENTS_NULL +}; +/**********************************************************************************/ +// +//CaptureFilterDispatch: +// +//This is the dispatch table for the capture filter. It provides notification +//of creation, closure, processing (for filter-centrics, not for the capture +//filter), and resets (for filter-centrics, not for the capture filter). +// +const KSFILTER_DISPATCH SkyWalker1CaptureDispatchTable = +{ + /* Create */ CCaptureFilter::Create, //Routine called when the Filter is created + /* Close */ NULL, //Routine called when the Filter is closed + /* Process */ NULL, + /* Reset */ NULL +}; + +// +//Capture Pin Descriptors +// +//This data structure defines the pin types available in the filters +//template topology. These structures will be used to create a +//KDPinFactory for a pin type when BdaCreatePin or BdaMethodCreatePin +//are called. +// +//This structure defines ALL pins the filter is capable of supporting, +//including those pins which may only be created dynamically by a ring +//3 component such as a Network Provider. + +//The list of pin descriptors on the capture filter. +const KSPIN_DESCRIPTOR_EX SkyWalker1CapturePinDescriptors[]={ + { //Capture Filter input pin + &CaptureInputPinDispatch, //Dispatch Table + &NullAutomation, //Automation Table + { + 0, //Interfaces + NULL, + SIZEOF_ARRAY(TransportPinMediums), //Medium Count + TransportPinMediums, //Medium + SIZEOF_ARRAY(CaptureInPinDataRanges), //Range Count + CaptureInPinDataRanges, //Ranges + KSPIN_DATAFLOW_IN, //Specifies that data flow is into the pin + KSPIN_COMMUNICATION_BOTH, //Specifies that the pin factory instantiates pins + //that are both IRP sinks and IRP sources + (GUID *) &PINNAME_BDA_TRANSPORT, //Category GUID + (GUID *) &PINNAME_BDA_TRANSPORT, //GUID of the localized Unicode string + 0 + }, + KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT| + KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING| + KSPIN_FLAG_FIXED_FORMAT, + 1, //Maximum Possible Instances of the Pin + 1, //Mandatory Instances of this for the Filter function + NULL,//Allocator Framing + NULL //Data Interaction Handler + }, + { //Capture Filter output pin + &CaptureOutputPinDispatch, //Dispatch Table + &NullAutomation, //Automation Table + { + NULL, + 0, + NULL, + 0, + SIZEOF_ARRAY(CaptureOutPinDataRanges), //Range Count + CaptureOutPinDataRanges, + KSPIN_DATAFLOW_OUT, //Specifies that data flow is out of the pin + KSPIN_COMMUNICATION_BOTH,//Specifies that the pin factory instantiates pins + //that are both IRP sinks and IRP sources + (GUID *) &PINNAME_BDA_TRANSPORT, //Category GUID + (GUID *) &PINNAME_BDA_TRANSPORT, //GUID of the localized Unicode string + 0 + }, +#if !defined(_BUILD_SW_TUNER_ON_X64) + KSPIN_FLAG_GENERATE_MAPPINGS | //Pin Flags +#endif + KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY, + 1,//Maximum Possible Instances of the Pin + 1,//Mandatory Instances of this for the Filter function + &CapturePinAllocatorFraming, + NULL + }, +}; + + +/*****************************************************************************************/ +//Define BDA Template Topology Connections +// +//Lists the Connections that are possible between pin types and +//node types. This, together with the Template Filter Descriptor, and +//the Pin Pairings, describe how topologies can be created in the filter. +// +// ================= +//TransportPin ----| Capture Filter | +// ================= +// +//The Capture Filter is controlled by the Transport input pin. +//Capture Filter properties will be set as NODE properties (with NodeType == 0) +//on the filter's Tranport Pin +// +const KSTOPOLOGY_CONNECTION SkyWalker1CaptureConnections[]={ + {KSFILTER_NODE, 0, KSFILTER_NODE, KSNODEPIN_STANDARD_IN}, //Transport pin -> Capture Filter pin 0 +}; + +/*****************************************************************************************/ + +//Define the Filter Factory Descriptor for the filter +//This structure brings together all of the structures that define +//the tuner filter as it appears when it is first instantiated. +//Note that not all of the template pin and node types may be exposed as +//pin and node factories when the filter is first instanciated. + +//The KSFILTER_DESCRIPTOR structure describes the characteristics of a filter created by a given filter factory. +DEFINE_KSFILTER_DESCRIPTOR(SkyWalker1CaptureFilterDescriptor) +{ + &SkyWalker1CaptureDispatchTable, //Dispatch (Filter Specific Driver) + NULL, //AutomationTable + KSFILTER_DESCRIPTOR_VERSION, //Version + 0, //Flags + &SKYWALKER_CAPTURE_FILTER, //ReferenceGuid + DEFINE_KSFILTER_PIN_DESCRIPTORS(SkyWalker1CapturePinDescriptors), + //PinDescriptorsCount; must expose at least one pin + //PinDescriptorSize; size of each item + //PinDescriptors; table of pin descriptors + DEFINE_KSFILTER_CATEGORY(KSCATEGORY_BDA_RECEIVER_COMPONENT), + //CategoriesCount; number of categories in the table + //Categories; table of categories + DEFINE_KSFILTER_NODE_DESCRIPTORS_NULL, + //NodeDescriptorsCount; + //NodeDescriptorSize; + //NodeDescriptors; + DEFINE_KSFILTER_CONNECTIONS(SkyWalker1CaptureConnections), + //Automatically fills in the connections table for a filter which defines no explicit connections + //ConnectionsCount; number of connections in the table + //Connections; table of connections + NULL //ComponentId; +}; + +//Array of BDA_PIN_PAIRING structures that are used to determine +//which nodes get duplicated when more than one output pin type is +//connected to a single input pin type or when more that one input pin +//type is connected to a single output pin type. +// +const BDA_PIN_PAIRING SkyWalker1CapturePinPairings[] = +{ + //Input pin to Output pin Topology Joints + // + { + 0, //ulInputPin; 0 element in the TemplatePinDescriptors array. + 1, //ulOutputPin; 1 element in the TemplatePinDescriptors array. + 1, //ulcMaxInputsPerOutput + 1, //ulcMinInputsPerOutput + 1, //ulcMaxOutputsPerInput + 1, //ulcMinOutputsPerInput + 0, //ulcTopologyJoints + NULL //pTopologyJoints; array of joints + } + //If applicable, list topology of joints between other pins. + // +}; + + +//BDA_FILTER_TEMPLATE structure describes the template topology for BDA Driver +const BDA_FILTER_TEMPLATE SkyWalker1CaptureTemplate = +{ + &SkyWalker1CaptureFilterDescriptor,//Pointer to KS_FILTER_DESCRIPTOR which describes the Filter for BDA Device + SIZEOF_ARRAY(SkyWalker1CapturePinPairings), //Number of PAIRS of pins in BDA_PIN_PAIRING Array + SkyWalker1CapturePinPairings //Array of Pin Pairing describes topology between a pair of Filter's Input and Output Pins +}; + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CapturePin.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CapturePin.cpp new file mode 100644 index 0000000..ad5680b --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1CapturePin.cpp @@ -0,0 +1,693 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1CapturePin.cpp + Author : + Date : + Purpose : This file contains header for the video capture pin on + the capture filter. + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Common For all the Definitions, + //Declarations and Library Routines + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +VOID PrintStream(IN PKSSTREAM_POINTER pStreamPointer); +/* End of Function prototype definitions */ + + +/***************************************************************************** + Function : CCapturePin + Description : Constructor of the CCapturePin Class + IN PARAM : NONE + OUT PARAM : NONE + PreCondition : pKSPin Object is not created + PostCondtion : pKSPin Object is created and Initialzed on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +CCapturePin::CCapturePin(IN PKSPIN pKSPin) : + m_Pin (pKSPin) +{ + PKSDEVICE pKSDevice = KsPinGetDevice (pKSPin); + + PrintFunctionEntry(__FUNCTION__); + + //Set up our device pointer. This gives us access to "Hardware I/O" + //during the capture routines. + m_Device = reinterpret_cast (pKSDevice->Context); + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); +} + +/***************************************************************************** + Function : CCapturePin + Description : Destructor of the CCapturePin Class + IN PARAM : NONE + OUT PARAM : NONE + PreCondition : pKSPin Object is created + PostCondtion : pKSPin Object is Removed and Memory freed + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +CCapturePin::~CCapturePin() +{ + PrintFunctionEntry(__FUNCTION__); + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); +} + +/***************************************************************************** + Function : CCapturePin::PinCreate + Description : An AVStream minidriver's AVStrMiniPinCreate routine is + called when a pin is created. Typically, this routine is + used by minidrivers that want to initialize the context + and resources associated with the pin. + IN PARAM : Pointer to the KSPIN that was just created. + Pointer to the IRP_MJ_CREATE for pKSPin + OUT PARAM : STATUS_SUCCESS in case of successful pin creation + Failure Code in other cases + PreCondition : None + PostCondtion : Create a new capture pin. This is the creation dispatch for + the video capture pin. + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CCapturePin::PinCreate ( IN PKSPIN pKSPin, + IN PIRP pIoRequestPacket + ) +{ + + NTSTATUS ntCreateStatus = STATUS_SUCCESS; + PBDA_TRANSPORT_INFO pTransportInfo = NULL; + CCapturePin *pCapturePin = new (NonPagedPool, CAPTURE_MEM_TAG) CCapturePin (pKSPin); + + PrintFunctionEntry(__FUNCTION__); + + if (!IS_VALID(pCapturePin)) + { + //Return failure if we couldn't create the pin. + ntCreateStatus = STATUS_INSUFFICIENT_RESOURCES; + + } + else + { + //Add the item to the object bag if we we were successful. + //Whenever the pin closes, the bag is cleaned up and we will be + //freed. + + ntCreateStatus = KsAddItemToObjectBag ( + pKSPin->Bag, + reinterpret_cast (pCapturePin), + reinterpret_cast (CCapturePin::Cleanup) + ); + + if (!NT_SUCCESS (ntCreateStatus)) + { + delete pCapturePin; + } + else + { + pKSPin->Context = reinterpret_cast (pCapturePin); + } + + } + + //If we succeeded so far, stash the video info header away and change + //our allocator framing to reflect the fact that only now do we know + //the framing requirements based on the connection format. + if (NT_SUCCESS (ntCreateStatus)) + { + + pTransportInfo = pCapturePin->CaptureBdaTransportInfo(); + if (!pTransportInfo) + { + ntCreateStatus = STATUS_INSUFFICIENT_RESOURCES; + } + } + + if (NT_SUCCESS (ntCreateStatus)) + { + //We need to edit the descriptor to ensure we don't mess up any other + //pins using the descriptor or touch read-only memory. + + ntCreateStatus = KsEdit (pKSPin, &pKSPin->Descriptor, CAPTURE_MEM_TAG); + + if (NT_SUCCESS (ntCreateStatus)) + { + ntCreateStatus = KsEdit ( + pKSPin, + &(pKSPin->Descriptor->AllocatorFraming), + CAPTURE_MEM_TAG + ); + } + + //If the edits proceeded without running out of memory, adjust + //the framing based on the video info header. + if (NT_SUCCESS (ntCreateStatus)) + { + + //We've KsEdit'ed this... I'm safe to cast away constness as + //long as the edit succeeded. + PKSALLOCATOR_FRAMING_EX pFraming = + const_cast ( + pKSPin->Descriptor-> AllocatorFraming + ); + + pFraming->FramingItem[0].Frames = NUMBER_OF_FRAMES; + + //The physical and optimal ranges must be biSizeImage. We only + //support one frame size, precisely the size of each capture + //image. + pFraming->FramingItem[0].PhysicalRange.MinFrameSize = + pFraming->FramingItem[0].PhysicalRange.MaxFrameSize = + pFraming->FramingItem[0].FramingRange.Range.MinFrameSize = + pFraming->FramingItem[0].FramingRange.Range.MaxFrameSize = + pTransportInfo->ulcbPhyiscalFrame; + + pFraming->FramingItem[0].PhysicalRange.Stepping = + pFraming->FramingItem[0].FramingRange.Range.Stepping = + 0; + + } + + } + + PrintFunctionExit(__FUNCTION__,ntCreateStatus); + return ntCreateStatus; + +} + +/***************************************************************************** + Function : CCapturePin::CaptureBdaTransportInfo + Description : Capture the video info header out of the connection format. + This is what we use to base synthesized images off. + IN PARAM : NONE + OUT PARAM : The captured video info header or + NULL if there is insufficient memory. + PreCondition : None + PostCondtion : Create a new capture pin. This is the creation dispatch for + the video capture pin. + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +PBDA_TRANSPORT_INFO CCapturePin::CaptureBdaTransportInfo() +{ + PrintFunctionEntry(__FUNCTION__); + + m_TransportInfo = reinterpret_cast ( + ExAllocatePoolWithTag ( + NonPagedPool, + sizeof(BDA_TRANSPORT_INFO), + CAPTURE_MEM_TAG + ) + ); + + if (!IS_VALID(m_TransportInfo)) + { + return NULL; + } + + //Bag the newly allocated header space. This will get cleaned up + //automatically when the pin closes. + NTSTATUS Status = + KsAddItemToObjectBag ( + m_Pin->Bag, + reinterpret_cast (m_TransportInfo), + NULL + ); + + if (!NT_SUCCESS (Status)) + { + ExFreePoolWithTag (m_TransportInfo, CAPTURE_MEM_TAG); + return NULL; + + } + else + { + m_TransportInfo->ulcbPhyiscalPacket = TRANSPORT_PACKET_SIZE; + m_TransportInfo->ulcbPhyiscalFrame = TRANSPORT_PACKET_SIZE * TRANSPORT_PACKET_COUNT; + m_TransportInfo->ulcbPhyiscalFrameAlignment = 1; + m_TransportInfo->AvgTimePerFrame = ((ULONGLONG)(19200)/* Maximum Sample Frequency */ * + 10000 /* Maximum Bits Per second */ * + NUMBER_OF_FRAMES) /*Maximum Channels */ / + (TRANSPORT_PACKET_SIZE * TRANSPORT_PACKET_COUNT); + + } + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + return m_TransportInfo; + +} + +/***************************************************************************** + Function : CCapturePin::CleanupReferences + Description : Clean up any references we're holding on frames after + we abruptly stop the hardware. + IN PARAM : NONE + OUT PARAM : Success / Failure + PreCondition : NONE + PostCondtion : NONE + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CCapturePin::CleanupReferences () +{ + PKSSTREAM_POINTER pCloneStream = KsPinGetFirstCloneStreamPointer(m_Pin); + PKSSTREAM_POINTER pNextCloneStream = NULL; + + PrintFunctionEntry(__FUNCTION__); + + //Walk through the clones, deleting them, and setting DataUsed to + //zero since we didn't use any data! + while (pCloneStream) + { + + pNextCloneStream = KsStreamPointerGetNextClone(pCloneStream); + + pCloneStream->StreamHeader->DataUsed = 0; + KsStreamPointerDelete (pCloneStream); + + pCloneStream = pNextCloneStream; + + } + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + return STATUS_SUCCESS; +} + +/***************************************************************************** + Function : CCapturePin::SetState + Description : This is called when the caputre pin transitions state. + The routine attempts to acquire / release any hardware + resources and start up or shut down capture based on + the states we are transitioning to and away from. + IN PARAM : ToState : The state we're transitioning to + FromState : The state we're transitioning away from + OUT PARAM : Success / Failure + PreCondition : NONE + PostCondtion : NONE + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CCapturePin::SetState ( + IN KSSTATE ToState, + IN KSSTATE FromState + ) +{ + + NTSTATUS ntSetStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + PrintDeviceChangeState(ToState,FromState); + + switch (ToState) + { + + case KSSTATE_STOP: + //Stopping the Device Operation + if (m_HardwareState != HardwareStopped) + { + ntSetStatus = m_Device->StopStream(); + m_HardwareState = HardwareStopped; + } + + + //The Device is Stopped + //It has cancelled the IRPs and Stopped the Streaming + //In case any Streaming Pointer is left Clean it up + ntSetStatus = CleanupReferences(); + + //Release any hardware resources related to this pin. + if (m_AcquiredResources) + { + //Release the Clock Reference on the Pin + if (m_Clock) + { + m_Clock->Release(); + m_Clock = NULL; + } + + m_Device->RemoveCaptureSink(); + m_AcquiredResources = FALSE; + } + break; + + case KSSTATE_ACQUIRE: + + //Acquire Hardware resources here instead of Filter + //Creation Time.So that the Filter creation does not + //Fail because of Limited Hardware resources. + if (FromState == KSSTATE_STOP) + { + ntSetStatus = m_Device->SetupCaptureSink(this,m_TransportInfo); + + if (NT_SUCCESS (ntSetStatus)) + { + m_AcquiredResources = TRUE; + + //Attempt to get an interface to the master clock. + //This will fail if one has not been assigned. Since + //one must be assigned while the pin is still in + //KSSTATE_STOP, this is a guranteed method of getting + //the clock should one be assigned. + + if (!NT_SUCCESS (KsPinGetReferenceClockInterface(m_Pin, + &m_Clock))) + { + //If we could not get an interface to the clock, + //don't use one. + SkyWalkerDebugPrint(ENTRY_LEVEL,("No Clock Assigned to the Pin\n")); + m_Clock = NULL; + + } + + } + else + { + m_AcquiredResources = FALSE; + } + + } + else + { + // + //Standard transport pins will always receive transitions in + //+/- 1 manner. This means we'll always see a PAUSE->ACQUIRE + //transition before stopping the pin. + // + //The below is done because on DirectX 8.0, when the pin gets + //a message to stop, the queue is inaccessible. The reset + //which comes on every stop happens after this (at which time + //the queue is inaccessible also). So, for compatibility with + //DirectX 8.0, I am stopping the hardware at this + //point and cleaning up all references we have on frames.See + //the comments above regarding the CleanupReferences call. + + if (m_HardwareState != HardwareStopped) + { + ntSetStatus = m_Device->StopStream(); + m_HardwareState = HardwareStopped; + } + + ntSetStatus = CleanupReferences (); + } + + break; + + case KSSTATE_PAUSE: + + //Stop the Streaming if we're coming down from run. + if (FromState == KSSTATE_RUN) + { + + ntSetStatus = m_Device->PauseStream(TRUE); + + if (NT_SUCCESS (ntSetStatus)) + { + m_HardwareState = HardwarePaused; + } + + } + break; + + case KSSTATE_RUN: + + //Start the Streaming or unpause it depending on + //whether we're initially running or we've paused and restarted. + if (m_HardwareState == HardwarePaused) + { + ntSetStatus = m_Device->PauseStream (FALSE); + } + else + { + ntSetStatus = m_Device->StartStream(); + } + + if (NT_SUCCESS (ntSetStatus)) + { + m_HardwareState = HardwareRunning; + } + + break; + + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Completed the State Change\n")); + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; + +} + +/***************************************************************************** + Function : CCapturePin::Process + Description : The process dispatch for the pin bridges to this location. + We handle setting up scatter gather mappings, etc... + IN PARAM : NONE + OUT PARAM : Success / Failure + PreCondition : NONE + PostCondtion : NONE + Logic : NONE + Assumption : NONE + Note : Future Approach for the Streaming Buffer + 1) Create a Buffer of Size Stream->Data/m_SampleSize Here + 2) Store the reference of the Newly Created Buffer into the + Stream Context + 3) Send the Buffer to the ReadStream(BufferPointer) + 4) When CompleteMapping is returned Copy Data from Stream + Context to Stream->Data + Revision History: + *****************************************************************************/ +NTSTATUS CCapturePin::Process() +{ + NTSTATUS ntProcessStatus = STATUS_SUCCESS; + PKSSTREAM_POINTER pLeadingStream = NULL; + PKSSTREAM_POINTER pCloneStream = NULL; + PSTREAM_POINTER_CONTEXT pStreamContext = NULL; + + PrintFunctionEntry(__FUNCTION__); + + pLeadingStream = KsPinGetLeadingEdgeStreamPointer ( + m_Pin, + KSSTREAM_POINTER_STATE_LOCKED + ); + + + if( !pLeadingStream ) + { + //no system buffer available + //This case can happen if it is the last pointer in the queue or + //the system cannot give us the required buffer + SkyWalkerDebugPrint(ENTRY_LEVEL,("Warning: No system buffer available\n")); + ntProcessStatus = STATUS_UNSUCCESSFUL; + goto CompleteProcessing; + } + else + { + + //First thing we need to do is clone the leading edge. This allows + //us to keep reference on the frames while they're in DMA. + ntProcessStatus = KsStreamPointerClone ( + pLeadingStream, + NULL, + sizeof (STREAM_POINTER_CONTEXT), + &pCloneStream + ); + + if( !NT_SUCCESS(ntProcessStatus) ) + { + //No System Buffer Available + SkyWalkerDebugPrint(ENTRY_LEVEL, + ("Error: Streampointer cloning unsuccessful\n")); + ntProcessStatus = STATUS_UNSUCCESSFUL; + goto CompleteProcessing; + } + + //Is the buffer size correct + if( pCloneStream->StreamHeader->FrameExtent < + (static_cast (m_TransportInfo->ulcbPhyiscalFrame)) ) + { + //Buffer size incorrect + KsStreamPointerDelete(pCloneStream); //void function + SkyWalkerDebugPrint(ENTRY_LEVEL,("Error: Buffer size Incorrect\n")); + ntProcessStatus = STATUS_UNSUCCESSFUL; + goto CompleteProcessing; + } + + //Set the stream header data used to 0. We update this + //in the USB Data Read completions. + pCloneStream->StreamHeader->DataUsed = 0; + + pStreamContext = reinterpret_cast + (pCloneStream->Context); + + //Set the Stream Index + pStreamContext->ulFrameIndex = m_CurrentFrameIndex; + + PrintStream(pLeadingStream); + + //(Refer NOTE above) Create a Stream Buffer Here and Submit + //it for the Reading / DMA + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Current Stream Index = %lu",m_CurrentFrameIndex)); + m_Device->ReadStream(m_CurrentFrameIndex); + m_CurrentFrameIndex = (m_CurrentFrameIndex+1) % NUMBER_OF_FRAMES; + + //Advance Stream pointer to the next available data frame + ntProcessStatus = KsStreamPointerAdvance(pLeadingStream); + + if( (ntProcessStatus != STATUS_DEVICE_NOT_READY) && + (ntProcessStatus != STATUS_SUCCESS) ) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, + ("Error: Video Capture Streampointer Advacement Failed\n")); + } + } + +CompleteProcessing: + + PrintFunctionExit(__FUNCTION__,ntProcessStatus); + return ntProcessStatus; +} + +/***************************************************************************** + Function : CCapturePin::ReleaseStream + Description : Called to notify the pin that a given Stream is completed + IN PARAM : The Stream Index + OUT PARAM : NONE + PreCondition : NONE + PostCondtion : Stream data is filled from the Internal Stream Buffer + Other Stream Parameters are set and Clone is Deleted + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +void CCapturePin::ReleaseStream(IN ULONG ulStreamIndex) +{ + + PrintFunctionEntry(__FUNCTION__); + + //Walk through the clones list and delete clones whose time has come. + //The list is guaranteed to be kept in the order they were cloned. + SkyWalkerDebugPrint(EXTREME_LEVEL,("Completing Stream %lu\n",ulStreamIndex)); + + PKSSTREAM_POINTER pCloneStream = KsPinGetFirstCloneStreamPointer (m_Pin); + SkyWalkerDebugPrint(EXTREME_LEVEL,("Clone Stream pointer = 0x%p\n",pCloneStream)); + + if(pCloneStream) + { + //Copy the Stream data from the Corresponding Streaming Buffer + RtlCopyMemory((PUCHAR)pCloneStream->StreamHeader->Data, + m_Device->GetSynthBuffer(ulStreamIndex), + m_TransportInfo->ulcbPhyiscalFrame); + + pCloneStream->StreamHeader->DataUsed = m_TransportInfo->ulcbPhyiscalFrame; + + SkyWalkerDebugPrint(EXTREME_LEVEL,("pCloneStream->StreamHeader->DataUsed = " + "%lu\n", + pCloneStream->StreamHeader->DataUsed)); + + pCloneStream->StreamHeader->Duration = m_TransportInfo->AvgTimePerFrame; + + pCloneStream->StreamHeader->PresentationTime.Numerator = + pCloneStream->StreamHeader->PresentationTime.Denominator = 1; + + //If a clock has been assigned, timestamp the packets with the + //time shown on the clock. + if (m_Clock) + { + + LONGLONG ClockTime = m_Clock->GetTime (); + pCloneStream->StreamHeader->PresentationTime.Time = ClockTime; + pCloneStream->StreamHeader->OptionsFlags = + KSSTREAM_HEADER_OPTIONSF_TIMEVALID | + KSSTREAM_HEADER_OPTIONSF_DURATIONVALID; + + } + else + { + + //If there is no clock, don't time stamp the packets. + pCloneStream->StreamHeader->PresentationTime.Time = 0; + + } + + PrintStream(pCloneStream); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Stream Processed thus deleting the Clone\n")); + KsStreamPointerDelete (pCloneStream); + + } + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + +} + +VOID PrintStream(IN PKSSTREAM_POINTER pStreamPointer) +{ + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->Context = 0x%p\n",pStreamPointer->Context)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->Pin = 0x%p\n",pStreamPointer->Pin)); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader = 0x%p\n",pStreamPointer->StreamHeader)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->Size = %lu\n",pStreamPointer->StreamHeader->Size)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->TypeSpecificFlags = %lu\n",pStreamPointer->StreamHeader->TypeSpecificFlags)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->PresentationTime.Time= %l\n",pStreamPointer->StreamHeader->PresentationTime.Time)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->PresentationTime.Numerator= %lu\n",pStreamPointer->StreamHeader->PresentationTime.Numerator)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->PresentationTime.Denominator= %lu\n",pStreamPointer->StreamHeader->PresentationTime.Denominator)); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->Duration = %l\n",pStreamPointer->StreamHeader->Duration)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->FrameExtent = %lu\n",pStreamPointer->StreamHeader->FrameExtent)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->DataUsed = %lu\n",pStreamPointer->StreamHeader->DataUsed)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->Data = 0x%p\n",pStreamPointer->StreamHeader->Data)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->StreamHeader->OptionsFlags = %lu\n",pStreamPointer->StreamHeader->OptionsFlags)); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->Offset = 0x%p\n",pStreamPointer->Offset)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->Offset->Data = 0x%p\n",pStreamPointer->Offset->Data)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->Offset->Mappings = 0x%p\n",pStreamPointer->Offset->Mappings)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->Offset->Count = %lu\n",pStreamPointer->Offset->Count)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->Offset->Remaining = %lu\n",pStreamPointer->Offset->Remaining)); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->OffsetIn.Data = 0x%p\n",pStreamPointer->OffsetIn.Data)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->OffsetIn.Mappings = 0x%p\n",pStreamPointer->OffsetIn.Mappings)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->OffsetIn.Count = %lu\n",pStreamPointer->OffsetIn.Count)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->OffsetIn.Remaining = %lu\n",pStreamPointer->OffsetIn.Remaining)); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->OffsetOut.Data = 0x%p\n",pStreamPointer->OffsetOut.Data)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->OffsetOut.Mappings = 0x%p\n",pStreamPointer->OffsetOut.Mappings)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->OffsetOut.Count = %lu\n",pStreamPointer->OffsetOut.Count)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamPointer->OffsetOut.Remaining = %lu\n",pStreamPointer->OffsetOut.Remaining)); +} \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Control.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Control.cpp new file mode 100644 index 0000000..0f698d2 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Control.cpp @@ -0,0 +1,704 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Control.cpp + Author : + Date : + Purpose : This File Holds the Device Control related declarations + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Common For all the Definitions, + //Declarations and Library Routines + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +VOID PrintDiseqcCommand(PDISEQC_COMMAND pDiseqcCommand); +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : GetSignalStatus + Description : This Function Get the Signal Lock Status + IN PARAM : Pointer to the KSDevice Object + true in case of Signal Locked else False + OUT PARAM : STATUS_SUCCESS in case of successful Lock Read + Failure Code in other cases + PreCondition : None + PostCondtion : Gets the Signal Lock Status in case of successful execution + Logic : NONE + Assumption : NONE + Note : None + Revision History: + *****************************************************************************/ +NTSTATUS GetSignalStatus( IN PKSDEVICE pKSDeviceObject, + OUT PBOOLEAN pbSignalLockStatus + ) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + UCHAR ucSignalStatus = 0; + + PrintFunctionEntry(__FUNCTION__); + + //gp8psk_usb_in_op(st->d, GET_SIGNAL_LOCK, 0, 0, &lock,1) + ntStatus = ControlUsbDevice( pKSDeviceObject, + GET_SIGNAL_LOCK, + 0, + 0, + &ucSignalStatus, + 1, + true); + if(NT_SUCCESS(ntStatus)) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("ucSignalStatus = 0x%02X\n",ucSignalStatus)); + + if(ucSignalStatus) + { + *pbSignalLockStatus = TRUE; + } + else + { + *pbSignalLockStatus = FALSE; + } + } + + //if (lock) + // *status = FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_SIGNAL | FE_HAS_CARRIER; + //else + // *status = 0; + + if(ucSignalStatus) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Signal Lock = 0x%02X\n",*pbSignalLockStatus)); + } + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; + +} + +/***************************************************************************** + Function : ReadTunerSignalStrength + Description : This Function reads the Tuner Signal Strength + IN PARAM : Pointer to the KSDevice Object + Pointer to hold the Signal Strength + OUT PARAM : STATUS_SUCCESS in case of successful read + Failure Code in other cases + PreCondition : None + PostCondtion : Reads the Signal Strength + Logic : NONE + Assumption : NONE + Note : None + Revision History: + *****************************************************************************/ +NTSTATUS ReadTunerSignalStrength( IN PKSDEVICE pKSDeviceObject, + OUT PULONG pulSigStrength + ) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + UCHAR ucBuffer[6] = {0,0,0,0,0,0}; + ULONG ulSignalStrength = 0L; + + PrintFunctionEntry(__FUNCTION__); + + //gp8psk_usb_in_op(st->d, GET_SIGNAL_STRENGTH, 0,0,buf,6); + ntStatus = ControlUsbDevice( pKSDeviceObject, + GET_SIGNAL_STRENGTH, + 0, + 0, + ucBuffer, + 6, + true); + if(NT_SUCCESS(ntStatus)) + { + ulSignalStrength = (int)(ucBuffer[1]) << 8 | ucBuffer[0]; + SkyWalkerDebugPrint(EXTREME_LEVEL,("ulSignalStrength = %lu,ucBuffer[1] = 0x%02X, ucBuffer[2] = 0x%02X\n", + ulSignalStrength,ucBuffer[1],ucBuffer[0])); + //*pulSigStrength = (int)(ucBuffer[1]) << 8 | ucBuffer[0]; + /* snr is reported in dBu*256 */ + /* snr / 38.4 ~= 100% strength */ + /* snr * 17 returns 100% strength as 65535 */ + if (ulSignalStrength <= 0x0F00) + { + *pulSigStrength = (ulSignalStrength <<4) + ulSignalStrength; + } + else + { + *pulSigStrength = 0xFFFF; + } + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Signal Strength = %lu\n",*pulSigStrength)); + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; + +} + +/***************************************************************************** + Function : SetLnbVoltage + Description : This Function Sets the LNB Voltage + IN PARAM : Pointer to the KSDevice Object + Voltage to set 1 for 18V and 0 for 13V + OUT PARAM : STATUS_SUCCESS in case of successful Set + Failure Code in other cases + PreCondition : None + PostCondtion : Sets the LNB Voltage in case of successful execution + Logic : NONE + Assumption : NONE + Note : None + Revision History: + *****************************************************************************/ +NTSTATUS SetLnbVoltage(IN PKSDEVICE pKSDeviceObject, + IN UCHAR ucVoltage) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("New Lnb Voltage (0 = 13V, 1 = 18V) = %02d \n",ucVoltage)); + + //gp8psk_usb_out_op(state->d,SET_LNB_VOLTAGE, + // voltage == SEC_VOLTAGE_18, 0, NULL, 0) + ntStatus = ControlUsbDevice( pKSDeviceObject, + SET_LNB_VOLTAGE, + (ucVoltage == SEC_VOLTAGE_18), + 0, + NULL, + 0, + false); + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; + + +} + + +/***************************************************************************** + Function : TuneDevice + Description : This Function Tunes the Tuner + IN PARAM : Pointer to the KSDevice Object + Tuner parameters to set + OUT PARAM : STATUS_SUCCESS in case of successful Set + Failure Code in other cases + PreCondition : None + PostCondtion : Tuners the Tuner in case of successful execution + Logic : NONE + Assumption : NONE + Note : To tune the Tuner following command needs to be sent + 9 8 7 6 5 4 3 2 1 0 +================================================================================= +| FECR | MOD | TFQ0 | TFQ0 | TFQ0 | TFQ0 | SBR3 | SBR2 | SBR1 | SBR0 | +================================================================================= +Where FECR -> Inner FEC Rate (1 Byte) +MOD = Modulation = QPSK (1 Byte) +TF = Tuner Frequency (4 Bytes) +SBR = Symbol Rate (4 Bytes) + + Revision History: + *****************************************************************************/ +NTSTATUS TuneDevice(IN PKSDEVICE pKSDeviceObject, + IN PBDATUNER_DEVICE_PARAMETER pDeviceParameter) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + UCHAR ucCommand[10]; + ULONG ulTempFrequency = 0L; + ULONG ulTunerFrequency = 0L; + ULONG ulLOFrequency = 0L; + ULONG ulTempSymbolRate = 0L; + + PrintFunctionEntry(__FUNCTION__); + + //Setting the Local Oscillator Frequency + if(pDeviceParameter->ulLnbSwitchFrequency >= pDeviceParameter->ulCarrierFrequency) + { + ulLOFrequency = pDeviceParameter->ulLnbLowLOFrequency; + } + else + { + ulLOFrequency = pDeviceParameter->ulLnbHighLOFrequency; + } + + //Getting the Frequency to be tuned based on the Carrier frequency and + //Local Oscillator frequency (LOF) + if(pDeviceParameter->ulCarrierFrequency > ulLOFrequency) + { + ulTempFrequency = pDeviceParameter->ulCarrierFrequency - ulLOFrequency; + } + else + { + ulTempFrequency = ulLOFrequency - pDeviceParameter->ulCarrierFrequency; + } + + if( (ulTempFrequency < TUNER_FREQ_MIN) || + (ulTempFrequency > TUNER_FREQ_MAX)) + { + SkyWalkerDebugPrint(EXTREME_LEVEL, + ("Frequency Out of Bound %lu, Resetting to %lu\n", + ulTempFrequency,TUNER_FREQ_MIN)); + ulTempFrequency = TUNER_FREQ_MIN; + } + ulTunerFrequency= ulTempFrequency * pDeviceParameter->ulFrequencyMultiplier; + + //Symbol Rate should be in Sample Per Second thus converting the + //Kilo Samples per Second (ksps) to Samples Per Second (sps) + ulTempSymbolRate = pDeviceParameter->ulSymbolRate * 1000; + + SkyWalkerDebugPrint(EXTREME_LEVEL,("New Symbol Rate = %lu sps (%lu ksps)\n" + "Carrier Frequency = %lu\n" + "Local Oscillator Freq = %lu\n" + "Frequency Multiplier = %lu\n" + "Tuner Frequency = %lu\n" + "New Modulation Type (QPSK = 0)= %lu\n" + "New FEC Rate (VITERBI = 1)= %lu \n", + ulTempSymbolRate, + pDeviceParameter->ulSymbolRate, + pDeviceParameter->ulCarrierFrequency, + ulLOFrequency, + pDeviceParameter->ulFrequencyMultiplier, + ulTunerFrequency, + ADV_MOD_DVB_QPSK, + pDeviceParameter->InnerFecRate)); + + ucCommand[0] = (UCHAR)(ulTempSymbolRate & 0xFF); + ucCommand[1] = (UCHAR)((ulTempSymbolRate >> 8) & 0xFF); + ucCommand[2] = (UCHAR)((ulTempSymbolRate >> 16) & 0xFF); + ucCommand[3] = (UCHAR)((ulTempSymbolRate >> 24) & 0xFF); + + ucCommand[4] = (UCHAR)(ulTunerFrequency & 0xFF); + ucCommand[5] = (UCHAR)((ulTunerFrequency >> 8) & 0xFF); + ucCommand[6] = (UCHAR)((ulTunerFrequency >> 16) & 0xFF); + ucCommand[7] = (UCHAR)((ulTunerFrequency >> 24) & 0xFF); + + ucCommand[8] = ADV_MOD_DVB_QPSK; + ucCommand[9] = 0x05; + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Tune Command : Symbol Rate = 0x%02X%02X%02X%02X," + "Frequency = 0x%02X%02X%02X%02X", + ucCommand[3],ucCommand[2],ucCommand[1],ucCommand[0], + ucCommand[7],ucCommand[6],ucCommand[5],ucCommand[4])); + + //gp8psk_usb_out_op(state->d,TUNE_8PSK,0,0,cmd,10); + ntStatus = ControlUsbDevice( pKSDeviceObject, + TUNE_8PSK, + 0, + 0, + ucCommand, + 10, + false); + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : SetupTunerPower + Description : Function to used to Setup the SkyWalker1 Device Power + IN PARAM : Pointer to Device Object which needs Power setup + Switch on / Switch Off + OUT PARAM : ntStatus of the SkyWalker1 Power Setup + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Device ready for the Operation + Logic : Linux Method to Setup the Device + 1) Download Firmware (Not done here) + 2) Set Power State to ON + 3) Read 8PSK Config ntStatus + 4) if(Device not Started) then Start it + 5) if(BCM4500 Firmware not loaded) then load it + 6) if (LNB Power not set) then Set it + 7) Set DVB_MODE to 1 + 8) Read Again the 8PSK Config ntStatus + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS SetupTunerPower( IN PKSDEVICE pKSDeviceObject, + IN BOOLEAN bOnOff) +{ + + NTSTATUS ntStatus = STATUS_SUCCESS; + UCHAR ucDeviceConfig = 0; + UCHAR ucBuffer = 0; + + PrintFunctionEntry(__FUNCTION__); + + if (bOnOff) + { + //If Tuner Power On + + //Read the Tuner Configuration First + //gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1); + ntStatus = ControlUsbDevice( pKSDeviceObject, + GET_8PSK_CONFIG, + 0, + 0, + &ucDeviceConfig, + 1, + true); + + if(!NT_SUCCESS(ntStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to Read the Device Configuration\n")); + goto ExitSetupPower; + + } + + SkyWalkerDebugPrint(EXTREME_LEVEL, + ("Device Status Bit0:Device Start,Bit1:Firmware Loaded," \ + "Bit2:LNB Powerup = 0x%02X\n", + ucDeviceConfig)); + + if (!(ucDeviceConfig & bm8pskStarted)) /* Device Start ntStatus BIT-0 */ + { + //Device Not Started + //Send the Boot Command to the Device + //gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1)) + ntStatus = ControlUsbDevice( pKSDeviceObject, + BOOT_8PSK, + 1, + 0, + &ucBuffer, + 1, + true); + if(!NT_SUCCESS(ntStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to Boot the Device\n")); + goto ExitSetupPower; + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Boot Response 0x%02X\n",ucBuffer)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("Device Bootedup\n")); + + } + + if (!(ucDeviceConfig & bm8pskFW_Loaded)) /* Firmware ntStatus BIT-1 */ + { + //Firmware Not Loaded + SkyWalkerDebugPrint(ENTRY_LEVEL,("Firmware not Loaded\n")); + } + + if (!(ucDeviceConfig & bmIntersilOn)) /* LNB Power Status BIT-2 */ + { + //LNB Not powered On + //Sent the Power On Command to the LNB + ucBuffer = 0; + //gp8psk_usb_in_op(d, START_INTERSIL, 1, 0,&buf, 1)) + ntStatus = ControlUsbDevice( pKSDeviceObject, + START_INTERSIL, + 1, + 0, + &ucBuffer, + 1, + true); + if(!NT_SUCCESS(ntStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to Powerup the Device\n")); + goto ExitSetupPower; + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("LNB Powerup Response 0x%02X\n",ucBuffer)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("Device Poweredup\n")); + + } + + /* Abort possible TS (if previous tune crashed) */ + //gp8psk_usb_out_op(d, ARM_TRANSFER, 0, 0, NULL, 0) + ntStatus = ControlUsbDevice( pKSDeviceObject, + ARM_TRANSFER, + 0, + 0, + NULL, + 0, + false); + + //Reread the Device Configuration + //gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1); + ntStatus = ControlUsbDevice( pKSDeviceObject, + GET_8PSK_CONFIG, + 0, + 0, + &ucDeviceConfig, + 1, + true); + + if(!NT_SUCCESS(ntStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to Read the Device Configuration\n")); + goto ExitSetupPower; + + } + + SkyWalkerDebugPrint(EXTREME_LEVEL, + ("Device ntStatus Bit0:Device Start,Bit1:Firmware Loaded," \ + "Bit2:LNB Powerup = 0x%02X\n", + ucDeviceConfig)); + + + } + else + { + //Turn Off LNB Power + //gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1) + ucBuffer = 0; + ntStatus = ControlUsbDevice( pKSDeviceObject, + START_INTERSIL, + 0, + 0, + &ucBuffer, + 1, + true); + if(!NT_SUCCESS(ntStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to Powerdown the LNB\n")); + goto ExitSetupPower; + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("LNB Powerdown Response 0x%02X\n",ucBuffer)); + + //Turn Off 8PSK Power + //gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1) + ucBuffer = 0; + ntStatus = ControlUsbDevice( pKSDeviceObject, + BOOT_8PSK, + 0, + 0, + &ucBuffer, + 1, + true); + if(!NT_SUCCESS(ntStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to Powerdown the SkyWalker1\n")); + goto ExitSetupPower; + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Tuner Powerdown Response 0x%02X\n",ucBuffer)); + } + +ExitSetupPower: + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; + +} +/***************************************************************************** + Function : SetStreamingControl + Description : This Function Enables / Disables the Streaming + IN PARAM : Pointer to the KSDevice Object + Streaming Control 1 for ON and 0 for OFF + OUT PARAM : STATUS_SUCCESS in case of successful Set + Failure Code in other cases + PreCondition : None + PostCondtion : Controls Streaming in case of successful execution + Logic : NONE + Assumption : NONE + Note : None + Revision History: + *****************************************************************************/ +NTSTATUS SetStreamingControl( IN PKSDEVICE pKSDeviceObject, + IN UCHAR ucOnOff) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Streaming Control (0 = OFF, 1 = ON) = %02d \n",ucOnOff)); + + //gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0); + ntStatus = ControlUsbDevice( pKSDeviceObject, + ARM_TRANSFER, + ucOnOff, + 0, + NULL, + 0, + false); + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : SetTunerTone + Description : This Function Sets the Tuner Tone + IN PARAM : Pointer to the KSDevice Object + Tuner Tone : 0 for TONE ON and 1 for TONE OFF + OUT PARAM : STATUS_SUCCESS in case of successful Set + Failure Code in other cases + PreCondition : None + PostCondtion : Sets the Tuner Tone in case of successful execution + Logic : NONE + Assumption : NONE + Note : None + Revision History: + *****************************************************************************/ +NTSTATUS SetTunerTone( IN PKSDEVICE pKSDeviceObject, + IN UCHAR ucTone) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Tuner Tone (0 = TONE_ON, 1 = TONE_OFF) = %02d \n",ucTone)); + + //gp8psk_usb_out_op(state->d,SET_22KHZ_TONE, + // (tone == SEC_TONE_ON), 0, NULL, 0) + ntStatus = ControlUsbDevice( pKSDeviceObject, + SET_22KHZ_TONE, + (ucTone == 0), + 0, + NULL, + 0, + false); + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : ConfigureTuner + Description : This Function Configures Tuner Frequency, Polarity, + Symbol Rate, Tone etc. + IN PARAM : Pointer to the KSDevice Object + Configuration to tune + OUT PARAM : STATUS_SUCCESS in case of successful Set + Failure Code in other cases + PreCondition : None + PostCondtion : Configures the Tuner with the COnfiguration provided + Logic : NONE + Assumption : NONE + Note : None + Revision History: + *****************************************************************************/ +NTSTATUS ConfigureTuner(IN PKSDEVICE pKSDeviceObject, + IN PBDATUNER_DEVICE_PARAMETER pNewConfiguration) +{ + + NTSTATUS ntStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + //Set the LNB Voltage based on the Polarity + if((pNewConfiguration->Polarity == BDA_POLARISATION_LINEAR_H) || + (pNewConfiguration->Polarity == BDA_POLARISATION_CIRCULAR_L)) + { + //Set the LNB Voltage to 18 Volts + ntStatus = SetLnbVoltage(pKSDeviceObject,SEC_VOLTAGE_18); + } + else + { + //Set the LNB Voltage to 13 Volts + ntStatus = SetLnbVoltage(pKSDeviceObject,SEC_VOLTAGE_13); + } + if(NT_SUCCESS(ntStatus)) + { + ntStatus = SetTunerTone(pKSDeviceObject,SEC_TONE_OFF); + if(NT_SUCCESS(ntStatus)) + { + //Configure the updated resource on the hardware here. + ntStatus = TuneDevice(pKSDeviceObject,pNewConfiguration); + } + } + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : DiseqcCommand + Description : This Function Sends Diseqc Command to the Tuner + IN PARAM : Pointer to the KSDevice Object + Command to be sent to the Device + OUT PARAM : STATUS_SUCCESS in case of successful Set + Failure Code in other cases + PreCondition : None + PostCondtion : Diseqc Command sent to the Tuner + Logic : 1) Validate the Diseqc Message + 2) Check the Diseqc Message Length + 3) If length == 1 + Treat the Diseqc Command as the Simple Tone Burst + 4) Else + Treat it as normal Diseqc Command + Assumption : NONE + Note : None + Revision History: + *****************************************************************************/ +NTSTATUS DiseqcCommand( IN PKSDEVICE pKSDeviceObject, + IN PDISEQC_COMMAND pCommand) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + if( !IS_VALID(pCommand) || + (pCommand->ucMessageLength == 0) || + (pCommand->ucMessageLength == 2) || + (pCommand->ucMessageLength > MAX_DISEQC_COMMAND_LENGTH)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Invalid Diseqc Command Received \n")); + ntStatus = STATUS_INVALID_PARAMETER; + goto ExitDiseqcCommand; + } + + if(pCommand->ucMessageLength == 1) + { + //Simple Tone Burst + UCHAR ucBurst = (pCommand->ucMessage[0] == SEC_MINI_A) ? 0x00 : 0x01; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Sending Simple Tone Burst Command = 0x%02X \n",ucBurst)); + //gp8psk_usb_out_op(st->d,SEND_DISEQC_COMMAND, cmd, 0,&cmd, 0) + ntStatus = ControlUsbDevice( pKSDeviceObject, + SEND_DISEQC_COMMAND, + ucBurst, + 0, + &ucBurst, + 0, + false); + + } + else + { + //Normal Diseqc Command + SkyWalkerDebugPrint(EXTREME_LEVEL,("Sending Normal Diseqc Command\n")); + PrintDiseqcCommand(pCommand); + //gp8psk_usb_out_op(st->d,SEND_DISEQC_COMMAND, m->msg[0], 0,m->msg, m->msg_len) + ntStatus = ControlUsbDevice( pKSDeviceObject, + SEND_DISEQC_COMMAND, + pCommand->ucMessage[0], + 0, + pCommand->ucMessage, + pCommand->ucMessageLength, + false); + + } + +ExitDiseqcCommand: + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +VOID PrintDiseqcCommand(PDISEQC_COMMAND pDiseqcCommand) +{ + if(pDiseqcCommand) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("pDiseqcCommand->ucMessage[0] = 0x%02X\n",pDiseqcCommand->ucMessage[0])); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pDiseqcCommand->ucMessage[1] = 0x%02X\n",pDiseqcCommand->ucMessage[1])); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pDiseqcCommand->ucMessage[2] = 0x%02X\n",pDiseqcCommand->ucMessage[2])); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pDiseqcCommand->ucMessage[3] = 0x%02X\n",pDiseqcCommand->ucMessage[3])); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pDiseqcCommand->ucMessage[4] = 0x%02X\n",pDiseqcCommand->ucMessage[4])); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pDiseqcCommand->ucMessage[5] = 0x%02X\n",pDiseqcCommand->ucMessage[5])); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pDiseqcCommand->ucMessageLength = %02u\n",pDiseqcCommand->ucMessageLength)); + } +} \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Device.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Device.cpp new file mode 100644 index 0000000..9464d05 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Device.cpp @@ -0,0 +1,1142 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Device.cpp + Author : + Date : + Purpose : Main Skywalker Device level Implementation + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Header for the Tuner related definitions + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +static ULONG ulDeviceInstance = 0; +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +void PrintDMAAdapter(PDMA_ADAPTER pDMAAdapter); +void PrintMappingInfo(IN PKSMAPPING pMapping); + +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : CSkyWalker1Device::Create + Description : This Function is called during the Add Device IRP Processing + IN PARAM : Pointer to the Enumerated Physical Device + KSDEVICE is a WDM Functional Device which is managed by the AVStream + OUT PARAM : ntStatus of the Device Addition + STATUS_SUCCESS when the Device added to the System + Reason for Failure incase of Error + PreCondition : Driver is Loaded without Functional/ Filter Device Objects + PostCondtion : Functional Device Object [FDO] or Filter Device Object [FiDO] are created + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::Create(IN PKSDEVICE pKSDeviceObject) +{ + NTSTATUS ntCreateStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if (pKSDeviceObject) + { + + //Point the KSDEVICE at our device class. + pKSDeviceObject->Context = this; + + m_pKSDevice = pKSDeviceObject; + + //Make the resource available for a filter to use. + m_ulcResourceUsers = 0; + m_ulCurResourceID = 0; + + //Get the instance number of this device. + m_ulDeviceInstance = ulDeviceInstance++; + + //Hold requests until the device is started + QueueState = HoldRequests; + + //Initialize the stop event to signaled. + KeInitializeEvent(&EvDeviceStopOk, //PKEVENT + NotificationEvent, //Type + TRUE); //State + + //Initialize the remove event to not-signaled. + KeInitializeEvent(&EvDeviceRemoveOk, //PKEVENT + NotificationEvent, //Type + FALSE); //State + + //The KeInitializeSpinLock routine initializes a variable of + //type KSPIN_LOCK. + KeInitializeSpinLock(&DeviceStateLock); + INITIALIZE_PNP_STATE(this); + + //OutstandingIo count biased to 1. + //Transition to 0 during remove device means IO is finished. + //Transition to 1 means the device can be stopped + + ulOutStandingIoCount = 1; + KeInitializeSpinLock(&kIoCountLock); + + } + else + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Invalid KS Device Object Received\n")); + ntCreateStatus = STATUS_INVALID_PARAMETER; + } + + PrintFunctionExit(__FUNCTION__,ntCreateStatus); + return ntCreateStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::Start + Description : This function Initializes the Tuner Hardware + IN PARAM : Reference to Device to be Started + IoRequest Packet + Resource List + Translated Resource List + OUT PARAM : ntStatus of the Tuner Start + STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : Stopped Device or Device Enumerated for the First Time + PostCondtion : Device Initialized with the Newly allocated Resources, + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ + +NTSTATUS CSkyWalker1Device::Start( + IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket, + IN PCM_RESOURCE_LIST pResourceList OPTIONAL, + IN PCM_RESOURCE_LIST pTranslatedResourceList OPTIONAL + ) +{ + NTSTATUS ntStartStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = NULL; + PKSFILTERFACTORY pKSFilterFactory = NULL; + + PrintFunctionEntry(__FUNCTION__); + + pDevice = reinterpret_cast(pKSDeviceObject->Context); + + //Initialize the Tuner Hardware. + ntStartStatus = pDevice->InitializeTuner(pKSDeviceObject,pIoRequestPacket); + SkyWalkerDebugPrint(EXTREME_LEVEL,("USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE = %d",USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE)); + + if (ntStartStatus == STATUS_SUCCESS) + { + //Create the the Filter Factory. This factory is used to + //create instances of the filter. + ntStartStatus = BdaCreateFilterFactoryEx( + pKSDeviceObject, + &SkyWalker1TunerFilterDescriptor, + &TunerFilterTemplate, + &pKSFilterFactory + ); + } + + if ((ntStartStatus == STATUS_SUCCESS) && pKSFilterFactory) + { + BdaFilterFactoryUpdateCacheData( + pKSFilterFactory, + TunerFilterTemplate.pFilterDescriptor + ); + } + + + PrintFunctionExit(__FUNCTION__,ntStartStatus); + return ntStartStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::Stop + Description : This routine is invoked when the device is stopped. + This routine services Irp of minor type IRP_MN_STOP_DEVICE + IN PARAM : Pointer to KS Device Object + STOP DEVICE Irp + OUT PARAM : ntStatus of the Device Stop + STATUS_SUCCESS on Successful execution + else Error + PreCondition : NONE + PostCondtion : USB Device Stopped + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::Stop( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntDeviceStopStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + if(m_pDMAAdapter) + { + m_pDMAAdapter->DmaOperations->PutDmaAdapter(m_pDMAAdapter); + m_pDMAAdapter = NULL; + } + + //Maintain the USB ntStatus i.e Remove the Selected Configuration by sending Null descriptor + ntDeviceStopStatus = StopUsbDevice(pKSDeviceObject,pIoRequestPacket); + + PrintFunctionExit(__FUNCTION__,ntDeviceStopStatus); + + return ntDeviceStopStatus; +} + + +/***************************************************************************** + Function : CSkyWalker1Device::Close + Description : This routine is invoked when the device is Removed. + This routine services Irp of minor type IRP_MN_REMOVE_DEVICE + IN PARAM : Pointer to KS Device Object + STOP DEVICE Irp + OUT PARAM : ntStatus of the Device Remove + STATUS_SUCCESS on Successful execution + else Error + PreCondition : NONE + PostCondtion : USB Device Removed + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::Close( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntDeviceCloseStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + ntDeviceCloseStatus = RemoveUsbDevice(pKSDeviceObject,pIoRequestPacket); + + PrintFunctionExit(__FUNCTION__,ntDeviceCloseStatus); + + return ntDeviceCloseStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::SetPower + Description : This routine is invoked when the Power Irp is received + This routine services Irp of minor type IRP_MJ_POWER + IN PARAM : Pointer to KS Device Object + STOP DEVICE Irp + OUT PARAM : ntStatus of the Set POwer + STATUS_SUCCESS on Successful execution + else Error + PreCondition : NONE + PostCondtion : Power Condition Managed + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::SetPower( + IN PKSDEVICE pKSDeviceObject, //Pointer to the device object + //provided by the system. + IN PIRP pIoRequestPacket, //Pointer to the IRP related to this request. + IN DEVICE_POWER_STATE To, //Requested power state. + IN DEVICE_POWER_STATE From //Current power state. +) +{ + NTSTATUS ntSetPowerStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + //Set USB Power condition from here + + PrintFunctionExit(__FUNCTION__,ntSetPowerStatus); + + return ntSetPowerStatus; +} + + +/***************************************************************************** + Function : CSkyWalker1Device::InitializeTuner + Description : This function is used to setup and initialize the Tuner + Interface + IN PARAM : Reference to Device to be Started + IoRequest Packet + OUT PARAM : ntStatus of the Tuner Initializations + STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : Stopped Device or Device Enumerated for the First Time + PostCondtion : Device Initialized with the Newly allocated Resources, + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::InitializeTuner( + IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntInitStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + //Initialize the USB hardware here. + ntInitStatus = InitializeUsbDevice(pKSDeviceObject,pIoRequestPacket); + if(!NT_SUCCESS(ntInitStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Failed to Initialize the USB Device\n")); + goto ExitInitTuner; + } + + //Setup the SkyWalker1 Device + ntInitStatus = SetupTunerPower(pKSDeviceObject,SWITCH_ON_TUNER); + if(!NT_SUCCESS(ntInitStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Failed to Setup the SkyWalker1 Device\n")); + goto ExitInitTuner; + } + + //Initialize Adapter + ntInitStatus = InitializeAdapterStream(pKSDeviceObject); + if(!NT_SUCCESS(ntInitStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Failed to Initialize the Adapter Stream\n")); + goto ExitInitTuner; + } + +ExitInitTuner: + + PrintFunctionExit(__FUNCTION__,ntInitStatus); + return ntInitStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::InitializeAdapterStream + Description : This function is used to Register the Adapter Object and + setup the Private Memory for the Streams + IN PARAM : Reference to KS Device Object + OUT PARAM : ntStatus of the Adapter Stream Initialization + STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Adapter Object Registered with the AVStream and Streaming + Memory allocated + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::InitializeAdapterStream( + IN PKSDEVICE pKSDeviceObject) +{ + + NTSTATUS ntInitStatus = STATUS_SUCCESS; + DEVICE_DESCRIPTION DeviceDescription; //Object to hold the Device description + ULONG ulMaxDMAMapRegisters = 0L; + + PrintFunctionEntry(__FUNCTION__); + + //Create DMA adapter + + memset(&DeviceDescription, 0, sizeof(DeviceDescription)); + + DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION; + DeviceDescription.Master = TRUE; + DeviceDescription.ScatterGather = TRUE; + DeviceDescription.Dma32BitAddresses = TRUE; + DeviceDescription.Dma64BitAddresses = FALSE; + DeviceDescription.DmaChannel = ((ULONG) ~0); + DeviceDescription.InterfaceType = PCIBus; + DeviceDescription.MaximumLength = 0xfffffff8; + + //not used + DeviceDescription.IgnoreCount; + DeviceDescription.DemandMode; + DeviceDescription.AutoInitialize; + DeviceDescription.DmaWidth; + DeviceDescription.Reserved1; + DeviceDescription.DmaSpeed; + DeviceDescription.DmaPort; + + //The IoGetDmaAdapter routine returns a pointer to the DMA adapter structure + //for a physical device object. + m_pDMAAdapter = IoGetDmaAdapter( + pKSDeviceObject->PhysicalDeviceObject, //Pointer to Physical Device Object + //requesting the DMA Adapter structure + &DeviceDescription, //Pointer to the Device Descriptor Structure which + //describes the attributes of the Structure + &ulMaxDMAMapRegisters); //Maximum Map registers that driver can allocate for + //Dma transfer + if(!IS_VALID(m_pDMAAdapter)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to get the Dma Adapter for the Device\n")); + ntInitStatus = STATUS_UNSUCCESSFUL; + goto ExitInitAdapter; + + } + + if(!IS_VALID(m_pDMAAdapter->DmaOperations)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("No Dma Operatios found for the DMA Adapter\n")); + ntInitStatus = STATUS_UNSUCCESSFUL; + goto ExitInitAdapter; + } + + //Print the DMA Adapter details + PrintDMAAdapter(m_pDMAAdapter); + SkyWalkerDebugPrint(EXTREME_LEVEL,("Number of Map Registers = %lu\n",ulMaxDMAMapRegisters)); + + //Register the DMA Adapter with the AVStream + //The KsDeviceRegisterAdapterObject function registers a DMA adapter object with + //AVStream for performing scatter/gather DMA on the specified device. + KsDeviceRegisterAdapterObject( + pKSDeviceObject, //Device For which to register an adapter object + m_pDMAAdapter, //Pointer to DMA Adapter (IoGetDmaAdapter) + 0xfffffff8, //Maximum number of bytes that device can handle for a single mapping + sizeof(KSMAPPING)); //Number of bytes each entry in the mapping table requires + + //Allocate the Space for storing the Streaming contents + KeInitializeEvent (&m_HardwareEvent,SynchronizationEvent,FALSE); + + RtlZeroMemory(pUsbStreamIrp,sizeof(pUsbStreamIrp)); + +ExitInitAdapter: + + PrintFunctionExit(__FUNCTION__,ntInitStatus); + return ntInitStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::ReadStream + Description : This function is called when streaming data from the USb + is requested to read.This function is called when the streaming + is started and every time after Stream processing to read a + new Stream + IN PARAM : Index of the Stream to Read + OUT PARAM : ntStatus of the Read Stream + STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Stream Read + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::ReadStream(IN ULONG ulStreamIndex) +{ + NTSTATUS ntReadStreamStatus = STATUS_SUCCESS; + PUCHAR pStreamBuffer = NULL; + ULONG ulPacketCount = PACKET_PER_FRAME; + ULONG ulPacketSize = MAX_BULK_PACKET_SIZE ; + + PrintFunctionEntry(__FUNCTION__); + + //Get the Stream buffer related to the Current Stream index + pStreamBuffer = m_SynthesisBuffer[ulStreamIndex]; + //Set the number of Bytes read + m_NumberOfBytesRead[ulStreamIndex] = 0; + + //Send the Read request of the 4K Size Each + for(ULONG ulPacketIndex = 0; ulPacketIndex <= ulPacketCount-1 ; ulPacketIndex++) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("pStreamBuffer[%03lu] = 0x%p",ulPacketIndex,pStreamBuffer)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("m_SampleSize = %lu",m_SampleSize)); + if(IS_VALID(pStreamBuffer)) + { + if(ulPacketIndex == 23) + { + ulPacketSize = 2048; + } + ntReadStreamStatus = ReadWriteUsbDevice( m_pKSDevice, + ulStreamIndex, + ulPacketIndex, + pStreamBuffer, + ulPacketSize , + true + ); + + + if(NT_SUCCESS(ntReadStreamStatus)) + { + SkyWalkerDebugPrint(EXTREME_LEVEL, ("Sent the Stream Read Request\n")); + } + else + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Failed to Send Stream Read from the Device")); + } + + pStreamBuffer += ulPacketSize; + } + else + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Invalid Stream Aborting Stream Read\n")); + break; + } + } + PrintFunctionExit(__FUNCTION__,ntReadStreamStatus); + + return ntReadStreamStatus; + + +} + +/***************************************************************************** + Function : CSkyWalker1Device::GetStatus + Description : This function is used to Get the Current ntStatus of the + Tuner i.e. Current Carrier Freq. Signal Locked status etc. + IN PARAM : Device ntStatus + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Device ntStatus updated and returned + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::GetStatus(OUT PBDATUNER_DEVICE_STATUS pDeviceStatus) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + pDeviceStatus->fCarrierPresent = FALSE; + pDeviceStatus->fSignalLocked = FALSE; + pDeviceStatus->dwSignalQuality = 0; + pDeviceStatus->dwSignalStrength = 0; + + PrintFunctionEntry(__FUNCTION__); + + if(m_HardwareState != HardwareRunning) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Streaming is not started yet\n")); + ntStatus = STATUS_UNSUCCESSFUL; + goto ExitGetStatus; + + } + + if(TimeToReadSignalStatus()) + { + //It's Time to read Signal Status + //Get the signal status from the HW here + ReadTunerSignalStrength(m_pKSDevice, + &m_TunerStatus.dwSignalStrength); + + m_TunerStatus.dwSignalQuality = (m_TunerStatus.dwSignalStrength * 100)/65535; + + GetSignalStatus(m_pKSDevice, + &m_TunerStatus.fSignalLocked); + + + if(m_TunerStatus.fSignalLocked) + { + m_TunerStatus.fCarrierPresent = TRUE; + } + } + + *pDeviceStatus = m_TunerStatus; + +#ifdef FAKE_SIGNAL + pDeviceStatus->dwSignalStrength = 2; + pDeviceStatus->dwSignalQuality = 99; + pDeviceStatus->fCarrierPresent = TRUE; + pDeviceStatus->fSignalLocked = TRUE; +#endif + +ExitGetStatus : + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::TimeToReadSignalStatus + Description : This function is used Check whether time to read + the status from device has occurred or not + IN PARAM : NONE + OUT PARAM : TRUE = Time to read status from Device, + FALSE otherwise + PreCondition : None + PostCondtion : Whether time to read from device has occurred or not + is checked + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +BOOLEAN CSkyWalker1Device::TimeToReadSignalStatus(void) +{ + LARGE_INTEGER CurrentTime; + ULONG ulReadPeriod = 10 * 1000 * 1000; + KeQuerySystemTime (&CurrentTime); + + //If Current time is greater than the last + if(m_TunerStatus.fSignalLocked == FALSE) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Signal Not Locked Reading Status @ 100msec\n")); + ulReadPeriod = 10 * 1000 * 100; + } + if(CurrentTime.QuadPart - m_PreviousStatusReadTime.QuadPart >= ulReadPeriod) + { + m_PreviousStatusReadTime.QuadPart = CurrentTime.QuadPart; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Time to read signal status\n")); + return TRUE; + } + + return FALSE; +} + +/***************************************************************************** + Function : CSkyWalker1Device::Acquire + Description : This function is used to set the Tuner parameters and + called once when the tuner resources are acquired + From this function various device related command are executed + to set the device parameters + IN PARAM : New Device Parameters to be set + Resource ID + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Device ntStatus updated and returned + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::Acquire( + IN PBDATUNER_DEVICE_PARAMETER pNewResource, + OUT PULONG pulAcquiredResourceID + ) +{ + NTSTATUS ntAcquireStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + //Continue only if the Device is acquired currently + if (!m_ulcResourceUsers) + { + m_CurResource = *pNewResource; + + //Generate a new resource ID and hand it back. + m_ulCurResourceID += 25; + *pulAcquiredResourceID = m_ulCurResourceID; + m_ulcResourceUsers += 1; + + //Configure the new resource on the hardware here. + //Send the Tune, SetLnbVoltage etc Commands from here + ConfigureTuner(m_pKSDevice,pNewResource); + + } + else + { + //Only one active filter is allowed + ntAcquireStatus = STATUS_DEVICE_BUSY; + } + + PrintFunctionExit(__FUNCTION__,ntAcquireStatus); + return ntAcquireStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::Update + Description : This function is used to set the Tuner parameters and + called everytime after the tuner resources are acquired + From this function various device related command are executed + to set the device parameters + IN PARAM : New Device Parameters to be set + Resource ID + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Device ntStatus updated and returned + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::Update( + IN PBDATUNER_DEVICE_PARAMETER pNewResource, + IN ULONG ulResourceID + ) +{ + NTSTATUS ntUpdateStatus = STATUS_SUCCESS; + LONGLONG ulhzFrequency; + + PrintFunctionEntry(__FUNCTION__); + + //Continue only if the Device is acquired currently + if (m_ulcResourceUsers && (ulResourceID == m_ulCurResourceID)) + { + m_CurResource = *pNewResource; + + //Configure the new resource on the hardware here. + //Send the Tune, SetLnbVoltage etc Commands from here + ConfigureTuner(m_pKSDevice,pNewResource); + + } + else + { + //Only one active filter is allowed + ntUpdateStatus = STATUS_INVALID_DEVICE_REQUEST; + } + + PrintFunctionExit(__FUNCTION__,ntUpdateStatus); + return ntUpdateStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::SendDiseqcCommand + Description : This function is used to send the Diseqc Command to the Tuner + IN PARAM : Diseqc Command to be sent to the Tuner + Resource ID + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Diseqc Command sent to the Tuner + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::SendDiseqcCommand( + IN PDISEQC_COMMAND pDiseqcCommand, + IN ULONG ulResourceID + ) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + //Continue only if the Device is acquired currently + //if (m_ulcResourceUsers && (ulResourceID == m_ulCurResourceID)) + { + + SkyWalkerDebugPrint(EXTREME_LEVEL,("m_ulcResourceUsers = %lu\n",m_ulcResourceUsers)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("ulResourceID = %lu\n",ulResourceID)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("m_ulCurResourceID = %lu\n",m_ulCurResourceID)); + //Send the Diseqc Command to the Tuner device + DiseqcCommand(m_pKSDevice,pDiseqcCommand); + + } + //else + //{ + // //Only one active filter is allowed + // ntStatus = STATUS_INVALID_DEVICE_REQUEST; + // } + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::Release + Description : This function is used to decrement the Resource User count + to allow other filters to use the resources + IN PARAM : Resource ID + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Device ntStatus updated and returned + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::Release(IN ULONG ulResourceID) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + if(m_ulcResourceUsers && (ulResourceID == m_ulCurResourceID)) + { + //Free the resource to be used by another filter. + m_ulcResourceUsers--; + } + else + { + ntStatus = STATUS_INVALID_DEVICE_REQUEST; + } + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : CSkyWalker1Device::StartStream + Description : This function is used to Initialize the Prestreaming + parameters and also it sends the Streaming command to + the Tuner + IN PARAM : NONE + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Streaming Started on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::StartStream () +{ + + NTSTATUS ntStreamStartStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + //Initializing the Streaming Parameters + + m_TimePerFrame = m_TransportInfo->AvgTimePerFrame; + m_SampleSize = m_TransportInfo->ulcbPhyiscalFrame; + m_PacketSize = m_TransportInfo->ulcbPhyiscalPacket; + m_PacketsPerSample = m_TransportInfo->ulcbPhyiscalFrame / m_TransportInfo->ulcbPhyiscalPacket; + m_TunerStatus.fCarrierPresent = FALSE; + m_TunerStatus.fSignalLocked = FALSE; + m_TunerStatus.dwSignalQuality = 0; + m_TunerStatus.dwSignalStrength = 0; + + + //Allocate a scratch buffer for the Streaming Buffer. + + for(int nBufferIndex = 0 ; + nBufferIndex < SIZEOF_ARRAY(m_SynthesisBuffer); + nBufferIndex++) + { + m_SynthesisBuffer[nBufferIndex] = reinterpret_cast ( + ExAllocatePoolWithTag ( + NonPagedPool, + m_SampleSize, + CAPTURE_MEM_TAG + ) + ); + + if (!IS_VALID(m_SynthesisBuffer)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Insufficient Resource for Scatter/Gather DMA\n")); + ntStreamStartStatus = STATUS_INSUFFICIENT_RESOURCES; + goto ExitStreamStart; + } + + } + + //Send Device Streaming Start Control + SetStreamingControl(m_pKSDevice,1); + m_HardwareState = HardwareRunning; + +ExitStreamStart: + PrintFunctionExit(__FUNCTION__,ntStreamStartStatus); + return ntStreamStartStatus; + +} + +/***************************************************************************** + Function : CSkyWalker1Device::PauseStream + Description : This function is used to Pause/Run the Streaming if On/Off. + IN PARAM : True : Pause Streaming , False : Start Streaming + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Streaming Paused/Started on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::PauseStream (BOOLEAN bPausing) +{ + + NTSTATUS ntStreamPauseStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + //If Streaming is in Progress then Stop the Streaming by + //Stop sending read requests and Cancelling any on going IRP + if (bPausing && (m_HardwareState == HardwareRunning)) + { + m_StopHardware = TRUE; + //Stop Streaming + SetStreamingControl(m_pKSDevice,0); + + for(int ulPacketIndex = 0; + ulPacketIndex < SIZEOF_ARRAY(pUsbStreamIrp) ; + ulPacketIndex++) + { + if(pUsbStreamIrp[ulPacketIndex]) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Cancelling pUsbStreamIrp[%lu] = 0x%p\n", + ulPacketIndex,pUsbStreamIrp[ulPacketIndex])); + IoCancelIrp(pUsbStreamIrp[ulPacketIndex]); + pUsbStreamIrp[ulPacketIndex] = NULL; + + KeWaitForSingleObject ( + &m_HardwareEvent, + Suspended, + KernelMode, + FALSE, + NULL + ); + + KeResetEvent(&m_HardwareEvent); + m_StopHardware = TRUE; + } + } + + m_HardwareState = HardwarePaused; + + } + else if (!bPausing && (m_HardwareState == HardwarePaused) ) + { + + m_HardwareState = HardwareRunning; + + //Start Streaming + SetStreamingControl(m_pKSDevice,1); + + } + + PrintFunctionExit(__FUNCTION__,ntStreamPauseStatus); + return ntStreamPauseStatus; + +} + +/***************************************************************************** + Function : CSkyWalker1Device::StopStream + Description : This function is used to Stop the Streaming if On. + IN PARAM : NONE + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Streaming Stopped on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device::StopStream () +{ + + NTSTATUS ntStreamStopStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + //Stop the Streaming in case it's already on + if (m_HardwareState == HardwareRunning) + { + m_StopHardware = TRUE; + //Stop Streaming + SetStreamingControl(m_pKSDevice,0); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("SIZEOF_ARRAY[pUsbStreamIrp] = %d\n", + SIZEOF_ARRAY(pUsbStreamIrp))); + + for(int ulPacketIndex = 0; + ulPacketIndex < SIZEOF_ARRAY(pUsbStreamIrp) ; + ulPacketIndex++) + { + if(pUsbStreamIrp[ulPacketIndex]) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Cancelling pUsbStreamIrp[%lu] = 0x%p\n", + ulPacketIndex,pUsbStreamIrp[ulPacketIndex])); + IoCancelIrp(pUsbStreamIrp[ulPacketIndex]); + pUsbStreamIrp[ulPacketIndex] = NULL; + + KeWaitForSingleObject ( + &m_HardwareEvent, + Suspended, + KernelMode, + FALSE, + NULL + ); + + KeResetEvent(&m_HardwareEvent); + m_StopHardware = TRUE; + } + } + + } + + m_HardwareState = HardwareStopped; + + for(int nBufferIndex = 0 ; + nBufferIndex < SIZEOF_ARRAY(m_SynthesisBuffer) ; + nBufferIndex++) + { + if (m_SynthesisBuffer[nBufferIndex]) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Freeing Streaming Buffer m_SynthesisBuffer[%lu] = 0x%p\n", + nBufferIndex,m_SynthesisBuffer[nBufferIndex])); + ExFreePool (m_SynthesisBuffer[nBufferIndex]); + m_SynthesisBuffer[nBufferIndex] = NULL; + } + } + + PrintFunctionExit(__FUNCTION__,ntStreamStopStatus); + return ntStreamStopStatus; + +} + +/***************************************************************************** + Function : CSkyWalker1Device::ProcessStream + Description : This function is used to Process the Streaming Data after + reading it.This function is called from the USB Read Write + Completion routine + IN PARAM : Index of the Stream whose read completed + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Read Stream is processed and Streaming data is filled into the + used Buffer. + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +void CSkyWalker1Device::ProcessStream(ULONG ulStreamIndex) +{ + + PrintFunctionEntry(__FUNCTION__); + + //The hardware can be in a pause state in which case, it issues interrupts + //but does not complete mappings. In this case, don't bother synthesizing + //a frame and doing the work of looking through the mappings table. + + if (m_HardwareState == HardwareRunning) + { + + SkyWalkerDebugPrint(EXTREME_LEVEL,("(%d * %d) = %lu\n", TRANSPORT_PACKET_SIZE, + TRANSPORT_PACKET_COUNT, + m_SampleSize)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("m_NumberOfBytesRead[%lu] = %lu\n", + ulStreamIndex, + m_NumberOfBytesRead[ulStreamIndex])); + + if (InterlockedCompareExchange((LONG *)&m_NumberOfBytesRead[ulStreamIndex], + m_SampleSize, m_SampleSize) == m_SampleSize) + { + //Inform the capture sink + m_CaptureSink->ReleaseStream(ulStreamIndex); + } + + } + + if (m_StopHardware) + { + + //If someone is waiting on the hardware to stop, raise the stop + //event and clear the flag. + SkyWalkerDebugPrint(EXTREME_LEVEL,("Sending the Stop Event\n")); + m_StopHardware = FALSE; + KeSetEvent (&m_HardwareEvent, IO_NO_INCREMENT, FALSE); + } + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + +} + +/***************************************************************************** + Function : CSkyWalker1Device::SetupCaptureSink + Description : Acquire hardware resources for the capture hardware. + If the resources are already acquired, this will return + an error.The hardware configuration must be passed as + a VideoInfoHeader. + IN PARAM : The capture sink attempting to acquire + resources. When scatter /gather mappings are completed, + the capture sink specified here is what is notified + of the completions. + Information about the capture stream. + This **MUST** remain stable until the caller releases + hardware resources. Note that this could also be guaranteed + by bagging it in the device object bag as well. + OUT PARAM : STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : None + PostCondtion : Capture Pin to the notified and Video Info Header set in case + of successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CSkyWalker1Device:: SetupCaptureSink( + IN ICaptureSink *CaptureSink, + IN PBDA_TRANSPORT_INFO TransportInfo + ) +{ + + NTSTATUS ntStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + //If we're the first pin to go into acquire (remember we can have + //a filter in another graph going simultaneously), grab the resources. + if (InterlockedCompareExchange(&m_PinsWithResources,1,0) == 0) + { + m_TransportInfo = TransportInfo; + m_CaptureSink = CaptureSink; + + } + else + { + + ntStatus = STATUS_SHARING_VIOLATION; + } + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; + +} + +/***************************************************************************** + Function : CSkyWalker1Device::RemoveCaptureSink + Description : Release hardware resources. This should only be called by + an object which has acquired them. + IN PARAM : NONE + OUT PARAM : NONE + PreCondition : None + PostCondtion : Video Info Header and Capture Sink info cleared + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +void CSkyWalker1Device::RemoveCaptureSink() +{ + + PrintFunctionEntry(__FUNCTION__); + + m_TransportInfo = NULL; + m_CaptureSink = NULL; + + //Release our "lock" on hardware resources. This will allow another + //pin (perhaps in another graph) to acquire them. + InterlockedExchange(&m_PinsWithResources,0); + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + +} + +void PrintDMAAdapter(PDMA_ADAPTER pDMAAdapter) +{ + SkyWalkerDebugPrint(ENTRY_LEVEL,("pDMAAdapter->Version = %u\n",pDMAAdapter->Version)); + SkyWalkerDebugPrint(ENTRY_LEVEL,("pDMAAdapter->Size = %u\n",pDMAAdapter->Size)); + SkyWalkerDebugPrint(ENTRY_LEVEL,("pDMAAdapter->DmaOperations = 0x%p\n",pDMAAdapter->DmaOperations)); +} + +void PrintMappingInfo(IN PKSMAPPING pMapping) +{ + SkyWalkerDebugPrint(ENTRY_LEVEL,("pMapping->PhysicalAddress = %llu\n",pMapping->PhysicalAddress.QuadPart)); + SkyWalkerDebugPrint(ENTRY_LEVEL,("pMapping->ByteCount = %lu\n",pMapping->ByteCount)); + SkyWalkerDebugPrint(ENTRY_LEVEL,("pMapping->Alignment = %lu\n",pMapping->Alignment)); + +} \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Installer.inf b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Installer.inf new file mode 100644 index 0000000..1a42430 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Installer.inf @@ -0,0 +1,142 @@ +; SkyWalker1Installer.INF -- This file installs SkyWalker1 Driver +; +[Version] +signature="$CHICAGO$" +Class=Media +ClassGUID={4d36e96c-e325-11ce-bfc1-08002be10318} +Provider=%SGI% +CatalogFile=SkyWalker1Installer.cat +DriverVer= 8/17/2009 + +; F i l e c o p y i n g s e c t i o n s (where the files go to). +; +[DestinationDirs] +DefaultDestDir=10,system32\drivers + +[Manufacturer] +%SGI%=SGI + +[ControlFlags] +;ExcludeFromSelect=* +;ExcludeFromSelect.NT=* + +; =================== Generic ================================== + +[SGI] +%SkyWalker1.DeviceDesc%=Skywalker1.Device,USB\VID_09C0&PID_0203 ;SkyWalker1 + +[Skywalker1.Device] +Include = ks.inf, kscaptur.inf, bda.inf +needs = KS.Registration, KSCAPTUR.Registration, BDA.Installation +AddReg = Skywalker1.AddReg +CopyFiles = Skywalker1.CopyDrivers + +[Skywalker1.Device.NT] +Include = ks.inf, kscaptur.inf, bda.inf +needs = KS.Registration.NT, KSCAPTUR.Registration.NT, BDA.Installation.NT +;AddReg = Skywalker1.AddReg +CopyFiles = Skywalker1.CopyDrivers +; KnownFiles = Skywalker1.KnownFiles + +[Skywalker1.Device.NT.Services] +Addservice=SkyWalker1TVTuner, 0x00000002, Skywalker1.AddService + +[Skywalker1.AddService] +DisplayName=%SkyWalker1.FriendlyName% +ServiceType=1 ; SERVICE_KERNEL_DRIVER +StartType=3 ; SERVICE_DEMAND_START +ErrorControl=1 ; SERVICE_ERROR_NORMAL +ServiceBinary=%10%\System32\Drivers\SkyWalker1TVTuner.sys +LoadOrderGroup=ExtendedBase + +[Skywalker1.CopyDrivers] +SkyWalker1TVTuner.sys + +[Skywalker1.AddReg] +HKR,,DevLoader,,*NTKERN +HKR,,NTMPDriver,,SkyWalker1TVTuner.sys +HKR,,PageOutWhenUnopened,3,01 + +[Skywalker1.Device.Interfaces] +AddInterface=%KSCATEGORY_BDA_RECEIVER_COMPONENT%,%SKYWALKER_CAPTURE%,Skywalker1.Receiver.Interfaces +AddInterface=%KSCATEGORY_BDA_NETWORK_TUNER%,%SKYWALKER_TUNER%,Skywalker1.Tuner.Interfaces + +[Skywalker1.Device.NT.Interfaces] +AddInterface=%KSCATEGORY_BDA_RECEIVER_COMPONENT%,%SKYWALKER_CAPTURE%,Skywalker1.Receiver.Interfaces +AddInterface=%KSCATEGORY_BDA_NETWORK_TUNER%,%SKYWALKER_TUNER%,Skywalker1.Tuner.Interfaces + +[Skywalker1.Tuner.Interfaces] +AddReg=Skywalker1.Tuner.Interfaces.AddReg + +[Skywalker1.Tuner.Interfaces.AddReg] +HKR,,CLSID,,%KSProxy.CLSID% +HKR,,FriendlyName,,%SkyWalker1.Tuner.FriendlyName% + +[Skywalker1.Receiver.Interfaces] +AddReg=Skywalker1.Receiver.Interfaces.AddReg + +[Skywalker1.Receiver.Interfaces.AddReg] +HKR,,CLSID,,%KSProxy.CLSID% +HKR,,FriendlyName,,%SkyWalker1.Receiver.FriendlyName% + + +[Strings] +;non-localizable +SGI="Plethorasoft" +MfgName="SGI" +SkyWalker1.DeviceDesc="SkyWalker1 BDA TVTuner" +SkyWalker1.Tuner.FriendlyName="SkyWalker1 TV Tuner" +SkyWalker1.Receiver.FriendlyName="SkyWalker1 TV Receiver" +SkyWalker1.Tuner="SkyWalker1.Tuner" +KSProxy.CLSID="{17CCA71B-ECD7-11D0-B908-00A0C9223196}" +KSCATEGORY_BDA_NETWORK_TUNER="{71985F48-1CA1-11d3-9CC8-00C04F7971E0}" +KSCATEGORY_BDA_RECEIVER_COMPONENT="{FD0A5AF4-B41D-11d2-9C95-00C04F7971E0}" +SKYWALKER_TUNER="{5C4E764F-AB43-46A9-B21E-8529C70F0A23}" +SKYWALKER_CAPTURE="{0F8F74D9-E524-4D05-BB60-F0C69ACB1756}" + +; +; ServiceType values +SERVICE_KERNEL_DRIVER = 0x00000001 +SERVICE_FILE_SYSTEM_DRIVER = 0x00000002 +SERVICE_ADAPTER = 0x00000004 +SERVICE_RECOGNIZER_DRIVER = 0x00000008 +SERVICE_WIN32_OWN_PROCESS = 0x00000010 +SERVICE_WIN32_SHARE_PROCESS = 0x00000020 +SERVICE_INTERACTIVE_PROCESS = 0x00000100 +SERVICE_INTERACTIVE_SHARE_PROCESS = 0x00000120 + +; StartType values +SERVICE_BOOT_START = 0x00000000 +SERVICE_SYSTEM_START = 0x00000001 +SERVICE_AUTO_START = 0x00000002 +SERVICE_DEMAND_START = 0x00000003 +SERVICE_DISABLED = 0x00000004 + +; ErrorControl values +SERVICE_ERROR_IGNORE = 0x00000000 +SERVICE_ERROR_NORMAL = 0x00000001 +SERVICE_ERROR_SEVERE = 0x00000002 +SERVICE_ERROR_CRITICAL = 0x00000003 + +; Characteristic flags +NCF_VIRTUAL = 0x0001 +NCF_WRAPPER = 0x0002 +NCF_PHYSICAL = 0x0004 +NCF_HIDDEN = 0x0008 +NCF_NO_SERVICE = 0x0010 +NCF_NOT_USER_REMOVABLE = 0x0020 +NCF_HAS_UI = 0x0080 +NCF_MODEM = 0x0100 + +; Registry types +REG_MULTI_SZ = 0x10000 +REG_EXPAND_SZ = 0x20000 +REG_DWORD = 0x10001 + +; Win9x Compatible Types +REG_BINARY = 17 +REG_SZ = 0 + +; Service install flags +SPSVCINST_TAGTOFRONT = 0x1 +SPSVCINST_ASSOCSERVICE = 0x2 \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Main.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Main.cpp new file mode 100644 index 0000000..467e9bf --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Main.cpp @@ -0,0 +1,137 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Main.cpp + Author : + Date : + Purpose : This file contains the Entry Point of the Device Driver. + The File also defines various Dispatch Routine pointers + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Common For all the Definitions, + //Declarations and Library Routines + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ + +//Device Dispatch Table : Lists the dispatch routines for the +//major events in the life of Device +const KSDEVICE_DISPATCH SkyWalker1DispatchTable = { + /* Add */ SkyWalker1AddDevice, + /* Start */ SkyWalker1Start, + /* PostStart */ NULL, + /* QueryStop */ SkyWalker1QueryStop, + /* CancelStop */ NULL, + /* Stop */ SkyWalker1Stop, + /* QueryRemove */ NULL, /*QueryRemoveUsbDevice,*/ + /* CancelRemove */ NULL, + /* Remove */ SkyWalker1Remove, + /* QueryCapabilities */ NULL, + /* SurpriseRemoval */ NULL, + /* QueryPower */ NULL, + /* SetPower */ SkyWalker1SetPower +}; + +//Array of Filter Descriptors supported by the Current Driver +// Hold all the filter descriptors in an array +DEFINE_KSFILTER_DESCRIPTOR_TABLE(FilterDescriptors) +{ + &SkyWalker1CaptureFilterDescriptor //Only Capture filter is a Kernel Streaming Filter +}; + +//Device Descriptor : It Describes the Device with all it's dispatch +//functions and Filters +const KSDEVICE_DESCRIPTOR SkyWalker1DeviceDescriptor = +{ + &SkyWalker1DispatchTable, + SIZEOF_ARRAY(FilterDescriptors), //Filter Descriptor Count + FilterDescriptors, //Filter Descriptor Table + KSDEVICE_DESCRIPTOR_VERSION +}; + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : DriverEntry + Description : This is a Entry Point function of the Windows Device Driver + It defines various dispatch routine Entry Point for the Driver + IN PARAM : Pointer to Driver Object which is called + Pointer to the Registry Entry of the Driver + OUT PARAM : Status of the Driver Entry routine + STATUS_SUCCESS always + PreCondition : Driver is Unloaded + PostCondtion : Driver is Loaded with various Entry Point defined + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, + IN PUNICODE_STRING pRegistryPath) +{ + NTSTATUS ntEntryStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + SkyWalkerDebugPrint(ENTRY_LEVEL, ("SkyWalker1 Driver Compiled on Date = %s, Time = %s\n",__DATE__,__TIME__)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Debug Level = %u\n",nCurrentDebugLevel)); + + //As this is an AVStream Minidriver it should call the KsInitializeDriver() + ntEntryStatus = KsInitializeDriver( + pDriverObject, + pRegistryPath, + &SkyWalker1DeviceDescriptor); + + PrintFunctionExit(__FUNCTION__,ntEntryStatus); + + return ntEntryStatus; +} + +/***************************************************************************** + Function : SkyWalker1DriverUnload + Description : This is a Exit Point function of the Windows Device Driver + It does not usedful job for the PnP Driver but required to + unload the Driver from the Running System. + IN PARAM : Pointer to Driver Object which is to be Unloaded + OUT PARAM : NONE + PreCondition : Driver is Loaded + PostCondtion : Driver is Unloaded + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +VOID SkyWalker1DriverUnload(PDRIVER_OBJECT pDriverObject) +{ + PrintFunctionEntry(__FUNCTION__); + + //No Processing + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + +} + + + diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1PnP.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1PnP.cpp new file mode 100644 index 0000000..dd82709 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1PnP.cpp @@ -0,0 +1,336 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1PnP.cpp + Author : + Date : + Purpose : PnP IRP Message Handler + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ +#include "SkyWalker1Main.h" //Common For all the Definitions, + //Declarations and Library Routines +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +void PrintKSDeviceObject(IN PKSDEVICE pKSDeviceObject); +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : SkyWalker1AddDevice + Description : This Function is called by the PnP Manager for each Device + managed by the Driver.It is called during the System Initialization + and any time a new Device is enumerated while the System is running. + IN PARAM : Pointer to the Enumerated Physical Device + KSDEVICE is a WDM Functional Device which is managed by the AVStream + OUT PARAM : Status of the Device Addition + STATUS_SUCCESS when the Device added to the System + Reason for Failure incase of Error + PreCondition : Driver is Loaded without Functional/ Filter Device Objects + PostCondtion : Functional Device Object [FDO] or Filter Device Object [FiDO] are created + Logic : NONE + Assumption : NONE + Note : AddDevice is Must for the PnP Drivers + This routine runs at PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS SkyWalker1AddDevice(IN PKSDEVICE pKSDeviceObject) +{ + NTSTATUS ntAddDeviceStatus = STATUS_SUCCESS; + PKSFILTERFACTORY pFilterFactory = NULL; + + PrintFunctionEntry(__FUNCTION__); + PrintKSDeviceObject(pKSDeviceObject); + + if(!IS_VALID(pKSDeviceObject)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Invalid KS Device Object Received\n")); + ntAddDeviceStatus = STATUS_UNSUCCESSFUL; + goto FinishAddDevice; + } + + //Allcate Memory for the SkyWalker1 Device + CSkyWalker1Device * pDevice = new(NonPagedPool,TUNER_MEM_TAG)CSkyWalker1Device; + if(!IS_VALID(pDevice)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Can not allocate Memory for the SkyWalker1 Device\n")); + ntAddDeviceStatus = STATUS_INSUFFICIENT_RESOURCES; + goto FinishAddDevice; + } + + ntAddDeviceStatus = pDevice->Create(pKSDeviceObject); + + PrintKSDeviceObject(pKSDeviceObject); + +FinishAddDevice: + + PrintFunctionExit(__FUNCTION__,ntAddDeviceStatus); + + return ntAddDeviceStatus; +} +/***************************************************************************** + Function : SkyWalker1Remove + Description : This function is called when the IRP_MN_REMOVE_DEVICE is sent + by the PnP Manager during Device Removal + IN PARAM : Pointer to the Enumerated Physical Device + KSDEVICE is a WDM Functional Device which is managed by the AVStream + Remove Device Io Request Packet + OUT PARAM : NONE + PreCondition : Started Device + PostCondtion : Device Removed + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +VOID SkyWalker1Remove( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntDeviceRemoveStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = NULL; + PrintFunctionEntry(__FUNCTION__); + + //Get the SkyWalker1 Device Object from the Context Info. + pDevice = reinterpret_cast(pKSDeviceObject->Context); + + if(!IS_VALID(pDevice)) + { + //Unexpected Remove for the Device + SkyWalkerDebugPrint(ENTRY_LEVEL,("No Connection found with SkyWalker Device\n")); + ntDeviceRemoveStatus = STATUS_UNSUCCESSFUL; + goto ExitRemoveDevice; + } + + ntDeviceRemoveStatus = pDevice->Close(pKSDeviceObject,pIoRequestPacket); + + //Deallocate the SkyWalker1 Device Object Memory + delete pDevice; + //Remove Reference of the SkyWalker1 Device from the KS Object + pKSDeviceObject->Context = NULL; + +ExitRemoveDevice: + + PrintFunctionExit(__FUNCTION__,ntDeviceRemoveStatus); + +} + +/***************************************************************************** + Function : SkyWalker1Start + Description : This function is called when the IRP_MN_START_DEVICE is sent + by the PnP Manager after Allocating Resources to the Device. + IRP_MN_START_DEVICE is called once for each device created from + the Driver using the IoCreateDevice() call. + When BDA Device Starts operating Pnp Dispatches the IRP_MN_START_DEVICE to the ks.sys + AvStream class Driver inturn calls the start routine of the BDA minidriver + associated with the BDA Device. This Start Routine retrives information about the + device from the registry, sets information about the Device and then calls the + BdaCreateFilterFactory() support function to + 1) Create Filter Factory from the Initial Filter Descriptor (KSFILTER_DESCRIPTOR) + for the Device.The Initial Filter Descriptor references Dispatch and Automation + tables for the Filter and Input Pins + 2) Associate Filter Factory with the BDA_FILTER_TEMPLATE structure.This structure + references template filter descriptor for the Device and the list of possible + pairs of the input and output pins.The Descriptor and list inturn reference. + a) Static Template Structure that can be used by Network Provider to determine + BDA Driver topology + b) Static Template Structure that can be used by Network Provider to manipulate + BDA Filter + c) Nodes and Pins for a BDA Filter along with possible ways to connect the Filter + d) Routines that a Netwrok provider can use to Create and Close a Filter instance + 3) Register the Static Template structures that are specified by BDA_FILTER_TEMPLATE + with the BDA support library so that the library can provide default handling + for a BDA MiniDriver's Properties and methods. + IN PARAM : Reference to Device to be Started + IoRequest Packet + OUT PARAM : Status of the Tuner Start + STATUS_SUCCESS in case of successful execution + Failure Code in other cases + PreCondition : Stopped Device or Device Enumerated for the First Time + PostCondtion : Device Initialized with the Newly allocated Resources, + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS SkyWalker1Start(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket, + IN PCM_RESOURCE_LIST pResourceList, + IN PCM_RESOURCE_LIST pResourceListTranslated) +{ + + NTSTATUS ntStartStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = NULL; + PrintFunctionEntry(__FUNCTION__); + + //Get the SkyWalker1 Device Object from the Context Info. + pDevice = reinterpret_cast(pKSDeviceObject->Context); + + if(!IS_VALID(pDevice)) + { + //No Device Found + SkyWalkerDebugPrint(ENTRY_LEVEL,("No Connection with SkyWalker Device\n")); + ntStartStatus = STATUS_UNSUCCESSFUL; + goto ExitStartDevice; + } + + //Call the Start device function of the SkyWalker1 Device class + ntStartStatus = pDevice->Start( pKSDeviceObject, + pIoRequestPacket, + pResourceList, + pResourceListTranslated); + +ExitStartDevice: + + PrintFunctionExit(__FUNCTION__,ntStartStatus); + return STATUS_SUCCESS; +} + +/***************************************************************************** + Function : SkyWalker1Stop + Description : This function is called when the IRP_MN_STOP_DEVICE is sent + by the PnP Manager during Device Removal + IN PARAM : Reference to Device to be Removed + Stop Device Io Request Packet + OUT PARAM : NONE + PreCondition : Started Device + PostCondtion : Device Stopped + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +VOID SkyWalker1Stop(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + + NTSTATUS ntStopStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = NULL; + PrintFunctionEntry(__FUNCTION__); + + //Get the SkyWalker1 Device Object from the Context Info. + pDevice = reinterpret_cast(pKSDeviceObject->Context); + + if(!IS_VALID(pDevice)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("No Connection with SkyWalker Device\n")); + goto ExitStopDevice; + } + + //Call the Stop device function of the SkyWalker1 Device class + ntStopStatus = pDevice->Stop( pKSDeviceObject, + pIoRequestPacket + ); +ExitStopDevice: + PrintFunctionExit(__FUNCTION__,ntStopStatus); +} + +/***************************************************************************** + Function : SkyWalker1QueryStop + Description : This function is called when the IRP_MN_QUERY_STOP_DEVICE is sent + by the PnP Manager during Device Stop + IN PARAM : Pointer to the Enumerated Physical Device + KSDEVICE is a WDM Functional Device which is managed by the AVStream + Remove Device Io Request Packet + OUT PARAM : NONE + PreCondition : Started Device + PostCondtion : Query for stopping device is returned + Logic : NONE + Assumption : NONE + Note : All the Devices created by the Driver are connected with Each other + with the NextDevice Member of the Device Object + Revision History: + *****************************************************************************/ +NTSTATUS SkyWalker1QueryStop( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + PrintFunctionEntry(__FUNCTION__); + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + return STATUS_SUCCESS; + +} + +/***************************************************************************** + Function : SkyWalker1SetPower + Description : This function is called when the IRP_MJ_POWER is sent + by the PnP Manager during Power Management + IN PARAM : Pointer to the Enumerated Physical Device + KSDEVICE is a WDM Functional Device which is managed by the AVStream + Power Device Io Request Packet + OUT PARAM : NONE + PreCondition : Started Device + PostCondtion : Query for stopping device is returned + Logic : NONE + Assumption : NONE + Note : All the Devices created by the Driver are connected with Each other + with the NextDevice Member of the Device Object + Revision History: + *****************************************************************************/ +VOID SkyWalker1SetPower +( + IN PKSDEVICE pKSDeviceObject, //Pointer to the device object + //provided by the system. + IN PIRP pIoRequestPacket,//Pointer to the IRP related to this request. + IN DEVICE_POWER_STATE To, //Requested power state. + IN DEVICE_POWER_STATE From //Current power state. +) +{ + CSkyWalker1Device * pDevice = NULL; + + PrintFunctionEntry(__FUNCTION__); + //Get the SkyWalker1 Device Object from the Context Info. + pDevice = reinterpret_cast(pKSDeviceObject->Context); + + if(!IS_VALID(pDevice)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("No Connection with SkyWalker Device\n")); + goto ExitSetPower; + } + + //Call the Set Power device function of the SkyWalker1 Device class + pDevice->SetPower( pKSDeviceObject, + pIoRequestPacket, + To, + From + ); +ExitSetPower: + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + +} + + + +void PrintKSDeviceObject(IN PKSDEVICE pKSDeviceObject) +{ + SkyWalkerDebugPrint(ENTRY_LEVEL, (__FUNCTION__"\n")); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor = 0x%p \n",pKSDeviceObject->Descriptor)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor->Dispatch = 0x%p \n",pKSDeviceObject->Descriptor->Dispatch)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor->FilterDescriptorsCount = %lu \n",pKSDeviceObject->Descriptor->FilterDescriptorsCount)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor->FilterDescriptors = 0x%p \n",pKSDeviceObject->Descriptor->FilterDescriptors)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor->Version = %lu \n",pKSDeviceObject->Descriptor->Version)); + + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->Bag = 0x%p\n",pKSDeviceObject->Bag)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->Context = 0x%p\n",pKSDeviceObject->Context)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->FunctionalDeviceObject = 0x%p\n",pKSDeviceObject->FunctionalDeviceObject)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->PhysicalDeviceObject = 0x%p\n",pKSDeviceObject->PhysicalDeviceObject)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->NextDeviceObject = 0x%p\n",pKSDeviceObject->NextDeviceObject)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->Started = %d\n",pKSDeviceObject->Started)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->SystemPowerState = %d\n",pKSDeviceObject->SystemPowerState)); + SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->DevicePowerState = %d\n",pKSDeviceObject->DevicePowerState)); +} \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TransportPin.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TransportPin.cpp new file mode 100644 index 0000000..41689f9 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TransportPin.cpp @@ -0,0 +1,414 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1TransportPin.cpp + Author : + Date : + Purpose : This file contains header for the Transport pin on the Tuner + filter. + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Common For all the Definitions, + //Declarations and Library Routines + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +VOID PrintBdaTransport(PKS_DATARANGE_BDA_TRANSPORT pBdaTransport); +VOID PrintBdaTransportInfo(PBDA_TRANSPORT_INFO pBdaTransportInfo); +VOID PrintKsDataFormat(PKSDATAFORMAT pKsDataFormat); +PCHAR GetDemodPropertyString(ULONG ulDemodProperty); +PCHAR GetExtendedPropertyString(ULONG ulTunerExtendedProperty); +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : CTransportPin::IntersectDataFormat + Description : Enables connection of the output pin with a downstream filter. + IN PARAM : + OUT PARAM : Status of the IntersectDataFormat + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CTransportPin::IntersectDataFormat( + IN PVOID pContext, + IN PIRP pIoRequestPacket, + IN PKSP_PIN Pin, + IN PKSDATARANGE pDataRange, + IN PKSDATARANGE pMatchingDataRange, + IN ULONG ulDataBufferSize, + OUT PVOID pData OPTIONAL, + OUT PULONG pulDataSize + ) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if ( ulDataBufferSize < sizeof(KS_DATARANGE_BDA_TRANSPORT) ) + { + *pulDataSize = sizeof( KS_DATARANGE_BDA_TRANSPORT ); + ntStatus = STATUS_BUFFER_OVERFLOW; + goto ExitDataFormat; + } + else if (pDataRange->FormatSize < sizeof (KS_DATARANGE_BDA_TRANSPORT)) + { + ntStatus = STATUS_NO_MATCH; + goto ExitDataFormat; + } + else + { + *pulDataSize = sizeof( KS_DATARANGE_BDA_TRANSPORT ); + RtlCopyMemory( pData, (PVOID)pDataRange, sizeof(KS_DATARANGE_BDA_TRANSPORT)); + ntStatus = STATUS_SUCCESS; + PrintBdaTransport((PKS_DATARANGE_BDA_TRANSPORT)pDataRange); + } + +ExitDataFormat: + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; + +} + +/***************************************************************************** + Function : CTransportPin::SetDigitalDemodProperty + Description : Sets the value of the digital demodulator node properties. + IN PARAM : + OUT PARAM : Status SUCCESS in case Valid Property Set request + STATUS_INVALID_PARAMETER in case of Invalid property set request + PreCondition : None + PostCondtion : Demodulator propery Set in case of successful execution + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CTransportPin::SetDigitalDemodProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + CTransportPin* pPin; + CTunerFilter* pFilter; + ModulationType NewModulationType; + BinaryConvolutionCodeRate NewFecRate; + ULONG ulNewSymbolRate; + + + PrintFunctionEntry(__FUNCTION__); + + // Call the BDA support library to + // validate that the node type is associated with this pin. + // + ntSetStatus = BdaValidateNodeProperty( pIoRequestPacket, pKSProperty); + if (NT_SUCCESS( ntSetStatus)) + { + // Obtain a pointer to the pin object. + // + // Because the property dispatch table calls the CTransportPin::SetDigitalDemodProperty() + // method directly, the method must retrieve a pointer to the underlying pin object. + // + pPin = reinterpret_cast(KsGetPinFromIrp(pIoRequestPacket)->Context); + + // Retrieve the filter context from the pin context. + // + pFilter = pPin->GetFilter(); + SkyWalkerDebugPrint(EXTREME_LEVEL,("Set : %s : %lu(%l)",GetDemodPropertyString(pKSProperty->Id),*pulProperty,*((LONG*)(pulProperty)))); + + switch (pKSProperty->Id) + { + case KSPROPERTY_BDA_MODULATION_TYPE: + ntSetStatus = pFilter->SetModulatorType((ModulationType)*pulProperty); + break; + case KSPROPERTY_BDA_INNER_FEC_TYPE: + ntSetStatus = pFilter->SetInnerFecType(*pulProperty); + break; + case KSPROPERTY_BDA_INNER_FEC_RATE: + ntSetStatus = pFilter->SetInnerFecRate((BinaryConvolutionCodeRate)*pulProperty); + break; + case KSPROPERTY_BDA_OUTER_FEC_TYPE: + ntSetStatus = pFilter->SetOuterFecType(*pulProperty); + break; + case KSPROPERTY_BDA_OUTER_FEC_RATE: + ntSetStatus = pFilter->SetOuterFecRate((BinaryConvolutionCodeRate)*pulProperty); + break; + case KSPROPERTY_BDA_SYMBOL_RATE: + ntSetStatus = pFilter->SetSymbolRate(*pulProperty); + break; + case KSPROPERTY_BDA_SPECTRAL_INVERSION: + ntSetStatus = pFilter->SetSpectralInversion((SpectralInversion)*pulProperty); + break; + case KSPROPERTY_BDA_GUARD_INTERVAL: + ntSetStatus = pFilter->SetGuardInterval((GuardInterval)*pulProperty); + break; + case KSPROPERTY_BDA_TRANSMISSION_MODE: + ntSetStatus = pFilter->SetTransmissionMode((TransmissionMode)*pulProperty); + break; + default: + ntSetStatus = STATUS_INVALID_PARAMETER; + break; + } + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + + return ntSetStatus; +} + +/***************************************************************************** + Function : CTransportPin::GetDigitalDemodProperty + Description : Gets the value of the digital demodulator node properties. + IN PARAM : + OUT PARAM : Status SUCCESS in case Valid Property Get request + STATUS_INVALID_PARAMETER in case of Invalid property Get request + PreCondition : None + PostCondtion : Demodulator propery returned in case of successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTransportPin::GetDigitalDemodProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ) +{ + NTSTATUS ntGetStatus = STATUS_SUCCESS; + CTransportPin* pPin; + CTunerFilter* pFilter; + BDATUNER_DEVICE_PARAMETER DemodProperty; + + PrintFunctionEntry(__FUNCTION__); + + // Call the BDA support library to + // validate that the node type is associated with this pin. + // + ntGetStatus = BdaValidateNodeProperty( pIoRequestPacket, pKSProperty); + if (NT_SUCCESS( ntGetStatus)) + { + // Obtain a pointer to the pin object. + // + // Because the property dispatch table calls the CTransportPin::GetDigitalDemodProperty() + // method directly, the method must retrieve a pointer to the underlying pin object. + // + pPin = reinterpret_cast(KsGetPinFromIrp(pIoRequestPacket)->Context); + + // Retrieve the filter context from the pin context. + // + pFilter = pPin->GetFilter(); + + ntGetStatus = pFilter->GetDemodProperty(&DemodProperty); + + switch (pKSProperty->Id) + { + case KSPROPERTY_BDA_MODULATION_TYPE: + *pulProperty = (ModulationType)DemodProperty.CurrentModulationType; + break; + case KSPROPERTY_BDA_INNER_FEC_TYPE: + *pulProperty = BDA_FEC_VITERBI; + break; + case KSPROPERTY_BDA_INNER_FEC_RATE: + *pulProperty = (BinaryConvolutionCodeRate)DemodProperty.InnerFecRate; + break; + case KSPROPERTY_BDA_OUTER_FEC_TYPE: + *pulProperty = BDA_FEC_VITERBI; + break; + case KSPROPERTY_BDA_OUTER_FEC_RATE: + *pulProperty = (BinaryConvolutionCodeRate)DemodProperty.OuterFecRate; + break; + case KSPROPERTY_BDA_SYMBOL_RATE: + *pulProperty = DemodProperty.ulSymbolRate; + break; + case KSPROPERTY_BDA_SPECTRAL_INVERSION: + *pulProperty = (SpectralInversion) DemodProperty.CurrentSpectralInversion; + break; + case KSPROPERTY_BDA_GUARD_INTERVAL: + *pulProperty = (GuardInterval) DemodProperty.CurrentGuardInterval; + break; + case KSPROPERTY_BDA_TRANSMISSION_MODE: + *pulProperty = (TransmissionMode) DemodProperty.CurrentTransmissionMode; + break; + default: + ntGetStatus = STATUS_INVALID_PARAMETER; + break; + } + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Get : %s : %ul",GetDemodPropertyString(pKSProperty->Id),*pulProperty)); + + PrintFunctionExit(__FUNCTION__,ntGetStatus); + return ntGetStatus; +} + +/***************************************************************************** + Function : CTransportPin::SetExtendedProperty + Description : Sets the Extended Property of the Tuner + IN PARAM : IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + OUT PARAM : Status SUCCESS in case Valid Property request + STATUS_INVALID_PARAMETER in case of Invalid property request + Else error from the lower device + PreCondition : None + PostCondtion : Extended Property Set in case of successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTransportPin::SetExtendedProperty( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + IN PULONG pulProperty + ) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + CTransportPin * pPin = NULL; + CTunerFilter* pFilter = NULL; + + PrintFunctionEntry(__FUNCTION__); + //Call the BDA support library to + //validate that the node type is associated with the pin. + + //The BdaValidateNodeProperty function validates that a node property + //request is associated with a specific pin. + ntSetStatus = BdaValidateNodeProperty( pIoRequestPacket, pKSProperty); + if (NT_SUCCESS( ntSetStatus)) + { + //Obtain a pointer to the pin object. + + //Because the property dispatch table calls the CTransportPin::SetExtendedProperty() + //method directly, the method must retrieve a pointer to the underlying pin object. + + pPin = reinterpret_cast(KsGetPinFromIrp(pIoRequestPacket)->Context); + + //Retrieve the filter context from the pin context. + pFilter = pPin->GetFilter(); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Set : %s : %lu(%l)", + GetExtendedPropertyString(pKSProperty->Id), + *pulProperty, + *((LONG*)(pulProperty)))); + + //Retrieve the actual filter parameter. + switch (pKSProperty->Id) + { + case KSPROPERTY_BDA_DISEQC: + ntSetStatus = pFilter->SendDiseqcCommand((PDISEQC_COMMAND) pulProperty); + break; + default: + ntSetStatus = STATUS_INVALID_PARAMETER; + break; + } + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +//Debug Functions +VOID PrintBdaTransport(PKS_DATARANGE_BDA_TRANSPORT pBdaTransport) +{ + PrintBdaTransportInfo(&pBdaTransport->BdaTransportInfo); + PrintKsDataFormat(&pBdaTransport->DataRange); + +} + +VOID PrintBdaTransportInfo(PBDA_TRANSPORT_INFO pBdaTransportInfo) +{ + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pBdaTransportInfo->ulcbPhyiscalPacket = %lu Bytes\n", + pBdaTransportInfo->ulcbPhyiscalPacket)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pBdaTransportInfo->ulcbPhyiscalFrame = %lu Bytes\n", + pBdaTransportInfo->ulcbPhyiscalFrame)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pBdaTransportInfo->ulcbPhyiscalFrameAlignment = %lu\n", + pBdaTransportInfo->ulcbPhyiscalFrameAlignment)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pBdaTransportInfo->ulcbPhyiscalPacket = %ll (Normal Active Movie units)\n", + pBdaTransportInfo->ulcbPhyiscalPacket)); + +} + +VOID PrintKsDataFormat(PKSDATAFORMAT pKsDataFormat) +{ + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pKsDataFormat->FormatSize = %lu\n", + pKsDataFormat->FormatSize)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pKsDataFormat->Flags = %lu\n", + pKsDataFormat->Flags)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pKsDataFormat->SampleSize = %lu\n", + pKsDataFormat->SampleSize)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pKsDataFormat->Reserved = %lu\n", + pKsDataFormat->Reserved)); + +} + +PCHAR GetDemodPropertyString(ULONG ulDemodProperty) +{ + switch(ulDemodProperty) + { + case KSPROPERTY_BDA_MODULATION_TYPE: + return "KSPROPERTY_BDA_MODULATION_TYPE"; + + case KSPROPERTY_BDA_INNER_FEC_TYPE: + return "KSPROPERTY_BDA_INNER_FEC_TYPE"; + + case KSPROPERTY_BDA_INNER_FEC_RATE: + return "KSPROPERTY_BDA_INNER_FEC_RATE"; + + case KSPROPERTY_BDA_OUTER_FEC_TYPE: + return "KSPROPERTY_BDA_OUTER_FEC_TYPE"; + + case KSPROPERTY_BDA_OUTER_FEC_RATE: + return "KSPROPERTY_BDA_OUTER_FEC_RATE"; + + case KSPROPERTY_BDA_SYMBOL_RATE: + return "KSPROPERTY_BDA_SYMBOL_RATE"; + + case KSPROPERTY_BDA_SPECTRAL_INVERSION: + return "KSPROPERTY_BDA_SPECTRAL_INVERSION"; + + case KSPROPERTY_BDA_GUARD_INTERVAL: + return "KSPROPERTY_BDA_GUARD_INTERVAL"; + + case KSPROPERTY_BDA_TRANSMISSION_MODE: + return "KSPROPERTY_BDA_TRANSMISSION_MODE"; + + default: + return "KSPROPERTY_BDA_INVALID_PROPERTY"; + } +} + +PCHAR GetExtendedPropertyString(ULONG ulTunerExtendedProperty) +{ + switch(ulTunerExtendedProperty) + { + case KSPROPERTY_BDA_DISEQC: + return "KSPROPERTY_BDA_DISEQC"; + default: + return "KSPROPERTY_BDA_INVALID_PROPERTY"; + } +} diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerFilter.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerFilter.cpp new file mode 100644 index 0000000..e6de863 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerFilter.cpp @@ -0,0 +1,1402 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1TunerFilter.cpp + Author : + Date : + Purpose : Tuner Filter Class Definition + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Main Header file +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : CTunerFilter + Description : Constructor of the CTunerFilter Class + Creates the filter object,associates it with the device + object, and initializes member variables for it. + IN PARAM : NONE + OUT PARAM : NONE + PreCondition : Filter Object is not created + PostCondtion : Filter Object is created and Initialzed on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +CTunerFilter::CTunerFilter() +{ + PrintFunctionEntry(__FUNCTION__); + + //Setting the Tuner Parameters Default + m_CurResource.ulCarrierFrequency = TUNER_FREQ_MIN; + m_CurResource.ulFrequencyMultiplier = 1000; + m_CurResource.ulBandWidth = 0; + m_CurResource.Polarity = BDA_POLARISATION_LINEAR_H; + m_CurResource.ulInnerFecType = BDA_FEC_VITERBI; + m_CurResource.InnerFecRate = BDA_BCC_RATE_1_2; + m_CurResource.ulOuterFecType = BDA_FEC_VITERBI; + m_CurResource.OuterFecRate = BDA_BCC_RATE_1_2; + m_CurResource.CurrentModulationType = BDA_MOD_QPSK; + m_CurResource.CurrentTransmissionMode = BDA_XMIT_MODE_2K; + m_CurResource.CurrentGuardInterval = BDA_GUARD_NOT_DEFINED; + m_CurResource.CurrentSpectralInversion = BDA_SPECTRAL_INVERSION_NOT_DEFINED; + m_CurResource.ulSymbolRate = 20000; + m_NewResource = m_CurResource; + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); +} + +/***************************************************************************** + Function : CTunerFilter + Description : Destructor of the CTunerFilter Class + Destroys the filter object + IN PARAM : NONE + OUT PARAM : NONE + PreCondition : Filter Object is created + PostCondtion : Filter Object is Removed and Memory freed + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +CTunerFilter::~CTunerFilter() +{ + PrintFunctionEntry(__FUNCTION__); + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); +} + +/***************************************************************************** + Function : CTunerFilter::Create() + Description : This function is called when a Filter is Created.MiniDriver + uses this function to Initialize the Context and resources + associted with the Filter. + Creates the filter object,associates it with the device object, and + initializes member variables for it. + IN PARAM : Pointer to KSFILTER that just created + Pointer to IRP_MJ_CREATE for Filter + OUT PARAM : Status of the Filter Create routine + STATUS_SUCCESS on Routine success + Else Error code from the attempt to create the Filter + PreCondition : Filter is not created + PostCondtion : Filter is created and Initialzed on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::Create( IN OUT PKSFILTER pKSFilter, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntFilterCreationStatus = STATUS_SUCCESS; + PKSDEVICE pKSDeviceObject = NULL; + CSkyWalker1Device * pDevice = NULL; + + PrintFunctionEntry(__FUNCTION__); + + //Create a filter object for the filter instance. + CTunerFilter* pFilter = new(PagedPool,TUNER_MEM_TAG) CTunerFilter; // Tags the allocated memory + if (!IS_VALID(pFilter)) + { + //Exit if the Filter Memory could not be allocated + SkyWalkerDebugPrint(ENTRY_LEVEL,("Low on Memory Resource to Create the Filter\n")); + ntFilterCreationStatus = STATUS_INSUFFICIENT_RESOURCES; + goto ErrorFilterCreate; + } + + //Link the filter context to the passed in pointer to the KSFILTER structure. + pKSFilter->Context = pFilter; + + //Set the Back reference to the Streaming Device + //The KsFilterGetDevice function returns the AVStream device to which Filter belongs. + pKSDeviceObject = KsFilterGetDevice(pKSFilter); + + if( (!(IS_VALID(pKSDeviceObject))) || + (!(IS_VALID(pKSDeviceObject->Context)))) + { + //if the Filter does not belong to any Streaming Device or + //Streaming Device Extension is NULL then the Device is not connected + SkyWalkerDebugPrint(ENTRY_LEVEL,("No Device for the Filter\n")); + ntFilterCreationStatus = STATUS_DEVICE_NOT_CONNECTED; + goto ErrorFilterCreate; + } + // Get the device object from the retrieved pointer to the KSDevice for this filter. + pDevice = reinterpret_cast(pKSDeviceObject->Context); + + // Link the filter context to the device context. + // That is, set the filter's device pointer data member to the obtained device pointer. + pFilter->m_pDevice = pDevice; + + // Initialize member variables. + pFilter->m_KsState = KSSTATE_STOP; + pFilter->m_BdaChangeState = BDA_CHANGES_COMPLETE; + pFilter->m_ulResourceID = 0; + + // Configure the initial resource for DVBS . + pFilter->m_CurResource.ulCarrierFrequency = TUNER_FREQ_MIN; + pFilter->m_CurResource.ulFrequencyMultiplier = 1000; + pFilter->m_CurResource.Polarity = BDA_POLARISATION_LINEAR_H; + pFilter->m_CurResource.ulSymbolRate = 20000; + pFilter->m_fResourceAcquired = FALSE; + + //Initialize the Filter Context i.e. Extension + + //The BdaInitFilter() function initializes the BDA filter context + //associated with a filter instance. + ntFilterCreationStatus = BdaInitFilter( pKSFilter, //Pointer to Filter inwhich Context to be initialize + &TunerFilterTemplate); //Filter Template Description for the BDA Device + if(NT_ERROR(ntFilterCreationStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Failed to Initialize the Printer\n")); + goto ErrorFilterCreate; + } + else + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Successfully Created the Filter\n")); + ntFilterCreationStatus = STATUS_SUCCESS; + } + +CompleteFilterCreate : + + PrintFunctionExit(__FUNCTION__,ntFilterCreationStatus); + return ntFilterCreationStatus; + +ErrorFilterCreate: + if (IS_VALID(pFilter)) + { + delete pFilter; + } + pKSFilter->Context = NULL; + + goto CompleteFilterCreate; +} + +/***************************************************************************** + Function : CTunerFilter::FilterClose + Description : This function is called when a Filter is Closed.MiniDriver + uses this function to uninitialize the Context and resources + associted with the Filter + Deletes the previously created filter object. + IN PARAM : Pointer to KSFILTER that just closed + Pointer to IRP_MJ_CLOSE for Filter + OUT PARAM : Status of the Filter Close routine + STATUS_SUCCESS Always + PreCondition : Filter is created + PostCondtion : Filter is Closed on successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::FilterClose( IN OUT PKSFILTER pKSFilter, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntFilterCloseStatus = STATUS_SUCCESS; + PrintFunctionEntry(__FUNCTION__); + + CTunerFilter* pFilter = reinterpret_cast(pKSFilter->Context); + + if(IS_VALID(pFilter)) + { + delete pFilter; + pFilter = NULL; + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Closed the Filter\n")); + PrintFunctionExit(__FUNCTION__,ntFilterCloseStatus); + return ntFilterCloseStatus; +} + +/***************************************************************************** + Function : CTunerFilter::StartChanges + Description : This is called when the BDA Topology Change is requested + by Network Provider + IN PARAM : Pointer to the IRP request + Pointer to PKSMETHOD for Filter + Ignored + OUT PARAM : Status of the BdaStartChanges() routine + STATUS_SUCCESS Always + PreCondition : None + PostCondtion : Puts the filter into change state. All changes to BDA topology + and properties changed after this will be in effect only after + a call to the CTunerFilter::CommitChanges() method. + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::StartChanges( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OPTIONAL PVOID pvIgnored + ) +{ + NTSTATUS ntFilterChangeStatus = STATUS_SUCCESS; + CTunerFilter * pFilter; + + PrintFunctionEntry(__FUNCTION__); + + // Obtain a "this" pointer to the filter object. + // + // Because the property dispatch table calls the CTunerFilter::StartChanges() method + // directly, the method must retrieve a pointer to the underlying filter object. + // + pFilter = reinterpret_cast(KsGetFilterFromIrp(pIoRequestPacket)->Context); + + // Call the BDA support library to + // reset any pending BDA topolgoy changes. + ntFilterChangeStatus = BdaStartChanges( pIoRequestPacket); + if(!NT_SUCCESS(ntFilterChangeStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Start Changes Failed\n")); + goto ExitStartChanges; + } + + // Reset any pending resource changes. + pFilter->m_NewResource = pFilter->m_CurResource; + pFilter->m_BdaChangeState = BDA_CHANGES_COMPLETE; + +ExitStartChanges: + PrintFunctionExit(__FUNCTION__,ntFilterChangeStatus); + return ntFilterChangeStatus; +} + +/***************************************************************************** + Function : CTunerFilter::CheckChanges + Description : This is called after completion of the BDA Topology Change + to verify the new topology before committing the change + IN PARAM : Pointer to the IRP request + Pointer to PKSMETHOD for Filter + Ignored + OUT PARAM : Status of the BdaCheckChanges() routine + STATUS_SUCCESS Always + PreCondition : None + PostCondtion : Checks the changes to BDA interfaces that have occured since the + last call to the CTunerFilter::StartChanges() method. Returns the identical + result that the CTunerFilter::CommitChanges() method returns. + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::CheckChanges( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OPTIONAL PVOID pvIgnored + ) +{ + NTSTATUS ntFilterChangeStatus = STATUS_SUCCESS; + CTunerFilter * pFilter; + + PrintFunctionEntry(__FUNCTION__); + + // Obtain a "this" pointer to the filter object. + // + // Because the property dispatch table calls the CTunerFilter::StartChanges() method + // directly, the method must retrieve a pointer to the underlying filter object. + // + pFilter = reinterpret_cast(KsGetFilterFromIrp(pIoRequestPacket)->Context); + + // Call the BDA support library to + // verify a new set of BDA topology changes. + ntFilterChangeStatus = BdaCheckChanges(pIoRequestPacket); + if (!NT_SUCCESS(ntFilterChangeStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Check Changes Failed\n")); + goto ExitCheckChanges; + } + + // Validate the new resource list here. + // In this driver the new resource list is always valid. + +ExitCheckChanges: + PrintFunctionExit(__FUNCTION__,ntFilterChangeStatus); + return ntFilterChangeStatus; + +} +/***************************************************************************** + Function : CTunerFilter::CommitChanges + Description : This is called after validation of the New Topology to + commit the changes + IN PARAM : Pointer to the IRP request + Pointer to PKSMETHOD for Filter + Ignored + OUT PARAM : Status of the Commit Changes + STATUS_SUCCESS Always + PreCondition : None + PostCondtion : Checks and commits the changes to BDA interfaces that have + occured since the last call to the CTunerFilter::StartChanges() + method. + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::CommitChanges( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OPTIONAL PVOID pvIgnored + ) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + CTunerFilter * pFilter; + + PrintFunctionEntry(__FUNCTION__); + + // Obtain a "this" pointer to the filter object. + // + // Because the property dispatch table calls the CTunerFilter::CommitChanges() method + // directly, the method must retrieve a pointer to the underlying filter object. + // + pFilter = reinterpret_cast(KsGetFilterFromIrp(pIoRequestPacket)->Context); + + // + // Validate the new resource list here. + // In this driver the new resource list is always valid. + // + + // Mark the changes as having been made. + // + pFilter->m_CurResource = pFilter->m_NewResource; + pFilter->m_BdaChangeState = BDA_CHANGES_COMPLETE; + + if (pFilter->m_KsState != KSSTATE_STOP) + { + // Commit the resources on the underlying device + // + ntStatus = pFilter->AcquireResources(); + } + + // Call the BDA support library to + // commit a new set of BDA topology changes. + // + ntStatus = BdaCommitChanges( pIoRequestPacket); + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : CTunerFilter::GetChangeState + Description : This function is called to know the Current state + change of the Topology + IN PARAM : Pointer to the IRP request + Pointer to PKSMETHOD for Filter + Status of the Change State + OUT PARAM : Status of the Change State + PreCondition : None + PostCondtion : Returns the current BDA change state + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::GetChangeState( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + OUT PULONG pulChangeState + ) +{ + NTSTATUS ntFilterChangeStatus = STATUS_SUCCESS; + CTunerFilter * pFilter; + BDA_CHANGE_STATE TopologyChangeState; + + PrintFunctionEntry(__FUNCTION__); + + // pulChangeState needs to be verified because minData is zero + // in the KSMETHOD_ITEM definition in bdamedia.h + if (!IS_VALID(pulChangeState)) + { + pIoRequestPacket->IoStatus.Information = sizeof(ULONG); + ntFilterChangeStatus = STATUS_MORE_ENTRIES; + goto ExitGetChangeState; + } + + // Obtain a "this" pointer to the filter object. + // + // Because the property dispatch table calls the CTunerFilter::GetChangeState() method + // directly, the method must retrieve a pointer to the underlying filter object. + // + pFilter = reinterpret_cast(KsGetFilterFromIrp(pIoRequestPacket)->Context); + + // Call the BDA support library to + // verify for any pending BDA topology changes. + ntFilterChangeStatus = BdaGetChangeState( pIoRequestPacket, &TopologyChangeState); + + if (NT_SUCCESS(ntFilterChangeStatus)) + { + // Figure out if there are changes pending. + // + if ( (TopologyChangeState == BDA_CHANGES_PENDING) + || (pFilter->m_BdaChangeState == BDA_CHANGES_PENDING) + ) + { + *pulChangeState = BDA_CHANGES_PENDING; + } + else + { + *pulChangeState = BDA_CHANGES_COMPLETE; + } + } + +ExitGetChangeState: + + PrintFunctionExit(__FUNCTION__,ntFilterChangeStatus); + return ntFilterChangeStatus; +} + +/***************************************************************************** + Function : CTunerFilter::CreateTopology + Description : Keeps track of the topology association between input and output pins + IN PARAM : Pointer to the IRP request + Pointer to PKSMETHOD for Filter + Pounter to the Medium Object + OUT PARAM : Status of the Create topology + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::CreateTopology( IN PIRP pIoRequestPacket, + IN PKSMETHOD pKSMethod, + PVOID pvIgnored + ) +{ + NTSTATUS ntCreateStatus = STATUS_SUCCESS; + CTunerFilter * pFilter; + ULONG ulPinType; + PKSFILTER pKSFilter; + KSP_PIN * pKSPPin = (KSP_PIN *) pKSMethod; + + PrintFunctionEntry(__FUNCTION__); + + // Obtain a "this" pointer to the filter object. + // + // Because the property dispatch table calls the CTunerFilter::CreateTopology() method + // directly, the method must retrieve a pointer to the underlying filter object. + // + pFilter = reinterpret_cast(KsGetFilterFromIrp(pIoRequestPacket)->Context); + + // + // Configure the hardware to complete its internal connection between + // the input pin and output pin here. + // + + // Call the BDA support library to create the standard topology and + // validate the method, instance count, etc. + // + ntCreateStatus = BdaMethodCreateTopology( pIoRequestPacket, pKSMethod, pvIgnored); + + PrintFunctionExit(__FUNCTION__,ntCreateStatus); + return ntCreateStatus; +} + +/***************************************************************************** + Function : CTunerFilter::GetStatus + Description : Gets the current device status for this filter instance + IN PARAM : Pointer to the GUID of Demodulator + OUT PARAM : Status of the Set Demodulator + STATUS_INVALID_PARAMETER -> In case of NULL GUID + STATUS_NOT_SUPPORTED -> In case of GUID other than QPSK Demod. + STATUS_SUCCESS -> On successful execution + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::GetStatus(OUT PBDATUNER_DEVICE_STATUS pDeviceStatus) +{ + NTSTATUS ntGetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if (m_KsState == KSSTATE_STOP) + { + // If we're in stop state then the device status + // doesn't reflect our resource list. + // + pDeviceStatus->fCarrierPresent = FALSE; + pDeviceStatus->fSignalLocked = FALSE; + ntGetStatus = STATUS_SUCCESS; + } + else + { + ntGetStatus = m_pDevice->GetStatus( pDeviceStatus); + } + + PrintFunctionExit(__FUNCTION__,ntGetStatus); + return ntGetStatus; + +} + + +/***************************************************************************** + Function : CTunerFilter::AcquireResources + Description : Acquires resources for the underlying device. + IN PARAM : None + OUT PARAM : Status of Acquire resources + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::AcquireResources() +{ + NTSTATUS ntAcquireStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if (m_fResourceAcquired) + { + ntAcquireStatus = m_pDevice->Update(&m_CurResource,m_ulResourceID); + } + else + { + + //Commit the resources on the underlying device + ntAcquireStatus = m_pDevice->Acquire(&m_CurResource,&m_ulResourceID); + m_fResourceAcquired = NT_SUCCESS(ntAcquireStatus); + } + + PrintFunctionExit(__FUNCTION__,ntAcquireStatus); + return ntAcquireStatus; +} + +/***************************************************************************** + Function : CTunerFilter::ReleaseResources + Description : Releases resources from the underlying device. + IN PARAM : None + OUT PARAM : Status of Release resources + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::ReleaseResources() +{ + NTSTATUS ntReleaseStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + // Release the resources on the underlying device + if (m_fResourceAcquired) + { + ntReleaseStatus = m_pDevice->Release(m_ulResourceID); + m_ulResourceID = 0; + m_fResourceAcquired = FALSE; + } + + PrintFunctionExit(__FUNCTION__,ntReleaseStatus); + return ntReleaseStatus; +} + +/***************************************************************************** + Function : CTunerFilter::GetTunerProperty + Description : Get the Current Tuner Properties + IN PARAM : Will hold the Tuner Properties + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::GetTunerProperty(OUT PBDATUNER_DEVICE_PARAMETER pTunerParameter) +{ + NTSTATUS ntGetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + *pTunerParameter = m_CurResource; + + PrintFunctionExit(__FUNCTION__,ntGetStatus); + return ntGetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetFrequency + Description : Set the New Frequency for the Tuner + IN PARAM : New frequency + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetFrequency(IN ULONG ulBdaParameter) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (ulBdaParameter == BDA_FREQUENCY_NOT_SET)|| + (ulBdaParameter == BDA_FREQUENCY_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + else if(m_CurResource.ulCarrierFrequency != ulBdaParameter) + { + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Set Frequency = %lu\n", + ulBdaParameter)); + + //Set the Frequency + m_NewResource.ulCarrierFrequency = ulBdaParameter; + m_BdaChangeState = BDA_CHANGES_PENDING; + + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetMultiplier + Description : Set the Frequency Multiplier of the Tuner + IN PARAM : New Frequency Multiplier + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetMultiplier(IN ULONG ulBdaParameter) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (ulBdaParameter == BDA_FREQUENCY_MULTIPLIER_NOT_SET)|| + (ulBdaParameter == BDA_FREQUENCY_MULTIPLIER_NOT_DEFINED)) + { + m_NewResource.ulFrequencyMultiplier = 1000; //Default Multiplier + } + else if(m_CurResource.ulFrequencyMultiplier != ulBdaParameter) + { + //Set the Frequency Multiplier + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Set Frequency Multipler = %lu\n", + ulBdaParameter)); + m_NewResource.ulFrequencyMultiplier = ulBdaParameter; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //Update the device Parameters too + //Send 10 bytes mentioning the Parameters + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetBandwidth + Description : Set the Bandwidth of the Tuner + IN PARAM : New Bandwidth + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetBandwidth(IN ULONG ulBdaParameter) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (ulBdaParameter == BDA_CHAN_BANDWITH_NOT_SET)|| + (ulBdaParameter == BDA_CHAN_BANDWITH_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + else if(m_CurResource.ulBandWidth != ulBdaParameter) + { + //Set the Bandwidth + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Set BandWidth = %lu\n", + ulBdaParameter)); + m_NewResource.ulBandWidth = ulBdaParameter; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //Not Supported by Device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetPolarity + Description : Set the Polarity of the Tuner + IN PARAM : New Polarity + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetPolarity(IN Polarisation NewPolarity) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (NewPolarity == BDA_POLARISATION_NOT_SET )|| + (NewPolarity == BDA_POLARISATION_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + //Tuner does not have Polarity, it can set LNB voltage which in tern selects LNB Polarity. + //SEC_VOLTAGE_13 is for Verical/Right polarization, SEC_VOLTAGE_18 is for Horizintal/Left + //polarization + else if ((NewPolarity >= BDA_POLARISATION_LINEAR_H) && + (NewPolarity <= BDA_POLARISATION_CIRCULAR_R)) + { + //Change the Polarization only if new setting is requested + if(m_CurResource.Polarity != NewPolarity) + { + //Set the Polarity + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Set Polarity = %lu\n", + NewPolarity)); + + m_NewResource.Polarity = NewPolarity; + + m_BdaChangeState = BDA_CHANGES_PENDING; + + } + } + else + { + ntSetStatus = STATUS_INVALID_PARAMETER; + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetRange + Description : Set the Tuner Range + IN PARAM : Tuner Range + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetRange(IN ULONG ulRange) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (ulRange == BDA_RANGE_NOT_SET )|| + (ulRange == BDA_RANGE_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + else if(m_CurResource.ulRange != ulRange) + { + m_NewResource.ulRange = ulRange; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //not supported by device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetLowLOFrequency + Description : Set the Low LOF + IN PARAM : Low LOF + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetLowLOFrequency(IN ULONG ulLowLOF) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if(m_CurResource.ulLnbLowLOFrequency != ulLowLOF) + { + m_NewResource.ulLnbLowLOFrequency = ulLowLOF; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //not supported by device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetHighLOFrequency + Description : Set the High LOF + IN PARAM : High LOF + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetHighLOFrequency(IN ULONG ulHighLOF) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if(m_CurResource.ulLnbHighLOFrequency != ulHighLOF) + { + m_NewResource.ulLnbHighLOFrequency = ulHighLOF; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //not supported by device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetSwitchFrequency + Description : Set the Switch Frequency + IN PARAM : Switch Frequency + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetSwitchFrequency(IN ULONG ulSwitchFrequency) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if(m_CurResource.ulLnbSwitchFrequency != ulSwitchFrequency) + { + m_NewResource.ulLnbSwitchFrequency = ulSwitchFrequency; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //not supported by device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetTransponder + Description : Set the Transponder + IN PARAM : Transponder + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetTransponder(IN ULONG ulTransponder) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if(m_CurResource.ulTransponder != ulTransponder) + { + m_NewResource.ulRange = ulTransponder; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //not supported by device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + + +/***************************************************************************** + Function : CTunerFilter::GetDemodProperties + Description : Get the Current Demodulator Properties + IN PARAM : Will hold the Demodulator Properties + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::GetDemodProperty(OUT PBDATUNER_DEVICE_PARAMETER pDemodParameter) +{ + NTSTATUS ntGetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + *pDemodParameter = m_CurResource; + + PrintFunctionExit(__FUNCTION__,ntGetStatus); + return ntGetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetModulatorType + Description : Set the Modulation Type + IN PARAM : New Modulation Type + OUT PARAM : STATUS_SUCCESS in case of QPSK Modulation type + else STATUS_INVALID_PARAMETER + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetModulatorType(IN ModulationType NewModulationType) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (NewModulationType == BDA_MOD_NOT_SET )|| + (NewModulationType == BDA_MOD_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + else if(NewModulationType == BDA_MOD_QPSK) + { + if(m_CurResource.CurrentModulationType != NewModulationType) + { + //Only supporting QPSK + m_NewResource.CurrentModulationType = NewModulationType; + + m_BdaChangeState = BDA_CHANGES_PENDING; + + //Send the Modulation update request to the Device. + //Send 10 bytes mentioning the Parameters + //Byte 8 of the Tuner Command but fixed thus not needed the below command still + //sending the same + + } + } + else + { + ntSetStatus = STATUS_INVALID_PARAMETER; + } + + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetInnerFecType + Description : Set the Inner Fec Type + IN PARAM : New Inner Fec Type + OUT PARAM : STATUS_SUCCESS in case of BDA_FEC_VITERBI + else STATUS_INVALID_PARAMETER + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetInnerFecType(IN ULONG ulNewInnerFecType) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (ulNewInnerFecType == BDA_FEC_METHOD_NOT_SET )|| + (ulNewInnerFecType == BDA_FEC_METHOD_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + //Only supported FEC VITERBI Type Error Correction + else if(ulNewInnerFecType == BDA_FEC_VITERBI) + { + if(m_CurResource.ulInnerFecType != ulNewInnerFecType) + { + m_NewResource.ulInnerFecType = ulNewInnerFecType; + m_BdaChangeState = BDA_CHANGES_PENDING; + } + } + else + { + ntSetStatus = STATUS_INVALID_PARAMETER; + } + + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetInnerFecRate + Description : Set the Inner Fec Rate + IN PARAM : New Inner Fec Rate + OUT PARAM : STATUS_SUCCESS in case of supported Fec Rate + else STATUS_INVALID_PARAMETER + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetInnerFecRate(IN BinaryConvolutionCodeRate NewFecRate) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (NewFecRate == BDA_BCC_RATE_NOT_SET )|| + (NewFecRate == BDA_BCC_RATE_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + else if((NewFecRate!=BDA_BCC_RATE_1_2)&& + (NewFecRate!=BDA_BCC_RATE_2_3)&& + (NewFecRate!=BDA_BCC_RATE_3_4)&& + (NewFecRate!=BDA_BCC_RATE_5_6)&& + (NewFecRate!=BDA_BCC_RATE_7_8)) + { + ntSetStatus = STATUS_INVALID_PARAMETER; + } + else + { + if(m_CurResource.InnerFecRate != NewFecRate) + { + m_NewResource.InnerFecRate = NewFecRate; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //Update the Device Parameters too + //Byte 9 of the Tuner setting command + + } + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetOuterFecType + Description : Set the Outer Fec Type + IN PARAM : New Outer Fec Type + OUT PARAM : STATUS_SUCCESS in case of BDA_FEC_VITERBI + else STATUS_INVALID_PARAMETER + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetOuterFecType(IN ULONG ulNewOuterFecType) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (ulNewOuterFecType == BDA_FEC_METHOD_NOT_SET )|| + (ulNewOuterFecType == BDA_FEC_METHOD_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + //Only supported FEC VITERBI Type Error Correction + else if(ulNewOuterFecType == BDA_FEC_VITERBI) + { + if(m_CurResource.ulOuterFecType != ulNewOuterFecType) + { + m_NewResource.ulOuterFecType = ulNewOuterFecType; + m_BdaChangeState = BDA_CHANGES_PENDING; + } + } + else + { + ntSetStatus = STATUS_INVALID_PARAMETER; + } + + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetOuterFecRate + Description : Set the Outer Fec Rate + IN PARAM : New Outer Fec Rate + OUT PARAM : STATUS_SUCCESS in case of supported Fec Rate + else STATUS_INVALID_PARAMETER + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetOuterFecRate(IN BinaryConvolutionCodeRate NewFecRate) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (NewFecRate == BDA_BCC_RATE_NOT_SET )|| + (NewFecRate == BDA_BCC_RATE_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + else if((NewFecRate!=BDA_BCC_RATE_1_2)&& + (NewFecRate!=BDA_BCC_RATE_2_3)&& + (NewFecRate!=BDA_BCC_RATE_3_4)&& + (NewFecRate!=BDA_BCC_RATE_5_6)&& + (NewFecRate!=BDA_BCC_RATE_7_8)) + { + ntSetStatus = STATUS_INVALID_PARAMETER; + } + else + { + if(m_CurResource.OuterFecRate != NewFecRate) + { + m_NewResource.OuterFecRate = NewFecRate; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //Not supported by SkyWalker1 thus not udpating the Device Parameter + } + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetSymbolRate + Description : Set the Symbol Rate + IN PARAM : New Symbol Rate + OUT PARAM : STATUS_SUCCESS in case of Valid Symbol Rate + else STATUS_INVALID_PARAMETER + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetSymbolRate(IN ULONG ulNewSymbolRate) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (ulNewSymbolRate >= SYMBOL_RATE_MIN) && + (ulNewSymbolRate <= SYMBOL_RATE_MAX)) + { + + if(m_CurResource.ulSymbolRate != ulNewSymbolRate) + { + m_NewResource.ulSymbolRate = ulNewSymbolRate; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //Update the device Parameters too + //Send 10 bytes mentioning the Parameters + } + } + else + { + ntSetStatus = STATUS_INVALID_PARAMETER; + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetSpectralInversion + Description : Set the Spectral Inversion + IN PARAM : Spectral Inversion + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetSpectralInversion(IN SpectralInversion SpecInv) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (SpecInv == BDA_SPECTRAL_INVERSION_NOT_SET )|| + (SpecInv == BDA_SPECTRAL_INVERSION_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + else if(m_CurResource.CurrentSpectralInversion != SpecInv) + { + m_NewResource.CurrentSpectralInversion = SpecInv; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //not supported by device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetGuardInterval + Description : Set the Guard Interval + IN PARAM : Guard Interval + OUT PARAM : STATUS_SUCCESS in case of Valid Symbol Rate + else STATUS_INVALID_PARAMETER + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetGuardInterval(IN GuardInterval GuardInt) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (GuardInt == BDA_GUARD_NOT_SET )|| + (GuardInt == BDA_GUARD_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + else if(m_CurResource.CurrentGuardInterval != GuardInt) + { + m_NewResource.CurrentGuardInterval = GuardInt; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //not supported by device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + +/***************************************************************************** + Function : CTunerFilter::SetTransmissionMode + Description : Set the Transmission Mode + IN PARAM : Transmission Mode + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SetTransmissionMode(IN TransmissionMode TransMode) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + if( (TransMode == BDA_XMIT_MODE_NOT_SET )|| + (TransMode == BDA_XMIT_MODE_NOT_DEFINED)) + { + //Do nothing return SUCCESS + } + if(m_CurResource.CurrentTransmissionMode != TransMode) + { + m_NewResource.CurrentTransmissionMode = TransMode; + m_BdaChangeState = BDA_CHANGES_PENDING; + + //not supported by device + } + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} + + +/***************************************************************************** + Function : CTunerFilter::SendDiseqcCommand + Description : Send Diseqc Command to the Tuner + IN PARAM : Diseqc Command to be sent to the Tuner + OUT PARAM : STATUS_SUCCESS always + PreCondition : None + PostCondtion : None + Logic : 1) Validate the Input Parameters + 2) Check which command is been sent by the application + 3) Send the Command to the Tuner Immediately + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerFilter::SendDiseqcCommand(IN PDISEQC_COMMAND pDiseqcCommand) +{ + NTSTATUS ntSetStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + //Validate the Diseqc Parameters here + + //Send the Diseqc Command to the Device + ntSetStatus = m_pDevice->SendDiseqcCommand(pDiseqcCommand,m_ulResourceID); + + PrintFunctionExit(__FUNCTION__,ntSetStatus); + return ntSetStatus; +} \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerFilterDefinitions.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerFilterDefinitions.cpp new file mode 100644 index 0000000..4c250bf --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerFilterDefinitions.cpp @@ -0,0 +1,717 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1TunerFilterDefinitions.cpp + Author : + Date : + Purpose : Tuner Filter Definition + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Main Header file + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ + +//BDA Tuner Frequency Property Set +DEFINE_KSPROPERTY_TABLE(SkyWalker1TunerFrequencyProperties) +{ + DEFINE_KSPROPERTY_ITEM_BDA_RF_TUNER_FREQUENCY( + CAntennaPin::GetTunerProperty, + CAntennaPin::SetTunerProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_RF_TUNER_FREQUENCY_MULTIPLIER( + CAntennaPin::GetTunerProperty, + CAntennaPin::SetTunerProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_RF_TUNER_POLARITY( + CAntennaPin::GetTunerProperty, + CAntennaPin::SetTunerProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_RF_TUNER_RANGE( + CAntennaPin::GetTunerProperty, + CAntennaPin::SetTunerProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_RF_TUNER_BANDWIDTH( + CAntennaPin::GetTunerProperty, + CAntennaPin::SetTunerProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_RF_TUNER_TRANSPONDER( + CAntennaPin::GetTunerProperty, + CAntennaPin::SetTunerProperty + ), +}; + +//BDA LNB Info Property Set +DEFINE_KSPROPERTY_TABLE(SkyWalker1TunerLnbProperties) +{ + DEFINE_KSPROPERTY_ITEM_BDA_LNB_LOF_HIGH_BAND( + CAntennaPin::GetTunerLnbProperty, + CAntennaPin::SetTunerLnbProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_LNB_LOF_LOW_BAND( + CAntennaPin::GetTunerLnbProperty, + CAntennaPin::SetTunerLnbProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_LNB_SWITCH_FREQUENCY( + CAntennaPin::GetTunerLnbProperty, + CAntennaPin::SetTunerLnbProperty + ), +}; + +//BDA Signal Statistics Properties +// +//Defines the dispatch routines for the Signal Statistics Properties +//on the RF Tuner, Demodulator, and PID Filter Nodes +// +DEFINE_KSPROPERTY_TABLE(SkyWalker1TunerSignalProperties) +{ + + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_STRENGTH( + CAntennaPin::GetSignalStatus, + NULL + ), + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_QUALITY( + CAntennaPin::GetSignalStatus, + NULL + ), + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_PRESENT( + CAntennaPin::GetSignalStatus, + NULL + ), + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_LOCKED( + CAntennaPin::GetSignalStatus, + NULL + ), +#ifdef LOCK_CODE + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_LOCK_CAPS( + CAntennaPin::GetSignalStatus + ), + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_LOCK_TYPE( + CAntennaPin::GetSignalStatus + ), + DEFINE_KSPROPERTY_ITEM_BDA_SAMPLE_TIME( + CTransportPin::GetSignalStatus, + NULL + ), +#endif + + +}; + +DEFINE_KSPROPERTY_SET_TABLE(SkyWalker1TunerAutomationProperties) +{ + DEFINE_KSPROPERTY_SET + ( + &KSPROPSETID_BdaFrequencyFilter, //Property Set defined elsewhere + SIZEOF_ARRAY(SkyWalker1TunerFrequencyProperties), //Number of properties in the array + SkyWalker1TunerFrequencyProperties, //Property set array + 0, //FastIoCount + NULL //FastIoTable + ), + DEFINE_KSPROPERTY_SET + ( + &KSPROPSETID_BdaLNBInfo, //Property Set defined elsewhere + SIZEOF_ARRAY(SkyWalker1TunerLnbProperties), //Number of properties in the array + SkyWalker1TunerLnbProperties, //Property set array + 0, //FastIoCount + NULL //FastIoTable + ), + DEFINE_KSPROPERTY_SET + ( + &KSPROPSETID_BdaSignalStats, //Property Set defined elsewhere + SIZEOF_ARRAY(SkyWalker1TunerSignalProperties), //Number of properties in the array + SkyWalker1TunerSignalProperties, //Property set array + 0, //FastIoCount + NULL //FastIoTable + ), +}; + +//Tuner Automation Table.Used to get and tuner related Methods, +//Events and Properties +DEFINE_KSAUTOMATION_TABLE(SkyWalker1TunerAutomation) +{ + DEFINE_KSAUTOMATION_PROPERTIES(SkyWalker1TunerAutomationProperties), + DEFINE_KSAUTOMATION_METHODS_NULL, + DEFINE_KSAUTOMATION_EVENTS_NULL +}; + +//BDA Signal Statistics Properties for Demodulator Node + +//Defines the dispatch routines for the Signal Statistics Properties +//on the Demodulator Node. +DEFINE_KSPROPERTY_TABLE(SkyWalker1DemodulatorSignalStats) +{ + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_QUALITY( + CTransportPin::GetSignalStatus, + NULL + ), + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_LOCKED( + CTransportPin::GetSignalStatus, + NULL + ), + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_PRESENT( + CTransportPin::GetSignalStatus, + NULL + ), + DEFINE_KSPROPERTY_ITEM_BDA_SIGNAL_STRENGTH( + CTransportPin::GetSignalStatus, + NULL + ), +}; + +// +//BDA Digital Demodulator Property Set for Demodulator Node +// +//Defines the dispatch routines for the Digital Demodulator Properties +//on the Demodulator Node. +// +DEFINE_KSPROPERTY_TABLE(SkyWalker1DemodulatorProps) +{ + DEFINE_KSPROPERTY_ITEM_BDA_MODULATION_TYPE( + CTransportPin::GetDigitalDemodProperty, + CTransportPin::SetDigitalDemodProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_INNER_FEC_TYPE( + CTransportPin::GetDigitalDemodProperty, + CTransportPin::SetDigitalDemodProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_INNER_FEC_RATE( + CTransportPin::GetDigitalDemodProperty, + CTransportPin::SetDigitalDemodProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_OUTER_FEC_TYPE( + CTransportPin::GetDigitalDemodProperty, + CTransportPin::SetDigitalDemodProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_OUTER_FEC_RATE( + CTransportPin::GetDigitalDemodProperty, + CTransportPin::SetDigitalDemodProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_SYMBOL_RATE( + CTransportPin::GetDigitalDemodProperty, + CTransportPin::SetDigitalDemodProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_SPECTRAL_INVERSION( + CTransportPin::GetDigitalDemodProperty, + CTransportPin::SetDigitalDemodProperty + ), + DEFINE_KSPROPERTY_ITEM_BDA_TRANSMISSION_MODE( + CTransportPin::GetDigitalDemodProperty, + CTransportPin::SetDigitalDemodProperty + ), +}; + +//BDA Extended Property Set +DEFINE_KSPROPERTY_TABLE(SkyWalker1ExtendedProperties) +{ + DEFINE_KSPROPERTY_ITEM_BDA_DISEQC( + NULL, + CTransportPin::SetExtendedProperty + ), +}; + + +/*****************************************************************************************/ + +//Demodulator Node Property Sets supported +// +//This table defines all property sets supported by the +//Demodulator Node associated with the transport output pin. +// +DEFINE_KSPROPERTY_SET_TABLE(SkyWalker1DemodulatorProperties) +{ + + DEFINE_KSPROPERTY_SET + ( + &KSPROPSETID_BdaDigitalDemodulator, //Set + SIZEOF_ARRAY(SkyWalker1DemodulatorProps), //PropertiesCount + SkyWalker1DemodulatorProps, //PropertyItems + 0, //FastIoCount + NULL //FastIoTable + ), + DEFINE_KSPROPERTY_SET + ( + &KSPROPSETID_BdaExtendedProperty, //Set + SIZEOF_ARRAY(SkyWalker1ExtendedProperties), //PropertiesCount + SkyWalker1ExtendedProperties, //PropertyItems + 0, //FastIoCount + NULL //FastIoTable + ), + DEFINE_KSPROPERTY_SET + ( + &KSPROPSETID_BdaSignalStats, //Set + SIZEOF_ARRAY(SkyWalker1DemodulatorSignalStats), //PropertiesCount + SkyWalker1DemodulatorSignalStats, //PropertyItems + 0, //FastIoCount + NULL //FastIoTable + ), + + // + //Additional property sets for the node can be added here. + // +}; + + +DEFINE_KSAUTOMATION_TABLE(SkyWalker1DemodulatorAutomation) { + DEFINE_KSAUTOMATION_PROPERTIES(SkyWalker1DemodulatorProperties), + DEFINE_KSAUTOMATION_METHODS_NULL, + DEFINE_KSAUTOMATION_EVENTS_NULL +}; + +/*****************************************************************************************/ +//Template Node Descriptors +// +//Define an array that contains all the node types that are available in the template +//topology of the filter. +//These node types must be supported by BDA and +//defined elsewhere (for example, in Bdamedia.h). +// + +const KSNODE_DESCRIPTOR TunerFilterNodeDescriptors[] = +{ + DEFINE_NODE_DESCRIPTOR( + &SkyWalker1TunerAutomation, //Point to KSAUTOMATION_TABLE structure + //for the node's automation table + &KSNODE_BDA_RF_TUNER, //Point to the guid that defines function + //of the node + NULL //Point to the guid that represents the + //name of the topology node + ), + DEFINE_NODE_DESCRIPTOR( + &SkyWalker1DemodulatorAutomation,//Point to KSAUTOMATION_TABLE structure + //for the node's automation table + &KSNODE_BDA_QPSK_DEMODULATOR,//Point to the guid that defines function + //of the node + NULL //Point to the guid that represents the + //name of the topology node + ), +}; + +/*****************************************************************************************/ +//Define BDA Template Topology Connections +// +//Lists the Connections that are possible between pin types and +//node types. This, together with the Template Filter Descriptor, and +//the Pin Pairings, describe how topologies can be created in the filter. +// +// =========== ============ +//AntennaPin ----| RF Node |--Joint--|Demod Node|----TransportPin +// =========== ============ +// +//The RF Node of this filter is controlled by the Antenna input pin. +//RF properties will be set as NODE properties (with NodeType == 0) +//on the filter's Antenna Pin +// +//The Demodulator Node of this filter is controlled by the Transport output pin. +//Demod properties will be set as NODE properties (with NodeType == 1) +//on the filter's Transport Pin + +const KSTOPOLOGY_CONNECTION TunerFilterConnections[]={ + {KSFILTER_NODE, 0, 0, KSNODEPIN_STANDARD_IN}, //Antenna pin -> Tuner pin 0 + {0, KSNODEPIN_STANDARD_OUT, 1, KSNODEPIN_STANDARD_IN}, //Tuner pin 1 -> Demodulator pin 0 + {1, KSNODEPIN_STANDARD_OUT, KSFILTER_NODE, 1}, //Demodulator pin 1 -> Transport pin +}; + +//Lists the template joints between the Antenna Input Pin Type and +//the Transport Output Pin Type. +// +//In this case the RF Node is considered to belong to the antennea input +//pin and the 8VSB Demodulator Node is considered to belong to the +//tranport stream output pin. +// +const ULONG InterNodeJoints[] = +{ + 1 //joint occurs between the two node types (second element in array) + //indicates that 1st node is controlled by input pin and 2nd node by output pin +}; + + +//Array of BDA_PIN_PAIRING structures that are used to determine +//which nodes get duplicated when more than one output pin type is +//connected to a single input pin type or when more that one input pin +//type is connected to a single output pin type. +// +const BDA_PIN_PAIRING TunerFilterPinPairings[] = +{ + //Input pin to Output pin Topology Joints + { + 0, //ulInputPin; 0 element in the TemplatePinDescriptors array. + 1, //ulOutputPin; 1 element in the TemplatePinDescriptors array. + 1, //ulcMaxInputsPerOutput + 1, //ulcMinInputsPerOutput + 1, //ulcMaxOutputsPerInput + 1, //ulcMinOutputsPerInput + SIZEOF_ARRAY(InterNodeJoints), //ulcTopologyJoints + InterNodeJoints //pTopologyJoints; array of joints + } + //If applicable, list topology of joints between other pins. +}; + +/*****************************************************************************************/ + +const KSCOMPONENTID TunerFilterComponentId={ + NULL, + NULL, + NULL, + NULL, + 1, //Version + 0 //Revision +}; +/**********************************************************************************/ + +// +//Dispatch Table for the antenna pin. +// + +const KSPIN_DISPATCH AntennaPinDispatch={ + /* Create */ CAntennaPin::PinCreate, + /* Close */ CAntennaPin::PinClose, + /* Process */ NULL, + /* Reset */ NULL, + /* SetDataFormat */ NULL, + /* SetDeviceState */ CAntennaPin::PinSetDeviceState, + /* Connect */ NULL, + /* Disconnect */ NULL, + /* Allocator */ NULL +}; + +DEFINE_KSAUTOMATION_TABLE(NullAutomation) +{ + DEFINE_KSAUTOMATION_PROPERTIES_NULL, + DEFINE_KSAUTOMATION_METHODS_NULL, + DEFINE_KSAUTOMATION_EVENTS_NULL +}; + +const KS_DATARANGE_BDA_ANTENNA AntennaPinRange = +{ + //insert the KSDATARANGE and KSDATAFORMAT here + { + sizeof( KS_DATARANGE_BDA_ANTENNA), //FormatSize + 0, //Flags - (N/A) + 0, //SampleSize - (N/A) + 0, //Reserved + { STATIC_KSDATAFORMAT_TYPE_BDA_ANTENNA }, //MajorFormat + { STATIC_KSDATAFORMAT_SUBTYPE_NONE }, //SubFormat + { STATIC_KSDATAFORMAT_SPECIFIER_NONE } //Specifier + } +}; + +const PKSDATARANGE AntennaPinRanges[]={ + (PKSDATARANGE)&AntennaPinRange, +}; + +// +//Dispatch Table for the transport Output pin. +// +//Since data on the transport is actually delivered to the +//PCI bridge in hardware, this pin does not process data. +// +//Connection of, and state transitions on, this pin help the +//driver to determine when to allocate hardware resources for +//each node. +// +const KSPIN_DISPATCH TransportPinDispatch = +{ + CTransportPin::PinCreate, //Create + CTransportPin::PinClose, //Close + NULL, //Process + NULL, //Reset + NULL, //SetDataFormat + /*AntennaPinSetDeviceState*/ NULL, //SetDeviceState + NULL, //Connect + NULL, //Disconnect + NULL, //Clock + NULL //Allocator +}; + + +const KSPIN_INTERFACE StreamInterface[]={ + { + STATICGUIDOF(KSINTERFACESETID_Standard), + KSINTERFACE_STANDARD_STREAMING, + 0 + }, +}; + +//Medium GUIDs for the Transport Output Pin. +// +//Pin Medium descriptor containing all medium accepted to be connected to +//the tuner output pin.This insures contection to the correct Capture Filter pin. +// +//{2AEB4A94-FBB7-4FB1-8D74-243B91886EAB} + +const KSPIN_MEDIUM TransportPinMediums[] = +{ + { + GUID_SKYWALKER_TUNER_OUT_MEDIUM, + 0, + 0 + } +}; + +const KS_DATARANGE_BDA_TRANSPORT TransportPinRange = +{ + //insert the KSDATARANGE and KSDATAFORMAT here + { + sizeof( KS_DATARANGE_BDA_TRANSPORT), //FormatSize + 0, //Flags - (N/A) + 0, //SampleSize - (N/A) + 0, //Reserved + { STATIC_KSDATAFORMAT_TYPE_STREAM }, //MajorFormat + { STATIC_KSDATAFORMAT_TYPE_MPEG2_TRANSPORT }, //SubFormat + { STATIC_KSDATAFORMAT_SPECIFIER_BDA_TRANSPORT } //Specifier + }, + //BDA_TRANSPORT_INFO + { + TRANSPORT_PACKET_SIZE, //Bytes in Line + TRANSPORT_PACKET_SIZE * TRANSPORT_PACKET_COUNT, //Frame Size + 0, //ulcbPhysicalFrameAlignment (no requirement) + 0 //AvgTimePerFrame, Time / Sample (not known) + } +}; + +//Format Ranges of Transport Output Pin. +// +static PKSDATAFORMAT TransportPinRanges[] = +{ + (PKSDATAFORMAT) &TransportPinRange, + + //Add more formats here if additional transport formats are supported. + // +}; + +DECLARE_SIMPLE_FRAMING_EX(TransportAllocator, + STATICGUIDOF(KSMEMORY_TYPE_KERNEL_NONPAGED), + KSALLOCATOR_REQUIREMENTF_SYSTEM_MEMORY/*|KSALLOCATOR_REQUIREMENTF_PREFERENCES_ONLY*/, + 8, + 0, + TRANSPORT_PACKET_COUNT*TRANSPORT_PACKET_SIZE, + TRANSPORT_PACKET_COUNT*TRANSPORT_PACKET_SIZE); + + +//Template Pin Descriptors + +//This data structure defines the pin types available in the filters +//template topology. These structures will be used to create a +//KDPinFactory for a pin type when BdaCreatePin or BdaMethodCreatePin +//are called. +// +//This structure defines ALL pins the filter is capable of supporting, +//including those pins which may only be created dynamically by a ring +//3 component such as a Network Provider. + +const KSPIN_DESCRIPTOR_EX TunerFilterPinDescriptors[]={ + { //Antenna input pin + &AntennaPinDispatch, //Dispatch Table + &NullAutomation, //Automation Table + { + 0, //Interfaces + NULL, + 0, //Mediums + NULL, + SIZEOF_ARRAY(AntennaPinRanges), + AntennaPinRanges, + KSPIN_DATAFLOW_IN, //Specifies that data flow is into the pin + KSPIN_COMMUNICATION_BOTH, //Specifies that the pin factory instantiates pins + //that are both IRP sinks and IRP sources + NULL, //Category + NULL, //Name + 0 + }, + KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT| + KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING| + KSPIN_FLAG_FIXED_FORMAT, + 1, //Maximum Possible Instances of the Pin + 1, //Mandatory Instances of this for the Filter function + NULL, + CAntennaPin::IntersectDataFormat //Data Interaction Handler + }, + //Tranport Output Pin + { + &TransportPinDispatch, //Point to the dispatch table for the output pin + &NullAutomation, //Point to the automation table for the output pin + { //Specify members of a KSPIN_DESCRIPTOR structure for the output pin + 0, //Interface Count + NULL, //Interfaces + SIZEOF_ARRAY(TransportPinMediums), //Medium Count + TransportPinMediums, //Medium + SIZEOF_ARRAY(TransportPinRanges), //Range Count + TransportPinRanges, //Ranges + KSPIN_DATAFLOW_OUT, //specifies that data flow is out of the pin + KSPIN_COMMUNICATION_BOTH, //specifies that the pin factory instantiates pins + (GUID *) &PINNAME_BDA_TRANSPORT, //Category GUID + (GUID *) &PINNAME_BDA_TRANSPORT, //GUID of the localized Unicode string //name for the pin type + 0 + }, //Specify flags + KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT | + KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING | + KSPIN_FLAG_FIXED_FORMAT, + 1, //Specify the maximum number of possible instances of the output pin + 1, //Specify the number of instances of this pin type that are necessary for proper functioning of this filter + NULL, //Allocator Framing + CTransportPin::IntersectDataFormat //Point to the data intersection handler function + } +}; + +/**********************************************************************************/ + +//BDA Device Topology Property Set + +//The BDA Support Library supplies a default implementation of the +//BDA Device Topology Property Set. If the driver needs to override +//this default implemenation, the definitions for the override properties +//will be defined here. + + +//BDA Device Configuration Method Set + +//The BDA Support Library provides a default implementation of +//the BDA Device Configuration Method Set. In this , the +//driver overrides the CreateTopology method. Note that the +//support libraries CreateTopology method is called before the +//driver's implementation returns. +// +DEFINE_KSMETHOD_TABLE(TunerFilterConfiguration) +{ + DEFINE_KSMETHOD_ITEM_BDA_CREATE_TOPOLOGY( + CTunerFilter::CreateTopology, //Calls BdaMethodCreateTopology + NULL + ) +}; + + +//BDA Change Sync Method Set + +//The Change Sync Method Set is required on BDA filters. Setting a +//node property should not become effective on the underlying device +//until CommitChanges is called. +//The BDA Support Library provides routines that handle committing +//changes to topology. The BDA Support Library routines should be +//called from the driver's implementation before the driver implementation +//returns. + +DEFINE_KSMETHOD_TABLE(TunerFilterChangeSync) +{ + DEFINE_KSMETHOD_ITEM_BDA_START_CHANGES( + CTunerFilter::StartChanges, //Calls BdaStartChanges + NULL + ), + DEFINE_KSMETHOD_ITEM_BDA_CHECK_CHANGES( + CTunerFilter::CheckChanges, //Calls BdaCheckChanges + NULL + ), + DEFINE_KSMETHOD_ITEM_BDA_COMMIT_CHANGES( + CTunerFilter::CommitChanges, //Calls BdaCommitChanges + NULL + ), + DEFINE_KSMETHOD_ITEM_BDA_GET_CHANGE_STATE( + CTunerFilter::GetChangeState, //Calls BdaGetChangeState + NULL + ) +}; + + +//Array of Method sets supported by filter +DEFINE_KSMETHOD_SET_TABLE(TunerFilterMethods) +{ + DEFINE_KSMETHOD_SET + ( + &KSMETHODSETID_BdaChangeSync, //Method set GUID + SIZEOF_ARRAY(TunerFilterChangeSync), //Number of methods + TunerFilterChangeSync, //Array of KSMETHOD_ITEM structures + 0, //FastIoCount + NULL //FastIoTable + ), + + DEFINE_KSMETHOD_SET + ( + &KSMETHODSETID_BdaDeviceConfiguration, //Method set GUID + SIZEOF_ARRAY(TunerFilterConfiguration), //Number of methods + TunerFilterConfiguration, //Array of KSMETHOD_ITEM structures + 0, //FastIoCount + NULL //FastIoTable + ) + +}; + +//Supporting only Filter Methods;Properties and Events are not supported +DEFINE_KSAUTOMATION_TABLE(TunerFilterAutomationTable) +{ + DEFINE_KSAUTOMATION_PROPERTIES_NULL, + DEFINE_KSAUTOMATION_METHODS(TunerFilterMethods), + DEFINE_KSAUTOMATION_EVENTS_NULL +}; +/**********************************************************************************/ +//Dispatch table for the Filter Processing +const KSFILTER_DISPATCH TunerFilterDispatchTable = +{ + /* Create */ CTunerFilter::Create, //Routine called when the Filter is created + /* Close */ CTunerFilter::FilterClose, //Routine called when the Filter is closed + /* Process */ NULL, + /* Reset */ NULL +}; + +/*****************************************************************************************/ + +//Define the Filter Factory Descriptor for the filter +//This structure brings together all of the structures that define +//the tuner filter as it appears when it is first instantiated. +//Note that not all of the template pin and node types may be exposed as +//pin and node factories when the filter is first instanciated. + +//The KSFILTER_DESCRIPTOR structure describes the characteristics of a filter created by a given filter factory. +DEFINE_KSFILTER_DESCRIPTOR(SkyWalker1TunerFilterDescriptor) +{ + &TunerFilterDispatchTable, //Dispatch (Filter Specific Driver) + &TunerFilterAutomationTable, //AutomationTable + KSFILTER_DESCRIPTOR_VERSION, //Version + 0, //Flags + &SKYWALKER_TUNER_FILTER, //ReferenceGuid + DEFINE_KSFILTER_PIN_DESCRIPTORS(TunerFilterPinDescriptors), + //PinDescriptorsCount; must expose at least one pin + //PinDescriptorSize; size of each item + //PinDescriptors; table of pin descriptors + DEFINE_KSFILTER_CATEGORY(KSCATEGORY_BDA_NETWORK_TUNER), + //CategoriesCount; number of categories in the table + //Categories; table of categories + DEFINE_KSFILTER_NODE_DESCRIPTORS(TunerFilterNodeDescriptors), + //NodeDescriptorsCount; + //NodeDescriptorSize; + //NodeDescriptors; + DEFINE_KSFILTER_CONNECTIONS(TunerFilterConnections), + //Automatically fills in the connections table for a filter which defines no explicit connections + //ConnectionsCount; number of connections in the table + //Connections; table of connections + &TunerFilterComponentId //ComponentId; +}; + +//BDA_FILTER_TEMPLATE structure describes the template topology for BDA Driver +const BDA_FILTER_TEMPLATE TunerFilterTemplate = +{ + &SkyWalker1TunerFilterDescriptor,//Pointer to KS_FILTER_DESCRIPTOR which describes the Filter for BDA Device + SIZEOF_ARRAY(TunerFilterPinPairings), //Number of PAIRS of pins in BDA_PIN_PAIRING Array + TunerFilterPinPairings //Array of Pin Pairing describes topology between a pair of Filter's Input and Output Pins +}; + +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerPin.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerPin.cpp new file mode 100644 index 0000000..d81001e --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1TunerPin.cpp @@ -0,0 +1,212 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1CPin.cpp + Author : + Date : + Purpose : This File Holds the General Pin related declarations + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Common For all the Definitions, + //Declarations and Library Routines + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + + +/***************************************************************************** + Function : CTunerPin::PinCreate + Description : An AVStream minidriver's AVStrMiniPinCreate routine is + called when a pin is created. Typically, this routine is + used by minidrivers that want to initialize the context + and resources associated with the pin. + IN PARAM : Pointer to the KSPIN that was just created. + Pointer to the IRP_MJ_CREATE for Pin + OUT PARAM : STATUS_SUCCESS in case of successful pin creation + Failure Code in other cases + PreCondition : None + PostCondtion : Creates the Tuner pin object and associates it + with the filter object. + Logic : NONE + Assumption : NONE + Note : None + Revision History: + *****************************************************************************/ +NTSTATUS CTunerPin::PinCreate( IN OUT PKSPIN pKSPin, + IN PIRP pIoRequestPacket + ) +{ + NTSTATUS ntCreateStatus = STATUS_SUCCESS; + CTunerPin* pPin = NULL; //Pointer to the Current Pin Instance + CTunerFilter* pFilter = NULL; //Pointer to the Filter associted with the Pin + + PrintFunctionEntry(__FUNCTION__); + SkyWalkerDebugPrint(ENTRY_LEVEL,("Sizeof DISEQC_COMMAND = %d\n",sizeof(DISEQC_COMMAND))); + //Obtain a pointer to the filter object for which the input pin is created. + + //The KsGetFilterFromIrp function returns the AVStream filter object + //associated with a given IRP. + pFilter = reinterpret_cast(KsGetFilterFromIrp(pIoRequestPacket)->Context); + + //Create the Tuner pin object. + pPin = new(PagedPool,TUNER_MEM_TAG) CTunerPin; // Tags the allocated memory + + if (pPin) + { + //Link the pin context to the filter context. + //That is, set the input pin's filter pointer data member to the obtained filter pointer. + pPin->SetFilter( pFilter); + + //Link the pin context to the passed in pointer to the KSPIN structure. + pKSPin->Context = pPin; + + } + else + { + ntCreateStatus = STATUS_INSUFFICIENT_RESOURCES; + } + + PrintFunctionExit(__FUNCTION__,ntCreateStatus); + return ntCreateStatus; +} + +/***************************************************************************** + Function : CTunerPin::PinClose + Description : An AVStream minidriver's AVStrMiniPinClose routine is + called when a pin is closed.It usually is provided by + minidrivers that want to free the context and resources + associated with the pin. + IN PARAM : Pointer to the KSPIN that was just closed. + Pointer to the IRP_MJ_CLOSE for Pin. + OUT PARAM : STATUS_SUCCESS in case of successful pin Close + Failure Code in other cases + PreCondition : None + PostCondtion : Deletes the previously created Tuner pin object. + Logic : NONE + Assumption : NONE + Note : This is called from the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS CTunerPin::PinClose( IN OUT PKSPIN pKSPin, + IN PIRP pIoRequestPacket + ) +{ + NTSTATUS ntCloseStatus = STATUS_SUCCESS; + CTunerPin* pPin = NULL; //Pointer to the Current Pin Instance + CTunerFilter* pFilter = NULL; //Pointer to the Filter associted with the Pin + + PrintFunctionEntry(__FUNCTION__); + + // Retrieve the Tuner pin object from the passed in + // KSPIN structure's context member. + // + pPin = reinterpret_cast(pKSPin->Context); + + if(IS_VALID(pPin)) + { + delete pPin; + pPin = NULL; + } + + PrintFunctionExit(__FUNCTION__,ntCloseStatus); + return ntCloseStatus; +} + +/***************************************************************************** + Function : CTunerPin::GetSignalStatus + Description : Retrieves the value of the signal statistics properties. + IN PARAM : IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + OUT PULONG pulProperty + OUT PARAM : Status SUCCESS in case Valid Property request + STATUS_INVALID_PARAMETER in case of Invalid property request + Else error from the lower device + PreCondition : None + PostCondtion : Signal Status read in case of successful execution + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CTunerPin::GetSignalStatus( + IN PIRP pIoRequestPacket, + IN PKSPROPERTY pKSProperty, + OUT PULONG pulProperty + ) +{ + NTSTATUS ntGetStatus = STATUS_SUCCESS; + CTunerPin* pPin = NULL; //Pointer to the Current Pin Instance + CTunerFilter* pFilter = NULL; //Pointer to the Filter associted with the Pin + BDATUNER_DEVICE_STATUS TunerStatus; + + PrintFunctionEntry(__FUNCTION__); + + + // Call the BDA support library to + // validate that the node type is associated with this pin. + ntGetStatus = BdaValidateNodeProperty( pIoRequestPacket, pKSProperty); + if (NT_SUCCESS( ntGetStatus)) + { + // Obtain a pointer to the pin object. + // + // Because the property dispatch table calls the CTunerPin::GetSignalStatus() + // method directly, the method must retrieve a pointer to the underlying pin object. + // + pPin = reinterpret_cast(KsGetPinFromIrp(pIoRequestPacket)->Context); + + // Retrieve the filter context from the pin context. + // + pFilter = pPin->GetFilter(); + + ntGetStatus = pFilter->GetStatus( &TunerStatus); + if (ntGetStatus == STATUS_SUCCESS) + { + switch (pKSProperty->Id) + { + case KSPROPERTY_BDA_SIGNAL_LOCKED: + *pulProperty = TunerStatus.fSignalLocked; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Signal Lock = 0x%02X\n",*pulProperty)); + break; + case KSPROPERTY_BDA_SIGNAL_QUALITY: + *pulProperty = TunerStatus.dwSignalQuality; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Signal Quality = %lu\n",*pulProperty)); + break; + case KSPROPERTY_BDA_SIGNAL_PRESENT: + *pulProperty = TunerStatus.fCarrierPresent; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Signal Present = 0x%02X\n",*pulProperty)); + break; + case KSPROPERTY_BDA_SIGNAL_STRENGTH: + *pulProperty = TunerStatus.dwSignalStrength; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Signal Strength = %lu\n", *pulProperty)); + break; + default: + ntGetStatus = STATUS_INVALID_PARAMETER; + } + } + } + + PrintFunctionExit(__FUNCTION__,ntGetStatus); + return ntGetStatus; +} \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1USB.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1USB.cpp new file mode 100644 index 0000000..e83ef37 --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1USB.cpp @@ -0,0 +1,2101 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Usb.cpp + Author : + Date : + Purpose : This File Holds all the USB Device access related declarations + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ +/* Include the Library and Other header file */ +//#include +#include "SkyWalker1Main.h" //Header for the Tuner related definitions + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +#define USB_MEMORY_TAG 'MBSU' +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +NTSTATUS ReadandSelectDescriptors( IN PKSDEVICE pKSDeviceObject ); +NTSTATUS ConfigureDevice(IN PKSDEVICE pKSDeviceObject); +NTSTATUS SelectInterfaces( IN PKSDEVICE pKSDeviceObject, + IN PUSB_CONFIGURATION_DESCRIPTOR pConfigurationDescriptor); + +NTSTATUS UsbReadWriteCompletion( + IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket, + IN PVOID pContext + ); +NTSTATUS ResetUsbPipe( IN PKSDEVICE pKSDeviceObject, + IN PUSBD_PIPE_INFORMATION pPipeInformation); +NTSTATUS ResetUsbDevice(IN PKSDEVICE pKSDeviceObject); +NTSTATUS GetUsbPortStatus( IN PKSDEVICE pKSDeviceObject, + IN OUT PULONG pulPortStatus); +NTSTATUS ResetUsbParentPort( IN PKSDEVICE pKSDeviceObject ); +NTSTATUS SendURBToBusDriver(IN PKSDEVICE pKSDeviceObject, + IN PURB pUSBRequestBlock ); +NTSTATUS AbortUsbPipes(IN PKSDEVICE pKSDeviceObject); +LONG IncrementPendingIoCount(IN OUT CSkyWalker1Device * pDevice); +LONG DecrementPendingIoCount(IN OUT CSkyWalker1Device * pDevice); + +//Debugging related Functions +VOID PrintDeviceDescriptor( PUSB_DEVICE_DESCRIPTOR pDeviceDescriptor); +VOID PrintConfigurationDescriptor(IN PUSB_CONFIGURATION_DESCRIPTOR pConfigurationDescriptor); +VOID PrintInterfaceDescriptor(IN PUSB_INTERFACE_DESCRIPTOR pInterfaceDescriptor); +VOID PrintPipeInformation(PUSBD_PIPE_INFORMATION pPipeInformation); +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : InitializeUsbDevice + Description : Function to used to Initialize the USB Interface of the Tuner + IN PARAM : Pointer to Device Object which needs to be Initialized + Irp to start the device IRP_MN_START + OUT PARAM : Status of the Device Initialization + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Device initialized + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS InitializeUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntInitStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = NULL; + KIRQL kOldIrql; + + PrintFunctionEntry(__FUNCTION__); + + pDevice = reinterpret_cast(pKSDeviceObject->Context); + + //We cannot touch the device (send it any non pnp irps) until a + //start device has been passed down to the lower drivers. + //first pass the Irp down + + ntInitStatus = PassDownIRPAndWaitForCompletion( pKSDeviceObject->NextDeviceObject, + pIoRequestPacket, + TRUE); + if(!NT_SUCCESS(ntInitStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Lower Driver did not start !!!,Stopping Device Start\n")); + goto FinishStartDevice; + } + + //Lower Device Initialized , Start the Device Now + // + //Read the device descriptor, configuration descriptor + //and select the interface descriptors + // + + ntInitStatus = ReadandSelectDescriptors(pKSDeviceObject); + + if(!NT_SUCCESS(ntInitStatus)) + { + + SkyWalkerDebugPrint(ENTRY_LEVEL,("ReadandSelectDescriptors failed\n")); + goto FinishStartDevice; + } + + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + SET_NEW_PNP_STATE(pDevice, Working); + pDevice->QueueState = AllowRequests; + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + +/* + //initialize wait wake outstanding flag to false. + //and issue a wait wake. + + deviceExtension->FlagWWOutstanding = 0; + deviceExtension->FlagWWCancel = 0; + deviceExtension->WaitWakeIrp = NULL; + + if(deviceExtension->WaitWakeEnable) + { + + IssueWaitWake(deviceExtension); + } + + ProcessQueuedRequests(deviceExtension); + +*/ +FinishStartDevice: + PrintFunctionExit(__FUNCTION__,ntInitStatus); + + return ntInitStatus; +} + +/***************************************************************************** + Function : ReadandSelectDescriptors + Description : Function to used to Read Device Descriptor + IN PARAM : Pointer to KS Device Object + OUT PARAM : Status of the Device Descriptor Read + STATUS_SUCCESS on Successful execution + else Error + PreCondition : NONE + PostCondtion : Device Descriptor Read + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS ReadandSelectDescriptors( IN PKSDEVICE pKSDeviceObject ) +{ + URB USBRequestBlock; + NTSTATUS ntStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + //1. Read the device descriptor + + UsbBuildGetDescriptorRequest( + &USBRequestBlock, + (USHORT) sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST), + USB_DEVICE_DESCRIPTOR_TYPE, + 0, + 0, + &pDevice->USBDeviceDescriptor, + NULL, + sizeof(pDevice->USBDeviceDescriptor), + NULL); + + ntStatus = SendURBToBusDriver( pKSDeviceObject, + &USBRequestBlock); + if (!NT_SUCCESS(ntStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Error Trying to Read Device Descriptor\n")); + goto CompleteReadAndSetup; + } + + PrintDeviceDescriptor(&pDevice->USBDeviceDescriptor); + + //Device Descriptor read successfully thus, Read and select configuration + ntStatus = ConfigureDevice(pKSDeviceObject); + +CompleteReadAndSetup: + + PrintFunctionExit(__FUNCTION__,ntStatus); + return ntStatus; +} + +/***************************************************************************** + Function : ConfigureDevice + Description : This helper routine reads the configuration descriptor + for the device in couple of steps. + IN PARAM : Pointer to KS Device Object + OUT PARAM : Status of the Configuration Descriptor Read + STATUS_SUCCESS on Successful execution + else Error + PreCondition : NONE + PostCondtion : Configuration Descriptor Read + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS ConfigureDevice(IN PKSDEVICE pKSDeviceObject) +{ + URB USBRequestBlock; + NTSTATUS ntConfigureStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + USB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor; + PUSB_CONFIGURATION_DESCRIPTOR pConfigurationDescriptor = NULL; + + PrintFunctionEntry(__FUNCTION__); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Total Number of Configurations = %d\n", pDevice->USBDeviceDescriptor.bNumConfigurations)); + + //Read the first configuration descriptor + //This requires two steps: + //1. Read the fixed sized configuration desciptor (CD) + //2. Read the CD with all embedded interface and endpoint descriptors + + UsbBuildGetDescriptorRequest( &USBRequestBlock, + sizeof(_URB_CONTROL_DESCRIPTOR_REQUEST), + USB_CONFIGURATION_DESCRIPTOR_TYPE, + 0, + 0, + &ConfigurationDescriptor, + NULL, + sizeof(ConfigurationDescriptor), + NULL); + + ntConfigureStatus = SendURBToBusDriver( pKSDeviceObject, + &USBRequestBlock); + if (!NT_SUCCESS(ntConfigureStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Error Trying to Read Fixed Size Configuration Descriptor\n")); + goto CompleteDeviceConfigure; + } + + ULONG ulConfigurationDesciptorSize = ConfigurationDescriptor.wTotalLength; + SkyWalkerDebugPrint(EXTREME_LEVEL, ("Configuration Descriptor Size = %lu \n",ulConfigurationDesciptorSize)); + + pConfigurationDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR) ExAllocatePoolWithTag( NonPagedPool, + ulConfigurationDesciptorSize, + USB_MEMORY_TAG); + if (!pConfigurationDescriptor) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to allocate %lu bytes for Configuration Descriptor\n", ulConfigurationDesciptorSize)); + ntConfigureStatus = STATUS_INSUFFICIENT_RESOURCES; + goto CompleteDeviceConfigure; + } + + UsbBuildGetDescriptorRequest( &USBRequestBlock, + sizeof(_URB_CONTROL_DESCRIPTOR_REQUEST), + USB_CONFIGURATION_DESCRIPTOR_TYPE, + 0, + 0, + pConfigurationDescriptor, + NULL, + ulConfigurationDesciptorSize, + NULL); + + ntConfigureStatus = SendURBToBusDriver( pKSDeviceObject, + &USBRequestBlock); + if (!NT_SUCCESS(ntConfigureStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Error Trying to Read Actual Configuration Descriptor\n")); + goto CompleteDeviceConfigure; + } + + PrintConfigurationDescriptor(&ConfigurationDescriptor); + + ntConfigureStatus = SelectInterfaces(pKSDeviceObject, pConfigurationDescriptor); + +CompleteDeviceConfigure: + if(pConfigurationDescriptor) + { + ExFreePoolWithTag(pConfigurationDescriptor,USB_MEMORY_TAG); + } + PrintFunctionExit(__FUNCTION__,ntConfigureStatus); + return ntConfigureStatus; +} + +/***************************************************************************** + Function : SelectInterfaces + Description : This helper routine selects the configuration + IN PARAM : Pointer to KS Device Object + Configuration Descriptor + OUT PARAM : Status of the Configuration Descriptor Selection + STATUS_SUCCESS on Successful execution + else Error + PreCondition : NONE + PostCondtion : Configuration Descriptor Selection + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS SelectInterfaces( IN PKSDEVICE pKSDeviceObject, + IN PUSB_CONFIGURATION_DESCRIPTOR pConfigurationDescriptor) +{ + NTSTATUS ntSelectStatus = STATUS_SUCCESS; + URB USBRequestBlock; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + PUSB_INTERFACE_DESCRIPTOR pInterfaceDescriptor = NULL; + PUSBD_INTERFACE_INFORMATION pInterfaceInformation = NULL; + LONG lNumberOfInterfaces = pConfigurationDescriptor->bNumInterfaces; + LONG lInterfaceNumber = 0L; + LONG lInterfaceIndex = 0L; + ULONG ulPipeIndex = 0L; + + //The Device needs to be configured by sending a URB that specifies the configuration to use + //if device driver fails to configure the device then the I/O manager subsequently unloads + //the Driver from memory + //Search for the Configuration descriptor in the list of all configuration and obtain a pointer + //to the interface + pInterfaceDescriptor = USBD_ParseConfigurationDescriptorEx( + pConfigurationDescriptor, //Address of the Configuration Descriptor Structure + pConfigurationDescriptor, //Adress within the First Structure from where search should begin + -1, + -1, + -1, + -1, + -1); + if (!pInterfaceDescriptor) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("No Interface available for the Device\n")); + ntSelectStatus = STATUS_DEVICE_CONFIGURATION_ERROR; + goto FinishSelectInterface; + } + + //Create a URB that can be sent to the host controller driver (HCD) to set the Device + //in the configured state + USBD_INTERFACE_LIST_ENTRY Interfaces[2] = + { + {pInterfaceDescriptor, NULL}, + {NULL, NULL}, + }; + + PURB pConfigSelectURB = USBD_CreateConfigurationRequestEx(pConfigurationDescriptor, Interfaces); + if (!pConfigSelectURB) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Unable to Create Configuration Request\n")); + ntSelectStatus = STATUS_INSUFFICIENT_RESOURCES; + goto FinishSelectInterface; + } + + //Get the Interface supported by selected configuration + + pInterfaceInformation = &pConfigSelectURB->UrbSelectConfiguration.Interface; + + for(ulPipeIndex=0; ulPipeIndexNumberOfPipes; ulPipeIndex++) + { + //Perform pipe initialization here set the transfer size and any pipe flags we use + //USBD sets the rest of the Interface struct members + + //pInterfaceInformation->Pipes[ulPipeIndex].MaximumTransferSize = USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE; + } + + ntSelectStatus = SendURBToBusDriver(pKSDeviceObject,pConfigSelectURB); + + if (!NT_SUCCESS(ntSelectStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Error Trying to Select Configuration\n")); + goto FinishSelectInterface; + } + + PrintInterfaceDescriptor(pInterfaceDescriptor); + + for(ulPipeIndex=0; ulPipeIndexNumberOfPipes; ulPipeIndex++) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("--------------------------\n")); + PrintPipeInformation(&pInterfaceInformation->Pipes[ulPipeIndex]); + SkyWalkerDebugPrint(EXTREME_LEVEL,("--------------------------\n")); + + //Setting the Pipes + if(pInterfaceInformation->Pipes[ulPipeIndex].EndpointAddress == 0x82) + { + RtlCopyMemory( &pDevice->ReadPipe, + &pInterfaceInformation->Pipes[ulPipeIndex], + sizeof(pDevice->ReadPipe)); + } + else + { + RtlCopyMemory( &pDevice->WritePipe, + &pInterfaceInformation->Pipes[ulPipeIndex], + sizeof(pDevice->WritePipe)); + } + + } +FinishSelectInterface: + + if(pConfigSelectURB) + { + ExFreePool(pConfigSelectURB); + } + + PrintFunctionExit(__FUNCTION__,ntSelectStatus); + return ntSelectStatus; +} + +/***************************************************************************** + Function : QueryStopUsbDevice + Description : Function to used to Service PnP IRPs of Minor Type + IRP_MN_QUERY_STOP_DEVICE + IN PARAM : Pointer to Device Object whose stop query has come + Device Stop Query Irp with Minor Code IRP_MN_QUERY_STOP_DEVICE + OUT PARAM : Status of the Stop Query Processing + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Device can be stopped or not is returned + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS QueryStopUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + KIRQL kOldIrql; + NTSTATUS ntQueryStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *) pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + //If we can stop the device, we need to set the QueueState to + //HoldRequests so further requests will be queued. + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + SET_NEW_PNP_STATE(pDevice, PendingStop); + pDevice->QueueState = HoldRequests; + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + + //wait for the existing ones to be finished. + //first, decrement this operation + DecrementPendingIoCount(pDevice); + + KeWaitForSingleObject(&pDevice->EvDeviceStopOk, + Executive, + KernelMode, + FALSE, + NULL); + + PrintFunctionExit(__FUNCTION__,ntQueryStatus); + + return ntQueryStatus; +} + +/***************************************************************************** + Function : DecrementPendingIoCount + Description : This routine decrements the outstanding I/O count + This is typically invoked after the dispatch routine + has finished processing the irp. + IN PARAM : Device Pointer + OUT PARAM : Io Pending Count + PreCondition : NONE + PostCondtion : Pending IO Count is Decremented and same is returned to + the caller + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +LONG DecrementPendingIoCount(IN OUT CSkyWalker1Device * pDevice) +{ + LONG ulResult = 0; + KIRQL kOldIrql; + + PrintFunctionEntry(__FUNCTION__); + + KeAcquireSpinLock(&pDevice->kIoCountLock, &kOldIrql); + + ulResult = InterlockedDecrement((PLONG)&pDevice->ulOutStandingIoCount); + + if(ulResult == 1) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Device can be Stopped\n")); + KeSetEvent(&pDevice->EvDeviceStopOk, IO_NO_INCREMENT, FALSE); + } + + if(ulResult == 0) + { + SkyWalkerDebugPrint(EXTREME_LEVEL,("Device can be Removed\n")); + KeSetEvent(&pDevice->EvDeviceRemoveOk,IO_NO_INCREMENT, FALSE); + } + + KeReleaseSpinLock(&pDevice->kIoCountLock, kOldIrql); + + SkyWalkerDebugPrint(EXTREME_LEVEL, ("%s::%d\n",__FUNCTION__,ulResult)); + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + + return ulResult; +} +/***************************************************************************** + Function : IncrementPendingIoCount + Description : This routine increments the outstanding I/O count + This is typically invoked before the dispatch routine + to process new Irp is called + IN PARAM : Device Pointer + OUT PARAM : Io Pending Count + PreCondition : NONE + PostCondtion : Pending IO Count is Incremented and same is returned to + the caller + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +LONG IncrementPendingIoCount(IN OUT CSkyWalker1Device * pDevice) +{ + LONG ulResult = 0; + KIRQL kOldIrql; + + PrintFunctionEntry(__FUNCTION__); + KeAcquireSpinLock(&pDevice->kIoCountLock, &kOldIrql); + + ulResult = InterlockedIncrement((PLONG)&pDevice->ulOutStandingIoCount); + + //when OutStandingIO bumps from 1 to 2, clear the StopEvent + if(ulResult == 2) + { + + KeClearEvent(&pDevice->EvDeviceStopOk); + } + + KeReleaseSpinLock(&pDevice->kIoCountLock, kOldIrql); + + SkyWalkerDebugPrint(EXTREME_LEVEL, ("%s::%d\n",__FUNCTION__,ulResult)); + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); + + return ulResult; +} + +/***************************************************************************** + Function : CancelStopUsbDevice + Description : Function to used to Service PnP IRPs of Minor Type + IRP_MN_CANCEL_STOP_DEVICE + IN PARAM : Pointer to Device Object whose Cancel stop request has come + Device Stop Cancel Irp with Minor Code IRP_MN_CANCEL_STOP_DEVICE + OUT PARAM : Status of the Device Stop Cancel Processing + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Device Stop is cancelled + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CancelStopUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + KIRQL kOldIrql; + KEVENT Evevent; + NTSTATUS ntStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + //First check to see whether you have received cancel-stop + //without first receiving a query-stop. This could happen if someone + //above us fails a query-stop and passes down the subsequent + //cancel-stop. + if(pDevice->UsbDeviceState == PendingStop ) + { + if(NT_SUCCESS(ntStatus)) + { + + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + RESTORE_PREVIOUS_PNP_STATE(pDevice); + pDevice->QueueState = AllowRequests; + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + + //ProcessQueuedRequests(deviceExtension); + } + + } + else + { + + //spurious Irp + // + //If the device is already in an active state when the driver + //receives this IRP, a function driver simply sets status to + //success and passes the IRP to the next driver. For such a + //cancel-stop IRP, a function driver need not set a completion + //routine. + + } + + PrintFunctionExit(__FUNCTION__,ntStatus); + + return ntStatus; +} + +/***************************************************************************** + Function : DeconfigureUsbDevice + Description : This routine is invoked when the device is removed or stopped. + This routine de-configures the usb device. + IN PARAM : Pointer to KS Device Object + OUT PARAM : Status of the Device Deinitialization + STATUS_SUCCESS on Successful execution + else Error + PreCondition : NONE + PostCondtion : USB Device Uninitialized + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS DeconfigureUsbDevice(IN PKSDEVICE pKSDeviceObject) +{ + NTSTATUS ntUnInitStatus = STATUS_SUCCESS; + URB USBRequestBlock; + + PrintFunctionEntry(__FUNCTION__); + + UsbBuildSelectConfigurationRequest(&USBRequestBlock, sizeof(_URB_SELECT_CONFIGURATION), NULL); + + ntUnInitStatus = SendURBToBusDriver(pKSDeviceObject,&USBRequestBlock); + + if (!NT_SUCCESS(ntUnInitStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Error Trying to Deconfigure the Device\n")); + } + + PrintFunctionExit(__FUNCTION__,ntUnInitStatus); + return ntUnInitStatus; + +} + +/***************************************************************************** + Function : StopUsbDevice + Description : This routine is invoked when the device is stopped. + This routine services Irp of minor type IRP_MN_STOP_DEVICE + IN PARAM : Pointer to KS Device Object + STOP DEVICE Irp + OUT PARAM : Status of the Device Stop + STATUS_SUCCESS on Successful execution + else Error + PreCondition : NONE + PostCondtion : USB Device Stopped + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS StopUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + KIRQL kOldIrql; + NTSTATUS ntDeviceStopStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = NULL; + + PrintFunctionEntry(__FUNCTION__); + + //initialize variables + pDevice = (CSkyWalker1Device *) pKSDeviceObject->Context; + + + //if(WinXpOrBetter == deviceExtension->WdmVersion) { + + // if(deviceExtension->SSEnable) { + + // // + // //Cancel the timer so that the DPCs are no longer fired. + // //Thus, we are making judicious usage of our resources. + // //we do not need DPCs because the device is stopping. + // //The timers are re-initialized while handling the start + // //device irp. + // // + + // KeCancelTimer(&deviceExtension->Timer); + + // // + // //after the device is stopped, it can be surprise removed. + // //we set this to 0, so that we do not attempt to cancel + // //the timer while handling surprise remove or remove irps. + // //when we get the start device request, this flag will be + // //reinitialized. + // // + // deviceExtension->SSEnable = 0; + + // // + // //make sure that if a DPC was fired before we called cancel timer, + // //then the DPC and work-time have run to their completion + // // + // KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, + // Executive, + // KernelMode, + // FALSE, + // NULL); + + // // + // //make sure that the selective suspend request has been completed. + // // + // KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, + // Executive, + // KernelMode, + // FALSE, + // NULL); + // } + //} + + // + //after the stop Irp is sent to the lower driver object, + //the driver must not send any more Irps down that touch + //the device until another Start has occurred. + // + + /* if(deviceExtension->WaitWakeEnable) { + + CancelWaitWake(deviceExtension); + }*/ + + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + SET_NEW_PNP_STATE(pDevice, Stopped); + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + + ntDeviceStopStatus = DeconfigureUsbDevice(pKSDeviceObject); + + PrintFunctionExit(__FUNCTION__,ntDeviceStopStatus); + + return ntDeviceStopStatus; +} + +/***************************************************************************** + Function : ReadWriteUsbDevice + Description : Dispatch routine for read and write. + This routine creates a BULKUSB_RW_CONTEXT for a read/write. + This read/write is performed in stages of MAX_BULK_PACKET_SIZE. + once a stage of transfer is complete, then the irp is circulated again, + until the requested length of tranfer is performed. + IN PARAM : Pointer to Device Object + Device Register to/From which Write/ Read is to be performed + Transfer Buffer + Length of the Transfer Buffer + True if Read from else False for Write to device + OUT PARAM : Status of Read / Write request sending to Device + STATUS_PENDING on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Read/ Write Request submitted to Device + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS ReadWriteUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN ULONG ulStreamIndex, + IN ULONG ulPacketIndex, + IN PUCHAR pucTransferBuffer, + IN ULONG ulTransferLength, + IN BOOLEAN bRead) +{ + NTSTATUS ntReadWriteStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *) pKSDeviceObject->Context; + ULONG ulURBFlags = 0; + ULONG ulStageTransferLength = 0; + PURB pUSBRequestBlock = NULL; + PUSBD_PIPE_INFORMATION pPipeInformation = NULL; + PIO_STACK_LOCATION pNextStackLocation = NULL; + PBULKUSB_RW_CONTEXT pReadWriteContext = NULL; + PIRP pUsbIoRequestPacket = NULL; + + PrintFunctionEntry(__FUNCTION__); + + //Acquire device Remove lock here + if(pDevice->UsbDeviceState != Working) + { + + SkyWalkerDebugPrint(ENTRY_LEVEL,("Invalid device state\n")); + ntReadWriteStatus = STATUS_INVALID_DEVICE_STATE; + goto FinishDeviceReadWrite; + } + + if(!IS_VALID(pucTransferBuffer)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Invalid Transfer Buffer Passed\n")); + ntReadWriteStatus = STATUS_INVALID_PARAMETER; + goto FinishDeviceReadWrite; + } + + if(ulTransferLength > MAX_BULK_TRANSFER_SIZE) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, + ("Tansfer Length (%lu) > MAX_BULK_TRANSFER_SIZE (%lu)\n", + ulTransferLength, + MAX_BULK_TRANSFER_SIZE)); + ntReadWriteStatus = STATUS_INVALID_PARAMETER; + goto FinishDeviceReadWrite; + } + + if(ulTransferLength == 0) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Transfer data length = 0\n")); + ntReadWriteStatus = STATUS_SUCCESS; + goto FinishDeviceReadWrite; + } + + ulURBFlags = USBD_SHORT_TRANSFER_OK; + if(bRead) + { + ulURBFlags |= USBD_TRANSFER_DIRECTION_IN; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Read Operation\n")); + pPipeInformation = &pDevice->ReadPipe; + } + else + { + + ulURBFlags |= USBD_TRANSFER_DIRECTION_OUT; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Write Operation\n")); + pPipeInformation = &pDevice->WritePipe; + } + + DbgPrint("Pipe Information = %p\n",pPipeInformation); + + //the transfer request is for TransferLength. + //we can perform a max of Packet Size + //in each stage. + if(ulTransferLength > MAX_BULK_PACKET_SIZE) + { + ulStageTransferLength = MAX_BULK_PACKET_SIZE; + } + else + { + ulStageTransferLength = ulTransferLength; + } + + //Allocate IRP for the USB Transfer + pUsbIoRequestPacket = IoAllocateIrp(pKSDeviceObject->NextDeviceObject->StackSize, + FALSE); + if(!IS_VALID(pUsbIoRequestPacket)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Failed to Allocate Memory for the USB Irp\n")); + ntReadWriteStatus = STATUS_INSUFFICIENT_RESOURCES; + goto FinishDeviceReadWrite; + } + + ULONG ulStreamOffset = PACKET_PER_FRAME * ulStreamIndex; + pDevice->pUsbStreamIrp[ulPacketIndex + ulStreamOffset] = pUsbIoRequestPacket; + + + pUSBRequestBlock = (PURB)ExAllocatePoolWithTag( NonPagedPool, + sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER), + USB_MEMORY_TAG); + + if(!IS_VALID(pUSBRequestBlock)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Failed to Allocate Memory for the Bulk / Interrupt URB\n")); + ntReadWriteStatus = STATUS_INSUFFICIENT_RESOURCES; + goto FinishDeviceReadWrite; + } + + RtlZeroMemory(pUSBRequestBlock, sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER)); + + UsbBuildInterruptOrBulkTransferRequest( + pUSBRequestBlock, + sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER), + pPipeInformation->PipeHandle, + pucTransferBuffer, + NULL, + ulStageTransferLength, + ulURBFlags, + NULL); + + pReadWriteContext = (PBULKUSB_RW_CONTEXT)ExAllocatePoolWithTag( NonPagedPool, + sizeof(BULKUSB_RW_CONTEXT), + USB_MEMORY_TAG); + + if(!IS_VALID(pReadWriteContext)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Failed to Allocate Memory for the Read Write Context\n")); + ntReadWriteStatus = STATUS_INSUFFICIENT_RESOURCES; + goto FinishDeviceReadWrite; + } + + //set BULKUSB_RW_CONTEXT parameters. + pReadWriteContext->pUSBRequestBlock = pUSBRequestBlock; + pReadWriteContext->pTransferBuffer = pucTransferBuffer + ulStageTransferLength; + pReadWriteContext->ulRemainingByteTransfer = ulTransferLength - ulStageTransferLength ; + pReadWriteContext->ulCompletedByteTransfer = 0L; + pReadWriteContext->pDevice = pDevice; + pReadWriteContext->ulStreamIndex = ulStreamIndex; + + //use the original read/write irp as an internal device control irp + pNextStackLocation = IoGetNextIrpStackLocation(pUsbIoRequestPacket); + pNextStackLocation->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL; + pNextStackLocation->Parameters.Others.Argument1 = (PVOID)pUSBRequestBlock ; + pNextStackLocation->Parameters.DeviceIoControl.IoControlCode = + IOCTL_INTERNAL_USB_SUBMIT_URB; + + IoSetCompletionRoutine(pUsbIoRequestPacket, + (PIO_COMPLETION_ROUTINE)UsbReadWriteCompletion, + pReadWriteContext, + TRUE, + TRUE, + TRUE); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("USB Transfer Details for Stream %lu Packet %lu\n", + ulStreamIndex, + ulPacketIndex)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("ulStageTransferLength = %lu\n",ulStageTransferLength)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pReadWriteContext->ulCompletedByteTransfer = %lu\n",pReadWriteContext->ulCompletedByteTransfer)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pReadWriteContext->ulRemainingByteTransfer = %lu\n",pReadWriteContext->ulRemainingByteTransfer)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("bRead = %02d\n",bRead)); + + //since we return STATUS_PENDING call IoMarkIrpPending. + //This is the boiler plate code. + //This may cause extra overhead of an APC for the Irp completion + //but this is the correct thing to do. + + IoMarkIrpPending(pUsbIoRequestPacket); + IncrementPendingIoCount(pDevice); + + ntReadWriteStatus = IoCallDriver( pKSDeviceObject->NextDeviceObject, + pUsbIoRequestPacket); + + if(!NT_SUCCESS(ntReadWriteStatus)) + { + + SkyWalkerDebugPrint(ENTRY_LEVEL, ("IoCallDriver Failed with status %X\n", ntReadWriteStatus)); + + //if the device was yanked out, then the pipeInformation + //field is invalid. + //similarly if the request was cancelled, then we need not + //invoked reset pipe/device. + KIRQL CurrentIrql = KeGetCurrentIrql(); + + if((ntReadWriteStatus != STATUS_CANCELLED) && + (ntReadWriteStatus != STATUS_DEVICE_NOT_CONNECTED)) + { + + if(CurrentIrql < DISPATCH_LEVEL) + { + ntReadWriteStatus = ResetUsbPipe(pKSDeviceObject,pPipeInformation); + if(!NT_SUCCESS(ntReadWriteStatus)) + { + + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Reset USB Pipe Failed\n")); + + ntReadWriteStatus = ResetUsbDevice(pKSDeviceObject); + } + } + } + else + { + + SkyWalkerDebugPrint(ENTRY_LEVEL, ("ntReadWriteStatus is STATUS_CANCELLED or " + "STATUS_DEVICE_NOT_CONNECTED\n")); + } + //Freeing up the resources allocated in this routine + goto FinishDeviceReadWrite; + } + + PrintFunctionExit(__FUNCTION__,STATUS_PENDING); + + return STATUS_PENDING; + +FinishDeviceReadWrite: + + if(IS_VALID(pUSBRequestBlock)) + { + ExFreePoolWithTag(pUSBRequestBlock,USB_MEMORY_TAG); + pUSBRequestBlock = NULL; + } + if(IS_VALID(pReadWriteContext)) + { + ExFreePoolWithTag(pReadWriteContext,USB_MEMORY_TAG); + pReadWriteContext = NULL; + } + if(IS_VALID(pUsbIoRequestPacket)) + { + IoFreeIrp(pUsbIoRequestPacket); + pUsbIoRequestPacket = NULL; + } + + PrintFunctionExit(__FUNCTION__,ntReadWriteStatus); + + return ntReadWriteStatus; +} + +/***************************************************************************** + Function : UsbReadWriteCompletion + Description : This is the completion routine for reads/writes + If the irp completes with success, we check if we + need to recirculate this irp for another stage of + transfer. In this case return STATUS_MORE_PROCESSING_REQUIRED. + if the irp completes in error, free all memory allocs and + return the status. + IN PARAM : Pointer to Device Object + Io Request Packet + Context + OUT PARAM : Status of Read / Write request Completion + STATUS_MORE_PROCESSING_REQUIRED always + PreCondition : NONE + PostCondtion : On Success Read/ Write Request Completed + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS UsbReadWriteCompletion( + IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket, + IN PVOID pContext + ) +{ + ULONG ulStageTransferLength = 0; + NTSTATUS ntReadWriteCompleteStatus = pIoRequestPacket->IoStatus.Status; + PIO_STACK_LOCATION pNextStackLocation; + PBULKUSB_RW_CONTEXT pReadWriteContext = (PBULKUSB_RW_CONTEXT)pContext; + CSkyWalker1Device * pDevice = pReadWriteContext->pDevice; + ULONG ulStreamIndex = 0L; + PrintFunctionEntry(__FUNCTION__); + + //successfully performed a stageLength of transfer. + //check if we need to recirculate the irp. + if(NT_SUCCESS(ntReadWriteCompleteStatus)) + { + if(pReadWriteContext) + { + pReadWriteContext->ulCompletedByteTransfer += + pReadWriteContext->pUSBRequestBlock->UrbBulkOrInterruptTransfer.TransferBufferLength; + + if((pReadWriteContext->ulRemainingByteTransfer)&& (!pIoRequestPacket->Cancel)) + { + //another stage transfer + SkyWalkerDebugPrint(EXTREME_LEVEL, ("Another stage transfer...\n")); + + //the transfer request is for TransferLength. + //we can perform a max of MAX_BULK_PACKET_SIZE + //in each stage. + if(pReadWriteContext->ulRemainingByteTransfer > MAX_BULK_PACKET_SIZE) + { + ulStageTransferLength = MAX_BULK_PACKET_SIZE; + } + else + { + ulStageTransferLength = pReadWriteContext->ulRemainingByteTransfer; + } + + //Reinitialize the urb + pReadWriteContext->pUSBRequestBlock->UrbBulkOrInterruptTransfer.TransferBufferLength + = ulStageTransferLength; + + pReadWriteContext->pUSBRequestBlock->UrbBulkOrInterruptTransfer.TransferBuffer + = pReadWriteContext->pTransferBuffer; + + pReadWriteContext->pTransferBuffer += ulStageTransferLength; + pReadWriteContext->ulRemainingByteTransfer -= ulStageTransferLength ; + + //use the original read/write irp as an internal device control irp + pNextStackLocation = IoGetNextIrpStackLocation(pIoRequestPacket); + pNextStackLocation->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL; + pNextStackLocation->Parameters.Others.Argument1 = (PVOID)pReadWriteContext->pUSBRequestBlock ; + pNextStackLocation->Parameters.DeviceIoControl.IoControlCode = + IOCTL_INTERNAL_USB_SUBMIT_URB; + + IoSetCompletionRoutine(pIoRequestPacket, + (PIO_COMPLETION_ROUTINE)UsbReadWriteCompletion, + pReadWriteContext, + TRUE, + TRUE, + TRUE); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("USB Transfer Details for Stream %lu\n", + pReadWriteContext->ulStreamIndex)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("ulStageTransferLength = %lu\n",ulStageTransferLength)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pReadWriteContext->ulCompletedByteTransfer = %lu\n",pReadWriteContext->ulCompletedByteTransfer)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pReadWriteContext->ulRemainingByteTransfer = %lu\n",pReadWriteContext->ulRemainingByteTransfer)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pIoRequestPacket = 0x%p\n",pIoRequestPacket)); + ntReadWriteCompleteStatus = IoCallDriver( pDevice->m_pKSDevice->NextDeviceObject, + pIoRequestPacket); + + return STATUS_MORE_PROCESSING_REQUIRED; + } + else + { + + InterlockedExchangeAdd((LONG*)&pDevice->m_NumberOfBytesRead[pReadWriteContext->ulStreamIndex], + pReadWriteContext->ulCompletedByteTransfer); + + ulStreamIndex = pReadWriteContext->ulStreamIndex; + + //This is the last transfer + //SkyWalkerDebugPrint(ENTRY_LEVEL,("Valid Synthesis Buffer\n")); + // //This is not needed as anyways the IRP is going to Free soon + //pIoRequestPacket->IoStatus.Information = pReadWriteContext->ulCompletedByteTransfer; + ////Set the Frame Read Event here + // + //if(pReadWriteContext->ulCompletedByteTransfer == pDevice->m_SampleSize) + //{ + // pDevice->m_SynthesisDataValid = 1; + //} + + } + } + } + else + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("ReadWriteCompletion Failed \n")); + } + + if(pReadWriteContext) + { + //Dump pReadWriteContext + SkyWalkerDebugPrint(EXTREME_LEVEL,("Completed Stream = %lu",pReadWriteContext->ulStreamIndex)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pReadWriteContext->pUSBRequestBlock = 0x%p\n", + pReadWriteContext->pUSBRequestBlock)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pReadWriteContext->ulRemainingByteTransfer = %lu\n", + pReadWriteContext->ulRemainingByteTransfer)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pReadWriteContext->ulCompletedByteTransfer = %lu\n", + pReadWriteContext->ulCompletedByteTransfer)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pReadWriteContext->pDevice = 0x%p\n", + pReadWriteContext->pDevice)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("Actual Byte Transfer = %lu", + pReadWriteContext->pUSBRequestBlock-> + UrbBulkOrInterruptTransfer.TransferBufferLength)); + + + DecrementPendingIoCount(pDevice); + + if(IS_VALID(pReadWriteContext->pUSBRequestBlock)) + { + ExFreePoolWithTag(pReadWriteContext->pUSBRequestBlock,USB_MEMORY_TAG); + pReadWriteContext->pUSBRequestBlock = NULL; + } + + if(IS_VALID(pReadWriteContext)) + { + ExFreePoolWithTag(pReadWriteContext,USB_MEMORY_TAG); + pReadWriteContext = NULL; + } + + if(IS_VALID(pIoRequestPacket)) + { + IoFreeIrp(pIoRequestPacket); + pIoRequestPacket = NULL; + } + + } + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Calling ProcessStream \n")); + //TS is read, Process the stream + pDevice->ProcessStream(ulStreamIndex); + + PrintFunctionExit(__FUNCTION__,STATUS_MORE_PROCESSING_REQUIRED); + + //This is the only status that can be returned from the Asynchronous + //IRP created by Driver + return STATUS_MORE_PROCESSING_REQUIRED; +} +/***************************************************************************** + Function : ControlUsbDevice + Description : This Function is used to send the Vendor requests to the Device + IN PARAM : Pointer to Device Object + Vendor Request + Value corresponding to Request + Index for the Request (Used with Request) + Transfer Buffer for Read/Write + size of the Transfer Buffer + True if Read from else False for Write to device + OUT PARAM : Status of Vendor Request Execution + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Vendor Request Command Executed + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS ControlUsbDevice( IN PKSDEVICE pKSDeviceObject, + IN UCHAR ucRequest, + IN USHORT usValue, + IN USHORT usIndex, + IN PUCHAR pucTransferBuffer, + IN ULONG ulTransferLength, + IN BOOLEAN bRead) +{ + NTSTATUS ntControlStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *) pKSDeviceObject->Context; + PURB pUSBRequestBlock = NULL; + ULONG ulURBFlags = 0L; + PrintFunctionEntry(__FUNCTION__); + + if(pDevice->UsbDeviceState != Working) + { + + SkyWalkerDebugPrint(ENTRY_LEVEL,("Invalid device state\n")); + ntControlStatus = STATUS_INVALID_DEVICE_STATE; + goto ExitControlDevice; + } + ulURBFlags = USBD_SHORT_TRANSFER_OK; + if(bRead) + { + ulURBFlags |= USBD_TRANSFER_DIRECTION_IN; //Requst data from Device + SkyWalkerDebugPrint(EXTREME_LEVEL,("Read Operation\n")); + } + else + { + ulURBFlags |= USBD_TRANSFER_DIRECTION_OUT; + SkyWalkerDebugPrint(EXTREME_LEVEL,("Write Operation\n")); + } + + pUSBRequestBlock = (PURB)ExAllocatePoolWithTag( NonPagedPool, + sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST), + USB_MEMORY_TAG); + + if(!IS_VALID(pUSBRequestBlock)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Failed to Allocate Memory for the Vendor URB\n")); + ntControlStatus = STATUS_INSUFFICIENT_RESOURCES; + goto ExitControlDevice; + } + + UsbBuildVendorRequest( + pUSBRequestBlock,//Pointer to an URB that + //is to be formatted as a vendor or class + //request. + URB_FUNCTION_VENDOR_DEVICE, //Function + sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST), //Length of URB in Bytes + ulURBFlags, //Zero, One or Combination of + //USBD_TRANSFER_DIRECTION_IN & USBD_SHORT_TRANSFER_OK + 0, //Reserved + ucRequest, //USB/Vendor Specific Request Code + usValue, //Value Specific to Request + usIndex, //Device Defined identifier else Zero + pucTransferBuffer,//Pointer to Resident Buffer for Transfer or NULL + NULL, //Pointer to MDL for Transfer or NULL + ulTransferLength,//Length in Bytes of Buffer specified + NULL //NULL Always + ); + + + ntControlStatus = SendURBToBusDriver(pKSDeviceObject,pUSBRequestBlock); + + if(!NT_SUCCESS(ntControlStatus)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Sending Vendor Request Failed\n")); + } + + ExFreePool(pUSBRequestBlock); + +ExitControlDevice: + + PrintFunctionExit(__FUNCTION__,ntControlStatus); + return ntControlStatus; +} + +/***************************************************************************** + Function : SendURBToBusDriver + Description : Function to used to Send the URB to the USB Bus Driver (USBD.sys) + IN PARAM : Pointer to Device Object to which URB is to be sent + Pointer to the URB to be sent + OUT PARAM : Status of the URB Send operation + STATUS_SUCCESS on Successful execution + STATUS_INVALID_PARAMETER in case of Error + STATUS_INSUFFICIENT_RESOURCES in case IRP could not be created + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success URB sent to the Bus Driver + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS SendURBToBusDriver(IN PKSDEVICE pKSDeviceObject, + IN PURB pUSBRequestBlock ) +{ + NTSTATUS ntIrpProcessingStatus = STATUS_SUCCESS; + USBD_STATUS UsbStatus; + PIRP pIoRequestPacket = NULL; + KEVENT kIrpCompleted; + IO_STATUS_BLOCK IoStatusBlock; + PIO_STACK_LOCATION pNextIoStackLocation = NULL; + PDEVICE_OBJECT pRootDeviceObject = pKSDeviceObject->NextDeviceObject; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *) pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + if((!IS_VALID(pRootDeviceObject)) || (!(IS_VALID(pUSBRequestBlock)))) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("pRootDeviceObject = 0x%p, pUSBRequestBlock = 0x%p\n",pRootDeviceObject,pUSBRequestBlock)); + ntIrpProcessingStatus = STATUS_INVALID_PARAMETER; + goto CompleteURBSend; + } + //Initialize Kernel Event which should be trigerred after completion + //of the Device IO Control request + KeInitializeEvent(&kIrpCompleted, //PKEVENT + NotificationEvent, //Type + FALSE); //State + + //Create Internal Device Io Control Request + pIoRequestPacket = IoBuildDeviceIoControlRequest( IOCTL_INTERNAL_USB_SUBMIT_URB , + pRootDeviceObject, //Device to which the request to be sent + NULL, + 0, + NULL, + 0, + TRUE, //TRUE for IRM_MJ_INTERNAL_DEVICE_CONTROL, IRP_MJ_SCSI + &kIrpCompleted, //Event should be trigerred when the IRP completes + &IoStatusBlock); //The Status Block should be set when the Io request Completes + + + //If could not create the IRP return with the INSUFFICIENT RESOURCES + if(pIoRequestPacket == NULL) + { + ntIrpProcessingStatus = STATUS_INSUFFICIENT_RESOURCES; + goto CompleteURBSend; + } + + pNextIoStackLocation = IoGetNextIrpStackLocation(pIoRequestPacket); + pNextIoStackLocation->Parameters.Others.Argument1 = pUSBRequestBlock; + + IncrementPendingIoCount(pDevice); + + //Call the Next Driver + ntIrpProcessingStatus = IoCallDriver(pRootDeviceObject,pIoRequestPacket); + if(ntIrpProcessingStatus == STATUS_PENDING) + { + LARGE_INTEGER Timeout; + Timeout.QuadPart = (LONGLONG) 2 /*sec*/* 1000 /*msec*/ * 1000 /*usec*/ * (-10)/*Conv. Factor*/; + //for(int nRetry = 0; ((nRetry < 3) && (ntIrpProcessingStatus != STATUS_SUCCESS)) ; nRetry++) + { + //IRP is yet to be processed thus STATUS_PENDING is returned from the Lower Device Driver (USBD.sys) + ntIrpProcessingStatus = KeWaitForSingleObject(&kIrpCompleted, //PKEVENT + Executive, //Wait Reason has to be Executive + KernelMode, //Must be kernel mode so + //that Stack will not Paged out + FALSE, //No Alert + NULL//&Timeout //Wait for 2 sec max + ); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("KeWaitForSingleObject returned with status = %s(0x%X)\n", + NTStatusToString(ntIrpProcessingStatus),ntIrpProcessingStatus)); + //SkyWalkerDebugPrint(EXTREME_LEVEL,("nRetry = %d\n",nRetry)); + } + + ntIrpProcessingStatus = IoStatusBlock.Status; + UsbStatus = URB_STATUS(pUSBRequestBlock); + SkyWalkerDebugPrint(EXTREME_LEVEL,("URB STATUS = 0x%X\n",UsbStatus)); + } + + DecrementPendingIoCount(pDevice); + +CompleteURBSend: + + PrintFunctionExit(__FUNCTION__,ntIrpProcessingStatus); + + return ntIrpProcessingStatus; + +} + +/***************************************************************************** + Function : QueryRemoveUsbDevice + Description : Function to used to Service PnP IRPs of Minor Type + IRP_MN_QUERY_REMOVE_DEVICE + IN PARAM : Pointer to Device Object whose Remove Query has come + Device Remove Query Irp with Minor Code IRP_MN_QUERY_REMOVE_DEVICE + OUT PARAM : Status of the Device Remove Query Processing + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Device can be removed is conveyed to the caller + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS QueryRemoveUsbDevice( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + KIRQL kOldIrql; + NTSTATUS ntQueryStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *) pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + // + //If we can allow removal of the device, we should set the QueueState + //to HoldRequests so further requests will be queued. This is required + //so that we can process queued up requests in cancel-remove just in + //case somebody else in the stack fails the query-remove. + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + SET_NEW_PNP_STATE(pDevice, PendingRemove); + pDevice->QueueState = HoldRequests; + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + + //wait for the existing ones to be finished. + //first, decrement this operation + DecrementPendingIoCount(pDevice); + + KeWaitForSingleObject(&pDevice->EvDeviceStopOk, + Executive, + KernelMode, + FALSE, + NULL); + + PrintFunctionExit(__FUNCTION__,ntQueryStatus); + + return ntQueryStatus; + +} + +/***************************************************************************** + Function : CancelRemoveUsbDevice + Description : Function to used to Service PnP IRPs of Minor Type + IRP_MN_CANCEL_REMOVE_DEVICE + IN PARAM : Pointer to Device Object whose Remove request has + been cancelled + Device Remove Cancel Irp with Minor Code + IRP_MN_CANCEL_REMOVE_DEVICE + OUT PARAM : Status of the Device Remove Cancel Irp Processing + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Device Remove cancel request is processed + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS CancelRemoveUsbDevice(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + KIRQL kOldIrql; + KEVENT Evevent; + NTSTATUS ntStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + //We need to reset the QueueState flag to ProcessRequest, + //since the device resume its normal activities. + // + //First check to see whether you have received cancel-stop + //without first receiving a query-stop. This could happen if someone + //above us fails a query-stop and passes down the subsequent + //cancel-stop. + if(pDevice->UsbDeviceState == PendingRemove ) + { + ntStatus = PassDownIRPAndWaitForCompletion(pKSDeviceObject->NextDeviceObject, + pIoRequestPacket, + true); + if(NT_SUCCESS(ntStatus)) + { + + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + RESTORE_PREVIOUS_PNP_STATE(pDevice); + pDevice->QueueState = AllowRequests; + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + + //ProcessQueuedRequests(deviceExtension); + } + + } + else + { + + /* spurious cancel Remove + + If the device is already started when the driver receives + this IRP, the driver simply sets status to success and passes + the IRP to the next driver. For such a cancel-remove IRP, a + function driver need not set a completion routine. The device + may not be in the remove-pending state, because, for example, + the driver failed the previous IRP_MN_QUERY_REMOVE_DEVICE.*/ + + } + + PrintFunctionExit(__FUNCTION__,ntStatus); + + return ntStatus; + +} + +/***************************************************************************** + Function : SurpriseUsbDeviceRemoval + Description : Function to used to Service PnP IRPs of Minor Type + IRP_MN_SURPRISE_REMOVAL + IN PARAM : Pointer to Device Object which is removed + surprisingly + Device Remove Cancel Irp with Minor Code + IRP_MN_SURPRISE_REMOVAL + OUT PARAM : Status of the Spurious Device Removal Processing + STATUS_SUCCESS Always + PreCondition : NONE + PostCondtion : On Success Surprised Device Remove is processed + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS SurpriseUsbDeviceRemoval(IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + KIRQL kOldIrql; + KEVENT Evevent; + NTSTATUS ntStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + // + //1. fail pending requests + //2. return device and memory resources + //3. disable interfaces + // + + //if(deviceExtension->WaitWakeEnable) { + // + // CancelWaitWake(deviceExtension); + //} + + + //if(WinXpOrBetter == deviceExtension->WdmVersion) { + + // if(deviceExtension->SSEnable) { + + // // + // //Cancel the timer so that the DPCs are no longer fired. + // //we do not need DPCs because the device has been surprise + // //removed + // // + // + // KeCancelTimer(&deviceExtension->Timer); + + // deviceExtension->SSEnable = 0; + + // // + // //make sure that if a DPC was fired before we called cancel timer, + // //then the DPC and work-time have run to their completion + // // + // KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, + // Executive, + // KernelMode, + // FALSE, + // NULL); + + // // + // //make sure that the selective suspend request has been completed. + // // + // KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, + // Executive, + // KernelMode, + // FALSE, + // NULL); + // } + //} + + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + SET_NEW_PNP_STATE(pDevice, SurpriseRemoved); + pDevice->QueueState = FailRequests; + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + + //ProcessQueuedRequests(deviceExtension); + + AbortUsbPipes(pKSDeviceObject); + + PrintFunctionExit(__FUNCTION__,ntStatus); + + return ntStatus; +} + +/***************************************************************************** + Function : AbortUsbPipes + Description : This function sends an abort pipe request for pipes. + IN PARAM : Pointer to Device Object + OUT PARAM : Status of the Pipe Abort + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Pipe are aborted + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS AbortUsbPipes(IN PKSDEVICE pKSDeviceObject) +{ + PURB pUsbRequestBlock = NULL; + ULONG ulPipeIndex = 0; + NTSTATUS ntStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + PUSBD_PIPE_INFORMATION pPipeInformation = &pDevice->ReadPipe; + + PrintFunctionEntry(__FUNCTION__); + + for(ulPipeIndex = 0; ulPipeIndex < 2; ulPipeIndex++) + { + //if(pPipeInformation->PipeOpen) + { + + SkyWalkerDebugPrint(EXTREME_LEVEL, ("Aborting Pipe 0x%X\n",pPipeInformation->EndpointAddress)); + + pUsbRequestBlock = (PURB) ExAllocatePoolWithTag( NonPagedPool, + sizeof(struct _URB_PIPE_REQUEST), + USB_MEMORY_TAG); + + if(pUsbRequestBlock) + { + + pUsbRequestBlock->UrbHeader.Length = sizeof(struct _URB_PIPE_REQUEST); + pUsbRequestBlock->UrbHeader.Function = URB_FUNCTION_ABORT_PIPE; + pUsbRequestBlock->UrbPipeRequest.PipeHandle = pPipeInformation->PipeHandle; + + ntStatus = SendURBToBusDriver(pKSDeviceObject,pUsbRequestBlock); + + ExFreePool(pUsbRequestBlock); + } + else + { + + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Failed to Allocate memory for URB during Pipe Abort\n")); + ntStatus = STATUS_INSUFFICIENT_RESOURCES; + goto FinishAbortPipe; + } + + if(NT_SUCCESS(ntStatus)) + { + //pPipeInformation->PipeOpen = FALSE; + } + pPipeInformation = &pDevice->WritePipe; + } + } + +FinishAbortPipe: + + PrintFunctionExit(__FUNCTION__,ntStatus); + + return ntStatus; +} + +/***************************************************************************** + Function : RemoveUsbDevice + Description : Function to used to Service PnP IRPs of Minor Type + IRP_MN_REMOVE_DEVICE + IN PARAM : Pointer to Device Object whose remove + request has come + Device Remove Cancel Irp with Minor Code + IRP_MN_REMOVE_DEVICE + OUT PARAM : Status of the Device Removal + STATUS_SUCCESS Always + PreCondition : NONE + PostCondtion : On Success Device Remove request is processed + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS RemoveUsbDevice( IN PKSDEVICE pKSDeviceObject, + IN PIRP pIoRequestPacket) +{ + KIRQL kOldIrql; + KEVENT Evevent; + NTSTATUS ntStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + ULONG ulRequestCount = 0L; + PrintFunctionEntry(__FUNCTION__); + + // + //The Plug & Play system has dictated the removal of this device. We + //have no choice but to detach and delete the device object. + //(If we wanted to express an interest in preventing this removal, + //we should have failed the query remove IRP). + // + + if(pDevice->UsbDeviceState != SurpriseRemoved ) + { + + // + //we are here after QUERY_REMOVE + // + + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + pDevice->QueueState = FailRequests; + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + + //if(deviceExtension->WaitWakeEnable) { + // + // CancelWaitWake(deviceExtension); + //} + + //if(WinXpOrBetter == deviceExtension->WdmVersion) { + + // if(deviceExtension->SSEnable) { + + // // + // //Cancel the timer so that the DPCs are no longer fired. + // //we do not need DPCs because the device has been removed + // // + // KeCancelTimer(&deviceExtension->Timer); + + // deviceExtension->SSEnable = 0; + + // // + // //make sure that if a DPC was fired before we called cancel timer, + // //then the DPC and work-time have run to their completion + // // + // KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, + // Executive, + // KernelMode, + // FALSE, + // NULL); + + // // + // //make sure that the selective suspend request has been completed. + // // + // KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, + // Executive, + // KernelMode, + // FALSE, + // NULL); + // } + //} + + //ProcessQueuedRequests(deviceExtension); + + AbortUsbPipes(pKSDeviceObject); + } + + KeAcquireSpinLock(&pDevice->DeviceStateLock, &kOldIrql); + + SET_NEW_PNP_STATE(pDevice, Removed); + + KeReleaseSpinLock(&pDevice->DeviceStateLock, kOldIrql); + + // + //need 2 decrements + // + + ulRequestCount = DecrementPendingIoCount(pDevice); + ulRequestCount = DecrementPendingIoCount(pDevice); + + KeWaitForSingleObject(&pDevice->EvDeviceRemoveOk, + Executive, + KernelMode, + FALSE, + NULL); + + PrintFunctionExit(__FUNCTION__,ntStatus); + + return ntStatus; +} + +/***************************************************************************** + Function : ResetUsbPipe + Description : This routine synchronously submits a URB_FUNCTION_RESET_PIPE + request down the stack. + IN PARAM : Pointer to Device Object + Pipe to be reseted + OUT PARAM : Status of the Reset Usb Pipe Request + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Usb Pipe is reseted + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS ResetUsbPipe( IN PKSDEVICE pKSDeviceObject, + IN PUSBD_PIPE_INFORMATION pPipeInformation) +{ + PURB pUsbRequestBlock = NULL; + NTSTATUS ntResetStatus = STATUS_SUCCESS; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *)pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Pipe to Reset = 0x%X",pPipeInformation->EndpointAddress)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("Pipe Handle = 0x%p",pPipeInformation->PipeHandle)); + + pUsbRequestBlock = (PURB) ExAllocatePoolWithTag( NonPagedPool, + sizeof(struct _URB_PIPE_REQUEST), + USB_MEMORY_TAG); + + if(pUsbRequestBlock) + { + + pUsbRequestBlock->UrbHeader.Length = (USHORT) sizeof(struct _URB_PIPE_REQUEST); + pUsbRequestBlock->UrbHeader.Function = URB_FUNCTION_RESET_PIPE; + pUsbRequestBlock->UrbPipeRequest.PipeHandle = pPipeInformation->PipeHandle; + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Sending the Pipe Reset Command\n")); + ntResetStatus = SendURBToBusDriver(pKSDeviceObject, pUsbRequestBlock); + + ExFreePool(pUsbRequestBlock); + } + else + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Failed to allocate URB Memory during Pipe Reset\n")); + ntResetStatus = STATUS_INSUFFICIENT_RESOURCES; + } + + if(NT_SUCCESS(ntResetStatus)) + { + SkyWalkerDebugPrint(EXTREME_LEVEL, ("Successfully Reseted the Usb Pipe\n")); + ntResetStatus = STATUS_SUCCESS; + } + else + { + SkyWalkerDebugPrint(ENTRY_LEVEL, ("Failed to reset the Usb Pipe\n")); + } + + PrintFunctionExit(__FUNCTION__,ntResetStatus); + + return ntResetStatus; +} + +/***************************************************************************** + Function : ResetUsbDevice + Description : This routine checks the current status of the Usb Port + If Device is connected but not enabled then it resets + the Usb Port + IN PARAM : Pointer to Device Object + OUT PARAM : Status of the Reset Usb Device Request + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Usb Device is reseted + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS ResetUsbDevice(IN PKSDEVICE pKSDeviceObject) +{ + NTSTATUS ntResetStatus = STATUS_SUCCESS; + ULONG ulPortStatus = 0; + + PrintFunctionEntry(__FUNCTION__); + + ntResetStatus = GetUsbPortStatus(pKSDeviceObject, &ulPortStatus); + + if((NT_SUCCESS(ntResetStatus)) + && (!(ulPortStatus & USBD_PORT_ENABLED)) + && (ulPortStatus & USBD_PORT_CONNECTED)) + { + + SkyWalkerDebugPrint(ENTRY_LEVEL,("Resetting the Parent Port\n")); + ntResetStatus = ResetUsbParentPort(pKSDeviceObject); + } + + PrintFunctionExit(__FUNCTION__,ntResetStatus); + + return ntResetStatus; +} + +/***************************************************************************** + Function : GetUsbPortStatus + Description : This routine retrives the Usb Port Status as Enabled / Disabled + and Connected / Not Connected + IN PARAM : Pointer to Device Object + Port Status + OUT PARAM : Status of the USB Port Status Request + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Usb Port status is retrived + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS GetUsbPortStatus( IN PKSDEVICE pKSDeviceObject, + IN OUT PULONG pulPortStatus) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + KEVENT EvRequestComplete; + PIRP pIoRequestPacket = NULL; + IO_STATUS_BLOCK IoStatus; + PIO_STACK_LOCATION pNextStackLocation = NULL; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *) pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + *pulPortStatus = 0; + + //Initialize the Event to be triggerred after completion of Device Io Control request + KeInitializeEvent(&EvRequestComplete, NotificationEvent, FALSE); + + pIoRequestPacket = IoBuildDeviceIoControlRequest( + IOCTL_INTERNAL_USB_GET_PORT_STATUS, + pKSDeviceObject->NextDeviceObject, + NULL, + 0, + NULL, + 0, + TRUE, + &EvRequestComplete, + &IoStatus); + + if(!IS_VALID(pIoRequestPacket)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Memory Allocation during Get Port Status Failed\n")); + goto FinishGetPortStatus; + return STATUS_INSUFFICIENT_RESOURCES; + } + + pNextStackLocation = IoGetNextIrpStackLocation(pIoRequestPacket); + + pNextStackLocation->Parameters.Others.Argument1 = pulPortStatus; + + ntStatus = IoCallDriver(pKSDeviceObject->NextDeviceObject, pIoRequestPacket); + + if(ntStatus == STATUS_PENDING) + { + KeWaitForSingleObject(&EvRequestComplete, Executive, KernelMode, FALSE, NULL); + } + else + { + IoStatus.Status = ntStatus; + } + + ntStatus = IoStatus.Status; + + SkyWalkerDebugPrint(EXTREME_LEVEL,("Port Status = %lu (",*pulPortStatus)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("%s, ",(((*pulPortStatus) & USBD_PORT_ENABLED)? "Enabled" : "Disabled"))); + SkyWalkerDebugPrint(EXTREME_LEVEL,("%s)\n",(((*pulPortStatus) & USBD_PORT_CONNECTED)? "Connected" : "Not Connected"))); + +FinishGetPortStatus: + + PrintFunctionExit(__FUNCTION__,ntStatus); + + return ntStatus; +} + +/***************************************************************************** + Function : ResetUsbParentPort + Description : This routine sends an IOCTL_INTERNAL_USB_RESET_PORT + synchronously down the stack. + IN PARAM : Pointer to Device Object + OUT PARAM : Status of the Reset USB Port Request + STATUS_SUCCESS on Successful execution + else Error from the Bus Driver + PreCondition : NONE + PostCondtion : On Success Usb Port is reseted + Logic : NONE + Assumption : NONE + Revision History: + *****************************************************************************/ +NTSTATUS ResetUsbParentPort( IN PKSDEVICE pKSDeviceObject ) +{ + NTSTATUS ntStatus = STATUS_SUCCESS; + KEVENT EvRequestComplete; + PIRP pIoRequestPacket = NULL; + IO_STATUS_BLOCK IoStatus; + PIO_STACK_LOCATION pNextStackLocation = NULL; + CSkyWalker1Device * pDevice = (CSkyWalker1Device *) pKSDeviceObject->Context; + + PrintFunctionEntry(__FUNCTION__); + + //Initialize the Event to be triggerred after completion of Device Io Control request + KeInitializeEvent(&EvRequestComplete, NotificationEvent, FALSE); + + pIoRequestPacket = IoBuildDeviceIoControlRequest( + IOCTL_INTERNAL_USB_RESET_PORT, + pKSDeviceObject->NextDeviceObject, + NULL, + 0, + NULL, + 0, + TRUE, + &EvRequestComplete, + &IoStatus); + + if(!IS_VALID(pIoRequestPacket)) + { + SkyWalkerDebugPrint(ENTRY_LEVEL,("Memory Allocation during Reset Parent Device Failed\n")); + ntStatus = STATUS_INSUFFICIENT_RESOURCES; + goto FinishResetDevice; + + } + + pNextStackLocation = IoGetNextIrpStackLocation(pIoRequestPacket); + + ntStatus = IoCallDriver(pKSDeviceObject->NextDeviceObject, pIoRequestPacket); + + if(ntStatus == STATUS_PENDING) + { + KeWaitForSingleObject(&EvRequestComplete, Executive, KernelMode, FALSE, NULL); + } + else + { + IoStatus.Status = ntStatus; + } + + ntStatus = IoStatus.Status; + +FinishResetDevice: + + PrintFunctionExit(__FUNCTION__,ntStatus); + + return ntStatus; +} + +//Print Device Descriptor +VOID PrintDeviceDescriptor(IN PUSB_DEVICE_DESCRIPTOR pDeviceDescriptor) +{ + SkyWalkerDebugPrint(INTERMEDIATE_LEVEL, (__FUNCTION__"\n")); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bLength= %02d\n", + pDeviceDescriptor->bLength)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bDescriptorType= %02d\n", + pDeviceDescriptor->bDescriptorType)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bcdUSB= 0x%X\n", + pDeviceDescriptor->bcdUSB)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bDeviceClass= 0x%02X\n", + pDeviceDescriptor->bDeviceClass)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bDeviceSubClass= 0x%02X\n", + pDeviceDescriptor->bDeviceSubClass)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bDeviceProtocol= 0x%02X\n", + pDeviceDescriptor->bDeviceProtocol)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bMaxPacketSize0= %02d\n", + pDeviceDescriptor->bMaxPacketSize0)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->idVendor= 0x%X\n", + pDeviceDescriptor->idVendor)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->idProduct= 0x%X\n", + pDeviceDescriptor->idProduct)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bcdDevice= 0x%X\n", + pDeviceDescriptor->bcdDevice)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->iManufacturer= %02d\n", + pDeviceDescriptor->iManufacturer)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->iProduct= %02d\n", + pDeviceDescriptor->iProduct)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->iSerialNumber= %02d\n", + pDeviceDescriptor->iSerialNumber)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pDeviceDescriptor->bNumConfigurations= %02d\n", + pDeviceDescriptor->bNumConfigurations)); +} + +//Print Configuration Descriptor +VOID PrintConfigurationDescriptor(IN PUSB_CONFIGURATION_DESCRIPTOR pConfigurationDescriptor) +{ + SkyWalkerDebugPrint(INTERMEDIATE_LEVEL, (__FUNCTION__"\n")); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pConfigurationDescriptor->bLength= %02d\n", + pConfigurationDescriptor->bLength)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pConfigurationDescriptor->bDescriptorType= %02d\n", + pConfigurationDescriptor->bDescriptorType)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pConfigurationDescriptor->wTotalLength= %d\n", + pConfigurationDescriptor->wTotalLength)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pConfigurationDescriptor->bNumInterfaces= %02d\n", + pConfigurationDescriptor->bNumInterfaces)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pConfigurationDescriptor->bConfigurationValue= %02d\n", + pConfigurationDescriptor->bConfigurationValue)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pConfigurationDescriptor->iConfiguration= %02d\n", + pConfigurationDescriptor->iConfiguration)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pConfigurationDescriptor->bmAttributes= 0x%02X\n", + pConfigurationDescriptor->bmAttributes)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pConfigurationDescriptor->MaxPower= %02d\n", + pConfigurationDescriptor->MaxPower)); + +} +//Print Interface Descriptor +VOID PrintInterfaceDescriptor(IN PUSB_INTERFACE_DESCRIPTOR pInterfaceDescriptor) +{ + SkyWalkerDebugPrint(INTERMEDIATE_LEVEL, (__FUNCTION__"\n")); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->bLength= %02d\n", + pInterfaceDescriptor->bLength)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->bDescriptorType= %02d\n", + pInterfaceDescriptor->bDescriptorType)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->bInterfaceNumber= %02d\n", + pInterfaceDescriptor->bInterfaceNumber)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->bAlternateSetting= %02d\n", + pInterfaceDescriptor->bAlternateSetting)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->bNumEndpoints= %02d\n", + pInterfaceDescriptor->bNumEndpoints)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->bInterfaceClass= 0x%02X\n", + pInterfaceDescriptor->bInterfaceClass)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->bInterfaceSubClass= 0x%02X\n", + pInterfaceDescriptor->bInterfaceSubClass)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->bInterfaceProtocol= 0x%02X\n", + pInterfaceDescriptor->bInterfaceProtocol)); + SkyWalkerDebugPrint(EXTREME_LEVEL, ("pInterfaceDescriptor->iInterface= %02d\n", + pInterfaceDescriptor->iInterface)); + +} + +//Print Pipe Information +VOID PrintPipeInformation(PUSBD_PIPE_INFORMATION pPipeInformation) +{ + SkyWalkerDebugPrint(EXTREME_LEVEL,("pPipeInformation->PipeType = 0x%X\n", + pPipeInformation->PipeType)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pPipeInformation->EndpointAddress = 0x%X\n", + pPipeInformation->EndpointAddress)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pPipeInformation->MaximumPacketSize = 0x%X\n", + pPipeInformation->MaximumPacketSize)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pPipeInformation->Interval = 0x%X\n", + pPipeInformation->Interval)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pPipeInformation->PipeHandle = 0x%p\n", + pPipeInformation->PipeHandle)); + SkyWalkerDebugPrint(EXTREME_LEVEL,("pPipeInformation->MaximumTransferSize = 0x%X\n", + pPipeInformation->MaximumTransferSize)); + +} \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Utility.cpp b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Utility.cpp new file mode 100644 index 0000000..bba4deb --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker1Utility.cpp @@ -0,0 +1,2620 @@ +/***************************************************************************** + Company : Shree Ganesha Inc. + File Name : SkyWalker1Utility.cpp + Author : + Date : + Purpose : This file contains the Utility / Commanly Used Functions for the + SkyWalker1 Tuner Device Driver + + Revision History: +=============================================================================== + DATE VERSION AUTHOR REMARK +=============================================================================== + + XXth April,2009 01 Initial Version + +*****************************************************************************/ + +/* Include the Library and Other header file */ + +#include "SkyWalker1Main.h" //Common For all the Definitions, + //Declarations and Library Routines + +/* End of Inclusion the Library and Other header file */ + +/* Macro Definitions */ +/* End of Macro Definitions */ + +/* Global & Static variables Declaration */ +int nCurrentDebugLevel = EXTREME_LEVEL; +/* End of Global & Static variables Declaration */ + +/* External Variable Declaration */ +/* End of External Variable Declaration */ + +/* Declare Enumerations here */ +/* End of Enumeration declaration */ + +/* Function Prototypes */ +/* End of Function prototype definitions */ + +/***************************************************************************** + Function : PrintFunctionEntry + Description : Function to print Message while Entering the Function + IN PARAM : Function Name + OUT PARAM : NONE + PreCondition : NONE + PostCondtion : Function Entry Printed on Screen + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +void PrintFunctionEntry(IN char * pcFunctionName) +{ + + SkyWalkerDebugPrint(INTERMEDIATE_LEVEL, ("Entered into Function : %s() @ IRQ Level = %s\n", + pcFunctionName, + GetCurrentIrqlString())); + +} + +/***************************************************************************** + Function : PrintFunctionExit + Description : Function to print message while exiting the Function + IN PARAM : Function Name + Function Response + OUT PARAM : NONE + PreCondition : NONE + PostCondtion : Function Exit Printed on Screen + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +void PrintFunctionExit(IN char * pcFunctionName, IN NTSTATUS ntReturnCode) +{ + SkyWalkerDebugPrint(INTERMEDIATE_LEVEL, ("Exiting from Function : %s() @ IRQ Level = %s, with Status = %s(0x%08X)\n", + pcFunctionName, + GetCurrentIrqlString(), + NTStatusToString(ntReturnCode), + ntReturnCode)); +} + +/***************************************************************************** + Function : LowerDeviceCompletedIrp + Description : This function is a Completion Routine set when the IRP + is sent to the Lower Driver.It is called when the Lower Device + completes the IRP using the IoCompleteRequest() + IN PARAM : Reference of the Device Object whose lower device + was called + IRP Reference which sent Down + Context (In our case it is PKEVENT always) + OUT PARAM : STATUS_MORE_PROCESSING_REQUIRED always as Caller + will complete the IRP + PreCondition : IRP Passed Down to the Lower Device + PostCondtion : Event Set when the Response Received from the Lower Device + Logic : 1) Set the event is Pending Return from Lower Device + 2) return STATUS_MORE_PROCESSING_REQUIRED + Assumption : NONE + Note : This is usually called at the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS LowerDeviceCompletedIrp(IN PDEVICE_OBJECT pDeviceObject, + IN PIRP pIoRequestPacket, + IN PVOID pContext) +{ + + PrintFunctionEntry(__FUNCTION__); + + if (pIoRequestPacket->PendingReturned == TRUE) + { + // + // Set the event only if the lower driver has returned + // STATUS_PENDING earlier. This optimization removes the need to + // call KeSetEvent unnecessarily and improves performance because the + // system does not have to acquire an internal lock. + // (REFERENCE : Microsoft MSDN)http://support.microsoft.com/kb/320275 + + KeSetEvent ((PKEVENT) pContext, IO_NO_INCREMENT, FALSE); + } + + PrintFunctionExit(__FUNCTION__,STATUS_MORE_PROCESSING_REQUIRED); + // This is the only status that can be returned. + return STATUS_MORE_PROCESSING_REQUIRED; +} + +/***************************************************************************** + Function : PassDownIRPAndWaitForCompletion + Description : This function Passes the IRP to the Lower Device attached + and after passing waits for and Event which is triggerred after + the completion of the IRP (i.e. When IoCompleteRequest()is called by the + Lower Device) + IN PARAM : Reference of the Lower Device Object to be called + IRP Reference which needs to be pass Down + OUT PARAM : the Passing Down Status,Based on Status returned from + Lower Device + PreCondition : NONE + PostCondtion : IRP Passed Down to the Lower Device on successful Execution + Logic : 1) Initialize the Completion routine + 2) Copy Current IRP Stack location to Next (IoCopyCurrentIrpStackLocationToNext()) + 3) Set the IRP Completion Routine (IoSetCompeltionRoutine()) + 4) Call the Lower Device (IoCallDriver) + 5) Wait for the Irp Completion (KeWaitForSingleObject()) + Assumption : Device Extension has a Valid Lower Device Reference + Note : This is usually called at the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS PassDownIRPAndWaitForCompletion(IN PDEVICE_OBJECT pLowerDeviceObject, + IN PIRP pIoRequestPacket, + IN BOOLEAN bCopyStackLocation) +{ + NTSTATUS ntIrpProcessingStatus = STATUS_SUCCESS; + KEVENT kIrpCompleted; + PrintFunctionEntry(__FUNCTION__); + + //Initialize Kernel Event + KeInitializeEvent(&kIrpCompleted, //PKEVENT + NotificationEvent, //Type + FALSE); //State + + if(bCopyStackLocation) + { + //Copy Current IRP Stack to Next + IoCopyCurrentIrpStackLocationToNext(pIoRequestPacket); + } + + //Set Completion Routine + IoSetCompletionRoutine(pIoRequestPacket,//PIRP + LowerDeviceCompletedIrp,//Completion Routine + &kIrpCompleted, //PKEVENT (Context) + TRUE, //Flag on Success + TRUE, //Flag on Error + TRUE //Falg on Cancel + ); + //Call the Next Driver + ntIrpProcessingStatus = IoCallDriver(pLowerDeviceObject,pIoRequestPacket); + if(ntIrpProcessingStatus == STATUS_PENDING) + { + //IRP is to be processed + ntIrpProcessingStatus = KeWaitForSingleObject(&kIrpCompleted, //PKEVENT + Executive, //Wait Reason has to be Executive + KernelMode, //Must be kernel mode so + //that Stack will not Paged out + FALSE, //No Alert + NULL //Infinite Wait + ); + if(NT_SUCCESS(ntIrpProcessingStatus)) + { + //Lower Driver Completed the IRP (IoCompleteIrp()) + KeClearEvent(&kIrpCompleted); + ntIrpProcessingStatus = pIoRequestPacket->IoStatus.Status; + } + } + + PrintFunctionExit(__FUNCTION__,ntIrpProcessingStatus); + + return ntIrpProcessingStatus; + +} + + +/***************************************************************************** + Function : PassDownIRPAndForget + Description : This function Skips the IRP to the Lower Device attached + IN PARAM : Reference of the Lower Device Object to be called + IRP Reference which needs to be pass Down + OUT PARAM : the Passing Down Status,Based on Status returned from + IoCallDriver() Function + PreCondition : NONE + PostCondtion : IRP Passed Down to the Lower Device on successful Execution + Logic : 1) Skip the Current IRP + 2) Call the Lower Device Driver + Assumption : Device Extension has a Valid Lower Device Reference + Note : This is usually called at the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +NTSTATUS PassDownIRPAndForget(IN PDEVICE_OBJECT pLowerDeviceObject, + IN PIRP pIoRequestPacket) +{ + NTSTATUS ntIrpProcessingStatus = STATUS_SUCCESS; + + PrintFunctionEntry(__FUNCTION__); + + // + // As not setting a completion routine, skipping the stack + // location because it provides better performance. + // (REFERENCE : Microsoft MSDN) http://support.microsoft.com/kb/320275 + + //Skip Current IRP Stack + IoSkipCurrentIrpStackLocation(pIoRequestPacket); + + //Call the Lower Device + ntIrpProcessingStatus = IoCallDriver(pLowerDeviceObject,pIoRequestPacket); + + PrintFunctionExit(__FUNCTION__,ntIrpProcessingStatus); + + return ntIrpProcessingStatus; +} + +/***************************************************************************** + Function : CompleteIrpInDispatch + Description : This function Completes the IRP + IN PARAM : Reference of the Device Object + IRP Reference which needs to be Completed + OUT PARAM : NONE + PreCondition : NONE + PostCondtion : IRP Completed + Logic : NONE + Assumption : NONE + Note : This is usually called at the PASSIVE_LEVEL_IRQL + Revision History: + *****************************************************************************/ +VOID CompleteIrpInDispatch(IN PDEVICE_OBJECT pDeviceObject, + IN PIRP pIoRequestPacket) +{ + PrintFunctionEntry(__FUNCTION__); + + IoCompleteRequest(pIoRequestPacket,IO_NO_INCREMENT); + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); +} + +/***************************************************************************** + Function : Delay + Description : This function Delays Execution thread by the Microseconds passed + IN PARAM : Delay in MicroSeconds + OUT PARAM : NONE + PreCondition : NONE + PostCondtion : Delayed Execution Thread + Logic : NONE + Assumption : NONE + NOTE : This Function should always be called the the passive level + Revision History: + *****************************************************************************/ +VOID Delay(IN ULONG ulDelayInMicroSeconds) +{ + LARGE_INTEGER DelayIn100NanoSeconds; + PrintFunctionEntry(__FUNCTION__); + + //we need to Convert MicroSeconds to 100 nano Second Unit + //for the KeDelayExecutionThread() Call + //1000 nano Second = 1 MicroSecond + //100 nano Second = 0.1 MicroSecond + //Thus to Convert X Microseconds to Y 100 Nano Second Unit + // 1 (100 nano Second Unit) = 0.1 Micro Second Unit + // Y (100 nano Second Unit) = X Micro Second Unit + //Thus X (100 Nano Second Unit) = 0.1 Y MicroSecond Unit + //Thus Y (100 Nano Second Unit) = 10 * X (Micro Second) + //Thus Conversion Factor is 10 + + //Converting the Micro Seconds to 100 Nano Second Unit + //Negative Timeout Value is to Indicate the Relative Time from Current Time + DelayIn100NanoSeconds.QuadPart = (LONGLONG)ulDelayInMicroSeconds * (-10L); + + KeDelayExecutionThread(KernelMode, //Processor Wait Mode - Kernel + FALSE, //Lower Level Drivers are Not Alertable + &DelayIn100NanoSeconds); //Interval + + PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS); +} +/***************************************************************************** + Function : GetCurrentIrqlString + Description : This function converts the IRQ Level to the String + IN PARAM : Status to be converted + OUT PARAM : NONE + PreCondition : NONE + PostCondtion : String value of the IRQ Level returned + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +char * GetCurrentIrqlString(void) +{ + ULONG ulCurrentIrql = KeGetCurrentIrql(); + + switch(ulCurrentIrql) + { + case PASSIVE_LEVEL: + return "PASSIVE_LEVEL"; + case APC_LEVEL: + return "APC_LEVEL"; + case DISPATCH_LEVEL: + return "DISPATCH_LEVEL"; + default: + return "DEVICE IRQL"; + } +} +/***************************************************************************** + Function : PrintDeviceChangeState + Description : This function Prints the Tuner State change + IN PARAM : State to which transition occurred + State From which transition occurred + OUT PARAM : NONE + PreCondition : NONE + PostCondtion : State Transition Printed + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +VOID PrintDeviceChangeState(IN KSSTATE ToState,IN KSSTATE FromState) +{ + PCHAR pFromState = NULL; + PCHAR pToState = NULL; + KSSTATE State = ToState; + PCHAR pState = NULL; + + for(INT nStateIndex = 0;nStateIndex < 2;nStateIndex++) + { + switch(State) + { + case KSSTATE_STOP: + pState = "Stop"; + break; + case KSSTATE_ACQUIRE: + pState = "Acquire"; + break; + case KSSTATE_PAUSE: + pState = "Pause"; + break; + case KSSTATE_RUN: + pState = "Run"; + break; + default : + pState = "Unknown"; + break; + + } + if(nStateIndex == 0) + { + pToState = pState; + State = FromState; + } + else + { + pFromState = pState; + } + } + + SkyWalkerDebugPrint(EXTREME_LEVEL, ("Change State From %s to %s\n",pFromState,pToState)); + +} + +/***************************************************************************** + Function : NTStatusToString + Description : This function converts the NTSTATUS value to String + IN PARAM : Status to be converted + OUT PARAM : NONE + PreCondition : NONE + PostCondtion : String value of the Status returned + Logic : NONE + Assumption : NONE + Note : NONE + Revision History: + *****************************************************************************/ +PUCHAR NTStatusToString(NTSTATUS Status) +{ + + switch (Status) { + case STATUS_SUCCESS: + return (PUCHAR)"STATUS_SUCCESS"; + case STATUS_WAIT_1: + return (PUCHAR)"STATUS_WAIT_1"; + case STATUS_WAIT_2: + return (PUCHAR)"STATUS_WAIT_2"; + case STATUS_WAIT_3: + return (PUCHAR)"STATUS_WAIT_3"; + case STATUS_WAIT_63: + return (PUCHAR)"STATUS_WAIT_63"; + case STATUS_ABANDONED: + return (PUCHAR)"STATUS_ABANDONED"; + case STATUS_ABANDONED_WAIT_63: + return (PUCHAR)"STATUS_ABANDONED_WAIT_63"; + case STATUS_USER_APC: + return (PUCHAR)"STATUS_USER_APC"; + case STATUS_KERNEL_APC: + return (PUCHAR)"STATUS_KERNEL_APC"; + case STATUS_ALERTED: + return (PUCHAR)"STATUS_ALERTED"; + case STATUS_TIMEOUT: + return (PUCHAR)"STATUS_TIMEOUT"; + case STATUS_PENDING: + return (PUCHAR)"STATUS_PENDING"; + case STATUS_REPARSE: + return (PUCHAR)"STATUS_REPARSE"; + case STATUS_MORE_ENTRIES: + return (PUCHAR)"STATUS_MORE_ENTRIES"; + case STATUS_NOT_ALL_ASSIGNED: + return (PUCHAR)"STATUS_NOT_ALL_ASSIGNED"; + case STATUS_SOME_NOT_MAPPED: + return (PUCHAR)"STATUS_SOME_NOT_MAPPED"; + case STATUS_OPLOCK_BREAK_IN_PROGRESS: + return (PUCHAR)"STATUS_OPLOCK_BREAK_IN_PROGRESS"; + case STATUS_VOLUME_MOUNTED: + return (PUCHAR)"STATUS_VOLUME_MOUNTED"; + case STATUS_RXACT_COMMITTED: + return (PUCHAR)"STATUS_RXACT_COMMITTED"; + case STATUS_NOTIFY_CLEANUP: + return (PUCHAR)"STATUS_NOTIFY_CLEANUP"; + case STATUS_NOTIFY_ENUM_DIR: + return (PUCHAR)"STATUS_NOTIFY_ENUM_DIR"; + case STATUS_NO_QUOTAS_FOR_ACCOUNT: + return (PUCHAR)"STATUS_NO_QUOTAS_FOR_ACCOUNT"; + case STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED: + return (PUCHAR)"STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED"; + case STATUS_PAGE_FAULT_TRANSITION: + return (PUCHAR)"STATUS_PAGE_FAULT_TRANSITION"; + case STATUS_PAGE_FAULT_DEMAND_ZERO: + return (PUCHAR)"STATUS_PAGE_FAULT_DEMAND_ZERO"; + case STATUS_PAGE_FAULT_COPY_ON_WRITE: + return (PUCHAR)"STATUS_PAGE_FAULT_COPY_ON_WRITE"; + case STATUS_PAGE_FAULT_GUARD_PAGE: + return (PUCHAR)"STATUS_PAGE_FAULT_GUARD_PAGE"; + case STATUS_PAGE_FAULT_PAGING_FILE: + return (PUCHAR)"STATUS_PAGE_FAULT_PAGING_FILE"; + case STATUS_CACHE_PAGE_LOCKED: + return (PUCHAR)"STATUS_CACHE_PAGE_LOCKED"; + case STATUS_CRASH_DUMP: + return (PUCHAR)"STATUS_CRASH_DUMP"; + case STATUS_BUFFER_ALL_ZEROS: + return (PUCHAR)"STATUS_BUFFER_ALL_ZEROS"; + case STATUS_REPARSE_OBJECT: + return (PUCHAR)"STATUS_REPARSE_OBJECT"; + case STATUS_RESOURCE_REQUIREMENTS_CHANGED: + return (PUCHAR)"STATUS_RESOURCE_REQUIREMENTS_CHANGED"; + case STATUS_TRANSLATION_COMPLETE: + return (PUCHAR)"STATUS_TRANSLATION_COMPLETE"; + case STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY: + return (PUCHAR)"STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_NOTHING_TO_TERMINATE: + return (PUCHAR)"STATUS_NOTHING_TO_TERMINATE"; + case STATUS_PROCESS_NOT_IN_JOB: + return (PUCHAR)"STATUS_PROCESS_NOT_IN_JOB"; + case STATUS_PROCESS_IN_JOB: + return (PUCHAR)"STATUS_PROCESS_IN_JOB"; +#endif +#if (VER_PRODUCT_BUILD > 2600) + case STATUS_VOLSNAP_HIBERNATE_READY: + return (PUCHAR)"STATUS_VOLSNAP_HIBERNATE_READY"; + case STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY: + return (PUCHAR)"STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY"; +#endif +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_WAIT_FOR_OPLOCK: + return (PUCHAR)"STATUS_WAIT_FOR_OPLOCK"; +#endif + case DBG_EXCEPTION_HANDLED: + return (PUCHAR)"DBG_EXCEPTION_HANDLED"; + case DBG_CONTINUE: + return (PUCHAR)"DBG_CONTINUE"; + case STATUS_OBJECT_NAME_EXISTS: + return (PUCHAR)"STATUS_OBJECT_NAME_EXISTS"; + case STATUS_THREAD_WAS_SUSPENDED: + return (PUCHAR)"STATUS_THREAD_WAS_SUSPENDED"; + case STATUS_WORKING_SET_LIMIT_RANGE: + return (PUCHAR)"STATUS_WORKING_SET_LIMIT_RANGE"; + case STATUS_IMAGE_NOT_AT_BASE: + return (PUCHAR)"STATUS_IMAGE_NOT_AT_BASE"; + case STATUS_RXACT_STATE_CREATED: + return (PUCHAR)"STATUS_RXACT_STATE_CREATED"; + case STATUS_SEGMENT_NOTIFICATION: + return (PUCHAR)"STATUS_SEGMENT_NOTIFICATION"; + case STATUS_LOCAL_USER_SESSION_KEY: + return (PUCHAR)"STATUS_LOCAL_USER_SESSION_KEY"; + case STATUS_BAD_CURRENT_DIRECTORY: + return (PUCHAR)"STATUS_BAD_CURRENT_DIRECTORY"; + case STATUS_SERIAL_MORE_WRITES: + return (PUCHAR)"STATUS_SERIAL_MORE_WRITES"; + case STATUS_REGISTRY_RECOVERED: + return (PUCHAR)"STATUS_REGISTRY_RECOVERED"; + case STATUS_FT_READ_RECOVERY_FROM_BACKUP: + return (PUCHAR)"STATUS_FT_READ_RECOVERY_FROM_BACKUP"; + case STATUS_FT_WRITE_RECOVERY: + return (PUCHAR)"STATUS_FT_WRITE_RECOVERY"; + case STATUS_SERIAL_COUNTER_TIMEOUT: + return (PUCHAR)"STATUS_SERIAL_COUNTER_TIMEOUT"; + case STATUS_NULL_LM_PASSWORD: + return (PUCHAR)"STATUS_NULL_LM_PASSWORD"; + case STATUS_IMAGE_MACHINE_TYPE_MISMATCH: + return (PUCHAR)"STATUS_IMAGE_MACHINE_TYPE_MISMATCH"; + case STATUS_RECEIVE_PARTIAL: + return (PUCHAR)"STATUS_RECEIVE_PARTIAL"; + case STATUS_RECEIVE_EXPEDITED: + return (PUCHAR)"STATUS_RECEIVE_EXPEDITED"; + case STATUS_RECEIVE_PARTIAL_EXPEDITED: + return (PUCHAR)"STATUS_RECEIVE_PARTIAL_EXPEDITED"; + case STATUS_EVENT_DONE: + return (PUCHAR)"STATUS_EVENT_DONE"; + case STATUS_EVENT_PENDING: + return (PUCHAR)"STATUS_EVENT_PENDING"; + case STATUS_CHECKING_FILE_SYSTEM: + return (PUCHAR)"STATUS_CHECKING_FILE_SYSTEM"; + case STATUS_FATAL_APP_EXIT: + return (PUCHAR)"STATUS_FATAL_APP_EXIT"; + case STATUS_PREDEFINED_HANDLE: + return (PUCHAR)"STATUS_PREDEFINED_HANDLE"; + case STATUS_WAS_UNLOCKED: + return (PUCHAR)"STATUS_WAS_UNLOCKED"; + case STATUS_SERVICE_NOTIFICATION: + return (PUCHAR)"STATUS_SERVICE_NOTIFICATION"; + case STATUS_WAS_LOCKED: + return (PUCHAR)"STATUS_WAS_LOCKED"; + case STATUS_LOG_HARD_ERROR: + return (PUCHAR)"STATUS_LOG_HARD_ERROR"; + case STATUS_ALREADY_WIN32: + return (PUCHAR)"STATUS_ALREADY_WIN32"; + case STATUS_WX86_UNSIMULATE: + return (PUCHAR)"STATUS_WX86_UNSIMULATE"; + case STATUS_WX86_CONTINUE: + return (PUCHAR)"STATUS_WX86_CONTINUE"; + case STATUS_WX86_SINGLE_STEP: + return (PUCHAR)"STATUS_WX86_SINGLE_STEP"; + case STATUS_WX86_BREAKPOINT: + return (PUCHAR)"STATUS_WX86_BREAKPOINT"; + case STATUS_WX86_EXCEPTION_CONTINUE: + return (PUCHAR)"STATUS_WX86_EXCEPTION_CONTINUE"; + case STATUS_WX86_EXCEPTION_LASTCHANCE: + return (PUCHAR)"STATUS_WX86_EXCEPTION_LASTCHANCE"; + case STATUS_WX86_EXCEPTION_CHAIN: + return (PUCHAR)"STATUS_WX86_EXCEPTION_CHAIN"; + case STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE: + return (PUCHAR)"STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE"; + case STATUS_NO_YIELD_PERFORMED: + return (PUCHAR)"STATUS_NO_YIELD_PERFORMED"; + case STATUS_TIMER_RESUME_IGNORED: + return (PUCHAR)"STATUS_TIMER_RESUME_IGNORED"; + case STATUS_ARBITRATION_UNHANDLED: + return (PUCHAR)"STATUS_ARBITRATION_UNHANDLED"; + case STATUS_CARDBUS_NOT_SUPPORTED: + return (PUCHAR)"STATUS_CARDBUS_NOT_SUPPORTED"; + case STATUS_WX86_CREATEWX86TIB: + return (PUCHAR)"STATUS_WX86_CREATEWX86TIB"; + case STATUS_MP_PROCESSOR_MISMATCH: + return (PUCHAR)"STATUS_MP_PROCESSOR_MISMATCH"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_HIBERNATED: + return (PUCHAR)"STATUS_HIBERNATED"; + case STATUS_RESUME_HIBERNATION: + return (PUCHAR)"STATUS_RESUME_HIBERNATION"; +#endif +#if (VER_PRODUCT_BUILD > 2600) + case STATUS_FIRMWARE_UPDATED: + return (PUCHAR)"STATUS_FIRMWARE_UPDATED"; + case STATUS_DRIVERS_LEAKING_LOCKED_PAGES: + return (PUCHAR)"STATUS_DRIVERS_LEAKING_LOCKED_PAGES"; +#endif + case STATUS_WAKE_SYSTEM: + return (PUCHAR)"STATUS_WAKE_SYSTEM"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_DS_SHUTTING_DOWN: + return (PUCHAR)"STATUS_DS_SHUTTING_DOWN"; +#endif + case DBG_REPLY_LATER: + return (PUCHAR)"DBG_REPLY_LATER"; + case DBG_UNABLE_TO_PROVIDE_HANDLE: + return (PUCHAR)"DBG_UNABLE_TO_PROVIDE_HANDLE"; + case DBG_TERMINATE_THREAD: + return (PUCHAR)"DBG_TERMINATE_THREAD"; + case DBG_TERMINATE_PROCESS: + return (PUCHAR)"DBG_TERMINATE_PROCESS"; + case DBG_CONTROL_C: + return (PUCHAR)"DBG_CONTROL_C"; + case DBG_PRINTEXCEPTION_C: + return (PUCHAR)"DBG_PRINTEXCEPTION_C"; + case DBG_RIPEXCEPTION: + return (PUCHAR)"DBG_RIPEXCEPTION"; + case DBG_CONTROL_BREAK: + return (PUCHAR)"DBG_CONTROL_BREAK"; +#if (VER_PRODUCT_BUILD > 2600) + case DBG_COMMAND_EXCEPTION: + return (PUCHAR)"DBG_COMMAND_EXCEPTION"; +#endif + case RPC_NT_UUID_LOCAL_ONLY: + return (PUCHAR)"RPC_NT_UUID_LOCAL_ONLY"; + case RPC_NT_SEND_INCOMPLETE: + return (PUCHAR)"RPC_NT_SEND_INCOMPLETE"; + case STATUS_CTX_CDM_CONNECT: + return (PUCHAR)"STATUS_CTX_CDM_CONNECT"; + case STATUS_CTX_CDM_DISCONNECT: + return (PUCHAR)"STATUS_CTX_CDM_DISCONNECT"; + case STATUS_GUARD_PAGE_VIOLATION: + return (PUCHAR)"STATUS_GUARD_PAGE_VIOLATION"; + case STATUS_DATATYPE_MISALIGNMENT: + return (PUCHAR)"STATUS_DATATYPE_MISALIGNMENT"; + case STATUS_BREAKPOINT: + return (PUCHAR)"STATUS_BREAKPOINT"; + case STATUS_SINGLE_STEP: + return (PUCHAR)"STATUS_SINGLE_STEP"; + case STATUS_BUFFER_OVERFLOW: + return (PUCHAR)"STATUS_BUFFER_OVERFLOW"; + case STATUS_NO_MORE_FILES: + return (PUCHAR)"STATUS_NO_MORE_FILES"; + case STATUS_WAKE_SYSTEM_DEBUGGER: + return (PUCHAR)"STATUS_WAKE_SYSTEM_DEBUGGER"; + case STATUS_HANDLES_CLOSED: + return (PUCHAR)"STATUS_HANDLES_CLOSED"; + case STATUS_NO_INHERITANCE: + return (PUCHAR)"STATUS_NO_INHERITANCE"; + case STATUS_GUID_SUBSTITUTION_MADE: + return (PUCHAR)"STATUS_GUID_SUBSTITUTION_MADE"; + case STATUS_PARTIAL_COPY: + return (PUCHAR)"STATUS_PARTIAL_COPY"; + case STATUS_DEVICE_PAPER_EMPTY: + return (PUCHAR)"STATUS_DEVICE_PAPER_EMPTY"; + case STATUS_DEVICE_POWERED_OFF: + return (PUCHAR)"STATUS_DEVICE_POWERED_OFF"; + case STATUS_DEVICE_OFF_LINE: + return (PUCHAR)"STATUS_DEVICE_OFF_LINE"; + case STATUS_DEVICE_BUSY: + return (PUCHAR)"STATUS_DEVICE_BUSY"; + case STATUS_NO_MORE_EAS: + return (PUCHAR)"STATUS_NO_MORE_EAS"; + case STATUS_INVALID_EA_NAME: + return (PUCHAR)"STATUS_INVALID_EA_NAME"; + case STATUS_EA_LIST_INCONSISTENT: + return (PUCHAR)"STATUS_EA_LIST_INCONSISTENT"; + case STATUS_INVALID_EA_FLAG: + return (PUCHAR)"STATUS_INVALID_EA_FLAG"; + case STATUS_VERIFY_REQUIRED: + return (PUCHAR)"STATUS_VERIFY_REQUIRED"; + case STATUS_EXTRANEOUS_INFORMATION: + return (PUCHAR)"STATUS_EXTRANEOUS_INFORMATION"; + case STATUS_RXACT_COMMIT_NECESSARY: + return (PUCHAR)"STATUS_RXACT_COMMIT_NECESSARY"; + case STATUS_NO_MORE_ENTRIES: + return (PUCHAR)"STATUS_NO_MORE_ENTRIES"; + case STATUS_FILEMARK_DETECTED: + return (PUCHAR)"STATUS_FILEMARK_DETECTED"; + case STATUS_MEDIA_CHANGED: + return (PUCHAR)"STATUS_MEDIA_CHANGED"; + case STATUS_BUS_RESET: + return (PUCHAR)"STATUS_BUS_RESET"; + case STATUS_END_OF_MEDIA: + return (PUCHAR)"STATUS_END_OF_MEDIA"; + case STATUS_BEGINNING_OF_MEDIA: + return (PUCHAR)"STATUS_BEGINNING_OF_MEDIA"; + case STATUS_MEDIA_CHECK: + return (PUCHAR)"STATUS_MEDIA_CHECK"; + case STATUS_SETMARK_DETECTED: + return (PUCHAR)"STATUS_SETMARK_DETECTED"; + case STATUS_NO_DATA_DETECTED: + return (PUCHAR)"STATUS_NO_DATA_DETECTED"; + case STATUS_REDIRECTOR_HAS_OPEN_HANDLES: + return (PUCHAR)"STATUS_REDIRECTOR_HAS_OPEN_HANDLES"; + case STATUS_SERVER_HAS_OPEN_HANDLES: + return (PUCHAR)"STATUS_SERVER_HAS_OPEN_HANDLES"; + case STATUS_ALREADY_DISCONNECTED: + return (PUCHAR)"STATUS_ALREADY_DISCONNECTED"; + case STATUS_LONGJUMP: + return (PUCHAR)"STATUS_LONGJUMP"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_CLEANER_CARTRIDGE_INSTALLED: + return (PUCHAR)"STATUS_CLEANER_CARTRIDGE_INSTALLED"; + case STATUS_PLUGPLAY_QUERY_VETOED: + return (PUCHAR)"STATUS_PLUGPLAY_QUERY_VETOED"; + case STATUS_UNWIND_CONSOLIDATE: + return (PUCHAR)"STATUS_UNWIND_CONSOLIDATE"; +#endif +#if (VER_PRODUCT_BUILD > 2600) + case STATUS_REGISTRY_HIVE_RECOVERED: + return (PUCHAR)"STATUS_REGISTRY_HIVE_RECOVERED"; + case STATUS_DLL_MIGHT_BE_INSECURE: + return (PUCHAR)"STATUS_DLL_MIGHT_BE_INSECURE"; + case STATUS_DLL_MIGHT_BE_INCOMPATIBLE: + return (PUCHAR)"STATUS_DLL_MIGHT_BE_INCOMPATIBLE"; +#endif + case STATUS_DEVICE_REQUIRES_CLEANING: + return (PUCHAR)"STATUS_DEVICE_REQUIRES_CLEANING"; + case STATUS_DEVICE_DOOR_OPEN: + return (PUCHAR)"STATUS_DEVICE_DOOR_OPEN"; + case DBG_EXCEPTION_NOT_HANDLED: + return (PUCHAR)"DBG_EXCEPTION_NOT_HANDLED"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_CLUSTER_NODE_ALREADY_UP: + return (PUCHAR)"STATUS_CLUSTER_NODE_ALREADY_UP"; + case STATUS_CLUSTER_NODE_ALREADY_DOWN: + return (PUCHAR)"STATUS_CLUSTER_NODE_ALREADY_DOWN"; + case STATUS_CLUSTER_NETWORK_ALREADY_ONLINE: + return (PUCHAR)"STATUS_CLUSTER_NETWORK_ALREADY_ONLINE"; + case STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE: + return (PUCHAR)"STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE"; + case STATUS_CLUSTER_NODE_ALREADY_MEMBER: + return (PUCHAR)"STATUS_CLUSTER_NODE_ALREADY_MEMBER"; +#endif + case STATUS_UNSUCCESSFUL: + return (PUCHAR)"STATUS_UNSUCCESSFUL"; + case STATUS_NOT_IMPLEMENTED: + return (PUCHAR)"STATUS_NOT_IMPLEMENTED"; + case STATUS_INVALID_INFO_CLASS: + return (PUCHAR)"STATUS_INVALID_INFO_CLASS"; + case STATUS_INFO_LENGTH_MISMATCH: + return (PUCHAR)"STATUS_INFO_LENGTH_MISMATCH"; + case STATUS_ACCESS_VIOLATION: + return (PUCHAR)"STATUS_ACCESS_VIOLATION"; + case STATUS_IN_PAGE_ERROR: + return (PUCHAR)"STATUS_IN_PAGE_ERROR"; + case STATUS_PAGEFILE_QUOTA: + return (PUCHAR)"STATUS_PAGEFILE_QUOTA"; + case STATUS_INVALID_HANDLE: + return (PUCHAR)"STATUS_INVALID_HANDLE"; + case STATUS_BAD_INITIAL_STACK: + return (PUCHAR)"STATUS_BAD_INITIAL_STACK"; + case STATUS_BAD_INITIAL_PC: + return (PUCHAR)"STATUS_BAD_INITIAL_PC"; + case STATUS_INVALID_CID: + return (PUCHAR)"STATUS_INVALID_CID"; + case STATUS_TIMER_NOT_CANCELED: + return (PUCHAR)"STATUS_TIMER_NOT_CANCELED"; + case STATUS_INVALID_PARAMETER: + return (PUCHAR)"STATUS_INVALID_PARAMETER"; + case STATUS_NO_SUCH_DEVICE: + return (PUCHAR)"STATUS_NO_SUCH_DEVICE"; + case STATUS_NO_SUCH_FILE: + return (PUCHAR)"STATUS_NO_SUCH_FILE"; + case STATUS_INVALID_DEVICE_REQUEST: + return (PUCHAR)"STATUS_INVALID_DEVICE_REQUEST"; + case STATUS_END_OF_FILE: + return (PUCHAR)"STATUS_END_OF_FILE"; + case STATUS_WRONG_VOLUME: + return (PUCHAR)"STATUS_WRONG_VOLUME"; + case STATUS_NO_MEDIA_IN_DEVICE: + return (PUCHAR)"STATUS_NO_MEDIA_IN_DEVICE"; + case STATUS_UNRECOGNIZED_MEDIA: + return (PUCHAR)"STATUS_UNRECOGNIZED_MEDIA"; + case STATUS_NONEXISTENT_SECTOR: + return (PUCHAR)"STATUS_NONEXISTENT_SECTOR"; + case STATUS_MORE_PROCESSING_REQUIRED: + return (PUCHAR)"STATUS_MORE_PROCESSING_REQUIRED"; + case STATUS_NO_MEMORY: + return (PUCHAR)"STATUS_NO_MEMORY"; + case STATUS_CONFLICTING_ADDRESSES: + return (PUCHAR)"STATUS_CONFLICTING_ADDRESSES"; + case STATUS_NOT_MAPPED_VIEW: + return (PUCHAR)"STATUS_NOT_MAPPED_VIEW"; + case STATUS_UNABLE_TO_FREE_VM: + return (PUCHAR)"STATUS_UNABLE_TO_FREE_VM"; + case STATUS_UNABLE_TO_DELETE_SECTION: + return (PUCHAR)"STATUS_UNABLE_TO_DELETE_SECTION"; + case STATUS_INVALID_SYSTEM_SERVICE: + return (PUCHAR)"STATUS_INVALID_SYSTEM_SERVICE"; + case STATUS_ILLEGAL_INSTRUCTION: + return (PUCHAR)"STATUS_ILLEGAL_INSTRUCTION"; + case STATUS_INVALID_LOCK_SEQUENCE: + return (PUCHAR)"STATUS_INVALID_LOCK_SEQUENCE"; + case STATUS_INVALID_VIEW_SIZE: + return (PUCHAR)"STATUS_INVALID_VIEW_SIZE"; + case STATUS_INVALID_FILE_FOR_SECTION: + return (PUCHAR)"STATUS_INVALID_FILE_FOR_SECTION"; + case STATUS_ALREADY_COMMITTED: + return (PUCHAR)"STATUS_ALREADY_COMMITTED"; + case STATUS_ACCESS_DENIED: + return (PUCHAR)"STATUS_ACCESS_DENIED"; + case STATUS_BUFFER_TOO_SMALL: + return (PUCHAR)"STATUS_BUFFER_TOO_SMALL"; + case STATUS_OBJECT_TYPE_MISMATCH: + return (PUCHAR)"STATUS_OBJECT_TYPE_MISMATCH"; + case STATUS_NONCONTINUABLE_EXCEPTION: + return (PUCHAR)"STATUS_NONCONTINUABLE_EXCEPTION"; + case STATUS_INVALID_DISPOSITION: + return (PUCHAR)"STATUS_INVALID_DISPOSITION"; + case STATUS_UNWIND: + return (PUCHAR)"STATUS_UNWIND"; + case STATUS_BAD_STACK: + return (PUCHAR)"STATUS_BAD_STACK"; + case STATUS_INVALID_UNWIND_TARGET: + return (PUCHAR)"STATUS_INVALID_UNWIND_TARGET"; + case STATUS_NOT_LOCKED: + return (PUCHAR)"STATUS_NOT_LOCKED"; + case STATUS_PARITY_ERROR: + return (PUCHAR)"STATUS_PARITY_ERROR"; + case STATUS_UNABLE_TO_DECOMMIT_VM: + return (PUCHAR)"STATUS_UNABLE_TO_DECOMMIT_VM"; + case STATUS_NOT_COMMITTED: + return (PUCHAR)"STATUS_NOT_COMMITTED"; + case STATUS_INVALID_PORT_ATTRIBUTES: + return (PUCHAR)"STATUS_INVALID_PORT_ATTRIBUTES"; + case STATUS_PORT_MESSAGE_TOO_LONG: + return (PUCHAR)"STATUS_PORT_MESSAGE_TOO_LONG"; + case STATUS_INVALID_PARAMETER_MIX: + return (PUCHAR)"STATUS_INVALID_PARAMETER_MIX"; + case STATUS_INVALID_QUOTA_LOWER: + return (PUCHAR)"STATUS_INVALID_QUOTA_LOWER"; + case STATUS_DISK_CORRUPT_ERROR: + return (PUCHAR)"STATUS_DISK_CORRUPT_ERROR"; + case STATUS_OBJECT_NAME_INVALID: + return (PUCHAR)"STATUS_OBJECT_NAME_INVALID"; + case STATUS_OBJECT_NAME_NOT_FOUND: + return (PUCHAR)"STATUS_OBJECT_NAME_NOT_FOUND"; + case STATUS_OBJECT_NAME_COLLISION: + return (PUCHAR)"STATUS_OBJECT_NAME_COLLISION"; + case STATUS_PORT_DISCONNECTED: + return (PUCHAR)"STATUS_PORT_DISCONNECTED"; + case STATUS_DEVICE_ALREADY_ATTACHED: + return (PUCHAR)"STATUS_DEVICE_ALREADY_ATTACHED"; + case STATUS_OBJECT_PATH_INVALID: + return (PUCHAR)"STATUS_OBJECT_PATH_INVALID"; + case STATUS_OBJECT_PATH_NOT_FOUND: + return (PUCHAR)"STATUS_OBJECT_PATH_NOT_FOUND"; + case STATUS_OBJECT_PATH_SYNTAX_BAD: + return (PUCHAR)"STATUS_OBJECT_PATH_SYNTAX_BAD"; + case STATUS_DATA_OVERRUN: + return (PUCHAR)"STATUS_DATA_OVERRUN"; + case STATUS_DATA_LATE_ERROR: + return (PUCHAR)"STATUS_DATA_LATE_ERROR"; + case STATUS_DATA_ERROR: + return (PUCHAR)"STATUS_DATA_ERROR"; + case STATUS_CRC_ERROR: + return (PUCHAR)"STATUS_CRC_ERROR"; + case STATUS_SECTION_TOO_BIG: + return (PUCHAR)"STATUS_SECTION_TOO_BIG"; + case STATUS_PORT_CONNECTION_REFUSED: + return (PUCHAR)"STATUS_PORT_CONNECTION_REFUSED"; + case STATUS_INVALID_PORT_HANDLE: + return (PUCHAR)"STATUS_INVALID_PORT_HANDLE"; + case STATUS_SHARING_VIOLATION: + return (PUCHAR)"STATUS_SHARING_VIOLATION"; + case STATUS_QUOTA_EXCEEDED: + return (PUCHAR)"STATUS_QUOTA_EXCEEDED"; + case STATUS_INVALID_PAGE_PROTECTION: + return (PUCHAR)"STATUS_INVALID_PAGE_PROTECTION"; + case STATUS_MUTANT_NOT_OWNED: + return (PUCHAR)"STATUS_MUTANT_NOT_OWNED"; + case STATUS_SEMAPHORE_LIMIT_EXCEEDED: + return (PUCHAR)"STATUS_SEMAPHORE_LIMIT_EXCEEDED"; + case STATUS_PORT_ALREADY_SET: + return (PUCHAR)"STATUS_PORT_ALREADY_SET"; + case STATUS_SECTION_NOT_IMAGE: + return (PUCHAR)"STATUS_SECTION_NOT_IMAGE"; + case STATUS_SUSPEND_COUNT_EXCEEDED: + return (PUCHAR)"STATUS_SUSPEND_COUNT_EXCEEDED"; + case STATUS_THREAD_IS_TERMINATING: + return (PUCHAR)"STATUS_THREAD_IS_TERMINATING"; + case STATUS_BAD_WORKING_SET_LIMIT: + return (PUCHAR)"STATUS_BAD_WORKING_SET_LIMIT"; + case STATUS_INCOMPATIBLE_FILE_MAP: + return (PUCHAR)"STATUS_INCOMPATIBLE_FILE_MAP"; + case STATUS_SECTION_PROTECTION: + return (PUCHAR)"STATUS_SECTION_PROTECTION"; + case STATUS_EAS_NOT_SUPPORTED: + return (PUCHAR)"STATUS_EAS_NOT_SUPPORTED"; + case STATUS_EA_TOO_LARGE: + return (PUCHAR)"STATUS_EA_TOO_LARGE"; + case STATUS_NONEXISTENT_EA_ENTRY: + return (PUCHAR)"STATUS_NONEXISTENT_EA_ENTRY"; + case STATUS_NO_EAS_ON_FILE: + return (PUCHAR)"STATUS_NO_EAS_ON_FILE"; + case STATUS_EA_CORRUPT_ERROR: + return (PUCHAR)"STATUS_EA_CORRUPT_ERROR"; + case STATUS_FILE_LOCK_CONFLICT: + return (PUCHAR)"STATUS_FILE_LOCK_CONFLICT"; + case STATUS_LOCK_NOT_GRANTED: + return (PUCHAR)"STATUS_LOCK_NOT_GRANTED"; + case STATUS_DELETE_PENDING: + return (PUCHAR)"STATUS_DELETE_PENDING"; + case STATUS_CTL_FILE_NOT_SUPPORTED: + return (PUCHAR)"STATUS_CTL_FILE_NOT_SUPPORTED"; + case STATUS_UNKNOWN_REVISION: + return (PUCHAR)"STATUS_UNKNOWN_REVISION"; + case STATUS_REVISION_MISMATCH: + return (PUCHAR)"STATUS_REVISION_MISMATCH"; + case STATUS_INVALID_OWNER: + return (PUCHAR)"STATUS_INVALID_OWNER"; + case STATUS_INVALID_PRIMARY_GROUP: + return (PUCHAR)"STATUS_INVALID_PRIMARY_GROUP"; + case STATUS_NO_IMPERSONATION_TOKEN: + return (PUCHAR)"STATUS_NO_IMPERSONATION_TOKEN"; + case STATUS_CANT_DISABLE_MANDATORY: + return (PUCHAR)"STATUS_CANT_DISABLE_MANDATORY"; + case STATUS_NO_LOGON_SERVERS: + return (PUCHAR)"STATUS_NO_LOGON_SERVERS"; + case STATUS_NO_SUCH_LOGON_SESSION: + return (PUCHAR)"STATUS_NO_SUCH_LOGON_SESSION"; + case STATUS_NO_SUCH_PRIVILEGE: + return (PUCHAR)"STATUS_NO_SUCH_PRIVILEGE"; + case STATUS_PRIVILEGE_NOT_HELD: + return (PUCHAR)"STATUS_PRIVILEGE_NOT_HELD"; + case STATUS_INVALID_ACCOUNT_NAME: + return (PUCHAR)"STATUS_INVALID_ACCOUNT_NAME"; + case STATUS_USER_EXISTS: + return (PUCHAR)"STATUS_USER_EXISTS"; + case STATUS_NO_SUCH_USER: + return (PUCHAR)"STATUS_NO_SUCH_USER"; + case STATUS_GROUP_EXISTS: + return (PUCHAR)"STATUS_GROUP_EXISTS"; + case STATUS_NO_SUCH_GROUP: + return (PUCHAR)"STATUS_NO_SUCH_GROUP"; + case STATUS_MEMBER_IN_GROUP: + return (PUCHAR)"STATUS_MEMBER_IN_GROUP"; + case STATUS_MEMBER_NOT_IN_GROUP: + return (PUCHAR)"STATUS_MEMBER_NOT_IN_GROUP"; + case STATUS_LAST_ADMIN: + return (PUCHAR)"STATUS_LAST_ADMIN"; + case STATUS_WRONG_PASSWORD: + return (PUCHAR)"STATUS_WRONG_PASSWORD"; + case STATUS_ILL_FORMED_PASSWORD: + return (PUCHAR)"STATUS_ILL_FORMED_PASSWORD"; + case STATUS_PASSWORD_RESTRICTION: + return (PUCHAR)"STATUS_PASSWORD_RESTRICTION"; + case STATUS_LOGON_FAILURE: + return (PUCHAR)"STATUS_LOGON_FAILURE"; + case STATUS_ACCOUNT_RESTRICTION: + return (PUCHAR)"STATUS_ACCOUNT_RESTRICTION"; + case STATUS_INVALID_LOGON_HOURS: + return (PUCHAR)"STATUS_INVALID_LOGON_HOURS"; + case STATUS_INVALID_WORKSTATION: + return (PUCHAR)"STATUS_INVALID_WORKSTATION"; + case STATUS_PASSWORD_EXPIRED: + return (PUCHAR)"STATUS_PASSWORD_EXPIRED"; + case STATUS_ACCOUNT_DISABLED: + return (PUCHAR)"STATUS_ACCOUNT_DISABLED"; + case STATUS_NONE_MAPPED: + return (PUCHAR)"STATUS_NONE_MAPPED"; + case STATUS_TOO_MANY_LUIDS_REQUESTED: + return (PUCHAR)"STATUS_TOO_MANY_LUIDS_REQUESTED"; + case STATUS_LUIDS_EXHAUSTED: + return (PUCHAR)"STATUS_LUIDS_EXHAUSTED"; + case STATUS_INVALID_SUB_AUTHORITY: + return (PUCHAR)"STATUS_INVALID_SUB_AUTHORITY"; + case STATUS_INVALID_ACL: + return (PUCHAR)"STATUS_INVALID_ACL"; + case STATUS_INVALID_SID: + return (PUCHAR)"STATUS_INVALID_SID"; + case STATUS_INVALID_SECURITY_DESCR: + return (PUCHAR)"STATUS_INVALID_SECURITY_DESCR"; + case STATUS_PROCEDURE_NOT_FOUND: + return (PUCHAR)"STATUS_PROCEDURE_NOT_FOUND"; + case STATUS_INVALID_IMAGE_FORMAT: + return (PUCHAR)"STATUS_INVALID_IMAGE_FORMAT"; + case STATUS_NO_TOKEN: + return (PUCHAR)"STATUS_NO_TOKEN"; + case STATUS_BAD_INHERITANCE_ACL: + return (PUCHAR)"STATUS_BAD_INHERITANCE_ACL"; + case STATUS_RANGE_NOT_LOCKED: + return (PUCHAR)"STATUS_RANGE_NOT_LOCKED"; + case STATUS_DISK_FULL: + return (PUCHAR)"STATUS_DISK_FULL"; + case STATUS_SERVER_DISABLED: + return (PUCHAR)"STATUS_SERVER_DISABLED"; + case STATUS_SERVER_NOT_DISABLED: + return (PUCHAR)"STATUS_SERVER_NOT_DISABLED"; + case STATUS_TOO_MANY_GUIDS_REQUESTED: + return (PUCHAR)"STATUS_TOO_MANY_GUIDS_REQUESTED"; + case STATUS_GUIDS_EXHAUSTED: + return (PUCHAR)"STATUS_GUIDS_EXHAUSTED"; + case STATUS_INVALID_ID_AUTHORITY: + return (PUCHAR)"STATUS_INVALID_ID_AUTHORITY"; + case STATUS_AGENTS_EXHAUSTED: + return (PUCHAR)"STATUS_AGENTS_EXHAUSTED"; + case STATUS_INVALID_VOLUME_LABEL: + return (PUCHAR)"STATUS_INVALID_VOLUME_LABEL"; + case STATUS_SECTION_NOT_EXTENDED: + return (PUCHAR)"STATUS_SECTION_NOT_EXTENDED"; + case STATUS_NOT_MAPPED_DATA: + return (PUCHAR)"STATUS_NOT_MAPPED_DATA"; + case STATUS_RESOURCE_DATA_NOT_FOUND: + return (PUCHAR)"STATUS_RESOURCE_DATA_NOT_FOUND"; + case STATUS_RESOURCE_TYPE_NOT_FOUND: + return (PUCHAR)"STATUS_RESOURCE_TYPE_NOT_FOUND"; + case STATUS_RESOURCE_NAME_NOT_FOUND: + return (PUCHAR)"STATUS_RESOURCE_NAME_NOT_FOUND"; + case STATUS_ARRAY_BOUNDS_EXCEEDED: + return (PUCHAR)"STATUS_ARRAY_BOUNDS_EXCEEDED"; + case STATUS_FLOAT_DENORMAL_OPERAND: + return (PUCHAR)"STATUS_FLOAT_DENORMAL_OPERAND"; + case STATUS_FLOAT_DIVIDE_BY_ZERO: + return (PUCHAR)"STATUS_FLOAT_DIVIDE_BY_ZERO"; + case STATUS_FLOAT_INEXACT_RESULT: + return (PUCHAR)"STATUS_FLOAT_INEXACT_RESULT"; + case STATUS_FLOAT_INVALID_OPERATION: + return (PUCHAR)"STATUS_FLOAT_INVALID_OPERATION"; + case STATUS_FLOAT_OVERFLOW: + return (PUCHAR)"STATUS_FLOAT_OVERFLOW"; + case STATUS_FLOAT_STACK_CHECK: + return (PUCHAR)"STATUS_FLOAT_STACK_CHECK"; + case STATUS_FLOAT_UNDERFLOW: + return (PUCHAR)"STATUS_FLOAT_UNDERFLOW"; + case STATUS_INTEGER_DIVIDE_BY_ZERO: + return (PUCHAR)"STATUS_INTEGER_DIVIDE_BY_ZERO"; + case STATUS_INTEGER_OVERFLOW: + return (PUCHAR)"STATUS_INTEGER_OVERFLOW"; + case STATUS_PRIVILEGED_INSTRUCTION: + return (PUCHAR)"STATUS_PRIVILEGED_INSTRUCTION"; + case STATUS_TOO_MANY_PAGING_FILES: + return (PUCHAR)"STATUS_TOO_MANY_PAGING_FILES"; + case STATUS_FILE_INVALID: + return (PUCHAR)"STATUS_FILE_INVALID"; + case STATUS_ALLOTTED_SPACE_EXCEEDED: + return (PUCHAR)"STATUS_ALLOTTED_SPACE_EXCEEDED"; + case STATUS_INSUFFICIENT_RESOURCES: + return (PUCHAR)"STATUS_INSUFFICIENT_RESOURCES"; + case STATUS_DFS_EXIT_PATH_FOUND: + return (PUCHAR)"STATUS_DFS_EXIT_PATH_FOUND"; + case STATUS_DEVICE_DATA_ERROR: + return (PUCHAR)"STATUS_DEVICE_DATA_ERROR"; + case STATUS_DEVICE_NOT_CONNECTED: + return (PUCHAR)"STATUS_DEVICE_NOT_CONNECTED"; + case STATUS_DEVICE_POWER_FAILURE: + return (PUCHAR)"STATUS_DEVICE_POWER_FAILURE"; + case STATUS_FREE_VM_NOT_AT_BASE: + return (PUCHAR)"STATUS_FREE_VM_NOT_AT_BASE"; + case STATUS_MEMORY_NOT_ALLOCATED: + return (PUCHAR)"STATUS_MEMORY_NOT_ALLOCATED"; + case STATUS_WORKING_SET_QUOTA: + return (PUCHAR)"STATUS_WORKING_SET_QUOTA"; + case STATUS_MEDIA_WRITE_PROTECTED: + return (PUCHAR)"STATUS_MEDIA_WRITE_PROTECTED"; + case STATUS_DEVICE_NOT_READY: + return (PUCHAR)"STATUS_DEVICE_NOT_READY"; + case STATUS_INVALID_GROUP_ATTRIBUTES: + return (PUCHAR)"STATUS_INVALID_GROUP_ATTRIBUTES"; + case STATUS_BAD_IMPERSONATION_LEVEL: + return (PUCHAR)"STATUS_BAD_IMPERSONATION_LEVEL"; + case STATUS_CANT_OPEN_ANONYMOUS: + return (PUCHAR)"STATUS_CANT_OPEN_ANONYMOUS"; + case STATUS_BAD_VALIDATION_CLASS: + return (PUCHAR)"STATUS_BAD_VALIDATION_CLASS"; + case STATUS_BAD_TOKEN_TYPE: + return (PUCHAR)"STATUS_BAD_TOKEN_TYPE"; + case STATUS_BAD_MASTER_BOOT_RECORD: + return (PUCHAR)"STATUS_BAD_MASTER_BOOT_RECORD"; + case STATUS_INSTRUCTION_MISALIGNMENT: + return (PUCHAR)"STATUS_INSTRUCTION_MISALIGNMENT"; + case STATUS_INSTANCE_NOT_AVAILABLE: + return (PUCHAR)"STATUS_INSTANCE_NOT_AVAILABLE"; + case STATUS_PIPE_NOT_AVAILABLE: + return (PUCHAR)"STATUS_PIPE_NOT_AVAILABLE"; + case STATUS_INVALID_PIPE_STATE: + return (PUCHAR)"STATUS_INVALID_PIPE_STATE"; + case STATUS_PIPE_BUSY: + return (PUCHAR)"STATUS_PIPE_BUSY"; + case STATUS_ILLEGAL_FUNCTION: + return (PUCHAR)"STATUS_ILLEGAL_FUNCTION"; + case STATUS_PIPE_DISCONNECTED: + return (PUCHAR)"STATUS_PIPE_DISCONNECTED"; + case STATUS_PIPE_CLOSING: + return (PUCHAR)"STATUS_PIPE_CLOSING"; + case STATUS_PIPE_CONNECTED: + return (PUCHAR)"STATUS_PIPE_CONNECTED"; + case STATUS_PIPE_LISTENING: + return (PUCHAR)"STATUS_PIPE_LISTENING"; + case STATUS_INVALID_READ_MODE: + return (PUCHAR)"STATUS_INVALID_READ_MODE"; + case STATUS_IO_TIMEOUT: + return (PUCHAR)"STATUS_IO_TIMEOUT"; + case STATUS_FILE_FORCED_CLOSED: + return (PUCHAR)"STATUS_FILE_FORCED_CLOSED"; + case STATUS_PROFILING_NOT_STARTED: + return (PUCHAR)"STATUS_PROFILING_NOT_STARTED"; + case STATUS_PROFILING_NOT_STOPPED: + return (PUCHAR)"STATUS_PROFILING_NOT_STOPPED"; + case STATUS_COULD_NOT_INTERPRET: + return (PUCHAR)"STATUS_COULD_NOT_INTERPRET"; + case STATUS_FILE_IS_A_DIRECTORY: + return (PUCHAR)"STATUS_FILE_IS_A_DIRECTORY"; + case STATUS_NOT_SUPPORTED: + return (PUCHAR)"STATUS_NOT_SUPPORTED"; + case STATUS_REMOTE_NOT_LISTENING: + return (PUCHAR)"STATUS_REMOTE_NOT_LISTENING"; + case STATUS_DUPLICATE_NAME: + return (PUCHAR)"STATUS_DUPLICATE_NAME"; + case STATUS_BAD_NETWORK_PATH: + return (PUCHAR)"STATUS_BAD_NETWORK_PATH"; + case STATUS_NETWORK_BUSY: + return (PUCHAR)"STATUS_NETWORK_BUSY"; + case STATUS_DEVICE_DOES_NOT_EXIST: + return (PUCHAR)"STATUS_DEVICE_DOES_NOT_EXIST"; + case STATUS_TOO_MANY_COMMANDS: + return (PUCHAR)"STATUS_TOO_MANY_COMMANDS"; + case STATUS_ADAPTER_HARDWARE_ERROR: + return (PUCHAR)"STATUS_ADAPTER_HARDWARE_ERROR"; + case STATUS_INVALID_NETWORK_RESPONSE: + return (PUCHAR)"STATUS_INVALID_NETWORK_RESPONSE"; + case STATUS_UNEXPECTED_NETWORK_ERROR: + return (PUCHAR)"STATUS_UNEXPECTED_NETWORK_ERROR"; + case STATUS_BAD_REMOTE_ADAPTER: + return (PUCHAR)"STATUS_BAD_REMOTE_ADAPTER"; + case STATUS_PRINT_QUEUE_FULL: + return (PUCHAR)"STATUS_PRINT_QUEUE_FULL"; + case STATUS_NO_SPOOL_SPACE: + return (PUCHAR)"STATUS_NO_SPOOL_SPACE"; + case STATUS_PRINT_CANCELLED: + return (PUCHAR)"STATUS_PRINT_CANCELLED"; + case STATUS_NETWORK_NAME_DELETED: + return (PUCHAR)"STATUS_NETWORK_NAME_DELETED"; + case STATUS_NETWORK_ACCESS_DENIED: + return (PUCHAR)"STATUS_NETWORK_ACCESS_DENIED"; + case STATUS_BAD_DEVICE_TYPE: + return (PUCHAR)"STATUS_BAD_DEVICE_TYPE"; + case STATUS_BAD_NETWORK_NAME: + return (PUCHAR)"STATUS_BAD_NETWORK_NAME"; + case STATUS_TOO_MANY_NAMES: + return (PUCHAR)"STATUS_TOO_MANY_NAMES"; + case STATUS_TOO_MANY_SESSIONS: + return (PUCHAR)"STATUS_TOO_MANY_SESSIONS"; + case STATUS_SHARING_PAUSED: + return (PUCHAR)"STATUS_SHARING_PAUSED"; + case STATUS_REQUEST_NOT_ACCEPTED: + return (PUCHAR)"STATUS_REQUEST_NOT_ACCEPTED"; + case STATUS_REDIRECTOR_PAUSED: + return (PUCHAR)"STATUS_REDIRECTOR_PAUSED"; + case STATUS_NET_WRITE_FAULT: + return (PUCHAR)"STATUS_NET_WRITE_FAULT"; + case STATUS_PROFILING_AT_LIMIT: + return (PUCHAR)"STATUS_PROFILING_AT_LIMIT"; + case STATUS_NOT_SAME_DEVICE: + return (PUCHAR)"STATUS_NOT_SAME_DEVICE"; + case STATUS_FILE_RENAMED: + return (PUCHAR)"STATUS_FILE_RENAMED"; + case STATUS_VIRTUAL_CIRCUIT_CLOSED: + return (PUCHAR)"STATUS_VIRTUAL_CIRCUIT_CLOSED"; + case STATUS_NO_SECURITY_ON_OBJECT: + return (PUCHAR)"STATUS_NO_SECURITY_ON_OBJECT"; + case STATUS_CANT_WAIT: + return (PUCHAR)"STATUS_CANT_WAIT"; + case STATUS_PIPE_EMPTY: + return (PUCHAR)"STATUS_PIPE_EMPTY"; + case STATUS_CANT_ACCESS_DOMAIN_INFO: + return (PUCHAR)"STATUS_CANT_ACCESS_DOMAIN_INFO"; + case STATUS_CANT_TERMINATE_SELF: + return (PUCHAR)"STATUS_CANT_TERMINATE_SELF"; + case STATUS_INVALID_SERVER_STATE: + return (PUCHAR)"STATUS_INVALID_SERVER_STATE"; + case STATUS_INVALID_DOMAIN_STATE: + return (PUCHAR)"STATUS_INVALID_DOMAIN_STATE"; + case STATUS_INVALID_DOMAIN_ROLE: + return (PUCHAR)"STATUS_INVALID_DOMAIN_ROLE"; + case STATUS_NO_SUCH_DOMAIN: + return (PUCHAR)"STATUS_NO_SUCH_DOMAIN"; + case STATUS_DOMAIN_EXISTS: + return (PUCHAR)"STATUS_DOMAIN_EXISTS"; + case STATUS_DOMAIN_LIMIT_EXCEEDED: + return (PUCHAR)"STATUS_DOMAIN_LIMIT_EXCEEDED"; + case STATUS_OPLOCK_NOT_GRANTED: + return (PUCHAR)"STATUS_OPLOCK_NOT_GRANTED"; + case STATUS_INVALID_OPLOCK_PROTOCOL: + return (PUCHAR)"STATUS_INVALID_OPLOCK_PROTOCOL"; + case STATUS_INTERNAL_DB_CORRUPTION: + return (PUCHAR)"STATUS_INTERNAL_DB_CORRUPTION"; + case STATUS_INTERNAL_ERROR: + return (PUCHAR)"STATUS_INTERNAL_ERROR"; + case STATUS_GENERIC_NOT_MAPPED: + return (PUCHAR)"STATUS_GENERIC_NOT_MAPPED"; + case STATUS_BAD_DESCRIPTOR_FORMAT: + return (PUCHAR)"STATUS_BAD_DESCRIPTOR_FORMAT"; + case STATUS_INVALID_USER_BUFFER: + return (PUCHAR)"STATUS_INVALID_USER_BUFFER"; + case STATUS_UNEXPECTED_IO_ERROR: + return (PUCHAR)"STATUS_UNEXPECTED_IO_ERROR"; + case STATUS_UNEXPECTED_MM_CREATE_ERR: + return (PUCHAR)"STATUS_UNEXPECTED_MM_CREATE_ERR"; + case STATUS_UNEXPECTED_MM_MAP_ERROR: + return (PUCHAR)"STATUS_UNEXPECTED_MM_MAP_ERROR"; + case STATUS_UNEXPECTED_MM_EXTEND_ERR: + return (PUCHAR)"STATUS_UNEXPECTED_MM_EXTEND_ERR"; + case STATUS_NOT_LOGON_PROCESS: + return (PUCHAR)"STATUS_NOT_LOGON_PROCESS"; + case STATUS_LOGON_SESSION_EXISTS: + return (PUCHAR)"STATUS_LOGON_SESSION_EXISTS"; + case STATUS_INVALID_PARAMETER_1: + return (PUCHAR)"STATUS_INVALID_PARAMETER_1"; + case STATUS_INVALID_PARAMETER_2: + return (PUCHAR)"STATUS_INVALID_PARAMETER_2"; + case STATUS_INVALID_PARAMETER_3: + return (PUCHAR)"STATUS_INVALID_PARAMETER_3"; + case STATUS_INVALID_PARAMETER_4: + return (PUCHAR)"STATUS_INVALID_PARAMETER_4"; + case STATUS_INVALID_PARAMETER_5: + return (PUCHAR)"STATUS_INVALID_PARAMETER_5"; + case STATUS_INVALID_PARAMETER_6: + return (PUCHAR)"STATUS_INVALID_PARAMETER_6"; + case STATUS_INVALID_PARAMETER_7: + return (PUCHAR)"STATUS_INVALID_PARAMETER_7"; + case STATUS_INVALID_PARAMETER_8: + return (PUCHAR)"STATUS_INVALID_PARAMETER_8"; + case STATUS_INVALID_PARAMETER_9: + return (PUCHAR)"STATUS_INVALID_PARAMETER_9"; + case STATUS_INVALID_PARAMETER_10: + return (PUCHAR)"STATUS_INVALID_PARAMETER_10"; + case STATUS_INVALID_PARAMETER_11: + return (PUCHAR)"STATUS_INVALID_PARAMETER_11"; + case STATUS_INVALID_PARAMETER_12: + return (PUCHAR)"STATUS_INVALID_PARAMETER_12"; + case STATUS_REDIRECTOR_NOT_STARTED: + return (PUCHAR)"STATUS_REDIRECTOR_NOT_STARTED"; + case STATUS_REDIRECTOR_STARTED: + return (PUCHAR)"STATUS_REDIRECTOR_STARTED"; + case STATUS_STACK_OVERFLOW: + return (PUCHAR)"STATUS_STACK_OVERFLOW"; + case STATUS_NO_SUCH_PACKAGE: + return (PUCHAR)"STATUS_NO_SUCH_PACKAGE"; + case STATUS_BAD_FUNCTION_TABLE: + return (PUCHAR)"STATUS_BAD_FUNCTION_TABLE"; + case STATUS_VARIABLE_NOT_FOUND: + return (PUCHAR)"STATUS_VARIABLE_NOT_FOUND"; + case STATUS_DIRECTORY_NOT_EMPTY: + return (PUCHAR)"STATUS_DIRECTORY_NOT_EMPTY"; + case STATUS_FILE_CORRUPT_ERROR: + return (PUCHAR)"STATUS_FILE_CORRUPT_ERROR"; + case STATUS_NOT_A_DIRECTORY: + return (PUCHAR)"STATUS_NOT_A_DIRECTORY"; + case STATUS_BAD_LOGON_SESSION_STATE: + return (PUCHAR)"STATUS_BAD_LOGON_SESSION_STATE"; + case STATUS_LOGON_SESSION_COLLISION: + return (PUCHAR)"STATUS_LOGON_SESSION_COLLISION"; + case STATUS_NAME_TOO_LONG: + return (PUCHAR)"STATUS_NAME_TOO_LONG"; + case STATUS_FILES_OPEN: + return (PUCHAR)"STATUS_FILES_OPEN"; + case STATUS_CONNECTION_IN_USE: + return (PUCHAR)"STATUS_CONNECTION_IN_USE"; + case STATUS_MESSAGE_NOT_FOUND: + return (PUCHAR)"STATUS_MESSAGE_NOT_FOUND"; + case STATUS_PROCESS_IS_TERMINATING: + return (PUCHAR)"STATUS_PROCESS_IS_TERMINATING"; + case STATUS_INVALID_LOGON_TYPE: + return (PUCHAR)"STATUS_INVALID_LOGON_TYPE"; + case STATUS_NO_GUID_TRANSLATION: + return (PUCHAR)"STATUS_NO_GUID_TRANSLATION"; + case STATUS_CANNOT_IMPERSONATE: + return (PUCHAR)"STATUS_CANNOT_IMPERSONATE"; + case STATUS_IMAGE_ALREADY_LOADED: + return (PUCHAR)"STATUS_IMAGE_ALREADY_LOADED"; + case STATUS_ABIOS_NOT_PRESENT: + return (PUCHAR)"STATUS_ABIOS_NOT_PRESENT"; + case STATUS_ABIOS_LID_NOT_EXIST: + return (PUCHAR)"STATUS_ABIOS_LID_NOT_EXIST"; + case STATUS_ABIOS_LID_ALREADY_OWNED: + return (PUCHAR)"STATUS_ABIOS_LID_ALREADY_OWNED"; + case STATUS_ABIOS_NOT_LID_OWNER: + return (PUCHAR)"STATUS_ABIOS_NOT_LID_OWNER"; + case STATUS_ABIOS_INVALID_COMMAND: + return (PUCHAR)"STATUS_ABIOS_INVALID_COMMAND"; + case STATUS_ABIOS_INVALID_LID: + return (PUCHAR)"STATUS_ABIOS_INVALID_LID"; + case STATUS_ABIOS_SELECTOR_NOT_AVAILABLE: + return (PUCHAR)"STATUS_ABIOS_SELECTOR_NOT_AVAILABLE"; + case STATUS_ABIOS_INVALID_SELECTOR: + return (PUCHAR)"STATUS_ABIOS_INVALID_SELECTOR"; + case STATUS_NO_LDT: + return (PUCHAR)"STATUS_NO_LDT"; + case STATUS_INVALID_LDT_SIZE: + return (PUCHAR)"STATUS_INVALID_LDT_SIZE"; + case STATUS_INVALID_LDT_OFFSET: + return (PUCHAR)"STATUS_INVALID_LDT_OFFSET"; + case STATUS_INVALID_LDT_DESCRIPTOR: + return (PUCHAR)"STATUS_INVALID_LDT_DESCRIPTOR"; + case STATUS_INVALID_IMAGE_NE_FORMAT: + return (PUCHAR)"STATUS_INVALID_IMAGE_NE_FORMAT"; + case STATUS_RXACT_INVALID_STATE: + return (PUCHAR)"STATUS_RXACT_INVALID_STATE"; + case STATUS_RXACT_COMMIT_FAILURE: + return (PUCHAR)"STATUS_RXACT_COMMIT_FAILURE"; + case STATUS_MAPPED_FILE_SIZE_ZERO: + return (PUCHAR)"STATUS_MAPPED_FILE_SIZE_ZERO"; + case STATUS_TOO_MANY_OPENED_FILES: + return (PUCHAR)"STATUS_TOO_MANY_OPENED_FILES"; + case STATUS_CANCELLED: + return (PUCHAR)"STATUS_CANCELLED"; + case STATUS_CANNOT_DELETE: + return (PUCHAR)"STATUS_CANNOT_DELETE"; + case STATUS_INVALID_COMPUTER_NAME: + return (PUCHAR)"STATUS_INVALID_COMPUTER_NAME"; + case STATUS_FILE_DELETED: + return (PUCHAR)"STATUS_FILE_DELETED"; + case STATUS_SPECIAL_ACCOUNT: + return (PUCHAR)"STATUS_SPECIAL_ACCOUNT"; + case STATUS_SPECIAL_GROUP: + return (PUCHAR)"STATUS_SPECIAL_GROUP"; + case STATUS_SPECIAL_USER: + return (PUCHAR)"STATUS_SPECIAL_USER"; + case STATUS_MEMBERS_PRIMARY_GROUP: + return (PUCHAR)"STATUS_MEMBERS_PRIMARY_GROUP"; + case STATUS_FILE_CLOSED: + return (PUCHAR)"STATUS_FILE_CLOSED"; + case STATUS_TOO_MANY_THREADS: + return (PUCHAR)"STATUS_TOO_MANY_THREADS"; + case STATUS_THREAD_NOT_IN_PROCESS: + return (PUCHAR)"STATUS_THREAD_NOT_IN_PROCESS"; + case STATUS_TOKEN_ALREADY_IN_USE: + return (PUCHAR)"STATUS_TOKEN_ALREADY_IN_USE"; + case STATUS_PAGEFILE_QUOTA_EXCEEDED: + return (PUCHAR)"STATUS_PAGEFILE_QUOTA_EXCEEDED"; + case STATUS_COMMITMENT_LIMIT: + return (PUCHAR)"STATUS_COMMITMENT_LIMIT"; + case STATUS_INVALID_IMAGE_LE_FORMAT: + return (PUCHAR)"STATUS_INVALID_IMAGE_LE_FORMAT"; + case STATUS_INVALID_IMAGE_NOT_MZ: + return (PUCHAR)"STATUS_INVALID_IMAGE_NOT_MZ"; + case STATUS_INVALID_IMAGE_PROTECT: + return (PUCHAR)"STATUS_INVALID_IMAGE_PROTECT"; + case STATUS_INVALID_IMAGE_WIN_16: + return (PUCHAR)"STATUS_INVALID_IMAGE_WIN_16"; + case STATUS_LOGON_SERVER_CONFLICT: + return (PUCHAR)"STATUS_LOGON_SERVER_CONFLICT"; + case STATUS_TIME_DIFFERENCE_AT_DC: + return (PUCHAR)"STATUS_TIME_DIFFERENCE_AT_DC"; + case STATUS_SYNCHRONIZATION_REQUIRED: + return (PUCHAR)"STATUS_SYNCHRONIZATION_REQUIRED"; + case STATUS_DLL_NOT_FOUND: + return (PUCHAR)"STATUS_DLL_NOT_FOUND"; + case STATUS_OPEN_FAILED: + return (PUCHAR)"STATUS_OPEN_FAILED"; + case STATUS_IO_PRIVILEGE_FAILED: + return (PUCHAR)"STATUS_IO_PRIVILEGE_FAILED"; + case STATUS_ORDINAL_NOT_FOUND: + return (PUCHAR)"STATUS_ORDINAL_NOT_FOUND"; + case STATUS_ENTRYPOINT_NOT_FOUND: + return (PUCHAR)"STATUS_ENTRYPOINT_NOT_FOUND"; + case STATUS_CONTROL_C_EXIT: + return (PUCHAR)"STATUS_CONTROL_C_EXIT"; + case STATUS_LOCAL_DISCONNECT: + return (PUCHAR)"STATUS_LOCAL_DISCONNECT"; + case STATUS_REMOTE_DISCONNECT: + return (PUCHAR)"STATUS_REMOTE_DISCONNECT"; + case STATUS_REMOTE_RESOURCES: + return (PUCHAR)"STATUS_REMOTE_RESOURCES"; + case STATUS_LINK_FAILED: + return (PUCHAR)"STATUS_LINK_FAILED"; + case STATUS_LINK_TIMEOUT: + return (PUCHAR)"STATUS_LINK_TIMEOUT"; + case STATUS_INVALID_CONNECTION: + return (PUCHAR)"STATUS_INVALID_CONNECTION"; + case STATUS_INVALID_ADDRESS: + return (PUCHAR)"STATUS_INVALID_ADDRESS"; + case STATUS_DLL_INIT_FAILED: + return (PUCHAR)"STATUS_DLL_INIT_FAILED"; + case STATUS_MISSING_SYSTEMFILE: + return (PUCHAR)"STATUS_MISSING_SYSTEMFILE"; + case STATUS_UNHANDLED_EXCEPTION: + return (PUCHAR)"STATUS_UNHANDLED_EXCEPTION"; + case STATUS_APP_INIT_FAILURE: + return (PUCHAR)"STATUS_APP_INIT_FAILURE"; + case STATUS_PAGEFILE_CREATE_FAILED: + return (PUCHAR)"STATUS_PAGEFILE_CREATE_FAILED"; + case STATUS_NO_PAGEFILE: + return (PUCHAR)"STATUS_NO_PAGEFILE"; + case STATUS_INVALID_LEVEL: + return (PUCHAR)"STATUS_INVALID_LEVEL"; + case STATUS_WRONG_PASSWORD_CORE: + return (PUCHAR)"STATUS_WRONG_PASSWORD_CORE"; + case STATUS_ILLEGAL_FLOAT_CONTEXT: + return (PUCHAR)"STATUS_ILLEGAL_FLOAT_CONTEXT"; + case STATUS_PIPE_BROKEN: + return (PUCHAR)"STATUS_PIPE_BROKEN"; + case STATUS_REGISTRY_CORRUPT: + return (PUCHAR)"STATUS_REGISTRY_CORRUPT"; + case STATUS_REGISTRY_IO_FAILED: + return (PUCHAR)"STATUS_REGISTRY_IO_FAILED"; + case STATUS_NO_EVENT_PAIR: + return (PUCHAR)"STATUS_NO_EVENT_PAIR"; + case STATUS_UNRECOGNIZED_VOLUME: + return (PUCHAR)"STATUS_UNRECOGNIZED_VOLUME"; + case STATUS_SERIAL_NO_DEVICE_INITED: + return (PUCHAR)"STATUS_SERIAL_NO_DEVICE_INITED"; + case STATUS_NO_SUCH_ALIAS: + return (PUCHAR)"STATUS_NO_SUCH_ALIAS"; + case STATUS_MEMBER_NOT_IN_ALIAS: + return (PUCHAR)"STATUS_MEMBER_NOT_IN_ALIAS"; + case STATUS_MEMBER_IN_ALIAS: + return (PUCHAR)"STATUS_MEMBER_IN_ALIAS"; + case STATUS_ALIAS_EXISTS: + return (PUCHAR)"STATUS_ALIAS_EXISTS"; + case STATUS_LOGON_NOT_GRANTED: + return (PUCHAR)"STATUS_LOGON_NOT_GRANTED"; + case STATUS_TOO_MANY_SECRETS: + return (PUCHAR)"STATUS_TOO_MANY_SECRETS"; + case STATUS_SECRET_TOO_LONG: + return (PUCHAR)"STATUS_SECRET_TOO_LONG"; + case STATUS_INTERNAL_DB_ERROR: + return (PUCHAR)"STATUS_INTERNAL_DB_ERROR"; + case STATUS_FULLSCREEN_MODE: + return (PUCHAR)"STATUS_FULLSCREEN_MODE"; + case STATUS_TOO_MANY_CONTEXT_IDS: + return (PUCHAR)"STATUS_TOO_MANY_CONTEXT_IDS"; + case STATUS_LOGON_TYPE_NOT_GRANTED: + return (PUCHAR)"STATUS_LOGON_TYPE_NOT_GRANTED"; + case STATUS_NOT_REGISTRY_FILE: + return (PUCHAR)"STATUS_NOT_REGISTRY_FILE"; + case STATUS_NT_CROSS_ENCRYPTION_REQUIRED: + return (PUCHAR)"STATUS_NT_CROSS_ENCRYPTION_REQUIRED"; + case STATUS_DOMAIN_CTRLR_CONFIG_ERROR: + return (PUCHAR)"STATUS_DOMAIN_CTRLR_CONFIG_ERROR"; + case STATUS_FT_MISSING_MEMBER: + return (PUCHAR)"STATUS_FT_MISSING_MEMBER"; + case STATUS_ILL_FORMED_SERVICE_ENTRY: + return (PUCHAR)"STATUS_ILL_FORMED_SERVICE_ENTRY"; + case STATUS_ILLEGAL_CHARACTER: + return (PUCHAR)"STATUS_ILLEGAL_CHARACTER"; + case STATUS_UNMAPPABLE_CHARACTER: + return (PUCHAR)"STATUS_UNMAPPABLE_CHARACTER"; + case STATUS_UNDEFINED_CHARACTER: + return (PUCHAR)"STATUS_UNDEFINED_CHARACTER"; + case STATUS_FLOPPY_VOLUME: + return (PUCHAR)"STATUS_FLOPPY_VOLUME"; + case STATUS_FLOPPY_ID_MARK_NOT_FOUND: + return (PUCHAR)"STATUS_FLOPPY_ID_MARK_NOT_FOUND"; + case STATUS_FLOPPY_WRONG_CYLINDER: + return (PUCHAR)"STATUS_FLOPPY_WRONG_CYLINDER"; + case STATUS_FLOPPY_UNKNOWN_ERROR: + return (PUCHAR)"STATUS_FLOPPY_UNKNOWN_ERROR"; + case STATUS_FLOPPY_BAD_REGISTERS: + return (PUCHAR)"STATUS_FLOPPY_BAD_REGISTERS"; + case STATUS_DISK_RECALIBRATE_FAILED: + return (PUCHAR)"STATUS_DISK_RECALIBRATE_FAILED"; + case STATUS_DISK_OPERATION_FAILED: + return (PUCHAR)"STATUS_DISK_OPERATION_FAILED"; + case STATUS_DISK_RESET_FAILED: + return (PUCHAR)"STATUS_DISK_RESET_FAILED"; + case STATUS_SHARED_IRQ_BUSY: + return (PUCHAR)"STATUS_SHARED_IRQ_BUSY"; + case STATUS_FT_ORPHANING: + return (PUCHAR)"STATUS_FT_ORPHANING"; + case STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT: + return (PUCHAR)"STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT"; + case STATUS_PARTITION_FAILURE: + return (PUCHAR)"STATUS_PARTITION_FAILURE"; + case STATUS_INVALID_BLOCK_LENGTH: + return (PUCHAR)"STATUS_INVALID_BLOCK_LENGTH"; + case STATUS_DEVICE_NOT_PARTITIONED: + return (PUCHAR)"STATUS_DEVICE_NOT_PARTITIONED"; + case STATUS_UNABLE_TO_LOCK_MEDIA: + return (PUCHAR)"STATUS_UNABLE_TO_LOCK_MEDIA"; + case STATUS_UNABLE_TO_UNLOAD_MEDIA: + return (PUCHAR)"STATUS_UNABLE_TO_UNLOAD_MEDIA"; + case STATUS_EOM_OVERFLOW: + return (PUCHAR)"STATUS_EOM_OVERFLOW"; + case STATUS_NO_MEDIA: + return (PUCHAR)"STATUS_NO_MEDIA"; + case STATUS_NO_SUCH_MEMBER: + return (PUCHAR)"STATUS_NO_SUCH_MEMBER"; + case STATUS_INVALID_MEMBER: + return (PUCHAR)"STATUS_INVALID_MEMBER"; + case STATUS_KEY_DELETED: + return (PUCHAR)"STATUS_KEY_DELETED"; + case STATUS_NO_LOG_SPACE: + return (PUCHAR)"STATUS_NO_LOG_SPACE"; + case STATUS_TOO_MANY_SIDS: + return (PUCHAR)"STATUS_TOO_MANY_SIDS"; + case STATUS_LM_CROSS_ENCRYPTION_REQUIRED: + return (PUCHAR)"STATUS_LM_CROSS_ENCRYPTION_REQUIRED"; + case STATUS_KEY_HAS_CHILDREN: + return (PUCHAR)"STATUS_KEY_HAS_CHILDREN"; + case STATUS_CHILD_MUST_BE_VOLATILE: + return (PUCHAR)"STATUS_CHILD_MUST_BE_VOLATILE"; + case STATUS_DEVICE_CONFIGURATION_ERROR: + return (PUCHAR)"STATUS_DEVICE_CONFIGURATION_ERROR"; + case STATUS_DRIVER_INTERNAL_ERROR: + return (PUCHAR)"STATUS_DRIVER_INTERNAL_ERROR"; + case STATUS_INVALID_DEVICE_STATE: + return (PUCHAR)"STATUS_INVALID_DEVICE_STATE"; + case STATUS_IO_DEVICE_ERROR: + return (PUCHAR)"STATUS_IO_DEVICE_ERROR"; + case STATUS_DEVICE_PROTOCOL_ERROR: + return (PUCHAR)"STATUS_DEVICE_PROTOCOL_ERROR"; + case STATUS_BACKUP_CONTROLLER: + return (PUCHAR)"STATUS_BACKUP_CONTROLLER"; + case STATUS_LOG_FILE_FULL: + return (PUCHAR)"STATUS_LOG_FILE_FULL"; + case STATUS_TOO_LATE: + return (PUCHAR)"STATUS_TOO_LATE"; + case STATUS_NO_TRUST_LSA_SECRET: + return (PUCHAR)"STATUS_NO_TRUST_LSA_SECRET"; + case STATUS_NO_TRUST_SAM_ACCOUNT: + return (PUCHAR)"STATUS_NO_TRUST_SAM_ACCOUNT"; + case STATUS_TRUSTED_DOMAIN_FAILURE: + return (PUCHAR)"STATUS_TRUSTED_DOMAIN_FAILURE"; + case STATUS_TRUSTED_RELATIONSHIP_FAILURE: + return (PUCHAR)"STATUS_TRUSTED_RELATIONSHIP_FAILURE"; + case STATUS_EVENTLOG_FILE_CORRUPT: + return (PUCHAR)"STATUS_EVENTLOG_FILE_CORRUPT"; + case STATUS_EVENTLOG_CANT_START: + return (PUCHAR)"STATUS_EVENTLOG_CANT_START"; + case STATUS_TRUST_FAILURE: + return (PUCHAR)"STATUS_TRUST_FAILURE"; + case STATUS_MUTANT_LIMIT_EXCEEDED: + return (PUCHAR)"STATUS_MUTANT_LIMIT_EXCEEDED"; + case STATUS_NETLOGON_NOT_STARTED: + return (PUCHAR)"STATUS_NETLOGON_NOT_STARTED"; + case STATUS_ACCOUNT_EXPIRED: + return (PUCHAR)"STATUS_ACCOUNT_EXPIRED"; + case STATUS_POSSIBLE_DEADLOCK: + return (PUCHAR)"STATUS_POSSIBLE_DEADLOCK"; + case STATUS_NETWORK_CREDENTIAL_CONFLICT: + return (PUCHAR)"STATUS_NETWORK_CREDENTIAL_CONFLICT"; + case STATUS_REMOTE_SESSION_LIMIT: + return (PUCHAR)"STATUS_REMOTE_SESSION_LIMIT"; + case STATUS_EVENTLOG_FILE_CHANGED: + return (PUCHAR)"STATUS_EVENTLOG_FILE_CHANGED"; + case STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT: + return (PUCHAR)"STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT"; + case STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT: + return (PUCHAR)"STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT"; + case STATUS_NOLOGON_SERVER_TRUST_ACCOUNT: + return (PUCHAR)"STATUS_NOLOGON_SERVER_TRUST_ACCOUNT"; + case STATUS_DOMAIN_TRUST_INCONSISTENT: + return (PUCHAR)"STATUS_DOMAIN_TRUST_INCONSISTENT"; + case STATUS_FS_DRIVER_REQUIRED: + return (PUCHAR)"STATUS_FS_DRIVER_REQUIRED"; + case STATUS_NO_USER_SESSION_KEY: + return (PUCHAR)"STATUS_NO_USER_SESSION_KEY"; + case STATUS_USER_SESSION_DELETED: + return (PUCHAR)"STATUS_USER_SESSION_DELETED"; + case STATUS_RESOURCE_LANG_NOT_FOUND: + return (PUCHAR)"STATUS_RESOURCE_LANG_NOT_FOUND"; + case STATUS_INSUFF_SERVER_RESOURCES: + return (PUCHAR)"STATUS_INSUFF_SERVER_RESOURCES"; + case STATUS_INVALID_BUFFER_SIZE: + return (PUCHAR)"STATUS_INVALID_BUFFER_SIZE"; + case STATUS_INVALID_ADDRESS_COMPONENT: + return (PUCHAR)"STATUS_INVALID_ADDRESS_COMPONENT"; + case STATUS_INVALID_ADDRESS_WILDCARD: + return (PUCHAR)"STATUS_INVALID_ADDRESS_WILDCARD"; + case STATUS_TOO_MANY_ADDRESSES: + return (PUCHAR)"STATUS_TOO_MANY_ADDRESSES"; + case STATUS_ADDRESS_ALREADY_EXISTS: + return (PUCHAR)"STATUS_ADDRESS_ALREADY_EXISTS"; + case STATUS_ADDRESS_CLOSED: + return (PUCHAR)"STATUS_ADDRESS_CLOSED"; + case STATUS_CONNECTION_DISCONNECTED: + return (PUCHAR)"STATUS_CONNECTION_DISCONNECTED"; + case STATUS_CONNECTION_RESET: + return (PUCHAR)"STATUS_CONNECTION_RESET"; + case STATUS_TOO_MANY_NODES: + return (PUCHAR)"STATUS_TOO_MANY_NODES"; + case STATUS_TRANSACTION_ABORTED: + return (PUCHAR)"STATUS_TRANSACTION_ABORTED"; + case STATUS_TRANSACTION_TIMED_OUT: + return (PUCHAR)"STATUS_TRANSACTION_TIMED_OUT"; + case STATUS_TRANSACTION_NO_RELEASE: + return (PUCHAR)"STATUS_TRANSACTION_NO_RELEASE"; + case STATUS_TRANSACTION_NO_MATCH: + return (PUCHAR)"STATUS_TRANSACTION_NO_MATCH"; + case STATUS_TRANSACTION_RESPONDED: + return (PUCHAR)"STATUS_TRANSACTION_RESPONDED"; + case STATUS_TRANSACTION_INVALID_ID: + return (PUCHAR)"STATUS_TRANSACTION_INVALID_ID"; + case STATUS_TRANSACTION_INVALID_TYPE: + return (PUCHAR)"STATUS_TRANSACTION_INVALID_TYPE"; + case STATUS_NOT_SERVER_SESSION: + return (PUCHAR)"STATUS_NOT_SERVER_SESSION"; + case STATUS_NOT_CLIENT_SESSION: + return (PUCHAR)"STATUS_NOT_CLIENT_SESSION"; + case STATUS_CANNOT_LOAD_REGISTRY_FILE: + return (PUCHAR)"STATUS_CANNOT_LOAD_REGISTRY_FILE"; + case STATUS_DEBUG_ATTACH_FAILED: + return (PUCHAR)"STATUS_DEBUG_ATTACH_FAILED"; + case STATUS_SYSTEM_PROCESS_TERMINATED: + return (PUCHAR)"STATUS_SYSTEM_PROCESS_TERMINATED"; + case STATUS_DATA_NOT_ACCEPTED: + return (PUCHAR)"STATUS_DATA_NOT_ACCEPTED"; + case STATUS_NO_BROWSER_SERVERS_FOUND: + return (PUCHAR)"STATUS_NO_BROWSER_SERVERS_FOUND"; + case STATUS_VDM_HARD_ERROR: + return (PUCHAR)"STATUS_VDM_HARD_ERROR"; + case STATUS_DRIVER_CANCEL_TIMEOUT: + return (PUCHAR)"STATUS_DRIVER_CANCEL_TIMEOUT"; + case STATUS_REPLY_MESSAGE_MISMATCH: + return (PUCHAR)"STATUS_REPLY_MESSAGE_MISMATCH"; + case STATUS_MAPPED_ALIGNMENT: + return (PUCHAR)"STATUS_MAPPED_ALIGNMENT"; + case STATUS_IMAGE_CHECKSUM_MISMATCH: + return (PUCHAR)"STATUS_IMAGE_CHECKSUM_MISMATCH"; + case STATUS_LOST_WRITEBEHIND_DATA: + return (PUCHAR)"STATUS_LOST_WRITEBEHIND_DATA"; + case STATUS_CLIENT_SERVER_PARAMETERS_INVALID: + return (PUCHAR)"STATUS_CLIENT_SERVER_PARAMETERS_INVALID"; + case STATUS_PASSWORD_MUST_CHANGE: + return (PUCHAR)"STATUS_PASSWORD_MUST_CHANGE"; + case STATUS_NOT_FOUND: + return (PUCHAR)"STATUS_NOT_FOUND"; + case STATUS_NOT_TINY_STREAM: + return (PUCHAR)"STATUS_NOT_TINY_STREAM"; + case STATUS_RECOVERY_FAILURE: + return (PUCHAR)"STATUS_RECOVERY_FAILURE"; + case STATUS_STACK_OVERFLOW_READ: + return (PUCHAR)"STATUS_STACK_OVERFLOW_READ"; + case STATUS_FAIL_CHECK: + return (PUCHAR)"STATUS_FAIL_CHECK"; + case STATUS_DUPLICATE_OBJECTID: + return (PUCHAR)"STATUS_DUPLICATE_OBJECTID"; + case STATUS_OBJECTID_EXISTS: + return (PUCHAR)"STATUS_OBJECTID_EXISTS"; + case STATUS_CONVERT_TO_LARGE: + return (PUCHAR)"STATUS_CONVERT_TO_LARGE"; + case STATUS_RETRY: + return (PUCHAR)"STATUS_RETRY"; + case STATUS_FOUND_OUT_OF_SCOPE: + return (PUCHAR)"STATUS_FOUND_OUT_OF_SCOPE"; + case STATUS_ALLOCATE_BUCKET: + return (PUCHAR)"STATUS_ALLOCATE_BUCKET"; + case STATUS_PROPSET_NOT_FOUND: + return (PUCHAR)"STATUS_PROPSET_NOT_FOUND"; + case STATUS_MARSHALL_OVERFLOW: + return (PUCHAR)"STATUS_MARSHALL_OVERFLOW"; + case STATUS_INVALID_VARIANT: + return (PUCHAR)"STATUS_INVALID_VARIANT"; + case STATUS_DOMAIN_CONTROLLER_NOT_FOUND: + return (PUCHAR)"STATUS_DOMAIN_CONTROLLER_NOT_FOUND"; + case STATUS_ACCOUNT_LOCKED_OUT: + return (PUCHAR)"STATUS_ACCOUNT_LOCKED_OUT"; + case STATUS_HANDLE_NOT_CLOSABLE: + return (PUCHAR)"STATUS_HANDLE_NOT_CLOSABLE"; + case STATUS_CONNECTION_REFUSED: + return (PUCHAR)"STATUS_CONNECTION_REFUSED"; + case STATUS_GRACEFUL_DISCONNECT: + return (PUCHAR)"STATUS_GRACEFUL_DISCONNECT"; + case STATUS_ADDRESS_ALREADY_ASSOCIATED: + return (PUCHAR)"STATUS_ADDRESS_ALREADY_ASSOCIATED"; + case STATUS_ADDRESS_NOT_ASSOCIATED: + return (PUCHAR)"STATUS_ADDRESS_NOT_ASSOCIATED"; + case STATUS_CONNECTION_INVALID: + return (PUCHAR)"STATUS_CONNECTION_INVALID"; + case STATUS_CONNECTION_ACTIVE: + return (PUCHAR)"STATUS_CONNECTION_ACTIVE"; + case STATUS_NETWORK_UNREACHABLE: + return (PUCHAR)"STATUS_NETWORK_UNREACHABLE"; + case STATUS_HOST_UNREACHABLE: + return (PUCHAR)"STATUS_HOST_UNREACHABLE"; + case STATUS_PROTOCOL_UNREACHABLE: + return (PUCHAR)"STATUS_PROTOCOL_UNREACHABLE"; + case STATUS_PORT_UNREACHABLE: + return (PUCHAR)"STATUS_PORT_UNREACHABLE"; + case STATUS_REQUEST_ABORTED: + return (PUCHAR)"STATUS_REQUEST_ABORTED"; + case STATUS_CONNECTION_ABORTED: + return (PUCHAR)"STATUS_CONNECTION_ABORTED"; + case STATUS_BAD_COMPRESSION_BUFFER: + return (PUCHAR)"STATUS_BAD_COMPRESSION_BUFFER"; + case STATUS_USER_MAPPED_FILE: + return (PUCHAR)"STATUS_USER_MAPPED_FILE"; + case STATUS_AUDIT_FAILED: + return (PUCHAR)"STATUS_AUDIT_FAILED"; + case STATUS_TIMER_RESOLUTION_NOT_SET: + return (PUCHAR)"STATUS_TIMER_RESOLUTION_NOT_SET"; + case STATUS_CONNECTION_COUNT_LIMIT: + return (PUCHAR)"STATUS_CONNECTION_COUNT_LIMIT"; + case STATUS_LOGIN_TIME_RESTRICTION: + return (PUCHAR)"STATUS_LOGIN_TIME_RESTRICTION"; + case STATUS_LOGIN_WKSTA_RESTRICTION: + return (PUCHAR)"STATUS_LOGIN_WKSTA_RESTRICTION"; + case STATUS_IMAGE_MP_UP_MISMATCH: + return (PUCHAR)"STATUS_IMAGE_MP_UP_MISMATCH"; + case STATUS_INSUFFICIENT_LOGON_INFO: + return (PUCHAR)"STATUS_INSUFFICIENT_LOGON_INFO"; + case STATUS_BAD_DLL_ENTRYPOINT: + return (PUCHAR)"STATUS_BAD_DLL_ENTRYPOINT"; + case STATUS_BAD_SERVICE_ENTRYPOINT: + return (PUCHAR)"STATUS_BAD_SERVICE_ENTRYPOINT"; + case STATUS_LPC_REPLY_LOST: + return (PUCHAR)"STATUS_LPC_REPLY_LOST"; + case STATUS_IP_ADDRESS_CONFLICT1: + return (PUCHAR)"STATUS_IP_ADDRESS_CONFLICT1"; + case STATUS_IP_ADDRESS_CONFLICT2: + return (PUCHAR)"STATUS_IP_ADDRESS_CONFLICT2"; + case STATUS_REGISTRY_QUOTA_LIMIT: + return (PUCHAR)"STATUS_REGISTRY_QUOTA_LIMIT"; + case STATUS_PATH_NOT_COVERED: + return (PUCHAR)"STATUS_PATH_NOT_COVERED"; + case STATUS_NO_CALLBACK_ACTIVE: + return (PUCHAR)"STATUS_NO_CALLBACK_ACTIVE"; + case STATUS_LICENSE_QUOTA_EXCEEDED: + return (PUCHAR)"STATUS_LICENSE_QUOTA_EXCEEDED"; + case STATUS_PWD_TOO_SHORT: + return (PUCHAR)"STATUS_PWD_TOO_SHORT"; + case STATUS_PWD_TOO_RECENT: + return (PUCHAR)"STATUS_PWD_TOO_RECENT"; + case STATUS_PWD_HISTORY_CONFLICT: + return (PUCHAR)"STATUS_PWD_HISTORY_CONFLICT"; + case STATUS_PLUGPLAY_NO_DEVICE: + return (PUCHAR)"STATUS_PLUGPLAY_NO_DEVICE"; + case STATUS_UNSUPPORTED_COMPRESSION: + return (PUCHAR)"STATUS_UNSUPPORTED_COMPRESSION"; + case STATUS_INVALID_HW_PROFILE: + return (PUCHAR)"STATUS_INVALID_HW_PROFILE"; + case STATUS_INVALID_PLUGPLAY_DEVICE_PATH: + return (PUCHAR)"STATUS_INVALID_PLUGPLAY_DEVICE_PATH"; + case STATUS_DRIVER_ORDINAL_NOT_FOUND: + return (PUCHAR)"STATUS_DRIVER_ORDINAL_NOT_FOUND"; + case STATUS_DRIVER_ENTRYPOINT_NOT_FOUND: + return (PUCHAR)"STATUS_DRIVER_ENTRYPOINT_NOT_FOUND"; + case STATUS_RESOURCE_NOT_OWNED: + return (PUCHAR)"STATUS_RESOURCE_NOT_OWNED"; + case STATUS_TOO_MANY_LINKS: + return (PUCHAR)"STATUS_TOO_MANY_LINKS"; + case STATUS_QUOTA_LIST_INCONSISTENT: + return (PUCHAR)"STATUS_QUOTA_LIST_INCONSISTENT"; + case STATUS_FILE_IS_OFFLINE: + return (PUCHAR)"STATUS_FILE_IS_OFFLINE"; + case STATUS_EVALUATION_EXPIRATION: + return (PUCHAR)"STATUS_EVALUATION_EXPIRATION"; + case STATUS_ILLEGAL_DLL_RELOCATION: + return (PUCHAR)"STATUS_ILLEGAL_DLL_RELOCATION"; + case STATUS_LICENSE_VIOLATION: + return (PUCHAR)"STATUS_LICENSE_VIOLATION"; + case STATUS_DLL_INIT_FAILED_LOGOFF: + return (PUCHAR)"STATUS_DLL_INIT_FAILED_LOGOFF"; + case STATUS_DRIVER_UNABLE_TO_LOAD: + return (PUCHAR)"STATUS_DRIVER_UNABLE_TO_LOAD"; + case STATUS_DFS_UNAVAILABLE: + return (PUCHAR)"STATUS_DFS_UNAVAILABLE"; + case STATUS_VOLUME_DISMOUNTED: + return (PUCHAR)"STATUS_VOLUME_DISMOUNTED"; + case STATUS_WX86_INTERNAL_ERROR: + return (PUCHAR)"STATUS_WX86_INTERNAL_ERROR"; + case STATUS_WX86_FLOAT_STACK_CHECK: + return (PUCHAR)"STATUS_WX86_FLOAT_STACK_CHECK"; + case STATUS_VALIDATE_CONTINUE: + return (PUCHAR)"STATUS_VALIDATE_CONTINUE"; + case STATUS_NO_MATCH: + return (PUCHAR)"STATUS_NO_MATCH"; + case STATUS_NO_MORE_MATCHES: + return (PUCHAR)"STATUS_NO_MORE_MATCHES"; + case STATUS_NOT_A_REPARSE_POINT: + return (PUCHAR)"STATUS_NOT_A_REPARSE_POINT"; + case STATUS_IO_REPARSE_TAG_INVALID: + return (PUCHAR)"STATUS_IO_REPARSE_TAG_INVALID"; + case STATUS_IO_REPARSE_TAG_MISMATCH: + return (PUCHAR)"STATUS_IO_REPARSE_TAG_MISMATCH"; + case STATUS_IO_REPARSE_DATA_INVALID: + return (PUCHAR)"STATUS_IO_REPARSE_DATA_INVALID"; + case STATUS_IO_REPARSE_TAG_NOT_HANDLED: + return (PUCHAR)"STATUS_IO_REPARSE_TAG_NOT_HANDLED"; + case STATUS_REPARSE_POINT_NOT_RESOLVED: + return (PUCHAR)"STATUS_REPARSE_POINT_NOT_RESOLVED"; + case STATUS_DIRECTORY_IS_A_REPARSE_POINT: + return (PUCHAR)"STATUS_DIRECTORY_IS_A_REPARSE_POINT"; + case STATUS_RANGE_LIST_CONFLICT: + return (PUCHAR)"STATUS_RANGE_LIST_CONFLICT"; + case STATUS_SOURCE_ELEMENT_EMPTY: + return (PUCHAR)"STATUS_SOURCE_ELEMENT_EMPTY"; + case STATUS_DESTINATION_ELEMENT_FULL: + return (PUCHAR)"STATUS_DESTINATION_ELEMENT_FULL"; + case STATUS_ILLEGAL_ELEMENT_ADDRESS: + return (PUCHAR)"STATUS_ILLEGAL_ELEMENT_ADDRESS"; + case STATUS_MAGAZINE_NOT_PRESENT: + return (PUCHAR)"STATUS_MAGAZINE_NOT_PRESENT"; + case STATUS_REINITIALIZATION_NEEDED: + return (PUCHAR)"STATUS_REINITIALIZATION_NEEDED"; + case STATUS_ENCRYPTION_FAILED: + return (PUCHAR)"STATUS_ENCRYPTION_FAILED"; + case STATUS_DECRYPTION_FAILED: + return (PUCHAR)"STATUS_DECRYPTION_FAILED"; + case STATUS_RANGE_NOT_FOUND: + return (PUCHAR)"STATUS_RANGE_NOT_FOUND"; + case STATUS_NO_RECOVERY_POLICY: + return (PUCHAR)"STATUS_NO_RECOVERY_POLICY"; + case STATUS_NO_EFS: + return (PUCHAR)"STATUS_NO_EFS"; + case STATUS_WRONG_EFS: + return (PUCHAR)"STATUS_WRONG_EFS"; + case STATUS_NO_USER_KEYS: + return (PUCHAR)"STATUS_NO_USER_KEYS"; + case STATUS_FILE_NOT_ENCRYPTED: + return (PUCHAR)"STATUS_FILE_NOT_ENCRYPTED"; + case STATUS_NOT_EXPORT_FORMAT: + return (PUCHAR)"STATUS_NOT_EXPORT_FORMAT"; + case STATUS_FILE_ENCRYPTED: + return (PUCHAR)"STATUS_FILE_ENCRYPTED"; + case STATUS_WMI_GUID_NOT_FOUND: + return (PUCHAR)"STATUS_WMI_GUID_NOT_FOUND"; + case STATUS_WMI_INSTANCE_NOT_FOUND: + return (PUCHAR)"STATUS_WMI_INSTANCE_NOT_FOUND"; + case STATUS_WMI_ITEMID_NOT_FOUND: + return (PUCHAR)"STATUS_WMI_ITEMID_NOT_FOUND"; + case STATUS_WMI_TRY_AGAIN: + return (PUCHAR)"STATUS_WMI_TRY_AGAIN"; + case STATUS_SHARED_POLICY: + return (PUCHAR)"STATUS_SHARED_POLICY"; + case STATUS_POLICY_OBJECT_NOT_FOUND: + return (PUCHAR)"STATUS_POLICY_OBJECT_NOT_FOUND"; + case STATUS_POLICY_ONLY_IN_DS: + return (PUCHAR)"STATUS_POLICY_ONLY_IN_DS"; + case STATUS_VOLUME_NOT_UPGRADED: + return (PUCHAR)"STATUS_VOLUME_NOT_UPGRADED"; + case STATUS_REMOTE_STORAGE_NOT_ACTIVE: + return (PUCHAR)"STATUS_REMOTE_STORAGE_NOT_ACTIVE"; + case STATUS_REMOTE_STORAGE_MEDIA_ERROR: + return (PUCHAR)"STATUS_REMOTE_STORAGE_MEDIA_ERROR"; + case STATUS_NO_TRACKING_SERVICE: + return (PUCHAR)"STATUS_NO_TRACKING_SERVICE"; + case STATUS_SERVER_SID_MISMATCH: + return (PUCHAR)"STATUS_SERVER_SID_MISMATCH"; + case STATUS_DS_NO_ATTRIBUTE_OR_VALUE: + return (PUCHAR)"STATUS_DS_NO_ATTRIBUTE_OR_VALUE"; + case STATUS_DS_INVALID_ATTRIBUTE_SYNTAX: + return (PUCHAR)"STATUS_DS_INVALID_ATTRIBUTE_SYNTAX"; + case STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED: + return (PUCHAR)"STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED"; + case STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS: + return (PUCHAR)"STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS"; + case STATUS_DS_BUSY: + return (PUCHAR)"STATUS_DS_BUSY"; + case STATUS_DS_UNAVAILABLE: + return (PUCHAR)"STATUS_DS_UNAVAILABLE"; + case STATUS_DS_NO_RIDS_ALLOCATED: + return (PUCHAR)"STATUS_DS_NO_RIDS_ALLOCATED"; + case STATUS_DS_NO_MORE_RIDS: + return (PUCHAR)"STATUS_DS_NO_MORE_RIDS"; + case STATUS_DS_INCORRECT_ROLE_OWNER: + return (PUCHAR)"STATUS_DS_INCORRECT_ROLE_OWNER"; + case STATUS_DS_RIDMGR_INIT_ERROR: + return (PUCHAR)"STATUS_DS_RIDMGR_INIT_ERROR"; + case STATUS_DS_OBJ_CLASS_VIOLATION: + return (PUCHAR)"STATUS_DS_OBJ_CLASS_VIOLATION"; + case STATUS_DS_CANT_ON_NON_LEAF: + return (PUCHAR)"STATUS_DS_CANT_ON_NON_LEAF"; + case STATUS_DS_CANT_ON_RDN: + return (PUCHAR)"STATUS_DS_CANT_ON_RDN"; + case STATUS_DS_CANT_MOD_OBJ_CLASS: + return (PUCHAR)"STATUS_DS_CANT_MOD_OBJ_CLASS"; + case STATUS_DS_CROSS_DOM_MOVE_FAILED: + return (PUCHAR)"STATUS_DS_CROSS_DOM_MOVE_FAILED"; + case STATUS_DS_GC_NOT_AVAILABLE: + return (PUCHAR)"STATUS_DS_GC_NOT_AVAILABLE"; + case STATUS_DIRECTORY_SERVICE_REQUIRED: + return (PUCHAR)"STATUS_DIRECTORY_SERVICE_REQUIRED"; + case STATUS_REPARSE_ATTRIBUTE_CONFLICT: + return (PUCHAR)"STATUS_REPARSE_ATTRIBUTE_CONFLICT"; + case STATUS_CANT_ENABLE_DENY_ONLY: + return (PUCHAR)"STATUS_CANT_ENABLE_DENY_ONLY"; + case STATUS_FLOAT_MULTIPLE_FAULTS: + return (PUCHAR)"STATUS_FLOAT_MULTIPLE_FAULTS"; + case STATUS_FLOAT_MULTIPLE_TRAPS: + return (PUCHAR)"STATUS_FLOAT_MULTIPLE_TRAPS"; + case STATUS_DEVICE_REMOVED: + return (PUCHAR)"STATUS_DEVICE_REMOVED"; + case STATUS_JOURNAL_DELETE_IN_PROGRESS: + return (PUCHAR)"STATUS_JOURNAL_DELETE_IN_PROGRESS"; + case STATUS_JOURNAL_NOT_ACTIVE: + return (PUCHAR)"STATUS_JOURNAL_NOT_ACTIVE"; + case STATUS_NOINTERFACE: + return (PUCHAR)"STATUS_NOINTERFACE"; + case STATUS_DS_ADMIN_LIMIT_EXCEEDED: + return (PUCHAR)"STATUS_DS_ADMIN_LIMIT_EXCEEDED"; + case STATUS_DRIVER_FAILED_SLEEP: + return (PUCHAR)"STATUS_DRIVER_FAILED_SLEEP"; + case STATUS_MUTUAL_AUTHENTICATION_FAILED: + return (PUCHAR)"STATUS_MUTUAL_AUTHENTICATION_FAILED"; + case STATUS_CORRUPT_SYSTEM_FILE: + return (PUCHAR)"STATUS_CORRUPT_SYSTEM_FILE"; + case STATUS_DATATYPE_MISALIGNMENT_ERROR: + return (PUCHAR)"STATUS_DATATYPE_MISALIGNMENT_ERROR"; + case STATUS_WMI_READ_ONLY: + return (PUCHAR)"STATUS_WMI_READ_ONLY"; + case STATUS_WMI_SET_FAILURE: + return (PUCHAR)"STATUS_WMI_SET_FAILURE"; + case STATUS_COMMITMENT_MINIMUM: + return (PUCHAR)"STATUS_COMMITMENT_MINIMUM"; + case STATUS_REG_NAT_CONSUMPTION: + return (PUCHAR)"STATUS_REG_NAT_CONSUMPTION"; + case STATUS_TRANSPORT_FULL: + return (PUCHAR)"STATUS_TRANSPORT_FULL"; + case STATUS_DS_SAM_INIT_FAILURE: + return (PUCHAR)"STATUS_DS_SAM_INIT_FAILURE"; + case STATUS_ONLY_IF_CONNECTED: + return (PUCHAR)"STATUS_ONLY_IF_CONNECTED"; + case STATUS_DS_SENSITIVE_GROUP_VIOLATION: + return (PUCHAR)"STATUS_DS_SENSITIVE_GROUP_VIOLATION"; + case STATUS_PNP_RESTART_ENUMERATION: + return (PUCHAR)"STATUS_PNP_RESTART_ENUMERATION"; + case STATUS_JOURNAL_ENTRY_DELETED: + return (PUCHAR)"STATUS_JOURNAL_ENTRY_DELETED"; + case STATUS_DS_CANT_MOD_PRIMARYGROUPID: + return (PUCHAR)"STATUS_DS_CANT_MOD_PRIMARYGROUPID"; + case STATUS_SYSTEM_IMAGE_BAD_SIGNATURE: + return (PUCHAR)"STATUS_SYSTEM_IMAGE_BAD_SIGNATURE"; + case STATUS_PNP_REBOOT_REQUIRED: + return (PUCHAR)"STATUS_PNP_REBOOT_REQUIRED"; + case STATUS_POWER_STATE_INVALID: + return (PUCHAR)"STATUS_POWER_STATE_INVALID"; + case STATUS_DS_INVALID_GROUP_TYPE: + return (PUCHAR)"STATUS_DS_INVALID_GROUP_TYPE"; + case STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN: + return (PUCHAR)"STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN"; + case STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN: + return (PUCHAR)"STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN"; + case STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER: + return (PUCHAR)"STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER"; + case STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER: + return (PUCHAR)"STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER"; + case STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER: + return (PUCHAR)"STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER"; + case STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER: + return (PUCHAR)"STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER"; + case STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER: + return (PUCHAR)"STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER"; + case STATUS_DS_HAVE_PRIMARY_MEMBERS: + return (PUCHAR)"STATUS_DS_HAVE_PRIMARY_MEMBERS"; + case STATUS_WMI_NOT_SUPPORTED: + return (PUCHAR)"STATUS_WMI_NOT_SUPPORTED"; + case STATUS_INSUFFICIENT_POWER: + return (PUCHAR)"STATUS_INSUFFICIENT_POWER"; + case STATUS_SAM_NEED_BOOTKEY_PASSWORD: + return (PUCHAR)"STATUS_SAM_NEED_BOOTKEY_PASSWORD"; + case STATUS_SAM_NEED_BOOTKEY_FLOPPY: + return (PUCHAR)"STATUS_SAM_NEED_BOOTKEY_FLOPPY"; + case STATUS_DS_CANT_START: + return (PUCHAR)"STATUS_DS_CANT_START"; + case STATUS_DS_INIT_FAILURE: + return (PUCHAR)"STATUS_DS_INIT_FAILURE"; + case STATUS_SAM_INIT_FAILURE: + return (PUCHAR)"STATUS_SAM_INIT_FAILURE"; + case STATUS_DS_GC_REQUIRED: + return (PUCHAR)"STATUS_DS_GC_REQUIRED"; + case STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY: + return (PUCHAR)"STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY"; + case STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS: + return (PUCHAR)"STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS"; + case STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED: + return (PUCHAR)"STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED"; + case STATUS_MULTIPLE_FAULT_VIOLATION: + return (PUCHAR)"STATUS_MULTIPLE_FAULT_VIOLATION"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_CURRENT_DOMAIN_NOT_ALLOWED: + return (PUCHAR)"STATUS_CURRENT_DOMAIN_NOT_ALLOWED"; + case STATUS_CANNOT_MAKE: + return (PUCHAR)"STATUS_CANNOT_MAKE"; + case STATUS_SYSTEM_SHUTDOWN: + return (PUCHAR)"STATUS_SYSTEM_SHUTDOWN"; + case STATUS_DS_INIT_FAILURE_CONSOLE: + return (PUCHAR)"STATUS_DS_INIT_FAILURE_CONSOLE"; + case STATUS_DS_SAM_INIT_FAILURE_CONSOLE: + return (PUCHAR)"STATUS_DS_SAM_INIT_FAILURE_CONSOLE"; + case STATUS_UNFINISHED_CONTEXT_DELETED: + return (PUCHAR)"STATUS_UNFINISHED_CONTEXT_DELETED"; + case STATUS_NO_TGT_REPLY: + return (PUCHAR)"STATUS_NO_TGT_REPLY"; + case STATUS_OBJECTID_NOT_FOUND: + return (PUCHAR)"STATUS_OBJECTID_NOT_FOUND"; + case STATUS_NO_IP_ADDRESSES: + return (PUCHAR)"STATUS_NO_IP_ADDRESSES"; + case STATUS_WRONG_CREDENTIAL_HANDLE: + return (PUCHAR)"STATUS_WRONG_CREDENTIAL_HANDLE"; + case STATUS_CRYPTO_SYSTEM_INVALID: + return (PUCHAR)"STATUS_CRYPTO_SYSTEM_INVALID"; + case STATUS_MAX_REFERRALS_EXCEEDED: + return (PUCHAR)"STATUS_MAX_REFERRALS_EXCEEDED"; + case STATUS_MUST_BE_KDC: + return (PUCHAR)"STATUS_MUST_BE_KDC"; + case STATUS_STRONG_CRYPTO_NOT_SUPPORTED: + return (PUCHAR)"STATUS_STRONG_CRYPTO_NOT_SUPPORTED"; + case STATUS_TOO_MANY_PRINCIPALS: + return (PUCHAR)"STATUS_TOO_MANY_PRINCIPALS"; + case STATUS_NO_PA_DATA: + return (PUCHAR)"STATUS_NO_PA_DATA"; + case STATUS_PKINIT_NAME_MISMATCH: + return (PUCHAR)"STATUS_PKINIT_NAME_MISMATCH"; + case STATUS_SMARTCARD_LOGON_REQUIRED: + return (PUCHAR)"STATUS_SMARTCARD_LOGON_REQUIRED"; + case STATUS_KDC_INVALID_REQUEST: + return (PUCHAR)"STATUS_KDC_INVALID_REQUEST"; + case STATUS_KDC_UNABLE_TO_REFER: + return (PUCHAR)"STATUS_KDC_UNABLE_TO_REFER"; + case STATUS_KDC_UNKNOWN_ETYPE: + return (PUCHAR)"STATUS_KDC_UNKNOWN_ETYPE"; + case STATUS_SHUTDOWN_IN_PROGRESS: + return (PUCHAR)"STATUS_SHUTDOWN_IN_PROGRESS"; + case STATUS_SERVER_SHUTDOWN_IN_PROGRESS: + return (PUCHAR)"STATUS_SERVER_SHUTDOWN_IN_PROGRESS"; +#endif + case STATUS_NOT_SUPPORTED_ON_SBS: + return (PUCHAR)"STATUS_NOT_SUPPORTED_ON_SBS"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_WMI_GUID_DISCONNECTED: + return (PUCHAR)"STATUS_WMI_GUID_DISCONNECTED"; + case STATUS_WMI_ALREADY_DISABLED: + return (PUCHAR)"STATUS_WMI_ALREADY_DISABLED"; + case STATUS_WMI_ALREADY_ENABLED: + return (PUCHAR)"STATUS_WMI_ALREADY_ENABLED"; + case STATUS_MFT_TOO_FRAGMENTED: + return (PUCHAR)"STATUS_MFT_TOO_FRAGMENTED"; + case STATUS_COPY_PROTECTION_FAILURE: + return (PUCHAR)"STATUS_COPY_PROTECTION_FAILURE"; + case STATUS_CSS_AUTHENTICATION_FAILURE: + return (PUCHAR)"STATUS_CSS_AUTHENTICATION_FAILURE"; + case STATUS_CSS_KEY_NOT_PRESENT: + return (PUCHAR)"STATUS_CSS_KEY_NOT_PRESENT"; + case STATUS_CSS_KEY_NOT_ESTABLISHED: + return (PUCHAR)"STATUS_CSS_KEY_NOT_ESTABLISHED"; + case STATUS_CSS_SCRAMBLED_SECTOR: + return (PUCHAR)"STATUS_CSS_SCRAMBLED_SECTOR"; + case STATUS_CSS_REGION_MISMATCH: + return (PUCHAR)"STATUS_CSS_REGION_MISMATCH"; + case STATUS_CSS_RESETS_EXHAUSTED: + return (PUCHAR)"STATUS_CSS_RESETS_EXHAUSTED"; + case STATUS_PKINIT_FAILURE: + return (PUCHAR)"STATUS_PKINIT_FAILURE"; + case STATUS_SMARTCARD_SUBSYSTEM_FAILURE: + return (PUCHAR)"STATUS_SMARTCARD_SUBSYSTEM_FAILURE"; + case STATUS_NO_KERB_KEY: + return (PUCHAR)"STATUS_NO_KERB_KEY"; + case STATUS_HOST_DOWN: + return (PUCHAR)"STATUS_HOST_DOWN"; + case STATUS_UNSUPPORTED_PREAUTH: + return (PUCHAR)"STATUS_UNSUPPORTED_PREAUTH"; + case STATUS_EFS_ALG_BLOB_TOO_BIG: + return (PUCHAR)"STATUS_EFS_ALG_BLOB_TOO_BIG"; + case STATUS_PORT_NOT_SET: + return (PUCHAR)"STATUS_PORT_NOT_SET"; + case STATUS_DEBUGGER_INACTIVE: + return (PUCHAR)"STATUS_DEBUGGER_INACTIVE"; + case STATUS_DS_VERSION_CHECK_FAILURE: + return (PUCHAR)"STATUS_DS_VERSION_CHECK_FAILURE"; + case STATUS_AUDITING_DISABLED: + return (PUCHAR)"STATUS_AUDITING_DISABLED"; + case STATUS_PRENT4_MACHINE_ACCOUNT: + return (PUCHAR)"STATUS_PRENT4_MACHINE_ACCOUNT"; + case STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER: + return (PUCHAR)"STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER"; + case STATUS_INVALID_IMAGE_WIN_32: + return (PUCHAR)"STATUS_INVALID_IMAGE_WIN_32"; + case STATUS_INVALID_IMAGE_WIN_64: + return (PUCHAR)"STATUS_INVALID_IMAGE_WIN_64"; + case STATUS_BAD_BINDINGS: + return (PUCHAR)"STATUS_BAD_BINDINGS"; + case STATUS_NETWORK_SESSION_EXPIRED: + return (PUCHAR)"STATUS_NETWORK_SESSION_EXPIRED"; + case STATUS_APPHELP_BLOCK: + return (PUCHAR)"STATUS_APPHELP_BLOCK"; + case STATUS_ALL_SIDS_FILTERED: + return (PUCHAR)"STATUS_ALL_SIDS_FILTERED"; + case STATUS_NOT_SAFE_MODE_DRIVER: + return (PUCHAR)"STATUS_NOT_SAFE_MODE_DRIVER"; + case STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT: + return (PUCHAR)"STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT"; + case STATUS_ACCESS_DISABLED_BY_POLICY_PATH: + return (PUCHAR)"STATUS_ACCESS_DISABLED_BY_POLICY_PATH"; + case STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER: + return (PUCHAR)"STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER"; + case STATUS_ACCESS_DISABLED_BY_POLICY_OTHER: + return (PUCHAR)"STATUS_ACCESS_DISABLED_BY_POLICY_OTHER"; + case STATUS_FAILED_DRIVER_ENTRY: + return (PUCHAR)"STATUS_FAILED_DRIVER_ENTRY"; + case STATUS_DEVICE_ENUMERATION_ERROR: + return (PUCHAR)"STATUS_DEVICE_ENUMERATION_ERROR"; + case STATUS_MOUNT_POINT_NOT_RESOLVED: + return (PUCHAR)"STATUS_MOUNT_POINT_NOT_RESOLVED"; + case STATUS_INVALID_DEVICE_OBJECT_PARAMETER: + return (PUCHAR)"STATUS_INVALID_DEVICE_OBJECT_PARAMETER"; + case STATUS_MCA_OCCURED: + return (PUCHAR)"STATUS_MCA_OCCURED"; + case STATUS_DRIVER_BLOCKED_CRITICAL: + return (PUCHAR)"STATUS_DRIVER_BLOCKED_CRITICAL"; + case STATUS_DRIVER_BLOCKED: + return (PUCHAR)"STATUS_DRIVER_BLOCKED"; + case STATUS_DRIVER_DATABASE_ERROR: + return (PUCHAR)"STATUS_DRIVER_DATABASE_ERROR"; + case STATUS_SYSTEM_HIVE_TOO_LARGE: + return (PUCHAR)"STATUS_SYSTEM_HIVE_TOO_LARGE"; + case STATUS_INVALID_IMPORT_OF_NON_DLL: + return (PUCHAR)"STATUS_INVALID_IMPORT_OF_NON_DLL"; + case STATUS_SMARTCARD_WRONG_PIN: + return (PUCHAR)"STATUS_SMARTCARD_WRONG_PIN"; + case STATUS_SMARTCARD_CARD_BLOCKED: + return (PUCHAR)"STATUS_SMARTCARD_CARD_BLOCKED"; + case STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED: + return (PUCHAR)"STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED"; + case STATUS_SMARTCARD_NO_CARD: + return (PUCHAR)"STATUS_SMARTCARD_NO_CARD"; + case STATUS_SMARTCARD_NO_KEY_CONTAINER: + return (PUCHAR)"STATUS_SMARTCARD_NO_KEY_CONTAINER"; + case STATUS_SMARTCARD_NO_CERTIFICATE: + return (PUCHAR)"STATUS_SMARTCARD_NO_CERTIFICATE"; + case STATUS_SMARTCARD_NO_KEYSET: + return (PUCHAR)"STATUS_SMARTCARD_NO_KEYSET"; + case STATUS_SMARTCARD_IO_ERROR: + return (PUCHAR)"STATUS_SMARTCARD_IO_ERROR"; + case STATUS_DOWNGRADE_DETECTED: + return (PUCHAR)"STATUS_DOWNGRADE_DETECTED"; + case STATUS_SMARTCARD_CERT_REVOKED: + return (PUCHAR)"STATUS_SMARTCARD_CERT_REVOKED"; + case STATUS_ISSUING_CA_UNTRUSTED: + return (PUCHAR)"STATUS_ISSUING_CA_UNTRUSTED"; + case STATUS_REVOCATION_OFFLINE_C: + return (PUCHAR)"STATUS_REVOCATION_OFFLINE_C"; + case STATUS_PKINIT_CLIENT_FAILURE: + return (PUCHAR)"STATUS_PKINIT_CLIENT_FAILURE"; + case STATUS_SMARTCARD_CERT_EXPIRED: + return (PUCHAR)"STATUS_SMARTCARD_CERT_EXPIRED"; + case STATUS_DRIVER_FAILED_PRIOR_UNLOAD: + return (PUCHAR)"STATUS_DRIVER_FAILED_PRIOR_UNLOAD"; +#endif +#if (VER_PRODUCT_BUILD > 2600) + case STATUS_SMARTCARD_SILENT_CONTEXT: + return (PUCHAR)"STATUS_SMARTCARD_SILENT_CONTEXT"; + case STATUS_PER_USER_TRUST_QUOTA_EXCEEDED: + return (PUCHAR)"STATUS_PER_USER_TRUST_QUOTA_EXCEEDED"; + case STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED: + return (PUCHAR)"STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED"; + case STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED: + return (PUCHAR)"STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED"; + case STATUS_DS_NAME_NOT_UNIQUE: + return (PUCHAR)"STATUS_DS_NAME_NOT_UNIQUE"; + case STATUS_DS_DUPLICATE_ID_FOUND: + return (PUCHAR)"STATUS_DS_DUPLICATE_ID_FOUND"; + case STATUS_DS_GROUP_CONVERSION_ERROR: + return (PUCHAR)"STATUS_DS_GROUP_CONVERSION_ERROR"; + case STATUS_VOLSNAP_PREPARE_HIBERNATE: + return (PUCHAR)"STATUS_VOLSNAP_PREPARE_HIBERNATE"; + case STATUS_USER2USER_REQUIRED: + return (PUCHAR)"STATUS_USER2USER_REQUIRED"; + case STATUS_STACK_BUFFER_OVERRUN: + return (PUCHAR)"STATUS_STACK_BUFFER_OVERRUN"; + case STATUS_NO_S4U_PROT_SUPPORT: + return (PUCHAR)"STATUS_NO_S4U_PROT_SUPPORT"; + case STATUS_CROSSREALM_DELEGATION_FAILURE: + return (PUCHAR)"STATUS_CROSSREALM_DELEGATION_FAILURE"; + case STATUS_REVOCATION_OFFLINE_KDC: + return (PUCHAR)"STATUS_REVOCATION_OFFLINE_KDC"; + case STATUS_ISSUING_CA_UNTRUSTED_KDC: + return (PUCHAR)"STATUS_ISSUING_CA_UNTRUSTED_KDC"; + case STATUS_KDC_CERT_EXPIRED: + return (PUCHAR)"STATUS_KDC_CERT_EXPIRED"; + case STATUS_KDC_CERT_REVOKED: + return (PUCHAR)"STATUS_KDC_CERT_REVOKED"; + case STATUS_PARAMETER_QUOTA_EXCEEDED: + return (PUCHAR)"STATUS_PARAMETER_QUOTA_EXCEEDED"; + case STATUS_HIBERNATION_FAILURE: + return (PUCHAR)"STATUS_HIBERNATION_FAILURE"; + case STATUS_DELAY_LOAD_FAILED: + return (PUCHAR)"STATUS_DELAY_LOAD_FAILED"; + case STATUS_AUTHENTICATION_FIREWALL_FAILED: + return (PUCHAR)"STATUS_AUTHENTICATION_FIREWALL_FAILED"; + case STATUS_VDM_DISALLOWED: + return (PUCHAR)"STATUS_VDM_DISALLOWED"; + case STATUS_HUNG_DISPLAY_DRIVER_THREAD: + return (PUCHAR)"STATUS_HUNG_DISPLAY_DRIVER_THREAD"; +#endif + case STATUS_WOW_ASSERTION: + return (PUCHAR)"STATUS_WOW_ASSERTION"; + case DBG_NO_STATE_CHANGE: + return (PUCHAR)"DBG_NO_STATE_CHANGE"; + case DBG_APP_NOT_IDLE: + return (PUCHAR)"DBG_APP_NOT_IDLE"; + case RPC_NT_INVALID_STRING_BINDING: + return (PUCHAR)"RPC_NT_INVALID_STRING_BINDING"; + case RPC_NT_WRONG_KIND_OF_BINDING: + return (PUCHAR)"RPC_NT_WRONG_KIND_OF_BINDING"; + case RPC_NT_INVALID_BINDING: + return (PUCHAR)"RPC_NT_INVALID_BINDING"; + case RPC_NT_PROTSEQ_NOT_SUPPORTED: + return (PUCHAR)"RPC_NT_PROTSEQ_NOT_SUPPORTED"; + case RPC_NT_INVALID_RPC_PROTSEQ: + return (PUCHAR)"RPC_NT_INVALID_RPC_PROTSEQ"; + case RPC_NT_INVALID_STRING_UUID: + return (PUCHAR)"RPC_NT_INVALID_STRING_UUID"; + case RPC_NT_INVALID_ENDPOINT_FORMAT: + return (PUCHAR)"RPC_NT_INVALID_ENDPOINT_FORMAT"; + case RPC_NT_INVALID_NET_ADDR: + return (PUCHAR)"RPC_NT_INVALID_NET_ADDR"; + case RPC_NT_NO_ENDPOINT_FOUND: + return (PUCHAR)"RPC_NT_NO_ENDPOINT_FOUND"; + case RPC_NT_INVALID_TIMEOUT: + return (PUCHAR)"RPC_NT_INVALID_TIMEOUT"; + case RPC_NT_OBJECT_NOT_FOUND: + return (PUCHAR)"RPC_NT_OBJECT_NOT_FOUND"; + case RPC_NT_ALREADY_REGISTERED: + return (PUCHAR)"RPC_NT_ALREADY_REGISTERED"; + case RPC_NT_TYPE_ALREADY_REGISTERED: + return (PUCHAR)"RPC_NT_TYPE_ALREADY_REGISTERED"; + case RPC_NT_ALREADY_LISTENING: + return (PUCHAR)"RPC_NT_ALREADY_LISTENING"; + case RPC_NT_NO_PROTSEQS_REGISTERED: + return (PUCHAR)"RPC_NT_NO_PROTSEQS_REGISTERED"; + case RPC_NT_NOT_LISTENING: + return (PUCHAR)"RPC_NT_NOT_LISTENING"; + case RPC_NT_UNKNOWN_MGR_TYPE: + return (PUCHAR)"RPC_NT_UNKNOWN_MGR_TYPE"; + case RPC_NT_UNKNOWN_IF: + return (PUCHAR)"RPC_NT_UNKNOWN_IF"; + case RPC_NT_NO_BINDINGS: + return (PUCHAR)"RPC_NT_NO_BINDINGS"; + case RPC_NT_NO_PROTSEQS: + return (PUCHAR)"RPC_NT_NO_PROTSEQS"; + case RPC_NT_CANT_CREATE_ENDPOINT: + return (PUCHAR)"RPC_NT_CANT_CREATE_ENDPOINT"; + case RPC_NT_OUT_OF_RESOURCES: + return (PUCHAR)"RPC_NT_OUT_OF_RESOURCES"; + case RPC_NT_SERVER_UNAVAILABLE: + return (PUCHAR)"RPC_NT_SERVER_UNAVAILABLE"; + case RPC_NT_SERVER_TOO_BUSY: + return (PUCHAR)"RPC_NT_SERVER_TOO_BUSY"; + case RPC_NT_INVALID_NETWORK_OPTIONS: + return (PUCHAR)"RPC_NT_INVALID_NETWORK_OPTIONS"; + case RPC_NT_NO_CALL_ACTIVE: + return (PUCHAR)"RPC_NT_NO_CALL_ACTIVE"; + case RPC_NT_CALL_FAILED: + return (PUCHAR)"RPC_NT_CALL_FAILED"; + case RPC_NT_CALL_FAILED_DNE: + return (PUCHAR)"RPC_NT_CALL_FAILED_DNE"; + case RPC_NT_PROTOCOL_ERROR: + return (PUCHAR)"RPC_NT_PROTOCOL_ERROR"; + case RPC_NT_UNSUPPORTED_TRANS_SYN: + return (PUCHAR)"RPC_NT_UNSUPPORTED_TRANS_SYN"; + case RPC_NT_UNSUPPORTED_TYPE: + return (PUCHAR)"RPC_NT_UNSUPPORTED_TYPE"; + case RPC_NT_INVALID_TAG: + return (PUCHAR)"RPC_NT_INVALID_TAG"; + case RPC_NT_INVALID_BOUND: + return (PUCHAR)"RPC_NT_INVALID_BOUND"; + case RPC_NT_NO_ENTRY_NAME: + return (PUCHAR)"RPC_NT_NO_ENTRY_NAME"; + case RPC_NT_INVALID_NAME_SYNTAX: + return (PUCHAR)"RPC_NT_INVALID_NAME_SYNTAX"; + case RPC_NT_UNSUPPORTED_NAME_SYNTAX: + return (PUCHAR)"RPC_NT_UNSUPPORTED_NAME_SYNTAX"; + case RPC_NT_UUID_NO_ADDRESS: + return (PUCHAR)"RPC_NT_UUID_NO_ADDRESS"; + case RPC_NT_DUPLICATE_ENDPOINT: + return (PUCHAR)"RPC_NT_DUPLICATE_ENDPOINT"; + case RPC_NT_UNKNOWN_AUTHN_TYPE: + return (PUCHAR)"RPC_NT_UNKNOWN_AUTHN_TYPE"; + case RPC_NT_MAX_CALLS_TOO_SMALL: + return (PUCHAR)"RPC_NT_MAX_CALLS_TOO_SMALL"; + case RPC_NT_STRING_TOO_LONG: + return (PUCHAR)"RPC_NT_STRING_TOO_LONG"; + case RPC_NT_PROTSEQ_NOT_FOUND: + return (PUCHAR)"RPC_NT_PROTSEQ_NOT_FOUND"; + case RPC_NT_PROCNUM_OUT_OF_RANGE: + return (PUCHAR)"RPC_NT_PROCNUM_OUT_OF_RANGE"; + case RPC_NT_BINDING_HAS_NO_AUTH: + return (PUCHAR)"RPC_NT_BINDING_HAS_NO_AUTH"; + case RPC_NT_UNKNOWN_AUTHN_SERVICE: + return (PUCHAR)"RPC_NT_UNKNOWN_AUTHN_SERVICE"; + case RPC_NT_UNKNOWN_AUTHN_LEVEL: + return (PUCHAR)"RPC_NT_UNKNOWN_AUTHN_LEVEL"; + case RPC_NT_INVALID_AUTH_IDENTITY: + return (PUCHAR)"RPC_NT_INVALID_AUTH_IDENTITY"; + case RPC_NT_UNKNOWN_AUTHZ_SERVICE: + return (PUCHAR)"RPC_NT_UNKNOWN_AUTHZ_SERVICE"; + case EPT_NT_INVALID_ENTRY: + return (PUCHAR)"EPT_NT_INVALID_ENTRY"; + case EPT_NT_CANT_PERFORM_OP: + return (PUCHAR)"EPT_NT_CANT_PERFORM_OP"; + case EPT_NT_NOT_REGISTERED: + return (PUCHAR)"EPT_NT_NOT_REGISTERED"; + case RPC_NT_NOTHING_TO_EXPORT: + return (PUCHAR)"RPC_NT_NOTHING_TO_EXPORT"; + case RPC_NT_INCOMPLETE_NAME: + return (PUCHAR)"RPC_NT_INCOMPLETE_NAME"; + case RPC_NT_INVALID_VERS_OPTION: + return (PUCHAR)"RPC_NT_INVALID_VERS_OPTION"; + case RPC_NT_NO_MORE_MEMBERS: + return (PUCHAR)"RPC_NT_NO_MORE_MEMBERS"; + case RPC_NT_NOT_ALL_OBJS_UNEXPORTED: + return (PUCHAR)"RPC_NT_NOT_ALL_OBJS_UNEXPORTED"; + case RPC_NT_INTERFACE_NOT_FOUND: + return (PUCHAR)"RPC_NT_INTERFACE_NOT_FOUND"; + case RPC_NT_ENTRY_ALREADY_EXISTS: + return (PUCHAR)"RPC_NT_ENTRY_ALREADY_EXISTS"; + case RPC_NT_ENTRY_NOT_FOUND: + return (PUCHAR)"RPC_NT_ENTRY_NOT_FOUND"; + case RPC_NT_NAME_SERVICE_UNAVAILABLE: + return (PUCHAR)"RPC_NT_NAME_SERVICE_UNAVAILABLE"; + case RPC_NT_INVALID_NAF_ID: + return (PUCHAR)"RPC_NT_INVALID_NAF_ID"; + case RPC_NT_CANNOT_SUPPORT: + return (PUCHAR)"RPC_NT_CANNOT_SUPPORT"; + case RPC_NT_NO_CONTEXT_AVAILABLE: + return (PUCHAR)"RPC_NT_NO_CONTEXT_AVAILABLE"; + case RPC_NT_INTERNAL_ERROR: + return (PUCHAR)"RPC_NT_INTERNAL_ERROR"; + case RPC_NT_ZERO_DIVIDE: + return (PUCHAR)"RPC_NT_ZERO_DIVIDE"; + case RPC_NT_ADDRESS_ERROR: + return (PUCHAR)"RPC_NT_ADDRESS_ERROR"; + case RPC_NT_FP_DIV_ZERO: + return (PUCHAR)"RPC_NT_FP_DIV_ZERO"; + case RPC_NT_FP_UNDERFLOW: + return (PUCHAR)"RPC_NT_FP_UNDERFLOW"; + case RPC_NT_FP_OVERFLOW: + return (PUCHAR)"RPC_NT_FP_OVERFLOW"; + case RPC_NT_CALL_IN_PROGRESS: + return (PUCHAR)"RPC_NT_CALL_IN_PROGRESS"; + case RPC_NT_NO_MORE_BINDINGS: + return (PUCHAR)"RPC_NT_NO_MORE_BINDINGS"; + case RPC_NT_GROUP_MEMBER_NOT_FOUND: + return (PUCHAR)"RPC_NT_GROUP_MEMBER_NOT_FOUND"; + case EPT_NT_CANT_CREATE: + return (PUCHAR)"EPT_NT_CANT_CREATE"; + case RPC_NT_INVALID_OBJECT: + return (PUCHAR)"RPC_NT_INVALID_OBJECT"; + case RPC_NT_NO_INTERFACES: + return (PUCHAR)"RPC_NT_NO_INTERFACES"; + case RPC_NT_CALL_CANCELLED: + return (PUCHAR)"RPC_NT_CALL_CANCELLED"; + case RPC_NT_BINDING_INCOMPLETE: + return (PUCHAR)"RPC_NT_BINDING_INCOMPLETE"; + case RPC_NT_COMM_FAILURE: + return (PUCHAR)"RPC_NT_COMM_FAILURE"; + case RPC_NT_UNSUPPORTED_AUTHN_LEVEL: + return (PUCHAR)"RPC_NT_UNSUPPORTED_AUTHN_LEVEL"; + case RPC_NT_NO_PRINC_NAME: + return (PUCHAR)"RPC_NT_NO_PRINC_NAME"; + case RPC_NT_NOT_RPC_ERROR: + return (PUCHAR)"RPC_NT_NOT_RPC_ERROR"; + case RPC_NT_SEC_PKG_ERROR: + return (PUCHAR)"RPC_NT_SEC_PKG_ERROR"; + case RPC_NT_NOT_CANCELLED: + return (PUCHAR)"RPC_NT_NOT_CANCELLED"; + case RPC_NT_INVALID_ASYNC_HANDLE: + return (PUCHAR)"RPC_NT_INVALID_ASYNC_HANDLE"; + case RPC_NT_INVALID_ASYNC_CALL: + return (PUCHAR)"RPC_NT_INVALID_ASYNC_CALL"; + case RPC_NT_NO_MORE_ENTRIES: + return (PUCHAR)"RPC_NT_NO_MORE_ENTRIES"; + case RPC_NT_SS_CHAR_TRANS_OPEN_FAIL: + return (PUCHAR)"RPC_NT_SS_CHAR_TRANS_OPEN_FAIL"; + case RPC_NT_SS_CHAR_TRANS_SHORT_FILE: + return (PUCHAR)"RPC_NT_SS_CHAR_TRANS_SHORT_FILE"; + case RPC_NT_SS_IN_NULL_CONTEXT: + return (PUCHAR)"RPC_NT_SS_IN_NULL_CONTEXT"; + case RPC_NT_SS_CONTEXT_MISMATCH: + return (PUCHAR)"RPC_NT_SS_CONTEXT_MISMATCH"; + case RPC_NT_SS_CONTEXT_DAMAGED: + return (PUCHAR)"RPC_NT_SS_CONTEXT_DAMAGED"; + case RPC_NT_SS_HANDLES_MISMATCH: + return (PUCHAR)"RPC_NT_SS_HANDLES_MISMATCH"; + case RPC_NT_SS_CANNOT_GET_CALL_HANDLE: + return (PUCHAR)"RPC_NT_SS_CANNOT_GET_CALL_HANDLE"; + case RPC_NT_NULL_REF_POINTER: + return (PUCHAR)"RPC_NT_NULL_REF_POINTER"; + case RPC_NT_ENUM_VALUE_OUT_OF_RANGE: + return (PUCHAR)"RPC_NT_ENUM_VALUE_OUT_OF_RANGE"; + case RPC_NT_BYTE_COUNT_TOO_SMALL: + return (PUCHAR)"RPC_NT_BYTE_COUNT_TOO_SMALL"; + case RPC_NT_BAD_STUB_DATA: + return (PUCHAR)"RPC_NT_BAD_STUB_DATA"; + case RPC_NT_INVALID_ES_ACTION: + return (PUCHAR)"RPC_NT_INVALID_ES_ACTION"; + case RPC_NT_WRONG_ES_VERSION: + return (PUCHAR)"RPC_NT_WRONG_ES_VERSION"; + case RPC_NT_WRONG_STUB_VERSION: + return (PUCHAR)"RPC_NT_WRONG_STUB_VERSION"; + case RPC_NT_INVALID_PIPE_OBJECT: + return (PUCHAR)"RPC_NT_INVALID_PIPE_OBJECT"; + case RPC_NT_INVALID_PIPE_OPERATION: + return (PUCHAR)"RPC_NT_INVALID_PIPE_OPERATION"; + case RPC_NT_WRONG_PIPE_VERSION: + return (PUCHAR)"RPC_NT_WRONG_PIPE_VERSION"; + case RPC_NT_PIPE_CLOSED: + return (PUCHAR)"RPC_NT_PIPE_CLOSED"; + case RPC_NT_PIPE_DISCIPLINE_ERROR: + return (PUCHAR)"RPC_NT_PIPE_DISCIPLINE_ERROR"; + case RPC_NT_PIPE_EMPTY: + return (PUCHAR)"RPC_NT_PIPE_EMPTY"; + case STATUS_PNP_BAD_MPS_TABLE: + return (PUCHAR)"STATUS_PNP_BAD_MPS_TABLE"; + case STATUS_PNP_TRANSLATION_FAILED: + return (PUCHAR)"STATUS_PNP_TRANSLATION_FAILED"; + case STATUS_PNP_IRQ_TRANSLATION_FAILED: + return (PUCHAR)"STATUS_PNP_IRQ_TRANSLATION_FAILED"; +#if (VER_PRODUCT_BUILD > 2600) + case STATUS_PNP_INVALID_ID: + return (PUCHAR)"STATUS_PNP_INVALID_ID"; +#endif + case STATUS_CTX_WINSTATION_NAME_INVALID: + return (PUCHAR)"STATUS_CTX_WINSTATION_NAME_INVALID"; + case STATUS_CTX_INVALID_PD: + return (PUCHAR)"STATUS_CTX_INVALID_PD"; + case STATUS_CTX_PD_NOT_FOUND: + return (PUCHAR)"STATUS_CTX_PD_NOT_FOUND"; + case STATUS_CTX_CLOSE_PENDING: + return (PUCHAR)"STATUS_CTX_CLOSE_PENDING"; + case STATUS_CTX_NO_OUTBUF: + return (PUCHAR)"STATUS_CTX_NO_OUTBUF"; + case STATUS_CTX_MODEM_INF_NOT_FOUND: + return (PUCHAR)"STATUS_CTX_MODEM_INF_NOT_FOUND"; + case STATUS_CTX_INVALID_MODEMNAME: + return (PUCHAR)"STATUS_CTX_INVALID_MODEMNAME"; + case STATUS_CTX_RESPONSE_ERROR: + return (PUCHAR)"STATUS_CTX_RESPONSE_ERROR"; + case STATUS_CTX_MODEM_RESPONSE_TIMEOUT: + return (PUCHAR)"STATUS_CTX_MODEM_RESPONSE_TIMEOUT"; + case STATUS_CTX_MODEM_RESPONSE_NO_CARRIER: + return (PUCHAR)"STATUS_CTX_MODEM_RESPONSE_NO_CARRIER"; + case STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE: + return (PUCHAR)"STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE"; + case STATUS_CTX_MODEM_RESPONSE_BUSY: + return (PUCHAR)"STATUS_CTX_MODEM_RESPONSE_BUSY"; + case STATUS_CTX_MODEM_RESPONSE_VOICE: + return (PUCHAR)"STATUS_CTX_MODEM_RESPONSE_VOICE"; + case STATUS_CTX_TD_ERROR: + return (PUCHAR)"STATUS_CTX_TD_ERROR"; + case STATUS_CTX_LICENSE_CLIENT_INVALID: + return (PUCHAR)"STATUS_CTX_LICENSE_CLIENT_INVALID"; + case STATUS_CTX_LICENSE_NOT_AVAILABLE: + return (PUCHAR)"STATUS_CTX_LICENSE_NOT_AVAILABLE"; + case STATUS_CTX_LICENSE_EXPIRED: + return (PUCHAR)"STATUS_CTX_LICENSE_EXPIRED"; + case STATUS_CTX_WINSTATION_NOT_FOUND: + return (PUCHAR)"STATUS_CTX_WINSTATION_NOT_FOUND"; + case STATUS_CTX_WINSTATION_NAME_COLLISION: + return (PUCHAR)"STATUS_CTX_WINSTATION_NAME_COLLISION"; + case STATUS_CTX_WINSTATION_BUSY: + return (PUCHAR)"STATUS_CTX_WINSTATION_BUSY"; + case STATUS_CTX_BAD_VIDEO_MODE: + return (PUCHAR)"STATUS_CTX_BAD_VIDEO_MODE"; + case STATUS_CTX_GRAPHICS_INVALID: + return (PUCHAR)"STATUS_CTX_GRAPHICS_INVALID"; + case STATUS_CTX_NOT_CONSOLE: + return (PUCHAR)"STATUS_CTX_NOT_CONSOLE"; + case STATUS_CTX_CLIENT_QUERY_TIMEOUT: + return (PUCHAR)"STATUS_CTX_CLIENT_QUERY_TIMEOUT"; + case STATUS_CTX_CONSOLE_DISCONNECT: + return (PUCHAR)"STATUS_CTX_CONSOLE_DISCONNECT"; + case STATUS_CTX_CONSOLE_CONNECT: + return (PUCHAR)"STATUS_CTX_CONSOLE_CONNECT"; + case STATUS_CTX_SHADOW_DENIED: + return (PUCHAR)"STATUS_CTX_SHADOW_DENIED"; + case STATUS_CTX_WINSTATION_ACCESS_DENIED: + return (PUCHAR)"STATUS_CTX_WINSTATION_ACCESS_DENIED"; + case STATUS_CTX_INVALID_WD: + return (PUCHAR)"STATUS_CTX_INVALID_WD"; + case STATUS_CTX_WD_NOT_FOUND: + return (PUCHAR)"STATUS_CTX_WD_NOT_FOUND"; + case STATUS_CTX_SHADOW_INVALID: + return (PUCHAR)"STATUS_CTX_SHADOW_INVALID"; + case STATUS_CTX_SHADOW_DISABLED: + return (PUCHAR)"STATUS_CTX_SHADOW_DISABLED"; + case STATUS_RDP_PROTOCOL_ERROR: + return (PUCHAR)"STATUS_RDP_PROTOCOL_ERROR"; + case STATUS_CTX_CLIENT_LICENSE_NOT_SET: + return (PUCHAR)"STATUS_CTX_CLIENT_LICENSE_NOT_SET"; + case STATUS_CTX_CLIENT_LICENSE_IN_USE: + return (PUCHAR)"STATUS_CTX_CLIENT_LICENSE_IN_USE"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE: + return (PUCHAR)"STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE"; + case STATUS_CTX_SHADOW_NOT_RUNNING: + return (PUCHAR)"STATUS_CTX_SHADOW_NOT_RUNNING"; + case STATUS_CLUSTER_INVALID_NODE: + return (PUCHAR)"STATUS_CLUSTER_INVALID_NODE"; + case STATUS_CLUSTER_NODE_EXISTS: + return (PUCHAR)"STATUS_CLUSTER_NODE_EXISTS"; + case STATUS_CLUSTER_JOIN_IN_PROGRESS: + return (PUCHAR)"STATUS_CLUSTER_JOIN_IN_PROGRESS"; + case STATUS_CLUSTER_NODE_NOT_FOUND: + return (PUCHAR)"STATUS_CLUSTER_NODE_NOT_FOUND"; + case STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND: + return (PUCHAR)"STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND"; + case STATUS_CLUSTER_NETWORK_EXISTS: + return (PUCHAR)"STATUS_CLUSTER_NETWORK_EXISTS"; + case STATUS_CLUSTER_NETWORK_NOT_FOUND: + return (PUCHAR)"STATUS_CLUSTER_NETWORK_NOT_FOUND"; + case STATUS_CLUSTER_NETINTERFACE_EXISTS: + return (PUCHAR)"STATUS_CLUSTER_NETINTERFACE_EXISTS"; + case STATUS_CLUSTER_NETINTERFACE_NOT_FOUND: + return (PUCHAR)"STATUS_CLUSTER_NETINTERFACE_NOT_FOUND"; + case STATUS_CLUSTER_INVALID_REQUEST: + return (PUCHAR)"STATUS_CLUSTER_INVALID_REQUEST"; + case STATUS_CLUSTER_INVALID_NETWORK_PROVIDER: + return (PUCHAR)"STATUS_CLUSTER_INVALID_NETWORK_PROVIDER"; + case STATUS_CLUSTER_NODE_DOWN: + return (PUCHAR)"STATUS_CLUSTER_NODE_DOWN"; + case STATUS_CLUSTER_NODE_UNREACHABLE: + return (PUCHAR)"STATUS_CLUSTER_NODE_UNREACHABLE"; + case STATUS_CLUSTER_NODE_NOT_MEMBER: + return (PUCHAR)"STATUS_CLUSTER_NODE_NOT_MEMBER"; + case STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS: + return (PUCHAR)"STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS"; + case STATUS_CLUSTER_INVALID_NETWORK: + return (PUCHAR)"STATUS_CLUSTER_INVALID_NETWORK"; + case STATUS_CLUSTER_NO_NET_ADAPTERS: + return (PUCHAR)"STATUS_CLUSTER_NO_NET_ADAPTERS"; + case STATUS_CLUSTER_NODE_UP: + return (PUCHAR)"STATUS_CLUSTER_NODE_UP"; + case STATUS_CLUSTER_NODE_PAUSED: + return (PUCHAR)"STATUS_CLUSTER_NODE_PAUSED"; + case STATUS_CLUSTER_NODE_NOT_PAUSED: + return (PUCHAR)"STATUS_CLUSTER_NODE_NOT_PAUSED"; + case STATUS_CLUSTER_NO_SECURITY_CONTEXT: + return (PUCHAR)"STATUS_CLUSTER_NO_SECURITY_CONTEXT"; + case STATUS_CLUSTER_NETWORK_NOT_INTERNAL: + return (PUCHAR)"STATUS_CLUSTER_NETWORK_NOT_INTERNAL"; + case STATUS_CLUSTER_POISONED: + return (PUCHAR)"STATUS_CLUSTER_POISONED"; +#endif + case STATUS_ACPI_INVALID_OPCODE: + return (PUCHAR)"STATUS_ACPI_INVALID_OPCODE"; + case STATUS_ACPI_STACK_OVERFLOW: + return (PUCHAR)"STATUS_ACPI_STACK_OVERFLOW"; + case STATUS_ACPI_ASSERT_FAILED: + return (PUCHAR)"STATUS_ACPI_ASSERT_FAILED"; + case STATUS_ACPI_INVALID_INDEX: + return (PUCHAR)"STATUS_ACPI_INVALID_INDEX"; + case STATUS_ACPI_INVALID_ARGUMENT: + return (PUCHAR)"STATUS_ACPI_INVALID_ARGUMENT"; + case STATUS_ACPI_FATAL: + return (PUCHAR)"STATUS_ACPI_FATAL"; + case STATUS_ACPI_INVALID_SUPERNAME: + return (PUCHAR)"STATUS_ACPI_INVALID_SUPERNAME"; + case STATUS_ACPI_INVALID_ARGTYPE: + return (PUCHAR)"STATUS_ACPI_INVALID_ARGTYPE"; + case STATUS_ACPI_INVALID_OBJTYPE: + return (PUCHAR)"STATUS_ACPI_INVALID_OBJTYPE"; + case STATUS_ACPI_INVALID_TARGETTYPE: + return (PUCHAR)"STATUS_ACPI_INVALID_TARGETTYPE"; + case STATUS_ACPI_INCORRECT_ARGUMENT_COUNT: + return (PUCHAR)"STATUS_ACPI_INCORRECT_ARGUMENT_COUNT"; + case STATUS_ACPI_ADDRESS_NOT_MAPPED: + return (PUCHAR)"STATUS_ACPI_ADDRESS_NOT_MAPPED"; + case STATUS_ACPI_INVALID_EVENTTYPE: + return (PUCHAR)"STATUS_ACPI_INVALID_EVENTTYPE"; + case STATUS_ACPI_HANDLER_COLLISION: + return (PUCHAR)"STATUS_ACPI_HANDLER_COLLISION"; + case STATUS_ACPI_INVALID_DATA: + return (PUCHAR)"STATUS_ACPI_INVALID_DATA"; + case STATUS_ACPI_INVALID_REGION: + return (PUCHAR)"STATUS_ACPI_INVALID_REGION"; + case STATUS_ACPI_INVALID_ACCESS_SIZE: + return (PUCHAR)"STATUS_ACPI_INVALID_ACCESS_SIZE"; + case STATUS_ACPI_ACQUIRE_GLOBAL_LOCK: + return (PUCHAR)"STATUS_ACPI_ACQUIRE_GLOBAL_LOCK"; + case STATUS_ACPI_ALREADY_INITIALIZED: + return (PUCHAR)"STATUS_ACPI_ALREADY_INITIALIZED"; + case STATUS_ACPI_NOT_INITIALIZED: + return (PUCHAR)"STATUS_ACPI_NOT_INITIALIZED"; + case STATUS_ACPI_INVALID_MUTEX_LEVEL: + return (PUCHAR)"STATUS_ACPI_INVALID_MUTEX_LEVEL"; + case STATUS_ACPI_MUTEX_NOT_OWNED: + return (PUCHAR)"STATUS_ACPI_MUTEX_NOT_OWNED"; + case STATUS_ACPI_MUTEX_NOT_OWNER: + return (PUCHAR)"STATUS_ACPI_MUTEX_NOT_OWNER"; + case STATUS_ACPI_RS_ACCESS: + return (PUCHAR)"STATUS_ACPI_RS_ACCESS"; + case STATUS_ACPI_INVALID_TABLE: + return (PUCHAR)"STATUS_ACPI_INVALID_TABLE"; + case STATUS_ACPI_REG_HANDLER_FAILED: + return (PUCHAR)"STATUS_ACPI_REG_HANDLER_FAILED"; + case STATUS_ACPI_POWER_REQUEST_FAILED: + return (PUCHAR)"STATUS_ACPI_POWER_REQUEST_FAILED"; +#if (VER_PRODUCT_BUILD >= 2600) + case STATUS_SXS_SECTION_NOT_FOUND: + return (PUCHAR)"STATUS_SXS_SECTION_NOT_FOUND"; + case STATUS_SXS_CANT_GEN_ACTCTX: + return (PUCHAR)"STATUS_SXS_CANT_GEN_ACTCTX"; + case STATUS_SXS_INVALID_ACTCTXDATA_FORMAT: + return (PUCHAR)"STATUS_SXS_INVALID_ACTCTXDATA_FORMAT"; + case STATUS_SXS_ASSEMBLY_NOT_FOUND: + return (PUCHAR)"STATUS_SXS_ASSEMBLY_NOT_FOUND"; + case STATUS_SXS_MANIFEST_FORMAT_ERROR: + return (PUCHAR)"STATUS_SXS_MANIFEST_FORMAT_ERROR"; + case STATUS_SXS_MANIFEST_PARSE_ERROR: + return (PUCHAR)"STATUS_SXS_MANIFEST_PARSE_ERROR"; + case STATUS_SXS_ACTIVATION_CONTEXT_DISABLED: + return (PUCHAR)"STATUS_SXS_ACTIVATION_CONTEXT_DISABLED"; + case STATUS_SXS_KEY_NOT_FOUND: + return (PUCHAR)"STATUS_SXS_KEY_NOT_FOUND"; + case STATUS_SXS_VERSION_CONFLICT: + return (PUCHAR)"STATUS_SXS_VERSION_CONFLICT"; + case STATUS_SXS_WRONG_SECTION_TYPE: + return (PUCHAR)"STATUS_SXS_WRONG_SECTION_TYPE"; + case STATUS_SXS_THREAD_QUERIES_DISABLED: + return (PUCHAR)"STATUS_SXS_THREAD_QUERIES_DISABLED"; + case STATUS_SXS_ASSEMBLY_MISSING: + return (PUCHAR)"STATUS_SXS_ASSEMBLY_MISSING"; + case STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET: + return (PUCHAR)"STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET"; + case STATUS_SXS_EARLY_DEACTIVATION: + return (PUCHAR)"STATUS_SXS_EARLY_DEACTIVATION"; + case STATUS_SXS_INVALID_DEACTIVATION: + return (PUCHAR)"STATUS_SXS_INVALID_DEACTIVATION"; + case STATUS_SXS_MULTIPLE_DEACTIVATION: + return (PUCHAR)"STATUS_SXS_MULTIPLE_DEACTIVATION"; + case STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY: + return (PUCHAR)"STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY"; + case STATUS_SXS_PROCESS_TERMINATION_REQUESTED: + return (PUCHAR)"STATUS_SXS_PROCESS_TERMINATION_REQUESTED"; +#endif +#if (VER_PRODUCT_BUILD > 2600) + case STATUS_SXS_CORRUPT_ACTIVATION_STACK: + return (PUCHAR)"STATUS_SXS_CORRUPT_ACTIVATION_STACK"; +#endif + default: + return (PUCHAR)"NTSTATSTR_UNKNOWN_STATUS"; + } +} diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker2Installer.inf b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker2Installer.inf new file mode 100644 index 0000000..959b14d --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/SkyWalker2Installer.inf @@ -0,0 +1,142 @@ +; SkyWalker2Installer.INF -- This file installs SkyWalker2 Driver +; +[Version] +signature="$CHICAGO$" +Class=Media +ClassGUID={4d36e96c-e325-11ce-bfc1-08002be10318} +Provider=%SGI% +CatalogFile=SkyWalker2Installer.cat +DriverVer= 8/17/2009 + +; F i l e c o p y i n g s e c t i o n s (where the files go to). +; +[DestinationDirs] +DefaultDestDir=10,system32\drivers + +[Manufacturer] +%SGI%=SGI + +[ControlFlags] +;ExcludeFromSelect=* +;ExcludeFromSelect.NT=* + +; =================== Generic ================================== + +[SGI] +%SkyWalker2.DeviceDesc%=SkyWalker2.Device,USB\VID_09C0&PID_0206 ;SkyWalker2 + +[SkyWalker2.Device] +Include = ks.inf, kscaptur.inf, bda.inf +needs = KS.Registration, KSCAPTUR.Registration, BDA.Installation +AddReg = SkyWalker2.AddReg +CopyFiles = SkyWalker2.CopyDrivers + +[SkyWalker2.Device.NT] +Include = ks.inf, kscaptur.inf, bda.inf +needs = KS.Registration.NT, KSCAPTUR.Registration.NT, BDA.Installation.NT +;AddReg = SkyWalker2.AddReg +CopyFiles = SkyWalker2.CopyDrivers +; KnownFiles = SkyWalker2.KnownFiles + +[SkyWalker2.Device.NT.Services] +Addservice=SkyWalker2TVTuner, 0x00000002, SkyWalker2.AddService + +[SkyWalker2.AddService] +DisplayName=%SkyWalker2.FriendlyName% +ServiceType=1 ; SERVICE_KERNEL_DRIVER +StartType=3 ; SERVICE_DEMAND_START +ErrorControl=1 ; SERVICE_ERROR_NORMAL +ServiceBinary=%10%\System32\Drivers\SkyWalker1TVTuner.sys +LoadOrderGroup=ExtendedBase + +[SkyWalker2.CopyDrivers] +SkyWalker1TVTuner.sys + +[SkyWalker2.AddReg] +HKR,,DevLoader,,*NTKERN +HKR,,NTMPDriver,,SkyWalker1TVTuner.sys +HKR,,PageOutWhenUnopened,3,01 + +[SkyWalker2.Device.Interfaces] +AddInterface=%KSCATEGORY_BDA_RECEIVER_COMPONENT%,%SKYWALKER_CAPTURE%,SkyWalker2.Receiver.Interfaces +AddInterface=%KSCATEGORY_BDA_NETWORK_TUNER%,%SKYWALKER_TUNER%,SkyWalker2.Tuner.Interfaces + +[SkyWalker2.Device.NT.Interfaces] +AddInterface=%KSCATEGORY_BDA_RECEIVER_COMPONENT%,%SKYWALKER_CAPTURE%,SkyWalker2.Receiver.Interfaces +AddInterface=%KSCATEGORY_BDA_NETWORK_TUNER%,%SKYWALKER_TUNER%,SkyWalker2.Tuner.Interfaces + +[SkyWalker2.Tuner.Interfaces] +AddReg=SkyWalker2.Tuner.Interfaces.AddReg + +[SkyWalker2.Tuner.Interfaces.AddReg] +HKR,,CLSID,,%KSProxy.CLSID% +HKR,,FriendlyName,,%SkyWalker2.Tuner.FriendlyName% + +[SkyWalker2.Receiver.Interfaces] +AddReg=SkyWalker2.Receiver.Interfaces.AddReg + +[SkyWalker2.Receiver.Interfaces.AddReg] +HKR,,CLSID,,%KSProxy.CLSID% +HKR,,FriendlyName,,%SkyWalker2.Receiver.FriendlyName% + + +[Strings] +;non-localizable +SGI="Plethorasoft" +MfgName="SGI" +SkyWalker2.DeviceDesc="SkyWalker2 BDA TVTuner" +SkyWalker2.Tuner.FriendlyName="SkyWalker2 TV Tuner" +SkyWalker2.Receiver.FriendlyName="SkyWalker2 TV Receiver" +SkyWalker2.Tuner="SkyWalker2.Tuner" +KSProxy.CLSID="{17CCA71B-ECD7-11D0-B908-00A0C9223196}" +KSCATEGORY_BDA_NETWORK_TUNER="{71985F48-1CA1-11d3-9CC8-00C04F7971E0}" +KSCATEGORY_BDA_RECEIVER_COMPONENT="{FD0A5AF4-B41D-11d2-9C95-00C04F7971E0}" +SKYWALKER_TUNER="{5C4E764F-AB43-46A9-B21E-8529C70F0A23}" +SKYWALKER_CAPTURE="{0F8F74D9-E524-4D05-BB60-F0C69ACB1756}" + +; +; ServiceType values +SERVICE_KERNEL_DRIVER = 0x00000001 +SERVICE_FILE_SYSTEM_DRIVER = 0x00000002 +SERVICE_ADAPTER = 0x00000004 +SERVICE_RECOGNIZER_DRIVER = 0x00000008 +SERVICE_WIN32_OWN_PROCESS = 0x00000010 +SERVICE_WIN32_SHARE_PROCESS = 0x00000020 +SERVICE_INTERACTIVE_PROCESS = 0x00000100 +SERVICE_INTERACTIVE_SHARE_PROCESS = 0x00000120 + +; StartType values +SERVICE_BOOT_START = 0x00000000 +SERVICE_SYSTEM_START = 0x00000001 +SERVICE_AUTO_START = 0x00000002 +SERVICE_DEMAND_START = 0x00000003 +SERVICE_DISABLED = 0x00000004 + +; ErrorControl values +SERVICE_ERROR_IGNORE = 0x00000000 +SERVICE_ERROR_NORMAL = 0x00000001 +SERVICE_ERROR_SEVERE = 0x00000002 +SERVICE_ERROR_CRITICAL = 0x00000003 + +; Characteristic flags +NCF_VIRTUAL = 0x0001 +NCF_WRAPPER = 0x0002 +NCF_PHYSICAL = 0x0004 +NCF_HIDDEN = 0x0008 +NCF_NO_SERVICE = 0x0010 +NCF_NOT_USER_REMOVABLE = 0x0020 +NCF_HAS_UI = 0x0080 +NCF_MODEM = 0x0100 + +; Registry types +REG_MULTI_SZ = 0x10000 +REG_EXPAND_SZ = 0x20000 +REG_DWORD = 0x10001 + +; Win9x Compatible Types +REG_BINARY = 17 +REG_SZ = 0 + +; Service install flags +SPSVCINST_TAGTOFRONT = 0x1 +SPSVCINST_ASSOCSERVICE = 0x2 \ No newline at end of file diff --git a/firmware-driver/SkyWalker1_Final_Release/Source/Sources b/firmware-driver/SkyWalker1_Final_Release/Source/Sources new file mode 100644 index 0000000..64686ce --- /dev/null +++ b/firmware-driver/SkyWalker1_Final_Release/Source/Sources @@ -0,0 +1,62 @@ +############################################################################# +# Shree Ganesha Inc. +# Sources File for the Skywalker1 TV Tuner +# Date : 29th September, 2009 +# Description : This file is a must for the Compilation of the +# Skywalker Driver. +# +########################################################################## + +TARGETNAME=SkyWalker1TVTuner # Set driver's name +TARGETTYPE=DRIVER # Set type of file built, for example, program, DLL, or driver + # For BDA minidriver, set to DRIVER. +TARGETPATH=obj$(BUILD_ALT_DIR) # Set destination directory for the built file + # Depending on whether your build environment is "free" or "checked", + # the BUILD_ALT_DIR variable appends "fre" or "chk" to the \obj subdirectory. +DRIVERTYPE=WDM # Set type of driver, can be set to either WDM or VXD. + # For BDA, set to WDM. + +# Generate .SYM and .PDB (map) files. These files map names to addresses. +# Required to debug on Win9x. +USE_MAPSYM=1 + +# Point to the header files that the sample source requires. +INCLUDES= \ + $(DDK_INC_PATH); \ + $(DDK_INC_PATH)\wdm; \ + $(SDK_INC_PATH); \ + $(SDK_PATH)\AMovie\Inc; \ + $(INCLUDES) + +# Point to the library files that the sample source requires. +TARGETLIBS= \ + $(DDK_LIB_PATH)\ks.lib \ + $(DDK_LIB_PATH)\ksguid.lib \ + $(DDK_LIB_PATH)\BdaSup.lib \ + $(DDK_LIB_PATH)\usbd.lib + +# The following macros are used with the Soft-ICE debugging tool. +!ifdef BUILD_SOFTICE_SYMBOLS +TARGETPATHEX=$(TARGETPATH)\$(TARGET_DIRECTORY) + +NTTARGETFILES=$(TARGETPATH)\$(TARGETNAME).dbg + +NTTARGETFILES=$(TARGETPATHEX)\$(TARGETNAME).nms $(NTTARGETFILES) +!endif + +# Source files that must be compiled. +SOURCES = SkyWalker1TunerPin.cpp \ + SkyWalker1AntennaPin.cpp \ + SkyWalker1CaptureFilter.cpp \ + SkyWalker1CaptureFilterDefinitions.cpp \ + SkyWalker1CapturePin.cpp \ + SkyWalker1Control.cpp \ + SkyWalker1Device.cpp \ + SkyWalker1Main.cpp \ + SkyWalker1PnP.cpp \ + SkyWalker1TransportPin.cpp \ + SkyWalker1TunerFilter.cpp \ + SkyWalker1TunerFilterDefinitions.cpp \ + SkyWalker1USB.cpp \ + SkyWalker1Utility.cpp + \ No newline at end of file diff --git a/firmware-driver/Skywalker-1 BDA Driver 08172009.zip b/firmware-driver/Skywalker-1 BDA Driver 08172009.zip new file mode 100644 index 0000000..056c2c9 Binary files /dev/null and b/firmware-driver/Skywalker-1 BDA Driver 08172009.zip differ diff --git a/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker1Installer.inf b/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker1Installer.inf new file mode 100644 index 0000000..1a42430 --- /dev/null +++ b/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker1Installer.inf @@ -0,0 +1,142 @@ +; SkyWalker1Installer.INF -- This file installs SkyWalker1 Driver +; +[Version] +signature="$CHICAGO$" +Class=Media +ClassGUID={4d36e96c-e325-11ce-bfc1-08002be10318} +Provider=%SGI% +CatalogFile=SkyWalker1Installer.cat +DriverVer= 8/17/2009 + +; F i l e c o p y i n g s e c t i o n s (where the files go to). +; +[DestinationDirs] +DefaultDestDir=10,system32\drivers + +[Manufacturer] +%SGI%=SGI + +[ControlFlags] +;ExcludeFromSelect=* +;ExcludeFromSelect.NT=* + +; =================== Generic ================================== + +[SGI] +%SkyWalker1.DeviceDesc%=Skywalker1.Device,USB\VID_09C0&PID_0203 ;SkyWalker1 + +[Skywalker1.Device] +Include = ks.inf, kscaptur.inf, bda.inf +needs = KS.Registration, KSCAPTUR.Registration, BDA.Installation +AddReg = Skywalker1.AddReg +CopyFiles = Skywalker1.CopyDrivers + +[Skywalker1.Device.NT] +Include = ks.inf, kscaptur.inf, bda.inf +needs = KS.Registration.NT, KSCAPTUR.Registration.NT, BDA.Installation.NT +;AddReg = Skywalker1.AddReg +CopyFiles = Skywalker1.CopyDrivers +; KnownFiles = Skywalker1.KnownFiles + +[Skywalker1.Device.NT.Services] +Addservice=SkyWalker1TVTuner, 0x00000002, Skywalker1.AddService + +[Skywalker1.AddService] +DisplayName=%SkyWalker1.FriendlyName% +ServiceType=1 ; SERVICE_KERNEL_DRIVER +StartType=3 ; SERVICE_DEMAND_START +ErrorControl=1 ; SERVICE_ERROR_NORMAL +ServiceBinary=%10%\System32\Drivers\SkyWalker1TVTuner.sys +LoadOrderGroup=ExtendedBase + +[Skywalker1.CopyDrivers] +SkyWalker1TVTuner.sys + +[Skywalker1.AddReg] +HKR,,DevLoader,,*NTKERN +HKR,,NTMPDriver,,SkyWalker1TVTuner.sys +HKR,,PageOutWhenUnopened,3,01 + +[Skywalker1.Device.Interfaces] +AddInterface=%KSCATEGORY_BDA_RECEIVER_COMPONENT%,%SKYWALKER_CAPTURE%,Skywalker1.Receiver.Interfaces +AddInterface=%KSCATEGORY_BDA_NETWORK_TUNER%,%SKYWALKER_TUNER%,Skywalker1.Tuner.Interfaces + +[Skywalker1.Device.NT.Interfaces] +AddInterface=%KSCATEGORY_BDA_RECEIVER_COMPONENT%,%SKYWALKER_CAPTURE%,Skywalker1.Receiver.Interfaces +AddInterface=%KSCATEGORY_BDA_NETWORK_TUNER%,%SKYWALKER_TUNER%,Skywalker1.Tuner.Interfaces + +[Skywalker1.Tuner.Interfaces] +AddReg=Skywalker1.Tuner.Interfaces.AddReg + +[Skywalker1.Tuner.Interfaces.AddReg] +HKR,,CLSID,,%KSProxy.CLSID% +HKR,,FriendlyName,,%SkyWalker1.Tuner.FriendlyName% + +[Skywalker1.Receiver.Interfaces] +AddReg=Skywalker1.Receiver.Interfaces.AddReg + +[Skywalker1.Receiver.Interfaces.AddReg] +HKR,,CLSID,,%KSProxy.CLSID% +HKR,,FriendlyName,,%SkyWalker1.Receiver.FriendlyName% + + +[Strings] +;non-localizable +SGI="Plethorasoft" +MfgName="SGI" +SkyWalker1.DeviceDesc="SkyWalker1 BDA TVTuner" +SkyWalker1.Tuner.FriendlyName="SkyWalker1 TV Tuner" +SkyWalker1.Receiver.FriendlyName="SkyWalker1 TV Receiver" +SkyWalker1.Tuner="SkyWalker1.Tuner" +KSProxy.CLSID="{17CCA71B-ECD7-11D0-B908-00A0C9223196}" +KSCATEGORY_BDA_NETWORK_TUNER="{71985F48-1CA1-11d3-9CC8-00C04F7971E0}" +KSCATEGORY_BDA_RECEIVER_COMPONENT="{FD0A5AF4-B41D-11d2-9C95-00C04F7971E0}" +SKYWALKER_TUNER="{5C4E764F-AB43-46A9-B21E-8529C70F0A23}" +SKYWALKER_CAPTURE="{0F8F74D9-E524-4D05-BB60-F0C69ACB1756}" + +; +; ServiceType values +SERVICE_KERNEL_DRIVER = 0x00000001 +SERVICE_FILE_SYSTEM_DRIVER = 0x00000002 +SERVICE_ADAPTER = 0x00000004 +SERVICE_RECOGNIZER_DRIVER = 0x00000008 +SERVICE_WIN32_OWN_PROCESS = 0x00000010 +SERVICE_WIN32_SHARE_PROCESS = 0x00000020 +SERVICE_INTERACTIVE_PROCESS = 0x00000100 +SERVICE_INTERACTIVE_SHARE_PROCESS = 0x00000120 + +; StartType values +SERVICE_BOOT_START = 0x00000000 +SERVICE_SYSTEM_START = 0x00000001 +SERVICE_AUTO_START = 0x00000002 +SERVICE_DEMAND_START = 0x00000003 +SERVICE_DISABLED = 0x00000004 + +; ErrorControl values +SERVICE_ERROR_IGNORE = 0x00000000 +SERVICE_ERROR_NORMAL = 0x00000001 +SERVICE_ERROR_SEVERE = 0x00000002 +SERVICE_ERROR_CRITICAL = 0x00000003 + +; Characteristic flags +NCF_VIRTUAL = 0x0001 +NCF_WRAPPER = 0x0002 +NCF_PHYSICAL = 0x0004 +NCF_HIDDEN = 0x0008 +NCF_NO_SERVICE = 0x0010 +NCF_NOT_USER_REMOVABLE = 0x0020 +NCF_HAS_UI = 0x0080 +NCF_MODEM = 0x0100 + +; Registry types +REG_MULTI_SZ = 0x10000 +REG_EXPAND_SZ = 0x20000 +REG_DWORD = 0x10001 + +; Win9x Compatible Types +REG_BINARY = 17 +REG_SZ = 0 + +; Service install flags +SPSVCINST_TAGTOFRONT = 0x1 +SPSVCINST_ASSOCSERVICE = 0x2 \ No newline at end of file diff --git a/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker1TVTuner.sys b/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker1TVTuner.sys new file mode 100644 index 0000000..acf255b Binary files /dev/null and b/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker1TVTuner.sys differ diff --git a/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker2Installer.inf b/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker2Installer.inf new file mode 100644 index 0000000..959b14d --- /dev/null +++ b/firmware-driver/Skywalker-1 BDA Driver 08172009/SkyWalker2Installer.inf @@ -0,0 +1,142 @@ +; SkyWalker2Installer.INF -- This file installs SkyWalker2 Driver +; +[Version] +signature="$CHICAGO$" +Class=Media +ClassGUID={4d36e96c-e325-11ce-bfc1-08002be10318} +Provider=%SGI% +CatalogFile=SkyWalker2Installer.cat +DriverVer= 8/17/2009 + +; F i l e c o p y i n g s e c t i o n s (where the files go to). +; +[DestinationDirs] +DefaultDestDir=10,system32\drivers + +[Manufacturer] +%SGI%=SGI + +[ControlFlags] +;ExcludeFromSelect=* +;ExcludeFromSelect.NT=* + +; =================== Generic ================================== + +[SGI] +%SkyWalker2.DeviceDesc%=SkyWalker2.Device,USB\VID_09C0&PID_0206 ;SkyWalker2 + +[SkyWalker2.Device] +Include = ks.inf, kscaptur.inf, bda.inf +needs = KS.Registration, KSCAPTUR.Registration, BDA.Installation +AddReg = SkyWalker2.AddReg +CopyFiles = SkyWalker2.CopyDrivers + +[SkyWalker2.Device.NT] +Include = ks.inf, kscaptur.inf, bda.inf +needs = KS.Registration.NT, KSCAPTUR.Registration.NT, BDA.Installation.NT +;AddReg = SkyWalker2.AddReg +CopyFiles = SkyWalker2.CopyDrivers +; KnownFiles = SkyWalker2.KnownFiles + +[SkyWalker2.Device.NT.Services] +Addservice=SkyWalker2TVTuner, 0x00000002, SkyWalker2.AddService + +[SkyWalker2.AddService] +DisplayName=%SkyWalker2.FriendlyName% +ServiceType=1 ; SERVICE_KERNEL_DRIVER +StartType=3 ; SERVICE_DEMAND_START +ErrorControl=1 ; SERVICE_ERROR_NORMAL +ServiceBinary=%10%\System32\Drivers\SkyWalker1TVTuner.sys +LoadOrderGroup=ExtendedBase + +[SkyWalker2.CopyDrivers] +SkyWalker1TVTuner.sys + +[SkyWalker2.AddReg] +HKR,,DevLoader,,*NTKERN +HKR,,NTMPDriver,,SkyWalker1TVTuner.sys +HKR,,PageOutWhenUnopened,3,01 + +[SkyWalker2.Device.Interfaces] +AddInterface=%KSCATEGORY_BDA_RECEIVER_COMPONENT%,%SKYWALKER_CAPTURE%,SkyWalker2.Receiver.Interfaces +AddInterface=%KSCATEGORY_BDA_NETWORK_TUNER%,%SKYWALKER_TUNER%,SkyWalker2.Tuner.Interfaces + +[SkyWalker2.Device.NT.Interfaces] +AddInterface=%KSCATEGORY_BDA_RECEIVER_COMPONENT%,%SKYWALKER_CAPTURE%,SkyWalker2.Receiver.Interfaces +AddInterface=%KSCATEGORY_BDA_NETWORK_TUNER%,%SKYWALKER_TUNER%,SkyWalker2.Tuner.Interfaces + +[SkyWalker2.Tuner.Interfaces] +AddReg=SkyWalker2.Tuner.Interfaces.AddReg + +[SkyWalker2.Tuner.Interfaces.AddReg] +HKR,,CLSID,,%KSProxy.CLSID% +HKR,,FriendlyName,,%SkyWalker2.Tuner.FriendlyName% + +[SkyWalker2.Receiver.Interfaces] +AddReg=SkyWalker2.Receiver.Interfaces.AddReg + +[SkyWalker2.Receiver.Interfaces.AddReg] +HKR,,CLSID,,%KSProxy.CLSID% +HKR,,FriendlyName,,%SkyWalker2.Receiver.FriendlyName% + + +[Strings] +;non-localizable +SGI="Plethorasoft" +MfgName="SGI" +SkyWalker2.DeviceDesc="SkyWalker2 BDA TVTuner" +SkyWalker2.Tuner.FriendlyName="SkyWalker2 TV Tuner" +SkyWalker2.Receiver.FriendlyName="SkyWalker2 TV Receiver" +SkyWalker2.Tuner="SkyWalker2.Tuner" +KSProxy.CLSID="{17CCA71B-ECD7-11D0-B908-00A0C9223196}" +KSCATEGORY_BDA_NETWORK_TUNER="{71985F48-1CA1-11d3-9CC8-00C04F7971E0}" +KSCATEGORY_BDA_RECEIVER_COMPONENT="{FD0A5AF4-B41D-11d2-9C95-00C04F7971E0}" +SKYWALKER_TUNER="{5C4E764F-AB43-46A9-B21E-8529C70F0A23}" +SKYWALKER_CAPTURE="{0F8F74D9-E524-4D05-BB60-F0C69ACB1756}" + +; +; ServiceType values +SERVICE_KERNEL_DRIVER = 0x00000001 +SERVICE_FILE_SYSTEM_DRIVER = 0x00000002 +SERVICE_ADAPTER = 0x00000004 +SERVICE_RECOGNIZER_DRIVER = 0x00000008 +SERVICE_WIN32_OWN_PROCESS = 0x00000010 +SERVICE_WIN32_SHARE_PROCESS = 0x00000020 +SERVICE_INTERACTIVE_PROCESS = 0x00000100 +SERVICE_INTERACTIVE_SHARE_PROCESS = 0x00000120 + +; StartType values +SERVICE_BOOT_START = 0x00000000 +SERVICE_SYSTEM_START = 0x00000001 +SERVICE_AUTO_START = 0x00000002 +SERVICE_DEMAND_START = 0x00000003 +SERVICE_DISABLED = 0x00000004 + +; ErrorControl values +SERVICE_ERROR_IGNORE = 0x00000000 +SERVICE_ERROR_NORMAL = 0x00000001 +SERVICE_ERROR_SEVERE = 0x00000002 +SERVICE_ERROR_CRITICAL = 0x00000003 + +; Characteristic flags +NCF_VIRTUAL = 0x0001 +NCF_WRAPPER = 0x0002 +NCF_PHYSICAL = 0x0004 +NCF_HIDDEN = 0x0008 +NCF_NO_SERVICE = 0x0010 +NCF_NOT_USER_REMOVABLE = 0x0020 +NCF_HAS_UI = 0x0080 +NCF_MODEM = 0x0100 + +; Registry types +REG_MULTI_SZ = 0x10000 +REG_EXPAND_SZ = 0x20000 +REG_DWORD = 0x10001 + +; Win9x Compatible Types +REG_BINARY = 17 +REG_SZ = 0 + +; Service install flags +SPSVCINST_TAGTOFRONT = 0x1 +SPSVCINST_ASSOCSERVICE = 0x2 \ No newline at end of file diff --git a/firmware-driver/Skywalker-1 BDA Driver 08172009/bdasup.sys b/firmware-driver/Skywalker-1 BDA Driver 08172009/bdasup.sys new file mode 100644 index 0000000..8f308e7 Binary files /dev/null and b/firmware-driver/Skywalker-1 BDA Driver 08172009/bdasup.sys differ diff --git a/firmware-driver/Source.zip b/firmware-driver/Source.zip new file mode 100644 index 0000000..1edf2fd Binary files /dev/null and b/firmware-driver/Source.zip differ