l2cap.c

linux系统下的关于蓝牙模块的源代码！十分的经典的程序！

/*
 * l2cap.c -- Implementation of Bluetooth Logical Link Control 
 *            and Adaption Protocol (L2CAP)          
 *
 * Copyright (C) 2000, 2001  Axis Communications AB
 *
 * Author: Mattias Agren <[e-mail]>
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * Exceptionally, Axis Communications AB grants discretionary and
 * conditional permissions for additional use of the text contained
 * in the company's release of the AXIS OpenBT Stack under the
 * provisions set forth hereunder.
 *
 * Provided that, if you use the AXIS OpenBT Stack with other files,
 * that do not implement functionality as specified in the Bluetooth
 * System specification, to produce an executable, this does not by
 * itself cause the resulting executable to be covered by the GNU
 * General Public License. Your use of that executable is in no way
 * restricted on account of using the AXIS OpenBT Stack code with it.
 *
 * This exception does not however invalidate any other reasons why
 * the executable file might be covered by the provisions of the GNU
 * General Public License.
 *
 * $Id: l2cap.c,v 1.122 2001/10/16 10:51:29 pkj Exp $
 *
 */

/****************** INCLUDE FILES SECTION ***********************************/

#define __NO_VERSION__ /* don't define kernel_version in module.h */

#ifdef __KERNEL__
#include <linux/config.h>
#include <linux/bluetooth/sysdep-2.1.h>
#include <linux/malloc.h>
#include <linux/bluetooth/l2cap.h>
#include <linux/bluetooth/hci.h>
#include <linux/bluetooth/hci_internal.h>
#include <linux/bluetooth/rfcomm.h>
#include <linux/bluetooth/sdp.h>
#include <linux/bluetooth/test.h>
#include <linux/bluetooth/btmem.h>
#include <linux/bluetooth/l2cap_internal.h>
#include <linux/bluetooth/l2cap_con.h>
#include <linux/bluetooth/l2cap_sec.h>
#include <linux/bluetooth/bt_errno.h>
#include <asm/byteorder.h>
#include <asm/unaligned.h>
#else /* user mode */
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <signal.h>
#include <errno.h>
#include <asm/unaligned.h>

#include "include/l2cap.h"
#include "include/hci.h"
#include "include/hci_internal.h"
#include "include/l2cap_internal.h"
#include "include/l2cap_con.h"
#include "include/l2cap_sec.h"
#include "include/rfcomm.h"
#include "include/sdp.h"
#include "include/test.h"
#include "include/btmem.h"
#include "include/local.h"
#include "include/bt_errno.h"
#endif

/****************** DEBUG CONSTANT AND MACRO SECTION ************************/

#if L2CAP_DEBUG_STATE
/* State machine */
#define D_STATE(fmt...) printk(L2CAP_DBG_STR fmt)
#define PRINTSTATE(con) (printk(L2CAP_DBG_STR "Current state of (%d:%d) is %s\n", con->local_cid, con->remote_cid, state_name[con->current_state]))
#else
/* State machine */
#define D_STATE(fmt...)
#define PRINTSTATE(con)
#endif

#if L2CAP_DEBUG_TIMER
#define D_TIM(fmt...) printk(L2CAP_DBG_STR fmt)
#else
#define D_TIM(fmt...)
#endif

#if L2CAP_DEBUG_CON
/* Connection manager */
#define D_CON(fmt...) printk(L2CAP_DBG_STR fmt)

#define SHOW_CON(str, con) show_con(str, con)
#define SHOW_LIST() show_list()
#else
#define D_CON(fmt...)
#define SHOW_CON(str, con)
#define SHOW_LIST()
#endif

#if L2CAP_DEBUG_RCV
/* Receive data */
#define D_RCV(fmt...) printk(L2CAP_DBG_STR fmt)
#else
#define D_RCV(fmt...)
#endif

#if L2CAP_DEBUG_XMIT
/* Send data */
#define D_XMIT(fmt...) printk(L2CAP_DBG_STR fmt)
#else
#define D_XMIT(fmt...)
#endif

#if L2CAP_DEBUG_MISC
/* Misc */
#define D_MISC(fmt...) printk(L2CAP_DBG_STR fmt)
#else
#define D_MISC(fmt...)
#endif

#if L2CAP_DEBUG_DATA
#define PRINTPKT(str, data, len) print_data(str, data, len)
#else
#define PRINTPKT(str, data, len)
#endif

/****************** CONSTANT AND MACRO SECTION ******************************/

#define CON_LESS 0
#define CON_ORIENTED 1

#define MIN_CID 0x0040
#define MAX_CID 0xffff

/* EVEN => REQUEST */ 
#define ISREQUEST(x) (!(x%2))
#define SET_L2CAP_HDR(frame, len, cid) {\
        (*(u8 *)(frame)) = (u8)(((len) & 0xff)); \
        (*(u8 *)(frame + 1)) = (u8)((len) >> 8); \
        (*(u8 *)(frame + 2)) = (u8)(((cid) & 0xff)); \
        (*(u8 *)(frame + 3)) = (u8)((cid) >> 8); \
}

#define ENTERSTATE(con, state) (con->current_state = state)

#define RCID_NOT_SET 0
#define RCID_SET 1

#define CMDREJ_NOTUNDERSTOOD 0x0
#define CMDREJ_MTUEXCEEDED 0x1
#define CMDREJ_INVALIDCID 0x2

#define CONFREQ_NO_OPTIONS 0x11

const u8* psm2str(u16 psm)
{
	switch (psm) {
	case 1:
		return "SDP";
		break;

	case 3:
		return "RFCOMM";
		break;

	case 5:
		return "TCS";
		break;

	case 0x1231:
		return "TEST";
		break;

	case 0x1233:
		return "TEST-2";
		break;

	case 0x4561:
		return "TEST-3";
		break;

	default :
		return "unknown";
	}
}

const u8* cmdrej_reason[] = {
	"Command not understood",
	"Signalling MTU exceeded",
	"Invalid CID in request",
};

/****************** TYPE DEFINITION SECTION *********************************/

/****************** LOCAL FUNCTION DECLARATION SECTION **********************/

/* MISC */
static u8 set_id(l2cap_con* con);
static u8 get_id(void);
static s32 id_matched(l2cap_con* con, u8 rcv_id);

static s32 parse_options(l2cap_con* con, u8 *data, u32 len);
static void print_flow(flow *f);
static s32 l2cap_cmdrej(s32 hci_hdl, u8 reason, u8 *opt_data, s32 opt_len);

static s32 insert_upper(protocol_layer *upper_layer);
static protocol_layer* get_upper(u32 psm);
static void remove_all_upper(void);

#ifdef CONFIG_BLUETOOTH_L2CAP_USE_TIMERS

/* fixme -- calculate this using flush timeout */
#define MAX_NO_RTX 3
#define RTX_TIMEOUT 2 /* sec */
#define ERTX_TIMEOUT 60 /* sec */


#ifdef __KERNEL__
static void l2cap_rtx_timeout(unsigned long ptr);
static void l2cap_ertx_timeout(unsigned long ptr);
#else /* usermode stack */
static l2cap_con *timeout_con = NULL;
static s32 timer_cancelled = 0;
static void l2cap_rtx_timeout(void);
static void l2cap_ertx_timeout(unsigned long ptr);
#endif

static void start_rtx(l2cap_con *con, unsigned short timeout, unsigned short action);
static void disable_rtx(l2cap_con *con);

static void start_ertx(l2cap_con *con, unsigned short timeout);
static void disable_ertx(l2cap_con *con);

#endif

/****************** GLOBAL VARIABLE DECLARATION SECTION *********************/

/****************** LOCAL VARIABLE DECLARATION SECTION **********************/

static l2cap_layer l2capmain; /* Main structure */
static l2cap_layer* l2cap;
static struct protocol_layer default_protocol;
extern int bt_max_connections;
extern hci_controller hci_ctrl;

/****************** FUNCTION DEFINITION SECTION *****************************/
  
/*********************************************************************/
/*---------------------- INIT AND SHUTDOWN --------------------------*/
/*********************************************************************/

s32
l2cap_init(void)
{
	s32 i;
	u8 bd_name[20];
	DSYS("Initialising L2CAP\n");
	l2cap = &l2capmain;
	init_con_list();
        l2cap->cid_count = MIN_CID; /* Moved from init_con_list */

	/* Set all upper layers to default */

	l2cap_protocol_default(&default_protocol);
	
	l2cap->id_count = 1;
	l2cap->mtu = MTU_DEFAULT ;
	l2cap->flush_timeout = FLUSHTIMEOUT_DEFAULT; /* Always retransmit */
	l2cap->upper_layers = NULL;
	init_flow(&l2cap->qos);

	/* get local bd address */
	hci_read_local_bd(l2cap->my_bd);

	/* check result... */
	if (!l2cap->my_bd[0] && !l2cap->my_bd[1] && !l2cap->my_bd[2] &&
	    !l2cap->my_bd[3] && !l2cap->my_bd[4] && !l2cap->my_bd[5])
		D_ERR(__FUNCTION__ ": Failed to get local BD addr\n");
	else {
		i = l2cap_sprint_bd(bd_name, l2cap->my_bd);
		bd_name[i] = 0;
		DSYS("Local bd [%s]\n", bd_name);
	}

#ifdef CONFIG_BLUETOOTH_USE_SECURITY_MANAGER
        /* Initialize security */
        l2cap_sec_man_init();
#endif
        
#if L2CAP_SELFTEST
	test_conlist();
#endif
#ifdef CONFIG_BLUETOOTH_L2CAP_CONNECTIONLESS
	l2cap->allow_conless = 1;
#else
	l2cap->allow_conless = 0;
#endif
	l2cap->initiated = 1;
	return 0;
}

void 
l2cap_protocol_default(struct protocol_layer *prot)
{
	prot->psm = 0;
	prot->con_pnd = not_registered_cfm;
	prot->con_cfm = not_registered_cfm;
	prot->conf_cfm = not_registered_cfm;
	prot->disc_cfm = not_registered_cfm_noparams;

	prot->con_ind = not_registered_ind;
	prot->conf_ind = not_registered_ind;
	prot->disc_ind = not_registered_ind;

	prot->receive_data = not_registered_rcv;
	prot->next_layer = NULL;
}

void 
l2cap_register_default_upper(struct protocol_layer *prot)
{
	memcpy(&default_protocol, prot, sizeof default_protocol);
}

s32 
l2cap_shutdown(void)
{
	DSYS("Shutting down L2CAP\n");
	if (!l2cap->initiated) {
		D_ERR(__FUNCTION__ ": L2CAP not initiated\n");
		return -1;
	}
	
	/* fixme -- experimental */
#if 0
	{
		l2cap_con *con;
		con = get_first_con();
		while (con != NULL) {
			if (l2ca_disconnect_req(con) != 0)
				break;
			con = get_first_con();
		}
	}
#endif

	free_con_list();
	remove_all_upper();

	/* ALWAYS SUCCESS */
	return 0;
}

/* is called with a struct of functions to handle incoming data */


s32 
l2cap_register_upper(u16 psm, struct protocol_layer *prot) 
{
        if (((psm % 2) == 0) || (prot == NULL)) {
		D_ERR(__FUNCTION__ ": incorrect parameters\n");
		return -EINVAL;
        }
    
	D_MISC(__FUNCTION__ ": psm 0x%x\n", psm);

        if ((psm > MAX_PSM) && (psm < MIN_DYNAMIC_PSM)) {
		D_ERR(__FUNCTION__ ": value of psm reserved\n");
		return -EINVAL;
        }

        if (psm > MAX_DYNAMIC_PSM) {
		D_ERR(__FUNCTION__ ": psm not valid!\n");
		return -EINVAL;
        }

	prot->psm = psm;
	return insert_upper(prot);
}

/* Inserts the function pointers to a new upper layer in the list */

s32
insert_upper(protocol_layer *upper_layer)
{
	protocol_layer *new_layer;
	D_MISC(__FUNCTION__ ": Inserting layer psm:0x%x\n", upper_layer->psm);

	if (!(new_layer = kmalloc(sizeof *new_layer, GFP_ATOMIC)))
		return -ENOMEM;

	memcpy(new_layer, upper_layer, sizeof *new_layer);

	/* Add to head of list of upper layers */
	new_layer->next_layer = l2cap->upper_layers;
	l2cap->upper_layers = new_layer;

	return 0;
}
 
protocol_layer*
get_upper(u32 psm)
{
	protocol_layer *tmp_layer;
	
	/* Check PSM value */
        if((psm % 2) == 0) {
		D_ERR(__FUNCTION__ ": incorrect psm\n");
		return &default_protocol;
        }
        if((psm > MAX_PSM) && (psm < MIN_DYNAMIC_PSM)) {
		D_ERR(__FUNCTION__ ": value of psm reserved\n");
		return &default_protocol;
        }
        if(psm > MAX_DYNAMIC_PSM) {
		D_ERR(__FUNCTION__ ": psm not valid!\n");
		return &default_protocol;
        }

	D_MISC(__FUNCTION__ ": Try to retrieve psm 0x%x\n",psm);
	tmp_layer = l2cap->upper_layers;
	while (tmp_layer != NULL) {
		if (tmp_layer->psm == psm) {
			D_MISC(__FUNCTION__ ": Actually got psm:0x%x\n",
			       tmp_layer->psm);
			return tmp_layer;
		}
		tmp_layer = tmp_layer->next_layer;
	}
	D_MISC(__FUNCTION__ ": Didn't get any layer, returning default\n");
	return &default_protocol;
}

void
remove_all_upper(void)
{
	protocol_layer *tmp_layer;

	D_MISC(__FUNCTION__ ": Freeing all upper layers\n");

	while (l2cap->upper_layers != NULL) {
		tmp_layer = l2cap->upper_layers;
		l2cap->upper_layers = tmp_layer->next_layer;
		kfree(tmp_layer);
	}
}

/* needed ? */
void 
not_registered_cfm(l2cap_con *con, s32 result)
{
	DSYS("No upper layer confirm function defined (psm:0x%x)\n", con->psm);
	DSYS("silent discard...\n");
}

void 
not_registered_cfm_noparams(l2cap_con *con)
{
	DSYS("No upper layer confirm function defined (psm:0x%x)\n", con->psm);
	DSYS("silent discard...\n");
}

void 
not_registered_ind(l2cap_con *con)
{
	DSYS("No upper layer ind function defined (psm:0x%x)\n", con->psm);
	DSYS("silent discard...\n");
}

void 
not_registered_rcv(l2cap_con *con, u8 *data, u32 len)
{
	DSYS("No upper layer receive_data function defined (psm:0x%x)\n", 
	     con->psm);
	DSYS("silent discard...\n");
}

/****************************************************************/
/*---------------------- STATE MACHINE -------------------------*/
/****************************************************************/



/* If l2cap_len is 0 then we know we have a new frame. Parse the length field
   and set l2cap_len and compare len to this value each time new data arrives.
   When equal a whole frame is received and we can parse it */  

void 
l2cap_receive_data(u8 *data,  u32 len, u16 hci_handle, /*u8 pb_flag,*/  
                   /*u8 bc_flag,*/ u32 *l2cap_len)
{
	l2cap_packet *pkt = NULL;
	l2cap_con *con;
	u16 pkt_len;
	CID pkt_cid;

	D_RCV(__FUNCTION__ ": got %d bytes on hci_handle : %d\n", len, hci_handle);