[DRIVERS] Use KeClearEvent instead of KeResetEvent where the previous state is not...
[reactos.git] / drivers / wdm / audio / legacy / stream / pnp.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: drivers/wdm/audio/legacy/stream/pnp.c
5 * PURPOSE: pnp handling
6 * PROGRAMMER: Johannes Anderwald
7 */
8
9 #include "stream.h"
10
11 VOID
12 CompleteIrp(
13 IN PIRP Irp,
14 IN NTSTATUS Status,
15 IN ULONG_PTR Information)
16 {
17 Irp->IoStatus.Status = Status;
18 Irp->IoStatus.Information = Information;
19 IoCompleteRequest(Irp, IO_NO_INCREMENT);
20 }
21
22 VOID
23 NTAPI
24 StreamClassReleaseResources(
25 IN PDEVICE_OBJECT DeviceObject)
26 {
27 PSTREAM_DEVICE_EXTENSION DeviceExtension;
28 PLIST_ENTRY Entry;
29 PMEMORY_RESOURCE_LIST Mem;
30
31 /* Get device extension */
32 DeviceExtension = (PSTREAM_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
33
34 /* Disconnect interrupt */
35 if (DeviceExtension->Interrupt)
36 {
37 IoDisconnectInterrupt(DeviceExtension->Interrupt);
38 DeviceExtension->Interrupt = NULL;
39 }
40
41 /* Release DmaAdapter */
42 if (DeviceExtension->DmaAdapter)
43 {
44 DeviceExtension->DmaAdapter->DmaOperations->PutDmaAdapter(DeviceExtension->DmaAdapter);
45 DeviceExtension->DmaAdapter = NULL;
46 }
47
48 /* Release mem mapped I/O */
49 while(!IsListEmpty(&DeviceExtension->MemoryResourceList))
50 {
51 Entry = RemoveHeadList(&DeviceExtension->MemoryResourceList);
52 Mem = (PMEMORY_RESOURCE_LIST)CONTAINING_RECORD(Entry, MEMORY_RESOURCE_LIST, Entry);
53
54 MmUnmapIoSpace(Mem->Start, Mem->Length);
55 ExFreePool(Entry);
56 }
57 }
58
59 BOOLEAN
60 NTAPI
61 StreamClassSynchronize(
62 IN PKINTERRUPT Interrupt,
63 IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
64 IN PVOID SynchronizeContext)
65 {
66 /* This function is used when the driver either implements synchronization on its own
67 * or if there is no interrupt assigned
68 */
69 return SynchronizeRoutine(SynchronizeContext);
70 }
71
72 VOID
73 NTAPI
74 StreamClassInterruptDpc(
75 IN PKDPC Dpc,
76 IN PVOID DeferredContext,
77 IN PVOID SystemArgument1,
78 IN PVOID SystemArgument2)
79 {
80 //TODO
81 //read/write data
82 }
83
84
85 BOOLEAN
86 NTAPI
87 StreamClassInterruptRoutine(
88 IN PKINTERRUPT Interrupt,
89 IN PVOID ServiceContext)
90 {
91 BOOLEAN Ret = FALSE;
92 PSTREAM_DEVICE_EXTENSION DeviceExtension = (PSTREAM_DEVICE_EXTENSION)ServiceContext;
93
94 /* Does the driver implement HwInterrupt routine */
95 if (DeviceExtension->DriverExtension->Data.HwInterrupt)
96 {
97 /* Check if the interrupt was coming from this device */
98 Ret = DeviceExtension->DriverExtension->Data.HwInterrupt(DeviceExtension->DeviceExtension);
99 if (Ret)
100 {
101 /* Interrupt has from this device, schedule a Dpc for us */
102 KeInsertQueueDpc(&DeviceExtension->InterruptDpc, NULL, NULL);
103 }
104 }
105 /* Return result */
106 return Ret;
107 }
108
109
110
111 NTSTATUS
112 NTAPI
113 StreamClassStartDevice(
114 IN PDEVICE_OBJECT DeviceObject,
115 IN PIRP Irp)
116 {
117 PHW_STREAM_REQUEST_BLOCK_EXT RequestBlock;
118 PPORT_CONFIGURATION_INFORMATION Config;
119 PSTREAM_DEVICE_EXTENSION DeviceExtension;
120 PIO_STACK_LOCATION IoStack;
121 PCM_RESOURCE_LIST List;
122 PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
123 PSTREAM_CLASS_DRIVER_EXTENSION DriverObjectExtension;
124 PDMA_ADAPTER Adapter;
125 DEVICE_DESCRIPTION DeviceDesc;
126 NTSTATUS Status = STATUS_SUCCESS;
127 ULONG ResultLength, Index;
128 BOOLEAN bUseDMA, bUseInterrupt;
129 ULONG MapRegisters;
130 KAFFINITY Affinity = 0;
131 PHW_STREAM_DESCRIPTOR StreamDescriptor;
132 PACCESS_RANGE Range;
133 PVOID MappedAddr;
134 PMEMORY_RESOURCE_LIST Mem;
135
136 /* Get current stack location */
137 IoStack = IoGetCurrentIrpStackLocation(Irp);
138
139 /* Get resource list */
140 List = IoStack->Parameters.StartDevice.AllocatedResourcesTranslated;
141 /* Calculate request length */
142 ResultLength = sizeof(HW_STREAM_REQUEST_BLOCK_EXT) + sizeof(PPORT_CONFIGURATION_INFORMATION) + List->List[0].PartialResourceList.Count * sizeof(ACCESS_RANGE);
143
144 /* Allocate Request Block */
145 RequestBlock = ExAllocatePool(NonPagedPool, ResultLength);
146
147 if (!RequestBlock)
148 {
149 /* Not enough memory */
150 CompleteIrp(Irp, STATUS_INSUFFICIENT_RESOURCES, 0);
151 return STATUS_INSUFFICIENT_RESOURCES;
152 }
153
154 /* Get device extension */
155 DeviceExtension = (PSTREAM_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
156
157 /* Get driver object extension */
158 DriverObjectExtension = IoGetDriverObjectExtension(DeviceObject->DriverObject, (PVOID)StreamClassAddDevice);
159
160 /* sanity checks */
161 ASSERT(DeviceExtension);
162 ASSERT(DriverObjectExtension);
163
164 /* Zero request block */
165 RtlZeroMemory(RequestBlock, ResultLength);
166
167 /* Locate Config struct */
168 Config = (PPORT_CONFIGURATION_INFORMATION) (RequestBlock + 1);
169 Range = (PACCESS_RANGE) (Config + 1);
170
171 /* Initialize Request */
172 RequestBlock->Block.SizeOfThisPacket = sizeof(HW_STREAM_REQUEST_BLOCK);
173 RequestBlock->Block.Command = SRB_INITIALIZE_DEVICE;
174 RequestBlock->Block.CommandData.ConfigInfo = Config;
175 KeInitializeEvent(&RequestBlock->Event, SynchronizationEvent, FALSE);
176
177 Config->SizeOfThisPacket = sizeof(PPORT_CONFIGURATION_INFORMATION);
178 Config->HwDeviceExtension = (PVOID) (DeviceExtension + 1);
179 Config->ClassDeviceObject = DeviceObject;
180 Config->PhysicalDeviceObject = DeviceExtension->LowerDeviceObject;
181 Config->RealPhysicalDeviceObject = DeviceExtension->PhysicalDeviceObject;
182 Config->AccessRanges = Range;
183
184 IoGetDeviceProperty(DeviceObject, DevicePropertyBusNumber, sizeof(ULONG), (PVOID)&Config->SystemIoBusNumber, &ResultLength);
185 IoGetDeviceProperty(DeviceObject, DevicePropertyLegacyBusType, sizeof(INTERFACE_TYPE), (PVOID)&Config->AdapterInterfaceType, &ResultLength);
186
187 /* Get resource list */
188 List = IoStack->Parameters.StartDevice.AllocatedResourcesTranslated;
189
190 /* Scan the translated resources */
191 bUseDMA = FALSE;
192 bUseInterrupt = FALSE;
193
194 Range = (PACCESS_RANGE) (Config + 1);
195
196 for(Index = 0; Index < List->List[0].PartialResourceList.Count; Index++)
197 {
198 /* Locate partial descriptor */
199 Descriptor = &List->List[0].PartialResourceList.PartialDescriptors[Index];
200
201 switch(Descriptor->Type)
202 {
203 case CmResourceTypePort:
204 {
205 /* Store resource information in AccessRange struct */
206 Range[Config->NumberOfAccessRanges].RangeLength = Descriptor->u.Port.Length;
207 Range[Config->NumberOfAccessRanges].RangeStart.QuadPart = Descriptor->u.Port.Start.QuadPart;
208 Range[Config->NumberOfAccessRanges].RangeInMemory = FALSE;
209 Config->NumberOfAccessRanges++;
210 break;
211 }
212 case CmResourceTypeInterrupt:
213 {
214 /* Store resource information */
215 Config->BusInterruptLevel = Descriptor->u.Interrupt.Level;
216 Config->BusInterruptVector = Descriptor->u.Interrupt.Vector;
217 Config->InterruptMode = Descriptor->Flags;
218 Affinity = Descriptor->u.Interrupt.Affinity;
219 bUseInterrupt = TRUE;
220 break;
221 }
222 case CmResourceTypeMemory:
223 {
224 Mem = ExAllocatePool(NonPagedPool, sizeof(MEMORY_RESOURCE_LIST));
225 MappedAddr = MmMapIoSpace(Descriptor->u.Memory.Start, Descriptor->u.Memory.Length, MmNonCached);
226 if (!MappedAddr || !Mem)
227 {
228 if (Mem)
229 {
230 /* Release Memory resource descriptor */
231 ExFreePool(Mem);
232 }
233
234 if (MappedAddr)
235 {
236 /* Release mem mapped I/O */
237 MmUnmapIoSpace(MappedAddr, Descriptor->u.Memory.Length);
238 }
239
240 /* Release resources */
241 StreamClassReleaseResources(DeviceObject);
242 /* Complete irp */
243 CompleteIrp(Irp, STATUS_INSUFFICIENT_RESOURCES, 0);
244 ExFreePool(RequestBlock);
245 return STATUS_INSUFFICIENT_RESOURCES;
246 }
247 /* Store range for driver */
248 Range[Config->NumberOfAccessRanges].RangeLength = Descriptor->u.Memory.Length;
249 Range[Config->NumberOfAccessRanges].RangeStart.QuadPart = Descriptor->u.Memory.Start.QuadPart;
250 Range[Config->NumberOfAccessRanges].RangeInMemory = TRUE;
251 Config->NumberOfAccessRanges++;
252 /* Initialize Memory resource descriptor */
253 Mem->Length = Descriptor->u.Memory.Length;
254 Mem->Start = MappedAddr;
255 InsertTailList(&DeviceExtension->MemoryResourceList, &Mem->Entry);
256 break;
257 }
258 case CmResourceTypeDma:
259 {
260 bUseDMA = TRUE;
261 Config->DmaChannel = Descriptor->u.Dma.Channel;
262 break;
263 }
264 }
265 }
266
267 if (!bUseInterrupt || DriverObjectExtension->Data.HwInterrupt == NULL || Config->BusInterruptLevel == 0 || Config->BusInterruptVector == 0)
268 {
269 /* requirements not satisfied */
270 DeviceExtension->SynchronizeFunction = StreamClassSynchronize;
271 }
272 else
273 {
274 /* use real sync routine */
275 DeviceExtension->SynchronizeFunction = KeSynchronizeExecution;
276
277 /* connect interrupt */
278 Status = IoConnectInterrupt(&DeviceExtension->Interrupt,
279 StreamClassInterruptRoutine,
280 (PVOID)DeviceExtension,
281 NULL,
282 Config->BusInterruptVector,
283 Config->BusInterruptLevel,
284 Config->BusInterruptLevel,
285 Config->InterruptMode,
286 TRUE,
287 Affinity,
288 FALSE);
289 if (!NT_SUCCESS(Status))
290 {
291 /* Release resources */
292 StreamClassReleaseResources(DeviceObject);
293 /* Failed to connect interrupt */
294 CompleteIrp(Irp, Status, 0);
295 /* Release request block */
296 ExFreePool(RequestBlock);
297 return Status;
298 }
299
300 /* store interrupt object */
301 Config->InterruptObject = DeviceExtension->Interrupt;
302 }
303
304 /* does the device use DMA */
305 if (bUseDMA && DriverObjectExtension->Data.BusMasterDMA)
306 {
307 /* Zero device description */
308 RtlZeroMemory(&DeviceDesc, sizeof(DEVICE_DESCRIPTION));
309
310 DeviceDesc.Version = DEVICE_DESCRIPTION_VERSION;
311 DeviceDesc.Master = TRUE;
312 DeviceDesc.ScatterGather = TRUE;
313 DeviceDesc.AutoInitialize = FALSE;
314 DeviceDesc.DmaChannel = Config->DmaChannel;
315 DeviceDesc.InterfaceType = Config->AdapterInterfaceType;
316 DeviceDesc.DmaWidth = Width32Bits;
317 DeviceDesc.DmaSpeed = Compatible;
318 DeviceDesc.MaximumLength = MAXULONG;
319 DeviceDesc.Dma32BitAddresses = DriverObjectExtension->Data.Dma24BitAddresses;
320
321 Adapter = IoGetDmaAdapter(DeviceExtension->PhysicalDeviceObject, &DeviceDesc, &MapRegisters);
322 if (!Adapter)
323 {
324 /* Failed to claim DMA Adapter */
325 CompleteIrp(Irp, Status, 0);
326 /* Release resources */
327 StreamClassReleaseResources(DeviceObject);
328 /* Release request block */
329 ExFreePool(RequestBlock);
330 return Status;
331 }
332
333 if (DeviceExtension->DriverExtension->Data.DmaBufferSize)
334 {
335 DeviceExtension->DmaCommonBuffer = Adapter->DmaOperations->AllocateCommonBuffer(Adapter, DeviceExtension->DriverExtension->Data.DmaBufferSize, &DeviceExtension->DmaPhysicalAddress, FALSE);
336 if (!DeviceExtension->DmaCommonBuffer)
337 {
338 /* Failed to allocate a common buffer */
339 CompleteIrp(Irp, Status, 0);
340 /* Release resources */
341 StreamClassReleaseResources(DeviceObject);
342 /* Release request block */
343 ExFreePool(RequestBlock);
344 return Status;
345 }
346 }
347
348
349 DeviceExtension->MapRegisters = MapRegisters;
350 DeviceExtension->DmaAdapter = Adapter;
351 Config->DmaAdapterObject = (PADAPTER_OBJECT)Adapter;
352 }
353
354
355 /* First forward the request to lower attached device object */
356 Status = ForwardIrpSynchronous(DeviceObject, Irp);
357 if (!NT_SUCCESS(Status))
358 {
359 /* Failed to start lower devices */
360 CompleteIrp(Irp, Status, 0);
361 /* Release resources */
362 StreamClassReleaseResources(DeviceObject);
363 /* Release request block */
364 ExFreePool(RequestBlock);
365 return Status;
366 }
367
368 Config->Irp = Irp;
369
370 /* FIXME SYNCHRONIZATION */
371
372 /* Send the request */
373 DriverObjectExtension->Data.HwReceivePacket((PHW_STREAM_REQUEST_BLOCK)RequestBlock);
374 if (RequestBlock->Block.Status == STATUS_PENDING)
375 {
376 /* Request is pending, wait for result */
377 KeWaitForSingleObject(&RequestBlock->Event, Executive, KernelMode, FALSE, NULL);
378 /* Get final status code */
379 Status = RequestBlock->Block.Status;
380 }
381
382 /* Copy stream descriptor size */
383 DeviceExtension->StreamDescriptorSize = Config->StreamDescriptorSize;
384
385 /* check if the request has succeeded or if stream size is valid*/
386 if (!NT_SUCCESS(Status)|| !Config->StreamDescriptorSize)
387 {
388 /* Failed to start device */
389 CompleteIrp(Irp, Status, 0);
390 /* Release resources */
391 StreamClassReleaseResources(DeviceObject);
392 /* Release request block */
393 ExFreePool(RequestBlock);
394 return Status;
395 }
396
397 /* Allocate a stream Descriptor */
398 StreamDescriptor = ExAllocatePool(NonPagedPool, DeviceExtension->StreamDescriptorSize);
399 if (!StreamDescriptor)
400 {
401 /* Not enough memory */
402 CompleteIrp(Irp, STATUS_INSUFFICIENT_RESOURCES, 0);
403 /* Release resources */
404 StreamClassReleaseResources(DeviceObject);
405 /* Release request block */
406 ExFreePool(RequestBlock);
407 return STATUS_INSUFFICIENT_RESOURCES;
408 }
409
410 /* Zero stream descriptor */
411 RtlZeroMemory(StreamDescriptor, DeviceExtension->StreamDescriptorSize);
412
413 /* Setup get stream info struct */
414 RequestBlock->Block.Command = SRB_GET_STREAM_INFO;
415 RequestBlock->Block.CommandData.StreamBuffer = StreamDescriptor;
416 KeClearEvent(&RequestBlock->Event);
417
418 /* send the request */
419 DriverObjectExtension->Data.HwReceivePacket((PHW_STREAM_REQUEST_BLOCK)RequestBlock);
420 if (RequestBlock->Block.Status == STATUS_PENDING)
421 {
422 /* Request is pending, wait for result */
423 KeWaitForSingleObject(&RequestBlock->Event, Executive, KernelMode, FALSE, NULL);
424 /* Get final status code */
425 Status = RequestBlock->Block.Status;
426 }
427
428 if (NT_SUCCESS(Status))
429 {
430 /* store stream descriptor */
431 DeviceExtension->StreamDescriptor = StreamDescriptor;
432 }
433 else
434 {
435 /* cleanup resources */
436 ExFreePool(StreamDescriptor);
437 }
438
439 ExFreePool(RequestBlock);
440 /* Complete Irp */
441 CompleteIrp(Irp, Status, 0);
442 /* Return result */
443 return Status;
444 }
445
446 NTSTATUS
447 NTAPI
448 StreamClassPnp(
449 IN PDEVICE_OBJECT DeviceObject,
450 IN PIRP Irp)
451 {
452 PIO_STACK_LOCATION IoStack;
453
454 /* Get current irp stack location */
455 IoStack = IoGetCurrentIrpStackLocation(Irp);
456
457 switch (IoStack->MinorFunction)
458 {
459 case IRP_MN_START_DEVICE:
460 {
461 return StreamClassStartDevice(DeviceObject, Irp);
462 }
463 }
464
465 IoCompleteRequest(Irp, IO_NO_INCREMENT);
466 return STATUS_NOT_SUPPORTED;
467 }
468
469