retronetworking
/
dahdi-linux
mirror of https://gerrit.osmocom.org/dahdi-linux
13
0
Fork 0
Code Issues Projects Releases Wiki Activity
dahdi-linux/drivers/dahdi/oct612x/apilib/llman/octapi_llman.c

2788 lines
89 KiB
C
Raw Blame History

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
File: octapi_llman.c
Copyright (c) 2001-2007 Octasic Inc.
Description:
Library used to manage allocation tables and linked lists. The library is
made such that only a block of contiguous memory is needed for the
management of the linked list/allocation table.
This file is part of the Octasic OCT6100 GPL API . The OCT6100 GPL API is
free software; you can redistribute it and/or modify it under the terms of
the GNU General Public License as published by the Free Software Foundation;
either version 2 of the License, or (at your option) any later version.
The OCT6100 GPL API is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with the OCT6100 GPL API; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
$Octasic_Release: OCT612xAPI-01.00-PR49 $
$Octasic_Revision: 22 $
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#include "octapi_llman_private.h"
#include "apilib/octapi_llman.h"
#include "apilib/octapi_largmath.h"
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctapiLlmAllocGetSize.
|
| Description: This function determines the amount of memory needed to
| manage the allocation of a fixed amount of resources.
| The memory is measured in bytes.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| number_of_items UINT32 The number of resources to be allocated.
| *l_size UINT32 UINT32 The amount of memory needed, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctapiLlmAllocGetSize
UINT32 OctapiLlmAllocGetSize(UINT32 number_of_items,UINT32 * l_size)
{
if (number_of_items == 0) return(GENERIC_BAD_PARAM);
*l_size = (sizeof(LLM_ALLOC)) + (number_of_items * sizeof(UINT32));
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctapiLlmAllocInit.
|
| Description: This function intializes the LLM_ALLOC structure.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| **l void The memory used by the LLM_ALLOC structure.
| number_of_items UINT32 The number of resources to be allocated.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctapiLlmAllocInit
UINT32 OctapiLlmAllocInit(void ** l,UINT32 number_of_items)
{
LLM_ALLOC* ls;
UINT32 i;
/* Check the number of items required.*/
if (number_of_items == 0) return(GENERIC_BAD_PARAM);
/* If no memory has been allocated yet:*/
if (*l == NULL) return(OCTAPI_LLM_MEMORY_NOT_ALLOCATED);
/* Build the structure before starting.*/
ls = (LLM_ALLOC *)(*l);
ls->linked_list = (UINT32 *)((BYTE *)ls + sizeof(LLM_ALLOC));
ls->number_of_items = number_of_items;
/* Linked list links all structures in ascending order.*/
for(i=0;i<number_of_items;i++)
{
ls->linked_list[i] = i+1;
}
ls->linked_list[number_of_items - 1] = 0xFFFFFFFF; /* Invalid link.*/
/* Next avail is 0.*/
ls->next_avail_num = 0;
/* Number of allocated items is null.*/
ls->allocated_items = 0;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctapiLlmAllocInfo.
|
| Description: This function returns the number of free and allocated
| block in the LLMAN list.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_ALLOC structure.
| *allocated_items UINT32 Number of allocated items.
| *available_items UINT32 Number of available items.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctapiLlmAllocInfo
UINT32 OctapiLlmAllocInfo(void * l,UINT32 * allocated_items,UINT32 * available_items)
{
LLM_ALLOC* ls;
/* Build the structure before starting.*/
ls = (LLM_ALLOC *)l;
ls->linked_list = (UINT32 *)((BYTE *)ls + sizeof(LLM_ALLOC));
*allocated_items = ls->allocated_items;
*available_items = ls->number_of_items - ls->allocated_items;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctapiLlmAllocInfo.
|
| Description: This function allocates the resource indicated by blocknum.
| If the resource can be allocated then GENERIC_OK is returned.
| Else an error.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_ALLOC structure.
| *block_num UINT32 The resource to be allocated.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctapiLlmAllocAlloc
UINT32 OctapiLlmAllocAlloc(void * l,UINT32 * blocknum)
{
LLM_ALLOC* ls;
UINT32 allocated_block;
UINT32* node;
/* Build the structure before starting.*/
ls = (LLM_ALLOC *)l;
ls->linked_list = (UINT32 *)((BYTE *)ls + sizeof(LLM_ALLOC));
/* Get next available block number.*/
allocated_block = ls->next_avail_num;
/* Check if block is invalid.*/
if (allocated_block == 0xFFFFFFFF)
{
/* Make blocknum NULL.*/
*blocknum = 0xFFFFFFFF;
return(OCTAPI_LLM_NO_STRUCTURES_LEFT);
}
node = &ls->linked_list[allocated_block];
/* Copy next block number.*/
ls->next_avail_num = *node;
/* Tag as used the current block number.*/
*node = 0xFFFFFFFE;
/* Return proper block number.*/
*blocknum = allocated_block;
/* Update block usage number.*/
ls->allocated_items++;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctapiLlmAllocDealloc.
|
| Description: This function deallocates the resource indicated by blocknum.
| If the resource is not already allocated an error is returned.
| Else GENERIC_OK is returned.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_ALLOC structure.
| block_num UINT32 The resource to be deallocated.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctapiLlmAllocDealloc
UINT32 OctapiLlmAllocDealloc(void * l,UINT32 blocknum)
{
LLM_ALLOC* ls;
UINT32* node;
/* Build the structure before starting.*/
ls = (LLM_ALLOC *)l;
ls->linked_list = (UINT32 *)((BYTE *)ls + sizeof(LLM_ALLOC));
/* Check for null item pointer.*/
if (blocknum == 0xFFFFFFFF) return(GENERIC_OK);
/* Check if blocknum is within specified item range.*/
if (blocknum >= ls->number_of_items) return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
node = &ls->linked_list[blocknum];
/* Check if block is really used as of now.*/
if (*node != 0xFFFFFFFE) return(OCTAPI_LLM_MEMORY_NOT_ALLOCATED);
/* Add link to list.*/
*node = ls->next_avail_num;
/* Point to returned block.*/
ls->next_avail_num = blocknum;
/* Update block usage number.*/
ls->allocated_items--;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiTllmAllocGetSize.
|
| Description: This function determines the amount of memory needed to
| manage the allocation of a fixed amount of resources.
| The memory is measured in bytes.
|
| This version is a time manage version of llman.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| number_of_items UINT32 The number of resources to be allocated.
| *l_size UINT32 UINT32 The amount of memory needed, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiTllmAllocGetSize
UINT32 OctApiTllmAllocGetSize(UINT32 number_of_items,UINT32 * l_size)
{
if (number_of_items == 0) return(GENERIC_BAD_PARAM);
*l_size = (sizeof(TLLM_ALLOC)) + (number_of_items * sizeof(TLLM_ALLOC_NODE));
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiTllmAllocInit.
|
| Description: This function intializes the TLLM_ALLOC structure.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| **l void The memory used by the LLM_ALLOC structure.
| number_of_items UINT32 The number of resources to be allocated.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiTllmAllocInit
UINT32 OctApiTllmAllocInit(void ** l,UINT32 number_of_items)
{
TLLM_ALLOC* ls;
UINT32 i;
/* Check the number of items required.*/
if (number_of_items == 0) return(GENERIC_BAD_PARAM);
/* If no memory has been allocated yet.*/
if (*l == NULL) return(OCTAPI_LLM_MEMORY_NOT_ALLOCATED);
/* Build the structure before starting.*/
ls = (TLLM_ALLOC *)(*l);
ls->linked_list = (TLLM_ALLOC_NODE *)((BYTE *)ls + sizeof(TLLM_ALLOC));
ls->number_of_items = number_of_items;
/* Linked list links all structures in ascending order.*/
for(i=0;i<number_of_items;i++)
{
ls->linked_list[i].value = i+1;
}
ls->linked_list[number_of_items - 1].value = 0xFFFFFFFF; /* Invalid link.*/
/* Next avail is 0.*/
ls->next_avail_num = 0;
/* Number of allocated items is null.*/
ls->allocated_items = 0;
/* Set the number of timeout entry.*/
ls->number_of_timeout = 0;
/* Next timeout is 0.*/
ls->next_timeout_num = 0xFFFFFFFF;
ls->last_timeout_num = 0xFFFFFFFF;
/* Set the known time to 0.*/
ls->last_known_time[ 0 ] = 0;
ls->last_known_time[ 1 ] = 0;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiTllmAllocInfo.
|
| Description: This function returns the number of free and allocated
| block in the TLLMAN list.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_ALLOC structure.
| *allocated_items UINT32 Number of allocated items.
| *available_items UINT32 Number of available items.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiTllmAllocInfo
UINT32 OctApiTllmAllocInfo(void * l,UINT32 * allocated_items,UINT32 * available_items)
{
TLLM_ALLOC* ls;
/* Build the structure before starting.*/
ls = (TLLM_ALLOC *)l;
*allocated_items = ls->allocated_items;
*available_items = ls->number_of_items - ls->allocated_items;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiTllmAllocAlloc.
|
| Description: This function allocates the resource indicated by blocknum.
| If the resource can be allocated then GENERIC_OK is returned.
| Else an error.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_ALLOC structure.
| *block_num UINT32 The resource to be allocated.
| *current_time UINT32
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiTllmAllocAlloc
UINT32 OctApiTllmAllocAlloc(void * l,UINT32 * blocknum, UINT32 *current_time)
{
TLLM_ALLOC* ls;
UINT32 allocated_block;
TLLM_ALLOC_NODE* node;
/* Build the structure before starting.*/
ls = (TLLM_ALLOC *)l;
ls->linked_list = (TLLM_ALLOC_NODE *)((BYTE *)ls + sizeof(TLLM_ALLOC));
if ( ls->allocated_items == ls->number_of_items &&
ls->next_timeout_num != 0xFFFFFFFF )
{
UINT32 l_ulResult;
l_ulResult = OctApiTllmCheckTimeoutList( ls, current_time );
if ( l_ulResult != GENERIC_OK )
return l_ulResult;
}
/* Get next available block number.*/
allocated_block = ls->next_avail_num;
/* Check if block is invalid.*/
if (allocated_block == 0xFFFFFFFF)
{
/* Make blocknum NULL.*/
*blocknum = 0xFFFFFFFF;
return(OCTAPI_LLM_NO_STRUCTURES_LEFT);
}
node = &ls->linked_list[allocated_block];
/* Copy next block number.*/
ls->next_avail_num = node->value;
/* Tag as used the current block number.*/
node->value = 0xFFFFFFFE;
/* Return proper block number.*/
*blocknum = allocated_block;
/* Update block usage number.*/
ls->allocated_items++;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiTllmAllocDealloc.
|
| Description: This function deallocates the resource indicated by blocknum.
| If the resource is not already allocated an error is returned.
| Else GENERIC_OK is returned.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_ALLOC structure.
| block_num UINT32 The resource to be deallocated.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiTllmAllocDealloc
UINT32 OctApiTllmAllocDealloc(void * l,UINT32 blocknum, UINT32 timeout_value, UINT32 current_time[2])
{
TLLM_ALLOC* ls;
TLLM_ALLOC_NODE* node;
UINT32 l_ulResult;
/* Build the structure before starting.*/
ls = (TLLM_ALLOC *)l;
ls->linked_list = (TLLM_ALLOC_NODE *)((BYTE *)ls + sizeof(TLLM_ALLOC));
/* Check for null item pointer.*/
if (blocknum == 0xFFFFFFFF) return(GENERIC_OK);
/* Check if blocknum is within specified item range.*/
if (blocknum >= ls->number_of_items) return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
if ( ls->next_timeout_num != 0xFFFFFFFF )
{
l_ulResult = OctApiTllmCheckTimeoutList( ls, current_time );
if ( l_ulResult != GENERIC_OK )
return l_ulResult;
}
node = &ls->linked_list[blocknum];
/* Check if block is really used as of now.*/
if (node->value != 0xFFFFFFFE) return(OCTAPI_LLM_MEMORY_NOT_ALLOCATED);
/* Add link to timeout list.*/
if ( ls->last_timeout_num != 0xFFFFFFFF )
{
TLLM_ALLOC_NODE* last_node;
/* insert the node at the end of the list.*/
node->value = 0xFFFFFFFF;
last_node = &ls->linked_list[ ls->last_timeout_num ];
last_node->value = blocknum;
}
else
{
/* The node is alone in the list.*/
node->value = 0xFFFFFFFF;
ls->next_timeout_num = blocknum;
}
ls->last_timeout_num = blocknum;
ls->number_of_timeout++;
/* Set the timeout time of the node.*/
l_ulResult = OctApiLmAdd( current_time, 1, &timeout_value, 0, node->timeout, 1 );
if (l_ulResult != GENERIC_OK)
return(l_ulResult);
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiTllmCheckTimeoutList.
|
| Description: This function will verify if the timeout time
| of all the node present in the timeout list are bigger
| then the current time. If so the node will be returned
| ot the free node list.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *ls TLLM_ALLOC The memory used by the TLLM_ALLOC structure.
| current_time UINT32[2] The current time in msec.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiTllmCheckTimeoutList
UINT32 OctApiTllmCheckTimeoutList(TLLM_ALLOC *ls, UINT32 current_time[2])
{
UINT32 result;
UINT32 fConditionFlag = TRUE;
/* Free-up any pending memory before trying the allocation:*/
if ((ls->last_known_time[0] != current_time[0] ||
ls->last_known_time[1] != current_time[1]) &&
(current_time[1] != 0 || current_time[0] != 0)) /* Time has changed.*/
{
TLLM_ALLOC_NODE *pcurrent_node;
UINT32 current_num;
USHORT neg;
/* Remember time for next time!*/
ls->last_known_time[0] = current_time[0];
ls->last_known_time[1] = current_time[1];
while ( fConditionFlag == TRUE )
{
/* Get a node from the timeout list.*/
pcurrent_node = &ls->linked_list[ ls->next_timeout_num ];
current_num = ls->next_timeout_num;
/* Check if first node has timeout.*/
result = OctApiLmCompare(current_time,1,pcurrent_node->timeout ,1,&neg);
if (result != GENERIC_OK) return(result);
/* if the timeout tiem was exceeded, set the block as free.*/
if ( neg == FALSE )
{
/* set the next node pointer.*/
ls->next_timeout_num = pcurrent_node->value;
ls->number_of_timeout--;
/* reset the last pointer of the timeout list.*/
if ( ls->number_of_timeout == 0 )
ls->last_timeout_num = 0xFFFFFFFF;
/* return the node the free list.*/
pcurrent_node->value = ls->next_avail_num;
ls->next_avail_num = current_num;
ls->allocated_items--;
}
else /* node not in timeout */
{
fConditionFlag = FALSE;
break;
}
if ( ls->next_timeout_num == 0xFFFFFFFF )
{
fConditionFlag = FALSE;
break; /* end of timeout list.*/
}
}
}
return(GENERIC_OK);
}
#endif
/**************************************** llm_alloc section **********************************************/
/**************************************** llm_list section **********************************************/
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListGetSize
|
| Description: This function determines the amount of memory needed by
| the LLM_LIST structure to manage the allocation of
| number_of_items number of resources. The memory is
| measured in bytes.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| number_of_items UINT32 The number of resources to be allocated
| amongst all linked-lists.
| number_of_lists UINT32 The maximum number of linked-lists that
| can be allocated.
| *l_size UINT32 UINT32 The amount of memory needed, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListGetSize
UINT32 OctApiLlmListGetSize(UINT32 number_of_items,UINT32 number_of_lists,UINT32 user_info_size,UINT32 * l_size)
{
UINT32 head_alloc_size;
UINT32 result;
UINT32 user_info_size_roundup;
if (number_of_items == 0) return(GENERIC_BAD_PARAM);
if (number_of_lists == 0) return(GENERIC_BAD_PARAM);
if (user_info_size == 0) return(GENERIC_BAD_PARAM);
user_info_size_roundup = ((user_info_size + 3) / 4) * 4;
result = OctapiLlmAllocGetSize(number_of_lists,&head_alloc_size);
if(result != GENERIC_OK) return(result);
*l_size = sizeof(LLM_LIST) + (number_of_lists * sizeof(LLM_LIST_HEAD)) + head_alloc_size + (number_of_items * (sizeof(LLM_LIST_ITEM) + user_info_size_roundup - 4));
return(GENERIC_OK);
}
#endif
#if !SKIP_OctApiLlmListGetItemPointer
LLM_LIST_ITEM * OctApiLlmListGetItemPointer(LLM_LIST * ls, UINT32 item_number)
{
return (LLM_LIST_ITEM *) (((BYTE *)ls->li) + (ls->item_size * item_number)) ;
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListInit.
|
| Description: This function intializes the LLM_TALLOC structure.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| number_of_items UINT32 The number of resources to be allocated
| amongst all linked-lists.
| number_of_lists UINT32 The maximum number of linked-lists that
| can be allocated.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListInit
UINT32 OctApiLlmListInit(void ** l,UINT32 number_of_items,UINT32 number_of_lists,UINT32 user_info_size)
{
LLM_LIST* ls;
LLM_LIST_ITEM* item;
UINT32 i;
UINT32 head_alloc_size;
UINT32 result;
UINT32 user_info_size_roundup;
UINT32 total_lists;
BYTE* lsbyte;
if (number_of_items == 0) return(GENERIC_BAD_PARAM);
if (number_of_lists == 0) return(GENERIC_BAD_PARAM);
if (user_info_size == 0) return(GENERIC_BAD_PARAM);
user_info_size_roundup = ((user_info_size + 3) / 4) * 4;
/* Get the size of the Alloc structure used to manage head of list structures.*/
result = OctapiLlmAllocGetSize(number_of_lists,&head_alloc_size);
if(result != GENERIC_OK) return(result);
if (*l == NULL) return(OCTAPI_LLM_MEMORY_NOT_ALLOCATED);
/* Built the structure based on the base address:*/
ls = (LLM_LIST *)(*l);
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
/* Initialize parameters in the structure.*/
ls->head_alloc_size = head_alloc_size;
ls->user_info_bytes = user_info_size;
ls->user_info_size = user_info_size_roundup;
ls->total_items = number_of_items;
ls->assigned_items = 0;
ls->total_lists = number_of_lists;
ls->assigned_lists = 0;
ls->next_empty_item = 0;
ls->item_size = sizeof(LLM_LIST_ITEM) + user_info_size_roundup - 4;
/* Complete the build!*/
ls = (LLM_LIST *)(*l);
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
/* Initialize the head of queue Alloc structure.*/
result = OctapiLlmAllocInit(&(ls->list_head_alloc),number_of_lists);
if(result != GENERIC_OK) return(result);
/* Initialize the linked list of the items:*/
for(i=0; i<number_of_items; i++)
{
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * i);
if (i == (number_of_items - 1))
item->forward_link = 0xFFFFFFFF;
else
item->forward_link = i + 1;
}
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListInfo.
|
| Description: This function returns the status of the LLM_LIST structure.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| *allocated_lists UINT32 The number of linked_lists allocated.
| *free_lists UINT32 The number of linked_lists still free.
| *allocated_items UINT32 The number of items allocated to lists.
| *free_items UINT32 The number of items still free.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListInfo
UINT32 OctApiLlmListInfo(void * l,UINT32 * allocated_lists,UINT32 * allocated_items,
UINT32 * free_lists,UINT32 * free_items)
{
LLM_LIST* ls;
BYTE* lsbyte;
UINT32 total_lists;
/* Built the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
*allocated_items = ls->assigned_items;
*free_items = ls->total_items - ls->assigned_items;
*allocated_lists = ls->assigned_lists;
*free_lists = ls->total_lists - ls->assigned_lists;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListCreate.
|
| Description: This function creates a linked list. The target which is
| allocated the newly created list can request additions
| or removals from the list later on. To target identifies
| its list with the returned list handle.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| *list_handle UINT32 The handle to the new list, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListCreate
UINT32 OctApiLlmListCreate(void * l,UINT32 * list_handle)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
UINT32 blocknum;
UINT32 total_lists;
UINT32 result;
BYTE* lsbyte;
/* Built the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
/* Get a list using the list head alloc structure.*/
result = OctapiLlmAllocAlloc(ls->list_head_alloc, &blocknum);
if (result != GENERIC_OK) return(result);
/* The handle is the block number.*/
*list_handle = blocknum;
/* Initialize the list head structure.*/
lh = &ls->lh[blocknum];
lh->list_length = 0;
lh->head_pointer = 0xFFFFFFFF;
lh->tail_pointer = 0xFFFFFFFF;
lh->cache_item_number = 0xFFFFFFFF;
lh->cache_item_pointer = 0xFFFFFFFF;
ls->assigned_lists++;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListDelete.
|
| Description: This function deletes the linked list indicated by the
| handle list_handle. Any items which are still allocated
| to the list are first deallocated.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| *list_handle UINT32 The handle to the list.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListDelete
UINT32 OctApiLlmListDelete(void * l,UINT32 list_handle)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
UINT32 total_lists;
UINT32 result;
BYTE* lsbyte;
/* Built the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
if (list_handle >= ls->total_lists) return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
if (ls->lh[list_handle].list_length == 0xFFFFFFFF) return(OCTAPI_LLM_INVALID_LIST_HANDLE);
/* Release internal list header handle...*/
result = OctapiLlmAllocDealloc(ls->list_head_alloc,list_handle);
if (result != GENERIC_OK) return(result);
lh = &ls->lh[list_handle];
/* Deallocate all items in the list!*/
if (lh->list_length != 0)
{
LLM_LIST_ITEM * item;
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * lh->tail_pointer);
/* Release the items using only the links.*/
item->forward_link = ls->next_empty_item;
ls->next_empty_item = lh->head_pointer;
/* Remove items from item counter.*/
ls->assigned_items -= lh->list_length;
}
lh->list_length = 0xFFFFFFFF;
lh->head_pointer = 0xFFFFFFFF;
lh->tail_pointer = 0xFFFFFFFF;
lh->cache_item_number = 0xFFFFFFFF;
lh->cache_item_pointer = 0xFFFFFFFF;
ls->assigned_lists--;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListLength.
|
| Description: This function returns the number of items allocated to the
| list indicated by the handle list_handle.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| list_handle UINT32 The handle to the list.
| *number_of_items UINT32 The number of items in the list, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListLength
UINT32 OctApiLlmListLength(void * l,UINT32 list_handle, UINT32 * number_of_items_in_list)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
UINT32 total_lists;
BYTE* lsbyte;
/* Built the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
lh = &ls->lh[list_handle];
if (list_handle >= ls->total_lists) return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
if (lh->list_length == 0xFFFFFFFF) return(OCTAPI_LLM_INVALID_LIST_HANDLE);
*number_of_items_in_list = lh->list_length;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListItemData
|
| Description: This function returns a pointer to the user data associated
| with an item.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| list_handle UINT32 The handle to the list.
| item_number UINT32 The number of the list node in question.
| **item_data_pnt void The pointer to the user data, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListItemData
UINT32 OctApiLlmListItemData(void * l,UINT32 list_handle,UINT32 item_number,void ** item_data_pnt)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
LLM_LIST_ITEM* item;
UINT32 cur_list_pnt;
UINT32 cur_list_num;
UINT32 total_lists;
UINT32 list_length;
BYTE* lsbyte;
UINT32 fConditionFlag = TRUE;
/* Built the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
lh = &ls->lh[list_handle];
list_length = lh->list_length;
*item_data_pnt = NULL;
if (list_handle >= ls->total_lists) return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
if (list_length == 0xFFFFFFFF) return(OCTAPI_LLM_INVALID_LIST_HANDLE);
if (list_length <= item_number) return(OCTAPI_LLM_ELEMENT_NOT_FOUND);
/* Determine where the search will start.*/
if (list_length == (item_number + 1)) /* Last item in list:*/
{
cur_list_pnt = lh->tail_pointer;
cur_list_num = item_number;
}
else if (lh->cache_item_number <= item_number) /* Start at cache:*/
{
cur_list_pnt = lh->cache_item_pointer;
cur_list_num = lh->cache_item_number;
}
else /* Start at beginning:*/
{
cur_list_pnt = lh->head_pointer;
cur_list_num = 0;
}
/* Start search from cur_list_pnt and cur_list_num.*/
while ( fConditionFlag == TRUE )
{
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
if (cur_list_num == item_number) /* Item number found.*/
{
/* Write new cache entry.*/
lh->cache_item_pointer = cur_list_pnt;
lh->cache_item_number = cur_list_num;
/* Get item info.*/
*item_data_pnt = (void *)item->user_info;
return(GENERIC_OK);
}
else if(item->forward_link == 0xFFFFFFFF) /* End of list found?!?*/
{
return(OCTAPI_LLM_INTERNAL_ERROR0);
}
else /* Item was not found, but continue searching.*/
{
cur_list_pnt = item->forward_link;
}
cur_list_num++;
}
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListInsertItem.
|
| Description: This function allocates a node to the linked list specified
| by the handle list_handle. The position of the new item
| can be specified. A position of 0xFFFFFFFF means append to the
| list( use the OCTAPI_LLM_LIST_APPEND define for clarity);
| a position of 0 mean insert at the begining of the list.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| *list_handle UINT32 The handle to the list.
| **item_data void Address of the user data space for this item.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListInsertItem
UINT32 OctApiLlmListInsertItem(void * l,UINT32 list_handle,UINT32 item_number,void ** item_data_pnt)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
LLM_LIST_ITEM* free_item;
UINT32 free_item_pnt;
UINT32 total_lists;
BYTE* lsbyte;
UINT32 fConditionFlag = TRUE;
/* Built the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
lh = &ls->lh[list_handle];
*item_data_pnt = NULL;
if (list_handle >= ls->total_lists) return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
if (lh->list_length == 0xFFFFFFFF) return(OCTAPI_LLM_INVALID_LIST_HANDLE);
if (lh->list_length < item_number && item_number != 0xFFFFFFFF)
return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
if (ls->next_empty_item == 0xFFFFFFFF) return(OCTAPI_LLM_NO_STRUCTURES_LEFT);
/* Get a free item from the free item list!*/
free_item_pnt = ls->next_empty_item;
free_item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * free_item_pnt);
ls->next_empty_item = free_item->forward_link;
if (item_number == 0xFFFFFFFF)
item_number = lh->list_length;
if (lh->list_length == 0) /* First item and only item:*/
{
free_item->forward_link = 0xFFFFFFFF;
lh->tail_pointer = free_item_pnt;
lh->head_pointer = free_item_pnt;
}
else if (item_number == 0) /* First item and but list not empty:*/
{
free_item->forward_link = lh->head_pointer;
lh->head_pointer = free_item_pnt;
}
else if (item_number == lh->list_length) /* Append:*/
{
LLM_LIST_ITEM * last_item;
last_item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * lh->tail_pointer);
last_item->forward_link = free_item_pnt;
free_item->forward_link = 0xFFFFFFFF;
lh->tail_pointer = free_item_pnt;
}
else /* Insert:*/
{
LLM_LIST_ITEM * last_item = NULL;
LLM_LIST_ITEM * item;
UINT32 last_list_pnt;
UINT32 cur_list_pnt;
UINT32 cur_list_num;
if (lh->cache_item_number < item_number) /* Start at cache:*/
{
cur_list_pnt = lh->cache_item_pointer;
cur_list_num = lh->cache_item_number;
}
else /* Start at beginning:*/
{
cur_list_pnt = lh->head_pointer;
cur_list_num = 0;
}
last_list_pnt = 0xFFFFFFFF;
/* Start search from cur_list_pnt and cur_list_num.*/
while ( fConditionFlag == TRUE )
{
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
if (cur_list_num == item_number) /* Item number found.*/
{
if (last_list_pnt == 0xFFFFFFFF) return(OCTAPI_LLM_INTERNAL_ERROR1);
free_item->forward_link = cur_list_pnt;
last_item->forward_link = free_item_pnt;
fConditionFlag = FALSE;
break;
}
else if (item->forward_link == 0xFFFFFFFF) /* End of list found?!?*/
{
return(OCTAPI_LLM_INTERNAL_ERROR0);
}
else /* Item was not found, but continue searching.*/
{
last_item = item;
last_list_pnt = cur_list_pnt;
cur_list_pnt = item->forward_link;
}
cur_list_num++;
}
}
/* Increase the list length.*/
lh->list_length++;
ls->assigned_items++;
*item_data_pnt = (void *)free_item->user_info;
/* Write new cache entry.*/
lh->cache_item_pointer = free_item_pnt;
lh->cache_item_number = item_number;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListCreateFull.
|
| Description: This function allocates the desired number of nodes to
| the linked list specified by the handle list_handle.
| The position of the new item can be specified. A
| position of 0xFFFFFFFF means append to the list (use the
| OCTAPI_LLM_LIST_APPEND define for clarity); a position
| of 0 means insert at the begining of the list.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| *list_handle UINT32 The handle to the list.
| **item_data void Address of the user data space for this item.
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListCreateFull
UINT32 OctApiLlmListCreateFull(void* l, UINT32 list_length, UINT32* plist_handle)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
LLM_LIST_ITEM* free_item;
LLM_LIST_ITEM* last_item = NULL;
UINT32 free_item_pnt = 0xFFFFFFFF;
UINT32 total_lists;
UINT32 list_handle;
UINT32 list_length_m1;
UINT32 next_empty_item;
UINT32 result;
UINT32 i;
BYTE* lsbyte;
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Build the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Make sure another list can be created.*/
if (ls->assigned_lists == ls->total_lists)
return(OCTAPI_LLM_ELEMENT_ALREADY_ASSIGNED);
/* Make sure there are enough free nodes to fill the new list.*/
if (list_length > (ls->total_items - ls->assigned_items))
return(OCTAPI_LLM_ELEMENT_ALREADY_ASSIGNED);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Create list (i.e. get a list using the list head alloc structure.*/
result = OctapiLlmAllocAlloc(ls->list_head_alloc, &list_handle);
if (result != GENERIC_OK) return(result);
/* Initialize the list head structure.*/
lh = &ls->lh[list_handle];
lh->list_length = 0;
lh->head_pointer = 0xFFFFFFFF;
lh->tail_pointer = 0xFFFFFFFF;
lh->cache_item_number = 0xFFFFFFFF;
lh->cache_item_pointer = 0xFFFFFFFF;
ls->assigned_lists++;
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Add the number of requested nodes to the list.*/
lh = &ls->lh[list_handle];
list_length_m1 = list_length - 1;
next_empty_item = ls->next_empty_item;
for (i=0; i<list_length; i++)
{
/* Get a free item from the free item list!*/
free_item_pnt = next_empty_item;
free_item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * free_item_pnt);
next_empty_item = free_item->forward_link;
/* Branch according to whether the node is the first in list, last, or in
the middle.*/
if (i == 0)
{
/* First item.*/
free_item->forward_link = 0xFFFFFFFF;
lh->head_pointer = free_item_pnt;
lh->tail_pointer = free_item_pnt;
}
else if (i == list_length_m1)
{
/* Last item.*/
last_item->forward_link = free_item_pnt;
free_item->forward_link = 0xFFFFFFFF;
lh->tail_pointer = free_item_pnt;
}
else
{
/* Node somewhere in the middle.*/
last_item->forward_link = free_item_pnt;
}
/* Store pointer to free item as pointer to last item (for next iteration).*/
last_item = free_item;
}
/* Store new value of next_empty_item.*/
ls->next_empty_item = next_empty_item;
/* Write new cache entry.*/
lh->cache_item_pointer = free_item_pnt;
lh->cache_item_number = list_length_m1;
/* Set the list length.*/
lh->list_length = list_length;
ls->assigned_items += list_length;
/* Return pointer to new list.*/
*plist_handle = list_handle;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListAppendItems.
|
| Description: This function allocates the desired number of nodes to
| the linked list specified by the handle list_handle.
| The position of the new item can be specified. A
| position of 0xFFFFFFFF means append to the list (use the
| OCTAPI_LLM_LIST_APPEND define for clarity); a position
| of 0 means insert at the begining of the list.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| *list_handle UINT32 The handle to the list.
| **item_data void Address of the user data space for this item.
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListAppendItems
UINT32 OctApiLlmListAppendItems(void* l, UINT32 list_handle, UINT32 num_items)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
LLM_LIST_ITEM* item_list;
LLM_LIST_ITEM* curr_item = NULL;
LLM_LIST_ITEM* free_item;
UINT32 curr_item_pnt = 0xFFFFFFFF;
UINT32 total_lists;
UINT32 next_empty_item;
UINT32 item_size;
UINT32 i;
BYTE* lsbyte;
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Build the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Make sure list handle is valid.*/
if (list_handle >= ls->total_lists)
return(OCTAPI_LLM_INVALID_LIST_HANDLE);
/* Make sure there is at least one item.*/
if (num_items == 0)
return(OCTAPI_LLM_INVALID_PARAMETER);
/* Make sure there are enough free nodes.*/
if (num_items > (ls->total_items - ls->assigned_items))
return(OCTAPI_LLM_NO_STRUCTURES_LEFT);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Get pointer to list structure.*/
lh = &ls->lh[list_handle];
if (lh->list_length == 0xFFFFFFFF)
return(OCTAPI_LLM_INVALID_LIST_HANDLE);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Add the number of requested nodes to the list.*/
item_list = ls->li;
item_size = ls->item_size;
next_empty_item = ls->next_empty_item;
for (i=0; i<num_items; i++)
{
if (i == 0)
{
if (lh->head_pointer == 0xFFFFFFFF)
{
/* Current and next items are one and the same!*/
curr_item = (LLM_LIST_ITEM *)((BYTE *)item_list + item_size * next_empty_item);
/* Set new head and tail pointers.*/
lh->head_pointer = next_empty_item;
lh->tail_pointer = next_empty_item;
/* Update current item pnt.*/
curr_item_pnt = next_empty_item;
/* Update next item.*/
next_empty_item = curr_item->forward_link;
/* Set first item to be only item in list.*/
curr_item->forward_link = 0xFFFFFFFF;
}
else
{
/* Get a free item from the free item list!*/
curr_item = (LLM_LIST_ITEM *)((BYTE *)item_list + item_size * lh->tail_pointer);
free_item = (LLM_LIST_ITEM *)((BYTE *)item_list + item_size * next_empty_item);
/* Have current item point to next empty item.*/
curr_item->forward_link = next_empty_item;
/* Update current item pnt.*/
curr_item_pnt = next_empty_item;
/* Update next_empty_item.*/
next_empty_item = free_item->forward_link;
/* Update pointers to current item and free item.*/
curr_item = free_item;
}
}
else
{
/* Update pointers to current item and free item.*/
free_item = (LLM_LIST_ITEM *)((BYTE *)item_list + item_size * next_empty_item);
/* Have current item point to next empty item.*/
curr_item->forward_link = next_empty_item;
/* Update current item pnt.*/
curr_item_pnt = next_empty_item;
/* Update next_empty_item.*/
next_empty_item = free_item->forward_link;
/* Update pointers to current item and free item.*/
curr_item = free_item;
}
}
/* Terminate list.*/
if ( curr_item != NULL )
curr_item->forward_link = 0xFFFFFFFF;
/* Update llman structure variables.*/
ls->next_empty_item = next_empty_item;
ls->assigned_items += num_items;
/* Update list variables.*/
lh->list_length += num_items;
lh->cache_item_pointer = curr_item_pnt;
lh->cache_item_number = lh->list_length - 1;
lh->tail_pointer = curr_item_pnt;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListAppendAndSetItems.
|
| Description:
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListAppendAndSetItems
UINT32 OctApiLlmListAppendAndSetItems(void* l, UINT32 list_handle, UINT32 num_items, void* data_list)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
LLM_LIST_ITEM* item_list;
LLM_LIST_ITEM* curr_item = NULL;
LLM_LIST_ITEM* free_item;
UINT32 curr_item_pnt = 0xFFFFFFFF;
UINT32 total_lists;
UINT32 next_empty_item;
UINT32 user_info_bytes;
UINT32 item_size;
UINT32 i;
BYTE* lsbyte;
void* data_item;
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Build the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Make sure list handle is valid.*/
if (list_handle >= ls->total_lists)
return(OCTAPI_LLM_INVALID_LIST_HANDLE);
/* Make sure there is at least one item.*/
if (num_items == 0)
return(OCTAPI_LLM_INVALID_PARAMETER);
/* Make sure there are enough free nodes.*/
if (num_items > (ls->total_items - ls->assigned_items))
return(OCTAPI_LLM_NO_STRUCTURES_LEFT);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Get pointer to list structure.*/
lh = &ls->lh[list_handle];
if (lh->list_length == 0xFFFFFFFF)
return(OCTAPI_LLM_INVALID_LIST_HANDLE);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Add the number of requested nodes to the list.*/
item_list = ls->li;
user_info_bytes = ls->user_info_bytes;
item_size = ls->item_size;
next_empty_item = ls->next_empty_item;
data_item = data_list;
for (i=0; i<num_items; i++)
{
if (i == 0)
{
if (lh->head_pointer == 0xFFFFFFFF)
{
/* Current and next items are one and the same!*/
curr_item = (LLM_LIST_ITEM *)((BYTE *)item_list + item_size * next_empty_item);
/* Set new head and tail pointers.*/
lh->head_pointer = next_empty_item;
lh->tail_pointer = next_empty_item;
/* Update current item pnt.*/
curr_item_pnt = next_empty_item;
/* Update next item.*/
next_empty_item = curr_item->forward_link;
/* Set first item to be only item in list.*/
curr_item->forward_link = 0xFFFFFFFF;
}
else
{
/* Get a free item from the free item list!*/
curr_item = (LLM_LIST_ITEM *)((BYTE *)item_list + item_size * lh->tail_pointer);
free_item = (LLM_LIST_ITEM *)((BYTE *)item_list + item_size * next_empty_item);
/* Have current item point to next empty item.*/
curr_item->forward_link = next_empty_item;
/* Update current item pnt.*/
curr_item_pnt = next_empty_item;
/* Update next_empty_item.*/
next_empty_item = free_item->forward_link;
/* Update pointers to current item and free item.*/
curr_item = free_item;
}
}
else
{
/* Update pointers to current item and free item.*/
free_item = (LLM_LIST_ITEM *)((BYTE *)item_list + item_size * next_empty_item);
/* Have current item point to next empty item.*/
curr_item->forward_link = next_empty_item;
/* Update current item pnt.*/
curr_item_pnt = next_empty_item;
/* Update next_empty_item.*/
next_empty_item = free_item->forward_link;
/* Update pointers to current item and free item.*/
curr_item = free_item;
}
/* Copy data to new item.*/
OctApiLlmMemCpy(curr_item->user_info, data_item, user_info_bytes);
/* Update data_item pointer for next iteration (item).*/
data_item = (void *)((BYTE *)data_item + user_info_bytes);
}
/* Terminate list.*/
if ( curr_item != NULL )
curr_item->forward_link = 0xFFFFFFFF;
/* Update llman structure variables.*/
ls->next_empty_item = next_empty_item;
ls->assigned_items += num_items;
/* Update list variables.*/
lh->list_length += num_items;
lh->cache_item_pointer = curr_item_pnt;
lh->cache_item_number = lh->list_length - 1;
lh->tail_pointer = curr_item_pnt;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListSetItems.
|
| Description: This function takes a start entry (0 to length - 1),
| a pointer to a list of data (each item of list is the
| size of one data unit, specified at init), and the
| length of the data list. From this, the data will be
| copied from the data list to the linked list, from
| entry start_entry to (start_entry + data_length - 1).
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListSetItems
UINT32 OctApiLlmListSetItems(void* l, UINT32 list_handle, UINT32 start_item, UINT32 data_length, void* pdata_list)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
LLM_LIST_ITEM* item = NULL;
UINT32 total_lists;
UINT32 item_pnt = 0xFFFFFFFF;
UINT32 i, j;
BYTE* lsbyte;
void* pdata_item = NULL;
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Build the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Make sure list handle is valid.*/
if (list_handle >= ls->total_lists)
return(OCTAPI_LLM_INVALID_LIST_HANDLE);
lh = &ls->lh[list_handle];
if (lh->list_length == 0xFFFFFFFF)
return(OCTAPI_LLM_INVALID_LIST_HANDLE);
/* Make sure the start_entry is within limits.*/
if (start_item >= lh->list_length)
return(OCTAPI_LLM_INVALID_PARAMETER);
/* Make sure the end_entry is within limits.*/
lh = &ls->lh[list_handle];
if ((start_item + data_length) > lh->list_length)
return(OCTAPI_LLM_INVALID_PARAMETER);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Set the data of each node.*/
for (i=0; i<data_length; i++)
{
/* Obtain pointer to current item.*/
if (i == 0)
{
/* Check if location of start item is already cached. If not, must search
for it manually.*/
if (start_item == (lh->cache_item_number + 1))
{
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * lh->cache_item_pointer);
item_pnt = item->forward_link;
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * item_pnt);
}
else
{
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * lh->head_pointer);
item_pnt = lh->head_pointer;
for (j=0; j<start_item; j++)
{
item_pnt = item->forward_link;
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * item_pnt);
}
}
pdata_item = (void *)((BYTE *)pdata_list + (i * ls->user_info_bytes));
}
else
{
item_pnt = item->forward_link;
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * item_pnt);
pdata_item = (void *)((BYTE *)pdata_item + ls->user_info_bytes);
}
/* Set the value of the item's user data.*/
OctApiLlmMemCpy(item->user_info, pdata_item, ls->user_info_bytes);
}
/* Write new cache entry.*/
lh->cache_item_pointer = item_pnt;
lh->cache_item_number = start_item + data_length - 1;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListCopyData.
|
| Description: This function takes a start entry (0 to length - 1),
| a pointer to a list of data (each item of list is the
| size of one data unit, specified at init), and the
| length of the data list. From this, the data will be
| copied from the linked list to the data list, from
| entry start_entry of the linked list to
| (start_entry + data_length - 1).
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListCopyData
UINT32 OctApiLlmListCopyData(void* l, UINT32 list_handle, UINT32 start_item, UINT32 data_length, void* pdata_list)
{
LLM_LIST* ls;
LLM_LIST_HEAD* lh;
LLM_LIST_ITEM* item = NULL;
UINT32 item_pnt = 0xFFFFFFFF;
UINT32 total_lists;
UINT32 i, j;
BYTE* lsbyte;
void* pdata_item = NULL;
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Build the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Make sure list handle is valid.*/
if (list_handle >= ls->total_lists)
return(OCTAPI_LLM_INVALID_LIST_HANDLE);
lh = &ls->lh[list_handle];
if (lh->list_length == 0xFFFFFFFF)
return(OCTAPI_LLM_INVALID_LIST_HANDLE);
/* Make sure the start_entry is within limits.*/
if (start_item >= lh->list_length)
return(OCTAPI_LLM_INVALID_PARAMETER);
/* Make sure the end_entry is within limits.*/
lh = &ls->lh[list_handle];
if ((start_item + data_length) > lh->list_length)
return(OCTAPI_LLM_INVALID_PARAMETER);
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
/* Set the data of each node.*/
for (i=0; i<data_length; i++)
{
/* Obtain pointer to current item.*/
if (i == 0)
{
/* Check if location of start item is already cached. If not, must search
for it manually.*/
if (start_item == (lh->cache_item_number + 1))
{
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * lh->cache_item_pointer);
item_pnt = item->forward_link;
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * item_pnt);
}
else
{
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * lh->head_pointer);
for (j=0; j<start_item; j++)
{
item_pnt = item->forward_link;
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * item_pnt);
}
}
pdata_item = (void *)((BYTE *)pdata_list + (i * ls->user_info_bytes));
}
else
{
item_pnt = item->forward_link;
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * item_pnt);
pdata_item = (void *)((BYTE *)pdata_item + ls->user_info_bytes);
}
/* Set the value of the item's user data.*/
OctApiLlmMemCpy(pdata_item, item->user_info, ls->user_info_bytes);
}
/* Write new cache entry.*/
lh->cache_item_pointer = item_pnt;
lh->cache_item_number = start_item + data_length - 1;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListRemoveItem.
|
| Description: This function deallocates a node of the linked list specified
| by the handle list_handle.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| list_handle UINT32 The handle to the list.
| item_number UINT32 The number of the item to be removed.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmListRemoveItem
UINT32 OctApiLlmListRemoveItem(void * l,UINT32 list_handle,UINT32 item_number)
{
LLM_LIST* ls;
LLM_LIST_ITEM* freed_item = NULL;
LLM_LIST_HEAD* lh;
UINT32 freed_item_pnt = 0xFFFFFFFF;
UINT32 total_lists;
BYTE* lsbyte;
UINT32 fConditionFlag = TRUE;
/* Built the structure based on the base address:*/
ls = (LLM_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM_LIST_HEAD *)(lsbyte + sizeof(LLM_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)));
ls->li = (LLM_LIST_ITEM *)(lsbyte + sizeof(LLM_LIST) + (total_lists * sizeof(LLM_LIST_HEAD)) + ls->head_alloc_size);
lh = &ls->lh[list_handle];
if (list_handle >= ls->total_lists) return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
if (lh->list_length == 0xFFFFFFFF) return(OCTAPI_LLM_INVALID_LIST_HANDLE);
if (lh->list_length <= item_number) return(OCTAPI_LLM_BLOCKNUM_OUT_OF_RANGE);
if (item_number == 0 && lh->list_length == 1)/* First item and only item:*/
{
freed_item_pnt = lh->head_pointer;
freed_item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * freed_item_pnt);
lh->head_pointer = 0xFFFFFFFF;
lh->tail_pointer = 0xFFFFFFFF;
lh->cache_item_number = 0xFFFFFFFF;
lh->cache_item_pointer = 0xFFFFFFFF;
}
else if (item_number == 0) /* First item and but list not empty:*/
{
freed_item_pnt = ls->lh[list_handle].head_pointer;
freed_item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * freed_item_pnt);
lh->head_pointer = freed_item->forward_link;
lh->cache_item_number = 0;
lh->cache_item_pointer = freed_item->forward_link;
}
else /* Discard non-first item! (Caution: this could be the last item!)*/
{
LLM_LIST_ITEM * last_item = NULL;
LLM_LIST_ITEM * item;
UINT32 last_list_pnt;
UINT32 cur_list_pnt;
UINT32 cur_list_num;
if (lh->cache_item_number < item_number) /* Start at cache:*/
{
cur_list_pnt = lh->cache_item_pointer;
cur_list_num = lh->cache_item_number;
}
else /* Start at beginning:*/
{
cur_list_pnt = lh->head_pointer;
cur_list_num = 0;
}
last_list_pnt = 0xFFFFFFFF;
/* Start search from cur_list_pnt and cur_list_num.*/
while( fConditionFlag == TRUE )
{
item = (LLM_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
if (cur_list_num == item_number) /* Item number found.*/
{
if (last_list_pnt == 0xFFFFFFFF) return(OCTAPI_LLM_INTERNAL_ERROR1);
if ((item_number + 1) == lh->list_length)
{
lh->tail_pointer = last_list_pnt;
last_item->forward_link = 0xFFFFFFFF;
}
else
{
last_item->forward_link = item->forward_link;
}
freed_item_pnt = cur_list_pnt;
freed_item = item;
/* Reset cache entry.*/
lh->cache_item_pointer = last_list_pnt;
lh->cache_item_number = cur_list_num - 1;
fConditionFlag = FALSE;
break;
}
else if (item->forward_link == 0xFFFFFFFF) /* End of list found?!?*/
{
return(OCTAPI_LLM_INTERNAL_ERROR0);
}
else /* Item was not found, but continue searching.*/
{
last_item = item;
last_list_pnt = cur_list_pnt;
cur_list_pnt = item->forward_link;
}
cur_list_num++;
}
}
/* Decrease the list length.*/
lh->list_length--;
ls->assigned_items--;
/* Return free block to free block list:*/
freed_item->forward_link = ls->next_empty_item;
ls->next_empty_item = freed_item_pnt;
return(GENERIC_OK);
}
#endif
/**************************************** llm2 function section *****************************************/
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlm2ListGetSize
|
| Description: This function determines the amount of memory needed by
| the LLM2_LIST structure to manage the allocation of
| number_of_items number of resources. The memory is
| measured in bytes.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| number_of_items UINT32 The number of resources to be allocated
| amongst all linked-lists.
| number_of_lists UINT32 The maximum number of linked-lists that
| can be allocated.
| *l_size UINT32 UINT32 The amount of memory needed, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlm2ListGetSize
UINT32 OctApiLlm2ListGetSize(UINT32 number_of_items,UINT32 number_of_lists,UINT32 user_info_size,UINT32 * l_size)
{
UINT32 head_alloc_size;
UINT32 result;
UINT32 user_info_size_roundup;
if (number_of_items == 0) return(GENERIC_BAD_PARAM);
if (number_of_lists == 0) return(GENERIC_BAD_PARAM);
if (user_info_size == 0) return(GENERIC_BAD_PARAM);
user_info_size_roundup = ((user_info_size + 3) / 4) * 4;
result = OctapiLlmAllocGetSize(number_of_lists,&head_alloc_size);
if(result != GENERIC_OK) return(result);
*l_size = sizeof(LLM2_LIST) + (number_of_lists * sizeof(LLM2_LIST_HEAD)) + head_alloc_size + (number_of_items * (sizeof(LLM2_LIST_ITEM) + user_info_size_roundup - 4));
return(GENERIC_OK);
}
#endif
#if !SKIP_OctApiLlm2ListGetItemPointer
LLM2_LIST_ITEM * OctApiLlm2ListGetItemPointer(LLM2_LIST * ls, UINT32 item_number)
{
return (LLM2_LIST_ITEM *) (((BYTE *)ls->li) + (ls->item_size * item_number)) ;
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlm2ListInit.
|
| Description: This function intializes the LLM2_TALLOC structure.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM2_LIST structure.
| number_of_items UINT32 The number of resources to be allocated
| amongst all linked-lists.
| number_of_lists UINT32 The maximum number of linked-lists that
| can be allocated.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlm2ListInit
UINT32 OctApiLlm2ListInit(void ** l,UINT32 number_of_items,UINT32 number_of_lists,UINT32 user_info_size)
{
LLM2_LIST* ls;
LLM2_LIST_ITEM* item;
UINT32 i;
UINT32 head_alloc_size;
UINT32 result;
UINT32 user_info_size_roundup;
UINT32 total_lists;
BYTE* lsbyte;
if (number_of_items == 0) return(GENERIC_BAD_PARAM);
if (number_of_lists == 0) return(GENERIC_BAD_PARAM);
if (user_info_size == 0) return(GENERIC_BAD_PARAM);
user_info_size_roundup = ((user_info_size + 3) / 4) * 4;
/* Get the size of the Alloc structure used to manage head of list structures.*/
result = OctapiLlmAllocGetSize(number_of_lists,&head_alloc_size);
if(result != GENERIC_OK) return(result);
if (*l == NULL) return(OCTAPI_LLM_MEMORY_NOT_ALLOCATED);
/* Built the structure based on the base address:*/
ls = (LLM2_LIST *)(*l);
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM2_LIST_HEAD *)(lsbyte + sizeof(LLM2_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)));
ls->li = (LLM2_LIST_ITEM *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)) + ls->head_alloc_size);
/* Initialize parameters in the structure.*/
ls->head_alloc_size = head_alloc_size;
ls->user_info_bytes = user_info_size;
ls->user_info_size = user_info_size_roundup;
ls->total_items = number_of_items;
ls->assigned_items = 0;
ls->total_lists = number_of_lists;
ls->assigned_lists = 0;
ls->next_empty_item = 0;
ls->item_size = sizeof(LLM2_LIST_ITEM) + user_info_size_roundup - 4;
/* Complete the build!*/
ls = (LLM2_LIST *)(*l);
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM2_LIST_HEAD *)(lsbyte + sizeof(LLM2_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)));
ls->li = (LLM2_LIST_ITEM *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)) + ls->head_alloc_size);
/* Initialize the head of queue Alloc structure.*/
result = OctapiLlmAllocInit(&(ls->list_head_alloc),number_of_lists);
if(result != GENERIC_OK) return(result);
/* Initialize the linked list of the items:*/
for(i=0; i<number_of_items; i++)
{
item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * i);
if (i == (number_of_items - 1))
item->forward_link = 0xFFFFFFFF;
else
item->forward_link = i + 1;
}
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlm2ListCreate.
|
| Description: This function creates a linked list. The target which is
| allocated the newly created list can request additions
| or removals from the list later on. To target identifies
| its list with the returned list handle.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM_LIST structure.
| *list_handle UINT32 The handle to the new list, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlm2ListCreate
UINT32 OctApiLlm2ListCreate(void * l,UINT32 * list_handle)
{
LLM2_LIST* ls;
LLM2_LIST_HEAD* lh;
UINT32 blocknum;
UINT32 total_lists;
UINT32 result;
BYTE* lsbyte;
/* Built the structure based on the base address:*/
ls = (LLM2_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM2_LIST_HEAD *)(lsbyte + sizeof(LLM2_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)));
ls->li = (LLM2_LIST_ITEM *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)) + ls->head_alloc_size);
/* Get a list using the list head alloc structure.*/
result = OctapiLlmAllocAlloc(ls->list_head_alloc, &blocknum);
if (result != GENERIC_OK) return(result);
/* The handle is the block number.*/
*list_handle = blocknum;
/* Initialize the list head structure.*/
lh = &ls->lh[blocknum];
lh->list_length = 0;
lh->head_pointer = 0xFFFFFFFF;
lh->tail_pointer = 0xFFFFFFFF;
ls->assigned_lists++;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListDelete.
|
| Description: This function deletes the linked list indicated by the
| handle list_handle. Any items which are still allocated
| to the list are first deallocated.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM2_LIST structure.
| *list_handle UINT32 The handle to the list.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlm2ListDelete
UINT32 OctApiLlm2ListDelete(void * l,UINT32 list_handle)
{
LLM2_LIST* ls;
LLM2_LIST_HEAD* lh;
UINT32 total_lists;
UINT32 result;
BYTE* lsbyte;
/* Built the structure based on the base address:*/
ls = (LLM2_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM2_LIST_HEAD *)(lsbyte + sizeof(LLM2_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)));
ls->li = (LLM2_LIST_ITEM *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)) + ls->head_alloc_size);
if (list_handle >= ls->total_lists) return(OCTAPI_LLM2_BLOCKNUM_OUT_OF_RANGE);
if (ls->lh[list_handle].list_length == 0xFFFFFFFF) return(OCTAPI_LLM2_INVALID_LIST_HANDLE);
/* Release internal list header handle...*/
result = OctapiLlmAllocDealloc(ls->list_head_alloc,list_handle);
if (result != GENERIC_OK) return(result);
lh = &ls->lh[list_handle];
/* Deallocate all items in the list!*/
if (lh->list_length != 0)
{
LLM2_LIST_ITEM * item;
item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * lh->tail_pointer);
/* Release the items using only the links.*/
item->forward_link = ls->next_empty_item;
ls->next_empty_item = lh->head_pointer;
/* Remove items from item counter.*/
ls->assigned_items -= lh->list_length;
}
lh->list_length = 0xFFFFFFFF;
lh->head_pointer = 0xFFFFFFFF;
lh->tail_pointer = 0xFFFFFFFF;
ls->assigned_lists--;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmListLength.
|
| Description: This function returns the number of items allocated to the
| list indicated by the handle list_handle.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM2_LIST structure.
| list_handle UINT32 The handle to the list.
| *number_of_items UINT32 The number of items in the list, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlm2ListLength
UINT32 OctApiLlm2ListLength(void * l,UINT32 list_handle, UINT32 * number_of_items_in_list)
{
LLM2_LIST* ls;
LLM2_LIST_HEAD* lh;
UINT32 total_lists;
BYTE* lsbyte;
/* Built the structure based on the base address:*/
ls = (LLM2_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM2_LIST_HEAD *)(lsbyte + sizeof(LLM2_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)));
ls->li = (LLM2_LIST_ITEM *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)) + ls->head_alloc_size);
lh = &ls->lh[list_handle];
if (list_handle >= ls->total_lists) return(OCTAPI_LLM2_BLOCKNUM_OUT_OF_RANGE);
if (lh->list_length == 0xFFFFFFFF) return(OCTAPI_LLM2_INVALID_LIST_HANDLE);
*number_of_items_in_list = lh->list_length;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlm2ListItemData
|
| Description: This function returns a pointer to the user data associated
| with an item.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM2_LIST structure.
| list_handle UINT32 The handle to the list.
| item_number UINT32 The number of the list node in question.
| **item_data_pnt void The pointer to the user data, returned.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlm2ListItemData
UINT32 OctApiLlm2ListItemData(void * l,UINT32 list_handle,UINT32 item_key,void ** item_data_pnt, PUINT32 item_number_pnt)
{
LLM2_LIST* ls;
LLM2_LIST_HEAD* lh;
LLM2_LIST_ITEM* item;
UINT32 cur_list_pnt;
UINT32 cur_list_key = 0xFFFFFFFF;
UINT32 total_lists;
UINT32 list_length;
BYTE* lsbyte;
UINT32 fConditionFlag = TRUE;
/* Built the structure based on the base address:*/
ls = (LLM2_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM2_LIST_HEAD *)(lsbyte + sizeof(LLM2_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)));
ls->li = (LLM2_LIST_ITEM *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)) + ls->head_alloc_size);
lh = &ls->lh[list_handle];
list_length = lh->list_length;
*item_data_pnt = NULL;
*item_number_pnt = 0;
if (list_handle >= ls->total_lists) return(OCTAPI_LLM2_BLOCKNUM_OUT_OF_RANGE);
if (list_length == 0xFFFFFFFF) return(OCTAPI_LLM2_INVALID_LIST_HANDLE);
/* Determine where the search will start.*/
/* Start at beginning:*/
cur_list_pnt = lh->head_pointer;
item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
cur_list_key = item->key;
/* Start search from cur_list_pnt and cur_list_num.*/
while ( fConditionFlag == TRUE )
{
if (cur_list_key == item_key) /* Item key found.*/
{
/* Get item info.*/
*item_data_pnt = (void *)item->user_info;
return(GENERIC_OK);
}
else if(item->forward_link == 0xFFFFFFFF) /* End of list found?!?*/
{
return(OCTAPI_LLM2_INTERNAL_ERROR0);
}
else /* Item was not found, but continue searching.*/
{
cur_list_pnt = item->forward_link;
}
item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
cur_list_key = item->key;
(*item_number_pnt)++;
}
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlm2ListInsertItem.
|
| Description: This function allocates a node to the linked list specified
| by the handle list_handle. The position of the new item
| will be defined based on the key value. All entry are inserted
| in the list in incremental Key value.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM2_LIST structure.
| *list_handle UINT32 The handle to the list.
| **item_data void Address of the user data space for this item.
| **prev_item_data void Address of the user data space for the previous item.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlm2ListInsertItem
UINT32 OctApiLlm2ListInsertItem(void * l,UINT32 list_handle,UINT32 item_key,void ** item_data_pnt, void ** prev_item_data_pnt, void ** prev_prev_item_data_pnt, PUINT32 insert_status_pnt )
{
LLM2_LIST* ls;
LLM2_LIST_HEAD* lh;
LLM2_LIST_ITEM* free_item;
UINT32 free_item_pnt;
UINT32 total_lists;
BYTE* lsbyte;
UINT32 ulPassCount = 0;
UINT32 fConditionFlag = TRUE;
/* Set the status of the insertion.*/
*insert_status_pnt = OCTAPI_LLM2_INSERT_ERROR;
/* Built the structure based on the base address:*/
ls = (LLM2_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
ls->lh = (LLM2_LIST_HEAD *)(lsbyte + sizeof(LLM2_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)));
ls->li = (LLM2_LIST_ITEM *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)) + ls->head_alloc_size);
lh = &ls->lh[list_handle];
*item_data_pnt = NULL;
if (list_handle >= ls->total_lists) return(OCTAPI_LLM2_BLOCKNUM_OUT_OF_RANGE);
if (lh->list_length == 0xFFFFFFFF) return(OCTAPI_LLM2_INVALID_LIST_HANDLE);
if (ls->next_empty_item == 0xFFFFFFFF) return(OCTAPI_LLM2_NO_STRUCTURES_LEFT);
/* Get a free item from the free item list!*/
free_item_pnt = ls->next_empty_item;
free_item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * free_item_pnt);
free_item->key = item_key;
ls->next_empty_item = free_item->forward_link;
if (lh->list_length == 0) /* First item and only item:*/
{
free_item->forward_link = 0xFFFFFFFF;
lh->tail_pointer = free_item_pnt;
lh->head_pointer = free_item_pnt;
*insert_status_pnt = OCTAPI_LLM2_INSERT_FIRST_NODE;
/* There is no previous node information to return.*/
*prev_item_data_pnt = NULL;
*prev_prev_item_data_pnt = NULL;
}
else /* Insert:*/
{
LLM2_LIST_ITEM * last_last_item = NULL;
LLM2_LIST_ITEM * last_item = NULL;
LLM2_LIST_ITEM * item;
UINT32 last_list_pnt;
UINT32 cur_list_pnt;
UINT32 cur_list_key = 0xFFFFFFFF;
/* Start at beginning:*/
cur_list_pnt = lh->head_pointer;
item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
cur_list_key = item->key;
last_list_pnt = 0xFFFFFFFF;
/* Start search from cur_list_pnt and cur_list_num.*/
while ( fConditionFlag == TRUE )
{
/* Increment the pass count to determine if the addition will happen next to last.*/
ulPassCount++;
if (cur_list_key >= item_key) /* Item new node between the last and the curent. */
{
if (last_list_pnt == 0xFFFFFFFF) /* Must insert at the head of the list.*/
{
free_item->forward_link = cur_list_pnt;
lh->head_pointer = free_item_pnt;
}
else /* Standard insertion.*/
{
free_item->forward_link = cur_list_pnt;
last_item->forward_link = free_item_pnt;
}
/* Check if the entry was made before the last one.*/
if ( ulPassCount == lh->list_length )
*insert_status_pnt = OCTAPI_LLM2_INSERT_BEFORE_LAST_NODE;
else
*insert_status_pnt = OCTAPI_LLM2_INSERT_LIST_NODE;
fConditionFlag = FALSE;
break;
}
else if (item->forward_link == 0xFFFFFFFF) /* End of list found, must insert at the end.*/
{
free_item->forward_link = 0xFFFFFFFF;
item->forward_link = free_item_pnt;
lh->tail_pointer = free_item_pnt;
*insert_status_pnt = OCTAPI_LLM2_INSERT_LAST_NODE;
fConditionFlag = FALSE;
break;
}
else /* Item was not found, but continue searching.*/
{
last_last_item = last_item;
last_item = item;
last_list_pnt = cur_list_pnt;
cur_list_pnt = item->forward_link;
}
item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
cur_list_key = item->key;
}
/* Return the previous node if possible.*/
if ( *insert_status_pnt == OCTAPI_LLM2_INSERT_LIST_NODE ||
*insert_status_pnt == OCTAPI_LLM2_INSERT_BEFORE_LAST_NODE )
{
if ( last_item != NULL )
*prev_item_data_pnt = (void *)last_item->user_info;
if ( last_last_item != NULL )
*prev_prev_item_data_pnt = (void *)last_last_item->user_info;
else
*prev_prev_item_data_pnt = NULL;
}
else
{
*prev_item_data_pnt = (void *)item->user_info;
if ( ( last_last_item != NULL ) && ( last_item != NULL ) )
*prev_prev_item_data_pnt = (void *)last_item->user_info;
else
*prev_prev_item_data_pnt = NULL;
}
}
/* Increase the list length.*/
lh->list_length++;
ls->assigned_items++;
*item_data_pnt = (void *)free_item->user_info;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlm2ListRemoveItem.
|
| Description: This function deallocates a node of the linked list specified
| by the handle list_handle.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *l void The memory used by the LLM2_LIST structure.
| list_handle UINT32 The handle to the list.
| item_key UINT32 The key of the item to be removed.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlm2ListRemoveItem
UINT32 OctApiLlm2ListRemoveItem(void * l,UINT32 list_handle,UINT32 item_key, PUINT32 prev_item_key_pnt, PUINT32 prev_prev_item_key_pnt, PUINT32 remove_status_pnt )
{
LLM2_LIST* ls;
LLM2_LIST_ITEM* freed_item = NULL;
LLM2_LIST_HEAD* lh;
UINT32 freed_item_pnt = 0xFFFFFFFF;
UINT32 total_lists;
BYTE* lsbyte;
UINT32 fConditionFlag = TRUE;
UINT32 ulPassCount = 0;
/* Built the structure based on the base address:*/
ls = (LLM2_LIST *)l;
lsbyte = (BYTE *)ls;
total_lists = ls->total_lists;
/* Set the status of the removal to error as a default value.*/
*remove_status_pnt = OCTAPI_LLM2_REMOVE_ERROR;
ls->lh = (LLM2_LIST_HEAD *)(lsbyte + sizeof(LLM2_LIST));
ls->list_head_alloc = (void *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)));
ls->li = (LLM2_LIST_ITEM *)(lsbyte + sizeof(LLM2_LIST) + (total_lists * sizeof(LLM2_LIST_HEAD)) + ls->head_alloc_size);
lh = &ls->lh[list_handle];
if (list_handle >= ls->total_lists) return(OCTAPI_LLM2_BLOCKNUM_OUT_OF_RANGE);
if (lh->list_length == 0xFFFFFFFF) return(OCTAPI_LLM2_INVALID_LIST_HANDLE);
if (lh->list_length == 1)/* First item and only item if he matches.*/
{
freed_item_pnt = lh->head_pointer;
freed_item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * freed_item_pnt);
if ( freed_item->key == item_key )
{
lh->head_pointer = 0xFFFFFFFF;
lh->tail_pointer = 0xFFFFFFFF;
}
else
return(OCTAPI_LLM2_INTERNAL_ERROR1);
/* Indicate that there was no node prior to the one removed.*/
*prev_item_key_pnt = 0xFFFFFFFF;
*prev_prev_item_key_pnt = 0xFFFFFFFF;
*remove_status_pnt = OCTAPI_LLM2_REMOVE_FIRST_NODE;
}
else /* Discard non-first item! (Caution: this could be the last item!)*/
{
LLM2_LIST_ITEM * last_last_item = NULL;
LLM2_LIST_ITEM * last_item = NULL;
LLM2_LIST_ITEM * item;
UINT32 last_list_pnt;
UINT32 cur_list_pnt;
UINT32 cur_list_key;
/* Start at beginning:*/
cur_list_pnt = lh->head_pointer;
item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
cur_list_key = item->key;
last_list_pnt = 0xFFFFFFFF;
/* Start search from cur_list_pnt and cur_list_num.*/
while( fConditionFlag == TRUE )
{
ulPassCount++;
if (cur_list_key == item_key) /* Item number found.*/
{
if (last_list_pnt == 0xFFFFFFFF) /* First item in the list.*/
{
lh->head_pointer = item->forward_link;
*remove_status_pnt = OCTAPI_LLM2_REMOVE_FIRST_NODE;
}
else if ( item->forward_link == 0xFFFFFFFF) /* Last item of the list.*/
{
last_item->forward_link = 0xFFFFFFFF;
lh->tail_pointer = last_list_pnt;
*remove_status_pnt = OCTAPI_LLM2_REMOVE_LAST_NODE;
}
else
{
last_item->forward_link = item->forward_link;
if ( ulPassCount == ( lh->list_length - 1 ) )
*remove_status_pnt = OCTAPI_LLM2_REMOVE_BEFORE_LAST_NODE;
else
*remove_status_pnt = OCTAPI_LLM2_REMOVE_LIST_NODE;
}
freed_item_pnt = cur_list_pnt;
freed_item = item;
fConditionFlag = FALSE;
break;
}
else if (item->forward_link == 0xFFFFFFFF) /* End of list found?!?*/
{
return(OCTAPI_LLM2_INTERNAL_ERROR0);
}
else /* Item was not found, but continue searching.*/
{
last_last_item = last_item;
last_item = item;
last_list_pnt = cur_list_pnt;
cur_list_pnt = item->forward_link;
}
item = (LLM2_LIST_ITEM *)((BYTE *)ls->li + ls->item_size * cur_list_pnt);
cur_list_key = item->key;
}
/* Return the key of the node before the node removed if possible.*/
if ( last_list_pnt == 0xFFFFFFFF )
*prev_item_key_pnt = 0xFFFFFFFF;
else if ( last_item != NULL )
*prev_item_key_pnt = last_item->key;
/* Return the key of the node before before the node removed if possible.*/
if ( last_last_item == NULL )
*prev_prev_item_key_pnt = 0xFFFFFFFF;
else
*prev_prev_item_key_pnt = last_last_item->key;
}
/* Decrease the list length.*/
lh->list_length--;
ls->assigned_items--;
/* Return free block to free block list:*/
freed_item->forward_link = ls->next_empty_item;
ls->next_empty_item = freed_item_pnt;
return(GENERIC_OK);
}
#endif
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\
| API UTILITIES
|
| Function: OctApiLlmMemCpy.
|
| Description: This function copies data from a source to a destination.
|
| -----------------------------------------------------------------------
| | Variable | Type | Description
| -----------------------------------------------------------------------
| *f_pvDestination VOID The destination where to copy the data.
| *f_pvSource VOID The source where to copy the data from.
| f_ulSize UINT32 The number of bytes to copy.
|
\*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#if !SKIP_OctApiLlmMemCpy
VOID * OctApiLlmMemCpy( VOID *f_pvDestination, const VOID * f_pvSource, UINT32 f_ulSize )
{
CHAR * pbyDst;
const CHAR * pbySrc;
UINT32 * f_pulAlignedDst;
const UINT32 * f_pulAlignedSrc;
pbyDst = (CHAR *)f_pvDestination;
pbySrc = (const CHAR *)f_pvSource;
/*
* If the size is small, or either SRC or DST is unaligned,
* then punt into the byte copy loop. This should be rare.
*/
if ( ( f_ulSize < sizeof(UINT32) )
|| ( ( (unsigned long)( pbySrc ) & ( sizeof(UINT32) - 1 ) ) | ( (unsigned long)( pbyDst ) & ( sizeof(UINT32) - 1 ) ) ) )
{
while ( f_ulSize-- )
*pbyDst++ = *pbySrc++;
return f_pvDestination;
}
f_pulAlignedDst = (UINT32 *)pbyDst;
f_pulAlignedSrc = (const UINT32 *)pbySrc;
/* Copy 4X long words at a time if possible. */
while ( f_ulSize >= 4 * sizeof(UINT32) )
{
*f_pulAlignedDst++ = *f_pulAlignedSrc++;
*f_pulAlignedDst++ = *f_pulAlignedSrc++;
*f_pulAlignedDst++ = *f_pulAlignedSrc++;
*f_pulAlignedDst++ = *f_pulAlignedSrc++;
f_ulSize -= 4 * sizeof(UINT32);
}
/* Copy one long word at a time if possible. */
while ( f_ulSize >= sizeof(UINT32) )
{
*f_pulAlignedDst++ = *f_pulAlignedSrc++;
f_ulSize -= sizeof(UINT32);
}
/* Pick up any residual with a byte copier. */
pbyDst = (CHAR *)f_pulAlignedDst;
pbySrc = (const CHAR *)f_pulAlignedSrc;
while ( f_ulSize-- )
*pbyDst++ = *pbySrc++;
return f_pvDestination;
}
#endif
/**************************************** llm_list section **********************************************/
Reference in New Issue View Git Blame Copy Permalink