view src/nucleus/dmce.c @ 287:3dee79757ae4

UI fw: load handheld audio mode on boot We have now reached the point where use of audio mode config files should be considered mandatory. In ACI usage we can tell users that they need to perform an AT@AUL of some appropriate audio mode, but in UI-enabled fw we really need to have the firmware load audio modes on its own, so that correct audio config gets established when the handset or development board runs on its own, without a connected host computer. Once have FC Venus with both main and headset audio channels and headset plug insertion detection, our fw will need to automatically load the handheld mode or the headset mode depending on the plug insertion state. For now we load only the handheld mode, which has been tuned for FC-HDS4 on FC Luna.
author Mychaela Falconia <falcon@freecalypso.org>
date Sat, 13 Nov 2021 03:20:57 +0000
parents 4e78acac3d88
children
line wrap: on
line source

/*************************************************************************/
/*                                                                       */
/*               Copyright Mentor Graphics Corporation 2002              */
/*                         All Rights Reserved.                          */
/*                                                                       */
/* THIS WORK CONTAINS TRADE SECRET AND PROPRIETARY INFORMATION WHICH IS  */
/* THE PROPERTY OF MENTOR GRAPHICS CORPORATION OR ITS LICENSORS AND IS   */
/* SUBJECT TO LICENSE TERMS.                                             */
/*                                                                       */
/*************************************************************************/

/*************************************************************************/
/*                                                                       */
/* FILE NAME                                               VERSION       */
/*                                                                       */
/*      dmce.c                                         Nucleus PLUS 1.14 */
/*                                                                       */
/* COMPONENT                                                             */
/*                                                                       */
/*      DM - Dynamic Memory Management                                   */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      This file contains the error checking routines for the functions */
/*      in the dynamic memory management component.  This permits easy   */
/*      removal of the error checking logic when it is not needed.       */
/*                                                                       */
/* DATA STRUCTURES                                                       */
/*                                                                       */
/*      None                                                             */
/*                                                                       */
/* FUNCTIONS                                                             */
/*                                                                       */
/*      DMCE_Create_Memory_Pool             Create a dynamic memory pool */
/*      DMCE_Delete_Memory_Pool             Delete a dynamic memory pool */
/*      DMCE_Allocate_Memory                Allocate a memory block from */
/*                                            a dynamic memory pool      */
/*      DMCE_Deallocate_Memory              Deallocate a memory block    */
/*                                            from a dynamic memory pool */
/*                                                                       */
/* DEPENDENCIES                                                          */
/*                                                                       */
/*      cs_extr.h                           Common Service functions     */
/*      tc_extr.h                           Thread Control functions     */
/*      dm_extr.h                           Partition functions          */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*         DATE                    REMARKS                               */
/*                                                                       */
/*      03-01-1993      Created initial version 1.0                      */
/*      04-19-1993      Verified version 1.0                             */
/*      11-01-1993      Corrected call of actual                         */
/*                        function to delete a memory                    */
/*                        pool, resulting in version 1.0a                */
/*      11-01-1993      Verfied version 1.0a                             */
/*      03-01-1994      Changed name original error                      */
/*                        checking file and changed                      */
/*                        function interfaces, resulting                 */
/*                        in version 1.1                                 */
/*                                                                       */
/*      03-18-1994      Verified version 1.1                             */
/*      04-17-1996      updated to version 1.2                           */
/*      03-24-1998      Released version 1.3.                            */
/*      04-17-2002      Released version 1.13m                           */
/*      11-07-2002      Released version 1.14                            */
/*************************************************************************/
#define         NU_SOURCE_FILE


#include        "cs_extr.h"                 /* Common service functions  */
#include        "tc_extr.h"                 /* Thread control functions  */
#include        "dm_extr.h"                 /* Dynamic memory functions  */


/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      DMCE_Create_Memory_Pool                                          */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      This function performs error checking on the parameters supplied */
/*      to the create dynamic memory pool function.                      */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      DMC_Create_Memory_Pool              Actual create dynamic memory */
/*                                            pool function              */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      pool_ptr                            Memory pool control block    */
/*                                            pointer                    */
/*      name                                Memory pool name             */
/*      start_address                       Starting address of the pool */
/*      pool_size                           Number of bytes in the pool  */
/*      min_allocation                      Minimum allocation size      */
/*      suspend_type                        Suspension type              */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      NU_INVALID_POOL                     Indicates the pool control   */
/*                                            block pointer is invalid   */
/*      NU_INVALID_MEMORY                   Indicates the starting       */
/*                                            memory address is NULL     */
/*      NU_INVALID_SIZE                     Indicates that either the    */
/*                                            pool size and/or the       */
/*                                            minimum allocation size is */
/*                                            invalid                    */
/*      NU_INVALID_SUSPEND                  Indicate the suspension type */
/*                                            is invalid                 */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*         DATE                    REMARKS                               */
/*                                                                       */
/*      03-01-1993      Created initial version 1.0                      */
/*      04-19-1993      Verified version 1.0                             */
/*      03-01-1994      Modified function interface,                     */
/*                        resulting in version 1.1                       */
/*                                                                       */
/*      03-18-1994      Verified version 1.1                             */
/*                                                                       */
/*************************************************************************/
STATUS  DMCE_Create_Memory_Pool(NU_MEMORY_POOL *pool_ptr, CHAR *name, 
                        VOID *start_address, UNSIGNED pool_size, 
                        UNSIGNED min_allocation, OPTION suspend_type)
{

DM_PCB         *pool;                       /* Pool control block ptr    */
STATUS          status;                     /* Completion status         */
UNSIGNED        adjusted_min;               /* Adjusted size of minimum  */
UNSIGNED        adjusted_pool;              /* Adjusted size of pool     */


    /* Move input pool pointer into internal pointer.  */
    pool =  (DM_PCB *) pool_ptr;

    /* Adjust the minimum allocation size to something that is evenly 
       divisible by the number of bytes in an UNSIGNED data type.  */
    adjusted_min = ((min_allocation + sizeof(UNSIGNED) - 1)/sizeof(UNSIGNED)) *
                                                        sizeof(UNSIGNED);

    /* Adjust the pool size to something that is evenly divisible by the 
       number of bytes in an UNSIGNED data type.  */
    adjusted_pool = ((pool_size + sizeof(UNSIGNED) - 1)/sizeof(UNSIGNED)) *
                                                        sizeof(UNSIGNED);

    /* Check for a NULL dynamic memory pool control block pointer or a control
       block that is already created.  */
    if ((pool == NU_NULL) || (pool -> dm_id == DM_DYNAMIC_ID))
    
        /* Invalid dynamic memory pool control block pointer.  */
        status =  NU_INVALID_POOL;
        
    else if (start_address == NU_NULL)
    
        /* Invalid memory pointer.  */
        status =  NU_INVALID_MEMORY;
        
    else if ((adjusted_min == 0) || 
                ((adjusted_min + (2 * DM_OVERHEAD)) > adjusted_pool))
    
        /* Pool could not even accommodate one allocation.  */
        status =  NU_INVALID_SIZE;
        
    else if ((suspend_type != NU_FIFO) && (suspend_type != NU_PRIORITY))
    
        /* Invalid suspension type.  */
        status =  NU_INVALID_SUSPEND;
        
    else
    
        /* Call the actual service to create the dynamic memory pool.  */
        status =  DMC_Create_Memory_Pool(pool_ptr, name, start_address, 
                                    pool_size, min_allocation, suspend_type);
        
    /* Return completion status.  */
    return(status);
}


/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      DMCE_Delete_Memory_Pool                                          */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      This function performs error checking on the parameters supplied */
/*      to the delete dynamic memory pool function.                      */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      DMC_Delete_Memory_Pool              Actual function to delete a  */
/*                                            dynamic memory pool        */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      pool_ptr                            Memory pool control block    */
/*                                            pointer                    */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      NU_INVALID_POOL                     Indicates the pool pointer   */
/*                                            is invalid                 */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*         DATE                    REMARKS                               */
/*                                                                       */
/*      03-01-1993      Created initial version 1.0                      */
/*      04-19-1993      Verified version 1.0                             */
/*      11-01-1993      Corrected call of actual                         */
/*                        function to delete a memory                    */
/*                        pool, resulting in version 1.0a                */
/*      11-01-1993      Verfied version 1.0a                             */
/*      03-01-1994      Modified function interface,                     */
/*                        resulting in version 1.1                       */
/*                                                                       */
/*      03-18-1994      Verified version 1.1                             */
/*                                                                       */
/*************************************************************************/
STATUS  DMCE_Delete_Memory_Pool(NU_MEMORY_POOL *pool_ptr)
{

DM_PCB         *pool;                       /* Pool control block ptr    */
STATUS          status;                     /* Completion status         */

    
    /* Move input pool pointer into internal pointer.  */
    pool =  (DM_PCB *) pool_ptr;

    /* Determine if the dynamic memory pool pointer is valid.  */
    if ((pool) && (pool -> dm_id == DM_DYNAMIC_ID))
    
        /* Dynamic memory pool pointer is valid, call the function to 
           delete it.  */
        status =  DMC_Delete_Memory_Pool(pool_ptr);
        
    else
    
        /* Dynamic memory pool pointer is invalid, indicate in 
           completion status. */
        status =  NU_INVALID_POOL;
        
    /* Return completion status.  */
    return(status);
}


/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      DMCE_Allocate_Memory                                             */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      This function performs error checking on the parameters supplied */
/*      to the allocate memory function.                                 */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      DMC_Allocate_Memory                 Actual memory allocation     */
/*                                            function                   */
/*      TCCE_Suspend_Error                  Check for suspension error   */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      pool_ptr                            Memory pool pointer          */
/*      return_pointer                      Pointer to the destination   */
/*                                            memory pointer             */
/*      size                                Number of bytes requested    */
/*      suspend                             Suspension option if full    */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      NU_INVALID_POOL                     Indicates the supplied pool  */
/*                                            pointer is invalid         */
/*      NU_INVALID_POINTER                  Indicates the return pointer */
/*                                            is NULL                    */
/*      NU_INVALID_SIZE                     Indicates the size is 0 or   */
/*                                            larger than the pool       */
/*      NU_INVALID_SUSPEND                  Invalid suspension requested */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*         DATE                    REMARKS                               */
/*                                                                       */
/*      03-01-1993      Created initial version 1.0                      */
/*      04-19-1993      Verified version 1.0                             */
/*      03-01-1994      Modified function interface                ,     */
/*                        resulting in version 1.1                       */
/*                                                                       */
/*      03-18-1994      Verified version 1.1                             */
/*                                                                       */
/*************************************************************************/
STATUS  DMCE_Allocate_Memory(NU_MEMORY_POOL *pool_ptr, VOID **return_pointer,
                                        UNSIGNED size, UNSIGNED suspend)
{

DM_PCB         *pool;                       /* Pool control block ptr    */
STATUS          status;                     /* Completion status         */


    /* Move input pool pointer into internal pointer.  */
    pool =  (DM_PCB *) pool_ptr;

    /* Determine if dynamic memory pool pointer is invalid.  */
    if (pool == NU_NULL)
    
        /* Dynamic memory pool pointer is invalid, indicate in 
           completion status. */
        status =  NU_INVALID_POOL;

    else if (pool -> dm_id != DM_DYNAMIC_ID)
    
        /* Dynamic memory pool pointer is invalid, indicate in 
           completion status. */
        status =  NU_INVALID_POOL;

    else if (return_pointer == NU_NULL)

        /* Return pointer is invalid.  */
        status =  NU_INVALID_POINTER;
        
    else if ((size == 0) || 
        (size > (pool -> dm_pool_size - (2 * DM_OVERHEAD))))
        
        /* Return the invalid size error.  */
        status =  NU_INVALID_SIZE;

    else if ((suspend) && (TCCE_Suspend_Error()))
    
        /* Suspension from an non-task thread.  */
        status =  NU_INVALID_SUSPEND;

    else 
    
        /* Parameters are valid, call actual function.  */
        status = DMC_Allocate_Memory(pool_ptr, return_pointer, size, suspend);

    /* Return the completion status.  */
    return(status);
}


/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      DMCE_Deallocate_Memory                                           */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      This function performs error checking on the parameters supplied */
/*      to the deallocate memory function.                               */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      DMC_Deallocate_Memory               Actual deallocate memory     */
/*                                            function                   */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      memory                              Pointer to dynamic memory    */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      NU_INVALID_POINTER                  Indicates the supplied       */
/*                                            pointer is invalid         */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*         DATE                    REMARKS                               */
/*                                                                       */
/*      03-01-1993      Created initial version 1.0                      */
/*      04-19-1993      Verified version 1.0                             */
/*      03-01-1994      Modified function interface,                     */
/*                        resulting in version 1.1                       */
/*                                                                       */
/*      03-18-1994      Verified version 1.1                             */
/*                                                                       */
/*************************************************************************/
STATUS  DMCE_Deallocate_Memory(VOID *memory)
{

DM_PCB         *pool;                       /* Pool pointer              */
DM_HEADER      *header_ptr;                 /* Pointer to memory block   */
STATUS          status;                     /* Completion status         */


    /* Pickup the associated pool's pointer.  It is inside the header of
       each memory block.  */
    header_ptr =  (DM_HEADER *) (((BYTE_PTR) memory) - DM_OVERHEAD);
        
    /* Determine if the pointer(s) are NULL.  */
    if ((header_ptr == NU_NULL) || (memory == NU_NULL))
    
        /* Dynamic memory pointer is invalid.  */
        status =  NU_INVALID_POINTER;

    /* Determine if dynamic memory pool pointer is invalid.  */
    else if ((pool =  header_ptr -> dm_memory_pool) == NU_NULL)
    
        /* Dynamic memory pointer is invalid, indicate in completion 
           status.  */
        status =  NU_INVALID_POINTER;

    else if (pool -> dm_id != DM_DYNAMIC_ID)
    
        /* Dynamic memory pool pointer is invalid, indicate in completion 
           status. */
        status =  NU_INVALID_POINTER;
        
    else if (header_ptr -> dm_memory_free)
    
        /* Dynamic memory is free - must not be allocated.  */
        status =  NU_INVALID_POINTER;

    else 
    
        /* Parameters are valid, call actual function.  */
        status =  DMC_Deallocate_Memory(memory);

    /* Return the completion status.  */
    return(status);
}