sys/netgraph7/bluetooth/hci/ng_hci_main.c

   1 /*
   2  * ng_hci_main.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_main.c,v 1.2 2003/03/18 00:09:36 max Exp $
  31  * $FreeBSD: src/sys/netgraph/bluetooth/hci/ng_hci_main.c,v 1.6 2005/01/07 01:45:43 imp Exp $
  32  * $DragonFly: src/sys/netgraph7/bluetooth/hci/ng_hci_main.c,v 1.2 2008/06/26 23:05:40 dillon Exp $
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/endian.h>
  39 #include <sys/malloc.h>
  40 #include <sys/mbuf.h>
  41 #include <sys/queue.h>
  42 #include "ng_message.h"
  43 #include "netgraph.h"
  44 #include "ng_parse.h"
  45 #include "bluetooth/include/ng_bluetooth.h"
  46 #include "bluetooth/include/ng_hci.h"
  47 #include "bluetooth/hci/ng_hci_var.h"
  48 #include "bluetooth/hci/ng_hci_prse.h"
  49 #include "bluetooth/hci/ng_hci_cmds.h"
  50 #include "bluetooth/hci/ng_hci_evnt.h"
  51 #include "bluetooth/hci/ng_hci_ulpi.h"
  52 #include "bluetooth/hci/ng_hci_misc.h"
  53
  54 /******************************************************************************
  55  ******************************************************************************
  56  **     This node implements Bluetooth Host Controller Interface (HCI)
  57  ******************************************************************************
  58  ******************************************************************************/
  59
  60 /* MALLOC define */
  61 #ifdef NG_SEPARATE_MALLOC
  62 MALLOC_DEFINE(M_NETGRAPH_HCI, "netgraph_hci", "Netgraph Bluetooth HCI node");
  63 #else
  64 #define M_NETGRAPH_HCI M_NETGRAPH
  65 #endif /* NG_SEPARATE_MALLOC */
  66
  67 /* Netgraph node methods */
  68 static  ng_constructor_t        ng_hci_constructor;
  69 static  ng_shutdown_t           ng_hci_shutdown;
  70 static  ng_newhook_t            ng_hci_newhook;
  71 static  ng_connect_t            ng_hci_connect;
  72 static  ng_disconnect_t         ng_hci_disconnect;
  73 static  ng_rcvmsg_t             ng_hci_default_rcvmsg;
  74 static  ng_rcvmsg_t             ng_hci_upper_rcvmsg;
  75 static  ng_rcvdata_t            ng_hci_drv_rcvdata;
  76 static  ng_rcvdata_t            ng_hci_acl_rcvdata;
  77 static  ng_rcvdata_t            ng_hci_sco_rcvdata;
  78 static  ng_rcvdata_t            ng_hci_raw_rcvdata;
  79
  80 /* Netgraph node type descriptor */
  81 static  struct ng_type          typestruct = {
  82         .version =      NG_ABI_VERSION,
  83         .name =         NG_HCI_NODE_TYPE,
  84         .constructor =  ng_hci_constructor,
  85         .rcvmsg =       ng_hci_default_rcvmsg,
  86         .shutdown =     ng_hci_shutdown,
  87         .newhook =      ng_hci_newhook,
  88         .connect =      ng_hci_connect,
  89         .rcvdata =      ng_hci_drv_rcvdata,
  90         .disconnect =   ng_hci_disconnect,
  91         .cmdlist =      ng_hci_cmdlist,
  92 };
  93 NETGRAPH_INIT(hci, &typestruct);
  94 MODULE_VERSION(ng_hci, NG_BLUETOOTH_VERSION);
  95 MODULE_DEPEND(ng_hci, ng_bluetooth, NG_BLUETOOTH_VERSION,
  96         NG_BLUETOOTH_VERSION, NG_BLUETOOTH_VERSION);
  97
  98 /*****************************************************************************
  99  *****************************************************************************
 100  **                   Netgraph methods implementation
 101  *****************************************************************************
 102  *****************************************************************************/
 103
 104 /*
 105  * Create new instance of HCI node (new unit)
 106  */
 107
 108 static int
 109 ng_hci_constructor(node_p node)
 110 {
 111         ng_hci_unit_p   unit = NULL;
 112
 113         MALLOC(unit, ng_hci_unit_p, sizeof(*unit), M_NETGRAPH_HCI,
 114                 M_WAITOK | M_NULLOK | M_ZERO);
 115         if (unit == NULL)
 116                 return (ENOMEM);
 117
 118         unit->node = node;
 119         unit->debug = NG_HCI_WARN_LEVEL;
 120
 121         unit->link_policy_mask = 0xffff; /* Enable all supported modes */
 122         unit->packet_mask = 0xffff; /* Enable all packet types */
 123         unit->role_switch = 1; /* Enable role switch (if device supports it) */
 124
 125         /*
 126          * Set default buffer info
 127          *
 128          * One HCI command
 129          * One ACL packet with max. size of 17 bytes (1 DM1 packet)
 130          * One SCO packet with max. size of 10 bytes (1 HV1 packet)
 131          */
 132
 133         NG_HCI_BUFF_CMD_SET(unit->buffer, 1);
 134         NG_HCI_BUFF_ACL_SET(unit->buffer, 1, 17, 1);
 135         NG_HCI_BUFF_SCO_SET(unit->buffer, 1, 10, 1);
 136
 137         /* Init command queue & command timeout handler */
 138         ng_callout_init(&unit->cmd_timo);
 139         NG_BT_MBUFQ_INIT(&unit->cmdq, NG_HCI_CMD_QUEUE_LEN);
 140
 141         /* Init lists */
 142         LIST_INIT(&unit->con_list);
 143         LIST_INIT(&unit->neighbors);
 144
 145         /*
 146          * This node has to be a WRITER because both data and messages
 147          * can change node state.
 148          */
 149
 150         NG_NODE_FORCE_WRITER(node);
 151         NG_NODE_SET_PRIVATE(node, unit);
 152
 153         return (0);
 154 } /* ng_hci_constructor */
 155
 156 /*
 157  * Destroy the node
 158  */
 159
 160 static int
 161 ng_hci_shutdown(node_p node)
 162 {
 163         ng_hci_unit_p   unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node);
 164
 165         NG_NODE_SET_PRIVATE(node, NULL);
 166         NG_NODE_UNREF(node);
 167
 168         unit->node = NULL;
 169         ng_hci_unit_clean(unit, 0x16 /* Connection terminated by local host */);
 170
 171         NG_BT_MBUFQ_DESTROY(&unit->cmdq);
 172
 173         bzero(unit, sizeof(*unit));
 174         FREE(unit, M_NETGRAPH_HCI);
 175
 176         return (0);
 177 } /* ng_hci_shutdown */
 178
 179 /*
 180  * Give our OK for a hook to be added. Unit driver is connected to the driver
 181  * (NG_HCI_HOOK_DRV) hook. Upper layer protocols are connected to appropriate
 182  * (NG_HCI_HOOK_ACL or NG_HCI_HOOK_SCO) hooks.
 183  */
 184
 185 static int
 186 ng_hci_newhook(node_p node, hook_p hook, char const *name)
 187 {
 188         ng_hci_unit_p    unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node);
 189         hook_p          *h = NULL;
 190
 191         if (strcmp(name, NG_HCI_HOOK_DRV) == 0)
 192                 h = &unit->drv;
 193         else if (strcmp(name, NG_HCI_HOOK_ACL) == 0)
 194                 h = &unit->acl;
 195         else if (strcmp(name, NG_HCI_HOOK_SCO) == 0)
 196                 h = &unit->sco;
 197         else if (strcmp(name, NG_HCI_HOOK_RAW) == 0)
 198                 h = &unit->raw;
 199         else
 200                 return (EINVAL);
 201
 202         if (*h != NULL)
 203                 return (EISCONN);
 204
 205         *h = hook;
 206
 207         return (0);
 208 } /* ng_hci_newhook */
 209
 210 /*
 211  * Give our final OK to connect hook
 212  */
 213
 214 static int
 215 ng_hci_connect(hook_p hook)
 216 {
 217         ng_hci_unit_p   unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 218
 219         if (hook != unit->drv) {
 220                 if (hook == unit->acl) {
 221                         NG_HOOK_SET_RCVMSG(hook, ng_hci_upper_rcvmsg);
 222                         NG_HOOK_SET_RCVDATA(hook, ng_hci_acl_rcvdata);
 223                 } else if (hook == unit->sco) {
 224                         NG_HOOK_SET_RCVMSG(hook, ng_hci_upper_rcvmsg);
 225                         NG_HOOK_SET_RCVDATA(hook, ng_hci_sco_rcvdata);
 226                 } else
 227                         NG_HOOK_SET_RCVDATA(hook, ng_hci_raw_rcvdata);
 228
 229                 /* Send delayed notification to the upper layers */
 230                 if (hook != unit->raw)
 231                         ng_send_fn(unit->node, hook, ng_hci_node_is_up, NULL,0);
 232         } else
 233                 unit->state |= NG_HCI_UNIT_CONNECTED;
 234
 235         return (0);
 236 } /* ng_hci_connect */
 237
 238 /*
 239  * Disconnect the hook
 240  */
 241
 242 static int
 243 ng_hci_disconnect(hook_p hook)
 244 {
 245         ng_hci_unit_p    unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 246
 247         if (hook == unit->acl)
 248                 unit->acl = NULL;
 249         else if (hook == unit->sco)
 250                 unit->sco = NULL;
 251         else if (hook == unit->raw)
 252                 unit->raw = NULL;
 253         else if (hook == unit->drv) {
 254                 unit->drv = NULL;
 255
 256                 /* Connection terminated by local host */
 257                 ng_hci_unit_clean(unit, 0x16);
 258                 unit->state &= ~(NG_HCI_UNIT_CONNECTED|NG_HCI_UNIT_INITED);
 259         } else
 260                 return (EINVAL);
 261
 262         /* Shutdown when all hooks are disconnected */
 263         if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0) &&
 264             (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
 265                 ng_rmnode_self(NG_HOOK_NODE(hook));
 266
 267         return (0);
 268 } /* ng_hci_disconnect */
 269
 270 /*
 271  * Default control message processing routine. Control message could be:
 272  *
 273  * 1) GENERIC Netgraph messages
 274  *
 275  * 2) Control message directed to the node itself.
 276  */
 277
 278 static int
 279 ng_hci_default_rcvmsg(node_p node, item_p item, hook_p lasthook)
 280 {
 281         ng_hci_unit_p    unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node);
 282         struct ng_mesg  *msg = NULL, *rsp = NULL;
 283         int              error = 0;
 284
 285         NGI_GET_MSG(item, msg);
 286
 287         switch (msg->header.typecookie) {
 288         case NGM_GENERIC_COOKIE:
 289                 switch (msg->header.cmd) {
 290                 case NGM_TEXT_STATUS: {
 291                         int     cmd_avail,
 292                                 acl_total, acl_avail, acl_size,
 293                                 sco_total, sco_avail, sco_size;
 294
 295                         NG_MKRESPONSE(rsp, msg, NG_TEXTRESPONSE, M_WAITOK | M_NULLOK);
 296                         if (rsp == NULL) {
 297                                 error = ENOMEM;
 298                                 break;
 299                         }
 300
 301                         NG_HCI_BUFF_CMD_GET(unit->buffer, cmd_avail);
 302
 303                         NG_HCI_BUFF_ACL_AVAIL(unit->buffer, acl_avail);
 304                         NG_HCI_BUFF_ACL_TOTAL(unit->buffer, acl_total);
 305                         NG_HCI_BUFF_ACL_SIZE(unit->buffer, acl_size);
 306
 307                         NG_HCI_BUFF_SCO_AVAIL(unit->buffer, sco_avail);
 308                         NG_HCI_BUFF_SCO_TOTAL(unit->buffer, sco_total);
 309                         NG_HCI_BUFF_SCO_SIZE(unit->buffer, sco_size);
 310
 311                         snprintf(rsp->data, NG_TEXTRESPONSE,
 312                                 "bdaddr %x:%x:%x:%x:%x:%x\n" \
 313                                 "Hooks  %s %s %s %s\n" \
 314                                 "State  %#x\n" \
 315                                 "Queue  cmd:%d\n" \
 316                                 "Buffer cmd:%d,acl:%d,%d,%d,sco:%d,%d,%d",
 317                                 unit->bdaddr.b[5], unit->bdaddr.b[4],
 318                                 unit->bdaddr.b[3], unit->bdaddr.b[2],
 319                                 unit->bdaddr.b[1], unit->bdaddr.b[0],
 320                                 (unit->drv != NULL)? NG_HCI_HOOK_DRV : "",
 321                                 (unit->acl != NULL)? NG_HCI_HOOK_ACL : "",
 322                                 (unit->sco != NULL)? NG_HCI_HOOK_SCO : "",
 323                                 (unit->raw != NULL)? NG_HCI_HOOK_RAW : "",
 324                                 unit->state,
 325                                 NG_BT_MBUFQ_LEN(&unit->cmdq),
 326                                 cmd_avail,
 327                                 acl_avail, acl_total, acl_size,
 328                                 sco_avail, sco_total, sco_size);
 329                         } break;
 330
 331                 default:
 332                         error = EINVAL;
 333                         break;
 334                 }
 335                 break;
 336
 337         case NGM_HCI_COOKIE:
 338                 switch (msg->header.cmd) {
 339                 /* Get current node state */
 340                 case NGM_HCI_NODE_GET_STATE:
 341                         NG_MKRESPONSE(rsp, msg, sizeof(unit->state), M_WAITOK | M_NULLOK);
 342                         if (rsp == NULL) {
 343                                 error = ENOMEM;
 344                                 break;
 345                         }
 346
 347                         *((ng_hci_node_state_ep *)(rsp->data)) = unit->state;
 348                         break;
 349
 350                 /* Turn INITED bit - node initialized */
 351                 case NGM_HCI_NODE_INIT:
 352                         if (bcmp(&unit->bdaddr, NG_HCI_BDADDR_ANY,
 353                                         sizeof(bdaddr_t)) == 0) {
 354                                 error = ENXIO;
 355                                 break;
 356                         }
 357
 358                         unit->state |= NG_HCI_UNIT_INITED;
 359
 360                         ng_hci_node_is_up(unit->node, unit->acl, NULL, 0);
 361                         ng_hci_node_is_up(unit->node, unit->sco, NULL, 0);
 362                         break;
 363
 364                 /* Get node debug level */
 365                 case NGM_HCI_NODE_GET_DEBUG:
 366                         NG_MKRESPONSE(rsp, msg, sizeof(unit->debug), M_WAITOK | M_NULLOK);
 367                         if (rsp == NULL) {
 368                                 error = ENOMEM;
 369                                 break;
 370                         }
 371
 372                         *((ng_hci_node_debug_ep *)(rsp->data)) = unit->debug;
 373                         break;
 374
 375                 /* Set node debug level */
 376                 case NGM_HCI_NODE_SET_DEBUG:
 377                         if (msg->header.arglen != sizeof(ng_hci_node_debug_ep)){
 378                                 error = EMSGSIZE;
 379                                 break;
 380                         }
 381
 382                         unit->debug = *((ng_hci_node_debug_ep *)(msg->data));
 383                         break;
 384
 385                 /* Get buffer info */
 386                 case NGM_HCI_NODE_GET_BUFFER: {
 387                         ng_hci_node_buffer_ep   *ep = NULL;
 388
 389                         NG_MKRESPONSE(rsp, msg, sizeof(ng_hci_node_buffer_ep),
 390                                 M_WAITOK | M_NULLOK);
 391                         if (rsp == NULL) {
 392                                 error = ENOMEM;
 393                                 break;
 394                         }
 395
 396                         ep = (ng_hci_node_buffer_ep *)(rsp->data);
 397
 398                         NG_HCI_BUFF_CMD_GET(unit->buffer, ep->cmd_free);
 399                         NG_HCI_BUFF_ACL_AVAIL(unit->buffer, ep->acl_free);
 400                         NG_HCI_BUFF_ACL_TOTAL(unit->buffer, ep->acl_pkts);
 401                         NG_HCI_BUFF_ACL_SIZE(unit->buffer, ep->acl_size);
 402                         NG_HCI_BUFF_SCO_AVAIL(unit->buffer, ep->sco_free);
 403                         NG_HCI_BUFF_SCO_TOTAL(unit->buffer, ep->sco_pkts);
 404                         NG_HCI_BUFF_SCO_SIZE(unit->buffer, ep->sco_size);
 405                         } break;
 406
 407                 /* Get BDADDR */
 408                 case NGM_HCI_NODE_GET_BDADDR:
 409                         NG_MKRESPONSE(rsp, msg, sizeof(bdaddr_t), M_WAITOK | M_NULLOK);
 410                         if (rsp == NULL) {
 411                                 error = ENOMEM;
 412                                 break;
 413                         }
 414
 415                         bcopy(&unit->bdaddr, rsp->data, sizeof(bdaddr_t));
 416                         break;
 417
 418                 /* Get features */
 419                 case NGM_HCI_NODE_GET_FEATURES:
 420                         NG_MKRESPONSE(rsp,msg,sizeof(unit->features),M_WAITOK | M_NULLOK);
 421                         if (rsp == NULL) {
 422                                 error = ENOMEM;
 423                                 break;
 424                         }
 425
 426                         bcopy(&unit->features,rsp->data,sizeof(unit->features));
 427                         break;
 428
 429                 /* Get stat */
 430                 case NGM_HCI_NODE_GET_STAT:
 431                         NG_MKRESPONSE(rsp, msg, sizeof(unit->stat), M_WAITOK | M_NULLOK);
 432                         if (rsp == NULL) {
 433                                 error = ENOMEM;
 434                                 break;
 435                         }
 436
 437                         bcopy(&unit->stat, rsp->data, sizeof(unit->stat));
 438                         break;
 439
 440                 /* Reset stat */
 441                 case NGM_HCI_NODE_RESET_STAT:
 442                         NG_HCI_STAT_RESET(unit->stat);
 443                         break;
 444
 445                 /* Clean up neighbors list */
 446                 case NGM_HCI_NODE_FLUSH_NEIGHBOR_CACHE:
 447                         ng_hci_flush_neighbor_cache(unit);
 448                         break;
 449
 450                 /* Get neighbor cache entries */
 451                 case NGM_HCI_NODE_GET_NEIGHBOR_CACHE: {
 452                         ng_hci_neighbor_p                        n = NULL;
 453                         ng_hci_node_get_neighbor_cache_ep       *e1 = NULL;
 454                         ng_hci_node_neighbor_cache_entry_ep     *e2 = NULL;
 455                         int                                      s = 0;
 456
 457                         /* Look for the fresh entries in the cache */
 458                         for (n = LIST_FIRST(&unit->neighbors); n != NULL; ) {
 459                                 ng_hci_neighbor_p       nn = LIST_NEXT(n, next);
 460
 461                                 if (ng_hci_neighbor_stale(n))
 462                                         ng_hci_free_neighbor(n);
 463                                 else
 464                                         s ++;
 465
 466                                 n = nn;
 467                         }
 468                         if (s > NG_HCI_MAX_NEIGHBOR_NUM)
 469                                 s = NG_HCI_MAX_NEIGHBOR_NUM;
 470
 471                         /* Prepare response */
 472                         NG_MKRESPONSE(rsp, msg, sizeof(*e1) + s * sizeof(*e2),
 473                                 M_WAITOK | M_NULLOK);
 474                         if (rsp == NULL) {
 475                                 error = ENOMEM;
 476                                 break;
 477                         }
 478
 479                         e1 = (ng_hci_node_get_neighbor_cache_ep *)(rsp->data);
 480                         e2 = (ng_hci_node_neighbor_cache_entry_ep *)(e1 + 1);
 481
 482                         e1->num_entries = s;
 483
 484                         LIST_FOREACH(n, &unit->neighbors, next) {
 485                                 e2->page_scan_rep_mode = n->page_scan_rep_mode;
 486                                 e2->page_scan_mode = n->page_scan_mode;
 487                                 e2->clock_offset = n->clock_offset;
 488                                 bcopy(&n->bdaddr, &e2->bdaddr,
 489                                         sizeof(e2->bdaddr));
 490                                 bcopy(&n->features, &e2->features,
 491                                         sizeof(e2->features));
 492
 493                                 e2 ++;
 494                                 if (--s <= 0)
 495                                         break;
 496                         }
 497                         } break;
 498
 499                 /* Get connection list */
 500                 case NGM_HCI_NODE_GET_CON_LIST: {
 501                         ng_hci_unit_con_p        c = NULL;
 502                         ng_hci_node_con_list_ep *e1 = NULL;
 503                         ng_hci_node_con_ep      *e2 = NULL;
 504                         int                      s = 0;
 505
 506                         /* Count number of connections in the list */
 507                         LIST_FOREACH(c, &unit->con_list, next)
 508                                 s ++;
 509                         if (s > NG_HCI_MAX_CON_NUM)
 510                                 s = NG_HCI_MAX_CON_NUM;
 511
 512                         /* Prepare response */
 513                         NG_MKRESPONSE(rsp, msg, sizeof(*e1) + s * sizeof(*e2),
 514                                 M_WAITOK | M_NULLOK);
 515                         if (rsp == NULL) {
 516                                 error = ENOMEM;
 517                                 break;
 518                         }
 519
 520                         e1 = (ng_hci_node_con_list_ep *)(rsp->data);
 521                         e2 = (ng_hci_node_con_ep *)(e1 + 1);
 522
 523                         e1->num_connections = s;
 524
 525                         LIST_FOREACH(c, &unit->con_list, next) {
 526                                 e2->link_type = c->link_type;
 527                                 e2->encryption_mode= c->encryption_mode;
 528                                 e2->mode = c->mode;
 529                                 e2->role = c->role;
 530
 531                                 e2->state = c->state;
 532
 533                                 e2->pending = c->pending;
 534                                 e2->queue_len = NG_BT_ITEMQ_LEN(&c->conq);
 535
 536                                 e2->con_handle = c->con_handle;
 537                                 bcopy(&c->bdaddr, &e2->bdaddr,
 538                                         sizeof(e2->bdaddr));
 539
 540                                 e2 ++;
 541                                 if (--s <= 0)
 542                                         break;
 543                         }
 544                         } break;
 545
 546                 /* Get link policy settings mask */
 547                 case NGM_HCI_NODE_GET_LINK_POLICY_SETTINGS_MASK:
 548                         NG_MKRESPONSE(rsp, msg, sizeof(unit->link_policy_mask),
 549                                 M_WAITOK | M_NULLOK);
 550                         if (rsp == NULL) {
 551                                 error = ENOMEM;
 552                                 break;
 553                         }
 554
 555                         *((ng_hci_node_link_policy_mask_ep *)(rsp->data)) =
 556                                 unit->link_policy_mask;
 557                         break;
 558
 559                 /* Set link policy settings mask */
 560                 case NGM_HCI_NODE_SET_LINK_POLICY_SETTINGS_MASK:
 561                         if (msg->header.arglen !=
 562                                 sizeof(ng_hci_node_link_policy_mask_ep)) {
 563                                 error = EMSGSIZE;
 564                                 break;
 565                         }
 566
 567                         unit->link_policy_mask =
 568                                 *((ng_hci_node_link_policy_mask_ep *)
 569                                         (msg->data));
 570                         break;
 571
 572                 /* Get packet mask */
 573                 case NGM_HCI_NODE_GET_PACKET_MASK:
 574                         NG_MKRESPONSE(rsp, msg, sizeof(unit->packet_mask),
 575                                 M_WAITOK | M_NULLOK);
 576                         if (rsp == NULL) {
 577                                 error = ENOMEM;
 578                                 break;
 579                         }
 580
 581                         *((ng_hci_node_packet_mask_ep *)(rsp->data)) =
 582                                 unit->packet_mask;
 583                         break;
 584
 585                 /* Set packet mask */
 586                 case NGM_HCI_NODE_SET_PACKET_MASK:
 587                         if (msg->header.arglen !=
 588                                         sizeof(ng_hci_node_packet_mask_ep)) {
 589                                 error = EMSGSIZE;
 590                                 break;
 591                         }
 592
 593                         unit->packet_mask =
 594                                 *((ng_hci_node_packet_mask_ep *)(msg->data));
 595                         break;
 596
 597                 /* Get role switch */
 598                 case NGM_HCI_NODE_GET_ROLE_SWITCH:
 599                         NG_MKRESPONSE(rsp, msg, sizeof(unit->role_switch),
 600                                 M_WAITOK | M_NULLOK);
 601                         if (rsp == NULL) {
 602                                 error = ENOMEM;
 603                                 break;
 604                         }
 605
 606                         *((ng_hci_node_role_switch_ep *)(rsp->data)) =
 607                                 unit->role_switch;
 608                         break;
 609
 610                 /* Set role switch */
 611                 case NGM_HCI_NODE_SET_ROLE_SWITCH:
 612                         if (msg->header.arglen !=
 613                                         sizeof(ng_hci_node_role_switch_ep)) {
 614                                 error = EMSGSIZE;
 615                                 break;
 616                         }
 617
 618                         unit->role_switch =
 619                                 *((ng_hci_node_role_switch_ep *)(msg->data));
 620                         break;
 621
 622                 default:
 623                         error = EINVAL;
 624                         break;
 625                 }
 626                 break;
 627
 628         default:
 629                 error = EINVAL;
 630                 break;
 631         }
 632
 633         /* NG_RESPOND_MSG should take care of "item" and "rsp" */
 634         NG_RESPOND_MSG(error, node, item, rsp);
 635         NG_FREE_MSG(msg);
 636
 637         return (error);
 638 } /* ng_hci_default_rcvmsg */
 639
 640 /*
 641  * Process control message from upstream hooks (ACL and SCO).
 642  * Handle LP_xxx messages here, give everything else to default routine.
 643  */
 644
 645 static int
 646 ng_hci_upper_rcvmsg(node_p node, item_p item, hook_p lasthook)
 647 {
 648         ng_hci_unit_p   unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node);
 649         int             error = 0;
 650
 651         switch (NGI_MSG(item)->header.typecookie) {
 652         case NGM_HCI_COOKIE:
 653                 switch (NGI_MSG(item)->header.cmd) {
 654                 case NGM_HCI_LP_CON_REQ:
 655                         error = ng_hci_lp_con_req(unit, item, lasthook);
 656                         break;
 657
 658                 case NGM_HCI_LP_DISCON_REQ: /* XXX not defined by specs */
 659                         error = ng_hci_lp_discon_req(unit, item, lasthook);
 660                         break;
 661
 662                 case NGM_HCI_LP_CON_RSP:
 663                         error = ng_hci_lp_con_rsp(unit, item, lasthook);
 664                         break;
 665
 666                 case NGM_HCI_LP_QOS_REQ:
 667                         error = ng_hci_lp_qos_req(unit, item, lasthook);
 668                         break;
 669
 670                 default:
 671                         error = ng_hci_default_rcvmsg(node, item, lasthook);
 672                         break;
 673                 }
 674                 break;
 675
 676         default:
 677                 error = ng_hci_default_rcvmsg(node, item, lasthook);
 678                 break;
 679         }
 680
 681         return (error);
 682 } /* ng_hci_upper_rcvmsg */
 683
 684 /*
 685  * Process data packet from the driver hook.
 686  * We expect HCI events, ACL or SCO data packets.
 687  */
 688
 689 static int
 690 ng_hci_drv_rcvdata(hook_p hook, item_p item)
 691 {
 692         ng_hci_unit_p    unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 693         struct mbuf     *m = NULL;
 694         int              error = 0;
 695
 696         /* Process packet */
 697         m = NGI_M(item); /* item still has mbuf, just peeking */
 698         m->m_flags |= M_PROTO1; /* mark as incoming packet */
 699
 700         NG_HCI_STAT_BYTES_RECV(unit->stat, m->m_pkthdr.len);
 701
 702         /* Give copy packet to RAW hook */
 703         ng_hci_mtap(unit, m);
 704
 705         /*
 706          * XXX XXX XXX
 707          * Lower layer drivers MUST NOT send mbuf chain with empty mbuf at
 708          * the beginning of the chain. HCI layer WILL NOT call m_pullup() here.
 709          */
 710
 711         switch (*mtod(m, u_int8_t *)) {
 712         case NG_HCI_ACL_DATA_PKT:
 713                 NG_HCI_STAT_ACL_RECV(unit->stat);
 714
 715                 if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY ||
 716                     unit->acl == NULL || NG_HOOK_NOT_VALID(unit->acl)) {
 717                         NG_HCI_WARN(
 718 "%s: %s - could not forward HCI ACL data packet, state=%#x, hook=%p\n",
 719                                 __func__, NG_NODE_NAME(unit->node),
 720                                 unit->state, unit->acl);
 721
 722                         NG_FREE_ITEM(item);
 723                 } else
 724                         NG_FWD_ITEM_HOOK(error, item, unit->acl);
 725                 break;
 726
 727         case NG_HCI_SCO_DATA_PKT:
 728                 NG_HCI_STAT_SCO_RECV(unit->stat);
 729
 730                 if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY ||
 731                     unit->sco == NULL || NG_HOOK_NOT_VALID(unit->sco)) {
 732                         NG_HCI_WARN(
 733 "%s: %s - could not forward HCI SCO data packet, state=%#x, hook=%p\n",
 734                                 __func__, NG_NODE_NAME(unit->node),
 735                                 unit->state, unit->sco);
 736
 737                         NG_FREE_ITEM(item);
 738                 } else
 739                         NG_FWD_ITEM_HOOK(error, item, unit->sco);
 740                 break;
 741
 742         case NG_HCI_EVENT_PKT:
 743                 NG_HCI_STAT_EVNT_RECV(unit->stat);
 744
 745                 /* Detach mbuf, discard item and process event */
 746                 NGI_GET_M(item, m);
 747                 NG_FREE_ITEM(item);
 748
 749                 error = ng_hci_process_event(unit, m);
 750                 break;
 751
 752         default:
 753                 NG_HCI_ALERT(
 754 "%s: %s - got unknown HCI packet type=%#x\n",
 755                         __func__, NG_NODE_NAME(unit->node),
 756                         *mtod(m, u_int8_t *));
 757
 758                 NG_FREE_ITEM(item);
 759
 760                 error = EINVAL;
 761                 break;
 762         }
 763
 764         return (error);
 765 } /* ng_hci_drv_rcvdata */
 766
 767 /*
 768  * Process data packet from ACL upstream hook.
 769  * We expect valid HCI ACL data packets.
 770  */
 771
 772 static int
 773 ng_hci_acl_rcvdata(hook_p hook, item_p item)
 774 {
 775         ng_hci_unit_p            unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 776         struct mbuf             *m = NULL;
 777         ng_hci_unit_con_p        con = NULL;
 778         u_int16_t                con_handle;
 779         int                      size, error = 0;
 780
 781         NG_HCI_BUFF_ACL_SIZE(unit->buffer, size);
 782
 783         /* Check packet */
 784         NGI_GET_M(item, m);
 785
 786         if (*mtod(m, u_int8_t *) != NG_HCI_ACL_DATA_PKT) {
 787                 NG_HCI_ALERT(
 788 "%s: %s - invalid HCI data packet type=%#x\n",
 789                         __func__, NG_NODE_NAME(unit->node),
 790                         *mtod(m, u_int8_t *));
 791
 792                 error = EINVAL;
 793                 goto drop;
 794         }
 795
 796         if (m->m_pkthdr.len < sizeof(ng_hci_acldata_pkt_t) ||
 797             m->m_pkthdr.len > sizeof(ng_hci_acldata_pkt_t) + size) {
 798                 NG_HCI_ALERT(
 799 "%s: %s - invalid HCI ACL data packet, len=%d, mtu=%d\n",
 800                         __func__, NG_NODE_NAME(unit->node),
 801                         m->m_pkthdr.len, size);
 802
 803                 error = EMSGSIZE;
 804                 goto drop;
 805         }
 806
 807         NG_HCI_M_PULLUP(m, sizeof(ng_hci_acldata_pkt_t));
 808         if (m == NULL) {
 809                 error = ENOBUFS;
 810                 goto drop;
 811         }
 812
 813         con_handle = NG_HCI_CON_HANDLE(le16toh(
 814                         mtod(m, ng_hci_acldata_pkt_t *)->con_handle));
 815         size = le16toh(mtod(m, ng_hci_acldata_pkt_t *)->length);
 816
 817         if (m->m_pkthdr.len != sizeof(ng_hci_acldata_pkt_t) + size) {
 818                 NG_HCI_ALERT(
 819 "%s: %s - invalid HCI ACL data packet size, len=%d, length=%d\n",
 820                         __func__, NG_NODE_NAME(unit->node),
 821                         m->m_pkthdr.len, size);
 822
 823                 error = EMSGSIZE;
 824                 goto drop;
 825         }
 826
 827         /* Queue packet */
 828         con = ng_hci_con_by_handle(unit, con_handle);
 829         if (con == NULL) {
 830                 NG_HCI_ERR(
 831 "%s: %s - unexpected HCI ACL data packet. Connection does not exists, " \
 832 "con_handle=%d\n",      __func__, NG_NODE_NAME(unit->node), con_handle);
 833
 834                 error = ENOENT;
 835                 goto drop;
 836         }
 837
 838         if (con->link_type != NG_HCI_LINK_ACL) {
 839                 NG_HCI_ERR(
 840 "%s: %s - unexpected HCI ACL data packet. Not ACL link, con_handle=%d, " \
 841 "link_type=%d\n",       __func__, NG_NODE_NAME(unit->node),
 842                         con_handle, con->link_type);
 843
 844                 error = EINVAL;
 845                 goto drop;
 846         }
 847
 848         if (con->state != NG_HCI_CON_OPEN) {
 849                 NG_HCI_ERR(
 850 "%s: %s - unexpected HCI ACL data packet. Invalid connection state=%d, " \
 851 "con_handle=%d\n",       __func__, NG_NODE_NAME(unit->node),
 852                         con->state, con_handle);
 853
 854                 error = EHOSTDOWN;
 855                 goto drop;
 856         }
 857
 858         if (NG_BT_ITEMQ_FULL(&con->conq)) {
 859                 NG_HCI_ALERT(
 860 "%s: %s - dropping HCI ACL data packet, con_handle=%d, len=%d, queue_len=%d\n",
 861                          __func__, NG_NODE_NAME(unit->node), con_handle,
 862                         m->m_pkthdr.len, NG_BT_ITEMQ_LEN(&con->conq));
 863
 864                 NG_BT_ITEMQ_DROP(&con->conq);
 865
 866                 error = ENOBUFS;
 867                 goto drop;
 868         }
 869
 870         /* Queue item and schedule data transfer */
 871         NGI_M(item) = m;
 872         NG_BT_ITEMQ_ENQUEUE(&con->conq, item);
 873         item = NULL;
 874         m = NULL;
 875
 876         ng_hci_send_data(unit);
 877 drop:
 878         if (item != NULL)
 879                 NG_FREE_ITEM(item);
 880
 881         NG_FREE_M(m); /* NG_FREE_M() checks for m != NULL */
 882
 883         return (error);
 884 } /* ng_hci_acl_rcvdata */
 885
 886 /*
 887  * Process data packet from SCO upstream hook.
 888  * We expect valid HCI SCO data packets
 889  */
 890
 891 static int
 892 ng_hci_sco_rcvdata(hook_p hook, item_p item)
 893 {
 894         ng_hci_unit_p            unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 895         struct mbuf             *m = NULL;
 896         ng_hci_unit_con_p        con = NULL;
 897         u_int16_t                con_handle;
 898         int                      size, error = 0;
 899
 900         NG_HCI_BUFF_SCO_SIZE(unit->buffer, size);
 901
 902         /* Check packet */
 903         NGI_GET_M(item, m);
 904
 905         if (*mtod(m, u_int8_t *) != NG_HCI_SCO_DATA_PKT) {
 906                 NG_HCI_ALERT(
 907 "%s: %s - invalid HCI data packet type=%#x\n",
 908                         __func__, NG_NODE_NAME(unit->node),
 909                         *mtod(m, u_int8_t *));
 910
 911                 error = EINVAL;
 912                 goto drop;
 913         }
 914
 915         if (m->m_pkthdr.len < sizeof(ng_hci_scodata_pkt_t) ||
 916             m->m_pkthdr.len > sizeof(ng_hci_scodata_pkt_t) + size) {
 917                 NG_HCI_ALERT(
 918 "%s: %s - invalid HCI SCO data packet, len=%d, mtu=%d\n",
 919                         __func__, NG_NODE_NAME(unit->node),
 920                         m->m_pkthdr.len, size);
 921
 922                 error = EMSGSIZE;
 923                 goto drop;
 924         }
 925
 926         NG_HCI_M_PULLUP(m, sizeof(ng_hci_scodata_pkt_t));
 927         if (m == NULL) {
 928                 error = ENOBUFS;
 929                 goto drop;
 930         }
 931
 932         con_handle = NG_HCI_CON_HANDLE(le16toh(
 933                         mtod(m, ng_hci_scodata_pkt_t *)->con_handle));
 934         size = mtod(m, ng_hci_scodata_pkt_t *)->length;
 935
 936         if (m->m_pkthdr.len != sizeof(ng_hci_scodata_pkt_t) + size) {
 937                 NG_HCI_ALERT(
 938 "%s: %s - invalid HCI SCO data packet size, len=%d, length=%d\n",
 939                         __func__, NG_NODE_NAME(unit->node),
 940                         m->m_pkthdr.len, size);
 941
 942                 error = EMSGSIZE;
 943                 goto drop;
 944         }
 945
 946         /* Queue packet */
 947         con = ng_hci_con_by_handle(unit, con_handle);
 948         if (con == NULL) {
 949                 NG_HCI_ERR(
 950 "%s: %s - unexpected HCI SCO data packet. Connection does not exists, " \
 951 "con_handle=%d\n",      __func__, NG_NODE_NAME(unit->node), con_handle);
 952
 953                 error = ENOENT;
 954                 goto drop;
 955         }
 956
 957         if (con->link_type != NG_HCI_LINK_SCO) {
 958                 NG_HCI_ERR(
 959 "%s: %s - unexpected HCI SCO data packet. Not SCO link, con_handle=%d, " \
 960 "link_type=%d\n",       __func__, NG_NODE_NAME(unit->node),
 961                         con_handle, con->link_type);
 962
 963                 error = EINVAL;
 964                 goto drop;
 965         }
 966
 967         if (con->state != NG_HCI_CON_OPEN) {
 968                 NG_HCI_ERR(
 969 "%s: %s - unexpected HCI SCO data packet. Invalid connection state=%d, " \
 970 "con_handle=%d\n",      __func__, NG_NODE_NAME(unit->node),
 971                         con->state, con_handle);
 972
 973                 error = EHOSTDOWN;
 974                 goto drop;
 975         }
 976
 977         if (NG_BT_ITEMQ_FULL(&con->conq)) {
 978                 NG_HCI_ALERT(
 979 "%s: %s - dropping HCI SCO data packet, con_handle=%d, len=%d, queue_len=%d\n",
 980                         __func__, NG_NODE_NAME(unit->node), con_handle,
 981                         m->m_pkthdr.len, NG_BT_ITEMQ_LEN(&con->conq));
 982
 983                 NG_BT_ITEMQ_DROP(&con->conq);
 984
 985                 error = ENOBUFS;
 986                 goto drop;
 987         }
 988
 989         /* Queue item and schedule data transfer */
 990         NGI_M(item) = m;
 991         NG_BT_ITEMQ_ENQUEUE(&con->conq, item);
 992         item = NULL;
 993         m = NULL;
 994
 995         ng_hci_send_data(unit);
 996 drop:
 997         if (item != NULL)
 998                 NG_FREE_ITEM(item);
 999
1000         NG_FREE_M(m); /* NG_FREE_M() checks for m != NULL */
1001
1002         return (error);
1003 } /* ng_hci_sco_rcvdata */
1004
1005 /*
1006  * Process data packet from uptream RAW hook.
1007  * We expect valid HCI command packets.
1008  */
1009
1010 static int
1011 ng_hci_raw_rcvdata(hook_p hook, item_p item)
1012 {
1013         ng_hci_unit_p    unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
1014         struct mbuf     *m = NULL;
1015         int              error = 0;
1016
1017         NGI_GET_M(item, m);
1018         NG_FREE_ITEM(item);
1019
1020         /* Check packet */
1021         if (*mtod(m, u_int8_t *) != NG_HCI_CMD_PKT) {
1022                 NG_HCI_ALERT(
1023 "%s: %s - invalid HCI command packet type=%#x\n",
1024                         __func__, NG_NODE_NAME(unit->node),
1025                         *mtod(m, u_int8_t *));
1026
1027                 error = EINVAL;
1028                 goto drop;
1029         }
1030
1031         if (m->m_pkthdr.len < sizeof(ng_hci_cmd_pkt_t)) {
1032                 NG_HCI_ALERT(
1033 "%s: %s - invalid HCI command packet len=%d\n",
1034                         __func__, NG_NODE_NAME(unit->node), m->m_pkthdr.len);
1035
1036                 error = EMSGSIZE;
1037                 goto drop;
1038         }
1039
1040         NG_HCI_M_PULLUP(m, sizeof(ng_hci_cmd_pkt_t));
1041         if (m == NULL) {
1042                 error = ENOBUFS;
1043                 goto drop;
1044         }
1045
1046         if (m->m_pkthdr.len !=
1047             mtod(m, ng_hci_cmd_pkt_t *)->length + sizeof(ng_hci_cmd_pkt_t)) {
1048                 NG_HCI_ALERT(
1049 "%s: %s - invalid HCI command packet size, len=%d, length=%d\n",
1050                         __func__, NG_NODE_NAME(unit->node), m->m_pkthdr.len,
1051                         mtod(m, ng_hci_cmd_pkt_t *)->length);
1052
1053                 error = EMSGSIZE;
1054                 goto drop;
1055         }
1056
1057         if (mtod(m, ng_hci_cmd_pkt_t *)->opcode == 0) {
1058                 NG_HCI_ALERT(
1059 "%s: %s - invalid HCI command opcode\n",
1060                         __func__, NG_NODE_NAME(unit->node));
1061
1062                 error = EINVAL;
1063                 goto drop;
1064         }
1065
1066         if (NG_BT_MBUFQ_FULL(&unit->cmdq)) {
1067                 NG_HCI_ALERT(
1068 "%s: %s - dropping HCI command packet, len=%d, queue_len=%d\n",
1069                         __func__, NG_NODE_NAME(unit->node), m->m_pkthdr.len,
1070                         NG_BT_MBUFQ_LEN(&unit->cmdq));
1071
1072                 NG_BT_MBUFQ_DROP(&unit->cmdq);
1073
1074                 error = ENOBUFS;
1075                 goto drop;
1076         }
1077
1078         /* Queue and send command */
1079         NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m);
1080         m = NULL;
1081
1082         if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING))
1083                 error = ng_hci_send_command(unit);
1084 drop:
1085         NG_FREE_M(m); /* NG_FREE_M() checks for m != NULL */
1086
1087         return (error);
1088 } /* ng_hci_raw_rcvdata */
1089