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
@@ -3,55 +3,35 @@
 #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 */
@@ -166,24 +146,26 @@ 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:
@@ -247,26 +229,34 @@ int ATGEN_ExtractOneParameter(unsigned char *input, unsigned char *output)
                 *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++;
@@ -313,24 +303,36 @@ GSM_Error ATGEN_DispatchMessage(GSM_StateMachine *s)
                 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;
@@ -361,52 +363,90 @@ GSM_Error ATGEN_GenericReply(GSM_Protocol_Message msg, GSM_StateMachine *s)
                 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;
 
@@ -472,24 +512,29 @@ GSM_Error ATGEN_ReplyGetManufacturer(GSM_Protocol_Message msg, GSM_StateMachine
                         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;
@@ -665,34 +710,44 @@ GSM_Error ATGEN_ReplyGetSMSMemories(GSM_Protocol_Message msg, GSM_StateMachine *
         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)
@@ -849,26 +904,27 @@ GSM_Error ATGEN_ReplyGetSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s
                         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;
@@ -885,25 +941,25 @@ GSM_Error ATGEN_ReplyGetSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s
                         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++];
@@ -916,49 +972,49 @@ GSM_Error ATGEN_ReplyGetSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s
                                 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;
@@ -1631,35 +1687,35 @@ GSM_Error ATGEN_ReplySendSMS(GSM_Protocol_Message msg, GSM_StateMachine *s)
         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;
@@ -1778,24 +1834,37 @@ GSM_Error ATGEN_SetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
 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;
@@ -2193,24 +2262,26 @@ GSM_Error ATGEN_GetMemoryInfo(GSM_StateMachine *s, GSM_MemoryStatus *Status, GSM
                 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;
@@ -2259,24 +2330,30 @@ GSM_Error ATGEN_SetPBKCharset(GSM_StateMachine *s, bool PreferUnicode)
                 /* 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");
@@ -2376,25 +2453,55 @@ GSM_Error ATGEN_ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
                 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;
@@ -2553,24 +2660,26 @@ GSM_Error ATGEN_DialVoice(GSM_StateMachine *s, char *number, GSM_CallShowNumber
 
 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 :
@@ -2915,24 +3024,30 @@ GSM_Error ATGEN_PrivSetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
                         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");
@@ -3243,24 +3358,61 @@ GSM_Error ATGEN_AddCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *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_Errorerror;
                 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;
@@ -3337,24 +3489,35 @@ GSM_Error ATGEN_SetIncomingCB(GSM_StateMachine *s, bool enable)
                         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];
@@ -3415,32 +3578,49 @@ GSM_Error ATGEN_SetIncomingSMS(GSM_StateMachine *s, bool enable)
                         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 },
@@ -3453,122 +3633,134 @@ GSM_Reply_Function ATGENReplyFunctions[] = {
         {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     */
@@ -3583,43 +3775,44 @@ GSM_Phone_Functions ATGENPhone = {
                 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  */
@@ -3637,25 +3830,25 @@ GSM_Phone_Functions ATGENPhone = {
         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*/