summaryrefslogtreecommitdiffabout
path: root/gammu/emb/common/phone/at/atgen.c
Side-by-side diff
Diffstat (limited to 'gammu/emb/common/phone/at/atgen.c') (more/less context) (show whitespace changes)
-rw-r--r--gammu/emb/common/phone/at/atgen.c295
1 files changed, 244 insertions, 51 deletions
diff --git a/gammu/emb/common/phone/at/atgen.c b/gammu/emb/common/phone/at/atgen.c
index 1834f15..ba23eb2 100644
--- a/gammu/emb/common/phone/at/atgen.c
+++ b/gammu/emb/common/phone/at/atgen.c
@@ -1,69 +1,49 @@
/* (c) 2002-2004 by Marcin Wiacek and Michal Cihar */
#include "../../gsmstate.h"
#ifdef GSM_ENABLE_ATGEN
#include <string.h>
#include <time.h>
#include <ctype.h>
#include "../../gsmcomon.h"
#include "../../misc/coding/coding.h"
#include "../../service/sms/gsmsms.h"
#include "../pfunc.h"
+
#include "atgen.h"
+#include "samsung.h"
+#include "siemens.h"
+#include "sonyeric.h"
+
#ifdef GSM_ENABLE_ALCATEL
-extern GSM_Error ALCATEL_ProtocolVersionReply (GSM_Protocol_Message msg, GSM_StateMachine *s);
+GSM_Error ALCATEL_ProtocolVersionReply (GSM_Protocol_Message, GSM_StateMachine *);
#endif
-extern GSM_Error ATGEN_CMS35ReplyGetBitmap (GSM_Protocol_Message msg, GSM_StateMachine *s);
-extern GSM_Error ATGEN_CMS35ReplySetBitmap (GSM_Protocol_Message msg, GSM_StateMachine *s);
-extern GSM_Error ATGEN_CMS35ReplyGetRingtone (GSM_Protocol_Message msg, GSM_StateMachine *s);
-extern GSM_Error ATGEN_CMS35ReplySetRingtone (GSM_Protocol_Message msg, GSM_StateMachine *s);
-extern GSM_Error ATGEN_CMS35ReplyGetNextCal (GSM_Protocol_Message msg, GSM_StateMachine *s);
-extern GSM_Error ATGEN_CMS35ReplySetCalendar (GSM_Protocol_Message msg, GSM_StateMachine *s);
-extern GSM_Error ATGEN_CMS35ReplyDeleteCalendar (GSM_Protocol_Message msg, GSM_StateMachine *s);
-extern GSM_Error ATGEN_SL45ReplyGetMemory (GSM_Protocol_Message msg, GSM_StateMachine *s);
-
-extern GSM_Error ATGEN_GetRingtone (GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone);
-extern GSM_Error ATGEN_SetRingtone (GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength);
-extern GSM_Error ATGEN_GetBitmap (GSM_StateMachine *s, GSM_Bitmap *Bitmap);
-extern GSM_Error ATGEN_SetBitmap (GSM_StateMachine *s, GSM_Bitmap *Bitmap);
-extern GSM_Error SIEMENS_GetNextCalendar (GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start);
-extern GSM_Error SIEMENS_AddCalendarNote (GSM_StateMachine *s, GSM_CalendarEntry *Note);
-extern GSM_Error SIEMENS_DelCalendarNote (GSM_StateMachine *s, GSM_CalendarEntry *Note);
-
-extern GSM_Error SONYERIC_GetNextCalendar (GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start);
-extern GSM_Error SONYERIC_GetNextToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool start);
-extern GSM_Error SONYERIC_GetToDoStatus (GSM_StateMachine *s, GSM_ToDoStatus *status);
-extern GSM_Error SONYERIC_AddCalendarNote (GSM_StateMachine *s, GSM_CalendarEntry *Note);
-extern GSM_Error SONYERIC_AddToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo);
-extern GSM_Error SONYERIC_DeleteAllToDo (GSM_StateMachine *s);
-extern GSM_Error SONYERIC_DelCalendarNote (GSM_StateMachine *s, GSM_CalendarEntry *Note);
-extern GSM_Error SONYERIC_GetCalendarStatus (GSM_StateMachine *s, GSM_CalendarStatus *Status);
typedef struct {
int Number;
char Text[60];
} ATErrorCode;
static ATErrorCode CMSErrorCodes[] = {
/*
* Error codes not specified here were either undefined or reserved in my
* copy of specifications, if you have newer one, please fill in the gaps.
*/
/* 0...127 from GSM 04.11 Annex E-2 */
{1, "Unassigned (unallocated) number"},
{8, "Operator determined barring"},
{10, "Call barred"},
{21, "Short message transfer rejected"},
{27, "Destination out of service"},
{28, "Unidentified subscriber"},
{29, "Facility rejected"},
{30, "Unknown subscriber"},
{38, "Network out of order"},
{41, "Temporary failure"},
{42, "Congestion"},
{47, "Resources unavailable, unspecified"},
@@ -154,48 +134,50 @@ static ATErrorCode CMEErrorCodes[] = {
{23, "memory failure"},
{24, "text string too long"},
{25, "invalid characters in text string"},
{26, "dial string too long"},
{27, "invalid characters in dial string"},
{30, "no network service"},
{31, "network timeout"},
{100, "unknown"},
};
GSM_Error ATGEN_HandleCMEError(GSM_StateMachine *s)
{
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
if (Priv->ErrorCode == 0) {
smprintf(s, "CME Error occured, but it's type not detected\n");
} else if (Priv->ErrorText == NULL) {
smprintf(s, "CME Error %i, no description available\n", Priv->ErrorCode);
} else {
smprintf(s, "CME Error %i: \"%s\"\n", Priv->ErrorCode, Priv->ErrorText);
}
/* For error codes descriptions see table a bit above */
switch (Priv->ErrorCode) {
+ case -1:
+ return ERR_EMPTY;
case 3:
return ERR_PERMISSION;
case 4:
return ERR_NOTSUPPORTED;
case 5:
case 11:
case 12:
case 16:
case 17:
case 18:
return ERR_SECURITYERROR;
case 20:
return ERR_FULL;
case 21:
return ERR_INVALIDLOCATION;
case 22:
return ERR_EMPTY;
case 23:
return ERR_MEMORY;
case 24:
case 25:
case 26:
case 27:
return ERR_INVALIDDATA;
@@ -235,50 +217,58 @@ GSM_Error ATGEN_HandleCMSError(GSM_StateMachine *s)
return ERR_UNKNOWN;
}
}
/* FIXME: Function doesn't respect quoting of parameters and thus +FOO:
* "ab","cd,ef" will consider as three arguments: "ab" >> "cd >> ef"
*/
int ATGEN_ExtractOneParameter(unsigned char *input, unsigned char *output)
{
int position=0;
while (*input!=',' && *input!=0x0d && *input!=0x00) {
*output=*input;
input ++;
output ++;
position++;
}
*output=0;
position++;
return position;
}
void ATGEN_DecodeDateTime(GSM_DateTime *dt, unsigned char *input)
{
- dt->Year=2000+(*input-'0')*10; input++;
+ /* Samsung phones report year as %d instead of %02d */
+ if (input[2] == '/') {
+ dt->Year=(*input-'0')*10;
+ input++;
+ } else {
+ dt->Year=0;
+ }
+
dt->Year=dt->Year+(*input-'0'); input++;
+ dt->Year+=2000;
input++;
dt->Month=(*input-'0')*10; input++;
dt->Month=dt->Month+(*input-'0'); input++;
input++;
dt->Day=(*input-'0')*10; input++;
dt->Day=dt->Day+(*input-'0'); input++;
input++;
dt->Hour=(*input-'0')*10; input++;
dt->Hour=dt->Hour+(*input-'0'); input++;
input++;
dt->Minute=(*input-'0')*10; input++;
dt->Minute=dt->Minute+(*input-'0');input++;
input++;
dt->Second=(*input-'0')*10; input++;
dt->Second=dt->Second+(*input-'0');input++;
if (input!=NULL) {
input++;
dt->Timezone=(*input-'0')*10; input++;
@@ -301,124 +291,174 @@ GSM_Error ATGEN_DispatchMessage(GSM_StateMachine *s)
/* Find number of lines */
while (Priv->Lines.numbers[i*2+1] != 0) {
/* FIXME: handle special chars correctly */
smprintf(s, "%i \"%s\"\n",i+1,GetLineString(msg->Buffer,Priv->Lines,i+1));
i++;
}
Priv->ReplyState = AT_Reply_Unknown;
Priv->ErrorText = NULL;
Priv->ErrorCode = 0;
line = GetLineString(msg->Buffer,Priv->Lines,i);
if (!strcmp(line,"OK")) Priv->ReplyState = AT_Reply_OK;
if (!strcmp(line,"> ")) Priv->ReplyState = AT_Reply_SMSEdit;
if (!strcmp(line,"CONNECT")) Priv->ReplyState = AT_Reply_Connect;
if (!strcmp(line,"ERROR" )) Priv->ReplyState = AT_Reply_Error;
if (!strncmp(line,"+CME ERROR:",11)) {
Priv->ReplyState = AT_Reply_CMEError;
ErrorCodes = CMEErrorCodes;
}
if (!strncmp(line,"+CMS ERROR:",11)) {
Priv->ReplyState = AT_Reply_CMSError;
ErrorCodes = CMSErrorCodes;
}
+
+ /* FIXME: Samsung phones can answer +CME ERROR:-1 meaning empty location */
+ if (Priv->ReplyState == AT_Reply_CMEError && Priv->Manufacturer == AT_Samsung) {
+ err = line + 11;
+ Priv->ErrorCode = atoi(err);
+
+ if (Priv->ErrorCode == -1) {
+ Priv->ErrorText = "[Samsung] Empty location";
+ return GSM_DispatchMessage(s);
+ }
+ }
+
if (Priv->ReplyState == AT_Reply_CMEError || Priv->ReplyState == AT_Reply_CMSError) {
j = 0;
/* One char behind +CM[SE] ERROR */
err = line + 12;
while (err[j] && !isalnum(err[j])) j++;
if (isdigit(err[j])) {
Priv->ErrorCode = atoi(&(err[j]));
k = 0;
while (ErrorCodes[k].Number != -1) {
if (ErrorCodes[k].Number == Priv->ErrorCode) {
Priv->ErrorText = (char *)&(ErrorCodes[k].Text);
break;
}
k++;
}
} else if (isalpha(err[j])) {
k = 0;
while (ErrorCodes[k].Number != -1) {
if (!strncmp(err + j, ErrorCodes[k].Text, strlen(ErrorCodes[k].Text))) {
Priv->ErrorCode = ErrorCodes[k].Number;
Priv->ErrorText = (char *)&(ErrorCodes[k].Text);
break;
}
k++;
}
}
}
return GSM_DispatchMessage(s);
}
GSM_Error ATGEN_GenericReply(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
case AT_Reply_OK:
case AT_Reply_Connect:
return ERR_NONE;
case AT_Reply_Error:
return ERR_UNKNOWN;
case AT_Reply_CMSError:
return ATGEN_HandleCMSError(s);
case AT_Reply_CMEError:
return ATGEN_HandleCMEError(s);
default:
break;
}
return ERR_UNKNOWNRESPONSE;
}
+GSM_Error ATGEN_ReplyGetUSSD(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ unsigned char buffer[2000],buffer2[4000];
+ int i = 10;
+
+ /* Ugly hack */
+ while (msg.Buffer[i]!=13) i++;
+ i = i - 6;
+ memcpy(buffer,msg.Buffer+10,i-11);
+ buffer[i-11] = 0x00;
+
+ smprintf(s, "USSD reply: \"%s\"\n",buffer);
+
+ if (s->Phone.Data.EnableIncomingUSSD && s->User.IncomingUSSD!=NULL) {
+ EncodeUnicode(buffer2,buffer,strlen(buffer));
+ s->User.IncomingUSSD(s->CurrentConfig->Device, buffer2);
+ }
+
+ return ERR_NONE;
+}
+
+GSM_Error ATGEN_SetIncomingUSSD(GSM_StateMachine *s, bool enable)
+{
+ GSM_Error error;
+
+ if (enable) {
+ smprintf(s, "Enabling incoming USSD\n");
+ error=GSM_WaitFor (s, "AT+CUSD=1\r", 10, 0x00, 3, ID_SetUSSD);
+ } else {
+ smprintf(s, "Disabling incoming USSD\n");
+ error=GSM_WaitFor (s, "AT+CUSD=0\r", 10, 0x00, 3, ID_SetUSSD);
+ }
+ if (error==ERR_NONE) s->Phone.Data.EnableIncomingUSSD = enable;
+ return error;
+}
+
GSM_Error ATGEN_ReplyGetModel(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
GSM_Phone_Data *Data = &s->Phone.Data;
if (s->Phone.Data.Priv.ATGEN.ReplyState != AT_Reply_OK) return ERR_NOTSUPPORTED;
if (strlen(GetLineString(msg.Buffer, Priv->Lines, 2)) <= MAX_MODEL_LENGTH) {
CopyLineString(Data->Model, msg.Buffer, Priv->Lines, 2);
/* Sometimes phone adds this before manufacturer (Sagem) */
if (strncmp("+CGMM: ", Data->Model, 7) == 0) {
memmove(Data->Model, Data->Model + 7, strlen(Data->Model + 7) + 1);
}
Data->ModelInfo = GetModelData(NULL,Data->Model,NULL);
if (Data->ModelInfo->number[0] == 0) Data->ModelInfo = GetModelData(NULL,NULL,Data->Model);
if (Data->ModelInfo->number[0] == 0) Data->ModelInfo = GetModelData(Data->Model,NULL,NULL);
if (Data->ModelInfo->number[0] != 0) strcpy(Data->Model,Data->ModelInfo->number);
if (strstr(msg.Buffer,"Nokia")) Priv->Manufacturer = AT_Nokia;
else if (strstr(msg.Buffer,"M20")) Priv->Manufacturer = AT_Siemens;
else if (strstr(msg.Buffer,"MC35")) Priv->Manufacturer = AT_Siemens;
+ else if (strstr(msg.Buffer,"TC35")) Priv->Manufacturer = AT_Siemens;
else if (strstr(msg.Buffer, "iPAQ")) Priv->Manufacturer = AT_HP;
if (strstr(msg.Buffer,"M20")) strcpy(Data->Model,"M20");
else if (strstr(msg.Buffer,"MC35")) strcpy(Data->Model,"MC35");
+ else if (strstr(msg.Buffer,"TC35")) strcpy(Data->Model,"TC35");
else if (strstr(msg.Buffer, "iPAQ")) strcpy(Data->Model,"iPAQ");
} else {
smprintf(s, "WARNING: Model name too long, increase MAX_MODEL_LENGTH to at least %zd\n", strlen(GetLineString(msg.Buffer, Priv->Lines, 2)));
}
return ERR_NONE;
}
GSM_Error ATGEN_GetModel(GSM_StateMachine *s)
{
GSM_Error error;
if (s->Phone.Data.Model[0] != 0) return ERR_NONE;
smprintf(s, "Getting model\n");
error=GSM_WaitFor (s, "AT+CGMM\r", 8, 0x00, 3, ID_GetModel);
if (error==ERR_NONE) {
if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL ||
s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE) {
smprintf(s, "[Connected model - \"%s\"]\n",s->Phone.Data.Model);
}
}
return error;
}
@@ -460,48 +500,53 @@ GSM_Error ATGEN_ReplyGetManufacturer(GSM_Protocol_Message msg, GSM_StateMachine
smprintf(s, "Siemens\n");
strcpy(s->Phone.Data.Manufacturer,"Siemens");
Priv->Manufacturer = AT_Siemens;
}
if (strstr(msg.Buffer,"ERICSSON")) {
smprintf(s, "Ericsson\n");
strcpy(s->Phone.Data.Manufacturer,"Ericsson");
Priv->Manufacturer = AT_Ericsson;
}
if (strstr(msg.Buffer,"iPAQ")) {
smprintf(s, "iPAQ\n");
strcpy(s->Phone.Data.Manufacturer,"HP");
Priv->Manufacturer = AT_HP;
}
if (strstr(msg.Buffer,"ALCATEL")) {
smprintf(s, "Alcatel\n");
strcpy(s->Phone.Data.Manufacturer,"Alcatel");
Priv->Manufacturer = AT_Alcatel;
}
if (strstr(msg.Buffer,"SAGEM")) {
smprintf(s, "Sagem\n");
strcpy(s->Phone.Data.Manufacturer,"Sagem");
Priv->Manufacturer = AT_Sagem;
}
+ if (strstr(msg.Buffer,"Samsung")) {
+ smprintf(s, "Samsung\n");
+ strcpy(s->Phone.Data.Manufacturer,"Samsung");
+ Priv->Manufacturer = AT_Samsung;
+ }
return ERR_NONE;
case AT_Reply_CMSError:
return ATGEN_HandleCMSError(s);
default:
break;
}
return ERR_UNKNOWNRESPONSE;
}
GSM_Error ATGEN_GetManufacturer(GSM_StateMachine *s)
{
if (s->Phone.Data.Manufacturer[0] != 0) return ERR_NONE;
return GSM_WaitFor (s, "AT+CGMI\r", 8, 0x00, 4, ID_GetManufacturer);
}
GSM_Error ATGEN_ReplyGetFirmwareCGMR(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
unsigned int i = 0;
strcpy(s->Phone.Data.Version,"unknown");
s->Phone.Data.VerNum = 0;
if (Priv->ReplyState == AT_Reply_OK) {
@@ -653,58 +698,68 @@ GSM_Error ATGEN_SetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
if (smsc->Location!=1) return ERR_NOTSUPPORTED;
sprintf(req, "AT+CSCA=\"%s\"\r",DecodeUnicodeString(smsc->Number));
smprintf(s, "Setting SMSC\n");
return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_SetSMSC);
}
GSM_Error ATGEN_ReplyGetSMSMemories(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
case AT_Reply_OK:
/* Reply here is:
* (memories for reading)[, (memories for writing)[, (memories for storing received messages)]]
* each memory is in quotes,
* Example: ("SM"), ("SM"), ("SM")
*
* We need to get from this supported memories. For this case
* we assume, that just appearence of memory makes it
* available for everything. Then we need to find out whether
* phone supports writing to memory. This is done by searching
* for "), (", which will appear between lists.
*/
- s->Phone.Data.Priv.ATGEN.CanSaveSMS = (strstr(msg.Buffer, "), (") != NULL);
+ s->Phone.Data.Priv.ATGEN.CanSaveSMS = false;
+ if (strstr(msg.Buffer, "), (") != NULL || strstr(msg.Buffer, "),(") != NULL) {
+ s->Phone.Data.Priv.ATGEN.CanSaveSMS = true;
+ }
+
if (strstr(msg.Buffer, "\"SM\"") != NULL) s->Phone.Data.Priv.ATGEN.SIMSMSMemory = AT_AVAILABLE;
else s->Phone.Data.Priv.ATGEN.SIMSMSMemory = AT_NOTAVAILABLE;
+
if (strstr(msg.Buffer, "\"ME\"") != NULL) s->Phone.Data.Priv.ATGEN.PhoneSMSMemory = AT_AVAILABLE;
else s->Phone.Data.Priv.ATGEN.PhoneSMSMemory = AT_NOTAVAILABLE;
- smprintf(s, "Available SMS memories received, ME = %d, SM = %d\n", s->Phone.Data.Priv.ATGEN.PhoneSMSMemory, s->Phone.Data.Priv.ATGEN.SIMSMSMemory);
+
+ smprintf(s, "Available SMS memories received, ME = %d, SM = %d, cansavesms =", s->Phone.Data.Priv.ATGEN.PhoneSMSMemory, s->Phone.Data.Priv.ATGEN.SIMSMSMemory);
+ if (s->Phone.Data.Priv.ATGEN.CanSaveSMS) smprintf(s, "true");
+ smprintf(s, "\n");
return ERR_NONE;
case AT_Reply_Error:
case AT_Reply_CMSError:
return ATGEN_HandleCMSError(s);
+ case AT_Reply_CMEError:
+ return ATGEN_HandleCMEError(s);
default:
return ERR_UNKNOWNRESPONSE;
}
}
GSM_Error ATGEN_GetSMSMemories(GSM_StateMachine *s)
{
smprintf(s, "Getting available SMS memories\n");
return GSM_WaitFor (s, "AT+CPMS=?\r", 10, 0x00, 4, ID_GetSMSMemories);
}
GSM_Error ATGEN_SetSMSMemory(GSM_StateMachine *s, bool SIM)
{
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
char req[] = "AT+CPMS=\"XX\",\"XX\"\r";
int reqlen = 18;
GSM_Error error;
if ((SIM && Priv->SIMSMSMemory == 0) || (!SIM && Priv->PhoneSMSMemory == 0)) {
/* We silently ignore error here, because when this fails, we can try to setmemory anyway */
ATGEN_GetSMSMemories(s);
}
/* If phone can not save SMS, don't try to set memory for saving */
@@ -837,140 +892,141 @@ GSM_Error ATGEN_ReplyGetSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s
unsigned char buffer[300],smsframe[800];
unsigned char firstbyte, TPDCS, TPUDL, TPStatus;
GSM_Error error;
switch (Priv->ReplyState) {
case AT_Reply_OK:
if (Priv->Lines.numbers[4] == 0x00) return ERR_EMPTY;
s->Phone.Data.GetSMSMessage->Number = 1;
s->Phone.Data.GetSMSMessage->SMS[0].Name[0] = 0;
s->Phone.Data.GetSMSMessage->SMS[0].Name[1] = 0;
switch (Priv->SMSMode) {
case SMS_AT_PDU:
CopyLineString(buffer, msg.Buffer, Priv->Lines, 2);
switch (buffer[7]) {
case '0': sms->State = SMS_UnRead; break;
case '1': sms->State = SMS_Read; break;
case '2': sms->State = SMS_UnSent; break;
default : sms->State = SMS_Sent; break;//case '3'
}
DecodeHexBin (buffer, GetLineString(msg.Buffer,Priv->Lines,3), strlen(GetLineString(msg.Buffer,Priv->Lines,3)));
/* Siemens MC35 (only ?) */
if (strstr(msg.Buffer,"+CMGR: 0,,0")!=NULL) return ERR_EMPTY;
/* Siemens M20 */
if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_M20SMS)) {
- if (buffer[1]!=NUMBER_UNKNOWN && buffer[1]!=NUMBER_INTERNATIONAL &&
- buffer[1]!=NUMBER_ALPHANUMERIC) {
+ /* we check for the most often visible */
+ if (buffer[1]!=NUMBER_UNKNOWN_NUMBERING_PLAN_ISDN && buffer[1]!=NUMBER_INTERNATIONAL_NUMBERING_PLAN_ISDN &&
+ buffer[1]!=NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN) {
/* Seems to be Delivery Report */
smprintf(s, "SMS type - status report (M20 style)\n");
sms->PDU = SMS_Status_Report;
sms->Folder = 1; /*INBOX SIM*/
sms->InboxFolder = true;
smsframe[12]=buffer[current++];
smsframe[PHONE_SMSStatusReport.TPMR]=buffer[current++];
current2=((buffer[current])+1)/2+1;
for(i=0;i<current2+1;i++) smsframe[PHONE_SMSStatusReport.Number+i]=buffer[current++];
for(i=0;i<7;i++) smsframe[PHONE_SMSStatusReport.DateTime+i]=buffer[current++];
smsframe[0] = 0;
for(i=0;i<7;i++) smsframe[PHONE_SMSStatusReport.SMSCTime+i]=buffer[current++];
smsframe[PHONE_SMSStatusReport.TPStatus]=buffer[current];
GSM_DecodeSMSFrame(sms,smsframe,PHONE_SMSStatusReport);
return ERR_NONE;
}
}
/* We use locations from SMS layouts like in ../phone2.c(h) */
for(i=0;i<buffer[0]+1;i++) smsframe[i]=buffer[current++];
smsframe[12]=buffer[current++];
/* See GSM 03.40 section 9.2.3.1 */
switch (smsframe[12] & 0x03) {
case 0x00:
smprintf(s, "SMS type - deliver\n");
sms->PDU = SMS_Deliver;
if (Priv->SMSMemory == MEM_SM) {
sms->Folder = 1; /*INBOX SIM*/
} else {
sms->Folder = 3; /*INBOX ME*/
}
sms->InboxFolder = true;
current2=((buffer[current])+1)/2+1;
if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_M20SMS)) {
- if (buffer[current+1]==NUMBER_ALPHANUMERIC) {
+ if (buffer[current+1]==NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN) {
smprintf(s, "Trying to read alphanumeric number\n");
for(i=0;i<4;i++) smsframe[PHONE_SMSDeliver.Number+i]=buffer[current++];
current+=6;
for(i=0;i<current2-3;i++) smsframe[PHONE_SMSDeliver.Number+i+4]=buffer[current++];
} else {
for(i=0;i<current2+1;i++) smsframe[PHONE_SMSDeliver.Number+i]=buffer[current++];
}
} else {
for(i=0;i<current2+1;i++) smsframe[PHONE_SMSDeliver.Number+i]=buffer[current++];
}
smsframe[PHONE_SMSDeliver.TPPID] = buffer[current++];
smsframe[PHONE_SMSDeliver.TPDCS] = buffer[current++];
for(i=0;i<7;i++) smsframe[PHONE_SMSDeliver.DateTime+i]=buffer[current++];
smsframe[PHONE_SMSDeliver.TPUDL] = buffer[current++];
for(i=0;i<smsframe[PHONE_SMSDeliver.TPUDL];i++) smsframe[i+PHONE_SMSDeliver.Text]=buffer[current++];
GSM_DecodeSMSFrame(sms,smsframe,PHONE_SMSDeliver);
return ERR_NONE;
case 0x01:
smprintf(s, "SMS type - submit\n");
sms->PDU = SMS_Submit;
if (Priv->SMSMemory == MEM_SM) {
sms->Folder = 2; /*OUTBOX SIM*/
smprintf(s, "Outbox SIM\n");
} else {
sms->Folder = 4; /*OUTBOX ME*/
}
sms->InboxFolder = false;
smsframe[PHONE_SMSSubmit.TPMR] = buffer[current++];
current2=((buffer[current])+1)/2+1;
if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_M20SMS)) {
- if (buffer[current+1]==NUMBER_ALPHANUMERIC) {
+ if (buffer[current+1]==NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN) {
smprintf(s, "Trying to read alphanumeric number\n");
for(i=0;i<4;i++) smsframe[PHONE_SMSSubmit.Number+i]=buffer[current++];
current+=6;
for(i=0;i<current2-3;i++) smsframe[PHONE_SMSSubmit.Number+i+4]=buffer[current++];
} else {
for(i=0;i<current2+1;i++) smsframe[PHONE_SMSSubmit.Number+i]=buffer[current++];
}
} else {
for(i=0;i<current2+1;i++) smsframe[PHONE_SMSSubmit.Number+i]=buffer[current++];
}
smsframe[PHONE_SMSSubmit.TPPID] = buffer[current++];
smsframe[PHONE_SMSSubmit.TPDCS] = buffer[current++];
/* See GSM 03.40 9.2.3.3 - TPVP can not exist in frame */
if ((smsframe[12] & 0x18)!=0) current++; //TPVP is ignored now
smsframe[PHONE_SMSSubmit.TPUDL] = buffer[current++];
for(i=0;i<smsframe[PHONE_SMSSubmit.TPUDL];i++) smsframe[i+PHONE_SMSSubmit.Text]=buffer[current++];
GSM_DecodeSMSFrame(sms,smsframe,PHONE_SMSSubmit);
return ERR_NONE;
case 0x02:
smprintf(s, "SMS type - status report\n");
sms->PDU = SMS_Status_Report;
sms->Folder = 1; /*INBOX SIM*/
sms->InboxFolder = true;
- smprintf(s, "TPMR is %02x\n",buffer[current]);
+ smprintf(s, "TPMR is %d\n",buffer[current]);
smsframe[PHONE_SMSStatusReport.TPMR] = buffer[current++];
current2=((buffer[current])+1)/2+1;
for(i=0;i<current2+1;i++) smsframe[PHONE_SMSStatusReport.Number+i]=buffer[current++];
for(i=0;i<7;i++) smsframe[PHONE_SMSStatusReport.DateTime+i]=buffer[current++];
for(i=0;i<7;i++) smsframe[PHONE_SMSStatusReport.SMSCTime+i]=buffer[current++];
smsframe[PHONE_SMSStatusReport.TPStatus]=buffer[current];
GSM_DecodeSMSFrame(sms,smsframe,PHONE_SMSStatusReport);
return ERR_NONE;
}
break;
case SMS_AT_TXT:
current = 0;
while (msg.Buffer[current]!='"') current++;
current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
if (!strcmp(buffer,"\"0\"") || !strcmp(buffer,"\"REC UNREAD\"")) {
smprintf(s, "SMS type - deliver\n");
sms->State = SMS_UnRead;
sms->PDU = SMS_Deliver;
if (Priv->SMSMemory == MEM_SM) {
sms->Folder = 1; /*INBOX SIM*/
} else {
sms->Folder = 3; /*INBOX ME*/
}
sms->InboxFolder = true;
@@ -1619,59 +1675,59 @@ GSM_Error ATGEN_AddSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
return error;
}
}
return Phone->DispatchError;
}
GSM_Error ATGEN_ReplySendSMS(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
char *start;
if (s->Protocol.Data.AT.EditMode) {
if (s->Phone.Data.Priv.ATGEN.ReplyState != AT_Reply_SMSEdit) {
return ERR_UNKNOWN;
}
s->Protocol.Data.AT.EditMode = false;
return ERR_NONE;
}
switch (Priv->ReplyState) {
case AT_Reply_OK:
smprintf(s, "SMS sent OK\n");
if (s->User.SendSMSStatus!=NULL) {
- start = strstr(msg.Buffer, "+CMGW: ");
+ start = strstr(msg.Buffer, "+CMGS: ");
if (start != NULL) {
s->User.SendSMSStatus(s->CurrentConfig->Device,0,atoi(start+7));
} else {
- s->User.SendSMSStatus(s->CurrentConfig->Device,0,0);
+ s->User.SendSMSStatus(s->CurrentConfig->Device,0,-1);
}
}
return ERR_NONE;
case AT_Reply_CMSError:
smprintf(s, "Error %i\n",Priv->ErrorCode);
- if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,Priv->ErrorCode,0);
+ if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,Priv->ErrorCode,-1);
return ATGEN_HandleCMSError(s);
case AT_Reply_Error:
return ERR_UNKNOWN;
default:
return ERR_UNKNOWNRESPONSE;
}
}
GSM_Error ATGEN_SendSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
{
GSM_Error error,error2;
int current, current2, Replies;
unsigned char buffer[1000], hexreq[1000];
GSM_Phone_Data *Phone = &s->Phone.Data;
if (sms->PDU == SMS_Deliver) sms->PDU = SMS_Submit;
error = ATGEN_MakeSMSFrame(s, sms, hexreq, &current, &current2);
if (error != ERR_NONE) return error;
switch (Phone->Priv.ATGEN.SMSMode) {
case SMS_AT_PDU:
sprintf(buffer, "AT+CMGS=%i\r",current);
break;
@@ -1766,48 +1822,61 @@ GSM_Error ATGEN_GetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
GSM_Error ATGEN_SetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
{
char req[128];
sprintf(req, "AT+CCLK=\"%02i/%02i/%02i,%02i:%02i:%02i+00\"\r",
date_time->Year-2000,date_time->Month,date_time->Day,
date_time->Hour,date_time->Minute,date_time->Second);
smprintf(s, "Setting date & time\n");
return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_SetDateTime);
}
GSM_Error ATGEN_GetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
{
if (alarm->Location != 1) return ERR_NOTSUPPORTED;
alarm->Repeating = true;
alarm->Text[0] = 0; alarm->Text[1] = 0;
s->Phone.Data.Alarm = alarm;
smprintf(s, "Getting alarm\n");
return GSM_WaitFor (s, "AT+CALA?\r", 9, 0x00, 4, ID_GetAlarm);
}
+/* R320 only takes HH:MM. Do other phones understand full date? */
+GSM_Error ATGEN_SetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
+{
+ char req[20];
+
+ if (alarm->Location != 1) return ERR_INVALIDLOCATION;
+
+ sprintf(req, "AT+CALA=\"%02i:%02i\"\r",alarm->DateTime.Hour,alarm->DateTime.Minute);
+
+ smprintf(s, "Setting Alarm\n");
+ return GSM_WaitFor (s, req, strlen(req), 0x00, 3, ID_SetAlarm);
+}
+
GSM_Error ATGEN_ReplyGetSMSC(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_SMSC *SMSC = s->Phone.Data.SMSC;
int current;
int len;
unsigned char buffer[100];
switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
case AT_Reply_OK:
smprintf(s, "SMSC info received\n");
current = 0;
while (msg.Buffer[current]!='"') current++;
/* SMSC number */
/* FIXME: support for all formats */
current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
/*
* Some phones return this as unicode encoded when they are
* switched to UCS2 mode, so we try to solve this correctly.
*/
len = strlen(buffer + 1) - 1;
buffer[len + 1] = 0;
if ((len > 20) && (len % 4 == 0) && (strchr(buffer + 1, '+') == NULL)) {
@@ -2181,48 +2250,50 @@ GSM_Error ATGEN_ReplyGetCPBRMemoryStatus(GSM_Protocol_Message msg, GSM_StateMach
case AT_Reply_Error:
return ERR_UNKNOWN;
case AT_Reply_CMSError:
return ATGEN_HandleCMSError(s);
default:
return ERR_UNKNOWNRESPONSE;
}
}
GSM_Error ATGEN_GetMemoryInfo(GSM_StateMachine *s, GSM_MemoryStatus *Status, GSM_AT_NeededMemoryInfo NeededInfo)
{
GSM_Error error;
char req[20];
int start;
int end;
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
smprintf(s, "Getting memory information\n");
Priv->MemorySize = 0;
Priv->TextLength = 0;
Priv->NumberLength = 0;
error = GSM_WaitFor (s, "AT+CPBR=?\r", 10, 0x00, 4, ID_GetMemoryStatus);
+ if (Priv->Manufacturer == AT_Samsung)
+ error = GSM_WaitFor (s, "", 0, 0x00, 4, ID_GetMemoryStatus);
if (error != ERR_NONE) return error;
if (NeededInfo == AT_Total || NeededInfo == AT_Sizes || NeededInfo == AT_First) return ERR_NONE;
smprintf(s, "Getting memory status by reading values\n");
s->Phone.Data.MemoryStatus = Status;
Status->MemoryUsed = 0;
Status->MemoryFree = 0;
start = Priv->FirstMemoryEntry;
Priv->NextMemoryEntry = 0;
while (1) {
end = start + 20;
if (end > Priv->MemorySize) end = Priv->MemorySize;
sprintf(req, "AT+CPBR=%i,%i\r", start, end);
error = GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetMemoryStatus);
if (error != ERR_NONE) return error;
if (NeededInfo == AT_NextEmpty && Priv->NextMemoryEntry != 0 && Priv->NextMemoryEntry != end + 1) return ERR_NONE;
if (end == Priv->MemorySize) {
Status->MemoryFree = Priv->MemorySize - Status->MemoryUsed;
return ERR_NONE;
}
start = end + 1;
}
}
@@ -2247,48 +2318,54 @@ GSM_Error ATGEN_GetMemoryStatus(GSM_StateMachine *s, GSM_MemoryStatus *Status)
}
return ATGEN_GetMemoryInfo(s, Status, AT_Status);
}
GSM_Error ATGEN_SetPBKCharset(GSM_StateMachine *s, bool PreferUnicode)
{
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
GSM_Error error;
/* Have we already selected something? */
if (Priv->PBKCharset!=0) {
/* If we want unicode charset and we have it already or setting of it
* failed, we have nothing to do. */
if (PreferUnicode && (Priv->PBKCharset==AT_PBK_UCS2 || Priv->UCS2CharsetFailed)) return ERR_NONE;
/* If we don't need unicode charset and we have some (or have unicode
* charset when other failed), we have nothing to do. */
if (!PreferUnicode && (Priv->PBKCharset!=AT_PBK_UCS2 || Priv->NonUCS2CharsetFailed)) return ERR_NONE;
}
error=ATGEN_GetManufacturer(s);
if (error != ERR_NONE) return error;
+ /* Samsung (and Sagem?) phones use only PCCP437? */
+ if (Priv->Manufacturer == AT_Samsung) {
+ Priv->PBKCharset = AT_PBK_PCCP437;
+ return ERR_NONE;
+ }
+
if (PreferUnicode && !Priv->UCS2CharsetFailed) {
smprintf(s, "Setting charset to UCS2\n");
error=GSM_WaitFor (s, "AT+CSCS=\"UCS2\"\r", 15, 0x00, 3, ID_SetMemoryCharset);
if (error == ERR_NONE) {
Priv->PBKCharset = AT_PBK_UCS2;
return ERR_NONE;
} else {
Priv->UCS2CharsetFailed = true;
}
}
smprintf(s, "Setting charset to HEX\n");
error=GSM_WaitFor (s, "AT+CSCS=\"HEX\"\r", 14, 0x00, 3, ID_SetMemoryCharset);
/* Falcom replies OK for HEX mode and send everything
* in normal format */
if (error == ERR_NONE && Priv->Manufacturer != AT_Falcom) {
Priv->PBKCharset = AT_PBK_HEX;
return ERR_NONE;
}
smprintf(s, "Setting charset to GSM\n");
error=GSM_WaitFor (s, "AT+CSCS=\"GSM\"\r", 14, 0x00, 3, ID_SetMemoryCharset);
if (error == ERR_NONE) {
Priv->PBKCharset = AT_PBK_GSM;
@@ -2364,49 +2441,79 @@ GSM_Error ATGEN_ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
if (strlen(buffer+1)!=0 && buffer[1] != '+') {
/* Sony Ericsson issue */
/* International number is without + */
buffer[0] = '+';
EncodeUnicode(Memory->Entries[0].Text,buffer,strlen(buffer));
}
}
/* Name */
pos += ATGEN_ExtractOneParameter(pos, buffer);
smprintf(s, "Name text: %s\n",buffer);
Memory->EntriesNum++;
Memory->Entries[1].EntryType=PBK_Text_Name;
switch (Priv->PBKCharset) {
case AT_PBK_HEX:
DecodeHexBin(buffer2,buffer+1,strlen(buffer)-2);
DecodeDefault(Memory->Entries[1].Text,buffer2,strlen(buffer2),false,NULL);
break;
case AT_PBK_GSM:
DecodeDefault(Memory->Entries[1].Text,buffer+1,strlen(buffer)-2,false,NULL);
break;
case AT_PBK_UCS2:
DecodeHexUnicode(Memory->Entries[1].Text,buffer+1,strlen(buffer+1) - 1);
break;
+ case AT_PBK_PCCP437:
+ /* FIXME: correctly decode PCCP437 */
+ DecodeDefault(Memory->Entries[1].Text,buffer+1,strlen(buffer)-2,false,NULL);
+ break;
+ }
+
+ /* Samsung number type */
+ if (Priv->Manufacturer == AT_Samsung) {
+ int type;
+
+ pos += ATGEN_ExtractOneParameter(pos, buffer);
+ smprintf(s, "Number type: %s\n",buffer);
+ type = strtoul(buffer, NULL, 0);
+ switch (type) {
+ case 0:
+ Memory->Entries[0].EntryType = PBK_Number_Mobile;
+ break;
+ case 1:
+ Memory->Entries[0].EntryType = PBK_Number_Work;
+ break;
+ case 2:
+ Memory->Entries[0].EntryType = PBK_Number_Home;
+ break;
+ case 3:
+ Memory->Entries[0].EntryType = PBK_Text_Email;
+ break;
+ default:
+ Memory->Entries[0].EntryType = PBK_Number_General;
+ }
}
+
return ERR_NONE;
case AT_Reply_CMEError:
return ATGEN_HandleCMEError(s);
case AT_Reply_Error:
smprintf(s, "Error - too high location ?\n");
return ERR_INVALIDLOCATION;
case AT_Reply_CMSError:
return ATGEN_HandleCMSError(s);
default:
break;
}
return ERR_UNKNOWNRESPONSE;
}
GSM_Error ATGEN_PrivGetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry, int endlocation)
{
GSM_Error error;
unsigned char req[20];
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
if (entry->Location==0x00) return ERR_INVALIDLOCATION;
if (entry->MemoryType == MEM_ME) {
if (Priv->PBKSBNR == 0) {
@@ -2541,48 +2648,50 @@ GSM_Error ATGEN_DialVoice(GSM_StateMachine *s, char *number, GSM_CallShowNumber
{
char req[39] = "ATDT";
if (ShowNumber != GSM_CALL_DefaultNumberPresence) return ERR_NOTSUPPORTED;
if (strlen(number) > 32) return (ERR_UNKNOWN);
strcat(req, number);
strcat(req, ";\r");
smprintf(s, "Making voice call\n");
return GSM_WaitFor (s, req, 4+2+strlen(number), 0x00, 5, ID_DialVoice);
}
GSM_Error ATGEN_ReplyEnterSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
case AT_Reply_OK:
smprintf(s, "Security code was OK\n");
return ERR_NONE;
case AT_Reply_Error:
smprintf(s, "Incorrect security code\n");
return ERR_SECURITYERROR;
case AT_Reply_CMSError:
return ATGEN_HandleCMSError(s);
+ case AT_Reply_CMEError:
+ return ATGEN_HandleCMEError(s);
default:
break;
}
return ERR_UNKNOWNRESPONSE;
}
GSM_Error ATGEN_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode Code)
{
unsigned char req[50];
switch (Code.Type) {
case SEC_Pin :
sprintf(req, "AT+CPIN=\"%s\"\r" , Code.Code);
break;
case SEC_Pin2 :
if (s->Phone.Data.Priv.ATGEN.Manufacturer == AT_Siemens) {
sprintf(req, "AT+CPIN2=\"%s\"\r", Code.Code);
} else {
sprintf(req, "AT+CPIN=\"%s\"\r" , Code.Code);
}
break;
default : return ERR_NOTIMPLEMENTED;
}
@@ -2903,48 +3012,54 @@ GSM_Error ATGEN_PrivSetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
if ((Priv->TextLength != 0) && ((Priv->TextLength * 7 / 16) <= len)) {
PreferUnicode = false;
} else {
PreferUnicode = true;
}
}
error = ATGEN_SetPBKCharset(s, PreferUnicode);
if (error != ERR_NONE) return error;
switch (Priv->PBKCharset) {
case AT_PBK_HEX:
EncodeHexBin(name, DecodeUnicodeString(entry->Entries[Name].Text), UnicodeLength(entry->Entries[Name].Text));
len = strlen(name);
break;
case AT_PBK_GSM:
smprintf(s, "str: %s\n", DecodeUnicodeString(entry->Entries[Name].Text));
len = UnicodeLength(entry->Entries[Name].Text);
EncodeDefault(name, entry->Entries[Name].Text, &len, true, NULL);
break;
case AT_PBK_UCS2:
EncodeHexUnicode(name, entry->Entries[Name].Text, UnicodeLength(entry->Entries[Name].Text));
len = strlen(name);
break;
+ case AT_PBK_PCCP437:
+ /* FIXME: correctly decode PCCP437 */
+ smprintf(s, "str: %s\n", DecodeUnicodeString(entry->Entries[Name].Text));
+ len = UnicodeLength(entry->Entries[Name].Text);
+ EncodeDefault(name, entry->Entries[Name].Text, &len, true, NULL);
+ break;
}
} else {
smprintf(s, "WARNING: No usable name found!\n");
len = 0;
}
if (Number != -1) {
GSM_PackSemiOctetNumber(entry->Entries[Number].Text, number, false);
NumberType = number[0];
sprintf(number,"%s",DecodeUnicodeString(entry->Entries[Number].Text));
} else {
smprintf(s, "WARNING: No usable number found!\n");
number[0] = 0;
}
if (Priv->FirstMemoryEntry == 0) {
error = ATGEN_GetMemoryInfo(s, NULL, AT_First);
if (error != ERR_NONE) return error;
}
/* We can't use here:
* sprintf(req, "AT+CPBW=%d, \"%s\", %i, \"%s\"\r",
* entry->Location, number, NumberType, name);
* because name can contain 0 when using GSM alphabet.
@@ -3231,48 +3346,85 @@ GSM_Error ATGEN_Terminate(GSM_StateMachine *s)
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
free(Priv->file.Buffer);
return ERR_NONE;
}
GSM_Error ATGEN_AddCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note)
{
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
if (Priv->Manufacturer==AT_Siemens) return SIEMENS_AddCalendarNote(s, Note);
if (Priv->Manufacturer==AT_Ericsson) return SONYERIC_AddCalendarNote(s, Note);
return ERR_NOTSUPPORTED;
}
GSM_Error ATGEN_DelCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note)
{
GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
if (Priv->Manufacturer==AT_Siemens) return SIEMENS_DelCalendarNote(s, Note);
if (Priv->Manufacturer==AT_Ericsson) return SONYERIC_DelCalendarNote(s, Note);
return ERR_NOTSUPPORTED;
}
+
+GSM_Error ATGEN_GetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
+{
+ GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
+
+ if (Priv->Manufacturer==AT_Siemens) return SIEMENS_GetBitmap(s, Bitmap);
+ if (Priv->Manufacturer==AT_Samsung) return SAMSUNG_GetBitmap(s, Bitmap);
+ return ERR_NOTSUPPORTED;
+}
+
+GSM_Error ATGEN_SetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
+{
+ GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
+
+ if (Priv->Manufacturer==AT_Siemens) return SIEMENS_SetBitmap(s, Bitmap);
+ if (Priv->Manufacturer==AT_Samsung) return SAMSUNG_SetBitmap(s, Bitmap);
+ return ERR_NOTSUPPORTED;
+}
+
+GSM_Error ATGEN_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone)
+{
+ GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
+
+ if (Priv->Manufacturer==AT_Siemens) return SIEMENS_GetRingtone(s, Ringtone, PhoneRingtone);
+ if (Priv->Manufacturer==AT_Samsung) return SAMSUNG_GetRingtone(s, Ringtone, PhoneRingtone);
+ return ERR_NOTSUPPORTED;
+}
+
+GSM_Error ATGEN_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength)
+{
+ GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
+
+ if (Priv->Manufacturer==AT_Siemens) return SIEMENS_SetRingtone(s, Ringtone, maxlength);
+ if (Priv->Manufacturer==AT_Samsung) return SAMSUNG_SetRingtone(s, Ringtone, maxlength);
+ return ERR_NOTSUPPORTED;
+}
+
GSM_Error ATGEN_PressKey(GSM_StateMachine *s, GSM_KeyCode Key, bool Press)
{
GSM_Error error;
unsigned char Frame[] = "AT+CKPD=\"?\"\r";
if (Press) {
switch (Key) {
case GSM_KEY_1 : Frame[9] = '1'; break;
case GSM_KEY_2 : Frame[9] = '2'; break;
case GSM_KEY_3 : Frame[9] = '3'; break;
case GSM_KEY_4 : Frame[9] = '4'; break;
case GSM_KEY_5 : Frame[9] = '5'; break;
case GSM_KEY_6 : Frame[9] = '6'; break;
case GSM_KEY_7 : Frame[9] = '7'; break;
case GSM_KEY_8 : Frame[9] = '8'; break;
case GSM_KEY_9 : Frame[9] = '9'; break;
case GSM_KEY_0 : Frame[9] = '0'; break;
case GSM_KEY_HASH : Frame[9] = '#'; break;
case GSM_KEY_ASTERISK : Frame[9] = '*'; break;
case GSM_KEY_POWER : return ERR_NOTSUPPORTED;
case GSM_KEY_GREEN : Frame[9] = 'S'; break;
case GSM_KEY_RED : Frame[9] = 'E'; break;
case GSM_KEY_INCREASEVOLUME : Frame[9] = 'U'; break;
case GSM_KEY_DECREASEVOLUME : Frame[9] = 'D'; break;
@@ -3325,48 +3477,59 @@ GSM_Error ATGEN_ReplyIncomingCB(GSM_Protocol_Message msg, GSM_StateMachine *s)
return ERR_NONE;
}
#endif
GSM_Error ATGEN_SetIncomingCB(GSM_StateMachine *s, bool enable)
{
#ifdef GSM_ENABLE_CELLBROADCAST
if (s->Phone.Data.EnableIncomingCB!=enable) {
s->Phone.Data.EnableIncomingCB = enable;
if (enable) {
smprintf(s, "Enabling incoming CB\n");
return GSM_WaitFor(s, "AT+CNMI=3,,2\r", 13, 0x00, 4, ID_SetIncomingCB);
} else {
smprintf(s, "Disabling incoming CB\n");
return GSM_WaitFor(s, "AT+CNMI=3,,0\r", 13, 0x00, 4, ID_SetIncomingCB);
}
}
return ERR_NONE;
#else
return ERR_SOURCENOTAVAILABLE;
#endif
}
+GSM_Error ATGEN_SetFastSMSSending(GSM_StateMachine *s, bool enable)
+{
+ if (enable) {
+ smprintf(s, "Enabling fast SMS sending\n");
+ return GSM_WaitFor(s, "AT+CMMS=2\r", 10, 0x00, 4, ID_SetFastSMSSending);
+ } else {
+ smprintf(s, "Disabling fast SMS sending\n");
+ return GSM_WaitFor(s, "AT+CMMS=0\r", 10, 0x00, 4, ID_SetFastSMSSending);
+ }
+}
+
GSM_Error ATGEN_IncomingSMSInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
smprintf(s, "Incoming SMS\n");
return ERR_NONE;
}
GSM_Error ATGEN_IncomingSMSDeliver(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_Data *Data = &s->Phone.Data;
GSM_SMSMessage sms;
int current = 0, current2, i=0;
unsigned char buffer[300],smsframe[800];
smprintf(s, "Incoming SMS received (Deliver)\n");
if (Data->EnableIncomingSMS && s->User.IncomingSMS!=NULL) {
sms.State = SMS_UnRead;
sms.InboxFolder = true;
sms.PDU = SMS_Deliver;
/* T310 with larger SMS goes crazy and mix this incoming
* frame with normal answers. PDU is always last frame
* We find its' number and parse it */
while (Data->Priv.ATGEN.Lines.numbers[i*2+1] != 0) {
/* FIXME: handle special chars correctly */
@@ -3403,267 +3566,297 @@ GSM_Error ATGEN_IncomingSMSReport(GSM_Protocol_Message msg, GSM_StateMachine *s)
GSM_Error ATGEN_SetIncomingSMS(GSM_StateMachine *s, bool enable)
{
/* Nokia returns OK, but doesn't return anything */
if (s->Phone.Data.Priv.ATGEN.Manufacturer == AT_Nokia) return ERR_NOTSUPPORTED;
if (s->Phone.Data.EnableIncomingSMS!=enable) {
s->Phone.Data.EnableIncomingSMS = enable;
if (enable) {
smprintf(s, "Enabling incoming SMS\n");
/* Delivery reports */
GSM_WaitFor(s, "AT+CNMI=3,,,1\r", 14, 0x00, 4, ID_SetIncomingSMS);
/* SMS deliver */
return GSM_WaitFor(s, "AT+CNMI=3,3\r", 12, 0x00, 4, ID_SetIncomingSMS);
} else {
smprintf(s, "Disabling incoming SMS\n");
return GSM_WaitFor(s, "AT+CNMI=3,0\r", 12, 0x00, 4, ID_SetIncomingSMS);
}
}
return ERR_NONE;
}
+GSM_Error ATGEN_GetLocale(GSM_StateMachine *s, GSM_Locale *locale)
+{
+ if (s->Phone.Data.Priv.ATGEN.Manufacturer==AT_Ericsson) return ERICSSON_GetLocale(s,locale);
+ return ERR_NOTSUPPORTED;
+}
+
+GSM_Error ATGEN_SetLocale(GSM_StateMachine *s, GSM_Locale *locale)
+{
+ if (s->Phone.Data.Priv.ATGEN.Manufacturer==AT_Ericsson) return ERICSSON_SetLocale(s,locale);
+ return ERR_NOTSUPPORTED;
+}
+
GSM_Reply_Function ATGENReplyFunctions[] = {
{ATGEN_GenericReply, "AT\r" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_GenericReply, "ATE1" ,0x00,0x00,ID_EnableEcho },
{ATGEN_GenericReply, "AT+CMEE=" ,0x00,0x00,ID_EnableErrorInfo },
{ATGEN_GenericReply, "AT+CKPD=" ,0x00,0x00,ID_PressKey },
{ATGEN_ReplyGetSIMIMSI, "AT+CIMI" ,0x00,0x00,ID_GetSIMIMSI },
{ATGEN_GenericReply, "AT*EOBEX" ,0x00,0x00,ID_SetOBEX },
+{ERICSSON_ReplyGetDateLocale, "*ESDF:" ,0x00,0x00,ID_GetLocale },
+{ERICSSON_ReplyGetTimeLocale, "*ESTF:" ,0x00,0x00,ID_GetLocale },
+{ATGEN_GenericReply, "AT*ESDF=" ,0x00,0x00,ID_SetLocale },
+{ATGEN_GenericReply, "AT*ESTF=" ,0x00,0x00,ID_SetLocale },
+
#ifdef GSM_ENABLE_CELLBROADCAST
{ATGEN_ReplyIncomingCB, "+CBM:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_GenericReply, "AT+CNMI" ,0x00,0x00,ID_SetIncomingCB },
#endif
{ATGEN_IncomingBattery, "_OBS:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyGetBatteryCharge, "AT+CBC" ,0x00,0x00,ID_GetBatteryCharge },
{ATGEN_ReplyGetModel, "AT+CGMM" ,0x00,0x00,ID_GetModel },
{ATGEN_ReplyGetManufacturer, "AT+CGMI" ,0x00,0x00,ID_GetManufacturer },
{ATGEN_ReplyGetFirmwareCGMR, "AT+CGMR" ,0x00,0x00,ID_GetFirmware },
{ATGEN_ReplyGetFirmwareATI, "ATI" ,0x00,0x00,ID_GetFirmware },
{ATGEN_ReplyGetIMEI, "AT+CGSN" ,0x00,0x00,ID_GetIMEI },
{ATGEN_ReplySendSMS, "AT+CMGS" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplySendSMS, "AT+CMSS" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_GenericReply, "AT+CNMI" ,0x00,0x00,ID_SetIncomingSMS },
{ATGEN_GenericReply, "AT+CMGF" ,0x00,0x00,ID_GetSMSMode },
{ATGEN_GenericReply, "AT+CSDH" ,0x00,0x00,ID_GetSMSMode },
{ATGEN_ReplyGetSMSMessage, "AT+CMGR" ,0x00,0x00,ID_GetSMSMessage },
{ATGEN_GenericReply, "AT+CPMS" ,0x00,0x00,ID_SetMemoryType },
{ATGEN_ReplyGetSMSStatus, "AT+CPMS" ,0x00,0x00,ID_GetSMSStatus },
{ATGEN_ReplyGetSMSMemories, "AT+CPMS=?" ,0x00,0x00,ID_GetSMSMemories },
{ATGEN_ReplyAddSMSMessage, "AT+CMGW" ,0x00,0x00,ID_SaveSMSMessage },
{ATGEN_GenericReply, "AT+CSMP" ,0x00,0x00,ID_SetSMSParameters },
{ATGEN_GenericReply, "AT+CSCA" ,0x00,0x00,ID_SetSMSC },
{ATGEN_ReplyGetSMSC, "AT+CSCA?" ,0x00,0x00,ID_GetSMSC },
{ATGEN_ReplyDeleteSMSMessage, "AT+CMGD" ,0x00,0x00,ID_DeleteSMSMessage },
{ATGEN_GenericReply, "ATE1" ,0x00,0x00,ID_SetSMSParameters },
{ATGEN_GenericReply, "\x1b\x0D" ,0x00,0x00,ID_SetSMSParameters },
+{ATGEN_GenericReply, "AT+CMMS" ,0x00,0x00,ID_SetFastSMSSending },
{ATGEN_IncomingSMSInfo, "+CMTI:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_IncomingSMSDeliver, "+CMT:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_IncomingSMSReport, "+CDS:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_IncomingSMSCInfo, "^SCN:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyGetDateTime_Alarm, "AT+CCLK?" ,0x00,0x00,ID_GetDateTime },
{ATGEN_GenericReply, "AT+CCLK=" ,0x00,0x00,ID_SetDateTime },
+{ATGEN_GenericReply, "AT+CALA=" ,0x00,0x00,ID_SetAlarm },
{ATGEN_ReplyGetDateTime_Alarm, "AT+CALA?" ,0x00,0x00,ID_GetAlarm },
{ATGEN_ReplyGetNetworkLAC_CID, "AT+CREG?" ,0x00,0x00,ID_GetNetworkInfo },
{ATGEN_GenericReply, "AT+CREG=2" ,0x00,0x00,ID_GetNetworkInfo },
{ATGEN_GenericReply, "AT+COPS=" ,0x00,0x00,ID_GetNetworkInfo },
{ATGEN_GenericReply, "AT+COPS=" ,0x00,0x00,ID_SetAutoNetworkLogin},
{ATGEN_ReplyGetNetworkCode, "AT+COPS" ,0x00,0x00,ID_GetNetworkInfo },
{ATGEN_ReplyGetSignalQuality, "AT+CSQ" ,0x00,0x00,ID_GetSignalQuality },
{ATGEN_IncomingNetworkLevel, "_OSIGQ:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_IncomingGPRS, "+CGREG:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyGetNetworkLAC_CID, "+CREG:" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyGetPBKMemories, "AT+CPBS=?" ,0x00,0x00,ID_SetMemoryType },
{ATGEN_GenericReply, "AT+CPBS=" ,0x00,0x00,ID_SetMemoryType },
{ATGEN_ReplyGetCPBSMemoryStatus,"AT+CPBS?" ,0x00,0x00,ID_GetMemoryStatus },
+// /* Samsung phones reply +CPBR: after OK --claudio*/
{ATGEN_ReplyGetCPBRMemoryInfo, "AT+CPBR=?" ,0x00,0x00,ID_GetMemoryStatus },
+{ATGEN_ReplyGetCPBRMemoryInfo, "+CPBR:" ,0x00,0x00,ID_GetMemoryStatus },
{ATGEN_ReplyGetCPBRMemoryStatus,"AT+CPBR=" ,0x00,0x00,ID_GetMemoryStatus },
{ATGEN_GenericReply, "AT+CSCS=" ,0x00,0x00,ID_SetMemoryCharset },
{ATGEN_ReplyGetMemory, "AT+CPBR=" ,0x00,0x00,ID_GetMemory },
{ATGEN_GenericReply, "AT^SBNR=?" ,0x00,0x00,ID_GetMemory },
-{ATGEN_SL45ReplyGetMemory, "AT^SBNR" ,0x00,0x00,ID_GetMemory },
+{SIEMENS_ReplyGetMemory, "AT^SBNR" ,0x00,0x00,ID_GetMemory },
{ATGEN_ReplySetMemory, "AT+CPBW" ,0x00,0x00,ID_SetMemory },
-{ATGEN_CMS35ReplyGetBitmap, "AT^SBNR=\"bmp\"" ,0x00,0x00,ID_GetBitmap },
-{ATGEN_CMS35ReplySetBitmap, "AT^SBNW=\"bmp\"" ,0x00,0x00,ID_SetBitmap },
+{SIEMENS_ReplyGetBitmap, "AT^SBNR=\"bmp\"" ,0x00,0x00,ID_GetBitmap },
+{SIEMENS_ReplySetBitmap, "AT^SBNW=\"bmp\"" ,0x00,0x00,ID_SetBitmap },
-{ATGEN_CMS35ReplyGetRingtone, "AT^SBNR=\"mid\"" ,0x00,0x00,ID_GetRingtone },
-{ATGEN_CMS35ReplySetRingtone, "AT^SBNW=\"mid\"" ,0x00,0x00,ID_SetRingtone },
+{SIEMENS_ReplyGetRingtone, "AT^SBNR=\"mid\"" ,0x00,0x00,ID_GetRingtone },
+{SIEMENS_ReplySetRingtone, "AT^SBNW=\"mid\"" ,0x00,0x00,ID_SetRingtone },
-{ATGEN_CMS35ReplyGetNextCal, "AT^SBNR=\"vcs\"" ,0x00,0x00,ID_GetCalendarNote },
-{ATGEN_CMS35ReplySetCalendar, "AT^SBNW=\"vcs\"" ,0x00,0x00,ID_SetCalendarNote },
-{ATGEN_CMS35ReplyDeleteCalendar,"AT^SBNW=\"vcs\"" ,0x00,0x00,ID_DeleteCalendarNote },
+{SIEMENS_ReplyGetNextCalendar, "AT^SBNR=\"vcs\"" ,0x00,0x00,ID_GetCalendarNote },
+{SIEMENS_ReplyAddCalendarNote, "AT^SBNW=\"vcs\"" ,0x00,0x00,ID_SetCalendarNote },
+{SIEMENS_ReplyDelCalendarNote, "AT^SBNW=\"vcs\"" ,0x00,0x00,ID_DeleteCalendarNote },
{ATGEN_ReplyEnterSecurityCode, "AT+CPIN=" ,0x00,0x00,ID_EnterSecurityCode },
{ATGEN_ReplyEnterSecurityCode, "AT+CPIN2=" ,0x00,0x00,ID_EnterSecurityCode },
{ATGEN_ReplyGetSecurityStatus, "AT+CPIN?" ,0x00,0x00,ID_GetSecurityStatus },
{ATGEN_ReplyOK, "OK" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_GenericReply, "AT+VTS" ,0x00,0x00,ID_SendDTMF },
{ATGEN_ReplyCancelCall, "AT+CHUP" ,0x00,0x00,ID_CancelCall },
{ATGEN_ReplyDialVoice, "ATDT" ,0x00,0x00,ID_DialVoice },
{ATGEN_ReplyCancelCall, "ATH" ,0x00,0x00,ID_CancelCall },
+{ATGEN_GenericReply, "AT+CUSD" ,0x00,0x00,ID_SetUSSD },
+{ATGEN_ReplyGetUSSD, "+CUSD" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_GenericReply, "AT+CLIP=1" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyIncomingCallInfo, "+CLIP" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyIncomingCallInfo, "+COLP" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyIncomingCallInfo, "RING" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyIncomingCallInfo, "NO CARRIER" ,0x00,0x00,ID_IncomingFrame },
{ATGEN_ReplyReset, "AT^SRESET" ,0x00,0x00,ID_Reset },
{ATGEN_ReplyReset, "AT+CFUN=1,1" ,0x00,0x00,ID_Reset },
{ATGEN_ReplyResetPhoneSettings, "AT&F" ,0x00,0x00,ID_ResetPhoneSettings },
+{SAMSUNG_ReplyGetBitmap, "AT+IMGR=" ,0x00,0x00,ID_GetBitmap },
+{SAMSUNG_ReplySetBitmap, "SDNDCRC =" ,0x00,0x00,ID_SetBitmap },
+
+{SAMSUNG_ReplyGetRingtone, "AT+MELR=" ,0x00,0x00,ID_GetRingtone },
+{SAMSUNG_ReplySetRingtone, "SDNDCRC =" ,0x00,0x00,ID_SetRingtone },
+
#ifdef GSM_ENABLE_ALCATEL
/* Why do I give Alcatel specific things here? It's simple, Alcatel needs
* some AT commands to start it's binary mode, so this needs to be in AT
* related stuff.
*
* XXX: AT+IFC could later move outside this ifdef, because it is not Alcatel
* specific and it's part of ETSI specifications
*/
{ATGEN_GenericReply, "AT+IFC" ,0x00,0x00,ID_SetFlowControl },
{ALCATEL_ProtocolVersionReply, "AT+CPROT=?" ,0x00,0x00,ID_AlcatelProtocol },
{ATGEN_GenericReply, "AT+CPROT" ,0x00,0x00,ID_AlcatelConnect },
#endif
{NULL, "\x00" ,0x00,0x00,ID_None }
};
GSM_Phone_Functions ATGENPhone = {
- "A2D|iPAQ|at|M20|S25|MC35|C35i|5110|5130|5190|5210|6110|6130|6150|6190|6210|6250|6310|6310i|6510|7110|8210|8250|8290|8310|8390|8850|8855|8890|8910|9110|9210",
+ "A2D|iPAQ|at|M20|S25|MC35|TC35|C35i|S300|5110|5130|5190|5210|6110|6130|6150|6190|6210|6250|6310|6310i|6510|7110|8210|8250|8290|8310|8390|8850|8855|8890|8910|9110|9210",
ATGENReplyFunctions,
ATGEN_Initialise,
ATGEN_Terminate,
ATGEN_DispatchMessage,
NOTSUPPORTED, /* ShowStartInfo */
ATGEN_GetManufacturer,
ATGEN_GetModel,
ATGEN_GetFirmware,
ATGEN_GetIMEI,
NOTSUPPORTED, /* GetOriginalIMEI */
NOTSUPPORTED, /* GetManufactureMonth */
NOTSUPPORTED, /* GetProductCode */
NOTSUPPORTED, /* GetHardware */
NOTSUPPORTED, /* GetPPM */
ATGEN_GetSIMIMSI,
ATGEN_GetDateTime,
ATGEN_SetDateTime,
ATGEN_GetAlarm,
- NOTIMPLEMENTED, /* SetAlarm */
- NOTSUPPORTED, /* GetLocale */
- NOTSUPPORTED, /* SetLocale */
+ ATGEN_SetAlarm,
+ ATGEN_GetLocale,
+ ATGEN_SetLocale,
ATGEN_PressKey,
ATGEN_Reset,
ATGEN_ResetPhoneSettings,
ATGEN_EnterSecurityCode,
ATGEN_GetSecurityStatus,
ATGEN_GetDisplayStatus,
ATGEN_SetAutoNetworkLogin,
ATGEN_GetBatteryCharge,
ATGEN_GetSignalQuality,
ATGEN_GetNetworkInfo,
NOTSUPPORTED, /* GetCategory */
NOTSUPPORTED, /* AddCategory */
NOTSUPPORTED, /* GetCategoryStatus */
ATGEN_GetMemoryStatus,
ATGEN_GetMemory,
ATGEN_GetNextMemory,
ATGEN_SetMemory,
ATGEN_AddMemory,
ATGEN_DeleteMemory,
ATGEN_DeleteAllMemory,
NOTSUPPORTED, /* GetSpeedDial */
NOTSUPPORTED, /* SetSpeedDial */
ATGEN_GetSMSC,
ATGEN_SetSMSC,
ATGEN_GetSMSStatus,
ATGEN_GetSMS,
ATGEN_GetNextSMS,
NOTSUPPORTED, /* SetSMS */
ATGEN_AddSMS,
ATGEN_DeleteSMS,
ATGEN_SendSMS,
ATGEN_SendSavedSMS,
+ ATGEN_SetFastSMSSending,
ATGEN_SetIncomingSMS,
ATGEN_SetIncomingCB,
ATGEN_GetSMSFolders,
NOTSUPPORTED, /* AddSMSFolder */
NOTSUPPORTED, /* DeleteSMSFolder */
ATGEN_DialVoice,
ATGEN_AnswerCall,
ATGEN_CancelCall,
NOTSUPPORTED, /* HoldCall */
NOTSUPPORTED, /* UnholdCall */
NOTSUPPORTED, /* ConferenceCall */
NOTSUPPORTED, /* SplitCall */
NOTSUPPORTED, /* TransferCall */
NOTSUPPORTED, /* SwitchCall */
NOTSUPPORTED, /* GetCallDivert */
NOTSUPPORTED, /* SetCallDivert */
NOTSUPPORTED, /* CancelAllDiverts */
NONEFUNCTION, /* SetIncomingCall */
- NOTSUPPORTED, /* SetIncomingUSSD */
+ ATGEN_SetIncomingUSSD,
ATGEN_SendDTMF,
ATGEN_GetRingtone,
ATGEN_SetRingtone,
NOTSUPPORTED, /* GetRingtonesInfo */
NOTSUPPORTED, /* DeleteUserRingtones */
NOTSUPPORTED, /* PlayTone */
NOTSUPPORTED, /* GetWAPBookmark */
NOTSUPPORTED, /* SetWAPBookmark */
NOTSUPPORTED, /* DeleteWAPBookmark */
NOTSUPPORTED, /* GetWAPSettings */
NOTSUPPORTED, /* SetWAPSettings */
NOTSUPPORTED, /* GetMMSSettings */
NOTSUPPORTED, /* SetMMSSettings */
NOTSUPPORTED, /* GetSyncMLSettings */
NOTSUPPORTED, /* SetSyncMLSettings */
NOTSUPPORTED, /* GetChatSettings */
NOTSUPPORTED, /* SetChatSettings */
ATGEN_GetBitmap, /* GetBitmap */
ATGEN_SetBitmap, /* SetBitmap */
SONYERIC_GetToDoStatus,
NOTSUPPORTED, /* GetToDo */
SONYERIC_GetNextToDo,
NOTSUPPORTED, /* SetToDo */
SONYERIC_AddToDo,
NOTSUPPORTED, /* DeleteToDo */
SONYERIC_DeleteAllToDo,
SONYERIC_GetCalendarStatus,
NOTIMPLEMENTED, /* GetCalendar */
ATGEN_GetNextCalendar,
NOTIMPLEMENTED, /* SetCalendar */
ATGEN_AddCalendarNote,
ATGEN_DelCalendarNote,
NOTIMPLEMENTED, /* DeleteAllCalendar */
NOTSUPPORTED, /* GetCalendarSettings */
NOTSUPPORTED, /* SetCalendarSettings */
- NOTSUPPORTED, /* GetNote */
+ NOTSUPPORTED, /* GetNextNote */
NOTSUPPORTED, /* GetProfile */
NOTSUPPORTED, /* SetProfile */
NOTSUPPORTED, /* GetFMStation */
NOTSUPPORTED, /* SetFMStation */
NOTSUPPORTED, /* ClearFMStations */
NOTSUPPORTED, /* GetNextFileFolder */
NOTSUPPORTED, /* GetFilePart */
NOTSUPPORTED, /* AddFile */
NOTSUPPORTED, /* GetFileSystemStatus */
NOTSUPPORTED, /* DeleteFile */
NOTSUPPORTED, /* AddFolder */
NOTSUPPORTED, /* GetGPRSAccessPoint */
NOTSUPPORTED /* SetGPRSAccessPoint */
};
#endif
/* How should editor hadle tabs in this file? Add editor commands here.
* vim: noexpandtab sw=8 ts=8 sts=8:
*/