[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / hci_conn.c

/*
   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.
*/

/* Bluetooth HCI connection handling. */

#include <linux/module.h>

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/interrupt.h>
#include <linux/notifier.h>
#include <net/sock.h>

#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/unaligned.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>

#ifndef CONFIG_BT_HCI_CORE_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif

void hci_acl_connect(struct hci_conn *conn)
{
	struct hci_dev *hdev = conn->hdev;
	struct inquiry_entry *ie;
	struct hci_cp_create_conn cp;

	BT_DBG("%p", conn);

	conn->state = BT_CONNECT;
	conn->out = 1;

	conn->link_mode = HCI_LM_MASTER;

	conn->attempt++;

	conn->link_policy = hdev->link_policy;

	memset(&cp, 0, sizeof(cp));
	bacpy(&cp.bdaddr, &conn->dst);
	cp.pscan_rep_mode = 0x02;

	if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
		if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
			cp.pscan_rep_mode = ie->data.pscan_rep_mode;
			cp.pscan_mode     = ie->data.pscan_mode;
			cp.clock_offset   = ie->data.clock_offset |
							cpu_to_le16(0x8000);
		}

		memcpy(conn->dev_class, ie->data.dev_class, 3);
		conn->ssp_mode = ie->data.ssp_mode;
	}

	cp.pkt_type = cpu_to_le16(conn->pkt_type);
	if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
		cp.role_switch = 0x01;
	else
		cp.role_switch = 0x00;

	hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
}

static void hci_acl_connect_cancel(struct hci_conn *conn)
{
	struct hci_cp_create_conn_cancel cp;

	BT_DBG("%p", conn);

	if (conn->hdev->hci_ver < 2)
		return;

	bacpy(&cp.bdaddr, &conn->dst);
	hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
}

void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
{
	struct hci_cp_disconnect cp;

	BT_DBG("%p", conn);

	conn->state = BT_DISCONN;

	cp.handle = cpu_to_le16(conn->handle);
	cp.reason = reason;
	hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
}

void hci_add_sco(struct hci_conn *conn, __u16 handle)
{
	struct hci_dev *hdev = conn->hdev;
	struct hci_cp_add_sco cp;

	BT_DBG("%p", conn);

	conn->state = BT_CONNECT;
	conn->out = 1;

	cp.handle   = cpu_to_le16(handle);
	cp.pkt_type = cpu_to_le16(conn->pkt_type);

	hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
}

void hci_setup_sync(struct hci_conn *conn, __u16 handle)
{
	struct hci_dev *hdev = conn->hdev;
	struct hci_cp_setup_sync_conn cp;

	BT_DBG("%p", conn);

	conn->state = BT_CONNECT;
	conn->out = 1;

	cp.handle   = cpu_to_le16(handle);
	cp.pkt_type = cpu_to_le16(conn->pkt_type);

	cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
	cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
	cp.max_latency    = cpu_to_le16(0xffff);
	cp.voice_setting  = cpu_to_le16(hdev->voice_setting);
	cp.retrans_effort = 0xff;

	hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
}

static void hci_conn_timeout(unsigned long arg)
{
	struct hci_conn *conn = (void *) arg;
	struct hci_dev *hdev = conn->hdev;

	BT_DBG("conn %p state %d", conn, conn->state);

	if (atomic_read(&conn->refcnt))
		return;

	hci_dev_lock(hdev);

	switch (conn->state) {
	case BT_CONNECT:
	case BT_CONNECT2:
		if (conn->type == ACL_LINK)
			hci_acl_connect_cancel(conn);
		else
			hci_acl_disconn(conn, 0x13);
		break;
	case BT_CONFIG:
	case BT_CONNECTED:
		hci_acl_disconn(conn, 0x13);
		break;
	default:
		conn->state = BT_CLOSED;
		break;
	}

	hci_dev_unlock(hdev);
}

static void hci_conn_idle(unsigned long arg)
{
	struct hci_conn *conn = (void *) arg;

	BT_DBG("conn %p mode %d", conn, conn->mode);

	hci_conn_enter_sniff_mode(conn);
}

struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
{
	struct hci_conn *conn;

	BT_DBG("%s dst %s", hdev->name, batostr(dst));

	conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
	if (!conn)
		return NULL;

	bacpy(&conn->dst, dst);
	conn->hdev  = hdev;
	conn->type  = type;
	conn->mode  = HCI_CM_ACTIVE;
	conn->state = BT_OPEN;

	conn->power_save = 1;

	switch (type) {
	case ACL_LINK:
		conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
		break;
	case SCO_LINK:
		if (lmp_esco_capable(hdev))
			conn->pkt_type = hdev->esco_type & SCO_ESCO_MASK;
		else
			conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
		break;
	case ESCO_LINK:
		conn->pkt_type = hdev->esco_type;
		break;
	}

	skb_queue_head_init(&conn->data_q);

	setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
	setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);

	atomic_set(&conn->refcnt, 0);

	hci_dev_hold(hdev);

	tasklet_disable(&hdev->tx_task);

	hci_conn_hash_add(hdev, conn);
	if (hdev->notify)
		hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);

	tasklet_enable(&hdev->tx_task);

	return conn;
}

int hci_conn_del(struct hci_conn *conn)
{
	struct hci_dev *hdev = conn->hdev;

	BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);

	del_timer(&conn->idle_timer);

	del_timer(&conn->disc_timer);

	if (conn->type == ACL_LINK) {
		struct hci_conn *sco = conn->link;
		if (sco)
			sco->link = NULL;

		/* Unacked frames */
		hdev->acl_cnt += conn->sent;
	} else {
		struct hci_conn *acl = conn->link;
		if (acl) {
			acl->link = NULL;
			hci_conn_put(acl);
		}
	}

	tasklet_disable(&hdev->tx_task);

	hci_conn_hash_del(hdev, conn);
	if (hdev->notify)
		hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);

	tasklet_enable(&hdev->tx_task);

	skb_queue_purge(&conn->data_q);

	return 0;
}

struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
{
	int use_src = bacmp(src, BDADDR_ANY);
	struct hci_dev *hdev = NULL;
	struct list_head *p;

	BT_DBG("%s -> %s", batostr(src), batostr(dst));

	read_lock_bh(&hci_dev_list_lock);

	list_for_each(p, &hci_dev_list) {
		struct hci_dev *d = list_entry(p, struct hci_dev, list);

		if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
			continue;

		/* Simple routing:
		 *   No source address - find interface with bdaddr != dst
		 *   Source address    - find interface with bdaddr == src
		 */

		if (use_src) {
			if (!bacmp(&d->bdaddr, src)) {
				hdev = d; break;
			}
		} else {
			if (bacmp(&d->bdaddr, dst)) {
				hdev = d; break;
			}
		}
	}

	if (hdev)
		hdev = hci_dev_hold(hdev);

	read_unlock_bh(&hci_dev_list_lock);
	return hdev;
}
EXPORT_SYMBOL(hci_get_route);

/* Create SCO or ACL connection.
 * Device _must_ be locked */
struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 auth_type)
{
	struct hci_conn *acl;
	struct hci_conn *sco;

	BT_DBG("%s dst %s", hdev->name, batostr(dst));

	if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
		if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
			return NULL;
	}

	hci_conn_hold(acl);

	if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
		acl->auth_type = auth_type;
		hci_acl_connect(acl);
	}

	if (type == ACL_LINK)
		return acl;

	if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
		if (!(sco = hci_conn_add(hdev, type, dst))) {
			hci_conn_put(acl);
			return NULL;
		}
	}

	acl->link = sco;
	sco->link = acl;

	hci_conn_hold(sco);

	if (acl->state == BT_CONNECTED &&
			(sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
		if (lmp_esco_capable(hdev))
			hci_setup_sync(sco, acl->handle);
		else
			hci_add_sco(sco, acl->handle);
	}

	return sco;
}
EXPORT_SYMBOL(hci_connect);

/* Check link security requirement */
int hci_conn_check_link_mode(struct hci_conn *conn)
{
	BT_DBG("conn %p", conn);

	if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
					!(conn->link_mode & HCI_LM_ENCRYPT))
		return 0;

	return 1;
}
EXPORT_SYMBOL(hci_conn_check_link_mode);

/* Authenticate remote device */
int hci_conn_auth(struct hci_conn *conn)
{
	BT_DBG("conn %p", conn);

	if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0) {
		if (!(conn->auth_type & 0x01)) {
			conn->auth_type |= 0x01;
			conn->link_mode &= ~HCI_LM_AUTH;
		}
	}

	if (conn->link_mode & HCI_LM_AUTH)
		return 1;

	if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
		struct hci_cp_auth_requested cp;
		cp.handle = cpu_to_le16(conn->handle);
		hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
							sizeof(cp), &cp);
	}
	return 0;
}
EXPORT_SYMBOL(hci_conn_auth);

/* Enable encryption */
int hci_conn_encrypt(struct hci_conn *conn)
{
	BT_DBG("conn %p", conn);

	if (conn->link_mode & HCI_LM_ENCRYPT)
		return hci_conn_auth(conn);

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

	if (hci_conn_auth(conn)) {
		struct hci_cp_set_conn_encrypt cp;
		cp.handle  = cpu_to_le16(conn->handle);
		cp.encrypt = 1;
		hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT,
							sizeof(cp), &cp);
	}
	return 0;
}
EXPORT_SYMBOL(hci_conn_encrypt);

/* Change link key */
int hci_conn_change_link_key(struct hci_conn *conn)
{
	BT_DBG("conn %p", conn);

	if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
		struct hci_cp_change_conn_link_key cp;
		cp.handle = cpu_to_le16(conn->handle);
		hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
							sizeof(cp), &cp);
	}
	return 0;
}
EXPORT_SYMBOL(hci_conn_change_link_key);

/* Switch role */
int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
{
	BT_DBG("conn %p", conn);

	if (!role && conn->link_mode & HCI_LM_MASTER)
		return 1;

	if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
		struct hci_cp_switch_role cp;
		bacpy(&cp.bdaddr, &conn->dst);
		cp.role = role;
		hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
	}
	return 0;
}
EXPORT_SYMBOL(hci_conn_switch_role);

/* Enter active mode */
void hci_conn_enter_active_mode(struct hci_conn *conn)
{
	struct hci_dev *hdev = conn->hdev;

	BT_DBG("conn %p mode %d", conn, conn->mode);

	if (test_bit(HCI_RAW, &hdev->flags))
		return;

	if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
		goto timer;

	if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
		struct hci_cp_exit_sniff_mode cp;
		cp.handle = cpu_to_le16(conn->handle);
		hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
	}

timer:
	if (hdev->idle_timeout > 0)
		mod_timer(&conn->idle_timer,
			jiffies + msecs_to_jiffies(hdev->idle_timeout));
}

/* Enter sniff mode */
void hci_conn_enter_sniff_mode(struct hci_conn *conn)
{
	struct hci_dev *hdev = conn->hdev;

	BT_DBG("conn %p mode %d", conn, conn->mode);

	if (test_bit(HCI_RAW, &hdev->flags))
		return;

	if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
		return;

	if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
		return;

	if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
		struct hci_cp_sniff_subrate cp;
		cp.handle             = cpu_to_le16(conn->handle);
		cp.max_latency        = cpu_to_le16(0);
		cp.min_remote_timeout = cpu_to_le16(0);
		cp.min_local_timeout  = cpu_to_le16(0);
		hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
	}

	if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
		struct hci_cp_sniff_mode cp;
		cp.handle       = cpu_to_le16(conn->handle);
		cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
		cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
		cp.attempt      = cpu_to_le16(4);
		cp.timeout      = cpu_to_le16(1);
		hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
	}
}

/* Drop all connection on the device */
void hci_conn_hash_flush(struct hci_dev *hdev)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	struct list_head *p;

	BT_DBG("hdev %s", hdev->name);

	p = h->list.next;
	while (p != &h->list) {
		struct hci_conn *c;

		c = list_entry(p, struct hci_conn, list);
		p = p->next;

		c->state = BT_CLOSED;

		hci_conn_del_sysfs(c);

		hci_proto_disconn_ind(c, 0x16);
		hci_conn_del(c);
	}
}

/* Check pending connect attempts */
void hci_conn_check_pending(struct hci_dev *hdev)
{
	struct hci_conn *conn;

	BT_DBG("hdev %s", hdev->name);

	hci_dev_lock(hdev);

	conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
	if (conn)
		hci_acl_connect(conn);

	hci_dev_unlock(hdev);
}

int hci_get_conn_list(void __user *arg)
{
	struct hci_conn_list_req req, *cl;
	struct hci_conn_info *ci;
	struct hci_dev *hdev;
	struct list_head *p;
	int n = 0, size, err;

	if (copy_from_user(&req, arg, sizeof(req)))
		return -EFAULT;

	if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
		return -EINVAL;

	size = sizeof(req) + req.conn_num * sizeof(*ci);

	if (!(cl = kmalloc(size, GFP_KERNEL)))
		return -ENOMEM;

	if (!(hdev = hci_dev_get(req.dev_id))) {
		kfree(cl);
		return -ENODEV;
	}

	ci = cl->conn_info;

	hci_dev_lock_bh(hdev);
	list_for_each(p, &hdev->conn_hash.list) {
		register struct hci_conn *c;
		c = list_entry(p, struct hci_conn, list);

		bacpy(&(ci + n)->bdaddr, &c->dst);
		(ci + n)->handle = c->handle;
		(ci + n)->type  = c->type;
		(ci + n)->out   = c->out;
		(ci + n)->state = c->state;
		(ci + n)->link_mode = c->link_mode;
		if (++n >= req.conn_num)
			break;
	}
	hci_dev_unlock_bh(hdev);

	cl->dev_id = hdev->id;
	cl->conn_num = n;
	size = sizeof(req) + n * sizeof(*ci);

	hci_dev_put(hdev);

	err = copy_to_user(arg, cl, size);
	kfree(cl);

	return err ? -EFAULT : 0;
}

int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
{
	struct hci_conn_info_req req;
	struct hci_conn_info ci;
	struct hci_conn *conn;
	char __user *ptr = arg + sizeof(req);

	if (copy_from_user(&req, arg, sizeof(req)))
		return -EFAULT;

	hci_dev_lock_bh(hdev);
	conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
	if (conn) {
		bacpy(&ci.bdaddr, &conn->dst);
		ci.handle = conn->handle;
		ci.type  = conn->type;
		ci.out   = conn->out;
		ci.state = conn->state;
		ci.link_mode = conn->link_mode;
	}
	hci_dev_unlock_bh(hdev);

	if (!conn)
		return -ENOENT;

	return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
}

int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
{
	struct hci_auth_info_req req;
	struct hci_conn *conn;

	if (copy_from_user(&req, arg, sizeof(req)))
		return -EFAULT;

	hci_dev_lock_bh(hdev);
	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
	if (conn)
		req.type = conn->auth_type;
	hci_dev_unlock_bh(hdev);

	if (!conn)
		return -ENOENT;

	return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
}
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	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
8e87d142 YH	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
1da177e4 LT	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	19
8e87d142 YH	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	22	SOFTWARE IS DISCLAIMED.
	23	*/
	24
	25	/* Bluetooth HCI connection handling. */
	26
1da177e4 LT	27	#include <linux/module.h>
	28
	29	#include <linux/types.h>
	30	#include <linux/errno.h>
	31	#include <linux/kernel.h>
1da177e4 LT	32	#include <linux/slab.h>
	33	#include <linux/poll.h>
	34	#include <linux/fcntl.h>
	35	#include <linux/init.h>
	36	#include <linux/skbuff.h>
	37	#include <linux/interrupt.h>
	38	#include <linux/notifier.h>
	39	#include <net/sock.h>
	40
	41	#include <asm/system.h>
	42	#include <asm/uaccess.h>
	43	#include <asm/unaligned.h>
	44
	45	#include <net/bluetooth/bluetooth.h>
	46	#include <net/bluetooth/hci_core.h>
	47
	48	#ifndef CONFIG_BT_HCI_CORE_DEBUG
	49	#undef BT_DBG
	50	#define BT_DBG(D...)
	51	#endif
	52
4c67bc74	53	void hci_acl_connect(struct hci_conn *conn)
1da177e4 LT	54	{
	55	struct hci_dev *hdev = conn->hdev;
	56	struct inquiry_entry *ie;
	57	struct hci_cp_create_conn cp;
	58
	59	BT_DBG("%p", conn);
	60
	61	conn->state = BT_CONNECT;
a8746417 MH	62	conn->out = 1;
a8746417 MH	63
1da177e4 LT	64	conn->link_mode = HCI_LM_MASTER;
1da177e4 LT	65
4c67bc74 MH	66	conn->attempt++;
4c67bc74 MH	67
e4e8e37c MH	68	conn->link_policy = hdev->link_policy;
e4e8e37c MH	69
1da177e4 LT	70	memset(&cp, 0, sizeof(cp));
	71	bacpy(&cp.bdaddr, &conn->dst);
	72	cp.pscan_rep_mode = 0x02;
	73
41a96212 MH	74	if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
	75	if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
	76	cp.pscan_rep_mode = ie->data.pscan_rep_mode;
	77	cp.pscan_mode = ie->data.pscan_mode;
	78	cp.clock_offset = ie->data.clock_offset \|
	79	cpu_to_le16(0x8000);
	80	}
	81
1da177e4	82	memcpy(conn->dev_class, ie->data.dev_class, 3);
41a96212	83	conn->ssp_mode = ie->data.ssp_mode;
1da177e4 LT	84	}
1da177e4 LT	85
a8746417	86	cp.pkt_type = cpu_to_le16(conn->pkt_type);
1da177e4	87	if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
b6a0dc82	88	cp.role_switch = 0x01;
1da177e4	89	else
b6a0dc82	90	cp.role_switch = 0x00;
4c67bc74	91
a9de9248	92	hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
1da177e4 LT	93	}
1da177e4 LT	94
6ac59344 MH	95	static void hci_acl_connect_cancel(struct hci_conn *conn)
	96	{
	97	struct hci_cp_create_conn_cancel cp;
	98
	99	BT_DBG("%p", conn);
	100
	101	if (conn->hdev->hci_ver < 2)
	102	return;
	103
	104	bacpy(&cp.bdaddr, &conn->dst);
a9de9248	105	hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
6ac59344 MH	106	}
6ac59344 MH	107
1da177e4 LT	108	void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
	109	{
	110	struct hci_cp_disconnect cp;
	111
	112	BT_DBG("%p", conn);
	113
	114	conn->state = BT_DISCONN;
	115
aca3192c	116	cp.handle = cpu_to_le16(conn->handle);
1da177e4	117	cp.reason = reason;
a9de9248	118	hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
1da177e4 LT	119	}
	120
	121	void hci_add_sco(struct hci_conn *conn, __u16 handle)
	122	{
	123	struct hci_dev *hdev = conn->hdev;
	124	struct hci_cp_add_sco cp;
	125
	126	BT_DBG("%p", conn);
	127
	128	conn->state = BT_CONNECT;
	129	conn->out = 1;
	130
aca3192c	131	cp.handle = cpu_to_le16(handle);
a8746417	132	cp.pkt_type = cpu_to_le16(conn->pkt_type);
1da177e4	133
a9de9248	134	hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
1da177e4 LT	135	}
1da177e4 LT	136
b6a0dc82 MH	137	void hci_setup_sync(struct hci_conn *conn, __u16 handle)
	138	{
	139	struct hci_dev *hdev = conn->hdev;
	140	struct hci_cp_setup_sync_conn cp;
	141
	142	BT_DBG("%p", conn);
	143
	144	conn->state = BT_CONNECT;
	145	conn->out = 1;
	146
	147	cp.handle = cpu_to_le16(handle);
a8746417	148	cp.pkt_type = cpu_to_le16(conn->pkt_type);
b6a0dc82 MH	149
	150	cp.tx_bandwidth = cpu_to_le32(0x00001f40);
	151	cp.rx_bandwidth = cpu_to_le32(0x00001f40);
	152	cp.max_latency = cpu_to_le16(0xffff);
	153	cp.voice_setting = cpu_to_le16(hdev->voice_setting);
	154	cp.retrans_effort = 0xff;
	155
	156	hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
	157	}
	158
1da177e4 LT	159	static void hci_conn_timeout(unsigned long arg)
1da177e4 LT	160	{
04837f64 MH	161	struct hci_conn conn = (void ) arg;
04837f64 MH	162	struct hci_dev *hdev = conn->hdev;
1da177e4 LT	163
	164	BT_DBG("conn %p state %d", conn, conn->state);
	165
	166	if (atomic_read(&conn->refcnt))
	167	return;
	168
	169	hci_dev_lock(hdev);
6ac59344 MH	170
	171	switch (conn->state) {
	172	case BT_CONNECT:
769be974	173	case BT_CONNECT2:
b6a0dc82 MH	174	if (conn->type == ACL_LINK)
	175	hci_acl_connect_cancel(conn);
	176	else
	177	hci_acl_disconn(conn, 0x13);
6ac59344	178	break;
769be974	179	case BT_CONFIG:
8e87d142	180	case BT_CONNECTED:
1da177e4	181	hci_acl_disconn(conn, 0x13);
6ac59344 MH	182	break;
6ac59344 MH	183	default:
1da177e4	184	conn->state = BT_CLOSED;
6ac59344 MH	185	break;
	186	}
	187
1da177e4	188	hci_dev_unlock(hdev);
1da177e4 LT	189	}
1da177e4 LT	190
04837f64	191	static void hci_conn_idle(unsigned long arg)
1da177e4	192	{
04837f64 MH	193	struct hci_conn conn = (void ) arg;
	194
	195	BT_DBG("conn %p mode %d", conn, conn->mode);
	196
	197	hci_conn_enter_sniff_mode(conn);
1da177e4 LT	198	}
	199
	200	struct hci_conn hci_conn_add(struct hci_dev hdev, int type, bdaddr_t *dst)
	201	{
	202	struct hci_conn *conn;
	203
	204	BT_DBG("%s dst %s", hdev->name, batostr(dst));
	205
04837f64 MH	206	conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
04837f64 MH	207	if (!conn)
1da177e4	208	return NULL;
1da177e4 LT	209
1da177e4 LT	210	bacpy(&conn->dst, dst);
a8746417 MH	211	conn->hdev = hdev;
	212	conn->type = type;
	213	conn->mode = HCI_CM_ACTIVE;
	214	conn->state = BT_OPEN;
1da177e4	215
04837f64 MH	216	conn->power_save = 1;
04837f64 MH	217
a8746417 MH	218	switch (type) {
	219	case ACL_LINK:
	220	conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
	221	break;
	222	case SCO_LINK:
	223	if (lmp_esco_capable(hdev))
	224	conn->pkt_type = hdev->esco_type & SCO_ESCO_MASK;
	225	else
	226	conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
	227	break;
	228	case ESCO_LINK:
	229	conn->pkt_type = hdev->esco_type;
	230	break;
	231	}
	232
1da177e4	233	skb_queue_head_init(&conn->data_q);
04837f64	234
b24b8a24 PE	235	setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
b24b8a24 PE	236	setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
1da177e4 LT	237
	238	atomic_set(&conn->refcnt, 0);
	239
	240	hci_dev_hold(hdev);
	241
	242	tasklet_disable(&hdev->tx_task);
	243
	244	hci_conn_hash_add(hdev, conn);
	245	if (hdev->notify)
	246	hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
	247
	248	tasklet_enable(&hdev->tx_task);
	249
	250	return conn;
	251	}
	252
	253	int hci_conn_del(struct hci_conn *conn)
	254	{
	255	struct hci_dev *hdev = conn->hdev;
	256
	257	BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
	258
04837f64 MH	259	del_timer(&conn->idle_timer);
	260
	261	del_timer(&conn->disc_timer);
1da177e4	262
5b7f9909	263	if (conn->type == ACL_LINK) {
1da177e4 LT	264	struct hci_conn *sco = conn->link;
	265	if (sco)
	266	sco->link = NULL;
	267
	268	/* Unacked frames */
	269	hdev->acl_cnt += conn->sent;
5b7f9909 MH	270	} else {
	271	struct hci_conn *acl = conn->link;
	272	if (acl) {
	273	acl->link = NULL;
	274	hci_conn_put(acl);
	275	}
1da177e4 LT	276	}
	277
	278	tasklet_disable(&hdev->tx_task);
7d0db0a3	279
1da177e4 LT	280	hci_conn_hash_del(hdev, conn);
	281	if (hdev->notify)
	282	hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
7d0db0a3	283
1da177e4	284	tasklet_enable(&hdev->tx_task);
7d0db0a3	285
1da177e4	286	skb_queue_purge(&conn->data_q);
1da177e4	287
1da177e4 LT	288	return 0;
	289	}
	290
	291	struct hci_dev hci_get_route(bdaddr_t dst, bdaddr_t *src)
	292	{
	293	int use_src = bacmp(src, BDADDR_ANY);
	294	struct hci_dev *hdev = NULL;
	295	struct list_head *p;
	296
	297	BT_DBG("%s -> %s", batostr(src), batostr(dst));
	298
	299	read_lock_bh(&hci_dev_list_lock);
	300
	301	list_for_each(p, &hci_dev_list) {
	302	struct hci_dev *d = list_entry(p, struct hci_dev, list);
	303
	304	if (!test_bit(HCI_UP, &d->flags) \|\| test_bit(HCI_RAW, &d->flags))
	305	continue;
	306
8e87d142	307	/* Simple routing:
1da177e4 LT	308	* No source address - find interface with bdaddr != dst
	309	* Source address - find interface with bdaddr == src
	310	*/
	311
	312	if (use_src) {
	313	if (!bacmp(&d->bdaddr, src)) {
	314	hdev = d; break;
	315	}
	316	} else {
	317	if (bacmp(&d->bdaddr, dst)) {
	318	hdev = d; break;
	319	}
	320	}
	321	}
	322
	323	if (hdev)
	324	hdev = hci_dev_hold(hdev);
	325
	326	read_unlock_bh(&hci_dev_list_lock);
	327	return hdev;
	328	}
	329	EXPORT_SYMBOL(hci_get_route);
	330
	331	/* Create SCO or ACL connection.
	332	* Device _must_ be locked */
09ab6f4c	333	struct hci_conn hci_connect(struct hci_dev hdev, int type, bdaddr_t *dst, __u8 auth_type)
1da177e4 LT	334	{
1da177e4 LT	335	struct hci_conn *acl;
5b7f9909	336	struct hci_conn *sco;
1da177e4 LT	337
	338	BT_DBG("%s dst %s", hdev->name, batostr(dst));
	339
	340	if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
	341	if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
	342	return NULL;
	343	}
	344
	345	hci_conn_hold(acl);
	346
09ab6f4c MH	347	if (acl->state == BT_OPEN \|\| acl->state == BT_CLOSED) {
09ab6f4c MH	348	acl->auth_type = auth_type;
1da177e4	349	hci_acl_connect(acl);
09ab6f4c	350	}
1da177e4	351
5b7f9909 MH	352	if (type == ACL_LINK)
5b7f9909 MH	353	return acl;
1da177e4	354
5b7f9909 MH	355	if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
	356	if (!(sco = hci_conn_add(hdev, type, dst))) {
	357	hci_conn_put(acl);
	358	return NULL;
1da177e4	359	}
5b7f9909	360	}
1da177e4	361
5b7f9909 MH	362	acl->link = sco;
5b7f9909 MH	363	sco->link = acl;
1da177e4	364
5b7f9909	365	hci_conn_hold(sco);
1da177e4	366
5b7f9909	367	if (acl->state == BT_CONNECTED &&
b6a0dc82 MH	368	(sco->state == BT_OPEN \|\| sco->state == BT_CLOSED)) {
	369	if (lmp_esco_capable(hdev))
	370	hci_setup_sync(sco, acl->handle);
	371	else
	372	hci_add_sco(sco, acl->handle);
	373	}
5b7f9909 MH	374
5b7f9909 MH	375	return sco;
1da177e4 LT	376	}
	377	EXPORT_SYMBOL(hci_connect);
	378
e7c29cb1 MH	379	/* Check link security requirement */
	380	int hci_conn_check_link_mode(struct hci_conn *conn)
	381	{
	382	BT_DBG("conn %p", conn);
	383
	384	if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
	385	!(conn->link_mode & HCI_LM_ENCRYPT))
	386	return 0;
	387
	388	return 1;
	389	}
	390	EXPORT_SYMBOL(hci_conn_check_link_mode);
	391
1da177e4 LT	392	/* Authenticate remote device */
	393	int hci_conn_auth(struct hci_conn *conn)
	394	{
	395	BT_DBG("conn %p", conn);
	396
40be492f MH	397	if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0) {
40be492f MH	398	if (!(conn->auth_type & 0x01)) {
09ab6f4c	399	conn->auth_type \|= 0x01;
40be492f MH	400	conn->link_mode &= ~HCI_LM_AUTH;
	401	}
	402	}
	403
1da177e4 LT	404	if (conn->link_mode & HCI_LM_AUTH)
	405	return 1;
	406
	407	if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
	408	struct hci_cp_auth_requested cp;
aca3192c	409	cp.handle = cpu_to_le16(conn->handle);
40be492f MH	410	hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
40be492f MH	411	sizeof(cp), &cp);
1da177e4 LT	412	}
	413	return 0;
	414	}
	415	EXPORT_SYMBOL(hci_conn_auth);
	416
	417	/* Enable encryption */
	418	int hci_conn_encrypt(struct hci_conn *conn)
	419	{
	420	BT_DBG("conn %p", conn);
	421
	422	if (conn->link_mode & HCI_LM_ENCRYPT)
40be492f	423	return hci_conn_auth(conn);
1da177e4 LT	424
	425	if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
	426	return 0;
	427
	428	if (hci_conn_auth(conn)) {
	429	struct hci_cp_set_conn_encrypt cp;
aca3192c	430	cp.handle = cpu_to_le16(conn->handle);
8e87d142	431	cp.encrypt = 1;
40be492f MH	432	hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT,
40be492f MH	433	sizeof(cp), &cp);
1da177e4 LT	434	}
	435	return 0;
	436	}
	437	EXPORT_SYMBOL(hci_conn_encrypt);
	438
	439	/* Change link key */
	440	int hci_conn_change_link_key(struct hci_conn *conn)
	441	{
	442	BT_DBG("conn %p", conn);
	443
	444	if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
	445	struct hci_cp_change_conn_link_key cp;
aca3192c	446	cp.handle = cpu_to_le16(conn->handle);
40be492f MH	447	hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
40be492f MH	448	sizeof(cp), &cp);
1da177e4 LT	449	}
	450	return 0;
	451	}
	452	EXPORT_SYMBOL(hci_conn_change_link_key);
	453
	454	/* Switch role */
	455	int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
	456	{
	457	BT_DBG("conn %p", conn);
	458
	459	if (!role && conn->link_mode & HCI_LM_MASTER)
	460	return 1;
	461
	462	if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
	463	struct hci_cp_switch_role cp;
	464	bacpy(&cp.bdaddr, &conn->dst);
	465	cp.role = role;
a9de9248	466	hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
1da177e4 LT	467	}
	468	return 0;
	469	}
	470	EXPORT_SYMBOL(hci_conn_switch_role);
	471
04837f64 MH	472	/* Enter active mode */
	473	void hci_conn_enter_active_mode(struct hci_conn *conn)
	474	{
	475	struct hci_dev *hdev = conn->hdev;
	476
	477	BT_DBG("conn %p mode %d", conn, conn->mode);
	478
	479	if (test_bit(HCI_RAW, &hdev->flags))
	480	return;
	481
	482	if (conn->mode != HCI_CM_SNIFF \|\| !conn->power_save)
	483	goto timer;
	484
	485	if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
	486	struct hci_cp_exit_sniff_mode cp;
aca3192c	487	cp.handle = cpu_to_le16(conn->handle);
a9de9248	488	hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
04837f64 MH	489	}
	490
	491	timer:
	492	if (hdev->idle_timeout > 0)
	493	mod_timer(&conn->idle_timer,
	494	jiffies + msecs_to_jiffies(hdev->idle_timeout));
	495	}
	496
	497	/* Enter sniff mode */
	498	void hci_conn_enter_sniff_mode(struct hci_conn *conn)
	499	{
	500	struct hci_dev *hdev = conn->hdev;
	501
	502	BT_DBG("conn %p mode %d", conn, conn->mode);
	503
	504	if (test_bit(HCI_RAW, &hdev->flags))
	505	return;
	506
	507	if (!lmp_sniff_capable(hdev) \|\| !lmp_sniff_capable(conn))
	508	return;
	509
	510	if (conn->mode != HCI_CM_ACTIVE \|\| !(conn->link_policy & HCI_LP_SNIFF))
	511	return;
	512
	513	if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
	514	struct hci_cp_sniff_subrate cp;
aca3192c YH	515	cp.handle = cpu_to_le16(conn->handle);
	516	cp.max_latency = cpu_to_le16(0);
	517	cp.min_remote_timeout = cpu_to_le16(0);
	518	cp.min_local_timeout = cpu_to_le16(0);
a9de9248	519	hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
04837f64 MH	520	}
	521
	522	if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
	523	struct hci_cp_sniff_mode cp;
aca3192c YH	524	cp.handle = cpu_to_le16(conn->handle);
	525	cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
	526	cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
	527	cp.attempt = cpu_to_le16(4);
	528	cp.timeout = cpu_to_le16(1);
a9de9248	529	hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
04837f64 MH	530	}
	531	}
	532
1da177e4 LT	533	/* Drop all connection on the device */
	534	void hci_conn_hash_flush(struct hci_dev *hdev)
	535	{
	536	struct hci_conn_hash *h = &hdev->conn_hash;
	537	struct list_head *p;
	538
	539	BT_DBG("hdev %s", hdev->name);
	540
	541	p = h->list.next;
	542	while (p != &h->list) {
	543	struct hci_conn *c;
	544
	545	c = list_entry(p, struct hci_conn, list);
	546	p = p->next;
	547
	548	c->state = BT_CLOSED;
	549
7d0db0a3 MH	550	hci_conn_del_sysfs(c);
7d0db0a3 MH	551
1da177e4 LT	552	hci_proto_disconn_ind(c, 0x16);
	553	hci_conn_del(c);
	554	}
	555	}
	556
a9de9248 MH	557	/* Check pending connect attempts */
	558	void hci_conn_check_pending(struct hci_dev *hdev)
	559	{
	560	struct hci_conn *conn;
	561
	562	BT_DBG("hdev %s", hdev->name);
	563
	564	hci_dev_lock(hdev);
	565
	566	conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
	567	if (conn)
	568	hci_acl_connect(conn);
	569
	570	hci_dev_unlock(hdev);
	571	}
	572
1da177e4 LT	573	int hci_get_conn_list(void __user *arg)
	574	{
	575	struct hci_conn_list_req req, *cl;
	576	struct hci_conn_info *ci;
	577	struct hci_dev *hdev;
	578	struct list_head *p;
	579	int n = 0, size, err;
	580
	581	if (copy_from_user(&req, arg, sizeof(req)))
	582	return -EFAULT;
	583
	584	if (!req.conn_num \|\| req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
	585	return -EINVAL;
	586
	587	size = sizeof(req) + req.conn_num * sizeof(*ci);
	588
12fe2c58	589	if (!(cl = kmalloc(size, GFP_KERNEL)))
1da177e4 LT	590	return -ENOMEM;
	591
	592	if (!(hdev = hci_dev_get(req.dev_id))) {
	593	kfree(cl);
	594	return -ENODEV;
	595	}
	596
	597	ci = cl->conn_info;
	598
	599	hci_dev_lock_bh(hdev);
	600	list_for_each(p, &hdev->conn_hash.list) {
	601	register struct hci_conn *c;
	602	c = list_entry(p, struct hci_conn, list);
	603
	604	bacpy(&(ci + n)->bdaddr, &c->dst);
	605	(ci + n)->handle = c->handle;
	606	(ci + n)->type = c->type;
	607	(ci + n)->out = c->out;
	608	(ci + n)->state = c->state;
	609	(ci + n)->link_mode = c->link_mode;
	610	if (++n >= req.conn_num)
	611	break;
	612	}
	613	hci_dev_unlock_bh(hdev);
	614
	615	cl->dev_id = hdev->id;
	616	cl->conn_num = n;
	617	size = sizeof(req) + n * sizeof(*ci);
	618
	619	hci_dev_put(hdev);
	620
	621	err = copy_to_user(arg, cl, size);
	622	kfree(cl);
	623
	624	return err ? -EFAULT : 0;
	625	}
	626
	627	int hci_get_conn_info(struct hci_dev hdev, void __user arg)
	628	{
	629	struct hci_conn_info_req req;
	630	struct hci_conn_info ci;
	631	struct hci_conn *conn;
	632	char __user *ptr = arg + sizeof(req);
	633
	634	if (copy_from_user(&req, arg, sizeof(req)))
	635	return -EFAULT;
	636
	637	hci_dev_lock_bh(hdev);
	638	conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
	639	if (conn) {
	640	bacpy(&ci.bdaddr, &conn->dst);
	641	ci.handle = conn->handle;
	642	ci.type = conn->type;
	643	ci.out = conn->out;
	644	ci.state = conn->state;
	645	ci.link_mode = conn->link_mode;
	646	}
	647	hci_dev_unlock_bh(hdev);
	648
	649	if (!conn)
	650	return -ENOENT;
	651
	652	return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
	653	}
40be492f MH	654
	655	int hci_get_auth_info(struct hci_dev hdev, void __user arg)
	656	{
	657	struct hci_auth_info_req req;
	658	struct hci_conn *conn;
	659
	660	if (copy_from_user(&req, arg, sizeof(req)))
	661	return -EFAULT;
	662
	663	hci_dev_lock_bh(hdev);
	664	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
	665	if (conn)
	666	req.type = conn->auth_type;
	667	hci_dev_unlock_bh(hdev);
	668
	669	if (!conn)
	670	return -ENOENT;
	671
	672	return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
	673	}