int
ng_hci_lp_enc_change(ng_hci_unit_con_p con, int status)
{
ng_hci_unit_p unit = con->unit;
struct ng_mesg *msg = NULL;
ng_hci_lp_enc_change_ep *ep = NULL;
int error;
if (con->link_type != NG_HCI_LINK_SCO) {
if (unit->acl != NULL && NG_HOOK_IS_VALID(unit->acl)) {
NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_ENC_CHG,
sizeof(*ep), M_NOWAIT);
if (msg != NULL) {
ep = (ng_hci_lp_enc_change_ep *) msg->data;
ep->status = status;
ep->link_type = con->link_type;
ep->con_handle = con->con_handle;
NG_SEND_MSG_HOOK(error, unit->node, msg,
unit->acl, 0);
}
} else
NG_HCI_INFO(
"%s: %s - ACL hook not valid, hook=%p\n",
__func__, NG_NODE_NAME(unit->node), unit->acl);
}
return (0);
} /* ng_hci_lp_con_cfm */
static void
bt3c_forward(node_p node, hook_p hook, void *arg1, int arg2)
{
bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node);
struct mbuf *m = NULL;
int error;
if (sc == NULL)
return;
if (sc->hook != NULL && NG_HOOK_IS_VALID(sc->hook)) {
for (;;) {
IF_DEQUEUE(&sc->inq, m);
if (m == NULL)
break;
NG_SEND_DATA_ONLY(error, sc->hook, m);
if (error != 0)
NG_BT3C_STAT_IERROR(sc->stat);
}
} else {
IF_LOCK(&sc->inq);
for (;;) {
_IF_DEQUEUE(&sc->inq, m);
if (m == NULL)
break;
NG_BT3C_STAT_IERROR(sc->stat);
NG_FREE_M(m);
}
IF_UNLOCK(&sc->inq);
}
} /* bt3c_forward */
void
ng_hci_mtap(ng_hci_unit_p unit, struct mbuf *m0)
{
struct mbuf *m = NULL;
int error = 0;
if (unit->raw != NULL && NG_HOOK_IS_VALID(unit->raw)) {
m = m_dup(m0, M_DONTWAIT);
if (m != NULL)
NG_SEND_DATA_ONLY(error, unit->raw, m);
if (error != 0)
NG_HCI_INFO(
"%s: %s - Could not forward packet, error=%d\n",
__func__, NG_NODE_NAME(unit->node), error);
}
} /* ng_hci_mtap */
int
ng_hci_lp_con_ind(ng_hci_unit_con_p con, u_int8_t *uclass)
{
ng_hci_unit_p unit = con->unit;
struct ng_mesg *msg = NULL;
ng_hci_lp_con_ind_ep *ep = NULL;
hook_p hook = NULL;
int error = 0;
/*
* Connection_Request event is generated for specific link type.
* Use link_type to select upstream hook.
*/
if (con->link_type == NG_HCI_LINK_ACL)
hook = unit->acl;
else
hook = unit->sco;
if (hook != NULL && NG_HOOK_IS_VALID(hook)) {
NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_CON_IND,
sizeof(*ep), M_NOWAIT);
if (msg == NULL)
return (ENOMEM);
ep = (ng_hci_lp_con_ind_ep *)(msg->data);
ep->link_type = con->link_type;
bcopy(uclass, ep->uclass, sizeof(ep->uclass));
bcopy(&con->bdaddr, &ep->bdaddr, sizeof(ep->bdaddr));
NG_SEND_MSG_HOOK(error, unit->node, msg, hook, 0);
} else {
NG_HCI_WARN(
"%s: %s - Upstream hook is not connected or not valid, hook=%p\n",
__func__, NG_NODE_NAME(unit->node), hook);
error = ENOTCONN;
}
return (error);
} /* ng_hci_lp_con_ind */
static int
ng_vlan_rcvmsg(node_p node, item_p item, hook_p lasthook)
{
const priv_p priv = NG_NODE_PRIVATE(node);
struct ng_mesg *msg, *resp = NULL;
struct ng_vlan_filter *vf;
hook_p hook;
struct ng_vlan_table *t;
uintptr_t hook_data;
int i, vlan_count;
uint16_t vid;
int error = 0;
NGI_GET_MSG(item, msg);
/* Deal with message according to cookie and command. */
switch (msg->header.typecookie) {
case NGM_VLAN_COOKIE:
switch (msg->header.cmd) {
case NGM_VLAN_ADD_FILTER:
/* Check that message is long enough. */
if (msg->header.arglen != sizeof(*vf)) {
error = EINVAL;
break;
}
vf = (struct ng_vlan_filter *)msg->data;
/* Sanity check the VLAN ID value. */
#ifdef NG_VLAN_USE_OLD_VLAN_NAME
if (vf->vid == 0 && vf->vid != vf->vlan) {
vf->vid = vf->vlan;
} else if (vf->vid != 0 && vf->vlan != 0 &&
vf->vid != vf->vlan) {
error = EINVAL;
break;
}
#endif
if (vf->vid & ~EVL_VLID_MASK ||
vf->pcp & ~7 ||
vf->cfi & ~1) {
error = EINVAL;
break;
}
/* Check that a referenced hook exists. */
hook = ng_findhook(node, vf->hook_name);
if (hook == NULL) {
error = ENOENT;
break;
}
/* And is not one of the special hooks. */
if (hook == priv->downstream_hook ||
hook == priv->nomatch_hook) {
error = EINVAL;
break;
}
/* And is not already in service. */
if (IS_HOOK_VLAN_SET(NG_HOOK_PRIVATE(hook))) {
error = EEXIST;
break;
}
/* Check we don't already trap this VLAN. */
if (priv->vlan_hook[vf->vid] != NULL) {
error = EEXIST;
break;
}
/* Link vlan and hook together. */
NG_HOOK_SET_PRIVATE(hook,
(void *)(HOOK_VLAN_TAG_SET_MASK |
EVL_MAKETAG(vf->vid, vf->pcp, vf->cfi)));
priv->vlan_hook[vf->vid] = hook;
break;
case NGM_VLAN_DEL_FILTER:
/* Check that message is long enough. */
if (msg->header.arglen != NG_HOOKSIZ) {
error = EINVAL;
break;
}
/* Check that hook exists and is active. */
hook = ng_findhook(node, (char *)msg->data);
if (hook == NULL) {
error = ENOENT;
break;
}
hook_data = (uintptr_t)NG_HOOK_PRIVATE(hook);
if (IS_HOOK_VLAN_SET(hook_data) == 0) {
error = ENOENT;
break;
}
KASSERT(priv->vlan_hook[EVL_VLANOFTAG(hook_data)] == hook,
("%s: NGM_VLAN_DEL_FILTER: Invalid VID for Hook = %s\n",
__func__, (char *)msg->data));
/* Purge a rule that refers to this hook. */
priv->vlan_hook[EVL_VLANOFTAG(hook_data)] = NULL;
NG_HOOK_SET_PRIVATE(hook, NULL);
break;
case NGM_VLAN_DEL_VID_FLT:
/* Check that message is long enough. */
if (msg->header.arglen != sizeof(uint16_t)) {
error = EINVAL;
break;
}
vid = (*((uint16_t *)msg->data));
/* Sanity check the VLAN ID value. */
if (vid & ~EVL_VLID_MASK) {
error = EINVAL;
break;
}
/* Check that hook exists and is active. */
hook = priv->vlan_hook[vid];
if (hook == NULL) {
error = ENOENT;
break;
}
hook_data = (uintptr_t)NG_HOOK_PRIVATE(hook);
if (IS_HOOK_VLAN_SET(hook_data) == 0) {
error = ENOENT;
break;
}
KASSERT(EVL_VLANOFTAG(hook_data) == vid,
("%s: NGM_VLAN_DEL_VID_FLT:"
" Invalid VID Hook = %us, must be: %us\n",
__func__, (uint16_t )EVL_VLANOFTAG(hook_data),
vid));
/* Purge a rule that refers to this hook. */
priv->vlan_hook[vid] = NULL;
NG_HOOK_SET_PRIVATE(hook, NULL);
break;
case NGM_VLAN_GET_TABLE:
/* Calculate vlans. */
vlan_count = 0;
for (i = 0; i < (EVL_VLID_MASK + 1); i ++) {
if (priv->vlan_hook[i] != NULL &&
NG_HOOK_IS_VALID(priv->vlan_hook[i]))
vlan_count ++;
}
/* Allocate memory for responce. */
NG_MKRESPONSE(resp, msg, sizeof(*t) +
vlan_count * sizeof(*t->filter), M_NOWAIT);
if (resp == NULL) {
error = ENOMEM;
break;
}
/* Pack data to responce. */
t = (struct ng_vlan_table *)resp->data;
t->n = 0;
vf = &t->filter[0];
for (i = 0; i < (EVL_VLID_MASK + 1); i ++) {
hook = priv->vlan_hook[i];
if (hook == NULL || NG_HOOK_NOT_VALID(hook))
continue;
hook_data = (uintptr_t)NG_HOOK_PRIVATE(hook);
if (IS_HOOK_VLAN_SET(hook_data) == 0)
continue;
KASSERT(EVL_VLANOFTAG(hook_data) == i,
("%s: NGM_VLAN_GET_TABLE:"
" hook %s VID = %us, must be: %i\n",
__func__, NG_HOOK_NAME(hook),
(uint16_t)EVL_VLANOFTAG(hook_data), i));
#ifdef NG_VLAN_USE_OLD_VLAN_NAME
vf->vlan = i;
#endif
vf->vid = i;
vf->pcp = EVL_PRIOFTAG(hook_data);
vf->cfi = EVL_CFIOFTAG(hook_data);
strncpy(vf->hook_name,
NG_HOOK_NAME(hook), NG_HOOKSIZ);
vf ++;
t->n ++;
}
break;
case NGM_VLAN_GET_DECAP:
NG_MKRESPONSE(resp, msg, sizeof(uint32_t), M_NOWAIT);
if (resp == NULL) {
error = ENOMEM;
break;
}
(*((uint32_t *)resp->data)) = priv->decap_enable;
break;
case NGM_VLAN_SET_DECAP:
if (msg->header.arglen != sizeof(uint32_t)) {
error = EINVAL;
break;
}
priv->decap_enable = (*((uint32_t *)msg->data));
break;
case NGM_VLAN_GET_ENCAP:
NG_MKRESPONSE(resp, msg, sizeof(uint32_t), M_NOWAIT);
if (resp == NULL) {
error = ENOMEM;
break;
}
(*((uint32_t *)resp->data)) = priv->encap_enable;
break;
case NGM_VLAN_SET_ENCAP:
if (msg->header.arglen != sizeof(uint32_t)) {
error = EINVAL;
break;
}
priv->encap_enable = (*((uint32_t *)msg->data));
break;
case NGM_VLAN_GET_ENCAP_PROTO:
NG_MKRESPONSE(resp, msg, sizeof(uint16_t), M_NOWAIT);
if (resp == NULL) {
error = ENOMEM;
break;
}
(*((uint16_t *)resp->data)) = ntohs(priv->encap_proto);
break;
case NGM_VLAN_SET_ENCAP_PROTO:
if (msg->header.arglen != sizeof(uint16_t)) {
error = EINVAL;
break;
}
priv->encap_proto = htons((*((uint16_t *)msg->data)));
break;
default: /* Unknown command. */
error = EINVAL;
break;
}
break;
case NGM_FLOW_COOKIE:
{
struct ng_mesg *copy;
/*
* Flow control messages should come only
* from downstream.
*/
if (lasthook == NULL)
break;
if (lasthook != priv->downstream_hook)
break;
/* Broadcast the event to all uplinks. */
for (i = 0; i < (EVL_VLID_MASK + 1); i ++) {
if (priv->vlan_hook[i] == NULL)
continue;
NG_COPYMESSAGE(copy, msg, M_NOWAIT);
if (copy == NULL)
continue;
NG_SEND_MSG_HOOK(error, node, copy,
priv->vlan_hook[i], 0);
}
break;
}
default: /* Unknown type cookie. */
error = EINVAL;
break;
}
NG_RESPOND_MSG(error, node, item, resp);
NG_FREE_MSG(msg);
return (error);
}
int
ng_l2cap_l2ca_enable_clt(ng_l2cap_p l2cap, struct ng_mesg *msg)
{
ng_l2cap_l2ca_enable_clt_ip *ip = NULL;
int error = 0;
#if 0
* ng_l2cap_l2ca_enable_clt_op *op = NULL;
* u_int16_t result;
* u_int32_t token;
#endif
/* Check message */
if (msg->header.arglen != sizeof(*ip)) {
NG_L2CAP_ALERT(
"%s: %s - invalid L2CA_EnableCLT message size, size=%d\n",
__func__, NG_NODE_NAME(l2cap->node),
msg->header.arglen);
return (EMSGSIZE);
}
/* Process request */
ip = (ng_l2cap_l2ca_enable_clt_ip *) (msg->data);
#if 0
* result = NG_L2CAP_SUCCESS;
#endif
switch (ip->psm)
{
case 0:
/* Special case: disable/enable all PSM */
if (ip->enable)
l2cap->flags &= ~(NG_L2CAP_CLT_SDP_DISABLED |
NG_L2CAP_CLT_RFCOMM_DISABLED |
NG_L2CAP_CLT_TCP_DISABLED);
else
l2cap->flags |= (NG_L2CAP_CLT_SDP_DISABLED |
NG_L2CAP_CLT_RFCOMM_DISABLED |
NG_L2CAP_CLT_TCP_DISABLED);
break;
case NG_L2CAP_PSM_SDP:
if (ip->enable)
l2cap->flags &= ~NG_L2CAP_CLT_SDP_DISABLED;
else
l2cap->flags |= NG_L2CAP_CLT_SDP_DISABLED;
break;
case NG_L2CAP_PSM_RFCOMM:
if (ip->enable)
l2cap->flags &= ~NG_L2CAP_CLT_RFCOMM_DISABLED;
else
l2cap->flags |= NG_L2CAP_CLT_RFCOMM_DISABLED;
break;
case NG_L2CAP_PSM_TCP:
if (ip->enable)
l2cap->flags &= ~NG_L2CAP_CLT_TCP_DISABLED;
else
l2cap->flags |= NG_L2CAP_CLT_TCP_DISABLED;
break;
default:
NG_L2CAP_ERR(
"%s: %s - unsupported PSM=%d\n", __func__, NG_NODE_NAME(l2cap->node), ip->psm);
#if 0
* result = NG_L2CAP_PSM_NOT_SUPPORTED;
#endif
error = ENOTSUP;
break;
}
#if 0
* /* Create and send response message */
* token = msg->header.token;
* NG_FREE_MSG(msg);
* NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_ENABLE_CLT,
* sizeof(*op), M_NOWAIT);
* if (msg == NULL)
* error = ENOMEM;
* else {
* msg->header.token = token;
* msg->header.flags |= NGF_RESP;
*
* op = (ng_l2cap_l2ca_enable_clt_op *)(msg->data);
* op->result = result;
* }
*
* /* Send response to control hook */
* if (l2cap->ctl != NULL && NG_HOOK_IS_VALID(l2cap->ctl))
* NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->ctl, 0);
#endif
return (error);
} /* ng_l2cap_l2ca_enable_clt */
int
ng_hci_lp_con_cfm(ng_hci_unit_con_p con, int status)
{
ng_hci_unit_p unit = con->unit;
struct ng_mesg *msg = NULL;
ng_hci_lp_con_cfm_ep *ep = NULL;
int error;
/*
* Check who wants to be notified. For ACL links both ACL and SCO
* upstream hooks will be notified (if required). For SCO links
* only SCO upstream hook will receive notification
*/
if (con->link_type == NG_HCI_LINK_ACL &&
con->flags & NG_HCI_CON_NOTIFY_ACL) {
if (unit->acl != NULL && NG_HOOK_IS_VALID(unit->acl)) {
NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_CON_CFM,
sizeof(*ep), M_NOWAIT);
if (msg != NULL) {
ep = (ng_hci_lp_con_cfm_ep *) msg->data;
ep->status = status;
ep->link_type = con->link_type;
ep->con_handle = con->con_handle;
bcopy(&con->bdaddr, &ep->bdaddr,
sizeof(ep->bdaddr));
NG_SEND_MSG_HOOK(error, unit->node, msg,
unit->acl, 0);
}
} else
NG_HCI_INFO(
"%s: %s - ACL hook not valid, hook=%p\n",
__func__, NG_NODE_NAME(unit->node), unit->acl);
con->flags &= ~NG_HCI_CON_NOTIFY_ACL;
}
if (con->flags & NG_HCI_CON_NOTIFY_SCO) {
if (unit->sco != NULL && NG_HOOK_IS_VALID(unit->sco)) {
NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_CON_CFM,
sizeof(*ep), M_NOWAIT);
if (msg != NULL) {
ep = (ng_hci_lp_con_cfm_ep *) msg->data;
ep->status = status;
ep->link_type = con->link_type;
ep->con_handle = con->con_handle;
bcopy(&con->bdaddr, &ep->bdaddr,
sizeof(ep->bdaddr));
NG_SEND_MSG_HOOK(error, unit->node, msg,
unit->sco, 0);
}
} else
NG_HCI_INFO(
"%s: %s - SCO hook not valid, hook=%p\n",
__func__, NG_NODE_NAME(unit->node), unit->acl);
con->flags &= ~NG_HCI_CON_NOTIFY_SCO;
}
return (0);
} /* ng_hci_lp_con_cfm */
static int
ng_hci_lp_acl_con_req(ng_hci_unit_p unit, item_p item, hook_p hook)
{
struct acl_con_req {
ng_hci_cmd_pkt_t hdr;
ng_hci_create_con_cp cp;
} __attribute__ ((packed)) *req = NULL;
ng_hci_lp_con_req_ep *ep = NULL;
ng_hci_unit_con_p con = NULL;
ng_hci_neighbor_t *n = NULL;
struct mbuf *m = NULL;
int error = 0;
ep = (ng_hci_lp_con_req_ep *)(NGI_MSG(item)->data);
/*
* Only one ACL connection can exist between each pair of units.
* So try to find ACL connection descriptor (in any state) that
* has requested remote BD_ADDR.
*
* Two cases:
*
* 1) We do not have connection to the remote unit. This is simple.
* Just create new connection descriptor and send HCI command to
* create new connection.
*
* 2) We do have connection descriptor. We need to check connection
* state:
*
* 2.1) NG_HCI_CON_W4_LP_CON_RSP means that we are in the middle of
* accepting connection from the remote unit. This is a race
* condition. We will ignore this message.
*
* 2.2) NG_HCI_CON_W4_CONN_COMPLETE means that upper layer already
* requested connection or we just accepted it. In any case
* all we need to do here is set appropriate notification bit
* and wait.
*
* 2.3) NG_HCI_CON_OPEN means connection is open. Just reply back
* and let upper layer know that we have connection already.
*/
con = ng_hci_con_by_bdaddr(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
if (con != NULL) {
switch (con->state) {
case NG_HCI_CON_W4_LP_CON_RSP: /* XXX */
error = EALREADY;
break;
case NG_HCI_CON_W4_CONN_COMPLETE:
if (hook == unit->acl)
con->flags |= NG_HCI_CON_NOTIFY_ACL;
else
con->flags |= NG_HCI_CON_NOTIFY_SCO;
break;
case NG_HCI_CON_OPEN: {
struct ng_mesg *msg = NULL;
ng_hci_lp_con_cfm_ep *cfm = NULL;
if (hook != NULL && NG_HOOK_IS_VALID(hook)) {
NGI_GET_MSG(item, msg);
NG_FREE_MSG(msg);
NG_MKMESSAGE(msg, NGM_HCI_COOKIE,
NGM_HCI_LP_CON_CFM, sizeof(*cfm),
M_NOWAIT);
if (msg != NULL) {
cfm = (ng_hci_lp_con_cfm_ep *)msg->data;
cfm->status = 0;
cfm->link_type = con->link_type;
cfm->con_handle = con->con_handle;
bcopy(&con->bdaddr, &cfm->bdaddr,
sizeof(cfm->bdaddr));
/*
* This will forward item back to
* sender and set item to NULL
*/
_NGI_MSG(item) = msg;
NG_FWD_ITEM_HOOK(error, item, hook);
} else
error = ENOMEM;
} else
NG_HCI_INFO(
"%s: %s - Source hook is not valid, hook=%p\n",
__func__, NG_NODE_NAME(unit->node),
hook);
} break;
default:
panic(
"%s: %s - Invalid connection state=%d\n",
__func__, NG_NODE_NAME(unit->node), con->state);
break;
}
goto out;
}
/*
* If we got here then we need to create new ACL connection descriptor
* and submit HCI command. First create new connection desriptor, set
* bdaddr and notification flags.
*/
con = ng_hci_new_con(unit, NG_HCI_LINK_ACL);
if (con == NULL) {
error = ENOMEM;
goto out;
}
bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr));
/*
* Create HCI command
*/
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL) {
ng_hci_free_con(con);
error = ENOBUFS;
goto out;
}
m->m_pkthdr.len = m->m_len = sizeof(*req);
req = mtod(m, struct acl_con_req *);
req->hdr.type = NG_HCI_CMD_PKT;
req->hdr.length = sizeof(req->cp);
req->hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL,
NG_HCI_OCF_CREATE_CON));
bcopy(&ep->bdaddr, &req->cp.bdaddr, sizeof(req->cp.bdaddr));
req->cp.pkt_type = (NG_HCI_PKT_DM1|NG_HCI_PKT_DH1);
if (unit->features[0] & NG_HCI_LMP_3SLOT)
req->cp.pkt_type |= (NG_HCI_PKT_DM3|NG_HCI_PKT_DH3);
if (unit->features[0] & NG_HCI_LMP_5SLOT)
req->cp.pkt_type |= (NG_HCI_PKT_DM5|NG_HCI_PKT_DH5);
req->cp.pkt_type &= unit->packet_mask;
if ((req->cp.pkt_type & (NG_HCI_PKT_DM1|NG_HCI_PKT_DH1|
NG_HCI_PKT_DM3|NG_HCI_PKT_DH3|
NG_HCI_PKT_DM5|NG_HCI_PKT_DH5)) == 0)
req->cp.pkt_type = (NG_HCI_PKT_DM1|NG_HCI_PKT_DH1);
req->cp.pkt_type = htole16(req->cp.pkt_type);
if ((unit->features[0] & NG_HCI_LMP_SWITCH) && unit->role_switch)
req->cp.accept_role_switch = 1;
else
req->cp.accept_role_switch = 0;
/*
* We may speed up connect by specifying valid parameters.
* So check the neighbor cache.
*/
n = ng_hci_get_neighbor(unit, &ep->bdaddr);
if (n == NULL) {
req->cp.page_scan_rep_mode = 0;
req->cp.page_scan_mode = 0;
req->cp.clock_offset = 0;
} else {
req->cp.page_scan_rep_mode = n->page_scan_rep_mode;
req->cp.page_scan_mode = n->page_scan_mode;
req->cp.clock_offset = htole16(n->clock_offset);
}
/*
* Adust connection state
*/
if (hook == unit->acl)
con->flags |= NG_HCI_CON_NOTIFY_ACL;
else
con->flags |= NG_HCI_CON_NOTIFY_SCO;
con->state = NG_HCI_CON_W4_CONN_COMPLETE;
ng_hci_con_timeout(con);
/*
* Queue and send HCI command
*/
NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m);
if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING))
error = ng_hci_send_command(unit);
out:
if (item != NULL)
NG_FREE_ITEM(item);
return (error);
} /* ng_hci_lp_acl_con_req */
static int
ng_hci_lp_le_con_req(ng_hci_unit_p unit, item_p item, hook_p hook, int link_type)
{
struct acl_con_req {
ng_hci_cmd_pkt_t hdr;
ng_hci_le_create_connection_cp cp;
} __attribute__ ((packed)) *req = NULL;
ng_hci_lp_con_req_ep *ep = NULL;
ng_hci_unit_con_p con = NULL;
struct mbuf *m = NULL;
int error = 0;
ep = (ng_hci_lp_con_req_ep *)(NGI_MSG(item)->data);
if((link_type != NG_HCI_LINK_LE_PUBLIC)&&
(link_type != NG_HCI_LINK_LE_RANDOM)){
printf("%s: Link type %d Cannot be here \n", __func__,
link_type);
}
/*
* Only one ACL connection can exist between each pair of units.
* So try to find ACL connection descriptor (in any state) that
* has requested remote BD_ADDR.
*
* Two cases:
*
* 1) We do not have connection to the remote unit. This is simple.
* Just create new connection descriptor and send HCI command to
* create new connection.
*
* 2) We do have connection descriptor. We need to check connection
* state:
*
* 2.1) NG_HCI_CON_W4_LP_CON_RSP means that we are in the middle of
* accepting connection from the remote unit. This is a race
* condition. We will ignore this message.
*
* 2.2) NG_HCI_CON_W4_CONN_COMPLETE means that upper layer already
* requested connection or we just accepted it. In any case
* all we need to do here is set appropriate notification bit
* and wait.
*
* 2.3) NG_HCI_CON_OPEN means connection is open. Just reply back
* and let upper layer know that we have connection already.
*/
con = ng_hci_con_by_bdaddr(unit, &ep->bdaddr, link_type);
if (con != NULL) {
switch (con->state) {
case NG_HCI_CON_W4_LP_CON_RSP: /* XXX */
error = EALREADY;
break;
case NG_HCI_CON_W4_CONN_COMPLETE:
if (hook != unit->sco)
con->flags |= NG_HCI_CON_NOTIFY_ACL;
else
con->flags |= NG_HCI_CON_NOTIFY_SCO;
break;
case NG_HCI_CON_OPEN: {
struct ng_mesg *msg = NULL;
ng_hci_lp_con_cfm_ep *cfm = NULL;
if (hook != NULL && NG_HOOK_IS_VALID(hook)) {
NGI_GET_MSG(item, msg);
NG_FREE_MSG(msg);
NG_MKMESSAGE(msg, NGM_HCI_COOKIE,
NGM_HCI_LP_CON_CFM, sizeof(*cfm),
M_NOWAIT);
if (msg != NULL) {
cfm = (ng_hci_lp_con_cfm_ep *)msg->data;
cfm->status = 0;
cfm->link_type = con->link_type;
cfm->con_handle = con->con_handle;
bcopy(&con->bdaddr, &cfm->bdaddr,
sizeof(cfm->bdaddr));
/*
* This will forward item back to
* sender and set item to NULL
*/
_NGI_MSG(item) = msg;
NG_FWD_ITEM_HOOK(error, item, hook);
} else
error = ENOMEM;
} else
NG_HCI_INFO(
"%s: %s - Source hook is not valid, hook=%p\n",
__func__, NG_NODE_NAME(unit->node),
hook);
} break;
default:
panic(
"%s: %s - Invalid connection state=%d\n",
__func__, NG_NODE_NAME(unit->node), con->state);
break;
}
goto out;
}
/*
* If we got here then we need to create new ACL connection descriptor
* and submit HCI command. First create new connection desriptor, set
* bdaddr and notification flags.
*/
con = ng_hci_new_con(unit, link_type);
if (con == NULL) {
error = ENOMEM;
goto out;
}
bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr));
/*
* Create HCI command
*/
MGETHDR(m, M_NOWAIT, MT_DATA);
if (m == NULL) {
ng_hci_free_con(con);
error = ENOBUFS;
goto out;
}
m->m_pkthdr.len = m->m_len = sizeof(*req);
req = mtod(m, struct acl_con_req *);
req->hdr.type = NG_HCI_CMD_PKT;
req->hdr.length = sizeof(req->cp);
req->hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_LE,
NG_HCI_OCF_LE_CREATE_CONNECTION));
bcopy(&ep->bdaddr, &req->cp.peer_addr, sizeof(req->cp.peer_addr));
req->cp.own_address_type = 0;
req->cp.peer_addr_type = (link_type == NG_HCI_LINK_LE_RANDOM)? 1:0;
req->cp.scan_interval = htole16(4);
req->cp.scan_window = htole16(4);
req->cp.filter_policy = 0;
req->cp.conn_interval_min = htole16(0xf);
req->cp.conn_interval_max = htole16(0xf);
req->cp.conn_latency = htole16(0);
req->cp.supervision_timeout = htole16(0xc80);
req->cp.min_ce_length = htole16(1);
req->cp.max_ce_length = htole16(1);
/*
* Adust connection state
*/
if (hook != unit->sco)
con->flags |= NG_HCI_CON_NOTIFY_ACL;
else
con->flags |= NG_HCI_CON_NOTIFY_SCO;
con->state = NG_HCI_CON_W4_CONN_COMPLETE;
ng_hci_con_timeout(con);
/*
* Queue and send HCI command
*/
NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m);
if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING))
error = ng_hci_send_command(unit);
out:
if (item != NULL)
NG_FREE_ITEM(item);
return (error);
} /* ng_hci_lp_acl_con_req */
