Amd64/misc 64bit fixes (#236)
[reactos.git] / drivers / network / ndis / ndis / memory.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS NDIS library
4 * FILE: ndis/memory.c
5 * PURPOSE: Memory management routines
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Vizzini (vizzini@plasmic.com)
8 * REVISIONS:
9 * CSH 01/08-2000 Created
10 * 15 Aug 2003 Vizzini - DMA support
11 * 3 Oct 2003 Vizzini - formatting and minor bugfixing
12 */
13
14 #include "ndissys.h"
15
16 /*
17 * @implemented
18 */
19 NDIS_STATUS
20 EXPORT
21 NdisAllocateMemoryWithTag(
22 OUT PVOID *VirtualAddress,
23 IN UINT Length,
24 IN ULONG Tag)
25 /*
26 * FUNCTION: Allocates a block of memory, with a 32-bit tag
27 * ARGUMENTS:
28 * VirtualAddress = a pointer to the returned memory block
29 * Length = the number of requested bytes
30 * Tag = 32-bit pool tag
31 * RETURNS:
32 * NDIS_STATUS_SUCCESS on success
33 * NDIS_STATUS_FAILURE on failure
34 */
35 {
36 PVOID Block;
37
38 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
39
40 Block = ExAllocatePoolWithTag(NonPagedPool, Length, Tag);
41 *VirtualAddress = Block;
42
43 if (!Block) {
44 NDIS_DbgPrint(MIN_TRACE, ("Failed to allocate memory (%lx)\n", Length));
45 return NDIS_STATUS_FAILURE;
46 }
47
48 return NDIS_STATUS_SUCCESS;
49 }
50
51
52 /*
53 * @implemented
54 */
55 NDIS_STATUS
56 EXPORT
57 NdisAllocateMemory(
58 OUT PVOID *VirtualAddress,
59 IN UINT Length,
60 IN UINT MemoryFlags,
61 IN NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress)
62 /*
63 * FUNCTION: Allocates a block of memory
64 * ARGUMENTS:
65 * VirtualAddress = Address of buffer to place virtual
66 * address of the allocated memory
67 * Length = Size of the memory block to allocate
68 * MemoryFlags = Flags to specify special restrictions
69 * HighestAcceptableAddress = Specifies -1
70 * RETURNS:
71 * NDIS_STATUS_SUCCESS on success
72 * NDIS_STATUS_FAILURE on failure
73 */
74 {
75 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
76
77 if (MemoryFlags & NDIS_MEMORY_CONTIGUOUS)
78 {
79 /* Allocate contiguous memory (possibly noncached) */
80 *VirtualAddress = MmAllocateContiguousMemorySpecifyCache(Length,
81 RtlConvertUlongToLargeInteger(0),
82 HighestAcceptableAddress,
83 RtlConvertUlongToLargeInteger(0),
84 (MemoryFlags & NDIS_MEMORY_NONCACHED) ? MmNonCached : MmCached);
85 }
86 else if (MemoryFlags & NDIS_MEMORY_NONCACHED)
87 {
88 /* Allocate noncached noncontiguous memory */
89 *VirtualAddress = MmAllocateNonCachedMemory(Length);
90 }
91 else
92 {
93 /* Allocate plain nonpaged memory */
94 *VirtualAddress = ExAllocatePool(NonPagedPool, Length);
95 }
96
97 if (!*VirtualAddress) {
98 NDIS_DbgPrint(MIN_TRACE, ("Allocation failed (%lx, %lx)\n", MemoryFlags, Length));
99 return NDIS_STATUS_FAILURE;
100 }
101
102 return NDIS_STATUS_SUCCESS;
103 }
104
105 /*
106 * @implemented
107 */
108 VOID
109 EXPORT
110 NdisFreeMemory(
111 IN PVOID VirtualAddress,
112 IN UINT Length,
113 IN UINT MemoryFlags)
114 /*
115 * FUNCTION: Frees a memory block allocated with NdisAllocateMemory
116 * ARGUMENTS:
117 * VirtualAddress = Pointer to the base virtual address of the allocated memory
118 * Length = Size of the allocated memory block as passed to NdisAllocateMemory
119 * MemoryFlags = Memory flags passed to NdisAllocateMemory
120 */
121 {
122 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
123
124 if (MemoryFlags & NDIS_MEMORY_CONTIGUOUS)
125 {
126 /* Free contiguous memory (possibly noncached) */
127 MmFreeContiguousMemorySpecifyCache(VirtualAddress,
128 Length,
129 (MemoryFlags & NDIS_MEMORY_NONCACHED) ? MmNonCached : MmCached);
130 }
131 else if (MemoryFlags & NDIS_MEMORY_NONCACHED)
132 {
133 /* Free noncached noncontiguous memory */
134 MmFreeNonCachedMemory(VirtualAddress, Length);
135 }
136 else
137 {
138 /* Free nonpaged pool */
139 ExFreePool(VirtualAddress);
140 }
141 }
142
143 /*
144 * @implemented
145 */
146 VOID
147 EXPORT
148 NdisMAllocateSharedMemory(
149 IN NDIS_HANDLE MiniportAdapterHandle,
150 IN ULONG Length,
151 IN BOOLEAN Cached,
152 OUT PVOID *VirtualAddress,
153 OUT PNDIS_PHYSICAL_ADDRESS PhysicalAddress)
154 /*
155 * FUNCTION: Allocate a common buffer for DMA
156 * ARGUMENTS:
157 * MiniportAdapterHandle: Handle passed into MiniportInitialize
158 * Length: Number of bytes to allocate
159 * Cached: Whether or not the memory can be cached
160 * VirtualAddress: Pointer to memory is returned here
161 * PhysicalAddress: Physical address corresponding to virtual address
162 * NOTES:
163 * - Cached is ignored; we always allocate non-cached
164 */
165 {
166 PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
167
168 NDIS_DbgPrint(MAX_TRACE,("Called.\n"));
169
170 if (KeGetCurrentIrql() != PASSIVE_LEVEL)
171 {
172 KeBugCheckEx(BUGCODE_ID_DRIVER,
173 (ULONG_PTR)MiniportAdapterHandle,
174 Length,
175 0,
176 1);
177 }
178
179 *VirtualAddress = Adapter->NdisMiniportBlock.SystemAdapterObject->DmaOperations->AllocateCommonBuffer(
180 Adapter->NdisMiniportBlock.SystemAdapterObject, Length, PhysicalAddress, Cached);
181 }
182
183 VOID
184 NTAPI
185 NdisMFreeSharedMemoryPassive(
186 PDEVICE_OBJECT DeviceObject,
187 PVOID Context)
188 /*
189 * FUNCTION: Free a common buffer
190 * ARGUMENTS:
191 * Context: Pointer to a miniport shared memory context
192 * NOTES:
193 * - Called by NdisMFreeSharedMemory to do the actual work
194 */
195 {
196 PMINIPORT_SHARED_MEMORY Memory = (PMINIPORT_SHARED_MEMORY)Context;
197
198 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
199
200 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
201
202 Memory->AdapterObject->DmaOperations->FreeCommonBuffer(
203 Memory->AdapterObject, Memory->Length, Memory->PhysicalAddress,
204 Memory->VirtualAddress, Memory->Cached);
205
206 IoFreeWorkItem(Memory->WorkItem);
207 ExFreePool(Memory);
208 }
209
210 /*
211 * @implemented
212 */
213 VOID
214 EXPORT
215 NdisMFreeSharedMemory(
216 IN NDIS_HANDLE MiniportAdapterHandle,
217 IN ULONG Length,
218 IN BOOLEAN Cached,
219 IN PVOID VirtualAddress,
220 IN NDIS_PHYSICAL_ADDRESS PhysicalAddress)
221 /*
222 * FUNCTION: Free a shared memory block
223 * ARGUMENTS:
224 * MiniportAdapterHandle: Handle passed into MiniportInitialize
225 * Length: Number of bytes in the block to free
226 * Cached: Whether or not the memory was cached
227 * VirtualAddress: Address to free
228 * PhysicalAddress: corresponding physical addres
229 * NOTES:
230 * - This function can be called at dispatch_level or passive_level.
231 * Therefore we have to do this in a worker thread.
232 */
233 {
234 PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
235 PMINIPORT_SHARED_MEMORY Memory;
236 PDMA_ADAPTER DmaAdapter = Adapter->NdisMiniportBlock.SystemAdapterObject;
237
238 NDIS_DbgPrint(MAX_TRACE,("Called.\n"));
239
240 ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
241
242 /* Call FreeCommonBuffer synchronously if we are at PASSIVE_LEVEL */
243 if (KeGetCurrentIrql() == PASSIVE_LEVEL)
244 {
245 /* We need this case because we free shared memory asynchronously
246 * and the miniport (and DMA adapter object) could be freed before
247 * our work item executes. Lucky for us, the scenarios where the
248 * freeing needs to be synchronous (failed init, MiniportHalt,
249 * and driver unload) are all at PASSIVE_LEVEL so we can just
250 * call FreeCommonBuffer synchronously and not have to worry
251 * about the miniport falling out from under us */
252
253 NDIS_DbgPrint(MID_TRACE,("Freeing shared memory synchronously\n"));
254
255 DmaAdapter->DmaOperations->FreeCommonBuffer(DmaAdapter,
256 Length,
257 PhysicalAddress,
258 VirtualAddress,
259 Cached);
260 return;
261 }
262
263 /* Must be NonpagedPool because by definition we're at DISPATCH_LEVEL */
264 Memory = ExAllocatePool(NonPagedPool, sizeof(MINIPORT_SHARED_MEMORY));
265
266 if(!Memory)
267 {
268 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
269 return;
270 }
271
272 Memory->AdapterObject = Adapter->NdisMiniportBlock.SystemAdapterObject;
273 Memory->Length = Length;
274 Memory->PhysicalAddress = PhysicalAddress;
275 Memory->VirtualAddress = VirtualAddress;
276 Memory->Cached = Cached;
277 Memory->Adapter = &Adapter->NdisMiniportBlock;
278
279 Memory->WorkItem = IoAllocateWorkItem(Adapter->NdisMiniportBlock.DeviceObject);
280 if (!Memory->WorkItem)
281 {
282 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
283 ExFreePool(Memory);
284 return;
285 }
286
287 IoQueueWorkItem(Memory->WorkItem,
288 NdisMFreeSharedMemoryPassive,
289 CriticalWorkQueue,
290 Memory);
291 }
292
293 VOID
294 NTAPI
295 NdisMAllocateSharedMemoryPassive(
296 PDEVICE_OBJECT DeviceObject,
297 PVOID Context)
298 /*
299 * FUNCTION: Allocate a common buffer
300 * ARGUMENTS:
301 * Context: Pointer to a miniport shared memory context
302 * NOTES:
303 * - Called by NdisMAllocateSharedMemoryAsync to do the actual work
304 */
305 {
306 PMINIPORT_SHARED_MEMORY Memory = (PMINIPORT_SHARED_MEMORY)Context;
307
308 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
309
310 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
311
312 Memory->VirtualAddress = Memory->AdapterObject->DmaOperations->AllocateCommonBuffer(
313 Memory->AdapterObject, Memory->Length, &Memory->PhysicalAddress, Memory->Cached);
314
315 if (Memory->Adapter->DriverHandle->MiniportCharacteristics.AllocateCompleteHandler)
316 Memory->Adapter->DriverHandle->MiniportCharacteristics.AllocateCompleteHandler(
317 Memory->Adapter->MiniportAdapterContext, Memory->VirtualAddress,
318 &Memory->PhysicalAddress, Memory->Length, Memory->Context);
319
320 IoFreeWorkItem(Memory->WorkItem);
321 ExFreePool(Memory);
322 }
323
324
325 /*
326 * @implemented
327 */
328 NDIS_STATUS
329 EXPORT
330 NdisMAllocateSharedMemoryAsync(
331 IN NDIS_HANDLE MiniportAdapterHandle,
332 IN ULONG Length,
333 IN BOOLEAN Cached,
334 IN PVOID Context)
335 {
336 PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
337 PMINIPORT_SHARED_MEMORY Memory;
338
339 NDIS_DbgPrint(MAX_TRACE,("Called.\n"));
340
341 ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
342
343 /* Must be NonpagedPool because by definition we're at DISPATCH_LEVEL */
344 Memory = ExAllocatePool(NonPagedPool, sizeof(MINIPORT_SHARED_MEMORY));
345
346 if(!Memory)
347 {
348 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
349 return NDIS_STATUS_FAILURE;
350 }
351
352 Memory->AdapterObject = Adapter->NdisMiniportBlock.SystemAdapterObject;
353 Memory->Length = Length;
354 Memory->Cached = Cached;
355 Memory->Adapter = &Adapter->NdisMiniportBlock;
356 Memory->Context = Context;
357
358 Memory->WorkItem = IoAllocateWorkItem(Adapter->NdisMiniportBlock.DeviceObject);
359 if (!Memory->WorkItem)
360 {
361 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
362 ExFreePool(Memory);
363 return NDIS_STATUS_FAILURE;
364 }
365
366 IoQueueWorkItem(Memory->WorkItem,
367 NdisMAllocateSharedMemoryPassive,
368 DelayedWorkQueue,
369 Memory);
370
371 return NDIS_STATUS_PENDING;
372 }
373
374 /*
375 * @implemented
376 */
377 VOID
378 EXPORT
379 NdisAllocateSharedMemory(
380 IN NDIS_HANDLE NdisAdapterHandle,
381 IN ULONG Length,
382 IN BOOLEAN Cached,
383 OUT PVOID *VirtualAddress,
384 OUT PNDIS_PHYSICAL_ADDRESS PhysicalAddress)
385 {
386 NdisMAllocateSharedMemory(NdisAdapterHandle,
387 Length,
388 Cached,
389 VirtualAddress,
390 PhysicalAddress);
391 }
392
393
394 /*
395 * @implemented
396 */
397 VOID
398 EXPORT
399 NdisFreeSharedMemory(
400 IN NDIS_HANDLE NdisAdapterHandle,
401 IN ULONG Length,
402 IN BOOLEAN Cached,
403 IN PVOID VirtualAddress,
404 IN NDIS_PHYSICAL_ADDRESS PhysicalAddress)
405 /*
406 * FUNCTION:
407 * ARGUMENTS:
408 * NOTES:
409 * NDIS 4.0
410 */
411 {
412 NdisMFreeSharedMemory(NdisAdapterHandle,
413 Length,
414 Cached,
415 VirtualAddress,
416 PhysicalAddress);
417 }
418
419
420 /* EOF */