Attachment #1403 for bug #9161

View | Details | Raw Unified | Return to bug 9161
Collapse All | Expand All




		i->state = FBUS_RX_GetMessage;
		i->buffer_count = 0;

		if (i->message_buffer)
			free(i->message_buffer);

		if ((i->message_buffer = malloc(i->message_length)) == NULL) {
			dprintf("PHONET: Not enough memory for message buffer\n");
			i->state = FBUS_RX_Sync;
			break;
		}

		break;

	case FBUS_RX_GetMessage:

		i->message_buffer[i->buffer_count] = rx_byte;
		i->buffer_count++;

		if (i->buffer_count > PHONET_FRAME_MAX_LENGTH) {
			dprintf("PHONET: Message buffer overun - resetting\n");
			i->state = FBUS_RX_Sync;
			break;
		}

		/* Is that it? */

		if (i->buffer_count == i->message_length) {

static gn_error phonet_send_message(unsigned int messagesize, unsigned char messagetype, unsigned char *message, struct gn_statemachine *state)
{

	u8 *out_buffer;
	int current = 0;
	int total, sent;

	if (!state)
		return GN_ERR_FAILED;

	if ((out_buffer = malloc(messagesize + 6)) == NULL)
		return GN_ERR_MEMORYFULL;

	/* Now construct the message header. */


		else current += sent;
	} while (current < total);

	free(out_buffer);

	sm_incoming_acknowledge(state);

	return GN_ERR_NONE;




/*

  $Id: fbus-phonet.c,v 1.40 2005/04/20 20:43:32 pkot Exp $

  G N O K I I

  A Linux/Unix toolset and driver for the mobile phones.

  This file is part of gnokii.

  Gnokii is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  Gnokii is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with gnokii; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  Copyright (C) 1999-2000 Hugh Blemings & Pavel Janík ml.
  Copyright (C) 2000-2001 Chris Kemp
  Copyright (C) 2001-2004 Pawel Kot
  Copyright (C) 2001      Manfred Jonsson, Martin Jancar
  Copyright (C) 2002      Ladis Michl
  Copyright (C) 2002-2003 BORBELY Zoltan

  This file provides an API for accessing functions via fbus over irda.
  See README for more details on supported mobile phones.

  The various routines are called phonet_(whatever).

*/


/* System header files */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/* Various header file */
#include "config.h"
#include "compat.h"
#include "misc.h"
#include "gnokii.h"
#include "device.h"
#include "links/fbus-phonet.h"
#include "links/fbus.h"
#include "gnokii-internal.h"

static void phonet_rx_statemachine(unsigned char rx_byte, struct gn_statemachine *state);
static gn_error phonet_send_message(unsigned int messagesize, unsigned char messagetype, unsigned char *message, struct gn_statemachine *state);


#define FBUSINST(s) (*((phonet_incoming_message **)(&(s)->link.link_instance)))

#define FBUS_PHONET_BLUETOOTH_INITSEQ 0xd0, 0x00, 0x01

/*--------------------------------------------*/

static bool phonet_open(struct gn_statemachine *state)
{
	int result, i, n, total = 0;
	unsigned char init_sequence[] = { FBUS_PHONET_BLUETOOTH_FRAME_ID,
					  FBUS_DEVICE_PHONE,
					  FBUS_PHONET_BLUETOOTH_DEVICE_PC,
					  FBUS_PHONET_BLUETOOTH_INITSEQ,
					  0x04};
	unsigned char init_resp[7];
	unsigned char init_pattern[7] = { FBUS_PHONET_BLUETOOTH_FRAME_ID,
					 FBUS_PHONET_BLUETOOTH_DEVICE_PC,
					 FBUS_DEVICE_PHONE,
					 FBUS_PHONET_BLUETOOTH_INITSEQ,
					 0x05};

	if (!state)
		return false;

	memset(&init_resp, 0, 7);

	/* Open device. */
	result = device_open(state->config.port_device, false, false, false,
			     state->config.connection_type, state);

	if (!result) {
		perror(_("Couldn't open PHONET device"));
		return false;
	}

	if (state->config.connection_type == GN_CT_Bluetooth) {
		device_write(&init_sequence, 7, state);
		while (total < 7) {
			n = device_read(&init_resp + total, 7 - total, state);
			total += n;
		}
		for (i = 0; i < n; i++) {
			if (init_resp[i] != init_pattern[i]) {
				dprintf("Incorrect byte in the answer\n");
				return false;
			}
		}
	}

	return true;
}

/* RX_State machine for receive handling.  Called once for each character
   received from the phone. */
static void phonet_rx_statemachine(unsigned char rx_byte, struct gn_statemachine *state)
{
	phonet_incoming_message *i = FBUSINST(state);

	/* FIXME: perhaps we should return something here */
	if (!i)
		return;

	switch (i->state) {
	case FBUS_RX_Sync:
		if (rx_byte == FBUS_PHONET_FRAME_ID ||
		    rx_byte == FBUS_PHONET_BLUETOOTH_FRAME_ID ||
		    rx_byte == FBUS_PHONET_DKU2_FRAME_ID) {
			i->state = FBUS_RX_GetDestination;
		}
		break;

	case FBUS_RX_GetDestination:

		i->message_destination = rx_byte;
		i->state = FBUS_RX_GetSource;

		if (rx_byte != FBUS_DEVICE_PC &&
		    rx_byte != FBUS_PHONET_DKU2_DEVICE_PC &&
		    rx_byte != FBUS_PHONET_BLUETOOTH_DEVICE_PC) {
			i->state = FBUS_RX_Sync;
			dprintf("The fbus stream is out of sync - expected 0x0c, got 0x%02x\n", rx_byte);
		}
		break;

	case FBUS_RX_GetSource:

		i->message_source = rx_byte;
		i->state = FBUS_RX_GetType;

		if (rx_byte != FBUS_DEVICE_PHONE) {
			i->state = FBUS_RX_Sync;
			dprintf("The fbus stream is out of sync - expected 0x00, got 0x%02x\n", rx_byte);
		}

		break;

	case FBUS_RX_GetType:

		i->message_type = rx_byte;
		i->state = FBUS_RX_GetLength1;

		break;

	case FBUS_RX_GetLength1:

		i->message_length = rx_byte << 8;
		i->state = FBUS_RX_GetLength2;

		break;

	case FBUS_RX_GetLength2:

		i->message_length = i->message_length + rx_byte;
		i->state = FBUS_RX_GetMessage;
		i->buffer_count = 0;

		break;

	case FBUS_RX_GetMessage:

		i->message_buffer[i->buffer_count] = rx_byte;
		i->buffer_count++;

		if (i->buffer_count > PHONET_FRAME_MAX_LENGTH) {
			dprintf("PHONET: Message buffer overun - resetting\n");
			i->state = FBUS_RX_Sync;
			break;
		}

		/* Is that it? */

		if (i->buffer_count == i->message_length) {
			sm_incoming_function(i->message_type, i->message_buffer, i->message_length, state);
			i->state = FBUS_RX_Sync;
		}
		break;
	default:
		i->state = FBUS_RX_Sync;
		break;
	}
}


/* This is the main loop function which must be called regularly */
/* timeout can be used to make it 'busy' or not */

static gn_error phonet_loop(struct timeval *timeout, struct gn_statemachine *state)
{
	gn_error	error = GN_ERR_INTERNALERROR;
	unsigned char	buffer[255];
	int		count, res;

	res = device_select(timeout, state);

	if (res > 0) {
		res = device_read(buffer, 255, state);
		for (count = 0; count < res; count++) {
			phonet_rx_statemachine(buffer[count], state);
		}
		if (res > 0) {
			error = GN_ERR_NONE;	/* This traps errors from device_read */
		}
	} else if (!res) {
		error = GN_ERR_TIMEOUT;
	}

	return error;
}

/* Main function to send an fbus message */

static gn_error phonet_send_message(unsigned int messagesize, unsigned char messagetype, unsigned char *message, struct gn_statemachine *state)
{

	u8 out_buffer[PHONET_TRANSMIT_MAX_LENGTH + 5];
	int current = 0;
	int total, sent;

	if (!state)
		return GN_ERR_FAILED;

	/* FIXME - we should check for the message length ... */

	/* Now construct the message header. */

	if (state->config.connection_type == GN_CT_Bluetooth) {
		out_buffer[current++] = FBUS_PHONET_BLUETOOTH_FRAME_ID;
		out_buffer[current++] = FBUS_DEVICE_PHONE;
		out_buffer[current++] = FBUS_PHONET_BLUETOOTH_DEVICE_PC;
	} else if (state->config.connection_type == GN_CT_DKU2) {
		out_buffer[current++] = FBUS_PHONET_DKU2_FRAME_ID;
		out_buffer[current++] = FBUS_DEVICE_PHONE;
		out_buffer[current++] = FBUS_PHONET_DKU2_DEVICE_PC;
	} else {
		out_buffer[current++] = FBUS_PHONET_FRAME_ID;
		out_buffer[current++] = FBUS_DEVICE_PHONE; /* Destination */
		out_buffer[current++] = FBUS_DEVICE_PC;    /* Source */
	}

	out_buffer[current++] = messagetype; /* Type */

	out_buffer[current++] = (messagesize & 0xff00) >> 8;
	out_buffer[current++] = (messagesize & 0x00ff);

	/* Copy in data if any. */

	if (messagesize > 0) {
		memcpy(out_buffer + current, message, messagesize);
		current += messagesize;
	}

	/* Send it out... */

	total = current;
	current = 0;
	sent = 0;

	do {
		sent = device_write(out_buffer + current, total - current, state);
		if (sent < 0) return GN_ERR_FAILED;
		else current += sent;
	} while (current < total);

	sm_incoming_acknowledge(state);

	return GN_ERR_NONE;
}

/* Initialise variables and start the link */
gn_error phonet_initialise(struct gn_statemachine *state)
{
	gn_error error = GN_ERR_FAILED;

	if (!state)
		return error;

	/* Fill in the link functions */
	state->link.loop = &phonet_loop;
	state->link.send_message = &phonet_send_message;

	if ((FBUSINST(state) = calloc(1, sizeof(phonet_incoming_message))) == NULL)
		return GN_ERR_MEMORYFULL;

	switch (state->config.connection_type) {
	case GN_CT_Infrared:
	case GN_CT_Irda:
	case GN_CT_DKU2:
	case GN_CT_Bluetooth:
		if (phonet_open(state) == true)
			error = GN_ERR_NONE;
		break;
	default:
		break;
	}
	if (error != GN_ERR_NONE) {
		free(FBUSINST(state));
		FBUSINST(state) = NULL;
		return error;
	}

	/* Init variables */
	FBUSINST(state)->state = FBUS_RX_Sync;
	FBUSINST(state)->buffer_count = 0;

	return error;
}

Lines 63-69 Link Here

(-)gnokii-0.6.11-orig/include/links/fbus-phonet.h (-1 / +1 lines)
63	int message_destination;	63	int message_destination;
64	int message_type;	64	int message_type;
65	int message_length;	65	int message_length;
66	char message_buffer[PHONET_FRAME_MAX_LENGTH];	66	char *message_buffer;
67	} phonet_incoming_message;	67	} phonet_incoming_message;
68		68
69	#endif /* #ifndef _gnokii_links_fbus_phonet_h */	69	#endif /* #ifndef _gnokii_links_fbus_phonet_h */

Return to bug 9161

Lines 172-177 Link Here

(-)gnokii-0.6.11-orig/common/links/fbus-phonet.c (-8 / +14 lines)
172	i->state = FBUS_RX_GetMessage;	172	i->state = FBUS_RX_GetMessage;
173	i->buffer_count = 0;	173	i->buffer_count = 0;
174		174
		175	if (i->message_buffer)
		176	free(i->message_buffer);
		177
		178	if ((i->message_buffer = malloc(i->message_length)) == NULL) {
		179	dprintf("PHONET: Not enough memory for message buffer\n");
		180	i->state = FBUS_RX_Sync;
		181	break;
		182	}
		183
175	break;	184	break;
176		185
177	case FBUS_RX_GetMessage:	186	case FBUS_RX_GetMessage:
Lines 179-190 Link Here
179	i->message_buffer[i->buffer_count] = rx_byte;	188	i->message_buffer[i->buffer_count] = rx_byte;
180	i->buffer_count++;	189	i->buffer_count++;
181		190
182	if (i->buffer_count > PHONET_FRAME_MAX_LENGTH) {
183	dprintf("PHONET: Message buffer overun - resetting\n");
184	i->state = FBUS_RX_Sync;
185	break;
186	}
187
188	/* Is that it? */	191	/* Is that it? */
189		192
190	if (i->buffer_count == i->message_length) {	193	if (i->buffer_count == i->message_length) {
Lines 230-243 Link Here
230	static gn_error phonet_send_message(unsigned int messagesize, unsigned char messagetype, unsigned char message, struct gn_statemachine state)	233	static gn_error phonet_send_message(unsigned int messagesize, unsigned char messagetype, unsigned char message, struct gn_statemachine state)
231	{	234	{
232		235
233	u8 out_buffer[PHONET_TRANSMIT_MAX_LENGTH + 5];	236	u8 *out_buffer;
234	int current = 0;	237	int current = 0;
235	int total, sent;	238	int total, sent;
236		239
237	if (!state)	240	if (!state)
238	return GN_ERR_FAILED;	241	return GN_ERR_FAILED;
239		242
240	/* FIXME - we should check for the message length ... */	243	if ((out_buffer = malloc(messagesize + 6)) == NULL)
		244	return GN_ERR_MEMORYFULL;
241		245
242	/* Now construct the message header. */	246	/* Now construct the message header. */
243		247
Lines 279-284 Link Here
279	else current += sent;	283	else current += sent;
280	} while (current < total);	284	} while (current < total);
281		285
		286	free(out_buffer);
		287
282	sm_incoming_acknowledge(state);	288	sm_incoming_acknowledge(state);
283		289
284	return GN_ERR_NONE;	290	return GN_ERR_NONE;

Line 0 Link Here

(-)gnokii-0.6.11-orig/common/links/fbus-phonet.c.orig (+324 lines)
		1	/*
		2
		3	$Id: fbus-phonet.c,v 1.40 2005/04/20 20:43:32 pkot Exp $
		4
		5	G N O K I I
		6
		7	A Linux/Unix toolset and driver for the mobile phones.
		8
		9	This file is part of gnokii.
		10
		11	Gnokii is free software; you can redistribute it and/or modify
		12	it under the terms of the GNU General Public License as published by
		13	the Free Software Foundation; either version 2 of the License, or
		14	(at your option) any later version.
		15
		16	Gnokii is distributed in the hope that it will be useful,
		17	but WITHOUT ANY WARRANTY; without even the implied warranty of
		18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		19	GNU General Public License for more details.
		20
		21	You should have received a copy of the GNU General Public License
		22	along with gnokii; if not, write to the Free Software
		23	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		24
		25	Copyright (C) 1999-2000 Hugh Blemings & Pavel Janík ml.
		26	Copyright (C) 2000-2001 Chris Kemp
		27	Copyright (C) 2001-2004 Pawel Kot
		28	Copyright (C) 2001 Manfred Jonsson, Martin Jancar
		29	Copyright (C) 2002 Ladis Michl
		30	Copyright (C) 2002-2003 BORBELY Zoltan
		31
		32	This file provides an API for accessing functions via fbus over irda.
		33	See README for more details on supported mobile phones.
		34
		35	The various routines are called phonet_(whatever).
		36
		37	*/
		38
		39
		40	/* System header files */
		41	#include <stdio.h>
		42	#include <string.h>
		43	#include <stdlib.h>
		44
		45	/* Various header file */
		46	#include "config.h"
		47	#include "compat.h"
		48	#include "misc.h"
		49	#include "gnokii.h"
		50	#include "device.h"
		51	#include "links/fbus-phonet.h"
		52	#include "links/fbus.h"
		53	#include "gnokii-internal.h"
		54
		55	static void phonet_rx_statemachine(unsigned char rx_byte, struct gn_statemachine *state);
		56	static gn_error phonet_send_message(unsigned int messagesize, unsigned char messagetype, unsigned char message, struct gn_statemachine state);
		57
		58
		59	#define FBUSINST(s) (((phonet_incoming_message *)(&(s)->link.link_instance)))
		60
		61	#define FBUS_PHONET_BLUETOOTH_INITSEQ 0xd0, 0x00, 0x01
		62
		63	/--------------------------------------------/
		64
65	static bool phonet_open(struct gn_statemachine *state)
66	{
67	int result, i, n, total = 0;
68	unsigned char init_sequence[] = { FBUS_PHONET_BLUETOOTH_FRAME_ID,
69	FBUS_DEVICE_PHONE,
70	FBUS_PHONET_BLUETOOTH_DEVICE_PC,
71	FBUS_PHONET_BLUETOOTH_INITSEQ,
72	0x04};
73	unsigned char init_resp[7];
74	unsigned char init_pattern[7] = { FBUS_PHONET_BLUETOOTH_FRAME_ID,
75	FBUS_PHONET_BLUETOOTH_DEVICE_PC,
76	FBUS_DEVICE_PHONE,
77	FBUS_PHONET_BLUETOOTH_INITSEQ,
78	0x05};
79
80	if (!state)
81	return false;
82
83	memset(&init_resp, 0, 7);
84
85	/* Open device. */
86	result = device_open(state->config.port_device, false, false, false,
87	state->config.connection_type, state);
88
89	if (!result) {
90	perror(_("Couldn't open PHONET device"));
91	return false;
92	}
93
94	if (state->config.connection_type == GN_CT_Bluetooth) {
95	device_write(&init_sequence, 7, state);
96	while (total < 7) {
97	n = device_read(&init_resp + total, 7 - total, state);
98	total += n;
99	}
100	for (i = 0; i < n; i++) {
101	if (init_resp[i] != init_pattern[i]) {
102	dprintf("Incorrect byte in the answer\n");
103	return false;
104	}
105	}
106	}
107
108	return true;
109	}
110
111	/* RX_State machine for receive handling. Called once for each character
112	received from the phone. */
113	static void phonet_rx_statemachine(unsigned char rx_byte, struct gn_statemachine *state)
114	{
115	phonet_incoming_message *i = FBUSINST(state);
116
117	/* FIXME: perhaps we should return something here */
118	if (!i)
119	return;
120
121	switch (i->state) {
122	case FBUS_RX_Sync:
123	if (rx_byte == FBUS_PHONET_FRAME_ID \|\|
124	rx_byte == FBUS_PHONET_BLUETOOTH_FRAME_ID \|\|
125	rx_byte == FBUS_PHONET_DKU2_FRAME_ID) {
126	i->state = FBUS_RX_GetDestination;
127	}
128	break;
129
130	case FBUS_RX_GetDestination:
131
132	i->message_destination = rx_byte;
133	i->state = FBUS_RX_GetSource;
134
135	if (rx_byte != FBUS_DEVICE_PC &&
136	rx_byte != FBUS_PHONET_DKU2_DEVICE_PC &&
137	rx_byte != FBUS_PHONET_BLUETOOTH_DEVICE_PC) {
138	i->state = FBUS_RX_Sync;
139	dprintf("The fbus stream is out of sync - expected 0x0c, got 0x%02x\n", rx_byte);
140	}
141	break;
142
143	case FBUS_RX_GetSource:
144
145	i->message_source = rx_byte;
146	i->state = FBUS_RX_GetType;
147
148	if (rx_byte != FBUS_DEVICE_PHONE) {
149	i->state = FBUS_RX_Sync;
150	dprintf("The fbus stream is out of sync - expected 0x00, got 0x%02x\n", rx_byte);
151	}
152
153	break;
154
155	case FBUS_RX_GetType:
156
157	i->message_type = rx_byte;
158	i->state = FBUS_RX_GetLength1;
159
160	break;
161
162	case FBUS_RX_GetLength1:
163
164	i->message_length = rx_byte << 8;
165	i->state = FBUS_RX_GetLength2;
166
167	break;
168
169	case FBUS_RX_GetLength2:
170
171	i->message_length = i->message_length + rx_byte;
172	i->state = FBUS_RX_GetMessage;
173	i->buffer_count = 0;
174
175	break;
176
177	case FBUS_RX_GetMessage:
178
179	i->message_buffer[i->buffer_count] = rx_byte;
180	i->buffer_count++;
181
182	if (i->buffer_count > PHONET_FRAME_MAX_LENGTH) {
183	dprintf("PHONET: Message buffer overun - resetting\n");
184	i->state = FBUS_RX_Sync;
185	break;
186	}
187
188	/* Is that it? */
189
190	if (i->buffer_count == i->message_length) {
191	sm_incoming_function(i->message_type, i->message_buffer, i->message_length, state);
192	i->state = FBUS_RX_Sync;
193	}
194	break;
195	default:
196	i->state = FBUS_RX_Sync;
197	break;
198	}
199	}
200
201
202	/* This is the main loop function which must be called regularly */
203	/* timeout can be used to make it 'busy' or not */
204
205	static gn_error phonet_loop(struct timeval timeout, struct gn_statemachine state)
206	{
207	gn_error error = GN_ERR_INTERNALERROR;
208	unsigned char buffer[255];
209	int count, res;
210
211	res = device_select(timeout, state);
212
213	if (res > 0) {
214	res = device_read(buffer, 255, state);
215	for (count = 0; count < res; count++) {
216	phonet_rx_statemachine(buffer[count], state);
217	}
218	if (res > 0) {
219	error = GN_ERR_NONE; /* This traps errors from device_read */
220	}
221	} else if (!res) {
222	error = GN_ERR_TIMEOUT;
223	}
224
225	return error;
226	}
227
228	/* Main function to send an fbus message */
229
230	static gn_error phonet_send_message(unsigned int messagesize, unsigned char messagetype, unsigned char message, struct gn_statemachine state)
231	{
232
233	u8 out_buffer[PHONET_TRANSMIT_MAX_LENGTH + 5];
234	int current = 0;
235	int total, sent;
236
237	if (!state)
238	return GN_ERR_FAILED;
239
240	/* FIXME - we should check for the message length ... */
241
242	/* Now construct the message header. */
243
244	if (state->config.connection_type == GN_CT_Bluetooth) {
245	out_buffer[current++] = FBUS_PHONET_BLUETOOTH_FRAME_ID;
246	out_buffer[current++] = FBUS_DEVICE_PHONE;
247	out_buffer[current++] = FBUS_PHONET_BLUETOOTH_DEVICE_PC;
248	} else if (state->config.connection_type == GN_CT_DKU2) {
249	out_buffer[current++] = FBUS_PHONET_DKU2_FRAME_ID;
250	out_buffer[current++] = FBUS_DEVICE_PHONE;
251	out_buffer[current++] = FBUS_PHONET_DKU2_DEVICE_PC;
252	} else {
253	out_buffer[current++] = FBUS_PHONET_FRAME_ID;
254	out_buffer[current++] = FBUS_DEVICE_PHONE; /* Destination */
255	out_buffer[current++] = FBUS_DEVICE_PC; /* Source */
256	}
257
258	out_buffer[current++] = messagetype; /* Type */
259
260	out_buffer[current++] = (messagesize & 0xff00) >> 8;
261	out_buffer[current++] = (messagesize & 0x00ff);
262
263	/* Copy in data if any. */
264
265	if (messagesize > 0) {
266	memcpy(out_buffer + current, message, messagesize);
267	current += messagesize;
268	}
269
270	/* Send it out... */
271
272	total = current;
273	current = 0;
274	sent = 0;
275
276	do {
277	sent = device_write(out_buffer + current, total - current, state);
278	if (sent < 0) return GN_ERR_FAILED;
279	else current += sent;
280	} while (current < total);
281
282	sm_incoming_acknowledge(state);
283
284	return GN_ERR_NONE;
285	}
286
287	/* Initialise variables and start the link */
288	gn_error phonet_initialise(struct gn_statemachine *state)
289	{
290	gn_error error = GN_ERR_FAILED;
291
292	if (!state)
293	return error;
294
295	/* Fill in the link functions */
296	state->link.loop = &phonet_loop;
297	state->link.send_message = &phonet_send_message;
298
299	if ((FBUSINST(state) = calloc(1, sizeof(phonet_incoming_message))) == NULL)
300	return GN_ERR_MEMORYFULL;
301
302	switch (state->config.connection_type) {
303	case GN_CT_Infrared:
304	case GN_CT_Irda:
305	case GN_CT_DKU2:
306	case GN_CT_Bluetooth:
307	if (phonet_open(state) == true)
308	error = GN_ERR_NONE;
309	break;
310	default:
311	break;
312	}
313	if (error != GN_ERR_NONE) {
314	free(FBUSINST(state));
315	FBUSINST(state) = NULL;
316	return error;
317	}
318
319	/* Init variables */
320	FBUSINST(state)->state = FBUS_RX_Sync;
321	FBUSINST(state)->buffer_count = 0;
322
323	return error;
324	}