FreeCalypso > hg > fc-tourmaline

view src/gpf/ccd/asn1_integ_ext.c @ 223:740a8e8fc9d7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
startup sync logic rework for the new PWON button boot scheme Previously we added logic to the MMI task to hold off PEI init until R2D is running, and then extended that condition to wait for FCHG init too. However, the dependencies of MMI upon R2D and FCHG don't start until mmiInit(), and that call is driven by Switch_ON() code, hence the wait for R2D and FCHG init can be made in that code path instead of the MMI task. Furthermore, with our new way of signaling PWON button boot to MMI, we need a new wait to ensure that the MMI task is up - previously this assurance was provided by the wait for Kp pointers to be set. Solution: revert our previous PEI init hold-off additions to MMI, add a new flag indicating MMI task init done, and put the combined wait for all needed conditions into our new PWON button boot code in power.c.
author Mychaela Falconia <falcon@freecalypso.org>
date Tue, 27 Apr 2021 06:24:52 +0000
parents 4e78acac3d88
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  Project :  
|  Modul   : asn1_integ_ext.c
+----------------------------------------------------------------------------- 
|  Copyright 2002 Texas Instruments Berlin, AG 
|                 All rights reserved. 
| 
|                 This file is confidential and a trade secret of Texas 
|                 Instruments Berlin, AG 
|                 The receipt of or possession of this file does not convey 
|                 any rights to reproduce or disclose its contents or to 
|                 manufacture, use, or sell anything it may describe, in 
|                 whole, or in part, without the specific written consent of 
|                 Texas Instruments Berlin, AG. 
+----------------------------------------------------------------------------- 
|  Purpose :  Encoding and decoding functions for ASN1_INTEGER_EXTENSIBLE type
+----------------------------------------------------------------------------- 
*/ 

/*
 * Standard definitions like UCHAR, ERROR etc.
 */
#include "typedefs.h"
#include "header.h"

/*
 * Prototypes of ccd (USE_DRIVER EQ undef) for prototypes only
 * look at ccdapi.h
 */
#undef USE_DRIVER
#include "ccdapi.h"

/*
 * Types and functions for bit access and manipulation
 */
#include "ccd_globs.h"
#include "bitfun.h"

/*
 * Prototypes and constants in the common part of ccd
 */
#include "ccd.h"

/*
 * Declaration of coder/decoder tables
 */
#include "ccdtable.h"
#include "ccddata.h"

#ifndef RUN_INT_RAM
/*
+------------------------------------------------------------------------+
| PROJECT : CCD (6144)              MODULE  : asn1_integ_ext             |
| STATE   : code                    ROUTINE : cdc_asn1_integ_ext_decode  |
+------------------------------------------------------------------------+

  PURPOSE : Decode UNALIGNED PER extensible ENUMERATED and INTEGER type 
            PER-visible constraints restrict the integer value to be a
            constrained whole number. This gives a lower and an upper 
            bound for the integer. The lb is also called offset. The 
            encoded value is the difference between the actual and the
            offset value.
            A possible and meant default value is never encoded.

            If the value is in the extension root, it will be encoded as
            a normally small non-negative whole number. Otherwise it will 
            be encoded in the smalles number of bits needed to express
            every enumeration.
*/
SHORT cdc_asn1_integ_ext_decode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
{
  ULONG   repeat=1, max_rep=1, var_ref, val_ref;
  BOOL    DefaultFound= FALSE;
  S32     IfnotPresent;
  UBYTE   *value, *old_pstruct = NULL;

  var_ref = (ULONG) melem[e_ref].elemRef;

#ifdef DEBUG_CCD
	#ifndef CCD_SYMBOLS
  TRACE_CCD (globs, "cdc_asn1_integ_ext_decode()");
	#else
	TRACE_CCD (globs, "cdc_asn1_integ_ext_decode() %s", ccddata_get_alias((USHORT) e_ref, 1));
	#endif
#endif

  /* 
   * For integer with only one possible value in the extension root:
   * If the extensinon bit is 0, the encoded value is in the extension root.
   * In this case no arrays are expected.
   * For other types:
   * The extension bit and the value will be read in the while-loop below.
   */
  if (mvar[var_ref].bSize EQ 0)
  {
    if (bf_readBit (globs) EQ FALSE)
    {
      Read_unique_Integer (e_ref, globs);
      return 1;
    }
    else
    {
      bf_incBitpos (-1, globs);
    }
  }

  val_ref = (ULONG) mvar[var_ref].valueDefs;
  /* 
   * Set pstrcutOffs and max_rep. Check the valid flag in case of optional elements.
   */
  if (PER_CommonBegin (e_ref, &max_rep, globs) NEQ ccdOK)
    return 1;

#ifdef DYNAMIC_ARRAYS
  /*
   * Allocate memory if this is a pointer type (dynamic array)
   */
  if ( is_pointer_type(e_ref) ) {
    old_pstruct = globs->pstruct;
    if ( PER_allocmem_and_update(e_ref, max_rep, globs) NEQ ccdOK)
      /* No memory - Return.  Error already set in function call above. */
      return 1;
  }
#endif

  /* 
   * Check if there is a default value for the element. 
   * If yes, just set it aside for a later comparision.  
   */
  if (mval[val_ref+1].isDefault EQ 2)
  {
    IfnotPresent = mval[val_ref+1].startValue;
    DefaultFound = TRUE;
  }

  /*
   * Decode all elements of the array.
   */
  while ( repeat <= max_rep)
  {

    value = globs->pstruct + globs->pstructOffs;

    /* 
     * There is a default value for this integer elment. 
     * While decoding of the ASN1-SEQUENCE contiaing this integer
     * we have used a particular byte of C-structure to signalize 
     * the decoding of a default value (byte set to 0).
     */
    if (DefaultFound AND !globs->pstruct[melem[e_ref].structOffs])
    {
      switch (mvar[var_ref].cType)
      {
        case 'B':
                  *(U8*)  value = (U8)   IfnotPresent;
                  break;
        case 'C':
                  *(S8*)  value = (S8)   IfnotPresent;
                  break;
        case 'S':
                  *(U16*) value = (U16)  IfnotPresent;
                  break;
        case 'T':
                  *(S16*) value = (S16)  IfnotPresent;
                  break;
        case 'L':
                  *(U32*) value = (U32)  IfnotPresent;
                  break;
        case 'M':
                  *(S32*) value = (S32)  IfnotPresent;
                  break;
        default:
                  ccd_recordFault (globs,ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref, value);
                  break;
      }
    }
    /* 
     * There is no default value defined for this integer elment.
     * Read the value from the bit buffer.
     */
    else
    {
      U32 ub, lb;
      ULONG readBits;
      U32 DecodedValue;

      lb = mval[val_ref].startValue;
      ub = mval[val_ref].endValue;
      /*
       * Read first the extensinon bit.
       * Then the non-negative value from the air message.
       */
      if (bf_readBit (globs) EQ FALSE)
      { 
        readBits = bf_getBits (mvar[var_ref].bSize, globs);
      }
      /* Value out of the extension root. */ 
      else
      {
      	U16 calcRef = calcidx[melem[e_ref].calcIdxRef].condCalcRef;
        /*
         * Get max value of integer within the extension root.
         */
        if (calcRef EQ NO_REF 
            OR 
            calc[calcRef].operation NEQ 'P')
        {
          ccd_recordFault (globs, ERR_DEFECT_CCDDATA, BREAK, (USHORT)   
                           e_ref, globs->pstruct+globs->pstructOffs);
        }
        else
        {
          lb = calc[calcRef].operand;
        }
        readBits = Read_NormallySmallNonNegativeWholeNr (globs);
      }      


      if (readBits <= (U32)(ub - lb))
      {
        DecodedValue = lb + readBits;
        /* 
         * Add the offset to the read value to get the actual one.
         */
        switch (mvar[var_ref].cType)
        {
          case 'B':
                    *(U8*)  value = (U8) DecodedValue;
                    break;
          case 'C':
                    *(S8*)  value = (S8) DecodedValue;
                    break;
          case 'S':
                    *(U16*) value = (U16) DecodedValue;
                    break;
          case 'T':
                    *(S16*) value = (S16) DecodedValue;
                    break;
          case 'L':
                    *(U32*) value = (U32) DecodedValue;
                    break;
          case 'M':
                    *(S32*) value = (S32) DecodedValue;
                    break;
          default:
                    ccd_recordFault (globs,ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref, value);
                    break;
        } 
      }
      else
      {
#ifdef DEBUG_CCD
        TRACE_CCD (globs, "integer out of range! %ld require: %ld .. %ld ", DecodedValue, lb, ub);
#endif
        if (melem[e_ref].optional)
          ccd_recordFault (globs, ERR_ASN1_OPT_IE, CONTINUE, (USHORT) e_ref, value);
        else
          ccd_recordFault (globs, ERR_ASN1_MAND_IE, CONTINUE, (USHORT) e_ref, value);
      }
    }
    repeat ++;
    globs->pstructOffs += mvar[var_ref].cSize; 
  }/*while*/

#ifdef DYNAMIC_ARRAYS
  if (old_pstruct NEQ NULL)
    globs->pstruct = old_pstruct;
#endif

  return 1;
}
#endif /* !RUN_INT_RAM */

#ifndef RUN_INT_RAM
/*
+------------------------------------------------------------------------+
| PROJECT : CCD (6144)              MODULE  : asn1_integ_ext             |
| STATE   : code                    ROUTINE : cdc_asn1_integ_ext_encode  |
+------------------------------------------------------------------------+

  PURPOSE : UNALIGNED PER extensible ENUMERATED and INTEGER type 
            PER-visible constraints restrict the integer value to be a
            constrained whole number. This gives a lower and an upper 
            bound for the integer. The lb is also called offset. The 
            encoded value is the difference between the actual and the
            offset value.
            A possible and meant default value is never encoded.

            If the value is in the extension root, it will be encoded as
            a normally small non-negative whole number. Otherwise it will 
            be encoded in the smalles number of bits needed to express
            every enumeration.

			       -----------------------------------------------
			      | extension  | value encoded as a normally      |
			      | bit = 1    | non-negtive integer whole number |
			       -----------------------------------------------

			       -----------------------------------------------
			      | extension  | value encoded in the bit size    |
			      | bit = 0    | needed to express ub - lb        |
			       -----------------------------------------------
*/
SHORT cdc_asn1_integ_ext_encode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
{
  ULONG   repeat=1, max_rep=1, var_ref, val_ref;
  BOOL    DefaultFound= FALSE;
  S32     IfnotPresent;
  U8     *base_pstruct;

#ifdef DEBUG_CCD
	#ifndef CCD_SYMBOLS
  TRACE_CCD (globs, "cdc_asn1_integ_ext_encode()");
	#else
	TRACE_CCD (globs, "cdc_asn1_integ_ext_encode() %s", ccddata_get_alias((USHORT) e_ref, 1));
	#endif
#endif

  var_ref = (ULONG) melem[e_ref].elemRef;
  val_ref = (ULONG) mvar[var_ref].valueDefs;

  /* 
   * Set pstrcutOffs and max_rep. Check the valid flag in case of optional elements.
   */
  if (PER_CommonBegin (e_ref, &max_rep, globs) NEQ ccdOK)
    return 1;
  /* 
   * Check if there is a default value for the element. 
   * If yes, just set it aside for a later comparision.  
   */
  if (mval[val_ref+1].isDefault EQ 2)
  {
    IfnotPresent = mval[val_ref+1].startValue;
    DefaultFound = TRUE;
  }

#ifdef DYNAMIC_ARRAYS
  if ( is_pointer_type(e_ref) )
  {
    base_pstruct = *(U8 **)(globs->pstruct + globs->pstructOffs);
    if (ccd_check_pointer(base_pstruct) == ccdOK)
    {
      globs->pstructOffs = 0;
    }
    else
    {
      ccd_recordFault (globs, ERR_INVALID_PTR, BREAK, (USHORT) e_ref, 
                       &globs->pstruct[globs->pstructOffs]);
      return 1;
    }
  }
  else
#endif
    base_pstruct = globs->pstruct;

  /*
   * Encode all elements of the array.
   */
  while ( repeat <= max_rep)
  {
    S32     ub, lb, value;
    U32     extension_lb;
    UBYTE   *p;
    U16     calcRef = calcidx[melem[e_ref].calcIdxRef].condCalcRef;
    /*
     * Get offset value of integer in the extension addition.
     */
    if (calcRef EQ NO_REF 
        OR 
        calc[calcRef].operation NEQ 'P')
    {
      ccd_recordFault (globs, ERR_DEFECT_CCDDATA, BREAK,(USHORT) e_ref,
                       globs->pstruct+globs->pstructOffs);
      return 1;
    }
    else
    {
      extension_lb = calc[calcRef].operand;
    }
    /*
     * setup the read pointer to the element in the C-structure
     */
    p = base_pstruct + globs->pstructOffs;

    switch (mvar[var_ref].cType)
    {
    case 'B':
      value = (S32)*(UBYTE *) p;
      break;
    case 'C':
      value = (S32)*(S8 *) p;
      break;
    case 'S':
      value = (S32)*(USHORT *) p;
      break;
    case 'T':
      value = (S32)*(S16 *) p;
      break;
    case 'L':
      /* 
       * This type casting can be critical.
       * Thus the case of bSize=32 will be handled separately.
       */
      if (mvar[var_ref].bSize < 32)
      {
        value = (S32)*(U32 *) p;
      }
      break;
    case 'M':
      value = *(S32 *) p;
      break;
    default:
      ccd_recordFault (globs,ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref, p);
      return 1;
    }

    if (mvar[var_ref].cType EQ 'L' AND  
           (mvar[var_ref].bSize EQ 32))
    {
      U32 CriticalValue;
      CriticalValue = *(U32 *) p;
      if (CriticalValue >= extension_lb)
      {
        bf_writeBit (1, globs);
        if (!DefaultFound OR (U32)IfnotPresent NEQ CriticalValue)
          Write_NormallySmallNonNegativeWholeNr (CriticalValue - extension_lb, globs);
      }
      else
      {
        bf_writeBit (0, globs);          
        if (!DefaultFound OR (U32)IfnotPresent NEQ CriticalValue)
        {
          U32 lb, ub;
          lb = (U32) mval[val_ref].startValue;
          ub = (U32) mval[val_ref].endValue;
          if (lb <= CriticalValue && CriticalValue <= ub)
          {
            bf_writeVal (CriticalValue - lb, mvar[var_ref].bSize, globs);
          }
         else
          {
#ifdef DEBUG_CCD
            TRACE_CCD (globs, "integer out of range! %ld require: %ld .. %ld ",
                               value, lb, ub);
#endif
            ccd_recordFault (globs, ERR_INT_VALUE, CONTINUE, (USHORT) e_ref, p);
          }
        }
      }
    }
    else 
    {
      /* 
       * Encode only non-default values.
       */
      if (!DefaultFound OR IfnotPresent NEQ value)
      {
        /* 
         * Set the extension bit to 0 if the value belongs to the extension root.
         * Otherwise set it to 1.
         * A non-negative-binary-integer will be encoded since the offset must
         * be subtracted from the value read from the C-structure.
         */
        lb = mval[val_ref].startValue;
        ub = mval[val_ref].endValue;

        if (value >= (S32)extension_lb AND value <= ub)
        {
          bf_writeBit (1, globs);
          Write_NormallySmallNonNegativeWholeNr ((U32)value - extension_lb, globs);
        }
        else if (lb <= value AND value <= ub)
        {
          bf_writeBit (0, globs);
          /* 
           * Do not encode single valued extension roots.
           */
          if (mvar[var_ref].bSize NEQ 0) 
            bf_writeVal ((ULONG)(value-lb), mvar[var_ref].bSize, globs);
        }
        else
        {
#ifdef DEBUG_CCD
          TRACE_CCD (globs, "integer out of range! %ld require: %ld .. %ld ", value, lb, ub);
#endif
          ccd_recordFault (globs, ERR_INT_VALUE, CONTINUE, (USHORT) e_ref, p);
        }
      }
    } /* value not critical*/
    repeat ++; 
    globs->pstructOffs += mvar[var_ref].cSize;
  }/* while-loop */

  return 1;
}
#endif /* !RUN_INT_RAM */