fc-magnetite: src/g23m-aci/aci/aci

comparison src/g23m-aci/aci/aci_util.c @ 162:53929b40109c

src/g23m-aci: initial import from TCS3.2/LoCosto

author	Mychaela Falconia <falcon@freecalypso.org>
date	Tue, 11 Oct 2016 02:02:43 +0000
parents
children

comparison

equal deleted inserted replaced

-:4557e2a9c18e
+:53929b40109c
+/*
++-----------------------------------------------------------------------------
+|  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) */

FreeCalypso > hg > fc-magnetite

comparison src/g23m-aci/aci/aci_util.c @ 162:53929b40109c