[HEADERS]
[reactos.git] / reactos / drivers / base / beep / beep.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: drivers/base/beep/beep.c
5 * PURPOSE: Beep Device Driver
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Eric Kohl
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntddk.h>
13 #include <ntddbeep.h>
14 #ifndef NDEBUG
15 #define NDEBUG
16 #endif
17 #include <debug.h>
18
19 /* TYPES *********************************************************************/
20
21 typedef struct _BEEP_DEVICE_EXTENSION
22 {
23 LONG ReferenceCount;
24 FAST_MUTEX Mutex;
25 KTIMER Timer;
26 LONG TimerActive;
27 PVOID SectionHandle;
28 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
29
30 /* FUNCTIONS *****************************************************************/
31
32 VOID
33 NTAPI
34 BeepDPC(IN PKDPC Dpc,
35 IN PDEVICE_OBJECT DeviceObject,
36 IN PVOID SystemArgument1,
37 IN PVOID SystemArgument2)
38 {
39 PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
40
41 /* Stop the beep */
42 HalMakeBeep(0);
43
44 /* Disable the timer */
45 InterlockedDecrement(&DeviceExtension->TimerActive);
46 }
47
48 DRIVER_DISPATCH BeepCreate;
49 NTSTATUS
50 NTAPI
51 BeepCreate(IN PDEVICE_OBJECT DeviceObject,
52 IN PIRP Irp)
53 {
54 PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
55
56 /* Acquire the mutex and increase reference count */
57 ExAcquireFastMutex(&DeviceExtension->Mutex);
58 if (++DeviceExtension->ReferenceCount == 1)
59 {
60 /* First reference, lock the data section */
61 DeviceExtension->SectionHandle = MmLockPagableDataSection(BeepCreate);
62 }
63
64 /* Release it */
65 ExReleaseFastMutex(&DeviceExtension->Mutex);
66
67 /* Complete the request */
68 Irp->IoStatus.Status = STATUS_SUCCESS;
69 Irp->IoStatus.Information = 0;
70 IoCompleteRequest(Irp, IO_NO_INCREMENT);
71 return STATUS_SUCCESS;
72 }
73
74 DRIVER_DISPATCH BeepClose;
75 NTSTATUS
76 NTAPI
77 BeepClose(IN PDEVICE_OBJECT DeviceObject,
78 IN PIRP Irp)
79 {
80 PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
81
82 /* Acquire the mutex and decrease reference count */
83 ExAcquireFastMutex(&DeviceExtension->Mutex);
84 if (!(--DeviceExtension->ReferenceCount))
85 {
86 /* Check for active timer */
87 if (DeviceExtension->TimerActive)
88 {
89 /* Cancel it */
90 if (KeCancelTimer(&DeviceExtension->Timer))
91 {
92 /* Mark it as cancelled */
93 InterlockedDecrement(&DeviceExtension->TimerActive);
94 }
95 }
96
97 /* Page the driver */
98 MmUnlockPagableImageSection(DeviceExtension->SectionHandle);
99 }
100
101 /* Release the lock */
102 ExReleaseFastMutex(&DeviceExtension->Mutex);
103
104 /* Complete the request */
105 Irp->IoStatus.Status = STATUS_SUCCESS;
106 Irp->IoStatus.Information = 0;
107 IoCompleteRequest(Irp, IO_NO_INCREMENT);
108 return STATUS_SUCCESS;
109 }
110
111 DRIVER_CANCEL BeepCancel;
112 VOID
113 NTAPI
114 BeepCancel(IN PDEVICE_OBJECT DeviceObject,
115 IN PIRP Irp)
116 {
117 /* Check if this is the current request */
118 if (Irp == DeviceObject->CurrentIrp)
119 {
120 /* Clear it */
121 DeviceObject->CurrentIrp = NULL;
122
123 /* Release the cancel lock and start the next packet */
124 IoReleaseCancelSpinLock(Irp->CancelIrql);
125 IoStartNextPacket(DeviceObject, TRUE);
126 }
127 else
128 {
129 /* Otherwise, remove the packet from the queue and relelase the lock */
130 KeRemoveEntryDeviceQueue(&DeviceObject->DeviceQueue,
131 &Irp->Tail.Overlay.DeviceQueueEntry);
132 IoReleaseCancelSpinLock(Irp->CancelIrql);
133 }
134
135 /* Complete the request */
136 Irp->IoStatus.Status = STATUS_CANCELLED;
137 Irp->IoStatus.Information = 0;
138 IoCompleteRequest (Irp, IO_NO_INCREMENT);
139 }
140
141 DRIVER_DISPATCH BeepCleanup;
142 NTSTATUS
143 NTAPI
144 BeepCleanup(IN PDEVICE_OBJECT DeviceObject,
145 IN PIRP Irp)
146 {
147 KIRQL OldIrql, CancelIrql;
148 PKDEVICE_QUEUE_ENTRY Packet;
149 PIRP CurrentIrp;
150
151 /* Raise IRQL and acquire the cancel lock */
152 KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
153 IoAcquireCancelSpinLock(&CancelIrql);
154
155 /* Get the current IRP */
156 CurrentIrp = DeviceObject->CurrentIrp;
157 DeviceObject->CurrentIrp = NULL;
158 while (CurrentIrp)
159 {
160 /* Clear its cancel routine */
161 (VOID)IoSetCancelRoutine(CurrentIrp, NULL);
162
163 /* Cancel the IRP */
164 CurrentIrp->IoStatus.Status = STATUS_CANCELLED;
165 CurrentIrp->IoStatus.Information = 0;
166
167 /* Release the cancel lock and complete it */
168 IoReleaseCancelSpinLock(CancelIrql);
169 IoCompleteRequest(CurrentIrp, IO_NO_INCREMENT);
170
171 /* Reacquire the lock and get the next queue packet */
172 IoAcquireCancelSpinLock(&CancelIrql);
173 Packet = KeRemoveDeviceQueue(&DeviceObject->DeviceQueue);
174 if (Packet)
175 {
176 /* Get the IRP */
177 CurrentIrp = CONTAINING_RECORD(Packet,
178 IRP,
179 Tail.Overlay.DeviceQueueEntry);
180 }
181 else
182 {
183 /* No more IRPs */
184 CurrentIrp = NULL;
185 }
186 }
187
188 /* Release lock and go back to low IRQL */
189 IoReleaseCancelSpinLock(CancelIrql);
190 KeLowerIrql(OldIrql);
191
192 /* Complete the IRP */
193 Irp->IoStatus.Status = STATUS_SUCCESS;
194 Irp->IoStatus.Information = 0;
195 IoCompleteRequest(Irp, IO_NO_INCREMENT);
196
197 /* Stop and beep and return */
198 HalMakeBeep(0);
199 return STATUS_SUCCESS;
200 }
201
202 DRIVER_DISPATCH BeepDeviceControl;
203 NTSTATUS
204 NTAPI
205 BeepDeviceControl(IN PDEVICE_OBJECT DeviceObject,
206 IN PIRP Irp)
207 {
208 PIO_STACK_LOCATION Stack;
209 PBEEP_SET_PARAMETERS BeepParam;
210 NTSTATUS Status;
211
212 /* Get the stack location and parameters */
213 Stack = IoGetCurrentIrpStackLocation(Irp);
214 BeepParam = (PBEEP_SET_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
215
216 /* We only support one IOCTL */
217 if (Stack->Parameters.DeviceIoControl.IoControlCode != IOCTL_BEEP_SET)
218 {
219 /* Unsupported command */
220 Status = STATUS_NOT_IMPLEMENTED;
221 }
222 else
223 {
224 /* Validate the input buffer length */
225 if (Stack->Parameters.DeviceIoControl.InputBufferLength <
226 sizeof(BEEP_SET_PARAMETERS))
227 {
228 /* Invalid buffer */
229 Status = STATUS_INVALID_PARAMETER;
230 }
231 else if ((BeepParam->Frequency != 0) && !(BeepParam->Duration))
232 {
233 /* No duration, return imemdiately */
234 Status = STATUS_SUCCESS;
235 }
236 else
237 {
238 /* We'll queue this request */
239 Status = STATUS_PENDING;
240 }
241 }
242
243 /* Set packet information */
244 Irp->IoStatus.Status = Status;
245 Irp->IoStatus.Information = 0;
246
247 /* Check if we're completing or queuing a packet */
248 if (Status == STATUS_PENDING)
249 {
250 /* Start the queue */
251 IoMarkIrpPending(Irp);
252 IoStartPacket(DeviceObject, Irp, NULL, BeepCancel);
253 }
254 else
255 {
256 /* Complete the request */
257 IoCompleteRequest(Irp, IO_NO_INCREMENT);
258 }
259
260 /* Return */
261 return Status;
262 }
263
264 DRIVER_UNLOAD BeepUnload;
265 VOID
266 NTAPI
267 BeepUnload(IN PDRIVER_OBJECT DriverObject)
268 {
269 PDEVICE_EXTENSION DeviceExtension;
270 PDEVICE_OBJECT DeviceObject;
271
272 /* Get DO and DE */
273 DeviceObject = DriverObject->DeviceObject;
274 DeviceExtension = DeviceObject->DeviceExtension;
275
276 /* Check if the timer is active */
277 if (DeviceExtension->TimerActive)
278 {
279 /* Cancel it */
280 if (KeCancelTimer(&DeviceExtension->Timer))
281 {
282 /* All done */
283 InterlockedDecrement(&DeviceExtension->TimerActive);
284 }
285 }
286
287 /* Delete the object */
288 IoDeleteDevice(DeviceObject);
289 }
290
291 DRIVER_STARTIO BeepStartIo;
292 VOID
293 NTAPI
294 BeepStartIo(IN PDEVICE_OBJECT DeviceObject,
295 IN PIRP Irp)
296 {
297 PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
298 KIRQL CancelIrql;
299 PIO_STACK_LOCATION IoStack;
300 PBEEP_SET_PARAMETERS BeepParam;
301 LARGE_INTEGER DueTime;
302 NTSTATUS Status;
303
304 /* Acquire the cancel lock and make sure the IRP is valid */
305 IoAcquireCancelSpinLock(&CancelIrql);
306 if (!Irp)
307 {
308 /* It's not, release the lock and quit */
309 IoReleaseCancelSpinLock(CancelIrql);
310 return;
311 }
312
313 /* Remove the cancel routine and release the lock */
314 (VOID)IoSetCancelRoutine(Irp, NULL);
315 IoReleaseCancelSpinLock(CancelIrql);
316
317 /* Get the I/O Stack and make sure the request is valid */
318 BeepParam = (PBEEP_SET_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
319 IoStack = IoGetCurrentIrpStackLocation(Irp);
320 if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_BEEP_SET)
321 {
322 /* Check if we have an active timer */
323 if (DeviceExtension->TimerActive)
324 {
325 /* Cancel it */
326 if (KeCancelTimer(&DeviceExtension->Timer))
327 {
328 /* Set the state */
329 InterlockedDecrement(&DeviceExtension->TimerActive);
330 }
331 }
332
333 /* Make the beep */
334 if (HalMakeBeep(BeepParam->Frequency))
335 {
336 /* Beep successful, queue a DPC to stop it */
337 Status = STATUS_SUCCESS;
338 DueTime.QuadPart = BeepParam->Duration * -10000;
339 InterlockedIncrement(&DeviceExtension->TimerActive);
340 KeSetTimer(&DeviceExtension->Timer, DueTime, &DeviceObject->Dpc);
341 }
342 else
343 {
344 /* Beep has failed */
345 Status = STATUS_INVALID_PARAMETER;
346 }
347 }
348 else
349 {
350 /* Invalid request */
351 Status = STATUS_INVALID_PARAMETER;
352 }
353
354 /* Complete the request and start the next packet */
355 Irp->IoStatus.Status = Status;
356 Irp->IoStatus.Information = 0;
357 IoStartNextPacket(DeviceObject, TRUE);
358 IoCompleteRequest(Irp, IO_NO_INCREMENT);
359 }
360
361 NTSTATUS
362 NTAPI
363 DriverEntry(IN PDRIVER_OBJECT DriverObject,
364 IN PUNICODE_STRING RegistryPath)
365 {
366 PDEVICE_EXTENSION DeviceExtension;
367 PDEVICE_OBJECT DeviceObject;
368 UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\Beep");
369 NTSTATUS Status;
370
371 /* Create the device */
372 Status = IoCreateDevice(DriverObject,
373 sizeof(DEVICE_EXTENSION),
374 &DeviceName,
375 FILE_DEVICE_BEEP,
376 0,
377 FALSE,
378 &DeviceObject);
379 if (!NT_SUCCESS(Status)) return Status;
380
381 /* Make it use buffered I/O */
382 DeviceObject->Flags |= DO_BUFFERED_IO;
383
384 /* Setup the Driver Object */
385 DriverObject->MajorFunction[IRP_MJ_CREATE] = BeepCreate;
386 DriverObject->MajorFunction[IRP_MJ_CLOSE] = BeepClose;
387 DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BeepCleanup;
388 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BeepDeviceControl;
389 DriverObject->DriverUnload = BeepUnload;
390 DriverObject->DriverStartIo = BeepStartIo;
391
392 /* Set up device extension */
393 DeviceExtension = DeviceObject->DeviceExtension;
394 DeviceExtension->ReferenceCount = 0;
395 DeviceExtension->TimerActive = FALSE;
396 IoInitializeDpcRequest(DeviceObject, (PIO_DPC_ROUTINE)BeepDPC);
397 KeInitializeTimer(&DeviceExtension->Timer);
398 ExInitializeFastMutex(&DeviceExtension->Mutex);
399
400 /* Page the entire driver */
401 MmPageEntireDriver(DriverEntry);
402 return STATUS_SUCCESS;
403 }
404
405 /* EOF */