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