/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
* Copyright (c) 2002-2006 Neterion, Inc.
*/
#include "xge-os-pal.h"
#include "xgehal-mm.h"
#include "xge-debug.h"
/*
* __hal_mempool_grow
*
* Will resize mempool up to %num_allocate value.
*/
int *num_allocated)
{
*num_allocated = 0;
mempool->memblocks_max) {
"__hal_mempool_grow: can grow anymore");
return XGE_HAL_ERR_OUT_OF_MEMORY;
}
for (i = mempool->memblocks_allocated;
int j;
int is_last =
mempool->memblocks_dma_arr + i;
void *the_memblock;
int dma_flags;
#ifdef XGE_HAL_DMA_DTR_CONSISTENT
#else
#endif
/* allocate DMA-capable memblock */
&dma_object->handle,
&dma_object->acc_handle);
"memblock[%d]: out of DMA memory", i);
return XGE_HAL_ERR_OUT_OF_MEMORY;
}
/* allocate memblock's private part. Each DMA memblock
* has a space allocated for item's private usage upon
* mempool's user request. Each time mempool grows, it will
* allocate new memblock and its private part at once.
* This helps to minimize memory usage a lot. */
&dma_object->handle);
"memblock_priv[%d]: out of virtual memory, "
"requested %d(%d:%d) bytes", i,
return XGE_HAL_ERR_OUT_OF_MEMORY;
}
/* map memblock to physical memory */
#ifdef XGE_HAL_DMA_DTR_CONSISTENT
#else
#endif
);
n_items);
&dma_object->handle);
return XGE_HAL_ERR_OUT_OF_MAPPING;
}
/* fill the items hash array */
for (j=0; j<n_items; j++) {
break;
}
/* let caller to do more job on each item */
i,
int k;
for (k=0; k<j; k++) {
(void)mempool->item_func_free(
i, dma_object,
}
}
n_items);
&dma_object->handle);
return status;
}
}
}
(unsigned long long)dma_object->addr);
(*num_allocated)++;
mempool->items_initial) {
break;
}
}
/* increment actual number of allocated memblocks */
return XGE_HAL_OK;
}
/*
* xge_hal_mempool_create
* @memblock_size:
* @items_initial:
* @items_max:
* @item_size:
* @item_func:
*
* This function will create memory pool object. Pool may grow but will
* never shrink. Pool consists of number of dynamically allocated blocks
* with size enough to hold %items_initial number of items. Memory is
* See also: xge_os_dma_map(), xge_hal_dma_unmap(), xge_hal_status_e{}.
*/
{
int allocated;
if (memblock_size < item_size) {
"memblock_size %d < item_size %d: misconfiguration",
return NULL;
}
mempool = (xge_hal_mempool_t *) \
return NULL;
}
mempool->memblocks_allocated = 0;
/* allocate array of memblocks */
sizeof(void*) * mempool->memblocks_max);
return NULL;
}
sizeof(void*) * mempool->memblocks_max);
/* allocate array of private parts of items per memblocks */
sizeof(void*) * mempool->memblocks_max);
return NULL;
}
sizeof(void*) * mempool->memblocks_max);
/* allocate array of memblocks DMA objects */
return NULL;
}
/* allocate hash array of items */
return NULL;
}
return NULL;
}
/* calculate initial number of memblocks */
"%d items per memblock", memblocks_to_allocate,
/* pre-allocate the mempool */
if (status != XGE_HAL_OK) {
return NULL;
}
"total: allocated %dk of DMA-capable memory",
return mempool;
}
/*
* xge_hal_mempool_destroy
*/
void
{
int i, j;
for (i=0; i<mempool->memblocks_allocated; i++) {
for (j=0; j<mempool->items_per_memblock; j++) {
/* to skip last partially filled(if any) memblock */
break;
}
/* let caller to do more job on each item */
mempool->memblocks_arr[i],
i, dma_object,
}
}
&dma_object->handle);
}
}
if (mempool->shadow_items_arr) {
}
if (mempool->memblocks_dma_arr) {
sizeof(xge_hal_mempool_dma_t) *
}
if (mempool->memblocks_priv_arr) {
sizeof(void*) * mempool->memblocks_max);
}
if (mempool->memblocks_arr) {
sizeof(void*) * mempool->memblocks_max);
}
}