1 /*
2 * ng_hci_evnt.c
3 */
4
5 /*-
6 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
7 *
8 * Copyright (c) Maksim Yevmenkin <[email protected]>
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
19 *
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
30 * SUCH DAMAGE.
31 *
32 * $Id: ng_hci_evnt.c,v 1.6 2003/09/08 18:57:51 max Exp $
33 * $FreeBSD$
34 */
35
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>
41 #include <sys/mbuf.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>
52
53 /******************************************************************************
54 ******************************************************************************
55 ** HCI event processing module
56 ******************************************************************************
57 ******************************************************************************/
58
59 /*
60 * Event processing routines
61 */
62
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 *);
82
83 /*
84 * Process HCI event packet
85 */
86
87 int
ng_hci_process_event(ng_hci_unit_p unit,struct mbuf * event)88 ng_hci_process_event(ng_hci_unit_p unit, struct mbuf *event)
89 {
90 ng_hci_event_pkt_t *hdr = NULL;
91 int error = 0;
92
93 /* Get event packet header */
94 NG_HCI_M_PULLUP(event, sizeof(*hdr));
95 if (event == NULL)
96 return (ENOBUFS);
97
98 hdr = mtod(event, ng_hci_event_pkt_t *);
99
100 NG_HCI_INFO(
101 "%s: %s - got HCI event=%#x, length=%d\n",
102 __func__, NG_NODE_NAME(unit->node), hdr->event, hdr->length);
103
104 /* Get rid of event header and process event */
105 m_adj(event, sizeof(*hdr));
106
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 */
125 NG_FREE_M(event);
126 break;
127 case NG_HCI_EVENT_LE:
128 error = le_event(unit, event);
129 break;
130
131 case NG_HCI_EVENT_INQUIRY_RESULT:
132 error = inquiry_result(unit, event);
133 break;
134
135 case NG_HCI_EVENT_CON_COMPL:
136 error = con_compl(unit, event);
137 break;
138
139 case NG_HCI_EVENT_CON_REQ:
140 error = con_req(unit, event);
141 break;
142
143 case NG_HCI_EVENT_DISCON_COMPL:
144 error = discon_compl(unit, event);
145 break;
146
147 case NG_HCI_EVENT_ENCRYPTION_CHANGE:
148 error = encryption_change(unit, event);
149 break;
150
151 case NG_HCI_EVENT_READ_REMOTE_FEATURES_COMPL:
152 error = read_remote_features_compl(unit, event);
153 break;
154
155 case NG_HCI_EVENT_QOS_SETUP_COMPL:
156 error = qos_setup_compl(unit, event);
157 break;
158
159 case NG_HCI_EVENT_COMMAND_COMPL:
160 error = ng_hci_process_command_complete(unit, event);
161 break;
162
163 case NG_HCI_EVENT_COMMAND_STATUS:
164 error = ng_hci_process_command_status(unit, event);
165 break;
166
167 case NG_HCI_EVENT_HARDWARE_ERROR:
168 error = hardware_error(unit, event);
169 break;
170
171 case NG_HCI_EVENT_ROLE_CHANGE:
172 error = role_change(unit, event);
173 break;
174
175 case NG_HCI_EVENT_NUM_COMPL_PKTS:
176 error = num_compl_pkts(unit, event);
177 break;
178
179 case NG_HCI_EVENT_MODE_CHANGE:
180 error = mode_change(unit, event);
181 break;
182
183 case NG_HCI_EVENT_DATA_BUFFER_OVERFLOW:
184 error = data_buffer_overflow(unit, event);
185 break;
186
187 case NG_HCI_EVENT_READ_CLOCK_OFFSET_COMPL:
188 error = read_clock_offset_compl(unit, event);
189 break;
190
191 case NG_HCI_EVENT_QOS_VIOLATION:
192 error = qos_violation(unit, event);
193 break;
194
195 case NG_HCI_EVENT_PAGE_SCAN_MODE_CHANGE:
196 error = page_scan_mode_change(unit, event);
197 break;
198
199 case NG_HCI_EVENT_PAGE_SCAN_REP_MODE_CHANGE:
200 error = page_scan_rep_mode_change(unit, event);
201 break;
202
203 default:
204 NG_FREE_M(event);
205 error = EINVAL;
206 break;
207 }
208
209 return (error);
210 } /* ng_hci_process_event */
211
212 /*
213 * Send ACL and/or SCO data to the unit driver
214 */
215
216 void
ng_hci_send_data(ng_hci_unit_p unit)217 ng_hci_send_data(ng_hci_unit_p unit)
218 {
219 int count;
220
221 /* Send ACL data */
222 NG_HCI_BUFF_ACL_AVAIL(unit->buffer, count);
223
224 NG_HCI_INFO(
225 "%s: %s - sending ACL data packets, count=%d\n",
226 __func__, NG_NODE_NAME(unit->node), count);
227
228 if (count > 0) {
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);
232 }
233
234 /* Send SCO data */
235 NG_HCI_BUFF_SCO_AVAIL(unit->buffer, count);
236
237 NG_HCI_INFO(
238 "%s: %s - sending SCO data packets, count=%d\n",
239 __func__, NG_NODE_NAME(unit->node), count);
240
241 if (count > 0) {
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);
245 }
246 } /* ng_hci_send_data */
247
248 /*
249 * Send data packets to the lower layer.
250 */
251
252 static int
send_data_packets(ng_hci_unit_p unit,int link_type,int limit)253 send_data_packets(ng_hci_unit_p unit, int link_type, int limit)
254 {
255 ng_hci_unit_con_p con = NULL, winner = NULL;
256 int reallink_type;
257 item_p item = NULL;
258 int min_pending, total_sent, sent, error, v;
259
260 for (total_sent = 0; limit > 0; ) {
261 min_pending = 0x0fffffff;
262 winner = NULL;
263
264 /*
265 * Find the connection that has has data to send
266 * and the smallest number of pending packets
267 */
268
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){
273 continue;
274 }
275 if (NG_BT_ITEMQ_LEN(&con->conq) == 0)
276 continue;
277
278 if (con->pending < min_pending) {
279 winner = con;
280 min_pending = con->pending;
281 }
282 }
283
284 if (winner == NULL)
285 break;
286
287 /*
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.
291 */
292
293 for (sent = 0; limit > 0; limit --, total_sent ++, sent ++) {
294 NG_BT_ITEMQ_DEQUEUE(&winner->conq, item);
295 if (item == NULL)
296 break;
297
298 NG_HCI_INFO(
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);
302
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) !=
306 NG_HCI_UNIT_READY) {
307 NG_HCI_ERR(
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 "),
311 unit->state);
312
313 NG_FREE_ITEM(item);
314 error = ENOTCONN;
315 } else {
316 v = NGI_M(item)->m_pkthdr.len;
317
318 /* Give packet to raw hook */
319 ng_hci_mtap(unit, NGI_M(item));
320
321 /* ... and forward item to the driver */
322 NG_FWD_ITEM_HOOK(error, item, unit->drv);
323 }
324
325 if (error != 0) {
326 NG_HCI_ERR(
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);
330 break;
331 }
332
333 winner->pending ++;
334 NG_HCI_STAT_BYTES_SENT(unit->stat, v);
335 }
336
337 /*
338 * Sync connection queue for the winner
339 */
340 sync_con_queue(unit, winner, sent);
341 }
342
343 return (total_sent);
344 } /* send_data_packets */
345
346 /*
347 * Send flow control messages to the upper layer
348 */
349
350 static int
sync_con_queue(ng_hci_unit_p unit,ng_hci_unit_con_p con,int completed)351 sync_con_queue(ng_hci_unit_p unit, ng_hci_unit_con_p con, int completed)
352 {
353 hook_p hook = NULL;
354 struct ng_mesg *msg = NULL;
355 ng_hci_sync_con_queue_ep *state = NULL;
356 int error;
357
358 hook = (con->link_type != NG_HCI_LINK_SCO)? unit->acl : unit->sco;
359 if (hook == NULL || NG_HOOK_NOT_VALID(hook))
360 return (ENOTCONN);
361
362 NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_SYNC_CON_QUEUE,
363 sizeof(*state), M_NOWAIT);
364 if (msg == NULL)
365 return (ENOMEM);
366
367 state = (ng_hci_sync_con_queue_ep *)(msg->data);
368 state->con_handle = con->con_handle;
369 state->completed = completed;
370
371 NG_SEND_MSG_HOOK(error, unit->node, msg, hook, 0);
372
373 return (error);
374 } /* sync_con_queue */
375 /* le meta event */
376 /* Inquiry result event */
377 static int
le_advertizing_report(ng_hci_unit_p unit,struct mbuf * event)378 le_advertizing_report(ng_hci_unit_p unit, struct mbuf *event)
379 {
380 ng_hci_le_advertising_report_ep *ep = NULL;
381 ng_hci_neighbor_p n = NULL;
382 bdaddr_t bdaddr;
383 int error = 0;
384 u_int8_t event_type;
385 u_int8_t addr_type;
386
387 NG_HCI_M_PULLUP(event, sizeof(*ep));
388 if (event == NULL)
389 return (ENOBUFS);
390
391 ep = mtod(event, ng_hci_le_advertising_report_ep *);
392 m_adj(event, sizeof(*ep));
393
394 for (; ep->num_reports > 0; ep->num_reports --) {
395 /* Get remote unit address */
396 NG_HCI_M_PULLUP(event, sizeof(u_int8_t));
397 event_type = *mtod(event, u_int8_t *);
398 m_adj(event, sizeof(u_int8_t));
399 NG_HCI_M_PULLUP(event, sizeof(u_int8_t));
400 addr_type = *mtod(event, u_int8_t *);
401 m_adj(event, sizeof(u_int8_t));
402
403 m_copydata(event, 0, sizeof(bdaddr), (caddr_t) &bdaddr);
404 m_adj(event, sizeof(bdaddr));
405
406 /* Lookup entry in the cache */
407 n = ng_hci_get_neighbor(unit, &bdaddr, (addr_type) ? NG_HCI_LINK_LE_RANDOM:NG_HCI_LINK_LE_PUBLIC);
408 if (n == NULL) {
409 /* Create new entry */
410 n = ng_hci_new_neighbor(unit);
411 if (n == NULL) {
412 error = ENOMEM;
413 break;
414 }
415 bcopy(&bdaddr, &n->bdaddr, sizeof(n->bdaddr));
416 n->addrtype = (addr_type)? NG_HCI_LINK_LE_RANDOM :
417 NG_HCI_LINK_LE_PUBLIC;
418
419 } else
420 getmicrotime(&n->updated);
421
422 {
423 /*
424 * TODO: Make these information
425 * Available from userland.
426 */
427 u_int8_t length_data;
428
429 event = m_pullup(event, sizeof(u_int8_t));
430 if(event == NULL){
431 NG_HCI_WARN("%s: Event datasize Pullup Failed\n", __func__);
432 goto out;
433 }
434 length_data = *mtod(event, u_int8_t *);
435 m_adj(event, sizeof(u_int8_t));
436 n->extinq_size = (length_data < NG_HCI_EXTINQ_MAX)?
437 length_data : NG_HCI_EXTINQ_MAX;
438
439 /*Advertizement data*/
440 event = m_pullup(event, n->extinq_size);
441 if(event == NULL){
442 NG_HCI_WARN("%s: Event data pullup Failed\n", __func__);
443 goto out;
444 }
445 m_copydata(event, 0, n->extinq_size, n->extinq_data);
446 m_adj(event, n->extinq_size);
447 event = m_pullup(event, sizeof(char ));
448 /*Get RSSI*/
449 if(event == NULL){
450 NG_HCI_WARN("%s: Event rssi pull up Failed\n", __func__);
451
452 goto out;
453 }
454 n->page_scan_mode = *mtod(event, char *);
455 m_adj(event, sizeof(u_int8_t));
456 }
457 }
458 out:
459 NG_FREE_M(event);
460
461 return (error);
462 } /* inquiry_result */
463
le_connection_complete(ng_hci_unit_p unit,struct mbuf * event)464 static int le_connection_complete(ng_hci_unit_p unit, struct mbuf *event)
465 {
466 int error = 0;
467
468 ng_hci_le_connection_complete_ep *ep = NULL;
469 ng_hci_unit_con_p con = NULL;
470 int link_type;
471 uint8_t uclass[3] = {0,0,0};//dummy uclass
472
473 NG_HCI_M_PULLUP(event, sizeof(*ep));
474 if (event == NULL)
475 return (ENOBUFS);
476
477 ep = mtod(event, ng_hci_le_connection_complete_ep *);
478 link_type = (ep->address_type)? NG_HCI_LINK_LE_RANDOM :
479 NG_HCI_LINK_LE_PUBLIC;
480 /*
481 * Find the first connection descriptor that matches the following:
482 *
483 * 1) con->link_type == link_type
484 * 2) con->state == NG_HCI_CON_W4_CONN_COMPLETE
485 * 3) con->bdaddr == ep->address
486 */
487 LIST_FOREACH(con, &unit->con_list, next)
488 if (con->link_type == link_type &&
489 con->state == NG_HCI_CON_W4_CONN_COMPLETE &&
490 bcmp(&con->bdaddr, &ep->address, sizeof(bdaddr_t)) == 0)
491 break;
492
493 /*
494 * Two possible cases:
495 *
496 * 1) We have found connection descriptor. That means upper layer has
497 * requested this connection via LP_CON_REQ message. In this case
498 * connection must have timeout set. If ng_hci_con_untimeout() fails
499 * then timeout message already went into node's queue. In this case
500 * ignore Connection_Complete event and let timeout deal with it.
501 *
502 * 2) We do not have connection descriptor. That means upper layer
503 * nas not requested this connection , (less likely) we gave up
504 * on this connection (timeout) or as node act as slave role.
505 * The most likely scenario is that
506 * we have received LE_Create_Connection command
507 * from the RAW hook
508 */
509
510 if (con == NULL) {
511 if (ep->status != 0)
512 goto out;
513
514 con = ng_hci_new_con(unit, link_type);
515 if (con == NULL) {
516 error = ENOMEM;
517 goto out;
518 }
519
520 con->state = NG_HCI_CON_W4_LP_CON_RSP;
521 ng_hci_con_timeout(con);
522
523 bcopy(&ep->address, &con->bdaddr, sizeof(con->bdaddr));
524 error = ng_hci_lp_con_ind(con, uclass);
525 if (error != 0) {
526 ng_hci_con_untimeout(con);
527 ng_hci_free_con(con);
528 }
529
530 } else if ((error = ng_hci_con_untimeout(con)) != 0)
531 goto out;
532
533 /*
534 * Update connection descriptor and send notification
535 * to the upper layers.
536 */
537
538 con->con_handle = NG_HCI_CON_HANDLE(le16toh(ep->handle));
539 con->encryption_mode = NG_HCI_ENCRYPTION_MODE_NONE;
540
541 ng_hci_lp_con_cfm(con, ep->status);
542
543 /* Adjust connection state */
544 if (ep->status != 0)
545 ng_hci_free_con(con);
546 else {
547 con->state = NG_HCI_CON_OPEN;
548
549 /*
550 * Change link policy for the ACL connections. Enable all
551 * supported link modes. Enable Role switch as well if
552 * device supports it.
553 */
554
555 }
556
557 out:
558 NG_FREE_M(event);
559
560 return (error);
561
562 }
563
le_connection_update(ng_hci_unit_p unit,struct mbuf * event)564 static int le_connection_update(ng_hci_unit_p unit, struct mbuf *event)
565 {
566 int error = 0;
567 /*TBD*/
568
569 NG_FREE_M(event);
570 return error;
571
572 }
573 static int
le_event(ng_hci_unit_p unit,struct mbuf * event)574 le_event(ng_hci_unit_p unit, struct mbuf *event)
575 {
576 int error = 0;
577 ng_hci_le_ep *lep;
578
579 NG_HCI_M_PULLUP(event, sizeof(*lep));
580 if(event ==NULL){
581 return ENOBUFS;
582 }
583 lep = mtod(event, ng_hci_le_ep *);
584 m_adj(event, sizeof(*lep));
585 switch(lep->subevent_code){
586 case NG_HCI_LEEV_CON_COMPL:
587 le_connection_complete(unit, event);
588 break;
589 case NG_HCI_LEEV_ADVREP:
590 le_advertizing_report(unit, event);
591 break;
592 case NG_HCI_LEEV_CON_UPDATE_COMPL:
593 le_connection_update(unit, event);
594 break;
595 case NG_HCI_LEEV_READ_REMOTE_FEATURES_COMPL:
596 //TBD
597 /*FALLTHROUGH*/
598 case NG_HCI_LEEV_LONG_TERM_KEY_REQUEST:
599 //TBD
600 /*FALLTHROUGH*/
601 default:
602 NG_FREE_M(event);
603 }
604 return error;
605 }
606
607 /* Inquiry result event */
608 static int
inquiry_result(ng_hci_unit_p unit,struct mbuf * event)609 inquiry_result(ng_hci_unit_p unit, struct mbuf *event)
610 {
611 ng_hci_inquiry_result_ep *ep = NULL;
612 ng_hci_neighbor_p n = NULL;
613 bdaddr_t bdaddr;
614 int error = 0;
615
616 NG_HCI_M_PULLUP(event, sizeof(*ep));
617 if (event == NULL)
618 return (ENOBUFS);
619
620 ep = mtod(event, ng_hci_inquiry_result_ep *);
621 m_adj(event, sizeof(*ep));
622
623 for (; ep->num_responses > 0; ep->num_responses --) {
624 /* Get remote unit address */
625 m_copydata(event, 0, sizeof(bdaddr), (caddr_t) &bdaddr);
626 m_adj(event, sizeof(bdaddr));
627
628 /* Lookup entry in the cache */
629 n = ng_hci_get_neighbor(unit, &bdaddr, NG_HCI_LINK_ACL);
630 if (n == NULL) {
631 /* Create new entry */
632 n = ng_hci_new_neighbor(unit);
633 if (n == NULL) {
634 error = ENOMEM;
635 break;
636 }
637 } else
638 getmicrotime(&n->updated);
639
640 bcopy(&bdaddr, &n->bdaddr, sizeof(n->bdaddr));
641 n->addrtype = NG_HCI_LINK_ACL;
642
643 /* XXX call m_pullup here? */
644
645 n->page_scan_rep_mode = *mtod(event, u_int8_t *);
646 m_adj(event, sizeof(u_int8_t));
647
648 /* page_scan_period_mode */
649 m_adj(event, sizeof(u_int8_t));
650
651 n->page_scan_mode = *mtod(event, u_int8_t *);
652 m_adj(event, sizeof(u_int8_t));
653
654 /* class */
655 m_adj(event, NG_HCI_CLASS_SIZE);
656
657 /* clock offset */
658 m_copydata(event, 0, sizeof(n->clock_offset),
659 (caddr_t) &n->clock_offset);
660 n->clock_offset = le16toh(n->clock_offset);
661 }
662
663 NG_FREE_M(event);
664
665 return (error);
666 } /* inquiry_result */
667
668 /* Connection complete event */
669 static int
con_compl(ng_hci_unit_p unit,struct mbuf * event)670 con_compl(ng_hci_unit_p unit, struct mbuf *event)
671 {
672 ng_hci_con_compl_ep *ep = NULL;
673 ng_hci_unit_con_p con = NULL;
674 int error = 0;
675
676 NG_HCI_M_PULLUP(event, sizeof(*ep));
677 if (event == NULL)
678 return (ENOBUFS);
679
680 ep = mtod(event, ng_hci_con_compl_ep *);
681
682 /*
683 * Find the first connection descriptor that matches the following:
684 *
685 * 1) con->link_type == ep->link_type
686 * 2) con->state == NG_HCI_CON_W4_CONN_COMPLETE
687 * 3) con->bdaddr == ep->bdaddr
688 */
689
690 LIST_FOREACH(con, &unit->con_list, next)
691 if (con->link_type == ep->link_type &&
692 con->state == NG_HCI_CON_W4_CONN_COMPLETE &&
693 bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0)
694 break;
695
696 /*
697 * Two possible cases:
698 *
699 * 1) We have found connection descriptor. That means upper layer has
700 * requested this connection via LP_CON_REQ message. In this case
701 * connection must have timeout set. If ng_hci_con_untimeout() fails
702 * then timeout message already went into node's queue. In this case
703 * ignore Connection_Complete event and let timeout deal with it.
704 *
705 * 2) We do not have connection descriptor. That means upper layer
706 * nas not requested this connection or (less likely) we gave up
707 * on this connection (timeout). The most likely scenario is that
708 * we have received Create_Connection/Add_SCO_Connection command
709 * from the RAW hook
710 */
711
712 if (con == NULL) {
713 if (ep->status != 0)
714 goto out;
715
716 con = ng_hci_new_con(unit, ep->link_type);
717 if (con == NULL) {
718 error = ENOMEM;
719 goto out;
720 }
721
722 bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr));
723 } else if ((error = ng_hci_con_untimeout(con)) != 0)
724 goto out;
725
726 /*
727 * Update connection descriptor and send notification
728 * to the upper layers.
729 */
730
731 con->con_handle = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
732 con->encryption_mode = ep->encryption_mode;
733
734 ng_hci_lp_con_cfm(con, ep->status);
735
736 /* Adjust connection state */
737 if (ep->status != 0)
738 ng_hci_free_con(con);
739 else {
740 con->state = NG_HCI_CON_OPEN;
741
742 /*
743 * Change link policy for the ACL connections. Enable all
744 * supported link modes. Enable Role switch as well if
745 * device supports it.
746 */
747
748 if (ep->link_type == NG_HCI_LINK_ACL) {
749 struct __link_policy {
750 ng_hci_cmd_pkt_t hdr;
751 ng_hci_write_link_policy_settings_cp cp;
752 } __attribute__ ((packed)) *lp;
753 struct mbuf *m;
754
755 MGETHDR(m, M_NOWAIT, MT_DATA);
756 if (m != NULL) {
757 m->m_pkthdr.len = m->m_len = sizeof(*lp);
758 lp = mtod(m, struct __link_policy *);
759
760 lp->hdr.type = NG_HCI_CMD_PKT;
761 lp->hdr.opcode = htole16(NG_HCI_OPCODE(
762 NG_HCI_OGF_LINK_POLICY,
763 NG_HCI_OCF_WRITE_LINK_POLICY_SETTINGS));
764 lp->hdr.length = sizeof(lp->cp);
765
766 lp->cp.con_handle = ep->con_handle;
767
768 lp->cp.settings = 0;
769 if ((unit->features[0] & NG_HCI_LMP_SWITCH) &&
770 unit->role_switch)
771 lp->cp.settings |= 0x1;
772 if (unit->features[0] & NG_HCI_LMP_HOLD_MODE)
773 lp->cp.settings |= 0x2;
774 if (unit->features[0] & NG_HCI_LMP_SNIFF_MODE)
775 lp->cp.settings |= 0x4;
776 if (unit->features[1] & NG_HCI_LMP_PARK_MODE)
777 lp->cp.settings |= 0x8;
778
779 lp->cp.settings &= unit->link_policy_mask;
780 lp->cp.settings = htole16(lp->cp.settings);
781
782 NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m);
783 if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING))
784 ng_hci_send_command(unit);
785 }
786 }
787 }
788 out:
789 NG_FREE_M(event);
790
791 return (error);
792 } /* con_compl */
793
794 /* Connection request event */
795 static int
con_req(ng_hci_unit_p unit,struct mbuf * event)796 con_req(ng_hci_unit_p unit, struct mbuf *event)
797 {
798 ng_hci_con_req_ep *ep = NULL;
799 ng_hci_unit_con_p con = NULL;
800 int error = 0;
801
802 NG_HCI_M_PULLUP(event, sizeof(*ep));
803 if (event == NULL)
804 return (ENOBUFS);
805
806 ep = mtod(event, ng_hci_con_req_ep *);
807
808 /*
809 * Find the first connection descriptor that matches the following:
810 *
811 * 1) con->link_type == ep->link_type
812 *
813 * 2) con->state == NG_HCI_CON_W4_LP_CON_RSP ||
814 * con->state == NG_HCI_CON_W4_CONN_COMPL
815 *
816 * 3) con->bdaddr == ep->bdaddr
817 *
818 * Possible cases:
819 *
820 * 1) We do not have connection descriptor. This is simple. Create
821 * new fresh connection descriptor and send notification to the
822 * appropriate upstream hook (based on link_type).
823 *
824 * 2) We found connection handle. This is more complicated.
825 *
826 * 2.1) ACL links
827 *
828 * Since only one ACL link can exist between each pair of
829 * units then we have a race. Our upper layer has requested
830 * an ACL connection to the remote unit, but we did not send
831 * command yet. At the same time the remote unit has requested
832 * an ACL connection from us. In this case we will ignore
833 * Connection_Request event. This probably will cause connect
834 * failure on both units.
835 *
836 * 2.2) SCO links
837 *
838 * The spec on page 45 says :
839 *
840 * "The master can support up to three SCO links to the same
841 * slave or to different slaves. A slave can support up to
842 * three SCO links from the same master, or two SCO links if
843 * the links originate from different masters."
844 *
845 * The only problem is how to handle multiple SCO links between
846 * matster and slave. For now we will assume that multiple SCO
847 * links MUST be opened one after another.
848 */
849
850 LIST_FOREACH(con, &unit->con_list, next)
851 if (con->link_type == ep->link_type &&
852 (con->state == NG_HCI_CON_W4_LP_CON_RSP ||
853 con->state == NG_HCI_CON_W4_CONN_COMPLETE) &&
854 bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0)
855 break;
856
857 if (con == NULL) {
858 con = ng_hci_new_con(unit, ep->link_type);
859 if (con != NULL) {
860 bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr));
861
862 con->state = NG_HCI_CON_W4_LP_CON_RSP;
863 ng_hci_con_timeout(con);
864
865 error = ng_hci_lp_con_ind(con, ep->uclass);
866 if (error != 0) {
867 ng_hci_con_untimeout(con);
868 ng_hci_free_con(con);
869 }
870 } else
871 error = ENOMEM;
872 }
873
874 NG_FREE_M(event);
875
876 return (error);
877 } /* con_req */
878
879 /* Disconnect complete event */
880 static int
discon_compl(ng_hci_unit_p unit,struct mbuf * event)881 discon_compl(ng_hci_unit_p unit, struct mbuf *event)
882 {
883 ng_hci_discon_compl_ep *ep = NULL;
884 ng_hci_unit_con_p con = NULL;
885 int error = 0;
886 u_int16_t h;
887
888 NG_HCI_M_PULLUP(event, sizeof(*ep));
889 if (event == NULL)
890 return (ENOBUFS);
891
892 ep = mtod(event, ng_hci_discon_compl_ep *);
893
894 /*
895 * XXX
896 * Do we have to send notification if ep->status != 0?
897 * For now we will send notification for both ACL and SCO connections
898 * ONLY if ep->status == 0.
899 */
900
901 if (ep->status == 0) {
902 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
903 con = ng_hci_con_by_handle(unit, h);
904 if (con != NULL) {
905 error = ng_hci_lp_discon_ind(con, ep->reason);
906
907 /* Remove all timeouts (if any) */
908 if (con->flags & NG_HCI_CON_TIMEOUT_PENDING)
909 ng_hci_con_untimeout(con);
910
911 ng_hci_free_con(con);
912 } else {
913 NG_HCI_ALERT(
914 "%s: %s - invalid connection handle=%d\n",
915 __func__, NG_NODE_NAME(unit->node), h);
916 error = ENOENT;
917 }
918 }
919
920 NG_FREE_M(event);
921
922 return (error);
923 } /* discon_compl */
924
925 /* Encryption change event */
926 static int
encryption_change(ng_hci_unit_p unit,struct mbuf * event)927 encryption_change(ng_hci_unit_p unit, struct mbuf *event)
928 {
929 ng_hci_encryption_change_ep *ep = NULL;
930 ng_hci_unit_con_p con = NULL;
931 int error = 0;
932 u_int16_t h;
933
934 NG_HCI_M_PULLUP(event, sizeof(*ep));
935 if (event == NULL)
936 return (ENOBUFS);
937
938 ep = mtod(event, ng_hci_encryption_change_ep *);
939 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
940 con = ng_hci_con_by_handle(unit, h);
941
942 if (ep->status == 0) {
943 if (con == NULL) {
944 NG_HCI_ALERT(
945 "%s: %s - invalid connection handle=%d\n",
946 __func__, NG_NODE_NAME(unit->node), h);
947 error = ENOENT;
948 } else if (con->link_type == NG_HCI_LINK_SCO) {
949 NG_HCI_ALERT(
950 "%s: %s - invalid link type=%d\n",
951 __func__, NG_NODE_NAME(unit->node),
952 con->link_type);
953 error = EINVAL;
954 } else if (ep->encryption_enable)
955 /* XXX is that true? */
956 con->encryption_mode = NG_HCI_ENCRYPTION_MODE_P2P;
957 else
958 con->encryption_mode = NG_HCI_ENCRYPTION_MODE_NONE;
959 } else
960 NG_HCI_ERR(
961 "%s: %s - failed to change encryption mode, status=%d\n",
962 __func__, NG_NODE_NAME(unit->node), ep->status);
963
964 /*Anyway, propagete encryption status to upper layer*/
965 ng_hci_lp_enc_change(con, con->encryption_mode);
966
967 NG_FREE_M(event);
968
969 return (error);
970 } /* encryption_change */
971
972 /* Read remote feature complete event */
973 static int
read_remote_features_compl(ng_hci_unit_p unit,struct mbuf * event)974 read_remote_features_compl(ng_hci_unit_p unit, struct mbuf *event)
975 {
976 ng_hci_read_remote_features_compl_ep *ep = NULL;
977 ng_hci_unit_con_p con = NULL;
978 ng_hci_neighbor_p n = NULL;
979 u_int16_t h;
980 int error = 0;
981
982 NG_HCI_M_PULLUP(event, sizeof(*ep));
983 if (event == NULL)
984 return (ENOBUFS);
985
986 ep = mtod(event, ng_hci_read_remote_features_compl_ep *);
987
988 if (ep->status == 0) {
989 /* Check if we have this connection handle */
990 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
991 con = ng_hci_con_by_handle(unit, h);
992 if (con == NULL) {
993 NG_HCI_ALERT(
994 "%s: %s - invalid connection handle=%d\n",
995 __func__, NG_NODE_NAME(unit->node), h);
996 error = ENOENT;
997 goto out;
998 }
999
1000 /* Update cache entry */
1001 n = ng_hci_get_neighbor(unit, &con->bdaddr, NG_HCI_LINK_ACL);
1002 if (n == NULL) {
1003 n = ng_hci_new_neighbor(unit);
1004 if (n == NULL) {
1005 error = ENOMEM;
1006 goto out;
1007 }
1008
1009 bcopy(&con->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1010 n->addrtype = NG_HCI_LINK_ACL;
1011 } else
1012 getmicrotime(&n->updated);
1013
1014 bcopy(ep->features, n->features, sizeof(n->features));
1015 } else
1016 NG_HCI_ERR(
1017 "%s: %s - failed to read remote unit features, status=%d\n",
1018 __func__, NG_NODE_NAME(unit->node), ep->status);
1019 out:
1020 NG_FREE_M(event);
1021
1022 return (error);
1023 } /* read_remote_features_compl */
1024
1025 /* QoS setup complete event */
1026 static int
qos_setup_compl(ng_hci_unit_p unit,struct mbuf * event)1027 qos_setup_compl(ng_hci_unit_p unit, struct mbuf *event)
1028 {
1029 ng_hci_qos_setup_compl_ep *ep = NULL;
1030 ng_hci_unit_con_p con = NULL;
1031 u_int16_t h;
1032 int error = 0;
1033
1034 NG_HCI_M_PULLUP(event, sizeof(*ep));
1035 if (event == NULL)
1036 return (ENOBUFS);
1037
1038 ep = mtod(event, ng_hci_qos_setup_compl_ep *);
1039
1040 /* Check if we have this connection handle */
1041 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1042 con = ng_hci_con_by_handle(unit, h);
1043 if (con == NULL) {
1044 NG_HCI_ALERT(
1045 "%s: %s - invalid connection handle=%d\n",
1046 __func__, NG_NODE_NAME(unit->node), h);
1047 error = ENOENT;
1048 } else if (con->link_type != NG_HCI_LINK_ACL) {
1049 NG_HCI_ALERT(
1050 "%s: %s - invalid link type=%d, handle=%d\n",
1051 __func__, NG_NODE_NAME(unit->node), con->link_type, h);
1052 error = EINVAL;
1053 } else if (con->state != NG_HCI_CON_OPEN) {
1054 NG_HCI_ALERT(
1055 "%s: %s - invalid connection state=%d, handle=%d\n",
1056 __func__, NG_NODE_NAME(unit->node),
1057 con->state, h);
1058 error = EINVAL;
1059 } else /* Notify upper layer */
1060 error = ng_hci_lp_qos_cfm(con, ep->status);
1061
1062 NG_FREE_M(event);
1063
1064 return (error);
1065 } /* qos_setup_compl */
1066
1067 /* Hardware error event */
1068 static int
hardware_error(ng_hci_unit_p unit,struct mbuf * event)1069 hardware_error(ng_hci_unit_p unit, struct mbuf *event)
1070 {
1071 NG_HCI_ALERT(
1072 "%s: %s - hardware error %#x\n",
1073 __func__, NG_NODE_NAME(unit->node), *mtod(event, u_int8_t *));
1074
1075 NG_FREE_M(event);
1076
1077 return (0);
1078 } /* hardware_error */
1079
1080 /* Role change event */
1081 static int
role_change(ng_hci_unit_p unit,struct mbuf * event)1082 role_change(ng_hci_unit_p unit, struct mbuf *event)
1083 {
1084 ng_hci_role_change_ep *ep = NULL;
1085 ng_hci_unit_con_p con = NULL;
1086
1087 NG_HCI_M_PULLUP(event, sizeof(*ep));
1088 if (event == NULL)
1089 return (ENOBUFS);
1090
1091 ep = mtod(event, ng_hci_role_change_ep *);
1092
1093 if (ep->status == 0) {
1094 /* XXX shoud we also change "role" for SCO connections? */
1095 con = ng_hci_con_by_bdaddr(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1096 if (con != NULL)
1097 con->role = ep->role;
1098 else
1099 NG_HCI_ALERT(
1100 "%s: %s - ACL connection does not exist, bdaddr=%x:%x:%x:%x:%x:%x\n",
1101 __func__, NG_NODE_NAME(unit->node),
1102 ep->bdaddr.b[5], ep->bdaddr.b[4],
1103 ep->bdaddr.b[3], ep->bdaddr.b[2],
1104 ep->bdaddr.b[1], ep->bdaddr.b[0]);
1105 } else
1106 NG_HCI_ERR(
1107 "%s: %s - failed to change role, status=%d, bdaddr=%x:%x:%x:%x:%x:%x\n",
1108 __func__, NG_NODE_NAME(unit->node), ep->status,
1109 ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3],
1110 ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]);
1111
1112 NG_FREE_M(event);
1113
1114 return (0);
1115 } /* role_change */
1116
1117 /* Number of completed packets event */
1118 static int
num_compl_pkts(ng_hci_unit_p unit,struct mbuf * event)1119 num_compl_pkts(ng_hci_unit_p unit, struct mbuf *event)
1120 {
1121 ng_hci_num_compl_pkts_ep *ep = NULL;
1122 ng_hci_unit_con_p con = NULL;
1123 u_int16_t h, p;
1124
1125 NG_HCI_M_PULLUP(event, sizeof(*ep));
1126 if (event == NULL)
1127 return (ENOBUFS);
1128
1129 ep = mtod(event, ng_hci_num_compl_pkts_ep *);
1130 m_adj(event, sizeof(*ep));
1131
1132 for (; ep->num_con_handles > 0; ep->num_con_handles --) {
1133 /* Get connection handle */
1134 m_copydata(event, 0, sizeof(h), (caddr_t) &h);
1135 m_adj(event, sizeof(h));
1136 h = NG_HCI_CON_HANDLE(le16toh(h));
1137
1138 /* Get number of completed packets */
1139 m_copydata(event, 0, sizeof(p), (caddr_t) &p);
1140 m_adj(event, sizeof(p));
1141 p = le16toh(p);
1142
1143 /* Check if we have this connection handle */
1144 con = ng_hci_con_by_handle(unit, h);
1145 if (con != NULL) {
1146 con->pending -= p;
1147 if (con->pending < 0) {
1148 NG_HCI_WARN(
1149 "%s: %s - pending packet counter is out of sync! " \
1150 "handle=%d, pending=%d, ncp=%d\n", __func__, NG_NODE_NAME(unit->node),
1151 con->con_handle, con->pending, p);
1152
1153 con->pending = 0;
1154 }
1155
1156 /* Update buffer descriptor */
1157 if (con->link_type != NG_HCI_LINK_SCO)
1158 NG_HCI_BUFF_ACL_FREE(unit->buffer, p);
1159 else
1160 NG_HCI_BUFF_SCO_FREE(unit->buffer, p);
1161 } else
1162 NG_HCI_ALERT(
1163 "%s: %s - invalid connection handle=%d\n",
1164 __func__, NG_NODE_NAME(unit->node), h);
1165 }
1166
1167 NG_FREE_M(event);
1168
1169 /* Send more data */
1170 ng_hci_send_data(unit);
1171
1172 return (0);
1173 } /* num_compl_pkts */
1174
1175 /* Mode change event */
1176 static int
mode_change(ng_hci_unit_p unit,struct mbuf * event)1177 mode_change(ng_hci_unit_p unit, struct mbuf *event)
1178 {
1179 ng_hci_mode_change_ep *ep = NULL;
1180 ng_hci_unit_con_p con = NULL;
1181 int error = 0;
1182
1183 NG_HCI_M_PULLUP(event, sizeof(*ep));
1184 if (event == NULL)
1185 return (ENOBUFS);
1186
1187 ep = mtod(event, ng_hci_mode_change_ep *);
1188
1189 if (ep->status == 0) {
1190 u_int16_t h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1191
1192 con = ng_hci_con_by_handle(unit, h);
1193 if (con == NULL) {
1194 NG_HCI_ALERT(
1195 "%s: %s - invalid connection handle=%d\n",
1196 __func__, NG_NODE_NAME(unit->node), h);
1197 error = ENOENT;
1198 } else if (con->link_type != NG_HCI_LINK_ACL) {
1199 NG_HCI_ALERT(
1200 "%s: %s - invalid link type=%d\n",
1201 __func__, NG_NODE_NAME(unit->node),
1202 con->link_type);
1203 error = EINVAL;
1204 } else
1205 con->mode = ep->unit_mode;
1206 } else
1207 NG_HCI_ERR(
1208 "%s: %s - failed to change mode, status=%d\n",
1209 __func__, NG_NODE_NAME(unit->node), ep->status);
1210
1211 NG_FREE_M(event);
1212
1213 return (error);
1214 } /* mode_change */
1215
1216 /* Data buffer overflow event */
1217 static int
data_buffer_overflow(ng_hci_unit_p unit,struct mbuf * event)1218 data_buffer_overflow(ng_hci_unit_p unit, struct mbuf *event)
1219 {
1220 NG_HCI_ALERT(
1221 "%s: %s - %s data buffer overflow\n",
1222 __func__, NG_NODE_NAME(unit->node),
1223 (*mtod(event, u_int8_t *) == NG_HCI_LINK_ACL)? "ACL" : "SCO");
1224
1225 NG_FREE_M(event);
1226
1227 return (0);
1228 } /* data_buffer_overflow */
1229
1230 /* Read clock offset complete event */
1231 static int
read_clock_offset_compl(ng_hci_unit_p unit,struct mbuf * event)1232 read_clock_offset_compl(ng_hci_unit_p unit, struct mbuf *event)
1233 {
1234 ng_hci_read_clock_offset_compl_ep *ep = NULL;
1235 ng_hci_unit_con_p con = NULL;
1236 ng_hci_neighbor_p n = NULL;
1237 int error = 0;
1238
1239 NG_HCI_M_PULLUP(event, sizeof(*ep));
1240 if (event == NULL)
1241 return (ENOBUFS);
1242
1243 ep = mtod(event, ng_hci_read_clock_offset_compl_ep *);
1244
1245 if (ep->status == 0) {
1246 u_int16_t h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1247
1248 con = ng_hci_con_by_handle(unit, h);
1249 if (con == NULL) {
1250 NG_HCI_ALERT(
1251 "%s: %s - invalid connection handle=%d\n",
1252 __func__, NG_NODE_NAME(unit->node), h);
1253 error = ENOENT;
1254 goto out;
1255 }
1256
1257 /* Update cache entry */
1258 n = ng_hci_get_neighbor(unit, &con->bdaddr, NG_HCI_LINK_ACL);
1259 if (n == NULL) {
1260 n = ng_hci_new_neighbor(unit);
1261 if (n == NULL) {
1262 error = ENOMEM;
1263 goto out;
1264 }
1265
1266 bcopy(&con->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1267 n->addrtype = NG_HCI_LINK_ACL;
1268 } else
1269 getmicrotime(&n->updated);
1270
1271 n->clock_offset = le16toh(ep->clock_offset);
1272 } else
1273 NG_HCI_ERR(
1274 "%s: %s - failed to Read Remote Clock Offset, status=%d\n",
1275 __func__, NG_NODE_NAME(unit->node), ep->status);
1276 out:
1277 NG_FREE_M(event);
1278
1279 return (error);
1280 } /* read_clock_offset_compl */
1281
1282 /* QoS violation event */
1283 static int
qos_violation(ng_hci_unit_p unit,struct mbuf * event)1284 qos_violation(ng_hci_unit_p unit, struct mbuf *event)
1285 {
1286 ng_hci_qos_violation_ep *ep = NULL;
1287 ng_hci_unit_con_p con = NULL;
1288 u_int16_t h;
1289 int error = 0;
1290
1291 NG_HCI_M_PULLUP(event, sizeof(*ep));
1292 if (event == NULL)
1293 return (ENOBUFS);
1294
1295 ep = mtod(event, ng_hci_qos_violation_ep *);
1296
1297 /* Check if we have this connection handle */
1298 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1299 con = ng_hci_con_by_handle(unit, h);
1300 if (con == NULL) {
1301 NG_HCI_ALERT(
1302 "%s: %s - invalid connection handle=%d\n",
1303 __func__, NG_NODE_NAME(unit->node), h);
1304 error = ENOENT;
1305 } else if (con->link_type != NG_HCI_LINK_ACL) {
1306 NG_HCI_ALERT(
1307 "%s: %s - invalid link type=%d\n",
1308 __func__, NG_NODE_NAME(unit->node), con->link_type);
1309 error = EINVAL;
1310 } else if (con->state != NG_HCI_CON_OPEN) {
1311 NG_HCI_ALERT(
1312 "%s: %s - invalid connection state=%d, handle=%d\n",
1313 __func__, NG_NODE_NAME(unit->node), con->state, h);
1314 error = EINVAL;
1315 } else /* Notify upper layer */
1316 error = ng_hci_lp_qos_ind(con);
1317
1318 NG_FREE_M(event);
1319
1320 return (error);
1321 } /* qos_violation */
1322
1323 /* Page scan mode change event */
1324 static int
page_scan_mode_change(ng_hci_unit_p unit,struct mbuf * event)1325 page_scan_mode_change(ng_hci_unit_p unit, struct mbuf *event)
1326 {
1327 ng_hci_page_scan_mode_change_ep *ep = NULL;
1328 ng_hci_neighbor_p n = NULL;
1329 int error = 0;
1330
1331 NG_HCI_M_PULLUP(event, sizeof(*ep));
1332 if (event == NULL)
1333 return (ENOBUFS);
1334
1335 ep = mtod(event, ng_hci_page_scan_mode_change_ep *);
1336
1337 /* Update cache entry */
1338 n = ng_hci_get_neighbor(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1339 if (n == NULL) {
1340 n = ng_hci_new_neighbor(unit);
1341 if (n == NULL) {
1342 error = ENOMEM;
1343 goto out;
1344 }
1345
1346 bcopy(&ep->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1347 n->addrtype = NG_HCI_LINK_ACL;
1348 } else
1349 getmicrotime(&n->updated);
1350
1351 n->page_scan_mode = ep->page_scan_mode;
1352 out:
1353 NG_FREE_M(event);
1354
1355 return (error);
1356 } /* page_scan_mode_change */
1357
1358 /* Page scan repetition mode change event */
1359 static int
page_scan_rep_mode_change(ng_hci_unit_p unit,struct mbuf * event)1360 page_scan_rep_mode_change(ng_hci_unit_p unit, struct mbuf *event)
1361 {
1362 ng_hci_page_scan_rep_mode_change_ep *ep = NULL;
1363 ng_hci_neighbor_p n = NULL;
1364 int error = 0;
1365
1366 NG_HCI_M_PULLUP(event, sizeof(*ep));
1367 if (event == NULL)
1368 return (ENOBUFS);
1369
1370 ep = mtod(event, ng_hci_page_scan_rep_mode_change_ep *);
1371
1372 /* Update cache entry */
1373 n = ng_hci_get_neighbor(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1374 if (n == NULL) {
1375 n = ng_hci_new_neighbor(unit);
1376 if (n == NULL) {
1377 error = ENOMEM;
1378 goto out;
1379 }
1380
1381 bcopy(&ep->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1382 n->addrtype = NG_HCI_LINK_ACL;
1383 } else
1384 getmicrotime(&n->updated);
1385
1386 n->page_scan_rep_mode = ep->page_scan_rep_mode;
1387 out:
1388 NG_FREE_M(event);
1389
1390 return (error);
1391 } /* page_scan_rep_mode_change */
1392
1393