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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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