--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gpf/ccd/csn1_sx.c	Fri Oct 16 06:23:26 2020 +0000
@@ -0,0 +1,687 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project : CCD
+|  Modul   : csn1_sx.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 :  Definition of encoding and decoding functions for CSN1_S0 elements
++----------------------------------------------------------------------------- 
+*/
+/*
+ * standard definitions like GLOBAL, 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 of ccd internal functions
+ */
+#include "ccd.h"
+
+/*
+ * Declaration of coder/decoder tables
+ */
+#include "ccdtable.h"
+#include "ccddata.h"
+
+/*
+ * Need memory allocation functions for dynamic arrays (pointers)
+ */
+#ifdef DYNAMIC_ARRAYS
+#include "vsi.h"
+#include <string.h>
+#endif
+
+
+#ifndef RUN_FLASH
+/*
++--------------------------------------------------------------------+
+| PROJECT : CCD (6144)               MODULE  : CCD                   |
+| STATE   : code                     ROUTINE : cdc_csn1_sx_decode    |
++--------------------------------------------------------------------+
+
+  PURPOSE : The encoded IE consists of one bit for presence flag and 
+            a value part. 
+            In case of CSN1_S1 only if the flag bit is equal 1 the  
+            value part will follow it.
+            In case of CSN1_S0 only if the flag bit is equal 0 the 
+            value part will follow it.
+*/
+
+SHORT cdc_csn1_sx_decode (int flag, const ULONG e_ref, T_CCD_Globs *globs)
+{
+  ULONG  repeat, max_rep, act_offset;
+  ULONG  amount = 1;
+  BOOL   is_variable;
+  ULONG  cix_ref, num_prolog_steps, prolog_step_ref;
+#ifdef DYNAMIC_ARRAYS
+  U8     *old_pstruct = NULL;
+  U8     *addr = NULL;
+#endif
+
+#ifdef DEBUG_CCD
+  #ifndef CCD_SYMBOLS
+  TRACE_CCD (globs, "cdc_csn1_sx_decode()");
+	#else
+	TRACE_CCD (globs, "cdc_csn1_sx_decode() %s", ccddata_get_alias((USHORT) e_ref, 1));
+	#endif
+#endif
+
+  globs->SeekTLVExt = FALSE;
+  
+  cix_ref = melem[e_ref].calcIdxRef;
+  num_prolog_steps = calcidx[cix_ref].numPrologSteps;
+  prolog_step_ref  = calcidx[cix_ref].prologStepRef;
+
+  /*
+   * If this element is conditional, check the condition.
+   */
+  if (calcidx[cix_ref].numCondCalcs NEQ 0
+  AND ! ccd_conditionOK (e_ref, globs))
+    return 1;
+
+  /*
+   * If this element has a defined prologue
+   * we have to process it before decoding the bitstream.
+   */
+  if (num_prolog_steps)
+  {
+    ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
+  }
+  
+  if (melem[e_ref].repType NEQ ' ')
+  {
+    is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs);
+    /* Structured IE is to be handeled as bitstring.*/
+    if (melem[e_ref].repType == 's')
+    {
+      repeat--;
+    }
+  }
+  else
+  {
+    is_variable = FALSE;
+    repeat     = 1;
+  }
+
+#ifdef DYNAMIC_ARRAYS
+  /*
+   * Check for pointer types; allocate memory if necessary.
+   * May overwrite globs->pstruct (and initialize globs->pstructOffs to 0).
+   */
+  if ( is_pointer_type(e_ref) ) 
+  {
+    U32     cSize;
+
+    /*
+     * Find size to allocate;
+     * - Read from mcomp or mvar according to type
+     */
+    cSize = (ULONG)((melem[e_ref].elemType EQ 'F' OR
+		      melem[e_ref].elemType EQ 'R')
+                     ? mvar[melem[e_ref].elemRef].cSize
+                     : mcomp[melem[e_ref].elemRef].cSize
+		     ) * repeat;
+
+    /*
+     * Allocate additional memory
+     */
+    addr = (U8 *)DP_ALLOC( cSize, globs->alloc_head, DP_NO_FRAME_GUESS);
+
+    /* If no memory, log error and return immediately */
+    if (addr EQ NULL) {
+      ccd_setError (globs, ERR_NO_MEM,
+                    BREAK,
+                    (USHORT) -1);
+      return 1;
+    }
+    else
+      memset (addr, 0, (size_t)cSize);
+
+    /*
+     * Memory allocated;
+     */
+  }
+#endif
+    
+  if (melem[e_ref].elemType NEQ 'S')
+  {
+    /*
+     * Element is not a SPARE. Setup the struct pointer.
+     */
+    globs->pstructOffs = melem[e_ref].structOffs;
+
+
+    if (is_variable)
+    {
+      UBYTE *addr_v_xxx = NULL;
+      UBYTE *addr_c_xxx;
+      UBYTE  act_continue_array;
+  
+
+      if (melem[e_ref].optional)
+      {
+        /*
+         * For optional elements we must set the valid-flag,
+         * if there is at least one element in the message.
+         * Therefore we store the address of the valid flag.
+         */
+        /* Dynamic array addition.
+         * Postpone optional flag setting for non-code transparent
+         * pointer types ('P', 'Q', 'R').
+         * For these types, the optional flag is the pointer itself.
+         * These types cannot be set yet, as the pointer may be
+         * preceeded by a counter octet, a union tag id octet etc.
+         */
+        if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R')
+        addr_v_xxx = (UBYTE *) (globs->pstruct + globs->pstructOffs++);
+      }
+      /*
+       * For variable sized elements store the min-value
+       * as counter into the C-Structure (c_xxx).
+       */
+      addr_c_xxx = (UBYTE *) (globs->pstruct + globs->pstructOffs++);
+      if (max_rep > 255)
+        globs->pstructOffs++;      
+      
+      /*
+       * Store the initial offset
+       */
+
+      act_offset = (ULONG) globs->pstructOffs;
+
+#ifdef DYNAMIC_ARRAYS
+    if ( is_pointer_type(e_ref) ) 
+    {
+      /*
+       * 1. Save old "globs->pstruct" variables
+       * 2. Store pointer to freshly allocated memory area in structure
+       * 3. Initialize pstruct to point to the freshly allocated memory area.
+       * 4. Initialize pstructOffs to 0 to start decoding at offset 0
+       *    in the new memory area.
+       */
+      old_pstruct        = globs->pstruct;
+      *(U8 **)(globs->pstruct + globs->pstructOffs) = addr;
+      globs->pstruct     = addr;
+      globs->pstructOffs = 0;
+    }
+#endif
+
+      /*
+       * repType ='i':
+       * Repeat this element (if it is an array) until we detect a 
+       * flag indicating absence.
+       *
+       * repType ='v' and 'c':
+       * Repeat the IE and leave the loop.
+       *
+       * In both cases we expect a 0 at first.
+       */
+      if ((melem[e_ref].repType == 'v') || (melem[e_ref].repType == 'c'))
+      {
+        amount = repeat;
+      }
+      repeat = 0;
+      act_continue_array = globs->continue_array;
+      globs->continue_array = TRUE;
+
+      while (globs->continue_array)
+      {
+        if (flag == 0xFF) /* CSN1_SH type*/
+        {
+          if (bf_readBit(globs) != GET_HL_PREV(1))
+            break;
+        }
+        else
+        {
+          if (bf_readBit(globs) != flag)
+            break;
+        }
+          /*
+           * Flag is set, we must decode the element
+           */
+  
+          cdc_decodeElemvalue (e_ref, &amount, globs);
+
+          if (++repeat > max_rep)
+          {
+            /*
+             * Too many repetitions means error in encoded message.
+             */
+            ccd_setError (globs, ERR_MAX_REPEAT,
+                          BREAK,
+                          (USHORT) (globs->bitpos),
+                          (USHORT) -1);
+            return 1;
+          }
+          else if (melem[e_ref].repType EQ 'v')
+          {
+            repeat = amount;
+            break;
+          }
+          /*
+           * Recalculate the struct offset for repeatable IEs.
+           */
+          if (is_variable_type(e_ref))
+          {
+            globs->pstructOffs = (USHORT)(act_offset + 
+                                 (repeat * mvar[melem[e_ref].elemRef].cSize));
+          }
+          else
+          {
+            globs->pstructOffs = (USHORT)(act_offset +
+                                 (repeat * mcomp[melem[e_ref].elemRef].cSize));
+          }
+        }
+      globs->continue_array = act_continue_array;
+              
+#ifdef DYNAMIC_ARRAYS
+      /*
+       * Restore globs->pstruct 
+       */
+      if (old_pstruct NEQ NULL)
+      {
+        globs->pstruct     = old_pstruct;
+      }
+#endif
+
+      if (addr_v_xxx NEQ NULL)
+      {
+        /*
+         * For optional elements set the valid-flag
+         * In this case the pointer addr_c_xxx does not mark
+         * the counter. It points to the valid flag.
+         */
+        if (repeat > 0)
+          *addr_v_xxx++ = (UBYTE) TRUE;
+      }
+      /*
+       * Store the number of digits into the c_xxx variable if there is one.
+       */
+      if (max_rep > 65535)
+      {
+       ULONG *addr_c_xxx_u32;
+       addr_c_xxx_u32 = (ULONG *)addr_c_xxx;
+       *addr_c_xxx_u32 = repeat;
+      }
+      else if (max_rep > 255)
+      {
+        USHORT *addr_c_xxx_u16;
+        addr_c_xxx_u16 = (USHORT *)addr_c_xxx;
+        *addr_c_xxx_u16 = (USHORT) repeat;
+      }
+      else
+        *addr_c_xxx = (UBYTE) repeat;
+    }
+    /*
+     * IE is not defined as an array.
+     */
+    else
+    {
+      BOOL  elemPresent;
+
+      if (flag == 0xFF)     
+        elemPresent = (bf_readBit(globs) EQ GET_HL_PREV(1));
+      else 
+        elemPresent = (bf_readBit(globs) == flag);
+        
+      if (elemPresent)
+      {
+        if (melem[e_ref].optional)
+        {
+          /*
+           * For optional elements set the valid-flag.
+           */
+            globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE;
+        }
+        
+        /*
+         * Flag is set, we must decode the element.
+         */
+        cdc_decodeElemvalue (e_ref, &repeat, globs);
+        /*
+         * process the epilogue expression for this element if there is any 
+         */
+        if (num_prolog_steps)
+        {
+          if (  (calc[prolog_step_ref+1].operation EQ 'K')
+             || (calc[prolog_step_ref+1].operation EQ 'C')
+             || (calc[prolog_step_ref+1].operation EQ 's'))
+          {
+            ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
+          }
+        }
+      }
+    }
+  }
+
+  return 1;
+}
+#endif /* !RUN_FLASH */
+
+#ifndef RUN_FLASH
+/*
++--------------------------------------------------------------------+
+| PROJECT : CCD (6144)              MODULE  : CDC_GSM                |
+| STATE   : code                    ROUTINE : cdc_csn1_sx_encode     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Encoding of the CSN1 element.
+            1) GSM Type CSN1 S1 element
+               This element consists of a 1 bit valid flag and a 
+               value part. If the element is valid (the v_xxx 
+               components is TRUE in the decoded message) a 1 bit will
+               be coded followed by the coding of the value part.
+               Otherwise a 0 bit will be coded.
+
+            2) GSM Type CSN1 S0 element
+               This element consists of a single bit valid flag and a 
+               value part, too. But in this case the presence flag is
+               set to 0. If the element is present (the v_xxx component
+               is TRUE in the decoded message) a 0 bit will be coded 
+               followed by the encoded value part. Otherwise a 1 bit
+               will be encoded.
+*/
+
+SHORT cdc_csn1_sx_encode (int flag, const ULONG e_ref, T_CCD_Globs *globs)
+{
+  ULONG  i, repeat=1, amount=1;
+  USHORT cSize = 0, startOffset;
+  int    elemPresent;
+  ULONG  cix_ref, num_prolog_steps, prolog_step_ref;
+#ifdef DYNAMIC_ARRAYS
+  U8     *old_pstruct = NULL;
+#endif
+
+#ifdef DEBUG_CCD
+  #ifndef CCD_SYMBOLS
+  TRACE_CCD (globs, "cdc_csn1_sx_encode()");
+	#else
+	TRACE_CCD (globs, "cdc_csn1_sx_encode() %s", ccddata_get_alias((USHORT) e_ref, 1));
+	#endif
+#endif
+
+  cix_ref = melem[e_ref].calcIdxRef;
+  num_prolog_steps = calcidx[cix_ref].numPrologSteps;
+  prolog_step_ref  = calcidx[cix_ref].prologStepRef;
+  /*
+   * If this element is conditional, check the condition.
+   */
+  if (calcidx[cix_ref].numCondCalcs NEQ 0
+  AND ! ccd_conditionOK (e_ref, globs))
+    return 1;
+
+  /*
+   * If this element has a defined prologue
+   * we have to process it before decoding the bitstream.
+   */
+  if (num_prolog_steps)
+  {
+    ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
+  }
+  
+  if (melem[e_ref].elemType NEQ 'S')
+  {
+    UBYTE act_continue_array;
+
+    act_continue_array = globs->continue_array;
+    globs->continue_array = TRUE;
+    /*
+     * Element is not a SPARE.
+     * Setup the offset into the C-structure for this element
+     */
+    globs->pstructOffs = melem[e_ref].structOffs;
+
+    if (melem[e_ref].optional)
+    {  
+      /*
+       * For optional elements check the valid-flag in the C-struct.
+       * Spare elements does not have a corresponding valid flag.
+       */
+      /* Dynamic array addition.
+       * Postpone optional flag setting for non-code transparent
+       * pointer types ('P', 'Q', 'R').
+       * For these types, the optional flag is the pointer itself.
+       * These types cannot be set yet, as the pointer may be
+       * preceeded by a counter octet, a union tag id octet etc.
+       */
+      if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R')
+      {
+        if (globs->pstruct[globs->pstructOffs++] == FALSE)
+        {
+          /*
+           * The IE should not be present in the message so we code
+           * a single bit
+           * for CSN1_S1 as 0,
+           * for CSN1_S0 as 1 and
+           * for CSN1_SH as GET_HL(0)
+           */
+          if (flag == 0xFF)
+            elemPresent = GET_HL(0);
+          else
+            elemPresent = flag ^ 0x00000001;
+          bf_writeBit (elemPresent, globs);
+          return 1;
+        }
+#ifdef DEBUG_CCD
+        else if (globs->pstruct [melem[e_ref].structOffs] != TRUE)
+        {
+          TRACE_CCD (globs, "Ambiguous value for valid flag!\n...assumed 1 for ccdID=%d",
+                     e_ref);
+        }
+#endif
+      }
+    }
+
+    /* As a default amount =1 due to initialization. */
+    if (melem[e_ref].repType EQ 'i')
+    {
+      /* The actual number of elements belonging to the array is unknown.
+       * The user should have written the desired number to the C-Structure
+       * (c_xxx). CCD reads the number of these variable repeatable elements
+       * out of this C-Structure (c_xxx) and encodes each element with a
+       * preceeding bit set to '0'. The last element is followed by a bit
+       * set to '1' to indicate the end of this array. 
+       * If the number of repeats given by the C-Structure exceeds the 
+       * allowed value (maxRepeat) CCD gives a warning!
+       */
+      if (melem[e_ref].maxRepeat > 255)
+      {
+        ULONG count = (ULONG) (* (USHORT *)(globs->pstruct + globs->pstructOffs++));
+        repeat = MINIMUM (count, (ULONG) melem[e_ref].maxRepeat);
+        if (repeat < count) 
+          ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
+                           (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+      }
+      else
+      {
+        repeat = (ULONG) MINIMUM (globs->pstruct[globs->pstructOffs], 
+                                  melem[e_ref].maxRepeat);
+        if ( repeat < (ULONG) (globs->pstruct[globs->pstructOffs]) )
+          ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
+                           (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+      }
+      amount = 1;
+      globs->pstructOffs++;
+    }
+    else
+    if (melem[e_ref].repType EQ 'v')
+    {
+      /* The number of elements belonging to the array depends on the value 
+       * of another element. The user should have written this number to the 
+       * C-Structure (c_xxx).
+       * CCD reads the number of these variable repeatable elements out of 
+       * this C-Structure (c_xxx).
+       * If the number of repetitions given by the C-Structure exceeds the
+       * allowed value (maxRepeat) CCD gives a warning!
+       */
+      if (melem[e_ref].maxRepeat > 255)
+      {
+        ULONG count = (ULONG) (* (USHORT *)(globs->pstruct + globs->pstructOffs++));
+        amount = MINIMUM (count, (ULONG) melem[e_ref].maxRepeat);
+        if (amount < count) 
+          ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
+                           (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+      }
+      else
+      {
+        amount = (ULONG)MINIMUM (globs->pstruct[globs->pstructOffs], 
+                                  melem[e_ref].maxRepeat);
+        if ( amount < (ULONG) (globs->pstruct[globs->pstructOffs]) )
+          ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
+                           (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+      }
+      repeat = 1;
+      globs->pstructOffs++;
+    }
+    else
+    if (melem[e_ref].repType EQ 'c')
+    {
+      amount = (ULONG) melem[e_ref].maxRepeat;
+      repeat = 1;
+    }
+    else
+    if (melem[e_ref].repType == 's')
+    {
+      BOOL  is_variable;
+      ULONG max_rep;
+      
+      is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs);
+      /* Substract one bit which will be spent on the (CSN.1) flag. */
+      amount = repeat - 1;
+      repeat = 1;
+    }
+    if (melem[e_ref].repType EQ 'v' OR melem[e_ref].repType EQ 'i')
+    {
+      cSize = (USHORT)((melem[e_ref].elemType EQ 'V' OR
+		      melem[e_ref].elemType EQ 'R' OR melem[e_ref].elemType EQ 'F')
+                 ? mvar[melem[e_ref].elemRef].cSize
+                 : mcomp[melem[e_ref].elemRef].cSize
+              );
+      
+      startOffset = (USHORT) globs->pstructOffs;
+    }
+    
+    /* Dynamic array addition.
+     * Check for non-code transparent pointer types ('P', 'Q', 'R').
+     * For these types, the optional flag is the pointer itself.
+     * ASSUMPTION: The pointer may be preceeded by a counter octet,
+     * a union tag id octet etc., but it is up to CCDGEN to ensure
+     * word alignment (by inserting alignment bytes). Therefore
+     * we just read from globs->pstruct[globs->pstructOffs].
+    */
+#ifdef DEBUG_CCD
+    /* Check pointer alignment and re-align if necessary (should never happen) */
+    if ( is_pointer_type(e_ref) AND ((globs->pstructOffs & 3) NEQ 0)) {
+      TRACE_CCD (globs, "cdc_csn1_sx_encode(): Pointer misaligned! pstruct=0x08x,"
+		 " pstructOffs=0x%08x", globs->pstruct, globs->pstructOffs);
+      globs->pstructOffs = (globs->pstructOffs + 3) & 3;
+    }
+#endif
+#ifdef DYNAMIC_ARRAYS
+    /*
+     * Perform pointer dereference for pointer types.
+     * Also, check optionality for these types.
+     */
+    if ( is_pointer_type(e_ref) ) {
+      U8 *deref_pstruct;
+
+      /* Get pointer value */
+      deref_pstruct = *(U8 **)&globs->pstruct[globs->pstructOffs];
+
+      /*
+       * Strictly speaking the 'D' to 'F' types should not need this
+       * check (should have returned after the optionality check above),
+       * but it will catch stray NULL pointers (or uninitialized
+       * valid flags)
+      */
+      if (ccd_check_pointer(deref_pstruct) != ccdOK )
+      {
+        ccd_recordFault (globs, ERR_INVALID_PTR, BREAK, (USHORT) e_ref, 
+                         &globs->pstruct[globs->pstructOffs]);
+        return 1;
+      }
+      /*
+       * Pointer not NULL;
+       * 1. Save old globs->pstruct and assign pointer to globs->pstruct
+       *    as new base.
+       * 2. Set pstructOffs to 0 (zero) as the next offset will start
+       *    in the new memory area.
+       */
+      old_pstruct        = globs->pstruct;
+      globs->pstruct     = deref_pstruct;
+      startOffset        = 0;
+    }
+#endif /* DYNAMIC_ARRAYS */
+  
+    for (i=0; i < repeat; i++)
+    {
+      /*
+       * The IE should be present in the message so we code 0 bit.
+       */
+      if (flag == 0xFF)
+        elemPresent = GET_HL(1);
+      else
+        elemPresent = flag;
+        
+      bf_writeBit (elemPresent, globs);
+      if (cSize)
+      {
+        /*
+         * Calculate the offset if it is an array.
+         */
+        globs->pstructOffs = (USHORT)(startOffset + (i * cSize));
+      }
+      /*
+       * Encode the value.
+       */
+      cdc_encodeElemvalue (e_ref, amount, globs);
+    }
+
+#ifdef DYNAMIC_ARRAYS
+  if ( old_pstruct NEQ NULL )
+    globs->pstruct = old_pstruct;
+#endif
+
+    if ((melem[e_ref].repType == 'i') && (globs->continue_array == TRUE))
+    {
+      /*
+       * For fields of variable length we code a 1 flag
+       * to mark the end of the array.
+       */
+      if (flag == 0xFF)
+        elemPresent = GET_HL(0);
+      else
+        elemPresent = flag ^ 0x00000001;
+      bf_writeBit (elemPresent, globs);
+    }
+    globs->continue_array = act_continue_array;
+  }
+
+  return 1;
+}
+#endif /* !RUN_FLASH */