Initial revision

6 files changed, 1014 insertions, 0 deletions

diff --git a/gammu/emb/common/protocol/nokia/fbus2.c b/gammu/emb/common/protocol/nokia/fbus2.c
new file mode 100644
index 0000000..8b3e024
--- a/dev/null
+++ b/gammu/emb/common/protocol/nokia/fbus2.c
@@ -0,0 +1,444 @@
+/* (c) 2002-2003 by Marcin Wiacek */
+/* based on some work from Gnokii and MyGnokii */
+
+#include "../../gsmstate.h"
+
+#if defined(GSM_ENABLE_FBUS2) || defined(GSM_ENABLE_FBUS2IRDA) || defined(GSM_ENABLE_FBUS2DLR3) || defined(GSM_ENABLE_FBUS2BLUE) || defined(GSM_ENABLE_BLUEFBUS2) || defined(GSM_ENABLE_FBUS2DKU5) || defined(GSM_ENABLE_FBUS2PL2303)
+
+#include <stdio.h>
+#include <string.h>
+
+#include "../../gsmcomon.h"
+#include "fbus2.h"
+
+        static GSM_Error FBUS2_WriteFrame(GSM_StateMachine *s,
+                                          unsigned char *MsgBuffer,
+                                          int           MsgLength,
+                                          unsigned char MsgType)
+{
+                unsigned char     buffer2[FBUS2_MAX_TRANSMIT_LENGTH + 10];  
+                unsigned char     checksum=0;
+                int               i, len, sent;
+
+                buffer2[0] = FBUS2_FRAME_ID;
+        if (s->ConnectionType==GCT_FBUS2IRDA) buffer2[0] = FBUS2_IRDA_FRAME_ID;
+
+                buffer2[1]      = FBUS2_DEVICE_PHONE;   //destination
+                buffer2[2]      = FBUS2_DEVICE_PC;      //source
+                buffer2[3]= MsgType;
+                buffer2[4]= MsgLength / 256;
+                buffer2[5]= MsgLength % 256;
+
+        memcpy(buffer2 + 6, MsgBuffer, MsgLength);
+        len = MsgLength + 6;
+
+        /* Odd messages require additional 0x00 byte */
+        if (MsgLength % 2) buffer2[len++] = 0x00;
+
+                checksum = 0;
+        for (i = 0; i < len; i+=2) checksum ^= buffer2[i];
+                buffer2[len++] = checksum;
+
+                checksum = 0;
+        for (i = 1; i < len; i+=2) checksum ^= buffer2[i];
+                buffer2[len++] = checksum;
+
+        /* Sending to phone */
+        sent=s->Device.Functions->WriteDevice(s,buffer2,len);
+        if (sent!=len) return ERR_DEVICEWRITEERROR;
+
+        return ERR_NONE;
+}
+
+        static GSM_Error FBUS2_WriteMessage (GSM_StateMachine *s,
+                                             unsigned char *MsgBuffer,
+                                             int        MsgLength,
+                                             unsigned char MsgType)
+{
+                int             i, nom, togo, thislength; /* number of messages, ... */
+                unsigned char   buffer2[FBUS2_MAX_TRANSMIT_LENGTH + 2], seqnum;
+                GSM_Protocol_FBUS2Data*d = &s->Protocol.Data.FBUS2;
+                GSM_Error       error;
+
+        GSM_DumpMessageLevel3(s, MsgBuffer, MsgLength, MsgType);
+
+        nom  = (MsgLength + FBUS2_MAX_TRANSMIT_LENGTH - 1) / FBUS2_MAX_TRANSMIT_LENGTH;
+        togo = MsgLength;
+
+        for (i = 0; i < nom; i++) {
+                        seqnum                  = d->MsgSequenceNumber;
+                        if (i==0) seqnum = seqnum + 0x40;
+                        d->MsgSequenceNumber = (d->MsgSequenceNumber + 1) & 0x07;
+
+                thislength = togo;
+                if (togo > FBUS2_MAX_TRANSMIT_LENGTH) thislength = FBUS2_MAX_TRANSMIT_LENGTH;
+                memcpy(buffer2, MsgBuffer + (MsgLength - togo), thislength);
+                        buffer2[thislength]= nom - i;
+                        buffer2[thislength + 1]= seqnum;
+                        togo            = togo - thislength;
+
+                GSM_DumpMessageLevel2(s, buffer2, thislength, MsgType);
+
+                error=FBUS2_WriteFrame(s, buffer2, thislength + 2, MsgType);
+                if (error!=ERR_NONE) return error;
+        }
+
+        return ERR_NONE;
+}
+
+        static GSM_Error FBUS2_SendAck(GSM_StateMachine *s,
+                                       unsigned char    MsgType,
+                                       unsigned char    MsgSequence)
+{
+        unsigned char buffer2[2];
+
+        buffer2[0] = MsgType;
+        buffer2[1] = MsgSequence;
+
+        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL ||
+            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE) {
+                smprintf(s,"[Sending Ack of type %02x, seq %x]\n",buffer2[0],buffer2[1]);
+        }
+
+        /* Sending to phone */
+        return FBUS2_WriteFrame(s, buffer2, 2, FBUS2_ACK_BYTE);
+}
+
+static GSM_Error FBUS2_StateMachine(GSM_StateMachine *s, unsigned char rx_char)
+{
+                GSM_Protocol_FBUS2Data *d = &s->Protocol.Data.FBUS2;
+                unsigned char   frm_num, seq_num;
+                bool            correct = false;
+
+        /* XOR the byte with the earlier checksum */
+        d->Msg.CheckSum[d->Msg.Count & 1] ^= rx_char;
+
+        if (d->MsgRXState == RX_GetMessage) {
+                d->Msg.Buffer[d->Msg.Count] = rx_char;
+                d->Msg.Count++;
+
+                /* This is not last byte in frame */
+                if (d->Msg.Count != d->Msg.Length+(d->Msg.Length%2)+2) return ERR_NONE;
+
+                /* Checksum is incorrect */
+                if (d->Msg.CheckSum[0] != d->Msg.CheckSum[1]) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                        smprintf(s,"[ERROR: checksum]\n");
+                        }
+                        free(d->Msg.Buffer);
+                                d->Msg.Length   = 0;
+                                d->Msg.Buffer   = NULL;
+
+                                d->MsgRXState   = RX_Sync;
+                        return ERR_NONE;
+                }
+
+                seq_num = d->Msg.Buffer[d->Msg.Length-1];
+
+                if (d->Msg.Type == FBUS2_ACK_BYTE) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE) {
+                                smprintf(s, "[Received Ack of type %02x, seq %02x]\n",d->Msg.Buffer[0],seq_num);
+                        }
+
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+
+                frm_num = d->Msg.Buffer[d->Msg.Length-2];
+
+                if ((seq_num & 0x40) == 0x40) {
+                                d->FramesToGo   = frm_num;
+                                d->MultiMsg.Length= 0;
+                                d->MultiMsg.Type= d->Msg.Type;
+                                d->MultiMsg.Destination= d->Msg.Destination;
+                                d->MultiMsg.Source= d->Msg.Source;
+                }
+
+                if ((seq_num & 0x40) != 0x40 && d->FramesToGo != frm_num) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s, "[ERROR: Missed part of multiframe msg]\n");
+                        }
+
+                        free(d->Msg.Buffer);
+                                d->Msg.Length   = 0;
+                                d->Msg.Buffer   = NULL;
+
+                                d->MsgRXState   = RX_Sync;
+                        return ERR_NONE;
+                }
+
+                if ((seq_num & 0x40) != 0x40 && d->Msg.Type != d->MultiMsg.Type) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s, "[ERROR: Multiframe msg in multiframe msg]\n");
+                        }
+
+                        free(d->Msg.Buffer);
+                                d->Msg.Length   = 0;
+                                d->Msg.Buffer   = NULL;
+        
+                                d->MsgRXState   = RX_Sync;
+                        return ERR_NONE;
+                }
+
+                if (d->MultiMsg.BufferUsed < d->MultiMsg.Length+d->Msg.Length-2) {
+                                d->MultiMsg.BufferUsed = d->MultiMsg.Length+d->Msg.Length-2;
+                                d->MultiMsg.Buffer = (unsigned char *)realloc(d->MultiMsg.Buffer,d->MultiMsg.BufferUsed);
+                }
+                memcpy(d->MultiMsg.Buffer+d->MultiMsg.Length,d->Msg.Buffer,d->Msg.Length-2);
+                d->MultiMsg.Length = d->MultiMsg.Length+d->Msg.Length-2;
+        
+                free(d->Msg.Buffer);
+                        d->Msg.Length = 0;
+                        d->Msg.Buffer = NULL;
+
+                d->FramesToGo--;
+
+                /* do not ack debug trace, as this could generate a
+                 * (feedback loop) flood of which even Noah would be scared.
+                 */
+                if (d->Msg.Type != 0) {
+                        FBUS2_SendAck(s,d->Msg.Type,((unsigned char)(seq_num & 0x0f)));
+                }
+                                        
+                if (d->FramesToGo == 0) {
+                                s->Phone.Data.RequestMsg= &d->MultiMsg;
+                                s->Phone.Data.DispatchError= s->Phone.Functions->DispatchMessage(s);
+                }
+                d->MsgRXState = RX_Sync;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetLength2) {
+                        d->Msg.Length = d->Msg.Length + rx_char;
+                        d->Msg.Buffer = (unsigned char *)malloc(d->Msg.Length+3);
+                        d->MsgRXState = RX_GetMessage;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetLength1) {
+                d->Msg.Length = rx_char * 256;
+                d->MsgRXState = RX_GetLength2;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetType) {
+                d->Msg.Type   = rx_char;
+                d->MsgRXState = RX_GetLength1;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetSource) {
+                if (rx_char != FBUS2_DEVICE_PHONE) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s,"[ERROR: incorrect char - %02x, not %02x]\n", rx_char, FBUS2_DEVICE_PHONE);
+                        }
+
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+                d->Msg.Source = rx_char;
+
+                d->MsgRXState = RX_GetType;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetDestination) {
+                if (rx_char != FBUS2_DEVICE_PC) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                    smprintf(s,"[ERROR: incorrect char - %02x, not %02x]\n", rx_char, FBUS2_DEVICE_PC);
+                        }
+
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+                d->Msg.Destination = rx_char;
+
+                        d->MsgRXState    = RX_GetSource;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_Sync) {
+                switch (s->ConnectionType) {
+                        case GCT_FBUS2:
+                        case GCT_FBUS2DLR3:
+                        case GCT_FBUS2DKU5:
+                        case GCT_FBUS2PL2303:
+                        case GCT_FBUS2BLUE:
+                        case GCT_BLUEFBUS2:
+                                if (rx_char == FBUS2_FRAME_ID) correct = true;
+                                break;
+                        case GCT_FBUS2IRDA:
+                                if (rx_char == FBUS2_IRDA_FRAME_ID) correct = true;
+                                break;
+                        default:
+                                break;
+                }
+                if (!correct) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                if (s->ConnectionType==GCT_FBUS2IRDA) {
+                                        smprintf(s,"[ERROR: incorrect char - %02x, not %02x]\n", rx_char, FBUS2_IRDA_FRAME_ID);
+                                    } else {
+                                        smprintf(s,"[ERROR: incorrect char - %02x, not %02x]\n", rx_char, FBUS2_FRAME_ID);
+                                    }
+                                }       
+                        return ERR_NONE;
+                }
+
+                d->Msg.CheckSum[0] = rx_char;
+                d->Msg.CheckSum[1] = 0;
+                        d->Msg.Count   = 0;
+
+                        d->MsgRXState      = RX_GetDestination;
+                return ERR_NONE;
+        }
+        return ERR_NONE;
+}
+
+#if defined(GSM_ENABLE_FBUS2DLR3) || defined(GSM_ENABLE_FBUS2DKU5) || defined(GSM_ENABLE_FBUS2BLUE) || defined(GSM_ENABLE_BLUEFBUS2) || defined(GSM_ENABLE_FBUS2PL2303) 
+static void FBUS2_WriteDLR3(GSM_StateMachine *s, char *command, int length, int timeout)
+{
+                unsigned char   buff[300];
+                int             w = 0;
+                bool            wassomething = false;
+
+        s->Device.Functions->WriteDevice(s,command,length);
+
+        for (w=0;w<timeout;w++) {    
+                if (wassomething) {
+                        if (s->Device.Functions->ReadDevice(s, buff, 255)==0) return;
+                } else {
+                        if (s->Device.Functions->ReadDevice(s, buff, 255)>0) wassomething = true;
+                }
+                my_sleep(50);
+        }
+}
+#endif
+
+static GSM_Error FBUS2_Initialise(GSM_StateMachine *s)
+{
+                unsigned char           init_char= 0x55;
+#ifdef GSM_ENABLE_FBUS2IRDA
+                unsigned char           end_init_char= 0xc1;
+#endif
+
+                GSM_Protocol_FBUS2Data  *d      = &s->Protocol.Data.FBUS2;
+                GSM_Device_Functions    *Device = s->Device.Functions;
+                GSM_Error       error;
+                int             count;
+
+                d->Msg.Length   = 0;
+                d->Msg.Buffer   = NULL;
+                d->MultiMsg.BufferUsed= 0;
+                d->MultiMsg.Length= 0;
+                d->MultiMsg.Buffer= NULL;
+
+                d->MsgSequenceNumber= 0;
+                d->FramesToGo   = 0;
+                d->MsgRXState   = RX_Sync;
+
+        error=Device->DeviceSetParity(s,false);
+        if (error!=ERR_NONE) return error;
+
+        switch (s->ConnectionType) {
+#if defined(GSM_ENABLE_BLUEFBUS2) || defined(GSM_ENABLE_FBUS2BLUE)
+        case GCT_FBUS2BLUE:
+        case GCT_BLUEFBUS2:
+                        FBUS2_WriteDLR3(s,"AT\r\n",      4,10);
+                        FBUS2_WriteDLR3(s,"AT&F\r\n",    6,10);
+                        FBUS2_WriteDLR3(s,"AT*NOKIAFBUS\r\n",14,10);
+                break;
+#endif
+#if defined(GSM_ENABLE_FBUS2DLR3) || defined(GSM_ENABLE_FBUS2DKU5) || defined(GSM_ENABLE_FBUS2PL2303)
+        case GCT_FBUS2DKU5:
+        case GCT_FBUS2PL2303:
+        case GCT_FBUS2DLR3:
+                error=Device->DeviceSetDtrRts(s,false,false);
+                    if (error!=ERR_NONE) return error; 
+                my_sleep(1000);
+
+                error=Device->DeviceSetDtrRts(s,true,true);
+                    if (error!=ERR_NONE) return error; 
+                error=Device->DeviceSetSpeed(s,19200);
+                if (error!=ERR_NONE) return error;
+
+                        FBUS2_WriteDLR3(s,"AT\r\n",      4,10);
+                        FBUS2_WriteDLR3(s,"AT&F\r\n",    6,10);
+                        FBUS2_WriteDLR3(s,"AT*NOKIAFBUS\r\n",14,10);
+
+                error=Device->CloseDevice(s);
+                if (error!=ERR_NONE) return error;
+                my_sleep(1000);
+
+                error=Device->OpenDevice(s);
+                if (error!=ERR_NONE) return error;
+                error=Device->DeviceSetParity(s,false);
+                    if (error!=ERR_NONE) return error;
+                error=Device->DeviceSetSpeed(s,115200);
+                    if (error!=ERR_NONE) return error; 
+                error=Device->DeviceSetDtrRts(s,false,false);
+                if (error!=ERR_NONE) return error; 
+                        
+                for (count = 0; count < 55; count ++) {
+                        if (Device->WriteDevice(s,&init_char,1)!=1) return ERR_DEVICEWRITEERROR;
+                }
+                break;
+#endif
+        case GCT_FBUS2:
+                error=Device->DeviceSetSpeed(s,115200);
+                if (error!=ERR_NONE) return error; 
+
+                error=Device->DeviceSetDtrRts(s,true,false); /*DTR high,RTS low*/
+                if (error!=ERR_NONE) return error; 
+
+                for (count = 0; count < 55; count ++) {
+                        if (Device->WriteDevice(s,&init_char,1)!=1) return ERR_DEVICEWRITEERROR;
+                        my_sleep(10);
+                }
+                break;
+#ifdef GSM_ENABLE_FBUS2IRDA
+        case GCT_FBUS2IRDA:
+                error=Device->DeviceSetSpeed(s,9600);
+                if (error!=ERR_NONE) return error;
+
+                for (count = 0; count < 55; count ++) {
+                        if (Device->WriteDevice(s,&init_char,1)!=1) return ERR_DEVICEWRITEERROR;
+                        my_sleep(10);
+                }
+
+                if (Device->WriteDevice(s,&end_init_char,1)!=1) return ERR_DEVICEWRITEERROR;
+                my_sleep(20);
+
+                error=Device->DeviceSetSpeed(s,115200);
+                if (error!=ERR_NONE) return error;
+
+                        break;          
+#endif
+        default:
+                break;
+        }
+
+        return ERR_NONE;
+}
+
+static GSM_Error FBUS2_Terminate(GSM_StateMachine *s)
+{
+        free(s->Protocol.Data.FBUS2.Msg.Buffer);
+        free(s->Protocol.Data.FBUS2.MultiMsg.Buffer);
+
+        my_sleep(200);
+        return ERR_NONE;
+}
+
+GSM_Protocol_Functions FBUS2Protocol = {
+        FBUS2_WriteMessage,
+        FBUS2_StateMachine,
+        FBUS2_Initialise,
+        FBUS2_Terminate
+};
+
+#endif
+
+/* How should editor hadle tabs in this file? Add editor commands here.
+ * vim: noexpandtab sw=8 ts=8 sts=8:
+ */
diff --git a/gammu/emb/common/protocol/nokia/fbus2.h b/gammu/emb/common/protocol/nokia/fbus2.h
new file mode 100644
index 0000000..5dd45d7
--- a/dev/null
+++ b/gammu/emb/common/protocol/nokia/fbus2.h
@@ -0,0 +1,38 @@
+/* (c) 2002-2003 by Marcin Wiacek */
+/* based on some work from Gnokii and MyGnokii */
+
+#ifndef fbus2_h
+#define fbus2_h
+
+#include "../protocol.h"
+
+        #define FBUS2_FRAME_ID       0x1e
+        #define FBUS2_IRDA_FRAME_ID    0x1c
+        #define FBUS2_DEVICE_PHONE   0x00 /* Nokia mobile phone */
+        #define FBUS2_DEVICE_PC      0x0c /* Our PC */
+        #define FBUS2_ACK_BYTE       0x7f /* Acknowledge of the received frame */
+
+#define FBUS2_MAX_TRANSMIT_LENGTH 120
+
+typedef struct {
+                int             MsgSequenceNumber;
+                int             MsgRXState;
+                int             FramesToGo;
+                GSM_Protocol_MessageMultiMsg;
+                GSM_Protocol_MessageMsg;
+} GSM_Protocol_FBUS2Data;
+
+#ifndef GSM_USED_SERIALDEVICE
+#  define GSM_USED_SERIALDEVICE
+#endif
+#if defined(GSM_ENABLE_BLUEFBUS2)
+#  ifndef GSM_USED_BLUETOOTHDEVICE
+#    define GSM_USED_BLUETOOTHDEVICE
+#  endif
+#endif
+
+#endif
+
+/* How should editor hadle tabs in this file? Add editor commands here.
+ * vim: noexpandtab sw=8 ts=8 sts=8:
+ */
diff --git a/gammu/emb/common/protocol/nokia/mbus2.c b/gammu/emb/common/protocol/nokia/mbus2.c
new file mode 100644
index 0000000..f07d6c5
--- a/dev/null
+++ b/gammu/emb/common/protocol/nokia/mbus2.c
@@ -0,0 +1,252 @@
+/* (c) 2001-2003 by Marcin Wiacek */
+/* based on some work from MyGnokii */
+
+#include "../../gsmstate.h"
+
+#ifdef GSM_ENABLE_MBUS2
+
+#include <stdio.h>
+#include <string.h>
+
+#include "../../gsmcomon.h"
+#include "mbus2.h"
+
+        static GSM_Error MBUS2_WriteMessage (GSM_StateMachine *s,
+                                             unsigned char *MsgBuffer,
+                                             int        MsgLength,
+                                             unsigned char MsgType)
+{
+                unsigned char           *buffer2, checksum = 0;
+                GSM_Protocol_MBUS2Data          *d = &s->Protocol.Data.MBUS2;
+                int                     i, sent, len;
+
+        GSM_DumpMessageLevel3(s, MsgBuffer, MsgLength, MsgType);
+
+        buffer2 = (unsigned char *)malloc(MsgLength + 8);
+
+        buffer2[0] = MBUS2_FRAME_ID;
+                buffer2[1] = MBUS2_DEVICE_PHONE;        // destination
+                buffer2[2] = MBUS2_DEVICE_PC;           // source
+        buffer2[3] = MsgType;
+        buffer2[4] = MsgLength / 256;
+        buffer2[5] = MsgLength % 256;
+
+        memcpy(buffer2 + 6, MsgBuffer, MsgLength);
+        len = 6 + MsgLength;
+
+        /* According to http://www.flosys.com/tdma/n5160.html some phones
+         * can have problems with checksum equal 0x1F. Phones can recognize
+         * received frame, but won't send ACK for it. When checksum is 0x1F,
+         * we increment the sequence number
+         */
+        do {
+                d->MsgSequenceNumber++;
+
+                buffer2[len] = d->MsgSequenceNumber;  
+        
+                /* Calculating checksum */
+                checksum = 0;
+                for (i = 0; i < len + 1; i++) checksum ^= buffer2[i];
+        } while (checksum == 0x1f);
+
+        buffer2[len++] = d->MsgSequenceNumber;  
+        buffer2[len++] = checksum;
+
+        GSM_DumpMessageLevel2(s, buffer2+6, MsgLength, MsgType);
+
+        /* Sending to phone */
+        my_sleep(10);
+        sent=s->Device.Functions->WriteDevice(s,buffer2,len);
+
+        free(buffer2);
+
+        if (sent!=len) return ERR_DEVICEWRITEERROR;
+        return ERR_NONE;
+}
+
+        static GSM_Error MBUS2_SendAck(GSM_StateMachine *s,
+                                       unsigned char    type,
+                                       unsigned char    sequence)
+{
+                GSM_Device_Functions    *Device         = s->Device.Functions;
+                unsigned char   buffer2[6];
+                int             i;
+
+        buffer2[0] = MBUS2_FRAME_ID;
+                buffer2[1] = MBUS2_DEVICE_PHONE;//destination
+                buffer2[2] = MBUS2_DEVICE_PC;   //source
+        buffer2[3] = MBUS2_ACK_BYTE;
+        buffer2[4] = sequence;
+        buffer2[5] = 0;
+
+        /* Calculating checksum */
+        for (i = 0; i < 5; i++) buffer2[5] ^= buffer2[i];
+
+        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL ||
+            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE) {
+                smprintf(s,"[Sending Ack of type %02x, seq: %x]\n",type,sequence);
+        }
+
+        /* Sending to phone */
+        my_sleep(10);
+        if (Device->WriteDevice(s,buffer2,6)!=6) return ERR_DEVICEWRITEERROR;
+
+        return ERR_NONE;
+}
+
+static GSM_Error MBUS2_StateMachine(GSM_StateMachine *s, unsigned char rx_char)
+{
+                GSM_Phone_Functions     *Phone= s->Phone.Functions;
+                GSM_Protocol_MBUS2Data          *d= &s->Protocol.Data.MBUS2;
+
+        d->Msg.CheckSum[0] = d->Msg.CheckSum[1];
+        d->Msg.CheckSum[1] ^= rx_char;
+
+        if (d->MsgRXState == RX_GetMessage) {
+                d->Msg.Buffer[d->Msg.Count] = rx_char;
+                d->Msg.Count++;
+
+                /* This is not last byte in frame */
+                if (d->Msg.Count != d->Msg.Length+2) return ERR_NONE;
+
+                /* Checksum is incorrect */
+                if (d->Msg.CheckSum[0] != rx_char) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s,"[ERROR: checksum]\n");
+                        }
+
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+
+                if (d->Msg.Destination != MBUS2_DEVICE_PHONE) {
+                        MBUS2_SendAck(s, d->Msg.Type, d->Msg.Buffer[d->Msg.Count-2]);
+                                s->Phone.Data.RequestMsg= &d->Msg;
+                                s->Phone.Data.DispatchError= Phone->DispatchMessage(s);
+                }
+
+                d->MsgRXState = RX_Sync;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetLength2) {
+                if (d->Msg.Type == MBUS2_ACK_BYTE) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE) {
+                                smprintf(s,"[Received Ack]\n");
+                        }
+
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+
+                d->Msg.Length = d->Msg.Length + rx_char;
+                if (d->Msg.BufferUsed < d->Msg.Length+2) {
+                                d->Msg.BufferUsed = d->Msg.Length+2;
+                                d->Msg.Buffer   = (unsigned char *)realloc(d->Msg.Buffer,d->Msg.BufferUsed);
+                }
+
+                d->MsgRXState = RX_GetMessage;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetLength1) {
+                d->Msg.Length = rx_char * 256;
+
+                d->MsgRXState = RX_GetLength2;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetType) {
+                d->Msg.Type   = rx_char;
+
+                d->MsgRXState = RX_GetLength1;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetSource) {
+                if (rx_char != MBUS2_DEVICE_PHONE && rx_char != MBUS2_DEVICE_PC) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s,"[ERROR: incorrect char - %02x, not %02x and %02x]\n", rx_char, MBUS2_DEVICE_PHONE, MBUS2_DEVICE_PC);
+                        }
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+                d->Msg.Source = rx_char;
+
+                d->MsgRXState = RX_GetType;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_GetDestination) {
+                if (rx_char != MBUS2_DEVICE_PC && rx_char != MBUS2_DEVICE_PHONE) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s,"[ERROR: incorrect char - %02x, not %02x and %02x]\n", rx_char, MBUS2_DEVICE_PHONE, MBUS2_DEVICE_PC);
+                        }
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+                        d->Msg.Destination = rx_char;
+
+                        d->MsgRXState   = RX_GetSource;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState == RX_Sync) {
+                if (rx_char != MBUS2_FRAME_ID) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s,"[ERROR: incorrect char - %02x, not %02x]\n", rx_char, MBUS2_FRAME_ID);
+                        }
+                        return ERR_NONE;
+                }
+                        d->Msg.CheckSum[1] = MBUS2_FRAME_ID;
+                        d->Msg.Count    = 0;
+
+                        d->MsgRXState   = RX_GetDestination;
+                return ERR_NONE;
+        }
+        return ERR_NONE;
+}
+
+static GSM_Error MBUS2_Initialise(GSM_StateMachine *s)
+{
+                GSM_Device_Functions    *Device= s->Device.Functions;
+                GSM_Protocol_MBUS2Data          *d= &s->Protocol.Data.MBUS2;
+                GSM_Error       error;
+
+                d->Msg.Length   = 0;
+                d->Msg.BufferUsed= 0;
+                d->Msg.Buffer   = NULL;
+
+                d->MsgSequenceNumber= 0;
+                d->MsgRXState   = RX_Sync;
+
+        error=Device->DeviceSetSpeed(s,9600);
+        if (error!=ERR_NONE) return error;
+
+        error=Device->DeviceSetParity(s,true);
+        if (error!=ERR_NONE) return error;
+
+        error=Device->DeviceSetDtrRts(s,false,true); /*DTR low,RTS high*/
+        if (error!=ERR_NONE) return error; 
+        my_sleep(200);
+
+        return ERR_NONE;
+}
+
+static GSM_Error MBUS2_Terminate(GSM_StateMachine *s)
+{
+        free(s->Protocol.Data.MBUS2.Msg.Buffer);
+        return ERR_NONE;
+}
+
+GSM_Protocol_Functions MBUS2Protocol = {
+        MBUS2_WriteMessage,
+        MBUS2_StateMachine,
+        MBUS2_Initialise,
+        MBUS2_Terminate
+};
+
+#endif
+
+/* How should editor hadle tabs in this file? Add editor commands here.
+ * vim: noexpandtab sw=8 ts=8 sts=8:
+ */
diff --git a/gammu/emb/common/protocol/nokia/mbus2.h b/gammu/emb/common/protocol/nokia/mbus2.h
new file mode 100644
index 0000000..86fcab6
--- a/dev/null
+++ b/gammu/emb/common/protocol/nokia/mbus2.h
@@ -0,0 +1,28 @@
+/* (c) 2001-2003 by Marcin Wiacek */
+/* based on some work from MyGnokii */
+
+#ifndef mbus2_h
+#define mbus2_h
+
+#include "../protocol.h"
+
+#define MBUS2_FRAME_ID       0x1f
+#define MBUS2_DEVICE_PHONE   0x00 /* Nokia mobile phone */
+#define MBUS2_DEVICE_PC      0x10 /* Our PC (MBUS) */
+        #define MBUS2_ACK_BYTE     0x7f /* Acknowledge of the received frame */
+
+typedef struct {
+                int             MsgSequenceNumber;
+                int             MsgRXState;
+                GSM_Protocol_MessageMsg;
+} GSM_Protocol_MBUS2Data;
+
+#ifndef GSM_USED_SERIALDEVICE
+#  define GSM_USED_SERIALDEVICE
+#endif
+
+#endif
+
+/* How should editor hadle tabs in this file? Add editor commands here.
+ * vim: noexpandtab sw=8 ts=8 sts=8:
+ */
diff --git a/gammu/emb/common/protocol/nokia/phonet.c b/gammu/emb/common/protocol/nokia/phonet.c
new file mode 100644
index 0000000..bc5717d
--- a/dev/null
+++ b/gammu/emb/common/protocol/nokia/phonet.c
@@ -0,0 +1,217 @@
+/* (c) 2002-2003 by Marcin Wiacek */
+/* based on some work from Gnokii */
+
+#include "../../gsmstate.h"
+
+#if defined(GSM_ENABLE_IRDA) || defined(GSM_ENABLE_PHONETBLUE) || defined(GSM_ENABLE_BLUEPHONET)
+
+#include <stdio.h>
+#include <string.h>
+
+#include "../../gsmcomon.h"
+#include "phonet.h"
+
+        static GSM_Error PHONET_WriteMessage (GSM_StateMachine *s,
+                                              unsigned char *MsgBuffer,
+                                              int       MsgLength,
+                                              unsigned char MsgType)
+{
+                unsigned char   *buffer2; 
+                int             sent;
+
+        GSM_DumpMessageLevel3(s, MsgBuffer, MsgLength, MsgType);
+
+        buffer2 = (unsigned char *)malloc(MsgLength + 6);
+
+        buffer2[0] = PHONET_FRAME_ID,
+                buffer2[1] = PHONET_DEVICE_PHONE;       //destination
+                buffer2[2] = PHONET_DEVICE_PC;          //source
+        
+        if (s->ConnectionType==GCT_PHONETBLUE || s->ConnectionType==GCT_BLUEPHONET) {
+                buffer2[0] = PHONET_BLUE_FRAME_ID;
+                        buffer2[1] = PHONET_DEVICE_PHONE;//destination
+                        buffer2[2] = PHONET_BLUE_DEVICE_PC;//source
+        }
+
+        buffer2[3] = MsgType;
+        buffer2[4] = MsgLength / 256;
+        buffer2[5] = MsgLength % 256;
+
+        memcpy(buffer2 + 6, MsgBuffer, MsgLength);
+
+        GSM_DumpMessageLevel2(s, buffer2+6, MsgLength, MsgType);
+
+        /* Sending to phone */
+        sent = s->Device.Functions->WriteDevice(s,buffer2,MsgLength+6);
+
+        free(buffer2);
+
+        if (sent!=MsgLength+6) return ERR_DEVICEWRITEERROR;
+        return ERR_NONE;
+}
+
+static GSM_Error PHONET_StateMachine(GSM_StateMachine *s, unsigned char rx_char)
+{
+                GSM_Protocol_PHONETData *d = &s->Protocol.Data.PHONET;
+                bool                    correct = false;
+
+        if (d->MsgRXState==RX_GetMessage) {
+                d->Msg.Buffer[d->Msg.Count] = rx_char;
+                d->Msg.Count++;
+
+                /* This is not last byte in frame */
+                if (d->Msg.Count != d->Msg.Length) return ERR_NONE;
+
+                        s->Phone.Data.RequestMsg= &d->Msg;
+                        s->Phone.Data.DispatchError= s->Phone.Functions->DispatchMessage(s);
+
+                free(d->Msg.Buffer);
+                        d->Msg.Length           = 0;
+                        d->Msg.Buffer           = NULL;
+
+                        d->MsgRXState           = RX_Sync;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState==RX_GetLength2) {
+                        d->Msg.Length = d->Msg.Length + rx_char;
+                        d->Msg.Buffer = (unsigned char *)malloc(d->Msg.Length);
+
+                        d->MsgRXState = RX_GetMessage;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState==RX_GetLength1) {
+                d->Msg.Length = rx_char * 256;
+
+                d->MsgRXState = RX_GetLength2;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState==RX_GetType) {
+                d->Msg.Type   = rx_char;
+
+                d->MsgRXState = RX_GetLength1;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState==RX_GetSource) {
+                if (rx_char != PHONET_DEVICE_PHONE) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s,"[ERROR: incorrect char - %02x, not %02x]\n", rx_char, PHONET_DEVICE_PHONE);
+                        }
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+                d->Msg.Source = rx_char;
+
+                d->MsgRXState = RX_GetType;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState==RX_GetDestination) {
+                switch (s->ConnectionType) {
+                case GCT_IRDAPHONET:
+                        if (rx_char == PHONET_DEVICE_PC) correct = true;
+                        break;
+                case GCT_PHONETBLUE:
+                case GCT_BLUEPHONET:
+                        if (rx_char == PHONET_BLUE_DEVICE_PC) correct = true;
+                        break;
+                default:
+                        break;
+                }
+                if (!correct) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s,"[ERROR: incorrect char - %02x, not %02x]\n", rx_char, PHONET_DEVICE_PC);
+                        }
+                        d->MsgRXState = RX_Sync;
+                        return ERR_NONE;
+                }
+                        d->Msg.Destination = rx_char;
+
+                        d->MsgRXState   = RX_GetSource;
+                return ERR_NONE;
+        }
+        if (d->MsgRXState==RX_Sync) {
+                switch (s->ConnectionType) {
+                case GCT_IRDAPHONET:
+                        if (rx_char == PHONET_FRAME_ID) correct = true;
+                        break;
+                case GCT_PHONETBLUE:
+                case GCT_BLUEPHONET:
+                        if (rx_char == PHONET_BLUE_FRAME_ID) correct = true;
+                        break;
+                default:
+                        break;
+                }
+                if (!correct) {
+                        if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
+                            s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
+                                smprintf(s,"[ERROR: incorrect char - %02x, not %02x]\n", rx_char, PHONET_FRAME_ID);
+                                }       
+                        return ERR_NONE;
+                }
+                d->Msg.Count  = 0;
+
+                        d->MsgRXState = RX_GetDestination;
+                return ERR_NONE;
+        }
+        return ERR_NONE;
+}
+
+static GSM_Error PHONET_Initialise(GSM_StateMachine *s)
+{
+                int                     total = 0, i, n;
+                GSM_Protocol_PHONETData *d = &s->Protocol.Data.PHONET;
+                unsigned char           req[50];
+
+                d->Msg.Length= 0;
+                d->Msg.Buffer= NULL;
+                d->MsgRXState= RX_Sync;
+
+        if (s->ConnectionType == GCT_PHONETBLUE || s->ConnectionType == GCT_BLUEPHONET) {
+                /* Send frame in PHONET style */
+                req[0] = PHONET_BLUE_FRAME_ID;  req[1] = PHONET_DEVICE_PHONE;
+                req[2] = PHONET_BLUE_DEVICE_PC; req[3] = 0xD0;
+                        req[4] = 0x00;          req[5] = 0x01;
+                req[6] = 0x04;
+                if (s->Device.Functions->WriteDevice(s,req,7) != 7) return ERR_DEVICEWRITEERROR;
+
+                while (total < 7) {
+                        n = s->Device.Functions->ReadDevice(s, req + total, 50 - total);
+                        total += n;
+                }
+
+                /* Answer frame in PHONET style */
+                req[10] = PHONET_BLUE_FRAME_ID; req[11] = PHONET_BLUE_DEVICE_PC;
+                        req[12] = PHONET_DEVICE_PHONE;req[13] = 0xD0;
+                        req[14] = 0x00;                 req[15] = 0x01;
+                req[16] = 0x05;
+
+                for (i = 0; i < 7; i++) {
+                        if (req[i] != req[10+i]) {
+                                smprintf(s,"Incorrect byte in the answer\n");
+                                return ERR_UNKNOWN;
+                        }
+                }
+        }
+
+        return ERR_NONE;
+}
+
+static GSM_Error PHONET_Terminate(GSM_StateMachine *s)
+{
+        free(s->Protocol.Data.PHONET.Msg.Buffer);
+        return ERR_NONE;
+}
+
+GSM_Protocol_Functions PHONETProtocol = {
+        PHONET_WriteMessage,
+        PHONET_StateMachine,
+        PHONET_Initialise,
+        PHONET_Terminate
+};
+
+#endif
+
+/* How should editor hadle tabs in this file? Add editor commands here.
+ * vim: noexpandtab sw=8 ts=8 sts=8:
+ */
diff --git a/gammu/emb/common/protocol/nokia/phonet.h b/gammu/emb/common/protocol/nokia/phonet.h
new file mode 100644
index 0000000..2f6e836
--- a/dev/null
+++ b/gammu/emb/common/protocol/nokia/phonet.h
@@ -0,0 +1,35 @@
+/* (c) 2002-2003 by Marcin Wiacek */
+/* based on some work from Gnokii */
+
+#ifndef PHONET_h
+#define PHONET_h
+
+#include "../protocol.h"
+
+        #define PHONET_FRAME_ID      0x14
+        #define PHONET_BLUE_FRAME_ID0x19
+        #define PHONET_DEVICE_PHONE   0x00 /* Nokia mobile phone */
+        #define PHONET_DEVICE_PC      0x0c /* Our PC */
+#define PHONET_BLUE_DEVICE_PC   0x10 /* Our PC */
+
+typedef struct {
+                int             MsgRXState;
+                GSM_Protocol_MessageMsg;
+} GSM_Protocol_PHONETData;
+
+#if defined(GSM_ENABLE_IRDAPHONET)
+#  ifndef GSM_USED_IRDADEVICE
+#    define GSM_USED_IRDADEVICE
+#  endif
+#endif
+#if defined(GSM_ENABLE_BLUEPHONET)
+#  ifndef GSM_USED_BLUETOOTHDEVICE
+#    define GSM_USED_BLUETOOTHDEVICE
+#  endif
+#endif
+
+#endif
+
+/* How should editor hadle tabs in this file? Add editor commands here.
+ * vim: noexpandtab sw=8 ts=8 sts=8:
+ */