sys/netgraph/bluetooth/hci/ng_hci_evnt.c

   1 /*
   2  * ng_hci_evnt.c
   3  */
   4
   5 /*-
   6  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   7  *
   8  * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com>
   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
  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
 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
 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
 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
 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         int                              num_reports = 0;
 385         u_int8_t event_type;
 386         u_int8_t addr_type;
 387
 388         NG_HCI_M_PULLUP(event, sizeof(*ep));
 389         if (event == NULL)
 390                 return (ENOBUFS);
 391
 392         ep = mtod(event, ng_hci_le_advertising_report_ep *);
 393         num_reports = ep->num_reports;
 394         m_adj(event, sizeof(*ep));
 395         ep = NULL;
 396
 397         for (; num_reports > 0; num_reports --) {
 398                 /* Get remote unit address */
 399                 NG_HCI_M_PULLUP(event, sizeof(u_int8_t));
 400                 event_type = *mtod(event, u_int8_t *);
 401                 m_adj(event, sizeof(u_int8_t));
 402                 NG_HCI_M_PULLUP(event, sizeof(u_int8_t));
 403                 addr_type = *mtod(event, u_int8_t *);
 404                 m_adj(event, sizeof(u_int8_t));
 405
 406                 m_copydata(event, 0, sizeof(bdaddr), (caddr_t) &bdaddr);
 407                 m_adj(event, sizeof(bdaddr));
 408
 409                 /* Lookup entry in the cache */
 410                 n = ng_hci_get_neighbor(unit, &bdaddr, (addr_type) ? NG_HCI_LINK_LE_RANDOM:NG_HCI_LINK_LE_PUBLIC);
 411                 if (n == NULL) {
 412                         /* Create new entry */
 413                         n = ng_hci_new_neighbor(unit);
 414                         if (n == NULL) {
 415                                 error = ENOMEM;
 416                                 break;
 417                         }
 418                         bcopy(&bdaddr, &n->bdaddr, sizeof(n->bdaddr));
 419                         n->addrtype = (addr_type)? NG_HCI_LINK_LE_RANDOM :
 420                           NG_HCI_LINK_LE_PUBLIC;
 421
 422                 } else
 423                         getmicrotime(&n->updated);
 424
 425                 {
 426                         /*
 427                          * TODO: Make these information
 428                          * Available from userland.
 429                          */
 430                         u_int8_t length_data;
 431
 432                         event = m_pullup(event, sizeof(u_int8_t));
 433                         if(event == NULL){
 434                                 NG_HCI_WARN("%s: Event datasize Pullup Failed\n", __func__);
 435                                 goto out;
 436                         }
 437                         length_data = *mtod(event, u_int8_t *);
 438                         m_adj(event, sizeof(u_int8_t));
 439                         n->extinq_size = (length_data < NG_HCI_EXTINQ_MAX)?
 440                                 length_data : NG_HCI_EXTINQ_MAX;
 441
 442                         /*Advertizement data*/
 443                         event = m_pullup(event, n->extinq_size);
 444                         if(event == NULL){
 445                                 NG_HCI_WARN("%s: Event data pullup Failed\n", __func__);
 446                                 goto out;
 447                         }
 448                         m_copydata(event, 0, n->extinq_size, n->extinq_data);
 449                         m_adj(event, n->extinq_size);
 450                         event = m_pullup(event, sizeof(char ));
 451                         /*Get RSSI*/
 452                         if(event == NULL){
 453                                 NG_HCI_WARN("%s: Event rssi pull up Failed\n", __func__);
 454
 455                                 goto out;
 456                         }
 457                         n->page_scan_mode = *mtod(event, char *);
 458                         m_adj(event, sizeof(u_int8_t));
 459                 }
 460         }
 461  out:
 462         NG_FREE_M(event);
 463
 464         return (error);
 465 } /* inquiry_result */
 466
 467 static int le_connection_complete(ng_hci_unit_p unit, struct mbuf *event)
 468 {
 469         int                      error = 0;
 470
 471         ng_hci_le_connection_complete_ep        *ep = NULL;
 472         ng_hci_unit_con_p        con = NULL;
 473         int link_type;
 474         uint8_t uclass[3] = {0,0,0};//dummy uclass
 475
 476         NG_HCI_M_PULLUP(event, sizeof(*ep));
 477         if (event == NULL)
 478                 return (ENOBUFS);
 479
 480         ep = mtod(event, ng_hci_le_connection_complete_ep *);
 481         link_type = (ep->address_type)? NG_HCI_LINK_LE_RANDOM :
 482           NG_HCI_LINK_LE_PUBLIC;
 483         /*
 484          * Find the first connection descriptor that matches the following:
 485          *
 486          * 1) con->link_type == link_type
 487          * 2) con->state == NG_HCI_CON_W4_CONN_COMPLETE
 488          * 3) con->bdaddr == ep->address
 489          */
 490         LIST_FOREACH(con, &unit->con_list, next)
 491                 if (con->link_type == link_type &&
 492                     con->state == NG_HCI_CON_W4_CONN_COMPLETE &&
 493                     bcmp(&con->bdaddr, &ep->address, sizeof(bdaddr_t)) == 0)
 494                         break;
 495
 496         /*
 497          * Two possible cases:
 498          *
 499          * 1) We have found connection descriptor. That means upper layer has
 500          *    requested this connection via LP_CON_REQ message. In this case
 501          *    connection must have timeout set. If ng_hci_con_untimeout() fails
 502          *    then timeout message already went into node's queue. In this case
 503          *    ignore Connection_Complete event and let timeout deal with it.
 504          *
 505          * 2) We do not have connection descriptor. That means upper layer
 506          *    nas not requested this connection , (less likely) we gave up
 507          *    on this connection (timeout) or as node act as slave role.
 508          *    The most likely scenario is that
 509          *    we have received LE_Create_Connection command
 510          *    from the RAW hook
 511          */
 512
 513         if (con == NULL) {
 514                 if (ep->status != 0)
 515                         goto out;
 516
 517                 con = ng_hci_new_con(unit, link_type);
 518                 if (con == NULL) {
 519                         error = ENOMEM;
 520                         goto out;
 521                 }
 522
 523                 con->state = NG_HCI_CON_W4_LP_CON_RSP;
 524                 ng_hci_con_timeout(con);
 525
 526                 bcopy(&ep->address, &con->bdaddr, sizeof(con->bdaddr));
 527                 error = ng_hci_lp_con_ind(con, uclass);
 528                 if (error != 0) {
 529                         ng_hci_con_untimeout(con);
 530                         ng_hci_free_con(con);
 531                         goto out;
 532                 }
 533
 534         } else if ((error = ng_hci_con_untimeout(con)) != 0)
 535                         goto out;
 536
 537         /*
 538          * Update connection descriptor and send notification
 539          * to the upper layers.
 540          */
 541
 542         con->con_handle = NG_HCI_CON_HANDLE(le16toh(ep->handle));
 543         con->encryption_mode = NG_HCI_ENCRYPTION_MODE_NONE;
 544
 545         ng_hci_lp_con_cfm(con, ep->status);
 546
 547         /* Adjust connection state */
 548         if (ep->status != 0)
 549                 ng_hci_free_con(con);
 550         else {
 551                 con->state = NG_HCI_CON_OPEN;
 552
 553                 /*
 554                  * Change link policy for the ACL connections. Enable all
 555                  * supported link modes. Enable Role switch as well if
 556                  * device supports it.
 557                  */
 558         }
 559
 560 out:
 561         NG_FREE_M(event);
 562
 563         return (error);
 564
 565 }
 566
 567 static int le_connection_update(ng_hci_unit_p unit, struct mbuf *event)
 568 {
 569         int error = 0;
 570         /*TBD*/
 571
 572         NG_FREE_M(event);
 573         return error;
 574
 575 }
 576 static int
 577 le_event(ng_hci_unit_p unit, struct mbuf *event)
 578 {
 579         int error = 0;
 580         ng_hci_le_ep *lep;
 581
 582         NG_HCI_M_PULLUP(event, sizeof(*lep));
 583         if(event ==NULL){
 584                 return ENOBUFS;
 585         }
 586         lep = mtod(event, ng_hci_le_ep *);
 587         m_adj(event, sizeof(*lep));
 588         switch(lep->subevent_code){
 589         case NG_HCI_LEEV_CON_COMPL:
 590                 le_connection_complete(unit, event);
 591                 break;
 592         case NG_HCI_LEEV_ADVREP:
 593                 le_advertizing_report(unit, event);
 594                 break;
 595         case NG_HCI_LEEV_CON_UPDATE_COMPL:
 596                 le_connection_update(unit, event);
 597                 break;
 598         case NG_HCI_LEEV_READ_REMOTE_FEATURES_COMPL:
 599                 //TBD
 600           /*FALLTHROUGH*/
 601         case NG_HCI_LEEV_LONG_TERM_KEY_REQUEST:
 602                 //TBD
 603           /*FALLTHROUGH*/
 604         default:
 605                 NG_FREE_M(event);
 606         }
 607         return error;
 608 }
 609
 610 /* Inquiry result event */
 611 static int
 612 inquiry_result(ng_hci_unit_p unit, struct mbuf *event)
 613 {
 614         ng_hci_inquiry_result_ep        *ep = NULL;
 615         ng_hci_neighbor_p                n = NULL;
 616         bdaddr_t                         bdaddr;
 617         int                              error = 0;
 618
 619         NG_HCI_M_PULLUP(event, sizeof(*ep));
 620         if (event == NULL)
 621                 return (ENOBUFS);
 622
 623         ep = mtod(event, ng_hci_inquiry_result_ep *);
 624         m_adj(event, sizeof(*ep));
 625
 626         for (; ep->num_responses > 0; ep->num_responses --) {
 627                 /* Get remote unit address */
 628                 m_copydata(event, 0, sizeof(bdaddr), (caddr_t) &bdaddr);
 629                 m_adj(event, sizeof(bdaddr));
 630
 631                 /* Lookup entry in the cache */
 632                 n = ng_hci_get_neighbor(unit, &bdaddr, NG_HCI_LINK_ACL);
 633                 if (n == NULL) {
 634                         /* Create new entry */
 635                         n = ng_hci_new_neighbor(unit);
 636                         if (n == NULL) {
 637                                 error = ENOMEM;
 638                                 break;
 639                         }
 640                 } else
 641                         getmicrotime(&n->updated);
 642
 643                 bcopy(&bdaddr, &n->bdaddr, sizeof(n->bdaddr));
 644                 n->addrtype = NG_HCI_LINK_ACL;
 645
 646                 /* XXX call m_pullup here? */
 647
 648                 n->page_scan_rep_mode = *mtod(event, u_int8_t *);
 649                 m_adj(event, sizeof(u_int8_t));
 650
 651                 /* page_scan_period_mode */
 652                 m_adj(event, sizeof(u_int8_t));
 653
 654                 n->page_scan_mode = *mtod(event, u_int8_t *);
 655                 m_adj(event, sizeof(u_int8_t));
 656
 657                 /* class */
 658                 m_adj(event, NG_HCI_CLASS_SIZE);
 659
 660                 /* clock offset */
 661                 m_copydata(event, 0, sizeof(n->clock_offset),
 662                         (caddr_t) &n->clock_offset);
 663                 n->clock_offset = le16toh(n->clock_offset);
 664         }
 665
 666         NG_FREE_M(event);
 667
 668         return (error);
 669 } /* inquiry_result */
 670
 671 /* Connection complete event */
 672 static int
 673 con_compl(ng_hci_unit_p unit, struct mbuf *event)
 674 {
 675         ng_hci_con_compl_ep     *ep = NULL;
 676         ng_hci_unit_con_p        con = NULL;
 677         int                      error = 0;
 678
 679         NG_HCI_M_PULLUP(event, sizeof(*ep));
 680         if (event == NULL)
 681                 return (ENOBUFS);
 682
 683         ep = mtod(event, ng_hci_con_compl_ep *);
 684
 685         /*
 686          * Find the first connection descriptor that matches the following:
 687          *
 688          * 1) con->link_type == ep->link_type
 689          * 2) con->state == NG_HCI_CON_W4_CONN_COMPLETE
 690          * 3) con->bdaddr == ep->bdaddr
 691          */
 692
 693         LIST_FOREACH(con, &unit->con_list, next)
 694                 if (con->link_type == ep->link_type &&
 695                     con->state == NG_HCI_CON_W4_CONN_COMPLETE &&
 696                     bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0)
 697                         break;
 698
 699         /*
 700          * Two possible cases:
 701          *
 702          * 1) We have found connection descriptor. That means upper layer has
 703          *    requested this connection via LP_CON_REQ message. In this case
 704          *    connection must have timeout set. If ng_hci_con_untimeout() fails
 705          *    then timeout message already went into node's queue. In this case
 706          *    ignore Connection_Complete event and let timeout deal with it.
 707          *
 708          * 2) We do not have connection descriptor. That means upper layer
 709          *    nas not requested this connection or (less likely) we gave up
 710          *    on this connection (timeout). The most likely scenario is that
 711          *    we have received Create_Connection/Add_SCO_Connection command
 712          *    from the RAW hook
 713          */
 714
 715         if (con == NULL) {
 716                 if (ep->status != 0)
 717                         goto out;
 718
 719                 con = ng_hci_new_con(unit, ep->link_type);
 720                 if (con == NULL) {
 721                         error = ENOMEM;
 722                         goto out;
 723                 }
 724
 725                 bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr));
 726         } else if ((error = ng_hci_con_untimeout(con)) != 0)
 727                         goto out;
 728
 729         /*
 730          * Update connection descriptor and send notification
 731          * to the upper layers.
 732          */
 733
 734         con->con_handle = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
 735         con->encryption_mode = ep->encryption_mode;
 736
 737         ng_hci_lp_con_cfm(con, ep->status);
 738
 739         /* Adjust connection state */
 740         if (ep->status != 0)
 741                 ng_hci_free_con(con);
 742         else {
 743                 con->state = NG_HCI_CON_OPEN;
 744
 745                 /*
 746                  * Change link policy for the ACL connections. Enable all
 747                  * supported link modes. Enable Role switch as well if
 748                  * device supports it.
 749                  */
 750
 751                 if (ep->link_type == NG_HCI_LINK_ACL) {
 752                         struct __link_policy {
 753                                 ng_hci_cmd_pkt_t                         hdr;
 754                                 ng_hci_write_link_policy_settings_cp     cp;
 755                         } __attribute__ ((packed))                      *lp;
 756                         struct mbuf                                     *m;
 757
 758                         MGETHDR(m, M_NOWAIT, MT_DATA);
 759                         if (m != NULL) {
 760                                 m->m_pkthdr.len = m->m_len = sizeof(*lp);
 761                                 lp = mtod(m, struct __link_policy *);
 762
 763                                 lp->hdr.type = NG_HCI_CMD_PKT;
 764                                 lp->hdr.opcode = htole16(NG_HCI_OPCODE(
 765                                         NG_HCI_OGF_LINK_POLICY,
 766                                         NG_HCI_OCF_WRITE_LINK_POLICY_SETTINGS));
 767                                 lp->hdr.length = sizeof(lp->cp);
 768
 769                                 lp->cp.con_handle = ep->con_handle;
 770
 771                                 lp->cp.settings = 0;
 772                                 if ((unit->features[0] & NG_HCI_LMP_SWITCH) &&
 773                                     unit->role_switch)
 774                                         lp->cp.settings |= 0x1;
 775                                 if (unit->features[0] & NG_HCI_LMP_HOLD_MODE)
 776                                         lp->cp.settings |= 0x2;
 777                                 if (unit->features[0] & NG_HCI_LMP_SNIFF_MODE)
 778                                         lp->cp.settings |= 0x4;
 779                                 if (unit->features[1] & NG_HCI_LMP_PARK_MODE)
 780                                         lp->cp.settings |= 0x8;
 781
 782                                 lp->cp.settings &= unit->link_policy_mask;
 783                                 lp->cp.settings = htole16(lp->cp.settings);
 784
 785                                 NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m);
 786                                 if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING))
 787                                         ng_hci_send_command(unit);
 788                         }
 789                 }
 790         }
 791 out:
 792         NG_FREE_M(event);
 793
 794         return (error);
 795 } /* con_compl */
 796
 797 /* Connection request event */
 798 static int
 799 con_req(ng_hci_unit_p unit, struct mbuf *event)
 800 {
 801         ng_hci_con_req_ep       *ep = NULL;
 802         ng_hci_unit_con_p        con = NULL;
 803         int                      error = 0;
 804
 805         NG_HCI_M_PULLUP(event, sizeof(*ep));
 806         if (event == NULL)
 807                 return (ENOBUFS);
 808
 809         ep = mtod(event, ng_hci_con_req_ep *);
 810
 811         /*
 812          * Find the first connection descriptor that matches the following:
 813          *
 814          * 1) con->link_type == ep->link_type
 815          *
 816          * 2) con->state == NG_HCI_CON_W4_LP_CON_RSP ||
 817          *    con->state == NG_HCI_CON_W4_CONN_COMPL
 818          *
 819          * 3) con->bdaddr == ep->bdaddr
 820          *
 821          * Possible cases:
 822          *
 823          * 1) We do not have connection descriptor. This is simple. Create
 824          *    new fresh connection descriptor and send notification to the
 825          *    appropriate upstream hook (based on link_type).
 826          *
 827          * 2) We found connection handle. This is more complicated.
 828          *
 829          * 2.1) ACL links
 830          *
 831          *      Since only one ACL link can exist between each pair of
 832          *      units then we have a race. Our upper layer has requested
 833          *      an ACL connection to the remote unit, but we did not send
 834          *      command yet. At the same time the remote unit has requested
 835          *      an ACL connection from us. In this case we will ignore
 836          *      Connection_Request event. This probably will cause connect
 837          *      failure on both units.
 838          *
 839          * 2.2) SCO links
 840          *
 841          *      The spec on page 45 says :
 842          *
 843          *      "The master can support up to three SCO links to the same
 844          *       slave or to different slaves. A slave can support up to
 845          *       three SCO links from the same master, or two SCO links if
 846          *       the links originate from different masters."
 847          *
 848          *      The only problem is how to handle multiple SCO links between
 849          *      matster and slave. For now we will assume that multiple SCO
 850          *      links MUST be opened one after another.
 851          */
 852
 853         LIST_FOREACH(con, &unit->con_list, next)
 854                 if (con->link_type == ep->link_type &&
 855                     (con->state == NG_HCI_CON_W4_LP_CON_RSP ||
 856                      con->state == NG_HCI_CON_W4_CONN_COMPLETE) &&
 857                     bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0)
 858                         break;
 859
 860         if (con == NULL) {
 861                 con = ng_hci_new_con(unit, ep->link_type);
 862                 if (con != NULL) {
 863                         bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr));
 864
 865                         con->state = NG_HCI_CON_W4_LP_CON_RSP;
 866                         ng_hci_con_timeout(con);
 867
 868                         error = ng_hci_lp_con_ind(con, ep->uclass);
 869                         if (error != 0) {
 870                                 ng_hci_con_untimeout(con);
 871                                 ng_hci_free_con(con);
 872                         }
 873                 } else
 874                         error = ENOMEM;
 875         }
 876
 877         NG_FREE_M(event);
 878
 879         return (error);
 880 } /* con_req */
 881
 882 /* Disconnect complete event */
 883 static int
 884 discon_compl(ng_hci_unit_p unit, struct mbuf *event)
 885 {
 886         ng_hci_discon_compl_ep  *ep = NULL;
 887         ng_hci_unit_con_p        con = NULL;
 888         int                      error = 0;
 889         u_int16_t                h;
 890
 891         NG_HCI_M_PULLUP(event, sizeof(*ep));
 892         if (event == NULL)
 893                 return (ENOBUFS);
 894
 895         ep = mtod(event, ng_hci_discon_compl_ep *);
 896
 897         /*
 898          * XXX
 899          * Do we have to send notification if ep->status != 0?
 900          * For now we will send notification for both ACL and SCO connections
 901          * ONLY if ep->status == 0.
 902          */
 903
 904         if (ep->status == 0) {
 905                 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
 906                 con = ng_hci_con_by_handle(unit, h);
 907                 if (con != NULL) {
 908                         error = ng_hci_lp_discon_ind(con, ep->reason);
 909
 910                         /* Remove all timeouts (if any) */
 911                         if (con->flags & NG_HCI_CON_TIMEOUT_PENDING)
 912                                 ng_hci_con_untimeout(con);
 913
 914                         ng_hci_free_con(con);
 915                 } else {
 916                         NG_HCI_ALERT(
 917 "%s: %s - invalid connection handle=%d\n",
 918                                 __func__, NG_NODE_NAME(unit->node), h);
 919                         error = ENOENT;
 920                 }
 921         }
 922
 923         NG_FREE_M(event);
 924
 925         return (error);
 926 } /* discon_compl */
 927
 928 /* Encryption change event */
 929 static int
 930 encryption_change(ng_hci_unit_p unit, struct mbuf *event)
 931 {
 932         ng_hci_encryption_change_ep     *ep = NULL;
 933         ng_hci_unit_con_p                con = NULL;
 934         int                              error = 0;
 935         u_int16_t       h;
 936
 937         NG_HCI_M_PULLUP(event, sizeof(*ep));
 938         if (event == NULL)
 939                 return (ENOBUFS);
 940
 941         ep = mtod(event, ng_hci_encryption_change_ep *);
 942         h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
 943         con = ng_hci_con_by_handle(unit, h);
 944
 945         if (ep->status == 0) {
 946                 if (con == NULL) {
 947                         NG_HCI_ALERT(
 948 "%s: %s - invalid connection handle=%d\n",
 949                                 __func__, NG_NODE_NAME(unit->node), h);
 950                         error = ENOENT;
 951                 } else if (con->link_type == NG_HCI_LINK_SCO) {
 952                         NG_HCI_ALERT(
 953 "%s: %s - invalid link type=%d\n",
 954                                 __func__, NG_NODE_NAME(unit->node),
 955                                 con->link_type);
 956                         error = EINVAL;
 957                 } else if (ep->encryption_enable)
 958                         /* XXX is that true? */
 959                         con->encryption_mode = NG_HCI_ENCRYPTION_MODE_P2P;
 960                 else
 961                         con->encryption_mode = NG_HCI_ENCRYPTION_MODE_NONE;
 962         } else
 963                 NG_HCI_ERR(
 964 "%s: %s - failed to change encryption mode, status=%d\n",
 965                         __func__, NG_NODE_NAME(unit->node), ep->status);
 966
 967         /*Anyway, propagete encryption status to upper layer*/
 968         ng_hci_lp_enc_change(con, con->encryption_mode);
 969
 970         NG_FREE_M(event);
 971
 972         return (error);
 973 } /* encryption_change */
 974
 975 /* Read remote feature complete event */
 976 static int
 977 read_remote_features_compl(ng_hci_unit_p unit, struct mbuf *event)
 978 {
 979         ng_hci_read_remote_features_compl_ep    *ep = NULL;
 980         ng_hci_unit_con_p                        con = NULL;
 981         ng_hci_neighbor_p                        n = NULL;
 982         u_int16_t                                h;
 983         int                                      error = 0;
 984
 985         NG_HCI_M_PULLUP(event, sizeof(*ep));
 986         if (event == NULL)
 987                 return (ENOBUFS);
 988
 989         ep = mtod(event, ng_hci_read_remote_features_compl_ep *);
 990
 991         if (ep->status == 0) {
 992                 /* Check if we have this connection handle */
 993                 h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
 994                 con = ng_hci_con_by_handle(unit, h);
 995                 if (con == NULL) {
 996                         NG_HCI_ALERT(
 997 "%s: %s - invalid connection handle=%d\n",
 998                                 __func__, NG_NODE_NAME(unit->node), h);
 999                         error = ENOENT;
1000                         goto out;
1001                 }
1002
1003                 /* Update cache entry */
1004                 n = ng_hci_get_neighbor(unit, &con->bdaddr, NG_HCI_LINK_ACL);
1005                 if (n == NULL) {
1006                         n = ng_hci_new_neighbor(unit);
1007                         if (n == NULL) {
1008                                 error = ENOMEM;
1009                                 goto out;
1010                         }
1011
1012                         bcopy(&con->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1013                         n->addrtype = NG_HCI_LINK_ACL;
1014                 } else
1015                         getmicrotime(&n->updated);
1016
1017                 bcopy(ep->features, n->features, sizeof(n->features));
1018         } else
1019                 NG_HCI_ERR(
1020 "%s: %s - failed to read remote unit features, status=%d\n",
1021                         __func__, NG_NODE_NAME(unit->node), ep->status);
1022 out:
1023         NG_FREE_M(event);
1024
1025         return (error);
1026 } /* read_remote_features_compl */
1027
1028 /* QoS setup complete event */
1029 static int
1030 qos_setup_compl(ng_hci_unit_p unit, struct mbuf *event)
1031 {
1032         ng_hci_qos_setup_compl_ep       *ep = NULL;
1033         ng_hci_unit_con_p                con = NULL;
1034         u_int16_t                        h;
1035         int                              error = 0;
1036
1037         NG_HCI_M_PULLUP(event, sizeof(*ep));
1038         if (event == NULL)
1039                 return (ENOBUFS);
1040
1041         ep = mtod(event, ng_hci_qos_setup_compl_ep *);
1042
1043         /* Check if we have this connection handle */
1044         h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1045         con = ng_hci_con_by_handle(unit, h);
1046         if (con == NULL) {
1047                 NG_HCI_ALERT(
1048 "%s: %s - invalid connection handle=%d\n",
1049                         __func__, NG_NODE_NAME(unit->node), h);
1050                 error = ENOENT;
1051         } else if (con->link_type != NG_HCI_LINK_ACL) {
1052                 NG_HCI_ALERT(
1053 "%s: %s - invalid link type=%d, handle=%d\n",
1054                         __func__, NG_NODE_NAME(unit->node), con->link_type, h);
1055                 error = EINVAL;
1056         } else if (con->state != NG_HCI_CON_OPEN) {
1057                 NG_HCI_ALERT(
1058 "%s: %s - invalid connection state=%d, handle=%d\n",
1059                         __func__, NG_NODE_NAME(unit->node),
1060                         con->state, h);
1061                 error = EINVAL;
1062         } else /* Notify upper layer */
1063                 error = ng_hci_lp_qos_cfm(con, ep->status);
1064
1065         NG_FREE_M(event);
1066
1067         return (error);
1068 } /* qos_setup_compl */
1069
1070 /* Hardware error event */
1071 static int
1072 hardware_error(ng_hci_unit_p unit, struct mbuf *event)
1073 {
1074         NG_HCI_ALERT(
1075 "%s: %s - hardware error %#x\n",
1076                 __func__, NG_NODE_NAME(unit->node), *mtod(event, u_int8_t *));
1077
1078         NG_FREE_M(event);
1079
1080         return (0);
1081 } /* hardware_error */
1082
1083 /* Role change event */
1084 static int
1085 role_change(ng_hci_unit_p unit, struct mbuf *event)
1086 {
1087         ng_hci_role_change_ep   *ep = NULL;
1088         ng_hci_unit_con_p        con = NULL;
1089
1090         NG_HCI_M_PULLUP(event, sizeof(*ep));
1091         if (event == NULL)
1092                 return (ENOBUFS);
1093
1094         ep = mtod(event, ng_hci_role_change_ep *);
1095
1096         if (ep->status == 0) {
1097                 /* XXX shoud we also change "role" for SCO connections? */
1098                 con = ng_hci_con_by_bdaddr(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1099                 if (con != NULL)
1100                         con->role = ep->role;
1101                 else
1102                         NG_HCI_ALERT(
1103 "%s: %s - ACL connection does not exist, bdaddr=%x:%x:%x:%x:%x:%x\n",
1104                                 __func__, NG_NODE_NAME(unit->node),
1105                                 ep->bdaddr.b[5], ep->bdaddr.b[4],
1106                                 ep->bdaddr.b[3], ep->bdaddr.b[2],
1107                                 ep->bdaddr.b[1], ep->bdaddr.b[0]);
1108         } else
1109                 NG_HCI_ERR(
1110 "%s: %s - failed to change role, status=%d, bdaddr=%x:%x:%x:%x:%x:%x\n",
1111                         __func__, NG_NODE_NAME(unit->node), ep->status,
1112                         ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3],
1113                         ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]);
1114
1115         NG_FREE_M(event);
1116
1117         return (0);
1118 } /* role_change */
1119
1120 /* Number of completed packets event */
1121 static int
1122 num_compl_pkts(ng_hci_unit_p unit, struct mbuf *event)
1123 {
1124         ng_hci_num_compl_pkts_ep        *ep = NULL;
1125         ng_hci_unit_con_p                con = NULL;
1126         u_int16_t                        h, p;
1127
1128         NG_HCI_M_PULLUP(event, sizeof(*ep));
1129         if (event == NULL)
1130                 return (ENOBUFS);
1131
1132         ep = mtod(event, ng_hci_num_compl_pkts_ep *);
1133         m_adj(event, sizeof(*ep));
1134
1135         for (; ep->num_con_handles > 0; ep->num_con_handles --) {
1136                 /* Get connection handle */
1137                 m_copydata(event, 0, sizeof(h), (caddr_t) &h);
1138                 m_adj(event, sizeof(h));
1139                 h = NG_HCI_CON_HANDLE(le16toh(h));
1140
1141                 /* Get number of completed packets */
1142                 m_copydata(event, 0, sizeof(p), (caddr_t) &p);
1143                 m_adj(event, sizeof(p));
1144                 p = le16toh(p);
1145
1146                 /* Check if we have this connection handle */
1147                 con = ng_hci_con_by_handle(unit, h);
1148                 if (con != NULL) {
1149                         con->pending -= p;
1150                         if (con->pending < 0) {
1151                                 NG_HCI_WARN(
1152 "%s: %s - pending packet counter is out of sync! " \
1153 "handle=%d, pending=%d, ncp=%d\n",      __func__, NG_NODE_NAME(unit->node),
1154                                         con->con_handle, con->pending, p);
1155
1156                                 con->pending = 0;
1157                         }
1158
1159                         /* Update buffer descriptor */
1160                         if (con->link_type != NG_HCI_LINK_SCO)
1161                                 NG_HCI_BUFF_ACL_FREE(unit->buffer, p);
1162                         else
1163                                 NG_HCI_BUFF_SCO_FREE(unit->buffer, p);
1164                 } else
1165                         NG_HCI_ALERT(
1166 "%s: %s - invalid connection handle=%d\n",
1167                                 __func__, NG_NODE_NAME(unit->node), h);
1168         }
1169
1170         NG_FREE_M(event);
1171
1172         /* Send more data */
1173         ng_hci_send_data(unit);
1174
1175         return (0);
1176 } /* num_compl_pkts */
1177
1178 /* Mode change event */
1179 static int
1180 mode_change(ng_hci_unit_p unit, struct mbuf *event)
1181 {
1182         ng_hci_mode_change_ep   *ep = NULL;
1183         ng_hci_unit_con_p        con = NULL;
1184         int                      error = 0;
1185
1186         NG_HCI_M_PULLUP(event, sizeof(*ep));
1187         if (event == NULL)
1188                 return (ENOBUFS);
1189
1190         ep = mtod(event, ng_hci_mode_change_ep *);
1191
1192         if (ep->status == 0) {
1193                 u_int16_t       h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1194
1195                 con = ng_hci_con_by_handle(unit, h);
1196                 if (con == NULL) {
1197                         NG_HCI_ALERT(
1198 "%s: %s - invalid connection handle=%d\n",
1199                                 __func__, NG_NODE_NAME(unit->node), h);
1200                         error = ENOENT;
1201                 } else if (con->link_type != NG_HCI_LINK_ACL) {
1202                         NG_HCI_ALERT(
1203 "%s: %s - invalid link type=%d\n",
1204                                 __func__, NG_NODE_NAME(unit->node),
1205                                 con->link_type);
1206                         error = EINVAL;
1207                 } else
1208                         con->mode = ep->unit_mode;
1209         } else
1210                 NG_HCI_ERR(
1211 "%s: %s - failed to change mode, status=%d\n",
1212                         __func__, NG_NODE_NAME(unit->node), ep->status);
1213
1214         NG_FREE_M(event);
1215
1216         return (error);
1217 } /* mode_change */
1218
1219 /* Data buffer overflow event */
1220 static int
1221 data_buffer_overflow(ng_hci_unit_p unit, struct mbuf *event)
1222 {
1223         NG_HCI_ALERT(
1224 "%s: %s - %s data buffer overflow\n",
1225                 __func__, NG_NODE_NAME(unit->node),
1226                 (*mtod(event, u_int8_t *) == NG_HCI_LINK_ACL)? "ACL" : "SCO");
1227
1228         NG_FREE_M(event);
1229
1230         return (0);
1231 } /* data_buffer_overflow */
1232
1233 /* Read clock offset complete event */
1234 static int
1235 read_clock_offset_compl(ng_hci_unit_p unit, struct mbuf *event)
1236 {
1237         ng_hci_read_clock_offset_compl_ep       *ep = NULL;
1238         ng_hci_unit_con_p                        con = NULL;
1239         ng_hci_neighbor_p                        n = NULL;
1240         int                                      error = 0;
1241
1242         NG_HCI_M_PULLUP(event, sizeof(*ep));
1243         if (event == NULL)
1244                 return (ENOBUFS);
1245
1246         ep = mtod(event, ng_hci_read_clock_offset_compl_ep *);
1247
1248         if (ep->status == 0) {
1249                 u_int16_t       h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1250
1251                 con = ng_hci_con_by_handle(unit, h);
1252                 if (con == NULL) {
1253                         NG_HCI_ALERT(
1254 "%s: %s - invalid connection handle=%d\n",
1255                                 __func__, NG_NODE_NAME(unit->node), h);
1256                         error = ENOENT;
1257                         goto out;
1258                 }
1259
1260                 /* Update cache entry */
1261                 n = ng_hci_get_neighbor(unit, &con->bdaddr, NG_HCI_LINK_ACL);
1262                 if (n == NULL) {
1263                         n = ng_hci_new_neighbor(unit);
1264                         if (n == NULL) {
1265                                 error = ENOMEM;
1266                                 goto out;
1267                         }
1268
1269                         bcopy(&con->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1270                         n->addrtype = NG_HCI_LINK_ACL;
1271                 } else
1272                         getmicrotime(&n->updated);
1273
1274                 n->clock_offset = le16toh(ep->clock_offset);
1275         } else
1276                 NG_HCI_ERR(
1277 "%s: %s - failed to Read Remote Clock Offset, status=%d\n",
1278                         __func__, NG_NODE_NAME(unit->node), ep->status);
1279 out:
1280         NG_FREE_M(event);
1281
1282         return (error);
1283 } /* read_clock_offset_compl */
1284
1285 /* QoS violation event */
1286 static int
1287 qos_violation(ng_hci_unit_p unit, struct mbuf *event)
1288 {
1289         ng_hci_qos_violation_ep *ep = NULL;
1290         ng_hci_unit_con_p        con = NULL;
1291         u_int16_t                h;
1292         int                      error = 0;
1293
1294         NG_HCI_M_PULLUP(event, sizeof(*ep));
1295         if (event == NULL)
1296                 return (ENOBUFS);
1297
1298         ep = mtod(event, ng_hci_qos_violation_ep *);
1299
1300         /* Check if we have this connection handle */
1301         h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle));
1302         con = ng_hci_con_by_handle(unit, h);
1303         if (con == NULL) {
1304                 NG_HCI_ALERT(
1305 "%s: %s - invalid connection handle=%d\n",
1306                         __func__, NG_NODE_NAME(unit->node), h);
1307                 error = ENOENT;
1308         } else if (con->link_type != NG_HCI_LINK_ACL) {
1309                 NG_HCI_ALERT(
1310 "%s: %s - invalid link type=%d\n",
1311                         __func__, NG_NODE_NAME(unit->node), con->link_type);
1312                 error = EINVAL;
1313         } else if (con->state != NG_HCI_CON_OPEN) {
1314                 NG_HCI_ALERT(
1315 "%s: %s - invalid connection state=%d, handle=%d\n",
1316                         __func__, NG_NODE_NAME(unit->node), con->state, h);
1317                 error = EINVAL;
1318         } else /* Notify upper layer */
1319                 error = ng_hci_lp_qos_ind(con);
1320
1321         NG_FREE_M(event);
1322
1323         return (error);
1324 } /* qos_violation */
1325
1326 /* Page scan mode change event */
1327 static int
1328 page_scan_mode_change(ng_hci_unit_p unit, struct mbuf *event)
1329 {
1330         ng_hci_page_scan_mode_change_ep *ep = NULL;
1331         ng_hci_neighbor_p                n = NULL;
1332         int                              error = 0;
1333
1334         NG_HCI_M_PULLUP(event, sizeof(*ep));
1335         if (event == NULL)
1336                 return (ENOBUFS);
1337
1338         ep = mtod(event, ng_hci_page_scan_mode_change_ep *);
1339
1340         /* Update cache entry */
1341         n = ng_hci_get_neighbor(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1342         if (n == NULL) {
1343                 n = ng_hci_new_neighbor(unit);
1344                 if (n == NULL) {
1345                         error = ENOMEM;
1346                         goto out;
1347                 }
1348
1349                 bcopy(&ep->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1350                 n->addrtype = NG_HCI_LINK_ACL;
1351         } else
1352                 getmicrotime(&n->updated);
1353
1354         n->page_scan_mode = ep->page_scan_mode;
1355 out:
1356         NG_FREE_M(event);
1357
1358         return (error);
1359 } /* page_scan_mode_change */
1360
1361 /* Page scan repetition mode change event */
1362 static int
1363 page_scan_rep_mode_change(ng_hci_unit_p unit, struct mbuf *event)
1364 {
1365         ng_hci_page_scan_rep_mode_change_ep     *ep = NULL;
1366         ng_hci_neighbor_p                        n = NULL;
1367         int                                      error = 0;
1368
1369         NG_HCI_M_PULLUP(event, sizeof(*ep));
1370         if (event == NULL)
1371                 return (ENOBUFS);
1372
1373         ep = mtod(event, ng_hci_page_scan_rep_mode_change_ep *);
1374
1375         /* Update cache entry */
1376         n = ng_hci_get_neighbor(unit, &ep->bdaddr, NG_HCI_LINK_ACL);
1377         if (n == NULL) {
1378                 n = ng_hci_new_neighbor(unit);
1379                 if (n == NULL) {
1380                         error = ENOMEM;
1381                         goto out;
1382                 }
1383
1384                 bcopy(&ep->bdaddr, &n->bdaddr, sizeof(n->bdaddr));
1385                 n->addrtype = NG_HCI_LINK_ACL;
1386         } else
1387                 getmicrotime(&n->updated);
1388
1389         n->page_scan_rep_mode = ep->page_scan_rep_mode;
1390 out:
1391         NG_FREE_M(event);
1392
1393         return (error);
1394 } /* page_scan_rep_mode_change */