Annotation of sys/netbt/hci_event.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: hci_event.c,v 1.5 2007/06/19 08:12:35 uwe Exp $ */
! 2: /* $NetBSD: hci_event.c,v 1.6 2007/04/21 06:15:23 plunky Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 2005 Iain Hibbert.
! 6: * Copyright (c) 2006 Itronix Inc.
! 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: * 3. The name of Itronix Inc. may not be used to endorse
! 18: * or promote products derived from this software without specific
! 19: * prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 23: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 24: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
! 25: * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 26: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! 27: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
! 28: * ON ANY THEORY OF LIABILITY, WHETHER IN
! 29: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 30: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 31: * POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34: #include <sys/cdefs.h>
! 35:
! 36: #include <sys/param.h>
! 37: #include <sys/kernel.h>
! 38: #include <sys/malloc.h>
! 39: #include <sys/mbuf.h>
! 40: #include <sys/proc.h>
! 41: #include <sys/systm.h>
! 42:
! 43: #include <netbt/bluetooth.h>
! 44: #include <netbt/hci.h>
! 45: #include <netbt/sco.h>
! 46:
! 47: static void hci_event_inquiry_result(struct hci_unit *, struct mbuf *);
! 48: static void hci_event_command_status(struct hci_unit *, struct mbuf *);
! 49: static void hci_event_command_compl(struct hci_unit *, struct mbuf *);
! 50: static void hci_event_con_compl(struct hci_unit *, struct mbuf *);
! 51: static void hci_event_discon_compl(struct hci_unit *, struct mbuf *);
! 52: static void hci_event_con_req(struct hci_unit *, struct mbuf *);
! 53: static void hci_event_num_compl_pkts(struct hci_unit *, struct mbuf *);
! 54: static void hci_event_auth_compl(struct hci_unit *, struct mbuf *);
! 55: static void hci_event_encryption_change(struct hci_unit *, struct mbuf *);
! 56: static void hci_event_change_con_link_key_compl(struct hci_unit *, struct mbuf *);
! 57: static void hci_cmd_read_bdaddr(struct hci_unit *, struct mbuf *);
! 58: static void hci_cmd_read_buffer_size(struct hci_unit *, struct mbuf *);
! 59: static void hci_cmd_read_local_features(struct hci_unit *, struct mbuf *);
! 60: static void hci_cmd_reset(struct hci_unit *, struct mbuf *);
! 61:
! 62: #ifdef BLUETOOTH_DEBUG
! 63: int bluetooth_debug = 0;
! 64:
! 65: static const char *hci_eventnames[] = {
! 66: /* 0x00 */ "NULL",
! 67: /* 0x01 */ "INQUIRY COMPLETE",
! 68: /* 0x02 */ "INQUIRY RESULT",
! 69: /* 0x03 */ "CONN COMPLETE",
! 70: /* 0x04 */ "CONN REQ",
! 71: /* 0x05 */ "DISCONN COMPLETE",
! 72: /* 0x06 */ "AUTH COMPLETE",
! 73: /* 0x07 */ "REMOTE NAME REQ COMPLETE",
! 74: /* 0x08 */ "ENCRYPTION CHANGE",
! 75: /* 0x09 */ "CHANGE CONN LINK KEY COMPLETE",
! 76: /* 0x0a */ "MASTER LINK KEY COMPLETE",
! 77: /* 0x0b */ "READ REMOTE FEATURES COMPLETE",
! 78: /* 0x0c */ "READ REMOTE VERSION INFO COMPLETE",
! 79: /* 0x0d */ "QoS SETUP COMPLETE",
! 80: /* 0x0e */ "COMMAND COMPLETE",
! 81: /* 0x0f */ "COMMAND STATUS",
! 82: /* 0x10 */ "HARDWARE ERROR",
! 83: /* 0x11 */ "FLUSH OCCUR",
! 84: /* 0x12 */ "ROLE CHANGE",
! 85: /* 0x13 */ "NUM COMPLETED PACKETS",
! 86: /* 0x14 */ "MODE CHANGE",
! 87: /* 0x15 */ "RETURN LINK KEYS",
! 88: /* 0x16 */ "PIN CODE REQ",
! 89: /* 0x17 */ "LINK KEY REQ",
! 90: /* 0x18 */ "LINK KEY NOTIFICATION",
! 91: /* 0x19 */ "LOOPBACK COMMAND",
! 92: /* 0x1a */ "DATA BUFFER OVERFLOW",
! 93: /* 0x1b */ "MAX SLOT CHANGE",
! 94: /* 0x1c */ "READ CLOCK OFFSET COMPLETE",
! 95: /* 0x1d */ "CONN PKT TYPE CHANGED",
! 96: /* 0x1e */ "QOS VIOLATION",
! 97: /* 0x1f */ "PAGE SCAN MODE CHANGE",
! 98: /* 0x20 */ "PAGE SCAN REP MODE CHANGE",
! 99: /* 0x21 */ "FLOW SPECIFICATION COMPLETE",
! 100: /* 0x22 */ "RSSI RESULT",
! 101: /* 0x23 */ "READ REMOTE EXT FEATURES"
! 102: };
! 103:
! 104: static const char *
! 105: hci_eventstr(unsigned int event)
! 106: {
! 107:
! 108: if (event < (sizeof(hci_eventnames) / sizeof(*hci_eventnames)))
! 109: return hci_eventnames[event];
! 110:
! 111: switch (event) {
! 112: case HCI_EVENT_SCO_CON_COMPL: /* 0x2c */
! 113: return "SCO CON COMPLETE";
! 114:
! 115: case HCI_EVENT_SCO_CON_CHANGED: /* 0x2d */
! 116: return "SCO CON CHANGED";
! 117:
! 118: case HCI_EVENT_BT_LOGO: /* 0xfe */
! 119: return "BT_LOGO";
! 120:
! 121: case HCI_EVENT_VENDOR: /* 0xff */
! 122: return "VENDOR";
! 123: }
! 124:
! 125: return "UNRECOGNISED";
! 126: }
! 127: #endif /* BLUETOOTH_DEBUG */
! 128:
! 129: /*
! 130: * process HCI Events
! 131: *
! 132: * We will free the mbuf at the end, no need for any sub
! 133: * functions to handle that. We kind of assume that the
! 134: * device sends us valid events.
! 135: * XXX "kind of"? This needs to be fixed.
! 136: */
! 137: void
! 138: hci_event(struct mbuf *m, struct hci_unit *unit)
! 139: {
! 140: hci_event_hdr_t hdr;
! 141:
! 142: KASSERT(m->m_flags & M_PKTHDR);
! 143:
! 144: KASSERT(m->m_pkthdr.len >= sizeof(hdr));
! 145: m_copydata(m, 0, sizeof(hdr), (caddr_t)&hdr);
! 146: m_adj(m, sizeof(hdr));
! 147:
! 148: KASSERT(hdr.type == HCI_EVENT_PKT);
! 149:
! 150: DPRINTFN(1, "(%s) event %s\n", unit->hci_devname, hci_eventstr(hdr.event));
! 151:
! 152: switch(hdr.event) {
! 153: case HCI_EVENT_COMMAND_STATUS:
! 154: hci_event_command_status(unit, m);
! 155: break;
! 156:
! 157: case HCI_EVENT_COMMAND_COMPL:
! 158: hci_event_command_compl(unit, m);
! 159: break;
! 160:
! 161: case HCI_EVENT_NUM_COMPL_PKTS:
! 162: hci_event_num_compl_pkts(unit, m);
! 163: break;
! 164:
! 165: case HCI_EVENT_INQUIRY_RESULT:
! 166: hci_event_inquiry_result(unit, m);
! 167: break;
! 168:
! 169: case HCI_EVENT_CON_COMPL:
! 170: hci_event_con_compl(unit, m);
! 171: break;
! 172:
! 173: case HCI_EVENT_DISCON_COMPL:
! 174: hci_event_discon_compl(unit, m);
! 175: break;
! 176:
! 177: case HCI_EVENT_CON_REQ:
! 178: hci_event_con_req(unit, m);
! 179: break;
! 180:
! 181: case HCI_EVENT_AUTH_COMPL:
! 182: hci_event_auth_compl(unit, m);
! 183: break;
! 184:
! 185: case HCI_EVENT_ENCRYPTION_CHANGE:
! 186: hci_event_encryption_change(unit, m);
! 187: break;
! 188:
! 189: case HCI_EVENT_CHANGE_CON_LINK_KEY_COMPL:
! 190: hci_event_change_con_link_key_compl(unit, m);
! 191: break;
! 192:
! 193: case HCI_EVENT_SCO_CON_COMPL:
! 194: case HCI_EVENT_INQUIRY_COMPL:
! 195: case HCI_EVENT_REMOTE_NAME_REQ_COMPL:
! 196: case HCI_EVENT_MASTER_LINK_KEY_COMPL:
! 197: case HCI_EVENT_READ_REMOTE_FEATURES_COMPL:
! 198: case HCI_EVENT_READ_REMOTE_VER_INFO_COMPL:
! 199: case HCI_EVENT_QOS_SETUP_COMPL:
! 200: case HCI_EVENT_HARDWARE_ERROR:
! 201: case HCI_EVENT_FLUSH_OCCUR:
! 202: case HCI_EVENT_ROLE_CHANGE:
! 203: case HCI_EVENT_MODE_CHANGE:
! 204: case HCI_EVENT_RETURN_LINK_KEYS:
! 205: case HCI_EVENT_PIN_CODE_REQ:
! 206: case HCI_EVENT_LINK_KEY_REQ:
! 207: case HCI_EVENT_LINK_KEY_NOTIFICATION:
! 208: case HCI_EVENT_LOOPBACK_COMMAND:
! 209: case HCI_EVENT_DATA_BUFFER_OVERFLOW:
! 210: case HCI_EVENT_MAX_SLOT_CHANGE:
! 211: case HCI_EVENT_READ_CLOCK_OFFSET_COMPL:
! 212: case HCI_EVENT_CON_PKT_TYPE_CHANGED:
! 213: case HCI_EVENT_QOS_VIOLATION:
! 214: case HCI_EVENT_PAGE_SCAN_MODE_CHANGE:
! 215: case HCI_EVENT_PAGE_SCAN_REP_MODE_CHANGE:
! 216: case HCI_EVENT_FLOW_SPECIFICATION_COMPL:
! 217: case HCI_EVENT_RSSI_RESULT:
! 218: case HCI_EVENT_READ_REMOTE_EXTENDED_FEATURES:
! 219: case HCI_EVENT_SCO_CON_CHANGED:
! 220: case HCI_EVENT_BT_LOGO:
! 221: case HCI_EVENT_VENDOR:
! 222: break;
! 223:
! 224: default:
! 225: UNKNOWN(hdr.event);
! 226: break;
! 227: }
! 228:
! 229: m_freem(m);
! 230: }
! 231:
! 232: /*
! 233: * Command Status
! 234: *
! 235: * Update our record of num_cmd_pkts then post-process any pending commands
! 236: * and optionally restart cmd output on the unit.
! 237: */
! 238: static void
! 239: hci_event_command_status(struct hci_unit *unit, struct mbuf *m)
! 240: {
! 241: hci_command_status_ep ep;
! 242: struct hci_link *link;
! 243:
! 244: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 245: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 246: m_adj(m, sizeof(ep));
! 247:
! 248: DPRINTFN(1, "(%s) opcode (%03x|%04x) status = 0x%x num_cmd_pkts = %d\n",
! 249: unit->hci_devname,
! 250: HCI_OGF(letoh16(ep.opcode)), HCI_OCF(letoh16(ep.opcode)),
! 251: ep.status,
! 252: ep.num_cmd_pkts);
! 253:
! 254: unit->hci_num_cmd_pkts = ep.num_cmd_pkts;
! 255:
! 256: /*
! 257: * post processing of pending commands
! 258: */
! 259: switch(letoh16(ep.opcode)) {
! 260: case HCI_CMD_CREATE_CON:
! 261: switch (ep.status) {
! 262: case 0x12: /* Invalid HCI command parameters */
! 263: DPRINTF("(%s) Invalid HCI command parameters\n",
! 264: unit->hci_devname);
! 265: while ((link = hci_link_lookup_state(unit,
! 266: HCI_LINK_ACL, HCI_LINK_WAIT_CONNECT)) != NULL)
! 267: hci_link_free(link, ECONNABORTED);
! 268: break;
! 269: }
! 270: break;
! 271: default:
! 272: break;
! 273: }
! 274:
! 275: while (unit->hci_num_cmd_pkts > 0 && !IF_IS_EMPTY(&unit->hci_cmdwait)) {
! 276: IF_DEQUEUE(&unit->hci_cmdwait, m);
! 277: hci_output_cmd(unit, m);
! 278: }
! 279: }
! 280:
! 281: /*
! 282: * Command Complete
! 283: *
! 284: * Update our record of num_cmd_pkts then handle the completed command,
! 285: * and optionally restart cmd output on the unit.
! 286: */
! 287: static void
! 288: hci_event_command_compl(struct hci_unit *unit, struct mbuf *m)
! 289: {
! 290: hci_command_compl_ep ep;
! 291:
! 292: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 293: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 294: m_adj(m, sizeof(ep));
! 295:
! 296: DPRINTFN(1, "(%s) opcode (%03x|%04x) num_cmd_pkts = %d\n",
! 297: unit->hci_devname,
! 298: HCI_OGF(letoh16(ep.opcode)), HCI_OCF(letoh16(ep.opcode)),
! 299: ep.num_cmd_pkts);
! 300:
! 301: unit->hci_num_cmd_pkts = ep.num_cmd_pkts;
! 302:
! 303: /*
! 304: * post processing of completed commands
! 305: */
! 306: switch(letoh16(ep.opcode)) {
! 307: case HCI_CMD_READ_BDADDR:
! 308: hci_cmd_read_bdaddr(unit, m);
! 309: break;
! 310:
! 311: case HCI_CMD_READ_BUFFER_SIZE:
! 312: hci_cmd_read_buffer_size(unit, m);
! 313: break;
! 314:
! 315: case HCI_CMD_READ_LOCAL_FEATURES:
! 316: hci_cmd_read_local_features(unit, m);
! 317: break;
! 318:
! 319: case HCI_CMD_RESET:
! 320: hci_cmd_reset(unit, m);
! 321: break;
! 322:
! 323: default:
! 324: break;
! 325: }
! 326:
! 327: while (unit->hci_num_cmd_pkts > 0 && !IF_IS_EMPTY(&unit->hci_cmdwait)) {
! 328: IF_DEQUEUE(&unit->hci_cmdwait, m);
! 329: hci_output_cmd(unit, m);
! 330: }
! 331: }
! 332:
! 333: /*
! 334: * Number of Completed Packets
! 335: *
! 336: * This is sent periodically by the Controller telling us how many
! 337: * buffers are now freed up and which handle was using them. From
! 338: * this we determine which type of buffer it was and add the qty
! 339: * back into the relevant packet counter, then restart output on
! 340: * links that have halted.
! 341: */
! 342: static void
! 343: hci_event_num_compl_pkts(struct hci_unit *unit, struct mbuf *m)
! 344: {
! 345: hci_num_compl_pkts_ep ep;
! 346: struct hci_link *link, *next;
! 347: uint16_t handle, num;
! 348: int num_acl = 0, num_sco = 0;
! 349:
! 350: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 351: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 352: m_adj(m, sizeof(ep));
! 353:
! 354: while (ep.num_con_handles--) {
! 355: m_copydata(m, 0, sizeof(handle), (caddr_t)&handle);
! 356: m_adj(m, sizeof(handle));
! 357: handle = letoh16(handle);
! 358:
! 359: m_copydata(m, 0, sizeof(num), (caddr_t)&num);
! 360: m_adj(m, sizeof(num));
! 361: num = letoh16(num);
! 362:
! 363: link = hci_link_lookup_handle(unit, handle);
! 364: if (link) {
! 365: if (link->hl_type == HCI_LINK_ACL) {
! 366: num_acl += num;
! 367: hci_acl_complete(link, num);
! 368: } else {
! 369: num_sco += num;
! 370: hci_sco_complete(link, num);
! 371: }
! 372: } else {
! 373: /* XXX need to issue Read_Buffer_Size or Reset? */
! 374: printf("%s: unknown handle %d! "
! 375: "(losing track of %d packet buffer%s)\n",
! 376: unit->hci_devname, handle,
! 377: num, (num == 1 ? "" : "s"));
! 378: }
! 379: }
! 380:
! 381: /*
! 382: * Move up any queued packets. When a link has sent data, it will move
! 383: * to the back of the queue - technically then if a link had something
! 384: * to send and there were still buffers available it could get started
! 385: * twice but it seemed more important to to handle higher loads fairly
! 386: * than worry about wasting cycles when we are not busy.
! 387: */
! 388:
! 389: unit->hci_num_acl_pkts += num_acl;
! 390: unit->hci_num_sco_pkts += num_sco;
! 391:
! 392: link = TAILQ_FIRST(&unit->hci_links);
! 393: while (link && (unit->hci_num_acl_pkts > 0 || unit->hci_num_sco_pkts > 0)) {
! 394: next = TAILQ_NEXT(link, hl_next);
! 395:
! 396: if (link->hl_type == HCI_LINK_ACL) {
! 397: if (unit->hci_num_acl_pkts > 0 && link->hl_txqlen > 0)
! 398: hci_acl_start(link);
! 399: } else {
! 400: if (unit->hci_num_sco_pkts > 0 && link->hl_txqlen > 0)
! 401: hci_sco_start(link);
! 402: }
! 403:
! 404: link = next;
! 405: }
! 406: }
! 407:
! 408: /*
! 409: * Inquiry Result
! 410: *
! 411: * keep a note of devices seen, so we know which unit to use
! 412: * on outgoing connections
! 413: */
! 414: static void
! 415: hci_event_inquiry_result(struct hci_unit *unit, struct mbuf *m)
! 416: {
! 417: hci_inquiry_result_ep ep;
! 418: struct hci_memo *memo;
! 419: bdaddr_t bdaddr;
! 420:
! 421: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 422: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 423: m_adj(m, sizeof(ep));
! 424:
! 425: DPRINTFN(1, "%d response%s\n", ep.num_responses,
! 426: (ep.num_responses == 1 ? "" : "s"));
! 427:
! 428: while(ep.num_responses--) {
! 429: m_copydata(m, 0, sizeof(bdaddr_t), (caddr_t)&bdaddr);
! 430:
! 431: DPRINTFN(1, "bdaddr %02x:%02x:%02x:%02x:%02x:%02x\n",
! 432: bdaddr.b[5], bdaddr.b[4], bdaddr.b[3],
! 433: bdaddr.b[2], bdaddr.b[1], bdaddr.b[0]);
! 434:
! 435: memo = hci_memo_find(unit, &bdaddr);
! 436: if (memo == NULL) {
! 437: memo = malloc(sizeof(struct hci_memo),
! 438: M_BLUETOOTH, M_NOWAIT);
! 439: if (memo == NULL) {
! 440: DPRINTFN(0, "out of memo memory!\n");
! 441: break;
! 442: }
! 443: bzero(memo, sizeof *memo);
! 444:
! 445: LIST_INSERT_HEAD(&unit->hci_memos, memo, next);
! 446: }
! 447:
! 448: microtime(&memo->time);
! 449: m_copydata(m, 0, sizeof(hci_inquiry_response),
! 450: (caddr_t)&memo->response);
! 451: m_adj(m, sizeof(hci_inquiry_response));
! 452:
! 453: memo->response.clock_offset =
! 454: letoh16(memo->response.clock_offset);
! 455: }
! 456: }
! 457:
! 458: /*
! 459: * Connection Complete
! 460: *
! 461: * Sent to us when a connection is made. If there is no link
! 462: * structure already allocated for this, we must have changed
! 463: * our mind, so just disconnect.
! 464: */
! 465: static void
! 466: hci_event_con_compl(struct hci_unit *unit, struct mbuf *m)
! 467: {
! 468: hci_con_compl_ep ep;
! 469: hci_write_link_policy_settings_cp cp;
! 470: struct hci_link *link;
! 471: int err;
! 472:
! 473: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 474: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 475: m_adj(m, sizeof(ep));
! 476:
! 477: DPRINTFN(1, "(%s) %s connection complete for "
! 478: "%02x:%02x:%02x:%02x:%02x:%02x status %#x\n",
! 479: unit->hci_devname,
! 480: (ep.link_type == HCI_LINK_ACL ? "ACL" : "SCO"),
! 481: ep.bdaddr.b[5], ep.bdaddr.b[4], ep.bdaddr.b[3],
! 482: ep.bdaddr.b[2], ep.bdaddr.b[1], ep.bdaddr.b[0],
! 483: ep.status);
! 484:
! 485: link = hci_link_lookup_bdaddr(unit, &ep.bdaddr, ep.link_type);
! 486:
! 487: if (ep.status) {
! 488: if (link != NULL) {
! 489: switch (ep.status) {
! 490: case 0x04: /* "Page Timeout" */
! 491: err = EHOSTDOWN;
! 492: break;
! 493:
! 494: case 0x08: /* "Connection Timed Out" */
! 495: case 0x10: /* "Connection Accept Timeout Exceeded" */
! 496: err = ETIMEDOUT;
! 497: break;
! 498:
! 499: case 0x16: /* "Connection Terminated by Local Host" */
! 500: err = 0;
! 501: break;
! 502:
! 503: default:
! 504: err = ECONNREFUSED;
! 505: break;
! 506: }
! 507:
! 508: hci_link_free(link, err);
! 509: }
! 510:
! 511: return;
! 512: }
! 513:
! 514: if (link == NULL) {
! 515: hci_discon_cp dp;
! 516:
! 517: dp.con_handle = ep.con_handle;
! 518: dp.reason = 0x13; /* "Remote User Terminated Connection" */
! 519:
! 520: hci_send_cmd(unit, HCI_CMD_DISCONNECT, &dp, sizeof(dp));
! 521: return;
! 522: }
! 523:
! 524: /* XXX could check auth_enable here */
! 525:
! 526: if (ep.encryption_mode)
! 527: link->hl_flags |= (HCI_LINK_AUTH | HCI_LINK_ENCRYPT);
! 528:
! 529: link->hl_state = HCI_LINK_OPEN;
! 530: link->hl_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
! 531:
! 532: if (ep.link_type == HCI_LINK_ACL) {
! 533: cp.con_handle = ep.con_handle;
! 534: cp.settings = htole16(unit->hci_link_policy);
! 535: err = hci_send_cmd(unit, HCI_CMD_WRITE_LINK_POLICY_SETTINGS,
! 536: &cp, sizeof(cp));
! 537: if (err)
! 538: printf("%s: Warning, could not write link policy\n",
! 539: unit->hci_devname);
! 540:
! 541: err = hci_acl_setmode(link);
! 542: if (err == EINPROGRESS)
! 543: return;
! 544:
! 545: hci_acl_linkmode(link);
! 546: } else {
! 547: (*link->hl_sco->sp_proto->connected)(link->hl_sco->sp_upper);
! 548: }
! 549: }
! 550:
! 551: /*
! 552: * Disconnection Complete
! 553: *
! 554: * This is sent in response to a disconnection request, but also if
! 555: * the remote device goes out of range.
! 556: */
! 557: static void
! 558: hci_event_discon_compl(struct hci_unit *unit, struct mbuf *m)
! 559: {
! 560: hci_discon_compl_ep ep;
! 561: struct hci_link *link;
! 562:
! 563: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 564: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 565: m_adj(m, sizeof(ep));
! 566:
! 567: ep.con_handle = letoh16(ep.con_handle);
! 568:
! 569: DPRINTFN(1, "handle #%d, status=0x%x\n", ep.con_handle, ep.status);
! 570:
! 571: link = hci_link_lookup_handle(unit, HCI_CON_HANDLE(ep.con_handle));
! 572: if (link)
! 573: hci_link_free(link, ENOENT); /* XXX NetBSD used ENOLINK here */
! 574: }
! 575:
! 576: /*
! 577: * Connect Request
! 578: *
! 579: * We check upstream for appropriate listeners and accept connections
! 580: * that are wanted.
! 581: */
! 582: static void
! 583: hci_event_con_req(struct hci_unit *unit, struct mbuf *m)
! 584: {
! 585: hci_con_req_ep ep;
! 586: hci_accept_con_cp ap;
! 587: hci_reject_con_cp rp;
! 588: struct hci_link *link;
! 589:
! 590: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 591: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 592: m_adj(m, sizeof(ep));
! 593:
! 594: DPRINTFN(1, "bdaddr %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
! 595: "class %2.2x%2.2x%2.2x type %s\n",
! 596: ep.bdaddr.b[5], ep.bdaddr.b[4], ep.bdaddr.b[3],
! 597: ep.bdaddr.b[2], ep.bdaddr.b[1], ep.bdaddr.b[0],
! 598: ep.uclass[0], ep.uclass[1], ep.uclass[2],
! 599: ep.link_type == HCI_LINK_ACL ? "ACL" : "SCO");
! 600:
! 601: if (ep.link_type == HCI_LINK_ACL)
! 602: link = hci_acl_newconn(unit, &ep.bdaddr);
! 603: else
! 604: link = hci_sco_newconn(unit, &ep.bdaddr);
! 605:
! 606: if (link == NULL) {
! 607: memset(&rp, 0, sizeof(rp));
! 608: bdaddr_copy(&rp.bdaddr, &ep.bdaddr);
! 609: rp.reason = 0x0f; /* Unacceptable BD_ADDR */
! 610:
! 611: hci_send_cmd(unit, HCI_CMD_REJECT_CON, &rp, sizeof(rp));
! 612: } else {
! 613: memset(&ap, 0, sizeof(ap));
! 614: bdaddr_copy(&ap.bdaddr, &ep.bdaddr);
! 615: if (unit->hci_link_policy & HCI_LINK_POLICY_ENABLE_ROLE_SWITCH)
! 616: ap.role = HCI_ROLE_MASTER;
! 617: else
! 618: ap.role = HCI_ROLE_SLAVE;
! 619:
! 620: hci_send_cmd(unit, HCI_CMD_ACCEPT_CON, &ap, sizeof(ap));
! 621: }
! 622: }
! 623:
! 624: /*
! 625: * Auth Complete
! 626: *
! 627: * Authentication has been completed on an ACL link. We can notify the
! 628: * upper layer protocols unless further mode changes are pending.
! 629: */
! 630: static void
! 631: hci_event_auth_compl(struct hci_unit *unit, struct mbuf *m)
! 632: {
! 633: hci_auth_compl_ep ep;
! 634: struct hci_link *link;
! 635: int err;
! 636:
! 637: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 638: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 639: m_adj(m, sizeof(ep));
! 640:
! 641: ep.con_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
! 642:
! 643: DPRINTFN(1, "handle #%d, status=0x%x\n", ep.con_handle, ep.status);
! 644:
! 645: link = hci_link_lookup_handle(unit, ep.con_handle);
! 646: if (link == NULL || link->hl_type != HCI_LINK_ACL)
! 647: return;
! 648:
! 649: if (ep.status == 0) {
! 650: link->hl_flags |= HCI_LINK_AUTH;
! 651:
! 652: if (link->hl_state == HCI_LINK_WAIT_AUTH)
! 653: link->hl_state = HCI_LINK_OPEN;
! 654:
! 655: err = hci_acl_setmode(link);
! 656: if (err == EINPROGRESS)
! 657: return;
! 658: }
! 659:
! 660: hci_acl_linkmode(link);
! 661: }
! 662:
! 663: /*
! 664: * Encryption Change
! 665: *
! 666: * The encryption status has changed. Basically, we note the change
! 667: * then notify the upper layer protocol unless further mode changes
! 668: * are pending.
! 669: * Note that if encryption gets disabled when it has been requested,
! 670: * we will attempt to enable it again.. (its a feature not a bug :)
! 671: */
! 672: static void
! 673: hci_event_encryption_change(struct hci_unit *unit, struct mbuf *m)
! 674: {
! 675: hci_encryption_change_ep ep;
! 676: struct hci_link *link;
! 677: int err;
! 678:
! 679: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 680: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 681: m_adj(m, sizeof(ep));
! 682:
! 683: ep.con_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
! 684:
! 685: DPRINTFN(1, "handle #%d, status=0x%x, encryption_enable=0x%x\n",
! 686: ep.con_handle, ep.status, ep.encryption_enable);
! 687:
! 688: link = hci_link_lookup_handle(unit, ep.con_handle);
! 689: if (link == NULL || link->hl_type != HCI_LINK_ACL)
! 690: return;
! 691:
! 692: if (ep.status == 0) {
! 693: if (ep.encryption_enable == 0)
! 694: link->hl_flags &= ~HCI_LINK_ENCRYPT;
! 695: else
! 696: link->hl_flags |= (HCI_LINK_AUTH | HCI_LINK_ENCRYPT);
! 697:
! 698: if (link->hl_state == HCI_LINK_WAIT_ENCRYPT)
! 699: link->hl_state = HCI_LINK_OPEN;
! 700:
! 701: err = hci_acl_setmode(link);
! 702: if (err == EINPROGRESS)
! 703: return;
! 704: }
! 705:
! 706: hci_acl_linkmode(link);
! 707: }
! 708:
! 709: /*
! 710: * Change Connection Link Key Complete
! 711: *
! 712: * Link keys are handled in userland but if we are waiting to secure
! 713: * this link, we should notify the upper protocols. A SECURE request
! 714: * only needs a single key change, so we can cancel the request.
! 715: */
! 716: static void
! 717: hci_event_change_con_link_key_compl(struct hci_unit *unit, struct mbuf *m)
! 718: {
! 719: hci_change_con_link_key_compl_ep ep;
! 720: struct hci_link *link;
! 721: int err;
! 722:
! 723: KASSERT(m->m_pkthdr.len >= sizeof(ep));
! 724: m_copydata(m, 0, sizeof(ep), (caddr_t)&ep);
! 725: m_adj(m, sizeof(ep));
! 726:
! 727: ep.con_handle = HCI_CON_HANDLE(letoh16(ep.con_handle));
! 728:
! 729: DPRINTFN(1, "handle #%d, status=0x%x\n", ep.con_handle, ep.status);
! 730:
! 731: link = hci_link_lookup_handle(unit, ep.con_handle);
! 732: if (link == NULL || link->hl_type != HCI_LINK_ACL)
! 733: return;
! 734:
! 735: link->hl_flags &= ~HCI_LINK_SECURE_REQ;
! 736:
! 737: if (ep.status == 0) {
! 738: link->hl_flags |= (HCI_LINK_AUTH | HCI_LINK_SECURE);
! 739:
! 740: if (link->hl_state == HCI_LINK_WAIT_SECURE)
! 741: link->hl_state = HCI_LINK_OPEN;
! 742:
! 743: err = hci_acl_setmode(link);
! 744: if (err == EINPROGRESS)
! 745: return;
! 746: }
! 747:
! 748: hci_acl_linkmode(link);
! 749: }
! 750:
! 751: /*
! 752: * process results of read_bdaddr command_complete event
! 753: */
! 754: static void
! 755: hci_cmd_read_bdaddr(struct hci_unit *unit, struct mbuf *m)
! 756: {
! 757: hci_read_bdaddr_rp rp;
! 758: int s;
! 759:
! 760: KASSERT(m->m_pkthdr.len >= sizeof(rp));
! 761: m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
! 762: m_adj(m, sizeof(rp));
! 763:
! 764: if (rp.status > 0)
! 765: return;
! 766:
! 767: if ((unit->hci_flags & BTF_INIT_BDADDR) == 0)
! 768: return;
! 769:
! 770: bdaddr_copy(&unit->hci_bdaddr, &rp.bdaddr);
! 771:
! 772: s = splraiseipl(unit->hci_ipl);
! 773: unit->hci_flags &= ~BTF_INIT_BDADDR;
! 774: splx(s);
! 775:
! 776: wakeup(unit);
! 777: }
! 778:
! 779: /*
! 780: * process results of read_buffer_size command_complete event
! 781: */
! 782: static void
! 783: hci_cmd_read_buffer_size(struct hci_unit *unit, struct mbuf *m)
! 784: {
! 785: hci_read_buffer_size_rp rp;
! 786: int s;
! 787:
! 788: KASSERT(m->m_pkthdr.len >= sizeof(rp));
! 789: m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
! 790: m_adj(m, sizeof(rp));
! 791:
! 792: if (rp.status > 0)
! 793: return;
! 794:
! 795: if ((unit->hci_flags & BTF_INIT_BUFFER_SIZE) == 0)
! 796: return;
! 797:
! 798: unit->hci_max_acl_size = letoh16(rp.max_acl_size);
! 799: unit->hci_num_acl_pkts = letoh16(rp.num_acl_pkts);
! 800: unit->hci_max_sco_size = rp.max_sco_size;
! 801: unit->hci_num_sco_pkts = letoh16(rp.num_sco_pkts);
! 802:
! 803: s = splraiseipl(unit->hci_ipl);
! 804: unit->hci_flags &= ~BTF_INIT_BUFFER_SIZE;
! 805: splx(s);
! 806:
! 807: wakeup(unit);
! 808: }
! 809:
! 810: /*
! 811: * process results of read_local_features command_complete event
! 812: */
! 813: static void
! 814: hci_cmd_read_local_features(struct hci_unit *unit, struct mbuf *m)
! 815: {
! 816: hci_read_local_features_rp rp;
! 817: int s;
! 818:
! 819: KASSERT(m->m_pkthdr.len >= sizeof(rp));
! 820: m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
! 821: m_adj(m, sizeof(rp));
! 822:
! 823: if (rp.status > 0)
! 824: return;
! 825:
! 826: if ((unit->hci_flags & BTF_INIT_FEATURES) == 0)
! 827: return;
! 828:
! 829: unit->hci_lmp_mask = 0;
! 830:
! 831: if (rp.features[0] & HCI_LMP_ROLE_SWITCH)
! 832: unit->hci_lmp_mask |= HCI_LINK_POLICY_ENABLE_ROLE_SWITCH;
! 833:
! 834: if (rp.features[0] & HCI_LMP_HOLD_MODE)
! 835: unit->hci_lmp_mask |= HCI_LINK_POLICY_ENABLE_HOLD_MODE;
! 836:
! 837: if (rp.features[0] & HCI_LMP_SNIFF_MODE)
! 838: unit->hci_lmp_mask |= HCI_LINK_POLICY_ENABLE_SNIFF_MODE;
! 839:
! 840: if (rp.features[1] & HCI_LMP_PARK_MODE)
! 841: unit->hci_lmp_mask |= HCI_LINK_POLICY_ENABLE_PARK_MODE;
! 842:
! 843: /* ACL packet mask */
! 844: unit->hci_acl_mask = HCI_PKT_DM1 | HCI_PKT_DH1;
! 845:
! 846: if (rp.features[0] & HCI_LMP_3SLOT)
! 847: unit->hci_acl_mask |= HCI_PKT_DM3 | HCI_PKT_DH3;
! 848:
! 849: if (rp.features[0] & HCI_LMP_5SLOT)
! 850: unit->hci_acl_mask |= HCI_PKT_DM5 | HCI_PKT_DH5;
! 851:
! 852: if ((rp.features[3] & HCI_LMP_EDR_ACL_2MBPS) == 0)
! 853: unit->hci_acl_mask |= HCI_PKT_2MBPS_DH1
! 854: | HCI_PKT_2MBPS_DH3
! 855: | HCI_PKT_2MBPS_DH5;
! 856:
! 857: if ((rp.features[3] & HCI_LMP_EDR_ACL_3MBPS) == 0)
! 858: unit->hci_acl_mask |= HCI_PKT_3MBPS_DH1
! 859: | HCI_PKT_3MBPS_DH3
! 860: | HCI_PKT_3MBPS_DH5;
! 861:
! 862: if ((rp.features[4] & HCI_LMP_3SLOT_EDR_ACL) == 0)
! 863: unit->hci_acl_mask |= HCI_PKT_2MBPS_DH3
! 864: | HCI_PKT_3MBPS_DH3;
! 865:
! 866: if ((rp.features[5] & HCI_LMP_5SLOT_EDR_ACL) == 0)
! 867: unit->hci_acl_mask |= HCI_PKT_2MBPS_DH5
! 868: | HCI_PKT_3MBPS_DH5;
! 869:
! 870: unit->hci_packet_type = unit->hci_acl_mask;
! 871:
! 872: /* SCO packet mask */
! 873: unit->hci_sco_mask = 0;
! 874: if (rp.features[1] & HCI_LMP_SCO_LINK)
! 875: unit->hci_sco_mask |= HCI_PKT_HV1;
! 876:
! 877: if (rp.features[1] & HCI_LMP_HV2_PKT)
! 878: unit->hci_sco_mask |= HCI_PKT_HV2;
! 879:
! 880: if (rp.features[1] & HCI_LMP_HV3_PKT)
! 881: unit->hci_sco_mask |= HCI_PKT_HV3;
! 882:
! 883: if (rp.features[3] & HCI_LMP_EV3_PKT)
! 884: unit->hci_sco_mask |= HCI_PKT_EV3;
! 885:
! 886: if (rp.features[4] & HCI_LMP_EV4_PKT)
! 887: unit->hci_sco_mask |= HCI_PKT_EV4;
! 888:
! 889: if (rp.features[4] & HCI_LMP_EV5_PKT)
! 890: unit->hci_sco_mask |= HCI_PKT_EV5;
! 891:
! 892: /* XXX what do 2MBPS/3MBPS/3SLOT eSCO mean? */
! 893:
! 894: s = splraiseipl(unit->hci_ipl);
! 895: unit->hci_flags &= ~BTF_INIT_FEATURES;
! 896: splx(s);
! 897:
! 898: wakeup(unit);
! 899:
! 900: DPRINTFN(1, "%s: lmp_mask %4.4x, acl_mask %4.4x, sco_mask %4.4x\n",
! 901: unit->hci_devname, unit->hci_lmp_mask,
! 902: unit->hci_acl_mask, unit->hci_sco_mask);
! 903: }
! 904:
! 905: /*
! 906: * process results of reset command_complete event
! 907: *
! 908: * This has killed all the connections, so close down anything we have left,
! 909: * and reinitialise the unit.
! 910: */
! 911: static void
! 912: hci_cmd_reset(struct hci_unit *unit, struct mbuf *m)
! 913: {
! 914: hci_reset_rp rp;
! 915: struct hci_link *link, *next;
! 916: int acl;
! 917:
! 918: KASSERT(m->m_pkthdr.len >= sizeof(rp));
! 919: m_copydata(m, 0, sizeof(rp), (caddr_t)&rp);
! 920: m_adj(m, sizeof(rp));
! 921:
! 922: if (rp.status != 0)
! 923: return;
! 924:
! 925: /*
! 926: * release SCO links first, since they may be holding
! 927: * an ACL link reference.
! 928: */
! 929: for (acl = 0 ; acl < 2 ; acl++) {
! 930: next = TAILQ_FIRST(&unit->hci_links);
! 931: while ((link = next) != NULL) {
! 932: next = TAILQ_NEXT(link, hl_next);
! 933: if (acl || link->hl_type != HCI_LINK_ACL)
! 934: hci_link_free(link, ECONNABORTED);
! 935: }
! 936: }
! 937:
! 938: unit->hci_num_acl_pkts = 0;
! 939: unit->hci_num_sco_pkts = 0;
! 940:
! 941: if (hci_send_cmd(unit, HCI_CMD_READ_BDADDR, NULL, 0))
! 942: return;
! 943:
! 944: if (hci_send_cmd(unit, HCI_CMD_READ_BUFFER_SIZE, NULL, 0))
! 945: return;
! 946:
! 947: if (hci_send_cmd(unit, HCI_CMD_READ_LOCAL_FEATURES, NULL, 0))
! 948: return;
! 949: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to hci_event.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netbt