Diffstat (limited to 'gammu/emb/gammu/depend/nokia') (more/less context) (ignore whitespace changes)
20 files changed, 5921 insertions, 0 deletions
diff --git a/gammu/emb/gammu/depend/nokia/dct3.c b/gammu/emb/gammu/depend/nokia/dct3.c new file mode 100644 index 0000000..d4a55da --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3.c @@ -0,0 +1,801 @@ +/* (c) 2002-2004 by Marcin Wiacek */ +/* MSID by Walek */ + +#include "../../../common/gsmstate.h" + +#ifdef GSM_ENABLE_NOKIA_DCT3 + +#include <string.h> +#include <signal.h> + +#include "../../../common/misc/coding/coding.h" +#include "../../../common/gsmcomon.h" +#include "../../../common/service/gsmpbk.h" +#include "../../../common/phone/nokia/dct3/dct3func.h" +#include "../../../common/phone/pfunc.h" +#include "../../gammu.h" + +extern GSM_Reply_Function UserReplyFunctions3[]; + +/* ------- some usefull functions ----------------------------------------- */ + +GSM_Error CheckDCT3Only() +{ + bool found = false; + + /* Checking if phone is DCT3 */ +#ifdef GSM_ENABLE_NOKIA6110 + if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true; +#endif +#ifdef GSM_ENABLE_NOKIA7110 + if (strstr(N7110Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true; +#endif +#ifdef GSM_ENABLE_NOKIA9210 + if (strstr(N9210Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true; +#endif + if (!found) return ERR_NOTSUPPORTED; + + if (s.ConnectionType!=GCT_MBUS2 && s.ConnectionType!=GCT_FBUS2 && + s.ConnectionType!=GCT_FBUS2DLR3 && s.ConnectionType!=GCT_FBUS2BLUE && + s.ConnectionType!=GCT_FBUS2IRDA && s.ConnectionType!=GCT_IRDAPHONET && + s.ConnectionType!=GCT_BLUEFBUS2) { + return ERR_OTHERCONNECTIONREQUIRED; + } + return ERR_NONE; +} + +static void CheckDCT3() +{ + GSM_Error error; + + error = CheckDCT3Only(); + switch (error) { + case ERR_NOTSUPPORTED: + Print_Error(ERR_NOTSUPPORTED); + break; + case ERR_OTHERCONNECTIONREQUIRED: + printf("Can't do it with current phone protocol\n"); + GSM_TerminateConnection(&s); + exit(-1); + default: + break; + } +} + +static bool answer_yes3(char *text) +{ + int len; + char ans[99]; + + while (1) { + printf("%s (yes/no) ? ",text); + len=GetLine(stdin, ans, 99); + if (len==-1) exit(-1); + if (mystrncasecmp(ans, "yes",0)) return true; + if (mystrncasecmp(ans, "no" ,0)) return false; + } +} + +/* ------------------- functions ------------------------------------------- */ + +static FILE *DCT3T9File; + +static GSM_Error DCT3_ReplyGetT9(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int DCT3T9Size; + + DCT3T9Size = msg.Length - 6; + fwrite(msg.Buffer+6,1,DCT3T9Size,DCT3T9File); + return ERR_NONE; +} + +void DCT3GetT9(int argc, char *argv[]) +{ + int i; + unsigned char req[] = {0x00, 0x01, 0xAE, 0x02, 0x00, + 0x00}; /* Part number */ + +//"00 01 AE 00" gets some control values + + if (CheckDCT3Only()!=ERR_NONE) return; + + DCT3T9File = fopen("T9", "w"); + if (DCT3T9File == NULL) return; + + s.User.UserReplyFunctions=UserReplyFunctions3; + + for (i=0;i<5;i++) { + req[5] = i; + error=GSM_WaitFor (&s, req, 6, 0x40, 4, ID_User3); + Print_Error(error); + } + + fclose(DCT3T9File); +} + +void DCT3VibraTest(int argc, char *argv[]) +{ + unsigned char ans[200]; + unsigned char SetLevel[4] = {0x00, 0x01, 0xA3, + 0xff}; /* Level */ + + if (CheckDCT3Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions3; + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + error=GSM_WaitFor (&s, SetLevel, 4, 0x40, 4, ID_User3); + Print_Error(error); + + printf("Press any key to continue...\n"); + GetLine(stdin, ans, 99); + + SetLevel[3] = 0x00; + error=GSM_WaitFor (&s, SetLevel, 4, 0x40, 4, ID_User3); +} + +static GSM_Error DCT3_ReplyPhoneTests(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i; + + for (i=0;i<msg.Buffer[3];i++) { + switch (i) { + case 0: printf("Unknown(%02i) ",i);break; + case 1: printf("MCU ROM checksum (startup)"); break; + case 2: printf("MCU RAM interface (startup)"); break; + case 3: printf("MCU RAM component "); break; + case 4: printf("MCU EEPROM interface (startup)"); break; + case 5: printf("MCU EEPROM component "); break; + case 6: printf("Real Time Clock battery (startup)"); break; + case 7: printf("CCONT interface (startup)"); break; + case 8: printf("AD converter (startup)"); break; + case 9: printf("SW Reset "); break; + case 10:printf("Power Off "); break; + case 11:printf("Security Data "); break; + case 12:printf("EEPROM Tune checksum (startup)"); break; + case 13:printf("PPM checksum (startup)"); break; + case 14:printf("MCU download DSP (startup)"); break; + case 15:printf("DSP alive (startup)"); break; + case 16:printf("COBBA serial (startup)"); break; + case 17:printf("COBBA paraller (startup)"); break; + case 18:printf("EEPROM security checksum (startup)"); break; + case 19:printf("PPM validity (startup)"); break; + case 20:printf("Warranty state (startup)"); break; + case 21:printf("Simlock check/SW version (startup)"); break; + case 22:printf("IMEI check? "); break;/*from PC-Locals1.3.is OK?*/ + default:printf("Unknown(%02i) ",i);break; + } + switch (msg.Buffer[4+i]) { + case 0: printf(" : passed"); break; + case 0xff:printf(" : not executed"); break; + case 254: printf(" : fail"); break; + default: printf(" : result unknown(%i)",msg.Buffer[4+i]); break; + } + printf("\n"); + } + + return ERR_NONE; +} + +void DCT3SelfTests(int argc, char *argv[]) +{ + unsigned char buffer[3] = {0x00,0x01,0xcf}; + unsigned char buffer3[8] = {0x00,0x01,0xce,0x1d,0xfe,0x23,0x00,0x00}; + int i; + + if (CheckDCT3Only()!=ERR_NONE) return; + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + if (answer_yes3("Run all tests now ?")) { + /* make almost all tests */ + error = s.Protocol.Functions->WriteMessage(&s, buffer3, 8, 0x40); + Print_Error(error); + + GSM_Terminate(); + + while (!false) { + GSM_Init(false); + if (error==ERR_NONE) break; + GSM_Terminate(); + } + + my_sleep(400); + } + + s.User.UserReplyFunctions=UserReplyFunctions3; + + for (i=0;i<10;i++) { + error=GSM_WaitFor (&s, buffer, 3, 0x40, 4, ID_User1); + if (error == ERR_NONE) break; + } +} + +struct DCT3ADCInfo { + char *name; + char *unit; + int x; + int pos1; + int pos2; +}; + +static struct DCT3ADCInfo DCT3ADC[] = { + {"Battery voltage:", "mV", 1, 3, 2}, +// {"Charger voltage:", "mV", 1, -1, 7}, +// {"Charger current:", "mA", 1, -1, 5}, + {"Battery type:", "mAh", 1, 4, 3}, + {"Battery temperature:", "mK", 10, 5, 4}, +// {"Accessory detection:", "mV", 1, -1, -1}, + {"RSSI:", "", 1, 2, -1}, +// {"VCXO temperature:", "mV", 1, -1, -1}, +// {"Hook information:", "mV", 1, -1, -1}, + + {"", "", 1, -1, -1} +}; + +unsigned char DCT3ADCBuf[200]; +int DCT3ADCInt; + +static GSM_Error DCT3_ReplyGetADC(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + switch (msg.Buffer[2]) { + case 0x68: + memcpy(DCT3ADCBuf,msg.Buffer+4,msg.Length-4); + return ERR_NONE; + case 0x91: + DCT3ADCInt = msg.Buffer[4]*256+msg.Buffer[5]; + return ERR_NONE; + } + return ERR_UNKNOWNRESPONSE; +} + +void DCT3GetADC(int argc, char *argv[]) +{ + int i = 0; + unsigned char GetRaw[] = {0x00, 0x01, 0x68}; + unsigned char GetUnit[] = {0x00, 0x01, 0x91, + 0x02}; /* Test number */ + + if (CheckDCT3Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions3; + + error=DCT3_EnableSecurity (&s, 0x02); + Print_Error(error); + + error=GSM_WaitFor (&s, GetRaw, 3, 0x40, 6, ID_User3); + Print_Error(error); + + while (1) { + printf(" %30s ",DCT3ADC[i].name); + if (DCT3ADC[i].pos1 != -1) { + printf("raw "); + printf("%10i ", + DCT3ADCBuf[(DCT3ADC[i].pos1-1)*2]*256+ + DCT3ADCBuf[(DCT3ADC[i].pos1-1)*2+1]); + } + if (DCT3ADC[i].pos2 != -1) { + printf("unit result "); + GetUnit[3] = DCT3ADC[i].pos2; + error=GSM_WaitFor (&s, GetUnit, 6, 0x40, 4, ID_User3); + Print_Error(error); + printf("%10i ",DCT3ADCInt*DCT3ADC[i].x); + printf("%s\n",DCT3ADC[i].unit); + } + i++; + if (DCT3ADC[i].name[0] == 0x00) break; + } + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); +} + +void DCT3DisplayTest(int argc, char *argv[]) +{ + unsigned char ans[200]; + unsigned char req[] = {0x00, 0x01, 0xD3, + 0x03, /* 3=set, 2=clear */ + 0x03}; /* test number */ + + if (CheckDCT3Only()!=ERR_NONE) return; + + if (atoi(argv[2]) != 1 && atoi(argv[2]) != 2) { + printf("Give 1 or 2 as test number\n"); + } + + s.User.UserReplyFunctions=UserReplyFunctions3; + + req[4] = atoi(argv[2]); + s.Protocol.Functions->WriteMessage(&s, req, 5, 0x40); + + printf("Press any key to continue...\n"); + GetLine(stdin, ans, 99); + + req[3] = 0x02; + req[4] = 0x03; + s.Protocol.Functions->WriteMessage(&s, req, 5, 0x40); + + error=DCT3_EnableSecurity (&s, 0x03); + Print_Error(error); +} + +void DCT3netmonitor(int argc, char *argv[]) +{ + char value[100]; + + GSM_Init(true); + + CheckDCT3(); + + error=DCT3_Netmonitor(&s, atoi(argv[2]), value); + Print_Error(error); + + printf("%s\n",value); +#ifdef GSM_ENABLE_BEEP + if (atoi(argv[2]) == 243) GSM_PhoneBeep(); +#endif + GSM_Terminate(); +} + +static GSM_Error DCT3_ReplyGetMSID(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i; + + printf("MSID : "); + for (i=5;i<18;i++) printf("%02x",msg.Buffer[i]); + printf("\n"); + return ERR_NONE; +} + +static GSM_Error DCT3_ReplyGetDSPROM(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("DSP ROM : %c\n",msg.Buffer[5]); + return ERR_NONE; +} + +static GSM_Error DCT3_ReplySimlockInfo(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i, j; + char uni[100], buffer[50]; + + j=0; + for (i=0; i < 12; i++) { + if (j<24) { + uni[j]='0' + (msg.Buffer[9+i] >> 4); + j++; + } + if (j!=15) { + if (j<24) { + uni[j]='0' + (msg.Buffer[9+i] & 0x0f); + j++; + } + } else j++; + } + + strncpy(buffer,uni,5); + buffer[5]=0; + printf("Simlock 1 : MCC+MNC %10s, %s, %s, counter %i\n", + buffer, + ((msg.Buffer[6] & 1) == 1)==0?"opened":"CLOSED", + ((msg.Buffer[5] & 1) != 1)==0?"user ":"factory", + msg.Buffer[21]); + + strncpy(buffer,uni+16,4); + buffer[4]=0; + printf("Simlock 2 : GID1 %10s, %s, %s, counter %i\n", + buffer, + ((msg.Buffer[6] & 4) == 4)==0?"opened":"CLOSED", + ((msg.Buffer[5] & 4) != 4)==0?"user ":"factory", + msg.Buffer[23]); + + strncpy(buffer,uni+20,4); + buffer[4]=0; + printf("Simlock 3 : GID2 %10s, %s, %s, counter %i\n", + buffer, + ((msg.Buffer[6] & 8) == 8)==0?"opened":"CLOSED", + ((msg.Buffer[5] & 8) != 8)==0?"user ":"factory", + msg.Buffer[24]); + + strncpy(buffer,uni+5,10); + buffer[10]=0; + printf("Simlock 4 : MSIN %10s, %s, %s, counter %i\n", + buffer, + ((msg.Buffer[6] & 2) == 2)==0?"opened":"CLOSED", + ((msg.Buffer[5] & 2) != 2)==0?"user ":"factory", + msg.Buffer[22]); + + return ERR_NONE; +} + +static GSM_Error DCT3_ReplyGetMCUchkSum(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i; + + if (msg.Buffer[3] == 0x12) printf("Language Pack: %c\n",msg.Buffer[5]); + if (msg.Buffer[3] == 0x02) { + printf("MCU checksum : "); + for (i=5;i<9;i++) printf("%c",msg.Buffer[i]); + printf("\n"); + } + return ERR_NONE; +} + +static unsigned char MSID1; + +GSM_Error DCT3_ReplyEnableSecurity2(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + smprintf(s, "State of security commands set\n"); + MSID1 = msg.Buffer[5]; + return ERR_NONE; +} + +void DCT3Info(int argc, char *argv[]) +{ + unsigned char req[] = {0x00, 0x01, 0x8A, 0x00}; /* Get simlock info */ + unsigned char req2[] = {0x00, 0x01, 0xb4, 0x00, 0x00}; /* Get MSID */ + unsigned char req3[] = {0x00, 0x01, 0xc8, 0x02}; /* Get MCU chksum */ + unsigned char req4[] = {0x00, 0x01, 0xc8, 0x09}; /* Get DSP ROM */ + + if (CheckDCT3Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions3; + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + error=GSM_WaitFor (&s, req, 4, 0x40, 4, ID_User3); + Print_Error(error); + + req2[3] = MSID1; + req2[4] = req2[2] + req2[3]; + error=GSM_WaitFor (&s, req2, 5, 0x40, 4, ID_User8); + Print_Error(error); + + error=GSM_WaitFor (&s, req3, 4, 0x40, 4, ID_User9); + Print_Error(error); + + error=GSM_WaitFor (&s, req4, 4, 0x40, 4, ID_User10); + Print_Error(error); +} + +static GSM_Error DCT3_ReplyResetTest36(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("Netmonitor test 36 cleaned OK\n"); + return ERR_NONE; +} + +void DCT3ResetTest36(int argc, char *argv[]) +{ + unsigned char req[] = {0x00, 0x01, 0x65, 0x40, 0x00}; /* Reset test 36 in netmon */ + + GSM_Init(true); + + CheckDCT3(); + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + s.User.UserReplyFunctions=UserReplyFunctions3; + + error=GSM_WaitFor (&s, req, 5, 0x40, 4, ID_User2); + Print_Error(error); + +#ifdef GSM_ENABLE_BEEP + GSM_PhoneBeep(); +#endif + GSM_Terminate(); +} + +static unsigned char PPS[32]; /* Product Profile Settings */ + +static GSM_Error DCT3_ReplyGetPPS(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i,j,z; + +#ifdef DEBUG + dbgprintf("Product Profile Settings received -"); + for (i=0;i<4;i++) dbgprintf(" %02x",msg.Buffer[3+i]); + dbgprintf("\n"); +#endif + j=128;z=0; + for (i=0;i<32;i++) { + PPS[i]='0'; + if (msg.Buffer[z+3]&j) PPS[i]='1'; + if (j==1) { + j=128; + z++; + } else j=j/2; + } +#ifdef DEBUG + dbgprintf("After decoding: "); + for (i=0;i<32;i++) dbgprintf("%c",PPS[i]); + dbgprintf("\n"); +#endif + return ERR_NONE; +} + +static GSM_Error DCT3_ReplySetPPS(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("Setting done OK\n"); + return ERR_NONE; +} + +void DCT3SetPhoneMenus(int argc, char *argv[]) +{ + char value[100]; + int i,j,z; + unsigned char reqGet[] = {0x00, 0x01, 0x6a}; + unsigned char reqSet[] = { + 0x00, 0x01, 0x6b, + 0x00, 0x00, 0x00, 0x00 }; /* bytes with Product Profile Setings */ + + if (CheckDCT3Only()!=ERR_NONE) return; + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + s.User.UserReplyFunctions=UserReplyFunctions3; + + error=GSM_WaitFor (&s, reqGet, 3, 0x40, 4, ID_User4); + Print_Error(error); + + printf("ALS : enabling menu\n"); + PPS[10] = '1'; + + if (!strcmp(s.Phone.Data.ModelInfo->model,"3310") && s.Phone.Data.VerNum>5.87) { + printf("3310: enabling control of SMS charsets\n"); + PPS[11] = '0';//0 = ON, 1 = OFF + } + if (!strcmp(s.Phone.Data.ModelInfo->model,"6150")) { + printf("6150: enabling WellMate menu\n"); + PPS[18] = '1'; + } + /* FIXME */ + if (!strcmp(s.Phone.Data.ModelInfo->model,"3210")) { + printf("3210: enabling vibra menu\n"); + PPS[24] = '1'; + } + if (!strcmp(s.Phone.Data.ModelInfo->model,"3310") && s.Phone.Data.VerNum>5.13) { + printf("3310: enabling 3315 features\n"); + PPS[25] = '1'; + } + /* FIXME */ + if (!strcmp(s.Phone.Data.ModelInfo->model,"3210") && s.Phone.Data.VerNum>=5.31) { + printf("3210: enabling React and Logic game\n"); + PPS[26] = '1'; + } + +#ifdef DEBUG + dbgprintf("After settings: "); + for (i=0;i<32;i++) dbgprintf("%c",PPS[i]); + dbgprintf("\n"); +#endif + + j=128;z=0; + for (i=0;i<32;i++) { + if (PPS[i]=='1') reqSet[z+3]=reqSet[z+3]+j; + if (j==1) { + j=128; + z++; + } else j=j/2; + } + +// reqSet[3]=0xe7; +// reqSet[4]=0x25; +// reqSet[5]=0x00; +// reqSet[6]=0xe0; + + error=GSM_WaitFor (&s, reqSet, 7, 0x40, 4, ID_User4); + Print_Error(error); + + printf("Enabling netmonitor\n"); + error=DCT3_Netmonitor(&s, 243, value); + Print_Error(error); +} + +static GSM_Error DCT3_Reply61GetSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("Security Code is \"%s\"\n",msg.Buffer+5); + return ERR_NONE; +} + +static GSM_Error DCT3_Reply7191GetSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("Security Code is \"%s\"\n",msg.Buffer+6); + return ERR_NONE; +} + +void DCT3GetSecurityCode(int argc, char *argv[]) +{ + unsigned char req6110[] = {0x00, 0x01, 0x6e, + 0x01}; /* Code type */ + unsigned char req71_91[] = {N7110_FRAME_HEADER, 0xee, + 0x1c}; /* Setting */ + + if (CheckDCT3Only()!=ERR_NONE) return; + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + s.User.UserReplyFunctions=UserReplyFunctions3; + +#ifdef GSM_ENABLE_NOKIA6110 + if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) != NULL) { + error=GSM_WaitFor (&s, req6110, 4, 0x40, 4, ID_User6); + } +#endif +#ifdef GSM_ENABLE_NOKIA7110 + if (strstr(N7110Phone.models, s.Phone.Data.ModelInfo->model) != NULL) { + error=GSM_WaitFor (&s, req71_91, 5, 0x7a, 4, ID_User6); + } +#endif +#ifdef GSM_ENABLE_NOKIA9210 + if (strstr(N9210Phone.models, s.Phone.Data.ModelInfo->model) != NULL) { + error=GSM_WaitFor (&s, req71_91, 5, 0x7a, 4, ID_User6); + } +#endif + Print_Error(error); +} + +#ifdef GSM_ENABLE_NOKIA6110 + +static GSM_Error DCT3_ReplyGetOperatorName(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + unsigned char buffer[10]; + + NOKIA_DecodeNetworkCode(msg.Buffer+5, buffer); + buffer[6] = 0; + printf("Network : %s (%s ", buffer,DecodeUnicodeString(GSM_GetNetworkName(buffer))); + printf(", %s)\n", DecodeUnicodeString(GSM_GetCountryName(buffer))); + printf("Name : \"%s\"\n",msg.Buffer+8); + + return ERR_NONE; +} + +void DCT3GetOperatorName(int argc, char *argv[]) +{ + unsigned char req[] = {0x00,0x01,0x8c,0x00}; + + GSM_Init(true); + + if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) == NULL) Print_Error(ERR_NOTSUPPORTED); + CheckDCT3(); + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + s.User.UserReplyFunctions=UserReplyFunctions3; + + error=GSM_WaitFor (&s, req, 4, 0x40, 4, ID_User5); + Print_Error(error); + + GSM_Terminate(); +} + +static GSM_Error DCT3_ReplySetOperatorName(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("Operator name set OK\n"); + return ERR_NONE; +} + +void DCT3SetOperatorName(int argc, char *argv[]) +{ + int i = 0; + unsigned char req[256] = {0x00,0x01,0x8b,0x00, + 0x00,0x00, /* MCC */ + 0x00}; /* MNC */ + + GSM_Init(true); + + if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) == NULL) Print_Error(ERR_NOTSUPPORTED); + CheckDCT3(); + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + s.User.UserReplyFunctions=UserReplyFunctions3; + + switch (argc) { + case 2: + case 3: NOKIA_EncodeNetworkCode(req+4,"000 00"); + req[7] = 0x00; + i = 1; + break; + case 4: NOKIA_EncodeNetworkCode(req+4,argv[2]); + strncpy(req+7,argv[3],200); + i = strlen(argv[3]); + } + + error=GSM_WaitFor (&s, req, 8+i, 0x40, 4, ID_User7); + Print_Error(error); + + GSM_Terminate(); +} + +static GSM_Error DCT3_ReplyDisplayOutput(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + unsigned char buf[100]; + + switch (msg.Buffer[3]) { + case 0x50: + dbgprintf("Display string received\n"); + memcpy(buf,msg.Buffer+8,msg.Buffer[7]*2); + buf[msg.Buffer[7]*2] = 0; + buf[msg.Buffer[7]*2+1] = 0; + printf("X=%i, Y=%i, Text=\"%s\"\n",msg.Buffer[6],msg.Buffer[5],DecodeUnicodeString(buf)); + return ERR_NONE; + case 0x54: + dbgprintf("Display output set\n"); + return ERR_NONE; + } + return ERR_UNKNOWNRESPONSE; +} + +void DCT3DisplayOutput(int argc, char *argv[]) +{ + unsigned char req[] = {N6110_FRAME_HEADER, 0x53, + 0x01}; //1 = enable, 2 = disable + + GSM_Init(true); + + if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) == NULL) Print_Error(ERR_NOTSUPPORTED); + CheckDCT3(); + + s.User.UserReplyFunctions=UserReplyFunctions3; + + error=GSM_WaitFor (&s, req, 5, 0x0d, 4, ID_User7); + Print_Error(error); + + signal(SIGINT, interrupt); + printf("Press Ctrl+C to break...\n"); + printf("Entering monitor mode...\n\n"); + + while (!gshutdown) { + GSM_ReadDevice(&s,true); + my_sleep(10); + } + + req[4] = 0x02; + error=GSM_WaitFor (&s, req, 5, 0x0d, 4, ID_User7); + Print_Error(error); + + GSM_Terminate(); +} +#endif + +static GSM_Reply_Function UserReplyFunctions3[] = { + {DCT3_ReplyDisplayOutput, "\x0D",0x03,0x50,ID_IncomingFrame }, + {DCT3_ReplyDisplayOutput, "\x0D",0x03,0x54,ID_User7 }, + + {DCT3_ReplyEnableSecurity2, "\x40",0x02,0x64,ID_EnableSecurity }, + {DCT3_ReplyResetTest36, "\x40",0x02,0x65,ID_User2 }, + {DCT3_ReplyGetADC, "\x40",0x02,0x68,ID_User3 }, + {DCT3_ReplyGetPPS, "\x40",0x02,0x6A,ID_User4 }, + {DCT3_ReplySetPPS, "\x40",0x02,0x6B,ID_User4 }, + {DCT3_Reply61GetSecurityCode, "\x40",0x02,0x6E,ID_User6 }, + {DCT3_ReplySimlockInfo, "\x40",0x02,0x8A,ID_User3 }, +#ifdef GSM_ENABLE_NOKIA6110 + {DCT3_ReplySetOperatorName, "\x40",0x02,0x8B,ID_User7 }, + {DCT3_ReplyGetOperatorName, "\x40",0x02,0x8C,ID_User5 }, +#endif + {DCT3_ReplyGetADC, "\x40",0x02,0x91,ID_User3 }, + {NoneReply, "\x40",0x02,0xA3,ID_User3 }, + {DCT3_ReplyGetT9, "\x40",0x02,0xAE,ID_User3 }, + {DCT3_ReplyGetMSID, "\x40",0x02,0xb5,ID_User8 }, + {DCT3_ReplyGetDSPROM, "\x40",0x02,0xC8,ID_User10 }, + {DCT3_ReplyGetMCUchkSum, "\x40",0x02,0xC8,ID_User9 }, + {DCT3_ReplyPhoneTests, "\x40",0x02,0xCF,ID_User1 }, + + {DCT3_Reply7191GetSecurityCode, "\x7a",0x04,0x1C,ID_User6 }, + + {NULL, "\x00",0x00,0x00,ID_None } +}; + +#endif + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3.h b/gammu/emb/gammu/depend/nokia/dct3.h new file mode 100644 index 0000000..721222d --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3.h @@ -0,0 +1,26 @@ +/* (c) 2002-2004 by Marcin Wiacek */ + +void DCT3SelfTests (int argc, char *argv[]); +void DCT3netmonitor (int argc, char *argv[]); +void DCT3Info (int argc, char *argv[]); +void DCT3ResetTest36 (int argc, char *argv[]); +void DCT3SetPhoneMenus (int argc, char *argv[]); +void DCT3GetSecurityCode (int argc, char *argv[]); +void DCT3GetADC (int argc, char *argv[]); +void DCT3DisplayTest (int argc, char *argv[]); +void DCT3VibraTest (int argc, char *argv[]); +void DCT3GetT9 (int argc, char *argv[]); + +GSM_Error CheckDCT3Only(); + +#include "../../../common/gsmstate.h" + +#ifdef GSM_ENABLE_NOKIA6110 +void DCT3GetOperatorName (int argc, char *argv[]); +void DCT3SetOperatorName (int argc, char *argv[]); +void DCT3DisplayOutput (int argc, char *argv[]); +#endif + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/nhm5_587.txt b/gammu/emb/gammu/depend/nokia/dct3trac/nhm5_587.txt new file mode 100644 index 0000000..a68d9d2 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/nhm5_587.txt @@ -0,0 +1,2055 @@ +09XX CS:err/CS_ERROR_TRA +0900 CS:err/INVALID_PRIMITIVE +0901 CS:err/UNKNOWN_PRIMITIVE +0902 CS:err/UNDEFINED_PRIMITIVE +0903 CS:err/L1_UNKNOWN_MDI_MSG_SEND +0904 CS:err/HPLMN_READ_FAIL +0905 CS:err/L1_M82_UNKNOWN_TIMING_OFFSET +0906 CS:err/UNKNOWN_SSUPL_CM_RET_VALUE +0907 CS:err/UNKNOWN_MODE +0908 CS:err/UNKNOWN_PDU +0909 CS:err/UNDEFINED_PDU +090A CS:err/UNDEFINED_TIMER +090B CS:err/FATAL_ERROR_IN_L2_PDU +090C CS:err/UNKNOWN_INFO_ELEMENT +090D CS:err/TRAN_ID_CONFLICT +090E CS:err/UNKNOWN_ERROR_CODE +090F CS:err/L2_ERROR +0910 CS:err/RR_ERROR +0911 CS:err/MM_ERROR +0912 CS:err/CC_ERROR +0913 CS:err/SS_ERROR +0914 CS:err/CS_ERROR +0915 CS:err/RM_ERROR +0916 CS:err/LAPDM_CONT_RS_FAIL(22/061C) +0917 CS:err/LAPDM_INVALID_RESP(22/060D) +0918 CS:err/LAPDM_SEQUENCE_ERROR(22/05FD) +0919 CS:err/LAPDM_TIMEOUT_ERROR(22/05FE) +091A CS:err/LAPDM_AWAIT_EST_ERROR(22/061F) +091B CS:err/LAPDM_UNSOL_DM_IN_MF_EST(22/0602) +10XX Const/CONSTANT_WINDOW_TRA +1000 Const/CHANNEL_CONFIG +1001 Const/DSF +1002 Const/RLT +1003 Const/PWR_TA +1004 Const/PWR +1005 Const/TIM_ADV +1006 Const/MEAS_RESULTS +1007 Const/OWN_SYSPAR +1008 Const/NBOUR_SYSPAR +11XX L1:timer/L1_TIMER_TRA +1100 L1:timer/BCCH_TIMEOUT-start(4/008B) +1101 L1:timer/BCCH_TIMEOUT-stop +1102 L1:timer/BCCH_TIMEOUT-timeout(4/0087) +1103 L1:timer/RESEL_TIME-start +1104 L1:timer/RESEL_TIME-stop(4/008A) +1105 L1:timer/RESEL_TIME-timeout +1106 L1:timer/IMM_ASS_DELAY-start(4/0089) +1107 L1:timer/IMM_ASS_DELAY-stop +1108 L1:timer/IMM_ASS_DELAY-timeout(4/008D) +1109 L1:timer/EXT_PAGE_MODE-start +110A L1:timer/EXT_PAGE_MODE-stop(4/0088) +110B L1:timer/EXT_PAGE_MODE-timeout +110C L1:timer/SYNC_PERIOD-start(4/008C) +110D L1:timer/SYNC_PERIOD-stop +110E L1:timer/SYNC_PERIOD-timeout(4/008E) +110F L1:timer/SC1_NEG-start +1110 L1:timer/SC1_NEG-stop +1111 L1:timer/SC1_NEG-timeout +1112 L1:timer/NCX_GREAT-start +1113 L1:timer/NCX_GREAT-stop +1114 L1:timer/NCX_GREAT-timeout +1115 L1:timer/LAST_RESEL-start +1116 L1:timer/LAST_RESEL-stop +1117 L1:timer/LAST_RESEL-timeout +1118 L1:timer/FORBIDDEN_CELLS-start +1119 L1:timer/FORBIDDEN_CELLS-stop +111A L1:timer/FORBIDDEN_CELLS-timeout +111B L1:timer/CS_SCANN-start +111C L1:timer/CS_SCANN-stop +111D L1:timer/CS_SCANN-timeout +111E L1:timer/WEAK_NEIGH-start +111F L1:timer/WEAK_NEIGH-stop +1120 L1:timer/WEAK_NEIGH-timeout +1121 L1:timer/MEAS_REQ-start +1122 L1:timer/MEAS_REQ-stop +1123 L1:timer/MEAS_REQ-timeout +1124 L1:timer/OWN_BCCH_PER-start +1125 L1:timer/OWN_BCCH_PER-stop +1126 L1:timer/OWN_BCCH_PER-timeout +1127 L1:timer/OLD_SCELL-start +1128 L1:timer/OLD_SCELL-stop +1129 L1:timer/OLD_SCELL-timeout +112A L1:timer/PLMN_SEARCH-start +112B L1:timer/PLMN_SEARCH-stop +112C L1:timer/PLMN_SEARCH-timeout +18XX MDI:m2d/MDI_M2D_MSG_TRA +1800 MDI:m2d/INVALID_MDI_MSG 0 +1801 MDI:m2d/INVALID_MDI_MSG 1 +1802 MDI:m2d/CHANNEL_CONFIGURE +1803 MDI:m2d/DEACTIVATE +1804 MDI:m2d/CBCH +1805 MDI:m2d/FROM_MCU_TO_FBUS +1806 MDI:m2d/CIPHER_KEY +1807 MDI:m2d/MEAS_PLMN_RSSI +1808 MDI:m2d/TYPE_TEST_ENABLED +1809 MDI:m2d/PSW_SEARCH_LIST +180A MDI:m2d/INVALID_MDI_MSG 10 +180B MDI:m2d/HOPPING_PARAMETERS +180C MDI:m2d/IDLE_RA +180D MDI:m2d/MODULATOR_TABLE +180E MDI:m2d/MODULATOR_DC_OFFSET +180F MDI:m2d/NEIGHBOUR_LIST +1810 MDI:m2d/NEXT_BCCH +1811 MDI:m2d/NMEAS_INSTRUCTIONS +1812 MDI:m2d/INVALID_MDI_MSG 18 +1813 MDI:m2d/ON_OFF_CIPHER +1814 MDI:m2d/CIPHER_PARAMETERS +1815 MDI:m2d/INVALID_MDI_MSG 21 +1816 MDI:m2d/INVALID_MDI_MSG 22 +1817 MDI:m2d/INVALID_MDI_MSG 23 +1818 MDI:m2d/INVALID_MDI_MSG 24 +1819 MDI:m2d/INVALID_MDI_MSG 25 +181A MDI:m2d/SEARCH_LIST +181B MDI:m2d/SEND_BLOCK +181C MDI:m2d/INVALID_MDI_MSG 28 +181D MDI:m2d/INVALID_MDI_MSG 29 +181E MDI:m2d/INVALID_MDI_MSG 30 +181F MDI:m2d/TX_CONTROL +1820 MDI:m2d/INVALID_MDI_MSG 32 +1821 MDI:m2d/INVALID_MDI_MSG 33 +1822 MDI:m2d/INVALID_MDI_MSG 34 +1823 MDI:m2d/INVALID_MDI_MSG 35 +1824 MDI:m2d/INVALID_MDI_MSG 36 +1825 MDI:m2d/INVALID_MDI_MSG 37 +1826 MDI:m2d/INVALID_MDI_MSG 38 +1827 MDI:m2d/INVALID_MDI_MSG 39 +1828 MDI:m2d/IR_LINK_STATUS +1829 MDI:m2d/INVALID_MDI_MSG 41 +182A MDI:m2d/INVALID_MDI_MSG 42 +182B MDI:m2d/INVALID_MDI_MSG 43 +182C MDI:m2d/DSP_CONSTANTS +182D MDI:m2d/INVALID_MDI_MSG 45 +182E MDI:m2d/INVALID_MDI_MSG 46 +182F MDI:m2d/INVALID_MDI_MSG 47 +1830 MDI:m2d/TX_ENABLE +1831 MDI:m2d/MEAS_REQ_ON +1832 MDI:m2d/INVALID_MDI_MSG 50 +1833 MDI:m2d/INVALID_MDI_MSG 51 +1834 MDI:m2d/INVALID_MDI_MSG 52 +1835 MDI:m2d/INVALID_MDI_MSG 53 +1836 MDI:m2d/DISCHARGE +1837 MDI:m2d/INVALID_MDI_MSG 55 +1838 MDI:m2d/TYPE_LOOP_BACK +1839 MDI:m2d/PARAMETER_UPDATE +183A MDI:m2d/RX_TX_CONTROL +183B MDI:m2d/TEMPERATURE +183C MDI:m2d/DSP_PARAMETERS +183D MDI:m2d/INVALID_MDI_MSG 61 +183E MDI:m2d/DTX_CONTROL +183F MDI:m2d/POWER_LEVEL_RAMP +1840 MDI:m2d/INVALID_MDI_MSG 64 +1841 MDI:m2d/IGNORE_CBCH_MESSAGE +1842 MDI:m2d/CBCH_BITMAP +1843 MDI:m2d/INVALID_MDI_MSG 67 +1844 MDI:m2d/INVALID_MDI_MSG 68 +1845 MDI:m2d/OWN_BCCH +1846 MDI:m2d/MSI +1847 MDI:m2d/LOOP_BACK +1848 MDI:m2d/LOOP_BACK_SHORT +1849 MDI:m2d/RTC_CALIBRATION_REQUEST +184A MDI:m2d/TXC_BIAS_RESULT +184B MDI:m2d/MORE_RSSI +184C MDI:m2d/FBUS_MODE +184D MDI:m2d/SEND_DTE_DATA_BLOCK +184E MDI:m2d/SEND_IRLAP_DATA_BLOCK +184F MDI:m2d/DATA_CODING_MODE +1850 MDI:m2d/SEND_TCH_DATA_BLOCK +1851 MDI:m2d/INVALID_MDI_MSG 81 +1852 MDI:m2d/INVALID_MDI_MSG 82 +1853 MDI:m2d/INVALID_MDI_MSG 83 +1854 MDI:m2d/INVALID_MDI_MSG 84 +1855 MDI:m2d/INVALID_MDI_MSG 85 +1856 MDI:m2d/INVALID_MDI_MSG 86 +1857 MDI:m2d/INVALID_MDI_MSG 87 +1858 MDI:m2d/INVALID_MDI_MSG 88 +1859 MDI:m2d/INVALID_MDI_MSG 89 +185A MDI:m2d/INVALID_MDI_MSG 90 +185B MDI:m2d/INVALID_MDI_MSG 91 +185C MDI:m2d/INVALID_MDI_MSG 92 +185D MDI:m2d/INVALID_MDI_MSG 93 +185E MDI:m2d/INVALID_MDI_MSG 94 +185F MDI:m2d/INVALID_MDI_MSG 95 +1860 MDI:m2d/INVALID_MDI_MSG 96 +1861 MDI:m2d/INVALID_MDI_MSG 97 +1862 MDI:m2d/INVALID_MDI_MSG 98 +1863 MDI:m2d/INVALID_MDI_MSG 99 +1864 MDI:m2d/INVALID_MDI_MSG 100 +1865 MDI:m2d/INVALID_MDI_MSG 101 +1866 MDI:m2d/INVALID_MDI_MSG 102 +1867 MDI:m2d/INVALID_MDI_MSG 103 +1868 MDI:m2d/INVALID_MDI_MSG 104 +1869 MDI:m2d/INVALID_MDI_MSG 105 +186A MDI:m2d/INVALID_MDI_MSG 106 +186B MDI:m2d/INVALID_MDI_MSG 107 +186C MDI:m2d/INVALID_MDI_MSG 108 +186D MDI:m2d/INVALID_MDI_MSG 109 +186E MDI:m2d/INVALID_MDI_MSG 110 +186F MDI:m2d/INVALID_MDI_MSG 111 +1870 MDI:m2d/COMMAND_LOCAL +1871 MDI:m2d/INVALID_MDI_MSG 113 +1872 MDI:m2d/INVALID_MDI_MSG 114 +1873 MDI:m2d/INVALID_MDI_MSG 115 +1874 MDI:m2d/RESPONSE_LOCAL +1875 MDI:m2d/INVALID_MDI_MSG 117 +1876 MDI:m2d/INVALID_MDI_MSG 118 +1877 MDI:m2d/INVALID_MDI_MSG 119 +1878 MDI:m2d/INVALID_MDI_MSG 120 +1879 MDI:m2d/INVALID_MDI_MSG 121 +187A MDI:m2d/INVALID_MDI_MSG 122 +187B MDI:m2d/INVALID_MDI_MSG 123 +187C MDI:m2d/INVALID_MDI_MSG 124 +187D MDI:m2d/INVALID_MDI_MSG 125 +187E MDI:m2d/INVALID_MDI_MSG 126 +187F MDI:m2d/INVALID_MDI_MSG 127 +1880 MDI:m2d/RECEIVED_BLOCK +1881 MDI:m2d/MEAS_REQUEST +1882 MDI:m2d/INVALID_MDI_MSG 130 +1883 MDI:m2d/RSSI_RESULTS +1884 MDI:m2d/RA_INFO +1885 MDI:m2d/INVALID_MDI_MSG 133 +1886 MDI:m2d/BLOCK_REQUEST +1887 MDI:m2d/NO_BCCH_LEFT +1888 MDI:m2d/NEIGHBOUR_TIMING_OFFSET +1889 MDI:m2d/CHANNEL_CHANGED_CNF +188A MDI:m2d/NO_PSW_FOUND +188B MDI:m2d/ALL_RSSI_RESULTS +188C MDI:m2d/DOWNLINK_SIGNALLING_FAIL +188D MDI:m2d/FBUS_DISCONNECTED +188E MDI:m2d/FROM_FBUS_TO_MCU +188F MDI:m2d/NO_PSW_LEFT +1890 MDI:m2d/INVALID_MDI_MSG 144 +1891 MDI:m2d/INVALID_MDI_MSG 145 +1892 MDI:m2d/INVALID_MDI_MSG 146 +1893 MDI:m2d/INVALID_MDI_MSG 147 +1894 MDI:m2d/FBUS_ERROR +1895 MDI:m2d/IR_DISABLED +1896 MDI:m2d/LOOP_BACK_REPLY +1897 MDI:m2d/LOOP_BACK_SHORT_REPLY +1898 MDI:m2d/RTC_CALIBRATION_VALUE +1899 MDI:m2d/TXC_BIAS_MEAS +189A MDI:m2d/RECEIVED_DTE_DATA_BLOCK +189B MDI:m2d/RECEIVED_IRLAP_DATA_BLOCK +189C MDI:m2d/RECEIVED_TCH_DATA_BLOCK +189D MDI:m2d/INVALID_MDI_MSG 157 +189E MDI:m2d/INVALID_MDI_MSG 158 +189F MDI:m2d/INVALID_MDI_MSG 159 +18A0 MDI:m2d/INVALID_MDI_MSG 160 +18A1 MDI:m2d/INVALID_MDI_MSG 161 +18A2 MDI:m2d/INVALID_MDI_MSG 162 +18A3 MDI:m2d/INVALID_MDI_MSG 163 +18A4 MDI:m2d/INVALID_MDI_MSG 164 +18A5 MDI:m2d/INVALID_MDI_MSG 165 +18A6 MDI:m2d/INVALID_MDI_MSG 166 +18A7 MDI:m2d/INVALID_MDI_MSG 167 +18A8 MDI:m2d/INVALID_MDI_MSG 168 +18A9 MDI:m2d/INVALID_MDI_MSG 169 +18AA MDI:m2d/INVALID_MDI_MSG 170 +18AB MDI:m2d/UNKNOWN_MDI_MSG +19XX MDI:d2m/MDI_D2M_MSG_TRA +1900 MDI:d2m/INVALID_MDI_MSG 0 +1901 MDI:d2m/INVALID_MDI_MSG 1 +1902 MDI:d2m/CHANNEL_CONFIGURE +1903 MDI:d2m/DEACTIVATE +1904 MDI:d2m/CBCH +1905 MDI:d2m/FROM_MCU_TO_FBUS +1906 MDI:d2m/CIPHER_KEY +1907 MDI:d2m/MEAS_PLMN_RSSI +1908 MDI:d2m/TYPE_TEST_ENABLED +1909 MDI:d2m/PSW_SEARCH_LIST +190A MDI:d2m/INVALID_MDI_MSG 10 +190B MDI:d2m/HOPPING_PARAMETERS +190C MDI:d2m/IDLE_RA +190D MDI:d2m/MODULATOR_TABLE +190E MDI:d2m/MODULATOR_DC_OFFSET +190F MDI:d2m/NEIGHBOUR_LIST +1910 MDI:d2m/NEXT_BCCH +1911 MDI:d2m/NMEAS_INSTRUCTIONS +1912 MDI:d2m/INVALID_MDI_MSG 18 +1913 MDI:d2m/ON_OFF_CIPHER +1914 MDI:d2m/CIPHER_PARAMETERS +1915 MDI:d2m/INVALID_MDI_MSG 21 +1916 MDI:d2m/INVALID_MDI_MSG 22 +1917 MDI:d2m/INVALID_MDI_MSG 23 +1918 MDI:d2m/INVALID_MDI_MSG 24 +1919 MDI:d2m/INVALID_MDI_MSG 25 +191A MDI:d2m/SEARCH_LIST +191B MDI:d2m/SEND_BLOCK +191C MDI:d2m/INVALID_MDI_MSG 28 +191D MDI:d2m/INVALID_MDI_MSG 29 +191E MDI:d2m/INVALID_MDI_MSG 30 +191F MDI:d2m/TX_CONTROL +1920 MDI:d2m/INVALID_MDI_MSG 32 +1921 MDI:d2m/INVALID_MDI_MSG 33 +1922 MDI:d2m/INVALID_MDI_MSG 34 +1923 MDI:d2m/INVALID_MDI_MSG 35 +1924 MDI:d2m/INVALID_MDI_MSG 36 +1925 MDI:d2m/INVALID_MDI_MSG 37 +1926 MDI:d2m/INVALID_MDI_MSG 38 +1927 MDI:d2m/INVALID_MDI_MSG 39 +1928 MDI:d2m/IR_LINK_STATUS +1929 MDI:d2m/INVALID_MDI_MSG 41 +192A MDI:d2m/INVALID_MDI_MSG 42 +192B MDI:d2m/INVALID_MDI_MSG 43 +192C MDI:d2m/DSP_CONSTANTS +192D MDI:d2m/INVALID_MDI_MSG 45 +192E MDI:d2m/INVALID_MDI_MSG 46 +192F MDI:d2m/INVALID_MDI_MSG 47 +1930 MDI:d2m/TX_ENABLE +1931 MDI:d2m/MEAS_REQ_ON +1932 MDI:d2m/INVALID_MDI_MSG 50 +1933 MDI:d2m/INVALID_MDI_MSG 51 +1934 MDI:d2m/INVALID_MDI_MSG 52 +1935 MDI:d2m/INVALID_MDI_MSG 53 +1936 MDI:d2m/DISCHARGE +1937 MDI:d2m/INVALID_MDI_MSG 55 +1938 MDI:d2m/TYPE_LOOP_BACK +1939 MDI:d2m/PARAMETER_UPDATE +193A MDI:d2m/RX_TX_CONTROL +193B MDI:d2m/TEMPERATURE +193C MDI:d2m/DSP_PARAMETERS +193D MDI:d2m/INVALID_MDI_MSG 61 +193E MDI:d2m/DTX_CONTROL +193F MDI:d2m/POWER_LEVEL_RAMP +1940 MDI:d2m/INVALID_MDI_MSG 64 +1941 MDI:d2m/IGNORE_CBCH_MESSAGE +1942 MDI:d2m/CBCH_BITMAP +1943 MDI:d2m/INVALID_MDI_MSG 67 +1944 MDI:d2m/INVALID_MDI_MSG 68 +1945 MDI:d2m/OWN_BCCH +1946 MDI:d2m/MSI +1947 MDI:d2m/LOOP_BACK +1948 MDI:d2m/LOOP_BACK_SHORT +1949 MDI:d2m/RTC_CALIBRATION_REQUEST +194A MDI:d2m/TXC_BIAS_RESULT +194B MDI:d2m/MORE_RSSI +194C MDI:d2m/FBUS_MODE +194D MDI:d2m/SEND_DTE_DATA_BLOCK +194E MDI:d2m/SEND_IRLAP_DATA_BLOCK +194F MDI:d2m/DATA_CODING_MODE +1950 MDI:d2m/SEND_TCH_DATA_BLOCK +1951 MDI:d2m/INVALID_MDI_MSG 81 +1952 MDI:d2m/INVALID_MDI_MSG 82 +1953 MDI:d2m/INVALID_MDI_MSG 83 +1954 MDI:d2m/INVALID_MDI_MSG 84 +1955 MDI:d2m/INVALID_MDI_MSG 85 +1956 MDI:d2m/INVALID_MDI_MSG 86 +1957 MDI:d2m/INVALID_MDI_MSG 87 +1958 MDI:d2m/INVALID_MDI_MSG 88 +1959 MDI:d2m/INVALID_MDI_MSG 89 +195A MDI:d2m/INVALID_MDI_MSG 90 +195B MDI:d2m/INVALID_MDI_MSG 91 +195C MDI:d2m/INVALID_MDI_MSG 92 +195D MDI:d2m/INVALID_MDI_MSG 93 +195E MDI:d2m/INVALID_MDI_MSG 94 +195F MDI:d2m/INVALID_MDI_MSG 95 +1960 MDI:d2m/INVALID_MDI_MSG 96 +1961 MDI:d2m/INVALID_MDI_MSG 97 +1962 MDI:d2m/INVALID_MDI_MSG 98 +1963 MDI:d2m/INVALID_MDI_MSG 99 +1964 MDI:d2m/INVALID_MDI_MSG 100 +1965 MDI:d2m/INVALID_MDI_MSG 101 +1966 MDI:d2m/INVALID_MDI_MSG 102 +1967 MDI:d2m/INVALID_MDI_MSG 103 +1968 MDI:d2m/INVALID_MDI_MSG 104 +1969 MDI:d2m/INVALID_MDI_MSG 105 +196A MDI:d2m/INVALID_MDI_MSG 106 +196B MDI:d2m/INVALID_MDI_MSG 107 +196C MDI:d2m/INVALID_MDI_MSG 108 +196D MDI:d2m/INVALID_MDI_MSG 109 +196E MDI:d2m/INVALID_MDI_MSG 110 +196F MDI:d2m/INVALID_MDI_MSG 111 +1970 MDI:d2m/COMMAND_LOCAL +1971 MDI:d2m/INVALID_MDI_MSG 113 +1972 MDI:d2m/INVALID_MDI_MSG 114 +1973 MDI:d2m/INVALID_MDI_MSG 115 +1974 MDI:d2m/RESPONSE_LOCAL +1975 MDI:d2m/INVALID_MDI_MSG 117 +1976 MDI:d2m/INVALID_MDI_MSG 118 +1977 MDI:d2m/INVALID_MDI_MSG 119 +1978 MDI:d2m/INVALID_MDI_MSG 120 +1979 MDI:d2m/INVALID_MDI_MSG 121 +197A MDI:d2m/INVALID_MDI_MSG 122 +197B MDI:d2m/INVALID_MDI_MSG 123 +197C MDI:d2m/INVALID_MDI_MSG 124 +197D MDI:d2m/INVALID_MDI_MSG 125 +197E MDI:d2m/INVALID_MDI_MSG 126 +197F MDI:d2m/INVALID_MDI_MSG 127 +1980 MDI:d2m/RECEIVED_BLOCK +1981 MDI:d2m/MEAS_REQUEST +1982 MDI:d2m/INVALID_MDI_MSG 130 +1983 MDI:d2m/RSSI_RESULTS +1984 MDI:d2m/RA_INFO +1985 MDI:d2m/INVALID_MDI_MSG 133 +1986 MDI:d2m/BLOCK_REQUEST +1987 MDI:d2m/NO_BCCH_LEFT +1988 MDI:d2m/NEIGHBOUR_TIMING_OFFSET +1989 MDI:d2m/CHANNEL_CHANGED_CNF +198A MDI:d2m/NO_PSW_FOUND +198B MDI:d2m/ALL_RSSI_RESULTS +198C MDI:d2m/DOWNLINK_SIGNALLING_FAIL +198D MDI:d2m/FBUS_DISCONNECTED +198E MDI:d2m/FROM_FBUS_TO_MCU +198F MDI:d2m/NO_PSW_LEFT +1990 MDI:d2m/INVALID_MDI_MSG 144 +1991 MDI:d2m/INVALID_MDI_MSG 145 +1992 MDI:d2m/INVALID_MDI_MSG 146 +1993 MDI:d2m/INVALID_MDI_MSG 147 +1994 MDI:d2m/FBUS_ERROR +1995 MDI:d2m/IR_DISABLED +1996 MDI:d2m/LOOP_BACK_REPLY +1997 MDI:d2m/LOOP_BACK_SHORT_REPLY +1998 MDI:d2m/RTC_CALIBRATION_VALUE +1999 MDI:d2m/TXC_BIAS_MEAS +199A MDI:d2m/RECEIVED_DTE_DATA_BLOCK +199B MDI:d2m/RECEIVED_IRLAP_DATA_BLOCK +199C MDI:d2m/RECEIVED_TCH_DATA_BLOCK +199D MDI:d2m/INVALID_MDI_MSG 157 +199E MDI:d2m/INVALID_MDI_MSG 158 +199F MDI:d2m/INVALID_MDI_MSG 159 +19A0 MDI:d2m/INVALID_MDI_MSG 160 +19A1 MDI:d2m/INVALID_MDI_MSG 161 +19A2 MDI:d2m/INVALID_MDI_MSG 162 +19A3 MDI:d2m/INVALID_MDI_MSG 163 +19A4 MDI:d2m/INVALID_MDI_MSG 164 +19A5 MDI:d2m/INVALID_MDI_MSG 165 +19A6 MDI:d2m/INVALID_MDI_MSG 166 +19A7 MDI:d2m/INVALID_MDI_MSG 167 +19A8 MDI:d2m/INVALID_MDI_MSG 168 +19A9 MDI:d2m/INVALID_MDI_MSG 169 +19AA MDI:d2m/INVALID_MDI_MSG 170 +19AB MDI:d2m/UNKNOWN_MDI_MSG +1CXX L1:ph_rr/L1_PH_RR_MSG_TRA +1C00 L1:ph_rr/RR->:ACTIVATE_CNF(1/0002) +1C01 L1:ph_rr/RR<-:ACTIVATE_REQ(1/03E9) +1C02 L1:ph_rr/RR<-:DEACTIVATE_REQ(1/03EA) +1C03 L1:ph_rr/RR<-:START_AG_LISTEN_REQ(1/03EB) +1C04 L1:ph_rr/RR<-:STOP_AG_LISTEN_REQ(1/03EC) +1C05 L1:ph_rr/RR<-:ASSIGN_REQ(1/03ED) +1C06 L1:ph_rr/HANDOVER_REQ(1/03EE) +1C07 L1:ph_rr/RR<-:FREQUENCY_REDEF_REQ(1/03EF) +1C08 L1:ph_rr/RR<-:BACK_TO_PREV_CH_REQ(1/03F0) +1C09 L1:ph_rr/RR<-:DECONFIG_REQ(1/03F1) +1C0A L1:ph_rr/RR<-:CH_MODE_MODIFY_REQ(1/03F2) +1C0B L1:ph_rr/RR<-:PHYS_INFO_REQ(1/03F3) +1C0C L1:ph_rr/RR<-:CIPHER_START_REQ(1/03F4) +1C0D L1:ph_rr/RR<-:CIPHER_STOP_REQ(1/03F5) +1C0E L1:ph_rr/RR<-:PAGE_MODE_REQ(1/03F6) +1C0F L1:ph_rr/RR->:AG_LISTEN_REJ(1/03F7) +1C10 L1:ph_rr/RR<-:CONFIG_CNF(1/03F8) +1C11 L1:ph_rr/RR->:ERROR_IND(1/03F9) +1C12 L1:ph_rr/RR->:RANDOM_ACCESS_IND(1/03FA) +1C13 L1:ph_rr/RR->:AG_TIMEOUT_IND(1/03FB) +1C14 L1:ph_rr/RR->:RESEL_NEEDED_IND(1/03FC) +1C15 L1:ph_rr/RR->:RESEL_FAIL_IND(1/03FD) +1C16 L1:ph_rr/RR->:RESEL_IMPOSSIBLE_IND +1C17 L1:ph_rr/RR<-:STOP_RA_SENDING_REQ +1C18 L1:ph_rr/RR<-:LIMITED_SERVICE_REQ +1C19 L1:ph_rr/MDI->:TX_INIT +1C1A L1:ph_rr/RR<-:CONFIG_CHANGE_REQ +1C24 (1/040D) +1C25 (1/040E) +1C26 (1/040F) +1C27 (1/0410) +1C28 (1/0411) +1C29 (1/0412) +1C2A (1/0413) +1C2B (1/0414) +1C2C (1/0415) +1C2D (1/0416) +1C2E (1/0417) +1C2F (1/0418) +1C30 (1/0419) +1C31 (1/041A) +1C32 (1/041B) +1C33 (1/0420) +1C34 (1/0425) +20XX SIM:fil_msg/SIM_FIL_MSG_TRA +2000 SIM:fil_msg/UNKNOWN_CMD +2001 SIM:fil_msg/UPDATE_RECORD +2002 SIM:fil_msg/RESET_SIM +2003 SIM:fil_msg/DEACTIVATE_SIM +2004 SIM:fil_msg/UNBLOCK_GSM_APPLICATION +2005 SIM:fil_msg/SLEEP +2006 SIM:fil_msg/STATUS +2007 SIM:fil_msg/SELECT +2008 SIM:fil_msg/SEEK +2009 SIM:fil_msg/VERIFY_PIN +200A SIM:fil_msg/CHANGE_PIN +200B SIM:fil_msg/DISABLE_PIN +200C SIM:fil_msg/RENABLE_PIN +200D SIM:fil_msg/RUN_SIM_ALGORITHM +200E SIM:fil_msg/READ_BINARY +200F SIM:fil_msg/READ_RECORD +2010 SIM:fil_msg/GET_RESPONSE +2011 SIM:fil_msg/UPDATE_BINARY +2012 SIM:fil_msg/INVALIDATE +2013 SIM:fil_msg/REHABILITATE +2014 SIM:fil_msg/INCREASE +2015 SIM:fil_msg/RESET +2016 SIM:fil_msg/DEACTIVATE +2017 SIM:fil_msg/TERMINAL_PROFILE +2018 SIM:fil_msg/ENVELOPE +2019 SIM:fil_msg/FETCH +201A SIM:fil_msg/TERMINAL_RESPONSE +201B SIM:fil_msg/AUTHENTICATE +201C SIM:fil_msg/AKEY_VALIDATE +201D SIM:fil_msg/ASK_RANDOM +201E SIM:fil_msg/UPDATE_SSD +201F SIM:fil_msg/CONFIRM_SSD +2020 SIM:fil_msg/CMEA_ENCRYPT +2021 SIM:fil_msg/SWITCH_TO_5V +2022 SIM:fil_msg/VOLTAGE_SET +2023 SIM:fil_msg/SEND_ADM_CODE +21XX SIM_L2:msg/SIM_L2_MSG_TRA +2100 SIM_L2:msg/MSG_DATA +22XX SIM_L2:data/SIM_L2_DATA_TRA +2200 SIM_L2:data/RECEIVED_DATA +2201 SIM_L2:data/SENT_DATA +23XX SIM_L2:resp/SIM_L2_RESP_TRA +2300 SIM_L2:resp/UNKNOWN_PRIMITIVE +2301 SIM_L2:resp/CARD_NOT_OK +2302 SIM_L2:resp/BINARY_DATA_AVAIL +2303 SIM_L2:resp/FORMATTED_DATA_AVAIL +2304 SIM_L2:resp/SRES_KC_DATA_AVAIL +2305 SIM_L2:resp/DFIELD_INFO_AVAIL +2306 SIM_L2:resp/DIR_INFO_AVAIL +2307 SIM_L2:resp/ATR_TRACE +2308 SIM_L2:resp/MEMORY_PROBLEM +2309 SIM_L2:resp/OK +230A SIM_L2:resp/DFIELD_NOT_SELECTED +230B SIM_L2:resp/PATTERN_NOT_FOUND +230C SIM_L2:resp/OUT_OF_RANGE +230D SIM_L2:resp/ILLEGAL_OPERATION +230E SIM_L2:resp/NO_PIN +230F SIM_L2:resp/SECURITY_VIOLATION +2310 SIM_L2:resp/PIN_STATUS_MISMATCH +2311 SIM_L2:resp/CARD_BLOCKED +2312 SIM_L2:resp/TECH_PROB_NO_DIAG +2313 SIM_L2:resp/CARD_DISCONNECTED +2314 SIM_L2:resp/ICC_INSERTED +2315 SIM_L2:resp/MAX_VALUE_REACHED +2316 SIM_L2:resp/DUALMODE_DATA_AVAIL +2317 SIM_L2:resp/3V_SIM +2318 SIM_L2:resp/5V_SIM +2319 SIM_L2:resp/ENHANCED_PTS +231A SIM_L2:resp/ATR_FAILED +231B SIM_L2:resp/ERROR_IN_ATR +231C SIM_L2:resp/SEND_FAILED +231D SIM_L2:resp/PARITY_ERROR +231E SIM_L2:resp/TIMEOUT_ERROR +231F SIM_L2:resp/COMM_ERROR +2320 SIM_L2:resp/OVERFLOW_ERROR +2321 SIM_L2:resp/RESP_NOT_OK +2322 SIM_L2:resp/FETCH_REQUEST +2323 SIM_L2:resp/PROACTIVE_CMD +2324 SIM_L2:resp/INCREASE_INFO +2325 SIM_L2:resp/ENVELOPE_RESP +2326 SIM_L2:resp/INVALIDATION_STATUS_MISMATCH +2327 SIM_L2:resp/DUALMODE_SIM_SSD_IS_INCORRECT +2328 SIM_L2:resp/CARD_NOT_OK +2329 SIM_L2:resp/ENVELOPE_RESP_AVAILABLE +232A SIM_L2:resp/ATR_RECIEVED +232B SIM_L2:resp/CARD_BUSY +24XX L2:prim/L2_PRIMITIVE_TRA +2400 L2:prim/RR->:EST_REQ(0/05DD) +2401 L2:prim/RR->:RELEASE_REQ(0/05DE) +2402 L2:prim/RR->:ABORT_REQ(0/05DF) +2403 L2:prim/RR->:DATA_REQ(0/05E0) +2404 L2:prim/RR->:UNIT_DATA_REQ(0/05E1) +2405 L2:prim/RR->:SUSPEND_REQ(0/05E2) +2406 L2:prim/RR->:RESUME_REQ(0/05E3) +2407 L2:prim/RR->:RESUME_COMPLETE_REQ(0/060A) +2408 L2:prim/RR->:LOCAL_RELEASE_REQ(0/060B) +2409 L2:prim/RR<-:EST_CNF(0/05E6) +240A L2:prim/RR<-:EST_IND(0/05E7) +240B L2:prim/RR<-:RELEASE_CNF(0/05E8) +240C L2:prim/RR<-:RELEASE_IND(0/05E9) +240D L2:prim/RR<-:DATA_IND(0/05EA) +240E L2:prim/RR<-:UNIT_DATA_IND(0/05EB) +240F L2:prim/RR<-:SUSPEND_CNF(0/05EC) +2410 L2:prim/RR<-:RESUME_CNF(0/05ED) +2411 L2:prim/RR<-:ERROR_IND(0/05EE) +2412 L2:prim/RR<-:ABORT_IND(0/05EF) +2413 (0/0623) +2414 (0/0624) +2415 (0/0622) +2416 L2:prim/RR->:T200:TIMEOUT(0/05FB) +2417 L2:prim/RR->:T203:TIMEOUT(0/05FA) +2419 L2:prim/SMS->SAPI3_SACCH_REL_IND(0/0620) +241A L2:prim/SMS->SAPI3_NON_SACCH_REL_IND(0/0621) +25XX RR:prim/RR_PRIMITIVE_TRA +2500 RR:prim/L2<-:DL_EST_REQ(1/05DD) +2501 RR:prim/L2<-:DL_RELEASE_REQ(1/05DE) +2502 RR:prim/L2<-:DL_ABORT_REQ(1/05DF) +2503 RR:prim/L2<-:DL_DATA_REQ(1/05E0) +2504 RR:prim/L2<-DL_UNIT_DATA_REQ(1/05E1) +2505 RR:prim/L2<-:DL_SUSPEND_REQ(1/05E2) +2506 RR:prim/L2<-:DL_RESUME_REQ(1/05E3) +2507 RR:prim/L2<-:DL_RESUME_COMPLETE_REQ(1/060A) +2508 RR:prim/L2<-:DL_LOCAL_RELEASE_REQ(1/060B) +2509 RR:prim/L2->:DL_EST_CNF(1/05E6) +250A RR:prim/L2<-:DL_EST_IND(1/05E7) +250B RR:prim/L2->:DL_RELEASE_CNF(1/05E8) +250C RR:prim/L2->:DL_RELEASE_IND(1/05E9) +250D RR:prim/L2->:DL_DATA_IND(1/05EA) +250E RR:prim/L2->:DL_UNIT_DATA_IND(1/05EB) +250F RR:prim/L2->:DL_SUSPEND_CNF(1/05EC) +2510 RR:prim/L2->:DL_RESUME_CNF(1/05ED) +2511 RR:prim/L2->:DL_ERROR_IND(1/05EE) +2512 RR:prim/L2->:DL_ABORT_IND(1/05EF) +2513 RR:prim/MM->:REL_IND(1/07DB) +2514 RR:prim/MM->:SYNC_IND(1/07DC) +2515 RR:prim/MM->:TCH_NOT_ALLOC_IND(1/07E2) +2516 (1/07E3) +2517 RR:prim/MM->:DATA_IND(1/07DD) +2518 RR:prim/MM<-:ABORT_REQ(1/07D5) +2519 RR:prim/MM<-:ACTIVATE_REQ(1/07D6) +251A (1/0824) +251B (1/0A03) +251C (1/0A04) +251D (1/0A05) +251E (1/0A06) +251F (1/0A07) +2521 (1/0A09) +2523 (1/0825) +2524 (1/0826) +2525 (1/0A0A) +2527 RR:prim/MM->:UNIT_DATA_IND(1/07DE) +2528 (1/0A0B) +2529 RR:prim/MM<-:DEACTIVATE_REQ(1/07D7) +252A RR:prim/MM<-:CLASSMARK_CHANGE_REQ(1/07D8) +252B (1/09FD) +2531 RR:prim/MM->:TCH_SPEECH_ALLOC_IND(1/07E1) +2533 (1/040D) +2534 (1/03FE) +2535 RR:prim/L1->:RANDOM_ACCESS_IND(1/0400) +2536 RR:prim/L1->:RESEL_NEEDED_IND(1/0402) +2537 (1/0405) +2538 RR:prim/L1->:RESEL_IMPOSSIBLE_IND(1/0404) +2539 RR:prim/L1->:AG_TIMEOUT_IND(1/0401) +253A (1/0409) +253B RR:prim/L1->:RESEL_FAIL_IND(1/0403) +253C (1/0406) +253D (1/040C) +253E (1/040B) +253F RR:prim/L1->:CIPHER_START_REQ(1/03F4) +2540 (1/0804) +2542 (1/07FE) +2543 (1/0800) +2544 (1/0803) +2545 (1/0802) +2546 (1/0801) +2547 RR:prim/L1->:ERROR_IND(1/03FF) +2548 RR:prim/L1->:HANDOVER_REQ(1/03EE) +2556 RR:prim/L1->:CIPHER_STOP_REQ(1/03F5) +2557 RR:prim/L1->:PAGE_MODE_REQ(1/03F6) +2558 (1/07FD) +255D (1/09FF) +255E RR:prim/MM<-:EST_REQ(1/07D1) +255F RR:prim/MM<-:REL_REQ(1/07D2) +2560 RR:prim/MM<-:DATA_REQ(1/07D3) +2561 RR:prim/MM<-:UNIT_DATA_REQ(1/07D4) +2562 RR:prim/MM->:EST_CNF(1/07D9) +2563 RR:prim/MM->:EST_IND(1/07DA) +2564 RR:prim/MM->:ABORT_IND(1/07DF) +2565 RR:prim/MM->:ACTIVATE_IND(1/07E0) +2566 RR:prim/MM->:T3122_TIMEOUT_IND(1/07E4) +2567 RR:prim/MM<-:PREACTIVATE_REQ(1/07E5) +2568 RR:prim/MM->:PREACTIVATE_CNF(1/07E6) +2569 (1/07E7) +256A (1/09F7) +256B (1/09F8) +256C (1/09F9) +256D (1/09FA) +256E (1/09FB) +256F (1/09FC) +2570 (1/09FE) +2571 (1/0A02) +2572 (1/0A0C) +26XX MM:prim/MM_PRIMITIVE_TRA +2600 MM:prim/RM->:NREG_IND_LA_ON_REG_LIST(2/0A29) +2601 MM:prim/RM->:CONN_COMPL_IND(2/0A2A) +2602 MM:prim/RM->:CONN_REL_IND(2/0A2B) +2603 (2/0A2C) +2604 (2/0A2D) +2605 MM:prim/RR->:LIMITED_SERVICE_STATE_REQ(2/0A2E) +2606 MM:prim/RM->:PLMN_SEARCH_TERM_IND(2/0A2F) +2607 MM:prim/RM<-:PLMN_SEARCH_START_REQ(2/0A30) +2608 (2/0A36) +2609 (2/0A37) +260A (2/0A38) +260B (2/0A39) +260C (2/0A3B) +260D (2/0A3C) +260E (2/0A3E) +260F (2/0A40) +2610 (2/0A42) +2611 (2/0A43) +2612 (2/0A45) +2613 (2/0A46) +2614 (2/0A48) +2615 (2/0A49) +2616 (2/0A4B) +2617 (2/0A4D) +2618 (2/0A4F) +261A (2/158C) +261C (2/0A50) +261D (2/158D) +261E (2/1580) +2620 (2/1581) +2621 (2/1582) +2623 (2/0A64) +2624 (2/0A65) +2625 (2/0A66) +2626 (2/0A67) +2627 (2/0A68) +2628 (2/0A69) +2629 (2/0A6A) +262A (2/0A6C) +262B (2/0A6D) +262C (2/0A6E) +262D (2/0A55) +262E (2/0A56) +262F (2/0A57) +2630 (2/0A58) +2631 (2/0A59) +2632 (2/0A5A) +2633 (2/0A62) +2634 (2/0A63) +2635 (2/0A85) +2636 (2/0A87) +2637 (2/0A8C) +2638 (2/0A88) +2639 (2/0A8D) +263C (2/0DDF) +263D MM:prim/RR<-:REL_IND(2/07DB) +263E MM:prim/RR<-:SYNC_IND(2/07DC) +263F (2/07E2) +2640 MM:prim/RR<-:DATA_IND(2/07DD) +2641 MM:prim/RR->:ABORT_REQ(2/07D5) +2642 MM:prim/RR->:ACTIVATE_REQ(2/07D6) +2643 MM:prim/CM<-:EST_REQ_EMERGENCY(2/0A03) +2644 MM:prim/CM<-:REEST_REQ(2/0A04) +2645 MM:prim/CM<-:REL_REQ(2/0A05) +2646 MM:prim/CM<-:DATA_REQ(2/0A06) +2647 MM:prim/MM<-:LAI_LISTS_TIMEOUT(2/0A07) +2649 MM:prim/CM->:EST_CNF(2/0A09) +264B MM:prim/CM->:ERROR_IND(2/0A0A) +264C (2/0A0B) +264D MM:prim/RR->:DEACTIVATE_REQ(2/07D7) +264E (2/07D8) +264F MM:prim/MM<-:T3240_TIMEOUT(2/09FD) +2653 MM:prim/RR<-:UNIT_DATA_IND(2/07DE) +2654 (2/07E1) +2655 (2/0A5B) +2656 (2/0A5C) +2657 (2/0A5D) +2658 (2/0A5E) +2659 (2/0A5F) +265A (2/0A60) +265B (2/0A61) +265C (2/0A81) +265D (2/0A6B) +265E MM:prim/SMS<-:DATA_REQ(2/09C9) +265F MM:prim/SMS->:ERROR_IND(2/09CA) +2660 (2/158A) +2668 (2/0AA0) +2669 (2/0AA1) +266A MM:prim/SMS->:REL_IND(2/09CB) +2675 (2/1584) +2676 (2/1585) +2677 (2/1586) +2678 (2/1587) +2679 (2/1588) +267A (2/158E) +267B MM:prim/RR->:EST_REQ(2/07D1) +267C MM:prim/RR->:REL_REQ(2/07D2) +267D MM:prim/RR->:DATA_REQ(2/07D3) +267E (2/07D4) +267F MM:prim/RR<-:EST_CNF(2/07D9) +2680 MM:prim/RR<-:EST_IND(2/07DA) +2681 MM:prim/RR<-:ABORT_IND(2/07DF) +2682 MM:prim/RR<-:ACTIVATE_IND(2/07E0) +2683 MM:prim/RR<-:T3122_TIMEOUT_IND(2/07E4) +2684 MM:prim/RR->:PREACTIVATE_REQ(2/07E5) +2685 MM:prim/RR->:PREACTIVATE_CNF(2/07E6) +2686 (2/07E7) +2687 MM:prim/MM<-:T3210_TIMEOUT(2/09F7) +2688 MM:prim/MM<-:T3211_TIMEOUT(2/09F8) +2689 MM:prim/MM<-:T3212_TIMEOUT(2/09F9) +268A MM:prim/MM<-:T3213_TIMEOUT(2/09FA) +268B MM:prim/MM<-:T3220_TIMEOUT(2/09FB) +268C MM:prim/MM<-:T3230_TIMEOUT(2/09FC) +268D MM:prim/RM->:NREG_IND_NO_IMSI(2/09FE) +268E MM:prim/CM<-:EST_REQ_NORMAL(2/0A02) +268F (2/0A0C) +27XX CC:prim/CC_PRIMITIVE_TRA +2700 (3/0FA2) +2701 CC:prim/CS->:SETUP_REQ(3/0FA3) +2702 CC:prim/CS->:EMERGENCY_SETUP_REQ(3/0FA4) +2703 CC:prim/CS->:SETUP_RES(3/0FA5) +2704 CC:prim/CS->:SETUP_REJ_REQ(3/0FA6) +2705 CC:prim/CS->:CALL_CONF_REQ(3/0FA7) +2706 CC:prim/CS->:MODIFY_REQ(3/0FA8) +2707 CC:prim/CS->:NOTIFY_REQ(3/0FA9) +2708 CC:prim/CS->:DISC_REQ(3/0FAA) +2709 CC:prim/CS->:REL_REQ(3/0FAB) +270A CC:prim/CS->:ALERTING_REQ(3/0FAC) +270C CC:prim/CS->:STATUS_ENQ_REQ(3/0FAE) +270E CC:prim/CS->:MODIFY_RES(3/0FB0) +270F CC:prim/CS->:MODIFY_REJ_REQ(3/0FB1) +2710 CC:prim/CS->:SS_REQ(3/0FB2) +2711 CC:prim/CS->:REJ_REQ(3/0FB3) +2712 CC:prim/CS<-:SETUP_IND(3/0FB4) +2713 CC:prim/CS<-:SETUP_CNF(3/0FB5) +2714 CC:prim/CS<-:SETUP_COMPL_IND(3/0FB6) +2715 CC:prim/CS<-:CALL_PROC_IND(3/0FB7) +2716 CC:prim/CS<-:PROGRESS_IND(3/0FB8) +2717 CC:prim/CS<-:ALERT_IND(3/0FB9) +271A CC:prim/CS<-:MODIFY_REJ_IND(3/0FBC) +271B CC:prim/CS<-:NOTIFY_IND(3/0FBD) +271C CC:prim/CS<-:DISC_IND(3/0FBE) +271D CC:prim/CS->:REJ_IND(3/0FBF) +271E CC:prim/CS->:REL_IND(3/0FC0) +271F CC:prim/CS<-:START_DTMF_CNF(3/0FC1) +2720 CC:prim/CS<-:START_DTMF_REJ_IND(3/0FC2) +2721 CC:prim/CS<-:STATE_UPDATE_IND(3/0FC3) +2722 CC:prim/CS<-:STATUS_IND(3/0FC4) +2723 CC:prim/CS<-:STOP_DTMF_IND(3/0FC5) +2724 CC:prim/CS<-:STOP_DTMF_CNF(3/0FC6) +2725 CC:prim/CS<-:ERROR_IND(3/0FC7) +2726 CC:prim/CS<-:SS_IND(3/0FC8) +2727 CC:prim/CS<-:REL_CNF(3/0FC9) +2728 CC:prim/CS<-:REL_COMPL_IND(3/0FCA) +2729 CC:prim/MM<-:MM_CONN_COMPL_IND(3/0FCB) +272A (3/100F) +272B (3/1010) +272C (3/1011) +272D (3/1012) +272E (3/1013) +272F (3/1014) +2730 (3/100D) +2731 (3/100E) +2732 (3/1020) +2733 (3/101C) +2734 (3/0A36) +2735 (3/0A37) +2736 (3/0A38) +2737 (3/0A39) +273E CC:prim/CS->:RESET_REQ(3/0FA1) +28XX CS:prim/CS_PRIMITIVE_TRA +2800 (5/15B4) +2802 CS:prim/PLMN_SELECT(5/157D) +2806 (5/15AE) +2807 (5/15AF) +280A (5/157E) +280B (5/15B2) +280C (5/15B3) +280E (5/15B5) +280F (5/15A4) +2810 (5/15A5) +2811 (5/15A6) +2812 (5/15A7) +2815 (5/15A8) +2816 (5/15A9) +2819 CS:prim/CC->:ALERT_IND(5/0FB9) +281A CS:prim/CC<-ALERTING_REQ(5/0FAC) +281B CS:prim/CC<-:CALL_CONF_REQ(5/0FA7) +281D CS:prim/CC->:DISC_IND(5/0FBE) +281E CS:prim/CC<-:DISC_REQ(5/0FAA) +2820 (5/1010) +2821 (5/100F) +2822 (5/1011) +2823 CS:prim/MM->:CONN_COMPL_IND(5/0FCB) +2826 CS:prim/CC<-:MODIFY_REQ(5/0FA8) +2827 CS:prim/CC->:MODIFY_RES(5/0FB0) +2828 CS:prim/CC<-:MODIFY_REJ_REQ(5/0FB1) +2829 CS:prim/CC->:MODIFY_REJ_IND(5/0FBC) +282B CS:prim/CC->:PROGRESS_IND(5/0FB8) +282C (5/100D) +282D (5/100E) +2830 CS:prim/CC<-:REL_IND(5/0FC0) +2831 CS:prim/CC<-:REL_REQ(5/0FAB) +2832 CS:prim/CC->:REL_COMPL_IND(5/0FCA) +2833 (5/1013) +2834 (5/1012) +2835 (5/1014) +2836 CS:prim/CC->:SETUP_CNF(5/0FB5) +2837 CS:prim/CC->:SETUP_COMPL_IND(5/0FB6) +2838 CS:prim/CC->:SETUP_IND(5/0FB4) +2839 CS:prim/CC<-:SETUP_REQ(5/0FA3) +283A CS:prim/CC->:SETUP_RES(5/0FA5) +283B CS:prim/CC<-:SETUP_REJ_REQ(5/0FA6) +283C CS:prim/CC->:SS_IND(5/0FC8) +283D CS:prim/CC<-:SS_REQ(5/0FB2) +283E CS:prim/CC<-:START_DTMF_REQ(5/0FAD) +2841 CS:prim/CC<-:STOP_DTMF_REQ(5/0FAF) +2843 (5/1015) +2844 (5/1016) +2845 (5/101C) +2846 (5/101D) +2847 (5/101E) +2848 (5/1020) +2849 (5/0A36) +284A (5/0A37) +284B (5/0A38) +284C (5/0A39) +284E (5/0A65) +284F (5/0A64) +2854 CS:prim/PLMN_SEARCH(5/1589) +285B (5/0826) +285C (5/0825) +2861 (5/15B6) +29XX SSCL:prim/SSCL_PRIMITIVE_TRA +2900 SSCL:prim/SS_UPL->:BEGIN_IND(6/1771) +2901 SSCL:prim/SS_UPL->:END_IND(6/1773) +2902 SSCL:prim/SS_UPL->:ERROR_IND(6/1774) +2903 SSCL:prim/MM<-:FACILITY_IND(7/177A) +2904 SSCL:prim/SS_UPL->:PARA_CONN_IND(6/177D) +2905 SSCL:prim/SS_UPL->:REL_IND(6/1775) +2906 SSCL:prim/MM->:PARA_MM_SS_REL_REQ(6/177F) +2907 SSCL:prim/MM->:PARA_MM_SS_DATA_REQ(6/179B) +2908 SSCL:prim/MM->:SS_DATA_REQ(6/0A46) +2909 SSCL:prim/MM->:SS_EST_REQ(6/0A43) +290A SSCL:prim/MM->:SS_REL_REQ(6/0A45) +290B SSCL:prim/UNKNOWN_SSCL_PRIMITIVE +2AXX SMS:prim/SMS_PRIMITIVE_TRA +2A00 SMS:prim/SMTL<-:SMRL_MEM_CAP_AVAIL_REQ(8/0BBF) +2A01 SMS:prim/SMTL<-:SMRL_DATA_REQ(8/0BB9) +2A02 SMS:prim/SMTL->:SMRL_REPORT_IND(8/0BBA) +2A03 SMS:prim/SMTL->:SMRL_DATA_IND(8/0BBC) +2A04 SMS:prim/SMTL->:SMRL_DATA_RSP(8/0BBD) +2A05 SMS:prim/SMTL<-:SMRL_INIT_STD_REQ(8/0BBE) +2A06 SMS:prim/SMTL<-:CB_ACTIVATE_REQ(8/0BC0) +2A07 SMS:prim/SMTL<-:CB_DEACTIVATE_REQ(8/0BC1) +2A08 SMS:prim/SMTL<-:MEM_CAP_AVAIL_REQ(8/0BBF) +2A09 SMS:prim/SMTL<-:SMTL_TPDU(8/0BEB) +2A0A SMS:prim/SMRL<-:SMCL_DATA_REQ(8/0DAD) +2A0B SMS:prim/SMRL->:SMCL_DATA_IND(8/0DAE) +2A0C SMS:prim/SMRL<-:SMCL_ABORT_REQ(8/0DAF) +2A0D SMS:prim/SMRL->:SMCL_EST_IND(8/0DB0) +2A0E SMS:prim/SMRL<-:SMCL_EST_REQ(8/0DB1) +2A0F SMS:prim/SMRL->:SMCL_ERROR_IND(8/0DB2) +2A10 SMS:prim/SMRL<-:SMCL_REL_REQ(8/0DB3) +2A11 SMS:prim/SMRL<-:SMCL_INIT_STD_REQ(8/0DB4) +2A12 SMS:prim/UNKNOWN_SMS_PRIMITIVE +2A13 SMS:prim/MM<-:SMSCB_ZONE_CHANGED_IND +2A14 SMS:prim/MM<-:EST_IND(8/0A29) +2A15 SMS:prim/MM->:EST_REQ(8/0A2A) +2A16 SMS:prim/MM<-:EST_CNF(8/0A2B) +2A17 SMS:prim/MM<-:DATA_IND(8/0A2C) +2A18 SMS:prim/MM->:DATA_REQ(8/0A2D) +2A19 SMS:prim/MM<-:ERROR_IND(8/0A2E) +2A1A SMS:prim/MM<-:REL_IND(8/0A2F) +2A1B SMS:prim/MM->:REL_REQ(8/0A30) +2A1C SMS:prim/L2<-SAPI3_SACCH_REL_IND(8/0620) +2A1D SMS:prim/L2<-SAPI3_NON_SACCH_REL_IND(8/0621) +2BXX SIM:prim/SIM_PRIMITIVE_TRA +2B00 SIM:prim/PIN_VERIFY_START +2B01 SIM:prim/PIN_CHANGE_START +2B02 SIM:prim/PIN_DISABLE_START +2B03 SIM:prim/PIN_ENABLE_START +2B04 SIM:prim/UNBLOCK_START +2B05 SIM:prim/INIT +2B06 SIM:prim/DEACTIVATE +2B07 SIM:prim/UPDATE +2B08 SIM:prim/COMPUTE_GSM_ALGORITHMS +2B09 SIM:prim/STORE_SCM_NBR +2B0A SIM:prim/SCM_NBR_TO_BE_STORED +2B0B SIM:prim/RECALL_SCM_NBR +2B0C SIM:prim/PIN2_VERIFY_START +2B0D SIM:prim/PIN2_CHANGE_START +2B0E SIM:prim/PIN2_UNBLOCK_START +2B0F SIM:prim/ACM_INCREMENT +2B10 SIM:prim/ACM_SET +2B11 SIM:prim/ACM_MAX_VALUE_SET +2B12 SIM:prim/PUCT_SET +2B13 SIM:prim/PUCT_READ +2B14 SIM:prim/STORE_MSISDN_NBR +2B15 SIM:prim/READ_MSISDN_NBR +2B16 SIM:prim/STORE_SMS_PARAM +2B17 SIM:prim/READ_SMS_PARAM +2B18 SIM:prim/STORE_FIXDIAL_NUMBER +2B19 SIM:prim/READ_FIXDIAL_NUMBER +2B1A SIM:prim/ACTIVATE_FIXDIAL +2B1B SIM:prim/DEACTIVATE_FIXDIAL +2B1C SIM:prim/FDN_NBR_TO_BE_STORED +2B1D SIM:prim/MSISDN_TO_BE_STORED +2B1E SIM:prim/STO_SCM_NBR +2B1F SIM:prim/RCL_SCM_NBR +2B20 SIM:prim/SMS_PARAM_TO_BE_STORED +2B21 SIM:prim/RECALL_SCM_NBR_SIF +2B22 SIM:prim/TEST_SYNC_MSG +2B23 SIM:prim/ACM_FROM_CARD +2B24 SIM:prim/MAILBOX_NBR_STORE_MSG +2B25 SIM:prim/MAILBOX_NBR_READ_MSG +2B26 SIM:prim/OPERATOR_NAME_READ_MSG +2B27 SIM:prim/MICROTEL_PARAMS_READ_MSG +2B28 SIM:prim/CSP_READ_MSG +2B29 SIM:prim/MAILBOX_NBR_TO_BE_STORED +2B2A SIM:prim/SMS_READ_MSG +2B2B SIM:prim/SMS_STORE_MO_MSG +2B2C SIM:prim/SMS_CLEAR_MSG +2B2D SIM:prim/SMS_UPDATE_MSG +2B2E SIM:prim/SMS_STORE_MT_MSG +2B2F SIM:prim/SMS_MSG_TO_BE_STORED +2B30 SIM:prim/SMS_STORE_MSG +2B31 SIM:prim/SMS_INIT +2B32 SIM:prim/SCM_INIT +2B33 SIM:prim/FDN_INIT +2B34 SIM:prim/UNDEFINED_SIM_PRIMITIVE +2B35 SIM:prim/PIN_CHECK_START +2B36 SIM:prim/SIM_REFRESH +2B37 SIM:prim/SMS_STORE_AND_CLEAR +2B38 SIM:prim/WELCOME_MSG_READ +2B39 SIM:prim/FIRST_PLMN_WRITE +2B3A SIM:prim/UPDATE_MSG_REF +2B3B SIM:prim/PLUG_IN_CARD_DISCONNECTED +2B3C SIM:prim/READ_INF_NBR_MSG +2B3D SIM:prim/READ_JACOB_ID_MSG +2B3E SIM:prim/SIMP_WARM_INIT +2B3F SIM:prim/SIMP_REFRESH_RSP +2B40 SIM:prim/SIMP_UI_REFRESH_RSP +2B41 SIM:prim/SIMP_SMS_PP_STORE_MSG +2B42 SIM:prim/READ_SID_LIST +2B43 SIM:prim/READ_CALL_COUNT +2B44 SIM:prim/INC_CALL_COUNT +2B45 SIM:prim/WRITE_CALL_COUNT +2B46 SIM:prim/AUTH_SIGN_CALC +2B47 SIM:prim/AUTH_RANDBS_GET +2B48 SIM:prim/AKEY_VALIDATE +2B49 SIM:prim/SSD_GENERATE +2B4A SIM:prim/SSD_CONFIRM +2B4B SIM:prim/CMEA_ENCRYPT +2B4C SIM:prim/AUTH_CHECK +2CXX RM:prim/RM_PRIMITIVE_TRA +2C00 RM:prim/CC->:EMERGENCY_SETUP_REQ(4/0FA4) +2C01 RM:prim/MM->:LIMITED_SERVICE_STATE_REQ(4/09CF) +2C02 RM:prim/MM->:REG_REQ(4/09CD) +2C03 RM:prim/MM->:NREG_REQ(4/09CE) +2C04 RM:prim/MM->:SIM_INFO_READ_ALL_REQ(4/09D2) +2C05 RM:prim/MM->:SIM_INSERTED_REQ(4/09D3) +2C06 RM:prim/MM->:PLMN_SEARCH_START_REQ(4/09C9) +2C07 RM:prim/MM->:PLMN_SEARCH_STOP_REQ(4/09CA) +2C08 RM:prim/MM->:PLMN_REL_SEARCH_INFO(4/09CB) +2C09 RM:prim/MM->:PH_UPL_PLMN_SEARCH_START_REQ(4/09C8) +2C0A RM:prim/MM->PH_UPL_PLMN_SEARCH_STOP_REQ(4/09C7) +2C0B RM:prim/MM->:NSPS_MON_START_REQ(4/09C5) +2C0C RM:prim/MM->:NSPS_MON_STOP_REQ(4/09C6) +2C0D RM:prim/UNKNOWN_RM_PRIMITIVE(4/09CC) +2C0E (4/09D0) +2C0F (4/09D1) +2C10 (4/09D6) +2DXX L2:pdu/L2_PDU_TRA +2D00 L2:pdu/->:DISC(9/060F) +2D01 L2:pdu/->:DM(9/0610) +2D02 L2:pdu/->:EMPTY(9/0611) +2D03 L2:pdu/->:RRE(9/0612) +2D04 L2:pdu/->:SABM(9/0613) +2D05 L2:pdu/->:UA(9/0614) +2D06 (9/1025) +2D07 L2:pdu/->:I_CMD(9/0616) +2D08 L2:pdu/->:RNR(9/0617) +2D09 L2:pdu/->:REJ(9/0618) +2D0A L2:pdu/->:UNNUMBERED_INFO(9/061A) +2D0B L2:pdu/->:PDU_ERROR(9/061B) +2D0C L2:pdu/<-:DISC(10/060F) +2D0D L2:pdu/<-:DM(10/0610) +2D0E L2:pdu/<-:EMPTY(10/0611) +2D0F L2:pdu/<-:RRE(10/0612) +2D10 L2:pdu/<-:SABM(10/0613) +2D11 L2:pdu/<-:UA(10/0614) +2D12 (10/1025) +2D13 L2:pdu/<-:I_CMD(10/0616) +2D14 L2:pdu/<-:RNR(10/0617) +2D15 L2:pdu/<-:REJ(10/0618) +2D16 L2:pdu/<-:UNNUMBERED_INFO(10/061A) +2D17 L2:pdu/<-:PDU_ERROR(10/061B) +2EXX RR:pdu/RR_PDU_TRA +2E00 RR:pdu/->:CH_REQ +2E01 RR:pdu/->:ASSIGN_COM(11/08A6) +2E02 RR:pdu/->:ASSIGN_FAILURE(11/08A7) +2E03 RR:pdu/->:CH_MODE_MODIFY_ACK(11/08A8) +2E04 RR:pdu/->:HANDOVER_COM(11/08A9) +2E05 RR:pdu/->:HANDOVER_FAILURE(11/08AA) +2E06 RR:pdu/->:RR_STATUS(11/08AB) +2E07 RR:pdu/->:PAGING_RESP(11/08AC) +2E08 RR:pdu/->:CIPH_MODE_COM(11/08AD) +2E09 RR:pdu/->:CLASSMARK_CHANGE(11/08AE) +2E0A RR:pdu/<-:PDU_IGNORE(12/0000) +2E0B RR:pdu/<-:ASSIGN_CMD(12/0898) +2E0C RR:pdu/<-:IMM_ASSIGN(12/0899) +2E0D RR:pdu/<-:IMM_ASSIGN_REJ(12/089A) +2E0E RR:pdu/<-:CH_MODE_MODIFY(12/089B) +2E0F RR:pdu/<-:HANDOVER_CMD(12/089C) +2E10 RR:pdu/<-:PHYS_INFO(12/089D) +2E11 RR:pdu/<-:CH_REL(12/089E) +2E12 RR:pdu/<-:CLASSMARK_ENQ(12/089F) +2E13 RR:pdu/<-:FREQ_REDEF(12/08A0) +2E14 RR:pdu/<-:CIPH_MODE_CMD(12/08A1) +2E15 RR:pdu/<-:PAG_REQ_1(12/08A2) +2E16 RR:pdu/<-:PAG_REQ_2(12/08A3) +2E17 RR:pdu/<-:PAG_REQ_3(12/08A4) +2E18 RR:pdu/<-:CLASSMARK_CHANGE(12/08AE) +2E19 RR:pdu/<-:OWN_PAGE_MODE(12/08AF) +2E1A RR:pdu/<-:MESSAGE_TYPE_ERROR(12/08B0) +2E1B RR:pdu/<-:IE_CONTENT_ERROR(12/08B1) +2E1C RR:pdu/<-:ASSIGN_CMD_MISSING_CA(12/08B2) +2E1D RR:pdu/<-:ASSIGN_CMD_CH_MODE_ERR(12/08B3) +2E1E RR:pdu/<-:ASSIGN_CMD_FREQ_ERR(12/08B4) +2E1F RR:pdu/<-:HANDOVER_CMD_CH_MODE_ERR(12/08B5) +2E20 RR:pdu/<-:HANDOVER_CMD_CIPH_MSG_ERR(12/08C2) +2E21 RR:pdu/<-:HANDOVER_CMD_FREQ_ERR(12/08B6) +2E22 RR:pdu/<-:HANDOVER_CMD_TA_RANGE_ERR(12/08C4) +2E23 RR:pdu/<-:ASSIGN_FREQLIST_ID_ERROR(12/08BA) +2E24 RR:pdu/<-:HO_FREQLIST_ID_ERROR(12/08BB) +2E25 RR:pdu/<-:HO_FREQLIST_SHORT_ERROR(12/08BC) +2E26 RR:pdu/<-:UNSPEC_PROTOCOL_ERROR(12/08BD) +2E27 RR:pdu/<-:MESSAGE_MAND_INFO_ERROR(12/08BE) +2E28 RR:pdu/<-:MESSAGE_PROTOCOL_STATE_ERROR(12/08BF) +2E29 RR:pdu/<-:MESSAGE_SEMANTICAL_ERROR(12/08C0) +2E2A RR:pdu/<-:MESSAGE_COND_INFO_ERROR(12/08C1) +2E2B RR:pdu/<-:ASSIGN_CMD_CIPH_MSG_ERR(12/08C3) +2E2C RR:pdu/<-:IMM_ASS_SEMANTIC_ERROR(12/08C5) +2E2D RR:pdu/UNKNOWNPDU +2E2E RR:pdu/->:CONFIG_CHANGE_ACK +2E2F RR:pdu/->:CONFIG_CHANGE_REJ +2E30 RR:pdu/<-:CONFIG_CHANGE +2FXX MM:pdu/MM_PDU_TRA +2F00 MM:pdu/->:CM_SERV_ABORT(13/0062) +2F01 MM:pdu/->:IMSI_DETACH_IND(13/0047) +2F02 MM:pdu/->:LOC_UPD_REQ(13/004A) +2F03 MM:pdu/->:AUT_RESPONSE(13/004D) +2F04 MM:pdu/->:TMSI_REAL_COM(13/004F) +2F05 MM:pdu/->:ID_RESPONSE(13/0051) +2F06 MM:pdu/->:CM_SERV_REQ(13/0054) +2F07 MM:pdu/->:PDU_CM_REEST_REQ(13/0055) +2F08 MM:pdu/->:MM_STATUS(13/0056) +2F09 MM:pdu/<-:LOC_UPD_ACCEPT(14/0048) +2F0A MM:pdu/<-:LOC_UPD_REJECT(14/0049) +2F0B MM:pdu/<-:AUT_REJ_CMD(14/004B) +2F0C MM:pdu/<-:AUT_REQ(14/004C) +2F0D MM:pdu/<-:TMSI_REAL_CMD(14/004E) +2F0E MM:pdu/<-:ID_REQ(14/0050) +2F0F MM:pdu/<-:CM_SERV_ACCEPT(14/0052) +2F10 MM:pdu/<-:CM_SERV_REJECT(14/0053) +2F11 MM:pdu/<-:MM_STATUS(14/0056) +2F12 MM:pdu/<-:RR_CM_DATA_IND(14/0057) +2F13 MM:pdu/<-:ILLEGAL_PDU(14/0063) +2F14 MM:pdu/<-:EMMI_PDU(14/0065) +2F15 MM:pdu/<-:ABORT(14/0061) +2F16 MM:pdu/<-:MM_INFORMATION(14/006B) +2F17 MM:pdu/<-:PDU_IGNORED(14/0064) +2F18 MM:pdu/UNKNOWNPDU +30XX CC:pdu/CC_PDU_TRA +3000 CC:pdu/->:ALERT(15/1022) +3001 CC:pdu/->:CALL_CONF(15/1023) +3002 CC:pdu/->:CONN(15/1025) +3003 CC:pdu/->:CONN_ACK(15/1026) +3004 CC:pdu/->:EMERGENCY_SETUP(15/1027) +3005 CC:pdu/->:SETUP(15/1029) +3006 CC:pdu/->:MODIFY +3007 CC:pdu/->:MODIFY_COM(15/102B) +3008 CC:pdu/->:MODIFY_REJ(15/102C) +3009 CC:pdu/->:DISC(15/102D) +300A CC:pdu/->:REL(15/102E) +300B CC:pdu/->:REL_COM(15/102F) +300C CC:pdu/->:CONG(15/1030) +300D CC:pdu/->:NOTIFY(15/1031) +300E CC:pdu/->:START_DTMF(15/1032) +300F CC:pdu/->:START_DTMF_ACK +3010 CC:pdu/->:START_DTMF_REJ +3011 CC:pdu/->:STATUS(15/1035) +3012 CC:pdu/->:STATUS_ENQ(15/1036) +3013 CC:pdu/->:STOP_DTMF(15/1037) +3014 CC:pdu/->:STOP_DTMF_ACK +3015 CC:pdu/->:HOLD(15/1039) +3016 CC:pdu/->:FACILITY(15/103A) +3017 CC:pdu/->:HOLD_REJ +3018 CC:pdu/->:RETRIEVE(15/103F) +3019 CC:pdu/->:USER_INFO(15/1040) +301A CC:pdu/->:UNKNOWN_PDU +301B CC:pdu/<-:ALERT(16/1022) +301C CC:pdu/<-:CALL_PROC(16/1024) +301D CC:pdu/<-:CONN(16/1025) +301E CC:pdu/<-:CONN_ACK(16/1026) +301F CC:pdu/<-:PROG(16/1028) +3020 CC:pdu/<-:SETUP(16/1029) +3021 CC:pdu/<-:MODIFY(16/102A) +3022 CC:pdu/<-:MODIFY_COM +3023 CC:pdu/<-:MODIFY_REJ +3024 CC:pdu/<-:DISC(16/102D) +3025 CC:pdu/<-:REL(16/102E) +3026 CC:pdu/<-:REL_COM(16/102F) +3027 CC:pdu/<-:CONG(16/1030) +3028 CC:pdu/<-:NOTIFY(16/1031) +3029 CC:pdu/<-:START_DTMF_ACK(16/1033) +302A CC:pdu/<-:START_DTMF_REJ(16/1034) +302B CC:pdu/<-:STATUS(16/1035) +302C CC:pdu/<-:STATUS_ENQ(16/1036) +302D CC:pdu/<-:STOP_DTMF_ACK(16/1038) +302E CC:pdu/<-:FACILITY(16/103A) +302F CC:pdu/<-:HOLD_REJ(16/103B) +3030 CC:pdu/<-:HOLD_ACK(16/103C) +3031 CC:pdu/<-:RETRIEVE_ACK(16/103D) +3032 CC:pdu/<-:RETRIEVE_REJ(16/103E) +3033 CC:pdu/<-:USER_INFO(16/1040) +3034 CC:pdu/<-:PDU_IGNORE +3035 CC:pdu/<-:UNKNOWN_PDU +3036 CC:pdu/UNKNOWN_PDU +3037 CC:pdu/Err/INVALID_TRAN_ID(16/1041) +3038 CC:pdu/Err/MESSAGE_MAND(16/1043) +3039 CC:pdu/Err/MESSAGE_COND(16/1049) +303A CC:pdu/Err/MESSAGE_PROTOCOL(16/104B) +303B CC:pdu/Err/MESSAGE_SEMANTICAL(16/104A) +303C CC:pdu/Err/MESSAGE_TYPE(16/1042) +303D CC:pdu/Err/DISC_MAND(16/1044) +303E CC:pdu/Err/DISC_OPT(16/1045) +303F CC:pdu/Err/PDU_IGNORE(16/0000) +3040 CC:pdu/Err/REL_MAND(16/1046) +3041 CC:pdu/Err/REL_OPT(16/1047) +3042 CC:pdu/Err/SETUP(16/1048) +31XX SSCL:pdu/SSCL_PDU_TRA +3100 SSCL:pdu/->:RELEASE_COMPLETE(17/002A) +3101 SSCL:pdu/->:FACILITY(17/003A) +3102 SSCL:pdu/->:REGISTER(17/003B) +3103 SSCL:pdu/<-:RELEASE_COMPLETE(18/002A) +3104 SSCL:pdu/<-:FACILITY(18/003A) +3105 SSCL:pdu/<-:REGISTER(18/003B) +3106 SSCL:pdu/UNKNOWN_PDU +32XX SMS:pdu/SMS_PDU_TRA +3200 SMS:pdu/->:RP_DATA(19/0BCD) +3201 SMS:pdu/->:RP_ACK(19/0BCE) +3202 SMS:pdu/->:RP_ERROR(19/0BCF) +3203 SMS:pdu/->:RP_SMMA(19/0BD0) +3204 SMS:pdu/->:TR1M_TIMEOUT(19/0BD7) +3205 SMS:pdu/->:TRAM_TIMEOUT(19/0BD8) +3206 SMS:pdu/->:TR99_TIMEOUT(19/0BD9) +3207 SMS:pdu/->:TR2M_TIMEOUT(19/0BDA) +3208 SMS:pdu/->:CP_WAIT_TIMEOUT(19/0DCD) +3209 SMS:pdu/->:CB_SCHEDULE_TIMEOUT(19/0DCE) +320A SMS:pdu/->:TC1M_TIMEOUT(19/0DCB) +320B SMS:pdu/->:TC2M_TIMEOUT(19/0DCC) +320C SMS:pdu/->:CP_DATA(19/0DC1) +320D SMS:pdu/->:CP_ACK(19/0DC2) +320E SMS:pdu/->:CP_ERROR(19/0DC3) +320F SMS:pdu/<-:RP_DATA(20/0BCD) +3210 SMS:pdu/<-:RP_ACK(20/0BCE) +3211 SMS:pdu/<-:RP_ERROR(20/0BCF) +3212 SMS:pdu/<-:CP_DATA(20/0DC1) +3213 SMS:pdu/<-:CP_ACK(20/0DC2) +3214 SMS:pdu/<-:CP_ERROR(20/0DC3) +3215 SMS:pdu/<-:CP_PDU_ERROR(20/0DC4) +3216 SMS:pdu/<-:CP_PDU_NEW_TRAN_ID(20/0DC5) +3217 SMS:pdu/UNKNOWN_PDU +33XX CS:trans/CS_TRANSITION_TRA +3300 CS:trans/TRANSITION_TO +34XX L2:trans/L2_TRANSITION_TRA +3400 L2:trans/TRANSITION_TO +35XX RR:trans/RR_TRANSITION_TRA +3500 RR:trans/TRANSITION_TO +36XX CC:trans/CC_TRANSITION_TRA +3600 CC:trans/TRANSITION_TO +37XX RM_CTRL:trans/RM_CTRL_TRANSITION_TRA +3700 RM_CTRL:trans/TRANSITION_TO +38XX MM:trans/MM_TRANSITION_TRA +3800 MM:trans/TRANSITION_TO +39XX SSCL:trans/SSCL_TRANSITION_TRA +3900 SSCL:trans/TRANSITION_TO +3AXX SSCL_MO:trans/SMCL_MO_TRANSITION_TRA +3A00 SSCL_MO:trans/unused +3BXX SSCL_MT:trans/SMCL_MT_TRANSITION_TRA +3B00 SSCL_MT:trans/unused +3CXX SMRL:trans/SMRL_TRANSITION_TRA +3C00 SMRL:trans/unused +47XX L1:PLMN_info/PLMN_INFO_TRA +4700 L1:PLMN_info/PLMN_PTR +4701 L1:PLMN_info/M88_PLMN_MEAS_PLMN_OK +4702 L1:PLMN_info/M105_PLMN_MEAS_PLMN_OK +4703 L1:PLMN_info/M92_PLMN_C1 +4704 L1:PLMN_info/M94_SEL_PLMN_FOUND +4705 L1:PLMN_info/M88_PLMN_MEAS_SYSPAR_OK +4706 L1:PLMN_info/M94_PLMN_MEAS_SYSPAR_OK +4707 L1:PLMN_info/M86_PLMN_MEAS_NO_PSW +4708 L1:PLMN_info/M86_PLMN_MEAS_BCCH_DONE +4709 L1:PLMN_info/M87_PLMN_MEAS_BCCH_DONE +470A L1:PLMN_info/M88_PLMN_MEAS_BCCH_DONE +470B L1:PLMN_info/M93_PLMN_MEAS_BCCH_DONE +470C L1:PLMN_info/I_L1_M94_SEL_PLMN_FOUND +470D L1:PLMN_info/M102_PLMN_MEAS_BCCH_DONE +470E L1:PLMN_info/M105_PLMN_MEAS_BCCH_DONE +470F L1:PLMN_info/M_EEPROM_PLMN_SELECTED +4710 L1:PLMN_info/M82_PSW_RESULT_RECEIVED +4711 L1:PLMN_info/M83_SORTED_RSSIS +4712 L1:PLMN_info/M83_SORTED_CARR_LIST +4713 L1:PLMN_info/M86_SAVED_CARRIERS_UPDATED +4714 L1:PLMN_info/M88_NSYSPARS_RECEIVED +4715 L1:PLMN_info/M88_CORRUPTED_SYSPAR +4716 L1:PLMN_info/M105_NSYSPARS_RECEIVED +4717 L1:PLMN_info/E_L1_M82_UNKNOWN_TIMING_OFFSET +48XX L1:NMEAS_info/NMEAS_INFO_TRA +4800 L1:NMEAS_info/MEAS_INSTR_SENDED +4801 L1:NMEAS_info/MEAS_REQ_STATE_UPDATED +4802 L1:NMEAS_info/M27_MEAS_REQ_DISCARDED +4803 L1:NMEAS_info/M28_MEAS_INITED_FOR_NEIGH +4804 L1:NMEAS_info/M29_MEAS_INITED_FOR_NEIGH +4805 L1:NMEAS_info/M9_NSYSPARS_RECEIVED +4806 L1:NMEAS_info/M9_NSYSPARS_RERECEIVED +4807 L1:NMEAS_info/M18_NLIST_CHANGED +4808 L1:NMEAS_info/M25_SYNC_PERIOD_STARTED +4809 L1:NMEAS_info/M26_SYSPAR_PERIOD_STARTED +480A L1:NMEAS_info/M27_NO_NEIGHBOURS +480B L1:NMEAS_info/M28_SYNC_CARRIER_SELECTED +480C L1:NMEAS_info/M29_SYNC_CARRIER_SELECTED +480D L1:NMEAS_info/M29_NO_SYNC_NEIGH_FOUND +480E L1:NMEAS_info/M2_PSW_RESULT_RECEIVED +480F L1:NMEAS_info/M30_PSW_CARRIER_SELECTED +4810 L1:NMEAS_info/M30_NO_PSW_NEIGH_FOUND +4811 L1:NMEAS_info/M10_SYNC_RECEIVED +4812 L1:NMEAS_info/M10_SYNC_RERECEIVED +4813 L1:NMEAS_info/M10_UNKNOWN_BSIC +4814 L1:NMEAS_info/M10_UNPERMITTED_PLMN +4815 L1:NMEAS_info/M31_SYNC_REREC_SELECTED +4816 L1:NMEAS_info/M31_NO_SYNC_REREC_SELECT +4817 L1:NMEAS_info/M32_SYSPAR_CARRIER_SELECT +4818 L1:NMEAS_info/M32_SYS_MEAS_TYPE_NOT_FOUN +4AXX SSCL:input/SSCL_INPUT_TRA +4A00 SSCL:input/MM<-:SSCL_BEGIN_REQ(7/1776) +4A01 SSCL:input/MM<-:SSCL_END_REQ(7/1778) +4A02 SSCL:input/MM<-:FACILITY_IND +4A03 SSCL:input/MM<-:SSCL_FACILITY_REQ(7/1777) +4A04 SSCL:input/NO_EVENT(7/0000) +4A05 SSCL:input/MM<-:SSCL_PARA_REL_COM(7/177E) +4A06 SSCL:input/RELEASE_COMPLETE_IND(7/177B) +4A07 SSCL:input/MM<-:SSCL_PDU_ERROR_IND(7/177C) +4A08 SSCL:input/MM<-:REGISTER_IND(7/1779) +4A09 SSCL:input/MM<-:SS_EST_IND(7/0A49) +4A0A SSCL:input/MM<-:SS_EST_CNF(7/0A48) +4A0B SSCL:input/MM<-:SS_REL_IND(7/0A4B) +4A0C SSCL:input/MM<-:SS_ERROR_IND(7/0A4F) +4A0D SSCL:input/MM<-:SS_DATA_IND +4A0E SSCL:input/UNKNOWN_SSCL_INPUT_PRIMITIVE +4BXX CS:func/CS_FUNCTION_TRA +4B00 CS:func/DTMF_START +4B01 CS:func/DTMF_STOP +4B02 CS:func/DTMF_DIGIT_START +4B03 CS:func/DTMF_DIGIT_STOP +4B04 CS:func/DATA_IF_ACTIVATE +4B05 CS:func/DATA_IF_DEACTIVATE +4B06 CS:func/SPEECH_BC_DEFAULT_SET +4B07 CS:func/DATA_BC_DEFAULT_SET +4B08 CS:func/SIM_INIT_STATUS +4B09 CS:func/SIM_SRES_KC_UPDATE +4B0A CS:func/FACILITY_RECEIVED +4B0B CS:func/CURRENT_BC_READ +4B0C CS:func/CALLING_PARTY_NUMBER_RECEIVED +4B0D CS:func/CALLING_PARTY_NUMBER_READ +4B0E CS:func/MS_PAR_READ_NEIGH_BCCH_LIST +4B0F CS:func/CCM_NEW_TRANS_ACT_ID_IN_USE +4B10 CS:func/CCM_MO_CALL_ESTAB_CHECK +4B11 CS:func/CCM_MO_CALL_ESTAB_CHECK_RETURN +4B12 CS:func/MPARTY_HOLD +4B13 CS:func/MPARTY_RETRIEVE +4B14 CS:func/MPARTY_SWAP +4B15 CS:func/MPARTY_SPLIT_CNF +4B16 CS:func/MPARTY_BUILD_CNF +4B17 CS:func/MPARTY_HOLD_CNF +4B18 CS:func/MPARTY_RETRIEVE_CNF +4B19 CS:func/FACILITY_OPER_FAIL_CHECK +4B1A CS:func/CALL_TRANSFER +4B1B CS:func/MS_PAR_WRITE_NEIGH_BCCH_LIST +4B1C CS:func/CALL_TRANSFER_CNF +4B1D CS:func/MM_PAGING_ALLOWED +4B1E CS:func/L1_INFO_READ_CA_VALID +4B1F CS:func/MS_PAR_SET_LAI_LISTS_IGNORE +4B20 CS:func/CS_ICM_MO_ACTIVATE +4B21 CS:func/CS_FCF_DUMMY_0_1 +4B22 CS:func/CS_FCN_DUMMY_0_2 +4B23 CS:func/CS_FCN_DUMMY_0_3 +4B24 CS:func/CS_FCN_DUMMY_0_4 +4B25 CS:func/CS_FCN_DUMMY_0_5 +4B26 CS:func/CS_FCN_DUMMY_0_6 +4B27 CS:func/CS_FCN_DUMMY_0_7 +4B28 CS:func/CS_FCN_DUMMY_0_8 +4B29 CS:func/CS_FCN_DUMMY_0_9 +4B2A CS:func/ +4B2B CS:func/CS_CALL_HOLD +4B2C CS:func/CS_CALL_SWAP +4B2D CS:func/SEND_AOC_ACKNOWLEDGE +4B2E CS:func/CS_CALL_ANSWER +4B2F CS:func/CS_BUILD_CONFERENCE +4B30 CS:func/CS_SPLIT_CONFERENCE +4B31 CS:func/CS_UPL_CALL_TERMINATE_SIF +4B32 CS:func/CS_CALL_TERMINATE +4B33 CS:func/CS_FCN_DUMMY_1_1 +4B34 CS:func/CS_FCN_DUMMY_1_2 +4B35 CS:func/CS_FCN_DUMMY_1_3 +4B36 CS:func/CS_FCN_DUMMY_1_4 +4B37 CS:func/CS_FCN_DUMMY_1_5 +4B38 CS:func/CS_FCN_DUMMY_1_6 +4B39 CS:func/CS_FCN_DUMMY_1_7 +4B3A CS:func/CS_FCN_DUMMY_1_8 +4B3B CS:func/CS_FCN_DUMMY_1_9 +4B3C CS:func/ +4B3D CS:func/CS_CALL_RETRIEVE +4B3E CS:func/CS_CALL_RELEASE +4B3F CS:func/MS_PAR_WRITE_BCCH_LIST +4B40 CS:func/MS_PAR_WRITE_SELECTED_PLMN +4B41 CS:func/CS_CALL_CREATE +4B42 CS:func/CCM_CHECK_TCH_CH_MODE +4B43 CS:func/CS_TASK_INIT_COMPLETE +4B44 CS:func/CS_DEV_TASK_INIT_COMPLETED +4B45 CS:func/CCM_HSCSD_CALL_STATE_PARAMS +4CXX SIM_INFO:func/SIM_INFO_FUNCTION_TRA +4C00 SIM_INFO:func/READ_SERV_TABLE +4C01 SIM_INFO:func/READ_ADM_DATA +4C02 SIM_INFO:func/READ_ID_DATA +4C03 SIM_INFO:func/READ_TMSI +4C04 SIM_INFO:func/WRITE_TMSI +4C05 SIM_INFO:func/READ_LAI +4C06 SIM_INFO:func/WRITE_LAI +4C07 SIM_INFO:func/READ_CIPH_KEY +4C08 SIM_INFO:func/WRITE_CIPH_KEY +4C09 SIM_INFO:func/READ_CIPH_KEY_SNR +4C0A SIM_INFO:func/WRITE_CIPH_KEY_SNR +4C0B SIM_INFO:func/READ_T3212 +4C0C SIM_INFO:func/WRITE_T3212 +4C0D SIM_INFO:func/READ_BCCH_INFO_LIST +4C0E SIM_INFO:func/WRITE_BCCH_INFO_LIST +4C0F SIM_INFO:func/SIM_INFO_DUMMY_0_0 +4C10 SIM_INFO:func/ADD_FORBIDDEN_PLMN +4C11 SIM_INFO:func/ERASE_FORBIDDEN_PLMN +4C12 SIM_INFO:func/CHECK_FORBIDDEN_PLMN +4C13 SIM_INFO:func/READ_LOC_UPD_STATUS +4C14 SIM_INFO:func/WRITE_LOC_UPD_STATUS +4C15 SIM_INFO:func/FIRST_PLMN_SELECTOR +4C16 SIM_INFO:func/NEXT_PLMN_SELECTOR +4C17 SIM_INFO:func/WRITE_PLMN_LIST +4C18 SIM_INFO:func/DISABLE_IMSI +4C19 SIM_INFO:func/READ_HPLMN +4C1A SIM_INFO:func/SIM_INFO_AVAILABLE +4C1B SIM_INFO:func/READ_MOBILE_IDENTITY +4C1C SIM_INFO:func/CLEAR_SIM_INFO +4C1D SIM_INFO:func/READ_PLMN_LIST +4C1E SIM_INFO:func/READ_BCCH_BIT_MAP +4C1F SIM_INFO:func/PIN_STATUS +4C20 SIM_INFO:func/WRITE_LANGUAGE_PREF +4C21 SIM_INFO:func/READ_LANGUAGE_PREF +4C22 SIM_INFO:func/WRITE_SMS_STATUS +4C23 SIM_INFO:func/READ_SMS_STATUS +4C24 SIM_INFO:func/READ_DATA_SIZES +4C25 SIM_INFO:func/READ_FIRST_MSISDN_NBR +4C26 SIM_INFO:func/PIN2_STATUS +4C27 SIM_INFO:func/FIXDIAL_STATUS +4C28 SIM_INFO:func/READ_HPLMN_SEARCH +4C29 SIM_INFO:func/READ_SERV_CONTROL_TBL +4C2A SIM_INFO:func/WRITE_DYN_FLAGS +4C2B SIM_INFO:func/READ_DYN_FLAGS +4C2C SIM_INFO:func/WRITE_VOICE_MSG_FLAGS +4C2D SIM_INFO:func/READ_VOICE_MSG_FLAGS +4C2E SIM_INFO:func/WRITE_CALL_FORWARD_FLAGS +4C2F SIM_INFO:func/READ_CALL_FORWARD_FLAGS +4C30 SIM_INFO:func/READ_WELCOME_MESSAGE +4C31 SIM_INFO:func/READ_OPERATOR_NAME +4C32 SIM_INFO:func/WRITE_DYN2_FLAGS +4C33 SIM_INFO:func/READ_DYN2_FLAGS +4C34 SIM_INFO:func/READ_PUCT +4C35 SIM_INFO:func/READ_CPHS +4C36 SIM_INFO:func/READ_CELL_BC_MSG_ID +4C37 SIM_INFO:func/WRITE_CELL_BC_MSG_ID +4C38 SIM_INFO:func/FIRST_FREE_SMS_LOC +4C39 SIM_INFO:func/READ_LOCAL_CALL_TEXT +4C3A SIM_INFO:func/READ_TARIFF_PACKAGE +4C3B SIM_INFO:func/READ_HOME_ZONE_COORD +4C3C SIM_INFO:func/READ_AOC_STATUS +4C3D SIM_INFO:func/READ_FORB_PLMN_LIST +4C3E SIM_INFO:func/READ_SIM_LOCK_INFO +4C3F SIM_INFO:func/BCCH_LIST_NOT_VALID +4C40 SIM_INFO:func/READ_SERV_PROV_NAME +4C41 SIM_INFO:func/READ_DUALMODE_NAM_DATA +4C42 SIM_INFO:func/CHECK_EMERG_CALL_CODES +4C43 SIM_INFO:func/READ_EMERG_CALL_CODES +4C44 SIM_INFO:func/READ_FDN_INFO +4C45 SIM_INFO:func/READ_ADN_INFO +4C46 SIM_INFO:func/READ_DUALMODE_SID_LIST +4C47 SIM_INFO:func/READ_DUALMODE_NET_FLAG +4C48 SIM_INFO:func/READ_DUALMODE_FAC_CODE +4C49 SIM_INFO:func/READ_DUALMODE_SYS_PRIORITY_LIST +4C4A SIM_INFO:func/CHECK_IF_DUALMODE_SIM +4C4B SIM_INFO:func/SIM_INFO_DUMMY_0_1 +4C4C SIM_INFO:func/SIM_INFO_DUMMY_0_2 +4C4D SIM_INFO:func/SIM_INFO_DUMMY_0_3 +4C4E SIM_INFO:func/SIM_INFO_DUMMY_0_4 +4C4F SIM_INFO:func/SIM_INFO_DUMMY_0_5 +4C50 SIM_INFO:func/SIM_INFO_DUMMY_0_6 +4C51 SIM_INFO:func/SIM_INFO_DUMMY_0_7 +4C52 SIM_INFO:func/SIM_INFO_DUMMY_0_8 +4C53 SIM_INFO:func/SIM_INFO_DUMMY_0_9 +4C54 SIM_INFO:func/SIM_INFO_DUMMY_0_10 +4C55 SIM_INFO:func/SIM_INFO_DUMMY_0_11 +4C56 SIM_INFO:func/SIM_INFO_DUMMY_0_12 +4C57 SIM_INFO:func/ +4C58 SIM_INFO:func/CHECK_HOME_ZONE +4C59 SIM_INFO:func/SIM_INFO_DUMMY_1_1 +4C5A SIM_INFO:func/SIM_INFO_DUMMY_1_2 +4C5B SIM_INFO:func/SIM_INFO_DUMMY_1_3 +4C5C SIM_INFO:func/SIM_INFO_DUMMY_1_4 +4C5D SIM_INFO:func/SIM_INFO_DUMMY_1_5 +4C5E SIM_INFO:func/SIM_INFO_DUMMY_1_6 +4C5F SIM_INFO:func/SIM_INFO_DUMMY_1_7 +4C60 SIM_INFO:func/SIM_INFO_DUMMY_1_8 +4C61 SIM_INFO:func/SIM_INFO_DUMMY_1_9 +4C62 SIM_INFO:func/SIM_INFO_DUMMY_1_10 +4C63 SIM_INFO:func/ +4C64 SIM_INFO:func/READ_ACM +4C65 SIM_INFO:func/READ_ACM_MAX_VALUE +4C66 SIM_INFO:func/READ_ACM_WARNING_LEVEL +4C67 SIM_INFO:func/READ_CSP +4C68 SIM_INFO:func/READ_ZONAL_IND_LABEL +4C69 SIM_INFO:func/READ_CARD_TYPE +4C6A SIM_INFO:func/WRITE_BCCH_DESCR +4C6B SIM_INFO:func/READ_IMSI +4C6C SIM_INFO:func/READ_ACCESS_CTRL +4C6D SIM_INFO:func/WRITE_DUALMODE_NAM +4C6E SIM_INFO:func/READ_SDN_INFO +5BXX EM_IF:func/CHA_IF_TRA +5B00 EM_IF:func/INIT +5B01 EM_IF:func/CHARGER_CONNECTED +5B02 EM_IF:func/CHARGER_DISCONNECTED +5B03 EM_IF:func/CHARGER_VOL_LIMITATION_ON +5B04 EM_IF:func/CHARGER_VOL_LIMITATION_OFF +5B05 EM_IF:func/CHARGING_ENABLE +5B06 EM_IF:func/CHARGING_DISABLE +5B07 EM_IF:func/ACTING_DEAD +5B08 EM_IF:func/CALL_CONNECTED +5B09 EM_IF:func/CALL_DISCONNECTED +5B0A EM_IF:func/POWER_ON +5B0B EM_IF:func/ +5B0C EM_IF:func/ +5B0D EM_IF:func/CHARGER_TYPE_GET +5B0E EM_IF:func/CHARGER_CURRENT_GET +5B0F EM_IF:func/CHARGER_VOL_GET +5B10 EM_IF:func/CHARGE_STATUS_GET +5B11 EM_IF:func/BATTERY_TYPE_GET +5B12 EM_IF:func/BATTERY_SIZE_GET +5B13 EM_IF:func/BATTERY_TEMP_GET +5B14 EM_IF:func/BATTERY_VOL_GET +5B15 EM_IF:func/BATTERY_VOL_READ +5B16 EM_IF:func/BATTERY_VOL_READ_REQ +5B17 EM_IF:func/BATTERY_VOL_TX_READ +5B18 EM_IF:func/BATTERY_VOL_TX_READ_REQ +5B19 EM_IF:func/CHARGED_CAPACITY_GET +5CXX EM_INT:func/CHA_INT_FUNCTION_TRA +5C00 EM_INT:func/I_FAST_CHARGING +5C01 EM_INT:func/I_LI_BATTERY_CHARGING +5C02 EM_INT:func/I_COLD_CHARGING +5C03 EM_INT:func/I_MAINTENANCE_CHARGING +5C04 EM_INT:func/I_TX_ON_CHARGING +5C05 EM_INT:func/I_CHARGING_DISABLED +5C06 EM_INT:func/I_ONE_CELL_BROKEN +5C07 EM_INT:func/I_START_BATT_BAR_SCROLL_REQ +5C08 EM_INT:func/I_STOP_BATT_BAR_SCROLL_REQ +5C09 EM_INT:func/I_CHARGER_DISCONNECTED +5C0A EM_INT:func/I_CHARGER_CONNECTED +5C0B EM_INT:func/I_BATTERY_FULL +5C0C EM_INT:func/I_BATT_HOT +5C0D EM_INT:func/I_LI_BATT_PWM_OVER_LIMIT +5C0E EM_INT:func/I_LI_BATT_PWM_BELOW_LIMIT +5C0F EM_INT:func/E_CHARGER_CURRENT_FAIL +5C10 EM_INT:func/I_BATTERY_NOT_FULL +5C11 EM_INT:func/I_CHARGING_COMPLETED +5C12 EM_INT:func/E_CHARGER_VOLTAGE_FAIL +5C13 EM_INT:func/E_ILLEGAL_OPERATING_STATE +5C14 EM_INT:func/ +5C15 EM_INT:func/ +5C16 EM_INT:func/I_PWM_WRITE +5C17 EM_INT:func/I_CHARGE_CURRENT +5C18 EM_INT:func/I_CHARGER_CURRENT +5C19 EM_INT:func/I_CHARGER_TYPE +5C1A EM_INT:func/I_LI_BATT_EEPROM_DATA_CHECK +5C1B EM_INT:func/I_OPERATING_MODE +5C1C EM_INT:func/I_OPERATING_CURRENT +5EXX EM:volt/CHA_VOLTAGE_TRA +5E00 EM:volt/I_BATT_TEMP +5E01 EM:volt/I_BATT_SIZE +5E02 EM:volt/I_CHARGER_VOL_MAX +5E03 EM:volt/I_CHARGER_VOL_MIN +5E04 EM:volt/I_BATT_VOLTAGE +5E05 EM:volt/I_BATT_MEAN_VALUE +5E06 EM:volt/I_CHARGER_VOLTAGE +5E07 EM:volt/I_BFD_MEDIAN_VALUE +5E08 EM:volt/I_BFD_CHARGEAMOUNT +5E09 EM:volt/I_BFD_VOLDIFFTOMAX +5E0A EM:volt/I_BFD_VOLDROPCNT +5E0B EM:volt/I_BFD_TEMPERATURE +5E0C EM:volt/I_BFD_VOLTAGE +5E0D EM:volt/I_BFD_VOLDIFFTIME +5E0E EM:volt/I_BFD_AVERDIFF +5E0F EM:volt/I_BFD_DERIVCNT +5E10 EM:volt/I_BFD_FULL_BELIEF +5E11 EM:volt/I_CVC_BATT_VOL_DOWN +5E12 EM:volt/I_CVC_BATT_VOL_UP +5E13 EM:volt/I_CVC_BATT_VOL_AVER +5E14 EM:volt/I_CVC_BATT_VOL_ERROR +5E15 EM:volt/I_CVC_BATT_VOL_CHANGE +5E16 EM:volt/I_CVC_BATT_GOAL_VOL +5FXX EM:trans/CHA_TRANSITION_TRA +5F00 EM:trans/TRANSITION +60XX EM_PSM/EM_PSM_TRA +6000 EM_PSM/I_EM_PSM_TIME +6001 EM_PSM/I_EM_PSM_ITEM +6002 EM_PSM/I_EM_PSM_STATE +6003 EM_PSM/I_EM_PSM_MAX_ITEMS +6004 EM_PSM/I_EM_PSM_AVG_ITEMS +6005 EM_PSM/I_EM_PSM_CONSUMED +6006 EM_PSM/I_EM_PSM_AVG_CURRENT +6007 EM_PSM/I_EM_PSM_TMP_CURRENT +62XX LOC:timer/LOC_TIMER_TRA +6200 LOC:timer/EVENT_HANDLE +64XX LOC_IF:func/LOC_IF_TRA +6400 LOC_IF:func/MDI_MSG_RECEIVE +6401 LOC_IF:func/COUNTER_INCREMENT +6402 LOC_IF:func/COUNTER_READ +6403 LOC_IF:func/COUNTER_WRITE +6404 LOC_IF:func/DSP_INIT +6405 LOC_IF:func/SER_NUM_READ +6406 LOC_IF:func/SMS_DATA_DELETE_STATUS +6407 LOC_IF:func/PROD_INFO_READ +6408 LOC_IF:func/PROD_INFO_WRITE +6409 LOC_IF:func/SELF_TEST_RUN +640A LOC_IF:func/SELF_TEST_RESULT_GET +640B LOC_IF:func/SELF_TEST_PRESET_READ +640C LOC_IF:func/SELF_TEST_PRESET_WRITE +640D LOC_IF:func/SELF_TEST_IF_READ +640E LOC_IF:func/UI_TEST_CONTROL +640F LOC_IF:func/PROD_FAST_SERV_CH_READ +6410 LOC_IF:func/PROD_FAST_SERV_CH_WRITE +6411 LOC_IF:func/VERSION_READ +6412 LOC_IF:func/VERSION_WRITE +6413 LOC_IF:func/VERSION_MOVE +6414 LOC_IF:func/WARR_INFO_READ +6415 LOC_IF:func/WARR_INFO_WRITE +6416 LOC_IF:func/TRANSFER_START +6417 LOC_IF:func/SIM_LOC_CLOSE +6418 LOC_IF:func/SIM_LOC_OPEN +6419 LOC_IF:func/SIM_LOC_STATUS_GET +641A LOC_IF:func/SERIAL_NBR_READ +641B LOC_IF:func/SEC_CODE_CALC +641C LOC_IF:func/MASTER_CODE_CALC +641D LOC_IF:func/MASTER_CODE_CHECK +641E LOC_IF:func/IMEISV_READ +641F LOC_IF:func/SIM_STATUS +6420 LOC_IF:func/SMS_CLEAR +6421 LOC_IF:func/SCM_STORE_STATUS +6422 LOC_IF:func/SCM_READ_STATUS +6423 LOC_IF:func/KEY_PRESS +6424 LOC_IF:func/KEY_RELEASE +6425 LOC_IF:func/PP_INIT +6426 LOC_IF:func/MDI_MSG_RESEIVE +6427 LOC_IF:func/ADJ_DATA_READ +6428 LOC_IF:func/FACTORY_SET_STATUS +6429 LOC_IF:func/PP_READ +642A LOC_IF:func/PP_WRITE +65XX LOC_INT:func/LOC_INT_TRA +6500 LOC_INT:func/TASK_INIT +6501 LOC_INT:func/MS_TEST_MODE +6502 LOC_INT:func/MCU_CMD_EXECUTE +6503 LOC_INT:func/DSP_CMD_EXECUTE +6504 LOC_INT:func/PHONE_MEMORY_HANDLE +6505 LOC_INT:func/PAGING_STATE_GET +6506 LOC_INT:func/RESP_MSG_SEND +6507 LOC_INT:func/ADDRESS_CHECK +6508 LOC_INT:func/INT_CHSUM_CALC +6509 LOC_INT:func/EEP_CHSUM_CALC +650A LOC_INT:func/ERROR_MSG_SEND +650B LOC_INT:func/RF_TEMP_READ +650C LOC_INT:func/AD_CONV_READ +650D LOC_INT:func/EEP_CHSUM_SAVE +650E LOC_INT:func/FACTORY_SET_LOC +650F LOC_INT:func/IMEI_TRANSPORT +6510 LOC_INT:func/EVENT_TRC_HANDLE +6511 LOC_INT:func/MDI_RESP_HANDLE +6512 LOC_INT:func/DSP_MSG_TO_MDI +6513 LOC_INT:func/REROUTE_MSG +6514 LOC_INT:func/USER_MEMORY_READ +6515 LOC_INT:func/USER_MEMORY_WRITE +6516 LOC_INT:func/VERSION_HANDLE +6517 LOC_INT:func/IMEI_WRITE +6518 LOC_INT:func/IMEI_READ +6519 LOC_INT:func/PROD_INFO_HANDLE +651A LOC_INT:func/WARR_INFO_HANDLE +651B LOC_INT:func/TX_CONTROL +651C LOC_INT:func/RX_CONTROL +651D LOC_INT:func/PWR_RAMP_SEND +651E LOC_INT:func/FACTORY_VALUES_SET +651F LOC_INT:func/CALL_HANDLE +6520 LOC_INT:func/FTD_READ +6521 LOC_INT:func/UI_TEST +6522 LOC_INT:func/ORIG_IMEI_READ +6523 LOC_INT:func/ORIG_IMEI_WRITE +6524 LOC_INT:func/ST_RESULTS_READ +6525 LOC_INT:func/ST_INFO_READ +6526 LOC_INT:func/ST_PRESET_HANDLE +6527 LOC_INT:func/UI_CODE_READ +6528 LOC_INT:func/UI_CODE_WRITE +6529 LOC_INT:func/COUNTER_HANDLE +652A LOC_INT:func/STARTUP_RESULT_GET +652B LOC_INT:func/Tx_IQ_Cal +652C LOC_INT:func/resp_msg_header_make +652D LOC_INT:func/warr_data_transfer_handle +652E LOC_INT:func/ui_settings_handle +652F LOC_INT:func/ui_setting_read +6530 LOC_INT:func/ui_setting_write +6531 LOC_INT:func/int_aud_loop_set +6532 LOC_INT:func/counter_amount_check +6533 LOC_INT:func/ad_scaled_value_read +6534 LOC_INT:func/pp_handle +6535 LOC_INT:func/tx_pwr_ramp_set +6536 LOC_INT:func/local_mode_start +6537 LOC_INT:func/nsps_read +6538 LOC_INT:func/nsps_write +6539 LOC_INT:func/graph_display_read +653A LOC_INT:func/graph_display_write +653B LOC_INT:func/plmn_name_handle +653C LOC_INT:func/charging_state +653D LOC_INT:func/cs_status_get +653E LOC_INT:func/buzzer_test +653F LOC_INT:func/ear_volume_sett +6540 LOC_INT:func/rtc_time_read +6541 LOC_INT:func/rtc_time_set +6542 LOC_INT:func/ir_test +6543 LOC_INT:func/pwm_write +6544 LOC_INT:func/operator_logo_read +6545 LOC_INT:func/operator_logo_write +6546 LOC_INT:func/ring_tone_read +6547 LOC_INT:func/ring_tone_write +6548 LOC_INT:func/tx_iq_set +6549 LOC_INT:func/sec_startup_msg_send +654A LOC_INT:func/sec_ms_id_store +654B LOC_INT:func/sec_ms_id_read +654C LOC_INT:func/sec_ser_num_prg +654D LOC_INT:func/sec_check_sum_calc +654E LOC_INT:func/imei_string_get +654F LOC_INT:func/sec_encrypted_siml_store +6550 LOC_INT:func/sec_siml_state_chg_send +6551 LOC_INT:func/sec_master_code_req +6552 LOC_INT:func/sec_master_code_resp +6553 LOC_INT:func/sim_lock_close_ +6554 LOC_INT:func/sim_lock_open_ +6555 LOC_INT:func/sim_lock_status_get +6556 LOC_INT:func/sim_lock_config_data_set +6557 LOC_INT:func/sim_lock_keypad_close_set +6558 LOC_INT:func/sim_lock_state_read +6559 LOC_INT:func/sim_lock_action_resp_send +69XX LOC_MDI:send/LOC_MDI_MSG_SEND_TRA +6900 LOC_MDI:send/dsp_init +6901 LOC_MDI:send/task_init +6902 LOC_MDI:send/mdi_response_handle +6903 LOC_MDI:send/dsp_msg_to_mdi +6904 LOC_MDI:send/int_aud_loop_set +6905 LOC_MDI:send/reroute +6906 LOC_MDI:send/tx_power_ramp_send +6907 LOC_MDI:send/tx_control +6908 LOC_MDI:send/rx_control +6909 LOC_MDI:send/tx_pwr_ramp_set +690A LOC_MDI:send/local_mode_start +690B LOC_MDI:send/tx_iq_set +690C LOC_MDI:send/sec_startup_msg_send +690D LOC_MDI:send/sec_siml_state_chg_send +690E LOC_MDI:send/sec_master_code_req +6DXX DEV_IF:func/DEV_IF_TRA +6D00 DEV_IF:func/PWR_IF_POWER_ON +6D01 DEV_IF:func/PWR_IF_POWER_ON +6D02 DEV_IF:func/PWR_IF_POWER_OFF +6D03 DEV_IF:func/PWR_IF_UI_POWER_DOWN_READY +6D04 DEV_IF:func/PWR_IF_CS_POWER_DOWN_READY +6D05 DEV_IF:func/PWR_IF_EM_POWER_DOWN_READY +6D06 DEV_IF:func/PWR_IF_LOC_POWER_DOWN_READY +6D07 DEV_IF:func/PWR_IF_DEVTIME_POWER_DOWN_READY +6D08 DEV_IF:func/PWR_IF_SIM_POWER_DOWN_READY +6D09 DEV_IF:func/PWR_IF_CHARGER_CONNECTED +6D0A DEV_IF:func/PWR_IF_CHARGER_DISCONNECTED +6D0B DEV_IF:func/PWR_IF_CALL_CONN +6D0C DEV_IF:func/PWR_IF_CALL_DISCONN +6D0D DEV_IF:func/PWR_IF_CHARGING_COMPLETED +6D0E DEV_IF:func/PWR_IF_DISCHARGING_COMPLETED +6D0F DEV_IF:func/PWR_IF_SW_RESET +6D10 DEV_IF:func/PWR_IF_RESET_REASON_SET +6D11 DEV_IF:func/DISP_IF_REFRESH +6D12 DEV_IF:func/DISP_IF_IND_REFRESH +6D13 DEV_IF:func/DISP_IF_IND_ON +6D14 DEV_IF:func/DISP_IF_IND_OFF +6D15 DEV_IF:func/DISP_IF_IND_BLINK +6D16 DEV_IF:func/DISP_IF_CLEAR +6D17 DEV_IF:func/DISP_IF_BAR_SCROLL_START +6D18 DEV_IF:func/DISP_IF_BAR_SCROLL_STOP +6D19 DEV_IF:func/KBD_IF_KEY_CTRL_SET +6D1A DEV_IF:func/dev_time_set() +6D1B DEV_IF:func/dev_time_get() +6D1C DEV_IF:func/dev_time_alarm_set() +6D1D DEV_IF:func/dev_time_alarm_get() +6D1E DEV_IF:func/dev_time_alarm_set_off() +6D1F DEV_IF:func/dev_time_rtc_on() +6D20 DEV_IF:func/dev_time_rtc_off() +6D21 DEV_IF:func/dev_time_notify_mode_set() +6D22 DEV_IF:func/dev_time_notify_mode_get() +6D23 DEV_IF:func/dev_time_update() +6D24 DEV_IF:func/dev_time_alarm_update() +6D25 DEV_IF:func/dev_time_rtc_status() +6D26 DEV_IF:func/dev_time_full_days_in_secs() +6D27 DEV_IF:func/dev_time_alarm_set_check() +6D28 DEV_IF:func/dev_time_factory_set() +6D29 DEV_IF:func/dev_time_calib_value_calc() +6D2A DEV_IF:func/dev_time_date_set() +6D2B DEV_IF:func/dev_disp_update() +6D2C DEV_IF:func/dev_disp_indi_update() +6D2D DEV_IF:func/dev_indicator_on() +6D2E DEV_IF:func/dev_indicator_off() +6D2F DEV_IF:func/dev_indicator_blink() +6D30 DEV_IF:func/dev_disp_clear() +6D31 DEV_IF:func/dev_grph_area_set() +6D32 DEV_IF:func/dev_grph_font_info_get() +6D33 DEV_IF:func/dev_grph_battery_bar_on() +6D34 DEV_IF:func/dev_grph_battery_bar_off() +6D35 DEV_IF:func/dev_grph_battery_bar_blink() +6D36 DEV_IF:func/dev_grph_rf_bar_on() +6D37 DEV_IF:func/dev_grph_rf_bar_off() +6D38 DEV_IF:func/dev_grph_rf_bar_blink() +6D39 DEV_IF:func/dev_grph_bitmap_display() +6D3A DEV_IF:func/dev_grph_text_draw() +6D3B DEV_IF:func/dev_grph_pixel_set() +6D3C DEV_IF:func/dev_grph_line_draw() +6D3D DEV_IF:func/dev_grph_battery_bar_type_set() +6D3E DEV_IF:func/dev_grph_rf_bar_type_set +6D3F DEV_IF:func/dev_disp_blink_disable() +6D40 DEV_IF:func/dev_disp_batt_bar_write() +6D41 DEV_IF:func/dev_disp_rf_bar_write +6D42 DEV_IF:func/dev_disp_test_pattern_on() +6D43 DEV_IF:func/dev_disp_test_pattern_off() +6D44 DEV_IF:func/dev_indicator_state_get() +6D45 DEV_IF:func/dev_disp_acting_dead_bar_set() +6D46 DEV_IF:func/dev_disp_acting_dead_bar_clear() +6D47 DEV_IF:func/dev_grph_rectangle_draw() +6D48 DEV_IF:func/dev_grph_write_string() +6D49 DEV_IF:func/dev_grph_char_info_get() +6D4A DEV_IF:func/dev_grph_init() +6D4B DEV_IF:func/dev_discharge_start() +6D4C DEV_IF:func/dev_discharge_stop() +6D4D DEV_IF:func/dev_gsm_power_down() +6D4E DEV_IF:func/dev_sim_deactivated() +6D4F DEV_IF:func/dev_recovery_reset() +6D50 DEV_IF:func/dev_dsp_deactivate() +6D51 DEV_IF:func/dev_gsm_factory_set() +6D52 DEV_IF:func/dev_sms_message_clear() +6D53 DEV_IF:func/dev_sms_message_read_sif() +6D54 DEV_IF:func/dev_sms_message_store_sif() +6D55 DEV_IF:func/dev_sms_update_msg_reference() +6D56 DEV_IF:func/dev_sms_update_msg_status() +6D57 DEV_IF:func/dev_buzzer_test() +6D58 DEV_IF:func/dev_gsm_normal_power_up() +6D59 DEV_IF:func/dev_standby_status_get() +6D5A DEV_IF:func/dev_rf_bar_get() +6D5B DEV_IF:func/dev_nsps_status_get() +6D5C DEV_IF:func/dev_nsps_key_press() +6D5D DEV_IF:func/dev_nsps_timeout() +6D5E DEV_IF:func/dev_nsps_serv_off() +6D5F DEV_IF:func/dev_nsps_serv_on() +6D60 DEV_IF:func/dev_nsps_charger_status() +6D61 DEV_IF:func/dev_signal_indicator_set() +6D62 DEV_IF:func/dev_ccont_int_handler() +6D63 DEV_IF:func/dev_ccont_charger_exist() +6D64 DEV_IF:func/dev_ct_timer_start() +6D65 DEV_IF:func/dev_ct_timer_stop() +6D66 DEV_IF:func/dev_ct_timer_read() +6D67 DEV_IF:func/dev_cs_wakeup_needed() +6D68 DEV_IF:func/ +6D69 DEV_IF:func/ +72XX DEV_PWR:func/DEV_PWR_TRA +7200 DEV_PWR:func/unused +7201 DEV_PWR:func/DSP_STARTUP_COMPLETED +7202 DEV_PWR:func/CS_INIT_COMPLETED +7203 DEV_PWR:func/UI_INIT_COMPLETED +7204 DEV_PWR:func/EM_INIT_COMPLETED +7205 DEV_PWR:func/DETERMINE_WAKEUP_REASON +7206 DEV_PWR:func/RTC_CALIBRATION_COMPLETED +7207 DEV_PWR:func/ALARM_WRITE_COMPLETED +73XX DEV_GRPH:func/DEV_GRPH_TRA +7300 DEV_GRPH:func/unused +7301 DEV_GRPH:func/INDI_UPDATE +7302 DEV_GRPH:func/Indicator set ON +7303 DEV_GRPH:func/Indicator set OFF +7304 DEV_GRPH:func/Indicator set BLINKING +7305 DEV_GRPH:func/HORIZ text_draw() +7306 DEV_GRPH:func/VERT text_draw() +7307 DEV_GRPH:func/text_draw() reported to DDI +7308 DEV_GRPH:func/battery_bar type set to +7309 DEV_GRPH:func/rf_bar type set to +730A DEV_GRPH:func/blink_status set to ON +730B DEV_GRPH:func/blink_status set to OFF +730C DEV_GRPH:func/blinking ENABLED +730D DEV_GRPH:func/blinking DISABLED +730E DEV_GRPH:func/batt_bar_write(), segments +730F DEV_GRPH:func/rf_bar_write(), segments +7310 DEV_GRPH:func/PPM fonts found +7311 DEV_GRPH:func/ROM-fonts used +74XX DEV_DISP:func/DEV_DISP_TRA +7400 DEV_DISP:func/unused +7401 DEV_DISP:func/dev_disp_bars_update() +7402 DEV_DISP:func/dev_disp_batt_bar_update(), segments +7403 DEV_DISP:func/dev_disp_rf_bar_update(), segments +7404 DEV_DISP:func/dev_disp_batt_bar_clear() +7405 DEV_DISP:func/dev_disp_rf_bar_clear() +7406 DEV_DISP:func/dev_light_on() +7407 DEV_DISP:func/dev_light_off() +7408 DEV_DISP:func/dev_light_blink() +7409 DEV_DISP:func/dev_disp_light_on() +740A DEV_DISP:func/dev_disp_light_off() +740B DEV_DISP:func/dev_disp_light_blink() +740C DEV_DISP:func/dev_keyboard_light_on() +740D DEV_DISP:func/dev_keyboard_light_off() +740E DEV_DISP:func/dev_keyboard_light_blink() +740F DEV_DISP:func/dev_charge_bar_get() +7410 DEV_DISP:func/dev_disp_lcd_power_on() +7411 DEV_DISP:func/dev_disp_lcd_power_off() +7412 DEV_DISP:func/dev_disp_text_draw_report(), set ON +7413 DEV_DISP:func/dev_disp_text_draw_report(), set OFF +75XX DEV_ACC:func/DEV_ACC_TRA +7500 DEV_ACC:func/unused +7501 DEV_ACC:func/Use_mode_get +7502 DEV_ACC:func/Detect_poll +7503 DEV_ACC:func/Headset_connection_check +7504 DEV_ACC:func/Audio_control +7505 DEV_ACC:func/Audio_activate +7506 DEV_ACC:func/Audio_deactivate +7507 DEV_ACC:func/Car_speaker_mute_on +7508 DEV_ACC:func/Car_speaker_mute_off +7509 DEV_ACC:func/Car_mic_mute_on +750A DEV_ACC:func/Car_mic_mute_off +750B DEV_ACC:func/Radio_mute_set_on +750C DEV_ACC:func/Radio_mute_set_off +750D DEV_ACC:func/Car IGN +750E DEV_ACC:func/HFU2: Hook-On +750F DEV_ACC:func/HFU2: Hook-Off +7510 DEV_ACC:func/Antenna_motor_set_on +7511 DEV_ACC:func/Antenna_motor_set_off +7512 DEV_ACC:func/EAD_get +7513 DEV_ACC:func/Alive_msg_send +7514 DEV_ACC:func/Vibration_alert_set_on +7515 DEV_ACC:func/Vibration_alert_set_off +7516 DEV_ACC:func/New Mode +7517 DEV_ACC:func/Headset Button State +7518 DEV_ACC:func/Unknown HFU2 func +7519 DEV_ACC:func/Unk HFU2 IND sub_func +751A DEV_ACC:func/Unk HFU2 ACC sub_func +751B DEV_ACC:func/Bad HFU-2 Connection! +751C DEV_ACC:func/HFU-2 Selftest fail! +751D DEV_ACC:func/HFU-2 Port Read Resp +751E DEV_ACC:func/HFU-2 ADC Value +751F DEV_ACC:func/HFU-2 Model Message +7520 DEV_ACC:func/HFU-2 Audio Path +7521 DEV_ACC:func/HFU-2 Audio Path Resp +7522 DEV_ACC:func/Unk PN Obj Router Func +7523 DEV_ACC:func/Unk PN Router Sub Func +7524 DEV_ACC:func/dev_acc_power_off() +7525 DEV_ACC:func/dev_acc_power_off_ok() +76XX DEV_TIME:func/DEV_TIME_TRA +7600 DEV_TIME:func/unused +7601 DEV_TIME:func/TIME_SET +7602 DEV_TIME:func/TIME_GET +7603 DEV_TIME:func/ALARM_SET +7604 DEV_TIME:func/ALARM_GET +7605 DEV_TIME:func/NOTIFY_MODE_SET +7606 DEV_TIME:func/NOTIFY_MODE_GET +7607 DEV_TIME:func/TIME_NOTIFY +7608 DEV_TIME:func/ALARM_NOTIFY +7609 DEV_TIME:func/ALARM_CHK_NOTIFY +760A DEV_TIME:func/RTC_STATUS +760B DEV_TIME:func/RTC_STATUS_CHECK +760C DEV_TIME:func/RTC_STATUS_GET +760D DEV_TIME:func/FULL_DAYS_IN_SECS +760E DEV_TIME:func/CALIB_VALUE_CALC +760F DEV_TIME:func/NEW_CALIB_VALUE +7610 DEV_TIME:func/SLEEP_CLK_RATIO_SET +7611 DEV_TIME:func/SLEEP_CLK_CALIB_REQ +7612 DEV_TIME:func/WAITING_NEW_CALIB +7613 DEV_TIME:func/WAITING_NEW_ALARM +7614 DEV_TIME:func/INFORM_ALARM_TO_UI +7615 DEV_TIME:func/ALARM_TYPE_GET +7616 DEV_TIME:func/DEV_TIME_CSM_INIT +7617 DEV_TIME:func/DATE_SET +7618 DEV_TIME:func/dev_time_rtc_status_check(), comparison results +78XX DEV_GSM:func/DEV_GSM_TRA +7800 DEV_GSM:func/unused +7801 DEV_GSM:func/FAST discharge started +7802 DEV_GSM:func/SLOW discharge started +7803 DEV_GSM:func/Discharging stopped +7804 DEV_GSM:func/Last power-up was normal +7805 DEV_GSM:func/Last power-up was NOT normal +7806 DEV_GSM:func/dev_standby_status_get(), OK +7807 DEV_GSM:func/dev_standby_status_get(), FAIL +79XX DEV_CCNT:func/DEV_CCNT_TRA +7900 DEV_CCNT:func/unused +7901 DEV_CCNT:func/dev_ccont_int_handler(), CCONT intr. ID register +7902 DEV_CCNT:func/dev_ccont_int_handler(), RTC-DAY interrupt! +7903 DEV_CCNT:func/dev_ccont_int_handler(), RTC-MIN interrupt! +7904 DEV_CCNT:func/dev_ccont_int_handler(), RTC-SEC interrupt! +7905 DEV_CCNT:func/dev_ccont_int_handler(), RTC-ALR interrupt! +7906 DEV_CCNT:func/dev_ccont_int_handler(), CHARGER interrupt! +7907 DEV_CCNT:func/dev_ccont_charger_exist(), charger CONNECTION! +7908 DEV_CCNT:func/dev_ccont_charger_exist(), charger DISCONNECTION! +7DXX AUD:func/AUD_FUNCTION_TRA +7D00 AUD:func/aud_init +7D01 AUD:func/aud_acc_active +7D02 AUD:func/aud_path_on +7D03 AUD:func/aud_path_off +7D04 AUD:func/aud_mode +7D05 AUD:func/aud_mic_cs_on +7D06 AUD:func/aud_mic_cs_off +7D07 AUD:func/aud_mic_ui_on +7D08 AUD:func/aud_mic_ui_off +7D09 AUD:func/aud_mic_user_on +7D0A AUD:func/aud_mic_user_off +7D0B AUD:func/aud_ear_cs_on +7D0C AUD:func/aud_ear_cs_off +7D0D AUD:func/aud_ear_ui_on +7D0E AUD:func/aud_ear_ui_off +7D0F AUD:func/aud_ear_vol_set +7D10 AUD:func/aud_ear_vol_get +7D11 AUD:func/aud_ear_vol_inc +7D12 AUD:func/aud_ear_vol_dec +7D13 AUD:func/aud_request +7D14 AUD:func/audio dsp params chunk +7D15 AUD:func/mic/ear state +7EXX TONE:func/TONE_FUNCTION_TRA +7E00 TONE:func/aud_tone_start +7E01 TONE:func/aud_tone_stop +7E02 TONE:func/aud_dtmf_start +7E03 TONE:func/aud_tone_buzzer +7E04 TONE:func/aud_tone_ear +7E05 TONE:func/aud_tone_buzzer_ear +7FXX AUD:msg/AUD_MSG_TRA +7F00 AUD:msg/aud_api_write +7F01 AUD:msg/aud_api_error +80XX AUD:tim/AUD_TIMER_TRA +8000 AUD:tim/aud_ear_timer_start +8001 AUD:tim/aud_mic_timer_start +8002 AUD:tim/aud_param_timer_start +8003 AUD:tim/aud_refresh_timer_start +8004 AUD:tim/aud_test_timer_start +8005 AUD:tim/aud_ear_timeout +8006 AUD:tim/aud_mic_timeout +8007 AUD:tim/aud_param_timeout +8008 AUD:tim/aud_refresh_timeout +8009 AUD:tim/aud_test_timeout +800A AUD:tim/aud_message_error diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/type-cc.h b/gammu/emb/gammu/depend/nokia/dct3trac/type-cc.h new file mode 100644 index 0000000..6c07ca2 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/type-cc.h @@ -0,0 +1,43 @@ +{0x00, "", "Escape to nationally specific message types"}, +/* Call establishment messages: */ +{0x01, "9.3.1", "ALERTING"}, +{0x08, "9.3.2", "CALL CONFIRMED"}, +{0x02, "9.3.3", "CALL PROCEEDING"}, +{0x07, "9.3.5", "CONNECT"}, +{0x0F, "9.3.6", "CONNECT ACKNOWLEDGE"}, +{0x0E, "9.3.8", "EMERGENCY SETUP"}, +{0x03, "9.3.17", "PROGRESS"}, +{0x04, "9.3.17a", "CC-ESTABLISHMENT"}, +{0x06, "9.3.17b", "CC-ESTABLISHMENT CONFIRMED"}, +{0x0B, "9.3.18a", "RECALL"}, +{0x09, "9.3.23a", "START CC"}, +{0x05, "9.3.23", "SETUP"}, +/* Call information phase messages: */ +{0x17, "9.3.13", "MODIFY"}, +{0x1F, "9.3.14", "MODIFY COMPLETE"}, +{0x13, "9.3.15", "MODIFY REJECT"}, +{0x10, "9.3.31", "USER INFORMATION"}, +{0x18, "9.3.10", "HOLD"}, +{0x19, "9.3.11", "HOLD ACKNOWLEDGE"}, +{0x1A, "9.3.12", "HOLD REJECT"}, +{0x1C, "9.3.20", "RETRIEVE"}, +{0x1D, "9.3.21", "RETRIEVE ACKNOWLEDGE"}, +{0x1E, "9.3.22", "RETRIEVE REJECT"}, +/* Call clearing messages: */ +{0x25, "9.3.7", "DISCONNECT"}, +{0x2D, "9.3.18", "RELEASE"}, +{0x2A, "9.3.19", "RELEASE COMPLETE"}, +/* Miscellaneous messages: */ +{0x39, "9.3.4", "CONGESTION CONTROL"}, +{0x3E, "9.3.16", "NOTIFY"}, +{0x3D, "9.3.27", "STATUS"}, +{0x34, "9.3.28", "STATUS ENQUIRY"}, +{0x35, "9.3.24", "START DTMF"}, +{0x31, "9.3.29", "STOP DTMF"}, +{0x32, "9.3.30", "STOP DTMF ACKNOWLEDGE"}, +{0x36, "9.3.25", "START DTMF ACKNOWLEDGE"}, +{0x37, "9.3.26", "START DTMF REJECT"}, +{0x3A, "9.3.9", "FACILITY"}, +{-1, NULL, NULL} +/* Unused sections +*/ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/type-mm.h b/gammu/emb/gammu/depend/nokia/dct3trac/type-mm.h new file mode 100644 index 0000000..8ba36b2 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/type-mm.h @@ -0,0 +1,30 @@ +/* Registration messages: */ +{0x01, "9.2.12", "IMSI DETACH INDICATION"}, +{0x02, "9.2.13", "LOCATION UPDATING ACCEPT"}, +{0x04, "9.2.14", "LOCATION UPDATING REJECT"}, +{0x08, "9.2.15", "LOCATION UPDATING REQUEST"}, +/* Security messages: */ +{0x11, "9.2.1", "AUTHENTICATION REJECT"}, +{0x12, "9.2.2", "AUTHENTICATION REQUEST"}, +{0x14, "9.2.3", "AUTHENTICATION RESPONSE"}, +{0x1C, "9.2.3a", "CS AUTHENTICATION FAILURE"}, +{0x18, "9.2.10", "IDENTITY REQUEST"}, +{0x19, "9.2.11", "IDENTITY RESPONSE"}, +{0x1A, "9.2.17", "TMSI REALLOCATION COMMAND"}, +{0x1B, "9.2.18", "TMSI REALLOCATION COMPLETE"}, +/* Connection management messages: */ +{0x21, "9.2.5", "CM SERVICE ACCEPT"}, +{0x22, "9.2.6", "CM SERVICE REJECT"}, +{0x23, "9.2.7", "CM SERVICE ABORT"}, +{0x24, "9.2.9", "CM SERVICE REQUEST"}, +{0x25, "9.2.5a", "CM SERVICE PROMPT"}, +{0x26, "9.2.20", "NOTIFICATION RESPONSE"}, +{0x28, "9.2.4", "CM RE-ESTABLISHMENT REQUEST"}, +{0x29, "9.2.8", "ABORT"}, +/* Miscellaneous messages: */ +{0x30, "9.2.19", "MM NULL"}, +{0x31, "9.2.16", "MM STATUS"}, +{0x32, "9.2.15a", "MM INFORMATION"}, +{-1, NULL, NULL} +/* Unused sections +*/ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/type-rr.h b/gammu/emb/gammu/depend/nokia/dct3trac/type-rr.h new file mode 100644 index 0000000..31adee4 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/type-rr.h @@ -0,0 +1,100 @@ +/* Channel establishment messages: */ +{0x3C, "9.1.28a", "RR INITIALISATION REQUEST"}, +{0x3B, "9.1.1", "ADDITIONAL ASSIGNMENT"}, +{0x3F, "9.1.18", "IMMEDIATE ASSIGNMENT"}, +{0x39, "9.1.19", "IMMEDIATE ASSIGNMENT EXTENDED"}, +{0x3A, "9.1.20", "IMMEDIATE ASSIGNMENT REJECT"}, +{0x48, "9.1.12f", "DTM ASSIGNMENT FAILURE"}, +{0x49, "9.1.12h", "DTM REJECT"}, +{0x4A, "9.1.12i", "DTM REQUEST"}, +{0x4B, "9.1.21f", "PACKET ASSIGNMENT"}, +/* Ciphering messages: */ +{0x35, "9.1.9", "CIPHERING MODE COMMAND"}, +{0x32, "9.1.10", "CIPHERING MODE COMPLETE"}, +/* Configuration change messages: */ +{0x30, "9.1.12b", "CONFIGURATION CHANGE COMMAND"}, +{0x31, "9.1.12c", "CONFIGURATION CHANGE ACKNOWLEDGE"}, +{0x33, "9.1.12d", "CONFIGURATION CHANGE REJECT"}, +/* Handover messages: */ +{0x2E, "9.1.2", "ASSIGNMENT COMMAND"}, +{0x29, "9.1.3", "ASSIGNMENT COMPLETE"}, +{0x2F, "9.1.4", "ASSIGNMENT FAILURE"}, +{0x2B, "9.1.15", "HANDOVER COMMAND"}, +{0x2C, "9.1.16", "HANDOVER COMPLETE"}, +{0x28, "9.1.17", "HANDOVER FAILURE"}, +{0x2D, "9.1.28", "PHYSICAL INFORMATION"}, +{0x4C, "9.1.12e", "DTM ASSIGNMENT COMMAND"}, +{0x08, "9.1.21e", "RR-CELL CHANGE ORDER"}, +{0x23, "9.1.13a", "PDCH ASSIGNMENT COMMAND"}, +/* Channel release messages: */ +{0x0D, "9.1.7", "CHANNEL RELEASE"}, +{0x0A, "9.1.26", "PARTIAL RELEASE"}, +{0x0F, "9.1.27", "PARTIAL RELEASE COMPLETE"}, +/* Paging and Notification messages: */ +{0x21, "9.1.22", "PAGING REQUEST TYPE 1"}, +{0x22, "9.1.23", "PAGING REQUEST TYPE 2"}, +{0x24, "9.1.24", "PAGING REQUEST TYPE 3"}, +{0x27, "9.1.25", "PAGING RESPONSE"}, +{0x20, "9.1.21b", "NOTIFICATION/NCH"}, +{0x25, "", "Reserved"}, +{0x26, "9.1.21d", "NOTIFICATION RESPONSE"}, +{0x0B, "", "Reserved"}, +{0x4E, "9.1.21g", "PACKET NOTIFICATION"}, +/* 3G Specific messages */ +{0x60, "9.1.11a", "UTRAN CLASSMARK CHANGE"}, +{0x62, "9.1.11b", "cdma2000 CLASSMARK CHANGE"}, +{0x63, "9.1.15a", "INTER SYSTEM TO UTRAN HANDOVER COMMAND"}, +{0x64, "9.1.15b", "INTER SYSTEM TO CDMA2000 HANDOVER COMMAND"}, +/* System information messages: */ +{0x18, "9.1.42", "SYSTEM INFORMATION TYPE 8"}, +{0x19, "9.1.31", "SYSTEM INFORMATION TYPE 1"}, +{0x1A, "9.1.32", "SYSTEM INFORMATION TYPE 2"}, +{0x1B, "9.1.35", "SYSTEM INFORMATION TYPE 3"}, +{0x1C, "9.1.36", "SYSTEM INFORMATION TYPE 4"}, +{0x1D, "9.1.37", "SYSTEM INFORMATION TYPE 5"}, +{0x1E, "9.1.40", "SYSTEM INFORMATION TYPE 6"}, +{0x1F, "9.1.41", "SYSTEM INFORMATION TYPE 7"}, +/* System information messages: */ +{0x02, "9.1.33", "SYSTEM INFORMATION TYPE 2bis"}, +{0x03, "9.1.34", "SYSTEM INFORMATION TYPE 2ter"}, +{0x07, "9.1.34a", "SYSTEM INFORMATION TYPE 2quater"}, +{0x05, "9.1.38", "SYSTEM INFORMATION TYPE 5bis"}, +{0x06, "9.1.39", "SYSTEM INFORMATION TYPE 5ter"}, +{0x04, "9.1.43", "SYSTEM INFORMATION TYPE 9"}, +{0x00, "9.1.43a", "SYSTEM INFORMATION TYPE 13"}, +/* System information messages: */ +{0x3D, "9.1.43d", "SYSTEM INFORMATION TYPE 16"}, +{0x3E, "9.1.43e", "SYSTEM INFORMATION TYPE 17"}, +/* System information messages: */ +{0x40, "9.1.43.g", "SYSTEM INFORMATION TYPE 18"}, +{0x41, "9.1.43f", "SYSTEM INFORMATION TYPE 19"}, +{0x42, "9.1.43.h", "SYSTEM INFORMATION TYPE 20"}, +/* Miscellaneous messages: */ +{0x10, "9.1.5", "CHANNEL MODE MODIFY"}, +{0x12, "9.1.29", "RR STATUS"}, +{0x17, "9.1.6", "CHANNEL MODE MODIFY ACKNOWLEDGE"}, +{0x14, "9.1.13", "FREQUENCY REDEFINITION"}, +{0x15, "9.1.21", "MEASUREMENT REPORT"}, +{0x16, "9.1.11", "CLASSMARK CHANGE"}, +{0x13, "9.1.12", "CLASSMARK ENQUIRY"}, +{0x36, "9.1.52", "EXTENDED MEASUREMENT REPORT"}, +{0x37, "9.1.51", "EXTENDED MEASUREMENT ORDER"}, +{0x34, "9.1.13b", "GPRS SUSPENSION REQUEST"}, +{0x4D, "9.1.12g", "DTM INFORMATION"}, +{0x09, "9.1.49", "VGCS UPLINK GRANT"}, +{0x0E, "9.1.48", "UPLINK RELEASE"}, +{0x0C, "", "Reserved"}, +{0x2A, "9.1.46", "UPLINK BUSY"}, +{0x11, "9.1.44", "TALKER INDICATION"}, +{0x38, "9.1.53", "APPLICATION INFORMATION"}, +{-1, NULL, NULL} +/* Unused sections + NOTIFICATION/FACCH [9.1.21a] + HANDOVER ACCESS [9.1.14] + SYNCHRONIZATION CHANNEL INFORMATION [9.1.30] + UPLINK FREE [9.1.47] + UPLINK ACCESS [9.1.45] + ENHANCED MEASUREMENT REPORT [9.1.55] + CHANNEL REQUEST [9.1.8] + MEASUREMENT INFORMATION [9.1.54] +*/ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/type-sms.h b/gammu/emb/gammu/depend/nokia/dct3trac/type-sms.h new file mode 100644 index 0000000..54b9ec3 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/type-sms.h @@ -0,0 +1,6 @@ +{0x01, "7.2.1", "CP-DATA"}, +{0x04, "7.2.2", "CP-ACK"}, +{0x10, "7.2.3", "CP-ERROR"}, +{-1, NULL, NULL} +/* Unused sections +*/ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/type-ss.h b/gammu/emb/gammu/depend/nokia/dct3trac/type-ss.h new file mode 100644 index 0000000..d258892 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/type-ss.h @@ -0,0 +1,8 @@ +/* Clearing messages: */ +{0x2A, "2.5", "RELEASE COMPLETE"}, +/* Miscellaneous message group: */ +{0x3A, "2.3", "FACILITY"}, +{0x3B, "2.4", "REGISTER"}, +{-1, NULL, NULL} +/* Unused sections +*/ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx-gsm.c b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-gsm.c new file mode 100644 index 0000000..44db64b --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-gsm.c @@ -0,0 +1,416 @@ +/** + * Simple GSM frame decoder + * wumpus 2003 -- www.blacksphere.tk + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <signal.h> + +#include "wmx-util.h" +#include "wmx-gsm.h" + +/* Administrative */ +GSMDecoder *GSMDecoder_new() +{ + GSMDecoder *self; + + self = malloc(sizeof(GSMDecoder)); + self->xmlout = NULL; + + return self; +} + +/** + * Set 'sniffer' XML output stream + */ +void GSMDecoder_xmlout(GSMDecoder *self, FILE *f) +{ + self->xmlout = f; + if(self->xmlout) { + /* Open XML doc */ + fprintf(self->xmlout,"<?xml version=\"1.0\"?>\n"); + fprintf(self->xmlout,"<dump>\n"); + } +} + +void GSMDecoder_free(GSMDecoder *self) +{ + if(self->xmlout) { + fprintf(self->xmlout,"</dump>\n"); + fclose(self->xmlout); + } + free(self); +} + +char *GSM_protocols[]={ +/*0*/ "Group call control", +/*1*/ "Broadcast call control", +/*2*/ "PDSS1", +/*3*/ "Call Control; call related SS messages (TS 24.008)", +/*4*/ "PDSS2", +/*5*/ "Mobility Management messages (TS 24.008)", +/*6*/ "Radio Resources management messages (GSM 04.18)", +/*7*/ "RFU", +/*8*/ "GPRS mobility management messages", +/*9*/ "SMS messages (GSM 04.11)", +/*A*/ "GPRS session management messages", +/*B*/ "Non call related SS messages (GSM 04.80)", +/*C*/ "Location services", +/*D*/ "RFU", +/*E*/ "Reserved for extension of the PD to one octet length", +/*F*/ "Reserved for tests procedures described in GSM 11.10" +}; + +typedef struct GSMpackettypestruct { + int id; + char *section; + char *description; +} GSMpackettype; + +/* Include the data */ +GSMpackettype GSM_RR_packettypes[] = { +#include "type-rr.h" +}; +GSMpackettype GSM_MM_packettypes[] = { +#include "type-mm.h" +}; +GSMpackettype GSM_CC_packettypes[] = { +#include "type-cc.h" +}; +GSMpackettype GSM_SS_packettypes[] = { +#include "type-ss.h" +}; +GSMpackettype GSM_SMS_packettypes[] = { +#include "type-sms.h" +}; + +GSMpackettype *GSMpackettype_lookup(GSMpackettype list[], int id) +{ + GSMpackettype *ptr = list; + + while(ptr->id != -1 && ptr->id != id) ptr++; + if(ptr->id == -1) { + return NULL; + } else { + return ptr; + } +} + +/* disassemble L3 packet -- GSM 04.06 +tx=0 Network to MS +tx=1 MS to Network +*/ +void GSMDecoder_L3packet(GSMDecoder *self, GSMDecoder_l1l2data *l1, unsigned char *buffer, size_t length) +{ + int proto,type; + GSMpackettype *ptype; + + dumpraw("Inform", buffer, length); + printf(" "); + if(length < 2) return; + + /* Attempt at decoding first byte + -- protocol discriminator + */ + proto = buffer[0]&0xF; + printf("\n %s ", GSM_protocols[proto]); + + switch(proto) { + case 0x3: /* CC */ + type = buffer[1]&0x3F; + ptype = GSMpackettype_lookup(GSM_CC_packettypes, type); + if (ptype == NULL) { + printf("\n Unknown %02X", type); + } else { + printf("\n %s (%s)", ptype->description, ptype->section); + } + break; + case 0x5: /* MM */ + type = buffer[1]&0x3F; + ptype = GSMpackettype_lookup(GSM_MM_packettypes, type); + if (ptype == NULL) { + printf("\n Unknown %02X", type); + } else { + printf("\n %s (%s)", ptype->description, ptype->section); + } + break; + case 0x6: /* RR */ + if (buffer[0]>>4) { + printf("\n RR:Invalid Skip Indicator"); + return; + } + type = buffer[1]; + ptype = GSMpackettype_lookup(GSM_RR_packettypes, type); + if (ptype == NULL) { + printf("\n Unknown %02X", type); + } else { + printf("\n %s (%s)", ptype->description, ptype->section); + } + break; + case 0x9: /* SMS */ + type = buffer[1]&0x3F; + ptype = GSMpackettype_lookup(GSM_SMS_packettypes, type); + if (ptype == NULL) { + printf("\n Unknown %02X", type); + } else { + printf("\n %s (%s)", ptype->description, ptype->section); + } + break; + case 0xB: /* SS */ + if (buffer[1]&0x80) { + printf("\n SS:Invalid Message Type"); + return; + } + type = buffer[1]&0x3F; + ptype = GSMpackettype_lookup(GSM_SS_packettypes, type); + if (ptype == NULL) { + printf("\n Unknown %02X", type); + } else { + printf("\n %s (%s)", ptype->description, ptype->section); + } + break; + } +} + +static void GSMDecoder_l1xml_open(GSMDecoder *self, GSMDecoder_l1l2data *l1, unsigned char *buffer, size_t length) +{ + unsigned int x; + + if(self->xmlout) { + fprintf(self->xmlout, "<l1 "); + fprintf(self->xmlout, "direction=\"%s\" ", l1->tx==GSMDECODER_SEND?"up":"down"); + fprintf(self->xmlout, "logicalchannel=\"%i\" ", l1->ch); + if(l1->tx == GSMDECODER_RECEIVE) { + fprintf(self->xmlout, "physicalchannel=\"%i\" ", l1->arfcn); + fprintf(self->xmlout, "sequence=\"%u\" ", l1->seq); + fprintf(self->xmlout, "error=\"%i\" ", l1->err); + fprintf(self->xmlout, "timeshift=\"%i\" ", l1->timeshift); + fprintf(self->xmlout, "bsic=\"%i\" ", l1->bsic); + fprintf(self->xmlout, "data=\""); + for(x=0; x<length; x++) { + fprintf(self->xmlout, "%02X", buffer[x]); + } + fprintf(self->xmlout, "\" "); + } + fprintf(self->xmlout, ">\n"); + } +} + +static void GSMDecoder_l1xml_close(GSMDecoder *self) +{ + if(self->xmlout) fprintf(self->xmlout, "</l1>\n"); +} + +/* disassemble L2 pseudo length header packet -- GSM 04.06 + tx=0 Network to MS + tx=1 MS to Network + write XML stream +*/ +void GSMDecoder_L2short_packet(GSMDecoder *self, GSMDecoder_l1l2data *l1, unsigned char *buffer, size_t length) +{ + size_t ptr,usedlength, x; + + GSMDecoder_l1xml_open(self, l1, buffer, length); + + if(length<1) { + /* too small to contain 1 header byte */ + printf("L2 packet too small\n"); + GSMDecoder_l1xml_close(self); + return; + } + ptr = 0; + //printf("L2 packet\n"); + + /* dump Length Indicator field */ + usedlength = buffer[ptr]>>2; + if((buffer[ptr]&3) != 1) { + dumpraw("ErrPacket", buffer, length); + printf(" Invalid pseudo length byte\n"); + GSMDecoder_l1xml_close(self); + return; + } + printf("Length : used=%i ID=%i\n", + usedlength, + (buffer[ptr]>>0)&3); + ptr++; + /* dump Information */ + printf("Inform : "); + if((ptr+usedlength) > length) { + printf("Invalid used length\n"); + } + if(self->xmlout) { + fprintf(self->xmlout, "<l2 "); + fprintf(self->xmlout, "data=\""); + for(x=0; x<usedlength; x++) fprintf(self->xmlout, "%02X", buffer[ptr+x]); + fprintf(self->xmlout, "\" "); + /* Rest octets */ + fprintf(self->xmlout, "rest=\""); + for(x=(ptr+usedlength); x<length; x++) fprintf(self->xmlout, "%02X", buffer[x]); + fprintf(self->xmlout, "\" "); + fprintf(self->xmlout, ">\n"); + } + GSMDecoder_L3packet(self, l1, &buffer[ptr], usedlength); + if(self->xmlout) fprintf(self->xmlout, "</l2>\n"); + //dumpraw("Inform", &buffer[ptr], usedlength); + //printf("\n"); + GSMDecoder_l1xml_close(self); +} + +#define TYPE_I 0x01 /* Information */ +#define TYPE_S 0x02 /* Supervisory */ +#define TYPE_U 0x03 /* Unnumbered */ + +/* disassemble L2 packet -- GSM 04.06 +tx=0 Network to MS +tx=1 MS to Network +*/ +void GSMDecoder_L2packet(GSMDecoder *self, GSMDecoder_l1l2data *l1, unsigned char *buffer, size_t length) +{ + size_t ptr,usedlength,x; + int more; + int type; + char temp[80]; + + GSMDecoder_l1xml_open(self, l1, buffer, length); + + if(length<5) { + /* too small to contain 3 header bytes plus 20 data bytes */ + printf("L2 packet too small\n"); + GSMDecoder_l1xml_close(self); + return; + } + ptr = 0; + //printf("L2 packet\n"); + /* dump Address field */ + printf("Address: LPD=%i SAPI=%i C/R=%i EA=%i\n", + (buffer[ptr]>>5)&3, + (buffer[ptr]>>2)&7, + (buffer[ptr]>>1)&1, + (buffer[ptr]>>0)&1); + /* skip next address field bytes */ + while((buffer[ptr]&1)==0) ptr++; + ptr++; + /* dump Control field */ + + type = TYPE_I; + // if(!(buffer[ptr]&1)) type = TYPE_I; + if((buffer[ptr]&1) && !(buffer[ptr]&2)) type = TYPE_S; + if((buffer[ptr]&1) && (buffer[ptr]&2)) type = TYPE_U; + switch(type) { + case TYPE_I: + printf("Control: I TXSeq=%i P=%i RXSeq=%i\n", + (buffer[ptr]>>5)&7, + (buffer[ptr]>>4)&1, + (buffer[ptr]>>1)&7); + break; + case TYPE_S: { + char *desc = "Unknown"; + x = (buffer[ptr]>>2)&3; + switch(x) { + case 0: /* 00 */ desc="RR (Receive Ready)"; break; /* ALSO acknowledgement */ + case 1: /* 01 */ desc="RNR (Receive Not Ready)"; break; + case 2: /* 10 */ desc="REJ (Reject)"; break; + } + printf("Control: S TXSeq=%i P/F=%i S=%i %s\n", + (buffer[ptr]>>5)&7, + (buffer[ptr]>>4)&1, + x, desc); + } break; + case TYPE_U: { + char *desc = "Unknown"; + x = (((buffer[ptr]>>5)&7)<<2) | ((buffer[ptr]>>2)&3); + binstr(temp, x, 5); + switch(x) { + case 0: /* 00000 */ desc = "UI (Unnumbered information)"; break; + case 3: /* 00011 */ desc = "DM (Disconnect mode)"; break; + case 7: /* 00111 */ desc = "SABM (Set asynchronous balanced mode)"; break; + case 8: /* 01000 */ desc = "DISC (Disconnect)"; break; + case 12:/* 01100 */ desc = "UA (Unnumbered acknowledge)"; break; + } + + printf("Control: U U=%s %s P/F=%i\n", + temp, desc, + (buffer[ptr]>>4)&1); + } break; + } + ptr++; + /* dump Length Indicator field */ + usedlength = buffer[ptr]>>2; + more = (buffer[ptr]>>1)&1; /* more to go */ + printf("Length : used=%i M=%i EL=%i\n", + usedlength, more, + (buffer[ptr]>>0)&1); + while((buffer[ptr]&1)==0) ptr++; + ptr++; + /* dump Information */ + printf("Inform : "); + if((ptr+usedlength) > length) { + printf("Invalid used length\n"); + } + /* + for(x=0; x<usedlength; x++) { + printf("%02x ",buffer[ptr]); + ptr++; + } + */ + if(self->xmlout) { + char *desc; + fprintf(self->xmlout, "<l2 "); + switch(type) { + case TYPE_I: + fprintf(self->xmlout, "type=\"I\" "); + fprintf(self->xmlout, "txseq=\"%i\" p=\"%i\" rxseq=\"%i\" ", + (buffer[ptr]>>5)&7, + (buffer[ptr]>>4)&1, + (buffer[ptr]>>1)&7); + break; + case TYPE_S: + fprintf(self->xmlout, "type=\"S\" "); + desc = "Unknown"; + x = (buffer[ptr]>>2)&3; + switch(x) { + case 0: /* 00 */ desc="RR"; break; /* ALSO acknowledgement */ + case 1: /* 01 */ desc="RNR"; break; + case 2: /* 10 */ desc="REJ"; break; + } + fprintf(self->xmlout, "subtype=\"%s\" rxseq=\"%i\" p=\"%i\" ", + desc, + (buffer[ptr]>>5)&7, + (buffer[ptr]>>4)&1); + break; + case TYPE_U: + fprintf(self->xmlout, "type=\"U\" "); + desc = "Unknown"; + x = (((buffer[ptr]>>5)&7)<<2) | ((buffer[ptr]>>2)&3); + switch(x) { + case 0: /* 00000 */ desc = "UI"; break; + case 3: /* 00011 */ desc = "DM"; break; + case 7: /* 00111 */ desc = "SABM"; break; + case 8: /* 01000 */ desc = "DISC"; break; + case 12:/* 01100 */ desc = "UA"; break; + } + + fprintf(self->xmlout, "subtype=\"%s\" p=\"%i\" ", + desc, + (buffer[ptr]>>4)&1); + break; + default: + fprintf(self->xmlout, "type=\"Unknown\" "); + } + fprintf(self->xmlout, "data=\""); + for(x=0; x<usedlength; x++) fprintf(self->xmlout, "%02X", buffer[ptr+x]); + fprintf(self->xmlout, "\" "); + fprintf(self->xmlout, ">\n"); + } + GSMDecoder_L3packet(self, l1, &buffer[ptr], usedlength); + if(self->xmlout) fprintf(self->xmlout, "</l2>\n"); + GSMDecoder_l1xml_close(self); + //dumpraw("Inform", ); + //printf("\n"); +} + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx-gsm.h b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-gsm.h new file mode 100644 index 0000000..13b9ed8 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-gsm.h @@ -0,0 +1,41 @@ +#ifndef WMX_GSM_INCLUDED +#define WMX_GSM_INCLUDED + +typedef struct GSMDecoder_struct { + FILE *xmlout; +} GSMDecoder; + +typedef struct GSMDecoder_l1l2data_struct { + /* 0 receive + 1 send + */ + int tx; + + #define GSMDECODER_RECEIVE 0 + #define GSMDECODER_SEND 1 + + /* send and receive */ + int ch; /* logical channel */ + + /* receive only: */ + int bsic; /* base station identity code */ + int arfcn; /* physical channel */ + int seq; /* sequence number */ + short timeshift; /* diff time with sequence number */ + int err; /* error flag */ +} GSMDecoder_l1l2data; + +GSMDecoder *GSMDecoder_new(); + +void GSMDecoder_free (GSMDecoder *self); +void GSMDecoder_xmlout (GSMDecoder *self, FILE *f); + +void GSMDecoder_L3packet (GSMDecoder *self, GSMDecoder_l1l2data *l1, unsigned char *buffer, size_t length); +void GSMDecoder_L2short_packet (GSMDecoder *self, GSMDecoder_l1l2data *l1, unsigned char *buffer, size_t length); +void GSMDecoder_L2packet (GSMDecoder *self, GSMDecoder_l1l2data *l1, unsigned char *buffer, size_t length); + +#endif + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx-list.c b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-list.c new file mode 100644 index 0000000..9af4b48 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-list.c @@ -0,0 +1,137 @@ +/** + * Decode trace type using text file + * wumpus 2003 -- www.blacksphere.tk + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <signal.h> + +#include "wmx-util.h" +#include "wmx-list.h" + +static void wmx_tracelist_init(struct wmx_tracelist *tl) +{ + tl->entries = 0; + tl->max = 10; + tl->records = malloc(tl->max * sizeof(struct wmx_tracetype)); +} + +static void wmx_tracelist_add(struct wmx_tracelist *tl, int type, char *desc) +{ + /* Possibly expand list */ + if(tl->entries == tl->max) { + tl->max *= 2; + tl->records = realloc(tl->records, tl->max * sizeof(struct wmx_tracetype)); + } + /* Add record */ + tl->records[tl->entries].type = type; + tl->records[tl->entries].desc = strdup(desc); + /* Increase number of entries */ + tl->entries++; + //printf("%04x %04x\n", tl->entries, tl->max); +} + +static void wmx_tracelist_free(struct wmx_tracelist *tl) +{ + int x; + + for(x=0; x<tl->entries; x++) free(tl->records[x].desc); + free(tl->records); + tl->entries = tl->max = 0; + tl->records = NULL; +} + +/** Comparision function for bsearch */ +static int compar(const void *a, const void *b) +{ + int typea = ((struct wmx_tracetype*)a)->type; + int typeb = ((struct wmx_tracetype*)b)->type; + if(typea < typeb) return -1; + if(typea > typeb) return 1; + return 0; +} + +/** + * Look up debug trace type + */ +static struct wmx_tracetype *wmx_tracelist_search(struct wmx_tracelist *tl, int type) +{ + /* + int x; + for(x=0; x<tl->entries; x++) + if(tl->records[x].type == type) + return &tl->records[x]; + return NULL; + */ + + struct wmx_tracetype key; + + key.type = type; + return bsearch(&key, tl->records, tl->entries, sizeof(struct wmx_tracetype), &compar); +} + +struct wmx_tracestruct *wmx_tracestruct_load(char *listfile) +{ + char data[256]; + FILE *f; + struct wmx_tracestruct *tl; + int tpe; + + f = fopen(listfile, "r"); + + if(f == NULL) return NULL; + printf("Loading\n"); + + tl = malloc(sizeof(struct wmx_tracestruct)); + wmx_tracelist_init(&tl->minors); + wmx_tracelist_init(&tl->majors); + + while(fgets(data, sizeof(data), f)) { + int l = strlen(data); + if(l > 0 && data[l-1]=='\n') l--; + data[l] = 0; + if(l < 6) + /* Empty/invalid line */ + continue; + if(data[2] == 'X' && data[3] == 'X') { + sscanf(data, "%02X", &tpe); + wmx_tracelist_add(&tl->majors, tpe, &data[5]); + } else { + sscanf(data, "%04X", &tpe); + wmx_tracelist_add(&tl->minors, tpe, &data[5]); + } + } + fclose(f); + return tl; +} + + +struct wmx_tracetype *wmx_tracestruct_querymajor(struct wmx_tracestruct * ts, int type) { + return wmx_tracelist_search(&ts->majors, type); +} + +struct wmx_tracetype *wmx_tracestruct_queryminor(struct wmx_tracestruct * ts, int type) { + return wmx_tracelist_search(&ts->minors, type); +} + +void wmx_tracestruct_free(struct wmx_tracestruct * ts) { + wmx_tracelist_free(&ts->minors); + wmx_tracelist_free(&ts->majors); + free(ts); +} + +/* +main() { + int x; + struct wmx_tracestruct * tstruct= wmx_tracestruct_load( + "/home/orion/projects/blacksphere/tables/nhm5_587.txt"); + + printf("%s\n", wmx_tracestruct_queryminor(tstruct, 0x1802)->desc); +} +*/ + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx-list.h b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-list.h new file mode 100644 index 0000000..1e76af9 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-list.h @@ -0,0 +1,28 @@ +#ifndef WMX_TRACELIST_INCLUDED +#define WMX_TRACELIST_INCLUDED + +struct wmx_tracetype { + int type; + char *desc; +}; + +struct wmx_tracelist { + int max, entries; + struct wmx_tracetype *records; +}; + +struct wmx_tracestruct { + struct wmx_tracelist majors, minors; +}; + +struct wmx_tracestruct *wmx_tracestruct_load(char *listfile); +struct wmx_tracetype *wmx_tracestruct_querymajor(struct wmx_tracestruct * ts, int type); +struct wmx_tracetype *wmx_tracestruct_queryminor(struct wmx_tracestruct * ts, int type); + +void wmx_tracestruct_free(struct wmx_tracestruct * ts); + +#endif + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx-sim.c b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-sim.c new file mode 100644 index 0000000..039d9e9 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-sim.c @@ -0,0 +1,239 @@ +/** + * SIM packet disassembly functions + * The Monty <monty@technojunkie.gr> + */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <signal.h> + +#include "wmx-util.h" +#include "wmx-sim.h" + +/* Disassemble SIM Command packet (0x25) + * -- GSM 11.11 v6.2.0 (1999) + */ +/* vars: + * ins = sim cmd instruction + * type = 0x25 debug subtype + * buffer = sim cmd's parameter 1 (P1) + P2 + P3 + additional data if exist + * (ie select file, additional data is file id) + */ +void simCommand_data(unsigned char ins, unsigned char type, unsigned char *buffer, size_t length) +{ + size_t x; + int v=1; // v = verbose (to use or not to use ?) + + printf("[a0 %02x ", ins); + for(x=0;x<length;x++) printf("%02x ", buffer[x]); + printf("]\nSim "); + + /* This switches type. The below types are known/valid. Since I don't + * know all the types, i've created a switch based on instruction. + */ +/* switch(type) { + case 0x06: + printf("Request Status"); + break; + case 0x07: + printf("Select Command"); + break; + case 0x10: + printf("GetResponse Command\n"); + break; + default: + printf("Unknown Command\n"); + break; + } +*/ + + /* A switch case based on sim command's instruction */ + switch(ins) { + case 0xa4: + printf("Select Command"); + break; + case 0xf2: + printf("Request Status"); + break; + case 0xb0: + printf("Read Binary"); + break; + case 0xd6: + printf("Update Binary"); + break; + case 0xb2: + printf("Read Record"); + break; + case 0xdc: + printf("Update Record"); + break; + case 0xa2: + printf("Seek cmd"); + break; + case 0x32: + printf("Increase cmd"); + break; + case 0x20: + printf("Verify CHV"); + break; + case 0x24: + printf("Change CHV"); + break; + case 0x26: + printf("Disable CHV"); + break; + case 0x28: + printf("Enable CHV"); + break; + case 0x2c: + printf("Unblock CHV"); + break; + case 0x04: + printf("Invalidate"); + break; + case 0x44: + printf("Rehabilitate"); + break; + case 0x88: + printf("Run GSM Algorithm"); + break; + case 0xfa: + printf("Sleep"); + break; + case 0xc0: + printf("GetResponse Command"); + break; + case 0x10: + printf("Terminal Profile"); + break; + case 0xc2: + printf("Envelope"); + break; + case 0x12: + printf("Fetch"); + break; + case 0x14: + printf("Terminal Response"); + break; + default: + printf("Unknown SIM command "); + printf(" : INS=%02x P1=%02x P2=%02x P3=%02x ", buffer[0], buffer[1], buffer[2], buffer[3]); + printf("\nCommand="); + for(x=0; x<length; x++) printf("%02x ",buffer[x]&0xFF); + printf("\n"); + break; + } + + if(v) { + printf(" : INS=%02x P1=%02x P2=%02x P3=%02x ", ins, buffer[0], buffer[1], buffer[2]); + if (ins==0xa4) { + printf(" FileID=%02x%02x",buffer[3], buffer[4]); + } else { + //printf("\n"); + } + } +} + +void simResponse_Process(unsigned char type, unsigned char *buffer, size_t length) +{ + size_t x; +// for status process : + int RFU1,mem,fileID,fileT; + int lofd; //length of following data + +/* SIM responses to these commands: + - select (for MF/DF files: fileID,memory space available, CHV (en/)disable + indicator, CHV status, GSM specific data. + for EF files: fileID,fileSize,access conditions, valid/invalid + indicator, structure of EF and length of + records if they exist) + - status (fileID,memory space available, CHV en/disable indicator, + CHV status, GSM specific data like select command) + - read binary (string of bytes) + - read record (contents of the record) + - seek (only for seek type 2 response = 1 byte, the record number) + - increase ( etc.. etc.. described in GSM 11.11) + - run gsm algorithm + - get response + - envelope + - fetch +*/ + switch(type) { + case 0x02: + printf("(Read Binary) Binary's Data: "); + for(x=0; x<length; x++) printf("%02x ",buffer[x]&0xFF); + //printf("\n"); + break; + case 0x03: + printf("(Read Record) Record's Data:\n"); + for(x=0; x<length; x++) printf("%02x ",buffer[x]&0xFF); + //printf("\n"); + break; + case 0x05: + printf("Get Response Data: "); + for(x=0; x<length; x++) printf("%02x ",buffer[x]&0xFF); + //printf("\n"); + break; + case 0x06: + printf("Status Response : "); + RFU1 = ((buffer[0]&0xFF)<<8)|(buffer[1]&0xFF); + mem = ((buffer[2]&0xFF)<<8)|(buffer[3]&0xFF); + fileID = ((buffer[4]&0xFF)<<8)|(buffer[5]&0xFF); + fileT = (buffer[6]&0xFF); + //RFU2 = (((buffer[7]&0xFF)<<8)|(buffer[8]&0xFF))<<8|(buffe + lofd = (buffer[12]&0xFF); + printf("RFU=%04x, mem=%04x, fileID=%04x,\nfileType=%02x, RFU=%02x%02x%02x%02x%02x, ", + RFU1, mem, fileID, fileT, + buffer[7], buffer[8], buffer[9], buffer[10], buffer[11] // RFU2 + ); // not the proper way ;) + printf("%02x bytes of GSM specific data follows: ", lofd); + + /* we could analyze these too but there is no meaning or time */ + for(x=0;x<(unsigned int)lofd;x++) printf("%02x ", buffer[13+x]); + //printf("\n"); + break; + case 0x09: + printf("Select Response"); + // select response always has 00 bytes length + break; + default: + printf("Unknown SIM Response : "); + for(x=0; x<length; x++) printf("%02x ",buffer[x]&0xFF); + //printf("\n"); + break; + } +} + +void simAnswer_Process(unsigned char type, unsigned char *buffer, size_t length) +{ + size_t x; + + switch(type) { + case 0x00: + /* in some sim commands (i.e. status or read record) the answer + * is more than 2 bytes. we could analyse all the bytes but the + * usefull ones are only the last 2 of them. + * Should we make a switch() for the answer or would it be + * too much?? + */ + printf("SIM answer: "); + for(x=length-2;x<length;x++) printf("%02x ", buffer[x]&0xFF); + //printf("\n"); + break; + case 0x01: + /* 0x25XX sim command. I don't know why they re-write/send the command :-\ + for(x=0;x<length;x++) printf("%02x ", buffer[x]&0xFF); + printf("\n"); + */ + break; + default: + printf("Uknown subtype! dumping data: "); + for(x=0;x<length;x++) printf("%02x ", buffer[x]&0xFF); + //printf("\n"); + break; + } +} + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx-sim.h b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-sim.h new file mode 100644 index 0000000..c42bd5b --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-sim.h @@ -0,0 +1,13 @@ +#ifndef WMX_SIM + +#define WMX_SIM + +void simCommand_data (unsigned char ins, unsigned char type, unsigned char *buffer, size_t length); +void simResponse_Process(unsigned char type, unsigned char *buffer, size_t length); +void simAnswer_Process (unsigned char type, unsigned char *buffer, size_t length); + +#endif + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx-util.c b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-util.c new file mode 100644 index 0000000..f5e7c9f --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-util.c @@ -0,0 +1,46 @@ +/** + * Generic utils + * wumpus 2003 -- www.blacksphere.tk + */ + +#include <stdio.h> +#include <string.h> +#include <signal.h> + +#include "wmx-util.h" + +/** + * Dump raw hex + */ +void dumpraw(char *str, unsigned char *buffer, size_t length) +{ + size_t x; + + printf("["); + for(x=0; x<length; x++) { + if(x != (length-1)) { + printf("%02x ",buffer[x]); + } else { + printf("%02x",buffer[x]); + } + } + printf("]"); +} + +/** + * Integer to binary + */ +void binstr(char *dest, unsigned int value, int len) +{ + int x; + + for(x=len-1; x>=0; x--) { + dest[x] = '0' + (value & 1); + value >>= 1; + } + dest[len] = 0; +} + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx-util.h b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-util.h new file mode 100644 index 0000000..8c15df0 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx-util.h @@ -0,0 +1,11 @@ +#ifndef WMX_UTIL_INCLUDED +#define WMX_UTIL_INCLUDED + +void dumpraw(char *str, unsigned char *buffer, size_t length); +void binstr(char *dest, unsigned int value, int len); + +#endif + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx.c b/gammu/emb/gammu/depend/nokia/dct3trac/wmx.c new file mode 100644 index 0000000..64eda37 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx.c @@ -0,0 +1,480 @@ +/** + * Nokia DCT3 Firmware Debug Trace Monitor + * wumpus 2003 -- www.blacksphere.tk + * SIM stuff by The Monty + * + * Command line arguments: + * gammu --nokiadebug v00-0F,20,21 + * (v=verbose) + */ + +#include "../../../../common/gsmstate.h" + +#ifdef GSM_ENABLE_NOKIA_DCT3 + +#include <string.h> +#include <signal.h> + +#include "../../../../common/misc/coding/coding.h" +#include "../../../../common/gsmcomon.h" +#include "../../../../common/gsmstate.h" +#include "../../../../common/service/gsmpbk.h" +#include "../../../../common/phone/nokia/dct3/dct3func.h" +#include "../../../gammu.h" +#include "../dct3.h" +#include "wmx.h" +#include "wmx-util.h" +#include "wmx-gsm.h" +#include "wmx-sim.h" +#include "wmx-list.h" + +extern GSM_Reply_Function UserReplyFunctionsX[]; + +/* Global variables suck */ +GSMDecoder *gsmdec; +struct wmx_tracestruct *traces; + +static GSM_Error DCT3_ReplySwitchDebug(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + switch(msg.Buffer[2]) { + case 0x70: + printf("Debug Trace Enabled\n"); + break; + case 0x71: + printf("Debug Trace Disabled\n"); + break; + } + return ERR_NONE; +} + +/** + * RPC confirmation/reply + */ +static GSM_Error DCT3_ReplyRPC(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("RPC Reply "); + printf("call=%02x rettype=%02x data=", msg.Buffer[2], msg.Buffer[3]); + if(msg.Buffer[3] == 3) { + /* string */ + printf("%s", &msg.Buffer[4]); + } else { + dumpraw("RPC Reply data", &msg.Buffer[4], msg.Length-4); + } + printf("\n"); + return ERR_NONE; +} + +/* disassemble mdisnd (0x18xx) packet */ +static void mdisnd_data(unsigned char type, unsigned char *buffer, size_t length) +{ + GSMDecoder_l1l2data dat; + size_t x; + int ch; + + if(type==0x1B && length>2) { + /* channel packet */ + ch = buffer[1]; + dat.tx = GSMDECODER_SEND; + dat.ch = ch; + printf("%02X ch=%02X ",buffer[0],ch); + if (ch == 0x80 || ch == 0xB0) { + printf("\n"); + GSMDecoder_L2packet(gsmdec, &dat, &buffer[2], length-2); + } else if (ch == 0x70) { + dumpraw("MDI send ch70 prefix", &buffer[2], 2); + printf("\n"); + GSMDecoder_L2packet(gsmdec, &dat, &buffer[4], length-4); + } else { + dumpraw("MDI recv 1B packet", &buffer[2], length-2); + } + } else { + /* hex */ + for(x=0; x<length; x++) { + printf("%02x ",buffer[x]&0xFF); + } + } +} + +/* disassemble mdircv (0x19xx) packet */ +static void mdircv_data(unsigned char type, unsigned char *buffer, size_t length) +{ + size_t x; + int ch; + GSMDecoder_l1l2data dat; + + if (type==0x80 && length>1) { + // buffer[0] channel + // buffer[1] flag1 + // buffer[2] flag2 + // buffer[3..5] timestamp + // buffer[6..7] unknown_hw1 + // buffer[8..9] unknown_hw2 + ch = buffer[0]; + dat.tx = GSMDECODER_RECEIVE; + dat.ch = ch; + dat.bsic = buffer[1]; + dat.err = buffer[2]; + dat.seq = (buffer[3]<<16)|(buffer[4]<<8)|(buffer[5]); + dat.arfcn = (buffer[6]<<8)|buffer[7]; + dat.timeshift = (buffer[8]<<8)|buffer[9]; + + printf("ch=%02X bsic=%i err=%i t=%06X arfcn=%i shift=%i", + ch, buffer[1], buffer[2], + dat.seq, dat.arfcn, dat.timeshift + ); + + //dumpraw("MDI recv 80 header", &buffer[6], 4); + printf(" "); + if(buffer[2] == 0) { /* unencrypted */ + if(ch == 0x70) { + /* Normal header + 2b prefix */ + dumpraw("MDI recv ch70 prefix", &buffer[10], 2); + printf("\n"); + GSMDecoder_L2packet(gsmdec, &dat, &buffer[12], length-12); + } else if (ch == 0x80 || ch == 0xB0) { + /* Normal header */ + printf("\n"); + GSMDecoder_L2packet(gsmdec, &dat, &buffer[10], length-10); + } else if (ch == 0x50 || ch == 0x60) { + /* Short header */ + + printf("\n"); + GSMDecoder_L2short_packet(gsmdec, &dat, &buffer[10], length-10); + } else { + dumpraw("MDI send 80 packet", &buffer[10], length-10); + } + } else { + /* Encrypted (?) */ + dumpraw("MDI send err 80", &buffer[10], length-10); + } + } else { + /* hex */ + for(x=0; x<length; x++) { + printf("%02x ",buffer[x]&0xFF); + } + } +} + +static GSM_Error DCT3_ReplyDebugTrace(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int x; + int id,timestamp,number,length; + struct wmx_tracetype *minor; + char *desc; + + //printf("Debug Trace Received\n"); + /* parse frame + Debug trace packet: + packet type 0x00 + source subsystem 0x01 (LOCAL) + verder formaat zie notebook + 0x08 ID (payload=offset 0x02 here) + 0x0A timestamp + 0x0C seq nr + 0x0D .. parameters + */ + id = ((msg.Buffer[2]&0xFF)<<8)|(msg.Buffer[3]&0xFF); + timestamp = ((msg.Buffer[4]&0xFF)<<8)|(msg.Buffer[5]&0xFF); + number = msg.Buffer[6]&0xFF; + length = msg.Buffer[7]&0xFF; + + /* filter */ + //if((id&0xFF00)==0x1900 && id != 0x1980) + // return GE_NONE; + //printf("%02x\n",msg.Buffer[10]); + //if(msg.Buffer[10]!=0x40) + // return GE_NONE; + /* Query trace type name */ + desc = "Unknown"; + if(traces != NULL) { + minor = wmx_tracestruct_queryminor(traces, id); + if(minor != NULL) desc = minor->desc; + } + printf("<%04X> %s\n", id, desc); + printf("t=%04x nr=%02x: ", timestamp, number); + + /* TODO -- decode debug types on phone type */ + switch(id>>8) { + case 0x33: + case 0x34: + case 0x35: + case 0x37: + case 0x38: + case 0x39: + case 0x3A: + case 0x3B: + case 0x3C: + case 0x5F: + /* text */ + /* skip length byte */ + printf("\""); + for(x=8; x<msg.Length; x++) { + printf("%c",msg.Buffer[x]&0xFF); + } + printf("\""); + break; + /* + case 0x6801: + for(x=8; x<msg.Length; x++) { + printf("%02x%c ",msg.Buffer[x]&0xFF,msg.Buffer[x]&0xFF); + } + break; + */ + case 0x18: /* MDISND */ + + /* skip these: + +00 length + +01 type (also xx in 0x18xx) + */ + if(msg.Length<10 || msg.Buffer[9]!=(id&0xFF)) { + printf("C %02X: param:%02x", id&0xFF, msg.Buffer[8]); + } else { + //printf("D %02X: ", id&0xFF); + printf("D %02X: ", id&0xFF); + mdisnd_data((unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[10], msg.Length-10); + } + break; + case 0x19: /* MDIRCV */ + if(msg.Length<10 || msg.Buffer[9]!=(id&0xFF)) { + printf("C %02X: param:%02x", id&0xFF, msg.Buffer[8]); + } else { + printf("D %02X: ", id&0xFF); + mdircv_data((unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[10], msg.Length-10); + //dumpraw((unsigned char*)&msg.Buffer[10], msg.Length-10); + } + break; + case 0x20: /* 0x25 SIM commands */ + /* + for(x=8;x<msg.Length;x++) + printf("%02x ", msg.Buffer[x]&0xFF); + */ + printf("SIM command "); + if(msg.Buffer[8]==0xa0) { // check if valid (class=a0) + simCommand_data(msg.Buffer[9], (unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[10], msg.Length-10); + // TODO: pass the msg.Buffer[9] and skip 1rst arg + } else { + printf("Unknown 0x25 packet (NOT SIM cmd): "); + for(x=8;x<msg.Length;x++) printf("%02x ", msg.Buffer[x]&0xFF); + printf("\n"); + } + break; + case 0x22: /* 0x27 SIM answer to command (error/ok/etc..) */ + if(msg.Length<10) { + // Unknown response + for(x=0;x<msg.Length-10;x++) printf("%02x ", msg.Buffer[x]&0xFF); + printf(" (Unknown 0x27 packet ? ? )\n"); + } else { + simAnswer_Process((unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[8], length); + } + break; + case 0x23: /* 0x28 SIM response data to commands */ + if(msg.Length<10) { + // Unknown response + for(x=0;x<msg.Length-10;x++) printf("%02x ", msg.Buffer[x]&0xFF); + printf(" (Unknown 0x28 packet)\n"); + } else { + simResponse_Process((unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[8], length); + } + break; + default: + /* hex */ + for(x=8; x<msg.Length; x++) { + printf("%02x ",msg.Buffer[x]&0xFF); + } + break; + } + printf("\n"); + return ERR_NONE; +} + + +static GSM_Error DCT3_ReplyMyPacket(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int x; + + printf("MyPacket "); + for(x=0; x<msg.Length; x++) { + printf("%02x ",msg.Buffer[x]&0xFF); + } + printf("\n"); + return ERR_NONE; +} + +#define ID_DebugTrace 0x666 +#define ID_DebugSwitch 0x667 +#define ID_RPC 0x668 + +void DCT3SetDebug(int argc, char *argv[]) +{ + int x,count; + unsigned int y; + unsigned char reqDisable[] = {0x01, 0x01, 0x71}; +// unsigned char reqTest[] = {0x01, 0x01, 0x96, 0xFF, 0xFF}; + + /* RPC testing packets: */ + + /* RPC: Get version */ + //unsigned char reqTest2[] = {0x01, 0x01, 0x00, 0x03, 0x00}; + /* RPC: read I/O 0x6D mask 0xFF */ + //unsigned char reqTest2[] = {0x01, 0x01, 0x02, 0x01, 0x02, 0x6D, 0xFF}; /* */ + /* RPC: write I/O 0x03 mask 0xFF value 0x31 */ + //unsigned char reqTest2[] = {0x01, 0x01, 0x01, 0x01, 0x07, 0x03, 0xFF, 0x31}; /* write I/O */ + + /* RPC: write forged FBUS packet to MDISND */ +// unsigned char reqTest2[] = {0x01, 0x01, 0x16, 0x01, 0x06, +// 0x14, // R0 -- length +// 0x05, // R1 -- MDI type identifier 0x05(FBUS) +// 0x1e, 0x0c, 0x00, 0x66, +// 0x00, 0x0e, 0x01, 0x01, +// 0x66, 0x55, 0x44, 0x33, +// 0x0d, 0x01, 0x01, 0x01, +// 0x1b, 0x58, 0x01, 0x44}; +// 1805 t=cb37 nr=e2 :D 05: + + /* debug enable packet */ + unsigned char reqEnable[] = { + 0x00, 0x01, 0x70, + /* Debug bits + byte[bit>>3]&(1<<(7-(bit&7))) + */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x40 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x80 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xC0 */ + /* Debug verbose bits + byte[bit>>3]&(1<<(7-(bit&7))) + */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }; + + #define ENABLE_BIT(bit,verbose) reqEnable[3 + (bit>>3)] |= 1<<(7-(bit&7)); if(verbose){reqEnable[3 + 32 + (bit>>3)] |= 1<<(7-(bit&7));} + + /* Enable some bit + TODO command line or GUI interface + */ + //ENABLE_BIT(0x18, 1); /* Enable MDISND debugging */ + //ENABLE_BIT(0x19, 1); /* Enable MDIRCV debugging */ + //ENABLE_BIT(0x31, 1); + + gsmdec = GSMDecoder_new(); + /* Open XML file .. needs to be argument */ + { + FILE *xout = fopen("out.xml", "w"); + GSMDecoder_xmlout(gsmdec, xout); + } + printf("Debug Trace Mode -- wumpus 2003\n"); + traces = wmx_tracestruct_load(argv[2]); + if(traces == NULL) + printf("Warning: could not load trace description file %s\n", argv[2]); + printf("Activating ranges:\n"); + count = 0; + for(x=3; x<argc; x++) { + char *ptr = argv[x]; + unsigned from,to,verbose; + + while(*ptr) { + verbose = 0; + if(*ptr == 'v') { + verbose = 1; + ptr++; + } + to = from = strtol(ptr, &ptr, 16); + if(*ptr == '-') { + ptr ++; + to = strtol(ptr, &ptr, 16); + } + if(*ptr != ',' && *ptr != 0) { + printf("Invalid parameter '%s'\n", argv[x]); + return; + } + if(*ptr == ',') + ptr++; + if(from > 0xFF) from=0xFF; + if(to > 0xFF) to=0xFF; + printf(" %02x-%02x verbose=%i\n",from,to,verbose); + for(y=from; y<=to; y++) { + ENABLE_BIT(y, verbose); + count++; + } + } + } + if(count == 0) { + printf("Nothing activated -- bailing out\n"); + return; + } + //ENABLE_BIT(0x20, 1); /* SIM commands (literal) */ + //ENABLE_BIT(0x21, 1); /* SIML2 commands (literal) */ + //ENABLE_BIT(0x22, 1); /* SIM commands (literal) */ + //ENABLE_BIT(0x3B, 1); /* PHCTRL state */ + + GSM_Init(true); + + /* We Need DCT3 */ + if (CheckDCT3Only()!=ERR_NONE) return; + + error=DCT3_EnableSecurity (&s, 0x01); + Print_Error(error); + + s.User.UserReplyFunctions=UserReplyFunctionsX; + + //error=GSM_WaitFor (&s, reqTest, sizeof(reqTest), 0x40, 1, ID_DebugSwitch); + + //error=GSM_WaitFor (&s, reqTest2, sizeof(reqTest2), 0xD1, 4, ID_RPC); + + /* Enable Debug Mode */ + error=GSM_WaitFor (&s, reqEnable, sizeof(reqEnable), 0x40, 4, ID_DebugSwitch); + + Print_Error(error); + signal(SIGINT, interrupt); + printf("Press Ctrl+C to interrupt...\n"); + x=0; + + /* + while(x<100) { + //printf(": %02x\n",x); + s.Phone.Data.RequestID = ID_DebugTrace; + res = s.Device.Functions->ReadDevice(&s, buff, 255); + if(res) { + printf("%02x\n",x); + for(y=0;y<res;y++) { + //printf("%02x\n",x,buff[y]&0xFF); + s.Protocol.Functions->StateMachine(&s,buff[y]); + x++; + } + } + } + */ + ; + + /* todo: wait and dump for some time */ + while (!gshutdown) { + GSM_ReadDevice(&s,true); + my_sleep(10); + } + signal(SIGINT, SIG_DFL); + printf("Disabling\n"); + error=GSM_WaitFor (&s, reqDisable, sizeof(reqDisable), 0x40, 10, ID_DebugSwitch); + Print_Error(error); + + GSMDecoder_free(gsmdec); +} + +static GSM_Reply_Function UserReplyFunctionsX[] = { + {DCT3_ReplySwitchDebug, "\x40",0x02,0x70,ID_DebugSwitch }, + {DCT3_ReplySwitchDebug, "\x40",0x02,0x71,ID_DebugSwitch }, + {DCT3_ReplyDebugTrace, "\x00",0x00,0x00,ID_IncomingFrame }, + {DCT3_ReplyMyPacket, "\x40",0x00,0x00,ID_IncomingFrame }, + + {DCT3_ReplyRPC, "\xD2",0x00,0x00,ID_RPC }, + + {NULL, "\x00",0x00,0x00,ID_None } +}; + +#endif + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx.h b/gammu/emb/gammu/depend/nokia/dct3trac/wmx.h new file mode 100644 index 0000000..76fb394 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx.h @@ -0,0 +1,5 @@ +void DCT3SetDebug (int argc, char *argv[]); + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct4.c b/gammu/emb/gammu/depend/nokia/dct4.c new file mode 100644 index 0000000..f4ed305 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct4.c @@ -0,0 +1,1341 @@ +/* (c) 2002-2004 by Marcin Wiacek */ + +#include "../../../common/gsmstate.h" + +#ifdef GSM_ENABLE_NOKIA_DCT4 + +#include <string.h> + +#include "dct4.h" +#include "../../gammu.h" +#include "../../../common/phone/pfunc.h" +#include "../../../common/phone/nokia/nfunc.h" +#include "../../../common/phone/nokia/dct4/dct4func.h" +#include "../../../common/misc/coding/coding.h" + +extern GSM_Reply_Function UserReplyFunctions4[]; + +/* ------- some usefull functions ----------------------------------------- */ + +GSM_Error CheckDCT4Only() +{ + bool found = false; + + /* Checking if phone is DCT4 */ +#ifdef GSM_ENABLE_NOKIA3650 + if (strstr(N3650Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true; +#endif +#ifdef GSM_ENABLE_NOKIA6510 + if (strstr(N6510Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true; +#endif +#ifdef GSM_ENABLE_NOKIA3320 + if (strstr(N3320Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true; +#endif + if (!found) return ERR_NOTSUPPORTED; + + if (s.ConnectionType!=GCT_MBUS2 && s.ConnectionType!=GCT_FBUS2 && + s.ConnectionType!=GCT_FBUS2DLR3 && s.ConnectionType!=GCT_PHONETBLUE && + s.ConnectionType!=GCT_IRDAPHONET && s.ConnectionType!=GCT_BLUEPHONET) { + return ERR_OTHERCONNECTIONREQUIRED; + } + return ERR_NONE; +} + +static void CheckDCT4() +{ + GSM_Error error; + + error = CheckDCT4Only(); + switch (error) { + case ERR_NOTSUPPORTED: + Print_Error(ERR_NOTSUPPORTED); + break; + case ERR_OTHERCONNECTIONREQUIRED: + printf("Can't do it with current phone protocol\n"); + GSM_TerminateConnection(&s); + exit(-1); + default: + break; + } +} + +static bool answer_yes2(char *text) +{ + int len; + char ans[99]; + + while (1) { + printf("%s (yes/no) ? ",text); + len=GetLine(stdin, ans, 99); + if (len==-1) exit(-1); + if (mystrncasecmp(ans, "yes",0)) return true; + if (mystrncasecmp(ans, "no" ,0)) return false; + } +} + +/* ------------------- functions ------------------------------------------- */ + +static DCT4_Feature DCT4Features[] = { + {DCT4_ALWAYS_ONLINE, "GPRS Always Online", {{0,"on (Context)"},{1,"off (Attach)"},{0,""}}},///?? + {DCT4_GPRS_PCCH, "PCCH support for GPRS", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_GEA1, "GEA1 support indication", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_EOTD, "EOTD support", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_WAP_PUSH, "WAP push", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_USE_PREF_SIM_NET, "Use SIM preffered network list",{{1,"on"},{0,"off"},{0,""}}}, + {DCT4_JAVA_TCK, "Java TCK support", {{1,"on"},{0,"off"},{0,""}}}, + + {DCT4_ALS, "Alternate Line Service (ALS)", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_A52, "Ciphering alghoritm A52", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_CSP, "Customer Service Profile", {{0,"off"},{1,"on"},{0,""}}}, + {DCT4_EONS, "EONS support", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_3GINDICATOR, "3G indicator", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_DISPLAY_PHONE_NAME, "Display both number and name for incoming calls",{{1,"on"},{0,"off"},{0,""}}}, + {DCT4_DISPLAY_WAP_PROFILE, "Display selected WAP profile name instead of Home option menu in Services",{{1,"on"},{0,"off"},{0,""}}}, + + {DCT4_GAMES_WAP_DOWNLOAD, "Games WAP download", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_GAMES_SCORE_SEND, "Games WAP score send", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_GAMES_URL_CHECK, "Games URL check", {{1,"on"},{0,"off"},{0,""}}}, + + {DCT4_BLUETOOTH_MENU, "Bluetooth menu", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_WAP_BOOKMARKS_MENU, "Bookmarks menu in Services", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_WAP_BOOKMARKS_MENU2, "Bookmarks menu in Services", {{3,"bookmarks & download"},{0,"off"},{0,""}}}, + {DCT4_WAP_GOTO_MENU, "GoTo menu in Services", {{0,"on"},{1,"off"},{0,""}}}, + {DCT4_WAP_SETTINGS_MENU, "Profiles menu in Services", {{0,"on"},{1,"off"},{0,""}}}, + {DCT4_SERVICES_GAMES_APP_GALLERY,"Services menu in Games/Apps/Gallery",{{1,"on"},{0,"off"},{0,""}}}, + {DCT4_JAVA_GAMES_MENU, "Java games menu in Games", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_SAT_CONFIRM_MENU, "Can use confirming SIM service actions", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_INSTANT_MESS_MENU, "Instant Messaging in Messages",{{1,"on"},{0,"off"},{0,""}}}, + {DCT4_CONFIRM_ALS, "Confirm using ALS", {{1,"on"},{0,"off"},{0,""}}}, + {DCT4_BOOKMARK_GOTO_MENU, "Bookmarks in GoTo menu", {{1,"on"},{0,"off"},{0,""}}}, + + {DCT4_5100_IDENTIFY, "Phone identification", {{1,"NPM-6U"},{0,"NPM-6"},{0,""}}}, + +#ifdef DEBUG + {DCT4_TEST,"",{{1,"1"},{0,"0"}}}, +#endif + + {0, "", {{0,""}}} +}; + +static DCT4_Phone_Features DCT4PhoneFeatures[] = { +/*3100*/ {"RH-19", {{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,4},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + {DCT4_EONS,28},{DCT4_3GINDICATOR,30},{DCT4_INSTANT_MESS_MENU,33}, + {DCT4_CONFIRM_ALS,35}, + {0,0}}}, +/*3200*/ {"RH-30", {{DCT4_ALS,2},{DCT4_A52,4},{DCT4_CSP,5},{DCT4_GPRS_PCCH,14}, + {DCT4_GEA1,15},{DCT4_EOTD,18},{DCT4_WAP_SETTINGS_MENU,20}, + {DCT4_DISPLAY_PHONE_NAME,21},{DCT4_WAP_GOTO_MENU,23}, + {DCT4_SERVICES_GAMES_APP_GALLERY,26},{DCT4_3GINDICATOR,28}, + {DCT4_DISPLAY_WAP_PROFILE,31},{DCT4_SAT_CONFIRM_MENU,33}, + {DCT4_CONFIRM_ALS,34},{DCT4_EONS,40},{DCT4_ALWAYS_ONLINE,45}, + {0,0}}}, +/*3200*/ {"RH-31", {{DCT4_ALS,2},{DCT4_A52,4},{DCT4_CSP,5},{DCT4_GPRS_PCCH,14}, + {DCT4_GEA1,15},{DCT4_EOTD,18},{DCT4_WAP_SETTINGS_MENU,20}, + {DCT4_DISPLAY_PHONE_NAME,21},{DCT4_WAP_GOTO_MENU,23}, + {DCT4_SERVICES_GAMES_APP_GALLERY,26},{DCT4_3GINDICATOR,28}, + {DCT4_DISPLAY_WAP_PROFILE,31},{DCT4_SAT_CONFIRM_MENU,33}, + {DCT4_CONFIRM_ALS,34},{DCT4_EONS,40},{DCT4_ALWAYS_ONLINE,45}, + {0,0}}}, +/*3300*/ {"NEM-1", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + /*MORE*/ {0,0}}}, +/*3510*/ {"NHM-8", {{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,6}, + {DCT4_GAMES_WAP_DOWNLOAD,7},{DCT4_GAMES_SCORE_SEND,8}, + {DCT4_GAMES_URL_CHECK,9},{DCT4_GPRS_PCCH,13}, + {DCT4_GEA1,15},{DCT4_ALWAYS_ONLINE,18},{0,0}}}, +/*3510i*/{"RH-9", {{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,4},{DCT4_GPRS_PCCH,9}, + {DCT4_DISPLAY_PHONE_NAME,14},{DCT4_WAP_GOTO_MENU,15}, + {DCT4_WAP_SETTINGS_MENU,16},{DCT4_SERVICES_GAMES_APP_GALLERY,19}, + {DCT4_DISPLAY_WAP_PROFILE,25},{0,0}}}, +/*3650*/ {"NHL-8", {{DCT4_ALS,1},{0,0}}}, +/*5100*/ {"NPM-6", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + {DCT4_EONS,28}, + // {DCT4_5100_IDENTIFY,10}, + {0,0}}}, +/*5100*/ {"NPM-6U", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + {DCT4_EONS,28}, + // {DCT4_5100_IDENTIFY,10}, + {0,0}}}, +/*6100*/ {"NPL-2", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + {0,0}}}, +/*6220*/ {"RH-20", {{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,4}, + {DCT4_GEA1,14},{DCT4_EOTD,17},{DCT4_WAP_SETTINGS_MENU,19}, + {DCT4_DISPLAY_PHONE_NAME,20},{DCT4_WAP_GOTO_MENU,22}, + {DCT4_WAP_BOOKMARKS_MENU2,24},{DCT4_SERVICES_GAMES_APP_GALLERY,25}, + {DCT4_3GINDICATOR,27},{DCT4_DISPLAY_WAP_PROFILE,30},{DCT4_SAT_CONFIRM_MENU,32}, + {DCT4_CONFIRM_ALS,33},{DCT4_JAVA_TCK,36},{DCT4_BOOKMARK_GOTO_MENU,37}, + {0,0}}}, +/*6310*/ {"NPE-4", {{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,6},{DCT4_GAMES_WAP_DOWNLOAD,7}, + {DCT4_GAMES_SCORE_SEND,8},{DCT4_GAMES_URL_CHECK,9},{DCT4_BLUETOOTH_MENU,10}, + {DCT4_GPRS_PCCH,13},{DCT4_GEA1,15},{DCT4_ALWAYS_ONLINE,18},{0,0}}}, +/*6310i*/{"NPL-1", {{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,6},{DCT4_GAMES_WAP_DOWNLOAD,7}, + {DCT4_GAMES_SCORE_SEND,8},{DCT4_GAMES_URL_CHECK,9}, + {DCT4_BLUETOOTH_MENU,10},{DCT4_USE_PREF_SIM_NET,11}, + {DCT4_GPRS_PCCH,13},{DCT4_GEA1,15},{DCT4_EOTD,16}, + {DCT4_ALWAYS_ONLINE,17},{DCT4_JAVA_GAMES_MENU,18}, + {DCT4_WAP_BOOKMARKS_MENU,20},{DCT4_WAP_SETTINGS_MENU,21}, + {DCT4_WAP_PUSH,28},{DCT4_WAP_GOTO_MENU,29},{0,0}}}, +/*6510*/ {"NPM-9", {{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,6},{DCT4_GAMES_WAP_DOWNLOAD,7}, + {DCT4_GAMES_SCORE_SEND,8},{DCT4_GAMES_URL_CHECK,9}, + {DCT4_GPRS_PCCH,13},{DCT4_GEA1,15},{DCT4_ALWAYS_ONLINE,18},{0,0}}}, +/*6610*/ {"NHL-4U", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + {0,0}}}, +/*6800*/ {"NHL-6", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + /*MORE*/ {0,0}}}, +/*7210*/ {"NHL-4", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + {0,0}}}, +/*7250*/ {"NHL-4J", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + {0,0}}}, +/*7250i*/{"NHL-4JX", {{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8}, + {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12}, + {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18}, + {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22}, + {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27}, + /*MORE*/ {0,0}}}, +/*8310*/{"NHM-7", {{DCT4_ALS,1},{DCT4_CSP,6},{DCT4_GAMES_WAP_DOWNLOAD,7}, + {DCT4_GAMES_SCORE_SEND,8},{DCT4_GAMES_URL_CHECK,9},{DCT4_GPRS_PCCH,13}, + {DCT4_ALWAYS_ONLINE,18},{0,0}}}, + {"", {{0,0}}} +}; + +static GSM_Error DCT4_ReplySetPPS(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("Setting done OK\n"); + return ERR_NONE; +} + +void DCT4SetPhoneMenus(int argc, char *argv[]) +{ + int current = 10,i=0,j,z; + unsigned char reqSet[200] = { + N7110_FRAME_HEADER,0x04,0x00,0x01,0x47,0x48,0x02, + 0x00}; /* Number of changed features */ + + if (CheckDCT4Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + while (DCT4PhoneFeatures[i].Model[0] != 0x00) { + if (!strcmp(DCT4PhoneFeatures[i].Model,s.Phone.Data.Model)) { + j = 0; + while (DCT4PhoneFeatures[i].Features[j].Name != 0x00) { + z = 0; + while (DCT4Features[z].Name != 0x00) { + if (DCT4Features[z].Name == DCT4PhoneFeatures[i].Features[j].Name) { + printf("%s : %s\n",DCT4Features[z].Text,DCT4Features[z].Values[0].Text); + reqSet[9]++; /* Number of features */ + reqSet[current++] = DCT4PhoneFeatures[i].Features[j].Number; /* Feature number */ + reqSet[current++] = DCT4Features[z].Values[0].Value; /* Value */ + break; + } + z++; + } + j++; + } + } + i++; + } + + if (current == 10) { + printf("Sorry, but configuration matrix for this model is not added yet. Please report\n"); + return; + } + + reqSet[current++] = 0x00; + reqSet[current++] = 0x00; + + error=GSM_WaitFor (&s, reqSet, current, 0x1b, 4, ID_User1); + Print_Error(error); +} + +DCT4_Phone_Tests DCT4Tests; + +static GSM_Error DCT4_ReplyTestsNames(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i,pos; + + DCT4Tests.Num = msg.Buffer[5]; + pos = 6; + + smprintf(s,"%i names for phone tests received\n",msg.Buffer[5]); + for (i=0;i<msg.Buffer[5];i++) { + strcpy(DCT4Tests.Tests[i].Name,msg.Buffer+pos+4); + DCT4Tests.Tests[i].ID = msg.Buffer[pos+2]; + smprintf(s,"%x.\"%s\"\n",DCT4Tests.Tests[i].ID,DCT4Tests.Tests[i].Name); + pos+=msg.Buffer[pos+1]; + } + + return ERR_NONE; +} + +static GSM_Error DCT4_ReplyTestsStartup(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i,pos,j; + bool found; + + pos = 10; + + for (i=0;i<msg.Buffer[8];i++) { + found = false; + for (j=0;j<DCT4Tests.Num;j++) { + if (DCT4Tests.Tests[j].ID == msg.Buffer[pos]) { + DCT4Tests.Tests[j].Startup = true; + found = true; + break; + } + } + if (!found) printf("%x ",msg.Buffer[pos]); + pos++; + } + + return ERR_NONE; +} + +static GSM_Error DCT4_ReplyTestsStatus(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i,pos,j; + + pos = 6; + + smprintf(s,"%i status entries for phone tests received\n",msg.Buffer[5]); + for (i=0;i<msg.Buffer[5];i++) { + for (j=0;j<DCT4Tests.Num;j++) { + if (DCT4Tests.Tests[j].ID == msg.Buffer[pos+2]) { + printf("\"%40s\" : ",DCT4Tests.Tests[j].Name); + switch(msg.Buffer[pos+3]) { + case 0x00: printf("Passed"); break; + case 0x01: printf("Fail"); break; + case 0x03: printf("Not executed"); break; + case 0x06: printf("No signal"); break; + case 0x0D: printf("Timeout"); break; + default : printf("Unknown (%x)",msg.Buffer[pos+3]); + } + if (DCT4Tests.Tests[j].Startup) printf(" (startup)"); + printf("\n"); + break; + } + } + pos+=msg.Buffer[pos+1]; + } + + return ERR_NONE; +} + +void DCT4SelfTests(int argc, char *argv[]) +{ + int j; + unsigned char GetDoneST[6] = {0x00, 0x08, 0x01, 0x04, 0x01, 0x00}; + unsigned char GetDoneST2[6] = {0x00, 0x08, 0x02, 0x04, 0x02, 0x00}; + unsigned char GetNames[6] = {0x00, 0x08, 0x03, 0x06, 0x03, 0x00}; + unsigned char GetStatus[6] = {0x00, 0x08, 0x04, 0x02, 0x03, 0x00}; + + unsigned char RunALL[6] = {0x00, 0x06, 0x04, 0x00, 0x03, 0x00}; + +// unsigned char GetID[6] = {0x00, 0x08, 0x00, 0x04, 0x03, 0x00};//tests ID + + if (CheckDCT4Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + if (answer_yes2("Run all tests now ?")) { + error=GSM_WaitFor (&s, RunALL, 6, 0x35, 4, ID_User1); + Print_Error(error); + } + + error=GSM_WaitFor (&s, GetNames, 6, 0x35, 4, ID_User1); + Print_Error(error); + + for (j=0;j<DCT4Tests.Num;j++) DCT4Tests.Tests[j].Startup = false; + + error=GSM_WaitFor (&s, GetDoneST, 6, 0x35, 4, ID_User3); + Print_Error(error); + + error=GSM_WaitFor (&s, GetDoneST2, 6, 0x35, 4, ID_User3); + Print_Error(error); + + error=GSM_WaitFor (&s, GetStatus, 6, 0x35, 4, ID_User2); + Print_Error(error); +} + +static GSM_Error DCT4_ReplyVibra(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ +#ifdef DEBUG + switch (msg.Buffer[3]) { + case 0x0D : dbgprintf("Vibra state set OK\n"); break; + case 0x0F : dbgprintf("Vibra power set OK\n"); break; + } +#endif + return ERR_NONE; +} + +static GSM_Error DCT4EnableVibra(GSM_StateMachine *s, bool enable) +{ + /* Enables or disables vibra */ + unsigned char Control[6] = {N7110_FRAME_HEADER,0x0C, + 0x01, /* 0x01 = On, 0x00 = Off */ + 0x00}; + + if (!enable) Control[4] = 0x00; + return GSM_WaitFor (s, Control, 6, 0x1C, 4, ID_User3); +} + +void DCT4SetVibraLevel(int argc, char *argv[]) +{ + GSM_DateTime Date; + unsigned int i,j; + + /* Set vibra level */ + unsigned char SetLevel[6] = {N7110_FRAME_HEADER,0x0E, + 0x64, /* Vibra power (in percent) */ + 0x00}; + + GSM_Init(true); + + CheckDCT4(); + + s.User.UserReplyFunctions=UserReplyFunctions4; + + SetLevel[4] = atoi(argv[2]); + error=GSM_WaitFor (&s, SetLevel, 6, 0x1C, 4, ID_User3); + Print_Error(error); + + error=DCT4EnableVibra(&s, true); + Print_Error(error); + + for (i=0;i<3;i++) { + GSM_GetCurrentDateTime (&Date); + j=Date.Second; + while (j==Date.Second) { + my_sleep(10); + GSM_GetCurrentDateTime(&Date); + } + } + + error=DCT4EnableVibra(&s, false); + Print_Error(error); + + GSM_Terminate(); +} + +void DCT4VibraTest(int argc, char *argv[]) +{ + unsigned char ans[200]; + + if (CheckDCT4Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + error=DCT4EnableVibra(&s, true); + Print_Error(error); + + printf("Press any key to continue...\n"); + GetLine(stdin, ans, 99); + + error=DCT4EnableVibra(&s, false); + Print_Error(error); +} + +#ifdef DEBUG +static GSM_Error DCT4_ReplyResetSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + switch (msg.Buffer[3]) { + case 0x05: + printf("Security code set to \"12345\"\n"); + return ERR_NONE; + case 0x06: + printf("Unknown reason. Can't reset your security code\n"); + return ERR_UNKNOWN; + } + return ERR_UNKNOWNRESPONSE; +} + +void DCT4ResetSecurityCode(int argc, char *argv[]) +{ + unsigned int i; + unsigned char ResetCode[30] = {0x00,0x06,0x03,0x04,0x01, + '1','2','3','4','5','6','7','8','9','0', /* Old code */ + 0x00, + '1','2','3','4','5',0x00,0x00,0x00,0x00,0x00, /* New code */ + 0x00}; + + if (CheckDCT4Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + error=GSM_WaitFor (&s, ResetCode, 27, 0x08, 4, ID_User2); + if (error == ERR_UNKNOWN) { + if (answer_yes2("Try brutal force ?")) { + for (i=10000;i<9999999;i++) { + printf("Trying %i\n",i); + memset(ResetCode+6,0,22); + sprintf(ResetCode+5,"%i",i); + sprintf(ResetCode+16,"12345"); + error=GSM_WaitFor (&s, ResetCode, 27, 0x08, 4, ID_User2); + if (error == ERR_NONE) break; + } + } + } else Print_Error(error); +} +#endif + +char SecLength; + +static GSM_Error DCT4_ReplyGetSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + if (msg.Length > 12) { + SecLength = msg.Buffer[13]; + if ((msg.Buffer[17]+18) == msg.Length) { + printf("Security code is %s\n",msg.Buffer+18); +// DumpMessage(stdout, msg.Buffer, msg.Length); + } + } + return ERR_NONE; +} + +void DCT4GetSecurityCode(int argc, char *argv[]) +{ + GSM_Error error; + unsigned char getlen[]={0x00, 0x08, 0x01, 0x0C, + 0x00, 0x23, //ID + 0x00, 0x00, //Index + 0x00, 0x00}; + unsigned char read[]={0x00, 0x08, 0x02, 0x04, + 0x00, 0x23, //ID + 0x00, 0x00, //Index + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00}; //Length + + if (CheckDCT4Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + SecLength = 0; + error=GSM_WaitFor (&s, getlen, sizeof(getlen), 0x23, 1, ID_User1); + Print_Error(error); + if (SecLength != 0) { + read[17] = SecLength; + error=GSM_WaitFor (&s, read, sizeof(read), 0x23, 5, ID_User1); + Print_Error(error); + } +} + +static GSM_Error DCT4_ReplyGetVoiceRecord(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i=18,j; + unsigned char Buffer[100]; + + switch (msg.Buffer[3]) { + case 0x05: + dbgprintf("Part of voice record received\n"); + if (msg.Length == 6) { + dbgprintf("Empty\n"); + return ERR_EMPTY; + } + *s->Phone.Data.VoiceRecord = 0; + while (i<msg.Length) { + s->Phone.Data.PhoneString[(*s->Phone.Data.VoiceRecord)++] = msg.Buffer[i+1]; + s->Phone.Data.PhoneString[(*s->Phone.Data.VoiceRecord)++] = msg.Buffer[i]; + i += 2; + } + return ERR_NONE; + case 0x0D: + dbgprintf("Last part of voice record is %02x %02x\n",msg.Buffer[11],msg.Buffer[12]); + dbgprintf("Token is %02x\n",msg.Buffer[13]); + s->Phone.Data.PhoneString[0] = msg.Buffer[11]; + s->Phone.Data.PhoneString[1] = msg.Buffer[12]; + s->Phone.Data.PhoneString[2] = msg.Buffer[13]; + return ERR_NONE; + break; + case 0x31: + dbgprintf("Names of voice records received\n"); + j = 33; + for (i=0;i<msg.Buffer[9];i++) { + memcpy(Buffer,msg.Buffer+(j+1),msg.Buffer[j]); + Buffer[msg.Buffer[j]] = 0; + Buffer[msg.Buffer[j]+1] = 0; + dbgprintf("%i. \"%s\"\n",i+1,DecodeUnicodeString(Buffer)); + if (i==*s->Phone.Data.VoiceRecord) { + sprintf(s->Phone.Data.PhoneString,"%s.wav",DecodeUnicodeString(Buffer)); + return ERR_NONE; + } + if (i != msg.Buffer[9] - 1) { + j+=msg.Buffer[j] + 1; + if (msg.Buffer[j] == 0x00 && msg.Buffer[j+1]==0x00) j+=2; + j+=23; + } + } + return ERR_EMPTY; + } + return ERR_UNKNOWNRESPONSE; +} + +void DCT4GetVoiceRecord(int argc, char *argv[]) +{ + /* Voice records names */ + unsigned char ReqNames[200] = { + N7110_FRAME_HEADER, + 0x30,0x01,0x55,0x00,0x00,0xFF,0xFF,0x01,0x01,0x55,0x55}; + /* Voice record token */ + unsigned char ReqToken[200] = { + N7110_FRAME_HEADER,0x0C,0x00,0x44,0x00, + 0x00, /* Location: 0, 1, ... */ + 0x55,0x55}; + /* Voice record part */ + unsigned char ReqGet[200] = { + N7110_FRAME_HEADER,0x04,0x00,0x44, + 0x00,0x00, /* Location: 0, 1, ... */ + 0x55,0x55,0x00, + + 0x00,0x00, /* Part Location */ + 0x00,0x00,0x00, + + 0x04, /* ??? */ + + 0x00}; /* Token */ + + /* WAV file headers */ + unsigned char WAV_Header[] = { + 'R','I','F','F', + 0x00,0x00,0x00,0x00, /* Length */ + 'W','A','V','E'}; + unsigned char FMT_Header[] = {'f','m','t',' ', + 0x14,0x00,0x00,0x00,0x31,0x00,0x01,0x00,0x40,0x1f, + 0x00,0x00,0x59,0x06,0x00,0x00,0x41,0x00,0x00,0x00, + 0x02,0x00,0x40,0x01,'f', 'a', 'c', 't', 0x04,0x00, + 0x00,0x00, + 0x00,0x73,0x00,0x00}; /* Seems to be some length */ + unsigned char DATA_Header[] = { + 'd','a','t','a', + 0x00,0x00,0x00,0x00}; /* Length */ + + long wavfilesize=0; + unsigned char FileName[100], Buffer[10000], Token; + unsigned int Location, size=0, CurrentLocation = 0, TokenLocation; + int i; + FILE *WAVFile; + + Location = atoi(argv[2]); + if (Location == 0x00) { + printf("Please numerate locations from 1\n"); + return; + } + Location--; + + GSM_Init(true); + + CheckDCT4(); + + s.User.UserReplyFunctions=UserReplyFunctions4; + + s.Phone.Data.VoiceRecord = &Location; + s.Phone.Data.PhoneString = FileName; + dbgprintf("Getting voice record name\n"); + error=GSM_WaitFor (&s, ReqNames, 14, 0x4A, 4, ID_User4); + Print_Error(error); + + s.Phone.Data.PhoneString = Buffer; + ReqToken[7] = Location; + dbgprintf("Getting voice record token\n"); + error=GSM_WaitFor (&s, ReqToken, 10, 0x23, 4, ID_User4); + Print_Error(error); + TokenLocation = Buffer[0] * 256 + Buffer[1]; + Token = Buffer[2]; + + WAVFile = fopen(FileName, "wb"); + + fwrite(&WAV_Header, 1, sizeof(WAV_Header), WAVFile); + fwrite(&FMT_Header, 1, sizeof(FMT_Header), WAVFile); + fwrite(&DATA_Header, 1, sizeof(DATA_Header), WAVFile); + + s.Phone.Data.VoiceRecord = &size; + s.Phone.Data.PhoneString = Buffer; + ReqGet[7] = Location; + fprintf(stderr,"Getting voice record and saving to \"%s\": ",FileName); + while (1) { + dbgprintf("Getting next part of voice record\n"); + fprintf(stderr,"."); + error=GSM_WaitFor (&s, ReqGet, 18, 0x23, 4, ID_User4); + if (error == ERR_NONE) { + wavfilesize += size; + fwrite(Buffer,1,size,WAVFile); + } + if (error == ERR_EMPTY) break; + Print_Error(error); + CurrentLocation += 4; + ReqGet[11] = CurrentLocation / 256; + ReqGet[12] = CurrentLocation % 256; + if (CurrentLocation+4 > TokenLocation) break; + } + dbgprintf("Getting first part in last sequence of voice record\n"); + for (i=255;i>=0;i--) { + ReqGet[16] = i; + ReqGet[17] = Token; + fprintf(stderr,"."); + error=GSM_WaitFor (&s, ReqGet, 18, 0x23, 4, ID_User4); + if (error == ERR_NONE) { + wavfilesize += size; + fwrite(Buffer,1,size,WAVFile); + break; + } + if (error != ERR_EMPTY) Print_Error(error); + } + while (1) { + dbgprintf("Getting next part of last sequence in voice record\n"); + CurrentLocation += 4; + ReqGet[11] = CurrentLocation / 256; + ReqGet[12] = CurrentLocation % 256; + fprintf(stderr,"."); + error=GSM_WaitFor (&s, ReqGet, 18, 0x23, 4, ID_User4); + if (error == ERR_NONE) { + wavfilesize += size; + fwrite(Buffer,1,size,WAVFile); + } + if (error == ERR_EMPTY) break; + Print_Error(error); + } + fprintf(stderr,"\n"); + + wavfilesize += sizeof(WAV_Header) + sizeof(FMT_Header) + sizeof(DATA_Header); + WAV_Header[4] = (unsigned char)(wavfilesize % 256); + WAV_Header[5] = (unsigned char)(wavfilesize / 256); + WAV_Header[6] = (unsigned char)(wavfilesize / (256*256)); + WAV_Header[7] = (unsigned char)(wavfilesize / (256*256*256)); + + /* FIXME */ + FMT_Header[36] = (unsigned char)(((wavfilesize - 238) * 5 ) % 256); + FMT_Header[37] = (unsigned char)(((wavfilesize - 238) * 5 ) / 256); + FMT_Header[38] = (unsigned char)(((wavfilesize - 238) * 5 ) / (256*256)); + FMT_Header[39] = (unsigned char)(((wavfilesize - 238) * 5 ) / (256*256*256)); + + wavfilesize = wavfilesize - 54 - 6; + DATA_Header[4] = (unsigned char)(wavfilesize % 256); + DATA_Header[5] = (unsigned char)(wavfilesize / 256); + DATA_Header[6] = (unsigned char)(wavfilesize / (256*256)); + DATA_Header[7] = (unsigned char)(wavfilesize / (256*256*256)); + + fseek( WAVFile, 0, SEEK_SET); + fwrite(&WAV_Header, 1, sizeof(WAV_Header), WAVFile); + fwrite(&FMT_Header, 1, sizeof(FMT_Header), WAVFile); + fwrite(&DATA_Header, 1, sizeof(DATA_Header), WAVFile); + + fclose(WAVFile); + + GSM_Terminate(); +} + +static GSM_Error DCT4_ReplyGetBTInfo(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + printf("device address %02x%02x%02x%02x%02x%02x\n", + msg.Buffer[9],msg.Buffer[10],msg.Buffer[11], + msg.Buffer[12],msg.Buffer[13],msg.Buffer[14]); + return ERR_NONE; +} + +static GSM_Error DCT4_ReplyGetSimlock(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int i; + + switch (msg.Buffer[3]) { + case 0x0D: + dbgprintf("Simlock info received\n"); + dbgprintf("Config_Data: "); + for (i=14;i<22;i++) { + dbgprintf("%02x",msg.Buffer[i]); + } + dbgprintf("\n"); + dbgprintf("Profile_Bits: "); + for (i=22;i<30;i++) { + dbgprintf("%02x",msg.Buffer[i]); + } + dbgprintf("\n"); + return ERR_NONE; + case 0x13: + dbgprintf("Simlock info received\n"); + if (msg.Buffer[58] == 0x05 && msg.Buffer[59] == 0x02) { + dbgprintf("SIM_PATH: "); + for (i=44;i<52;i++) { + dbgprintf("%02x",msg.Buffer[i]); + } + dbgprintf("\n"); + printf("Simlock data : "); + for (i=60;i<63;i++) { + printf("%02x",msg.Buffer[i]); + } + printf("\n"); + } + return ERR_NONE; + } + return ERR_UNKNOWNRESPONSE; +} + +void DCT4Info(int argc, char *argv[]) +{ + unsigned char GetBTAddress[8] = {N6110_FRAME_HEADER, 0x09, 0x19, 0x01, 0x03, 0x06}; + unsigned char GetSimlock[5] = {N6110_FRAME_HEADER, 0x12, 0x0D}; + unsigned char value[10]; + + if (CheckDCT4Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + if (IsPhoneFeatureAvailable(s.Phone.Data.ModelInfo, F_BLUETOOTH)) { + printf("Bluetooth : "); + + error=GSM_WaitFor (&s, GetBTAddress, 8, 0xD7, 4, ID_User6); + Print_Error(error); + } + + error=GSM_WaitFor (&s, GetSimlock, 5, 0x53, 4, ID_User6); + Print_Error(error); + GetSimlock[4] = 0x0E; + error=GSM_WaitFor (&s, GetSimlock, 5, 0x53, 4, ID_User6); + Print_Error(error); + GetSimlock[3] = 0x0C; + error=GSM_WaitFor (&s, GetSimlock, 4, 0x53, 4, ID_User6); + Print_Error(error); + error=NOKIA_GetPhoneString(&s,"\x00\x03\x02\x07\x00\x08",6,0x1b,value,ID_User6,10); + Print_Error(error); + printf("UEM : %s\n",value); +} + +static FILE *T9File; +int T9Size; +int T9FullSize; + +static GSM_Error DCT4_ReplyGetT9(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + T9FullSize = msg.Buffer[18] * 256 + msg.Buffer[19]; + T9Size = msg.Length - 18; + fwrite(msg.Buffer+18,1,T9Size,T9File); + return ERR_NONE; +} + +void DCT4GetT9(int argc, char *argv[]) +{ + int i,T9Dictionary=0; + unsigned char req[] = {N7110_FRAME_HEADER, 0x04, 0x00, 0x5B, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, /* Start position */ + 0x00, 0x00, + 0x02, 0xBC}; /* How many bytes to read */ + + if (CheckDCT4Only()!=ERR_NONE) return; + + T9File = fopen("T9", "w"); + if (T9File == NULL) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + i = 0; + while (1) { + req[12] = i / 256; + req[13] = i % 256; + if (i != 0) { + if (T9Dictionary - i < req[16]*256+req[17]) { + req[16] = (T9Dictionary - i) / 256; + req[17] = (T9Dictionary - i) % 256; + } + if (T9Dictionary - i == 0) break; + } + error=GSM_WaitFor (&s, req, 18, 0x23, 4, ID_User3); + Print_Error(error); + if (i==0) { + T9Dictionary = T9FullSize; + dbgprintf("T9 dictionary size is %i\n",T9Dictionary); + } + i+=T9Size; + } + + fclose(T9File); +} + +extern GSM_Error N6510_SetLight(GSM_StateMachine *s, N6510_PHONE_LIGHTS light, bool enable); + +void DCT4SetLight(int argc, char *argv[]) +{ + int i; + N6510_PHONE_LIGHTS type; + bool enable; + + if (mystrncasecmp(argv[2],"display",0)) { type = N6510_LIGHT_DISPLAY; + } else if (mystrncasecmp(argv[2],"keypad",0)) { type = N6510_LIGHT_KEYPAD; + } else if (mystrncasecmp(argv[2],"torch",0)) { type = N6510_LIGHT_TORCH; + } else { + printf("What lights should I enable (\"%s\") ?\n",argv[2]); + exit(-1); + } + + if (mystrncasecmp(argv[3],"on",0)) { enable = true; + } else if (mystrncasecmp(argv[3],"off",0)) { enable = false; + } else { + printf("What should I do (\"%s\") ?\n",argv[3]); + exit(-1); + } + + for (i=0;i<s.ConfigNum;i++) { + s.Config[i].StartInfo = "false"; + } + + GSM_Init(true); + + CheckDCT4(); + + error=N6510_SetLight(&s, type, enable); + Print_Error(error); + + GSM_Terminate(); +} + +void DCT4DisplayTest(int argc, char *argv[]) +{ + unsigned char ans[200]; + unsigned char req0[] = {0x00, 0x08, 0x0D, 0x00, 0x0F, 0x00}; + unsigned char req[] = {0x00, 0x08, 0x0E, 0x00, 0x12, 0x01, 0x00, 0x04, + 0x09, /* test number */ + 0x00}; + + if (CheckDCT4Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + DCT4_SetPhoneMode(&s, DCT4_MODE_TEST); + + s.Protocol.Functions->WriteMessage(&s, req0, 6, 0x40); + + req[8] = atoi(argv[2]); + s.Protocol.Functions->WriteMessage(&s, req, 10, 0x40); + + printf("Press any key to continue...\n"); + GetLine(stdin, ans, 99); + + DCT4_SetPhoneMode(&s, DCT4_MODE_NORMAL); +} + +int ADC; + +static GSM_Error DCT4_ReplyGetADC(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + if (msg.Buffer[6] == 0xff && msg.Buffer[7] == 0xff) return ERR_NONE; + switch (msg.Buffer[3]) { + case 0x10: + printf("raw "); + printf("%10i ",msg.Buffer[8]*256+msg.Buffer[9]); + break; + case 0x12: + printf("unit result "); + printf("%10i ",(msg.Buffer[8]*256+msg.Buffer[9])*ADC); + break; + } + return ERR_NONE; +} + +struct DCT4ADCInfo { + char *name; + char *unit; + int x; +}; + +static struct DCT4ADCInfo DCT4ADC[] = { + {"Battery voltage, divided:", "mV", 1}, + {"Battery voltage, scaled:", "mV", 1}, + {"Charger voltage:", "mV", 1}, + {"Charger current:", "mA", 1}, + {"Battery size indicator:", "Ohms",100}, + {"Battery temperature:", "K", 1}, + {"Headset interconnection:", "mV", 1}, + {"Hook interconnection:", "mV", 1}, + {"Light sensor:", "mV", 1}, + {"Power amplifier temperature:", "K", 1}, + {"VCXO temperature:", "K", 1}, + {"Resistive keyboard 1/headint2:", "mV", 1}, + {"Resistive keyboard 1/auxdet:", "mV", 1}, + {"Initial battery voltage:", "mV", 1}, + {"Battery Current:", "mA", 1}, + {"Battery Current Fast:", "mA", 1}, + + {"", "", 1} +}; + +void DCT4GetADC(int argc, char *argv[]) +{ + int i = 0; + unsigned char GetRaw[] = {N6110_FRAME_HEADER, 0x0F, + 0x00, /* Test number */ + 0x01}; + unsigned char GetUnit[] = {N6110_FRAME_HEADER, 0x11, + 0x00, /* Test number */ + 0x01}; + + if (CheckDCT4Only()!=ERR_NONE) return; + + s.User.UserReplyFunctions=UserReplyFunctions4; + + while (1) { + printf(" %30s ",DCT4ADC[i].name); + GetRaw[4] = i; + error=GSM_WaitFor (&s, GetRaw, 6, 0x17, 4, ID_User3); + Print_Error(error); + GetUnit[4] = i; + ADC = DCT4ADC[i].x; + error=GSM_WaitFor (&s, GetUnit, 6, 0x17, 4, ID_User3); + Print_Error(error); + printf("%s\n",DCT4ADC[i].unit); + i++; + if (DCT4ADC[i].name[0] == 0x00) break; + } +} + +static double RadioFreq; +static unsigned char RadioName[100]; + +static GSM_Error DCT4_ReplyTuneRadio(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + int length; + unsigned char name[100]; + + switch (msg.Buffer[3]) { + case 0x09: + N6510_DecodeFMFrequency(&RadioFreq, msg.Buffer+16); + + length = msg.Buffer[8]; + memcpy(name,msg.Buffer+18,length*2); + name[length*2] = 0x00; + name[length*2+1] = 0x00; + CopyUnicodeString(RadioName,name); + smprintf(s,"Station name: \"%s\"\n",DecodeUnicodeString(RadioName)); + return ERR_NONE; + case 0x15: + case 0x16: + smprintf(s,"Response for enabling radio/headset status received\n"); + if (msg.Buffer[5] == 0) { + smprintf(s,"Connected\n"); + return ERR_NONE; + } + smprintf(s,"Probably not connected\n"); + return ERR_PERMISSION; + } + return ERR_UNKNOWNRESPONSE; +} + +void DCT4TuneRadio(int argc, char *argv[]) +{ + double Freq, diff; + GSM_FMStation FMStation[50],FMStat; + int i, j, num; + bool found; + + unsigned char Enable[] = {N6110_FRAME_HEADER, 0x00, 0x00, 0x00}; + unsigned char Disable[] = {N6110_FRAME_HEADER, 0x01, 0x0E, 0x00}; +// unsigned char SetVolume[] = {N6110_FRAME_HEADER, 0x14, +// 0x00, /* Volume level */ +// 0x00}; +// unsigned char MuteUnMute[] = {N6110_FRAME_HEADER, 0x0F, +// 0x0C, /* 0x0B = mute, 0x0C = unmute */ +// 0x00}; + unsigned char SetFreq[] = {N6110_FRAME_HEADER, 0x08, + 0x08, 0x14, 0x00, 0x01, + 0x9A, 0x28}; /* Frequency */ +// unsigned char Find1[] = {N6110_FRAME_HEADER, 0x08, +// 0x04, 0x14, 0x00, 0x00, 0x00, 0x00}; + unsigned char Find2[] = {N6110_FRAME_HEADER, 0x08, + 0x05, 0x14, 0x00, 0x00, 0x00, 0x00}; +// unsigned char SetStereo[] = {N6110_FRAME_HEADER, 0x19, +// 0x0A, 0x00, 0x15}; +// unsigned char SetMono[] = {N6110_FRAME_HEADER, 0x19, +// 0x09, 0x00, 0x96}; + + GSM_Init(true); + + CheckDCT4(); + + s.User.UserReplyFunctions=UserReplyFunctions4; + + FMStat.Location = 1; + error = Phone->GetFMStation(&s,&FMStat); + if (error != ERR_NONE && error != ERR_EMPTY) { + printf("Phone seems not to support radio\n"); + GSM_Terminate(); + exit(-1); + } + + error=GSM_WaitFor (&s, Enable, 6, 0x3E, 4, ID_User3); + if (error == ERR_PERMISSION) { + printf("Please connect headset. Required as antenna\n"); + GSM_Terminate(); + exit(-1); + } + Print_Error(error); + + num=0; + for (i=88;i<108;i++) { + fprintf(stderr,"%cSearching: %i percent",13,(i-88)*100/(108-88)); + Freq = i; + N6510_EncodeFMFrequency(Freq, SetFreq+8); + error=GSM_WaitFor (&s, SetFreq, 10, 0x3E, 4, ID_User3); + Print_Error(error); + + error=GSM_WaitFor (&s, Find2, 10, 0x3E, 4, ID_User3); + Print_Error(error); + found = false; + for (j=0;j<num;j++) { + if (FMStation[j].Frequency > RadioFreq) { + diff = FMStation[j].Frequency - RadioFreq; + } else { + diff = RadioFreq - FMStation[j].Frequency; + } + if (diff <= 0.2) { + dbgprintf("diff is %f\n",diff); + found = true; + break; + } + } + if (!found) { + dbgprintf("Adding %f, num %i\n",RadioFreq,num); + FMStation[num].Frequency = RadioFreq; + CopyUnicodeString(FMStation[num].StationName,RadioName); + num++; + } + } + fprintf(stderr,"%cSearching: %i percent",13,100); + fprintf(stderr,"\n\n"); + + i=0; + while(1) { + if (i==num || i==num-1) break; + if (FMStation[i].Frequency > FMStation[i+1].Frequency) { + memcpy(&FMStat,&FMStation[i],sizeof(GSM_FMStation)); + memcpy(&FMStation[i],&FMStation[i+1],sizeof(GSM_FMStation)); + memcpy(&FMStation[i+1],&FMStat,sizeof(GSM_FMStation)); + i = 0; + continue; + } + i++; + } + for (i=0;i<num;i++) { + fprintf(stderr,"%02i.",i+1); + if (FMStation[i].Frequency < 100) fprintf(stderr," "); + fprintf(stderr,"%.1f MHz - \"%s\" \n", + FMStation[i].Frequency, + DecodeUnicodeString(FMStation[i].StationName)); + } + + if (answer_yes2("Do you want to save found stations")) { + fprintf(stderr,"Deleting old FM stations: "); + error=Phone->ClearFMStations(&s); + Print_Error(error); + fprintf(stderr,"Done\n"); + for (i=0;i<num;i++) { + FMStation[i].Location = i+1; + error=Phone->SetFMStation(&s,&FMStation[i]); + Print_Error(error); + fprintf(stderr,"%cWriting: %i percent",13,(i+1)*100/num); + } + fprintf(stderr,"\n"); + } + + error=GSM_WaitFor (&s, Disable, 6, 0x3E, 4, ID_User3); + Print_Error(error); + + GSM_Terminate(); +} + +void DCT4PlaySavedRingtone(int argc, char *argv[]) +{ + unsigned char req[] = {N6110_FRAME_HEADER, + 0x01, + 0x00,0x64, //id + 0x01, //group + 0x01,0x00,0x00, + 0x0A, //volume + 0x00,0x00,0x00,0x00,0x00,0x00,0x00}; + GSM_AllRingtonesInfo Info; + + GSM_Init(true); + + CheckDCT4(); + + s.User.UserReplyFunctions=UserReplyFunctions4; + + error=Phone->GetRingtonesInfo(&s,&Info); + Print_Error(error); + + if (atoi(argv[2]) > Info.Number-1) { + GSM_Terminate(); + return; + } + req[4] = Info.Ringtone[atoi(argv[2])].ID / 256; + req[5] = Info.Ringtone[atoi(argv[2])].ID % 256; + req[6] = Info.Ringtone[atoi(argv[2])].Group; + + error=GSM_WaitFor (&s, req, 18, 0x1F, 4, ID_User3); + Print_Error(error); + +// for (i=0;i<Info.Number;i++) printmsg("%i. \"%s\"\n",i,DecodeUnicodeConsole(Info.Ringtone[i].Name)); + + GSM_Terminate(); +} + +static GSM_Error DCT4_ReplyMakeCameraShoot(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + return ERR_NONE; +} + +void DCT4MakeCameraShoot(int argc, char *argv[]) +{ + unsigned char SetCamera[] = {N6110_FRAME_HEADER, 0x09, 0x01, 0x02}; + unsigned char CameraON[] = {N6110_FRAME_HEADER, 0x02, 0x01, 0x00, 0x00, 0x00 , 0x00, 0x00}; + unsigned char CameraON2[] = {N6110_FRAME_HEADER, 0xF0, 0x02, 0x00}; + unsigned char MakeShot[200] = {N6110_FRAME_HEADER, 0x06, 0x01, 0x06, + 0x01, 0x00, 0x00, 0x02, 0x00, 0x04, 0x32, 0x00, 0x01, + 0x1D, //length of rest + 0x00, 0x00, 0x00, 0x01, + 0x00, 0x02, //master folder id + 0x00, 0x14}; //length + unsigned char CameraOFF[] = {N6110_FRAME_HEADER, 0x04, 0x01, 0x00}; + + GSM_Init(true); + + CheckDCT4(); + + s.User.UserReplyFunctions=UserReplyFunctions4; + + error=GSM_WaitFor (&s, SetCamera, 6, 0x61, 4, ID_User3); + Print_Error(error); + error=GSM_WaitFor (&s, CameraON, 10, 0x61, 4, ID_User3); + Print_Error(error); + error=GSM_WaitFor (&s, CameraON2, 6, 0x61, 4, ID_User3); + Print_Error(error); + EncodeUnicode(MakeShot+24,"GammuShot",9); + MakeShot[15] = 9+9*2; + MakeShot[23] = 9*2; + error=GSM_WaitFor (&s, MakeShot, 24+MakeShot[23], 0x61, 4, ID_User3); + Print_Error(error); + error=GSM_WaitFor (&s, SetCamera, 6, 0x61, 4, ID_User3); + Print_Error(error); + error=GSM_WaitFor (&s, CameraOFF, 6, 0x61, 4, ID_User3); + Print_Error(error); + + GSM_Terminate(); +} + +int len; + +static GSM_Error DCT4_ReplyGetScreenDump(GSM_Protocol_Message msg, GSM_StateMachine *s) +{ + if (msg.Buffer[7] == 0x0C) len = 1; + return ERR_NONE; +} + +void DCT4GetScreenDump(int argc, char *argv[]) +{ + unsigned char req[] = {N6110_FRAME_HEADER, 0x07, 0x01, 0x00}; + //n6110_frameheader 06//screen info + + GSM_Init(true); + + CheckDCT4(); + + s.User.UserReplyFunctions=UserReplyFunctions4; + + error=GSM_WaitFor (&s, req, 6, 0x0E, 4, ID_User3); + Print_Error(error); + len = 2000; + while (len >= 200) GSM_ReadDevice(&s,true); + + GSM_Terminate(); +} + +static GSM_Reply_Function UserReplyFunctions4[] = { + +#ifdef DEBUG + {DCT4_ReplyResetSecurityCode, "\x08",0x03,0x05,ID_User2 }, + {DCT4_ReplyResetSecurityCode, "\x08",0x03,0x06,ID_User2 }, +#endif + + {DCT4_ReplyGetScreenDump, "\x0E",0x00,0x00,ID_User3 }, + {DCT4_ReplyGetScreenDump, "\x0E",0x00,0x00,ID_IncomingFrame}, + + {DCT4_ReplyGetADC, "\x17",0x03,0x10,ID_User3 }, + {DCT4_ReplyGetADC, "\x17",0x03,0x12,ID_User3 }, + + {DCT4_ReplySetPPS, "\x1b",0x03,0x05,ID_User1 }, + {NOKIA_ReplyGetPhoneString, "\x1B",0x03,0x08,ID_User6 }, + + {DCT4_ReplyVibra, "\x1C",0x03,0x0D,ID_User3 }, + {DCT4_ReplyVibra, "\x1C",0x03,0x0F,ID_User3 }, + + {NoneReply, "\x1F",0x03,0x02,ID_User3 }, + + {DCT4_ReplyGetSecurityCode, "\x23",0x03,0x05,ID_User1 }, + {DCT4_ReplyGetT9, "\x23",0x03,0x05,ID_User3 }, + {DCT4_ReplyGetVoiceRecord, "\x23",0x03,0x05,ID_User4 }, + {DCT4_ReplyGetVoiceRecord, "\x23",0x03,0x0D,ID_User4 }, + {DCT4_ReplyGetSecurityCode, "\x23",0x03,0x0D,ID_User1 }, + + {DCT4_ReplyTestsStartup, "\x35",0x02,0x01,ID_User3 }, + {DCT4_ReplyTestsStartup, "\x35",0x02,0x02,ID_User3 }, + {DCT4_ReplyTestsNames, "\x35",0x02,0x03,ID_User1 }, + {DCT4_ReplyTestsStatus, "\x35",0x02,0x04,ID_User2 }, + + {DCT4_ReplyTuneRadio, "\x3E",0x03,0x09,ID_User3 }, + {DCT4_ReplyTuneRadio, "\x3E",0x03,0x15,ID_User3 }, + {DCT4_ReplyTuneRadio, "\x3E",0x03,0x15,ID_SetFMStation}, + {DCT4_ReplyTuneRadio, "\x3E",0x03,0x16,ID_User3 }, + + {DCT4_ReplyGetVoiceRecord, "\x4A",0x03,0x31,ID_User4 }, + + {DCT4_ReplyGetSimlock, "\x53",0x03,0x0D,ID_User6 }, + {DCT4_ReplyGetSimlock, "\x53",0x03,0x13,ID_User6 }, + + {DCT4_ReplyMakeCameraShoot, "\x61",0x03,0x03,ID_User3 }, + {DCT4_ReplyMakeCameraShoot, "\x61",0x03,0x07,ID_User3 }, + {DCT4_ReplyMakeCameraShoot, "\x61",0x03,0x08,ID_User3 }, + {DCT4_ReplyMakeCameraShoot, "\x61",0x03,0x0A,ID_User3 }, + {DCT4_ReplyMakeCameraShoot, "\x61",0x03,0xF0,ID_User3 }, + + {DCT4_ReplyGetBTInfo, "\xD7",0x03,0x0A,ID_User6 }, + + {NULL, "\x00",0x00,0x00,ID_None } +}; + +#endif + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ diff --git a/gammu/emb/gammu/depend/nokia/dct4.h b/gammu/emb/gammu/depend/nokia/dct4.h new file mode 100644 index 0000000..fde5b08 --- a/dev/null +++ b/gammu/emb/gammu/depend/nokia/dct4.h @@ -0,0 +1,95 @@ +/* (c) 2002-2004 by Marcin Wiacek */ + +#include "../../../common/gsmstate.h" + +void DCT4SetPhoneMenus (int argc, char *argv[]); +void DCT4SelfTests (int argc, char *argv[]); +void DCT4SetVibraLevel (int argc, char *argv[]); +void DCT4GetSecurityCode (int argc, char *argv[]); +#ifdef DEBUG +void DCT4ResetSecurityCode (int argc, char *argv[]); +#endif +void DCT4GetVoiceRecord (int argc, char *argv[]); +void DCT4Info (int argc, char *argv[]); +void DCT4GetT9 (int argc, char *argv[]); +void DCT4SetLight (int argc, char *argv[]); +void DCT4DisplayTest (int argc, char *argv[]); +void DCT4GetADC (int argc, char *argv[]); +void DCT4VibraTest (int argc, char *argv[]); +void DCT4TuneRadio (int argc, char *argv[]); +void DCT4PlaySavedRingtone (int argc, char *argv[]); +void DCT4MakeCameraShoot (int argc, char *argv[]); +void DCT4GetScreenDump (int argc, char *argv[]); + +/* ------------------- features matrix ------------------------------------- */ + +typedef enum { + DCT4_ALWAYS_ONLINE = 1, + DCT4_GPRS_PCCH, + DCT4_GEA1, + DCT4_EOTD, + DCT4_WAP_PUSH, + DCT4_USE_PREF_SIM_NET, + DCT4_JAVA_TCK, + + DCT4_ALS, + DCT4_A52, + DCT4_CSP, + DCT4_EONS, + DCT4_3GINDICATOR, + DCT4_DISPLAY_PHONE_NAME, + DCT4_DISPLAY_WAP_PROFILE, + + DCT4_GAMES_WAP_DOWNLOAD, + DCT4_GAMES_SCORE_SEND, + DCT4_GAMES_URL_CHECK, + + DCT4_BLUETOOTH_MENU, + DCT4_WAP_BOOKMARKS_MENU, + DCT4_WAP_BOOKMARKS_MENU2, + DCT4_WAP_GOTO_MENU, + DCT4_WAP_SETTINGS_MENU, + DCT4_SERVICES_GAMES_APP_GALLERY, + DCT4_JAVA_GAMES_MENU, + DCT4_SAT_CONFIRM_MENU, + DCT4_INSTANT_MESS_MENU, + DCT4_CONFIRM_ALS, + DCT4_BOOKMARK_GOTO_MENU, + + DCT4_5100_IDENTIFY, + + DCT4_TEST +} DCT4_Feature_Name; + +typedef struct { + DCT4_Feature_Name Name; + unsigned char *Text; + struct { + unsigned char Value; + unsigned char *Text; + } Values[10]; +} DCT4_Feature; + +typedef struct { + char *Model; + struct { + DCT4_Feature_Name Name; + int Number; + } Features[25]; +} DCT4_Phone_Features; + +typedef struct { + struct { + char Name[100]; + unsigned char ID; + unsigned char Value; + bool Startup; + } Tests[50]; + int Num; +} DCT4_Phone_Tests; + +/* ------------------------------------------------------------------------- */ + +/* How should editor hadle tabs in this file? Add editor commands here. + * vim: noexpandtab sw=8 ts=8 sts=8: + */ |