2 * Copyright(c) 2002-2011 Exar Corp.
5 * Redistribution and use in source and binary forms, with or without
6 * modification are permitted provided the following conditions are met:
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the Exar Corporation nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
33 #include <dev/vxge/vxgehal/vxgehal.h>
36 * __hal_blockpool_create - Create block pool
37 * @devh: Pointer to HAL Device object.
38 * @blockpool: Block pool to be created.
39 * @pool_size: Number of blocks in the pool.
40 * @pool_incr: Number of blocks to be request from OS at a time
41 * @pool_min: Number of blocks below which new blocks to be requested.
42 * @pool_max: Number of blocks above which block to be freed.
44 * This function creates block pool
48 __hal_blockpool_create(vxge_hal_device_h devh,
49 __hal_blockpool_t *blockpool,
56 __hal_device_t *hldev = (__hal_device_t *) devh;
57 __hal_blockpool_entry_t *entry;
61 pci_dma_acc_h acc_handle;
62 vxge_hal_status_e status = VXGE_HAL_OK;
64 vxge_assert(devh != NULL);
65 vxge_os_memzero(&dma_handle, sizeof(pci_dma_h));
66 vxge_os_memzero(&acc_handle, sizeof(pci_dma_acc_h));
68 vxge_hal_trace_log_pool("==> %s:%s:%d",
69 __FILE__, __func__, __LINE__);
71 vxge_hal_trace_log_pool("devh = 0x"VXGE_OS_STXFMT", "
72 "blockpool = 0x"VXGE_OS_STXFMT", pool_size = %d, pool_incr = %d, "
73 "pool_min = %d, pool_max = %d", (ptr_t) devh, (ptr_t) blockpool,
74 pool_size, pool_incr, pool_min, pool_max);
76 if (blockpool == NULL) {
77 vxge_hal_err_log_pool(
78 "%s:%d null pointer passed. blockpool is null",
80 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
81 __FILE__, __func__, __LINE__, VXGE_HAL_FAIL);
82 return (VXGE_HAL_FAIL);
85 blockpool->hldev = devh;
86 blockpool->block_size = VXGE_OS_HOST_PAGE_SIZE;
87 blockpool->pool_size = 0;
88 blockpool->pool_incr = pool_incr;
89 blockpool->pool_min = pool_min;
90 blockpool->pool_max = pool_max;
91 blockpool->req_out = 0;
93 #if defined(VXGE_HAL_DMA_CONSISTENT)
94 blockpool->dma_flags = VXGE_OS_DMA_CONSISTENT;
96 blockpool->dma_flags = VXGE_OS_DMA_STREAMING;
99 vxge_list_init(&blockpool->free_block_list);
101 vxge_list_init(&blockpool->free_entry_list);
103 #if defined(VXGE_HAL_BP_POST)
104 vxge_os_spin_lock_init(&blockpool->pool_lock, hldev->header.pdev);
105 #elif defined(VXGE_HAL_BP_POST_IRQ)
106 vxge_os_spin_lock_init_irq(&blockpool->pool_lock, hldev->header.irqh);
109 for (i = 0; i < pool_size + pool_max; i++) {
111 entry = (__hal_blockpool_entry_t *) vxge_os_malloc(
113 sizeof(__hal_blockpool_entry_t));
115 __hal_blockpool_destroy(blockpool);
117 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
118 __FILE__, __func__, __LINE__,
119 VXGE_HAL_ERR_OUT_OF_MEMORY);
121 return (VXGE_HAL_ERR_OUT_OF_MEMORY);
124 vxge_list_insert(&entry->item, &blockpool->free_entry_list);
127 for (i = 0; i < pool_size; i++) {
129 memblock = vxge_os_dma_malloc(
131 VXGE_OS_HOST_PAGE_SIZE,
132 blockpool->dma_flags,
136 if (memblock == NULL) {
137 __hal_blockpool_destroy(blockpool);
138 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
139 __FILE__, __func__, __LINE__,
140 VXGE_HAL_ERR_OUT_OF_MEMORY);
142 return (VXGE_HAL_ERR_OUT_OF_MEMORY);
145 dma_addr = vxge_os_dma_map(
149 VXGE_OS_HOST_PAGE_SIZE,
150 VXGE_OS_DMA_DIR_BIDIRECTIONAL,
151 blockpool->dma_flags);
153 if (dma_addr == VXGE_OS_INVALID_DMA_ADDR) {
154 vxge_os_dma_free(hldev->header.pdev,
156 VXGE_OS_HOST_PAGE_SIZE,
157 blockpool->dma_flags,
160 __hal_blockpool_destroy(blockpool);
162 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
163 __FILE__, __func__, __LINE__,
164 VXGE_HAL_ERR_OUT_OF_MEMORY);
166 return (VXGE_HAL_ERR_OUT_OF_MEMORY);
169 entry = (__hal_blockpool_entry_t *)
170 vxge_list_first_get(&blockpool->free_entry_list);
173 entry = (__hal_blockpool_entry_t *) vxge_os_malloc(
175 sizeof(__hal_blockpool_entry_t));
179 vxge_list_remove(&entry->item);
180 entry->length = VXGE_OS_HOST_PAGE_SIZE;
181 entry->memblock = memblock;
182 entry->dma_addr = dma_addr;
183 entry->acc_handle = acc_handle;
184 entry->dma_handle = dma_handle;
185 vxge_list_insert(&entry->item,
186 &blockpool->free_block_list);
187 blockpool->pool_size++;
189 __hal_blockpool_destroy(blockpool);
190 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
191 __FILE__, __func__, __LINE__,
192 VXGE_HAL_ERR_OUT_OF_MEMORY);
194 return (VXGE_HAL_ERR_OUT_OF_MEMORY);
198 vxge_hal_info_log_pool(
199 "Blockpool block size:%d block pool size: %d",
200 blockpool->block_size, blockpool->pool_size);
202 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
203 __FILE__, __func__, __LINE__, status);
209 * __hal_blockpool_destroy - Deallocates the block pool
210 * @blockpool: blockpool to be deallocated
212 * This function freeup the memory pool and removes the
217 __hal_blockpool_destroy(
218 __hal_blockpool_t *blockpool)
220 __hal_device_t *hldev;
223 vxge_assert(blockpool != NULL);
225 hldev = (__hal_device_t *) blockpool->hldev;
227 vxge_hal_trace_log_pool("==> %s:%s:%d",
228 __FILE__, __func__, __LINE__);
230 vxge_hal_trace_log_pool("blockpool = 0x"VXGE_OS_STXFMT,
233 if (blockpool == NULL) {
234 vxge_hal_err_log_pool(
235 "%s:%d null pointer passed blockpool = null",
237 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 1",
238 __FILE__, __func__, __LINE__);
242 vxge_list_for_each_safe(p, n, &blockpool->free_block_list) {
244 vxge_os_dma_unmap(hldev->header.pdev,
245 ((__hal_blockpool_entry_t *) p)->dma_handle,
246 ((__hal_blockpool_entry_t *) p)->dma_addr,
247 ((__hal_blockpool_entry_t *) p)->length,
248 VXGE_OS_DMA_DIR_BIDIRECTIONAL);
250 vxge_os_dma_free(hldev->header.pdev,
251 ((__hal_blockpool_entry_t *) p)->memblock,
252 ((__hal_blockpool_entry_t *) p)->length,
253 blockpool->dma_flags,
254 &((__hal_blockpool_entry_t *) p)->dma_handle,
255 &((__hal_blockpool_entry_t *) p)->acc_handle);
257 vxge_list_remove(&((__hal_blockpool_entry_t *) p)->item);
259 vxge_os_free(hldev->header.pdev,
260 (void *)p, sizeof(__hal_blockpool_entry_t));
262 blockpool->pool_size--;
265 vxge_list_for_each_safe(p, n, &blockpool->free_entry_list) {
267 vxge_list_remove(&((__hal_blockpool_entry_t *) p)->item);
269 vxge_os_free(hldev->header.pdev,
270 (void *)p, sizeof(__hal_blockpool_entry_t));
274 #if defined(VXGE_HAL_BP_POST)
275 vxge_os_spin_lock_destroy(&blockpool->pool_lock,
277 #elif defined(VXGE_HAL_BP_POST_IRQ)
278 vxge_os_spin_lock_destroy_irq(&blockpool->pool_lock,
282 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 0",
283 __FILE__, __func__, __LINE__);
287 * __hal_blockpool_blocks_add - Request additional blocks
288 * @blockpool: Block pool.
290 * Requests additional blocks to block pool
293 __hal_blockpool_blocks_add(
294 __hal_blockpool_t * blockpool)
297 __hal_device_t *hldev;
299 vxge_assert(blockpool != NULL);
301 hldev = (__hal_device_t *) blockpool->hldev;
303 vxge_hal_trace_log_pool("==> %s:%s:%d",
304 __FILE__, __func__, __LINE__);
306 vxge_hal_trace_log_pool("blockpool = 0x"VXGE_OS_STXFMT,
309 #if defined(VXGE_HAL_BP_POST)
310 vxge_os_spin_lock(&blockpool->pool_lock);
311 #elif defined(VXGE_HAL_BP_POST_IRQ)
312 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
314 if ((blockpool->pool_size + blockpool->req_out) <
315 blockpool->pool_min) {
316 nreq = blockpool->pool_incr;
317 blockpool->req_out += nreq;
320 #if defined(VXGE_HAL_BP_POST)
321 vxge_os_spin_unlock(&blockpool->pool_lock);
322 #elif defined(VXGE_HAL_BP_POST_IRQ)
323 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
326 for (i = 0; i < nreq; i++) {
327 vxge_os_dma_malloc_async(
328 ((__hal_device_t *) blockpool->hldev)->header.pdev,
330 VXGE_OS_HOST_PAGE_SIZE,
331 blockpool->dma_flags);
334 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 0",
335 __FILE__, __func__, __LINE__);
339 * __hal_blockpool_blocks_remove - Free additional blocks
340 * @blockpool: Block pool.
342 * Frees additional blocks over maximum from the block pool
345 __hal_blockpool_blocks_remove(
346 __hal_blockpool_t * blockpool)
349 __hal_device_t *hldev;
351 vxge_assert(blockpool != NULL);
353 hldev = (__hal_device_t *) blockpool->hldev;
355 vxge_hal_trace_log_pool("==> %s:%s:%d",
356 __FILE__, __func__, __LINE__);
358 vxge_hal_trace_log_pool("blockpool = 0x"VXGE_OS_STXFMT,
361 #if defined(VXGE_HAL_BP_POST)
362 vxge_os_spin_lock(&blockpool->pool_lock);
363 #elif defined(VXGE_HAL_BP_POST_IRQ)
364 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
366 vxge_list_for_each_safe(p, n, &blockpool->free_block_list) {
368 if (blockpool->pool_size < blockpool->pool_max)
372 ((__hal_device_t *) blockpool->hldev)->header.pdev,
373 ((__hal_blockpool_entry_t *) p)->dma_handle,
374 ((__hal_blockpool_entry_t *) p)->dma_addr,
375 ((__hal_blockpool_entry_t *) p)->length,
376 VXGE_OS_DMA_DIR_BIDIRECTIONAL);
379 ((__hal_device_t *) blockpool->hldev)->header.pdev,
380 ((__hal_blockpool_entry_t *) p)->memblock,
381 ((__hal_blockpool_entry_t *) p)->length,
382 blockpool->dma_flags,
383 &((__hal_blockpool_entry_t *) p)->dma_handle,
384 &((__hal_blockpool_entry_t *) p)->acc_handle);
386 vxge_list_remove(&((__hal_blockpool_entry_t *) p)->item);
388 vxge_list_insert(p, &blockpool->free_entry_list);
390 blockpool->pool_size--;
394 #if defined(VXGE_HAL_BP_POST)
395 vxge_os_spin_unlock(&blockpool->pool_lock);
396 #elif defined(VXGE_HAL_BP_POST_IRQ)
397 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
400 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 0",
401 __FILE__, __func__, __LINE__);
405 * vxge_hal_blockpool_block_add - callback for vxge_os_dma_malloc_async
406 * @devh: HAL device handle.
407 * @block_addr: Virtual address of the block
408 * @length: Length of the block.
409 * @p_dma_h: Physical address of the block
410 * @acc_handle: DMA acc handle
412 * Adds a block to block pool
415 vxge_hal_blockpool_block_add(
416 vxge_hal_device_h devh,
420 pci_dma_acc_h * acc_handle)
422 __hal_blockpool_t *blockpool;
423 __hal_blockpool_entry_t *entry;
424 __hal_device_t *hldev;
426 vxge_hal_status_e status;
429 vxge_assert(devh != NULL);
431 hldev = (__hal_device_t *) devh;
433 vxge_hal_trace_log_pool("==> %s:%s:%d",
434 __FILE__, __func__, __LINE__);
436 vxge_hal_trace_log_pool("devh = 0x"VXGE_OS_STXFMT", length = %d, "
437 "block_addr = 0x"VXGE_OS_STXFMT", dma_h = 0x"VXGE_OS_STXFMT", "
438 "acc_handle = 0x"VXGE_OS_STXFMT, (ptr_t) devh, length,
439 (ptr_t) block_addr, (ptr_t) dma_h, (ptr_t) acc_handle);
441 blockpool = &hldev->block_pool;
443 if (block_addr == NULL) {
444 #if defined(VXGE_HAL_BP_POST)
445 vxge_os_spin_lock(&blockpool->pool_lock);
446 #elif defined(VXGE_HAL_BP_POST_IRQ)
447 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
449 blockpool->req_out--;
451 #if defined(VXGE_HAL_BP_POST)
452 vxge_os_spin_unlock(&blockpool->pool_lock);
453 #elif defined(VXGE_HAL_BP_POST_IRQ)
454 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
456 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 1",
457 __FILE__, __func__, __LINE__);
461 dma_addr = vxge_os_dma_map(hldev->header.pdev,
465 VXGE_OS_DMA_DIR_BIDIRECTIONAL,
466 blockpool->dma_flags);
468 if (dma_addr == VXGE_OS_INVALID_DMA_ADDR) {
469 vxge_os_dma_free(hldev->header.pdev,
472 blockpool->dma_flags,
475 #if defined(VXGE_HAL_BP_POST)
476 vxge_os_spin_lock(&blockpool->pool_lock);
477 #elif defined(VXGE_HAL_BP_POST_IRQ)
478 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
480 blockpool->req_out--;
482 #if defined(VXGE_HAL_BP_POST)
483 vxge_os_spin_unlock(&blockpool->pool_lock);
484 #elif defined(VXGE_HAL_BP_POST_IRQ)
485 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
487 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 1",
488 __FILE__, __func__, __LINE__);
492 #if defined(VXGE_HAL_BP_POST)
493 vxge_os_spin_lock(&blockpool->pool_lock);
494 #elif defined(VXGE_HAL_BP_POST_IRQ)
495 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
498 entry = (__hal_blockpool_entry_t *)
499 vxge_list_first_get(&blockpool->free_entry_list);
502 entry = (__hal_blockpool_entry_t *) vxge_os_malloc(
504 sizeof(__hal_blockpool_entry_t));
506 vxge_list_remove(&entry->item);
510 entry->length = length;
511 entry->memblock = block_addr;
512 entry->dma_addr = dma_addr;
513 entry->acc_handle = *acc_handle;
514 entry->dma_handle = *dma_h;
515 vxge_list_insert(&entry->item, &blockpool->free_block_list);
516 blockpool->pool_size++;
517 status = VXGE_HAL_OK;
519 status = VXGE_HAL_ERR_OUT_OF_MEMORY;
522 blockpool->req_out--;
524 req_out = blockpool->req_out;
526 #if defined(VXGE_HAL_BP_POST)
527 vxge_os_spin_unlock(&blockpool->pool_lock);
528 #elif defined(VXGE_HAL_BP_POST_IRQ)
529 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
533 __hal_channel_process_pending_list(devh);
535 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
536 __FILE__, __func__, __LINE__, status);
540 * __hal_blockpool_malloc - Allocate a memory block from pool
541 * @devh: HAL device handle.
542 * @size: Length of the block.
543 * @dma_addr: Buffer to return DMA Address of the block.
544 * @dma_handle: Buffer to return DMA handle of the block.
545 * @acc_handle: Buffer to return DMA acc handle
548 * Allocates a block of memory of given size, either from block pool
549 * or by calling vxge_os_dma_malloc()
552 __hal_blockpool_malloc(vxge_hal_device_h devh,
554 dma_addr_t *dma_addr,
555 pci_dma_h *dma_handle,
556 pci_dma_acc_h *acc_handle)
558 __hal_blockpool_entry_t *entry;
559 __hal_blockpool_t *blockpool;
560 __hal_device_t *hldev;
561 void *memblock = NULL;
563 vxge_assert(devh != NULL);
565 hldev = (__hal_device_t *) devh;
567 vxge_hal_trace_log_pool("==> %s:%s:%d",
568 __FILE__, __func__, __LINE__);
570 vxge_hal_trace_log_pool(
571 "devh = 0x"VXGE_OS_STXFMT", size = %d, "
572 "dma_addr = 0x"VXGE_OS_STXFMT", dma_handle = 0x"VXGE_OS_STXFMT", "
573 "acc_handle = 0x"VXGE_OS_STXFMT, (ptr_t) devh, size,
574 (ptr_t) dma_addr, (ptr_t) dma_handle, (ptr_t) acc_handle);
576 blockpool = &((__hal_device_t *) devh)->block_pool;
578 if (size != blockpool->block_size) {
580 memblock = vxge_os_dma_malloc(
581 ((__hal_device_t *) devh)->header.pdev,
583 blockpool->dma_flags |
584 VXGE_OS_DMA_CACHELINE_ALIGNED,
588 if (memblock == NULL) {
589 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
590 __FILE__, __func__, __LINE__,
591 VXGE_HAL_ERR_OUT_OF_MEMORY);
595 *dma_addr = vxge_os_dma_map(
596 ((__hal_device_t *) devh)->header.pdev,
600 VXGE_OS_DMA_DIR_BIDIRECTIONAL,
601 blockpool->dma_flags);
603 if (*dma_addr == VXGE_OS_INVALID_DMA_ADDR) {
604 vxge_os_dma_free(((__hal_device_t *) devh)->header.pdev,
607 blockpool->dma_flags |
608 VXGE_OS_DMA_CACHELINE_ALIGNED,
612 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
613 __FILE__, __func__, __LINE__,
614 VXGE_HAL_ERR_OUT_OF_MEMORY);
621 #if defined(VXGE_HAL_BP_POST)
622 vxge_os_spin_lock(&blockpool->pool_lock);
623 #elif defined(VXGE_HAL_BP_POST_IRQ)
624 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
627 entry = (__hal_blockpool_entry_t *)
628 vxge_list_first_get(&blockpool->free_block_list);
631 vxge_list_remove(&entry->item);
632 *dma_addr = entry->dma_addr;
633 *dma_handle = entry->dma_handle;
634 *acc_handle = entry->acc_handle;
635 memblock = entry->memblock;
637 vxge_list_insert(&entry->item,
638 &blockpool->free_entry_list);
639 blockpool->pool_size--;
642 #if defined(VXGE_HAL_BP_POST)
643 vxge_os_spin_unlock(&blockpool->pool_lock);
644 #elif defined(VXGE_HAL_BP_POST_IRQ)
645 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
648 if (memblock != NULL)
649 __hal_blockpool_blocks_add(blockpool);
653 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
654 __FILE__, __func__, __LINE__, !memblock);
661 * __hal_blockpool_free - Frees the memory allcoated with __hal_blockpool_malloc
662 * @devh: HAL device handle.
663 * @memblock: Virtual address block
664 * @size: Length of the block.
665 * @dma_addr: DMA Address of the block.
666 * @dma_handle: DMA handle of the block.
667 * @acc_handle: DMA acc handle
670 * Frees the memory allocated with __hal_blockpool_malloc to blockpool or system
673 __hal_blockpool_free(vxge_hal_device_h devh,
676 dma_addr_t *dma_addr,
677 pci_dma_h *dma_handle,
678 pci_dma_acc_h *acc_handle)
680 __hal_blockpool_entry_t *entry;
681 __hal_blockpool_t *blockpool;
682 __hal_device_t *hldev;
683 vxge_hal_status_e status = VXGE_HAL_OK;
685 vxge_assert(devh != NULL);
687 hldev = (__hal_device_t *) devh;
689 vxge_hal_trace_log_pool("==> %s:%s:%d",
690 __FILE__, __func__, __LINE__);
692 vxge_hal_trace_log_pool("devh = 0x"VXGE_OS_STXFMT", size = %d, "
693 "dma_addr = 0x"VXGE_OS_STXFMT", dma_handle = 0x"VXGE_OS_STXFMT", "
694 "acc_handle = 0x"VXGE_OS_STXFMT, (ptr_t) devh, size,
695 (ptr_t) dma_addr, (ptr_t) dma_handle, (ptr_t) acc_handle);
697 blockpool = &((__hal_device_t *) devh)->block_pool;
699 if (size != blockpool->block_size) {
701 vxge_os_dma_unmap(((__hal_device_t *) devh)->header.pdev,
705 VXGE_OS_DMA_DIR_BIDIRECTIONAL);
707 vxge_os_dma_free(((__hal_device_t *) devh)->header.pdev,
710 blockpool->dma_flags |
711 VXGE_OS_DMA_CACHELINE_ALIGNED,
715 #if defined(VXGE_HAL_BP_POST)
716 vxge_os_spin_lock(&blockpool->pool_lock);
717 #elif defined(VXGE_HAL_BP_POST_IRQ)
718 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
721 entry = (__hal_blockpool_entry_t *)
722 vxge_list_first_get(&blockpool->free_entry_list);
725 entry = (__hal_blockpool_entry_t *) vxge_os_malloc(
726 ((__hal_device_t *) devh)->header.pdev,
727 sizeof(__hal_blockpool_entry_t));
729 vxge_list_remove(&entry->item);
733 entry->length = size;
734 entry->memblock = memblock;
735 entry->dma_addr = *dma_addr;
736 entry->acc_handle = *acc_handle;
737 entry->dma_handle = *dma_handle;
738 vxge_list_insert(&entry->item,
739 &blockpool->free_block_list);
740 blockpool->pool_size++;
741 status = VXGE_HAL_OK;
743 status = VXGE_HAL_ERR_OUT_OF_MEMORY;
746 #if defined(VXGE_HAL_BP_POST)
747 vxge_os_spin_unlock(&blockpool->pool_lock);
748 #elif defined(VXGE_HAL_BP_POST_IRQ)
749 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
751 if (status == VXGE_HAL_OK)
752 __hal_blockpool_blocks_remove(blockpool);
756 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
757 __FILE__, __func__, __LINE__, status);
761 * __hal_blockpool_block_allocate - Allocates a block from block pool
763 * @size: Size of the block to be allocated
765 * This function allocates a block from block pool or from the system
767 __hal_blockpool_entry_t *
768 __hal_blockpool_block_allocate(vxge_hal_device_h devh,
771 __hal_blockpool_entry_t *entry = NULL;
772 __hal_device_t *hldev;
773 __hal_blockpool_t *blockpool;
775 vxge_assert(devh != NULL);
777 hldev = (__hal_device_t *) devh;
779 vxge_hal_trace_log_pool("==> %s:%s:%d",
780 __FILE__, __func__, __LINE__);
782 vxge_hal_trace_log_pool("devh = 0x"VXGE_OS_STXFMT", size = %d",
785 blockpool = &((__hal_device_t *) devh)->block_pool;
787 if (size == blockpool->block_size) {
788 #if defined(VXGE_HAL_BP_POST)
789 vxge_os_spin_lock(&blockpool->pool_lock);
790 #elif defined(VXGE_HAL_BP_POST_IRQ)
791 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
794 entry = (__hal_blockpool_entry_t *)
795 vxge_list_first_get(&blockpool->free_block_list);
798 vxge_list_remove(&entry->item);
799 blockpool->pool_size--;
802 #if defined(VXGE_HAL_BP_POST)
803 vxge_os_spin_unlock(&blockpool->pool_lock);
804 #elif defined(VXGE_HAL_BP_POST_IRQ)
805 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
810 __hal_blockpool_blocks_add(blockpool);
813 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
814 __FILE__, __func__, __LINE__, !entry);
820 * __hal_blockpool_block_free - Frees a block from block pool
822 * @entry: Entry of block to be freed
824 * This function frees a block from block pool
827 __hal_blockpool_block_free(vxge_hal_device_h devh,
828 __hal_blockpool_entry_t *entry)
830 __hal_device_t *hldev;
831 __hal_blockpool_t *blockpool;
833 vxge_assert(devh != NULL);
835 hldev = (__hal_device_t *) devh;
837 vxge_hal_trace_log_pool("==> %s:%s:%d",
838 __FILE__, __func__, __LINE__);
840 vxge_hal_trace_log_pool(
841 "devh = 0x"VXGE_OS_STXFMT", entry = 0x"VXGE_OS_STXFMT,
842 (ptr_t) devh, (ptr_t) entry);
844 blockpool = &((__hal_device_t *) devh)->block_pool;
846 if (entry->length == blockpool->block_size) {
847 #if defined(VXGE_HAL_BP_POST)
848 vxge_os_spin_lock(&blockpool->pool_lock);
849 #elif defined(VXGE_HAL_BP_POST_IRQ)
850 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
853 vxge_list_insert(&entry->item, &blockpool->free_block_list);
854 blockpool->pool_size++;
856 #if defined(VXGE_HAL_BP_POST)
857 vxge_os_spin_unlock(&blockpool->pool_lock);
858 #elif defined(VXGE_HAL_BP_POST_IRQ)
859 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
863 __hal_blockpool_blocks_remove(blockpool);
865 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 0",
866 __FILE__, __func__, __LINE__);
871 * __hal_blockpool_list_allocate - Allocate blocks from block pool
873 * @blocklist: List into which the allocated blocks to be inserted
874 * @count: Number of blocks to be allocated
876 * This function allocates a register from the register pool
879 __hal_blockpool_list_allocate(
880 vxge_hal_device_h devh,
881 vxge_list_t *blocklist,
885 __hal_device_t *hldev;
886 __hal_blockpool_t *blockpool;
887 __hal_blockpool_entry_t *block_entry;
888 vxge_hal_status_e status = VXGE_HAL_OK;
890 vxge_assert(devh != NULL);
892 hldev = (__hal_device_t *) devh;
894 vxge_hal_trace_log_pool("==> %s:%s:%d",
895 __FILE__, __func__, __LINE__);
897 vxge_hal_trace_log_pool("devh = 0x"VXGE_OS_STXFMT", blocklist = "
898 "0x"VXGE_OS_STXFMT", count = %d", (ptr_t) devh,
899 (ptr_t) blocklist, count);
901 blockpool = &((__hal_device_t *) devh)->block_pool;
903 if (blocklist == NULL) {
904 vxge_hal_err_log_pool(
905 "null pointer passed blockpool = 0x"VXGE_OS_STXFMT", "
906 "blocklist = 0x"VXGE_OS_STXFMT, (ptr_t) blockpool,
908 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 1",
909 __FILE__, __func__, __LINE__);
910 return (VXGE_HAL_FAIL);
913 #if defined(VXGE_HAL_BP_POST)
914 vxge_os_spin_lock(&blockpool->pool_lock);
915 #elif defined(VXGE_HAL_BP_POST_IRQ)
916 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
919 vxge_list_init(blocklist);
921 for (i = 0; i < count; i++) {
923 block_entry = (__hal_blockpool_entry_t *)
924 vxge_list_first_get(&blockpool->free_block_list);
926 if (block_entry == NULL)
929 vxge_list_remove(&block_entry->item);
931 vxge_os_memzero(block_entry->memblock, blockpool->block_size);
933 vxge_list_insert(&block_entry->item, blocklist);
935 blockpool->pool_size++;
938 #if defined(VXGE_HAL_BP_POST)
939 vxge_os_spin_unlock(&blockpool->pool_lock);
940 #elif defined(VXGE_HAL_BP_POST_IRQ)
941 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
946 vxge_hal_err_log_pool("%s:%d Blockpool out of blocks",
951 __hal_blockpool_list_free(blockpool, blocklist);
953 status = VXGE_HAL_ERR_OUT_OF_MEMORY;
957 __hal_blockpool_blocks_add(blockpool);
959 vxge_hal_trace_log_pool("<== %s:%s:%d Result: %d",
960 __FILE__, __func__, __LINE__, status);
966 * __hal_blockpool_list_free - Free a list of blocks from block pool
968 * @blocklist: List of blocks to be freed
970 * This function frees a list of blocks to the block pool
973 __hal_blockpool_list_free(
974 vxge_hal_device_h devh,
975 vxge_list_t *blocklist)
977 __hal_device_t *hldev;
978 __hal_blockpool_t *blockpool;
979 __hal_blockpool_entry_t *block_entry;
981 vxge_assert(devh != NULL);
983 hldev = (__hal_device_t *) devh;
985 vxge_hal_trace_log_pool("==> %s:%s:%d",
986 __FILE__, __func__, __LINE__);
988 vxge_hal_trace_log_pool(
989 "devh = 0x"VXGE_OS_STXFMT", blocklist = 0x"VXGE_OS_STXFMT,
990 (ptr_t) devh, (ptr_t) blocklist);
992 blockpool = &((__hal_device_t *) devh)->block_pool;
994 if (blocklist == NULL) {
995 vxge_hal_err_log_pool(
996 "null pointer passed blockpool = 0x"VXGE_OS_STXFMT", "
997 "blocklist = 0x"VXGE_OS_STXFMT, (ptr_t) blockpool,
999 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 1",
1000 __FILE__, __func__, __LINE__);
1004 #if defined(VXGE_HAL_BP_POST)
1005 vxge_os_spin_lock(&blockpool->pool_lock);
1006 #elif defined(VXGE_HAL_BP_POST_IRQ)
1007 vxge_os_spin_lock_irq(&blockpool->pool_lock, flags);
1010 while ((block_entry = (__hal_blockpool_entry_t *)
1011 vxge_list_first_get(blocklist)) != NULL) {
1013 vxge_list_remove(&block_entry->item);
1015 vxge_list_insert(&block_entry->item,
1016 &blockpool->free_block_list);
1018 blockpool->pool_size++;
1021 #if defined(VXGE_HAL_BP_POST)
1022 vxge_os_spin_unlock(&blockpool->pool_lock);
1023 #elif defined(VXGE_HAL_BP_POST_IRQ)
1024 vxge_os_spin_unlock_irq(&blockpool->pool_lock, flags);
1027 __hal_blockpool_blocks_remove(blockpool);
1029 vxge_hal_trace_log_pool("<== %s:%s:%d Result: 0",
1030 __FILE__, __func__, __LINE__);