350ec71231cbaede4f474e94c180066b2958835c
[reactos.git] / drivers / wdm / audio / hdaudbus / hdaudbus.cpp
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: drivers/wdm/audio/hdaudbus/hdaudbus.cpp
5 * PURPOSE: HDA Driver Entry
6 * PROGRAMMER: Johannes Anderwald
7 */
8 #include "hdaudbus.h"
9
10 DRIVER_DISPATCH HDA_Pnp;
11 DRIVER_ADD_DEVICE HDA_AddDevice;
12 extern "C" DRIVER_INITIALIZE DriverEntry;
13
14 PVOID
15 AllocateItem(
16 _In_ POOL_TYPE PoolType,
17 _In_ SIZE_T NumberOfBytes)
18 {
19 PVOID Item = ExAllocatePoolWithTag(PoolType, NumberOfBytes, TAG_HDA);
20 if (!Item)
21 return Item;
22
23 RtlZeroMemory(Item, NumberOfBytes);
24 return Item;
25 }
26
27 VOID
28 FreeItem(
29 __drv_freesMem(Mem) PVOID Item)
30 {
31 ExFreePool(Item);
32 }
33
34 NTSTATUS
35 NTAPI
36 HDA_SyncForwardIrpCompletionRoutine(
37 IN PDEVICE_OBJECT DeviceObject,
38 IN PIRP Irp,
39 IN PVOID Context)
40 {
41 if (Irp->PendingReturned)
42 {
43 KeSetEvent((PKEVENT)Context, IO_NO_INCREMENT, FALSE);
44 }
45 return STATUS_MORE_PROCESSING_REQUIRED;
46 }
47
48 NTSTATUS
49 NTAPI
50 HDA_SyncForwardIrp(
51 IN PDEVICE_OBJECT DeviceObject,
52 IN PIRP Irp)
53 {
54 KEVENT Event;
55 NTSTATUS Status;
56
57 /* Initialize event */
58 KeInitializeEvent(&Event, NotificationEvent, FALSE);
59
60 /* Copy irp stack location */
61 IoCopyCurrentIrpStackLocationToNext(Irp);
62
63 /* Set completion routine */
64 IoSetCompletionRoutine(Irp,
65 HDA_SyncForwardIrpCompletionRoutine,
66 &Event,
67 TRUE,
68 TRUE,
69 TRUE);
70
71 /* Call driver */
72 Status = IoCallDriver(DeviceObject, Irp);
73
74 /* Check if pending */
75 if (Status == STATUS_PENDING)
76 {
77 /* Wait for the request to finish */
78 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
79
80 /* Copy status code */
81 Status = Irp->IoStatus.Status;
82 }
83
84 /* Done */
85 return Status;
86 }
87
88 NTSTATUS
89 HDA_FdoPnp(
90 _In_ PDEVICE_OBJECT DeviceObject,
91 _Inout_ PIRP Irp)
92 {
93 NTSTATUS Status;
94 PIO_STACK_LOCATION IoStack;
95 PHDA_FDO_DEVICE_EXTENSION FDODeviceExtension;
96
97 FDODeviceExtension = static_cast<PHDA_FDO_DEVICE_EXTENSION>(DeviceObject->DeviceExtension);
98 IoStack = IoGetCurrentIrpStackLocation(Irp);
99
100 if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
101 {
102 Status = HDA_FDOStartDevice(DeviceObject, Irp);
103 }
104 else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS)
105 {
106 /* handle bus device relations */
107 if (IoStack->Parameters.QueryDeviceRelations.Type == BusRelations)
108 {
109 Status = HDA_FDOQueryBusRelations(DeviceObject, Irp);
110 }
111 else
112 {
113 Status = Irp->IoStatus.Status;
114 }
115 }
116 else
117 {
118 /* get default status */
119 Status = Irp->IoStatus.Status;
120 }
121
122 Irp->IoStatus.Status = Status;
123 IoCompleteRequest(Irp, IO_NO_INCREMENT);
124
125 return Status;
126 }
127
128 NTSTATUS
129 HDA_PdoPnp(
130 _In_ PDEVICE_OBJECT DeviceObject,
131 _Inout_ PIRP Irp)
132 {
133 NTSTATUS Status;
134 PIO_STACK_LOCATION IoStack;
135 PDEVICE_RELATIONS DeviceRelation;
136
137 IoStack = IoGetCurrentIrpStackLocation(Irp);
138
139 if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
140 {
141 /* no op for pdo */
142 Status = STATUS_SUCCESS;
143 }
144 else if (IoStack->MinorFunction == IRP_MN_QUERY_BUS_INFORMATION)
145 {
146 /* query bus information */
147 Status = HDA_PDOQueryBusInformation(Irp);
148 }
149 else if (IoStack->MinorFunction == IRP_MN_QUERY_PNP_DEVICE_STATE)
150 {
151 /* query pnp state */
152 Status = HDA_PDOQueryBusDevicePnpState(Irp);
153 }
154 else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS)
155 {
156 if (IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
157 {
158 /* handle target device relations */
159 ASSERT(IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation);
160 ASSERT(Irp->IoStatus.Information == 0);
161
162 /* allocate device relation */
163 DeviceRelation = (PDEVICE_RELATIONS)AllocateItem(PagedPool, sizeof(DEVICE_RELATIONS));
164 if (DeviceRelation)
165 {
166 DeviceRelation->Count = 1;
167 DeviceRelation->Objects[0] = DeviceObject;
168
169 /* reference self */
170 ObReferenceObject(DeviceObject);
171
172 /* store result */
173 Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
174
175 /* done */
176 Status = STATUS_SUCCESS;
177 }
178 else
179 {
180 /* no memory */
181 Status = STATUS_INSUFFICIENT_RESOURCES;
182 }
183 }
184 }
185 else if (IoStack->MinorFunction == IRP_MN_QUERY_CAPABILITIES)
186 {
187 /* query capabilities */
188 Status = HDA_PDOQueryBusDeviceCapabilities(Irp);
189 }
190 else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCE_REQUIREMENTS)
191 {
192 /* no op */
193 Status = STATUS_SUCCESS;
194 }
195 else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCES)
196 {
197 /* no op */
198 Status = STATUS_SUCCESS;
199 }
200 else if (IoStack->MinorFunction == IRP_MN_QUERY_ID)
201 {
202 Status = HDA_PDOQueryId(DeviceObject, Irp);
203 }
204 else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_TEXT)
205 {
206 Status = HDA_PDOHandleQueryDeviceText(Irp);
207 }
208 else if (IoStack->MinorFunction == IRP_MN_QUERY_INTERFACE)
209 {
210 Status = HDA_PDOHandleQueryInterface(DeviceObject, Irp);
211 }
212 else
213 {
214 /* get default status */
215 Status = Irp->IoStatus.Status;
216 }
217
218 Irp->IoStatus.Status = Status;
219 IoCompleteRequest(Irp, IO_NO_INCREMENT);
220
221 return Status;
222 }
223
224 NTSTATUS
225 NTAPI
226 HDA_Pnp(
227 _In_ PDEVICE_OBJECT DeviceObject,
228 _Inout_ PIRP Irp)
229 {
230 PHDA_FDO_DEVICE_EXTENSION FDODeviceExtension;
231
232 FDODeviceExtension = static_cast<PHDA_FDO_DEVICE_EXTENSION>(DeviceObject->DeviceExtension);
233
234 if (FDODeviceExtension->IsFDO)
235 {
236 return HDA_FdoPnp(DeviceObject, Irp);
237 }
238 else
239 {
240 return HDA_PdoPnp(DeviceObject, Irp);
241 }
242 }
243
244
245 NTSTATUS
246 NTAPI
247 HDA_AddDevice(
248 _In_ PDRIVER_OBJECT DriverObject,
249 _In_ PDEVICE_OBJECT PhysicalDeviceObject)
250 {
251 PDEVICE_OBJECT DeviceObject;
252 PHDA_FDO_DEVICE_EXTENSION DeviceExtension;
253 NTSTATUS Status;
254
255 /* create device object */
256 Status = IoCreateDevice(DriverObject, sizeof(HDA_FDO_DEVICE_EXTENSION), NULL, FILE_DEVICE_BUS_EXTENDER, 0, FALSE, &DeviceObject);
257 if (!NT_SUCCESS(Status))
258 {
259 /* failed */
260 return Status;
261 }
262
263 /* get device extension*/
264 DeviceExtension = (PHDA_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
265
266 /* init device extension*/
267 DeviceExtension->IsFDO = TRUE;
268 DeviceExtension->LowerDevice = IoAttachDeviceToDeviceStack(DeviceObject, PhysicalDeviceObject);
269 RtlZeroMemory(DeviceExtension->Codecs, sizeof(PHDA_CODEC_ENTRY) * (HDA_MAX_CODECS + 1));
270
271 /* set device flags */
272 DeviceObject->Flags |= DO_POWER_PAGABLE;
273
274 return Status;
275 }
276 extern "C"
277 {
278 NTSTATUS
279 NTAPI
280 DriverEntry(
281 _In_ PDRIVER_OBJECT DriverObject,
282 _In_ PUNICODE_STRING RegistryPathName)
283 {
284 DriverObject->DriverExtension->AddDevice = HDA_AddDevice;
285 DriverObject->MajorFunction[IRP_MJ_PNP] = HDA_Pnp;
286
287 return STATUS_SUCCESS;
288 }
289
290 }