view src/g23m-aci/aci/aci_util.c @ 238:828a6898241e

doc/Modem-configs: L1 deblobbing status update
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 20 Mar 2017 04:00:10 +0000
parents 53929b40109c
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  Project :  GSM-PS (6147)
|  Modul   :  ACI_UTIL
+----------------------------------------------------------------------------- 
|  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 :  This module defines the utility functions for the AT
|             command interpreter.
+----------------------------------------------------------------------------- 
*/ 



#ifndef ACI_UTIL_C
#define ACI_UTIL_C
#endif

#include "aci_all.h"

#include "aci_cmh.h" 
#include "ati_cmd.h"  

#include "aci_cmd.h"

#ifdef FAX_AND_DATA
#include "aci_fd.h"
#endif    /* of #ifdef FAX_AND_DATA */

#include "psa.h"
#include "psa_sms.h"
#include "phb.h"
#include "cmh.h"
#include "cmh_sms.h"

#if defined (FF_ATI) || defined (FF_BAT)
#include "aci_mem.h"
#include "aci_lst.h"
#include "aci_io.h"
#include "ksd.h"
#include "cmh_ss.h"
#include "psa_ss.h"
#endif
#ifdef FF_ATI
#include "ati_int.h"
#endif
#ifdef FF_BAT
#include "aci_bat_cb.h"
#endif

#ifdef GPRS
#include "gaci_cmh.h"
#endif /* GPRS */

#ifdef TI_PS_OP_CNV_TAB_ROMBASED
  #include "rom_tables.h"
#endif /* TI_PS_OP_CNV_TAB_ROMBASED */


#ifdef TI_PS_OP_CNV_TAB_ROMBASED
    /* If this flag is enabled CSCS_CHSET_Chars is defined in rom_tables.h file */
#else
  #define CSCS_CHSET_Chars  256
#endif

/*==== CONSTANTS ==================================================*/
#ifdef REL99
#define NUM_EXT_TABLE_CHARS 9
#define NUM_IRA_8859_TABLE_CHARS 1
#endif


/*==== TYPES ======================================================*/

/*==== EXPORT =====================================================*/
/* This fucntion cuts the pathname from the file
   used by ACI_ASSERT makro*/
GLOBAL char * getFileName(char * file)
{
  char *cursor = file;
  do {
    #ifdef _SIMULATION_
    if(*cursor EQ '\\') { file = cursor+1;}
    #else
    if(*cursor EQ '/') { file = cursor+1;}
    #endif
    cursor++;
  } while(*cursor NEQ '\0');
  return file;
}


LOCAL USHORT utl_ucs2FromGsm ( UBYTE*           in,
                              USHORT           inLen,
                              UBYTE*           out,
                              USHORT           maxOutLen,
                              USHORT*          outLen,
                              T_ACI_GSM_ALPHA  gsm,
                              T_ACI_CSCS_ALPHA alphabet );

/*==== VARIABLES ==================================================*/
#ifdef TI_PS_OP_CNV_TAB_ROMBASED
/* Changes for ROM data */
/* NHK:
 * Once the tables chset and gsmToAsciiTable  go to ROM, their names below should match corresponding ROM addresses
 * KSR: Moved to g23m\condat\com\src\drivers\rom_tables
 */
#else
GLOBAL const UBYTE chset [CSCS_CHSET_Tables][CSCS_CHSET_Chars] =
{
/*
 *-------------------------------------------------------------------
 * Conversion table: IRA -> internal GSM
 *-------------------------------------------------------------------
 */
/* 0x00 */  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x08 */    0x00, 0x00, 0x8A, 0x00, 0x00, 0x8D, 0x00, 0x00,
/* 0x10 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x18 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x20 */    0xA0, 0xA1, 0xA2, 0xA3, 0x82, 0xA5, 0xA6, 0xA7,
/* 0x28 */    0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
/* 0x30 */    0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
/* 0x38 */    0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
/* 0x40 */    0x80, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
/* 0x48 */    0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
/* 0x50 */    0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
/* 0x58 */    0xD8, 0xD9, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x91/*00*/,
/* 0x60 */    0x00, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
/* 0x68 */    0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
/* 0x70 */    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
/* 0x78 */    0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x80 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x88 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x90 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x98 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xA0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xA8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xB0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xB8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xC0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xC8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xD0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xD8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xE0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xE8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xF0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xF8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },

/*
 *-------------------------------------------------------------------
 * Conversion table: PC Danish/Norwegian -> internal GSM
 *-------------------------------------------------------------------
 */
/* 0x00 */  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x08 */    0x00, 0x00, 0x8A, 0x00, 0x00, 0x8D, 0x00, 0x00,
/* 0x10 */    0x00, 0x00, 0x00, 0x00, 0x00, 0xDF, 0x00, 0x00,
/* 0x18 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x20 */    0xA0, 0xA1, 0xA2, 0xA3, 0x82, 0xA5, 0xA6, 0xA7,
/* 0x28 */    0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
/* 0x30 */    0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
/* 0x38 */    0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
/* 0x40 */    0x80, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
/* 0x48 */    0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
/* 0x50 */    0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
/* 0x58 */    0xD8, 0xD9, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x91/*00*/,
/* 0x60 */    0x00, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
/* 0x68 */    0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
/* 0x70 */    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
/* 0x78 */    0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x80 */    0x89, 0xFE, 0x85, 0xE1, 0xFB, 0xFF, 0x8F, 0x89,
/* 0x88 */    0xE5, 0xE5, 0x84, 0xE9, 0xE9, 0x87, 0xDB, 0x8E,
/* 0x90 */    0x9F/*C5*/, 0x9D, 0x9C, 0xEF, 0xFC, 0x88, 0xF5/*E5*/, 0x86,
/* 0x98 */    0xF9/*E9*/, 0xDC, 0xDE, 0x8C, 0x81, 0x8B, 0x00, 0x00,
/* 0xA0 */    0xE1, 0xE9, 0xEF, 0xF5, 0xFD, 0xDD, 0x00, 0x00,
/* 0xA8 */    0xE0, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00,
/* 0xB0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xB8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xC0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xC8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xD0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xD8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xE0 */    0x00, 0x9E, 0x93, 0x00, 0x98, 0x00, 0x00, 0x00,
/* 0xE8 */    0x92, 0x99, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xF0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xF8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },

/*
 *-------------------------------------------------------------------
 * Conversion table: ISO 8859 Latin 1 -> internal GSM
 *-------------------------------------------------------------------
 */
/* 0x00 */  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x08 */    0x00, 0x00, 0x8A, 0x00, 0x00, 0x8D, 0x00, 0x00,
/* 0x10 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x18 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x20 */    0xA0, 0xA1, 0xA2, 0xA3, 0x82, 0xA5, 0xA6, 0xA7,
/* 0x28 */    0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
/* 0x30 */    0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
/* 0x38 */    0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
/* 0x40 */    0x80, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
/* 0x48 */    0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
/* 0x50 */    0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
/* 0x58 */    0xD8, 0xD9, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x91/*00*/,
/* 0x60 */    0x00, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
/* 0x68 */    0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
/* 0x70 */    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
/* 0x78 */    0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x80 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x88 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x90 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x98 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xA0 */    0x00, 0xC0, 0x00, 0x81, 0xA4, 0x83, 0x00, 0xDF,
/* 0xA8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xB0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xB8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0,
/* 0xC0 */    0xC1, 0xC1, 0xC1, 0xC1, 0xDB, 0x8E, 0x9C, 0x89,
/* 0xC8 */    0xC5, 0x9F/*C5*/, 0xC5, 0xC5, 0xC9, 0xC9, 0xC9, 0xC9,
/* 0xD0 */    0x00, 0xDD, 0xCF, 0xCF, 0xCF, 0xCF, 0xDC, 0x00,
/* 0xD8 */    0x8B, 0xD5, 0xD5, 0xD5, 0xDE, 0xD9, 0x00, 0x9E,
/* 0xE0 */    0xFF, 0xE1, 0xE1, 0xE1, 0xFB, 0x8F, 0x9D, 0x89,
/* 0xE8 */    0x84, 0x85, 0xE5, 0xE5, 0x87, 0xE9, 0xE9, 0xE9,
/* 0xF0 */    0x00, 0xFD, 0x88, 0xEF, 0xEF, 0xEF, 0xFC, 0x00,
/* 0xF8 */    0x8C, 0x86, 0xF5, 0xF5, 0xFE, 0xF9, 0x00, 0xF9 },

/*
 *-------------------------------------------------------------------
 * Conversion table: PC Code Page 437 -> internal GSM
 *-------------------------------------------------------------------
 */
/* 0x00 */  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x08 */    0x00, 0x00, 0x8A, 0x00, 0x00, 0x8D, 0x00, 0x00,
/* 0x10 */    0x00, 0x00, 0x00, 0x00, 0x00, 0xDF, 0x00, 0x00,
/* 0x18 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x20 */    0xA0, 0xA1, 0xA2, 0xA3, 0x82, 0xA5, 0xA6, 0xA7,
/* 0x28 */    0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
/* 0x30 */    0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
/* 0x38 */    0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
/* 0x40 */    0x80, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
/* 0x48 */    0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
/* 0x50 */    0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
/* 0x58 */    0xD8, 0xD9, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x91/*00*/,
/* 0x60 */    0x00, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
/* 0x68 */    0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
/* 0x70 */    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
/* 0x78 */    0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x80 */    0x89, 0xFE, 0x85, 0xE1, 0xFB, 0xFF, 0x8F, 0x89,
/* 0x88 */    0xE5, 0xE5, 0x84, 0xE9, 0xE9, 0x87, 0xDB, 0x8E,
/* 0x90 */    0x9F/*C5*/, 0x9D, 0x9C, 0xEF, 0xFC, 0x88, 0xF5/*E5*/, 0x86,
/* 0x98 */    0xF9/*E9*/, 0xDC, 0xDE, 0x00, 0x81, 0x83, 0x00, 0x00,
/* 0xA0 */    0xE1, 0xE9, 0xEF, 0xF5, 0xFD, 0xDD, 0x00, 0x00,
/* 0xA8 */    0xE0, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00,
/* 0xB0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xB8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xC0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xC8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xD0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xD8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xE0 */    0x00, 0x9E, 0x93, 0x00, 0x98, 0x00, 0x00, 0x00,
/* 0xE8 */    0x92, 0x99, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xF0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xF8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },

/*
 *-------------------------------------------------------------------
 * Conversion table: GSM -> internal GSM
 *-------------------------------------------------------------------
 */
/* 0x00 */  { 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
/* 0x08 */    0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
/* 0x10 */    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
/* 0x18 */    0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
/* 0x20 */    0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
/* 0x28 */    0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
/* 0x30 */    0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
/* 0x38 */    0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
/* 0x40 */    0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
/* 0x48 */    0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
/* 0x50 */    0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
/* 0x58 */    0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
/* 0x60 */    0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
/* 0x68 */    0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
/* 0x70 */    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
/* 0x78 */    0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
/* 0x80 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x88 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x90 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0x98 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xA0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xA8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xB0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xB8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xC0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xC8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xD0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xD8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xE0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xE8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xF0 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0xF8 */    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
};


/*
 *-------------------------------------------------------------------
 * Conversion table: ASCII <-> internal GSM
 * ( needed for the conversion of UCS2 <-> internal GSM )
 *-------------------------------------------------------------------
 */
/* GSM alphabet characters unknown in the ASCII table have been 
   replaced by <SP> characters */
LOCAL const UBYTE gsmToAsciiTable[128] =
{   
    /*n =     0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */
/* 0x0n */   64,163, 36,165,232,233,249,236,242,199, 10,216,248, 13,197,229,
/* 0x1n */  128, 95,129,130,131,132,133,134,135,136,137, 27,198,230,223,201,
/* 0x2n */   32, 33, 34, 35,164, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
/* 0x3n */   48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
/* 0x4n */  161, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
/* 0x5n */   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,196,214,209,220,167,
/* 0x6n */  191, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
/* 0x7n */  112,113,114,115,116,117,118,119,120,121,122,228,246,241,252,224
};

LOCAL const UBYTE  hexVal[] = {"0123456789ABCDEF"};

#endif

/*
 * These tables are moved out of TI_PS_OP_CNV_TAB_ROMBASED
 */

#ifdef REL99
/*
 *-------------------------------------------------------------------
 * Conversion table: Extension character table that can be used for 
                     mapping IRA or PC D/N or ISO 8859 Latin 1 or PCCP 437
                     characters to GSM 7 extension table characters
 * The first column contains the GSM 7 extension table character value and 
 * the second column contains the corresponding character in the other 
 * character sets 
 * Ref: 23.038 Sec 6.2.1.1
 *-------------------------------------------------------------------
 */
GLOBAL const UBYTE ext_common_chset_map [NUM_EXT_TABLE_CHARS][2] =
{
  { 0x14, 0x5E }, /* ^  */
  { 0x1B, 0x20 }, /* Reserved for another extension table. To be replaced by space */
  { 0x28, 0x7B }, /* { */
  { 0x29, 0x7D }, /* } */
  { 0x2F, 0x5C }, /* \ */
  { 0x3C, 0x5B }, /* [ */
  { 0x3D, 0x7E }, /* ~ */
  { 0x3E, 0x5D }, /* ] */
  { 0x40, 0x7C }  /* | */  
};

/*
 *-------------------------------------------------------------------
 * Conversion table: Extension table character that is used only for 
   IRA OR ISO 8859 Latin 1, in addition to the character table given 
   above. 
 * Ref: 23.038 Sec 6.2.1.1
 * The Euro character is treated separately as it there is no mapping 
 * character in PCCP 437 and PCDN.  
 *-------------------------------------------------------------------
 */  
GLOBAL const UBYTE ext_ira_8859_chset_map [NUM_IRA_8859_TABLE_CHARS][2] =
{
  { 0x65, 0x80 }  /* Euro symbol */
};
#endif


/*
static const unsigned char
gsm_2_ascii_table[128] = 
{
  0x40, 0x9C, 0x24, 0x9D, 0x8A, 0x82, 0x97, 0x8D, 0x95, 0x80, 0x0A, 0x02, 0x07, 0x0D, 0x8F, 0x86,
  0x04, 0x5F, 0xE8, 0xE2, 0xEF, 0xEA, 0xE3, 0x05, 0xE6, 0xE9, 0xF0, 0x20, 0x92, 0x91, 0xE1, 0x90, 
  0x20, 0x21, 0x22, 0x23, 0x01, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
  0xAD, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x8E, 0x99, 0xA5, 0x9A, 0x06,
  0xA8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
  0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x84, 0x94, 0xA4, 0x81, 0x85
};
*/

/*==== FUNCTIONS ==================================================*/
#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : strupper                     |
+-------------------------------------------------------------------+

  PURPOSE : Converts all characters from 'a' to 'z' to capital
            characters from 'A' to 'Z'.
*/
GLOBAL char* strupper ( char* s )
{
  USHORT i = 0;

  while ( s NEQ 0 AND s[i] NEQ '\0')
  {
    if ( s[i] >= 0x61 AND s[i] <= 0x7a )

      s[i] = s[i] - 0x20;

    i++;
  }

  return s;
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_chsetToSim               |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the character set used within the AT command interpreter
            to the SIM GSM character set.
*/
GLOBAL void utl_chsetToSim ( UBYTE*          in,
                             USHORT          inLen,
                             UBYTE*          out,
                             USHORT*         outLen,
                             T_ACI_GSM_ALPHA gsm )
{
  UBYTE  cvtdVal;
  USHORT outIdx   = 0;
  USHORT inIdx;
  UBYTE  corr     = ( gsm EQ GSM_ALPHA_Int ? 0xFF : 0x7F );
  T_ACI_CSCS_CHSET cscsChset;
  UBYTE  srcId = srcId_cb;

  cscsChset = ati_user_output_cfg[srcId].cscsChset;
  
  if ( cscsChset EQ CSCS_CHSET_Hex )
  {
    utl_hexToGsm ( in, inLen, out, outLen, gsm, CSCS_ALPHA_8_Bit );
  }
  else if ( cscsChset EQ CSCS_CHSET_Ucs2 )
  {
    /* If the user chooses UCS2, then the best mode of coding should be 
     * used to store the characters in the SIM */
    utl_ucs2ToSim(in, inLen, out, outLen, gsm, CSCS_ALPHA_8_Bit);
  }
  else
  {
    for ( inIdx = 0; inIdx < inLen; inIdx++ )
    {
      cvtdVal = chset[cscsChset][( UBYTE ) in[inIdx]]; 
        
      if ( cvtdVal NEQ 0x00 )
      {
        out[outIdx] = ( CHAR ) cvtdVal & corr;
        outIdx++;
      }
    }

    if ( gsm EQ GSM_ALPHA_Int )
      out[outIdx] = '\0';

    *outLen = outIdx;
  }
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_codeUcs2                 |
+-------------------------------------------------------------------+

  PURPOSE : This function finds optimal coding format to store the 
            UCS2 character string in the phone book.
*/
GLOBAL void utl_ucs2ToSim( UBYTE*          in,
                           USHORT          inLen,
                           UBYTE*          out,
                           USHORT*         outLen,
                           T_ACI_GSM_ALPHA gsm,
                           T_ACI_CSCS_ALPHA alphabet)
{
  int    i;
  BOOL   flag = TRUE;
  UBYTE  hexOut[MAX_ALPHA_LEN * 4];
  USHORT hexOutLen = 0;

  /* Convert the hex character string to actual hex values */
  hexOutLen = utl_HexStrToBin(in, inLen, hexOut, (MAX_ALPHA_LEN * 4));

  /* Initial check is done for GSM or ASCII only characters */
  for(i = 0; i < (hexOutLen/2); i++)
  {
    if(( hexOut[i*2] NEQ 0x00 ))
    {
      flag = FALSE;
      break;
    }
  }
  if (flag EQ TRUE)
  {
    utl_ConvUcs2ToGSM(hexOut, hexOutLen, out, outLen, gsm, alphabet);
    if (*outLen)
      return;
  }

  /* If possible UCS2 character string is coded in 0x81 format which
     uses a one byte base pointer */
  utl_Ucs2InFormat1 (hexOut, hexOutLen, out, outLen);
  if (*outLen)
    return;

  /* If possible UCS2 character string is coded in 0x82 format which
     uses two byte base pointer */
  utl_Ucs2InFormat2 (hexOut, hexOutLen, out, outLen);
  if (*outLen)
    return;

  /* If none of the above work, UCS2 character string is coded in 0x80 */
  *out = 0x80;
  utl_hexToGsm ( in, inLen, out + 1, outLen, gsm, CSCS_ALPHA_8_Bit );
  (*outLen)++;
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_ConvUcs2ToGSM            |
+-------------------------------------------------------------------+

  PURPOSE : This function converts UCS2 charecter string consisting of 
            only ASCII charecters to default GSM values.
*/
GLOBAL void utl_ConvUcs2ToGSM ( UBYTE*           in,
                                USHORT           inLen,
                                UBYTE*           out,
                                USHORT*          outLen,
                                T_ACI_GSM_ALPHA  gsm,
                                T_ACI_CSCS_ALPHA alphabet )
{
  int i, j;
  BOOL   flag;
  UBYTE  val = 0x00;
  USHORT len;
  UBYTE  tmpOut;
  USHORT outIdx = 0;
  UBYTE  corr   = ( gsm EQ GSM_ALPHA_Int ? 0xFF : 0x7F );

  len = inLen/2;
  for (i = 0;i < len; i++)
  {
    tmpOut = in[(i*2) + 1];    
    /* convert the hexadecimal ASCII value to GSM, if the value is
     * not convertible then we exit */
    if ( tmpOut EQ ( gsmToAsciiTable[tmpOut])) /* ASCII and GSM are identical */
    {
      val = tmpOut;
    }
    else /* find match in the table and copy index of match */
    {
      flag = FALSE;
      for (j=0; j<128; j++)
      {
        if (tmpOut EQ gsmToAsciiTable[j])
        {
          val = (UBYTE)j;
          flag = TRUE;
          break;
        }
        #ifdef REL99
        else
        {
          /* There is a chance that this is in the mapping table */
          UBYTE ext_tbl_idx = 0;        
          while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
                 ext_common_chset_map[ext_tbl_idx][1] NEQ tmpOut )
          { 
            ext_tbl_idx++;
          }
          if(ext_tbl_idx < NUM_EXT_TABLE_CHARS)
          {
            /*Insert the escape character, 0x1B, to output stream*/
            out[outIdx++] = 0x1B |(corr &0x80);
            /* Insert the mapping character into the output stream */
            val = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80);
            flag = TRUE;
            break;
          }
        }
#endif /* REL99 */
      }
      if (!flag)
      {
        *outLen = 0;
        return;
      }
    }      
    
    /* if necessary, cut the GSM value to 7bit */
    if ( alphabet EQ CSCS_ALPHA_7_Bit AND !( val & 0x80 ) )
    {
      if ( gsm EQ GSM_ALPHA_Int )
      {
        out[outIdx++] = val | 0x80; 
      }
      else
      {
        out[outIdx++] = val;
      }
    }
    else
    {
      out[outIdx++] = val;
    }
  }
      
  if ( gsm EQ GSM_ALPHA_Int )
  {
    out[outIdx] = '\0';
  }

  /* set the outlength */
  *outLen = outIdx;
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_Ucs2InFormat1            |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the UCS2 character string in the 
            0x81 coding scheme for UCS2.
            Octet 1: 0x81
            Octet 2: Num of Characters
            Octet 3: Bits 15 to 8 of Base pointer
            Octet 4 onwards: Characters
*/
GLOBAL void utl_Ucs2InFormat1( UBYTE*           in,
                               USHORT           inLen,
                               UBYTE*           out,
                               USHORT*          outLen)
{
  int i, j;
  UBYTE  base_ptr = 0x00;
  UBYTE  temp_ptr;
  USHORT len = inLen/2;
  USHORT tmp_base;
  USHORT tmp;
  USHORT outIdx = 0;
  UBYTE corr = 0x7F;
  

  /* We first check if the UCS2 string can be coded 
   * using a single base pointer */
  for (i = 0; i < len; i++)
  {
    if (in[i*2])
    {
      if ((in[i*2] & 0x80))
      {
        *outLen = 0;
        return;
      }
      temp_ptr = in[i*2] & 0x7f;
      temp_ptr <<= 1;
      temp_ptr |= ((in[(i*2)+1] & 0x80) >> 7);
      
      if (base_ptr)
      {
        if (temp_ptr NEQ base_ptr)
        {
          *outLen = 0;
          return;           
        }
      } else
      {
        base_ptr = temp_ptr;
      }
    }
  }


  /* Characters are coded using the base pointer below */
  /* For details, see GSM 11.11 Annex B (normative) */
  out[0] = 0x81;
  if (len < PHB_MAX_TAG_LEN - 3)
  {
    out[1] = (UBYTE)len;
  } else
  {
    out[1] = PHB_MAX_TAG_LEN - 3;
  }
  out[2]   = base_ptr;
  tmp_base = 0;
  tmp_base = base_ptr << 7;
  outIdx   = 3;

  len = out[1];
  for (i = 0; i < len; i++)
  {
    if (in[i*2])
    {
      tmp  = 0;
      tmp  = in[i*2] << 8;
      tmp |= in[(i*2)+1];
      out[outIdx++] = (tmp - tmp_base) | 0x80;
    } else 
    {
      for (j=0; j<128; j++)
      {
        if (in[(i*2)+1] EQ gsmToAsciiTable[j])
        {
          out[outIdx++] = (UBYTE)j;
          break;
        }
      #ifdef REL99
        else
        {
          /* There is a chance that this is in the mapping table */
          UBYTE ext_tbl_idx = 0;        
          while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
                 ext_common_chset_map[ext_tbl_idx][1] NEQ in[(i*2)+1] )
          { 
            ext_tbl_idx++;
          }
          if(ext_tbl_idx < NUM_EXT_TABLE_CHARS)
          {
            /*Insert the escape character, 0x1B, to output stream*/
            out[outIdx++] = 0x1B |(corr &0x80);
            /* Insert the mapping character into the output stream */
            out[outIdx++] = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80);
            break;
          }
        }
#endif /* REL99 */
      }
    }
   /* If the charecter cannot be found in ASCII table exit */
   if (j EQ 128)
   {
     *outLen = 0;
     return ;
   }
 }

#ifdef REL99
 if (outIdx -3 > len)  
 { 
   if (outIdx >=  PHB_MAX_TAG_LEN)
   {
     if (out[PHB_MAX_TAG_LEN - 1] EQ 0x1B) 
     {
       outIdx = PHB_MAX_TAG_LEN - 1;
       out[1] = PHB_MAX_TAG_LEN - 4;
     }
     else 
     {
       outIdx = PHB_MAX_TAG_LEN;
       out[1] = PHB_MAX_TAG_LEN - 3;
     }
   }
   else 
   {
     out[1] = outIdx -3;
   }
 }
#endif /* REL99 */

  *outLen = outIdx;
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_Ucs2InFormat2            |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the UCS2 character string in the 
            0x82 coding scheme for UCS2.
            Octet 1: 0x82
            Octet 2: Number of characters
            Octet 3 and Octet 4: 2 byte base pointer
            Octet 5 onwards: Characters 
            
*/
GLOBAL void utl_Ucs2InFormat2( UBYTE*           in,
                               USHORT           inLen,
                               UBYTE*           out,
                               USHORT*          outLen)
{
  int i, j;
  USHORT len = inLen/2;
  USHORT lowest_ch  = 0;
  USHORT highest_ch = 0;
  USHORT tmp;
  USHORT outIdx = 0;
  UBYTE corr = 0x7F;

  /* We first check if the UCS2 string can be coded 
   * using a smallest char as the base pointer */
  for (i = 0; i < len; i++)
  {
    if (in[i*2])
    {
      tmp  = 0;
      tmp  = in[i*2] << 8;
      tmp |= in[(i*2)+1];

      if (lowest_ch EQ 0 OR tmp < lowest_ch)
        lowest_ch = tmp;

      if (tmp > highest_ch)
        highest_ch = tmp;
    }
  }

  /* To use lowest char can be used as the base pointer, the distance
   * between the lowest and highest char must not be more then 128 */
  /* correct here: must not equal or more then 128. the max offset will be less then 0x80 = 128 */
//TI-SH-TEST-PATCH for CSR OMAPS00168884 
  if ((highest_ch - lowest_ch) >= 0x80)
  {
    *outLen = 0;
    return;
  }

  /* Characters are coded using the base pointer below */
  /* For details, see GSM 11.11 Annex B (normative) */
  out[0] = 0x82;
  if (len < PHB_MAX_TAG_LEN - 4)
  {
    out[1] = (UBYTE)len;
  } else
  {
    out[1] = PHB_MAX_TAG_LEN - 4;
  }
  out[2] = (lowest_ch & 0xff00) >> 8;
  out[3] = (lowest_ch & 0x00ff);  
  outIdx   = 4;

  len = out[1];
  for (i = 0; i < len; i++)
  {
    if (in[i*2])
    {
      tmp  = 0;
      tmp  = in[i*2] << 8;
      tmp |= in[(i*2)+1];
      out[outIdx++] = (tmp - lowest_ch) | 0x80;
    } else 
    {
      for (j=0; j<128; j++)
      {
        if (in[(i*2)+1] EQ gsmToAsciiTable[j])
        {
          out[outIdx++] = (UBYTE)j;
          break;
        }
      #ifdef REL99
        else
        {
          /* There is a chance that this is in the mapping table */
          UBYTE ext_tbl_idx = 0;        
          while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
                 ext_common_chset_map[ext_tbl_idx][1] NEQ in[(i*2)+1] )
          { 
            ext_tbl_idx++;
          }
          if(ext_tbl_idx < NUM_EXT_TABLE_CHARS)
          {
            /*Insert the escape character, 0x1B, to output stream*/
            out[outIdx++] = 0x1B |(corr &0x80);
            /* Insert the mapping character into the output stream */
            out[outIdx++] = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80);
            break;
          }
        }
#endif /* REL99 */
      }

    /* If the charecter cannot be found in ASCII table exit */
     if (j EQ 128)
     {
      *outLen = 0;
      return ;
     }
    }
  }

#ifdef REL99
  if (outIdx -4 > len)  
  { 
    if (outIdx >=  PHB_MAX_TAG_LEN)
    {
      if (out[PHB_MAX_TAG_LEN - 1] EQ 0x1B) 
      {
        outIdx = PHB_MAX_TAG_LEN - 1;
        out[1] = PHB_MAX_TAG_LEN - 5;
      }
      else 
      {
        outIdx = PHB_MAX_TAG_LEN;
        out[1] = PHB_MAX_TAG_LEN - 4;
      }
    }
    else 
    {
      out[1] = outIdx -4;
    }
  }
#endif /* REL99 */

  *outLen = outIdx;
}
#endif

#ifdef FF_ATI

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_chsetToGsm               |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the character set used within the AT command interpreter
            to the ACI internal GSM character set. The outBufLen was added 
            so that buffer overflow is kept in check when replacing one  
            non-GSM character with two characters - an escape character 0x1B 
            and a character from the extension table.
*/
GLOBAL void utl_chsetToGsm ( UBYTE*          in,
                             USHORT          inLen,
                             UBYTE*          out,
                             USHORT*         outLen,
#ifdef REL99
                             USHORT          outBufLen,
#endif
                             T_ACI_GSM_ALPHA gsm )
{
  UBYTE  cvtdVal;
  USHORT outIdx   = 0;
  USHORT inIdx;
  UBYTE  corr     = ( gsm EQ GSM_ALPHA_Int ? 0xFF : 0x7F );
  T_ACI_CSCS_CHSET cscsChset;
  UBYTE  srcId = srcId_cb;

  cscsChset = ati_user_output_cfg[srcId].cscsChset;

  if ( ati_user_output_cfg[srcId].cscsChset EQ CSCS_CHSET_Hex )
  {
    utl_hexToGsm ( in, inLen, out, outLen, gsm, CSCS_ALPHA_8_Bit );
  }
  else if ( cscsChset EQ CSCS_CHSET_Ucs2 )
  {
    utl_ucs2ToGsm ( in, inLen, out, outLen, gsm, CSCS_ALPHA_8_Bit );
  }
  else
  {
#ifndef REL99
    for ( inIdx = 0; inIdx < inLen; inIdx++ )
    {
      cvtdVal = chset[cscsChset][( UBYTE ) in[inIdx]];
      if ( cvtdVal NEQ 0x00 )
      {
        out[outIdx] = ( CHAR ) cvtdVal & corr;
        outIdx++;
      }
    }
#else
    for ( inIdx = 0; inIdx < inLen AND outIdx < outBufLen; inIdx++ )
    {
      cvtdVal = chset[cscsChset][( UBYTE ) in[inIdx]];

      if ( cvtdVal NEQ 0x00 )
      {
        out[outIdx] = ( CHAR ) cvtdVal & corr;
        outIdx++;
      }
      else
      {
        /* There is a chance that this is in the mapping table */
        UBYTE ext_tbl_idx = 0;        
        while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
               ext_common_chset_map[ext_tbl_idx][1] NEQ in[inIdx] )
        {
          ext_tbl_idx++;
        }
        if(ext_tbl_idx < NUM_EXT_TABLE_CHARS)
        {
          /*Insert the escape character, 0x1B, to output stream*/
          out[outIdx++] = 0x1B |(corr &0x80);
          /* Check that output buffer limit has not been reached */
          if(outIdx < outBufLen)
          {
            /* Insert the mapping character into the output stream */
            out[outIdx++] = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80);
          }
        }
        else if ( ( cscsChset EQ CSCS_CHSET_Ira ) OR ( cscsChset EQ CSCS_CHSET_8859_1 ) )
        {
          /* Check if the character is present in ext_ira_8859_chset_map */
          ext_tbl_idx = 0;

          while( ext_tbl_idx < NUM_IRA_8859_TABLE_CHARS              AND 
                 ext_ira_8859_chset_map[ext_tbl_idx][1] NEQ in[inIdx] )
          {
            ext_tbl_idx++;
          }
             
          if( ext_tbl_idx < NUM_IRA_8859_TABLE_CHARS )
          {
            /*Insert the escape character, 0x1B, to output stream*/
            out[outIdx++] = 0x1B |(corr &0x80);
            /* Check that output buffer limit has not been reached */
            if(outIdx < outBufLen)
            {
              /* Insert the mapping character into the output stream */
              out[outIdx++] = ( UBYTE )ext_ira_8859_chset_map[ext_tbl_idx][0] |(corr &0x80);
            }
          }
        }
      }
    }
#endif /* ifndef REL99 */

    if ( gsm EQ GSM_ALPHA_Int )
      out[outIdx] = '\0';

    *outLen = outIdx;
  }
}
#endif


#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_hexFromAlpha             |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the SIM with UCS2 form 0x81 or 0x82 to 16 Bit hex values.
            see GSM 11.11 Annex B Coding of Alpha fields in the SIM for UCS2
            UCS2 form 0x81:
             - octet 1 = 0x81
             - octet 2 = length
             - octet 3 = Bits 15 to 8 of the base pointer to a half page in the UCS2 code space
                         0hhh hhhh h000 0000 , with h = bits of the half page base pointer
                        16... .... .... ...1

            UCS2 form 0x82:
             - octet 1 = 0x81
             - octet 2 = length
             - octet 3 = upper 8 Bit of 16 Bit base pointer to a half page in the UCS2 code space
             - octet 4 = lower 8 Bit of 16 Bit base pointer to a half page in the UCS2 code space           
*/
GLOBAL void utl_hexFromUCS2  ( UBYTE  *in, 
                              UBYTE  *out, 
                              USHORT  maxOutlen, 
                              USHORT *outlen,
                              T_ACI_GSM_ALPHA gsm)
{
  USHORT outIdx = 0;
  USHORT base_pointer;
  USHORT length = in[1];
  USHORT tmp;
  UBYTE  corr     = ( gsm EQ GSM_ALPHA_Int ? 0x00 : 0x80 );

  if (*in EQ 0x81)
  {
    base_pointer = in[2] << 7;
    in += 3;
  }
  else /* if (*in EQ 0x82) */
  {
    base_pointer = in[2]<<8 | in[3];
    in += 4;
  }
  
  while ( length-- AND outIdx < maxOutlen-2)
  {  
    if (*in & 0x80)
    {
      tmp  = base_pointer + (*in & 0x7F); 
    }
    else if((*in | corr) NEQ 0x9B)
    {
      tmp  = 0x0000 + gsmToAsciiTable[*in];
    }
    #ifdef REL99
    else
    {
      UBYTE ext_tbl_idx = 0;
      BOOL  mapping_char_found = FALSE;  
      in++;

      while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
             ext_common_chset_map[ext_tbl_idx][0] NEQ (*in & 0x7F))
      {
        ext_tbl_idx++;
      }
      if( ext_tbl_idx < NUM_EXT_TABLE_CHARS )
      {
        /* Insert the mapping character into the output stream */
        tmp = 0x0000 + ( UBYTE )ext_common_chset_map[ext_tbl_idx][1];
      }
    }
#endif
    out[outIdx++] = hexVal[(tmp >> 12) & 0x0F ];
    out[outIdx++] = hexVal[(tmp >>  8) & 0x0F ];
    out[outIdx++] = hexVal[(tmp >>  4) & 0x0F ];
    out[outIdx++] = hexVal[(tmp      ) & 0x0F ];

    in++;
  }

  out[outIdx] = '\0';
  *outlen = outIdx;
}
#endif


#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_chsetFromSim             |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the SIM format to the character set
            used within the AT command interpreter.
*/
GLOBAL void utl_chsetFromSim ( UBYTE*          in,
                               USHORT          inLen,
                               UBYTE*          out,
                               USHORT          maxOutLen,
                               USHORT*         outLen,
                               T_ACI_GSM_ALPHA gsm )
{
  T_ACI_CSCS_CHSET cscsChset;
  UBYTE srcId = srcId_cb;

  cscsChset = ati_user_output_cfg[srcId].cscsChset;

  if ( cscsChset EQ CSCS_CHSET_Ucs2 AND
        (( *in EQ 0x80 ) OR ( *in EQ 0x81 ) OR ( *in EQ 0x82 )) )
  {
    /* UCS2 with form 0x81 or 0x82 as HEX string */
    if (( *in EQ 0x81 ) OR ( *in EQ 0x82 ))
    {
      utl_hexFromUCS2 ( in, out, maxOutLen, outLen, gsm);
      return;
    }
    
    /* UCS2 form 0x80 as HEX string */
    utl_hexFromGsm ( in + 1, (USHORT)( inLen - 1 ), out, maxOutLen, outLen,
                     gsm, CSCS_ALPHA_8_Bit );
  } 
  else 
  {
    utl_chsetFromGsm ( in, inLen, out, maxOutLen, outLen, gsm );
  }
}
#endif /* #ifdef FF_ATI */

#if defined(FF_ATI) || defined(FF_BAT)
#ifdef TI_PS_OP_CNV_TAB_ROMBASED
#endif

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_chsetFromGsm             |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the ACI internal GSM character set to the character set
            used within the AT command interpreter.
*/

GLOBAL USHORT utl_chsetFromGsm(
  UBYTE*            in,
  USHORT            inLen,
  UBYTE*            out,
  USHORT            maxOutLen,
  USHORT*           outLen,
  T_ACI_GSM_ALPHA   gsm)
{
  USHORT outIdx = 0;
  USHORT inIdx  = 0;
  USHORT actLen = ( gsm EQ GSM_ALPHA_Int ?
                        ( USHORT ) strlen ( ( CHAR* ) in ) : inLen );
  UBYTE  corr   = ( gsm EQ GSM_ALPHA_Int ? 0x00 : 0x80 );
  T_ACI_CSCS_CHSET cscsChset;
  UBYTE  srcId = srcId_cb;
  USHORT tblIdx;

  cscsChset = ati_user_output_cfg[srcId].cscsChset;

  if ( cscsChset EQ CSCS_CHSET_Hex )
  {
    return utl_hexFromGsm ( in, inLen, out, maxOutLen, outLen, gsm, CSCS_ALPHA_8_Bit );
  }
  else if ( cscsChset EQ CSCS_CHSET_Ucs2 )
  {
    return utl_ucs2FromGsm ( in, inLen, out, maxOutLen, outLen, gsm, CSCS_ALPHA_8_Bit );
  }
  else
  {
#ifndef REL99

    while ( inIdx < actLen AND outIdx < maxOutLen - 1 )
    {
      tblIdx = 0;

      
      while ( tblIdx <= 0xFF                                      AND
               chset[cscsChset][tblIdx] NEQ (( UBYTE )in[inIdx] | corr ))
        tblIdx++;
      if ( tblIdx <= 0xFF )
      {
        out[outIdx] = ( UBYTE )tblIdx;
        outIdx++;
      }

      inIdx++;
    }

#else
    /* TODO: What if the CSCS is GSM7 itself. Do we have to do this? The following check
       if( cscsChset NEQ CSCS_CHSET_Gsm AND gsm EQ GSM_ALPHA_Def */
    while ( inIdx < actLen AND outIdx < maxOutLen - 1 )
    {
      /* Check if the character is a escape to an extension of the GSM 7 bit 
       * default alphabet table. */
      if( cscsChset NEQ CSCS_CHSET_Gsm AND ((in[inIdx] | corr) EQ 0x9B) )
      {
        UBYTE ext_tbl_idx = 0;
        BOOL  mapping_char_found = FALSE;  
        inIdx++;

        /* Check if the end of the array is reached */
        if(inIdx EQ actLen)
        {
          break;
        }

        while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
               ext_common_chset_map[ext_tbl_idx][0] NEQ (in[inIdx] & 0x7F))
        {
          ext_tbl_idx++;
        }
        if( ext_tbl_idx < NUM_EXT_TABLE_CHARS )
        {
          /* Insert the mapping character into the output stream */
          out[outIdx++] = ( UBYTE )ext_common_chset_map[ext_tbl_idx][1];
          mapping_char_found = TRUE;
        }
        else if( cscsChset EQ CSCS_CHSET_Ira OR cscsChset EQ CSCS_CHSET_8859_1 )
        { 
          ext_tbl_idx = 0;

          while( ext_tbl_idx < NUM_IRA_8859_TABLE_CHARS              AND 
                 ext_ira_8859_chset_map[ext_tbl_idx][0] NEQ (in[inIdx]&0x7F))
          {
            ext_tbl_idx++;
          }

          if(ext_tbl_idx < NUM_IRA_8859_TABLE_CHARS)
          {
            /* Insert the mapping character into the output stream */
            out[outIdx++] = ( UBYTE )ext_ira_8859_chset_map[ext_tbl_idx][1];
            mapping_char_found = TRUE;
          }
        }

        if(mapping_char_found EQ FALSE)
        {
          /* From 23.038: In the event that an MS receives a code where a symbol 
             is not represented  in the extension table then the MS shall display 
             the character shown in the main GSM 7 bit default alphabet table */
            tblIdx = 0;
            while ( tblIdx <= 0xFF     AND
                    chset[cscsChset][tblIdx] NEQ (( UBYTE )in[inIdx] | corr ))
              tblIdx++;

            if ( tblIdx <= 0xFF )
            {
              out[outIdx] = ( UBYTE )tblIdx;
              outIdx++;
            }

        }
      }
      else
      {
        tblIdx = 0;

        while ( tblIdx <= 0xFF                                      AND
                chset[cscsChset][tblIdx] NEQ (( UBYTE )in[inIdx] | corr ))
          tblIdx++;

        if ( tblIdx <= 0xFF )
        {
          out[outIdx] = ( UBYTE )tblIdx;
          outIdx++;
        }

      }

      inIdx++;
    }
#endif

    out[outIdx] = '\0';
    *outLen     = outIdx;

    return inIdx;
  }
}
#endif


#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_sprints                  |
+-------------------------------------------------------------------+

  PURPOSE : This function writes a not null terminated string to a
            buffer.
*/
GLOBAL USHORT sprints ( CHAR* buf, CHAR* arg, USHORT len )
{
  buf[0] = '\"';

  memcpy ( &buf[1], arg, len );

  buf[len + 1] = '\"';
  buf[len + 2] = '\0';

  return (len + 2);
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_sprintq                  |
+-------------------------------------------------------------------+

  PURPOSE : This function writes a not null terminated string to a
            buffer.
*/
GLOBAL USHORT sprintq ( CHAR* buf, CHAR* arg, USHORT len )
{
  memcpy ( &buf[0], arg, len );

  buf[len] = '\0';

  return (len);
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_hexToIntGsm              |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the "HEX" character set to the ACI internal GSM
            character set.
*/
GLOBAL void utl_hexToGsm ( UBYTE*           in,
                           USHORT           inLen,
                           UBYTE*           out,
                           USHORT*          outLen,
                           T_ACI_GSM_ALPHA  gsm,
                           T_ACI_CSCS_ALPHA alphabet )
{
  SHORT  val    = 0;
  UBYTE  digit;
  USHORT inIdx  = 0;
  USHORT outIdx = 0;
  SHORT  base   = 0x10;

  while ( inIdx < inLen )
  {
    if ( in[inIdx] >= 0x30 AND in[inIdx] <= 0x39 )        /* '0' ... '9' */
    {
      digit = in[inIdx] - 0x30;                           /* ->0 ... 9  */
    }
    else if ( in[inIdx] >= 0x61 AND in[inIdx] <= 0x66 )   /* 'a' ... 'f' */
    {
      digit = in[inIdx] - 0x61 + 0x0A;                    /* ->0x0a...0x0f */
    }
    else if ( in[inIdx] >= 0x41 AND in[inIdx] <= 0x46 )   /* 'A' ... 'F' */
    {
      digit = in[inIdx] - 0x41 + 0x0A;                    /* ->0x0a...0x0f */
    }
    else
    {
      digit = 0xFF;
    }

    if ( digit NEQ 0xFF )  /* skip invalid digit */
    {
      if ( base EQ 0x10 )
      {
        val = digit << 4;
      }
      else
      {
        val |= digit;

        if ( alphabet EQ CSCS_ALPHA_7_Bit AND !( val & 0x80 ) )
        {
          if ( gsm EQ GSM_ALPHA_Int )
          {
            out[outIdx++] = ( CHAR ) val | 0x80;
          }
          else
          {
            out[outIdx++] = ( CHAR ) val;
          }
        }
        else if ( alphabet NEQ CSCS_ALPHA_7_Bit )
        {
          out[outIdx++] = ( CHAR ) val;
        }
      }

      base ^= 0x10;
    }

    inIdx++;
  }

  if ( gsm EQ GSM_ALPHA_Int )
    out[outIdx] = '\0';

  *outLen = outIdx;
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_ucs2ToGsm              |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the "UCS2" character set to the ACI internal GSM
            character set.
*/
GLOBAL void utl_ucs2ToGsm ( UBYTE*           in,
                           USHORT           inLen,
                           UBYTE*           out,
                           USHORT*          outLen,
                           T_ACI_GSM_ALPHA  gsm,
                           T_ACI_CSCS_ALPHA alphabet )
{
  int i, j;
  UBYTE val;
  USHORT len;
  UBYTE tmpIn[2];  /* store temporary two chars (HEX conversion) */
  UBYTE tmpInIdx;  /* holds a temporary index for two chars (HEX conversion)*/
  UBYTE digit;     /* holds a digit (HEX conversion) */
  SHORT tmpVal;    /* hold a temporary value (HEX conversion) */
  UBYTE tmpOut; /* the HEX output (HEX conversion) */ 
  SHORT  base   = 0x10;
  USHORT outIdx = 0;
  UBYTE  corr   = ( gsm EQ GSM_ALPHA_Int ? 0xFF : 0x7F );
  
  /* TRACE_FUNCTION(" utl_ucs2ToGsm() "); */
  
  len = inLen/4;
  
  for (i=0;i<len;i++)
  {
    /* check if this is a UCS2 character in 00xy format */
    if ( ( in[i*4] EQ '0' ) AND ( in[i*4+1] EQ '0' )  ) 
    {
      /* convert the next two character to HEX */
      tmpIn[0] = in[i*4+2];
      tmpIn[1] = in[i*4+3];

      tmpVal = tmpOut = val = 0;
      
      /* convert the two characters into the real hexadecimal ASCII value */
      for( tmpInIdx=0; tmpInIdx<2; tmpInIdx++ )
      {
        if ( tmpIn[tmpInIdx] >= '0' AND tmpIn[tmpInIdx] <= '9' )
        {
          digit = tmpIn[tmpInIdx] - '0';
        }
        else if ( tmpIn[tmpInIdx] >= 'a' AND tmpIn[tmpInIdx] <= 'f' )
        {
          digit = tmpIn[tmpInIdx] - 'a' + 0x0A;
        }
        else if ( tmpIn[tmpInIdx] >= 'A' AND tmpIn[tmpInIdx] <= 'F' )
        {
          digit = tmpIn[tmpInIdx] - 'A' + 0x0A;
        }
        else
        {
          digit = 0xFF;
        }
        
        if ( digit NEQ 0xFF )
        {
          if ( base EQ 0x10 )
          {
            tmpVal = digit * 0x10;
          }
          else
          {
            tmpVal += digit;
            tmpOut = (UBYTE) tmpVal;
          }
          
          base ^= 0x10;
        }
      }      
      
      /* convert the hexadecimal ASCII value to GSM */
      if (!(tmpOut & 0x80))  
      {
        if ( tmpOut EQ ( gsmToAsciiTable[tmpOut])) /* ASCII and GSM are identical */
        {
          val = tmpOut;
        }
        else /* find match in the table and copy index of match */
        {
          for (j=0; j<128; j++)
          {
            if (tmpOut EQ gsmToAsciiTable[j])
            {
              val = (UBYTE)j;
              break;
            }
          #ifdef REL99
           else
           {
             /* There is a chance that this is in the mapping table */
             UBYTE ext_tbl_idx = 0;        
             while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
                    ext_common_chset_map[ext_tbl_idx][1] NEQ tmpOut )
             { 
               ext_tbl_idx++;
             }
             if(ext_tbl_idx < NUM_EXT_TABLE_CHARS)
             {
               /*Insert the escape character, 0x1B, to output stream*/
               out[outIdx++] = 0x1B |(corr &0x80);
               /* Insert the mapping character into the output stream */
               val = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80);
               break;
             }
           }
#endif /* REL99 */
          }
        }      
      }
      else /* find match in the table and copy index of match */
      {
        for (j=0; j<128; j++)
        {
          if (tmpOut EQ gsmToAsciiTable[j])
          {
            val = (UBYTE)j;
            break;
          }
#ifdef REL99
          else
          {
            /* There is a chance that this is in the mapping table */
            UBYTE ext_tbl_idx = 0;        
            while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
                   ext_common_chset_map[ext_tbl_idx][1] NEQ tmpOut )
            { 
              ext_tbl_idx++;
            }
            if(ext_tbl_idx < NUM_EXT_TABLE_CHARS)
            {
              /*Insert the escape character, 0x1B, to output stream*/
              out[outIdx++] = 0x1B |(corr &0x80);
              /* Insert the mapping character into the output stream */
              val = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80);
              break;
            }
          }
#endif /* REL99 */
        }
      }
      
      /* if necessary, cut the GSM value to 7bit */
      if ( alphabet EQ CSCS_ALPHA_7_Bit AND !( val & 0x80 ) )
      {
        if ( gsm EQ GSM_ALPHA_Int )
        {
          out[outIdx++] = val | 0x80; 
        }
        else
        {
          out[outIdx++] = val;
        }
      }
      else
      {
        out[outIdx++] = val;
      }
    }
    
    else  /* unknown char, skip it */
    {
      /* TRACE_EVENT("UCS2 MISMATCH: Unknown UCS2 entry, character skipped!"); */
      /* out[outIdx++] = '?'; */
    }
  }
  
  if ( gsm EQ GSM_ALPHA_Int )
  {
    out[outIdx] = '\0';
  }
  
  /* set the outlength */
  *outLen = outIdx;
  
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_hexFromGsm               |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the ACI internal GSM character set to the "HEX"
            character set.
*/
GLOBAL USHORT utl_hexFromGsm ( UBYTE*           in,
                             USHORT           inLen,
                             UBYTE*           out,
                             USHORT           maxOutLen,
                             USHORT*          outLen,
                             T_ACI_GSM_ALPHA  gsm,
                             T_ACI_CSCS_ALPHA alphabet )
{
  USHORT inIdx  = 0;
  USHORT outIdx = 0;

  while ( inIdx < inLen AND outIdx < maxOutLen - 2 )
  {
      if ( alphabet NEQ CSCS_ALPHA_7_Bit OR
         ( gsm EQ GSM_ALPHA_Def AND !( in[inIdx] & 0x80 ) )  OR
         ( gsm EQ GSM_ALPHA_Int AND  ( in[inIdx] & 0x80 ) ) )
    {
      /* Convert to 7bit default alphabet only if the data is 
         coded in internal GSM character set */
      if ( gsm EQ GSM_ALPHA_Int AND  ( in[inIdx] & 0x80 ) )
      {
        out[outIdx++] = hexVal[ (in[inIdx] & 0x7F) >> 4    ];
      }
      else
      {
        out[outIdx++] = hexVal[ in[inIdx] >> 4    ];
      }
      out[outIdx++] = hexVal[ in[inIdx]  & 0x0F ];
    }

    inIdx++;
  }

  out[outIdx] = '\0';
  *outLen     = outIdx;
  
  return inIdx;
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_ucs2FromGsm              |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the ACI internal GSM character set to the "UCS2"
            character set.
*/
LOCAL USHORT utl_ucs2FromGsm (UBYTE*           in,
                              USHORT           inLen,
                              UBYTE*           out,
                              USHORT           maxOutLen,
                              USHORT*          outLen,
                              T_ACI_GSM_ALPHA  gsm,
                              T_ACI_CSCS_ALPHA alphabet )
{
  USHORT inIdx  = 0;
  USHORT outIdx = 0;
  UBYTE  corr   = ( gsm EQ GSM_ALPHA_Int ? 0x00 : 0x80 );

  while ( inIdx < inLen AND outIdx < maxOutLen - 4 )
  {
    if ( alphabet NEQ CSCS_ALPHA_7_Bit OR
       ( gsm EQ GSM_ALPHA_Def AND !( in[inIdx] & 0x80 ) )     OR
       ( gsm EQ GSM_ALPHA_Int AND  ( in[inIdx] & 0x80 ) ) )
    {
      /* Insert two leading Os, convert GSM to ASCII and print out as HEX  */
      out[outIdx++] = '0';
      out[outIdx++] = '0';
    #ifdef REL99
      if( (in[inIdx] | corr) EQ 0x9B)
      {
        UBYTE ext_tbl_idx = 0;
        inIdx++;
        while( ext_tbl_idx < NUM_EXT_TABLE_CHARS              AND 
               ext_common_chset_map[ext_tbl_idx][0] NEQ (in[inIdx] & 0x7F))
        {
          ext_tbl_idx++;
        }
        if( ext_tbl_idx < NUM_EXT_TABLE_CHARS )
        {
          /* Insert the mapping character into the output stream */
          out[outIdx++] = hexVal[(ext_common_chset_map[ext_tbl_idx][1] & 0x7F) >> 4   ];
          out[outIdx++] = hexVal[(ext_common_chset_map[ext_tbl_idx][1] & 0x7F) & 0x0F ];
        }
      }
      else
      {
    #endif /* REL99 */
      out[outIdx++] = hexVal[ gsmToAsciiTable[in[inIdx] & 0x7F] >> 4    ];
      out[outIdx++] = hexVal[ gsmToAsciiTable[in[inIdx] & 0x7F] &  0x0F ];
    #ifdef REL99
      }
    #endif /* REL99 */

    }

    inIdx++;
  }

  out[outIdx] = '\0';
  *outLen     = outIdx;
  
  return inIdx;

}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_ucs2FromGsm_ussd         |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of USSD string from
            the ACI internal GSM character set to the "UCS2"
            character set with 2 bytes only.
*/
GLOBAL USHORT utl_ucs2FromGsm_ussd(UBYTE*           in,
                              USHORT           inLen,
                              UBYTE*           out,
                              USHORT           maxOutLen,
                              USHORT*          outLen,
                              T_ACI_GSM_ALPHA  gsm,
                              T_ACI_CSCS_ALPHA alphabet )
{
  USHORT inIdx  = 0;
  USHORT outIdx = 0;

  while ( inIdx < inLen AND outIdx < maxOutLen - 4 )
  {
    if ( alphabet NEQ CSCS_ALPHA_7_Bit OR
       ( gsm EQ GSM_ALPHA_Def AND !( in[inIdx] & 0x80 ) )     OR
       ( gsm EQ GSM_ALPHA_Int AND  ( in[inIdx] & 0x80 ) ) )
    {
      /* 2 bytes for convertion from GSM to UCS2 */
      out[outIdx++] = 0x00;
      out[outIdx++] = gsmToAsciiTable[in[inIdx] & 0x7F];      
    }

    inIdx++;
  }

  out[outIdx] = '\0';
  *outLen     = outIdx;
  
  return inIdx;

}
#endif
#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_smDtaToTe                |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the SM data in the format
            specified in Rec. GSM 07.05, message data parameter
            <data>, to the format used by the AT Command Interface.
*/
GLOBAL void utl_smDtaToTe ( UBYTE*  in,
                            USHORT  inLen,
                            UBYTE*  out,
                            USHORT  maxOutLen,
                            USHORT* outLen,
                            UBYTE   fo,
                            UBYTE   dcs )
{
  UBYTE alphabet = cmhSMS_getAlphabetPp ( dcs );

  if ( alphabet EQ CSCS_ALPHA_7_Bit AND
       (fo & TP_UDHI_MASK) EQ TP_UDHI_WITHOUT_HEADER )
  {
    utl_chsetFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def );
  }
  else if ( alphabet NEQ CSCS_ALPHA_7_Bit OR
            (fo & TP_UDHI_MASK) EQ TP_UDHI_WITH_HEADER )
  {
    utl_hexFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def, 
                     CSCS_ALPHA_8_Bit );
  }
  else
  {
    *outLen = MINIMUM ( inLen, maxOutLen - 1 );
    memcpy ( out, in,  *outLen );
    out[*outLen] = '\0';
  }
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_smDtaFromTe              |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the SM data in the format used
            by the AT Command Interface to the format specified in
            Rec. GSM 07.05, message data parameter <data>.
*/
GLOBAL void utl_smDtaFromTe ( UBYTE*  in,
                              USHORT  inLen,
                              UBYTE*  out,
                              USHORT* outLen,
#ifdef REL99
                              USHORT  outBufLen, 
#endif
                              UBYTE   fo,
                              UBYTE   dcs )
{
  UBYTE alphabet = cmhSMS_getAlphabetPp ( dcs );

  if ( alphabet EQ CSCS_ALPHA_7_Bit                AND
       ( fo & TP_UDHI_MASK ) EQ TP_UDHI_WITHOUT_HEADER )
  {
#ifdef REL99
    utl_chsetToGsm ( in, inLen, out, outLen, outBufLen, GSM_ALPHA_Def );
#else
    utl_chsetToGsm ( in, inLen, out, outLen, GSM_ALPHA_Def );
#endif

  }
  else if ( alphabet NEQ CSCS_ALPHA_7_Bit             OR
            ( fo & TP_UDHI_MASK ) EQ TP_UDHI_WITH_HEADER )
  {
    utl_hexToGsm ( in, inLen, out, outLen, GSM_ALPHA_Def, (T_ACI_CSCS_ALPHA)alphabet );
  }
  else
  {
    memcpy ( out, in, inLen );
    *outLen = inLen;
  }
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_ussdDtaFromTe            |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the USSD data in the format used
            by the AT Command Interface to the format specified in
            Rec. GSM 07.07.
*/
GLOBAL void utl_ussdDtaFromTe ( UBYTE*  in,
                                USHORT  inLen,
                                UBYTE*  out,
                                USHORT* outLen,
#ifdef REL99
                                USHORT  outBufLen,
#endif
                                UBYTE   dcs )
{
  /* Implements Measure 25 */
  UBYTE alphabet = cmh_getAlphabetCb ( dcs );

  if ( alphabet EQ CSCS_ALPHA_7_Bit )
  {
#ifdef REL99
    utl_chsetToGsm ( in, inLen, out, outLen, outBufLen, GSM_ALPHA_Def );
#else
    utl_chsetToGsm ( in, inLen, out, outLen, GSM_ALPHA_Def );
#endif

  }
  else
  {
    utl_hexToGsm ( in, inLen, out, outLen, GSM_ALPHA_Def, (T_ACI_CSCS_ALPHA)alphabet );
  }
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_ussdDtaToTe              |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the USSD data in the format
            specified in Rec. GSM 07.07 to the format used
            by the AT Command Interface.
*/

GLOBAL USHORT utl_ussdDtaToTe ( UBYTE*  in,
                              USHORT  inLen,
                              UBYTE*  out,
                              USHORT  maxOutLen,
                              USHORT* outLen,
                              UBYTE   dcs )
{
  /* Implements Measure 25 */
  UBYTE alphabet = cmh_getAlphabetCb ( dcs );
  if ( alphabet EQ CSCS_ALPHA_7_Bit )
  {
    return utl_chsetFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def );
  }
  else
  {
    return utl_hexFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def, (T_ACI_CSCS_ALPHA)alphabet );
  }
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_cbmDtaToTe               |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the CBM data in the format
            specified in Rec. GSM 07.05, message data parameter
            <data>, to the format used by the AT Command Interface.
*/
GLOBAL void utl_cbmDtaToTe ( UBYTE*  in,
                             USHORT  inLen,
                             UBYTE*  out,
                             USHORT  maxOutLen,
                             USHORT* outLen,
                             UBYTE   fo,
                             UBYTE   dcs )
{
  /* Implements Measure 25 */
  UBYTE alphabet = cmh_getAlphabetCb ( dcs );
  if ( alphabet EQ CSCS_ALPHA_7_Bit                AND
       ( fo & TP_UDHI_MASK ) EQ TP_UDHI_WITHOUT_HEADER )
  {
    utl_chsetFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def );
  }
  else if ( alphabet NEQ CSCS_ALPHA_7_Bit             OR
            ( fo & TP_UDHI_MASK ) EQ TP_UDHI_WITH_HEADER )
  {
    utl_hexFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def, (T_ACI_CSCS_ALPHA)alphabet );
  }
  else
  {
    *outLen = MINIMUM ( inLen, maxOutLen );
    memcpy ( out, in, *outLen );
  }
}
#endif

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_cvtGsmIra                |
+-------------------------------------------------------------------+

  PURPOSE : This function converts the characters of a string from
            the ACI internal GSM character set to the IRA character
            set or vice versa.
*/
GLOBAL BOOL utl_cvtGsmIra ( UBYTE*         in,
                            USHORT         inLen,
                            UBYTE*         out,
                            USHORT         outLen,
                            T_ACI_CSCS_DIR dir )
{
  USHORT inIdx  = 0;
  USHORT outIdx = 0;
  USHORT tblIdx;
  UBYTE  cvtdVal;

  TRACE_FUNCTION("utl_cvtGsmIra()");


  if ( inLen > outLen )
  {
    return ( FALSE );
  }

  if ( dir EQ CSCS_DIR_GsmToIra )
  {
    while ( inIdx < inLen )
    {
      tblIdx = 0;

      while ( tblIdx <= 0xFF                                             AND
              chset[CSCS_CHSET_Ira][tblIdx] NEQ (( UBYTE )in[inIdx] | 0x80 ))              
        tblIdx++;

      if ( tblIdx <= 0xFF )
      {
        out[outIdx] = ( UBYTE )tblIdx;
        outIdx++;
      }
      else
      {
        return ( FALSE );
      }

      inIdx++;
    }
  }
  else if ( dir EQ CSCS_DIR_IraToGsm )
  {
    for ( inIdx = 0; inIdx < inLen; inIdx++ )
    {
      cvtdVal = chset[CSCS_CHSET_Ira][( UBYTE ) in[inIdx]];
        
      if ( cvtdVal NEQ 0x00 )
      {
        out[outIdx] = ( CHAR ) cvtdVal & 0x7F;
        outIdx++;
      }
      else
      {
        return ( FALSE );
      }
    }

  }
  else
  {
    return ( FALSE );
  }

  return ( TRUE );
}


/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_binToHex                 |
+-------------------------------------------------------------------+

  PURPOSE : This function converts a binary string of bytes with a
            given length into an null terminated ASCII string
            representation.
*/
GLOBAL void utl_binToHex (UBYTE*         in,
                          SHORT          inLen,
                          CHAR*          out )
{
  SHORT idx = 0;
  UBYTE hNib;
  UBYTE lNib;

  while( idx < inLen )
  {
    hNib = (in[idx]&0xF0)>>4;

    if( hNib > 9 ) *out = (hNib-10)+0x41;
    else           *out = hNib + 0x30;

    out++;

    lNib = in[idx]&0x0F;

    if( lNib > 9 ) *out = (lNib-10)+0x41;
    else           *out = lNib + 0x30;

    out++;
    idx++;
  }
  *out = 0x0;
}


#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM              MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : utl_HexStrToBin              |
+-------------------------------------------------------------------+

  PURPOSE : This function converts a null terminated string of HEX
            values in a binary buffer.
            RETURN: byte count.
*/
GLOBAL USHORT utl_HexStrToBin (UBYTE         *in,
                               USHORT         inLen,
                               UBYTE         *out,
                               USHORT         outLen)
{
  USHORT inIdx = 0;
  USHORT outIdx = 0;
  UBYTE value;
  BOOL  hNib = TRUE;

  while ((inIdx < inLen) AND (outIdx < outLen))
  {
    if ((in[inIdx] >= 0x30) AND (in[inIdx] <= 0x39))
    {
      value = in[inIdx] - 0x30;
    }
    else if ((in[inIdx] >= 0x61) AND (in[inIdx] <= 0x66))
    {
      value = in[inIdx] - 0x61 + 0x0A;
    }
    else if ((in[inIdx] >= 0x41) AND (in[inIdx] <= 0x46))
    {
      value = in[inIdx] - 0x41 + 0x0A;
    }
    else
    {
      return (0);
    }

    if (hNib)
    {
      out[outIdx] = (value << 0x04) & 0xF0;
      hNib = FALSE;
    }
    else
    {
      out[outIdx] |= value & 0x0F;
      hNib = TRUE;
      outIdx++;
    }
    inIdx++;
  }

  return (outIdx);
}
#endif

#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : trace_cmd_line               |
+-------------------------------------------------------------------+

  PURPOSE : This function trace the command line and check
            this string for % character
*/

GLOBAL void trace_cmd_line (char *prefix, char *output, UBYTE srcId, USHORT output_len)
{
  char trcBuf[80];
  int dst_i;

  dst_i = sprintf (trcBuf, "%s(Src %d)[lth %d]", (prefix) ? prefix : "", srcId, output_len);

  strncpy(&trcBuf[dst_i], output, 79-dst_i);
  trcBuf[79] = '\0';

  if (trcBuf[76])
  {
    trcBuf[76] = trcBuf[77] = trcBuf[78] = '.';  /* add trailing "..." if string is >=76 */
  }

  /* Send the trace if either EVENT or CLASS8 is turned on */
  TRACE_USER_CLASS_P1(TC_EVENT|TC_USER8, "%s",trcBuf);
}
#endif


#ifdef FF_ATI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : ACI_UTIL                     |
| STATE   : code             ROUTINE : trace_cmd_state              |
+-------------------------------------------------------------------+

  PURPOSE : This function trace the command line state
*/

GLOBAL void trace_cmd_state (UBYTE            srcId, 
                             T_ATI_CMD_STATE  old_state, 
                             T_ATI_CMD_STATE  new_state)
{
  char trcBuf[50];

  if (old_state EQ new_state)
  {
    return;
  }

  sprintf (trcBuf, "(Src %d) cmd_state: ", srcId );

  switch (old_state)
  {
    case (CMD_IDLE):
      strcat (trcBuf, "CMD_IDLE -> ");
      break;
    case (CMD_TYPING):
      strcat (trcBuf, "CMD_TYPING -> ");
      break;
    case (CMD_RUNNING):
      strcat (trcBuf, "CMD_RUNNING -> ");
      break;
    default:
      strcat (trcBuf, "CMD_UNKNOWN ! ");
  }
  
  switch (new_state)
  {
    case (CMD_IDLE):
      strcat (trcBuf, "CMD_IDLE");
      break;
    case (CMD_TYPING):
      strcat (trcBuf, "CMD_TYPING");
      break;
    case (CMD_RUNNING):
      strcat (trcBuf, "CMD_RUNNING");
      break;
    default:
      strcat (trcBuf, "CMD_UNKNOWN !");
  }

  TRACE_EVENT_P1("%s",trcBuf);
}
#endif

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
| STATE   : code                        ROUTINE : toa_merge          |
+--------------------------------------------------------------------+

  PURPOSE : builds type of address octet from TOA structure

*/

GLOBAL UBYTE toa_merge (T_ACI_TOA type)
{

return   ((type.ton << 4) & 0xF0) 
       | ( type.npi       & 0x0F)
       | 0x80;
}



#ifdef GPRS
/*
  +-----------------------------------------------------------------------------
  | Function    : utl_create_pco
  +-----------------------------------------------------------------------------
  | Description : The function create_pco() creates protocol configuration
  |               options needed to activate a PDPcontext.
  |
  | Parameters  : buffer      - buffer to write the PCOs
  |               length      - on call: buffer size; on return: written bytes
  |               content     - mask to specify the PCO content
  |               config_prot - used configuration protocol (currently PPP)
  |               auth_prot   - authentication protocol (currently PAP)
  |               user_name   - string with the user name
  |               password    - string with the password
  |               dns1        - requested primary DNS address
  |               dns2        - requested secondary DNS address
  |
  | Return      :  0 - operation successful
  |               -1 - operation fails
  |
  +-----------------------------------------------------------------------------
*/
GLOBAL int utl_create_pco (UBYTE*  buffer,
                           USHORT* length,
                           ULONG   content,
                           UBYTE   config_prot,
                           USHORT  auth_prot,
                           UBYTE*  user_name,
                           UBYTE*  password,
                           ULONG   dns1,
                           ULONG   dns2)
{
  USHORT  size;
  USHORT  temp_len;
  USHORT  len_user;
  USHORT  len_pwd;
  USHORT  written;
  UBYTE*  pos;
  UBYTE*  len_pos1;
  UBYTE*  len_pos2;

  TRACE_FUNCTION( "create_pco" );

  /*
   * store buffer size
   */
  size = *length;
  /*
   * initialize values
   */
  *length = 0;
  written = 0;
  pos     = buffer;
  /*
   * calculate if requested content is writeable
   */
  temp_len = 1;
  if(content & ACI_PCO_CONTENTMASK_AUTH)
  {
    len_user = strlen((char*)user_name);
    len_pwd  = strlen((char*)password);
    temp_len+= ACI_PCO_PAP_OVERHEAD + len_user + len_pwd;
  }
  if((content & ACI_PCO_CONTENTMASK_DNS1) ||
     (content & ACI_PCO_CONTENTMASK_DNS2))
  {
    temp_len+= ACI_PCO_IPCP_OVERHEAD;
    if(content & ACI_PCO_CONTENTMASK_DNS1)
      temp_len+= ACI_PCO_IPCP_LENGTH_DNS1;
    if(content & ACI_PCO_CONTENTMASK_DNS2)
      temp_len+= ACI_PCO_IPCP_LENGTH_DNS2;
  }
  TRACE_EVENT_P2("temp_len=%d size=%d", temp_len, size);
  if(temp_len > size)
  {
    /*
     * content is to long
     */
    return -1;
  }
  /*
   * set configuration protocol identifier
   */
  *pos = 0x80 | config_prot;
  pos++;
  written++;

  /*
   * authentication
   */
  if(content & ACI_PCO_CONTENTMASK_AUTH)
  {
    /*
     * set authentication protocol
     */
    *pos = (UBYTE)((auth_prot >> 8) & 0x00ff);
    pos++;
    written++;
    *pos = (UBYTE)(auth_prot        & 0x00ff);
    pos++;
    written++;
    /*
     * store first length position
     */
    len_pos1 = pos;
    pos++;
    written++;
    /*
     * Code field
     */
    *pos = ACI_PCO_PAP_AUTH_REQ;
    pos++;
    written++;
    /*
     * Identifier field (just some value)
     */
    *pos = 0x01;
    pos++;
    written++;
    /*
     * Length field (store length position)
     */
    *pos = 0x00;
    pos++;
    written++;
    len_pos2 = pos;
    pos++;
    written++;
    /*
     * User Name Length field
     */
    *pos = (UBYTE)(/*lint -e(644) */len_user & 0x00ff);
    pos++;
    written++;
    /*
     * User Name field
     */
    memcpy(pos, user_name, len_user);
    pos    += len_user;
    written+= len_user;
    /*
     * Password Length field
     */
    *pos = (UBYTE)(/*lint -e(644) */len_pwd & 0x00ff);  
    pos++;
    written++;
    /*
     * Password field
     */
    memcpy(pos, password, len_pwd);
    pos    += len_pwd;
    written+= len_pwd;
    /*
     * fill length fields
     */
    *len_pos1 = (UBYTE)(pos - len_pos1 - 1);
    *len_pos2 = *len_pos1;
  }
  /*
   * DNS addresses
   */
  if((content & ACI_PCO_CONTENTMASK_DNS1) ||
     (content & ACI_PCO_CONTENTMASK_DNS2))
  {
    /*
     * set IPCP protocol
     */
    *pos = ACI_PCO_IPCP_PROT_MSB;
    pos++;
    written++;
    *pos = ACI_PCO_IPCP_PROT_LSB;
    pos++;
    written++;
    /*
     * store first length position
     */
    len_pos1 = pos;
    pos++;
    written++;
    /*
     * Code field
     */
    *pos = ACI_PCO_IPCP_CONF_REQ;
    pos++;
    written++;
    /*
     * Identifier field (just some value)
     */
    *pos = 0x01;
    pos++;
    written++;
    /*
     * Length field (store length position)
     */
    *pos = 0x00;
    pos++;
    written++;
    len_pos2 = pos;
    pos++;
    written++;
    /*
     * primary DNS address
     */
    if(content & ACI_PCO_CONTENTMASK_DNS1)
    {
      /*
       * Type field
       */
      *pos = ACI_PCO_IPCP_TYPE_DNS1;
      pos++;
      written++;
      /*
       * Length field
       */
      *pos = ACI_PCO_IPCP_LENGTH_DNS1;
      pos++;
      written++;
      /*
       * primary DNS address
       */
      *pos = (UBYTE)((dns1 >> 24) & 0x000000ff);
      pos++;
      written++;
      *pos = (UBYTE)((dns1 >> 16) & 0x000000ff);
      pos++;
      written++;
      *pos = (UBYTE)((dns1 >>  8) & 0x000000ff);
      pos++;
      written++;
      *pos = (UBYTE)(dns1         & 0x000000ff);
      pos++;
      written++;
    }
    /*
     * secondary DNS address
     */
    if(content & ACI_PCO_CONTENTMASK_DNS2)
    {
      /*
       * Type field
       */
      *pos = ACI_PCO_IPCP_TYPE_DNS2;
      pos++;
      written++;
      /*
       * Length field
       */
      *pos = ACI_PCO_IPCP_LENGTH_DNS2;
      pos++;
      written++;
      /*
       * primary DNS address
       */
      *pos = (UBYTE)((dns2 >> 24) & 0x000000ff);
      pos++;
      written++;
      *pos = (UBYTE)((dns2 >> 16) & 0x000000ff);
      pos++;
      written++;
      *pos = (UBYTE)((dns2 >>  8) & 0x000000ff);
      pos++;
      written++;
      *pos = (UBYTE)(dns2         & 0x000000ff);
      pos++;
      written++;
    }
    /*
     * fill length fields
     */
    *len_pos1 = (UBYTE)(pos - len_pos1 - 1);
    *len_pos2 = *len_pos1;
  }
  /*
   * pass written bytes to caller
   */
  *length = written;
  /*
   * return result
   */
  return 0;
} /* utl_create_pco() */



/*
  +-----------------------------------------------------------------------------
  | Function    : utl_analyze_pco
  +-----------------------------------------------------------------------------
  | Description : The function analyze_pco() analyzes the response protocol
  |               configuration from the network
  |
  | Parameters  : buffer  - buffer with the response PCOs
  |               length  - length of PCOs
  |               dns1    - returns primary DNS address
  |               dns2    - returns secondary DNS address
  |               gateway - returns Gateway address
  |
  | Return      :  0 - operation successful
  |               -1 - operation fails
  |
  +-----------------------------------------------------------------------------
*/
GLOBAL int utl_analyze_pco (UBYTE* buffer,
                            USHORT length,
                            ULONG* dns1,
                            ULONG* dns2,
                            ULONG* gateway)
{
  UBYTE*  pos;
  USHORT  pos_len;
  USHORT  packet_len;
  USHORT  start_pos;
  USHORT  dist_to_next;
  UBYTE   type_len;

  TRACE_FUNCTION( "utl_analyze_pco" );

  /*
   * initialize values
   */
  pos      = buffer;
  pos_len  = 0;
  *dns1    = 0;
  *dns2    = 0;
  *gateway = 0;
  /*
   * check configuration protocol
   */
  if( (length <= pos_len) ||
      !(*pos & 0x80) )
  {
    return -1;
  }

#if 0
  /* Table 10.5.154/3GPP TS 24.008 states:
       "All other values are interpreded as PPP in this version of the protocol.
     so the next check should not be performed
   */
  if((*pos & 0x07) NEQ ACI_PCO_CONFIG_PROT_PPP)
  {
    /*
     * configuration protocol is not PPP
     */
    return 0;
  }
#endif

  pos++;
  pos_len++;
  
  /*
   * search for IPCP packet
   */
  while(length > (pos_len + ACI_PCO_IPCP_OVERHEAD))
  {
    /*
     * initialize distance to next packet
     */
    dist_to_next = *(pos + 2) + 3;
    /*
     * check for IPCP packet
     */
    if((*pos       EQ ACI_PCO_IPCP_PROT_MSB) AND
       (*(pos + 1) EQ ACI_PCO_IPCP_PROT_LSB))
    {
      /*
       * check for correct length field
       */
      pos         += 2;
      pos_len     += 2;
      dist_to_next-= 2;
      packet_len   = *(pos + 3);
      packet_len   = packet_len << 8;
      packet_len  += *(pos + 4);
      if((packet_len EQ *pos) AND
         (length > (pos_len + packet_len)))
      {
        pos++;
        pos_len++;
        dist_to_next--;
        /*
         * check of code field
         */
        start_pos = pos_len;
        switch(*pos)
        {
          case ACI_PCO_IPCP_CONF_REQ:
            /*
             * search for Gateway address
             */
            pos    += 4;
            pos_len+= 4;
            while((pos_len + 1 - start_pos) < packet_len)
            {
              type_len = *(pos + 1);
              if((*pos     EQ ACI_PCO_IPCP_TYPE_IP) AND
                 (type_len EQ ACI_PCO_IPCP_LENGTH_IP) AND
                 ((pos_len +
                   ACI_PCO_IPCP_LENGTH_IP -
                   start_pos) <= packet_len))
              {
                *gateway = *(pos + 2);
                *gateway = ((*gateway) << 8);
                *gateway+= *(pos + 3);
                *gateway = ((*gateway) << 8);
                *gateway+= *(pos + 4);
                *gateway = ((*gateway) << 8);
                *gateway+= *(pos + 5);
              }
              pos    += type_len;
              pos_len+= type_len;
            }
            if((pos_len - start_pos) <= packet_len)
            {
              dist_to_next = packet_len + start_pos - pos_len;
            }
            else
            {
              dist_to_next = 0;
              pos         -= (pos_len - start_pos - packet_len);
              pos_len     -= (pos_len - start_pos - packet_len);
            }
            break;

          case ACI_PCO_IPCP_CONF_ACK:
          case ACI_PCO_IPCP_CONF_NAK:
            /*
             * search for DNS addresses
             */
            pos    += 4;
            pos_len+= 4;
            while((pos_len + 1 - start_pos) < packet_len)
            {
              type_len = *(pos + 1);
              if((*pos     EQ ACI_PCO_IPCP_TYPE_DNS1) AND
                 (type_len EQ ACI_PCO_IPCP_LENGTH_DNS1) AND
                 ((pos_len +
                   ACI_PCO_IPCP_LENGTH_DNS1 -
                   start_pos) <= packet_len))
              {
                *dns1 = *(pos + 2);
                *dns1 = ((*dns1) << 8);
                *dns1+= *(pos + 3);
                *dns1 = ((*dns1) << 8);
                *dns1+= *(pos + 4);
                *dns1 = ((*dns1) << 8);
                *dns1+= *(pos + 5);
              }
              else if((*pos     EQ ACI_PCO_IPCP_TYPE_DNS2) AND
                      (type_len EQ ACI_PCO_IPCP_LENGTH_DNS2) AND
                      ((pos_len +
                        ACI_PCO_IPCP_LENGTH_DNS2 -
                        start_pos) <= packet_len))
              {
                *dns2 = *(pos + 2);
                *dns2 = ((*dns2) << 8);
                *dns2+= *(pos + 3);
                *dns2 = ((*dns2) << 8);
                *dns2+= *(pos + 4);
                *dns2 = ((*dns2) << 8);
                *dns2+= *(pos + 5);
              }
              pos    += type_len;
              pos_len+= type_len;
            }
            if((pos_len - start_pos) <= packet_len)
            {
              dist_to_next = packet_len + start_pos - pos_len;
            }
            else
            {
              dist_to_next = 0;
              pos         -= (pos_len - start_pos - packet_len);
              pos_len     -= (pos_len - start_pos - packet_len);
            }
            break;
        }
      }
    }
    /*
     * go to next packet
     */
    pos_len+= dist_to_next;
    pos    += dist_to_next;
  }
  /*
   * return
   */
  return 0;
} /* utl_analyze_pco() */




GLOBAL int utl_strcasecmp (const char *s1, const char *s2)
{
  char c1, c2;
  int i;

  int len1 = (s1 EQ NULL) ? 0 : strlen(s1);
  int len2 = (s2 EQ NULL) ? 0 : strlen(s2);

  if (len1 > len2) 
  {
    return (1);
  }
  if(len1 < len2) 
  {
    return (-1);
  }
  for (i = 0; i < len1; i++)
  {
    c1 = s1[i]; /*lint !e613 (Warning -- 613: Possible use of null pointer 's1' in left argument to operator '[' [Reference: file condat\ms\src\aci\aci_util.c: line 2349] ) */
    c2 = s2[i]; /*lint !e613 (Warning -- 613: Possible use of null pointer 's2' in left argument to operator '[' [Reference: file condat\ms\src\aci\aci_util.c: line 2349] ) */
    if (c1 EQ c2)
    {
      continue ;
    }
    if (c1 >= 'a' AND c1 <= 'z')
    {
      c1 = c1 - ('a'-'A');
    }
    if (c2 >= 'a' AND c2 <= 'z')
    {
      c2 = c2 - ('a'-'A');
    }
    if (c1 NEQ c2)
    {
      return (1);
    }
  }
  return (0);
}


#endif /* GPRS */



#if defined (FF_ATI) || defined (FF_BAT)

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : ACI_UTIL                 |
| STATE   : code                  ROUTINE : rci_display_USSD         |
+--------------------------------------------------------------------+

  PURPOSE : used by rCI_PlusCUSD and utl_cb_percentKSIR
*/
GLOBAL void rci_display_USSD (UBYTE            srcId,
                              T_ACI_CUSD_MOD   mode,
                              UBYTE            *ussd_str,
                              UBYTE            ussd_len,
                              BOOL             cvtStr,
                              SHORT            dcs )
{
  SHORT  pos = 0;
  USHORT chunksize;
  USHORT lenCvtdStr;
  CHAR sa[80];


  TRACE_FUNCTION("rci_display_USSD()");

  pos = sprintf(sa,"+CUSD: ");

  if (mode NEQ CUSD_MOD_NotPresent)
  {
    pos += sprintf(sa+pos,"%d,",mode);
  }
  else
    pos += sprintf(sa+pos,",");

  if(ussd_str NEQ NULL)
  {
    pos += sprintf(sa+pos,"\"");    /* beginning double quote */
    while (ussd_len)
    {
      if( cvtStr EQ CONVERT_STRING )
      {
        chunksize = utl_ussdDtaToTe( ussd_str,
                         (USHORT)ussd_len,
                         (UBYTE*)(sa + pos),
                         sizeof(sa)-pos,
                         &lenCvtdStr,
                         (UBYTE)dcs );

        pos += lenCvtdStr;
      }
      else
      {
        /*
        *   How much space do we have left in the output array?
        */
        chunksize=(sizeof(sa)-pos)-1;

        if (ussd_len<chunksize)
        {
          /*
          *   Remaining data fits within the output array.
          */
          chunksize=ussd_len;
        }
        else if (chunksize>3)
        {
          /*
          *   If the remaining data will not fit in the output
          *   array, and we have more than 3 bytes available (which
          *   we will), make sure that the amount of data output
          *   divides by 4. This is so we don't split UCS2 characters
          *   between two lines of output.
          */
          chunksize &= ~0x3;
        }

        memcpy(sa+pos,ussd_str,chunksize);
        
        pos += chunksize;

        sa[pos]=0;
      }
      ussd_len-=chunksize;
      ussd_str+=chunksize;

      if (ussd_len OR (sizeof(sa)-pos) < 10)
      {
#ifdef _SIMULATION_
        io_sendMessage(srcId, sa, ATI_NORMAL_OUTPUT);   /* append CR+LF only for testcase */
#else
        io_sendMessage(srcId, sa, ATI_ECHO_OUTPUT);     /* normal output a chunk */
#endif
        pos=0;
        memset(sa, 0, 80);
      }
    }

    pos+=sprintf(sa+pos,"\",");   /* ending double quote */

    if (dcs EQ ACI_NumParmNotPresent)
    {
      /* see 07.07: default is 0 */
      dcs = 0;
    }

    pos+=sprintf(sa+pos,"%d",dcs);
  }
  
  ci_remTrailCom(sa, pos);
  io_sendMessage(srcId, sa, ATI_NORMAL_OUTPUT);
}

/*
 ****************************************************************
 */
LOCAL void utl_cvtCLIRStat ( UBYTE clirOpt,
                             UBYTE ssSt,
                             T_ACI_CLIR_STAT *clirStat )
{
  if ( clirOpt EQ KSD_CO_NOT_VALID )
  {
    /* SS Status of class - T_ACI_KSD_ST */
    if ( ssSt EQ KSD_ST_NOT_VALID )
      *clirStat = CLIR_STAT_Unknown;
    else if ( ssSt & SSS_P )
      *clirStat = CLIR_STAT_Permanent;
    else
      *clirStat = CLIR_STAT_NotProv;
  }
  else
  {
    switch ( clirOpt )
    {
      case( CLIR_OPT_PERMANENT ):
        *clirStat = CLIR_STAT_Permanent;
        break;

      case( CLIR_OPT_TEMPORARY ):
        *clirStat = CLIR_STAT_RestrictTemp;
        break;

      case( CLIR_OPT_ALLOWED ):
        *clirStat = CLIR_STAT_AllowTemp;
        break;

      default:
        *clirStat = CLIR_STAT_Unknown;
        break;
    }
  }
}

/*
 ****************************************************************
 */
LOCAL  void utl_cb_ccbs( UBYTE srcId, T_ACI_KSIR * ksStat )
{
  T_ACI_CCBS_SET *CCBS_Setting = NULL;

  T_ACI_CCBS_STAT status;
  T_basicService basicServ;
  int i;
  T_CC_FEAT *ccbs_features;

  TRACE_FUNCTION("utl_cb_ccbs()");

  /* SS Status of CCBS */
  if (ksStat->ir.rKSCC.ssSt EQ KSD_ST_NOT_VALID)
    status = CCBS_STAT_NotPresent;
  else if (!(ksStat->ir.rKSCC.ssSt & SSS_P))
    status = CCBS_STAT_NotProvisioned;
  else if (ksStat->ir.rKSCC.ssSt & SSS_A)
    status = CCBS_STAT_Active;
  else
    status = CCBS_STAT_Provisioned;

  ACI_MALLOC(CCBS_Setting, sizeof(T_ACI_CCBS_SET));

  /* CCBS_Setting infos */
  if (!ksStat->ir.rKSCC.c_ccFeatLst)
  {
    TRACE_EVENT("KSD_CMD_CCBS: no feature list");

    if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
    {
      rCI_PercentCCBS(CCBS_IND_IrgtResult,
                      status,
                      CCBS_Setting,
                      TRUE);
    }
#ifdef FF_BAT
    else /* CMD_MODE_BAT */
    {
      rBAT_PercentCCBS(CCBS_IND_IrgtResult,
                       status,
                       CCBS_Setting,
                       TRUE);
   }
#endif
    return;
  }

  for (i=0; i<ksStat->ir.rKSCC.c_ccFeatLst; i++)
  {
    ccbs_features = ksStat->ir.rKSCC.ccFeatLst + i;

    memcpy( CCBS_Setting->number, ccbs_features->num, MAX_B_SUBSCR_NUM_LEN);
    memcpy( CCBS_Setting->subaddr, ccbs_features->sub, MAX_SUBADDR_LEN);

    CCBS_Setting->type.npi   = ccbs_features->npi NEQ 0xFF 
                               ? (T_ACI_TOA_NPI)ccbs_features->npi 
                               : NPI_NotPresent;
    CCBS_Setting->type.ton   = ccbs_features->ton NEQ 0xFF 
                               ? (T_ACI_TOA_TON)ccbs_features->ton 
                               : TON_NotPresent;
    CCBS_Setting->satype.tos = ccbs_features->tos NEQ 0xFF 
                               ? (T_ACI_TOS_TOS)ccbs_features->tos 
                               : TOS_NotPresent;
    CCBS_Setting->satype.oe  = ccbs_features->oe NEQ 0xFF 
                               ? (T_ACI_TOS_OE)ccbs_features->oe 
                               : OE_NotPresent;

    if( ccbs_features->bsTp EQ BS_TELE_SRV )
    {
      basicServ.v_teleservice = TRUE;
      basicServ.v_bearerService = FALSE;
      basicServ.teleservice = ccbs_features->bsCd;
    }
    else /* if( p_servType EQ BS_BEAR_SRV ) */
    {
      basicServ.v_bearerService = TRUE;
      basicServ.v_teleservice = FALSE;
      basicServ.bearerService = ccbs_features->bsCd;
    }
    
    CCBS_Setting->class_type = cmhSS_GetClass( &basicServ );

    CCBS_Setting->idx = ccbs_features->idx NEQ 0xFF 
                        ? ccbs_features->idx 
                        : ACI_NumParmNotPresent;
    
    CCBS_Setting->alrtPtn = ALPT_NotPresent;
    
    if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
    {
      rCI_PercentCCBS(CCBS_IND_IrgtResult,
                      status,
                      CCBS_Setting,
                      TRUE);
    }
#ifdef FF_BAT
    else /* CMD_MODE_BAT */
    {
      rBAT_PercentCCBS(CCBS_IND_IrgtResult,
                      status,
                      CCBS_Setting,
                      TRUE);
    }
#endif
  }

  ACI_MFREE( CCBS_Setting );
}

/*
 ****************************************************************
 */
LOCAL void utl_cb_callwaiting( UBYTE srcId, T_ACI_KSIR *ksStat )
{
  T_ACI_CLSSTAT   classStat;
  UBYTE           idx;
  T_ACI_TOA       type;

  TRACE_FUNCTION("utl_cb_callwaiting()");

  if ( ksStat->ir.rKSCW.opCd NEQ KSD_OP_IRGT )
    return;

  /* SS Status of class - T_ACI_KSD_ST */
  if ( ksStat->ir.rKSCW.ssSt EQ KSD_ST_NOT_VALID )
  {
    classStat.status = STATUS_NotPresent;
  }
  else if ( ksStat->ir.rKSCW.ssSt & KSD_ST_A )
  {
    classStat.status = STATUS_Active;
  }
  else
  {
    classStat.status = STATUS_NotActive;
  }

  /* init parameter type: */
  type.npi = NPI_NotPresent;
  type.ton = TON_NotPresent;

  for( idx = 0; idx < ksStat->ir.rKSCW.c_cwBSGLst; idx++ )
  {
    /* type of class */
    classStat.class_type = cmhSS_GetClassType(ksStat->ir.rKSCW.cwBSGLst[idx].bsTp,
                                              ksStat->ir.rKSCW.cwBSGLst[idx].bsCd);
    if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
    {
    }
    else /* CMD_MODE_BAT */
    {
    }
    
    rCI_PlusCCWA(&classStat,"\0", &type, MNCC_PRES_NOT_PRES, CLASS_NotPresent, NULL);
  }
}

/*
 ****************************************************************
 */
LOCAL  void utl_cb_lineidentification( UBYTE srcId, T_ACI_KSIR * ksStat )
{
  T_ACI_CLIP_STAT clipStat;
  T_ACI_CLIR_MOD  clirMode;
  T_ACI_CLIR_STAT clirStat;
  T_ACI_COLP_STAT colpStat;
  T_ACI_COLR_STAT colrStat;

  TRACE_FUNCTION("utl_cb_lineidentification()");

  if ( ksStat->ir.rKSCL.opCd NEQ KSD_OP_IRGT )
    return;

  switch ( ksStat->ir.rKSCL.ssCd )
  {
    case KSD_SS_CLIP:
     {
      /* SS Status of class - T_ACI_KSD_ST */
      if ( ksStat->ir.rKSCL.ssSt EQ KSD_ST_NOT_VALID )
        clipStat = CLIP_STAT_Unknown;
      else if ( ksStat->ir.rKSCL.ssSt & SSS_P )
        clipStat = CLIP_STAT_Prov;
      else
        clipStat = CLIP_STAT_NotProv;

      if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
      {
        rCI_PlusCLIP ( clipStat, NULL, NULL, MNCC_PRES_NOT_PRES, NULL, NULL, NULL );
      }
#ifdef FF_BAT
      else /* CMD_MODE_BAT */
      {
        rBAT_PlusCLIP ( clipStat, NULL, NULL, MNCC_PRES_NOT_PRES, NULL, NULL, NULL );
      }
#endif
      break;
    }
    case KSD_SS_CLIR:
    {
      clirMode = ksStat->ir.rKSCL.mode;
      utl_cvtCLIRStat(ksStat->ir.rKSCL.clirOpt,
                      ksStat->ir.rKSCL.ssSt,
                      &clirStat);
      if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
      {
        rCI_PlusCLIR (clirMode, clirStat);
      }
#ifdef FF_BAT
      else /* CMD_MODE_BAT */
      {
        rBAT_PlusCLIR (clirMode, clirStat);
      }
#endif
      break;
    } 
    case KSD_SS_COLP:
    {
      /* SS Status of class - T_ACI_KSD_ST */
      if ( ksStat->ir.rKSCL.ssSt EQ KSD_ST_NOT_VALID )
        colpStat = COLP_STAT_Unknown;
      else if ( ksStat->ir.rKSCL.ssSt & SSS_P )
        colpStat = COLP_STAT_Prov;
      else
        colpStat = COLP_STAT_NotProv;

      if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
      {
        rCI_PlusCOLP ( colpStat, NULL, NULL, NULL, NULL, NULL );
      }
#ifdef FF_BAT
      else /* CMD_MODE_BAT */
      {
        rBAT_PlusCOLP ( colpStat, NULL, NULL, NULL, NULL, NULL );
      }
#endif
      break;
    } 
    case KSD_SS_COLR:
    {
      /* SS Status of class - T_ACI_KSD_ST */
      if ( ksStat->ir.rKSCL.ssSt EQ KSD_ST_NOT_VALID )
        colrStat = COLR_STAT_Unknown;
      else if ( ksStat->ir.rKSCL.ssSt & SSS_P )
        colrStat = COLR_STAT_Prov;
      else
        colrStat = COLR_STAT_NotProv;
      
      if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
      {
        rCI_PercentCOLR(colrStat);
      }
#ifdef FF_BAT
      else /* CMD_MODE_BAT */
      {
        rBAT_PercentCOLR(colrStat);
      } 
#endif
      break;
    }
  }
}

/*
 ****************************************************************
 */
LOCAL  void utl_cb_callforwarding( UBYTE srcId, T_ACI_KSIR * ksStat )
{
  T_ACI_CCFC_SET  ccfcSetting;
  UBYTE           idx;

  TRACE_FUNCTION("utl_cb_callforwarding()");

  if ( ksStat->ir.rKSCF.opCd NEQ KSD_OP_IRGT )
    return;

  for( idx = 0; idx < ksStat->ir.rKSCF.c_cfFeatLst; idx++ )
  {
    /* SS Status of class - T_ACI_KSD_ST */
    if ( ksStat->ir.rKSCF.cfFeatLst[idx].ssSt EQ KSD_ST_NOT_VALID )
      ccfcSetting.clsstat.status = STATUS_NotPresent;
    else if ( ksStat->ir.rKSCF.cfFeatLst[idx].ssSt & SSS_A )
      ccfcSetting.clsstat.status = STATUS_Active;
    else
      ccfcSetting.clsstat.status = STATUS_NotActive;
    /* type of class */
    if ( ksStat->ir.rKSCF.cfFeatLst[idx].bsTp EQ KSD_BS_TP_None
     AND ksStat->ir.rKSCF.cfFeatLst[idx].bsCd EQ KSD_BS_TeleBearerUnknown)
    {
      if (ccfcSetting.clsstat.status EQ STATUS_NotPresent)
        ccfcSetting.clsstat.class_type = CLASS_None;
      else
        ccfcSetting.clsstat.class_type = CLASS_VceDatFax;
    }
    else
      ccfcSetting.clsstat.class_type = cmhSS_GetClassType(ksStat->ir.rKSCF.cfFeatLst[idx].bsTp,
                                                           ksStat->ir.rKSCF.cfFeatLst[idx].bsCd);
    /* number */
    strcpy(ccfcSetting.number, (char *)ksStat->ir.rKSCF.cfFeatLst[idx].num);
    if ( !strlen ( ccfcSetting.number ))
    {
      ccfcSetting.type.npi   = NPI_NotPresent;
      ccfcSetting.type.ton   = TON_NotPresent;
      ccfcSetting.subaddr[0] = 0x0;
      ccfcSetting.satype.tos = TOS_NotPresent;
      ccfcSetting.satype.oe  = OE_NotPresent;
      ccfcSetting.time       = ACI_NumParmNotPresent;
    }
    else
    {
      T_CF_FEAT *cfFeat = &ksStat->ir.rKSCF.cfFeatLst[idx];
      /* toa */
      ccfcSetting.type.ton = cfFeat->ton NEQ 0xFF 
                             ? (T_ACI_TOA_TON)cfFeat->ton 
                             : TON_NotPresent;
      ccfcSetting.type.npi = cfFeat->npi NEQ 0xFF 
                             ? (T_ACI_TOA_NPI)cfFeat->npi 
                             : NPI_NotPresent;
      /* subaddr */
      strcpy(ccfcSetting.subaddr, (char *)ksStat->ir.rKSCF.cfFeatLst[idx].sub);
      /* tos */
      ccfcSetting.satype.tos = cfFeat->tos NEQ 0xFF
                               ? (T_ACI_TOS_TOS)cfFeat->tos
                               : TOS_NotPresent;
      ccfcSetting.satype.oe  = cfFeat->oe NEQ 0xFF 
                               ? (T_ACI_TOS_OE)cfFeat->oe 
                               : OE_NotPresent;
      /* time */
      ccfcSetting.time       = cfFeat->time NEQ 0xFF 
                               ? cfFeat->time 
                               : ACI_NumParmNotPresent;
    }
    if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
    {
      rCI_PlusCCFC (&ccfcSetting);
    }
#ifdef FF_BAT
    else
    {
      rBAT_PlusCCFC (&ccfcSetting);
    }
#endif
  }
}

/*
 ****************************************************************
 */
LOCAL  void utl_cb_callbarring( UBYTE srcId, T_ACI_KSIR * ksStat )
{
  T_ACI_CLSSTAT   classStat;
  UBYTE           idx;

  TRACE_FUNCTION("utl_cb_callbarring()");

  if (ksStat->ir.rKSCB.opCd NEQ KSD_OP_IRGT)
  {
    return;
  }
  for (idx = 0; idx < ksStat->ir.rKSCB.c_cbInfoLst; idx++)
  {
    /* type of class */
    classStat.class_type = cmhSS_GetCbClassType(ksStat->ir.rKSCB.cbInfoLst[idx].bsTp,
                                                 ksStat->ir.rKSCB.cbInfoLst[idx].bsCd);

    /* SS Status of class */
    if (classStat.class_type EQ CLASS_VceDatFaxSms 
     OR classStat.class_type EQ CLASS_None)
    {
      classStat.status = STATUS_NotActive;
    }
    else
    {
      classStat.status = STATUS_Active;
    }
    if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
    {
      rCI_PlusCLCK(&classStat);
    }
#ifdef FF_BAT
    else /* CMD_MODE_BAT */
    {
      rBAT_PlusCLCK(&classStat);
    }
#endif
  }
}

/*
 ****************************************************************
 */
LOCAL  void utl_cb_imei( UBYTE srcId, T_ACI_KSIR * ksStat )
{
  TRACE_FUNCTION("utl_cb_imei()");

  sprintf ( g_sa,
            "%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d",
            (ksStat->ir.rKSIMEI.tac1 >> 4) & 0x0F,
             ksStat->ir.rKSIMEI.tac1 & 0x0F,

            (ksStat->ir.rKSIMEI.tac2 >> 4) & 0x0F,
             ksStat->ir.rKSIMEI.tac2 & 0x0F,

            (ksStat->ir.rKSIMEI.tac3 >> 4) & 0x0F,
             ksStat->ir.rKSIMEI.tac3 & 0x0F,

            (ksStat->ir.rKSIMEI.fac  >> 4) & 0x0F,
             ksStat->ir.rKSIMEI.fac  & 0x0F,

            (ksStat->ir.rKSIMEI.snr1 >> 4) & 0x0F,
             ksStat->ir.rKSIMEI.snr1 & 0x0F,

            (ksStat->ir.rKSIMEI.snr2 >> 4) & 0x0F,
             ksStat->ir.rKSIMEI.snr2 & 0x0F,

            (ksStat->ir.rKSIMEI.snr3 >> 4) & 0x0F,
             ksStat->ir.rKSIMEI.snr3 & 0x0F,

             ksStat->ir.rKSIMEI.cd,
            (ksStat->ir.rKSIMEI.svn  >> 4) & 0x0F,
             ksStat->ir.rKSIMEI.svn  & 0x0F );

  io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_UTIL           |
| STATE   : code                        ROUTINE :                    |
+--------------------------------------------------------------------+

  PURPOSE : handles PercentKSIR call back

*/
GLOBAL void utl_cb_percentKSIR (U8 srcId, T_ACI_KSIR *ksStat)
{
#ifdef FF_BAT
  T_ACI_USSD_DATA  ussd;
#endif /* FF_BAT */

  TRACE_FUNCTION("utl_cb_percentKSIR()");
  
  switch (ksStat->ksdCmd)
  {
    case (KSD_CMD_IMEI):
      if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
      {
        utl_cb_imei(srcId, ksStat);
      }
#ifdef FF_BAT
      else /* CMD_MODE_BAT */
      {
        rBAT_PercentIMEI(&(ksStat->ir.rKSIMEI));
      }
#endif
      break;

    case (KSD_CMD_CB):
      utl_cb_callbarring(srcId, ksStat);
      break;

    case (KSD_CMD_CF):
      utl_cb_callforwarding(srcId, ksStat);
      break;

    case (KSD_CMD_CL):
      utl_cb_lineidentification(srcId, ksStat);
      break;

    case (KSD_CMD_CW):
      utl_cb_callwaiting(srcId, ksStat);
      break;

    case (KSD_CMD_PWD):
      /* no specific answer to +CPWD which is the corresponding AT cmd */
      break;

    case (KSD_CMD_UBLK):
      /* no specific answer to +CPIN which is the corresponding AT cmd */
      break;

    case (KSD_CMD_USSD):
      if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI)
      {
        rci_display_USSD(srcId,
                         ksStat->ir.rKSUS.mode,
                         (UBYTE *)ksStat->ir.rKSUS.ussd,
                         ksStat->ir.rKSUS.len,
                         FALSE, /* means DO NOT CONVERT STRING */
                         ksStat->ir.rKSUS.dcs);
      }
#ifdef FF_BAT
      else /* CMD_MODE_BAT */
      {
        ussd.len = ksStat->ir.rKSUS.len;
        memcpy (ussd.data, (UBYTE *)ksStat->ir.rKSUS.ussd, ussd.len);
        rBAT_PlusCUSD(ksStat->ir.rKSUS.mode, &ussd, ksStat->ir.rKSUS.dcs);
      }
#endif
      break;

    case (KSD_CMD_CCBS):
      utl_cb_ccbs(srcId, ksStat);
      break;
  }

}
#endif /* defined (FF_ATI) || defined (FF_BAT) */