6 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
8 * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com>
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * $Id: ng_hci_evnt.c,v 1.6 2003/09/08 18:57:51 max Exp $
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/endian.h>
40 #include <sys/malloc.h>
42 #include <sys/queue.h>
43 #include <netgraph/ng_message.h>
44 #include <netgraph/netgraph.h>
45 #include <netgraph/bluetooth/include/ng_bluetooth.h>
46 #include <netgraph/bluetooth/include/ng_hci.h>
47 #include <netgraph/bluetooth/hci/ng_hci_var.h>
48 #include <netgraph/bluetooth/hci/ng_hci_cmds.h>
49 #include <netgraph/bluetooth/hci/ng_hci_evnt.h>
50 #include <netgraph/bluetooth/hci/ng_hci_ulpi.h>
51 #include <netgraph/bluetooth/hci/ng_hci_misc.h>
53 /******************************************************************************
54 ******************************************************************************
55 ** HCI event processing module
56 ******************************************************************************
57 ******************************************************************************/
60 * Event processing routines
63 static int inquiry_result (ng_hci_unit_p, struct mbuf *);
64 static int con_compl (ng_hci_unit_p, struct mbuf *);
65 static int con_req (ng_hci_unit_p, struct mbuf *);
66 static int discon_compl (ng_hci_unit_p, struct mbuf *);
67 static int encryption_change (ng_hci_unit_p, struct mbuf *);
68 static int read_remote_features_compl (ng_hci_unit_p, struct mbuf *);
69 static int qos_setup_compl (ng_hci_unit_p, struct mbuf *);
70 static int hardware_error (ng_hci_unit_p, struct mbuf *);
71 static int role_change (ng_hci_unit_p, struct mbuf *);
72 static int num_compl_pkts (ng_hci_unit_p, struct mbuf *);
73 static int mode_change (ng_hci_unit_p, struct mbuf *);
74 static int data_buffer_overflow (ng_hci_unit_p, struct mbuf *);
75 static int read_clock_offset_compl (ng_hci_unit_p, struct mbuf *);
76 static int qos_violation (ng_hci_unit_p, struct mbuf *);
77 static int page_scan_mode_change (ng_hci_unit_p, struct mbuf *);
78 static int page_scan_rep_mode_change (ng_hci_unit_p, struct mbuf *);
79 static int sync_con_queue (ng_hci_unit_p, ng_hci_unit_con_p, int);
80 static int send_data_packets (ng_hci_unit_p, int, int);
81 static int le_event (ng_hci_unit_p, struct mbuf *);
84 * Process HCI event packet
88 ng_hci_process_event(ng_hci_unit_p unit, struct mbuf *event)
90 ng_hci_event_pkt_t *hdr = NULL;
93 /* Get event packet header */
94 NG_HCI_M_PULLUP(event, sizeof(*hdr));
98 hdr = mtod(event, ng_hci_event_pkt_t *);
101 "%s: %s - got HCI event=%#x, length=%d\n",
102 __func__, NG_NODE_NAME(unit->node), hdr->event, hdr->length);
104 /* Get rid of event header and process event */
105 m_adj(event, sizeof(*hdr));
107 switch (hdr->event) {
108 case NG_HCI_EVENT_INQUIRY_COMPL:
109 case NG_HCI_EVENT_RETURN_LINK_KEYS:
110 case NG_HCI_EVENT_PIN_CODE_REQ:
111 case NG_HCI_EVENT_LINK_KEY_REQ:
112 case NG_HCI_EVENT_LINK_KEY_NOTIFICATION:
113 case NG_HCI_EVENT_LOOPBACK_COMMAND:
114 case NG_HCI_EVENT_AUTH_COMPL:
115 case NG_HCI_EVENT_CHANGE_CON_LINK_KEY_COMPL:
116 case NG_HCI_EVENT_MASTER_LINK_KEY_COMPL:
117 case NG_HCI_EVENT_FLUSH_OCCUR: /* XXX Do we have to handle it? */
118 case NG_HCI_EVENT_MAX_SLOT_CHANGE:
119 case NG_HCI_EVENT_CON_PKT_TYPE_CHANGED:
120 case NG_HCI_EVENT_BT_LOGO:
121 case NG_HCI_EVENT_VENDOR:
122 case NG_HCI_EVENT_REMOTE_NAME_REQ_COMPL:
123 case NG_HCI_EVENT_READ_REMOTE_VER_INFO_COMPL:
124 /* These do not need post processing */
127 case NG_HCI_EVENT_LE:
128 error = le_event(unit, event);
131 case NG_HCI_EVENT_INQUIRY_RESULT:
132 error = inquiry_result(unit, event);
135 case NG_HCI_EVENT_CON_COMPL:
136 error = con_compl(unit, event);
139 case NG_HCI_EVENT_CON_REQ:
140 error = con_req(unit, event);
143 case NG_HCI_EVENT_DISCON_COMPL:
144 error = discon_compl(unit, event);
147 case NG_HCI_EVENT_ENCRYPTION_CHANGE:
148 error = encryption_change(unit, event);
151 case NG_HCI_EVENT_READ_REMOTE_FEATURES_COMPL:
152 error = read_remote_features_compl(unit, event);
155 case NG_HCI_EVENT_QOS_SETUP_COMPL:
156 error = qos_setup_compl(unit, event);
159 case NG_HCI_EVENT_COMMAND_COMPL:
160 error = ng_hci_process_command_complete(unit, event);
163 case NG_HCI_EVENT_COMMAND_STATUS:
164 error = ng_hci_process_command_status(unit, event);
167 case NG_HCI_EVENT_HARDWARE_ERROR:
168 error = hardware_error(unit, event);
171 case NG_HCI_EVENT_ROLE_CHANGE:
172 error = role_change(unit, event);
175 case NG_HCI_EVENT_NUM_COMPL_PKTS:
176 error = num_compl_pkts(unit, event);
179 case NG_HCI_EVENT_MODE_CHANGE:
180 error = mode_change(unit, event);
183 case NG_HCI_EVENT_DATA_BUFFER_OVERFLOW:
184 error = data_buffer_overflow(unit, event);
187 case NG_HCI_EVENT_READ_CLOCK_OFFSET_COMPL:
188 error = read_clock_offset_compl(unit, event);
191 case NG_HCI_EVENT_QOS_VIOLATION:
192 error = qos_violation(unit, event);
195 case NG_HCI_EVENT_PAGE_SCAN_MODE_CHANGE:
196 error = page_scan_mode_change(unit, event);
199 case NG_HCI_EVENT_PAGE_SCAN_REP_MODE_CHANGE:
200 error = page_scan_rep_mode_change(unit, event);
210 } /* ng_hci_process_event */
213 * Send ACL and/or SCO data to the unit driver
217 ng_hci_send_data(ng_hci_unit_p unit)
222 NG_HCI_BUFF_ACL_AVAIL(unit->buffer, count);
225 "%s: %s - sending ACL data packets, count=%d\n",
226 __func__, NG_NODE_NAME(unit->node), count);
229 count = send_data_packets(unit, NG_HCI_LINK_ACL, count);
230 NG_HCI_STAT_ACL_SENT(unit->stat, count);
231 NG_HCI_BUFF_ACL_USE(unit->buffer, count);
235 NG_HCI_BUFF_SCO_AVAIL(unit->buffer, count);
238 "%s: %s - sending SCO data packets, count=%d\n",
239 __func__, NG_NODE_NAME(unit->node), count);
242 count = send_data_packets(unit, NG_HCI_LINK_SCO, count);
243 NG_HCI_STAT_SCO_SENT(unit->stat, count);
244 NG_HCI_BUFF_SCO_USE(unit->buffer, count);
246 } /* ng_hci_send_data */
249 * Send data packets to the lower layer.
253 send_data_packets(ng_hci_unit_p unit, int link_type, int limit)
255 ng_hci_unit_con_p con = NULL, winner = NULL;
258 int min_pending, total_sent, sent, error, v;
260 for (total_sent = 0; limit > 0; ) {
261 min_pending = 0x0fffffff;
265 * Find the connection that has has data to send
266 * and the smallest number of pending packets
269 LIST_FOREACH(con, &unit->con_list, next) {
270 reallink_type = (con->link_type == NG_HCI_LINK_SCO)?
271 NG_HCI_LINK_SCO: NG_HCI_LINK_ACL;
272 if (reallink_type != link_type){
275 if (NG_BT_ITEMQ_LEN(&con->conq) == 0)
278 if (con->pending < min_pending) {
280 min_pending = con->pending;
288 * OK, we have a winner now send as much packets as we can
289 * Count the number of packets we have sent and then sync
290 * winner connection queue.
293 for (sent = 0; limit > 0; limit --, total_sent ++, sent ++) {
294 NG_BT_ITEMQ_DEQUEUE(&winner->conq, item);
299 "%s: %s - sending data packet, handle=%d, len=%d\n",
300 __func__, NG_NODE_NAME(unit->node),
301 winner->con_handle, NGI_M(item)->m_pkthdr.len);
303 /* Check if driver hook still there */
304 v = (unit->drv != NULL && NG_HOOK_IS_VALID(unit->drv));
305 if (!v || (unit->state & NG_HCI_UNIT_READY) !=
308 "%s: %s - could not send data. Hook \"%s\" is %svalid, state=%#x\n",
309 __func__, NG_NODE_NAME(unit->node),
310 NG_HCI_HOOK_DRV, ((v)? "" : "not "),
316 v = NGI_M(item)->m_pkthdr.len;
318 /* Give packet to raw hook */
319 ng_hci_mtap(unit, NGI_M(item));
321 /* ... and forward item to the driver */
322 NG_FWD_ITEM_HOOK(error, item, unit->drv);
327 "%s: %s - could not send data packet, handle=%d, error=%d\n",
328 __func__, NG_NODE_NAME(unit->node),
329 winner->con_handle, error);
334 NG_HCI_STAT_BYTES_SENT(unit->stat, v);
338 * Sync connection queue for the winner
340 sync_con_queue(unit, winner, sent);
344 } /* send_data_packets */
347 * Send flow control messages to the upper layer
351 sync_con_queue(ng_hci_unit_p unit, ng_hci_unit_con_p con, int completed)
354 struct ng_mesg *msg = NULL;
355 ng_hci_sync_con_queue_ep *state = NULL;
358 hook = (con->link_type != NG_HCI_LINK_SCO)? unit->acl : unit->sco;
359 if (hook == NULL || NG_HOOK_NOT_VALID(hook))
362 NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_SYNC_CON_QUEUE,
363 sizeof(*state), M_NOWAIT);
367 state = (ng_hci_sync_con_queue_ep *)(msg->data);
368 state->con_handle = con->con_handle;
369 state->completed = completed;
371 NG_SEND_MSG_HOOK(error, unit->node, msg, hook, 0);
374 } /* sync_con_queue */
376 /* Inquiry result event */
378 le_advertizing_report(ng_hci_unit_p unit, struct mbuf *event)
380 ng_hci_le_advertising_report_ep *ep = NULL;
381 ng_hci_neighbor_p n = NULL;
388 NG_HCI_M_PULLUP(event, sizeof(*ep));
392 ep = mtod(event, ng_hci_le_advertising_report_ep *);
393 num_reports = ep->num_reports;
394 m_adj(event, sizeof(*ep));
397 for (; num_reports > 0; num_reports --) {
398 /* Get remote unit address */
399 NG_HCI_M_PULLUP(event, sizeof(u_int8_t));
400 event_type = *mtod(event, u_int8_t *);
401 m_adj(event, sizeof(u_int8_t));
402 NG_HCI_M_PULLUP(event, sizeof(u_int8_t));
403 addr_type = *mtod(event, u_int8_t *);
404 m_adj(event, sizeof(u_int8_t));
406 m_copydata(event, 0, sizeof(bdaddr), (caddr_t) &bdaddr);
407 m_adj(event, sizeof(bdaddr));
409 /* Lookup entry in the cache */
410 n = ng_hci_get_neighbor(unit, &bdaddr, (addr_type) ? NG_HCI_LINK_LE_RANDOM:NG_HCI_LINK_LE_PUBLIC);
412 /* Create new entry */
413 n = ng_hci_new_neighbor(unit);
418 bcopy(&bdaddr, &n->bdaddr, sizeof(n->bdaddr));
419 n->addrtype = (addr_type)? NG_HCI_LINK_LE_RANDOM :
420 NG_HCI_LINK_LE_PUBLIC;
423 getmicrotime(&n->updated);
427 * TODO: Make these information
428 * Available from userland.
430 u_int8_t length_data;
432 event = m_pullup(event, sizeof(u_int8_t));
434 NG_HCI_WARN("%s: Event datasize Pullup Failed\n", __func__);
437 length_data = *mtod(event, u_int8_t *);
438 m_adj(event, sizeof(u_int8_t));
439 n->extinq_size = (length_data < NG_HCI_EXTINQ_MAX)?
440 length_data : NG_HCI_EXTINQ_MAX;
442 /*Advertizement data*/
443 event = m_pullup(event, n->extinq_size);
445 NG_HCI_WARN("%s: Event data pullup Failed\n", __func__);
448 m_copydata(event, 0, n->extinq_size, n->extinq_data);
449 m_adj(event, n->extinq_size);
450 event = m_pullup(event, sizeof(char ));
453 NG_HCI_WARN("%s: Event rssi pull up Failed\n", __func__);
457 n->page_scan_mode = *mtod(event, char *);
458 m_adj(event, sizeof(u_int8_t));
465 } /* inquiry_result */
467 static int le_connection_complete(ng_hci_unit_p unit, struct mbuf *event)
471 ng_hci_le_connection_complete_ep *ep = NULL;
472 ng_hci_unit_con_p con = NULL;
474 uint8_t uclass[3] = {0,0,0};//dummy uclass
476 NG_HCI_M_PULLUP(event, sizeof(*ep));
480 ep = mtod(event, ng_hci_le_connection_complete_ep *);
481 link_type = (ep->address_type)? NG_HCI_LINK_LE_RANDOM :
482 NG_HCI_LINK_LE_PUBLIC;
484 * Find the first connection descriptor that matches the following:
486 * 1) con->link_type == link_type
487 * 2) con->state == NG_HCI_CON_W4_CONN_COMPLETE
488 * 3) con->bdaddr == ep->address
490 LIST_FOREACH(con, &unit->con_list, next)
491 if (con->link_type == link_type &&
492 con->state == NG_HCI_CON_W4_CONN_COMPLETE &&
493 bcmp(&con->bdaddr, &ep->address, sizeof(bdaddr_t)) == 0)
497 * Two possible cases:
499 * 1) We have found connection descriptor. That means upper layer has
500 * requested this connection via LP_CON_REQ message. In this case
501 * connection must have timeout set. If ng_hci_con_untimeout() fails
502 * then timeout message already went into node's queue. In this case
503 * ignore Connection_Complete event and let timeout deal with it.
505 * 2) We do not have connection descriptor. That means upper layer
506 * nas not requested this connection , (less likely) we gave up
507 * on this connection (timeout) or as node act as slave role.
508 * The most likely scenario is that
509 * we have received LE_Create_Connection command
517 con = ng_hci_new_con(unit, link_type);
523 con->state = NG_HCI_CON_W4_LP_CON_RSP;
524 ng_hci_con_timeout(con);
526 bcopy(&ep->address, &con->bdaddr, sizeof(con->bdaddr));
527 error = ng_hci_lp_con_ind(con, uclass);
529 ng_hci_con_untimeout(con);
530 ng_hci_free_con(con);
533 } else if ((error = ng_hci_con_untimeout(con)) != 0)
537 * Update connection descriptor and send notification
538 * to the upper layers.
541 con->con_handle = NG_HCI_CON_HANDLE(le16toh(ep->handle));
542 con->encryption_mode = NG_HCI_ENCRYPTION_MODE_NONE;
544 ng_hci_lp_con_cfm(con, ep->status);
546 /* Adjust connection state */
548 ng_hci_free_con(con);
550 con->state = NG_HCI_CON_OPEN;
553 * Change link policy for the ACL connections. Enable all
554 * supported link modes. Enable Role switch as well if
555 * device supports it.
566 static int le_connection_update(ng_hci_unit_p unit, struct mbuf *event)
576 le_event(ng_hci_unit_p unit, struct mbuf *event)
581 NG_HCI_M_PULLUP(event, sizeof(*lep));
585 lep = mtod(event, ng_hci_le_ep *);
586 m_adj(event, sizeof(*lep));
587 switch(lep->subevent_code){
588 case NG_HCI_LEEV_CON_COMPL:
589 le_connection_complete(unit, event);
591 case NG_HCI_LEEV_ADVREP:
592 le_advertizing_report(unit, event);
594 case NG_HCI_LEEV_CON_UPDATE_COMPL:
595 le_connection_update(unit, event);
597 case NG_HCI_LEEV_READ_REMOTE_FEATURES_COMPL:
600 case NG_HCI_LEEV_LONG_TERM_KEY_REQUEST:
609 /* Inquiry result event */
611 inquiry_result(ng_hci_unit_p unit, struct mbuf *event)
613 ng_hci_inquiry_result_ep *ep = NULL;
614 ng_hci_neighbor_p n = NULL;
618 NG_HCI_M_PULLUP(event, sizeof(*ep));
622 ep = mtod(event, ng_hci_inquiry_result_ep *);
623 m_adj(event, sizeof(*ep));
625 for (; ep->num_responses > 0; ep->num_responses --) {
626 /* Get remote unit address */
627 m_copydata(event, 0, sizeof(bdaddr), (caddr_t) &bdaddr);
628 m_adj(event, sizeof(bdaddr));
630 /* Lookup entry in the cache */
631 n = ng_hci_get_neighbor(unit, &bdaddr, NG_HCI_LINK_ACL);
633 /* Create new entry */
634 n = ng_hci_new_neighbor(unit);
640 getmicrotime(&n->updated);
642 bcopy(&bdaddr, &n->bdaddr, sizeof(n->bdaddr));
643 n->addrtype = NG_HCI_LINK_ACL;
645 /* XXX call m_pullup here? */
647 n->page_scan_rep_mode = *mtod(event, u_int8_t *);
648 m_adj(event, sizeof(u_int8_t));
650 /* page_scan_period_mode */
651 m_adj(event, sizeof(u_int8_t));
653 n->page_scan_mode = *mtod(event, u_int8_t *);
654 m_adj(event, sizeof(u_int8_t));
657 m_adj(event, NG_HCI_CLASS_SIZE);
660 m_copydata(event, 0, sizeof(n->clock_offset),
661 (caddr_t) &n->clock_offset);
662 n->clock_offset = le16toh(n->clock_offset);
668 } /* inquiry_result */
670 /* Connection complete event */
672 con_compl(ng_hci_unit_p unit, struct mbuf *event)
674 ng_hci_con_compl_ep *ep = NULL;
675 ng_hci_unit_con_p con = NULL;
678 NG_HCI_M_PULLUP(event, sizeof(*ep));
682 ep = mtod(event, ng_hci_con_compl_ep *);
685 * Find the first connection descriptor that matches the following:
687 * 1) con->link_type == ep->link_type
688 * 2) con->state == NG_HCI_CON_W4_CONN_COMPLETE
689 * 3) con->bdaddr == ep->bdaddr
692 LIST_FOREACH(con, &unit->con_list, next)
693 if (con->link_type == ep->link_type &&
694 con->state == NG_HCI_CON_W4_CONN_COMPLETE &&
695 bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0)
699 * Two possible cases:
701 * 1) We have found connection descriptor. That means upper layer has
702 * requested this connection via LP_CON_REQ message. In this case
703 * connection must have timeout set. If ng_hci_con_untimeout() fails
704 * then timeout message already went into node's queue. In this case
705 * ignore Connection_Complete event and let timeout deal with it.
707 * 2) We do not have connection descriptor. That means upper layer
708 * nas not requested this connection or (less likely) we gave up
709 * on this connection (timeout). The most likely scenario is that
710 * we have received Create_Connection/Add_SCO_Connection command
718 con = ng_hci_new_con(unit, ep->link_type);
724 bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr));
725 } else if ((error = ng_hci_con_untimeout(con)) != 0)
729 * Update connection descriptor and send notification
730 * to the upper layers.
733 con->con_handle = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
734 con->encryption_mode = ep->encryption_mode;
736 ng_hci_lp_con_cfm(con, ep->status);
738 /* Adjust connection state */
740 ng_hci_free_con(con);
742 con->state = NG_HCI_CON_OPEN;
745 * Change link policy for the ACL connections. Enable all
746 * supported link modes. Enable Role switch as well if
747 * device supports it.
750 if (ep->link_type == NG_HCI_LINK_ACL) {
751 struct __link_policy {
752 ng_hci_cmd_pkt_t hdr;
753 ng_hci_write_link_policy_settings_cp cp;
754 } __attribute__ ((packed)) *lp;
757 MGETHDR(m, M_NOWAIT, MT_DATA);
759 m->m_pkthdr.len = m->m_len = sizeof(*lp);
760 lp = mtod(m, struct __link_policy *);
762 lp->hdr.type = NG_HCI_CMD_PKT;
763 lp->hdr.opcode = htole16(NG_HCI_OPCODE(
764 NG_HCI_OGF_LINK_POLICY,
765 NG_HCI_OCF_WRITE_LINK_POLICY_SETTINGS));
766 lp->hdr.length = sizeof(lp->cp);
768 lp->cp.con_handle = ep->con_handle;
771 if ((unit->features[0] & NG_HCI_LMP_SWITCH) &&
773 lp->cp.settings |= 0x1;
774 if (unit->features[0] & NG_HCI_LMP_HOLD_MODE)
775 lp->cp.settings |= 0x2;
776 if (unit->features[0] & NG_HCI_LMP_SNIFF_MODE)
777 lp->cp.settings |= 0x4;
778 if (unit->features[1] & NG_HCI_LMP_PARK_MODE)
779 lp->cp.settings |= 0x8;
781 lp->cp.settings &= unit->link_policy_mask;
782 lp->cp.settings = htole16(lp->cp.settings);
784 NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m);
785 if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING))
786 ng_hci_send_command(unit);
796 /* Connection request event */
798 con_req(ng_hci_unit_p unit, struct mbuf *event)
800 ng_hci_con_req_ep *ep = NULL;
801 ng_hci_unit_con_p con = NULL;
804 NG_HCI_M_PULLUP(event, sizeof(*ep));
808 ep = mtod(event, ng_hci_con_req_ep *);
811 * Find the first connection descriptor that matches the following:
813 * 1) con->link_type == ep->link_type
815 * 2) con->state == NG_HCI_CON_W4_LP_CON_RSP ||
816 * con->state == NG_HCI_CON_W4_CONN_COMPL
818 * 3) con->bdaddr == ep->bdaddr
822 * 1) We do not have connection descriptor. This is simple. Create
823 * new fresh connection descriptor and send notification to the
824 * appropriate upstream hook (based on link_type).
826 * 2) We found connection handle. This is more complicated.
830 * Since only one ACL link can exist between each pair of
831 * units then we have a race. Our upper layer has requested
832 * an ACL connection to the remote unit, but we did not send
833 * command yet. At the same time the remote unit has requested
834 * an ACL connection from us. In this case we will ignore
835 * Connection_Request event. This probably will cause connect
836 * failure on both units.
840 * The spec on page 45 says :
842 * "The master can support up to three SCO links to the same
843 * slave or to different slaves. A slave can support up to
844 * three SCO links from the same master, or two SCO links if
845 * the links originate from different masters."
847 * The only problem is how to handle multiple SCO links between
848 * matster and slave. For now we will assume that multiple SCO
849 * links MUST be opened one after another.
852 LIST_FOREACH(con, &unit->con_list, next)
853 if (con->link_type == ep->link_type &&
854 (con->state == NG_HCI_CON_W4_LP_CON_RSP ||
855 con->state == NG_HCI_CON_W4_CONN_COMPLETE) &&
856 bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0)
860 con = ng_hci_new_con(unit, ep->link_type);
862 bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr));
864 con->state = NG_HCI_CON_W4_LP_CON_RSP;
865 ng_hci_con_timeout(con);
867 error = ng_hci_lp_con_ind(con, ep->uclass);
869 ng_hci_con_untimeout(con);
870 ng_hci_free_con(con);
881 /* Disconnect complete event */
883 discon_compl(ng_hci_unit_p unit, struct mbuf *event)
885 ng_hci_discon_compl_ep *ep = NULL;
886 ng_hci_unit_con_p con = NULL;
890 NG_HCI_M_PULLUP(event, sizeof(*ep));
894 ep = mtod(event, ng_hci_discon_compl_ep *);
898 * Do we have to send notification if ep->status != 0?
899 * For now we will send notification for both ACL and SCO connections
900 * ONLY if ep->status == 0.
903 if (ep->status == 0) {
904 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
905 con = ng_hci_con_by_handle(unit, h);
907 error = ng_hci_lp_discon_ind(con, ep->reason);
909 /* Remove all timeouts (if any) */
910 if (con->flags & NG_HCI_CON_TIMEOUT_PENDING)
911 ng_hci_con_untimeout(con);
913 ng_hci_free_con(con);
916 "%s: %s - invalid connection handle=%d\n",
917 __func__, NG_NODE_NAME(unit->node), h);
927 /* Encryption change event */
929 encryption_change(ng_hci_unit_p unit, struct mbuf *event)
931 ng_hci_encryption_change_ep *ep = NULL;
932 ng_hci_unit_con_p con = NULL;
936 NG_HCI_M_PULLUP(event, sizeof(*ep));
940 ep = mtod(event, ng_hci_encryption_change_ep *);
941 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
942 con = ng_hci_con_by_handle(unit, h);
944 if (ep->status == 0) {
947 "%s: %s - invalid connection handle=%d\n",
948 __func__, NG_NODE_NAME(unit->node), h);
950 } else if (con->link_type == NG_HCI_LINK_SCO) {
952 "%s: %s - invalid link type=%d\n",
953 __func__, NG_NODE_NAME(unit->node),
956 } else if (ep->encryption_enable)
957 /* XXX is that true? */
958 con->encryption_mode = NG_HCI_ENCRYPTION_MODE_P2P;
960 con->encryption_mode = NG_HCI_ENCRYPTION_MODE_NONE;
963 "%s: %s - failed to change encryption mode, status=%d\n",
964 __func__, NG_NODE_NAME(unit->node), ep->status);
966 /*Anyway, propagete encryption status to upper layer*/
967 ng_hci_lp_enc_change(con, con->encryption_mode);
972 } /* encryption_change */
974 /* Read remote feature complete event */
976 read_remote_features_compl(ng_hci_unit_p unit, struct mbuf *event)
978 ng_hci_read_remote_features_compl_ep *ep = NULL;
979 ng_hci_unit_con_p con = NULL;
980 ng_hci_neighbor_p n = NULL;
984 NG_HCI_M_PULLUP(event, sizeof(*ep));
988 ep = mtod(event, ng_hci_read_remote_features_compl_ep *);
990 if (ep->status == 0) {
991 /* Check if we have this connection handle */
992 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
993 con = ng_hci_con_by_handle(unit, h);
996 "%s: %s - invalid connection handle=%d\n",
997 __func__, NG_NODE_NAME(unit->node), h);
1002 /* Update cache entry */
1003 n = ng_hci_get_neighbor(unit, &con->bdaddr, NG_HCI_LINK_ACL);
1005 n = ng_hci_new_neighbor(unit);
1011 bcopy(&con->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1012 n->addrtype = NG_HCI_LINK_ACL;
1014 getmicrotime(&n->updated);
1016 bcopy(ep->features, n->features, sizeof(n->features));
1019 "%s: %s - failed to read remote unit features, status=%d\n",
1020 __func__, NG_NODE_NAME(unit->node), ep->status);
1025 } /* read_remote_features_compl */
1027 /* QoS setup complete event */
1029 qos_setup_compl(ng_hci_unit_p unit, struct mbuf *event)
1031 ng_hci_qos_setup_compl_ep *ep = NULL;
1032 ng_hci_unit_con_p con = NULL;
1036 NG_HCI_M_PULLUP(event, sizeof(*ep));
1040 ep = mtod(event, ng_hci_qos_setup_compl_ep *);
1042 /* Check if we have this connection handle */
1043 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1044 con = ng_hci_con_by_handle(unit, h);
1047 "%s: %s - invalid connection handle=%d\n",
1048 __func__, NG_NODE_NAME(unit->node), h);
1050 } else if (con->link_type != NG_HCI_LINK_ACL) {
1052 "%s: %s - invalid link type=%d, handle=%d\n",
1053 __func__, NG_NODE_NAME(unit->node), con->link_type, h);
1055 } else if (con->state != NG_HCI_CON_OPEN) {
1057 "%s: %s - invalid connection state=%d, handle=%d\n",
1058 __func__, NG_NODE_NAME(unit->node),
1061 } else /* Notify upper layer */
1062 error = ng_hci_lp_qos_cfm(con, ep->status);
1067 } /* qos_setup_compl */
1069 /* Hardware error event */
1071 hardware_error(ng_hci_unit_p unit, struct mbuf *event)
1074 "%s: %s - hardware error %#x\n",
1075 __func__, NG_NODE_NAME(unit->node), *mtod(event, u_int8_t *));
1080 } /* hardware_error */
1082 /* Role change event */
1084 role_change(ng_hci_unit_p unit, struct mbuf *event)
1086 ng_hci_role_change_ep *ep = NULL;
1087 ng_hci_unit_con_p con = NULL;
1089 NG_HCI_M_PULLUP(event, sizeof(*ep));
1093 ep = mtod(event, ng_hci_role_change_ep *);
1095 if (ep->status == 0) {
1096 /* XXX shoud we also change "role" for SCO connections? */
1097 con = ng_hci_con_by_bdaddr(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1099 con->role = ep->role;
1102 "%s: %s - ACL connection does not exist, bdaddr=%x:%x:%x:%x:%x:%x\n",
1103 __func__, NG_NODE_NAME(unit->node),
1104 ep->bdaddr.b[5], ep->bdaddr.b[4],
1105 ep->bdaddr.b[3], ep->bdaddr.b[2],
1106 ep->bdaddr.b[1], ep->bdaddr.b[0]);
1109 "%s: %s - failed to change role, status=%d, bdaddr=%x:%x:%x:%x:%x:%x\n",
1110 __func__, NG_NODE_NAME(unit->node), ep->status,
1111 ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3],
1112 ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]);
1119 /* Number of completed packets event */
1121 num_compl_pkts(ng_hci_unit_p unit, struct mbuf *event)
1123 ng_hci_num_compl_pkts_ep *ep = NULL;
1124 ng_hci_unit_con_p con = NULL;
1127 NG_HCI_M_PULLUP(event, sizeof(*ep));
1131 ep = mtod(event, ng_hci_num_compl_pkts_ep *);
1132 m_adj(event, sizeof(*ep));
1134 for (; ep->num_con_handles > 0; ep->num_con_handles --) {
1135 /* Get connection handle */
1136 m_copydata(event, 0, sizeof(h), (caddr_t) &h);
1137 m_adj(event, sizeof(h));
1138 h = NG_HCI_CON_HANDLE(le16toh(h));
1140 /* Get number of completed packets */
1141 m_copydata(event, 0, sizeof(p), (caddr_t) &p);
1142 m_adj(event, sizeof(p));
1145 /* Check if we have this connection handle */
1146 con = ng_hci_con_by_handle(unit, h);
1149 if (con->pending < 0) {
1151 "%s: %s - pending packet counter is out of sync! " \
1152 "handle=%d, pending=%d, ncp=%d\n", __func__, NG_NODE_NAME(unit->node),
1153 con->con_handle, con->pending, p);
1158 /* Update buffer descriptor */
1159 if (con->link_type != NG_HCI_LINK_SCO)
1160 NG_HCI_BUFF_ACL_FREE(unit->buffer, p);
1162 NG_HCI_BUFF_SCO_FREE(unit->buffer, p);
1165 "%s: %s - invalid connection handle=%d\n",
1166 __func__, NG_NODE_NAME(unit->node), h);
1171 /* Send more data */
1172 ng_hci_send_data(unit);
1175 } /* num_compl_pkts */
1177 /* Mode change event */
1179 mode_change(ng_hci_unit_p unit, struct mbuf *event)
1181 ng_hci_mode_change_ep *ep = NULL;
1182 ng_hci_unit_con_p con = NULL;
1185 NG_HCI_M_PULLUP(event, sizeof(*ep));
1189 ep = mtod(event, ng_hci_mode_change_ep *);
1191 if (ep->status == 0) {
1192 u_int16_t h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1194 con = ng_hci_con_by_handle(unit, h);
1197 "%s: %s - invalid connection handle=%d\n",
1198 __func__, NG_NODE_NAME(unit->node), h);
1200 } else if (con->link_type != NG_HCI_LINK_ACL) {
1202 "%s: %s - invalid link type=%d\n",
1203 __func__, NG_NODE_NAME(unit->node),
1207 con->mode = ep->unit_mode;
1210 "%s: %s - failed to change mode, status=%d\n",
1211 __func__, NG_NODE_NAME(unit->node), ep->status);
1218 /* Data buffer overflow event */
1220 data_buffer_overflow(ng_hci_unit_p unit, struct mbuf *event)
1223 "%s: %s - %s data buffer overflow\n",
1224 __func__, NG_NODE_NAME(unit->node),
1225 (*mtod(event, u_int8_t *) == NG_HCI_LINK_ACL)? "ACL" : "SCO");
1230 } /* data_buffer_overflow */
1232 /* Read clock offset complete event */
1234 read_clock_offset_compl(ng_hci_unit_p unit, struct mbuf *event)
1236 ng_hci_read_clock_offset_compl_ep *ep = NULL;
1237 ng_hci_unit_con_p con = NULL;
1238 ng_hci_neighbor_p n = NULL;
1241 NG_HCI_M_PULLUP(event, sizeof(*ep));
1245 ep = mtod(event, ng_hci_read_clock_offset_compl_ep *);
1247 if (ep->status == 0) {
1248 u_int16_t h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1250 con = ng_hci_con_by_handle(unit, h);
1253 "%s: %s - invalid connection handle=%d\n",
1254 __func__, NG_NODE_NAME(unit->node), h);
1259 /* Update cache entry */
1260 n = ng_hci_get_neighbor(unit, &con->bdaddr, NG_HCI_LINK_ACL);
1262 n = ng_hci_new_neighbor(unit);
1268 bcopy(&con->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1269 n->addrtype = NG_HCI_LINK_ACL;
1271 getmicrotime(&n->updated);
1273 n->clock_offset = le16toh(ep->clock_offset);
1276 "%s: %s - failed to Read Remote Clock Offset, status=%d\n",
1277 __func__, NG_NODE_NAME(unit->node), ep->status);
1282 } /* read_clock_offset_compl */
1284 /* QoS violation event */
1286 qos_violation(ng_hci_unit_p unit, struct mbuf *event)
1288 ng_hci_qos_violation_ep *ep = NULL;
1289 ng_hci_unit_con_p con = NULL;
1293 NG_HCI_M_PULLUP(event, sizeof(*ep));
1297 ep = mtod(event, ng_hci_qos_violation_ep *);
1299 /* Check if we have this connection handle */
1300 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1301 con = ng_hci_con_by_handle(unit, h);
1304 "%s: %s - invalid connection handle=%d\n",
1305 __func__, NG_NODE_NAME(unit->node), h);
1307 } else if (con->link_type != NG_HCI_LINK_ACL) {
1309 "%s: %s - invalid link type=%d\n",
1310 __func__, NG_NODE_NAME(unit->node), con->link_type);
1312 } else if (con->state != NG_HCI_CON_OPEN) {
1314 "%s: %s - invalid connection state=%d, handle=%d\n",
1315 __func__, NG_NODE_NAME(unit->node), con->state, h);
1317 } else /* Notify upper layer */
1318 error = ng_hci_lp_qos_ind(con);
1323 } /* qos_violation */
1325 /* Page scan mode change event */
1327 page_scan_mode_change(ng_hci_unit_p unit, struct mbuf *event)
1329 ng_hci_page_scan_mode_change_ep *ep = NULL;
1330 ng_hci_neighbor_p n = NULL;
1333 NG_HCI_M_PULLUP(event, sizeof(*ep));
1337 ep = mtod(event, ng_hci_page_scan_mode_change_ep *);
1339 /* Update cache entry */
1340 n = ng_hci_get_neighbor(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1342 n = ng_hci_new_neighbor(unit);
1348 bcopy(&ep->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1349 n->addrtype = NG_HCI_LINK_ACL;
1351 getmicrotime(&n->updated);
1353 n->page_scan_mode = ep->page_scan_mode;
1358 } /* page_scan_mode_change */
1360 /* Page scan repetition mode change event */
1362 page_scan_rep_mode_change(ng_hci_unit_p unit, struct mbuf *event)
1364 ng_hci_page_scan_rep_mode_change_ep *ep = NULL;
1365 ng_hci_neighbor_p n = NULL;
1368 NG_HCI_M_PULLUP(event, sizeof(*ep));
1372 ep = mtod(event, ng_hci_page_scan_rep_mode_change_ep *);
1374 /* Update cache entry */
1375 n = ng_hci_get_neighbor(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1377 n = ng_hci_new_neighbor(unit);
1383 bcopy(&ep->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1384 n->addrtype = NG_HCI_LINK_ACL;
1386 getmicrotime(&n->updated);
1388 n->page_scan_rep_mode = ep->page_scan_rep_mode;
1393 } /* page_scan_rep_mode_change */