bfc1b1f058cb430b99ae2d189bc6a94032ebebc8
[reactos.git] / reactos / drivers / dd / beep / beep.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: services/dd/beep/beep.c
6 * PURPOSE: BEEP device driver
7 * PROGRAMMER: Eric Kohl (ekohl@rz-online.de)
8 * UPDATE HISTORY:
9 * 30/01/99 Created
10 * 16/10/99 Minor fixes
11 */
12
13 /* INCLUDES ****************************************************************/
14
15 #include <ntddk.h>
16 #include <ntddbeep.h>
17
18 #define NDEBUG
19 #include <debug.h>
20
21 NTSTATUS STDCALL
22 DriverEntry(PDRIVER_OBJECT DriverObject,
23 PUNICODE_STRING RegistryPath);
24
25 /* TYEPEDEFS ***************************************************************/
26
27 typedef struct _BEEP_DEVICE_EXTENSION
28 {
29 KDPC Dpc;
30 KTIMER Timer;
31 KEVENT Event;
32 BOOLEAN BeepOn;
33 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
34
35
36 /* FUNCTIONS ***************************************************************/
37
38 static VOID STDCALL
39 BeepDPC(PKDPC Dpc,
40 PVOID DeferredContext,
41 PVOID SystemArgument1,
42 PVOID SystemArgument2)
43 {
44 PDEVICE_EXTENSION DeviceExtension = DeferredContext;
45
46 DPRINT("BeepDPC() called!\n");
47
48 HalMakeBeep(0);
49 DeviceExtension->BeepOn = FALSE;
50 KeSetEvent(&DeviceExtension->Event,
51 0,
52 FALSE);
53
54 DPRINT("BeepDPC() finished!\n");
55 }
56
57
58 static NTSTATUS STDCALL
59 BeepCreate(
60 PDEVICE_OBJECT DeviceObject,
61 PIRP Irp)
62 /*
63 * FUNCTION: Handles user mode requests
64 * ARGUMENTS:
65 * DeviceObject = Device for request
66 * Irp = I/O request packet describing request
67 * RETURNS: Success or failure
68 */
69 {
70 DPRINT("BeepCreate() called!\n");
71
72 Irp->IoStatus.Status = STATUS_SUCCESS;
73 Irp->IoStatus.Information = 0;
74 IoCompleteRequest(Irp,
75 IO_NO_INCREMENT);
76
77 return(STATUS_SUCCESS);
78 }
79
80
81 static NTSTATUS STDCALL
82 BeepClose(PDEVICE_OBJECT DeviceObject,
83 PIRP Irp)
84 /*
85 * FUNCTION: Handles user mode requests
86 * ARGUMENTS:
87 * DeviceObject = Device for request
88 * Irp = I/O request packet describing request
89 * RETURNS: Success or failure
90 */
91 {
92 PDEVICE_EXTENSION DeviceExtension;
93 NTSTATUS Status;
94
95 DPRINT("BeepClose() called!\n");
96
97 DeviceExtension = DeviceObject->DeviceExtension;
98 if (DeviceExtension->BeepOn == TRUE)
99 {
100 HalMakeBeep(0);
101 DeviceExtension->BeepOn = FALSE;
102 KeCancelTimer(&DeviceExtension->Timer);
103 }
104
105 Status = STATUS_SUCCESS;
106
107 Irp->IoStatus.Status = Status;
108 Irp->IoStatus.Information = 0;
109 IoCompleteRequest(Irp,
110 IO_NO_INCREMENT);
111
112 return(Status);
113 }
114
115
116 static NTSTATUS STDCALL
117 BeepCleanup(PDEVICE_OBJECT DeviceObject,
118 PIRP Irp)
119 /*
120 * FUNCTION: Handles user mode requests
121 * ARGUMENTS:
122 * DeviceObject = Device for request
123 * Irp = I/O request packet describing request
124 * RETURNS: Success or failure
125 */
126 {
127 DPRINT("BeepCleanup() called!\n");
128
129 Irp->IoStatus.Status = STATUS_SUCCESS;
130 Irp->IoStatus.Information = 0;
131 IoCompleteRequest(Irp,
132 IO_NO_INCREMENT);
133
134 return(STATUS_SUCCESS);
135 }
136
137
138 static NTSTATUS STDCALL
139 BeepDeviceControl(PDEVICE_OBJECT DeviceObject,
140 PIRP Irp)
141 /*
142 * FUNCTION: Handles user mode requests
143 * ARGUMENTS:
144 * DeviceObject = Device for request
145 * Irp = I/O request packet describing request
146 * RETURNS: Success or failure
147 */
148 {
149 PIO_STACK_LOCATION Stack;
150 PDEVICE_EXTENSION DeviceExtension;
151 PBEEP_SET_PARAMETERS BeepParam;
152 LARGE_INTEGER DueTime;
153
154 DPRINT("BeepDeviceControl() called!\n");
155
156 DeviceExtension = DeviceObject->DeviceExtension;
157 Stack = IoGetCurrentIrpStackLocation(Irp);
158 BeepParam = (PBEEP_SET_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
159
160 Irp->IoStatus.Information = 0;
161
162 if (Stack->Parameters.DeviceIoControl.IoControlCode != IOCTL_BEEP_SET)
163 {
164 Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
165 IoCompleteRequest(Irp,
166 IO_NO_INCREMENT);
167 return(STATUS_NOT_IMPLEMENTED);
168 }
169
170 if ((Stack->Parameters.DeviceIoControl.InputBufferLength != sizeof(BEEP_SET_PARAMETERS))
171 || (BeepParam->Frequency < BEEP_FREQUENCY_MINIMUM)
172 || (BeepParam->Frequency > BEEP_FREQUENCY_MAXIMUM))
173 {
174 Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
175 IoCompleteRequest(Irp,
176 IO_NO_INCREMENT);
177 return(STATUS_INVALID_PARAMETER);
178 }
179
180 DueTime.QuadPart = 0;
181
182 /* do the beep!! */
183 DPRINT("Beep:\n Freq: %lu Hz\n Dur: %lu ms\n",
184 BeepParam->Frequency,
185 BeepParam->Duration);
186 if (BeepParam->Duration >= 0)
187 {
188 DueTime.QuadPart = (LONGLONG)BeepParam->Duration * -10000;
189
190 KeSetTimer(&DeviceExtension->Timer,
191 DueTime,
192 &DeviceExtension->Dpc);
193
194 HalMakeBeep(BeepParam->Frequency);
195 DeviceExtension->BeepOn = TRUE;
196 KeWaitForSingleObject(&DeviceExtension->Event,
197 Executive,
198 KernelMode,
199 FALSE,
200 NULL);
201 }
202 else if (BeepParam->Duration == (DWORD)-1)
203 {
204 if (DeviceExtension->BeepOn == TRUE)
205 {
206 HalMakeBeep(0);
207 DeviceExtension->BeepOn = FALSE;
208 }
209 else
210 {
211 HalMakeBeep(BeepParam->Frequency);
212 DeviceExtension->BeepOn = TRUE;
213 }
214 }
215
216 DPRINT("Did the beep!\n");
217
218 Irp->IoStatus.Status = STATUS_SUCCESS;
219 IoCompleteRequest(Irp,
220 IO_NO_INCREMENT);
221 return(STATUS_SUCCESS);
222 }
223
224
225 static VOID STDCALL
226 BeepUnload(PDRIVER_OBJECT DriverObject)
227 {
228 DPRINT("BeepUnload() called!\n");
229 }
230
231
232 NTSTATUS STDCALL
233 DriverEntry(PDRIVER_OBJECT DriverObject,
234 PUNICODE_STRING RegistryPath)
235 /*
236 * FUNCTION: Called by the system to initalize the driver
237 * ARGUMENTS:
238 * DriverObject = object describing this driver
239 * RegistryPath = path to our configuration entries
240 * RETURNS: Success or failure
241 */
242 {
243 PDEVICE_EXTENSION DeviceExtension;
244 PDEVICE_OBJECT DeviceObject;
245 UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\Beep");
246 NTSTATUS Status;
247
248 DPRINT("Beep Device Driver 0.0.3\n");
249
250 DriverObject->Flags = 0;
251 DriverObject->MajorFunction[IRP_MJ_CREATE] = BeepCreate;
252 DriverObject->MajorFunction[IRP_MJ_CLOSE] = BeepClose;
253 DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BeepCleanup;
254 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BeepDeviceControl;
255 DriverObject->DriverUnload = BeepUnload;
256
257 Status = IoCreateDevice(DriverObject,
258 sizeof(DEVICE_EXTENSION),
259 &DeviceName,
260 FILE_DEVICE_BEEP,
261 0,
262 FALSE,
263 &DeviceObject);
264 if (!NT_SUCCESS(Status))
265 return Status;
266
267 /* set up device extension */
268 DeviceExtension = DeviceObject->DeviceExtension;
269 DeviceExtension->BeepOn = FALSE;
270
271 KeInitializeDpc(&DeviceExtension->Dpc,
272 BeepDPC,
273 DeviceExtension);
274 KeInitializeTimer(&DeviceExtension->Timer);
275 KeInitializeEvent(&DeviceExtension->Event,
276 SynchronizationEvent,
277 FALSE);
278
279 return(STATUS_SUCCESS);
280 }
281
282 /* EOF */