← Back to branch summary

~steve-sk2/mingw-w64/oneiric

« back to all changes in this revision

Viewing changes to mingw-w64-headers/ddk/include/ddk/strmini.h

  • Committer: Bazaar Package Importer
  • Author(s): Stephen Kitt
  • Date: 2010-11-18 00:04:46 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20101118000446-xe24b423su55onyl
Tags: 1.0+20101003-1
http://bugs.debian.org/594371
http://bugs.debian.org/569914
http://bugs.debian.org/600451
* New maintainer. (Closes: #594371.)
* New upstream snapshot:
  - Includes getopt.h. (Closes: #569914.)
* Build g++ for Win64. (Closes: #600451.)
* Standards-Version 3.9.1 (new packaging).
* Include patch from
  http://mingw-w64.svn.sourceforge.net/viewvc/mingw-w64?view=revision&revision=3715
  as suggested by Rafaël Carré.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mingw-w64-headers/ddk/include/ddk/strmini.h
8
8
#define STREAMAPI __stdcall
9
9
#define STREAM_SYSTEM_TIME_MASK   ((STREAM_SYSTEM_TIME)0x00000001FFFFFFFF)
10
10
 
11
 
typedef enum
12
 
{
13
 
    DebugLevelFatal = 0,
14
 
    DebugLevelError,
15
 
    DebugLevelWarning,
16
 
    DebugLevelInfo,
17
 
    DebugLevelTrace,
18
 
    DebugLevelVerbose,
19
 
    DebugLevelMaximum
20
 
}STREAM_DEBUG_LEVEL;
21
 
 
 
11
typedef enum {
 
12
  DebugLevelFatal = 0,
 
13
  DebugLevelError,
 
14
  DebugLevelWarning,
 
15
  DebugLevelInfo,
 
16
  DebugLevelTrace,
 
17
  DebugLevelVerbose,
 
18
  DebugLevelMaximum
 
19
} STREAM_DEBUG_LEVEL;
22
20
 
23
21
#if DBG
24
22
 
25
23
#define DebugPrint(x) StreamClassDebugPrint x
26
24
#define DEBUG_BREAKPOINT() DbgBreakPoint()
27
25
#define DEBUG_ASSERT(exp) \
28
 
            if ( !(exp) ) { \
29
 
                StreamClassDebugAssert( __FILE__, __LINE__, #exp, exp); \
30
 
            }
 
26
  if ( !(exp) ) {         \
 
27
    StreamClassDebugAssert( __FILE__, __LINE__, #exp, exp); \
 
28
  }
31
29
#else
32
30
 
33
31
#define DebugPrint(x)
37
35
#endif
38
36
 
39
37
typedef PHYSICAL_ADDRESS STREAM_PHYSICAL_ADDRESS, *PSTREAM_PHYSICAL_ADDRESS;
40
 
typedef unsigned __int64 STREAM_SYSTEM_TIME, *PSTREAM_SYSTEM_TIME;
41
 
typedef unsigned __int64 STREAM_TIMESTAMP, *PSTREAM_TIMESTAMP;
42
 
 
43
 
typedef enum
44
 
{
45
 
    TIME_GET_STREAM_TIME,
46
 
    TIME_READ_ONBOARD_CLOCK,
47
 
    TIME_SET_ONBOARD_CLOCK
48
 
}TIME_FUNCTION;
49
 
 
50
 
typedef struct _HW_TIME_CONTEXT
51
 
{
52
 
    struct _HW_DEVICE_EXTENSION *HwDeviceExtension;
53
 
    struct _HW_STREAM_OBJECT *HwStreamObject;
54
 
    TIME_FUNCTION Function;
55
 
    ULONGLONG Time;
56
 
    ULONGLONG SystemTime;
57
 
}HW_TIME_CONTEXT, *PHW_TIME_CONTEXT;
58
 
 
59
 
typedef struct _HW_EVENT_DESCRIPTOR
60
 
{
61
 
    BOOLEAN Enable;
62
 
    PKSEVENT_ENTRY EventEntry;
63
 
    PKSEVENTDATA EventData;
64
 
    union
65
 
    {
66
 
        struct _HW_STREAM_OBJECT * StreamObject;
67
 
        struct _HW_DEVICE_EXTENSION *DeviceExtension;
68
 
    };
69
 
    ULONG EnableEventSetIndex;
70
 
    PVOID HwInstanceExtension;
71
 
    ULONG Reserved;
 
38
__GNU_EXTENSION typedef unsigned __int64 STREAM_SYSTEM_TIME, *PSTREAM_SYSTEM_TIME;
 
39
__GNU_EXTENSION typedef unsigned __int64 STREAM_TIMESTAMP, *PSTREAM_TIMESTAMP;
 
40
 
 
41
typedef enum {
 
42
  TIME_GET_STREAM_TIME,
 
43
  TIME_READ_ONBOARD_CLOCK,
 
44
  TIME_SET_ONBOARD_CLOCK
 
45
} TIME_FUNCTION;
 
46
 
 
47
typedef struct _HW_TIME_CONTEXT {
 
48
  struct _HW_DEVICE_EXTENSION *HwDeviceExtension;
 
49
  struct _HW_STREAM_OBJECT *HwStreamObject;
 
50
  TIME_FUNCTION Function;
 
51
  ULONGLONG Time;
 
52
  ULONGLONG SystemTime;
 
53
} HW_TIME_CONTEXT, *PHW_TIME_CONTEXT;
 
54
 
 
55
typedef struct _HW_EVENT_DESCRIPTOR {
 
56
  BOOLEAN Enable;
 
57
  PKSEVENT_ENTRY EventEntry;
 
58
  PKSEVENTDATA EventData;
 
59
  __GNU_EXTENSION union {
 
60
    struct _HW_STREAM_OBJECT * StreamObject;
 
61
    struct _HW_DEVICE_EXTENSION *DeviceExtension;
 
62
  };
 
63
  ULONG EnableEventSetIndex;
 
64
  PVOID HwInstanceExtension;
 
65
  ULONG Reserved;
72
66
} HW_EVENT_DESCRIPTOR, *PHW_EVENT_DESCRIPTOR;
73
67
 
74
68
struct _HW_STREAM_REQUEST_BLOCK;
75
69
 
76
 
typedef VOID (STREAMAPI * PHW_RECEIVE_STREAM_DATA_SRB) (IN struct _HW_STREAM_REQUEST_BLOCK * SRB);
77
 
typedef VOID (STREAMAPI * PHW_RECEIVE_STREAM_CONTROL_SRB) (IN struct _HW_STREAM_REQUEST_BLOCK  * SRB);
78
 
typedef NTSTATUS (STREAMAPI * PHW_EVENT_ROUTINE) (IN PHW_EVENT_DESCRIPTOR EventDescriptor);
79
 
typedef VOID (STREAMAPI * PHW_CLOCK_FUNCTION) (IN PHW_TIME_CONTEXT HwTimeContext);
 
70
typedef VOID (STREAMAPI *PHW_RECEIVE_STREAM_DATA_SRB) (IN struct _HW_STREAM_REQUEST_BLOCK *SRB);
 
71
typedef VOID (STREAMAPI *PHW_RECEIVE_STREAM_CONTROL_SRB) (IN struct _HW_STREAM_REQUEST_BLOCK *SRB);
 
72
typedef NTSTATUS (STREAMAPI *PHW_EVENT_ROUTINE) (IN PHW_EVENT_DESCRIPTOR EventDescriptor);
 
73
typedef VOID (STREAMAPI *PHW_CLOCK_FUNCTION) (IN PHW_TIME_CONTEXT HwTimeContext);
80
74
 
81
 
typedef struct _HW_CLOCK_OBJECT
82
 
{
83
 
    PHW_CLOCK_FUNCTION HwClockFunction;
84
 
    ULONG    ClockSupportFlags;
85
 
    ULONG Reserved[2];
 
75
typedef struct _HW_CLOCK_OBJECT {
 
76
  PHW_CLOCK_FUNCTION HwClockFunction;
 
77
  ULONG ClockSupportFlags;
 
78
  ULONG Reserved[2];
86
79
} HW_CLOCK_OBJECT, *PHW_CLOCK_OBJECT;
87
80
 
88
 
#define CLOCK_SUPPORT_CAN_SET_ONBOARD_CLOCK 0x1
 
81
#define CLOCK_SUPPORT_CAN_SET_ONBOARD_CLOCK  0x1
89
82
#define CLOCK_SUPPORT_CAN_READ_ONBOARD_CLOCK 0x2
90
83
#define CLOCK_SUPPORT_CAN_RETURN_STREAM_TIME 0x4
91
84
 
92
 
typedef struct _HW_STREAM_OBJECT
93
 
{
94
 
    ULONG           SizeOfThisPacket;
95
 
    ULONG           StreamNumber;
96
 
    PVOID           HwStreamExtension;
97
 
    PHW_RECEIVE_STREAM_DATA_SRB ReceiveDataPacket;
98
 
    PHW_RECEIVE_STREAM_CONTROL_SRB ReceiveControlPacket;
99
 
    HW_CLOCK_OBJECT HwClockObject;
100
 
    BOOLEAN         Dma;
101
 
    BOOLEAN         Pio;
102
 
    PVOID           HwDeviceExtension;
103
 
    ULONG    StreamHeaderMediaSpecific;
104
 
    ULONG    StreamHeaderWorkspace;
105
 
    BOOLEAN Allocator;
106
 
    PHW_EVENT_ROUTINE HwEventRoutine;
107
 
    ULONG Reserved[2];
 
85
typedef struct _HW_STREAM_OBJECT {
 
86
  ULONG SizeOfThisPacket;
 
87
  ULONG StreamNumber;
 
88
  PVOID HwStreamExtension;
 
89
  PHW_RECEIVE_STREAM_DATA_SRB ReceiveDataPacket;
 
90
  PHW_RECEIVE_STREAM_CONTROL_SRB ReceiveControlPacket;
 
91
  HW_CLOCK_OBJECT HwClockObject;
 
92
  BOOLEAN Dma;
 
93
  BOOLEAN Pio;
 
94
  PVOID HwDeviceExtension;
 
95
  ULONG StreamHeaderMediaSpecific;
 
96
  ULONG StreamHeaderWorkspace;
 
97
  BOOLEAN Allocator;
 
98
  PHW_EVENT_ROUTINE HwEventRoutine;
 
99
  ULONG Reserved[2];
108
100
} HW_STREAM_OBJECT, *PHW_STREAM_OBJECT;
109
101
 
110
 
typedef struct _HW_STREAM_HEADER
111
 
{
112
 
    ULONG           NumberOfStreams;
113
 
    ULONG SizeOfHwStreamInformation;
114
 
    ULONG           NumDevPropArrayEntries;
115
 
    PKSPROPERTY_SET DevicePropertiesArray;
116
 
    ULONG           NumDevEventArrayEntries;
117
 
    PKSEVENT_SET DeviceEventsArray;
118
 
    PKSTOPOLOGY Topology;
119
 
    PHW_EVENT_ROUTINE DeviceEventRoutine;
120
 
    LONG            NumDevMethodArrayEntries;
121
 
    PKSMETHOD_SET   DeviceMethodsArray;
122
 
}HW_STREAM_HEADER, *PHW_STREAM_HEADER;
123
 
 
124
 
typedef struct _HW_STREAM_INFORMATION
125
 
{
126
 
    ULONG           NumberOfPossibleInstances;
127
 
    KSPIN_DATAFLOW  DataFlow;
128
 
    BOOLEAN         DataAccessible;
129
 
    ULONG           NumberOfFormatArrayEntries;
130
 
    PKSDATAFORMAT*  StreamFormatsArray;
131
 
    PVOID           ClassReserved[4];
132
 
    ULONG           NumStreamPropArrayEntries;
133
 
    PKSPROPERTY_SET StreamPropertiesArray;
134
 
    ULONG           NumStreamEventArrayEntries;
135
 
    PKSEVENT_SET StreamEventsArray;
136
 
    GUID*                   Category;
137
 
    GUID*                   Name;
138
 
    ULONG                   MediumsCount;
139
 
    const KSPIN_MEDIUM*     Mediums;
140
 
    BOOLEAN         BridgeStream;
141
 
    ULONG Reserved[2];
142
 
}HW_STREAM_INFORMATION, *PHW_STREAM_INFORMATION;
143
 
 
144
 
 
145
 
typedef struct _HW_STREAM_DESCRIPTOR
146
 
{
147
 
    HW_STREAM_HEADER StreamHeader;
148
 
    HW_STREAM_INFORMATION StreamInfo;
 
102
typedef struct _HW_STREAM_HEADER {
 
103
  ULONG NumberOfStreams;
 
104
  ULONG SizeOfHwStreamInformation;
 
105
  ULONG NumDevPropArrayEntries;
 
106
  PKSPROPERTY_SET DevicePropertiesArray;
 
107
  ULONG NumDevEventArrayEntries;
 
108
  PKSEVENT_SET DeviceEventsArray;
 
109
  PKSTOPOLOGY Topology;
 
110
  PHW_EVENT_ROUTINE DeviceEventRoutine;
 
111
  LONG NumDevMethodArrayEntries;
 
112
  PKSMETHOD_SET DeviceMethodsArray;
 
113
} HW_STREAM_HEADER, *PHW_STREAM_HEADER;
 
114
 
 
115
typedef struct _HW_STREAM_INFORMATION {
 
116
  ULONG NumberOfPossibleInstances;
 
117
  KSPIN_DATAFLOW DataFlow;
 
118
  BOOLEAN DataAccessible;
 
119
  ULONG NumberOfFormatArrayEntries;
 
120
  PKSDATAFORMAT* StreamFormatsArray;
 
121
  PVOID ClassReserved[4];
 
122
  ULONG NumStreamPropArrayEntries;
 
123
  PKSPROPERTY_SET StreamPropertiesArray;
 
124
  ULONG NumStreamEventArrayEntries;
 
125
  PKSEVENT_SET StreamEventsArray;
 
126
  GUID* Category;
 
127
  GUID* Name;
 
128
  ULONG MediumsCount;
 
129
  const KSPIN_MEDIUM* Mediums;
 
130
  BOOLEAN BridgeStream;
 
131
  ULONG Reserved[2];
 
132
} HW_STREAM_INFORMATION, *PHW_STREAM_INFORMATION;
 
133
 
 
134
typedef struct _HW_STREAM_DESCRIPTOR {
 
135
  HW_STREAM_HEADER StreamHeader;
 
136
  HW_STREAM_INFORMATION StreamInfo;
149
137
} HW_STREAM_DESCRIPTOR, *PHW_STREAM_DESCRIPTOR;
150
138
 
151
 
typedef struct _STREAM_TIME_REFERENCE
152
 
{
153
 
    STREAM_TIMESTAMP CurrentOnboardClockValue;
154
 
    LARGE_INTEGER   OnboardClockFrequency;
155
 
    LARGE_INTEGER   CurrentSystemTime;
156
 
    ULONG Reserved[2];
157
 
}STREAM_TIME_REFERENCE, *PSTREAM_TIME_REFERENCE;
158
 
 
159
 
typedef struct _STREAM_DATA_INTERSECT_INFO
160
 
{
161
 
    ULONG StreamNumber;
162
 
    PKSDATARANGE DataRange;
163
 
    PVOID   DataFormatBuffer;
164
 
    ULONG  SizeOfDataFormatBuffer;
165
 
 
166
 
}STREAM_DATA_INTERSECT_INFO, *PSTREAM_DATA_INTERSECT_INFO;
167
 
 
168
 
typedef struct _STREAM_PROPERTY_DESCRIPTOR
169
 
{
170
 
    PKSPROPERTY     Property;
171
 
    ULONG           PropertySetID;
172
 
    PVOID           PropertyInfo;
173
 
    ULONG           PropertyInputSize;
174
 
    ULONG           PropertyOutputSize;
175
 
}STREAM_PROPERTY_DESCRIPTOR, *PSTREAM_PROPERTY_DESCRIPTOR;
176
 
 
177
 
typedef struct _STREAM_METHOD_DESCRIPTOR
178
 
{
179
 
    ULONG               MethodSetID;
180
 
    PKSMETHOD           Method;
181
 
    PVOID               MethodInfo;
182
 
    LONG                MethodInputSize;
183
 
    LONG                MethodOutputSize;
 
139
typedef struct _STREAM_TIME_REFERENCE {
 
140
  STREAM_TIMESTAMP CurrentOnboardClockValue;
 
141
  LARGE_INTEGER OnboardClockFrequency;
 
142
  LARGE_INTEGER CurrentSystemTime;
 
143
  ULONG Reserved[2];
 
144
} STREAM_TIME_REFERENCE, *PSTREAM_TIME_REFERENCE;
 
145
 
 
146
typedef struct _STREAM_DATA_INTERSECT_INFO {
 
147
  ULONG StreamNumber;
 
148
  PKSDATARANGE DataRange;
 
149
  PVOID DataFormatBuffer;
 
150
  ULONG SizeOfDataFormatBuffer;
 
151
} STREAM_DATA_INTERSECT_INFO, *PSTREAM_DATA_INTERSECT_INFO;
 
152
 
 
153
typedef struct _STREAM_PROPERTY_DESCRIPTOR {
 
154
  PKSPROPERTY Property;
 
155
  ULONG PropertySetID;
 
156
  PVOID PropertyInfo;
 
157
  ULONG PropertyInputSize;
 
158
  ULONG PropertyOutputSize;
 
159
} STREAM_PROPERTY_DESCRIPTOR, *PSTREAM_PROPERTY_DESCRIPTOR;
 
160
 
 
161
typedef struct _STREAM_METHOD_DESCRIPTOR {
 
162
  ULONG MethodSetID;
 
163
  PKSMETHOD Method;
 
164
  PVOID MethodInfo;
 
165
  LONG MethodInputSize;
 
166
  LONG MethodOutputSize;
184
167
} STREAM_METHOD_DESCRIPTOR, *PSTREAM_METHOD_DESCRIPTOR;
185
168
 
186
169
#define STREAM_REQUEST_BLOCK_SIZE sizeof(STREAM_REQUEST_BLOCK)
187
170
 
188
 
typedef enum _SRB_COMMAND
189
 
{
190
 
    SRB_READ_DATA,
191
 
    SRB_WRITE_DATA, 
192
 
    SRB_GET_STREAM_STATE,
193
 
    SRB_SET_STREAM_STATE,
194
 
    SRB_SET_STREAM_PROPERTY,
195
 
    SRB_GET_STREAM_PROPERTY,
196
 
    SRB_OPEN_MASTER_CLOCK,
197
 
 
198
 
    SRB_INDICATE_MASTER_CLOCK,
199
 
    SRB_UNKNOWN_STREAM_COMMAND,
200
 
    SRB_SET_STREAM_RATE,
201
 
    SRB_PROPOSE_DATA_FORMAT,
202
 
    SRB_CLOSE_MASTER_CLOCK,
203
 
    SRB_PROPOSE_STREAM_RATE,
204
 
    SRB_SET_DATA_FORMAT,
205
 
    SRB_GET_DATA_FORMAT,
206
 
    SRB_BEGIN_FLUSH,
207
 
    SRB_END_FLUSH,
208
 
 
209
 
    SRB_GET_STREAM_INFO = 0x100,
210
 
    SRB_OPEN_STREAM,
211
 
    SRB_CLOSE_STREAM,
212
 
    SRB_OPEN_DEVICE_INSTANCE,
213
 
    SRB_CLOSE_DEVICE_INSTANCE,
214
 
    SRB_GET_DEVICE_PROPERTY,
215
 
    SRB_SET_DEVICE_PROPERTY,
216
 
    SRB_INITIALIZE_DEVICE,
217
 
    SRB_CHANGE_POWER_STATE,
218
 
    SRB_UNINITIALIZE_DEVICE,
219
 
    SRB_UNKNOWN_DEVICE_COMMAND,
220
 
    SRB_PAGING_OUT_DRIVER,
221
 
    SRB_GET_DATA_INTERSECTION,
222
 
    SRB_INITIALIZATION_COMPLETE,
223
 
    SRB_SURPRISE_REMOVAL
 
171
typedef enum _SRB_COMMAND {
 
172
  SRB_READ_DATA,
 
173
  SRB_WRITE_DATA, 
 
174
  SRB_GET_STREAM_STATE,
 
175
  SRB_SET_STREAM_STATE,
 
176
  SRB_SET_STREAM_PROPERTY,
 
177
  SRB_GET_STREAM_PROPERTY,
 
178
  SRB_OPEN_MASTER_CLOCK,
 
179
 
 
180
  SRB_INDICATE_MASTER_CLOCK,
 
181
  SRB_UNKNOWN_STREAM_COMMAND,
 
182
  SRB_SET_STREAM_RATE,
 
183
  SRB_PROPOSE_DATA_FORMAT,
 
184
  SRB_CLOSE_MASTER_CLOCK,
 
185
  SRB_PROPOSE_STREAM_RATE,
 
186
  SRB_SET_DATA_FORMAT,
 
187
  SRB_GET_DATA_FORMAT,
 
188
  SRB_BEGIN_FLUSH,
 
189
  SRB_END_FLUSH,
 
190
 
 
191
  SRB_GET_STREAM_INFO = 0x100,
 
192
  SRB_OPEN_STREAM,
 
193
  SRB_CLOSE_STREAM,
 
194
  SRB_OPEN_DEVICE_INSTANCE,
 
195
  SRB_CLOSE_DEVICE_INSTANCE,
 
196
  SRB_GET_DEVICE_PROPERTY,
 
197
  SRB_SET_DEVICE_PROPERTY,
 
198
  SRB_INITIALIZE_DEVICE,
 
199
  SRB_CHANGE_POWER_STATE,
 
200
  SRB_UNINITIALIZE_DEVICE,
 
201
  SRB_UNKNOWN_DEVICE_COMMAND,
 
202
  SRB_PAGING_OUT_DRIVER,
 
203
  SRB_GET_DATA_INTERSECTION,
 
204
  SRB_INITIALIZATION_COMPLETE,
 
205
  SRB_SURPRISE_REMOVAL
224
206
 
225
207
#if (NTDDI_VERSION >= NTDDI_WINXP)
226
 
 
227
 
    ,SRB_DEVICE_METHOD
228
 
    ,SRB_STREAM_METHOD
229
 
 
 
208
 ,SRB_DEVICE_METHOD
 
209
 ,SRB_STREAM_METHOD
230
210
#if ( (NTDDI_VERSION >= NTDDI_WINXPSP2) && (NTDDI_VERSION < NTDDI_WS03) ) || (NTDDI_VERSION >= NTDDI_WS03SP1)
231
 
 
232
 
    ,SRB_NOTIFY_IDLE_STATE
233
 
 
234
 
#endif
235
 
 
236
 
#endif
237
 
 
238
 
}SRB_COMMAND;
239
 
 
240
 
typedef struct
241
 
{
242
 
    PHYSICAL_ADDRESS    PhysicalAddress;
243
 
    ULONG               Length;
 
211
 ,SRB_NOTIFY_IDLE_STATE
 
212
#endif
 
213
#endif
 
214
} SRB_COMMAND;
 
215
 
 
216
typedef struct {
 
217
  PHYSICAL_ADDRESS PhysicalAddress;
 
218
  ULONG Length;
244
219
} KSSCATTER_GATHER, *PKSSCATTER_GATHER;
245
220
 
246
221
 
247
 
typedef struct _HW_STREAM_REQUEST_BLOCK
248
 
{
249
 
    ULONG           SizeOfThisPacket;
250
 
    SRB_COMMAND     Command;
251
 
    NTSTATUS        Status;
252
 
    PHW_STREAM_OBJECT StreamObject;
253
 
    PVOID           HwDeviceExtension;
254
 
    PVOID           SRBExtension;
 
222
typedef struct _HW_STREAM_REQUEST_BLOCK {
 
223
  ULONG SizeOfThisPacket;
 
224
  SRB_COMMAND Command;
 
225
  NTSTATUS Status;
 
226
  PHW_STREAM_OBJECT StreamObject;
 
227
  PVOID HwDeviceExtension;
 
228
  PVOID SRBExtension;
255
229
 
256
 
    union _CommandData
257
 
        {
258
 
        PKSSTREAM_HEADER DataBufferArray;
259
 
        PHW_STREAM_DESCRIPTOR StreamBuffer;
260
 
        KSSTATE         StreamState;
261
 
        PSTREAM_TIME_REFERENCE TimeReference;
262
 
        PSTREAM_PROPERTY_DESCRIPTOR PropertyInfo;
263
 
        PKSDATAFORMAT   OpenFormat;
264
 
        struct _PORT_CONFIGURATION_INFORMATION *ConfigInfo;
265
 
        HANDLE          MasterClockHandle;
266
 
        DEVICE_POWER_STATE DeviceState;
267
 
        PSTREAM_DATA_INTERSECT_INFO IntersectInfo;
 
230
  union _CommandData {
 
231
    PKSSTREAM_HEADER DataBufferArray;
 
232
    PHW_STREAM_DESCRIPTOR StreamBuffer;
 
233
    KSSTATE StreamState;
 
234
    PSTREAM_TIME_REFERENCE TimeReference;
 
235
    PSTREAM_PROPERTY_DESCRIPTOR PropertyInfo;
 
236
    PKSDATAFORMAT OpenFormat;
 
237
    struct _PORT_CONFIGURATION_INFORMATION *ConfigInfo;
 
238
    HANDLE MasterClockHandle;
 
239
    DEVICE_POWER_STATE DeviceState;
 
240
    PSTREAM_DATA_INTERSECT_INFO IntersectInfo;
268
241
 
269
242
#if (NTDDI_VERSION >= NTDDI_WINXP)
270
 
        PVOID   MethodInfo;
271
 
        LONG    FilterTypeIndex;
 
243
    PVOID MethodInfo;
 
244
    LONG FilterTypeIndex;
272
245
#if ( (NTDDI_VERSION >= NTDDI_WINXPSP2) && (NTDDI_VERSION < NTDDI_WS03) ) || (NTDDI_VERSION >= NTDDI_WS03SP1)
273
 
        BOOLEAN Idle;
274
 
#endif
275
 
#endif
276
 
 
277
 
    }CommandData;
278
 
 
279
 
    ULONG NumberOfBuffers;
280
 
    ULONG           TimeoutCounter;
281
 
    ULONG           TimeoutOriginal;
282
 
    struct _HW_STREAM_REQUEST_BLOCK *NextSRB;
283
 
 
284
 
    PIRP            Irp;
285
 
    ULONG           Flags;
286
 
    PVOID       HwInstanceExtension;
287
 
 
288
 
    union
289
 
        {
290
 
        ULONG           NumberOfBytesToTransfer;
291
 
        ULONG           ActualBytesTransferred;
292
 
    };
293
 
 
294
 
    PKSSCATTER_GATHER ScatterGatherBuffer;
295
 
    ULONG           NumberOfPhysicalPages;
296
 
    ULONG           NumberOfScatterGatherElements;
297
 
    ULONG Reserved[1];
298
 
 
299
 
}HW_STREAM_REQUEST_BLOCK, *PHW_STREAM_REQUEST_BLOCK;
 
246
    BOOLEAN Idle;
 
247
#endif
 
248
#endif
 
249
  } CommandData;
 
250
 
 
251
  ULONG NumberOfBuffers;
 
252
  ULONG TimeoutCounter;
 
253
  ULONG TimeoutOriginal;
 
254
  struct _HW_STREAM_REQUEST_BLOCK *NextSRB;
 
255
 
 
256
  PIRP Irp;
 
257
  ULONG Flags;
 
258
  PVOID HwInstanceExtension;
 
259
 
 
260
  __GNU_EXTENSION union {
 
261
    ULONG NumberOfBytesToTransfer;
 
262
    ULONG ActualBytesTransferred;
 
263
  };
 
264
 
 
265
  PKSSCATTER_GATHER ScatterGatherBuffer;
 
266
  ULONG NumberOfPhysicalPages;
 
267
  ULONG NumberOfScatterGatherElements;
 
268
  ULONG Reserved[1];
 
269
} HW_STREAM_REQUEST_BLOCK, *PHW_STREAM_REQUEST_BLOCK;
300
270
 
301
271
#define SRB_HW_FLAGS_DATA_TRANSFER  0x01
302
272
#define SRB_HW_FLAGS_STREAM_REQUEST 0x2
303
273
 
304
 
typedef enum
305
 
{
306
 
    PerRequestExtension,
307
 
    DmaBuffer,
308
 
    SRBDataBuffer
309
 
}STREAM_BUFFER_TYPE;
310
 
 
311
 
typedef struct _ACCESS_RANGE
312
 
{
313
 
    STREAM_PHYSICAL_ADDRESS RangeStart;
314
 
    ULONG           RangeLength;
315
 
    BOOLEAN         RangeInMemory;
316
 
    ULONG           Reserved;
317
 
}ACCESS_RANGE, *PACCESS_RANGE;
318
 
 
319
 
typedef struct _PORT_CONFIGURATION_INFORMATION
320
 
{
321
 
    ULONG           SizeOfThisPacket;
322
 
    PVOID           HwDeviceExtension;
323
 
    PDEVICE_OBJECT  ClassDeviceObject;
324
 
    PDEVICE_OBJECT  PhysicalDeviceObject;
325
 
    ULONG           SystemIoBusNumber;
326
 
    INTERFACE_TYPE  AdapterInterfaceType;   
327
 
    ULONG           BusInterruptLevel;
328
 
    ULONG           BusInterruptVector;
329
 
    KINTERRUPT_MODE InterruptMode;
330
 
    ULONG           DmaChannel;
331
 
    ULONG           NumberOfAccessRanges;
332
 
    PACCESS_RANGE   AccessRanges;
333
 
    ULONG           StreamDescriptorSize;
334
 
    PIRP            Irp;
335
 
    PKINTERRUPT  InterruptObject;
336
 
    PADAPTER_OBJECT  DmaAdapterObject;
337
 
    PDEVICE_OBJECT  RealPhysicalDeviceObject;
338
 
    ULONG Reserved[1];
339
 
}PORT_CONFIGURATION_INFORMATION, *PPORT_CONFIGURATION_INFORMATION;
340
 
 
341
 
typedef VOID (STREAMAPI * PHW_RECEIVE_DEVICE_SRB) (IN PHW_STREAM_REQUEST_BLOCK SRB);
342
 
typedef VOID (STREAMAPI * PHW_CANCEL_SRB) (IN PHW_STREAM_REQUEST_BLOCK SRB);
343
 
typedef VOID (STREAMAPI * PHW_REQUEST_TIMEOUT_HANDLER) (IN PHW_STREAM_REQUEST_BLOCK SRB);
344
 
typedef BOOLEAN (STREAMAPI * PHW_INTERRUPT) (IN PVOID DeviceExtension);
345
 
typedef VOID (STREAMAPI * PHW_TIMER_ROUTINE) (IN PVOID Context);
346
 
typedef VOID (STREAMAPI * PHW_PRIORITY_ROUTINE) (IN PVOID Context);
347
 
typedef VOID (STREAMAPI * PHW_QUERY_CLOCK_ROUTINE) (IN PHW_TIME_CONTEXT TimeContext);
348
 
typedef BOOLEAN (STREAMAPI * PHW_RESET_ADAPTER) (IN PVOID DeviceExtension);
349
 
 
350
 
typedef enum _STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE
351
 
{
352
 
    ReadyForNextStreamDataRequest,
353
 
    ReadyForNextStreamControlRequest,
354
 
    HardwareStarved,
355
 
    StreamRequestComplete,
356
 
    SignalMultipleStreamEvents,
357
 
    SignalStreamEvent,
358
 
    DeleteStreamEvent,
359
 
    StreamNotificationMaximum
360
 
}STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE, *PSTREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE;
361
 
 
362
 
typedef enum _STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE
363
 
{
364
 
    ReadyForNextDeviceRequest,
365
 
    DeviceRequestComplete,
366
 
    SignalMultipleDeviceEvents,
367
 
    SignalDeviceEvent,
368
 
    DeleteDeviceEvent,
 
274
typedef enum {
 
275
  PerRequestExtension,
 
276
  DmaBuffer,
 
277
  SRBDataBuffer
 
278
} STREAM_BUFFER_TYPE;
 
279
 
 
280
typedef struct _ACCESS_RANGE {
 
281
  STREAM_PHYSICAL_ADDRESS RangeStart;
 
282
  ULONG RangeLength;
 
283
  BOOLEAN RangeInMemory;
 
284
  ULONG Reserved;
 
285
} ACCESS_RANGE, *PACCESS_RANGE;
 
286
 
 
287
typedef struct _PORT_CONFIGURATION_INFORMATION {
 
288
  ULONG SizeOfThisPacket;
 
289
  PVOID HwDeviceExtension;
 
290
  PDEVICE_OBJECT ClassDeviceObject;
 
291
  PDEVICE_OBJECT PhysicalDeviceObject;
 
292
  ULONG SystemIoBusNumber;
 
293
  INTERFACE_TYPE AdapterInterfaceType;
 
294
  ULONG BusInterruptLevel;
 
295
  ULONG BusInterruptVector;
 
296
  KINTERRUPT_MODE InterruptMode;
 
297
  ULONG DmaChannel;
 
298
  ULONG NumberOfAccessRanges;
 
299
  PACCESS_RANGE AccessRanges;
 
300
  ULONG StreamDescriptorSize;
 
301
  PIRP Irp;
 
302
  PKINTERRUPT InterruptObject;
 
303
  PADAPTER_OBJECT DmaAdapterObject;
 
304
  PDEVICE_OBJECT RealPhysicalDeviceObject;
 
305
  ULONG Reserved[1];
 
306
} PORT_CONFIGURATION_INFORMATION, *PPORT_CONFIGURATION_INFORMATION;
 
307
 
 
308
typedef VOID (STREAMAPI *PHW_RECEIVE_DEVICE_SRB) (IN PHW_STREAM_REQUEST_BLOCK SRB);
 
309
typedef VOID (STREAMAPI *PHW_CANCEL_SRB) (IN PHW_STREAM_REQUEST_BLOCK SRB);
 
310
typedef VOID (STREAMAPI *PHW_REQUEST_TIMEOUT_HANDLER) (IN PHW_STREAM_REQUEST_BLOCK SRB);
 
311
typedef BOOLEAN (STREAMAPI *PHW_INTERRUPT) (IN PVOID DeviceExtension);
 
312
typedef VOID (STREAMAPI *PHW_TIMER_ROUTINE) (IN PVOID Context);
 
313
typedef VOID (STREAMAPI *PHW_PRIORITY_ROUTINE) (IN PVOID Context);
 
314
typedef VOID (STREAMAPI *PHW_QUERY_CLOCK_ROUTINE) (IN PHW_TIME_CONTEXT TimeContext);
 
315
typedef BOOLEAN (STREAMAPI *PHW_RESET_ADAPTER) (IN PVOID DeviceExtension);
 
316
 
 
317
typedef enum _STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE {
 
318
  ReadyForNextStreamDataRequest,
 
319
  ReadyForNextStreamControlRequest,
 
320
  HardwareStarved,
 
321
  StreamRequestComplete,
 
322
  SignalMultipleStreamEvents,
 
323
  SignalStreamEvent,
 
324
  DeleteStreamEvent,
 
325
  StreamNotificationMaximum
 
326
} STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE, *PSTREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE;
 
327
 
 
328
typedef enum _STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE {
 
329
  ReadyForNextDeviceRequest,
 
330
  DeviceRequestComplete,
 
331
  SignalMultipleDeviceEvents,
 
332
  SignalDeviceEvent,
 
333
  DeleteDeviceEvent,
369
334
#if (NTDDI_VERSION >= NTDDI_WINXP)
370
 
    SignalMultipleDeviceInstanceEvents,
 
335
  SignalMultipleDeviceInstanceEvents,
371
336
#endif
372
 
    DeviceNotificationMaximum
 
337
  DeviceNotificationMaximum
373
338
} STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE, *PSTREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE;
374
339
 
375
340
#define STREAM_CLASS_VERSION_20 0x0200
376
341
 
377
342
typedef struct _HW_INITIALIZATION_DATA {
378
343
#if (NTDDI_VERSION >= NTDDI_WINXP)
379
 
    union
380
 
        {
381
 
        ULONG           HwInitializationDataSize;
382
 
        struct
383
 
                {
384
 
            USHORT      SizeOfThisPacket;
385
 
            USHORT      StreamClassVersion;
386
 
        };
 
344
  __GNU_EXTENSION union {
 
345
    ULONG HwInitializationDataSize;
 
346
    __GNU_EXTENSION struct {
 
347
      USHORT SizeOfThisPacket;
 
348
      USHORT StreamClassVersion;
387
349
    };
 
350
  };
388
351
#else
389
 
    ULONG           HwInitializationDataSize;
390
 
#endif
 
352
  ULONG HwInitializationDataSize;
 
353
#endif /* NTDDI_VERSION >= NTDDI_WINXP */
391
354
 
392
 
    PHW_INTERRUPT   HwInterrupt;
393
 
    PHW_RECEIVE_DEVICE_SRB HwReceivePacket;
394
 
    PHW_CANCEL_SRB  HwCancelPacket;
395
 
    PHW_REQUEST_TIMEOUT_HANDLER HwRequestTimeoutHandler;
396
 
    ULONG           DeviceExtensionSize;
397
 
    ULONG           PerRequestExtensionSize;
398
 
    ULONG           PerStreamExtensionSize;
399
 
    ULONG           FilterInstanceExtensionSize;
400
 
    BOOLEAN         BusMasterDMA;
401
 
    BOOLEAN         Dma24BitAddresses;
402
 
    ULONG           BufferAlignment;
403
 
    BOOLEAN         TurnOffSynchronization;
404
 
    ULONG           DmaBufferSize;
 
355
  PHW_INTERRUPT HwInterrupt;
 
356
  PHW_RECEIVE_DEVICE_SRB HwReceivePacket;
 
357
  PHW_CANCEL_SRB HwCancelPacket;
 
358
  PHW_REQUEST_TIMEOUT_HANDLER HwRequestTimeoutHandler;
 
359
  ULONG DeviceExtensionSize;
 
360
  ULONG PerRequestExtensionSize;
 
361
  ULONG PerStreamExtensionSize;
 
362
  ULONG FilterInstanceExtensionSize;
 
363
  BOOLEAN BusMasterDMA;
 
364
  BOOLEAN Dma24BitAddresses;
 
365
  ULONG BufferAlignment;
 
366
  BOOLEAN TurnOffSynchronization;
 
367
  ULONG DmaBufferSize;
405
368
 
406
369
#if (NTDDI_VERSION >= NTDDI_WINXP)
407
 
    ULONG                       NumNameExtensions;
408
 
    PWCHAR                      *NameExtensionArray;
 
370
  ULONG NumNameExtensions;
 
371
  PWCHAR *NameExtensionArray;
409
372
#else
410
 
    ULONG Reserved[2];
 
373
  ULONG Reserved[2];
411
374
#endif
412
375
} HW_INITIALIZATION_DATA, *PHW_INITIALIZATION_DATA;
413
376
 
414
 
typedef enum _STREAM_PRIORITY 
415
 
{
416
 
    High,
417
 
    Dispatch,
418
 
    Low,
419
 
    LowToHigh
420
 
}STREAM_PRIORITY, *PSTREAM_PRIORITY;
 
377
typedef enum _STREAM_PRIORITY {
 
378
  High,
 
379
  Dispatch,
 
380
  Low,
 
381
  LowToHigh
 
382
} STREAM_PRIORITY, *PSTREAM_PRIORITY;
421
383
 
422
384
 
423
385
VOID
424
386
StreamClassAbortOutstandingRequests(
425
 
    IN PVOID HwDeviceExtension,
426
 
    IN PHW_STREAM_OBJECT HwStreamObject,
427
 
    IN NTSTATUS Status
428
 
);
 
387
  IN PVOID HwDeviceExtension,
 
388
  IN PHW_STREAM_OBJECT HwStreamObject,
 
389
  IN NTSTATUS Status);
429
390
 
430
391
VOID
431
392
STREAMAPI 
432
393
StreamClassCallAtNewPriority(
433
 
    IN PHW_STREAM_OBJECT  StreamObject,
434
 
    IN PVOID  HwDeviceExtension,
435
 
    IN STREAM_PRIORITY  Priority,
436
 
    IN PHW_PRIORITY_ROUTINE  PriorityRoutine,
437
 
    IN PVOID  Context
438
 
    );
439
 
        
 
394
  IN PHW_STREAM_OBJECT StreamObject,
 
395
  IN PVOID HwDeviceExtension,
 
396
  IN STREAM_PRIORITY Priority,
 
397
  IN PHW_PRIORITY_ROUTINE PriorityRoutine,
 
398
  IN PVOID Context);
 
399
 
440
400
VOID
441
401
STREAMAPI
442
402
StreamClassCompleteRequestAndMarkQueueReady(
443
 
    IN PHW_STREAM_REQUEST_BLOCK Srb
444
 
);      
 
403
  IN PHW_STREAM_REQUEST_BLOCK Srb);
445
404
 
446
405
VOID
447
406
STREAMAPI
448
407
StreamClassDebugAssert(
449
 
    IN PCHAR File,
450
 
    IN ULONG Line,
451
 
    IN PCHAR AssertText,
452
 
    IN ULONG AssertValue
453
 
);
 
408
  IN PCHAR File,
 
409
  IN ULONG Line,
 
410
  IN PCHAR AssertText,
 
411
  IN ULONG AssertValue);
454
412
 
455
413
VOID
456
414
__cdecl
457
415
StreamClassDebugPrint(
458
 
    IN STREAM_DEBUG_LEVEL DebugPrintLevel,
459
 
    IN PCCHAR DebugMessage,
460
 
    ...
461
 
);
 
416
  IN STREAM_DEBUG_LEVEL DebugPrintLevel,
 
417
  IN PCCHAR DebugMessage,
 
418
  ...);
462
419
 
463
420
VOID
464
421
__cdecl
465
422
StreamClassDeviceNotification(
466
 
    IN STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE NotificationType,
467
 
    IN PVOID HwDeviceExtension,
468
 
    IN PHW_STREAM_REQUEST_BLOCK  pSrb,
469
 
    IN PKSEVENT_ENTRY  EventEntry,
470
 
    IN GUID  *EventSet,
471
 
    IN ULONG  EventId
472
 
);
 
423
  IN STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE NotificationType,
 
424
  IN PVOID HwDeviceExtension,
 
425
  IN PHW_STREAM_REQUEST_BLOCK pSrb,
 
426
  IN PKSEVENT_ENTRY EventEntry,
 
427
  IN GUID *EventSet,
 
428
  IN ULONG EventId);
473
429
 
474
430
VOID
475
431
STREAMAPI
476
432
StreamClassFilterReenumerateStreams(
477
 
    IN PVOID HwInstanceExtension,
478
 
    IN ULONG StreamDescriptorSize
479
 
);
 
433
  IN PVOID HwInstanceExtension,
 
434
  IN ULONG StreamDescriptorSize);
480
435
 
481
436
PVOID
482
437
STREAMAPI
483
438
StreamClassGetDmaBuffer(
484
 
    IN PVOID HwDeviceExtension
485
 
);
 
439
  IN PVOID HwDeviceExtension);
486
440
 
487
441
 
488
442
PKSEVENT_ENTRY
489
443
StreamClassGetNextEvent(
490
 
    IN PVOID HwInstanceExtension_OR_HwDeviceExtension,
491
 
    IN PHW_STREAM_OBJECT HwStreamObject,
492
 
    IN GUID * EventGuid,
493
 
    IN ULONG EventItem,
494
 
    IN PKSEVENT_ENTRY CurrentEvent
495
 
);
 
444
  IN PVOID HwInstanceExtension_OR_HwDeviceExtension,
 
445
  IN PHW_STREAM_OBJECT HwStreamObject,
 
446
  IN GUID * EventGuid,
 
447
  IN ULONG EventItem,
 
448
  IN PKSEVENT_ENTRY CurrentEvent);
496
449
 
497
450
STREAM_PHYSICAL_ADDRESS
498
451
STREAMAPI
499
452
StreamClassGetPhysicalAddress(
500
 
    IN PVOID HwDeviceExtension,
501
 
    IN PHW_STREAM_REQUEST_BLOCK HwSRB,
502
 
    IN PVOID VirtualAddress,
503
 
    IN STREAM_BUFFER_TYPE Type,
504
 
    IN ULONG * Length
505
 
);
 
453
  IN PVOID HwDeviceExtension,
 
454
  IN PHW_STREAM_REQUEST_BLOCK HwSRB,
 
455
  IN PVOID VirtualAddress,
 
456
  IN STREAM_BUFFER_TYPE Type,
 
457
  IN ULONG *Length);
506
458
 
507
459
VOID
508
460
StreamClassQueryMasterClock(
509
 
    IN PHW_STREAM_OBJECT HwStreamObject,
510
 
    IN HANDLE MasterClockHandle,
511
 
    IN TIME_FUNCTION TimeFunction,
512
 
    IN PHW_QUERY_CLOCK_ROUTINE ClockCallbackRoutine
513
 
);
 
461
  IN PHW_STREAM_OBJECT HwStreamObject,
 
462
  IN HANDLE MasterClockHandle,
 
463
  IN TIME_FUNCTION TimeFunction,
 
464
  IN PHW_QUERY_CLOCK_ROUTINE ClockCallbackRoutine);
514
465
 
515
466
VOID
516
467
STREAMAPI
517
468
StreamClassQueryMasterClockSync(
518
 
    IN HANDLE MasterClockHandle,
519
 
    IN PHW_TIME_CONTEXT TimeContext
520
 
);
 
469
  IN HANDLE MasterClockHandle,
 
470
  IN PHW_TIME_CONTEXT TimeContext);
521
471
 
522
472
BOOLEAN
523
473
STREAMAPI
524
 
StreamClassReadWriteConfig( 
525
 
    IN PVOID HwDeviceExtension,
526
 
    IN BOOLEAN Read,
527
 
    IN PVOID Buffer,
528
 
    IN ULONG Offset,
529
 
    IN ULONG Length
530
 
);
 
474
StreamClassReadWriteConfig(
 
475
  IN PVOID HwDeviceExtension,
 
476
  IN BOOLEAN Read,
 
477
  IN PVOID Buffer,
 
478
  IN ULONG Offset,
 
479
  IN ULONG Length);
531
480
 
532
481
VOID
533
482
STREAMAPI
534
483
StreamClassReenumerateStreams(
535
 
    IN PVOID HwDeviceExtension,
536
 
    IN ULONG StreamDescriptorSize
537
 
);
 
484
  IN PVOID HwDeviceExtension,
 
485
  IN ULONG StreamDescriptorSize);
538
486
 
539
487
NTSTATUS
540
488
STREAMAPI
541
489
StreamClassRegisterAdapter(
542
 
    IN PVOID Argument1,
543
 
    IN PVOID Argument2,
544
 
    IN PHW_INITIALIZATION_DATA HwInitializationData
545
 
);
 
490
  IN PVOID Argument1,
 
491
  IN PVOID Argument2,
 
492
  IN PHW_INITIALIZATION_DATA HwInitializationData);
546
493
 
547
494
#define StreamClassRegisterMinidriver StreamClassRegisterAdapter
548
495
 
549
496
NTSTATUS
550
 
StreamClassRegisterFilterWithNoKSPins( 
551
 
    IN PDEVICE_OBJECT   DeviceObject,
552
 
    IN const GUID     * InterfaceClassGUID,
553
 
    IN ULONG            PinCount,
554
 
    IN BOOLEAN * PinDirection,
555
 
    IN KSPIN_MEDIUM * MediumList,
556
 
    IN GUID * CategoryList
557
 
);
 
497
StreamClassRegisterFilterWithNoKSPins(
 
498
  IN PDEVICE_OBJECT DeviceObject,
 
499
  IN const GUID *InterfaceClassGUID,
 
500
  IN ULONG PinCount,
 
501
  IN BOOLEAN *PinDirection,
 
502
  IN KSPIN_MEDIUM *MediumList,
 
503
  IN GUID *CategoryList);
558
504
 
559
505
VOID
560
506
STREAMAPI
561
507
StreamClassScheduleTimer(
562
 
    IN PHW_STREAM_OBJECT StreamObject,
563
 
    IN PVOID HwDeviceExtension,
564
 
    IN ULONG NumberOfMicroseconds,
565
 
    IN PHW_TIMER_ROUTINE TimerRoutine,
566
 
    IN PVOID Context
567
 
);
 
508
  IN PHW_STREAM_OBJECT StreamObject,
 
509
  IN PVOID HwDeviceExtension,
 
510
  IN ULONG NumberOfMicroseconds,
 
511
  IN PHW_TIMER_ROUTINE TimerRoutine,
 
512
  IN PVOID Context);
568
513
 
569
514
VOID
570
515
__cdecl
571
516
StreamClassStreamNotification(
572
 
    IN STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE NotificationType,
573
 
    IN PHW_STREAM_OBJECT StreamObject,
574
 
    IN ...
575
 
);
 
517
  IN STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE NotificationType,
 
518
  IN PHW_STREAM_OBJECT StreamObject,
 
519
  IN ...);
576
520
 
577
 
#endif
 
521
#endif /* _STREAM_H */