自学教程：C++ BT_DBG函数代码示例

static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen){	struct sock *sk = sock->sk;	struct bt_security sec;	struct bt_power pwr;	int len, err = 0;	BT_DBG("sk %p", sk);	if (level == SOL_L2CAP)		return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);	if (level != SOL_BLUETOOTH)		return -ENOPROTOOPT;	if (get_user(len, optlen))		return -EFAULT;	lock_sock(sk);	switch (optname) {	case BT_SECURITY:		if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM				&& sk->sk_type != SOCK_RAW) {			err = -EINVAL;			break;		}		memset(&sec, 0, sizeof(sec));		sec.level = l2cap_pi(sk)->sec_level;		if (sk->sk_state == BT_CONNECTED) {			sec.key_size = l2cap_pi(sk)->conn->hcon->enc_key_size;			sec.level = l2cap_pi(sk)->conn->hcon->sec_level;		}		len = min_t(unsigned int, len, sizeof(sec));		if (copy_to_user(optval, (char *) &sec, len))			err = -EFAULT;		break;	case BT_DEFER_SETUP:		if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {			err = -EINVAL;			break;		}		if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))			err = -EFAULT;		break;	case BT_POWER:		if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM				&& sk->sk_type != SOCK_RAW) {			err = -EINVAL;			break;		}		pwr.force_active = l2cap_pi(sk)->force_active;		len = min_t(unsigned int, len, sizeof(pwr));		if (copy_to_user(optval, (char *) &pwr, len))			err = -EFAULT;		break;	case BT_AMP_POLICY:		if (put_user(l2cap_pi(sk)->amp_pref, (u32 __user *) optval))			err = -EFAULT;		break;	case BT_LE_PARAMS:		if (l2cap_pi(sk)->scid != L2CAP_CID_LE_DATA) {			err = -EINVAL;			break;		}		if (copy_to_user(optval, (char *) &bt_sk(sk)->le_params,						sizeof(bt_sk(sk)->le_params)))			err = -EFAULT;		break;	default:		err = -ENOPROTOOPT;		break;	}	release_sock(sk);	return err;}

static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb){	struct hci_ev_conn_complete *ev = (void *) skb->data;	struct hci_conn *conn;	BT_DBG("%s", hdev->name);	hci_dev_lock(hdev);	conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);	if (!conn) {		if (ev->link_type != SCO_LINK)			goto unlock;		conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);		if (!conn)			goto unlock;		conn->type = SCO_LINK;	}	if (!ev->status) {		conn->handle = __le16_to_cpu(ev->handle);		if (conn->type == ACL_LINK) {			conn->state = BT_CONFIG;			hci_conn_hold(conn);			conn->disc_timeout = HCI_DISCONN_TIMEOUT;		} else			conn->state = BT_CONNECTED;		hci_conn_hold_device(conn);		hci_conn_add_sysfs(conn);		if (test_bit(HCI_AUTH, &hdev->flags))			conn->link_mode |= HCI_LM_AUTH;		if (test_bit(HCI_ENCRYPT, &hdev->flags))			conn->link_mode |= HCI_LM_ENCRYPT;		/* Get remote features */		if (conn->type == ACL_LINK) {			struct hci_cp_read_remote_features cp;			cp.handle = ev->handle;			hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,							sizeof(cp), &cp);		}		/* Set packet type for incoming connection */		if (!conn->out && hdev->hci_ver < 3) {			struct hci_cp_change_conn_ptype cp;			cp.handle = ev->handle;			cp.pkt_type = cpu_to_le16(conn->pkt_type);			hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,							sizeof(cp), &cp);		}	} else		conn->state = BT_CLOSED;	if (conn->type == ACL_LINK) {		struct hci_conn *sco = conn->link;		if (sco) {			if (!ev->status) {				if (lmp_esco_capable(hdev))					hci_setup_sync(sco, conn->handle);				else					hci_add_sco(sco, conn->handle);			} else {				hci_proto_connect_cfm(sco, ev->status);				hci_conn_del(sco);			}		}	}	if (ev->status) {		hci_proto_connect_cfm(conn, ev->status);		hci_conn_del(conn);	} else if (ev->link_type != ACL_LINK)		hci_proto_connect_cfm(conn, ev->status);unlock:	hci_dev_unlock(hdev);	hci_conn_check_pending(hdev);}

static int bnep_net_set_mac_addr(struct net_device *dev, void *arg){	BT_DBG("%s", dev->name);	return 0;}

static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb){	BT_DBG("%s", hdev->name);}

static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status){	BT_DBG("%s status 0x%x", hdev->name, status);}

static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb){	BT_DBG("%s", hdev->name);}

static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb){	struct hci_ev_cmd_status *ev = (void *) skb->data;	__u16 opcode;	skb_pull(skb, sizeof(*ev));	opcode = __le16_to_cpu(ev->opcode);	switch (opcode) {	case HCI_OP_INQUIRY:		hci_cs_inquiry(hdev, ev->status);		break;	case HCI_OP_CREATE_CONN:		hci_cs_create_conn(hdev, ev->status);		break;	case HCI_OP_ADD_SCO:		hci_cs_add_sco(hdev, ev->status);		break;	case HCI_OP_AUTH_REQUESTED:		hci_cs_auth_requested(hdev, ev->status);		break;	case HCI_OP_SET_CONN_ENCRYPT:		hci_cs_set_conn_encrypt(hdev, ev->status);		break;	case HCI_OP_REMOTE_NAME_REQ:		hci_cs_remote_name_req(hdev, ev->status);		break;	case HCI_OP_READ_REMOTE_FEATURES:		hci_cs_read_remote_features(hdev, ev->status);		break;	case HCI_OP_READ_REMOTE_EXT_FEATURES:		hci_cs_read_remote_ext_features(hdev, ev->status);		break;	case HCI_OP_SETUP_SYNC_CONN:		hci_cs_setup_sync_conn(hdev, ev->status);		break;	case HCI_OP_SNIFF_MODE:		hci_cs_sniff_mode(hdev, ev->status);		break;	case HCI_OP_EXIT_SNIFF_MODE:		hci_cs_exit_sniff_mode(hdev, ev->status);		break;	default:		BT_DBG("%s opcode 0x%x", hdev->name, opcode);		break;	}	if (ev->ncmd) {		atomic_set(&hdev->cmd_cnt, 1);		if (!skb_queue_empty(&hdev->cmd_q))			tasklet_schedule(&hdev->cmd_task);	}}

void on_nble_gap_connect_evt(const struct nble_gap_connect_evt *evt){    struct bt_conn *conn;    /* Make lookup to check if there's a connection object in CONNECT state     * associated with passed peer LE address.     */    conn = bt_conn_lookup_state_le(&evt->peer_bda, BT_CONN_CONNECT);#if 0    /* Nordic has no connection error */    if (evt->status) {        if (!conn) {            return;        }        conn->err = BT_HCI_ERR_UNACCEPT_CONN_PARAMS;        bt_conn_set_state(conn, BT_CONN_DISCONNECTED);        /* Drop the reference got by lookup call in CONNECT state.         * We are now in DISCONNECTED state since no successful LE         * link been made.         */        bt_conn_unref(conn);        return;    }#endif    /*     * clear advertising even if we are not able to add connection object     * to keep host in sync with controller state     */    if (evt->role_slave == BT_CONN_ROLE_SLAVE) {        atomic_clear_bit(bt_dev.flags, BT_DEV_ADVERTISING);    }    if (!conn) {        conn = bt_conn_add_le(&evt->peer_bda);    }    if (!conn) {        BT_DBG("Unable to add new conn for handle %u",               evt->conn_handle);        return;    }    conn->handle = evt->conn_handle;    bt_addr_le_copy(&conn->le.dst, &evt->peer_bda);    conn->le.interval = evt->conn_values.interval;    conn->le.latency = evt->conn_values.latency;    conn->le.timeout = evt->conn_values.supervision_to;    conn->role = evt->role_slave;#if 0    src.type = BT_ADDR_LE_PUBLIC;    memcpy(src.val, bt_dev.bdaddr.val, sizeof(bt_dev.bdaddr.val));    /* use connection address (instead of identity address) as initiator     * or responder address     */    if (conn->role == BT_HCI_ROLE_MASTER) {        bt_addr_le_copy(&conn->le.init_addr, &src);        bt_addr_le_copy(&conn->le.resp_addr, &evt->peer_addr);    } else {        bt_addr_le_copy(&conn->le.init_addr, &evt->peer_addr);        bt_addr_le_copy(&conn->le.resp_addr, &src);    }#endif    bt_conn_set_state(conn, BT_CONN_CONNECTED);    /* Note: Connection update removed because Windows interop and BT spec recommendations */    bt_conn_unref(conn);#if 0    bt_le_scan_update(false);#endif}

void on_nble_up(void){    BT_DBG("%s", __FUNCTION__);    if (bt_ready_cb)        bt_ready_cb(bt_init());}

void l2cap_sock_clear_timer(struct sock *sk){	BT_DBG("sock %p state %d", sk, sk->sk_state);	sk_stop_timer(sk, &sk->sk_timer);}

static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len){	struct sock *sk = sock->sk;	struct l2cap_pinfo *pi = l2cap_pi(sk);	struct sk_buff *skb;	struct sk_buff_head seg_queue;	int err;	u8 amp_id;	BT_DBG("sock %p, sk %p", sock, sk);	err = sock_error(sk);	if (err)		return err;	if (msg->msg_flags & MSG_OOB)		return -EOPNOTSUPP;	lock_sock(sk);	if (sk->sk_state != BT_CONNECTED) {		err = -ENOTCONN;		goto done;	}	/* Connectionless channel */	if (sk->sk_type == SOCK_DGRAM) {		skb = l2cap_create_connless_pdu(sk, msg, len);		if (IS_ERR(skb)) {			err = PTR_ERR(skb);		} else {			l2cap_do_send(sk, skb);			err = len;		}		goto done;	}	switch (pi->mode) {	case L2CAP_MODE_BASIC:		/* Check outgoing MTU */		if (len > pi->omtu) {			err = -EMSGSIZE;			goto done;		}		/* Create a basic PDU */		skb = l2cap_create_basic_pdu(sk, msg, len);		if (IS_ERR(skb)) {			err = PTR_ERR(skb);			goto done;		}		l2cap_do_send(sk, skb);		err = len;		break;	case L2CAP_MODE_ERTM:	case L2CAP_MODE_STREAMING:		/* Check outgoing MTU */		if (len > pi->omtu) {			err = -EMSGSIZE;			goto done;		}		__skb_queue_head_init(&seg_queue);		/* Do segmentation before calling in to the state machine,		 * since it's possible to block while waiting for memory		 * allocation.		 */		amp_id = pi->amp_id;		err = l2cap_segment_sdu(sk, &seg_queue, msg, len, 0);		/* The socket lock is released while segmenting, so check		 * that the socket is still connected		 */		if (sk->sk_state != BT_CONNECTED) {			__skb_queue_purge(&seg_queue);			err = -ENOTCONN;		}		if (err) {			BT_DBG("Error %d, sk_sndbuf %d, sk_wmem_alloc %d",				err, sk->sk_sndbuf,				atomic_read(&sk->sk_wmem_alloc));			break;		}		if (pi->amp_id != amp_id) {			/* Channel moved while unlocked. Resegment. */			err = l2cap_resegment_queue(sk, &seg_queue);			if (err)				break;		}		if (pi->mode != L2CAP_MODE_STREAMING)			err = l2cap_ertm_tx(sk, 0, &seg_queue,				L2CAP_ERTM_EVENT_DATA_REQUEST);//.........这里部分代码省略.........

static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen){	struct sock *sk = sock->sk;	struct bt_security sec;	struct bt_power pwr;	struct bt_le_params le_params;	struct l2cap_conn *conn;	int len, err = 0;	u32 opt;	BT_DBG("sk %p", sk);	if (level == SOL_L2CAP)		return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);	if (level != SOL_BLUETOOTH)		return -ENOPROTOOPT;	lock_sock(sk);	switch (optname) {	case BT_SECURITY:		if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM				&& sk->sk_type != SOCK_RAW) {			err = -EINVAL;			break;		}		sec.level = BT_SECURITY_LOW;		len = min_t(unsigned int, sizeof(sec), optlen);		if (copy_from_user((char *) &sec, optval, len)) {			err = -EFAULT;			break;		}		if (sec.level < BT_SECURITY_LOW ||					sec.level > BT_SECURITY_HIGH) {			err = -EINVAL;			break;		}		l2cap_pi(sk)->sec_level = sec.level;		conn = l2cap_pi(sk)->conn;		if (conn && l2cap_pi(sk)->scid == L2CAP_CID_LE_DATA) {			if (!conn->hcon->out) {				err = -EINVAL;				break;			}			if (smp_conn_security(conn, sec.level))				break;			err = 0;			sk->sk_state = BT_CONFIG;		}		break;	case BT_DEFER_SETUP:		if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {			err = -EINVAL;			break;		}		if (get_user(opt, (u32 __user *) optval)) {			err = -EFAULT;			break;		}		bt_sk(sk)->defer_setup = opt;		break;	case BT_POWER:		if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM				&& sk->sk_type != SOCK_RAW) {			err = -EINVAL;			break;		}		pwr.force_active = 1;		len = min_t(unsigned int, sizeof(pwr), optlen);		if (copy_from_user((char *) &pwr, optval, len)) {			err = -EFAULT;			break;		}		l2cap_pi(sk)->force_active = pwr.force_active;		break;	case BT_AMP_POLICY:		if (get_user(opt, (u32 __user *) optval)) {			err = -EFAULT;			break;		}		if ((opt > BT_AMP_POLICY_PREFER_AMP) ||			((l2cap_pi(sk)->mode != L2CAP_MODE_ERTM) &&			 (l2cap_pi(sk)->mode != L2CAP_MODE_STREAMING))) {			err = -EINVAL;//.........这里部分代码省略.........

void l2cap_sock_set_timer(struct sock *sk, long timeout){	BT_DBG("sk %p state %d timeout %ld", sk, sk->sk_state, timeout);	sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);}

static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen){	struct sock *sk = sock->sk;	struct l2cap_options opts;	int len, le_sock, err = 0;	u32 opt;	BT_DBG("sk %p", sk);	lock_sock(sk);	le_sock = l2cap_pi(sk)->scid == L2CAP_CID_LE_DATA;	switch (optname) {	case L2CAP_OPTIONS:		if (sk->sk_state == BT_CONNECTED && !le_sock) {			err = -EINVAL;			break;		}		opts.imtu     = l2cap_pi(sk)->imtu;		opts.omtu     = l2cap_pi(sk)->omtu;		opts.flush_to = l2cap_pi(sk)->flush_to;		opts.mode     = l2cap_pi(sk)->mode;		opts.fcs      = l2cap_pi(sk)->fcs;		opts.max_tx   = l2cap_pi(sk)->max_tx;		opts.txwin_size = l2cap_pi(sk)->tx_win;		len = min_t(unsigned int, sizeof(opts), optlen);		if (copy_from_user((char *) &opts, optval, len)) {			err = -EFAULT;			break;		}		if ((opts.imtu || opts.omtu) && le_sock &&				(sk->sk_state == BT_CONNECTED)) {			if (opts.imtu >= L2CAP_LE_DEFAULT_MTU)				l2cap_pi(sk)->imtu = opts.imtu;			if (opts.omtu >= L2CAP_LE_DEFAULT_MTU)				l2cap_pi(sk)->omtu = opts.omtu;			if (opts.imtu < L2CAP_LE_DEFAULT_MTU ||					opts.omtu < L2CAP_LE_DEFAULT_MTU)				err = -EINVAL;			break;		}		if (opts.txwin_size < 1 ||			opts.txwin_size > L2CAP_TX_WIN_MAX_EXTENDED) {			err = -EINVAL;			break;		}		l2cap_pi(sk)->mode = opts.mode;		switch (l2cap_pi(sk)->mode) {		case L2CAP_MODE_BASIC:			l2cap_pi(sk)->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;			break;		case L2CAP_MODE_STREAMING:			if (!disable_ertm) {				/* No fallback to ERTM or Basic mode */				l2cap_pi(sk)->conf_state |=						L2CAP_CONF_STATE2_DEVICE;				break;			}			err = -EINVAL;			break;		case L2CAP_MODE_ERTM:			if (!disable_ertm)				break;			/* fall through */		default:			err = -EINVAL;			break;		}		l2cap_pi(sk)->imtu = opts.imtu;		l2cap_pi(sk)->omtu = opts.omtu;		l2cap_pi(sk)->fcs  = opts.fcs;		l2cap_pi(sk)->max_tx = opts.max_tx;		l2cap_pi(sk)->tx_win = opts.txwin_size;		l2cap_pi(sk)->flush_to = opts.flush_to;		break;	case L2CAP_LM:		if (get_user(opt, (u32 __user *) optval)) {			err = -EFAULT;			break;		}		if (opt & L2CAP_LM_AUTH)			l2cap_pi(sk)->sec_level = BT_SECURITY_LOW;		if (opt & L2CAP_LM_ENCRYPT)			l2cap_pi(sk)->sec_level = BT_SECURITY_MEDIUM;		if (opt & L2CAP_LM_SECURE)			l2cap_pi(sk)->sec_level = BT_SECURITY_HIGH;		l2cap_pi(sk)->role_switch    = (opt & L2CAP_LM_MASTER);		l2cap_pi(sk)->force_reliable = (opt & L2CAP_LM_RELIABLE);		l2cap_pi(sk)->flushable = (opt & L2CAP_LM_FLUSHABLE);		break;//.........这里部分代码省略.........

static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb){	BT_DBG("%s", hdev->name);	hci_conn_check_pending(hdev);}

static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb){	BT_DBG("%s", hdev->name);}

//.........这里部分代码省略.........		hci_cc_read_def_link_policy(hdev, skb);		break;	case HCI_OP_WRITE_DEF_LINK_POLICY:		hci_cc_write_def_link_policy(hdev, skb);		break;	case HCI_OP_RESET:		hci_cc_reset(hdev, skb);		break;	case HCI_OP_WRITE_LOCAL_NAME:		hci_cc_write_local_name(hdev, skb);		break;	case HCI_OP_READ_LOCAL_NAME:		hci_cc_read_local_name(hdev, skb);		break;	case HCI_OP_WRITE_AUTH_ENABLE:		hci_cc_write_auth_enable(hdev, skb);		break;	case HCI_OP_WRITE_ENCRYPT_MODE:		hci_cc_write_encrypt_mode(hdev, skb);		break;	case HCI_OP_WRITE_SCAN_ENABLE:		hci_cc_write_scan_enable(hdev, skb);		break;	case HCI_OP_READ_CLASS_OF_DEV:		hci_cc_read_class_of_dev(hdev, skb);		break;	case HCI_OP_WRITE_CLASS_OF_DEV:		hci_cc_write_class_of_dev(hdev, skb);		break;	case HCI_OP_READ_VOICE_SETTING:		hci_cc_read_voice_setting(hdev, skb);		break;	case HCI_OP_WRITE_VOICE_SETTING:		hci_cc_write_voice_setting(hdev, skb);		break;	case HCI_OP_HOST_BUFFER_SIZE:		hci_cc_host_buffer_size(hdev, skb);		break;	case HCI_OP_READ_SSP_MODE:		hci_cc_read_ssp_mode(hdev, skb);		break;	case HCI_OP_WRITE_SSP_MODE:		hci_cc_write_ssp_mode(hdev, skb);		break;	case HCI_OP_READ_LOCAL_VERSION:		hci_cc_read_local_version(hdev, skb);		break;	case HCI_OP_READ_LOCAL_COMMANDS:		hci_cc_read_local_commands(hdev, skb);		break;	case HCI_OP_READ_LOCAL_FEATURES:		hci_cc_read_local_features(hdev, skb);		break;	case HCI_OP_READ_BUFFER_SIZE:		hci_cc_read_buffer_size(hdev, skb);		break;	case HCI_OP_READ_BD_ADDR:		hci_cc_read_bd_addr(hdev, skb);		break;#ifdef CONFIG_BT_DEVICE    case HCI_OP_INQUIRY:    case 0x0403:        if(!hdev->inquiry_state){            hdev->inquiry_state = 1;            tasklet_disable(&hdev->tx_task);        }        break;#endif	default:		BT_DBG("%s opcode 0x%x", hdev->name, opcode);		break;	}	if (ev->ncmd) {		atomic_set(&hdev->cmd_cnt, 1);		if (!skb_queue_empty(&hdev->cmd_q))			tasklet_schedule(&hdev->cmd_task);	}}

static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb){	BT_DBG("%s", hdev->name);}

//.........这里部分代码省略.........	case HCI_EV_REMOTE_FEATURES:		hci_remote_features_evt(hdev, skb);		break;	case HCI_EV_REMOTE_VERSION:		hci_remote_version_evt(hdev, skb);		break;	case HCI_EV_QOS_SETUP_COMPLETE:		hci_qos_setup_complete_evt(hdev, skb);		break;	case HCI_EV_CMD_COMPLETE:		hci_cmd_complete_evt(hdev, skb);		break;	case HCI_EV_CMD_STATUS:		hci_cmd_status_evt(hdev, skb);		break;	case HCI_EV_ROLE_CHANGE:		hci_role_change_evt(hdev, skb);		break;	case HCI_EV_NUM_COMP_PKTS:		hci_num_comp_pkts_evt(hdev, skb);		break;	case HCI_EV_MODE_CHANGE:		hci_mode_change_evt(hdev, skb);		break;	case HCI_EV_PIN_CODE_REQ:		hci_pin_code_request_evt(hdev, skb);		break;	case HCI_EV_LINK_KEY_REQ:		hci_link_key_request_evt(hdev, skb);		break;	case HCI_EV_LINK_KEY_NOTIFY:		hci_link_key_notify_evt(hdev, skb);		break;	case HCI_EV_CLOCK_OFFSET:		hci_clock_offset_evt(hdev, skb);		break;	case HCI_EV_PKT_TYPE_CHANGE:		hci_pkt_type_change_evt(hdev, skb);		break;	case HCI_EV_PSCAN_REP_MODE:		hci_pscan_rep_mode_evt(hdev, skb);		break;	case HCI_EV_INQUIRY_RESULT_WITH_RSSI:		hci_inquiry_result_with_rssi_evt(hdev, skb);		break;	case HCI_EV_REMOTE_EXT_FEATURES:		hci_remote_ext_features_evt(hdev, skb);		break;	case HCI_EV_SYNC_CONN_COMPLETE:		hci_sync_conn_complete_evt(hdev, skb);		break;	case HCI_EV_SYNC_CONN_CHANGED:		hci_sync_conn_changed_evt(hdev, skb);		break;	case HCI_EV_SNIFF_SUBRATE:		hci_sniff_subrate_evt(hdev, skb);		break;	case HCI_EV_EXTENDED_INQUIRY_RESULT:		hci_extended_inquiry_result_evt(hdev, skb);		break;	case HCI_EV_IO_CAPA_REQUEST:		hci_io_capa_request_evt(hdev, skb);		break;	case HCI_EV_SIMPLE_PAIR_COMPLETE:		hci_simple_pair_complete_evt(hdev, skb);		break;	case HCI_EV_REMOTE_HOST_FEATURES:		hci_remote_host_features_evt(hdev, skb);		break;	default:		BT_DBG("%s event 0x%x", hdev->name, event);		break;	}	kfree_skb(skb);	hdev->stat.evt_rx++;}

static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb){	BT_DBG("%s", hdev->name);}

static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb){	struct hci_ev_conn_request *ev = (void *) skb->data;	int mask = hdev->link_mode;	BT_DBG("%s bdaddr %s type 0x%x", hdev->name,					batostr(&ev->bdaddr), ev->link_type);	mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);	if (mask & HCI_LM_ACCEPT) {		/* Connection accepted */		struct inquiry_entry *ie;		struct hci_conn *conn;		hci_dev_lock(hdev);		if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))			memcpy(ie->data.dev_class, ev->dev_class, 3);		conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);		if (!conn) {			/* pkt_type not yet used for incoming connections */			if (!(conn = hci_conn_add(hdev, ev->link_type, 0,							&ev->bdaddr))) {				BT_ERR("No memmory for new connection");				hci_dev_unlock(hdev);				return;			}		}		memcpy(conn->dev_class, ev->dev_class, 3);		conn->state = BT_CONNECT;		hci_dev_unlock(hdev);		if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {			struct hci_cp_accept_conn_req cp;			bacpy(&cp.bdaddr, &ev->bdaddr);			if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))				cp.role = 0x00; /* Become master */			else				cp.role = 0x01; /* Remain slave */			hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,							sizeof(cp), &cp);		} else {			struct hci_cp_accept_sync_conn_req cp;			bacpy(&cp.bdaddr, &ev->bdaddr);			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.content_format = cpu_to_le16(hdev->voice_setting);			cp.retrans_effort = 0xff;			hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,							sizeof(cp), &cp);		}	} else {		/* Connection rejected */		struct hci_cp_reject_conn_req cp;		bacpy(&cp.bdaddr, &ev->bdaddr);		cp.reason = 0x0f;		hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);	}}

static void bnep_net_timeout(struct net_device *dev){	BT_DBG("net_timeout");	netif_wake_queue(dev);}

static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen){	struct sock *sk = sock->sk;	struct l2cap_options opts;	struct l2cap_conninfo cinfo;	int len, err = 0;	u32 opt;	BT_DBG("sk %p", sk);	if (get_user(len, optlen))		return -EFAULT;	lock_sock(sk);	switch (optname) {	case L2CAP_OPTIONS:		memset(&opts, 0, sizeof(opts));		opts.imtu     = l2cap_pi(sk)->imtu;		opts.omtu     = l2cap_pi(sk)->omtu;		opts.flush_to = l2cap_pi(sk)->flush_to;		opts.mode     = l2cap_pi(sk)->mode;		opts.fcs      = l2cap_pi(sk)->fcs;		opts.max_tx   = l2cap_pi(sk)->max_tx;		opts.txwin_size = l2cap_pi(sk)->tx_win;		len = min_t(unsigned int, len, sizeof(opts));		if (copy_to_user(optval, (char *) &opts, len))			err = -EFAULT;		break;	case L2CAP_LM:		switch (l2cap_pi(sk)->sec_level) {		case BT_SECURITY_LOW:			opt = L2CAP_LM_AUTH;			break;		case BT_SECURITY_MEDIUM:			opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;			break;		case BT_SECURITY_HIGH:			opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |							L2CAP_LM_SECURE;			break;		default:			opt = 0;			break;		}		if (l2cap_pi(sk)->role_switch)			opt |= L2CAP_LM_MASTER;		if (l2cap_pi(sk)->force_reliable)			opt |= L2CAP_LM_RELIABLE;		if (l2cap_pi(sk)->flushable)			opt |= L2CAP_LM_FLUSHABLE;		if (put_user(opt, (u32 __user *) optval))			err = -EFAULT;		break;	case L2CAP_CONNINFO:		if (sk->sk_state != BT_CONNECTED &&					!(sk->sk_state == BT_CONNECT2 &&						bt_sk(sk)->defer_setup)) {			err = -ENOTCONN;			break;		}		cinfo.hci_handle = l2cap_pi(sk)->conn->hcon->handle;		memcpy(cinfo.dev_class, l2cap_pi(sk)->conn->hcon->dev_class, 3);		len = min_t(unsigned int, len, sizeof(cinfo));		if (copy_to_user(optval, (char *) &cinfo, len))			err = -EFAULT;		break;	default:		err = -ENOPROTOOPT;		break;	}	release_sock(sk);	return err;}