[mirror_ubuntu-bionic-kernel.git] / include / net / bluetooth / hci_core.h

/* 
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 
   SOFTWARE IS DISCLAIMED.
*/

#ifndef __HCI_CORE_H
#define __HCI_CORE_H

#include <net/bluetooth/hci.h>

/* HCI upper protocols */
#define HCI_PROTO_L2CAP	0
#define HCI_PROTO_SCO	1

/* HCI Core structures */
struct inquiry_data {
	bdaddr_t	bdaddr;
	__u8		pscan_rep_mode;
	__u8		pscan_period_mode;
	__u8		pscan_mode;
	__u8		dev_class[3];
	__le16		clock_offset;
	__s8		rssi;
	__u8		ssp_mode;
};

struct inquiry_entry {
	struct inquiry_entry 	*next;
	__u32			timestamp;
	struct inquiry_data	data;
};

struct inquiry_cache {
	spinlock_t 		lock;
	__u32			timestamp;
	struct inquiry_entry 	*list;
};

struct hci_conn_hash {
	struct list_head list;
	spinlock_t       lock;
	unsigned int     acl_num;
	unsigned int     sco_num;
};

struct hci_dev {
	struct list_head list;
	spinlock_t	lock;
	atomic_t	refcnt;

	char		name[8];
	unsigned long	flags;
	__u16		id;
	__u8		bus;
	bdaddr_t	bdaddr;
	__u8		dev_name[248];
	__u8		dev_class[3];
	__u8		features[8];
	__u8		commands[64];
	__u8		ssp_mode;
	__u8		hci_ver;
	__u16		hci_rev;
	__u16		manufacturer;
	__u16		voice_setting;

	__u16		pkt_type;
	__u16		esco_type;
	__u16		link_policy;
	__u16		link_mode;

	__u32		idle_timeout;
	__u16		sniff_min_interval;
	__u16		sniff_max_interval;

	unsigned long	quirks;

	atomic_t	cmd_cnt;
	unsigned int	acl_cnt;
	unsigned int	sco_cnt;

	unsigned int	acl_mtu;
	unsigned int	sco_mtu;
	unsigned int	acl_pkts;
	unsigned int	sco_pkts;

	unsigned long	cmd_last_tx;
	unsigned long	acl_last_tx;
	unsigned long	sco_last_tx;

	struct tasklet_struct	cmd_task;
	struct tasklet_struct	rx_task;
	struct tasklet_struct	tx_task;

	struct sk_buff_head	rx_q;
	struct sk_buff_head	raw_q;
	struct sk_buff_head	cmd_q;

	struct sk_buff		*sent_cmd;
	struct sk_buff		*reassembly[3];

	struct mutex		req_lock;
	wait_queue_head_t	req_wait_q;
	__u32			req_status;
	__u32			req_result;

	struct inquiry_cache	inq_cache;
	struct hci_conn_hash	conn_hash;

	struct hci_dev_stats	stat;

	struct sk_buff_head	driver_init;

	void			*driver_data;
	void			*core_data;

	atomic_t 		promisc;

	struct dentry		*debugfs;

	struct device		*parent;
	struct device		dev;

	struct rfkill		*rfkill;

	struct module 		*owner;

	int (*open)(struct hci_dev *hdev);
	int (*close)(struct hci_dev *hdev);
	int (*flush)(struct hci_dev *hdev);
	int (*send)(struct sk_buff *skb);
	void (*destruct)(struct hci_dev *hdev);
	void (*notify)(struct hci_dev *hdev, unsigned int evt);
	int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
};

struct hci_conn {
	struct list_head list;

	atomic_t	 refcnt;
	spinlock_t	 lock;

	bdaddr_t	 dst;
	__u16		 handle;
	__u16		 state;
	__u8             mode;
	__u8		 type;
	__u8		 out;
	__u8		 attempt;
	__u8		 dev_class[3];
	__u8             features[8];
	__u8             ssp_mode;
	__u16            interval;
	__u16            pkt_type;
	__u16            link_policy;
	__u32		 link_mode;
	__u8             auth_type;
	__u8             sec_level;
	__u8             power_save;
	__u16            disc_timeout;
	unsigned long	 pend;

	unsigned int	 sent;

	struct sk_buff_head data_q;

	struct timer_list disc_timer;
	struct timer_list idle_timer;

	struct work_struct work_add;
	struct work_struct work_del;

	struct device	dev;
	atomic_t	devref;

	struct hci_dev	*hdev;
	void		*l2cap_data;
	void		*sco_data;
	void		*priv;

	struct hci_conn	*link;
};

extern struct hci_proto *hci_proto[];
extern struct list_head hci_dev_list;
extern struct list_head hci_cb_list;
extern rwlock_t hci_dev_list_lock;
extern rwlock_t hci_cb_list_lock;

/* ----- Inquiry cache ----- */
#define INQUIRY_CACHE_AGE_MAX   (HZ*30)   // 30 seconds
#define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   // 60 seconds

#define inquiry_cache_lock(c)		spin_lock(&c->lock)
#define inquiry_cache_unlock(c)		spin_unlock(&c->lock)
#define inquiry_cache_lock_bh(c)	spin_lock_bh(&c->lock)
#define inquiry_cache_unlock_bh(c)	spin_unlock_bh(&c->lock)

static inline void inquiry_cache_init(struct hci_dev *hdev)
{
	struct inquiry_cache *c = &hdev->inq_cache;
	spin_lock_init(&c->lock);
	c->list = NULL;
}

static inline int inquiry_cache_empty(struct hci_dev *hdev)
{
	struct inquiry_cache *c = &hdev->inq_cache;
	return (c->list == NULL);
}

static inline long inquiry_cache_age(struct hci_dev *hdev)
{
	struct inquiry_cache *c = &hdev->inq_cache;
	return jiffies - c->timestamp;
}

static inline long inquiry_entry_age(struct inquiry_entry *e)
{
	return jiffies - e->timestamp;
}

struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr);
void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data);

/* ----- HCI Connections ----- */
enum {
	HCI_CONN_AUTH_PEND,
	HCI_CONN_ENCRYPT_PEND,
	HCI_CONN_RSWITCH_PEND,
	HCI_CONN_MODE_CHANGE_PEND,
};

static inline void hci_conn_hash_init(struct hci_dev *hdev)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	INIT_LIST_HEAD(&h->list);
	spin_lock_init(&h->lock);
	h->acl_num = 0;
	h->sco_num = 0;
}

static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	list_add(&c->list, &h->list);
	if (c->type == ACL_LINK)
		h->acl_num++;
	else
		h->sco_num++;
}

static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	list_del(&c->list);
	if (c->type == ACL_LINK)
		h->acl_num--;
	else
		h->sco_num--;
}

static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
					__u16 handle)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	struct list_head *p;
	struct hci_conn  *c;

	list_for_each(p, &h->list) {
		c = list_entry(p, struct hci_conn, list);
		if (c->handle == handle)
			return c;
	}
	return NULL;
}

static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
					__u8 type, bdaddr_t *ba)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	struct list_head *p;
	struct hci_conn  *c;

	list_for_each(p, &h->list) {
		c = list_entry(p, struct hci_conn, list);
		if (c->type == type && !bacmp(&c->dst, ba))
			return c;
	}
	return NULL;
}

static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
					__u8 type, __u16 state)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	struct list_head *p;
	struct hci_conn  *c;

	list_for_each(p, &h->list) {
		c = list_entry(p, struct hci_conn, list);
		if (c->type == type && c->state == state)
			return c;
	}
	return NULL;
}

void hci_acl_connect(struct hci_conn *conn);
void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
void hci_add_sco(struct hci_conn *conn, __u16 handle);
void hci_setup_sync(struct hci_conn *conn, __u16 handle);

struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
int hci_conn_del(struct hci_conn *conn);
void hci_conn_hash_flush(struct hci_dev *hdev);
void hci_conn_check_pending(struct hci_dev *hdev);

struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type);
int hci_conn_check_link_mode(struct hci_conn *conn);
int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type);
int hci_conn_change_link_key(struct hci_conn *conn);
int hci_conn_switch_role(struct hci_conn *conn, __u8 role);

void hci_conn_enter_active_mode(struct hci_conn *conn);
void hci_conn_enter_sniff_mode(struct hci_conn *conn);

void hci_conn_hold_device(struct hci_conn *conn);
void hci_conn_put_device(struct hci_conn *conn);

static inline void hci_conn_hold(struct hci_conn *conn)
{
	atomic_inc(&conn->refcnt);
	del_timer(&conn->disc_timer);
}

static inline void hci_conn_put(struct hci_conn *conn)
{
	if (atomic_dec_and_test(&conn->refcnt)) {
		unsigned long timeo;
		if (conn->type == ACL_LINK) {
			del_timer(&conn->idle_timer);
			if (conn->state == BT_CONNECTED) {
				timeo = msecs_to_jiffies(conn->disc_timeout);
				if (!conn->out)
					timeo *= 2;
			} else
				timeo = msecs_to_jiffies(10);
		} else
			timeo = msecs_to_jiffies(10);
		mod_timer(&conn->disc_timer, jiffies + timeo);
	}
}

/* ----- HCI Devices ----- */
static inline void __hci_dev_put(struct hci_dev *d)
{
	if (atomic_dec_and_test(&d->refcnt))
		d->destruct(d);
}

static inline void hci_dev_put(struct hci_dev *d)
{ 
	__hci_dev_put(d);
	module_put(d->owner);
}

static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
{
	atomic_inc(&d->refcnt);
	return d;
}

static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
{
	if (try_module_get(d->owner))
		return __hci_dev_hold(d);
	return NULL;
}

#define hci_dev_lock(d)		spin_lock(&d->lock)
#define hci_dev_unlock(d)	spin_unlock(&d->lock)
#define hci_dev_lock_bh(d)	spin_lock_bh(&d->lock)
#define hci_dev_unlock_bh(d)	spin_unlock_bh(&d->lock)

struct hci_dev *hci_dev_get(int index);
struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);

struct hci_dev *hci_alloc_dev(void);
void hci_free_dev(struct hci_dev *hdev);
int hci_register_dev(struct hci_dev *hdev);
int hci_unregister_dev(struct hci_dev *hdev);
int hci_suspend_dev(struct hci_dev *hdev);
int hci_resume_dev(struct hci_dev *hdev);
int hci_dev_open(__u16 dev);
int hci_dev_close(__u16 dev);
int hci_dev_reset(__u16 dev);
int hci_dev_reset_stat(__u16 dev);
int hci_dev_cmd(unsigned int cmd, void __user *arg);
int hci_get_dev_list(void __user *arg);
int hci_get_dev_info(void __user *arg);
int hci_get_conn_list(void __user *arg);
int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
int hci_inquiry(void __user *arg);

void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);

int hci_recv_frame(struct sk_buff *skb);
int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count);

int hci_register_sysfs(struct hci_dev *hdev);
void hci_unregister_sysfs(struct hci_dev *hdev);
void hci_conn_init_sysfs(struct hci_conn *conn);
void hci_conn_add_sysfs(struct hci_conn *conn);
void hci_conn_del_sysfs(struct hci_conn *conn);

#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev))

/* ----- LMP capabilities ----- */
#define lmp_rswitch_capable(dev)   ((dev)->features[0] & LMP_RSWITCH)
#define lmp_encrypt_capable(dev)   ((dev)->features[0] & LMP_ENCRYPT)
#define lmp_sniff_capable(dev)     ((dev)->features[0] & LMP_SNIFF)
#define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
#define lmp_esco_capable(dev)      ((dev)->features[3] & LMP_ESCO)
#define lmp_ssp_capable(dev)       ((dev)->features[6] & LMP_SIMPLE_PAIR)

/* ----- HCI protocols ----- */
struct hci_proto {
	char		*name;
	unsigned int	id;
	unsigned long	flags;

	void		*priv;

	int (*connect_ind)	(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type);
	int (*connect_cfm)	(struct hci_conn *conn, __u8 status);
	int (*disconn_ind)	(struct hci_conn *conn);
	int (*disconn_cfm)	(struct hci_conn *conn, __u8 reason);
	int (*recv_acldata)	(struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
	int (*recv_scodata)	(struct hci_conn *conn, struct sk_buff *skb);
	int (*security_cfm)	(struct hci_conn *conn, __u8 status, __u8 encrypt);
};

static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
{
	register struct hci_proto *hp;
	int mask = 0;

	hp = hci_proto[HCI_PROTO_L2CAP];
	if (hp && hp->connect_ind)
		mask |= hp->connect_ind(hdev, bdaddr, type);

	hp = hci_proto[HCI_PROTO_SCO];
	if (hp && hp->connect_ind)
		mask |= hp->connect_ind(hdev, bdaddr, type);

	return mask;
}

static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
{
	register struct hci_proto *hp;

	hp = hci_proto[HCI_PROTO_L2CAP];
	if (hp && hp->connect_cfm)
		hp->connect_cfm(conn, status);

	hp = hci_proto[HCI_PROTO_SCO];
	if (hp && hp->connect_cfm)
		hp->connect_cfm(conn, status);
}

static inline int hci_proto_disconn_ind(struct hci_conn *conn)
{
	register struct hci_proto *hp;
	int reason = 0x13;

	hp = hci_proto[HCI_PROTO_L2CAP];
	if (hp && hp->disconn_ind)
		reason = hp->disconn_ind(conn);

	hp = hci_proto[HCI_PROTO_SCO];
	if (hp && hp->disconn_ind)
		reason = hp->disconn_ind(conn);

	return reason;
}

static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason)
{
	register struct hci_proto *hp;

	hp = hci_proto[HCI_PROTO_L2CAP];
	if (hp && hp->disconn_cfm)
		hp->disconn_cfm(conn, reason);

	hp = hci_proto[HCI_PROTO_SCO];
	if (hp && hp->disconn_cfm)
		hp->disconn_cfm(conn, reason);
}

static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
{
	register struct hci_proto *hp;
	__u8 encrypt;

	if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
		return;

	encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;

	hp = hci_proto[HCI_PROTO_L2CAP];
	if (hp && hp->security_cfm)
		hp->security_cfm(conn, status, encrypt);

	hp = hci_proto[HCI_PROTO_SCO];
	if (hp && hp->security_cfm)
		hp->security_cfm(conn, status, encrypt);
}

static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
{
	register struct hci_proto *hp;

	hp = hci_proto[HCI_PROTO_L2CAP];
	if (hp && hp->security_cfm)
		hp->security_cfm(conn, status, encrypt);

	hp = hci_proto[HCI_PROTO_SCO];
	if (hp && hp->security_cfm)
		hp->security_cfm(conn, status, encrypt);
}

int hci_register_proto(struct hci_proto *hproto);
int hci_unregister_proto(struct hci_proto *hproto);

/* ----- HCI callbacks ----- */
struct hci_cb {
	struct list_head list;

	char *name;

	void (*security_cfm)	(struct hci_conn *conn, __u8 status, __u8 encrypt);
	void (*key_change_cfm)	(struct hci_conn *conn, __u8 status);
	void (*role_switch_cfm)	(struct hci_conn *conn, __u8 status, __u8 role);
};

static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
{
	struct list_head *p;
	__u8 encrypt;

	hci_proto_auth_cfm(conn, status);

	if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
		return;

	encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;

	read_lock_bh(&hci_cb_list_lock);
	list_for_each(p, &hci_cb_list) {
		struct hci_cb *cb = list_entry(p, struct hci_cb, list);
		if (cb->security_cfm)
			cb->security_cfm(conn, status, encrypt);
	}
	read_unlock_bh(&hci_cb_list_lock);
}

static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
{
	struct list_head *p;

	if (conn->sec_level == BT_SECURITY_SDP)
		conn->sec_level = BT_SECURITY_LOW;

	hci_proto_encrypt_cfm(conn, status, encrypt);

	read_lock_bh(&hci_cb_list_lock);
	list_for_each(p, &hci_cb_list) {
		struct hci_cb *cb = list_entry(p, struct hci_cb, list);
		if (cb->security_cfm)
			cb->security_cfm(conn, status, encrypt);
	}
	read_unlock_bh(&hci_cb_list_lock);
}

static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
{
	struct list_head *p;

	read_lock_bh(&hci_cb_list_lock);
	list_for_each(p, &hci_cb_list) {
		struct hci_cb *cb = list_entry(p, struct hci_cb, list);
		if (cb->key_change_cfm)
			cb->key_change_cfm(conn, status);
	}
	read_unlock_bh(&hci_cb_list_lock);
}

static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status, __u8 role)
{
	struct list_head *p;

	read_lock_bh(&hci_cb_list_lock);
	list_for_each(p, &hci_cb_list) {
		struct hci_cb *cb = list_entry(p, struct hci_cb, list);
		if (cb->role_switch_cfm)
			cb->role_switch_cfm(conn, status, role);
	}
	read_unlock_bh(&hci_cb_list_lock);
}

int hci_register_cb(struct hci_cb *hcb);
int hci_unregister_cb(struct hci_cb *hcb);

int hci_register_notifier(struct notifier_block *nb);
int hci_unregister_notifier(struct notifier_block *nb);

int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param);
int hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);

void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);

void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data);

/* ----- HCI Sockets ----- */
void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);

/* HCI info for socket */
#define hci_pi(sk) ((struct hci_pinfo *) sk)

struct hci_pinfo {
	struct bt_sock    bt;
	struct hci_dev    *hdev;
	struct hci_filter filter;
	__u32             cmsg_mask;
};

/* HCI security filter */
#define HCI_SFLT_MAX_OGF  5

struct hci_sec_filter {
	__u32 type_mask;
	__u32 event_mask[2];
	__u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
};

/* ----- HCI requests ----- */
#define HCI_REQ_DONE	  0
#define HCI_REQ_PEND	  1
#define HCI_REQ_CANCELED  2

#define hci_req_lock(d)		mutex_lock(&d->req_lock)
#define hci_req_unlock(d)	mutex_unlock(&d->req_lock)

void hci_req_complete(struct hci_dev *hdev, int result);

#endif /* __HCI_CORE_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	BlueZ - Bluetooth protocol stack for Linux
	3	Copyright (C) 2000-2001 Qualcomm Incorporated
	4
	5	Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License version 2 as
	9	published by the Free Software Foundation;
	10
	11	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	12	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	13	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	14	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
	15	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	16	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	17	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	19
	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
	22	SOFTWARE IS DISCLAIMED.
	23	*/
	24
	25	#ifndef __HCI_CORE_H
	26	#define __HCI_CORE_H
	27
1da177e4 LT	28	#include <net/bluetooth/hci.h>
	29
	30	/* HCI upper protocols */
	31	#define HCI_PROTO_L2CAP 0
	32	#define HCI_PROTO_SCO 1
	33
1da177e4	34	/* HCI Core structures */
1da177e4 LT	35	struct inquiry_data {
	36	bdaddr_t bdaddr;
	37	__u8 pscan_rep_mode;
	38	__u8 pscan_period_mode;
	39	__u8 pscan_mode;
	40	__u8 dev_class[3];
1ebb9252	41	__le16 clock_offset;
1da177e4	42	__s8 rssi;
41a96212	43	__u8 ssp_mode;
1da177e4 LT	44	};
	45
	46	struct inquiry_entry {
	47	struct inquiry_entry *next;
	48	__u32 timestamp;
	49	struct inquiry_data data;
	50	};
	51
	52	struct inquiry_cache {
	53	spinlock_t lock;
	54	__u32 timestamp;
	55	struct inquiry_entry *list;
	56	};
	57
	58	struct hci_conn_hash {
	59	struct list_head list;
	60	spinlock_t lock;
	61	unsigned int acl_num;
	62	unsigned int sco_num;
	63	};
	64
	65	struct hci_dev {
	66	struct list_head list;
	67	spinlock_t lock;
	68	atomic_t refcnt;
	69
	70	char name[8];
	71	unsigned long flags;
	72	__u16 id;
c13854ce	73	__u8 bus;
1da177e4	74	bdaddr_t bdaddr;
a9de9248 MH	75	__u8 dev_name[248];
a9de9248 MH	76	__u8 dev_class[3];
1da177e4	77	__u8 features[8];
a9de9248	78	__u8 commands[64];
333140b5	79	__u8 ssp_mode;
1143e5a6 MH	80	__u8 hci_ver;
	81	__u16 hci_rev;
	82	__u16 manufacturer;
1da177e4 LT	83	__u16 voice_setting;
	84
	85	__u16 pkt_type;
5b7f9909	86	__u16 esco_type;
1da177e4 LT	87	__u16 link_policy;
	88	__u16 link_mode;
	89
04837f64 MH	90	__u32 idle_timeout;
	91	__u16 sniff_min_interval;
	92	__u16 sniff_max_interval;
	93
1da177e4 LT	94	unsigned long quirks;
	95
	96	atomic_t cmd_cnt;
	97	unsigned int acl_cnt;
	98	unsigned int sco_cnt;
	99
	100	unsigned int acl_mtu;
	101	unsigned int sco_mtu;
	102	unsigned int acl_pkts;
	103	unsigned int sco_pkts;
	104
	105	unsigned long cmd_last_tx;
	106	unsigned long acl_last_tx;
	107	unsigned long sco_last_tx;
	108
	109	struct tasklet_struct cmd_task;
	110	struct tasklet_struct rx_task;
	111	struct tasklet_struct tx_task;
	112
	113	struct sk_buff_head rx_q;
	114	struct sk_buff_head raw_q;
	115	struct sk_buff_head cmd_q;
	116
	117	struct sk_buff *sent_cmd;
ef222013	118	struct sk_buff *reassembly[3];
1da177e4	119
a6a67efd	120	struct mutex req_lock;
1da177e4 LT	121	wait_queue_head_t req_wait_q;
	122	__u32 req_status;
	123	__u32 req_result;
	124
	125	struct inquiry_cache inq_cache;
	126	struct hci_conn_hash conn_hash;
	127
	128	struct hci_dev_stats stat;
	129
	130	struct sk_buff_head driver_init;
	131
	132	void *driver_data;
	133	void *core_data;
	134
	135	atomic_t promisc;
	136
ca325f69 MH	137	struct dentry *debugfs;
ca325f69 MH	138
a91f2e39 MH	139	struct device *parent;
a91f2e39 MH	140	struct device dev;
1da177e4	141
611b30f7 MH	142	struct rfkill *rfkill;
611b30f7 MH	143
1da177e4 LT	144	struct module *owner;
	145
	146	int (open)(struct hci_dev hdev);
	147	int (close)(struct hci_dev hdev);
	148	int (flush)(struct hci_dev hdev);
	149	int (send)(struct sk_buff skb);
	150	void (destruct)(struct hci_dev hdev);
	151	void (notify)(struct hci_dev hdev, unsigned int evt);
	152	int (ioctl)(struct hci_dev hdev, unsigned int cmd, unsigned long arg);
	153	};
	154
	155	struct hci_conn {
	156	struct list_head list;
	157
	158	atomic_t refcnt;
	159	spinlock_t lock;
	160
	161	bdaddr_t dst;
	162	__u16 handle;
	163	__u16 state;
04837f64	164	__u8 mode;
1da177e4 LT	165	__u8 type;
1da177e4 LT	166	__u8 out;
4c67bc74	167	__u8 attempt;
1da177e4	168	__u8 dev_class[3];
04837f64	169	__u8 features[8];
41a96212	170	__u8 ssp_mode;
04837f64	171	__u16 interval;
a8746417	172	__u16 pkt_type;
04837f64	173	__u16 link_policy;
1da177e4	174	__u32 link_mode;
40be492f	175	__u8 auth_type;
8c1b2355	176	__u8 sec_level;
04837f64	177	__u8 power_save;
052b30b0	178	__u16 disc_timeout;
1da177e4	179	unsigned long pend;
04837f64	180
1da177e4	181	unsigned int sent;
04837f64	182
1da177e4 LT	183	struct sk_buff_head data_q;
1da177e4 LT	184
04837f64 MH	185	struct timer_list disc_timer;
	186	struct timer_list idle_timer;
	187
f3784d83 RQ	188	struct work_struct work_add;
f3784d83 RQ	189	struct work_struct work_del;
b219e3ac MH	190
b219e3ac MH	191	struct device dev;
9eba32b8	192	atomic_t devref;
b219e3ac	193
1da177e4 LT	194	struct hci_dev *hdev;
	195	void *l2cap_data;
	196	void *sco_data;
	197	void *priv;
	198
	199	struct hci_conn *link;
	200	};
	201
	202	extern struct hci_proto *hci_proto[];
	203	extern struct list_head hci_dev_list;
	204	extern struct list_head hci_cb_list;
	205	extern rwlock_t hci_dev_list_lock;
	206	extern rwlock_t hci_cb_list_lock;
	207
	208	/* ----- Inquiry cache ----- */
	209	#define INQUIRY_CACHE_AGE_MAX (HZ*30) // 30 seconds
	210	#define INQUIRY_ENTRY_AGE_MAX (HZ*60) // 60 seconds
	211
	212	#define inquiry_cache_lock(c) spin_lock(&c->lock)
	213	#define inquiry_cache_unlock(c) spin_unlock(&c->lock)
	214	#define inquiry_cache_lock_bh(c) spin_lock_bh(&c->lock)
	215	#define inquiry_cache_unlock_bh(c) spin_unlock_bh(&c->lock)
	216
	217	static inline void inquiry_cache_init(struct hci_dev *hdev)
	218	{
	219	struct inquiry_cache *c = &hdev->inq_cache;
	220	spin_lock_init(&c->lock);
	221	c->list = NULL;
	222	}
	223
	224	static inline int inquiry_cache_empty(struct hci_dev *hdev)
	225	{
	226	struct inquiry_cache *c = &hdev->inq_cache;
	227	return (c->list == NULL);
	228	}
	229
	230	static inline long inquiry_cache_age(struct hci_dev *hdev)
	231	{
	232	struct inquiry_cache *c = &hdev->inq_cache;
	233	return jiffies - c->timestamp;
	234	}
	235
	236	static inline long inquiry_entry_age(struct inquiry_entry *e)
	237	{
	238	return jiffies - e->timestamp;
	239	}
	240
	241	struct inquiry_entry hci_inquiry_cache_lookup(struct hci_dev hdev, bdaddr_t *bdaddr);
	242	void hci_inquiry_cache_update(struct hci_dev hdev, struct inquiry_data data);
	243
	244	/* ----- HCI Connections ----- */
	245	enum {
	246	HCI_CONN_AUTH_PEND,
	247	HCI_CONN_ENCRYPT_PEND,
04837f64 MH	248	HCI_CONN_RSWITCH_PEND,
04837f64 MH	249	HCI_CONN_MODE_CHANGE_PEND,
1da177e4 LT	250	};
	251
	252	static inline void hci_conn_hash_init(struct hci_dev *hdev)
	253	{
	254	struct hci_conn_hash *h = &hdev->conn_hash;
	255	INIT_LIST_HEAD(&h->list);
	256	spin_lock_init(&h->lock);
	257	h->acl_num = 0;
	258	h->sco_num = 0;
	259	}
	260
	261	static inline void hci_conn_hash_add(struct hci_dev hdev, struct hci_conn c)
	262	{
	263	struct hci_conn_hash *h = &hdev->conn_hash;
	264	list_add(&c->list, &h->list);
	265	if (c->type == ACL_LINK)
	266	h->acl_num++;
	267	else
	268	h->sco_num++;
	269	}
	270
	271	static inline void hci_conn_hash_del(struct hci_dev hdev, struct hci_conn c)
	272	{
	273	struct hci_conn_hash *h = &hdev->conn_hash;
	274	list_del(&c->list);
	275	if (c->type == ACL_LINK)
	276	h->acl_num--;
	277	else
	278	h->sco_num--;
	279	}
	280
	281	static inline struct hci_conn hci_conn_hash_lookup_handle(struct hci_dev hdev,
	282	__u16 handle)
	283	{
	284	struct hci_conn_hash *h = &hdev->conn_hash;
	285	struct list_head *p;
	286	struct hci_conn *c;
	287
	288	list_for_each(p, &h->list) {
	289	c = list_entry(p, struct hci_conn, list);
	290	if (c->handle == handle)
	291	return c;
	292	}
	293	return NULL;
	294	}
	295
	296	static inline struct hci_conn hci_conn_hash_lookup_ba(struct hci_dev hdev,
	297	__u8 type, bdaddr_t *ba)
	298	{
	299	struct hci_conn_hash *h = &hdev->conn_hash;
	300	struct list_head *p;
	301	struct hci_conn *c;
	302
	303	list_for_each(p, &h->list) {
	304	c = list_entry(p, struct hci_conn, list);
	305	if (c->type == type && !bacmp(&c->dst, ba))
	306	return c;
	307	}
	308	return NULL;
	309	}
	310
4c67bc74 MH	311	static inline struct hci_conn hci_conn_hash_lookup_state(struct hci_dev hdev,
	312	__u8 type, __u16 state)
	313	{
	314	struct hci_conn_hash *h = &hdev->conn_hash;
	315	struct list_head *p;
	316	struct hci_conn *c;
	317
	318	list_for_each(p, &h->list) {
	319	c = list_entry(p, struct hci_conn, list);
	320	if (c->type == type && c->state == state)
	321	return c;
	322	}
	323	return NULL;
	324	}
	325
	326	void hci_acl_connect(struct hci_conn *conn);
1da177e4 LT	327	void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
1da177e4 LT	328	void hci_add_sco(struct hci_conn *conn, __u16 handle);
b6a0dc82	329	void hci_setup_sync(struct hci_conn *conn, __u16 handle);
1da177e4 LT	330
1da177e4 LT	331	struct hci_conn hci_conn_add(struct hci_dev hdev, int type, bdaddr_t *dst);
a9de9248 MH	332	int hci_conn_del(struct hci_conn *conn);
	333	void hci_conn_hash_flush(struct hci_dev *hdev);
	334	void hci_conn_check_pending(struct hci_dev *hdev);
1da177e4	335
8c1b2355	336	struct hci_conn hci_connect(struct hci_dev hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type);
e7c29cb1	337	int hci_conn_check_link_mode(struct hci_conn *conn);
0684e5f9	338	int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type);
1da177e4	339	int hci_conn_change_link_key(struct hci_conn *conn);
8c1b2355	340	int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
1da177e4	341
04837f64 MH	342	void hci_conn_enter_active_mode(struct hci_conn *conn);
04837f64 MH	343	void hci_conn_enter_sniff_mode(struct hci_conn *conn);
1da177e4	344
9eba32b8 MH	345	void hci_conn_hold_device(struct hci_conn *conn);
	346	void hci_conn_put_device(struct hci_conn *conn);
	347
1da177e4 LT	348	static inline void hci_conn_hold(struct hci_conn *conn)
	349	{
	350	atomic_inc(&conn->refcnt);
04837f64	351	del_timer(&conn->disc_timer);
1da177e4 LT	352	}
	353
	354	static inline void hci_conn_put(struct hci_conn *conn)
	355	{
	356	if (atomic_dec_and_test(&conn->refcnt)) {
04837f64	357	unsigned long timeo;
1da177e4	358	if (conn->type == ACL_LINK) {
04837f64	359	del_timer(&conn->idle_timer);
6ac59344	360	if (conn->state == BT_CONNECTED) {
052b30b0	361	timeo = msecs_to_jiffies(conn->disc_timeout);
6ac59344	362	if (!conn->out)
052b30b0	363	timeo *= 2;
6ac59344 MH	364	} else
6ac59344 MH	365	timeo = msecs_to_jiffies(10);
1da177e4	366	} else
04837f64 MH	367	timeo = msecs_to_jiffies(10);
04837f64 MH	368	mod_timer(&conn->disc_timer, jiffies + timeo);
1da177e4 LT	369	}
	370	}
	371
1da177e4 LT	372	/* ----- HCI Devices ----- */
	373	static inline void __hci_dev_put(struct hci_dev *d)
	374	{
	375	if (atomic_dec_and_test(&d->refcnt))
	376	d->destruct(d);
	377	}
	378
	379	static inline void hci_dev_put(struct hci_dev *d)
	380	{
	381	__hci_dev_put(d);
	382	module_put(d->owner);
	383	}
	384
	385	static inline struct hci_dev __hci_dev_hold(struct hci_dev d)
	386	{
	387	atomic_inc(&d->refcnt);
	388	return d;
	389	}
	390
	391	static inline struct hci_dev hci_dev_hold(struct hci_dev d)
	392	{
	393	if (try_module_get(d->owner))
	394	return __hci_dev_hold(d);
	395	return NULL;
	396	}
	397
	398	#define hci_dev_lock(d) spin_lock(&d->lock)
	399	#define hci_dev_unlock(d) spin_unlock(&d->lock)
	400	#define hci_dev_lock_bh(d) spin_lock_bh(&d->lock)
	401	#define hci_dev_unlock_bh(d) spin_unlock_bh(&d->lock)
	402
	403	struct hci_dev *hci_dev_get(int index);
	404	struct hci_dev hci_get_route(bdaddr_t src, bdaddr_t *dst);
	405
	406	struct hci_dev *hci_alloc_dev(void);
	407	void hci_free_dev(struct hci_dev *hdev);
	408	int hci_register_dev(struct hci_dev *hdev);
	409	int hci_unregister_dev(struct hci_dev *hdev);
	410	int hci_suspend_dev(struct hci_dev *hdev);
	411	int hci_resume_dev(struct hci_dev *hdev);
	412	int hci_dev_open(__u16 dev);
	413	int hci_dev_close(__u16 dev);
	414	int hci_dev_reset(__u16 dev);
	415	int hci_dev_reset_stat(__u16 dev);
	416	int hci_dev_cmd(unsigned int cmd, void __user *arg);
	417	int hci_get_dev_list(void __user *arg);
	418	int hci_get_dev_info(void __user *arg);
	419	int hci_get_conn_list(void __user *arg);
	420	int hci_get_conn_info(struct hci_dev hdev, void __user arg);
40be492f	421	int hci_get_auth_info(struct hci_dev hdev, void __user arg);
1da177e4 LT	422	int hci_inquiry(void __user *arg);
	423
	424	void hci_event_packet(struct hci_dev hdev, struct sk_buff skb);
	425
76bca880	426	int hci_recv_frame(struct sk_buff *skb);
ef222013 MH	427	int hci_recv_fragment(struct hci_dev hdev, int type, void data, int count);
ef222013 MH	428
1da177e4 LT	429	int hci_register_sysfs(struct hci_dev *hdev);
1da177e4 LT	430	void hci_unregister_sysfs(struct hci_dev *hdev);
a67e899c	431	void hci_conn_init_sysfs(struct hci_conn *conn);
b219e3ac MH	432	void hci_conn_add_sysfs(struct hci_conn *conn);
b219e3ac MH	433	void hci_conn_del_sysfs(struct hci_conn *conn);
1da177e4	434
a91f2e39	435	#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev))
1da177e4 LT	436
1da177e4 LT	437	/* ----- LMP capabilities ----- */
04837f64 MH	438	#define lmp_rswitch_capable(dev) ((dev)->features[0] & LMP_RSWITCH)
	439	#define lmp_encrypt_capable(dev) ((dev)->features[0] & LMP_ENCRYPT)
	440	#define lmp_sniff_capable(dev) ((dev)->features[0] & LMP_SNIFF)
	441	#define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
5b7f9909	442	#define lmp_esco_capable(dev) ((dev)->features[3] & LMP_ESCO)
769be974	443	#define lmp_ssp_capable(dev) ((dev)->features[6] & LMP_SIMPLE_PAIR)
1da177e4 LT	444
	445	/* ----- HCI protocols ----- */
	446	struct hci_proto {
8c1b2355	447	char *name;
1da177e4 LT	448	unsigned int id;
	449	unsigned long flags;
	450
	451	void *priv;
	452
8c1b2355	453	int (connect_ind) (struct hci_dev hdev, bdaddr_t *bdaddr, __u8 type);
1da177e4	454	int (connect_cfm) (struct hci_conn conn, __u8 status);
2950f21a MH	455	int (disconn_ind) (struct hci_conn conn);
2950f21a MH	456	int (disconn_cfm) (struct hci_conn conn, __u8 reason);
1da177e4 LT	457	int (recv_acldata) (struct hci_conn conn, struct sk_buff *skb, __u16 flags);
1da177e4 LT	458	int (recv_scodata) (struct hci_conn conn, struct sk_buff *skb);
8c1b2355	459	int (security_cfm) (struct hci_conn conn, __u8 status, __u8 encrypt);
1da177e4 LT	460	};
	461
	462	static inline int hci_proto_connect_ind(struct hci_dev hdev, bdaddr_t bdaddr, __u8 type)
	463	{
	464	register struct hci_proto *hp;
	465	int mask = 0;
8c1b2355	466
1da177e4 LT	467	hp = hci_proto[HCI_PROTO_L2CAP];
	468	if (hp && hp->connect_ind)
	469	mask \|= hp->connect_ind(hdev, bdaddr, type);
	470
	471	hp = hci_proto[HCI_PROTO_SCO];
	472	if (hp && hp->connect_ind)
	473	mask \|= hp->connect_ind(hdev, bdaddr, type);
	474
	475	return mask;
	476	}
	477
	478	static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
	479	{
	480	register struct hci_proto *hp;
	481
	482	hp = hci_proto[HCI_PROTO_L2CAP];
	483	if (hp && hp->connect_cfm)
	484	hp->connect_cfm(conn, status);
	485
	486	hp = hci_proto[HCI_PROTO_SCO];
	487	if (hp && hp->connect_cfm)
	488	hp->connect_cfm(conn, status);
	489	}
	490
2950f21a	491	static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1da177e4 LT	492	{
1da177e4 LT	493	register struct hci_proto *hp;
2950f21a	494	int reason = 0x13;
1da177e4 LT	495
	496	hp = hci_proto[HCI_PROTO_L2CAP];
	497	if (hp && hp->disconn_ind)
2950f21a	498	reason = hp->disconn_ind(conn);
1da177e4 LT	499
	500	hp = hci_proto[HCI_PROTO_SCO];
	501	if (hp && hp->disconn_ind)
2950f21a MH	502	reason = hp->disconn_ind(conn);
	503
	504	return reason;
	505	}
	506
	507	static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason)
	508	{
	509	register struct hci_proto *hp;
	510
	511	hp = hci_proto[HCI_PROTO_L2CAP];
	512	if (hp && hp->disconn_cfm)
	513	hp->disconn_cfm(conn, reason);
	514
	515	hp = hci_proto[HCI_PROTO_SCO];
	516	if (hp && hp->disconn_cfm)
	517	hp->disconn_cfm(conn, reason);
1da177e4 LT	518	}
	519
	520	static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
	521	{
	522	register struct hci_proto *hp;
8c1b2355 MH	523	__u8 encrypt;
	524
	525	if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
	526	return;
	527
	528	encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
1da177e4 LT	529
1da177e4 LT	530	hp = hci_proto[HCI_PROTO_L2CAP];
8c1b2355 MH	531	if (hp && hp->security_cfm)
8c1b2355 MH	532	hp->security_cfm(conn, status, encrypt);
1da177e4 LT	533
1da177e4 LT	534	hp = hci_proto[HCI_PROTO_SCO];
8c1b2355 MH	535	if (hp && hp->security_cfm)
8c1b2355 MH	536	hp->security_cfm(conn, status, encrypt);
1da177e4 LT	537	}
1da177e4 LT	538
9719f8af	539	static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
1da177e4 LT	540	{
	541	register struct hci_proto *hp;
	542
	543	hp = hci_proto[HCI_PROTO_L2CAP];
8c1b2355 MH	544	if (hp && hp->security_cfm)
8c1b2355 MH	545	hp->security_cfm(conn, status, encrypt);
1da177e4 LT	546
1da177e4 LT	547	hp = hci_proto[HCI_PROTO_SCO];
8c1b2355 MH	548	if (hp && hp->security_cfm)
8c1b2355 MH	549	hp->security_cfm(conn, status, encrypt);
1da177e4 LT	550	}
	551
	552	int hci_register_proto(struct hci_proto *hproto);
	553	int hci_unregister_proto(struct hci_proto *hproto);
	554
	555	/* ----- HCI callbacks ----- */
	556	struct hci_cb {
	557	struct list_head list;
	558
	559	char *name;
	560
8c1b2355	561	void (security_cfm) (struct hci_conn conn, __u8 status, __u8 encrypt);
1da177e4 LT	562	void (key_change_cfm) (struct hci_conn conn, __u8 status);
	563	void (role_switch_cfm) (struct hci_conn conn, __u8 status, __u8 role);
	564	};
	565
	566	static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
	567	{
	568	struct list_head *p;
8c1b2355	569	__u8 encrypt;
1da177e4 LT	570
	571	hci_proto_auth_cfm(conn, status);
	572
8c1b2355 MH	573	if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
	574	return;
	575
	576	encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
	577
1da177e4 LT	578	read_lock_bh(&hci_cb_list_lock);
	579	list_for_each(p, &hci_cb_list) {
	580	struct hci_cb *cb = list_entry(p, struct hci_cb, list);
8c1b2355 MH	581	if (cb->security_cfm)
8c1b2355 MH	582	cb->security_cfm(conn, status, encrypt);
1da177e4 LT	583	}
	584	read_unlock_bh(&hci_cb_list_lock);
	585	}
	586
	587	static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
	588	{
	589	struct list_head *p;
	590
435fef20 MH	591	if (conn->sec_level == BT_SECURITY_SDP)
	592	conn->sec_level = BT_SECURITY_LOW;
	593
9719f8af	594	hci_proto_encrypt_cfm(conn, status, encrypt);
1da177e4 LT	595
	596	read_lock_bh(&hci_cb_list_lock);
	597	list_for_each(p, &hci_cb_list) {
	598	struct hci_cb *cb = list_entry(p, struct hci_cb, list);
8c1b2355 MH	599	if (cb->security_cfm)
8c1b2355 MH	600	cb->security_cfm(conn, status, encrypt);
1da177e4 LT	601	}
	602	read_unlock_bh(&hci_cb_list_lock);
	603	}
	604
	605	static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
	606	{
	607	struct list_head *p;
	608
	609	read_lock_bh(&hci_cb_list_lock);
	610	list_for_each(p, &hci_cb_list) {
	611	struct hci_cb *cb = list_entry(p, struct hci_cb, list);
	612	if (cb->key_change_cfm)
	613	cb->key_change_cfm(conn, status);
	614	}
	615	read_unlock_bh(&hci_cb_list_lock);
	616	}
	617
	618	static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status, __u8 role)
	619	{
	620	struct list_head *p;
	621
	622	read_lock_bh(&hci_cb_list_lock);
	623	list_for_each(p, &hci_cb_list) {
	624	struct hci_cb *cb = list_entry(p, struct hci_cb, list);
	625	if (cb->role_switch_cfm)
	626	cb->role_switch_cfm(conn, status, role);
	627	}
	628	read_unlock_bh(&hci_cb_list_lock);
	629	}
	630
	631	int hci_register_cb(struct hci_cb *hcb);
	632	int hci_unregister_cb(struct hci_cb *hcb);
	633
	634	int hci_register_notifier(struct notifier_block *nb);
	635	int hci_unregister_notifier(struct notifier_block *nb);
	636
a9de9248	637	int hci_send_cmd(struct hci_dev hdev, __u16 opcode, __u32 plen, void param);
1da177e4 LT	638	int hci_send_acl(struct hci_conn conn, struct sk_buff skb, __u16 flags);
	639	int hci_send_sco(struct hci_conn conn, struct sk_buff skb);
	640
a9de9248	641	void hci_sent_cmd_data(struct hci_dev hdev, __u16 opcode);
1da177e4 LT	642
	643	void hci_si_event(struct hci_dev hdev, int type, int dlen, void data);
	644
	645	/* ----- HCI Sockets ----- */
	646	void hci_send_to_sock(struct hci_dev hdev, struct sk_buff skb);
	647
	648	/* HCI info for socket */
	649	#define hci_pi(sk) ((struct hci_pinfo *) sk)
	650
	651	struct hci_pinfo {
	652	struct bt_sock bt;
	653	struct hci_dev *hdev;
	654	struct hci_filter filter;
	655	__u32 cmsg_mask;
	656	};
	657
	658	/* HCI security filter */
	659	#define HCI_SFLT_MAX_OGF 5
	660
	661	struct hci_sec_filter {
	662	__u32 type_mask;
	663	__u32 event_mask[2];
	664	__u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
	665	};
	666
	667	/* ----- HCI requests ----- */
	668	#define HCI_REQ_DONE 0
	669	#define HCI_REQ_PEND 1
	670	#define HCI_REQ_CANCELED 2
	671
a6a67efd TG	672	#define hci_req_lock(d) mutex_lock(&d->req_lock)
a6a67efd TG	673	#define hci_req_unlock(d) mutex_unlock(&d->req_lock)
1da177e4 LT	674
	675	void hci_req_complete(struct hci_dev *hdev, int result);
	676
	677	#endif /* __HCI_CORE_H */