monitor/packet.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2011-2014  Intel Corporation
   6  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
   7  *
   8  *
   9  *  This library is free software; you can redistribute it and/or
  10  *  modify it under the terms of the GNU Lesser General Public
  11  *  License as published by the Free Software Foundation; either
  12  *  version 2.1 of the License, or (at your option) any later version.
  13  *
  14  *  This library is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  Lesser General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU Lesser General Public
  20  *  License along with this library; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <ctype.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <stdbool.h>
  36 #include <inttypes.h>
  37 #include <time.h>
  38 #include <sys/time.h>
  39 #include <sys/socket.h>
  40
  41 #include "lib/bluetooth.h"
  42 #include "lib/hci.h"
  43 #include "lib/hci_lib.h"
  44
  45 #include "src/shared/util.h"
  46 #include "src/shared/btsnoop.h"
  47 #include "display.h"
  48 #include "bt.h"
  49 #include "ll.h"
  50 #include "hwdb.h"
  51 #include "keys.h"
  52 #include "uuid.h"
  53 #include "l2cap.h"
  54 #include "control.h"
  55 #include "vendor.h"
  56 #include "intel.h"
  57 #include "broadcom.h"
  58 #include "packet.h"
  59
  60 #define COLOR_INDEX_LABEL               COLOR_WHITE
  61 #define COLOR_TIMESTAMP                 COLOR_YELLOW
  62
  63 #define COLOR_NEW_INDEX                 COLOR_GREEN
  64 #define COLOR_DEL_INDEX                 COLOR_RED
  65 #define COLOR_OPEN_INDEX                COLOR_GREEN
  66 #define COLOR_CLOSE_INDEX               COLOR_RED
  67 #define COLOR_INDEX_INFO                COLOR_GREEN
  68 #define COLOR_VENDOR_DIAG               COLOR_YELLOW
  69
  70 #define COLOR_HCI_COMMAND               COLOR_BLUE
  71 #define COLOR_HCI_COMMAND_UNKNOWN       COLOR_WHITE_BG
  72
  73 #define COLOR_HCI_EVENT                 COLOR_MAGENTA
  74 #define COLOR_HCI_EVENT_UNKNOWN         COLOR_WHITE_BG
  75
  76 #define COLOR_HCI_ACLDATA               COLOR_CYAN
  77 #define COLOR_HCI_SCODATA               COLOR_YELLOW
  78
  79 #define COLOR_UNKNOWN_ERROR             COLOR_WHITE_BG
  80 #define COLOR_UNKNOWN_FEATURE_BIT       COLOR_WHITE_BG
  81 #define COLOR_UNKNOWN_COMMAND_BIT       COLOR_WHITE_BG
  82 #define COLOR_UNKNOWN_EVENT_MASK        COLOR_WHITE_BG
  83 #define COLOR_UNKNOWN_LE_STATES         COLOR_WHITE_BG
  84 #define COLOR_UNKNOWN_SERVICE_CLASS     COLOR_WHITE_BG
  85 #define COLOR_UNKNOWN_PKT_TYPE_BIT      COLOR_WHITE_BG
  86
  87 #define COLOR_PHY_PACKET                COLOR_BLUE
  88
  89 static time_t time_offset = ((time_t) -1);
  90 static int priority_level = BTSNOOP_PRIORITY_INFO;
  91 static unsigned long filter_mask = 0;
  92 static bool index_filter = false;
  93 static uint16_t index_number = 0;
  94 static uint16_t index_current = 0;
  95
  96 #define UNKNOWN_MANUFACTURER 0xffff
  97
  98 #define MAX_CONN 16
  99
 100 struct conn_data {
 101         uint16_t handle;
 102         uint8_t  type;
 103 };
 104
 105 static struct conn_data conn_list[MAX_CONN];
 106
 107 static void assign_handle(uint16_t handle, uint8_t type)
 108 {
 109         int i;
 110
 111         for (i = 0; i < MAX_CONN; i++) {
 112                 if (conn_list[i].handle == 0x0000) {
 113                         conn_list[i].handle = handle;
 114                         conn_list[i].type = type;
 115                         break;
 116                 }
 117         }
 118 }
 119
 120 static void release_handle(uint16_t handle)
 121 {
 122         int i;
 123
 124         for (i = 0; i < MAX_CONN; i++) {
 125                 if (conn_list[i].handle == handle) {
 126                         conn_list[i].handle = 0x0000;
 127                         conn_list[i].type = 0x00;
 128                         break;
 129                 }
 130         }
 131 }
 132
 133 static uint8_t get_type(uint16_t handle)
 134 {
 135         int i;
 136
 137         for (i = 0; i < MAX_CONN; i++) {
 138                 if (conn_list[i].handle == handle)
 139                         return conn_list[i].type;
 140         }
 141
 142         return 0xff;
 143 }
 144
 145 void packet_set_filter(unsigned long filter)
 146 {
 147         filter_mask = filter;
 148 }
 149
 150 void packet_add_filter(unsigned long filter)
 151 {
 152         if (index_filter)
 153                 filter &= ~PACKET_FILTER_SHOW_INDEX;
 154
 155         filter_mask |= filter;
 156 }
 157
 158 void packet_del_filter(unsigned long filter)
 159 {
 160         filter_mask &= ~filter;
 161 }
 162
 163 void packet_set_priority(const char *priority)
 164 {
 165         if (!priority)
 166                 return;
 167
 168         if (!strcasecmp(priority, "debug"))
 169                 priority_level = BTSNOOP_PRIORITY_DEBUG;
 170         else
 171                 priority_level = atoi(priority);
 172 }
 173
 174 void packet_select_index(uint16_t index)
 175 {
 176         filter_mask &= ~PACKET_FILTER_SHOW_INDEX;
 177
 178         index_filter = true;
 179         index_number = index;
 180 }
 181
 182 #define print_space(x) printf("%*c", (x), ' ');
 183
 184 static void print_packet(struct timeval *tv, struct ucred *cred,
 185                                         uint16_t index, char ident,
 186                                         const char *color, const char *label,
 187                                         const char *text, const char *extra)
 188 {
 189         int col = num_columns();
 190         char line[256], ts_str[64];
 191         int n, ts_len = 0, ts_pos = 0, len = 0, pos = 0;
 192
 193         if ((filter_mask & PACKET_FILTER_SHOW_INDEX) &&
 194                                         index != HCI_DEV_NONE) {
 195                 if (use_color()) {
 196                         n = sprintf(ts_str + ts_pos, "%s", COLOR_INDEX_LABEL);
 197                         if (n > 0)
 198                                 ts_pos += n;
 199                 }
 200
 201                 n = sprintf(ts_str + ts_pos, " [hci%d]", index);
 202                 if (n > 0) {
 203                         ts_pos += n;
 204                         ts_len += n;
 205                 }
 206         }
 207
 208         if (tv) {
 209                 time_t t = tv->tv_sec;
 210                 struct tm tm;
 211
 212                 localtime_r(&t, &tm);
 213
 214                 if (use_color()) {
 215                         n = sprintf(ts_str + ts_pos, "%s", COLOR_TIMESTAMP);
 216                         if (n > 0)
 217                                 ts_pos += n;
 218                 }
 219
 220                 if (filter_mask & PACKET_FILTER_SHOW_DATE) {
 221                         n = sprintf(ts_str + ts_pos, " %04d-%02d-%02d",
 222                                 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
 223                         if (n > 0) {
 224                                 ts_pos += n;
 225                                 ts_len += n;
 226                         }
 227                 }
 228
 229                 if (filter_mask & PACKET_FILTER_SHOW_TIME) {
 230                         n = sprintf(ts_str + ts_pos, " %02d:%02d:%02d.%06lu",
 231                                 tm.tm_hour, tm.tm_min, tm.tm_sec, tv->tv_usec);
 232                         if (n > 0) {
 233                                 ts_pos += n;
 234                                 ts_len += n;
 235                         }
 236                 }
 237
 238                 if (filter_mask & PACKET_FILTER_SHOW_TIME_OFFSET) {
 239                         n = sprintf(ts_str + ts_pos, " %lu.%06lu",
 240                                         tv->tv_sec - time_offset, tv->tv_usec);
 241                         if (n > 0) {
 242                                 ts_pos += n;
 243                                 ts_len += n;
 244                         }
 245                 }
 246         }
 247
 248         if (use_color()) {
 249                 n = sprintf(ts_str + ts_pos, "%s", COLOR_OFF);
 250                 if (n > 0)
 251                         ts_pos += n;
 252         }
 253
 254         if (use_color()) {
 255                 n = sprintf(line + pos, "%s", color);
 256                 if (n > 0)
 257                         pos += n;
 258         }
 259
 260         n = sprintf(line + pos, "%c %s", ident, label ? label : "");
 261         if (n > 0) {
 262                 pos += n;
 263                 len += n;
 264         }
 265
 266         if (text) {
 267                 int extra_len = extra ? strlen(extra) : 0;
 268                 int max_len = col - len - extra_len - ts_len - 3;
 269
 270                 n = snprintf(line + pos, max_len + 1, "%s%s",
 271                                                 label ? ": " : "", text);
 272                 if (n > max_len) {
 273                         line[pos + max_len - 1] = '.';
 274                         line[pos + max_len - 2] = '.';
 275                         if (line[pos + max_len - 3] == ' ')
 276                                 line[pos + max_len - 3] = '.';
 277
 278                         n = max_len;
 279                 }
 280
 281                 if (n > 0) {
 282                         pos += n;
 283                         len += n;
 284                 }
 285         }
 286
 287         if (use_color()) {
 288                 n = sprintf(line + pos, "%s", COLOR_OFF);
 289                 if (n > 0)
 290                         pos += n;
 291         }
 292
 293         if (extra) {
 294                 n = sprintf(line + pos, " %s", extra);
 295                 if (n > 0) {
 296                         pos += n;
 297                         len += n;
 298                 }
 299         }
 300
 301         if (ts_len > 0) {
 302                 printf("%s", line);
 303                 if (len < col)
 304                         print_space(col - len - ts_len - 1);
 305                 printf("%s%s\n", use_color() ? COLOR_TIMESTAMP : "", ts_str);
 306         } else
 307                 printf("%s\n", line);
 308 }
 309
 310 static const struct {
 311         uint8_t error;
 312         const char *str;
 313 } error2str_table[] = {
 314         { 0x00, "Success"                                               },
 315         { 0x01, "Unknown HCI Command"                                   },
 316         { 0x02, "Unknown Connection Identifier"                         },
 317         { 0x03, "Hardware Failure"                                      },
 318         { 0x04, "Page Timeout"                                          },
 319         { 0x05, "Authentication Failure"                                },
 320         { 0x06, "PIN or Key Missing"                                    },
 321         { 0x07, "Memory Capacity Exceeded"                              },
 322         { 0x08, "Connection Timeout"                                    },
 323         { 0x09, "Connection Limit Exceeded"                             },
 324         { 0x0a, "Synchronous Connection Limit to a Device Exceeded"     },
 325         { 0x0b, "ACL Connection Already Exists"                         },
 326         { 0x0c, "Command Disallowed"                                    },
 327         { 0x0d, "Connection Rejected due to Limited Resources"          },
 328         { 0x0e, "Connection Rejected due to Security Reasons"           },
 329         { 0x0f, "Connection Rejected due to Unacceptable BD_ADDR"       },
 330         { 0x10, "Connection Accept Timeout Exceeded"                    },
 331         { 0x11, "Unsupported Feature or Parameter Value"                },
 332         { 0x12, "Invalid HCI Command Parameters"                        },
 333         { 0x13, "Remote User Terminated Connection"                     },
 334         { 0x14, "Remote Device Terminated due to Low Resources"         },
 335         { 0x15, "Remote Device Terminated due to Power Off"             },
 336         { 0x16, "Connection Terminated By Local Host"                   },
 337         { 0x17, "Repeated Attempts"                                     },
 338         { 0x18, "Pairing Not Allowed"                                   },
 339         { 0x19, "Unknown LMP PDU"                                       },
 340         { 0x1a, "Unsupported Remote Feature / Unsupported LMP Feature"  },
 341         { 0x1b, "SCO Offset Rejected"                                   },
 342         { 0x1c, "SCO Interval Rejected"                                 },
 343         { 0x1d, "SCO Air Mode Rejected"                                 },
 344         { 0x1e, "Invalid LMP Parameters / Invalid LL Parameters"        },
 345         { 0x1f, "Unspecified Error"                                     },
 346         { 0x20, "Unsupported LMP Parameter Value / "
 347                 "Unsupported LL Parameter Value"                        },
 348         { 0x21, "Role Change Not Allowed"                               },
 349         { 0x22, "LMP Response Timeout / LL Response Timeout"            },
 350         { 0x23, "LMP Error Transaction Collision"                       },
 351         { 0x24, "LMP PDU Not Allowed"                                   },
 352         { 0x25, "Encryption Mode Not Acceptable"                        },
 353         { 0x26, "Link Key cannot be Changed"                            },
 354         { 0x27, "Requested QoS Not Supported"                           },
 355         { 0x28, "Instant Passed"                                        },
 356         { 0x29, "Pairing With Unit Key Not Supported"                   },
 357         { 0x2a, "Different Transaction Collision"                       },
 358         { 0x2b, "Reserved"                                              },
 359         { 0x2c, "QoS Unacceptable Parameter"                            },
 360         { 0x2d, "QoS Rejected"                                          },
 361         { 0x2e, "Channel Classification Not Supported"                  },
 362         { 0x2f, "Insufficient Security"                                 },
 363         { 0x30, "Parameter Out Of Manadatory Range"                     },
 364         { 0x31, "Reserved"                                              },
 365         { 0x32, "Role Switch Pending"                                   },
 366         { 0x33, "Reserved"                                              },
 367         { 0x34, "Reserved Slot Violation"                               },
 368         { 0x35, "Role Switch Failed"                                    },
 369         { 0x36, "Extended Inquiry Response Too Large"                   },
 370         { 0x37, "Secure Simple Pairing Not Supported By Host"           },
 371         { 0x38, "Host Busy - Pairing"                                   },
 372         { 0x39, "Connection Rejected due to No Suitable Channel Found"  },
 373         { 0x3a, "Controller Busy"                                       },
 374         { 0x3b, "Unacceptable Connection Parameters"                    },
 375         { 0x3c, "Directed Advertising Timeout"                          },
 376         { 0x3d, "Connection Terminated due to MIC Failure"              },
 377         { 0x3e, "Connection Failed to be Established"                   },
 378         { 0x3f, "MAC Connection Failed"                                 },
 379         { 0x40, "Coarse Clock Adjustment Rejected "
 380                 "but Will Try to Adjust Using Clock Dragging"           },
 381         { }
 382 };
 383
 384 static void print_error(const char *label, uint8_t error)
 385 {
 386         const char *str = "Unknown";
 387         const char *color_on, *color_off;
 388         bool unknown = true;
 389         int i;
 390
 391         for (i = 0; error2str_table[i].str; i++) {
 392                 if (error2str_table[i].error == error) {
 393                         str = error2str_table[i].str;
 394                         unknown = false;
 395                         break;
 396                 }
 397         }
 398
 399         if (use_color()) {
 400                 if (error) {
 401                         if (unknown)
 402                                 color_on = COLOR_UNKNOWN_ERROR;
 403                         else
 404                                 color_on = COLOR_RED;
 405                 } else
 406                         color_on = COLOR_GREEN;
 407                 color_off = COLOR_OFF;
 408         } else {
 409                 color_on = "";
 410                 color_off = "";
 411         }
 412
 413         print_field("%s: %s%s%s (0x%2.2x)", label,
 414                                 color_on, str, color_off, error);
 415 }
 416
 417 static void print_status(uint8_t status)
 418 {
 419         print_error("Status", status);
 420 }
 421
 422 static void print_reason(uint8_t reason)
 423 {
 424         print_error("Reason", reason);
 425 }
 426
 427 void packet_print_error(const char *label, uint8_t error)
 428 {
 429         print_error(label, error);
 430 }
 431
 432 static void print_addr_type(const char *label, uint8_t addr_type)
 433 {
 434         const char *str;
 435
 436         switch (addr_type) {
 437         case 0x00:
 438                 str = "Public";
 439                 break;
 440         case 0x01:
 441                 str = "Random";
 442                 break;
 443         default:
 444                 str = "Reserved";
 445                 break;
 446         }
 447
 448         print_field("%s: %s (0x%2.2x)", label, str, addr_type);
 449 }
 450
 451 static void print_own_addr_type(uint8_t addr_type)
 452 {
 453         const char *str;
 454
 455         switch (addr_type) {
 456         case 0x00:
 457         case 0x02:
 458                 str = "Public";
 459                 break;
 460         case 0x01:
 461         case 0x03:
 462                 str = "Random";
 463                 break;
 464         default:
 465                 str = "Reserved";
 466                 break;
 467         }
 468
 469         print_field("Own address type: %s (0x%2.2x)", str, addr_type);
 470 }
 471
 472 static void print_peer_addr_type(const char *label, uint8_t addr_type)
 473 {
 474         const char *str;
 475
 476         switch (addr_type) {
 477         case 0x00:
 478                 str = "Public";
 479                 break;
 480         case 0x01:
 481                 str = "Random";
 482                 break;
 483         case 0x02:
 484                 str = "Resolved Public";
 485                 break;
 486         case 0x03:
 487                 str = "Resolved Random";
 488                 break;
 489         default:
 490                 str = "Reserved";
 491                 break;
 492         }
 493
 494         print_field("%s: %s (0x%2.2x)", label, str, addr_type);
 495 }
 496
 497 static void print_addr_resolve(const char *label, const uint8_t *addr,
 498                                         uint8_t addr_type, bool resolve)
 499 {
 500         const char *str;
 501         char *company;
 502
 503         switch (addr_type) {
 504         case 0x00:
 505         case 0x02:
 506                 if (!hwdb_get_company(addr, &company))
 507                         company = NULL;
 508
 509                 if (company) {
 510                         print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 511                                         " (%s)", label, addr[5], addr[4],
 512                                                         addr[3], addr[2],
 513                                                         addr[1], addr[0],
 514                                                         company);
 515                         free(company);
 516                 } else {
 517                         print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 518                                         " (OUI %2.2X-%2.2X-%2.2X)", label,
 519                                                 addr[5], addr[4], addr[3],
 520                                                 addr[2], addr[1], addr[0],
 521                                                 addr[5], addr[4], addr[3]);
 522                 }
 523                 break;
 524         case 0x01:
 525         case 0x03:
 526                 switch ((addr[5] & 0xc0) >> 6) {
 527                 case 0x00:
 528                         str = "Non-Resolvable";
 529                         break;
 530                 case 0x01:
 531                         str = "Resolvable";
 532                         break;
 533                 case 0x03:
 534                         str = "Static";
 535                         break;
 536                 default:
 537                         str = "Reserved";
 538                         break;
 539                 }
 540
 541                 print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X (%s)",
 542                                         label, addr[5], addr[4], addr[3],
 543                                         addr[2], addr[1], addr[0], str);
 544
 545                 if (resolve && (addr[5] & 0xc0) == 0x40) {
 546                         uint8_t ident[6], ident_type;
 547
 548                         if (keys_resolve_identity(addr, ident, &ident_type)) {
 549                                 print_addr_type("  Identity type", ident_type);
 550                                 print_addr_resolve("  Identity", ident,
 551                                                         ident_type, false);
 552                         }
 553                 }
 554                 break;
 555         default:
 556                 print_field("%s: %2.2X-%2.2X-%2.2X-%2.2X-%2.2X-%2.2X",
 557                                         label, addr[5], addr[4], addr[3],
 558                                         addr[2], addr[1], addr[0]);
 559                 break;
 560         }
 561 }
 562
 563 static void print_addr(const char *label, const uint8_t *addr,
 564                                                 uint8_t addr_type)
 565 {
 566         print_addr_resolve(label, addr, addr_type, true);
 567 }
 568
 569 static void print_bdaddr(const uint8_t *bdaddr)
 570 {
 571         print_addr("Address", bdaddr, 0x00);
 572 }
 573
 574 static void print_lt_addr(uint8_t lt_addr)
 575 {
 576         print_field("LT address: %d", lt_addr);
 577 }
 578
 579 static void print_handle(uint16_t handle)
 580 {
 581         print_field("Handle: %d", le16_to_cpu(handle));
 582 }
 583
 584 static void print_phy_handle(uint8_t phy_handle)
 585 {
 586         print_field("Physical handle: %d", phy_handle);
 587 }
 588
 589 static const struct {
 590         uint8_t bit;
 591         const char *str;
 592 } pkt_type_table[] = {
 593         {  1, "2-DH1 may not be used"   },
 594         {  2, "3-DH1 may not be used"   },
 595         {  3, "DM1 may be used"         },
 596         {  4, "DH1 may be used"         },
 597         {  8, "2-DH3 may not be used"   },
 598         {  9, "3-DH3 may not be used"   },
 599         { 10, "DM3 may be used"         },
 600         { 11, "DH3 may be used"         },
 601         { 12, "3-DH5 may not be used"   },
 602         { 13, "3-DH5 may not be used"   },
 603         { 14, "DM5 may be used"         },
 604         { 15, "DH5 may be used"         },
 605         { }
 606 };
 607
 608 static void print_pkt_type(uint16_t pkt_type)
 609 {
 610         uint16_t mask;
 611         int i;
 612
 613         print_field("Packet type: 0x%4.4x", le16_to_cpu(pkt_type));
 614
 615         mask = le16_to_cpu(pkt_type);
 616
 617         for (i = 0; pkt_type_table[i].str; i++) {
 618                 if (le16_to_cpu(pkt_type) & (1 << pkt_type_table[i].bit)) {
 619                         print_field("  %s", pkt_type_table[i].str);
 620                         mask &= ~(1 << pkt_type_table[i].bit);
 621                 }
 622         }
 623
 624         if (mask)
 625                 print_text(COLOR_UNKNOWN_PKT_TYPE_BIT,
 626                                 "  Unknown packet types (0x%4.4x)", mask);
 627 }
 628
 629 static const struct {
 630         uint8_t bit;
 631         const char *str;
 632 } pkt_type_sco_table[] = {
 633         {  0, "HV1 may be used"         },
 634         {  1, "HV2 may be used"         },
 635         {  2, "HV3 may be used"         },
 636         {  3, "EV3 may be used"         },
 637         {  4, "EV4 may be used"         },
 638         {  5, "EV5 may be used"         },
 639         {  6, "2-EV3 may not be used"   },
 640         {  7, "3-EV3 may not be used"   },
 641         {  8, "2-EV5 may not be used"   },
 642         {  9, "3-EV5 may not be used"   },
 643         { }
 644 };
 645
 646 static void print_pkt_type_sco(uint16_t pkt_type)
 647 {
 648         uint16_t mask;
 649         int i;
 650
 651         print_field("Packet type: 0x%4.4x", le16_to_cpu(pkt_type));
 652
 653         mask = le16_to_cpu(pkt_type);
 654
 655         for (i = 0; pkt_type_sco_table[i].str; i++) {
 656                 if (le16_to_cpu(pkt_type) & (1 << pkt_type_sco_table[i].bit)) {
 657                         print_field("  %s", pkt_type_sco_table[i].str);
 658                         mask &= ~(1 << pkt_type_sco_table[i].bit);
 659                 }
 660         }
 661
 662         if (mask)
 663                 print_text(COLOR_UNKNOWN_PKT_TYPE_BIT,
 664                                 "  Unknown packet types (0x%4.4x)", mask);
 665 }
 666
 667 static void print_iac(const uint8_t *lap)
 668 {
 669         const char *str = "";
 670
 671         if (lap[2] == 0x9e && lap[1] == 0x8b) {
 672                 switch (lap[0]) {
 673                 case 0x33:
 674                         str = " (General Inquiry)";
 675                         break;
 676                 case 0x00:
 677                         str = " (Limited Inquiry)";
 678                         break;
 679                 }
 680         }
 681
 682         print_field("Access code: 0x%2.2x%2.2x%2.2x%s",
 683                                                 lap[2], lap[1], lap[0], str);
 684 }
 685
 686 static void print_auth_enable(uint8_t enable)
 687 {
 688         const char *str;
 689
 690         switch (enable) {
 691         case 0x00:
 692                 str = "Authentication not required";
 693                 break;
 694         case 0x01:
 695                 str = "Authentication required for all connections";
 696                 break;
 697         default:
 698                 str = "Reserved";
 699                 break;
 700         }
 701
 702         print_field("Enable: %s (0x%2.2x)", str, enable);
 703 }
 704
 705 static void print_encrypt_mode(uint8_t mode)
 706 {
 707         const char *str;
 708
 709         switch (mode) {
 710         case 0x00:
 711                 str = "Encryption not required";
 712                 break;
 713         case 0x01:
 714                 str = "Encryption required for all connections";
 715                 break;
 716         default:
 717                 str = "Reserved";
 718                 break;
 719         }
 720
 721         print_field("Mode: %s (0x%2.2x)", str, mode);
 722 }
 723
 724 static const struct {
 725         uint8_t bit;
 726         const char *str;
 727 } svc_class_table[] = {
 728         { 0, "Positioning (Location identification)"            },
 729         { 1, "Networking (LAN, Ad hoc)"                         },
 730         { 2, "Rendering (Printing, Speaker)"                    },
 731         { 3, "Capturing (Scanner, Microphone)"                  },
 732         { 4, "Object Transfer (v-Inbox, v-Folder)"              },
 733         { 5, "Audio (Speaker, Microphone, Headset)"             },
 734         { 6, "Telephony (Cordless telephony, Modem, Headset)"   },
 735         { 7, "Information (WEB-server, WAP-server)"             },
 736         { }
 737 };
 738
 739 static const struct {
 740         uint8_t val;
 741         const char *str;
 742 } major_class_computer_table[] = {
 743         { 0x00, "Uncategorized, code for device not assigned"   },
 744         { 0x01, "Desktop workstation"                           },
 745         { 0x02, "Server-class computer"                         },
 746         { 0x03, "Laptop"                                        },
 747         { 0x04, "Handheld PC/PDA (clam shell)"                  },
 748         { 0x05, "Palm sized PC/PDA"                             },
 749         { 0x06, "Wearable computer (Watch sized)"               },
 750         { 0x07, "Tablet"                                        },
 751         { }
 752 };
 753
 754 static const char *major_class_computer(uint8_t minor)
 755 {
 756         int i;
 757
 758         for (i = 0; major_class_computer_table[i].str; i++) {
 759                 if (major_class_computer_table[i].val == minor)
 760                         return major_class_computer_table[i].str;
 761         }
 762
 763         return NULL;
 764 }
 765
 766 static const struct {
 767         uint8_t val;
 768         const char *str;
 769 } major_class_phone_table[] = {
 770         { 0x00, "Uncategorized, code for device not assigned"   },
 771         { 0x01, "Cellular"                                      },
 772         { 0x02, "Cordless"                                      },
 773         { 0x03, "Smart phone"                                   },
 774         { 0x04, "Wired modem or voice gateway"                  },
 775         { 0x05, "Common ISDN Access"                            },
 776         { }
 777 };
 778
 779 static const char *major_class_phone(uint8_t minor)
 780 {
 781         int i;
 782
 783         for (i = 0; major_class_phone_table[i].str; i++) {
 784                 if (major_class_phone_table[i].val == minor)
 785                         return major_class_phone_table[i].str;
 786         }
 787
 788         return NULL;
 789 }
 790
 791 static const struct {
 792         uint8_t val;
 793         const char *str;
 794 } major_class_av_table[] = {
 795         { 0x00, "Uncategorized, code for device not assigned"   },
 796         { 0x01, "Wearable Headset Device"                       },
 797         { 0x02, "Hands-free Device"                             },
 798         { 0x04, "Microphone"                                    },
 799         { 0x05, "Loudspeaker"                                   },
 800         { 0x06, "Headphones"                                    },
 801         { 0x07, "Portable Audio"                                },
 802         { 0x08, "Car audio"                                     },
 803         { 0x09, "Set-top box"                                   },
 804         { 0x0a, "HiFi Audio Device"                             },
 805         { 0x0b, "VCR"                                           },
 806         { 0x0c, "Video Camera"                                  },
 807         { 0x0d, "Camcorder"                                     },
 808         { 0x0e, "Video Monitor"                                 },
 809         { 0x0f, "Video Display and Loudspeaker"                 },
 810         { 0x10, "Video Conferencing"                            },
 811         { 0x12, "Gaming/Toy"                                    },
 812         { }
 813 };
 814
 815 static const char *major_class_av(uint8_t minor)
 816 {
 817         int i;
 818
 819         for (i = 0; major_class_av_table[i].str; i++) {
 820                 if (major_class_av_table[i].val == minor)
 821                         return major_class_av_table[i].str;
 822         }
 823
 824         return NULL;
 825 }
 826
 827 static const struct {
 828         uint8_t val;
 829         const char *str;
 830 } major_class_wearable_table[] = {
 831         { 0x01, "Wrist Watch"   },
 832         { 0x02, "Pager"         },
 833         { 0x03, "Jacket"        },
 834         { 0x04, "Helmet"        },
 835         { 0x05, "Glasses"       },
 836         { }
 837 };
 838
 839 static const char *major_class_wearable(uint8_t minor)
 840 {
 841         int i;
 842
 843         for (i = 0; major_class_wearable_table[i].str; i++) {
 844                 if (major_class_wearable_table[i].val == minor)
 845                         return major_class_wearable_table[i].str;
 846         }
 847
 848         return NULL;
 849 }
 850
 851 static const struct {
 852         uint8_t val;
 853         const char *str;
 854         const char *(*func)(uint8_t minor);
 855 } major_class_table[] = {
 856         { 0x00, "Miscellaneous"                                         },
 857         { 0x01, "Computer (desktop, notebook, PDA, organizers)",
 858                                                 major_class_computer    },
 859         { 0x02, "Phone (cellular, cordless, payphone, modem)",
 860                                                 major_class_phone       },
 861         { 0x03, "LAN /Network Access point"                             },
 862         { 0x04, "Audio/Video (headset, speaker, stereo, video, vcr)",
 863                                                 major_class_av          },
 864         { 0x05, "Peripheral (mouse, joystick, keyboards)"               },
 865         { 0x06, "Imaging (printing, scanner, camera, display)"          },
 866         { 0x07, "Wearable",                     major_class_wearable    },
 867         { 0x08, "Toy"                                                   },
 868         { 0x09, "Health"                                                },
 869         { 0x1f, "Uncategorized, specific device code not specified"     },
 870         { }
 871 };
 872
 873 static void print_dev_class(const uint8_t *dev_class)
 874 {
 875         uint8_t mask, major_cls, minor_cls;
 876         const char *major_str = NULL;
 877         const char *minor_str = NULL;
 878         int i;
 879
 880         print_field("Class: 0x%2.2x%2.2x%2.2x",
 881                         dev_class[2], dev_class[1], dev_class[0]);
 882
 883         if ((dev_class[0] & 0x03) != 0x00) {
 884                 print_field("  Format type: 0x%2.2x", dev_class[0] & 0x03);
 885                 print_text(COLOR_ERROR, "  invalid format type");
 886                 return;
 887         }
 888
 889         major_cls = dev_class[1] & 0x1f;
 890         minor_cls = (dev_class[0] & 0xfc) >> 2;
 891
 892         for (i = 0; major_class_table[i].str; i++) {
 893                 if (major_class_table[i].val == major_cls) {
 894                         major_str = major_class_table[i].str;
 895
 896                         if (!major_class_table[i].func)
 897                                 break;
 898
 899                         minor_str = major_class_table[i].func(minor_cls);
 900                         break;
 901                 }
 902         }
 903
 904         if (major_str) {
 905                 print_field("  Major class: %s", major_str);
 906                 if (minor_str)
 907                         print_field("  Minor class: %s", minor_str);
 908                 else
 909                         print_field("  Minor class: 0x%2.2x", minor_cls);
 910         } else {
 911                 print_field("  Major class: 0x%2.2x", major_cls);
 912                 print_field("  Minor class: 0x%2.2x", minor_cls);
 913         }
 914
 915         if (dev_class[1] & 0x20)
 916                 print_field("  Limited Discoverable Mode");
 917
 918         if ((dev_class[1] & 0xc0) != 0x00) {
 919                 print_text(COLOR_ERROR, "  invalid service class");
 920                 return;
 921         }
 922
 923         mask = dev_class[2];
 924
 925         for (i = 0; svc_class_table[i].str; i++) {
 926                 if (dev_class[2] & (1 << svc_class_table[i].bit)) {
 927                         print_field("  %s", svc_class_table[i].str);
 928                         mask &= ~(1 << svc_class_table[i].bit);
 929                 }
 930         }
 931
 932         if (mask)
 933                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
 934                                 "  Unknown service class (0x%2.2x)", mask);
 935 }
 936
 937 static const struct {
 938         uint16_t val;
 939         bool generic;
 940         const char *str;
 941 } appearance_table[] = {
 942         {    0, true,  "Unknown"                },
 943         {   64, true,  "Phone"                  },
 944         {  128, true,  "Computer"               },
 945         {  192, true,  "Watch"                  },
 946         {  193, false, "Sports Watch"           },
 947         {  256, true,  "Clock"                  },
 948         {  320, true,  "Display"                },
 949         {  384, true,  "Remote Control"         },
 950         {  448, true,  "Eye-glasses"            },
 951         {  512, true,  "Tag"                    },
 952         {  576, true,  "Keyring"                },
 953         {  640, true,  "Media Player"           },
 954         {  704, true,  "Barcode Scanner"        },
 955         {  768, true,  "Thermometer"            },
 956         {  769, false, "Thermometer: Ear"       },
 957         {  832, true,  "Heart Rate Sensor"      },
 958         {  833, false, "Heart Rate Belt"        },
 959         {  896, true,  "Blood Pressure"         },
 960         {  897, false, "Blood Pressure: Arm"    },
 961         {  898, false, "Blood Pressure: Wrist"  },
 962         {  960, true,  "Human Interface Device" },
 963         {  961, false, "Keyboard"               },
 964         {  962, false, "Mouse"                  },
 965         {  963, false, "Joystick"               },
 966         {  964, false, "Gamepad"                },
 967         {  965, false, "Digitizer Tablet"       },
 968         {  966, false, "Card Reader"            },
 969         {  967, false, "Digital Pen"            },
 970         {  968, false, "Barcode Scanner"        },
 971         { 1024, true,  "Glucose Meter"          },
 972         { 1088, true,  "Running Walking Sensor"                 },
 973         { 1089, false, "Running Walking Sensor: In-Shoe"        },
 974         { 1090, false, "Running Walking Sensor: On-Shoe"        },
 975         { 1091, false, "Running Walking Sensor: On-Hip"         },
 976         { 1152, true,  "Cycling"                                },
 977         { 1153, false, "Cycling: Cycling Computer"              },
 978         { 1154, false, "Cycling: Speed Sensor"                  },
 979         { 1155, false, "Cycling: Cadence Sensor"                },
 980         { 1156, false, "Cycling: Power Sensor"                  },
 981         { 1157, false, "Cycling: Speed and Cadence Sensor"      },
 982         { 1216, true,  "Undefined"                              },
 983
 984         { 3136, true,  "Pulse Oximeter"                         },
 985         { 3137, false, "Pulse Oximeter: Fingertip"              },
 986         { 3138, false, "Pulse Oximeter: Wrist Worn"             },
 987         { 3200, true,  "Weight Scale"                           },
 988         { 3264, true,  "Undefined"                              },
 989
 990         { 5184, true,  "Outdoor Sports Activity"                },
 991         { 5185, false, "Location Display Device"                },
 992         { 5186, false, "Location and Navigation Display Device" },
 993         { 5187, false, "Location Pod"                           },
 994         { 5188, false, "Location and Navigation Pod"            },
 995         { 5248, true,  "Undefined"                              },
 996         { }
 997 };
 998
 999 static void print_appearance(uint16_t appearance)
1000 {
1001         const char *str = NULL;
1002         int i, type = 0;
1003
1004         for (i = 0; appearance_table[i].str; i++) {
1005                 if (appearance_table[i].generic) {
1006                         if (appearance < appearance_table[i].val)
1007                                 break;
1008                         type = i;
1009                 }
1010
1011                 if (appearance_table[i].val == appearance) {
1012                         str = appearance_table[i].str;
1013                         break;
1014                 }
1015         }
1016
1017         if (!str)
1018                 str = appearance_table[type].str;
1019
1020         print_field("Appearance: %s (0x%4.4x)", str, appearance);
1021 }
1022
1023 static void print_num_broadcast_retrans(uint8_t num_retrans)
1024 {
1025         print_field("Number of broadcast retransmissions: %u", num_retrans);
1026 }
1027
1028 static void print_hold_mode_activity(uint8_t activity)
1029 {
1030         print_field("Activity: 0x%2.2x", activity);
1031
1032         if (activity == 0x00) {
1033                 print_field("  Maintain current Power State");
1034                 return;
1035         }
1036
1037         if (activity & 0x01)
1038                 print_field("  Suspend Page Scan");
1039         if (activity & 0x02)
1040                 print_field("  Suspend Inquiry Scan");
1041         if (activity & 0x04)
1042                 print_field("  Suspend Periodic Inquiries");
1043 }
1044
1045 static void print_power_type(uint8_t type)
1046 {
1047         const char *str;
1048
1049         switch (type) {
1050         case 0x00:
1051                 str = "Current Transmit Power Level";
1052                 break;
1053         case 0x01:
1054                 str = "Maximum Transmit Power Level";
1055                 break;
1056         default:
1057                 str = "Reserved";
1058                 break;
1059         }
1060
1061         print_field("Type: %s (0x%2.2x)", str, type);
1062 }
1063
1064 static void print_power_level(int8_t level, const char *type)
1065 {
1066         print_field("TX power%s%s%s: %d dBm",
1067                 type ? " (" : "", type ? type : "", type ? ")" : "", level);
1068 }
1069
1070 static void print_sync_flow_control(uint8_t enable)
1071 {
1072         const char *str;
1073
1074         switch (enable) {
1075         case 0x00:
1076                 str = "Disabled";
1077                 break;
1078         case 0x01:
1079                 str = "Enabled";
1080                 break;
1081         default:
1082                 str = "Reserved";
1083                 break;
1084         }
1085
1086         print_field("Flow control: %s (0x%2.2x)", str, enable);
1087 }
1088
1089 static void print_host_flow_control(uint8_t enable)
1090 {
1091         const char *str;
1092
1093         switch (enable) {
1094         case 0x00:
1095                 str = "Off";
1096                 break;
1097         case 0x01:
1098                 str = "ACL Data Packets";
1099                 break;
1100         case 0x02:
1101                 str = "Synchronous Data Packets";
1102                 break;
1103         case 0x03:
1104                 str = "ACL and Synchronous Data Packets";
1105                 break;
1106         default:
1107                 str = "Reserved";
1108                 break;
1109         }
1110
1111         print_field("Flow control: %s (0x%2.2x)", str, enable);
1112 }
1113
1114 static void print_voice_setting(uint16_t setting)
1115 {
1116         uint8_t input_coding = (le16_to_cpu(setting) & 0x0300) >> 8;
1117         uint8_t input_data_format = (le16_to_cpu(setting) & 0xc0) >> 6;
1118         uint8_t air_coding_format = le16_to_cpu(setting) & 0x0003;
1119         const char *str;
1120
1121         print_field("Setting: 0x%4.4x", le16_to_cpu(setting));
1122
1123         switch (input_coding) {
1124         case 0x00:
1125                 str = "Linear";
1126                 break;
1127         case 0x01:
1128                 str = "u-law";
1129                 break;
1130         case 0x02:
1131                 str = "A-law";
1132                 break;
1133         default:
1134                 str = "Reserved";
1135                 break;
1136         }
1137
1138         print_field("  Input Coding: %s", str);
1139
1140         switch (input_data_format) {
1141         case 0x00:
1142                 str = "1's complement";
1143                 break;
1144         case 0x01:
1145                 str = "2's complement";
1146                 break;
1147         case 0x02:
1148                 str = "Sign-Magnitude";
1149                 break;
1150         case 0x03:
1151                 str = "Unsigned";
1152                 break;
1153         default:
1154                 str = "Reserved";
1155                 break;
1156         }
1157
1158         print_field("  Input Data Format: %s", str);
1159
1160         if (input_coding == 0x00) {
1161                 print_field("  Input Sample Size: %s",
1162                         le16_to_cpu(setting) & 0x20 ? "16-bit" : "8-bit");
1163                 print_field("  # of bits padding at MSB: %d",
1164                                         (le16_to_cpu(setting) & 0x1c) >> 2);
1165         }
1166
1167         switch (air_coding_format) {
1168         case 0x00:
1169                 str = "CVSD";
1170                 break;
1171         case 0x01:
1172                 str = "u-law";
1173                 break;
1174         case 0x02:
1175                 str = "A-law";
1176                 break;
1177         case 0x03:
1178                 str = "Transparent Data";
1179                 break;
1180         default:
1181                 str = "Reserved";
1182                 break;
1183         }
1184
1185         print_field("  Air Coding Format: %s", str);
1186 }
1187
1188 static void print_retransmission_effort(uint8_t effort)
1189 {
1190         const char *str;
1191
1192         switch (effort) {
1193         case 0x00:
1194                 str = "No retransmissions";
1195                 break;
1196         case 0x01:
1197                 str = "Optimize for power consumption";
1198                 break;
1199         case 0x02:
1200                 str = "Optimize for link quality";
1201                 break;
1202         case 0xff:
1203                 str = "Don't care";
1204                 break;
1205         default:
1206                 str = "Reserved";
1207                 break;
1208         }
1209
1210         print_field("Retransmission effort: %s (0x%2.2x)", str, effort);
1211 }
1212
1213 static void print_scan_enable(uint8_t scan_enable)
1214 {
1215         const char *str;
1216
1217         switch (scan_enable) {
1218         case 0x00:
1219                 str = "No Scans";
1220                 break;
1221         case 0x01:
1222                 str = "Inquiry Scan";
1223                 break;
1224         case 0x02:
1225                 str = "Page Scan";
1226                 break;
1227         case 0x03:
1228                 str = "Inquiry Scan + Page Scan";
1229                 break;
1230         default:
1231                 str = "Reserved";
1232                 break;
1233         }
1234
1235         print_field("Scan enable: %s (0x%2.2x)", str, scan_enable);
1236 }
1237
1238 static void print_link_policy(uint16_t link_policy)
1239 {
1240         uint16_t policy = le16_to_cpu(link_policy);
1241
1242         print_field("Link policy: 0x%4.4x", policy);
1243
1244         if (policy == 0x0000) {
1245                 print_field("  Disable All Modes");
1246                 return;
1247         }
1248
1249         if (policy & 0x0001)
1250                 print_field("  Enable Role Switch");
1251         if (policy & 0x0002)
1252                 print_field("  Enable Hold Mode");
1253         if (policy & 0x0004)
1254                 print_field("  Enable Sniff Mode");
1255         if (policy & 0x0008)
1256                 print_field("  Enable Park State");
1257 }
1258
1259 static void print_air_mode(uint8_t mode)
1260 {
1261         const char *str;
1262
1263         switch (mode) {
1264         case 0x00:
1265                 str = "u-law log";
1266                 break;
1267         case 0x01:
1268                 str = "A-law log";
1269                 break;
1270         case 0x02:
1271                 str = "CVSD";
1272                 break;
1273         case 0x03:
1274                 str = "Transparent";
1275                 break;
1276         default:
1277                 str = "Reserved";
1278                 break;
1279         }
1280
1281         print_field("Air mode: %s (0x%2.2x)", str, mode);
1282 }
1283
1284 static void print_codec(const char *label, uint8_t codec)
1285 {
1286         const char *str;
1287
1288         switch (codec) {
1289         case 0x00:
1290                 str = "u-law log";
1291                 break;
1292         case 0x01:
1293                 str = "A-law log";
1294                 break;
1295         case 0x02:
1296                 str = "CVSD";
1297                 break;
1298         case 0x03:
1299                 str = "Transparent";
1300                 break;
1301         case 0x04:
1302                 str = "Linear PCM";
1303                 break;
1304         case 0x05:
1305                 str = "mSBC";
1306                 break;
1307         case 0xff:
1308                 str = "Vendor specific";
1309                 break;
1310         default:
1311                 str = "Reserved";
1312                 break;
1313         }
1314
1315         print_field("%s: %s (0x%2.2x)", label, str, codec);
1316 }
1317
1318 static void print_inquiry_mode(uint8_t mode)
1319 {
1320         const char *str;
1321
1322         switch (mode) {
1323         case 0x00:
1324                 str = "Standard Inquiry Result";
1325                 break;
1326         case 0x01:
1327                 str = "Inquiry Result with RSSI";
1328                 break;
1329         case 0x02:
1330                 str = "Inquiry Result with RSSI or Extended Inquiry Result";
1331                 break;
1332         default:
1333                 str = "Reserved";
1334                 break;
1335         }
1336
1337         print_field("Mode: %s (0x%2.2x)", str, mode);
1338 }
1339
1340 static void print_inquiry_scan_type(uint8_t type)
1341 {
1342         const char *str;
1343
1344         switch (type) {
1345         case 0x00:
1346                 str = "Standard Scan";
1347                 break;
1348         case 0x01:
1349                 str = "Interlaced Scan";
1350                 break;
1351         default:
1352                 str = "Reserved";
1353                 break;
1354         }
1355
1356         print_field("Type: %s (0x%2.2x)", str, type);
1357 }
1358
1359 static void print_pscan_type(uint8_t type)
1360 {
1361         const char *str;
1362
1363         switch (type) {
1364         case 0x00:
1365                 str = "Standard Scan";
1366                 break;
1367         case 0x01:
1368                 str = "Interlaced Scan";
1369                 break;
1370         default:
1371                 str = "Reserved";
1372                 break;
1373         }
1374
1375         print_field("Type: %s (0x%2.2x)", str, type);
1376 }
1377
1378 static void print_afh_mode(uint8_t mode)
1379 {
1380         const char *str;
1381
1382         switch (mode) {
1383         case 0x00:
1384                 str = "Disabled";
1385                 break;
1386         case 0x01:
1387                 str = "Enabled";
1388                 break;
1389         default:
1390                 str = "Reserved";
1391                 break;
1392         }
1393
1394         print_field("Mode: %s (0x%2.2x)", str, mode);
1395 }
1396
1397 static void print_erroneous_reporting(uint8_t mode)
1398 {
1399         const char *str;
1400
1401         switch (mode) {
1402         case 0x00:
1403                 str = "Disabled";
1404                 break;
1405         case 0x01:
1406                 str = "Enabled";
1407                 break;
1408         default:
1409                 str = "Reserved";
1410                 break;
1411         }
1412
1413         print_field("Mode: %s (0x%2.2x)", str, mode);
1414 }
1415
1416 static void print_loopback_mode(uint8_t mode)
1417 {
1418         const char *str;
1419
1420         switch (mode) {
1421         case 0x00:
1422                 str = "No Loopback";
1423                 break;
1424         case 0x01:
1425                 str = "Local Loopback";
1426                 break;
1427         case 0x02:
1428                 str = "Remote Loopback";
1429                 break;
1430         default:
1431                 str = "Reserved";
1432                 break;
1433         }
1434
1435         print_field("Mode: %s (0x%2.2x)", str, mode);
1436 }
1437
1438 static void print_simple_pairing_mode(uint8_t mode)
1439 {
1440         const char *str;
1441
1442         switch (mode) {
1443         case 0x00:
1444                 str = "Disabled";
1445                 break;
1446         case 0x01:
1447                 str = "Enabled";
1448                 break;
1449         default:
1450                 str = "Reserved";
1451                 break;
1452         }
1453
1454         print_field("Mode: %s (0x%2.2x)", str, mode);
1455 }
1456
1457 static void print_ssp_debug_mode(uint8_t mode)
1458 {
1459         const char *str;
1460
1461         switch (mode) {
1462         case 0x00:
1463                 str = "Disabled";
1464                 break;
1465         case 0x01:
1466                 str = "Enabled";
1467                 break;
1468         default:
1469                 str = "Reserved";
1470                 break;
1471         }
1472
1473         print_field("Debug mode: %s (0x%2.2x)", str, mode);
1474 }
1475
1476 static void print_secure_conn_support(uint8_t support)
1477 {
1478         const char *str;
1479
1480         switch (support) {
1481         case 0x00:
1482                 str = "Disabled";
1483                 break;
1484         case 0x01:
1485                 str = "Enabled";
1486                 break;
1487         default:
1488                 str = "Reserved";
1489                 break;
1490         }
1491
1492         print_field("Support: %s (0x%2.2x)", str, support);
1493 }
1494
1495 static void print_auth_payload_timeout(uint16_t timeout)
1496 {
1497         print_field("Timeout: %d msec (0x%4.4x)",
1498                         le16_to_cpu(timeout) * 10, le16_to_cpu(timeout));
1499 }
1500
1501 static void print_pscan_rep_mode(uint8_t pscan_rep_mode)
1502 {
1503         const char *str;
1504
1505         switch (pscan_rep_mode) {
1506         case 0x00:
1507                 str = "R0";
1508                 break;
1509         case 0x01:
1510                 str = "R1";
1511                 break;
1512         case 0x02:
1513                 str = "R2";
1514                 break;
1515         default:
1516                 str = "Reserved";
1517                 break;
1518         }
1519
1520         print_field("Page scan repetition mode: %s (0x%2.2x)",
1521                                                 str, pscan_rep_mode);
1522 }
1523
1524 static void print_pscan_period_mode(uint8_t pscan_period_mode)
1525 {
1526         const char *str;
1527
1528         switch (pscan_period_mode) {
1529         case 0x00:
1530                 str = "P0";
1531                 break;
1532         case 0x01:
1533                 str = "P1";
1534                 break;
1535         case 0x02:
1536                 str = "P2";
1537                 break;
1538         default:
1539                 str = "Reserved";
1540                 break;
1541         }
1542
1543         print_field("Page period mode: %s (0x%2.2x)", str, pscan_period_mode);
1544 }
1545
1546 static void print_pscan_mode(uint8_t pscan_mode)
1547 {
1548         const char *str;
1549
1550         switch (pscan_mode) {
1551         case 0x00:
1552                 str = "Mandatory";
1553                 break;
1554         case 0x01:
1555                 str = "Optional I";
1556                 break;
1557         case 0x02:
1558                 str = "Optional II";
1559                 break;
1560         case 0x03:
1561                 str = "Optional III";
1562                 break;
1563         default:
1564                 str = "Reserved";
1565                 break;
1566         }
1567
1568         print_field("Page scan mode: %s (0x%2.2x)", str, pscan_mode);
1569 }
1570
1571 static void print_clock_offset(uint16_t clock_offset)
1572 {
1573         print_field("Clock offset: 0x%4.4x", le16_to_cpu(clock_offset));
1574 }
1575
1576 static void print_clock(uint32_t clock)
1577 {
1578         print_field("Clock: 0x%8.8x", le32_to_cpu(clock));
1579 }
1580
1581 static void print_clock_type(uint8_t type)
1582 {
1583         const char *str;
1584
1585         switch (type) {
1586         case 0x00:
1587                 str = "Local clock";
1588                 break;
1589         case 0x01:
1590                 str = "Piconet clock";
1591                 break;
1592         default:
1593                 str = "Reserved";
1594                 break;
1595         }
1596
1597         print_field("Type: %s (0x%2.2x)", str, type);
1598 }
1599
1600 static void print_clock_accuracy(uint16_t accuracy)
1601 {
1602         if (le16_to_cpu(accuracy) == 0xffff)
1603                 print_field("Accuracy: Unknown (0x%4.4x)",
1604                                                 le16_to_cpu(accuracy));
1605         else
1606                 print_field("Accuracy: %.4f msec (0x%4.4x)",
1607                                                 le16_to_cpu(accuracy) * 0.3125,
1608                                                 le16_to_cpu(accuracy));
1609 }
1610
1611 static void print_lpo_allowed(uint8_t lpo_allowed)
1612 {
1613         print_field("LPO allowed: 0x%2.2x", lpo_allowed);
1614 }
1615
1616 static void print_broadcast_fragment(uint8_t fragment)
1617 {
1618         const char *str;
1619
1620         switch (fragment) {
1621         case 0x00:
1622                 str = "Continuation fragment";
1623                 break;
1624         case 0x01:
1625                 str = "Starting fragment";
1626                 break;
1627         case 0x02:
1628                 str = "Ending fragment";
1629                 break;
1630         case 0x03:
1631                 str = "No fragmentation";
1632                 break;
1633         default:
1634                 str = "Reserved";
1635                 break;
1636         }
1637
1638         print_field("Fragment: %s (0x%2.2x)", str, fragment);
1639 }
1640
1641 static void print_link_type(uint8_t link_type)
1642 {
1643         const char *str;
1644
1645         switch (link_type) {
1646         case 0x00:
1647                 str = "SCO";
1648                 break;
1649         case 0x01:
1650                 str = "ACL";
1651                 break;
1652         case 0x02:
1653                 str = "eSCO";
1654                 break;
1655         default:
1656                 str = "Reserved";
1657                 break;
1658         }
1659
1660         print_field("Link type: %s (0x%2.2x)", str, link_type);
1661 }
1662
1663 static void print_encr_mode(uint8_t encr_mode)
1664 {
1665         const char *str;
1666
1667         switch (encr_mode) {
1668         case 0x00:
1669                 str = "Disabled";
1670                 break;
1671         case 0x01:
1672                 str = "Enabled";
1673                 break;
1674         default:
1675                 str = "Reserved";
1676                 break;
1677         }
1678
1679         print_field("Encryption: %s (0x%2.2x)", str, encr_mode);
1680 }
1681
1682 static void print_encr_mode_change(uint8_t encr_mode, uint16_t handle)
1683 {
1684         const char *str;
1685         uint8_t conn_type;
1686
1687         conn_type = get_type(le16_to_cpu(handle));
1688
1689         switch (encr_mode) {
1690         case 0x00:
1691                 str = "Disabled";
1692                 break;
1693         case 0x01:
1694                 switch (conn_type) {
1695                 case 0x00:
1696                         str = "Enabled with E0";
1697                         break;
1698                 case 0x01:
1699                         str = "Enabled with AES-CCM";
1700                         break;
1701                 default:
1702                         str = "Enabled";
1703                         break;
1704                 }
1705                 break;
1706         case 0x02:
1707                 str = "Enabled with AES-CCM";
1708                 break;
1709         default:
1710                 str = "Reserved";
1711                 break;
1712         }
1713
1714         print_field("Encryption: %s (0x%2.2x)", str, encr_mode);
1715 }
1716
1717 static void print_pin_type(uint8_t pin_type)
1718 {
1719         const char *str;
1720
1721         switch (pin_type) {
1722         case 0x00:
1723                 str = "Variable";
1724                 break;
1725         case 0x01:
1726                 str = "Fixed";
1727                 break;
1728         default:
1729                 str = "Reserved";
1730                 break;
1731         }
1732
1733         print_field("PIN type: %s (0x%2.2x)", str, pin_type);
1734 }
1735
1736 static void print_key_flag(uint8_t key_flag)
1737 {
1738         const char *str;
1739
1740         switch (key_flag) {
1741         case 0x00:
1742                 str = "Semi-permanent";
1743                 break;
1744         case 0x01:
1745                 str = "Temporary";
1746                 break;
1747         default:
1748                 str = "Reserved";
1749                 break;
1750         }
1751
1752         print_field("Key flag: %s (0x%2.2x)", str, key_flag);
1753 }
1754
1755 static void print_key_len(uint8_t key_len)
1756 {
1757         const char *str;
1758
1759         switch (key_len) {
1760         case 32:
1761                 str = "802.11 PAL";
1762                 break;
1763         default:
1764                 str = "Reserved";
1765                 break;
1766         }
1767
1768         print_field("Key length: %s (%d)", str, key_len);
1769 }
1770
1771 static void print_key_type(uint8_t key_type)
1772 {
1773         const char *str;
1774
1775         switch (key_type) {
1776         case 0x00:
1777                 str = "Combination key";
1778                 break;
1779         case 0x01:
1780                 str = "Local Unit key";
1781                 break;
1782         case 0x02:
1783                 str = "Remote Unit key";
1784                 break;
1785         case 0x03:
1786                 str = "Debug Combination key";
1787                 break;
1788         case 0x04:
1789                 str = "Unauthenticated Combination key from P-192";
1790                 break;
1791         case 0x05:
1792                 str = "Authenticated Combination key from P-192";
1793                 break;
1794         case 0x06:
1795                 str = "Changed Combination key";
1796                 break;
1797         case 0x07:
1798                 str = "Unauthenticated Combination key from P-256";
1799                 break;
1800         case 0x08:
1801                 str = "Authenticated Combination key from P-256";
1802                 break;
1803         default:
1804                 str = "Reserved";
1805                 break;
1806         }
1807
1808         print_field("Key type: %s (0x%2.2x)", str, key_type);
1809 }
1810
1811 static void print_key_size(uint8_t key_size)
1812 {
1813         print_field("Key size: %d", key_size);
1814 }
1815
1816 static void print_hex_field(const char *label, const uint8_t *data,
1817                                                                 uint8_t len)
1818 {
1819         char str[len * 2 + 1];
1820         uint8_t i;
1821
1822         str[0] = '\0';
1823
1824         for (i = 0; i < len; i++)
1825                 sprintf(str + (i * 2), "%2.2x", data[i]);
1826
1827         print_field("%s: %s", label, str);
1828 }
1829
1830 static void print_key(const char *label, const uint8_t *link_key)
1831 {
1832         print_hex_field(label, link_key, 16);
1833 }
1834
1835 static void print_link_key(const uint8_t *link_key)
1836 {
1837         print_key("Link key", link_key);
1838 }
1839
1840 static void print_pin_code(const uint8_t *pin_code, uint8_t pin_len)
1841 {
1842         char str[pin_len + 1];
1843         uint8_t i;
1844
1845         for (i = 0; i < pin_len; i++)
1846                 sprintf(str + i, "%c", (const char) pin_code[i]);
1847
1848         print_field("PIN code: %s", str);
1849 }
1850
1851 static void print_hash_p192(const uint8_t *hash)
1852 {
1853         print_key("Hash C from P-192", hash);
1854 }
1855
1856 static void print_hash_p256(const uint8_t *hash)
1857 {
1858         print_key("Hash C from P-256", hash);
1859 }
1860
1861 static void print_randomizer_p192(const uint8_t *randomizer)
1862 {
1863         print_key("Randomizer R with P-192", randomizer);
1864 }
1865
1866 static void print_randomizer_p256(const uint8_t *randomizer)
1867 {
1868         print_key("Randomizer R with P-256", randomizer);
1869 }
1870
1871 static void print_pk256(const char *label, const uint8_t *key)
1872 {
1873         print_hex_field(label, key, 64);
1874 }
1875
1876 static void print_dhkey(const uint8_t *dhkey)
1877 {
1878         print_hex_field("Diffie-Hellman key", dhkey, 32);
1879 }
1880
1881 static void print_passkey(uint32_t passkey)
1882 {
1883         print_field("Passkey: %06d", le32_to_cpu(passkey));
1884 }
1885
1886 static void print_io_capability(uint8_t capability)
1887 {
1888         const char *str;
1889
1890         switch (capability) {
1891         case 0x00:
1892                 str = "DisplayOnly";
1893                 break;
1894         case 0x01:
1895                 str = "DisplayYesNo";
1896                 break;
1897         case 0x02:
1898                 str = "KeyboardOnly";
1899                 break;
1900         case 0x03:
1901                 str = "NoInputNoOutput";
1902                 break;
1903         default:
1904                 str = "Reserved";
1905                 break;
1906         }
1907
1908         print_field("IO capability: %s (0x%2.2x)", str, capability);
1909 }
1910
1911 static void print_oob_data(uint8_t oob_data)
1912 {
1913         const char *str;
1914
1915         switch (oob_data) {
1916         case 0x00:
1917                 str = "Authentication data not present";
1918                 break;
1919         case 0x01:
1920                 str = "P-192 authentication data present";
1921                 break;
1922         case 0x02:
1923                 str = "P-256 authentication data present";
1924                 break;
1925         case 0x03:
1926                 str = "P-192 and P-256 authentication data present";
1927                 break;
1928         default:
1929                 str = "Reserved";
1930                 break;
1931         }
1932
1933         print_field("OOB data: %s (0x%2.2x)", str, oob_data);
1934 }
1935
1936 static void print_oob_data_response(uint8_t oob_data)
1937 {
1938         const char *str;
1939
1940         switch (oob_data) {
1941         case 0x00:
1942                 str = "Authentication data not present";
1943                 break;
1944         case 0x01:
1945                 str = "Authentication data present";
1946                 break;
1947         default:
1948                 str = "Reserved";
1949                 break;
1950         }
1951
1952         print_field("OOB data: %s (0x%2.2x)", str, oob_data);
1953 }
1954
1955 static void print_authentication(uint8_t authentication)
1956 {
1957         const char *str;
1958
1959         switch (authentication) {
1960         case 0x00:
1961                 str = "No Bonding - MITM not required";
1962                 break;
1963         case 0x01:
1964                 str = "No Bonding - MITM required";
1965                 break;
1966         case 0x02:
1967                 str = "Dedicated Bonding - MITM not required";
1968                 break;
1969         case 0x03:
1970                 str = "Dedicated Bonding - MITM required";
1971                 break;
1972         case 0x04:
1973                 str = "General Bonding - MITM not required";
1974                 break;
1975         case 0x05:
1976                 str = "General Bonding - MITM required";
1977                 break;
1978         default:
1979                 str = "Reserved";
1980                 break;
1981         }
1982
1983         print_field("Authentication: %s (0x%2.2x)", str, authentication);
1984 }
1985
1986 void packet_print_io_capability(uint8_t capability)
1987 {
1988         print_io_capability(capability);
1989 }
1990
1991 void packet_print_io_authentication(uint8_t authentication)
1992 {
1993         print_authentication(authentication);
1994 }
1995
1996 static void print_location_domain_aware(uint8_t aware)
1997 {
1998         const char *str;
1999
2000         switch (aware) {
2001         case 0x00:
2002                 str = "Regulatory domain unknown";
2003                 break;
2004         case 0x01:
2005                 str = "Regulatory domain known";
2006                 break;
2007         default:
2008                 str = "Reserved";
2009                 break;
2010         }
2011
2012         print_field("Domain aware: %s (0x%2.2x)", str, aware);
2013 }
2014
2015 static void print_location_domain(const uint8_t *domain)
2016 {
2017         print_field("Domain: %c%c (0x%2.2x%2.2x)",
2018                 (char) domain[0], (char) domain[1], domain[0], domain[1]);
2019 }
2020
2021 static void print_location_domain_options(uint8_t options)
2022 {
2023         print_field("Domain options: %c (0x%2.2x)", (char) options, options);
2024 }
2025
2026 static void print_location_options(uint8_t options)
2027 {
2028         print_field("Options: 0x%2.2x", options);
2029 }
2030
2031 static void print_flow_control_mode(uint8_t mode)
2032 {
2033         const char *str;
2034
2035         switch (mode) {
2036         case 0x00:
2037                 str = "Packet based";
2038                 break;
2039         case 0x01:
2040                 str = "Data block based";
2041                 break;
2042         default:
2043                 str = "Reserved";
2044                 break;
2045         }
2046
2047         print_field("Flow control mode: %s (0x%2.2x)", str, mode);
2048 }
2049
2050 static void print_flow_direction(uint8_t direction)
2051 {
2052         const char *str;
2053
2054         switch (direction) {
2055         case 0x00:
2056                 str = "Outgoing";
2057                 break;
2058         case 0x01:
2059                 str = "Incoming";
2060                 break;
2061         default:
2062                 str = "Reserved";
2063                 break;
2064         }
2065
2066         print_field("Flow direction: %s (0x%2.2x)", str, direction);
2067 }
2068
2069 static void print_service_type(uint8_t service_type)
2070 {
2071         const char *str;
2072
2073         switch (service_type) {
2074         case 0x00:
2075                 str = "No Traffic";
2076                 break;
2077         case 0x01:
2078                 str = "Best Effort";
2079                 break;
2080         case 0x02:
2081                 str = "Guaranteed";
2082                 break;
2083         default:
2084                 str = "Reserved";
2085                 break;
2086         }
2087
2088         print_field("Service type: %s (0x%2.2x)", str, service_type);
2089 }
2090
2091 static void print_flow_spec(const char *label, const uint8_t *data)
2092 {
2093         const char *str;
2094
2095         switch (data[1]) {
2096         case 0x00:
2097                 str = "No traffic";
2098                 break;
2099         case 0x01:
2100                 str = "Best effort";
2101                 break;
2102         case 0x02:
2103                 str = "Guaranteed";
2104                 break;
2105         default:
2106                 str = "Reserved";
2107                 break;
2108         }
2109
2110         print_field("%s flow spec: 0x%2.2x", label, data[0]);
2111         print_field("  Service type: %s (0x%2.2x)", str, data[1]);
2112         print_field("  Maximum SDU size: 0x%4.4x", get_le16(data + 2));
2113         print_field("  SDU inter-arrival time: 0x%8.8x", get_le32(data + 4));
2114         print_field("  Access latency: 0x%8.8x", get_le32(data + 8));
2115         print_field("  Flush timeout: 0x%8.8x", get_le32(data + 12));
2116 }
2117
2118 static void print_short_range_mode(uint8_t mode)
2119 {
2120         const char *str;
2121
2122         switch (mode) {
2123         case 0x00:
2124                 str = "Disabled";
2125                 break;
2126         case 0x01:
2127                 str = "Enabled";
2128                 break;
2129         default:
2130                 str = "Reserved";
2131                 break;
2132         }
2133
2134         print_field("Short range mode: %s (0x%2.2x)", str, mode);
2135 }
2136
2137 static void print_amp_status(uint8_t amp_status)
2138 {
2139         const char *str;
2140
2141         switch (amp_status) {
2142         case 0x00:
2143                 str = "Present";
2144                 break;
2145         case 0x01:
2146                 str = "Bluetooth only";
2147                 break;
2148         case 0x02:
2149                 str = "No capacity";
2150                 break;
2151         case 0x03:
2152                 str = "Low capacity";
2153                 break;
2154         case 0x04:
2155                 str = "Medium capacity";
2156                 break;
2157         case 0x05:
2158                 str = "High capacity";
2159                 break;
2160         case 0x06:
2161                 str = "Full capacity";
2162                 break;
2163         default:
2164                 str = "Reserved";
2165                 break;
2166         }
2167
2168         print_field("AMP status: %s (0x%2.2x)", str, amp_status);
2169 }
2170
2171 static void print_num_resp(uint8_t num_resp)
2172 {
2173         print_field("Num responses: %d", num_resp);
2174 }
2175
2176 static void print_num_reports(uint8_t num_reports)
2177 {
2178         print_field("Num reports: %d", num_reports);
2179 }
2180
2181 static void print_adv_event_type(uint8_t type)
2182 {
2183         const char *str;
2184
2185         switch (type) {
2186         case 0x00:
2187                 str = "Connectable undirected - ADV_IND";
2188                 break;
2189         case 0x01:
2190                 str = "Connectable directed - ADV_DIRECT_IND";
2191                 break;
2192         case 0x02:
2193                 str = "Scannable undirected - ADV_SCAN_IND";
2194                 break;
2195         case 0x03:
2196                 str = "Non connectable undirected - ADV_NONCONN_IND";
2197                 break;
2198         case 0x04:
2199                 str = "Scan response - SCAN_RSP";
2200                 break;
2201         default:
2202                 str = "Reserved";
2203                 break;
2204         }
2205
2206         print_field("Event type: %s (0x%2.2x)", str, type);
2207 }
2208
2209 static void print_rssi(int8_t rssi)
2210 {
2211         if ((uint8_t) rssi == 0x99 || rssi == 127)
2212                 print_field("RSSI: invalid (0x%2.2x)", (uint8_t) rssi);
2213         else
2214                 print_field("RSSI: %d dBm (0x%2.2x)", rssi, (uint8_t) rssi);
2215 }
2216
2217 static void print_slot_625(const char *label, uint16_t value)
2218 {
2219          print_field("%s: %.3f msec (0x%4.4x)", label,
2220                                 le16_to_cpu(value) * 0.625, le16_to_cpu(value));
2221 }
2222
2223 static void print_slot_125(const char *label, uint16_t value)
2224 {
2225         print_field("%s: %.2f msec (0x%4.4x)", label,
2226                                 le16_to_cpu(value) * 1.25, le16_to_cpu(value));
2227 }
2228
2229 static void print_timeout(uint16_t timeout)
2230 {
2231         print_slot_625("Timeout", timeout);
2232 }
2233
2234 static void print_interval(uint16_t interval)
2235 {
2236         print_slot_625("Interval", interval);
2237 }
2238
2239 static void print_window(uint16_t window)
2240 {
2241         print_slot_625("Window", window);
2242 }
2243
2244 static void print_role(uint8_t role)
2245 {
2246         const char *str;
2247
2248         switch (role) {
2249         case 0x00:
2250                 str = "Master";
2251                 break;
2252         case 0x01:
2253                 str = "Slave";
2254                 break;
2255         default:
2256                 str = "Reserved";
2257                 break;
2258         }
2259
2260         print_field("Role: %s (0x%2.2x)", str, role);
2261 }
2262
2263 static void print_mode(uint8_t mode)
2264 {
2265         const char *str;
2266
2267         switch (mode) {
2268         case 0x00:
2269                 str = "Active";
2270                 break;
2271         case 0x01:
2272                 str = "Hold";
2273                 break;
2274         case 0x02:
2275                 str = "Sniff";
2276                 break;
2277         case 0x03:
2278                 str = "Park";
2279                 break;
2280         default:
2281                 str = "Reserved";
2282                 break;
2283         }
2284
2285         print_field("Mode: %s (0x%2.2x)", str, mode);
2286 }
2287
2288 static void print_name(const uint8_t *name)
2289 {
2290         char str[249];
2291
2292         memcpy(str, name, 248);
2293         str[248] = '\0';
2294
2295         print_field("Name: %s", str);
2296 }
2297
2298 static void print_channel_map(const uint8_t *map)
2299 {
2300         unsigned int count = 0, start = 0;
2301         char str[21];
2302         int i, n;
2303
2304         for (i = 0; i < 10; i++)
2305                 sprintf(str + (i * 2), "%2.2x", map[i]);
2306
2307         print_field("Channel map: 0x%s", str);
2308
2309         for (i = 0; i < 10; i++) {
2310                 for (n = 0; n < 8; n++) {
2311                         if (map[i] & (1 << n)) {
2312                                 if (count == 0)
2313                                         start = (i * 8) + n;
2314                                 count++;
2315                                 continue;
2316                         }
2317
2318                         if (count > 1) {
2319                                 print_field("  Channel %u-%u",
2320                                                 start, start + count - 1);
2321                                 count = 0;
2322                         } else if (count > 0) {
2323                                 print_field("  Channel %u", start);
2324                                 count = 0;
2325                         }
2326                 }
2327         }
2328 }
2329
2330 void packet_print_channel_map_lmp(const uint8_t *map)
2331 {
2332         print_channel_map(map);
2333 }
2334
2335 static void print_flush_timeout(uint16_t timeout)
2336 {
2337         if (timeout)
2338                 print_timeout(timeout);
2339         else
2340                 print_field("Timeout: No Automatic Flush");
2341 }
2342
2343 void packet_print_version(const char *label, uint8_t version,
2344                                 const char *sublabel, uint16_t subversion)
2345 {
2346         const char *str;
2347
2348         switch (version) {
2349         case 0x00:
2350                 str = "Bluetooth 1.0b";
2351                 break;
2352         case 0x01:
2353                 str = "Bluetooth 1.1";
2354                 break;
2355         case 0x02:
2356                 str = "Bluetooth 1.2";
2357                 break;
2358         case 0x03:
2359                 str = "Bluetooth 2.0";
2360                 break;
2361         case 0x04:
2362                 str = "Bluetooth 2.1";
2363                 break;
2364         case 0x05:
2365                 str = "Bluetooth 3.0";
2366                 break;
2367         case 0x06:
2368                 str = "Bluetooth 4.0";
2369                 break;
2370         case 0x07:
2371                 str = "Bluetooth 4.1";
2372                 break;
2373         case 0x08:
2374                 str = "Bluetooth 4.2";
2375                 break;
2376         default:
2377                 str = "Reserved";
2378                 break;
2379         }
2380
2381         print_field("%s: %s (0x%2.2x) - %s %d (0x%4.4x)", label, str, version,
2382                                         sublabel, subversion, subversion);
2383 }
2384
2385 static void print_hci_version(uint8_t version, uint16_t revision)
2386 {
2387         packet_print_version("HCI version", version,
2388                                 "Revision", le16_to_cpu(revision));
2389 }
2390
2391 static void print_lmp_version(uint8_t version, uint16_t subversion)
2392 {
2393         packet_print_version("LMP version", version,
2394                                 "Subversion", le16_to_cpu(subversion));
2395 }
2396
2397 static void print_pal_version(uint8_t version, uint16_t subversion)
2398 {
2399         const char *str;
2400
2401         switch (version) {
2402         case 0x01:
2403                 str = "Bluetooth 3.0";
2404                 break;
2405         default:
2406                 str = "Reserved";
2407                 break;
2408         }
2409
2410         print_field("PAL version: %s (0x%2.2x) - Subversion %d (0x%4.4x)",
2411                                                 str, version,
2412                                                 le16_to_cpu(subversion),
2413                                                 le16_to_cpu(subversion));
2414 }
2415
2416 void packet_print_company(const char *label, uint16_t company)
2417 {
2418         print_field("%s: %s (%d)", label, bt_compidtostr(company), company);
2419 }
2420
2421 static void print_manufacturer(uint16_t manufacturer)
2422 {
2423         packet_print_company("Manufacturer", le16_to_cpu(manufacturer));
2424 }
2425
2426 static const struct {
2427         uint16_t ver;
2428         const char *str;
2429 } broadcom_uart_subversion_table[] = {
2430         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
2431         { 0x410e, "BCM43341B0"  },      /* 002.001.014 */
2432         { 0x4406, "BCM4324B3"   },      /* 002.004.006 */
2433         { }
2434 };
2435
2436 static const struct {
2437         uint16_t ver;
2438         const char *str;
2439 } broadcom_usb_subversion_table[] = {
2440         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
2441         { 0x2112, "BCM4314A0"   },      /* 001.001.018 */
2442         { 0x2118, "BCM20702A0"  },      /* 001.001.024 */
2443         { 0x2126, "BCM4335A0"   },      /* 001.001.038 */
2444         { 0x220e, "BCM20702A1"  },      /* 001.002.014 */
2445         { 0x230f, "BCM4354A2"   },      /* 001.003.015 */
2446         { 0x4106, "BCM4335B0"   },      /* 002.001.006 */
2447         { 0x410e, "BCM20702B0"  },      /* 002.001.014 */
2448         { 0x6109, "BCM4335C0"   },      /* 003.001.009 */
2449         { 0x610c, "BCM4354"     },      /* 003.001.012 */
2450         { }
2451 };
2452
2453 static void print_manufacturer_broadcom(uint16_t subversion, uint16_t revision)
2454 {
2455         uint16_t ver = le16_to_cpu(subversion);
2456         uint16_t rev = le16_to_cpu(revision);
2457         const char *str = NULL;
2458         int i;
2459
2460         switch ((rev & 0xf000) >> 12) {
2461         case 0:
2462         case 3:
2463                 for (i = 0; broadcom_uart_subversion_table[i].str; i++) {
2464                         if (broadcom_uart_subversion_table[i].ver == ver) {
2465                                 str = broadcom_uart_subversion_table[i].str;
2466                                 break;
2467                         }
2468                 }
2469                 break;
2470         case 1:
2471         case 2:
2472                 for (i = 0; broadcom_usb_subversion_table[i].str; i++) {
2473                         if (broadcom_usb_subversion_table[i].ver == ver) {
2474                                 str = broadcom_usb_subversion_table[i].str;
2475                                 break;
2476                         }
2477                 }
2478                 break;
2479         }
2480
2481         if (str)
2482                 print_field("  Firmware: %3.3u.%3.3u.%3.3u (%s)",
2483                                 (ver & 0xe000) >> 13,
2484                                 (ver & 0x1f00) >> 8, ver & 0x00ff, str);
2485         else
2486                 print_field("  Firmware: %3.3u.%3.3u.%3.3u",
2487                                 (ver & 0xe000) >> 13,
2488                                 (ver & 0x1f00) >> 8, ver & 0x00ff);
2489
2490         if (rev != 0xffff)
2491                 print_field("  Build: %4.4u", rev & 0x0fff);
2492 }
2493
2494 static const char *get_supported_command(int bit);
2495
2496 static void print_commands(const uint8_t *commands)
2497 {
2498         unsigned int count = 0;
2499         int i, n;
2500
2501         for (i = 0; i < 64; i++) {
2502                 for (n = 0; n < 8; n++) {
2503                         if (commands[i] & (1 << n))
2504                                 count++;
2505                 }
2506         }
2507
2508         print_field("Commands: %u entr%s", count, count == 1 ? "y" : "ies");
2509
2510         for (i = 0; i < 64; i++) {
2511                 for (n = 0; n < 8; n++) {
2512                         const char *cmd;
2513
2514                         if (!(commands[i] & (1 << n)))
2515                                 continue;
2516
2517                         cmd = get_supported_command((i * 8) + n);
2518                         if (cmd)
2519                                 print_field("  %s (Octet %d - Bit %d)",
2520                                                                 cmd, i, n);
2521                         else
2522                                 print_text(COLOR_UNKNOWN_COMMAND_BIT,
2523                                                 "  Octet %d - Bit %d ", i, n);
2524                 }
2525         }
2526 }
2527
2528 struct features_data {
2529         uint8_t bit;
2530         const char *str;
2531 };
2532
2533 static const struct features_data features_page0[] = {
2534         {  0, "3 slot packets"                          },
2535         {  1, "5 slot packets"                          },
2536         {  2, "Encryption"                              },
2537         {  3, "Slot offset"                             },
2538         {  4, "Timing accuracy"                         },
2539         {  5, "Role switch"                             },
2540         {  6, "Hold mode"                               },
2541         {  7, "Sniff mode"                              },
2542         {  8, "Park state"                              },
2543         {  9, "Power control requests"                  },
2544         { 10, "Channel quality driven data rate (CQDDR)"},
2545         { 11, "SCO link"                                },
2546         { 12, "HV2 packets"                             },
2547         { 13, "HV3 packets"                             },
2548         { 14, "u-law log synchronous data"              },
2549         { 15, "A-law log synchronous data"              },
2550         { 16, "CVSD synchronous data"                   },
2551         { 17, "Paging parameter negotiation"            },
2552         { 18, "Power control"                           },
2553         { 19, "Transparent synchronous data"            },
2554         { 20, "Flow control lag (least significant bit)"},
2555         { 21, "Flow control lag (middle bit)"           },
2556         { 22, "Flow control lag (most significant bit)" },
2557         { 23, "Broadcast Encryption"                    },
2558         { 25, "Enhanced Data Rate ACL 2 Mbps mode"      },
2559         { 26, "Enhanced Data Rate ACL 3 Mbps mode"      },
2560         { 27, "Enhanced inquiry scan"                   },
2561         { 28, "Interlaced inquiry scan"                 },
2562         { 29, "Interlaced page scan"                    },
2563         { 30, "RSSI with inquiry results"               },
2564         { 31, "Extended SCO link (EV3 packets)"         },
2565         { 32, "EV4 packets"                             },
2566         { 33, "EV5 packets"                             },
2567         { 35, "AFH capable slave"                       },
2568         { 36, "AFH classification slave"                },
2569         { 37, "BR/EDR Not Supported"                    },
2570         { 38, "LE Supported (Controller)"               },
2571         { 39, "3-slot Enhanced Data Rate ACL packets"   },
2572         { 40, "5-slot Enhanced Data Rate ACL packets"   },
2573         { 41, "Sniff subrating"                         },
2574         { 42, "Pause encryption"                        },
2575         { 43, "AFH capable master"                      },
2576         { 44, "AFH classification master"               },
2577         { 45, "Enhanced Data Rate eSCO 2 Mbps mode"     },
2578         { 46, "Enhanced Data Rate eSCO 3 Mbps mode"     },
2579         { 47, "3-slot Enhanced Data Rate eSCO packets"  },
2580         { 48, "Extended Inquiry Response"               },
2581         { 49, "Simultaneous LE and BR/EDR (Controller)" },
2582         { 51, "Secure Simple Pairing"                   },
2583         { 52, "Encapsulated PDU"                        },
2584         { 53, "Erroneous Data Reporting"                },
2585         { 54, "Non-flushable Packet Boundary Flag"      },
2586         { 56, "Link Supervision Timeout Changed Event"  },
2587         { 57, "Inquiry TX Power Level"                  },
2588         { 58, "Enhanced Power Control"                  },
2589         { 63, "Extended features"                       },
2590         { }
2591 };
2592
2593 static const struct features_data features_page1[] = {
2594         {  0, "Secure Simple Pairing (Host Support)"    },
2595         {  1, "LE Supported (Host)"                     },
2596         {  2, "Simultaneous LE and BR/EDR (Host)"       },
2597         {  3, "Secure Connections (Host Support)"       },
2598         { }
2599 };
2600
2601 static const struct features_data features_page2[] = {
2602         {  0, "Connectionless Slave Broadcast - Master" },
2603         {  1, "Connectionless Slave Broadcast - Slave"  },
2604         {  2, "Synchronization Train"                   },
2605         {  3, "Synchronization Scan"                    },
2606         {  4, "Inquiry Response Notification Event"     },
2607         {  5, "Generalized interlaced scan"             },
2608         {  6, "Coarse Clock Adjustment"                 },
2609         {  8, "Secure Connections (Controller Support)" },
2610         {  9, "Ping"                                    },
2611         { 11, "Train nudging"                           },
2612         { }
2613 };
2614
2615 static const struct features_data features_le[] = {
2616         {  0, "LE Encryption"                           },
2617         {  1, "Connection Parameter Request Procedure"  },
2618         {  2, "Extended Reject Indication"              },
2619         {  3, "Slave-initiated Features Exchange"       },
2620         {  4, "LE Ping"                                 },
2621         {  5, "LE Data Packet Length Extension"         },
2622         {  6, "LL Privacy"                              },
2623         {  7, "Extended Scanner Filter Policies"        },
2624         { }
2625 };
2626
2627 static void print_features(uint8_t page, const uint8_t *features_array,
2628                                                                 uint8_t type)
2629 {
2630         const struct features_data *features_table = NULL;
2631         uint64_t mask, features = 0;
2632         char str[41];
2633         int i;
2634
2635         for (i = 0; i < 8; i++) {
2636                 sprintf(str + (i * 5), " 0x%2.2x", features_array[i]);
2637                 features |= ((uint64_t) features_array[i]) << (i * 8);
2638         }
2639
2640         print_field("Features:%s", str);
2641
2642         switch (type) {
2643         case 0x00:
2644                 switch (page) {
2645                 case 0:
2646                         features_table = features_page0;
2647                         break;
2648                 case 1:
2649                         features_table = features_page1;
2650                         break;
2651                 case 2:
2652                         features_table = features_page2;
2653                         break;
2654                 }
2655                 break;
2656         case 0x01:
2657                 switch (page) {
2658                 case 0:
2659                         features_table = features_le;
2660                         break;
2661                 }
2662                 break;
2663         }
2664
2665         if (!features_table)
2666                 return;
2667
2668         mask = features;
2669
2670         for (i = 0; features_table[i].str; i++) {
2671                 if (features & (((uint64_t) 1) << features_table[i].bit)) {
2672                         print_field("  %s", features_table[i].str);
2673                         mask &= ~(((uint64_t) 1) << features_table[i].bit);
2674                 }
2675         }
2676
2677         if (mask)
2678                 print_text(COLOR_UNKNOWN_FEATURE_BIT, "  Unknown features "
2679                                                 "(0x%16.16" PRIx64 ")", mask);
2680 }
2681
2682 void packet_print_features_lmp(const uint8_t *features, uint8_t page)
2683 {
2684         print_features(page, features, 0x00);
2685 }
2686
2687 void packet_print_features_ll(const uint8_t *features)
2688 {
2689         print_features(0, features, 0x01);
2690 }
2691
2692 #define LE_STATE_SCAN_ADV               0x0001
2693 #define LE_STATE_CONN_ADV               0x0002
2694 #define LE_STATE_NONCONN_ADV            0x0004
2695 #define LE_STATE_HIGH_DIRECT_ADV        0x0008
2696 #define LE_STATE_LOW_DIRECT_ADV         0x0010
2697 #define LE_STATE_ACTIVE_SCAN            0x0020
2698 #define LE_STATE_PASSIVE_SCAN           0x0040
2699 #define LE_STATE_INITIATING             0x0080
2700 #define LE_STATE_CONN_MASTER            0x0100
2701 #define LE_STATE_CONN_SLAVE             0x0200
2702 #define LE_STATE_MASTER_MASTER          0x0400
2703 #define LE_STATE_SLAVE_SLAVE            0x0800
2704 #define LE_STATE_MASTER_SLAVE           0x1000
2705
2706 static const struct {
2707         uint8_t bit;
2708         const char *str;
2709 } le_states_desc_table[] = {
2710         {  0, "Scannable Advertising State"                     },
2711         {  1, "Connectable Advertising State"                   },
2712         {  2, "Non-connectable Advertising State"               },
2713         {  3, "High Duty Cycle Directed Advertising State"      },
2714         {  4, "Low Duty Cycle Directed Advertising State"       },
2715         {  5, "Active Scanning State"                           },
2716         {  6, "Passive Scanning State"                          },
2717         {  7, "Initiating State"                                },
2718         {  8, "Connection State (Master Role)"                  },
2719         {  9, "Connection State (Slave Role)"                   },
2720         { 10, "Master Role & Master Role"                       },
2721         { 11, "Slave Role & Slave Role"                         },
2722         { 12, "Master Role & Slave Role"                        },
2723         { }
2724 };
2725
2726 static const struct {
2727         uint8_t bit;
2728         uint16_t states;
2729 } le_states_comb_table[] = {
2730         {  0, LE_STATE_NONCONN_ADV                              },
2731         {  1, LE_STATE_SCAN_ADV                                 },
2732         {  2, LE_STATE_CONN_ADV                                 },
2733         {  3, LE_STATE_HIGH_DIRECT_ADV                          },
2734         {  4, LE_STATE_PASSIVE_SCAN                             },
2735         {  5, LE_STATE_ACTIVE_SCAN                              },
2736         {  6, LE_STATE_INITIATING | LE_STATE_CONN_MASTER        },
2737         {  7, LE_STATE_CONN_SLAVE                               },
2738         {  8, LE_STATE_PASSIVE_SCAN | LE_STATE_NONCONN_ADV      },
2739         {  9, LE_STATE_PASSIVE_SCAN | LE_STATE_SCAN_ADV         },
2740         { 10, LE_STATE_PASSIVE_SCAN | LE_STATE_CONN_ADV         },
2741         { 11, LE_STATE_PASSIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV  },
2742         { 12, LE_STATE_ACTIVE_SCAN | LE_STATE_NONCONN_ADV       },
2743         { 13, LE_STATE_ACTIVE_SCAN | LE_STATE_SCAN_ADV          },
2744         { 14, LE_STATE_ACTIVE_SCAN | LE_STATE_CONN_ADV          },
2745         { 15, LE_STATE_ACTIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV   },
2746         { 16, LE_STATE_INITIATING | LE_STATE_NONCONN_ADV        },
2747         { 17, LE_STATE_INITIATING | LE_STATE_SCAN_ADV           },
2748         { 18, LE_STATE_CONN_MASTER | LE_STATE_NONCONN_ADV       },
2749         { 19, LE_STATE_CONN_MASTER | LE_STATE_SCAN_ADV          },
2750         { 20, LE_STATE_CONN_SLAVE | LE_STATE_NONCONN_ADV        },
2751         { 21, LE_STATE_CONN_SLAVE | LE_STATE_SCAN_ADV           },
2752         { 22, LE_STATE_INITIATING | LE_STATE_PASSIVE_SCAN       },
2753         { 23, LE_STATE_INITIATING | LE_STATE_ACTIVE_SCAN        },
2754         { 24, LE_STATE_CONN_MASTER | LE_STATE_PASSIVE_SCAN      },
2755         { 25, LE_STATE_CONN_MASTER | LE_STATE_ACTIVE_SCAN       },
2756         { 26, LE_STATE_CONN_SLAVE | LE_STATE_PASSIVE_SCAN       },
2757         { 27, LE_STATE_CONN_SLAVE | LE_STATE_ACTIVE_SCAN        },
2758         { 28, LE_STATE_INITIATING | LE_STATE_CONN_MASTER |
2759                                         LE_STATE_MASTER_MASTER  },
2760         { 29, LE_STATE_LOW_DIRECT_ADV                           },
2761         { 30, LE_STATE_LOW_DIRECT_ADV | LE_STATE_PASSIVE_SCAN   },
2762         { 31, LE_STATE_LOW_DIRECT_ADV | LE_STATE_ACTIVE_SCAN    },
2763         { 32, LE_STATE_INITIATING | LE_STATE_CONN_ADV |
2764                                         LE_STATE_MASTER_SLAVE   },
2765         { 33, LE_STATE_INITIATING | LE_STATE_HIGH_DIRECT_ADV |
2766                                         LE_STATE_MASTER_SLAVE   },
2767         { 34, LE_STATE_INITIATING | LE_STATE_LOW_DIRECT_ADV |
2768                                         LE_STATE_MASTER_SLAVE   },
2769         { 35, LE_STATE_CONN_MASTER | LE_STATE_CONN_ADV |
2770                                         LE_STATE_MASTER_SLAVE   },
2771         { 36, LE_STATE_CONN_MASTER | LE_STATE_HIGH_DIRECT_ADV |
2772                                         LE_STATE_MASTER_SLAVE   },
2773         { 37, LE_STATE_CONN_MASTER | LE_STATE_LOW_DIRECT_ADV |
2774                                         LE_STATE_MASTER_SLAVE   },
2775         { 38, LE_STATE_CONN_SLAVE | LE_STATE_CONN_ADV |
2776                                         LE_STATE_MASTER_SLAVE   },
2777         { 39, LE_STATE_CONN_SLAVE | LE_STATE_HIGH_DIRECT_ADV |
2778                                         LE_STATE_SLAVE_SLAVE    },
2779         { 40, LE_STATE_CONN_SLAVE | LE_STATE_LOW_DIRECT_ADV |
2780                                         LE_STATE_SLAVE_SLAVE    },
2781         { 41, LE_STATE_INITIATING | LE_STATE_CONN_SLAVE |
2782                                         LE_STATE_MASTER_SLAVE   },
2783         { }
2784 };
2785
2786 static void print_le_states(const uint8_t *states_array)
2787 {
2788         uint64_t mask, states = 0;
2789         int i, n;
2790
2791         for (i = 0; i < 8; i++)
2792                 states |= ((uint64_t) states_array[i]) << (i * 8);
2793
2794         print_field("States: 0x%16.16" PRIx64, states);
2795
2796         mask = states;
2797
2798         for (i = 0; le_states_comb_table[i].states; i++) {
2799                 uint64_t val = (((uint64_t) 1) << le_states_comb_table[i].bit);
2800                 const char *str[3] = { NULL, };
2801                 int num = 0;
2802
2803                 if (!(states & val))
2804                         continue;
2805
2806                 for (n = 0; n < 16; n++) {
2807                         if (le_states_comb_table[i].states & (1 << n))
2808                                 str[num++] = le_states_desc_table[n].str;
2809                 }
2810
2811                 if (num > 0) {
2812                         print_field("  %s", str[0]);
2813                         for (n = 1; n < num; n++)
2814                                 print_field("    and %s", str[n]);
2815                 }
2816
2817                 mask &= ~val;
2818         }
2819
2820         if (mask)
2821                 print_text(COLOR_UNKNOWN_LE_STATES, "  Unknown states "
2822                                                 "(0x%16.16" PRIx64 ")", mask);
2823 }
2824
2825 static void print_le_channel_map(const uint8_t *map)
2826 {
2827         unsigned int count = 0, start = 0;
2828         char str[11];
2829         int i, n;
2830
2831         for (i = 0; i < 5; i++)
2832                 sprintf(str + (i * 2), "%2.2x", map[i]);
2833
2834         print_field("Channel map: 0x%s", str);
2835
2836         for (i = 0; i < 5; i++) {
2837                 for (n = 0; n < 8; n++) {
2838                         if (map[i] & (1 << n)) {
2839                                 if (count == 0)
2840                                         start = (i * 8) + n;
2841                                 count++;
2842                                 continue;
2843                         }
2844
2845                         if (count > 1) {
2846                                 print_field("  Channel %u-%u",
2847                                                 start, start + count - 1);
2848                                 count = 0;
2849                         } else if (count > 0) {
2850                                 print_field("  Channel %u", start);
2851                                 count = 0;
2852                         }
2853                 }
2854         }
2855 }
2856
2857 void packet_print_channel_map_ll(const uint8_t *map)
2858 {
2859         print_le_channel_map(map);
2860 }
2861
2862 static void print_random_number(uint64_t rand)
2863 {
2864         print_field("Random number: 0x%16.16" PRIx64, le64_to_cpu(rand));
2865 }
2866
2867 static void print_encrypted_diversifier(uint16_t ediv)
2868 {
2869         print_field("Encrypted diversifier: 0x%4.4x", le16_to_cpu(ediv));
2870 }
2871
2872 static const struct {
2873         uint8_t bit;
2874         const char *str;
2875 } events_table[] = {
2876         {  0, "Inquiry Complete"                                        },
2877         {  1, "Inquiry Result"                                          },
2878         {  2, "Connection Complete"                                     },
2879         {  3, "Connection Request"                                      },
2880         {  4, "Disconnection Complete"                                  },
2881         {  5, "Authentication Complete"                                 },
2882         {  6, "Remote Name Request Complete"                            },
2883         {  7, "Encryption Change"                                       },
2884         {  8, "Change Connection Link Key Complete"                     },
2885         {  9, "Master Link Key Complete"                                },
2886         { 10, "Read Remote Supported Features Complete"                 },
2887         { 11, "Read Remote Version Information Complete"                },
2888         { 12, "QoS Setup Complete"                                      },
2889         { 13, "Command Complete"                                        },
2890         { 14, "Command Status"                                          },
2891         { 15, "Hardware Error"                                          },
2892         { 16, "Flush Occurred"                                          },
2893         { 17, "Role Change"                                             },
2894         { 18, "Number of Completed Packets"                             },
2895         { 19, "Mode Change"                                             },
2896         { 20, "Return Link Keys"                                        },
2897         { 21, "PIN Code Request"                                        },
2898         { 22, "Link Key Request"                                        },
2899         { 23, "Link Key Notification"                                   },
2900         { 24, "Loopback Command"                                        },
2901         { 25, "Data Buffer Overflow"                                    },
2902         { 26, "Max Slots Change"                                        },
2903         { 27, "Read Clock Offset Complete"                              },
2904         { 28, "Connection Packet Type Changed"                          },
2905         { 29, "QoS Violation"                                           },
2906         { 30, "Page Scan Mode Change"                                   },
2907         { 31, "Page Scan Repetition Mode Change"                        },
2908         { 32, "Flow Specification Complete"                             },
2909         { 33, "Inquiry Result with RSSI"                                },
2910         { 34, "Read Remote Extended Features Complete"                  },
2911         { 43, "Synchronous Connection Complete"                         },
2912         { 44, "Synchronous Connection Changed"                          },
2913         { 45, "Sniff Subrating"                                         },
2914         { 46, "Extended Inquiry Result"                                 },
2915         { 47, "Encryption Key Refresh Complete"                         },
2916         { 48, "IO Capability Request"                                   },
2917         { 49, "IO Capability Request Reply"                             },
2918         { 50, "User Confirmation Request"                               },
2919         { 51, "User Passkey Request"                                    },
2920         { 52, "Remote OOB Data Request"                                 },
2921         { 53, "Simple Pairing Complete"                                 },
2922         { 55, "Link Supervision Timeout Changed"                        },
2923         { 56, "Enhanced Flush Complete"                                 },
2924         { 58, "User Passkey Notification"                               },
2925         { 59, "Keypress Notification"                                   },
2926         { 60, "Remote Host Supported Features Notification"             },
2927         { 61, "LE Meta"                                                 },
2928         { }
2929 };
2930
2931 static void print_event_mask(const uint8_t *events_array)
2932 {
2933         uint64_t mask, events = 0;
2934         int i;
2935
2936         for (i = 0; i < 8; i++)
2937                 events |= ((uint64_t) events_array[i]) << (i * 8);
2938
2939         print_field("Mask: 0x%16.16" PRIx64, events);
2940
2941         mask = events;
2942
2943         for (i = 0; events_table[i].str; i++) {
2944                 if (events & (((uint64_t) 1) << events_table[i].bit)) {
2945                         print_field("  %s", events_table[i].str);
2946                         mask &= ~(((uint64_t) 1) << events_table[i].bit);
2947                 }
2948         }
2949
2950         if (mask)
2951                 print_text(COLOR_UNKNOWN_EVENT_MASK, "  Unknown mask "
2952                                                 "(0x%16.16" PRIx64 ")", mask);
2953 }
2954
2955 static const struct {
2956         uint8_t bit;
2957         const char *str;
2958 } events_page2_table[] = {
2959         {  0, "Physical Link Complete"                                  },
2960         {  1, "Channel Selected"                                        },
2961         {  2, "Disconnection Physical Link Complete"                    },
2962         {  3, "Physical Link Loss Early Warning"                        },
2963         {  4, "Physical Link Recovery"                                  },
2964         {  5, "Logical Link Complete"                                   },
2965         {  6, "Disconnection Logical Link Complete"                     },
2966         {  7, "Flow Specification Modify Complete"                      },
2967         {  8, "Number of Completed Data Blocks"                         },
2968         {  9, "AMP Start Test"                                          },
2969         { 10, "AMP Test End"                                            },
2970         { 11, "AMP Receiver Report"                                     },
2971         { 12, "Short Range Mode Change Complete"                        },
2972         { 13, "AMP Status Change"                                       },
2973         { 14, "Triggered Clock Capture"                                 },
2974         { 15, "Synchronization Train Complete"                          },
2975         { 16, "Synchronization Train Received"                          },
2976         { 17, "Connectionless Slave Broadcast Receive"                  },
2977         { 18, "Connectionless Slave Broadcast Timeout"                  },
2978         { 19, "Truncated Page Complete"                                 },
2979         { 20, "Slave Page Response Timeout"                             },
2980         { 21, "Connectionless Slave Broadcast Channel Map Change"       },
2981         { 22, "Inquiry Response Notification"                           },
2982         { 23, "Authenticated Payload Timeout Expired"                   },
2983         { }
2984 };
2985
2986 static void print_event_mask_page2(const uint8_t *events_array)
2987 {
2988         uint64_t mask, events = 0;
2989         int i;
2990
2991         for (i = 0; i < 8; i++)
2992                 events |= ((uint64_t) events_array[i]) << (i * 8);
2993
2994         print_field("Mask: 0x%16.16" PRIx64, events);
2995
2996         mask = events;
2997
2998         for (i = 0; events_page2_table[i].str; i++) {
2999                 if (events & (((uint64_t) 1) << events_page2_table[i].bit)) {
3000                         print_field("  %s", events_page2_table[i].str);
3001                         mask &= ~(((uint64_t) 1) << events_page2_table[i].bit);
3002                 }
3003         }
3004
3005         if (mask)
3006                 print_text(COLOR_UNKNOWN_EVENT_MASK, "  Unknown mask "
3007                                                 "(0x%16.16" PRIx64 ")", mask);
3008 }
3009
3010 static const struct {
3011         uint8_t bit;
3012         const char *str;
3013 } events_le_table[] = {
3014         {  0, "LE Connection Complete"                  },
3015         {  1, "LE Advertising Report"                   },
3016         {  2, "LE Connection Update Complete"           },
3017         {  3, "LE Read Remote Used Features Complete"   },
3018         {  4, "LE Long Term Key Request"                },
3019         {  5, "LE Remote Connection Parameter Request"  },
3020         {  6, "LE Data Length Change"                   },
3021         {  7, "LE Read Local P-256 Public Key Complete" },
3022         {  8, "LE Generate DHKey Complete"              },
3023         {  9, "LE Enhanced Connection Complete"         },
3024         { 10, "LE Direct Advertising Report"            },
3025         { }
3026 };
3027
3028 static void print_event_mask_le(const uint8_t *events_array)
3029 {
3030         uint64_t mask, events = 0;
3031         int i;
3032
3033         for (i = 0; i < 8; i++)
3034                 events |= ((uint64_t) events_array[i]) << (i * 8);
3035
3036         print_field("Mask: 0x%16.16" PRIx64, events);
3037
3038         mask = events;
3039
3040         for (i = 0; events_le_table[i].str; i++) {
3041                 if (events & (((uint64_t) 1) << events_le_table[i].bit)) {
3042                         print_field("  %s", events_le_table[i].str);
3043                         mask &= ~(((uint64_t) 1) << events_le_table[i].bit);
3044                 }
3045         }
3046
3047         if (mask)
3048                 print_text(COLOR_UNKNOWN_EVENT_MASK, "  Unknown mask "
3049                                                 "(0x%16.16" PRIx64 ")", mask);
3050 }
3051
3052 static void print_fec(uint8_t fec)
3053 {
3054         const char *str;
3055
3056         switch (fec) {
3057         case 0x00:
3058                 str = "Not required";
3059                 break;
3060         case 0x01:
3061                 str = "Required";
3062                 break;
3063         default:
3064                 str = "Reserved";
3065                 break;
3066         }
3067
3068         print_field("FEC: %s (0x%02x)", str, fec);
3069 }
3070
3071 #define BT_EIR_FLAGS                    0x01
3072 #define BT_EIR_UUID16_SOME              0x02
3073 #define BT_EIR_UUID16_ALL               0x03
3074 #define BT_EIR_UUID32_SOME              0x04
3075 #define BT_EIR_UUID32_ALL               0x05
3076 #define BT_EIR_UUID128_SOME             0x06
3077 #define BT_EIR_UUID128_ALL              0x07
3078 #define BT_EIR_NAME_SHORT               0x08
3079 #define BT_EIR_NAME_COMPLETE            0x09
3080 #define BT_EIR_TX_POWER                 0x0a
3081 #define BT_EIR_CLASS_OF_DEV             0x0d
3082 #define BT_EIR_SSP_HASH_P192            0x0e
3083 #define BT_EIR_SSP_RANDOMIZER_P192      0x0f
3084 #define BT_EIR_DEVICE_ID                0x10
3085 #define BT_EIR_SMP_TK                   0x10
3086 #define BT_EIR_SMP_OOB_FLAGS            0x11
3087 #define BT_EIR_SLAVE_CONN_INTERVAL      0x12
3088 #define BT_EIR_SERVICE_UUID16           0x14
3089 #define BT_EIR_SERVICE_UUID128          0x15
3090 #define BT_EIR_SERVICE_DATA             0x16
3091 #define BT_EIR_PUBLIC_ADDRESS           0x17
3092 #define BT_EIR_RANDOM_ADDRESS           0x18
3093 #define BT_EIR_GAP_APPEARANCE           0x19
3094 #define BT_EIR_ADVERTISING_INTERVAL     0x1a
3095 #define BT_EIR_LE_DEVICE_ADDRESS        0x1b
3096 #define BT_EIR_LE_ROLE                  0x1c
3097 #define BT_EIR_SSP_HASH_P256            0x1d
3098 #define BT_EIR_SSP_RANDOMIZER_P256      0x1e
3099 #define BT_EIR_3D_INFO_DATA             0x3d
3100 #define BT_EIR_MANUFACTURER_DATA        0xff
3101
3102 static void print_manufacturer_apple(const void *data, uint8_t data_len)
3103 {
3104         uint8_t type = *((uint8_t *) data);
3105
3106         if (data_len < 1)
3107                 return;
3108
3109         if (type == 0x01) {
3110                 char identifier[100];
3111
3112                 snprintf(identifier, sizeof(identifier) - 1, "%s",
3113                                                 (const char *) (data + 1));
3114
3115                 print_field("  Identifier: %s", identifier);
3116                 return;
3117         }
3118
3119         while (data_len > 0) {
3120                 uint8_t len;
3121                 const char *str;
3122
3123                 type = *((uint8_t *) data);
3124                 data++;
3125                 data_len--;
3126
3127                 if (type == 0x00)
3128                         continue;
3129
3130                 if (data_len < 1)
3131                         break;
3132
3133                 switch (type) {
3134                 case 0x02:
3135                         str = "iBeacon";
3136                         break;
3137                 case 0x05:
3138                         str = "AirDrop";
3139                         break;
3140                 case 0x09:
3141                         str = "Apple TV";
3142                         break;
3143                 default:
3144                         str = "Unknown";
3145                         break;
3146                 }
3147
3148                 print_field("  Type: %s (%u)", str, type);
3149
3150                 len = *((uint8_t *) data);
3151                 data++;
3152                 data_len--;
3153
3154                 if (len < 1)
3155                         continue;
3156
3157                 if (len > data_len)
3158                         break;
3159
3160                 if (type == 0x02 && len == 0x15) {
3161                         const uint8_t *uuid;
3162                         uint16_t minor, major;
3163                         int8_t tx_power;
3164
3165                         uuid = data;
3166                         print_field("  UUID: %8.8x-%4.4x-%4.4x-%4.4x-%8.8x%4.4x",
3167                                 get_le32(&uuid[12]), get_le16(&uuid[10]),
3168                                 get_le16(&uuid[8]), get_le16(&uuid[6]),
3169                                 get_le32(&uuid[2]), get_le16(&uuid[0]));
3170
3171                         major = get_le16(data + 16);
3172                         minor = get_le16(data + 18);
3173                         print_field("  Version: %u.%u", major, minor);
3174
3175                         tx_power = *(int8_t *) (data + 20);
3176                         print_field("  TX power: %d dB", tx_power);
3177                 } else
3178                         print_hex_field("  Data", data, len);
3179
3180                 data += len;
3181                 data_len -= len;
3182         }
3183
3184         packet_hexdump(data, data_len);
3185 }
3186
3187 static void print_manufacturer_data(const void *data, uint8_t data_len)
3188 {
3189         uint16_t company = get_le16(data);
3190
3191         packet_print_company("Company", company);
3192
3193         switch (company) {
3194         case 76:
3195         case 19456:
3196                 print_manufacturer_apple(data + 2, data_len - 2);
3197                 break;
3198         default:
3199                 print_hex_field("  Data", data + 2, data_len - 2);
3200                 break;
3201         }
3202 }
3203
3204 static void print_device_id(const void *data, uint8_t data_len)
3205 {
3206         uint16_t source, vendor, product, version;
3207         char modalias[26], *vendor_str, *product_str;
3208         const char *str;
3209
3210         if (data_len < 8)
3211                 return;
3212
3213         source = get_le16(data);
3214         vendor = get_le16(data + 2);
3215         product = get_le16(data + 4);
3216         version = get_le16(data + 6);
3217
3218         switch (source) {
3219         case 0x0001:
3220                 str = "Bluetooth SIG assigned";
3221                 sprintf(modalias, "bluetooth:v%04Xp%04Xd%04X",
3222                                                 vendor, product, version);
3223                 break;
3224         case 0x0002:
3225                 str = "USB Implementer's Forum assigned";
3226                 sprintf(modalias, "usb:v%04Xp%04Xd%04X",
3227                                                 vendor, product, version);
3228                 break;
3229         default:
3230                 str = "Reserved";
3231                 modalias[0] = '\0';
3232                 break;
3233         }
3234
3235         print_field("Device ID: %s (0x%4.4x)", str, source);
3236
3237         if (!hwdb_get_vendor_model(modalias, &vendor_str, &product_str)) {
3238                 vendor_str = NULL;
3239                 product_str = NULL;
3240         }
3241
3242         if (source != 0x0001) {
3243                 if (vendor_str)
3244                         print_field("  Vendor: %s (0x%4.4x)",
3245                                                 vendor_str, vendor);
3246                 else
3247                         print_field("  Vendor: 0x%4.4x", vendor);
3248         } else
3249                 packet_print_company("  Vendor", vendor);
3250
3251         if (product_str)
3252                 print_field("  Product: %s (0x%4.4x)", product_str, product);
3253         else
3254                 print_field("  Product: 0x%4.4x", product);
3255
3256         print_field("  Version: %u.%u.%u (0x%4.4x)",
3257                                         (version & 0xff00) >> 8,
3258                                         (version & 0x00f0) >> 4,
3259                                         (version & 0x000f), version);
3260
3261         free(vendor_str);
3262         free(product_str);
3263 }
3264
3265 static void print_uuid16_list(const char *label, const void *data,
3266                                                         uint8_t data_len)
3267 {
3268         uint8_t count = data_len / sizeof(uint16_t);
3269         unsigned int i;
3270
3271         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3272
3273         for (i = 0; i < count; i++) {
3274                 uint16_t uuid = get_le16(data + (i * 2));
3275                 print_field("  %s (0x%4.4x)", uuid16_to_str(uuid), uuid);
3276         }
3277 }
3278
3279 static void print_uuid32_list(const char *label, const void *data,
3280                                                         uint8_t data_len)
3281 {
3282         uint8_t count = data_len / sizeof(uint32_t);
3283         unsigned int i;
3284
3285         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3286
3287         for (i = 0; i < count; i++) {
3288                 uint32_t uuid = get_le32(data + (i * 4));
3289                 print_field("  %s (0x%8.8x)", uuid32_to_str(uuid), uuid);
3290         }
3291 }
3292
3293 static void print_uuid128_list(const char *label, const void *data,
3294                                                         uint8_t data_len)
3295 {
3296         uint8_t count = data_len / 16;
3297         unsigned int i;
3298
3299         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3300
3301         for (i = 0; i < count; i++) {
3302                 const uint8_t *uuid = data + (i * 16);
3303
3304                 print_field("  %8.8x-%4.4x-%4.4x-%4.4x-%8.8x%4.4x",
3305                                 get_le32(&uuid[12]), get_le16(&uuid[10]),
3306                                 get_le16(&uuid[8]), get_le16(&uuid[6]),
3307                                 get_le32(&uuid[2]), get_le16(&uuid[0]));
3308         }
3309 }
3310
3311 static const struct {
3312         uint8_t bit;
3313         const char *str;
3314 } eir_flags_table[] = {
3315         { 0, "LE Limited Discoverable Mode"             },
3316         { 1, "LE General Discoverable Mode"             },
3317         { 2, "BR/EDR Not Supported"                     },
3318         { 3, "Simultaneous LE and BR/EDR (Controller)"  },
3319         { 4, "Simultaneous LE and BR/EDR (Host)"        },
3320         { }
3321 };
3322
3323 static const struct {
3324         uint8_t bit;
3325         const char *str;
3326 } eir_3d_table[] = {
3327         { 0, "Association Notification"                                 },
3328         { 1, "Battery Level Reporting"                                  },
3329         { 2, "Send Battery Level Report on Start-up Synchronization"    },
3330         { 7, "Factory Test Mode"                                        },
3331         { }
3332 };
3333
3334 static void print_eir(const uint8_t *eir, uint8_t eir_len, bool le)
3335 {
3336         uint16_t len = 0;
3337
3338         if (eir_len == 0)
3339                 return;
3340
3341         while (len < eir_len - 1) {
3342                 uint8_t field_len = eir[0];
3343                 const uint8_t *data = &eir[2];
3344                 uint8_t data_len;
3345                 char name[239], label[100];
3346                 uint8_t flags, mask;
3347                 int i;
3348
3349                 /* Check for the end of EIR */
3350                 if (field_len == 0)
3351                         break;
3352
3353                 len += field_len + 1;
3354
3355                 /* Do not continue EIR Data parsing if got incorrect length */
3356                 if (len > eir_len) {
3357                         len -= field_len + 1;
3358                         break;
3359                 }
3360
3361                 data_len = field_len - 1;
3362
3363                 switch (eir[1]) {
3364                 case BT_EIR_FLAGS:
3365                         flags = *data;
3366                         mask = flags;
3367
3368                         print_field("Flags: 0x%2.2x", flags);
3369
3370                         for (i = 0; eir_flags_table[i].str; i++) {
3371                                 if (flags & (1 << eir_flags_table[i].bit)) {
3372                                         print_field("  %s",
3373                                                         eir_flags_table[i].str);
3374                                         mask &= ~(1 << eir_flags_table[i].bit);
3375                                 }
3376                         }
3377
3378                         if (mask)
3379                                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
3380                                         "  Unknown flags (0x%2.2x)", mask);
3381                         break;
3382
3383                 case BT_EIR_UUID16_SOME:
3384                         if (data_len < sizeof(uint16_t))
3385                                 break;
3386                         print_uuid16_list("16-bit Service UUIDs (partial)",
3387                                                         data, data_len);
3388                         break;
3389
3390                 case BT_EIR_UUID16_ALL:
3391                         if (data_len < sizeof(uint16_t))
3392                                 break;
3393                         print_uuid16_list("16-bit Service UUIDs (complete)",
3394                                                         data, data_len);
3395                         break;
3396
3397                 case BT_EIR_UUID32_SOME:
3398                         if (data_len < sizeof(uint32_t))
3399                                 break;
3400                         print_uuid32_list("32-bit Service UUIDs (partial)",
3401                                                         data, data_len);
3402                         break;
3403
3404                 case BT_EIR_UUID32_ALL:
3405                         if (data_len < sizeof(uint32_t))
3406                                 break;
3407                         print_uuid32_list("32-bit Service UUIDs (complete)",
3408                                                         data, data_len);
3409                         break;
3410
3411                 case BT_EIR_UUID128_SOME:
3412                         if (data_len < 16)
3413                                 break;
3414                         print_uuid128_list("128-bit Service UUIDs (partial)",
3415                                                                 data, data_len);
3416                         break;
3417
3418                 case BT_EIR_UUID128_ALL:
3419                         if (data_len < 16)
3420                                 break;
3421                         print_uuid128_list("128-bit Service UUIDs (complete)",
3422                                                                 data, data_len);
3423                         break;
3424
3425                 case BT_EIR_NAME_SHORT:
3426                         memset(name, 0, sizeof(name));
3427                         memcpy(name, data, data_len);
3428                         print_field("Name (short): %s", name);
3429                         break;
3430
3431                 case BT_EIR_NAME_COMPLETE:
3432                         memset(name, 0, sizeof(name));
3433                         memcpy(name, data, data_len);
3434                         print_field("Name (complete): %s", name);
3435                         break;
3436
3437                 case BT_EIR_TX_POWER:
3438                         if (data_len < 1)
3439                                 break;
3440                         print_field("TX power: %d dBm", (int8_t) *data);
3441                         break;
3442
3443                 case BT_EIR_CLASS_OF_DEV:
3444                         if (data_len < 3)
3445                                 break;
3446                         print_dev_class(data);
3447                         break;
3448
3449                 case BT_EIR_SSP_HASH_P192:
3450                         if (data_len < 16)
3451                                 break;
3452                         print_hash_p192(data);
3453                         break;
3454
3455                 case BT_EIR_SSP_RANDOMIZER_P192:
3456                         if (data_len < 16)
3457                                 break;
3458                         print_randomizer_p192(data);
3459                         break;
3460
3461                 case BT_EIR_DEVICE_ID:
3462                         /* SMP TK has the same value as Device ID */
3463                         if (le)
3464                                 print_hex_field("SMP TK", data, data_len);
3465                         else if (data_len >= 8)
3466                                 print_device_id(data, data_len);
3467                         break;
3468
3469                 case BT_EIR_SMP_OOB_FLAGS:
3470                         print_field("SMP OOB Flags: 0x%2.2x", *data);
3471                         break;
3472
3473                 case BT_EIR_SLAVE_CONN_INTERVAL:
3474                         if (data_len < 4)
3475                                 break;
3476                         print_field("Slave Conn. Interval: 0x%4.4x - 0x%4.4x",
3477                                                         get_le16(&data[0]),
3478                                                         get_le16(&data[2]));
3479                         break;
3480
3481                 case BT_EIR_SERVICE_UUID16:
3482                         if (data_len < sizeof(uint16_t))
3483                                 break;
3484                         print_uuid16_list("16-bit Service UUIDs",
3485                                                         data, data_len);
3486                         break;
3487
3488                 case BT_EIR_SERVICE_UUID128:
3489                         if (data_len < 16)
3490                                 break;
3491                         print_uuid128_list("128-bit Service UUIDs",
3492                                                         data, data_len);
3493                         break;
3494
3495                 case BT_EIR_SERVICE_DATA:
3496                         if (data_len < 2)
3497                                 break;
3498                         sprintf(label, "Service Data (UUID 0x%4.4x)",
3499                                                         get_le16(&data[0]));
3500                         print_hex_field(label, &data[2], data_len - 2);
3501                         break;
3502
3503                 case BT_EIR_RANDOM_ADDRESS:
3504                         if (data_len < 6)
3505                                 break;
3506                         print_addr("Random Address", data, 0x01);
3507                         break;
3508
3509                 case BT_EIR_PUBLIC_ADDRESS:
3510                         if (data_len < 6)
3511                                 break;
3512                         print_addr("Public Address", data, 0x00);
3513                         break;
3514
3515                 case BT_EIR_GAP_APPEARANCE:
3516                         if (data_len < 2)
3517                                 break;
3518                         print_appearance(get_le16(data));
3519                         break;
3520
3521                 case BT_EIR_SSP_HASH_P256:
3522                         if (data_len < 16)
3523                                 break;
3524                         print_hash_p256(data);
3525                         break;
3526
3527                 case BT_EIR_SSP_RANDOMIZER_P256:
3528                         if (data_len < 16)
3529                                 break;
3530                         print_randomizer_p256(data);
3531                         break;
3532
3533                 case BT_EIR_3D_INFO_DATA:
3534                         print_hex_field("3D Information Data", data, data_len);
3535                         if (data_len < 2)
3536                                 break;
3537
3538                         flags = *data;
3539                         mask = flags;
3540
3541                         print_field("  Features: 0x%2.2x", flags);
3542
3543                         for (i = 0; eir_3d_table[i].str; i++) {
3544                                 if (flags & (1 << eir_3d_table[i].bit)) {
3545                                         print_field("    %s",
3546                                                         eir_3d_table[i].str);
3547                                         mask &= ~(1 << eir_3d_table[i].bit);
3548                                 }
3549                         }
3550
3551                         if (mask)
3552                                 print_text(COLOR_UNKNOWN_FEATURE_BIT,
3553                                         "      Unknown features (0x%2.2x)", mask);
3554
3555                         print_field("  Path Loss Threshold: %d", data[1]);
3556                         break;
3557
3558                 case BT_EIR_MANUFACTURER_DATA:
3559                         if (data_len < 2)
3560                                 break;
3561                         print_manufacturer_data(data, data_len);
3562                         break;
3563
3564                 default:
3565                         sprintf(label, "Unknown EIR field 0x%2.2x", eir[1]);
3566                         print_hex_field(label, data, data_len);
3567                         break;
3568                 }
3569
3570                 eir += field_len + 1;
3571         }
3572
3573         if (len < eir_len && eir[0] != 0)
3574                 packet_hexdump(eir, eir_len - len);
3575 }
3576
3577 void packet_print_addr(const char *label, const void *data, bool random)
3578 {
3579         print_addr(label ? : "Address", data, random ? 0x01 : 0x00);
3580 }
3581
3582 void packet_print_ad(const void *data, uint8_t size)
3583 {
3584         print_eir(data, size, true);
3585 }
3586
3587 struct broadcast_message {
3588         uint32_t frame_sync_instant;
3589         uint16_t bluetooth_clock_phase;
3590         uint16_t left_open_offset;
3591         uint16_t left_close_offset;
3592         uint16_t right_open_offset;
3593         uint16_t right_close_offset;
3594         uint16_t frame_sync_period;
3595         uint8_t  frame_sync_period_fraction;
3596 } __attribute__ ((packed));
3597
3598 static void print_3d_broadcast(const void *data, uint8_t size)
3599 {
3600         const struct broadcast_message *msg = data;
3601         uint32_t instant;
3602         uint16_t left_open, left_close, right_open, right_close;
3603         uint16_t phase, period;
3604         uint8_t period_frac;
3605         bool mode;
3606
3607         instant = le32_to_cpu(msg->frame_sync_instant);
3608         mode = !!(instant & 0x40000000);
3609         phase = le16_to_cpu(msg->bluetooth_clock_phase);
3610         left_open = le16_to_cpu(msg->left_open_offset);
3611         left_close = le16_to_cpu(msg->left_close_offset);
3612         right_open = le16_to_cpu(msg->right_open_offset);
3613         right_close = le16_to_cpu(msg->right_close_offset);
3614         period = le16_to_cpu(msg->frame_sync_period);
3615         period_frac = msg->frame_sync_period_fraction;
3616
3617         print_field("  Frame sync instant: 0x%8.8x", instant & 0x7fffffff);
3618         print_field("  Video mode: %s (%d)", mode ? "Dual View" : "3D", mode);
3619         print_field("  Bluetooth clock phase: %d usec (0x%4.4x)",
3620                                                 phase, phase);
3621         print_field("  Left lense shutter open offset: %d usec (0x%4.4x)",
3622                                                 left_open, left_open);
3623         print_field("  Left lense shutter close offset: %d usec (0x%4.4x)",
3624                                                 left_close, left_close);
3625         print_field("  Right lense shutter open offset: %d usec (0x%4.4x)",
3626                                                 right_open, right_open);
3627         print_field("  Right lense shutter close offset: %d usec (0x%4.4x)",
3628                                                 right_close, right_close);
3629         print_field("  Frame sync period: %d.%d usec (0x%4.4x 0x%2.2x)",
3630                                                 period, period_frac * 256,
3631                                                 period, period_frac);
3632 }
3633
3634 void packet_hexdump(const unsigned char *buf, uint16_t len)
3635 {
3636         static const char hexdigits[] = "0123456789abcdef";
3637         char str[68];
3638         uint16_t i;
3639
3640         if (!len)
3641                 return;
3642
3643         for (i = 0; i < len; i++) {
3644                 str[((i % 16) * 3) + 0] = hexdigits[buf[i] >> 4];
3645                 str[((i % 16) * 3) + 1] = hexdigits[buf[i] & 0xf];
3646                 str[((i % 16) * 3) + 2] = ' ';
3647                 str[(i % 16) + 49] = isprint(buf[i]) ? buf[i] : '.';
3648
3649                 if ((i + 1) % 16 == 0) {
3650                         str[47] = ' ';
3651                         str[48] = ' ';
3652                         str[65] = '\0';
3653                         print_text(COLOR_WHITE, "%s", str);
3654                         str[0] = ' ';
3655                 }
3656         }
3657
3658         if (i % 16 > 0) {
3659                 uint16_t j;
3660                 for (j = (i % 16); j < 16; j++) {
3661                         str[(j * 3) + 0] = ' ';
3662                         str[(j * 3) + 1] = ' ';
3663                         str[(j * 3) + 2] = ' ';
3664                         str[j + 49] = ' ';
3665                 }
3666                 str[47] = ' ';
3667                 str[48] = ' ';
3668                 str[65] = '\0';
3669                 print_text(COLOR_WHITE, "%s", str);
3670         }
3671 }
3672
3673 void packet_control(struct timeval *tv, struct ucred *cred,
3674                                         uint16_t index, uint16_t opcode,
3675                                         const void *data, uint16_t size)
3676 {
3677         if (index_filter && index_number != index)
3678                 return;
3679
3680         control_message(opcode, data, size);
3681 }
3682
3683 static int addr2str(const uint8_t *addr, char *str)
3684 {
3685         return sprintf(str, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
3686                         addr[5], addr[4], addr[3], addr[2], addr[1], addr[0]);
3687 }
3688
3689 #define MAX_INDEX 16
3690
3691 struct index_data {
3692         uint8_t  type;
3693         uint8_t  bdaddr[6];
3694         uint16_t manufacturer;
3695 };
3696
3697 static struct index_data index_list[MAX_INDEX];
3698
3699 void packet_monitor(struct timeval *tv, struct ucred *cred,
3700                                         uint16_t index, uint16_t opcode,
3701                                         const void *data, uint16_t size)
3702 {
3703         const struct btsnoop_opcode_new_index *ni;
3704         const struct btsnoop_opcode_index_info *ii;
3705         const struct btsnoop_opcode_user_logging *ul;
3706         char str[18], extra_str[24];
3707         uint16_t manufacturer;
3708         const char *ident;
3709
3710         if (index_filter && index_number != index)
3711                 return;
3712
3713         index_current = index;
3714
3715         if (tv && time_offset == ((time_t) -1))
3716                 time_offset = tv->tv_sec;
3717
3718         switch (opcode) {
3719         case BTSNOOP_OPCODE_NEW_INDEX:
3720                 ni = data;
3721
3722                 if (index < MAX_INDEX) {
3723                         index_list[index].type = ni->type;
3724                         memcpy(index_list[index].bdaddr, ni->bdaddr, 6);
3725                         index_list[index].manufacturer = UNKNOWN_MANUFACTURER;
3726                 }
3727
3728                 addr2str(ni->bdaddr, str);
3729                 packet_new_index(tv, index, str, ni->type, ni->bus, ni->name);
3730                 break;
3731         case BTSNOOP_OPCODE_DEL_INDEX:
3732                 if (index < MAX_INDEX)
3733                         addr2str(index_list[index].bdaddr, str);
3734                 else
3735                         sprintf(str, "00:00:00:00:00:00");
3736
3737                 packet_del_index(tv, index, str);
3738                 break;
3739         case BTSNOOP_OPCODE_COMMAND_PKT:
3740                 packet_hci_command(tv, cred, index, data, size);
3741                 break;
3742         case BTSNOOP_OPCODE_EVENT_PKT:
3743                 packet_hci_event(tv, cred, index, data, size);
3744                 break;
3745         case BTSNOOP_OPCODE_ACL_TX_PKT:
3746                 packet_hci_acldata(tv, cred, index, false, data, size);
3747                 break;
3748         case BTSNOOP_OPCODE_ACL_RX_PKT:
3749                 packet_hci_acldata(tv, cred, index, true, data, size);
3750                 break;
3751         case BTSNOOP_OPCODE_SCO_TX_PKT:
3752                 packet_hci_scodata(tv, cred, index, false, data, size);
3753                 break;
3754         case BTSNOOP_OPCODE_SCO_RX_PKT:
3755                 packet_hci_scodata(tv, cred, index, true, data, size);
3756                 break;
3757         case BTSNOOP_OPCODE_OPEN_INDEX:
3758                 if (index < MAX_INDEX)
3759                         addr2str(index_list[index].bdaddr, str);
3760                 else
3761                         sprintf(str, "00:00:00:00:00:00");
3762
3763                 packet_open_index(tv, index, str);
3764                 break;
3765         case BTSNOOP_OPCODE_CLOSE_INDEX:
3766                 if (index < MAX_INDEX)
3767                         addr2str(index_list[index].bdaddr, str);
3768                 else
3769                         sprintf(str, "00:00:00:00:00:00");
3770
3771                 packet_close_index(tv, index, str);
3772                 break;
3773         case BTSNOOP_OPCODE_INDEX_INFO:
3774                 ii = data;
3775                 manufacturer = le16_to_cpu(ii->manufacturer);
3776
3777                 if (index < MAX_INDEX) {
3778                         memcpy(index_list[index].bdaddr, ii->bdaddr, 6);
3779                         index_list[index].manufacturer = manufacturer;
3780                 }
3781
3782                 addr2str(ii->bdaddr, str);
3783                 packet_index_info(tv, index, str, manufacturer);
3784                 break;
3785         case BTSNOOP_OPCODE_VENDOR_DIAG:
3786                 if (index < MAX_INDEX)
3787                         manufacturer = index_list[index].manufacturer;
3788                 else
3789                         manufacturer = UNKNOWN_MANUFACTURER;
3790
3791                 packet_vendor_diag(tv, index, manufacturer, data, size);
3792                 break;
3793         case BTSNOOP_OPCODE_SYSTEM_NOTE:
3794                 packet_system_note(tv, cred, index, data);
3795                 break;
3796         case BTSNOOP_OPCODE_USER_LOGGING:
3797                 ul = data;
3798                 ident = ul->ident_len ? data + sizeof(*ul) : NULL;
3799
3800                 packet_user_logging(tv, cred, index, ul->priority, ident,
3801                                         data + sizeof(*ul) + ul->ident_len);
3802                 break;
3803         default:
3804                 sprintf(extra_str, "(code %d len %d)", opcode, size);
3805                 print_packet(tv, cred, index, '*', COLOR_ERROR,
3806                                         "Unknown packet", NULL, extra_str);
3807                 packet_hexdump(data, size);
3808                 break;
3809         }
3810 }
3811
3812 void packet_simulator(struct timeval *tv, uint16_t frequency,
3813                                         const void *data, uint16_t size)
3814 {
3815         char str[10];
3816
3817         if (tv && time_offset == ((time_t) -1))
3818                 time_offset = tv->tv_sec;
3819
3820         sprintf(str, "%u MHz", frequency);
3821
3822         print_packet(tv, NULL, 0, '*', COLOR_PHY_PACKET,
3823                                         "Physical packet:", NULL, str);
3824
3825         ll_packet(frequency, data, size, false);
3826 }
3827
3828 static void null_cmd(const void *data, uint8_t size)
3829 {
3830 }
3831
3832 static void status_rsp(const void *data, uint8_t size)
3833 {
3834         uint8_t status = *((const uint8_t *) data);
3835
3836         print_status(status);
3837 }
3838
3839 static void status_bdaddr_rsp(const void *data, uint8_t size)
3840 {
3841         uint8_t status = *((const uint8_t *) data);
3842
3843         print_status(status);
3844         print_bdaddr(data + 1);
3845 }
3846
3847 static void inquiry_cmd(const void *data, uint8_t size)
3848 {
3849         const struct bt_hci_cmd_inquiry *cmd = data;
3850
3851         print_iac(cmd->lap);
3852         print_field("Length: %.2fs (0x%2.2x)",
3853                                 cmd->length * 1.28, cmd->length);
3854         print_num_resp(cmd->num_resp);
3855 }
3856
3857 static void periodic_inquiry_cmd(const void *data, uint8_t size)
3858 {
3859         const struct bt_hci_cmd_periodic_inquiry *cmd = data;
3860
3861         print_field("Max period: %.2fs (0x%2.2x)",
3862                                 cmd->max_period * 1.28, cmd->max_period);
3863         print_field("Min period: %.2fs (0x%2.2x)",
3864                                 cmd->min_period * 1.28, cmd->min_period);
3865         print_iac(cmd->lap);
3866         print_field("Length: %.2fs (0x%2.2x)",
3867                                 cmd->length * 1.28, cmd->length);
3868         print_num_resp(cmd->num_resp);
3869 }
3870
3871 static void create_conn_cmd(const void *data, uint8_t size)
3872 {
3873         const struct bt_hci_cmd_create_conn *cmd = data;
3874         const char *str;
3875
3876         print_bdaddr(cmd->bdaddr);
3877         print_pkt_type(cmd->pkt_type);
3878         print_pscan_rep_mode(cmd->pscan_rep_mode);
3879         print_pscan_mode(cmd->pscan_mode);
3880         print_clock_offset(cmd->clock_offset);
3881
3882         switch (cmd->role_switch) {
3883         case 0x00:
3884                 str = "Stay master";
3885                 break;
3886         case 0x01:
3887                 str = "Allow slave";
3888                 break;
3889         default:
3890                 str = "Reserved";
3891                 break;
3892         }
3893
3894         print_field("Role switch: %s (0x%2.2x)", str, cmd->role_switch);
3895 }
3896
3897 static void disconnect_cmd(const void *data, uint8_t size)
3898 {
3899         const struct bt_hci_cmd_disconnect *cmd = data;
3900
3901         print_handle(cmd->handle);
3902         print_reason(cmd->reason);
3903 }
3904
3905 static void add_sco_conn_cmd(const void *data, uint8_t size)
3906 {
3907         const struct bt_hci_cmd_add_sco_conn *cmd = data;
3908
3909         print_handle(cmd->handle);
3910         print_pkt_type_sco(cmd->pkt_type);
3911 }
3912
3913 static void create_conn_cancel_cmd(const void *data, uint8_t size)
3914 {
3915         const struct bt_hci_cmd_create_conn_cancel *cmd = data;
3916
3917         print_bdaddr(cmd->bdaddr);
3918 }
3919
3920 static void accept_conn_request_cmd(const void *data, uint8_t size)
3921 {
3922         const struct bt_hci_cmd_accept_conn_request *cmd = data;
3923
3924         print_bdaddr(cmd->bdaddr);
3925         print_role(cmd->role);
3926 }
3927
3928 static void reject_conn_request_cmd(const void *data, uint8_t size)
3929 {
3930         const struct bt_hci_cmd_reject_conn_request *cmd = data;
3931
3932         print_bdaddr(cmd->bdaddr);
3933         print_reason(cmd->reason);
3934 }
3935
3936 static void link_key_request_reply_cmd(const void *data, uint8_t size)
3937 {
3938         const struct bt_hci_cmd_link_key_request_reply *cmd = data;
3939
3940         print_bdaddr(cmd->bdaddr);
3941         print_link_key(cmd->link_key);
3942 }
3943
3944 static void link_key_request_neg_reply_cmd(const void *data, uint8_t size)
3945 {
3946         const struct bt_hci_cmd_link_key_request_neg_reply *cmd = data;
3947
3948         print_bdaddr(cmd->bdaddr);
3949 }
3950
3951 static void pin_code_request_reply_cmd(const void *data, uint8_t size)
3952 {
3953         const struct bt_hci_cmd_pin_code_request_reply *cmd = data;
3954
3955         print_bdaddr(cmd->bdaddr);
3956         print_field("PIN length: %d", cmd->pin_len);
3957         print_pin_code(cmd->pin_code, cmd->pin_len);
3958 }
3959
3960 static void pin_code_request_neg_reply_cmd(const void *data, uint8_t size)
3961 {
3962         const struct bt_hci_cmd_pin_code_request_neg_reply *cmd = data;
3963
3964         print_bdaddr(cmd->bdaddr);
3965 }
3966
3967 static void change_conn_pkt_type_cmd(const void *data, uint8_t size)
3968 {
3969         const struct bt_hci_cmd_change_conn_pkt_type *cmd = data;
3970
3971         print_handle(cmd->handle);
3972         print_pkt_type(cmd->pkt_type);
3973 }
3974
3975 static void auth_requested_cmd(const void *data, uint8_t size)
3976 {
3977         const struct bt_hci_cmd_auth_requested *cmd = data;
3978
3979         print_handle(cmd->handle);
3980 }
3981
3982 static void set_conn_encrypt_cmd(const void *data, uint8_t size)
3983 {
3984         const struct bt_hci_cmd_set_conn_encrypt *cmd = data;
3985
3986         print_handle(cmd->handle);
3987         print_encr_mode(cmd->encr_mode);
3988 }
3989
3990 static void change_conn_link_key_cmd(const void *data, uint8_t size)
3991 {
3992         const struct bt_hci_cmd_change_conn_link_key *cmd = data;
3993
3994         print_handle(cmd->handle);
3995 }
3996
3997 static void master_link_key_cmd(const void *data, uint8_t size)
3998 {
3999         const struct bt_hci_cmd_master_link_key *cmd = data;
4000
4001         print_key_flag(cmd->key_flag);
4002 }
4003
4004 static void remote_name_request_cmd(const void *data, uint8_t size)
4005 {
4006         const struct bt_hci_cmd_remote_name_request *cmd = data;
4007
4008         print_bdaddr(cmd->bdaddr);
4009         print_pscan_rep_mode(cmd->pscan_rep_mode);
4010         print_pscan_mode(cmd->pscan_mode);
4011         print_clock_offset(cmd->clock_offset);
4012 }
4013
4014 static void remote_name_request_cancel_cmd(const void *data, uint8_t size)
4015 {
4016         const struct bt_hci_cmd_remote_name_request_cancel *cmd = data;
4017
4018         print_bdaddr(cmd->bdaddr);
4019 }
4020
4021 static void read_remote_features_cmd(const void *data, uint8_t size)
4022 {
4023         const struct bt_hci_cmd_read_remote_features *cmd = data;
4024
4025         print_handle(cmd->handle);
4026 }
4027
4028 static void read_remote_ext_features_cmd(const void *data, uint8_t size)
4029 {
4030         const struct bt_hci_cmd_read_remote_ext_features *cmd = data;
4031
4032         print_handle(cmd->handle);
4033         print_field("Page: %d", cmd->page);
4034 }
4035
4036 static void read_remote_version_cmd(const void *data, uint8_t size)
4037 {
4038         const struct bt_hci_cmd_read_remote_version *cmd = data;
4039
4040         print_handle(cmd->handle);
4041 }
4042
4043 static void read_clock_offset_cmd(const void *data, uint8_t size)
4044 {
4045         const struct bt_hci_cmd_read_clock_offset *cmd = data;
4046
4047         print_handle(cmd->handle);
4048 }
4049
4050 static void read_lmp_handle_cmd(const void *data, uint8_t size)
4051 {
4052         const struct bt_hci_cmd_read_lmp_handle *cmd = data;
4053
4054         print_handle(cmd->handle);
4055 }
4056
4057 static void read_lmp_handle_rsp(const void *data, uint8_t size)
4058 {
4059         const struct bt_hci_rsp_read_lmp_handle *rsp = data;
4060
4061         print_status(rsp->status);
4062         print_handle(rsp->handle);
4063         print_field("LMP handle: %d", rsp->lmp_handle);
4064         print_field("Reserved: %d", le32_to_cpu(rsp->reserved));
4065 }
4066
4067 static void setup_sync_conn_cmd(const void *data, uint8_t size)
4068 {
4069         const struct bt_hci_cmd_setup_sync_conn *cmd = data;
4070
4071         print_handle(cmd->handle);
4072         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4073         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4074         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4075         print_voice_setting(cmd->voice_setting);
4076         print_retransmission_effort(cmd->retrans_effort);
4077         print_pkt_type_sco(cmd->pkt_type);
4078 }
4079
4080 static void accept_sync_conn_request_cmd(const void *data, uint8_t size)
4081 {
4082         const struct bt_hci_cmd_accept_sync_conn_request *cmd = data;
4083
4084         print_bdaddr(cmd->bdaddr);
4085         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4086         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4087         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4088         print_voice_setting(cmd->voice_setting);
4089         print_retransmission_effort(cmd->retrans_effort);
4090         print_pkt_type_sco(cmd->pkt_type);
4091 }
4092
4093 static void reject_sync_conn_request_cmd(const void *data, uint8_t size)
4094 {
4095         const struct bt_hci_cmd_reject_sync_conn_request *cmd = data;
4096
4097         print_bdaddr(cmd->bdaddr);
4098         print_reason(cmd->reason);
4099 }
4100
4101 static void io_capability_request_reply_cmd(const void *data, uint8_t size)
4102 {
4103         const struct bt_hci_cmd_io_capability_request_reply *cmd = data;
4104
4105         print_bdaddr(cmd->bdaddr);
4106         print_io_capability(cmd->capability);
4107         print_oob_data(cmd->oob_data);
4108         print_authentication(cmd->authentication);
4109 }
4110
4111 static void user_confirm_request_reply_cmd(const void *data, uint8_t size)
4112 {
4113         const struct bt_hci_cmd_user_confirm_request_reply *cmd = data;
4114
4115         print_bdaddr(cmd->bdaddr);
4116 }
4117
4118 static void user_confirm_request_neg_reply_cmd(const void *data, uint8_t size)
4119 {
4120         const struct bt_hci_cmd_user_confirm_request_neg_reply *cmd = data;
4121
4122         print_bdaddr(cmd->bdaddr);
4123 }
4124
4125 static void user_passkey_request_reply_cmd(const void *data, uint8_t size)
4126 {
4127         const struct bt_hci_cmd_user_passkey_request_reply *cmd = data;
4128
4129         print_bdaddr(cmd->bdaddr);
4130         print_passkey(cmd->passkey);
4131 }
4132
4133 static void user_passkey_request_neg_reply_cmd(const void *data, uint8_t size)
4134 {
4135         const struct bt_hci_cmd_user_passkey_request_neg_reply *cmd = data;
4136
4137         print_bdaddr(cmd->bdaddr);
4138 }
4139
4140 static void remote_oob_data_request_reply_cmd(const void *data, uint8_t size)
4141 {
4142         const struct bt_hci_cmd_remote_oob_data_request_reply *cmd = data;
4143
4144         print_bdaddr(cmd->bdaddr);
4145         print_hash_p192(cmd->hash);
4146         print_randomizer_p192(cmd->randomizer);
4147 }
4148
4149 static void remote_oob_data_request_neg_reply_cmd(const void *data, uint8_t size)
4150 {
4151         const struct bt_hci_cmd_remote_oob_data_request_neg_reply *cmd = data;
4152
4153         print_bdaddr(cmd->bdaddr);
4154 }
4155
4156 static void io_capability_request_neg_reply_cmd(const void *data, uint8_t size)
4157 {
4158         const struct bt_hci_cmd_io_capability_request_neg_reply *cmd = data;
4159
4160         print_bdaddr(cmd->bdaddr);
4161         print_reason(cmd->reason);
4162 }
4163
4164 static void create_phy_link_cmd(const void *data, uint8_t size)
4165 {
4166         const struct bt_hci_cmd_create_phy_link *cmd = data;
4167
4168         print_phy_handle(cmd->phy_handle);
4169         print_key_len(cmd->key_len);
4170         print_key_type(cmd->key_type);
4171
4172         packet_hexdump(data + 3, size - 3);
4173 }
4174
4175 static void accept_phy_link_cmd(const void *data, uint8_t size)
4176 {
4177         const struct bt_hci_cmd_accept_phy_link *cmd = data;
4178
4179         print_phy_handle(cmd->phy_handle);
4180         print_key_len(cmd->key_len);
4181         print_key_type(cmd->key_type);
4182
4183         packet_hexdump(data + 3, size - 3);
4184 }
4185
4186 static void disconn_phy_link_cmd(const void *data, uint8_t size)
4187 {
4188         const struct bt_hci_cmd_disconn_phy_link *cmd = data;
4189
4190         print_phy_handle(cmd->phy_handle);
4191         print_reason(cmd->reason);
4192 }
4193
4194 static void create_logic_link_cmd(const void *data, uint8_t size)
4195 {
4196         const struct bt_hci_cmd_create_logic_link *cmd = data;
4197
4198         print_phy_handle(cmd->phy_handle);
4199         print_flow_spec("TX", cmd->tx_flow_spec);
4200         print_flow_spec("RX", cmd->rx_flow_spec);
4201 }
4202
4203 static void accept_logic_link_cmd(const void *data, uint8_t size)
4204 {
4205         const struct bt_hci_cmd_accept_logic_link *cmd = data;
4206
4207         print_phy_handle(cmd->phy_handle);
4208         print_flow_spec("TX", cmd->tx_flow_spec);
4209         print_flow_spec("RX", cmd->rx_flow_spec);
4210 }
4211
4212 static void disconn_logic_link_cmd(const void *data, uint8_t size)
4213 {
4214         const struct bt_hci_cmd_disconn_logic_link *cmd = data;
4215
4216         print_handle(cmd->handle);
4217 }
4218
4219 static void logic_link_cancel_cmd(const void *data, uint8_t size)
4220 {
4221         const struct bt_hci_cmd_logic_link_cancel *cmd = data;
4222
4223         print_phy_handle(cmd->phy_handle);
4224         print_field("TX flow spec: 0x%2.2x", cmd->flow_spec);
4225 }
4226
4227 static void logic_link_cancel_rsp(const void *data, uint8_t size)
4228 {
4229         const struct bt_hci_rsp_logic_link_cancel *rsp = data;
4230
4231         print_status(rsp->status);
4232         print_phy_handle(rsp->phy_handle);
4233         print_field("TX flow spec: 0x%2.2x", rsp->flow_spec);
4234 }
4235
4236 static void flow_spec_modify_cmd(const void *data, uint8_t size)
4237 {
4238         const struct bt_hci_cmd_flow_spec_modify *cmd = data;
4239
4240         print_handle(cmd->handle);
4241         print_flow_spec("TX", cmd->tx_flow_spec);
4242         print_flow_spec("RX", cmd->rx_flow_spec);
4243 }
4244
4245 static void enhanced_setup_sync_conn_cmd(const void *data, uint8_t size)
4246 {
4247         const struct bt_hci_cmd_enhanced_setup_sync_conn *cmd = data;
4248
4249         print_handle(cmd->handle);
4250         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4251         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4252
4253         /* TODO */
4254
4255         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4256         print_pkt_type_sco(cmd->pkt_type);
4257         print_retransmission_effort(cmd->retrans_effort);
4258 }
4259
4260 static void enhanced_accept_sync_conn_request_cmd(const void *data, uint8_t size)
4261 {
4262         const struct bt_hci_cmd_enhanced_accept_sync_conn_request *cmd = data;
4263
4264         print_bdaddr(cmd->bdaddr);
4265         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4266         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4267
4268         /* TODO */
4269
4270         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4271         print_pkt_type_sco(cmd->pkt_type);
4272         print_retransmission_effort(cmd->retrans_effort);
4273 }
4274
4275 static void truncated_page_cmd(const void *data, uint8_t size)
4276 {
4277         const struct bt_hci_cmd_truncated_page *cmd = data;
4278
4279         print_bdaddr(cmd->bdaddr);
4280         print_pscan_rep_mode(cmd->pscan_rep_mode);
4281         print_clock_offset(cmd->clock_offset);
4282 }
4283
4284 static void truncated_page_cancel_cmd(const void *data, uint8_t size)
4285 {
4286         const struct bt_hci_cmd_truncated_page_cancel *cmd = data;
4287
4288         print_bdaddr(cmd->bdaddr);
4289 }
4290
4291 static void set_slave_broadcast_cmd(const void *data, uint8_t size)
4292 {
4293         const struct bt_hci_cmd_set_slave_broadcast *cmd = data;
4294
4295         print_field("Enable: 0x%2.2x", cmd->enable);
4296         print_lt_addr(cmd->lt_addr);
4297         print_lpo_allowed(cmd->lpo_allowed);
4298         print_pkt_type(cmd->pkt_type);
4299         print_slot_625("Min interval", cmd->min_interval);
4300         print_slot_625("Max interval", cmd->max_interval);
4301         print_slot_625("Supervision timeout", cmd->timeout);
4302 }
4303
4304 static void set_slave_broadcast_rsp(const void *data, uint8_t size)
4305 {
4306         const struct bt_hci_rsp_set_slave_broadcast *rsp = data;
4307
4308         print_status(rsp->status);
4309         print_lt_addr(rsp->lt_addr);
4310         print_interval(rsp->interval);
4311 }
4312
4313 static void set_slave_broadcast_receive_cmd(const void *data, uint8_t size)
4314 {
4315         const struct bt_hci_cmd_set_slave_broadcast_receive *cmd = data;
4316
4317         print_field("Enable: 0x%2.2x", cmd->enable);
4318         print_bdaddr(cmd->bdaddr);
4319         print_lt_addr(cmd->lt_addr);
4320         print_interval(cmd->interval);
4321         print_field("Offset: 0x%8.8x", le32_to_cpu(cmd->offset));
4322         print_field("Next broadcast instant: 0x%4.4x",
4323                                         le16_to_cpu(cmd->instant));
4324         print_slot_625("Supervision timeout", cmd->timeout);
4325         print_field("Remote timing accuracy: %d ppm", cmd->accuracy);
4326         print_field("Skip: 0x%2.2x", cmd->skip);
4327         print_pkt_type(cmd->pkt_type);
4328         print_channel_map(cmd->map);
4329 }
4330
4331 static void set_slave_broadcast_receive_rsp(const void *data, uint8_t size)
4332 {
4333         const struct bt_hci_rsp_set_slave_broadcast_receive *rsp = data;
4334
4335         print_status(rsp->status);
4336         print_bdaddr(rsp->bdaddr);
4337         print_lt_addr(rsp->lt_addr);
4338 }
4339
4340 static void receive_sync_train_cmd(const void *data, uint8_t size)
4341 {
4342         const struct bt_hci_cmd_receive_sync_train *cmd = data;
4343
4344         print_bdaddr(cmd->bdaddr);
4345         print_timeout(cmd->timeout);
4346         print_window(cmd->window);
4347         print_interval(cmd->interval);
4348 }
4349
4350 static void remote_oob_ext_data_request_reply_cmd(const void *data, uint8_t size)
4351 {
4352         const struct bt_hci_cmd_remote_oob_ext_data_request_reply *cmd = data;
4353
4354         print_bdaddr(cmd->bdaddr);
4355         print_hash_p192(cmd->hash192);
4356         print_randomizer_p192(cmd->randomizer192);
4357         print_hash_p256(cmd->hash256);
4358         print_randomizer_p256(cmd->randomizer256);
4359 }
4360
4361 static void hold_mode_cmd(const void *data, uint8_t size)
4362 {
4363         const struct bt_hci_cmd_hold_mode *cmd = data;
4364
4365         print_handle(cmd->handle);
4366         print_slot_625("Hold max interval", cmd->max_interval);
4367         print_slot_625("Hold min interval", cmd->min_interval);
4368 }
4369
4370 static void sniff_mode_cmd(const void *data, uint8_t size)
4371 {
4372         const struct bt_hci_cmd_sniff_mode *cmd = data;
4373
4374         print_handle(cmd->handle);
4375         print_slot_625("Sniff max interval", cmd->max_interval);
4376         print_slot_625("Sniff min interval", cmd->min_interval);
4377         print_slot_125("Sniff attempt", cmd->attempt);
4378         print_slot_125("Sniff timeout", cmd->timeout);
4379 }
4380
4381 static void exit_sniff_mode_cmd(const void *data, uint8_t size)
4382 {
4383         const struct bt_hci_cmd_exit_sniff_mode *cmd = data;
4384
4385         print_handle(cmd->handle);
4386 }
4387
4388 static void park_state_cmd(const void *data, uint8_t size)
4389 {
4390         const struct bt_hci_cmd_park_state *cmd = data;
4391
4392         print_handle(cmd->handle);
4393         print_slot_625("Beacon max interval", cmd->max_interval);
4394         print_slot_625("Beacon min interval", cmd->min_interval);
4395 }
4396
4397 static void exit_park_state_cmd(const void *data, uint8_t size)
4398 {
4399         const struct bt_hci_cmd_exit_park_state *cmd = data;
4400
4401         print_handle(cmd->handle);
4402 }
4403
4404 static void qos_setup_cmd(const void *data, uint8_t size)
4405 {
4406         const struct bt_hci_cmd_qos_setup *cmd = data;
4407
4408         print_handle(cmd->handle);
4409         print_field("Flags: 0x%2.2x", cmd->flags);
4410
4411         print_service_type(cmd->service_type);
4412
4413         print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
4414         print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
4415         print_field("Latency: %d", le32_to_cpu(cmd->latency));
4416         print_field("Delay variation: %d", le32_to_cpu(cmd->delay_variation));
4417 }
4418
4419 static void role_discovery_cmd(const void *data, uint8_t size)
4420 {
4421         const struct bt_hci_cmd_role_discovery *cmd = data;
4422
4423         print_handle(cmd->handle);
4424 }
4425
4426 static void role_discovery_rsp(const void *data, uint8_t size)
4427 {
4428         const struct bt_hci_rsp_role_discovery *rsp = data;
4429
4430         print_status(rsp->status);
4431         print_handle(rsp->handle);
4432         print_role(rsp->role);
4433 }
4434
4435 static void switch_role_cmd(const void *data, uint8_t size)
4436 {
4437         const struct bt_hci_cmd_switch_role *cmd = data;
4438
4439         print_bdaddr(cmd->bdaddr);
4440         print_role(cmd->role);
4441 }
4442
4443 static void read_link_policy_cmd(const void *data, uint8_t size)
4444 {
4445         const struct bt_hci_cmd_read_link_policy *cmd = data;
4446
4447         print_handle(cmd->handle);
4448 }
4449
4450 static void read_link_policy_rsp(const void *data, uint8_t size)
4451 {
4452         const struct bt_hci_rsp_read_link_policy *rsp = data;
4453
4454         print_status(rsp->status);
4455         print_handle(rsp->handle);
4456         print_link_policy(rsp->policy);
4457 }
4458
4459 static void write_link_policy_cmd(const void *data, uint8_t size)
4460 {
4461         const struct bt_hci_cmd_write_link_policy *cmd = data;
4462
4463         print_handle(cmd->handle);
4464         print_link_policy(cmd->policy);
4465 }
4466
4467 static void write_link_policy_rsp(const void *data, uint8_t size)
4468 {
4469         const struct bt_hci_rsp_write_link_policy *rsp = data;
4470
4471         print_status(rsp->status);
4472         print_handle(rsp->handle);
4473 }
4474
4475 static void read_default_link_policy_rsp(const void *data, uint8_t size)
4476 {
4477         const struct bt_hci_rsp_read_default_link_policy *rsp = data;
4478
4479         print_status(rsp->status);
4480         print_link_policy(rsp->policy);
4481 }
4482
4483 static void write_default_link_policy_cmd(const void *data, uint8_t size)
4484 {
4485         const struct bt_hci_cmd_write_default_link_policy *cmd = data;
4486
4487         print_link_policy(cmd->policy);
4488 }
4489
4490 static void flow_spec_cmd(const void *data, uint8_t size)
4491 {
4492         const struct bt_hci_cmd_flow_spec *cmd = data;
4493
4494         print_handle(cmd->handle);
4495         print_field("Flags: 0x%2.2x", cmd->flags);
4496
4497         print_flow_direction(cmd->direction);
4498         print_service_type(cmd->service_type);
4499
4500         print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
4501         print_field("Token bucket size: %d",
4502                                         le32_to_cpu(cmd->token_bucket_size));
4503         print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
4504         print_field("Access latency: %d", le32_to_cpu(cmd->access_latency));
4505 }
4506
4507 static void sniff_subrating_cmd(const void *data, uint8_t size)
4508 {
4509         const struct bt_hci_cmd_sniff_subrating *cmd = data;
4510
4511         print_handle(cmd->handle);
4512         print_slot_625("Max latency", cmd->max_latency);
4513         print_slot_625("Min remote timeout", cmd->min_remote_timeout);
4514         print_slot_625("Min local timeout", cmd->min_local_timeout);
4515 }
4516
4517 static void sniff_subrating_rsp(const void *data, uint8_t size)
4518 {
4519         const struct bt_hci_rsp_sniff_subrating *rsp = data;
4520
4521         print_status(rsp->status);
4522         print_handle(rsp->handle);
4523 }
4524
4525 static void set_event_mask_cmd(const void *data, uint8_t size)
4526 {
4527         const struct bt_hci_cmd_set_event_mask *cmd = data;
4528
4529         print_event_mask(cmd->mask);
4530 }
4531
4532 static void set_event_filter_cmd(const void *data, uint8_t size)
4533 {
4534         uint8_t type = *((const uint8_t *) data);
4535         uint8_t filter;
4536         const char *str;
4537
4538         switch (type) {
4539         case 0x00:
4540                 str = "Clear All Filters";
4541                 break;
4542         case 0x01:
4543                 str = "Inquiry Result";
4544                 break;
4545         case 0x02:
4546                 str = "Connection Setup";
4547                 break;
4548         default:
4549                 str = "Reserved";
4550                 break;
4551         }
4552
4553         print_field("Type: %s (0x%2.2x)", str, type);
4554
4555         switch (type) {
4556         case 0x00:
4557                 if (size > 1) {
4558                         print_text(COLOR_ERROR, "  invalid parameter size");
4559                         packet_hexdump(data + 1, size - 1);
4560                 }
4561                 break;
4562
4563         case 0x01:
4564                 filter = *((const uint8_t *) (data + 1));
4565
4566                 switch (filter) {
4567                 case 0x00:
4568                         str = "Return responses from all devices";
4569                         break;
4570                 case 0x01:
4571                         str = "Device with specific Class of Device";
4572                         break;
4573                 case 0x02:
4574                         str = "Device with specific BD_ADDR";
4575                         break;
4576                 default:
4577                         str = "Reserved";
4578                         break;
4579                 }
4580
4581                 print_field("Filter: %s (0x%2.2x)", str, filter);
4582                 packet_hexdump(data + 2, size - 2);
4583                 break;
4584
4585         case 0x02:
4586                 filter = *((const uint8_t *) (data + 1));
4587
4588                 switch (filter) {
4589                 case 0x00:
4590                         str = "Allow connections all devices";
4591                         break;
4592                 case 0x01:
4593                         str = "Allow connections with specific Class of Device";
4594                         break;
4595                 case 0x02:
4596                         str = "Allow connections with specific BD_ADDR";
4597                         break;
4598                 default:
4599                         str = "Reserved";
4600                         break;
4601                 }
4602
4603                 print_field("Filter: %s (0x%2.2x)", str, filter);
4604                 packet_hexdump(data + 2, size - 2);
4605                 break;
4606
4607         default:
4608                 filter = *((const uint8_t *) (data + 1));
4609
4610                 print_field("Filter: Reserved (0x%2.2x)", filter);
4611                 packet_hexdump(data + 2, size - 2);
4612                 break;
4613         }
4614 }
4615
4616 static void flush_cmd(const void *data, uint8_t size)
4617 {
4618         const struct bt_hci_cmd_flush *cmd = data;
4619
4620         print_handle(cmd->handle);
4621 }
4622
4623 static void flush_rsp(const void *data, uint8_t size)
4624 {
4625         const struct bt_hci_rsp_flush *rsp = data;
4626
4627         print_status(rsp->status);
4628         print_handle(rsp->handle);
4629 }
4630
4631 static void read_pin_type_rsp(const void *data, uint8_t size)
4632 {
4633         const struct bt_hci_rsp_read_pin_type *rsp = data;
4634
4635         print_status(rsp->status);
4636         print_pin_type(rsp->pin_type);
4637 }
4638
4639 static void write_pin_type_cmd(const void *data, uint8_t size)
4640 {
4641         const struct bt_hci_cmd_write_pin_type *cmd = data;
4642
4643         print_pin_type(cmd->pin_type);
4644 }
4645
4646 static void read_stored_link_key_cmd(const void *data, uint8_t size)
4647 {
4648         const struct bt_hci_cmd_read_stored_link_key *cmd = data;
4649
4650         print_bdaddr(cmd->bdaddr);
4651         print_field("Read all: 0x%2.2x", cmd->read_all);
4652 }
4653
4654 static void read_stored_link_key_rsp(const void *data, uint8_t size)
4655 {
4656         const struct bt_hci_rsp_read_stored_link_key *rsp = data;
4657
4658         print_status(rsp->status);
4659         print_field("Max num keys: %d", le16_to_cpu(rsp->max_num_keys));
4660         print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
4661 }
4662
4663 static void write_stored_link_key_cmd(const void *data, uint8_t size)
4664 {
4665         const struct bt_hci_cmd_write_stored_link_key *cmd = data;
4666
4667         print_field("Num keys: %d", cmd->num_keys);
4668
4669         packet_hexdump(data + 1, size - 1);
4670 }
4671
4672 static void write_stored_link_key_rsp(const void *data, uint8_t size)
4673 {
4674         const struct bt_hci_rsp_write_stored_link_key *rsp = data;
4675
4676         print_status(rsp->status);
4677         print_field("Num keys: %d", rsp->num_keys);
4678 }
4679
4680 static void delete_stored_link_key_cmd(const void *data, uint8_t size)
4681 {
4682         const struct bt_hci_cmd_delete_stored_link_key *cmd = data;
4683
4684         print_bdaddr(cmd->bdaddr);
4685         print_field("Delete all: 0x%2.2x", cmd->delete_all);
4686 }
4687
4688 static void delete_stored_link_key_rsp(const void *data, uint8_t size)
4689 {
4690         const struct bt_hci_rsp_delete_stored_link_key *rsp = data;
4691
4692         print_status(rsp->status);
4693         print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
4694 }
4695
4696 static void write_local_name_cmd(const void *data, uint8_t size)
4697 {
4698         const struct bt_hci_cmd_write_local_name *cmd = data;
4699
4700         print_name(cmd->name);
4701 }
4702
4703 static void read_local_name_rsp(const void *data, uint8_t size)
4704 {
4705         const struct bt_hci_rsp_read_local_name *rsp = data;
4706
4707         print_status(rsp->status);
4708         print_name(rsp->name);
4709 }
4710
4711 static void read_conn_accept_timeout_rsp(const void *data, uint8_t size)
4712 {
4713         const struct bt_hci_rsp_read_conn_accept_timeout *rsp = data;
4714
4715         print_status(rsp->status);
4716         print_timeout(rsp->timeout);
4717 }
4718
4719 static void write_conn_accept_timeout_cmd(const void *data, uint8_t size)
4720 {
4721         const struct bt_hci_cmd_write_conn_accept_timeout *cmd = data;
4722
4723         print_timeout(cmd->timeout);
4724 }
4725
4726 static void read_page_timeout_rsp(const void *data, uint8_t size)
4727 {
4728         const struct bt_hci_rsp_read_page_timeout *rsp = data;
4729
4730         print_status(rsp->status);
4731         print_timeout(rsp->timeout);
4732 }
4733
4734 static void write_page_timeout_cmd(const void *data, uint8_t size)
4735 {
4736         const struct bt_hci_cmd_write_page_timeout *cmd = data;
4737
4738         print_timeout(cmd->timeout);
4739 }
4740
4741 static void read_scan_enable_rsp(const void *data, uint8_t size)
4742 {
4743         const struct bt_hci_rsp_read_scan_enable *rsp = data;
4744
4745         print_status(rsp->status);
4746         print_scan_enable(rsp->enable);
4747 }
4748
4749 static void write_scan_enable_cmd(const void *data, uint8_t size)
4750 {
4751         const struct bt_hci_cmd_write_scan_enable *cmd = data;
4752
4753         print_scan_enable(cmd->enable);
4754 }
4755
4756 static void read_page_scan_activity_rsp(const void *data, uint8_t size)
4757 {
4758         const struct bt_hci_rsp_read_page_scan_activity *rsp = data;
4759
4760         print_status(rsp->status);
4761         print_interval(rsp->interval);
4762         print_window(rsp->window);
4763 }
4764
4765 static void write_page_scan_activity_cmd(const void *data, uint8_t size)
4766 {
4767         const struct bt_hci_cmd_write_page_scan_activity *cmd = data;
4768
4769         print_interval(cmd->interval);
4770         print_window(cmd->window);
4771 }
4772
4773 static void read_inquiry_scan_activity_rsp(const void *data, uint8_t size)
4774 {
4775         const struct bt_hci_rsp_read_inquiry_scan_activity *rsp = data;
4776
4777         print_status(rsp->status);
4778         print_interval(rsp->interval);
4779         print_window(rsp->window);
4780 }
4781
4782 static void write_inquiry_scan_activity_cmd(const void *data, uint8_t size)
4783 {
4784         const struct bt_hci_cmd_write_inquiry_scan_activity *cmd = data;
4785
4786         print_interval(cmd->interval);
4787         print_window(cmd->window);
4788 }
4789
4790 static void read_auth_enable_rsp(const void *data, uint8_t size)
4791 {
4792         const struct bt_hci_rsp_read_auth_enable *rsp = data;
4793
4794         print_status(rsp->status);
4795         print_auth_enable(rsp->enable);
4796 }
4797
4798 static void write_auth_enable_cmd(const void *data, uint8_t size)
4799 {
4800         const struct bt_hci_cmd_write_auth_enable *cmd = data;
4801
4802         print_auth_enable(cmd->enable);
4803 }
4804
4805 static void read_encrypt_mode_rsp(const void *data, uint8_t size)
4806 {
4807         const struct bt_hci_rsp_read_encrypt_mode *rsp = data;
4808
4809         print_status(rsp->status);
4810         print_encrypt_mode(rsp->mode);
4811 }
4812
4813 static void write_encrypt_mode_cmd(const void *data, uint8_t size)
4814 {
4815         const struct bt_hci_cmd_write_encrypt_mode *cmd = data;
4816
4817         print_encrypt_mode(cmd->mode);
4818 }
4819
4820 static void read_class_of_dev_rsp(const void *data, uint8_t size)
4821 {
4822         const struct bt_hci_rsp_read_class_of_dev *rsp = data;
4823
4824         print_status(rsp->status);
4825         print_dev_class(rsp->dev_class);
4826 }
4827
4828 static void write_class_of_dev_cmd(const void *data, uint8_t size)
4829 {
4830         const struct bt_hci_cmd_write_class_of_dev *cmd = data;
4831
4832         print_dev_class(cmd->dev_class);
4833 }
4834
4835 static void read_voice_setting_rsp(const void *data, uint8_t size)
4836 {
4837         const struct bt_hci_rsp_read_voice_setting *rsp = data;
4838
4839         print_status(rsp->status);
4840         print_voice_setting(rsp->setting);
4841 }
4842
4843 static void write_voice_setting_cmd(const void *data, uint8_t size)
4844 {
4845         const struct bt_hci_cmd_write_voice_setting *cmd = data;
4846
4847         print_voice_setting(cmd->setting);
4848 }
4849
4850 static void read_auto_flush_timeout_cmd(const void *data, uint8_t size)
4851 {
4852         const struct bt_hci_cmd_read_auto_flush_timeout *cmd = data;
4853
4854         print_handle(cmd->handle);
4855 }
4856
4857 static void read_auto_flush_timeout_rsp(const void *data, uint8_t size)
4858 {
4859         const struct bt_hci_rsp_read_auto_flush_timeout *rsp = data;
4860
4861         print_status(rsp->status);
4862         print_handle(rsp->handle);
4863         print_flush_timeout(rsp->timeout);
4864 }
4865
4866 static void write_auto_flush_timeout_cmd(const void *data, uint8_t size)
4867 {
4868         const struct bt_hci_cmd_write_auto_flush_timeout *cmd = data;
4869
4870         print_handle(cmd->handle);
4871         print_flush_timeout(cmd->timeout);
4872 }
4873
4874 static void write_auto_flush_timeout_rsp(const void *data, uint8_t size)
4875 {
4876         const struct bt_hci_rsp_write_auto_flush_timeout *rsp = data;
4877
4878         print_status(rsp->status);
4879         print_handle(rsp->handle);
4880 }
4881
4882 static void read_num_broadcast_retrans_rsp(const void *data, uint8_t size)
4883 {
4884         const struct bt_hci_rsp_read_num_broadcast_retrans *rsp = data;
4885
4886         print_status(rsp->status);
4887         print_num_broadcast_retrans(rsp->num_retrans);
4888 }
4889
4890 static void write_num_broadcast_retrans_cmd(const void *data, uint8_t size)
4891 {
4892         const struct bt_hci_cmd_write_num_broadcast_retrans *cmd = data;
4893
4894         print_num_broadcast_retrans(cmd->num_retrans);
4895 }
4896
4897 static void read_hold_mode_activity_rsp(const void *data, uint8_t size)
4898 {
4899         const struct bt_hci_rsp_read_hold_mode_activity *rsp = data;
4900
4901         print_status(rsp->status);
4902         print_hold_mode_activity(rsp->activity);
4903 }
4904
4905 static void write_hold_mode_activity_cmd(const void *data, uint8_t size)
4906 {
4907         const struct bt_hci_cmd_write_hold_mode_activity *cmd = data;
4908
4909         print_hold_mode_activity(cmd->activity);
4910 }
4911
4912 static void read_tx_power_cmd(const void *data, uint8_t size)
4913 {
4914         const struct bt_hci_cmd_read_tx_power *cmd = data;
4915
4916         print_handle(cmd->handle);
4917         print_power_type(cmd->type);
4918 }
4919
4920 static void read_tx_power_rsp(const void *data, uint8_t size)
4921 {
4922         const struct bt_hci_rsp_read_tx_power *rsp = data;
4923
4924         print_status(rsp->status);
4925         print_handle(rsp->handle);
4926         print_power_level(rsp->level, NULL);
4927 }
4928
4929 static void read_sync_flow_control_rsp(const void *data, uint8_t size)
4930 {
4931         const struct bt_hci_rsp_read_sync_flow_control *rsp = data;
4932
4933         print_status(rsp->status);
4934         print_sync_flow_control(rsp->enable);
4935 }
4936
4937 static void write_sync_flow_control_cmd(const void *data, uint8_t size)
4938 {
4939         const struct bt_hci_cmd_write_sync_flow_control *cmd = data;
4940
4941         print_sync_flow_control(cmd->enable);
4942 }
4943
4944 static void set_host_flow_control_cmd(const void *data, uint8_t size)
4945 {
4946         const struct bt_hci_cmd_set_host_flow_control *cmd = data;
4947
4948         print_host_flow_control(cmd->enable);
4949 }
4950
4951 static void host_buffer_size_cmd(const void *data, uint8_t size)
4952 {
4953         const struct bt_hci_cmd_host_buffer_size *cmd = data;
4954
4955         print_field("ACL MTU: %-4d ACL max packet: %d",
4956                                         le16_to_cpu(cmd->acl_mtu),
4957                                         le16_to_cpu(cmd->acl_max_pkt));
4958         print_field("SCO MTU: %-4d SCO max packet: %d",
4959                                         cmd->sco_mtu,
4960                                         le16_to_cpu(cmd->sco_max_pkt));
4961 }
4962
4963 static void host_num_completed_packets_cmd(const void *data, uint8_t size)
4964 {
4965         const struct bt_hci_cmd_host_num_completed_packets *cmd = data;
4966
4967         print_field("Num handles: %d", cmd->num_handles);
4968         print_handle(cmd->handle);
4969         print_field("Count: %d", le16_to_cpu(cmd->count));
4970
4971         if (size > sizeof(*cmd))
4972                 packet_hexdump(data + sizeof(*cmd), size - sizeof(*cmd));
4973 }
4974
4975 static void read_link_supv_timeout_cmd(const void *data, uint8_t size)
4976 {
4977         const struct bt_hci_cmd_read_link_supv_timeout *cmd = data;
4978
4979         print_handle(cmd->handle);
4980 }
4981
4982 static void read_link_supv_timeout_rsp(const void *data, uint8_t size)
4983 {
4984         const struct bt_hci_rsp_read_link_supv_timeout *rsp = data;
4985
4986         print_status(rsp->status);
4987         print_handle(rsp->handle);
4988         print_timeout(rsp->timeout);
4989 }
4990
4991 static void write_link_supv_timeout_cmd(const void *data, uint8_t size)
4992 {
4993         const struct bt_hci_cmd_write_link_supv_timeout *cmd = data;
4994
4995         print_handle(cmd->handle);
4996         print_timeout(cmd->timeout);
4997 }
4998
4999 static void write_link_supv_timeout_rsp(const void *data, uint8_t size)
5000 {
5001         const struct bt_hci_rsp_write_link_supv_timeout *rsp = data;
5002
5003         print_status(rsp->status);
5004         print_handle(rsp->handle);
5005 }
5006
5007 static void read_num_supported_iac_rsp(const void *data, uint8_t size)
5008 {
5009         const struct bt_hci_rsp_read_num_supported_iac *rsp = data;
5010
5011         print_status(rsp->status);
5012         print_field("Number of IAC: %d", rsp->num_iac);
5013 }
5014
5015 static void read_current_iac_lap_rsp(const void *data, uint8_t size)
5016 {
5017         const struct bt_hci_rsp_read_current_iac_lap *rsp = data;
5018         uint8_t i;
5019
5020         print_status(rsp->status);
5021         print_field("Number of IAC: %d", rsp->num_iac);
5022
5023         for (i = 0; i < rsp->num_iac; i++)
5024                 print_iac(rsp->iac_lap + (i * 3));
5025 }
5026
5027 static void write_current_iac_lap_cmd(const void *data, uint8_t size)
5028 {
5029         const struct bt_hci_cmd_write_current_iac_lap *cmd = data;
5030         uint8_t i;
5031
5032         print_field("Number of IAC: %d", cmd->num_iac);
5033
5034         for (i = 0; i < cmd->num_iac; i++)
5035                 print_iac(cmd->iac_lap + (i * 3));
5036 }
5037
5038 static void read_page_scan_period_mode_rsp(const void *data, uint8_t size)
5039 {
5040         const struct bt_hci_rsp_read_page_scan_period_mode *rsp = data;
5041
5042         print_status(rsp->status);
5043         print_pscan_period_mode(rsp->mode);
5044 }
5045
5046 static void write_page_scan_period_mode_cmd(const void *data, uint8_t size)
5047 {
5048         const struct bt_hci_cmd_write_page_scan_period_mode *cmd = data;
5049
5050         print_pscan_period_mode(cmd->mode);
5051 }
5052
5053 static void read_page_scan_mode_rsp(const void *data, uint8_t size)
5054 {
5055         const struct bt_hci_rsp_read_page_scan_mode *rsp = data;
5056
5057         print_status(rsp->status);
5058         print_pscan_mode(rsp->mode);
5059 }
5060
5061 static void write_page_scan_mode_cmd(const void *data, uint8_t size)
5062 {
5063         const struct bt_hci_cmd_write_page_scan_mode *cmd = data;
5064
5065         print_pscan_mode(cmd->mode);
5066 }
5067
5068 static void set_afh_host_classification_cmd(const void *data, uint8_t size)
5069 {
5070         const struct bt_hci_cmd_set_afh_host_classification *cmd = data;
5071
5072         print_channel_map(cmd->map);
5073 }
5074
5075 static void read_inquiry_scan_type_rsp(const void *data, uint8_t size)
5076 {
5077         const struct bt_hci_rsp_read_inquiry_scan_type *rsp = data;
5078
5079         print_status(rsp->status);
5080         print_inquiry_scan_type(rsp->type);
5081 }
5082
5083 static void write_inquiry_scan_type_cmd(const void *data, uint8_t size)
5084 {
5085         const struct bt_hci_cmd_write_inquiry_scan_type *cmd = data;
5086
5087         print_inquiry_scan_type(cmd->type);
5088 }
5089
5090 static void read_inquiry_mode_rsp(const void *data, uint8_t size)
5091 {
5092         const struct bt_hci_rsp_read_inquiry_mode *rsp = data;
5093
5094         print_status(rsp->status);
5095         print_inquiry_mode(rsp->mode);
5096 }
5097
5098 static void write_inquiry_mode_cmd(const void *data, uint8_t size)
5099 {
5100         const struct bt_hci_cmd_write_inquiry_mode *cmd = data;
5101
5102         print_inquiry_mode(cmd->mode);
5103 }
5104
5105 static void read_page_scan_type_rsp(const void *data, uint8_t size)
5106 {
5107         const struct bt_hci_rsp_read_page_scan_type *rsp = data;
5108
5109         print_status(rsp->status);
5110         print_pscan_type(rsp->type);
5111 }
5112
5113 static void write_page_scan_type_cmd(const void *data, uint8_t size)
5114 {
5115         const struct bt_hci_cmd_write_page_scan_type *cmd = data;
5116
5117         print_pscan_type(cmd->type);
5118 }
5119
5120 static void read_afh_assessment_mode_rsp(const void *data, uint8_t size)
5121 {
5122         const struct bt_hci_rsp_read_afh_assessment_mode *rsp = data;
5123
5124         print_status(rsp->status);
5125         print_afh_mode(rsp->mode);
5126 }
5127
5128 static void write_afh_assessment_mode_cmd(const void *data, uint8_t size)
5129 {
5130         const struct bt_hci_cmd_write_afh_assessment_mode *cmd = data;
5131
5132         print_afh_mode(cmd->mode);
5133 }
5134
5135 static void read_ext_inquiry_response_rsp(const void *data, uint8_t size)
5136 {
5137         const struct bt_hci_rsp_read_ext_inquiry_response *rsp = data;
5138
5139         print_status(rsp->status);
5140         print_fec(rsp->fec);
5141         print_eir(rsp->data, sizeof(rsp->data), false);
5142 }
5143
5144 static void write_ext_inquiry_response_cmd(const void *data, uint8_t size)
5145 {
5146         const struct bt_hci_cmd_write_ext_inquiry_response *cmd = data;
5147
5148         print_fec(cmd->fec);
5149         print_eir(cmd->data, sizeof(cmd->data), false);
5150 }
5151
5152 static void refresh_encrypt_key_cmd(const void *data, uint8_t size)
5153 {
5154         const struct bt_hci_cmd_refresh_encrypt_key *cmd = data;
5155
5156         print_handle(cmd->handle);
5157 }
5158
5159 static void read_simple_pairing_mode_rsp(const void *data, uint8_t size)
5160 {
5161         const struct bt_hci_rsp_read_simple_pairing_mode *rsp = data;
5162
5163         print_status(rsp->status);
5164         print_simple_pairing_mode(rsp->mode);
5165 }
5166
5167 static void write_simple_pairing_mode_cmd(const void *data, uint8_t size)
5168 {
5169         const struct bt_hci_cmd_write_simple_pairing_mode *cmd = data;
5170
5171         print_simple_pairing_mode(cmd->mode);
5172 }
5173
5174 static void read_local_oob_data_rsp(const void *data, uint8_t size)
5175 {
5176         const struct bt_hci_rsp_read_local_oob_data *rsp = data;
5177
5178         print_status(rsp->status);
5179         print_hash_p192(rsp->hash);
5180         print_randomizer_p192(rsp->randomizer);
5181 }
5182
5183 static void read_inquiry_resp_tx_power_rsp(const void *data, uint8_t size)
5184 {
5185         const struct bt_hci_rsp_read_inquiry_resp_tx_power *rsp = data;
5186
5187         print_status(rsp->status);
5188         print_power_level(rsp->level, NULL);
5189 }
5190
5191 static void write_inquiry_tx_power_cmd(const void *data, uint8_t size)
5192 {
5193         const struct bt_hci_cmd_write_inquiry_tx_power *cmd = data;
5194
5195         print_power_level(cmd->level, NULL);
5196 }
5197
5198 static void read_erroneous_reporting_rsp(const void *data, uint8_t size)
5199 {
5200         const struct bt_hci_rsp_read_erroneous_reporting *rsp = data;
5201
5202         print_status(rsp->status);
5203         print_erroneous_reporting(rsp->mode);
5204 }
5205
5206 static void write_erroneous_reporting_cmd(const void *data, uint8_t size)
5207 {
5208         const struct bt_hci_cmd_write_erroneous_reporting *cmd = data;
5209
5210         print_erroneous_reporting(cmd->mode);
5211 }
5212
5213 static void enhanced_flush_cmd(const void *data, uint8_t size)
5214 {
5215         const struct bt_hci_cmd_enhanced_flush *cmd = data;
5216         const char *str;
5217
5218         print_handle(cmd->handle);
5219
5220         switch (cmd->type) {
5221         case 0x00:
5222                 str = "Automatic flushable only";
5223                 break;
5224         default:
5225                 str = "Reserved";
5226                 break;
5227         }
5228
5229         print_field("Type: %s (0x%2.2x)", str, cmd->type);
5230 }
5231
5232 static void send_keypress_notify_cmd(const void *data, uint8_t size)
5233 {
5234         const struct bt_hci_cmd_send_keypress_notify *cmd = data;
5235         const char *str;
5236
5237         print_bdaddr(cmd->bdaddr);
5238
5239         switch (cmd->type) {
5240         case 0x00:
5241                 str = "Passkey entry started";
5242                 break;
5243         case 0x01:
5244                 str = "Passkey digit entered";
5245                 break;
5246         case 0x02:
5247                 str = "Passkey digit erased";
5248                 break;
5249         case 0x03:
5250                 str = "Passkey cleared";
5251                 break;
5252         case 0x04:
5253                 str = "Passkey entry completed";
5254                 break;
5255         default:
5256                 str = "Reserved";
5257                 break;
5258         }
5259
5260         print_field("Type: %s (0x%2.2x)", str, cmd->type);
5261 }
5262
5263 static void send_keypress_notify_rsp(const void *data, uint8_t size)
5264 {
5265         const struct bt_hci_rsp_send_keypress_notify *rsp = data;
5266
5267         print_status(rsp->status);
5268         print_bdaddr(rsp->bdaddr);
5269 }
5270
5271 static void set_event_mask_page2_cmd(const void *data, uint8_t size)
5272 {
5273         const struct bt_hci_cmd_set_event_mask_page2 *cmd = data;
5274
5275         print_event_mask_page2(cmd->mask);
5276 }
5277
5278 static void read_location_data_rsp(const void *data, uint8_t size)
5279 {
5280         const struct bt_hci_rsp_read_location_data *rsp = data;
5281
5282         print_status(rsp->status);
5283         print_location_domain_aware(rsp->domain_aware);
5284         print_location_domain(rsp->domain);
5285         print_location_domain_options(rsp->domain_options);
5286         print_location_options(rsp->options);
5287 }
5288
5289 static void write_location_data_cmd(const void *data, uint8_t size)
5290 {
5291         const struct bt_hci_cmd_write_location_data *cmd = data;
5292
5293         print_location_domain_aware(cmd->domain_aware);
5294         print_location_domain(cmd->domain);
5295         print_location_domain_options(cmd->domain_options);
5296         print_location_options(cmd->options);
5297 }
5298
5299 static void read_flow_control_mode_rsp(const void *data, uint8_t size)
5300 {
5301         const struct bt_hci_rsp_read_flow_control_mode *rsp = data;
5302
5303         print_status(rsp->status);
5304         print_flow_control_mode(rsp->mode);
5305 }
5306
5307 static void write_flow_control_mode_cmd(const void *data, uint8_t size)
5308 {
5309         const struct bt_hci_cmd_write_flow_control_mode *cmd = data;
5310
5311         print_flow_control_mode(cmd->mode);
5312 }
5313
5314 static void read_enhanced_tx_power_cmd(const void *data, uint8_t size)
5315 {
5316         const struct bt_hci_cmd_read_enhanced_tx_power *cmd = data;
5317
5318         print_handle(cmd->handle);
5319         print_power_type(cmd->type);
5320 }
5321
5322 static void read_enhanced_tx_power_rsp(const void *data, uint8_t size)
5323 {
5324         const struct bt_hci_rsp_read_enhanced_tx_power *rsp = data;
5325
5326         print_status(rsp->status);
5327         print_handle(rsp->handle);
5328         print_power_level(rsp->level_gfsk, "GFSK");
5329         print_power_level(rsp->level_dqpsk, "DQPSK");
5330         print_power_level(rsp->level_8dpsk, "8DPSK");
5331 }
5332
5333 static void short_range_mode_cmd(const void *data, uint8_t size)
5334 {
5335         const struct bt_hci_cmd_short_range_mode *cmd = data;
5336
5337         print_phy_handle(cmd->phy_handle);
5338         print_short_range_mode(cmd->mode);
5339 }
5340
5341 static void read_le_host_supported_rsp(const void *data, uint8_t size)
5342 {
5343         const struct bt_hci_rsp_read_le_host_supported *rsp = data;
5344
5345         print_status(rsp->status);
5346         print_field("Supported: 0x%2.2x", rsp->supported);
5347         print_field("Simultaneous: 0x%2.2x", rsp->simultaneous);
5348 }
5349
5350 static void write_le_host_supported_cmd(const void *data, uint8_t size)
5351 {
5352         const struct bt_hci_cmd_write_le_host_supported *cmd = data;
5353
5354         print_field("Supported: 0x%2.2x", cmd->supported);
5355         print_field("Simultaneous: 0x%2.2x", cmd->simultaneous);
5356 }
5357
5358 static void set_reserved_lt_addr_cmd(const void *data, uint8_t size)
5359 {
5360         const struct bt_hci_cmd_set_reserved_lt_addr *cmd = data;
5361
5362         print_lt_addr(cmd->lt_addr);
5363 }
5364
5365 static void set_reserved_lt_addr_rsp(const void *data, uint8_t size)
5366 {
5367         const struct bt_hci_rsp_set_reserved_lt_addr *rsp = data;
5368
5369         print_status(rsp->status);
5370         print_lt_addr(rsp->lt_addr);
5371 }
5372
5373 static void delete_reserved_lt_addr_cmd(const void *data, uint8_t size)
5374 {
5375         const struct bt_hci_cmd_delete_reserved_lt_addr *cmd = data;
5376
5377         print_lt_addr(cmd->lt_addr);
5378 }
5379
5380 static void delete_reserved_lt_addr_rsp(const void *data, uint8_t size)
5381 {
5382         const struct bt_hci_rsp_delete_reserved_lt_addr *rsp = data;
5383
5384         print_status(rsp->status);
5385         print_lt_addr(rsp->lt_addr);
5386 }
5387
5388 static void set_slave_broadcast_data_cmd(const void *data, uint8_t size)
5389 {
5390         const struct bt_hci_cmd_set_slave_broadcast_data *cmd = data;
5391
5392         print_lt_addr(cmd->lt_addr);
5393         print_broadcast_fragment(cmd->fragment);
5394         print_field("Length: %d", cmd->length);
5395
5396         if (size - 3 != cmd->length)
5397                 print_text(COLOR_ERROR, "invalid data size (%d != %d)",
5398                                                 size - 3, cmd->length);
5399
5400         packet_hexdump(data + 3, size - 3);
5401 }
5402
5403 static void set_slave_broadcast_data_rsp(const void *data, uint8_t size)
5404 {
5405         const struct bt_hci_rsp_set_slave_broadcast_data *rsp = data;
5406
5407         print_status(rsp->status);
5408         print_lt_addr(rsp->lt_addr);
5409 }
5410
5411 static void read_sync_train_params_rsp(const void *data, uint8_t size)
5412 {
5413         const struct bt_hci_rsp_read_sync_train_params *rsp = data;
5414
5415         print_status(rsp->status);
5416         print_interval(rsp->interval);
5417         print_field("Timeout: %.3f msec (0x%8.8x)",
5418                                         le32_to_cpu(rsp->timeout) * 0.625,
5419                                         le32_to_cpu(rsp->timeout));
5420         print_field("Service data: 0x%2.2x", rsp->service_data);
5421 }
5422
5423 static void write_sync_train_params_cmd(const void *data, uint8_t size)
5424 {
5425         const struct bt_hci_cmd_write_sync_train_params *cmd = data;
5426
5427         print_slot_625("Min interval", cmd->min_interval);
5428         print_slot_625("Max interval", cmd->max_interval);
5429         print_field("Timeout: %.3f msec (0x%8.8x)",
5430                                         le32_to_cpu(cmd->timeout) * 0.625,
5431                                         le32_to_cpu(cmd->timeout));
5432         print_field("Service data: 0x%2.2x", cmd->service_data);
5433 }
5434
5435 static void write_sync_train_params_rsp(const void *data, uint8_t size)
5436 {
5437         const struct bt_hci_rsp_write_sync_train_params *rsp = data;
5438
5439         print_status(rsp->status);
5440         print_interval(rsp->interval);
5441 }
5442
5443 static void read_secure_conn_support_rsp(const void *data, uint8_t size)
5444 {
5445         const struct bt_hci_rsp_read_secure_conn_support *rsp = data;
5446
5447         print_status(rsp->status);
5448         print_secure_conn_support(rsp->support);
5449 }
5450
5451 static void write_secure_conn_support_cmd(const void *data, uint8_t size)
5452 {
5453         const struct bt_hci_cmd_write_secure_conn_support *cmd = data;
5454
5455         print_secure_conn_support(cmd->support);
5456 }
5457
5458 static void read_auth_payload_timeout_cmd(const void *data, uint8_t size)
5459 {
5460         const struct bt_hci_cmd_read_auth_payload_timeout *cmd = data;
5461
5462         print_handle(cmd->handle);
5463 }
5464
5465 static void read_auth_payload_timeout_rsp(const void *data, uint8_t size)
5466 {
5467         const struct bt_hci_rsp_read_auth_payload_timeout *rsp = data;
5468
5469         print_status(rsp->status);
5470         print_handle(rsp->handle);
5471         print_auth_payload_timeout(rsp->timeout);
5472 }
5473
5474 static void write_auth_payload_timeout_cmd(const void *data, uint8_t size)
5475 {
5476         const struct bt_hci_cmd_write_auth_payload_timeout *cmd = data;
5477
5478         print_handle(cmd->handle);
5479         print_auth_payload_timeout(cmd->timeout);
5480 }
5481
5482 static void write_auth_payload_timeout_rsp(const void *data, uint8_t size)
5483 {
5484         const struct bt_hci_rsp_write_auth_payload_timeout *rsp = data;
5485
5486         print_status(rsp->status);
5487         print_handle(rsp->handle);
5488 }
5489
5490 static void read_local_oob_ext_data_rsp(const void *data, uint8_t size)
5491 {
5492         const struct bt_hci_rsp_read_local_oob_ext_data *rsp = data;
5493
5494         print_status(rsp->status);
5495         print_hash_p192(rsp->hash192);
5496         print_randomizer_p192(rsp->randomizer192);
5497         print_hash_p256(rsp->hash256);
5498         print_randomizer_p256(rsp->randomizer256);
5499 }
5500
5501 static void read_ext_page_timeout_rsp(const void *data, uint8_t size)
5502 {
5503         const struct bt_hci_rsp_read_ext_page_timeout *rsp = data;
5504
5505         print_status(rsp->status);
5506         print_timeout(rsp->timeout);
5507 }
5508
5509 static void write_ext_page_timeout_cmd(const void *data, uint8_t size)
5510 {
5511         const struct bt_hci_cmd_write_ext_page_timeout *cmd = data;
5512
5513         print_timeout(cmd->timeout);
5514 }
5515
5516 static void read_ext_inquiry_length_rsp(const void *data, uint8_t size)
5517 {
5518         const struct bt_hci_rsp_read_ext_inquiry_length *rsp = data;
5519
5520         print_status(rsp->status);
5521         print_interval(rsp->interval);
5522 }
5523
5524 static void write_ext_inquiry_length_cmd(const void *data, uint8_t size)
5525 {
5526         const struct bt_hci_cmd_write_ext_inquiry_length *cmd = data;
5527
5528         print_interval(cmd->interval);
5529 }
5530
5531 static void read_local_version_rsp(const void *data, uint8_t size)
5532 {
5533         const struct bt_hci_rsp_read_local_version *rsp = data;
5534         uint16_t manufacturer;
5535
5536         print_status(rsp->status);
5537         print_hci_version(rsp->hci_ver, rsp->hci_rev);
5538
5539         manufacturer = le16_to_cpu(rsp->manufacturer);
5540
5541         if (index_current < MAX_INDEX) {
5542                 switch (index_list[index_current].type) {
5543                 case HCI_BREDR:
5544                         print_lmp_version(rsp->lmp_ver, rsp->lmp_subver);
5545                         break;
5546                 case HCI_AMP:
5547                         print_pal_version(rsp->lmp_ver, rsp->lmp_subver);
5548                         break;
5549                 }
5550
5551                 index_list[index_current].manufacturer = manufacturer;
5552         }
5553
5554         print_manufacturer(rsp->manufacturer);
5555
5556         switch (manufacturer) {
5557         case 15:
5558                 print_manufacturer_broadcom(rsp->lmp_subver, rsp->hci_rev);
5559                 break;
5560         }
5561 }
5562
5563 static void read_local_commands_rsp(const void *data, uint8_t size)
5564 {
5565         const struct bt_hci_rsp_read_local_commands *rsp = data;
5566
5567         print_status(rsp->status);
5568         print_commands(rsp->commands);
5569 }
5570
5571 static void read_local_features_rsp(const void *data, uint8_t size)
5572 {
5573         const struct bt_hci_rsp_read_local_features *rsp = data;
5574
5575         print_status(rsp->status);
5576         print_features(0, rsp->features, 0x00);
5577 }
5578
5579 static void read_local_ext_features_cmd(const void *data, uint8_t size)
5580 {
5581         const struct bt_hci_cmd_read_local_ext_features *cmd = data;
5582
5583         print_field("Page: %d", cmd->page);
5584 }
5585
5586 static void read_local_ext_features_rsp(const void *data, uint8_t size)
5587 {
5588         const struct bt_hci_rsp_read_local_ext_features *rsp = data;
5589
5590         print_status(rsp->status);
5591         print_field("Page: %d/%d", rsp->page, rsp->max_page);
5592         print_features(rsp->page, rsp->features, 0x00);
5593 }
5594
5595 static void read_buffer_size_rsp(const void *data, uint8_t size)
5596 {
5597         const struct bt_hci_rsp_read_buffer_size *rsp = data;
5598
5599         print_status(rsp->status);
5600         print_field("ACL MTU: %-4d ACL max packet: %d",
5601                                         le16_to_cpu(rsp->acl_mtu),
5602                                         le16_to_cpu(rsp->acl_max_pkt));
5603         print_field("SCO MTU: %-4d SCO max packet: %d",
5604                                         rsp->sco_mtu,
5605                                         le16_to_cpu(rsp->sco_max_pkt));
5606 }
5607
5608 static void read_country_code_rsp(const void *data, uint8_t size)
5609 {
5610         const struct bt_hci_rsp_read_country_code *rsp = data;
5611         const char *str;
5612
5613         print_status(rsp->status);
5614
5615         switch (rsp->code) {
5616         case 0x00:
5617                 str = "North America, Europe*, Japan";
5618                 break;
5619         case 0x01:
5620                 str = "France";
5621                 break;
5622         default:
5623                 str = "Reserved";
5624                 break;
5625         }
5626
5627         print_field("Country code: %s (0x%2.2x)", str, rsp->code);
5628 }
5629
5630 static void read_bd_addr_rsp(const void *data, uint8_t size)
5631 {
5632         const struct bt_hci_rsp_read_bd_addr *rsp = data;
5633
5634         print_status(rsp->status);
5635         print_bdaddr(rsp->bdaddr);
5636
5637         if (index_current < MAX_INDEX)
5638                 memcpy(index_list[index_current].bdaddr, rsp->bdaddr, 6);
5639 }
5640
5641 static void read_data_block_size_rsp(const void *data, uint8_t size)
5642 {
5643         const struct bt_hci_rsp_read_data_block_size *rsp = data;
5644
5645         print_status(rsp->status);
5646         print_field("Max ACL length: %d", le16_to_cpu(rsp->max_acl_len));
5647         print_field("Block length: %d", le16_to_cpu(rsp->block_len));
5648         print_field("Num blocks: %d", le16_to_cpu(rsp->num_blocks));
5649 }
5650
5651 static void read_local_codecs_rsp(const void *data, uint8_t size)
5652 {
5653         const struct bt_hci_rsp_read_local_codecs *rsp = data;
5654         uint8_t i, num_vnd_codecs;
5655
5656         print_status(rsp->status);
5657         print_field("Number of supported codecs: %d", rsp->num_codecs);
5658
5659         for (i = 0; i < rsp->num_codecs; i++)
5660                 print_codec("  Codec", rsp->codec[i]);
5661
5662         num_vnd_codecs = rsp->codec[rsp->num_codecs];
5663
5664         print_field("Number of vendor codecs: %d", num_vnd_codecs);
5665
5666         packet_hexdump(data + rsp->num_codecs + 3,
5667                                         size - rsp->num_codecs - 3);
5668 }
5669
5670 static void read_failed_contact_counter_cmd(const void *data, uint8_t size)
5671 {
5672         const struct bt_hci_cmd_read_failed_contact_counter *cmd = data;
5673
5674         print_handle(cmd->handle);
5675 }
5676
5677 static void read_failed_contact_counter_rsp(const void *data, uint8_t size)
5678 {
5679         const struct bt_hci_rsp_read_failed_contact_counter *rsp = data;
5680
5681         print_status(rsp->status);
5682         print_handle(rsp->handle);
5683         print_field("Counter: %u", le16_to_cpu(rsp->counter));
5684 }
5685
5686 static void reset_failed_contact_counter_cmd(const void *data, uint8_t size)
5687 {
5688         const struct bt_hci_cmd_reset_failed_contact_counter *cmd = data;
5689
5690         print_handle(cmd->handle);
5691 }
5692
5693 static void reset_failed_contact_counter_rsp(const void *data, uint8_t size)
5694 {
5695         const struct bt_hci_rsp_reset_failed_contact_counter *rsp = data;
5696
5697         print_status(rsp->status);
5698         print_handle(rsp->handle);
5699 }
5700
5701 static void read_link_quality_cmd(const void *data, uint8_t size)
5702 {
5703         const struct bt_hci_cmd_read_link_quality *cmd = data;
5704
5705         print_handle(cmd->handle);
5706 }
5707
5708 static void read_link_quality_rsp(const void *data, uint8_t size)
5709 {
5710         const struct bt_hci_rsp_read_link_quality *rsp = data;
5711
5712         print_status(rsp->status);
5713         print_handle(rsp->handle);
5714         print_field("Link quality: 0x%2.2x", rsp->link_quality);
5715 }
5716
5717 static void read_rssi_cmd(const void *data, uint8_t size)
5718 {
5719         const struct bt_hci_cmd_read_rssi *cmd = data;
5720
5721         print_handle(cmd->handle);
5722 }
5723
5724 static void read_rssi_rsp(const void *data, uint8_t size)
5725 {
5726         const struct bt_hci_rsp_read_rssi *rsp = data;
5727
5728         print_status(rsp->status);
5729         print_handle(rsp->handle);
5730         print_rssi(rsp->rssi);
5731 }
5732
5733 static void read_afh_channel_map_cmd(const void *data, uint8_t size)
5734 {
5735         const struct bt_hci_cmd_read_afh_channel_map *cmd = data;
5736
5737         print_handle(cmd->handle);
5738 }
5739
5740 static void read_afh_channel_map_rsp(const void *data, uint8_t size)
5741 {
5742         const struct bt_hci_rsp_read_afh_channel_map *rsp = data;
5743
5744         print_status(rsp->status);
5745         print_handle(rsp->handle);
5746         print_afh_mode(rsp->mode);
5747         print_channel_map(rsp->map);
5748 }
5749
5750 static void read_clock_cmd(const void *data, uint8_t size)
5751 {
5752         const struct bt_hci_cmd_read_clock *cmd = data;
5753
5754         print_handle(cmd->handle);
5755         print_clock_type(cmd->type);
5756 }
5757
5758 static void read_clock_rsp(const void *data, uint8_t size)
5759 {
5760         const struct bt_hci_rsp_read_clock *rsp = data;
5761
5762         print_status(rsp->status);
5763         print_handle(rsp->handle);
5764         print_clock(rsp->clock);
5765         print_clock_accuracy(rsp->accuracy);
5766 }
5767
5768 static void read_encrypt_key_size_cmd(const void *data, uint8_t size)
5769 {
5770         const struct bt_hci_cmd_read_encrypt_key_size *cmd = data;
5771
5772         print_handle(cmd->handle);
5773 }
5774
5775 static void read_encrypt_key_size_rsp(const void *data, uint8_t size)
5776 {
5777         const struct bt_hci_rsp_read_encrypt_key_size *rsp = data;
5778
5779         print_status(rsp->status);
5780         print_handle(rsp->handle);
5781         print_key_size(rsp->key_size);
5782 }
5783
5784 static void read_local_amp_info_rsp(const void *data, uint8_t size)
5785 {
5786         const struct bt_hci_rsp_read_local_amp_info *rsp = data;
5787         const char *str;
5788
5789         print_status(rsp->status);
5790         print_amp_status(rsp->amp_status);
5791
5792         print_field("Total bandwidth: %d kbps", le32_to_cpu(rsp->total_bw));
5793         print_field("Max guaranteed bandwidth: %d kbps",
5794                                                 le32_to_cpu(rsp->max_bw));
5795         print_field("Min latency: %d", le32_to_cpu(rsp->min_latency));
5796         print_field("Max PDU size: %d", le32_to_cpu(rsp->max_pdu));
5797
5798         switch (rsp->amp_type) {
5799         case 0x00:
5800                 str = "Primary BR/EDR Controller";
5801                 break;
5802         case 0x01:
5803                 str = "802.11 AMP Controller";
5804                 break;
5805         default:
5806                 str = "Reserved";
5807                 break;
5808         }
5809
5810         print_field("Controller type: %s (0x%2.2x)", str, rsp->amp_type);
5811
5812         print_field("PAL capabilities: 0x%4.4x", le16_to_cpu(rsp->pal_cap));
5813         print_field("Max ASSOC length: %d", le16_to_cpu(rsp->max_assoc_len));
5814         print_field("Max flush timeout: %d", le32_to_cpu(rsp->max_flush_to));
5815         print_field("Best effort flush timeout: %d",
5816                                         le32_to_cpu(rsp->be_flush_to));
5817 }
5818
5819 static void read_local_amp_assoc_cmd(const void *data, uint8_t size)
5820 {
5821         const struct bt_hci_cmd_read_local_amp_assoc *cmd = data;
5822
5823         print_phy_handle(cmd->phy_handle);
5824         print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
5825         print_field("Max ASSOC length: %d", le16_to_cpu(cmd->max_assoc_len));
5826 }
5827
5828 static void read_local_amp_assoc_rsp(const void *data, uint8_t size)
5829 {
5830         const struct bt_hci_rsp_read_local_amp_assoc *rsp = data;
5831
5832         print_status(rsp->status);
5833         print_phy_handle(rsp->phy_handle);
5834         print_field("Remaining ASSOC length: %d",
5835                                         le16_to_cpu(rsp->remain_assoc_len));
5836
5837         packet_hexdump(data + 4, size - 4);
5838 }
5839
5840 static void write_remote_amp_assoc_cmd(const void *data, uint8_t size)
5841 {
5842         const struct bt_hci_cmd_write_remote_amp_assoc *cmd = data;
5843
5844         print_phy_handle(cmd->phy_handle);
5845         print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
5846         print_field("Remaining ASSOC length: %d",
5847                                         le16_to_cpu(cmd->remain_assoc_len));
5848
5849         packet_hexdump(data + 5, size - 5);
5850 }
5851
5852 static void write_remote_amp_assoc_rsp(const void *data, uint8_t size)
5853 {
5854         const struct bt_hci_rsp_write_remote_amp_assoc *rsp = data;
5855
5856         print_status(rsp->status);
5857         print_phy_handle(rsp->phy_handle);
5858 }
5859
5860 static void get_mws_transport_config_rsp(const void *data, uint8_t size)
5861 {
5862         const struct bt_hci_rsp_get_mws_transport_config *rsp = data;
5863         uint8_t sum_baud_rates = 0;
5864         int i;
5865
5866         print_status(rsp->status);
5867         print_field("Number of transports: %d", rsp->num_transports);
5868
5869         for (i = 0; i < rsp->num_transports; i++) {
5870                 uint8_t transport = rsp->transport[0];
5871                 uint8_t num_baud_rates = rsp->transport[1];
5872                 const char *str;
5873
5874                 switch (transport) {
5875                 case 0x00:
5876                         str = "Disbabled";
5877                         break;
5878                 case 0x01:
5879                         str = "WCI-1";
5880                         break;
5881                 case 0x02:
5882                         str = "WCI-2";
5883                         break;
5884                 default:
5885                         str = "Reserved";
5886                         break;
5887                 }
5888
5889                 print_field("  Transport layer: %s (0x%2.2x)", str, transport);
5890                 print_field("  Number of baud rates: %d", num_baud_rates);
5891
5892                 sum_baud_rates += num_baud_rates;
5893         }
5894
5895         print_field("Baud rate list: %u entr%s", sum_baud_rates,
5896                                         sum_baud_rates == 1 ? "y" : "ies");
5897
5898         for (i = 0; i < sum_baud_rates; i++) {
5899                 uint32_t to_baud_rate, from_baud_rate;
5900
5901                 to_baud_rate = get_le32(data + 2 +
5902                                         rsp->num_transports * 2 + i * 4);
5903                 from_baud_rate = get_le32(data + 2 +
5904                                                 rsp->num_transports * 2 +
5905                                                 sum_baud_rates * 4 + i * 4);
5906
5907                 print_field("  Bluetooth to MWS: %d", to_baud_rate);
5908                 print_field("  MWS to Bluetooth: %d", from_baud_rate);
5909         }
5910
5911         packet_hexdump(data + 2 + rsp->num_transports * 2 + sum_baud_rates * 8,
5912                 size - 2 - rsp->num_transports * 2 - sum_baud_rates * 8);
5913 }
5914
5915 static void set_triggered_clock_capture_cmd(const void *data, uint8_t size)
5916 {
5917         const struct bt_hci_cmd_set_triggered_clock_capture *cmd = data;
5918         const char *str;
5919
5920         print_handle(cmd->handle);
5921
5922         switch (cmd->enable) {
5923         case 0x00:
5924                 str = "Disabled";
5925                 break;
5926         case 0x01:
5927                 str = "Enabled";
5928                 break;
5929         default:
5930                 str = "Reserved";
5931                 break;
5932         }
5933
5934         print_field("Capture: %s (0x%2.2x)", str, cmd->enable);
5935
5936         print_clock_type(cmd->type);
5937         print_lpo_allowed(cmd->lpo_allowed);
5938         print_field("Clock captures to filter: %u", cmd->num_filter);
5939 }
5940
5941 static void read_loopback_mode_rsp(const void *data, uint8_t size)
5942 {
5943         const struct bt_hci_rsp_read_loopback_mode *rsp = data;
5944
5945         print_status(rsp->status);
5946         print_loopback_mode(rsp->mode);
5947 }
5948
5949 static void write_loopback_mode_cmd(const void *data, uint8_t size)
5950 {
5951         const struct bt_hci_cmd_write_loopback_mode *cmd = data;
5952
5953         print_loopback_mode(cmd->mode);
5954 }
5955
5956 static void write_ssp_debug_mode_cmd(const void *data, uint8_t size)
5957 {
5958         const struct bt_hci_cmd_write_ssp_debug_mode *cmd = data;
5959
5960         print_ssp_debug_mode(cmd->mode);
5961 }
5962
5963 static void le_set_event_mask_cmd(const void *data, uint8_t size)
5964 {
5965         const struct bt_hci_cmd_le_set_event_mask *cmd = data;
5966
5967         print_event_mask_le(cmd->mask);
5968 }
5969
5970 static void le_read_buffer_size_rsp(const void *data, uint8_t size)
5971 {
5972         const struct bt_hci_rsp_le_read_buffer_size *rsp = data;
5973
5974         print_status(rsp->status);
5975         print_field("Data packet length: %d", le16_to_cpu(rsp->le_mtu));
5976         print_field("Num data packets: %d", rsp->le_max_pkt);
5977 }
5978
5979 static void le_read_local_features_rsp(const void *data, uint8_t size)
5980 {
5981         const struct bt_hci_rsp_le_read_local_features *rsp = data;
5982
5983         print_status(rsp->status);
5984         print_features(0, rsp->features, 0x01);
5985 }
5986
5987 static void le_set_random_address_cmd(const void *data, uint8_t size)
5988 {
5989         const struct bt_hci_cmd_le_set_random_address *cmd = data;
5990
5991         print_addr("Address", cmd->addr, 0x01);
5992 }
5993
5994 static void le_set_adv_parameters_cmd(const void *data, uint8_t size)
5995 {
5996         const struct bt_hci_cmd_le_set_adv_parameters *cmd = data;
5997         const char *str;
5998
5999         print_slot_625("Min advertising interval", cmd->min_interval);
6000         print_slot_625("Max advertising interval", cmd->max_interval);
6001
6002         switch (cmd->type) {
6003         case 0x00:
6004                 str = "Connectable undirected - ADV_IND";
6005                 break;
6006         case 0x01:
6007                 str = "Connectable directed - ADV_DIRECT_IND (high duty cycle)";
6008                 break;
6009         case 0x02:
6010                 str = "Scannable undirected - ADV_SCAN_IND";
6011                 break;
6012         case 0x03:
6013                 str = "Non connectable undirected - ADV_NONCONN_IND";
6014                 break;
6015         case 0x04:
6016                 str = "Connectable directed - ADV_DIRECT_IND (low duty cycle)";
6017                 break;
6018         default:
6019                 str = "Reserved";
6020                 break;
6021         }
6022
6023         print_field("Type: %s (0x%2.2x)", str, cmd->type);
6024
6025         print_own_addr_type(cmd->own_addr_type);
6026         print_addr_type("Direct address type", cmd->direct_addr_type);
6027         print_addr("Direct address", cmd->direct_addr, cmd->direct_addr_type);
6028
6029         switch (cmd->channel_map) {
6030         case 0x01:
6031                 str = "37";
6032                 break;
6033         case 0x02:
6034                 str = "38";
6035                 break;
6036         case 0x03:
6037                 str = "37, 38";
6038                 break;
6039         case 0x04:
6040                 str = "39";
6041                 break;
6042         case 0x05:
6043                 str = "37, 39";
6044                 break;
6045         case 0x06:
6046                 str = "38, 39";
6047                 break;
6048         case 0x07:
6049                 str = "37, 38, 39";
6050                 break;
6051         default:
6052                 str = "Reserved";
6053                 break;
6054         }
6055
6056         print_field("Channel map: %s (0x%2.2x)", str, cmd->channel_map);
6057
6058         switch (cmd->filter_policy) {
6059         case 0x00:
6060                 str = "Allow Scan Request from Any, "
6061                         "Allow Connect Request from Any";
6062                 break;
6063         case 0x01:
6064                 str = "Allow Scan Request from White List Only, "
6065                         "Allow Connect Request from Any";
6066                 break;
6067         case 0x02:
6068                 str = "Allow Scan Request from Any, "
6069                         "Allow Connect Request from White List Only";
6070                 break;
6071         case 0x03:
6072                 str = "Allow Scan Request from White List Only, "
6073                         "Allow Connect Request from White List Only";
6074                 break;
6075         default:
6076                 str = "Reserved";
6077                 break;
6078         }
6079
6080         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
6081 }
6082
6083 static void le_read_adv_tx_power_rsp(const void *data, uint8_t size)
6084 {
6085         const struct bt_hci_rsp_le_read_adv_tx_power *rsp = data;
6086
6087         print_status(rsp->status);
6088         print_power_level(rsp->level, NULL);
6089 }
6090
6091 static void le_set_adv_data_cmd(const void *data, uint8_t size)
6092 {
6093         const struct bt_hci_cmd_le_set_adv_data *cmd = data;
6094
6095         print_field("Length: %d", cmd->len);
6096         print_eir(cmd->data, cmd->len, true);
6097 }
6098
6099 static void le_set_scan_rsp_data_cmd(const void *data, uint8_t size)
6100 {
6101         const struct bt_hci_cmd_le_set_scan_rsp_data *cmd = data;
6102
6103         print_field("Length: %d", cmd->len);
6104         print_eir(cmd->data, cmd->len, true);
6105 }
6106
6107 static void le_set_adv_enable_cmd(const void *data, uint8_t size)
6108 {
6109         const struct bt_hci_cmd_le_set_adv_enable *cmd = data;
6110         const char *str;
6111
6112         switch (cmd->enable) {
6113         case 0x00:
6114                 str = "Disabled";
6115                 break;
6116         case 0x01:
6117                 str = "Enabled";
6118                 break;
6119         default:
6120                 str = "Reserved";
6121                 break;
6122         }
6123
6124         print_field("Advertising: %s (0x%2.2x)", str, cmd->enable);
6125 }
6126
6127 static void le_set_scan_parameters_cmd(const void *data, uint8_t size)
6128 {
6129         const struct bt_hci_cmd_le_set_scan_parameters *cmd = data;
6130         const char *str;
6131
6132         switch (cmd->type) {
6133         case 0x00:
6134                 str = "Passive";
6135                 break;
6136         case 0x01:
6137                 str = "Active";
6138                 break;
6139         default:
6140                 str = "Reserved";
6141                 break;
6142         }
6143
6144         print_field("Type: %s (0x%2.2x)", str, cmd->type);
6145
6146         print_interval(cmd->interval);
6147         print_window(cmd->window);
6148         print_own_addr_type(cmd->own_addr_type);
6149
6150         switch (cmd->filter_policy) {
6151         case 0x00:
6152                 str = "Accept all advertisement";
6153                 break;
6154         case 0x01:
6155                 str = "Ignore not in white list";
6156                 break;
6157         default:
6158                 str = "Reserved";
6159                 break;
6160         }
6161
6162         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
6163 }
6164
6165 static void le_set_scan_enable_cmd(const void *data, uint8_t size)
6166 {
6167         const struct bt_hci_cmd_le_set_scan_enable *cmd = data;
6168         const char *str;
6169
6170         switch (cmd->enable) {
6171         case 0x00:
6172                 str = "Disabled";
6173                 break;
6174         case 0x01:
6175                 str = "Enabled";
6176                 break;
6177         default:
6178                 str = "Reserved";
6179                 break;
6180         }
6181
6182         print_field("Scanning: %s (0x%2.2x)", str, cmd->enable);
6183
6184         switch (cmd->filter_dup) {
6185         case 0x00:
6186                 str = "Disabled";
6187                 break;
6188         case 0x01:
6189                 str = "Enabled";
6190                 break;
6191         default:
6192                 str = "Reserved";
6193                 break;
6194         }
6195
6196         print_field("Filter duplicates: %s (0x%2.2x)", str, cmd->filter_dup);
6197 }
6198
6199 static void le_create_conn_cmd(const void *data, uint8_t size)
6200 {
6201         const struct bt_hci_cmd_le_create_conn *cmd = data;
6202         const char *str;
6203
6204         print_slot_625("Scan interval", cmd->scan_interval);
6205         print_slot_625("Scan window", cmd->scan_window);
6206
6207         switch (cmd->filter_policy) {
6208         case 0x00:
6209                 str = "White list is not used";
6210                 break;
6211         case 0x01:
6212                 str = "White list is used";
6213                 break;
6214         default:
6215                 str = "Reserved";
6216                 break;
6217         }
6218
6219         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
6220
6221         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
6222         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
6223         print_own_addr_type(cmd->own_addr_type);
6224
6225         print_slot_125("Min connection interval", cmd->min_interval);
6226         print_slot_125("Max connection interval", cmd->max_interval);
6227         print_field("Connection latency: 0x%4.4x", le16_to_cpu(cmd->latency));
6228         print_field("Supervision timeout: %d msec (0x%4.4x)",
6229                                         le16_to_cpu(cmd->supv_timeout) * 10,
6230                                         le16_to_cpu(cmd->supv_timeout));
6231         print_slot_625("Min connection length", cmd->min_length);
6232         print_slot_625("Max connection length", cmd->max_length);
6233 }
6234
6235 static void le_read_white_list_size_rsp(const void *data, uint8_t size)
6236 {
6237         const struct bt_hci_rsp_le_read_white_list_size *rsp = data;
6238
6239         print_status(rsp->status);
6240         print_field("Size: %u", rsp->size);
6241 }
6242
6243 static void le_add_to_white_list_cmd(const void *data, uint8_t size)
6244 {
6245         const struct bt_hci_cmd_le_add_to_white_list *cmd = data;
6246
6247         print_addr_type("Address type", cmd->addr_type);
6248         print_addr("Address", cmd->addr, cmd->addr_type);
6249 }
6250
6251 static void le_remove_from_white_list_cmd(const void *data, uint8_t size)
6252 {
6253         const struct bt_hci_cmd_le_remove_from_white_list *cmd = data;
6254
6255         print_addr_type("Address type", cmd->addr_type);
6256         print_addr("Address", cmd->addr, cmd->addr_type);
6257 }
6258
6259 static void le_conn_update_cmd(const void *data, uint8_t size)
6260 {
6261         const struct bt_hci_cmd_le_conn_update *cmd = data;
6262
6263         print_handle(cmd->handle);
6264         print_slot_125("Min connection interval", cmd->min_interval);
6265         print_slot_125("Max connection interval", cmd->max_interval);
6266         print_field("Connection latency: 0x%4.4x", le16_to_cpu(cmd->latency));
6267         print_field("Supervision timeout: %d msec (0x%4.4x)",
6268                                         le16_to_cpu(cmd->supv_timeout) * 10,
6269                                         le16_to_cpu(cmd->supv_timeout));
6270         print_slot_625("Min connection length", cmd->min_length);
6271         print_slot_625("Max connection length", cmd->max_length);
6272 }
6273
6274 static void le_set_host_classification_cmd(const void *data, uint8_t size)
6275 {
6276         const struct bt_hci_cmd_le_set_host_classification *cmd = data;
6277
6278         print_le_channel_map(cmd->map);
6279 }
6280
6281 static void le_read_channel_map_cmd(const void *data, uint8_t size)
6282 {
6283         const struct bt_hci_cmd_le_read_channel_map *cmd = data;
6284
6285         print_handle(cmd->handle);
6286 }
6287
6288 static void le_read_channel_map_rsp(const void *data, uint8_t size)
6289 {
6290         const struct bt_hci_rsp_le_read_channel_map *rsp = data;
6291
6292         print_status(rsp->status);
6293         print_handle(rsp->handle);
6294         print_le_channel_map(rsp->map);
6295 }
6296
6297 static void le_read_remote_features_cmd(const void *data, uint8_t size)
6298 {
6299         const struct bt_hci_cmd_le_read_remote_features *cmd = data;
6300
6301         print_handle(cmd->handle);
6302 }
6303
6304 static void le_encrypt_cmd(const void *data, uint8_t size)
6305 {
6306         const struct bt_hci_cmd_le_encrypt *cmd = data;
6307
6308         print_key("Key", cmd->key);
6309         print_key("Plaintext data", cmd->plaintext);
6310 }
6311
6312 static void le_encrypt_rsp(const void *data, uint8_t size)
6313 {
6314         const struct bt_hci_rsp_le_encrypt *rsp = data;
6315
6316         print_status(rsp->status);
6317         print_key("Encrypted data", rsp->data);
6318 }
6319
6320 static void le_rand_rsp(const void *data, uint8_t size)
6321 {
6322         const struct bt_hci_rsp_le_rand *rsp = data;
6323
6324         print_status(rsp->status);
6325         print_random_number(rsp->number);
6326 }
6327
6328 static void le_start_encrypt_cmd(const void *data, uint8_t size)
6329 {
6330         const struct bt_hci_cmd_le_start_encrypt *cmd = data;
6331
6332         print_handle(cmd->handle);
6333         print_random_number(cmd->rand);
6334         print_encrypted_diversifier(cmd->ediv);
6335         print_key("Long term key", cmd->ltk);
6336 }
6337
6338 static void le_ltk_req_reply_cmd(const void *data, uint8_t size)
6339 {
6340         const struct bt_hci_cmd_le_ltk_req_reply *cmd = data;
6341
6342         print_handle(cmd->handle);
6343         print_key("Long term key", cmd->ltk);
6344 }
6345
6346 static void le_ltk_req_reply_rsp(const void *data, uint8_t size)
6347 {
6348         const struct bt_hci_rsp_le_ltk_req_reply *rsp = data;
6349
6350         print_status(rsp->status);
6351         print_handle(rsp->handle);
6352 }
6353
6354 static void le_ltk_req_neg_reply_cmd(const void *data, uint8_t size)
6355 {
6356         const struct bt_hci_cmd_le_ltk_req_neg_reply *cmd = data;
6357
6358         print_handle(cmd->handle);
6359 }
6360
6361 static void le_ltk_req_neg_reply_rsp(const void *data, uint8_t size)
6362 {
6363         const struct bt_hci_rsp_le_ltk_req_neg_reply *rsp = data;
6364
6365         print_status(rsp->status);
6366         print_handle(rsp->handle);
6367 }
6368
6369 static void le_read_supported_states_rsp(const void *data, uint8_t size)
6370 {
6371         const struct bt_hci_rsp_le_read_supported_states *rsp = data;
6372
6373         print_status(rsp->status);
6374         print_le_states(rsp->states);
6375 }
6376
6377 static void le_receiver_test_cmd(const void *data, uint8_t size)
6378 {
6379         const struct bt_hci_cmd_le_receiver_test *cmd = data;
6380
6381         print_field("RX frequency: %d MHz (0x%2.2x)",
6382                                 (cmd->frequency * 2) + 2402, cmd->frequency);
6383 }
6384
6385 static void le_transmitter_test_cmd(const void *data, uint8_t size)
6386 {
6387         const struct bt_hci_cmd_le_transmitter_test *cmd = data;
6388
6389         print_field("TX frequency: %d MHz (0x%2.2x)",
6390                                 (cmd->frequency * 2) + 2402, cmd->frequency);
6391         print_field("Test data length: %d bytes", cmd->data_len);
6392         print_field("Packet payload: 0x%2.2x", cmd->payload);
6393 }
6394
6395 static void le_test_end_rsp(const void *data, uint8_t size)
6396 {
6397         const struct bt_hci_rsp_le_test_end *rsp = data;
6398
6399         print_status(rsp->status);
6400         print_field("Number of packets: %d", le16_to_cpu(rsp->num_packets));
6401 }
6402
6403 static void le_conn_param_req_reply_cmd(const void *data, uint8_t size)
6404 {
6405         const struct bt_hci_cmd_le_conn_param_req_reply *cmd = data;
6406
6407         print_handle(cmd->handle);
6408         print_slot_125("Min connection interval", cmd->min_interval);
6409         print_slot_125("Max connection interval", cmd->max_interval);
6410         print_field("Connection latency: 0x%4.4x", le16_to_cpu(cmd->latency));
6411         print_field("Supervision timeout: %d msec (0x%4.4x)",
6412                                         le16_to_cpu(cmd->supv_timeout) * 10,
6413                                         le16_to_cpu(cmd->supv_timeout));
6414         print_slot_625("Min connection length", cmd->min_length);
6415         print_slot_625("Max connection length", cmd->max_length);
6416 }
6417
6418 static void le_conn_param_req_reply_rsp(const void *data, uint8_t size)
6419 {
6420         const struct bt_hci_rsp_le_conn_param_req_reply *rsp = data;
6421
6422         print_status(rsp->status);
6423         print_handle(rsp->handle);
6424 }
6425
6426 static void le_conn_param_req_neg_reply_cmd(const void *data, uint8_t size)
6427 {
6428         const struct bt_hci_cmd_le_conn_param_req_neg_reply *cmd = data;
6429
6430         print_handle(cmd->handle);
6431         print_reason(cmd->reason);
6432 }
6433
6434 static void le_conn_param_req_neg_reply_rsp(const void *data, uint8_t size)
6435 {
6436         const struct bt_hci_rsp_le_conn_param_req_neg_reply *rsp = data;
6437
6438         print_status(rsp->status);
6439         print_handle(rsp->handle);
6440 }
6441
6442 static void le_set_data_length_cmd(const void *data, uint8_t size)
6443 {
6444         const struct bt_hci_cmd_le_set_data_length *cmd = data;
6445
6446         print_handle(cmd->handle);
6447         print_field("TX octets: %d", le16_to_cpu(cmd->tx_len));
6448         print_field("TX time: %d", le16_to_cpu(cmd->tx_time));
6449 }
6450
6451 static void le_set_data_length_rsp(const void *data, uint8_t size)
6452 {
6453         const struct bt_hci_rsp_le_set_data_length *rsp = data;
6454
6455         print_status(rsp->status);
6456         print_handle(rsp->handle);
6457 }
6458
6459 static void le_read_default_data_length_rsp(const void *data, uint8_t size)
6460 {
6461         const struct bt_hci_rsp_le_read_default_data_length *rsp = data;
6462
6463         print_status(rsp->status);
6464         print_field("TX octets: %d", le16_to_cpu(rsp->tx_len));
6465         print_field("TX time: %d", le16_to_cpu(rsp->tx_time));
6466 }
6467
6468 static void le_write_default_data_length_cmd(const void *data, uint8_t size)
6469 {
6470         const struct bt_hci_cmd_le_write_default_data_length *cmd = data;
6471
6472         print_field("TX octets: %d", le16_to_cpu(cmd->tx_len));
6473         print_field("TX time: %d", le16_to_cpu(cmd->tx_time));
6474 }
6475
6476 static void le_generate_dhkey_cmd(const void *data, uint8_t size)
6477 {
6478         const struct bt_hci_cmd_le_generate_dhkey *cmd = data;
6479
6480         print_pk256("Remote P-256 public key", cmd->remote_pk256);
6481 }
6482
6483 static void le_add_to_resolv_list_cmd(const void *data, uint8_t size)
6484 {
6485         const struct bt_hci_cmd_le_add_to_resolv_list *cmd = data;
6486
6487         print_addr_type("Address type", cmd->addr_type);
6488         print_addr("Address", cmd->addr, cmd->addr_type);
6489         print_key("Peer identity resolving key", cmd->peer_irk);
6490         print_key("Local identity resolving key", cmd->local_irk);
6491 }
6492
6493 static void le_remove_from_resolv_list_cmd(const void *data, uint8_t size)
6494 {
6495         const struct bt_hci_cmd_le_remove_from_resolv_list *cmd = data;
6496
6497         print_addr_type("Address type", cmd->addr_type);
6498         print_addr("Address", cmd->addr, cmd->addr_type);
6499 }
6500
6501 static void le_read_resolv_list_size_rsp(const void *data, uint8_t size)
6502 {
6503         const struct bt_hci_rsp_le_read_resolv_list_size *rsp = data;
6504
6505         print_status(rsp->status);
6506         print_field("Size: %u", rsp->size);
6507 }
6508
6509 static void le_read_peer_resolv_addr_cmd(const void *data, uint8_t size)
6510 {
6511         const struct bt_hci_cmd_le_read_peer_resolv_addr *cmd = data;
6512
6513         print_addr_type("Address type", cmd->addr_type);
6514         print_addr("Address", cmd->addr, cmd->addr_type);
6515 }
6516
6517 static void le_read_peer_resolv_addr_rsp(const void *data, uint8_t size)
6518 {
6519         const struct bt_hci_rsp_le_read_peer_resolv_addr *rsp = data;
6520
6521         print_status(rsp->status);
6522         print_addr("Address", rsp->addr, 0x01);
6523 }
6524
6525 static void le_read_local_resolv_addr_cmd(const void *data, uint8_t size)
6526 {
6527         const struct bt_hci_cmd_le_read_local_resolv_addr *cmd = data;
6528
6529         print_addr_type("Address type", cmd->addr_type);
6530         print_addr("Address", cmd->addr, cmd->addr_type);
6531 }
6532
6533 static void le_read_local_resolv_addr_rsp(const void *data, uint8_t size)
6534 {
6535         const struct bt_hci_rsp_le_read_local_resolv_addr *rsp = data;
6536
6537         print_status(rsp->status);
6538         print_addr("Address", rsp->addr, 0x01);
6539 }
6540
6541 static void le_set_resolv_enable_cmd(const void *data, uint8_t size)
6542 {
6543         const struct bt_hci_cmd_le_set_resolv_enable *cmd = data;
6544         const char *str;
6545
6546         switch (cmd->enable) {
6547         case 0x00:
6548                 str = "Disabled";
6549                 break;
6550         case 0x01:
6551                 str = "Enabled";
6552                 break;
6553         default:
6554                 str = "Reserved";
6555                 break;
6556         }
6557
6558         print_field("Address resolution: %s (0x%2.2x)", str, cmd->enable);
6559 }
6560
6561 static void le_set_resolv_timeout_cmd(const void *data, uint8_t size)
6562 {
6563         const struct bt_hci_cmd_le_set_resolv_timeout *cmd = data;
6564
6565         print_field("Timeout: %u seconds", le16_to_cpu(cmd->timeout));
6566 }
6567
6568 static void le_read_max_data_length_rsp(const void *data, uint8_t size)
6569 {
6570         const struct bt_hci_rsp_le_read_max_data_length *rsp = data;
6571
6572         print_status(rsp->status);
6573         print_field("Max TX octets: %d", le16_to_cpu(rsp->max_tx_len));
6574         print_field("Max TX time: %d", le16_to_cpu(rsp->max_tx_time));
6575         print_field("Max RX octets: %d", le16_to_cpu(rsp->max_rx_len));
6576         print_field("Max RX time: %d", le16_to_cpu(rsp->max_rx_time));
6577 }
6578
6579 struct opcode_data {
6580         uint16_t opcode;
6581         int bit;
6582         const char *str;
6583         void (*cmd_func) (const void *data, uint8_t size);
6584         uint8_t cmd_size;
6585         bool cmd_fixed;
6586         void (*rsp_func) (const void *data, uint8_t size);
6587         uint8_t rsp_size;
6588         bool rsp_fixed;
6589 };
6590
6591 static const struct opcode_data opcode_table[] = {
6592         { 0x0000,  -1, "NOP" },
6593
6594         /* OGF 1 - Link Control */
6595         { 0x0401,   0, "Inquiry",
6596                                 inquiry_cmd, 5, true },
6597         { 0x0402,   1, "Inquiry Cancel",
6598                                 null_cmd, 0, true,
6599                                 status_rsp, 1, true },
6600         { 0x0403,   2, "Periodic Inquiry Mode",
6601                                 periodic_inquiry_cmd, 9, true,
6602                                 status_rsp, 1, true },
6603         { 0x0404,   3, "Exit Periodic Inquiry Mode",
6604                                 null_cmd, 0, true,
6605                                 status_rsp, 1, true },
6606         { 0x0405,   4, "Create Connection",
6607                                 create_conn_cmd, 13, true },
6608         { 0x0406,   5, "Disconnect",
6609                                 disconnect_cmd, 3, true },
6610         { 0x0407,   6, "Add SCO Connection",
6611                                 add_sco_conn_cmd, 4, true },
6612         { 0x0408,   7, "Create Connection Cancel",
6613                                 create_conn_cancel_cmd, 6, true,
6614                                 status_bdaddr_rsp, 7, true },
6615         { 0x0409,   8, "Accept Connection Request",
6616                                 accept_conn_request_cmd, 7, true },
6617         { 0x040a,   9, "Reject Connection Request",
6618                                 reject_conn_request_cmd, 7, true },
6619         { 0x040b,  10, "Link Key Request Reply",
6620                                 link_key_request_reply_cmd, 22, true,
6621                                 status_bdaddr_rsp, 7, true },
6622         { 0x040c,  11, "Link Key Request Negative Reply",
6623                                 link_key_request_neg_reply_cmd, 6, true,
6624                                 status_bdaddr_rsp, 7, true },
6625         { 0x040d,  12, "PIN Code Request Reply",
6626                                 pin_code_request_reply_cmd, 23, true,
6627                                 status_bdaddr_rsp, 7, true },
6628         { 0x040e,  13, "PIN Code Request Negative Reply",
6629                                 pin_code_request_neg_reply_cmd, 6, true,
6630                                 status_bdaddr_rsp, 7, true },
6631         { 0x040f,  14, "Change Connection Packet Type",
6632                                 change_conn_pkt_type_cmd, 4, true },
6633         { 0x0411,  15, "Authentication Requested",
6634                                 auth_requested_cmd, 2, true },
6635         { 0x0413,  16, "Set Connection Encryption",
6636                                 set_conn_encrypt_cmd, 3, true },
6637         { 0x0415,  17, "Change Connection Link Key",
6638                                 change_conn_link_key_cmd, 2, true },
6639         { 0x0417,  18, "Master Link Key",
6640                                 master_link_key_cmd, 1, true },
6641         { 0x0419,  19, "Remote Name Request",
6642                                 remote_name_request_cmd, 10, true },
6643         { 0x041a,  20, "Remote Name Request Cancel",
6644                                 remote_name_request_cancel_cmd, 6, true,
6645                                 status_bdaddr_rsp, 7, true },
6646         { 0x041b,  21, "Read Remote Supported Features",
6647                                 read_remote_features_cmd, 2, true },
6648         { 0x041c,  22, "Read Remote Extended Features",
6649                                 read_remote_ext_features_cmd, 3, true },
6650         { 0x041d,  23, "Read Remote Version Information",
6651                                 read_remote_version_cmd, 2, true },
6652         { 0x041f,  24, "Read Clock Offset",
6653                                 read_clock_offset_cmd, 2, true },
6654         { 0x0420,  25, "Read LMP Handle",
6655                                 read_lmp_handle_cmd, 2, true,
6656                                 read_lmp_handle_rsp, 8, true },
6657         { 0x0428, 131, "Setup Synchronous Connection",
6658                                 setup_sync_conn_cmd, 17, true },
6659         { 0x0429, 132, "Accept Synchronous Connection Request",
6660                                 accept_sync_conn_request_cmd, 21, true },
6661         { 0x042a, 133, "Reject Synchronous Connection Request",
6662                                 reject_sync_conn_request_cmd, 7, true },
6663         { 0x042b, 151, "IO Capability Request Reply",
6664                                 io_capability_request_reply_cmd, 9, true,
6665                                 status_bdaddr_rsp, 7, true },
6666         { 0x042c, 152, "User Confirmation Request Reply",
6667                                 user_confirm_request_reply_cmd, 6, true,
6668                                 status_bdaddr_rsp, 7, true },
6669         { 0x042d, 153, "User Confirmation Request Neg Reply",
6670                                 user_confirm_request_neg_reply_cmd, 6, true,
6671                                 status_bdaddr_rsp, 7, true },
6672         { 0x042e, 154, "User Passkey Request Reply",
6673                                 user_passkey_request_reply_cmd, 10, true,
6674                                 status_bdaddr_rsp, 7, true },
6675         { 0x042f, 155, "User Passkey Request Negative Reply",
6676                                 user_passkey_request_neg_reply_cmd, 6, true,
6677                                 status_bdaddr_rsp, 7, true },
6678         { 0x0430, 156, "Remote OOB Data Request Reply",
6679                                 remote_oob_data_request_reply_cmd, 38, true,
6680                                 status_bdaddr_rsp, 7, true },
6681         { 0x0433, 159, "Remote OOB Data Request Neg Reply",
6682                                 remote_oob_data_request_neg_reply_cmd, 6, true,
6683                                 status_bdaddr_rsp, 7, true },
6684         { 0x0434, 163, "IO Capability Request Negative Reply",
6685                                 io_capability_request_neg_reply_cmd, 7, true,
6686                                 status_bdaddr_rsp, 7, true },
6687         { 0x0435, 168, "Create Physical Link",
6688                                 create_phy_link_cmd, 3, false },
6689         { 0x0436, 169, "Accept Physical Link",
6690                                 accept_phy_link_cmd, 3, false },
6691         { 0x0437, 170, "Disconnect Physical Link",
6692                                 disconn_phy_link_cmd, 2, true },
6693         { 0x0438, 171, "Create Logical Link",
6694                                 create_logic_link_cmd, 33, true },
6695         { 0x0439, 172, "Accept Logical Link",
6696                                 accept_logic_link_cmd, 33, true },
6697         { 0x043a, 173, "Disconnect Logical Link",
6698                                 disconn_logic_link_cmd, 2, true },
6699         { 0x043b, 174, "Logical Link Cancel",
6700                                 logic_link_cancel_cmd, 2, true,
6701                                 logic_link_cancel_rsp, 3, true },
6702         { 0x043c, 175, "Flow Specifcation Modify",
6703                                 flow_spec_modify_cmd, 34, true },
6704         { 0x043d, 235, "Enhanced Setup Synchronous Connection",
6705                                 enhanced_setup_sync_conn_cmd, 59, true },
6706         { 0x043e, 236, "Enhanced Accept Synchronous Connection Request",
6707                                 enhanced_accept_sync_conn_request_cmd, 63, true },
6708         { 0x043f, 246, "Truncated Page",
6709                                 truncated_page_cmd, 9, true },
6710         { 0x0440, 247, "Truncated Page Cancel",
6711                                 truncated_page_cancel_cmd, 6, true,
6712                                 status_bdaddr_rsp, 7, true },
6713         { 0x0441, 248, "Set Connectionless Slave Broadcast",
6714                                 set_slave_broadcast_cmd, 11, true,
6715                                 set_slave_broadcast_rsp, 4, true },
6716         { 0x0442, 249, "Set Connectionless Slave Broadcast Receive",
6717                                 set_slave_broadcast_receive_cmd, 34, true,
6718                                 set_slave_broadcast_receive_rsp, 8, true },
6719         { 0x0443, 250, "Start Synchronization Train",
6720                                 null_cmd, 0, true },
6721         { 0x0444, 251, "Receive Synchronization Train",
6722                                 receive_sync_train_cmd, 12, true },
6723         { 0x0445, 257, "Remote OOB Extended Data Request Reply",
6724                                 remote_oob_ext_data_request_reply_cmd, 70, true,
6725                                 status_bdaddr_rsp, 7, true },
6726
6727         /* OGF 2 - Link Policy */
6728         { 0x0801,  33, "Hold Mode",
6729                                 hold_mode_cmd, 6, true },
6730         { 0x0803,  34, "Sniff Mode",
6731                                 sniff_mode_cmd, 10, true },
6732         { 0x0804,  35, "Exit Sniff Mode",
6733                                 exit_sniff_mode_cmd, 2, true },
6734         { 0x0805,  36, "Park State",
6735                                 park_state_cmd, 6, true },
6736         { 0x0806,  37, "Exit Park State",
6737                                 exit_park_state_cmd, 2, true },
6738         { 0x0807,  38, "QoS Setup",
6739                                 qos_setup_cmd, 20, true },
6740         { 0x0809,  39, "Role Discovery",
6741                                 role_discovery_cmd, 2, true,
6742                                 role_discovery_rsp, 4, true },
6743         { 0x080b,  40, "Switch Role",
6744                                 switch_role_cmd, 7, true },
6745         { 0x080c,  41, "Read Link Policy Settings",
6746                                 read_link_policy_cmd, 2, true,
6747                                 read_link_policy_rsp, 5, true },
6748         { 0x080d,  42, "Write Link Policy Settings",
6749                                 write_link_policy_cmd, 4, true,
6750                                 write_link_policy_rsp, 3, true },
6751         { 0x080e,  43, "Read Default Link Policy Settings",
6752                                 null_cmd, 0, true,
6753                                 read_default_link_policy_rsp, 3, true },
6754         { 0x080f,  44, "Write Default Link Policy Settings",
6755                                 write_default_link_policy_cmd, 2, true,
6756                                 status_rsp, 1, true },
6757         { 0x0810,  45, "Flow Specification",
6758                                 flow_spec_cmd, 21, true },
6759         { 0x0811, 140, "Sniff Subrating",
6760                                 sniff_subrating_cmd, 8, true,
6761                                 sniff_subrating_rsp, 3, true },
6762
6763         /* OGF 3 - Host Control */
6764         { 0x0c01,  46, "Set Event Mask",
6765                                 set_event_mask_cmd, 8, true,
6766                                 status_rsp, 1, true },
6767         { 0x0c03,  47, "Reset",
6768                                 null_cmd, 0, true,
6769                                 status_rsp, 1, true },
6770         { 0x0c05,  48, "Set Event Filter",
6771                                 set_event_filter_cmd, 1, false,
6772                                 status_rsp, 1, true },
6773         { 0x0c08,  49, "Flush",
6774                                 flush_cmd, 2, true,
6775                                 flush_rsp, 3, true },
6776         { 0x0c09,  50, "Read PIN Type",
6777                                 null_cmd, 0, true,
6778                                 read_pin_type_rsp, 2, true },
6779         { 0x0c0a,  51, "Write PIN Type",
6780                                 write_pin_type_cmd, 1, true,
6781                                 status_rsp, 1, true },
6782         { 0x0c0b,  52, "Create New Unit Key",
6783                                 null_cmd, 0, true,
6784                                 status_rsp, 1, true },
6785         { 0x0c0d,  53, "Read Stored Link Key",
6786                                 read_stored_link_key_cmd, 7, true,
6787                                 read_stored_link_key_rsp, 5, true },
6788         { 0x0c11,  54, "Write Stored Link Key",
6789                                 write_stored_link_key_cmd, 1, false,
6790                                 write_stored_link_key_rsp, 2, true },
6791         { 0x0c12,  55, "Delete Stored Link Key",
6792                                 delete_stored_link_key_cmd, 7, true,
6793                                 delete_stored_link_key_rsp, 3, true },
6794         { 0x0c13,  56, "Write Local Name",
6795                                 write_local_name_cmd, 248, true,
6796                                 status_rsp, 1, true },
6797         { 0x0c14,  57, "Read Local Name",
6798                                 null_cmd, 0, true,
6799                                 read_local_name_rsp, 249, true },
6800         { 0x0c15,  58, "Read Connection Accept Timeout",
6801                                 null_cmd, 0, true,
6802                                 read_conn_accept_timeout_rsp, 3, true },
6803         { 0x0c16,  59, "Write Connection Accept Timeout",
6804                                 write_conn_accept_timeout_cmd, 2, true,
6805                                 status_rsp, 1, true },
6806         { 0x0c17,  60, "Read Page Timeout",
6807                                 null_cmd, 0, true,
6808                                 read_page_timeout_rsp, 3, true },
6809         { 0x0c18,  61, "Write Page Timeout",
6810                                 write_page_timeout_cmd, 2, true,
6811                                 status_rsp, 1, true },
6812         { 0x0c19,  62, "Read Scan Enable",
6813                                 null_cmd, 0, true,
6814                                 read_scan_enable_rsp, 2, true },
6815         { 0x0c1a,  63, "Write Scan Enable",
6816                                 write_scan_enable_cmd, 1, true,
6817                                 status_rsp, 1, true },
6818         { 0x0c1b,  64, "Read Page Scan Activity",
6819                                 null_cmd, 0, true,
6820                                 read_page_scan_activity_rsp, 5, true },
6821         { 0x0c1c,  65, "Write Page Scan Activity",
6822                                 write_page_scan_activity_cmd, 4, true,
6823                                 status_rsp, 1, true },
6824         { 0x0c1d,  66, "Read Inquiry Scan Activity",
6825                                 null_cmd, 0, true,
6826                                 read_inquiry_scan_activity_rsp, 5, true },
6827         { 0x0c1e,  67, "Write Inquiry Scan Activity",
6828                                 write_inquiry_scan_activity_cmd, 4, true,
6829                                 status_rsp, 1, true },
6830         { 0x0c1f,  68, "Read Authentication Enable",
6831                                 null_cmd, 0, true,
6832                                 read_auth_enable_rsp, 2, true },
6833         { 0x0c20,  69, "Write Authentication Enable",
6834                                 write_auth_enable_cmd, 1, true,
6835                                 status_rsp, 1, true },
6836         { 0x0c21,  70, "Read Encryption Mode",
6837                                 null_cmd, 0, true,
6838                                 read_encrypt_mode_rsp, 2, true },
6839         { 0x0c22,  71, "Write Encryption Mode",
6840                                 write_encrypt_mode_cmd, 1, true,
6841                                 status_rsp, 1, true },
6842         { 0x0c23,  72, "Read Class of Device",
6843                                 null_cmd, 0, true,
6844                                 read_class_of_dev_rsp, 4, true },
6845         { 0x0c24,  73, "Write Class of Device",
6846                                 write_class_of_dev_cmd, 3, true,
6847                                 status_rsp, 1, true },
6848         { 0x0c25,  74, "Read Voice Setting",
6849                                 null_cmd, 0, true,
6850                                 read_voice_setting_rsp, 3, true },
6851         { 0x0c26,  75, "Write Voice Setting",
6852                                 write_voice_setting_cmd, 2, true,
6853                                 status_rsp, 1, true },
6854         { 0x0c27,  76, "Read Automatic Flush Timeout",
6855                                 read_auto_flush_timeout_cmd, 2, true,
6856                                 read_auto_flush_timeout_rsp, 5, true },
6857         { 0x0c28,  77, "Write Automatic Flush Timeout",
6858                                 write_auto_flush_timeout_cmd, 4, true,
6859                                 write_auto_flush_timeout_rsp, 3, true },
6860         { 0x0c29,  78, "Read Num Broadcast Retransmissions",
6861                                 null_cmd, 0, true,
6862                                 read_num_broadcast_retrans_rsp, 2, true },
6863         { 0x0c2a,  79, "Write Num Broadcast Retransmissions",
6864                                 write_num_broadcast_retrans_cmd, 1, true,
6865                                 status_rsp, 1, true },
6866         { 0x0c2b,  80, "Read Hold Mode Activity",
6867                                 null_cmd, 0, true,
6868                                 read_hold_mode_activity_rsp, 2, true },
6869         { 0x0c2c,  81, "Write Hold Mode Activity",
6870                                 write_hold_mode_activity_cmd, 1, true,
6871                                 status_rsp, 1, true },
6872         { 0x0c2d,  82, "Read Transmit Power Level",
6873                                 read_tx_power_cmd, 3, true,
6874                                 read_tx_power_rsp, 4, true },
6875         { 0x0c2e,  83, "Read Sync Flow Control Enable",
6876                                 null_cmd, 0, true,
6877                                 read_sync_flow_control_rsp, 2, true },
6878         { 0x0c2f,  84, "Write Sync Flow Control Enable",
6879                                 write_sync_flow_control_cmd, 1, true,
6880                                 status_rsp, 1, true },
6881         { 0x0c31,  85, "Set Controller To Host Flow Control",
6882                                 set_host_flow_control_cmd, 1, true,
6883                                 status_rsp, 1, true },
6884         { 0x0c33,  86, "Host Buffer Size",
6885                                 host_buffer_size_cmd, 7, true,
6886                                 status_rsp, 1, true },
6887         { 0x0c35,  87, "Host Number of Completed Packets",
6888                                 host_num_completed_packets_cmd, 5, false },
6889         { 0x0c36,  88, "Read Link Supervision Timeout",
6890                                 read_link_supv_timeout_cmd, 2, true,
6891                                 read_link_supv_timeout_rsp, 5, true },
6892         { 0x0c37,  89, "Write Link Supervision Timeout",
6893                                 write_link_supv_timeout_cmd, 4, true,
6894                                 write_link_supv_timeout_rsp, 3, true },
6895         { 0x0c38,  90, "Read Number of Supported IAC",
6896                                 null_cmd, 0, true,
6897                                 read_num_supported_iac_rsp, 2, true },
6898         { 0x0c39,  91, "Read Current IAC LAP",
6899                                 null_cmd, 0, true,
6900                                 read_current_iac_lap_rsp, 2, false },
6901         { 0x0c3a,  92, "Write Current IAC LAP",
6902                                 write_current_iac_lap_cmd, 1, false,
6903                                 status_rsp, 1, true },
6904         { 0x0c3b,  93, "Read Page Scan Period Mode",
6905                                 null_cmd, 0, true,
6906                                 read_page_scan_period_mode_rsp, 2, true },
6907         { 0x0c3c,  94, "Write Page Scan Period Mode",
6908                                 write_page_scan_period_mode_cmd, 1, true,
6909                                 status_rsp, 1, true },
6910         { 0x0c3d,  95, "Read Page Scan Mode",
6911                                 null_cmd, 0, true,
6912                                 read_page_scan_mode_rsp, 2, true },
6913         { 0x0c3e,  96, "Write Page Scan Mode",
6914                                 write_page_scan_mode_cmd, 1, true,
6915                                 status_rsp, 1, true },
6916         { 0x0c3f,  97, "Set AFH Host Channel Classification",
6917                                 set_afh_host_classification_cmd, 10, true,
6918                                 status_rsp, 1, true },
6919         { 0x0c42, 100, "Read Inquiry Scan Type",
6920                                 null_cmd, 0, true,
6921                                 read_inquiry_scan_type_rsp, 2, true },
6922         { 0x0c43, 101, "Write Inquiry Scan Type",
6923                                 write_inquiry_scan_type_cmd, 1, true,
6924                                 status_rsp, 1, true },
6925         { 0x0c44, 102, "Read Inquiry Mode",
6926                                 null_cmd, 0, true,
6927                                 read_inquiry_mode_rsp, 2, true },
6928         { 0x0c45, 103, "Write Inquiry Mode",
6929                                 write_inquiry_mode_cmd, 1, true,
6930                                 status_rsp, 1, true },
6931         { 0x0c46, 104, "Read Page Scan Type",
6932                                 null_cmd, 0, true,
6933                                 read_page_scan_type_rsp, 2, true },
6934         { 0x0c47, 105, "Write Page Scan Type",
6935                                 write_page_scan_type_cmd, 1, true,
6936                                 status_rsp, 1, true },
6937         { 0x0c48, 106, "Read AFH Channel Assessment Mode",
6938                                 null_cmd, 0, true,
6939                                 read_afh_assessment_mode_rsp, 2, true },
6940         { 0x0c49, 107, "Write AFH Channel Assessment Mode",
6941                                 write_afh_assessment_mode_cmd, 1, true,
6942                                 status_rsp, 1, true },
6943         { 0x0c51, 136, "Read Extended Inquiry Response",
6944                                 null_cmd, 0, true,
6945                                 read_ext_inquiry_response_rsp, 242, true },
6946         { 0x0c52, 137, "Write Extended Inquiry Response",
6947                                 write_ext_inquiry_response_cmd, 241, true,
6948                                 status_rsp, 1, true },
6949         { 0x0c53, 138, "Refresh Encryption Key",
6950                                 refresh_encrypt_key_cmd, 2, true },
6951         { 0x0c55, 141, "Read Simple Pairing Mode",
6952                                 null_cmd, 0, true,
6953                                 read_simple_pairing_mode_rsp, 2, true },
6954         { 0x0c56, 142, "Write Simple Pairing Mode",
6955                                 write_simple_pairing_mode_cmd, 1, true,
6956                                 status_rsp, 1, true },
6957         { 0x0c57, 143, "Read Local OOB Data",
6958                                 null_cmd, 0, true,
6959                                 read_local_oob_data_rsp, 33, true },
6960         { 0x0c58, 144, "Read Inquiry Response TX Power Level",
6961                                 null_cmd, 0, true,
6962                                 read_inquiry_resp_tx_power_rsp, 2, true },
6963         { 0x0c59, 145, "Write Inquiry Transmit Power Level",
6964                                 write_inquiry_tx_power_cmd, 1, true,
6965                                 status_rsp, 1, true },
6966         { 0x0c5a, 146, "Read Default Erroneous Data Reporting",
6967                                 null_cmd, 0, true,
6968                                 read_erroneous_reporting_rsp, 2, true },
6969         { 0x0c5b, 147, "Write Default Erroneous Data Reporting",
6970                                 write_erroneous_reporting_cmd, 1, true,
6971                                 status_rsp, 1, true },
6972         { 0x0c5f, 158, "Enhanced Flush",
6973                                 enhanced_flush_cmd, 3, true },
6974         { 0x0c60, 162, "Send Keypress Notification",
6975                                 send_keypress_notify_cmd, 7, true,
6976                                 send_keypress_notify_rsp, 7, true },
6977         { 0x0c61, 176, "Read Logical Link Accept Timeout" },
6978         { 0x0c62, 177, "Write Logical Link Accept Timeout" },
6979         { 0x0c63, 178, "Set Event Mask Page 2",
6980                                 set_event_mask_page2_cmd, 8, true,
6981                                 status_rsp, 1, true },
6982         { 0x0c64, 179, "Read Location Data",
6983                                 null_cmd, 0, true,
6984                                 read_location_data_rsp, 6, true },
6985         { 0x0c65, 180, "Write Location Data",
6986                                 write_location_data_cmd, 5, true,
6987                                 status_rsp, 1, true },
6988         { 0x0c66, 184, "Read Flow Control Mode",
6989                                 null_cmd, 0, true,
6990                                 read_flow_control_mode_rsp, 2, true },
6991         { 0x0c67, 185, "Write Flow Control Mode",
6992                                 write_flow_control_mode_cmd, 1, true,
6993                                 status_rsp, 1, true },
6994         { 0x0c68, 192, "Read Enhanced Transmit Power Level",
6995                                 read_enhanced_tx_power_cmd, 3, true,
6996                                 read_enhanced_tx_power_rsp, 6, true },
6997         { 0x0c69, 194, "Read Best Effort Flush Timeout" },
6998         { 0x0c6a, 195, "Write Best Effort Flush Timeout" },
6999         { 0x0c6b, 196, "Short Range Mode",
7000                                 short_range_mode_cmd, 2, true },
7001         { 0x0c6c, 197, "Read LE Host Supported",
7002                                 null_cmd, 0, true,
7003                                 read_le_host_supported_rsp, 3, true },
7004         { 0x0c6d, 198, "Write LE Host Supported",
7005                                 write_le_host_supported_cmd, 2, true,
7006                                 status_rsp, 1, true },
7007         { 0x0c6e, 238, "Set MWS Channel Parameters" },
7008         { 0x0c6f, 239, "Set External Frame Configuration" },
7009         { 0x0c70, 240, "Set MWS Signaling" },
7010         { 0x0c71, 241, "Set MWS Transport Layer" },
7011         { 0x0c72, 242, "Set MWS Scan Frequency Table" },
7012         { 0x0c73, 244, "Set MWS Pattern Configuration" },
7013         { 0x0c74, 252, "Set Reserved LT_ADDR",
7014                                 set_reserved_lt_addr_cmd, 1, true,
7015                                 set_reserved_lt_addr_rsp, 2, true },
7016         { 0x0c75, 253, "Delete Reserved LT_ADDR",
7017                                 delete_reserved_lt_addr_cmd, 1, true,
7018                                 delete_reserved_lt_addr_rsp, 2, true },
7019         { 0x0c76, 254, "Set Connectionless Slave Broadcast Data",
7020                                 set_slave_broadcast_data_cmd, 3, false,
7021                                 set_slave_broadcast_data_rsp, 2, true },
7022         { 0x0c77, 255, "Read Synchronization Train Parameters",
7023                                 null_cmd, 0, true,
7024                                 read_sync_train_params_rsp, 8, true },
7025         { 0x0c78, 256, "Write Synchronization Train Parameters",
7026                                 write_sync_train_params_cmd, 9, true,
7027                                 write_sync_train_params_rsp, 3, true },
7028         { 0x0c79, 258, "Read Secure Connections Host Support",
7029                                 null_cmd, 0, true,
7030                                 read_secure_conn_support_rsp, 2, true },
7031         { 0x0c7a, 259, "Write Secure Connections Host Support",
7032                                 write_secure_conn_support_cmd, 1, true,
7033                                 status_rsp, 1, true },
7034         { 0x0c7b, 260, "Read Authenticated Payload Timeout",
7035                                 read_auth_payload_timeout_cmd, 2, true,
7036                                 read_auth_payload_timeout_rsp, 5, true },
7037         { 0x0c7c, 261, "Write Authenticated Payload Timeout",
7038                                 write_auth_payload_timeout_cmd, 4, true,
7039                                 write_auth_payload_timeout_rsp, 3, true },
7040         { 0x0c7d, 262, "Read Local OOB Extended Data",
7041                                 null_cmd, 0, true,
7042                                 read_local_oob_ext_data_rsp, 65, true },
7043         { 0x0c7e, 264, "Read Extended Page Timeout",
7044                                 null_cmd, 0, true,
7045                                 read_ext_page_timeout_rsp, 3, true },
7046         { 0x0c7f, 265, "Write Extended Page Timeout",
7047                                 write_ext_page_timeout_cmd, 2, true,
7048                                 status_rsp, 1, true },
7049         { 0x0c80, 266, "Read Extended Inquiry Length",
7050                                 null_cmd, 0, true,
7051                                 read_ext_inquiry_length_rsp, 3, true },
7052         { 0x0c81, 267, "Write Extended Inquiry Length",
7053                                 write_ext_inquiry_length_cmd, 2, true,
7054                                 status_rsp, 1, true },
7055
7056         /* OGF 4 - Information Parameter */
7057         { 0x1001, 115, "Read Local Version Information",
7058                                 null_cmd, 0, true,
7059                                 read_local_version_rsp, 9, true },
7060         { 0x1002, 116, "Read Local Supported Commands",
7061                                 null_cmd, 0, true,
7062                                 read_local_commands_rsp, 65, true },
7063         { 0x1003, 117, "Read Local Supported Features",
7064                                 null_cmd, 0, true,
7065                                 read_local_features_rsp, 9, true },
7066         { 0x1004, 118, "Read Local Extended Features",
7067                                 read_local_ext_features_cmd, 1, true,
7068                                 read_local_ext_features_rsp, 11, true },
7069         { 0x1005, 119, "Read Buffer Size",
7070                                 null_cmd, 0, true,
7071                                 read_buffer_size_rsp, 8, true },
7072         { 0x1007, 120, "Read Country Code",
7073                                 null_cmd, 0, true,
7074                                 read_country_code_rsp, 2, true },
7075         { 0x1009, 121, "Read BD ADDR",
7076                                 null_cmd, 0, true,
7077                                 read_bd_addr_rsp, 7, true },
7078         { 0x100a, 186, "Read Data Block Size",
7079                                 null_cmd, 0, true,
7080                                 read_data_block_size_rsp, 7, true },
7081         { 0x100b, 237, "Read Local Supported Codecs",
7082                                 null_cmd, 0, true,
7083                                 read_local_codecs_rsp, 3, false },
7084
7085         /* OGF 5 - Status Parameter */
7086         { 0x1401, 122, "Read Failed Contact Counter",
7087                                 read_failed_contact_counter_cmd, 2, true,
7088                                 read_failed_contact_counter_rsp, 5, true },
7089         { 0x1402, 123, "Reset Failed Contact Counter",
7090                                 reset_failed_contact_counter_cmd, 2, true,
7091                                 reset_failed_contact_counter_rsp, 3, true },
7092         { 0x1403, 124, "Read Link Quality",
7093                                 read_link_quality_cmd, 2, true,
7094                                 read_link_quality_rsp, 4, true },
7095         { 0x1405, 125, "Read RSSI",
7096                                 read_rssi_cmd, 2, true,
7097                                 read_rssi_rsp, 4, true },
7098         { 0x1406, 126, "Read AFH Channel Map",
7099                                 read_afh_channel_map_cmd, 2, true,
7100                                 read_afh_channel_map_rsp, 14, true },
7101         { 0x1407, 127, "Read Clock",
7102                                 read_clock_cmd, 3, true,
7103                                 read_clock_rsp, 9, true },
7104         { 0x1408, 164, "Read Encryption Key Size",
7105                                 read_encrypt_key_size_cmd, 2, true,
7106                                 read_encrypt_key_size_rsp, 4, true },
7107         { 0x1409, 181, "Read Local AMP Info",
7108                                 null_cmd, 0, true,
7109                                 read_local_amp_info_rsp, 31, true },
7110         { 0x140a, 182, "Read Local AMP ASSOC",
7111                                 read_local_amp_assoc_cmd, 5, true,
7112                                 read_local_amp_assoc_rsp, 5, false },
7113         { 0x140b, 183, "Write Remote AMP ASSOC",
7114                                 write_remote_amp_assoc_cmd, 6, false,
7115                                 write_remote_amp_assoc_rsp, 2, true },
7116         { 0x140c, 243, "Get MWS Transport Layer Configuration",
7117                                 null_cmd, 0, true,
7118                                 get_mws_transport_config_rsp, 2, false },
7119         { 0x140d, 245, "Set Triggered Clock Capture",
7120                                 set_triggered_clock_capture_cmd, 6, true,
7121                                 status_rsp, 1, true },
7122
7123         /* OGF 6 - Testing */
7124         { 0x1801, 128, "Read Loopback Mode",
7125                                 null_cmd, 0, true,
7126                                 read_loopback_mode_rsp, 2, true },
7127         { 0x1802, 129, "Write Loopback Mode",
7128                                 write_loopback_mode_cmd, 1, true,
7129                                 status_rsp, 1, true },
7130         { 0x1803, 130, "Enable Device Under Test Mode",
7131                                 null_cmd, 0, true,
7132                                 status_rsp, 1, true },
7133         { 0x1804, 157, "Write Simple Pairing Debug Mode",
7134                                 write_ssp_debug_mode_cmd, 1, true,
7135                                 status_rsp, 1, true },
7136         { 0x1807, 189, "Enable AMP Receiver Reports" },
7137         { 0x1808, 190, "AMP Test End" },
7138         { 0x1809, 191, "AMP Test" },
7139         { 0x180a, 263, "Write Secure Connections Test Mode" },
7140
7141         /* OGF 8 - LE Control */
7142         { 0x2001, 200, "LE Set Event Mask",
7143                                 le_set_event_mask_cmd, 8, true,
7144                                 status_rsp, 1, true },
7145         { 0x2002, 201, "LE Read Buffer Size",
7146                                 null_cmd, 0, true,
7147                                 le_read_buffer_size_rsp, 4, true },
7148         { 0x2003, 202, "LE Read Local Supported Features",
7149                                 null_cmd, 0, true,
7150                                 le_read_local_features_rsp, 9, true },
7151         { 0x2005, 204, "LE Set Random Address",
7152                                 le_set_random_address_cmd, 6, true,
7153                                 status_rsp, 1, true },
7154         { 0x2006, 205, "LE Set Advertising Parameters",
7155                                 le_set_adv_parameters_cmd, 15, true,
7156                                 status_rsp, 1, true },
7157         { 0x2007, 206, "LE Read Advertising Channel TX Power",
7158                                 null_cmd, 0, true,
7159                                 le_read_adv_tx_power_rsp, 2, true },
7160         { 0x2008, 207, "LE Set Advertising Data",
7161                                 le_set_adv_data_cmd, 32, true,
7162                                 status_rsp, 1, true },
7163         { 0x2009, 208, "LE Set Scan Response Data",
7164                                 le_set_scan_rsp_data_cmd, 32, true,
7165                                 status_rsp, 1, true },
7166         { 0x200a, 209, "LE Set Advertise Enable",
7167                                 le_set_adv_enable_cmd, 1, true,
7168                                 status_rsp, 1, true },
7169         { 0x200b, 210, "LE Set Scan Parameters",
7170                                 le_set_scan_parameters_cmd, 7, true,
7171                                 status_rsp, 1, true },
7172         { 0x200c, 211, "LE Set Scan Enable",
7173                                 le_set_scan_enable_cmd, 2, true,
7174                                 status_rsp, 1, true },
7175         { 0x200d, 212, "LE Create Connection",
7176                                 le_create_conn_cmd, 25, true },
7177         { 0x200e, 213, "LE Create Connection Cancel",
7178                                 null_cmd, 0, true,
7179                                 status_rsp, 1, true },
7180         { 0x200f, 214, "LE Read White List Size",
7181                                 null_cmd, 0, true,
7182                                 le_read_white_list_size_rsp, 2, true },
7183         { 0x2010, 215, "LE Clear White List",
7184                                 null_cmd, 0, true,
7185                                 status_rsp, 1, true },
7186         { 0x2011, 216, "LE Add Device To White List",
7187                                 le_add_to_white_list_cmd, 7, true,
7188                                 status_rsp, 1, true },
7189         { 0x2012, 217, "LE Remove Device From White List",
7190                                 le_remove_from_white_list_cmd, 7, true,
7191                                 status_rsp, 1, true },
7192         { 0x2013, 218, "LE Connection Update",
7193                                 le_conn_update_cmd, 14, true },
7194         { 0x2014, 219, "LE Set Host Channel Classification",
7195                                 le_set_host_classification_cmd, 5, true,
7196                                 status_rsp, 1, true },
7197         { 0x2015, 220, "LE Read Channel Map",
7198                                 le_read_channel_map_cmd, 2, true,
7199                                 le_read_channel_map_rsp, 8, true },
7200         { 0x2016, 221, "LE Read Remote Used Features",
7201                                 le_read_remote_features_cmd, 2, true },
7202         { 0x2017, 222, "LE Encrypt",
7203                                 le_encrypt_cmd, 32, true,
7204                                 le_encrypt_rsp, 17, true },
7205         { 0x2018, 223, "LE Rand",
7206                                 null_cmd, 0, true,
7207                                 le_rand_rsp, 9, true },
7208         { 0x2019, 224, "LE Start Encryption",
7209                                 le_start_encrypt_cmd, 28, true },
7210         { 0x201a, 225, "LE Long Term Key Request Reply",
7211                                 le_ltk_req_reply_cmd, 18, true,
7212                                 le_ltk_req_reply_rsp, 3, true },
7213         { 0x201b, 226, "LE Long Term Key Request Neg Reply",
7214                                 le_ltk_req_neg_reply_cmd, 2, true,
7215                                 le_ltk_req_neg_reply_rsp, 3, true },
7216         { 0x201c, 227, "LE Read Supported States",
7217                                 null_cmd, 0, true,
7218                                 le_read_supported_states_rsp, 9, true },
7219         { 0x201d, 228, "LE Receiver Test",
7220                                 le_receiver_test_cmd, 1, true,
7221                                 status_rsp, 1, true },
7222         { 0x201e, 229, "LE Transmitter Test",
7223                                 le_transmitter_test_cmd, 3, true,
7224                                 status_rsp, 1, true },
7225         { 0x201f, 230, "LE Test End",
7226                                 null_cmd, 0, true,
7227                                 le_test_end_rsp, 3, true },
7228         { 0x2020, 268, "LE Remote Connection Parameter Request Reply",
7229                                 le_conn_param_req_reply_cmd, 14, true,
7230                                 le_conn_param_req_reply_rsp, 3, true },
7231         { 0x2021, 269, "LE Remote Connection Parameter Request Negative Reply",
7232                                 le_conn_param_req_neg_reply_cmd, 3, true,
7233                                 le_conn_param_req_neg_reply_rsp, 3, true },
7234         { 0x2022, 270, "LE Set Data Length",
7235                                 le_set_data_length_cmd, 6, true,
7236                                 le_set_data_length_rsp, 3, true },
7237         { 0x2023, 271, "LE Read Suggested Default Data Length",
7238                                 null_cmd, 0, true,
7239                                 le_read_default_data_length_rsp, 5, true },
7240         { 0x2024, 272, "LE Write Suggested Default Data Length",
7241                                 le_write_default_data_length_cmd, 4, true,
7242                                 status_rsp, 1, true },
7243         { 0x2025, 273, "LE Read Local P-256 Public Key",
7244                                 null_cmd, 0, true },
7245         { 0x2026, 274, "LE Generate DHKey",
7246                                 le_generate_dhkey_cmd, 64, true },
7247         { 0x2027, 275, "LE Add Device To Resolving List",
7248                                 le_add_to_resolv_list_cmd, 39, true,
7249                                 status_rsp, 1, true },
7250         { 0x2028, 276, "LE Remove Device From Resolving List",
7251                                 le_remove_from_resolv_list_cmd, 7, true,
7252                                 status_rsp, 1, true },
7253         { 0x2029, 277, "LE Clear Resolving List",
7254                                 null_cmd, 0, true,
7255                                 status_rsp, 1, true },
7256         { 0x202a, 278, "LE Read Resolving List Size",
7257                                 null_cmd, 0, true,
7258                                 le_read_resolv_list_size_rsp, 2, true },
7259         { 0x202b, 279, "LE Read Peer Resolvable Address",
7260                                 le_read_peer_resolv_addr_cmd, 7, true,
7261                                 le_read_peer_resolv_addr_rsp, 7, true },
7262         { 0x202c, 280, "LE Read Local Resolvable Address",
7263                                 le_read_local_resolv_addr_cmd, 7, true,
7264                                 le_read_local_resolv_addr_rsp, 7, true },
7265         { 0x202d, 281, "LE Set Address Resolution Enable",
7266                                 le_set_resolv_enable_cmd, 1, true,
7267                                 status_rsp, 1, true },
7268         { 0x202e, 282, "LE Set Resolvable Private Address Timeout",
7269                                 le_set_resolv_timeout_cmd, 2, true,
7270                                 status_rsp, 1, true },
7271         { 0x202f, 283, "LE Read Maximum Data Length",
7272                                 null_cmd, 0, true,
7273                                 le_read_max_data_length_rsp, 9, true },
7274         { }
7275 };
7276
7277 static const char *get_supported_command(int bit)
7278 {
7279         int i;
7280
7281         for (i = 0; opcode_table[i].str; i++) {
7282                 if (opcode_table[i].bit == bit)
7283                         return opcode_table[i].str;
7284         }
7285
7286         return NULL;
7287 }
7288
7289 static const char *current_vendor_str(void)
7290 {
7291         uint16_t manufacturer;
7292
7293         if (index_current < MAX_INDEX)
7294                 manufacturer = index_list[index_current].manufacturer;
7295         else
7296                 manufacturer = UNKNOWN_MANUFACTURER;
7297
7298         switch (manufacturer) {
7299         case 2:
7300                 return "Intel";
7301         case 15:
7302                 return "Broadcom";
7303         }
7304
7305         return NULL;
7306 }
7307
7308 static const struct vendor_ocf *current_vendor_ocf(uint16_t ocf)
7309 {
7310         uint16_t manufacturer;
7311
7312         if (index_current < MAX_INDEX)
7313                 manufacturer = index_list[index_current].manufacturer;
7314         else
7315                 manufacturer = UNKNOWN_MANUFACTURER;
7316
7317         switch (manufacturer) {
7318         case 2:
7319                 return intel_vendor_ocf(ocf);
7320         case 15:
7321                 return broadcom_vendor_ocf(ocf);
7322         }
7323
7324         return NULL;
7325 }
7326
7327 static const struct vendor_evt *current_vendor_evt(uint8_t evt)
7328 {
7329         uint16_t manufacturer;
7330
7331         if (index_current < MAX_INDEX)
7332                 manufacturer = index_list[index_current].manufacturer;
7333         else
7334                 manufacturer = UNKNOWN_MANUFACTURER;
7335
7336         switch (manufacturer) {
7337         case 2:
7338                 return intel_vendor_evt(evt);
7339         case 15:
7340                 return broadcom_vendor_evt(evt);
7341         }
7342
7343         return NULL;
7344 }
7345
7346 static void inquiry_complete_evt(const void *data, uint8_t size)
7347 {
7348         const struct bt_hci_evt_inquiry_complete *evt = data;
7349
7350         print_status(evt->status);
7351 }
7352
7353 static void inquiry_result_evt(const void *data, uint8_t size)
7354 {
7355         const struct bt_hci_evt_inquiry_result *evt = data;
7356
7357         print_num_resp(evt->num_resp);
7358         print_bdaddr(evt->bdaddr);
7359         print_pscan_rep_mode(evt->pscan_rep_mode);
7360         print_pscan_period_mode(evt->pscan_period_mode);
7361         print_pscan_mode(evt->pscan_mode);
7362         print_dev_class(evt->dev_class);
7363         print_clock_offset(evt->clock_offset);
7364
7365         if (size > sizeof(*evt))
7366                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
7367 }
7368
7369 static void conn_complete_evt(const void *data, uint8_t size)
7370 {
7371         const struct bt_hci_evt_conn_complete *evt = data;
7372
7373         print_status(evt->status);
7374         print_handle(evt->handle);
7375         print_bdaddr(evt->bdaddr);
7376         print_link_type(evt->link_type);
7377         print_encr_mode(evt->encr_mode);
7378
7379         if (evt->status == 0x00)
7380                 assign_handle(le16_to_cpu(evt->handle), 0x00);
7381 }
7382
7383 static void conn_request_evt(const void *data, uint8_t size)
7384 {
7385         const struct bt_hci_evt_conn_request *evt = data;
7386
7387         print_bdaddr(evt->bdaddr);
7388         print_dev_class(evt->dev_class);
7389         print_link_type(evt->link_type);
7390 }
7391
7392 static void disconnect_complete_evt(const void *data, uint8_t size)
7393 {
7394         const struct bt_hci_evt_disconnect_complete *evt = data;
7395
7396         print_status(evt->status);
7397         print_handle(evt->handle);
7398         print_reason(evt->reason);
7399
7400         if (evt->status == 0x00)
7401                 release_handle(le16_to_cpu(evt->handle));
7402 }
7403
7404 static void auth_complete_evt(const void *data, uint8_t size)
7405 {
7406         const struct bt_hci_evt_auth_complete *evt = data;
7407
7408         print_status(evt->status);
7409         print_handle(evt->handle);
7410 }
7411
7412 static void remote_name_request_complete_evt(const void *data, uint8_t size)
7413 {
7414         const struct bt_hci_evt_remote_name_request_complete *evt = data;
7415
7416         print_status(evt->status);
7417         print_bdaddr(evt->bdaddr);
7418         print_name(evt->name);
7419 }
7420
7421 static void encrypt_change_evt(const void *data, uint8_t size)
7422 {
7423         const struct bt_hci_evt_encrypt_change *evt = data;
7424
7425         print_status(evt->status);
7426         print_handle(evt->handle);
7427         print_encr_mode_change(evt->encr_mode, evt->handle);
7428 }
7429
7430 static void change_conn_link_key_complete_evt(const void *data, uint8_t size)
7431 {
7432         const struct bt_hci_evt_change_conn_link_key_complete *evt = data;
7433
7434         print_status(evt->status);
7435         print_handle(evt->handle);
7436 }
7437
7438 static void master_link_key_complete_evt(const void *data, uint8_t size)
7439 {
7440         const struct bt_hci_evt_master_link_key_complete *evt = data;
7441
7442         print_status(evt->status);
7443         print_handle(evt->handle);
7444         print_key_flag(evt->key_flag);
7445 }
7446
7447 static void remote_features_complete_evt(const void *data, uint8_t size)
7448 {
7449         const struct bt_hci_evt_remote_features_complete *evt = data;
7450
7451         print_status(evt->status);
7452         print_handle(evt->handle);
7453         print_features(0, evt->features, 0x00);
7454 }
7455
7456 static void remote_version_complete_evt(const void *data, uint8_t size)
7457 {
7458         const struct bt_hci_evt_remote_version_complete *evt = data;
7459
7460         print_status(evt->status);
7461         print_handle(evt->handle);
7462         print_lmp_version(evt->lmp_ver, evt->lmp_subver);
7463         print_manufacturer(evt->manufacturer);
7464
7465         switch (le16_to_cpu(evt->manufacturer)) {
7466         case 15:
7467                 print_manufacturer_broadcom(evt->lmp_subver, 0xffff);
7468                 break;
7469         }
7470 }
7471
7472 static void qos_setup_complete_evt(const void *data, uint8_t size)
7473 {
7474         const struct bt_hci_evt_qos_setup_complete *evt = data;
7475
7476         print_status(evt->status);
7477         print_handle(evt->handle);
7478         print_field("Flags: 0x%2.2x", evt->flags);
7479
7480         print_service_type(evt->service_type);
7481
7482         print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
7483         print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
7484         print_field("Latency: %d", le32_to_cpu(evt->latency));
7485         print_field("Delay variation: %d", le32_to_cpu(evt->delay_variation));
7486 }
7487
7488 static void cmd_complete_evt(const void *data, uint8_t size)
7489 {
7490         const struct bt_hci_evt_cmd_complete *evt = data;
7491         uint16_t opcode = le16_to_cpu(evt->opcode);
7492         uint16_t ogf = cmd_opcode_ogf(opcode);
7493         uint16_t ocf = cmd_opcode_ocf(opcode);
7494         struct opcode_data vendor_data;
7495         const struct opcode_data *opcode_data = NULL;
7496         const char *opcode_color, *opcode_str;
7497         char vendor_str[150];
7498         int i;
7499
7500         for (i = 0; opcode_table[i].str; i++) {
7501                 if (opcode_table[i].opcode == opcode) {
7502                         opcode_data = &opcode_table[i];
7503                         break;
7504                 }
7505         }
7506
7507         if (opcode_data) {
7508                 if (opcode_data->rsp_func)
7509                         opcode_color = COLOR_HCI_COMMAND;
7510                 else
7511                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
7512                 opcode_str = opcode_data->str;
7513         } else {
7514                 if (ogf == 0x3f) {
7515                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
7516
7517                         if (vnd) {
7518                                 const char *str = current_vendor_str();
7519
7520                                 if (str) {
7521                                         snprintf(vendor_str, sizeof(vendor_str),
7522                                                         "%s %s", str, vnd->str);
7523                                         vendor_data.str = vendor_str;
7524                                 } else
7525                                         vendor_data.str = vnd->str;
7526                                 vendor_data.rsp_func = vnd->rsp_func;
7527                                 vendor_data.rsp_size = vnd->rsp_size;
7528                                 vendor_data.rsp_fixed = vnd->rsp_fixed;
7529
7530                                 opcode_data = &vendor_data;
7531
7532                                 if (opcode_data->rsp_func)
7533                                         opcode_color = COLOR_HCI_COMMAND;
7534                                 else
7535                                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
7536                                 opcode_str = opcode_data->str;
7537                         } else {
7538                                 opcode_color = COLOR_HCI_COMMAND;
7539                                 opcode_str = "Vendor";
7540                         }
7541                 } else {
7542                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
7543                         opcode_str = "Unknown";
7544                 }
7545         }
7546
7547         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
7548                         " (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
7549
7550         if (!opcode_data || !opcode_data->rsp_func) {
7551                 if (size > 3) {
7552                         uint8_t status = *((uint8_t *) (data + 3));
7553
7554                         print_status(status);
7555                         packet_hexdump(data + 4, size - 4);
7556                 }
7557                 return;
7558         }
7559
7560         if (opcode_data->rsp_size > 1 && size - 3 == 1) {
7561                 uint8_t status = *((uint8_t *) (data + 3));
7562
7563                 print_status(status);
7564                 return;
7565         }
7566
7567         if (opcode_data->rsp_fixed) {
7568                 if (size - 3 != opcode_data->rsp_size) {
7569                         print_text(COLOR_ERROR, "invalid packet size");
7570                         packet_hexdump(data + 3, size - 3);
7571                         return;
7572                 }
7573         } else {
7574                 if (size - 3 < opcode_data->rsp_size) {
7575                         print_text(COLOR_ERROR, "too short packet");
7576                         packet_hexdump(data + 3, size - 3);
7577                         return;
7578                 }
7579         }
7580
7581         opcode_data->rsp_func(data + 3, size - 3);
7582 }
7583
7584 static void cmd_status_evt(const void *data, uint8_t size)
7585 {
7586         const struct bt_hci_evt_cmd_status *evt = data;
7587         uint16_t opcode = le16_to_cpu(evt->opcode);
7588         uint16_t ogf = cmd_opcode_ogf(opcode);
7589         uint16_t ocf = cmd_opcode_ocf(opcode);
7590         const struct opcode_data *opcode_data = NULL;
7591         const char *opcode_color, *opcode_str;
7592         char vendor_str[150];
7593         int i;
7594
7595         for (i = 0; opcode_table[i].str; i++) {
7596                 if (opcode_table[i].opcode == opcode) {
7597                         opcode_data = &opcode_table[i];
7598                         break;
7599                 }
7600         }
7601
7602         if (opcode_data) {
7603                 opcode_color = COLOR_HCI_COMMAND;
7604                 opcode_str = opcode_data->str;
7605         } else {
7606                 if (ogf == 0x3f) {
7607                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
7608
7609                         if (vnd) {
7610                                 const char *str = current_vendor_str();
7611
7612                                 if (str) {
7613                                         snprintf(vendor_str, sizeof(vendor_str),
7614                                                         "%s %s", str, vnd->str);
7615                                         opcode_str = vendor_str;
7616                                 } else
7617                                         opcode_str = vnd->str;
7618
7619                                 opcode_color = COLOR_HCI_COMMAND;
7620                         } else {
7621                                 opcode_color = COLOR_HCI_COMMAND;
7622                                 opcode_str = "Vendor";
7623                         }
7624                 } else {
7625                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
7626                         opcode_str = "Unknown";
7627                 }
7628         }
7629
7630         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
7631                         " (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
7632
7633         print_status(evt->status);
7634 }
7635
7636 static void hardware_error_evt(const void *data, uint8_t size)
7637 {
7638         const struct bt_hci_evt_hardware_error *evt = data;
7639
7640         print_field("Code: 0x%2.2x", evt->code);
7641 }
7642
7643 static void flush_occurred_evt(const void *data, uint8_t size)
7644 {
7645         const struct bt_hci_evt_flush_occurred *evt = data;
7646
7647         print_handle(evt->handle);
7648 }
7649
7650 static void role_change_evt(const void *data, uint8_t size)
7651 {
7652         const struct bt_hci_evt_role_change *evt = data;
7653
7654         print_status(evt->status);
7655         print_bdaddr(evt->bdaddr);
7656         print_role(evt->role);
7657 }
7658
7659 static void num_completed_packets_evt(const void *data, uint8_t size)
7660 {
7661         const struct bt_hci_evt_num_completed_packets *evt = data;
7662
7663         print_field("Num handles: %d", evt->num_handles);
7664         print_handle(evt->handle);
7665         print_field("Count: %d", le16_to_cpu(evt->count));
7666
7667         if (size > sizeof(*evt))
7668                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
7669 }
7670
7671 static void mode_change_evt(const void *data, uint8_t size)
7672 {
7673         const struct bt_hci_evt_mode_change *evt = data;
7674
7675         print_status(evt->status);
7676         print_handle(evt->handle);
7677         print_mode(evt->mode);
7678         print_interval(evt->interval);
7679 }
7680
7681 static void return_link_keys_evt(const void *data, uint8_t size)
7682 {
7683         const struct bt_hci_evt_return_link_keys *evt = data;
7684         uint8_t i;
7685
7686         print_field("Num keys: %d", evt->num_keys);
7687
7688         for (i = 0; i < evt->num_keys; i++) {
7689                 print_bdaddr(evt->keys + (i * 22));
7690                 print_link_key(evt->keys + (i * 22) + 6);
7691         }
7692 }
7693
7694 static void pin_code_request_evt(const void *data, uint8_t size)
7695 {
7696         const struct bt_hci_evt_pin_code_request *evt = data;
7697
7698         print_bdaddr(evt->bdaddr);
7699 }
7700
7701 static void link_key_request_evt(const void *data, uint8_t size)
7702 {
7703         const struct bt_hci_evt_link_key_request *evt = data;
7704
7705         print_bdaddr(evt->bdaddr);
7706 }
7707
7708 static void link_key_notify_evt(const void *data, uint8_t size)
7709 {
7710         const struct bt_hci_evt_link_key_notify *evt = data;
7711
7712         print_bdaddr(evt->bdaddr);
7713         print_link_key(evt->link_key);
7714         print_key_type(evt->key_type);
7715 }
7716
7717 static void loopback_command_evt(const void *data, uint8_t size)
7718 {
7719         packet_hexdump(data, size);
7720 }
7721
7722 static void data_buffer_overflow_evt(const void *data, uint8_t size)
7723 {
7724         const struct bt_hci_evt_data_buffer_overflow *evt = data;
7725
7726         print_link_type(evt->link_type);
7727 }
7728
7729 static void max_slots_change_evt(const void *data, uint8_t size)
7730 {
7731         const struct bt_hci_evt_max_slots_change *evt = data;
7732
7733         print_handle(evt->handle);
7734         print_field("Max slots: %d", evt->max_slots);
7735 }
7736
7737 static void clock_offset_complete_evt(const void *data, uint8_t size)
7738 {
7739         const struct bt_hci_evt_clock_offset_complete *evt = data;
7740
7741         print_status(evt->status);
7742         print_handle(evt->handle);
7743         print_clock_offset(evt->clock_offset);
7744 }
7745
7746 static void conn_pkt_type_changed_evt(const void *data, uint8_t size)
7747 {
7748         const struct bt_hci_evt_conn_pkt_type_changed *evt = data;
7749
7750         print_status(evt->status);
7751         print_handle(evt->handle);
7752         print_pkt_type(evt->pkt_type);
7753 }
7754
7755 static void qos_violation_evt(const void *data, uint8_t size)
7756 {
7757         const struct bt_hci_evt_qos_violation *evt = data;
7758
7759         print_handle(evt->handle);
7760 }
7761
7762 static void pscan_mode_change_evt(const void *data, uint8_t size)
7763 {
7764         const struct bt_hci_evt_pscan_mode_change *evt = data;
7765
7766         print_bdaddr(evt->bdaddr);
7767         print_pscan_mode(evt->pscan_mode);
7768 }
7769
7770 static void pscan_rep_mode_change_evt(const void *data, uint8_t size)
7771 {
7772         const struct bt_hci_evt_pscan_rep_mode_change *evt = data;
7773
7774         print_bdaddr(evt->bdaddr);
7775         print_pscan_rep_mode(evt->pscan_rep_mode);
7776 }
7777
7778 static void flow_spec_complete_evt(const void *data, uint8_t size)
7779 {
7780         const struct bt_hci_evt_flow_spec_complete *evt = data;
7781
7782         print_status(evt->status);
7783         print_handle(evt->handle);
7784         print_field("Flags: 0x%2.2x", evt->flags);
7785
7786         print_flow_direction(evt->direction);
7787         print_service_type(evt->service_type);
7788
7789         print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
7790         print_field("Token bucket size: %d",
7791                                         le32_to_cpu(evt->token_bucket_size));
7792         print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
7793         print_field("Access latency: %d", le32_to_cpu(evt->access_latency));
7794 }
7795
7796 static void inquiry_result_with_rssi_evt(const void *data, uint8_t size)
7797 {
7798         const struct bt_hci_evt_inquiry_result_with_rssi *evt = data;
7799
7800         print_num_resp(evt->num_resp);
7801         print_bdaddr(evt->bdaddr);
7802         print_pscan_rep_mode(evt->pscan_rep_mode);
7803         print_pscan_period_mode(evt->pscan_period_mode);
7804         print_dev_class(evt->dev_class);
7805         print_clock_offset(evt->clock_offset);
7806         print_rssi(evt->rssi);
7807
7808         if (size > sizeof(*evt))
7809                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
7810 }
7811
7812 static void remote_ext_features_complete_evt(const void *data, uint8_t size)
7813 {
7814         const struct bt_hci_evt_remote_ext_features_complete *evt = data;
7815
7816         print_status(evt->status);
7817         print_handle(evt->handle);
7818         print_field("Page: %d/%d", evt->page, evt->max_page);
7819         print_features(evt->page, evt->features, 0x00);
7820 }
7821
7822 static void sync_conn_complete_evt(const void *data, uint8_t size)
7823 {
7824         const struct bt_hci_evt_sync_conn_complete *evt = data;
7825
7826         print_status(evt->status);
7827         print_handle(evt->handle);
7828         print_bdaddr(evt->bdaddr);
7829         print_link_type(evt->link_type);
7830         print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
7831         print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
7832         print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
7833         print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
7834         print_air_mode(evt->air_mode);
7835 }
7836
7837 static void sync_conn_changed_evt(const void *data, uint8_t size)
7838 {
7839         const struct bt_hci_evt_sync_conn_changed *evt = data;
7840
7841         print_status(evt->status);
7842         print_handle(evt->handle);
7843         print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
7844         print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
7845         print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
7846         print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
7847 }
7848
7849 static void sniff_subrating_evt(const void *data, uint8_t size)
7850 {
7851         const struct bt_hci_evt_sniff_subrating *evt = data;
7852
7853         print_status(evt->status);
7854         print_handle(evt->handle);
7855         print_slot_625("Max transmit latency", evt->max_tx_latency);
7856         print_slot_625("Max receive latency", evt->max_rx_latency);
7857         print_slot_625("Min remote timeout", evt->min_remote_timeout);
7858         print_slot_625("Min local timeout", evt->min_local_timeout);
7859 }
7860
7861 static void ext_inquiry_result_evt(const void *data, uint8_t size)
7862 {
7863         const struct bt_hci_evt_ext_inquiry_result *evt = data;
7864
7865         print_num_resp(evt->num_resp);
7866         print_bdaddr(evt->bdaddr);
7867         print_pscan_rep_mode(evt->pscan_rep_mode);
7868         print_pscan_period_mode(evt->pscan_period_mode);
7869         print_dev_class(evt->dev_class);
7870         print_clock_offset(evt->clock_offset);
7871         print_rssi(evt->rssi);
7872         print_eir(evt->data, sizeof(evt->data), false);
7873 }
7874
7875 static void encrypt_key_refresh_complete_evt(const void *data, uint8_t size)
7876 {
7877         const struct bt_hci_evt_encrypt_key_refresh_complete *evt = data;
7878
7879         print_status(evt->status);
7880         print_handle(evt->handle);
7881 }
7882
7883 static void io_capability_request_evt(const void *data, uint8_t size)
7884 {
7885         const struct bt_hci_evt_io_capability_request *evt = data;
7886
7887         print_bdaddr(evt->bdaddr);
7888 }
7889
7890 static void io_capability_response_evt(const void *data, uint8_t size)
7891 {
7892         const struct bt_hci_evt_io_capability_response *evt = data;
7893
7894         print_bdaddr(evt->bdaddr);
7895         print_io_capability(evt->capability);
7896         print_oob_data_response(evt->oob_data);
7897         print_authentication(evt->authentication);
7898 }
7899
7900 static void user_confirm_request_evt(const void *data, uint8_t size)
7901 {
7902         const struct bt_hci_evt_user_confirm_request *evt = data;
7903
7904         print_bdaddr(evt->bdaddr);
7905         print_passkey(evt->passkey);
7906 }
7907
7908 static void user_passkey_request_evt(const void *data, uint8_t size)
7909 {
7910         const struct bt_hci_evt_user_passkey_request *evt = data;
7911
7912         print_bdaddr(evt->bdaddr);
7913 }
7914
7915 static void remote_oob_data_request_evt(const void *data, uint8_t size)
7916 {
7917         const struct bt_hci_evt_remote_oob_data_request *evt = data;
7918
7919         print_bdaddr(evt->bdaddr);
7920 }
7921
7922 static void simple_pairing_complete_evt(const void *data, uint8_t size)
7923 {
7924         const struct bt_hci_evt_simple_pairing_complete *evt = data;
7925
7926         print_status(evt->status);
7927         print_bdaddr(evt->bdaddr);
7928 }
7929
7930 static void link_supv_timeout_changed_evt(const void *data, uint8_t size)
7931 {
7932         const struct bt_hci_evt_link_supv_timeout_changed *evt = data;
7933
7934         print_handle(evt->handle);
7935         print_timeout(evt->timeout);
7936 }
7937
7938 static void enhanced_flush_complete_evt(const void *data, uint8_t size)
7939 {
7940         const struct bt_hci_evt_enhanced_flush_complete *evt = data;
7941
7942         print_handle(evt->handle);
7943 }
7944
7945 static void user_passkey_notify_evt(const void *data, uint8_t size)
7946 {
7947         const struct bt_hci_evt_user_passkey_notify *evt = data;
7948
7949         print_bdaddr(evt->bdaddr);
7950         print_passkey(evt->passkey);
7951 }
7952
7953 static void keypress_notify_evt(const void *data, uint8_t size)
7954 {
7955         const struct bt_hci_evt_keypress_notify *evt = data;
7956         const char *str;
7957
7958         print_bdaddr(evt->bdaddr);
7959
7960         switch (evt->type) {
7961         case 0x00:
7962                 str = "Passkey entry started";
7963                 break;
7964         case 0x01:
7965                 str = "Passkey digit entered";
7966                 break;
7967         case 0x02:
7968                 str = "Passkey digit erased";
7969                 break;
7970         case 0x03:
7971                 str = "Passkey clared";
7972                 break;
7973         case 0x04:
7974                 str = "Passkey entry completed";
7975                 break;
7976         default:
7977                 str = "Reserved";
7978                 break;
7979         }
7980
7981         print_field("Notification type: %s (0x%2.2x)", str, evt->type);
7982 }
7983
7984 static void remote_host_features_notify_evt(const void *data, uint8_t size)
7985 {
7986         const struct bt_hci_evt_remote_host_features_notify *evt = data;
7987
7988         print_bdaddr(evt->bdaddr);
7989         print_features(1, evt->features, 0x00);
7990 }
7991
7992 static void phy_link_complete_evt(const void *data, uint8_t size)
7993 {
7994         const struct bt_hci_evt_phy_link_complete *evt = data;
7995
7996         print_status(evt->status);
7997         print_phy_handle(evt->phy_handle);
7998 }
7999
8000 static void channel_selected_evt(const void *data, uint8_t size)
8001 {
8002         const struct bt_hci_evt_channel_selected *evt = data;
8003
8004         print_phy_handle(evt->phy_handle);
8005 }
8006
8007 static void disconn_phy_link_complete_evt(const void *data, uint8_t size)
8008 {
8009         const struct bt_hci_evt_disconn_phy_link_complete *evt = data;
8010
8011         print_status(evt->status);
8012         print_phy_handle(evt->phy_handle);
8013         print_reason(evt->reason);
8014 }
8015
8016 static void phy_link_loss_early_warning_evt(const void *data, uint8_t size)
8017 {
8018         const struct bt_hci_evt_phy_link_loss_early_warning *evt = data;
8019         const char *str;
8020
8021         print_phy_handle(evt->phy_handle);
8022
8023         switch (evt->reason) {
8024         case 0x00:
8025                 str = "Unknown";
8026                 break;
8027         case 0x01:
8028                 str = "Range related";
8029                 break;
8030         case 0x02:
8031                 str = "Bandwidth related";
8032                 break;
8033         case 0x03:
8034                 str = "Resolving conflict";
8035                 break;
8036         case 0x04:
8037                 str = "Interference";
8038                 break;
8039         default:
8040                 str = "Reserved";
8041                 break;
8042         }
8043
8044         print_field("Reason: %s (0x%2.2x)", str, evt->reason);
8045 }
8046
8047 static void phy_link_recovery_evt(const void *data, uint8_t size)
8048 {
8049         const struct bt_hci_evt_phy_link_recovery *evt = data;
8050
8051         print_phy_handle(evt->phy_handle);
8052 }
8053
8054 static void logic_link_complete_evt(const void *data, uint8_t size)
8055 {
8056         const struct bt_hci_evt_logic_link_complete *evt = data;
8057
8058         print_status(evt->status);
8059         print_handle(evt->handle);
8060         print_phy_handle(evt->phy_handle);
8061         print_field("TX flow spec: 0x%2.2x", evt->flow_spec);
8062 }
8063
8064 static void disconn_logic_link_complete_evt(const void *data, uint8_t size)
8065 {
8066         const struct bt_hci_evt_disconn_logic_link_complete *evt = data;
8067
8068         print_status(evt->status);
8069         print_handle(evt->handle);
8070         print_reason(evt->reason);
8071 }
8072
8073 static void flow_spec_modify_complete_evt(const void *data, uint8_t size)
8074 {
8075         const struct bt_hci_evt_flow_spec_modify_complete *evt = data;
8076
8077         print_status(evt->status);
8078         print_handle(evt->handle);
8079 }
8080
8081 static void num_completed_data_blocks_evt(const void *data, uint8_t size)
8082 {
8083         const struct bt_hci_evt_num_completed_data_blocks *evt = data;
8084
8085         print_field("Total num data blocks: %d",
8086                                 le16_to_cpu(evt->total_num_blocks));
8087         print_field("Num handles: %d", evt->num_handles);
8088         print_handle(evt->handle);
8089         print_field("Num packets: %d", evt->num_packets);
8090         print_field("Num blocks: %d", evt->num_blocks);
8091
8092         if (size > sizeof(*evt))
8093                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
8094 }
8095
8096 static void short_range_mode_change_evt(const void *data, uint8_t size)
8097 {
8098         const struct bt_hci_evt_short_range_mode_change *evt = data;
8099
8100         print_status(evt->status);
8101         print_phy_handle(evt->phy_handle);
8102         print_short_range_mode(evt->mode);
8103 }
8104
8105 static void amp_status_change_evt(const void *data, uint8_t size)
8106 {
8107         const struct bt_hci_evt_amp_status_change *evt = data;
8108
8109         print_status(evt->status);
8110         print_amp_status(evt->amp_status);
8111 }
8112
8113 static void triggered_clock_capture_evt(const void *data, uint8_t size)
8114 {
8115         const struct bt_hci_evt_triggered_clock_capture *evt = data;
8116
8117         print_handle(evt->handle);
8118         print_clock_type(evt->type);
8119         print_clock(evt->clock);
8120         print_clock_offset(evt->clock_offset);
8121 }
8122
8123 static void sync_train_complete_evt(const void *data, uint8_t size)
8124 {
8125         const struct bt_hci_evt_sync_train_complete *evt = data;
8126
8127         print_status(evt->status);
8128 }
8129
8130 static void sync_train_received_evt(const void *data, uint8_t size)
8131 {
8132         const struct bt_hci_evt_sync_train_received *evt = data;
8133
8134         print_status(evt->status);
8135         print_bdaddr(evt->bdaddr);
8136         print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
8137         print_channel_map(evt->map);
8138         print_lt_addr(evt->lt_addr);
8139         print_field("Next broadcast instant: 0x%4.4x",
8140                                         le16_to_cpu(evt->instant));
8141         print_interval(evt->interval);
8142         print_field("Service Data: 0x%2.2x", evt->service_data);
8143 }
8144
8145 static void slave_broadcast_receive_evt(const void *data, uint8_t size)
8146 {
8147         const struct bt_hci_evt_slave_broadcast_receive *evt = data;
8148
8149         print_bdaddr(evt->bdaddr);
8150         print_lt_addr(evt->lt_addr);
8151         print_field("Clock: 0x%8.8x", le32_to_cpu(evt->clock));
8152         print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
8153         print_field("Receive status: 0x%2.2x", evt->status);
8154         print_broadcast_fragment(evt->fragment);
8155         print_field("Length: %d", evt->length);
8156
8157         if (size - 18 != evt->length)
8158                 print_text(COLOR_ERROR, "invalid data size (%d != %d)",
8159                                                 size - 18, evt->length);
8160
8161         if (evt->lt_addr == 0x01 && evt->length == 17)
8162                 print_3d_broadcast(data + 18, size - 18);
8163         else
8164                 packet_hexdump(data + 18, size - 18);
8165 }
8166
8167 static void slave_broadcast_timeout_evt(const void *data, uint8_t size)
8168 {
8169         const struct bt_hci_evt_slave_broadcast_timeout *evt = data;
8170
8171         print_bdaddr(evt->bdaddr);
8172         print_lt_addr(evt->lt_addr);
8173 }
8174
8175 static void truncated_page_complete_evt(const void *data, uint8_t size)
8176 {
8177         const struct bt_hci_evt_truncated_page_complete *evt = data;
8178
8179         print_status(evt->status);
8180         print_bdaddr(evt->bdaddr);
8181 }
8182
8183 static void slave_page_response_timeout_evt(const void *data, uint8_t size)
8184 {
8185 }
8186
8187 static void slave_broadcast_channel_map_change_evt(const void *data, uint8_t size)
8188 {
8189         const struct bt_hci_evt_slave_broadcast_channel_map_change *evt = data;
8190
8191         print_channel_map(evt->map);
8192 }
8193
8194 static void inquiry_response_notify_evt(const void *data, uint8_t size)
8195 {
8196         const struct bt_hci_evt_inquiry_response_notify *evt = data;
8197
8198         print_iac(evt->lap);
8199         print_rssi(evt->rssi);
8200 }
8201
8202 static void auth_payload_timeout_expired_evt(const void *data, uint8_t size)
8203 {
8204         const struct bt_hci_evt_auth_payload_timeout_expired *evt = data;
8205
8206         print_handle(evt->handle);
8207 }
8208
8209 static void le_conn_complete_evt(const void *data, uint8_t size)
8210 {
8211         const struct bt_hci_evt_le_conn_complete *evt = data;
8212
8213         print_status(evt->status);
8214         print_handle(evt->handle);
8215         print_role(evt->role);
8216         print_peer_addr_type("Peer address type", evt->peer_addr_type);
8217         print_addr("Peer address", evt->peer_addr, evt->peer_addr_type);
8218         print_slot_125("Connection interval", evt->interval);
8219         print_slot_125("Connection latency", evt->latency);
8220         print_field("Supervision timeout: %d msec (0x%4.4x)",
8221                                         le16_to_cpu(evt->supv_timeout) * 10,
8222                                         le16_to_cpu(evt->supv_timeout));
8223         print_field("Master clock accuracy: 0x%2.2x", evt->clock_accuracy);
8224
8225         if (evt->status == 0x00)
8226                 assign_handle(le16_to_cpu(evt->handle), 0x01);
8227 }
8228
8229 static void le_adv_report_evt(const void *data, uint8_t size)
8230 {
8231         const struct bt_hci_evt_le_adv_report *evt = data;
8232         uint8_t evt_len;
8233         int8_t *rssi;
8234
8235         print_num_reports(evt->num_reports);
8236
8237 report:
8238         print_adv_event_type(evt->event_type);
8239         print_peer_addr_type("Address type", evt->addr_type);
8240         print_addr("Address", evt->addr, evt->addr_type);
8241         print_field("Data length: %d", evt->data_len);
8242         print_eir(evt->data, evt->data_len, true);
8243
8244         rssi = (int8_t *) (evt->data + evt->data_len);
8245         print_rssi(*rssi);
8246
8247         evt_len = sizeof(*evt) + evt->data_len + 1;
8248
8249         if (size > evt_len) {
8250                 data += evt_len - 1;
8251                 size -= evt_len - 1;
8252                 evt = data;
8253                 goto report;
8254         }
8255 }
8256
8257 static void le_conn_update_complete_evt(const void *data, uint8_t size)
8258 {
8259         const struct bt_hci_evt_le_conn_update_complete *evt = data;
8260
8261         print_status(evt->status);
8262         print_handle(evt->handle);
8263         print_slot_125("Connection interval", evt->interval);
8264         print_slot_125("Connection latency", evt->latency);
8265         print_field("Supervision timeout: %d msec (0x%4.4x)",
8266                                         le16_to_cpu(evt->supv_timeout) * 10,
8267                                         le16_to_cpu(evt->supv_timeout));
8268 }
8269
8270 static void le_remote_features_complete_evt(const void *data, uint8_t size)
8271 {
8272         const struct bt_hci_evt_le_remote_features_complete *evt = data;
8273
8274         print_status(evt->status);
8275         print_handle(evt->handle);
8276         print_features(0, evt->features, 0x01);
8277 }
8278
8279 static void le_long_term_key_request_evt(const void *data, uint8_t size)
8280 {
8281         const struct bt_hci_evt_le_long_term_key_request *evt = data;
8282
8283         print_handle(evt->handle);
8284         print_random_number(evt->rand);
8285         print_encrypted_diversifier(evt->ediv);
8286 }
8287
8288 static void le_conn_param_request_evt(const void *data, uint8_t size)
8289 {
8290         const struct bt_hci_evt_le_conn_param_request *evt = data;
8291
8292         print_handle(evt->handle);
8293         print_slot_125("Min connection interval", evt->min_interval);
8294         print_slot_125("Max connection interval", evt->max_interval);
8295         print_field("Connection latency: 0x%4.4x", le16_to_cpu(evt->latency));
8296         print_field("Supervision timeout: %d msec (0x%4.4x)",
8297                                         le16_to_cpu(evt->supv_timeout) * 10,
8298                                         le16_to_cpu(evt->supv_timeout));
8299 }
8300
8301 static void le_data_length_change_evt(const void *data, uint8_t size)
8302 {
8303         const struct bt_hci_evt_le_data_length_change *evt = data;
8304
8305         print_handle(evt->handle);
8306         print_field("Max TX octets: %d", le16_to_cpu(evt->max_tx_len));
8307         print_field("Max TX time: %d", le16_to_cpu(evt->max_tx_time));
8308         print_field("Max RX octets: %d", le16_to_cpu(evt->max_rx_len));
8309         print_field("Max RX time: %d", le16_to_cpu(evt->max_rx_time));
8310 }
8311
8312 static void le_read_local_pk256_complete_evt(const void *data, uint8_t size)
8313 {
8314         const struct bt_hci_evt_le_read_local_pk256_complete *evt = data;
8315
8316         print_status(evt->status);
8317         print_pk256("Local P-256 public key", evt->local_pk256);
8318 }
8319
8320 static void le_generate_dhkey_complete_evt(const void *data, uint8_t size)
8321 {
8322         const struct bt_hci_evt_le_generate_dhkey_complete *evt = data;
8323
8324         print_status(evt->status);
8325         print_dhkey(evt->dhkey);
8326 }
8327
8328 static void le_enhanced_conn_complete_evt(const void *data, uint8_t size)
8329 {
8330         const struct bt_hci_evt_le_enhanced_conn_complete *evt = data;
8331
8332         print_status(evt->status);
8333         print_handle(evt->handle);
8334         print_role(evt->role);
8335         print_peer_addr_type("Peer address type", evt->peer_addr_type);
8336         print_addr("Peer address", evt->peer_addr, evt->peer_addr_type);
8337         print_addr("Local resolvable private address", evt->local_rpa, 0x01);
8338         print_addr("Peer resolvable private address", evt->peer_rpa, 0x01);
8339         print_slot_125("Connection interval", evt->interval);
8340         print_slot_125("Connection latency", evt->latency);
8341         print_field("Supervision timeout: %d msec (0x%4.4x)",
8342                                         le16_to_cpu(evt->supv_timeout) * 10,
8343                                         le16_to_cpu(evt->supv_timeout));
8344         print_field("Master clock accuracy: 0x%2.2x", evt->clock_accuracy);
8345
8346         if (evt->status == 0x00)
8347                 assign_handle(le16_to_cpu(evt->handle), 0x01);
8348 }
8349
8350 static void le_direct_adv_report_evt(const void *data, uint8_t size)
8351 {
8352         const struct bt_hci_evt_le_direct_adv_report *evt = data;
8353
8354         print_num_reports(evt->num_reports);
8355
8356         print_adv_event_type(evt->event_type);
8357         print_peer_addr_type("Address type", evt->addr_type);
8358         print_addr("Address", evt->addr, evt->addr_type);
8359         print_addr_type("Direct address type", evt->direct_addr_type);
8360         print_addr("Direct address", evt->direct_addr, evt->direct_addr_type);
8361         print_rssi(evt->rssi);
8362
8363         if (size > sizeof(*evt))
8364                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
8365 }
8366
8367 struct subevent_data {
8368         uint8_t subevent;
8369         const char *str;
8370         void (*func) (const void *data, uint8_t size);
8371         uint8_t size;
8372         bool fixed;
8373 };
8374
8375 static void print_subevent(const struct subevent_data *subevent_data,
8376                                         const void *data, uint8_t size)
8377 {
8378         const char *subevent_color, *subevent_str;
8379
8380         if (subevent_data) {
8381                 if (subevent_data->func)
8382                         subevent_color = COLOR_HCI_EVENT;
8383                 else
8384                         subevent_color = COLOR_HCI_EVENT_UNKNOWN;
8385                 subevent_str = subevent_data->str;
8386         } else {
8387                 subevent_color = COLOR_HCI_EVENT_UNKNOWN;
8388                 subevent_str = "Unknown";
8389         }
8390
8391         print_indent(6, subevent_color, "", subevent_str, COLOR_OFF,
8392                                         " (0x%2.2x)", subevent_data->subevent);
8393
8394         if (!subevent_data || !subevent_data->func) {
8395                 packet_hexdump(data, size);
8396                 return;
8397         }
8398
8399         if (subevent_data->fixed) {
8400                 if (size != subevent_data->size) {
8401                         print_text(COLOR_ERROR, "invalid packet size");
8402                         packet_hexdump(data, size);
8403                         return;
8404                 }
8405         } else {
8406                 if (size < subevent_data->size) {
8407                         print_text(COLOR_ERROR, "too short packet");
8408                         packet_hexdump(data, size);
8409                         return;
8410                 }
8411         }
8412
8413         subevent_data->func(data, size);
8414 }
8415
8416 static const struct subevent_data le_meta_event_table[] = {
8417         { 0x01, "LE Connection Complete",
8418                                 le_conn_complete_evt, 18, true },
8419         { 0x02, "LE Advertising Report",
8420                                 le_adv_report_evt, 1, false },
8421         { 0x03, "LE Connection Update Complete",
8422                                 le_conn_update_complete_evt, 9, true },
8423         { 0x04, "LE Read Remote Used Features",
8424                                 le_remote_features_complete_evt, 11, true },
8425         { 0x05, "LE Long Term Key Request",
8426                                 le_long_term_key_request_evt, 12, true },
8427         { 0x06, "LE Remote Connection Parameter Request",
8428                                 le_conn_param_request_evt, 10, true },
8429         { 0x07, "LE Data Length Change",
8430                                 le_data_length_change_evt, 10, true },
8431         { 0x08, "LE Read Local P-256 Public Key Complete",
8432                                 le_read_local_pk256_complete_evt, 65, true },
8433         { 0x09, "LE Generate DHKey Complete",
8434                                 le_generate_dhkey_complete_evt, 33, true },
8435         { 0x0a, "LE Enhanced Connection Complete",
8436                                 le_enhanced_conn_complete_evt, 30, true },
8437         { 0x0b, "LE Direct Advertising Report",
8438                                 le_direct_adv_report_evt, 1, false },
8439         { }
8440 };
8441
8442 static void le_meta_event_evt(const void *data, uint8_t size)
8443 {
8444         uint8_t subevent = *((const uint8_t *) data);
8445         const struct subevent_data *subevent_data = NULL;
8446         int i;
8447
8448         for (i = 0; le_meta_event_table[i].str; i++) {
8449                 if (le_meta_event_table[i].subevent == subevent) {
8450                         subevent_data = &le_meta_event_table[i];
8451                         break;
8452                 }
8453         }
8454
8455         print_subevent(subevent_data, data + 1, size - 1);
8456 }
8457
8458 static void vendor_evt(const void *data, uint8_t size)
8459 {
8460         uint8_t subevent = *((const uint8_t *) data);
8461         struct subevent_data vendor_data;
8462         char vendor_str[150];
8463         const struct vendor_evt *vnd = current_vendor_evt(subevent);
8464
8465         if (vnd) {
8466                 const char *str = current_vendor_str();
8467
8468                 if (str) {
8469                         snprintf(vendor_str, sizeof(vendor_str),
8470                                                 "%s %s", str, vnd->str);
8471                         vendor_data.str = vendor_str;
8472                 } else
8473                         vendor_data.str = vnd->str;
8474                 vendor_data.subevent = subevent;
8475                 vendor_data.func = vnd->evt_func;
8476                 vendor_data.size = vnd->evt_size;
8477                 vendor_data.fixed = vnd->evt_fixed;
8478
8479                 print_subevent(&vendor_data, data + 1, size - 1);
8480         } else {
8481                 uint16_t manufacturer;
8482
8483                 if (index_current < MAX_INDEX)
8484                         manufacturer = index_list[index_current].manufacturer;
8485                 else
8486                         manufacturer = UNKNOWN_MANUFACTURER;
8487
8488                 vendor_event(manufacturer, data, size);
8489         }
8490 }
8491
8492 struct event_data {
8493         uint8_t event;
8494         const char *str;
8495         void (*func) (const void *data, uint8_t size);
8496         uint8_t size;
8497         bool fixed;
8498 };
8499
8500 static const struct event_data event_table[] = {
8501         { 0x01, "Inquiry Complete",
8502                                 inquiry_complete_evt, 1, true },
8503         { 0x02, "Inquiry Result",
8504                                 inquiry_result_evt, 1, false },
8505         { 0x03, "Connect Complete",
8506                                 conn_complete_evt, 11, true },
8507         { 0x04, "Connect Request",
8508                                 conn_request_evt, 10, true },
8509         { 0x05, "Disconnect Complete",
8510                                 disconnect_complete_evt, 4, true },
8511         { 0x06, "Auth Complete",
8512                                 auth_complete_evt, 3, true },
8513         { 0x07, "Remote Name Req Complete",
8514                                 remote_name_request_complete_evt, 255, true },
8515         { 0x08, "Encryption Change",
8516                                 encrypt_change_evt, 4, true },
8517         { 0x09, "Change Connection Link Key Complete",
8518                                 change_conn_link_key_complete_evt, 3, true },
8519         { 0x0a, "Master Link Key Complete",
8520                                 master_link_key_complete_evt, 4, true },
8521         { 0x0b, "Read Remote Supported Features",
8522                                 remote_features_complete_evt, 11, true },
8523         { 0x0c, "Read Remote Version Complete",
8524                                 remote_version_complete_evt, 8, true },
8525         { 0x0d, "QoS Setup Complete",
8526                                 qos_setup_complete_evt, 21, true },
8527         { 0x0e, "Command Complete",
8528                                 cmd_complete_evt, 3, false },
8529         { 0x0f, "Command Status",
8530                                 cmd_status_evt, 4, true },
8531         { 0x10, "Hardware Error",
8532                                 hardware_error_evt, 1, true },
8533         { 0x11, "Flush Occurred",
8534                                 flush_occurred_evt, 2, true },
8535         { 0x12, "Role Change",
8536                                 role_change_evt, 8, true },
8537         { 0x13, "Number of Completed Packets",
8538                                 num_completed_packets_evt, 1, false },
8539         { 0x14, "Mode Change",
8540                                 mode_change_evt, 6, true },
8541         { 0x15, "Return Link Keys",
8542                                 return_link_keys_evt, 1, false },
8543         { 0x16, "PIN Code Request",
8544                                 pin_code_request_evt, 6, true },
8545         { 0x17, "Link Key Request",
8546                                 link_key_request_evt, 6, true },
8547         { 0x18, "Link Key Notification",
8548                                 link_key_notify_evt, 23, true },
8549         { 0x19, "Loopback Command",
8550                                 loopback_command_evt, 3, false },
8551         { 0x1a, "Data Buffer Overflow",
8552                                 data_buffer_overflow_evt, 1, true },
8553         { 0x1b, "Max Slots Change",
8554                                 max_slots_change_evt, 3, true },
8555         { 0x1c, "Read Clock Offset Complete",
8556                                 clock_offset_complete_evt, 5, true },
8557         { 0x1d, "Connection Packet Type Changed",
8558                                 conn_pkt_type_changed_evt, 5, true },
8559         { 0x1e, "QoS Violation",
8560                                 qos_violation_evt, 2, true },
8561         { 0x1f, "Page Scan Mode Change",
8562                                 pscan_mode_change_evt, 7, true },
8563         { 0x20, "Page Scan Repetition Mode Change",
8564                                 pscan_rep_mode_change_evt, 7, true },
8565         { 0x21, "Flow Specification Complete",
8566                                 flow_spec_complete_evt, 22, true },
8567         { 0x22, "Inquiry Result with RSSI",
8568                                 inquiry_result_with_rssi_evt, 1, false },
8569         { 0x23, "Read Remote Extended Features",
8570                                 remote_ext_features_complete_evt, 13, true },
8571         { 0x2c, "Synchronous Connect Complete",
8572                                 sync_conn_complete_evt, 17, true },
8573         { 0x2d, "Synchronous Connect Changed",
8574                                 sync_conn_changed_evt, 9, true },
8575         { 0x2e, "Sniff Subrating",
8576                                 sniff_subrating_evt, 11, true },
8577         { 0x2f, "Extended Inquiry Result",
8578                                 ext_inquiry_result_evt, 1, false },
8579         { 0x30, "Encryption Key Refresh Complete",
8580                                 encrypt_key_refresh_complete_evt, 3, true },
8581         { 0x31, "IO Capability Request",
8582                                 io_capability_request_evt, 6, true },
8583         { 0x32, "IO Capability Response",
8584                                 io_capability_response_evt, 9, true },
8585         { 0x33, "User Confirmation Request",
8586                                 user_confirm_request_evt, 10, true },
8587         { 0x34, "User Passkey Request",
8588                                 user_passkey_request_evt, 6, true },
8589         { 0x35, "Remote OOB Data Request",
8590                                 remote_oob_data_request_evt, 6, true },
8591         { 0x36, "Simple Pairing Complete",
8592                                 simple_pairing_complete_evt, 7, true },
8593         { 0x38, "Link Supervision Timeout Changed",
8594                                 link_supv_timeout_changed_evt, 4, true },
8595         { 0x39, "Enhanced Flush Complete",
8596                                 enhanced_flush_complete_evt, 2, true },
8597         { 0x3b, "User Passkey Notification",
8598                                 user_passkey_notify_evt, 10, true },
8599         { 0x3c, "Keypress Notification",
8600                                 keypress_notify_evt, 7, true },
8601         { 0x3d, "Remote Host Supported Features",
8602                                 remote_host_features_notify_evt, 14, true },
8603         { 0x3e, "LE Meta Event",
8604                                 le_meta_event_evt, 1, false },
8605         { 0x40, "Physical Link Complete",
8606                                 phy_link_complete_evt, 2, true },
8607         { 0x41, "Channel Selected",
8608                                 channel_selected_evt, 1, true },
8609         { 0x42, "Disconnect Physical Link Complete",
8610                                 disconn_phy_link_complete_evt, 3, true },
8611         { 0x43, "Physical Link Loss Early Warning",
8612                                 phy_link_loss_early_warning_evt, 2, true },
8613         { 0x44, "Physical Link Recovery",
8614                                 phy_link_recovery_evt, 1, true },
8615         { 0x45, "Logical Link Complete",
8616                                 logic_link_complete_evt, 5, true },
8617         { 0x46, "Disconnect Logical Link Complete",
8618                                 disconn_logic_link_complete_evt, 4, true },
8619         { 0x47, "Flow Specification Modify Complete",
8620                                 flow_spec_modify_complete_evt, 3, true },
8621         { 0x48, "Number of Completed Data Blocks",
8622                                 num_completed_data_blocks_evt, 3, false },
8623         { 0x49, "AMP Start Test" },
8624         { 0x4a, "AMP Test End" },
8625         { 0x4b, "AMP Receiver Report" },
8626         { 0x4c, "Short Range Mode Change Complete",
8627                                 short_range_mode_change_evt, 3, true },
8628         { 0x4d, "AMP Status Change",
8629                                 amp_status_change_evt, 2, true },
8630         { 0x4e, "Triggered Clock Capture",
8631                                 triggered_clock_capture_evt, 9, true },
8632         { 0x4f, "Synchronization Train Complete",
8633                                 sync_train_complete_evt, 1, true },
8634         { 0x50, "Synchronization Train Received",
8635                                 sync_train_received_evt, 29, true },
8636         { 0x51, "Connectionless Slave Broadcast Receive",
8637                                 slave_broadcast_receive_evt, 18, false },
8638         { 0x52, "Connectionless Slave Broadcast Timeout",
8639                                 slave_broadcast_timeout_evt, 7, true },
8640         { 0x53, "Truncated Page Complete",
8641                                 truncated_page_complete_evt, 7, true },
8642         { 0x54, "Slave Page Response Timeout",
8643                                 slave_page_response_timeout_evt, 0, true },
8644         { 0x55, "Connectionless Slave Broadcast Channel Map Change",
8645                                 slave_broadcast_channel_map_change_evt, 10, true },
8646         { 0x56, "Inquiry Response Notification",
8647                                 inquiry_response_notify_evt, 4, true },
8648         { 0x57, "Authenticated Payload Timeout Expired",
8649                                 auth_payload_timeout_expired_evt, 2, true },
8650         { 0xfe, "Testing" },
8651         { 0xff, "Vendor", vendor_evt, 0, false },
8652         { }
8653 };
8654
8655 void packet_new_index(struct timeval *tv, uint16_t index, const char *label,
8656                                 uint8_t type, uint8_t bus, const char *name)
8657 {
8658         char details[48];
8659
8660         sprintf(details, "(%s,%s,%s)", hci_typetostr(type),
8661                                         hci_bustostr(bus), name);
8662
8663         print_packet(tv, NULL, index, '=', COLOR_NEW_INDEX, "New Index",
8664                                                         label, details);
8665 }
8666
8667 void packet_del_index(struct timeval *tv, uint16_t index, const char *label)
8668 {
8669         print_packet(tv, NULL, index, '=', COLOR_DEL_INDEX, "Delete Index",
8670                                                         label, NULL);
8671 }
8672
8673 void packet_open_index(struct timeval *tv, uint16_t index, const char *label)
8674 {
8675         print_packet(tv, NULL, index, '=', COLOR_OPEN_INDEX, "Open Index",
8676                                                         label, NULL);
8677 }
8678
8679 void packet_close_index(struct timeval *tv, uint16_t index, const char *label)
8680 {
8681         print_packet(tv, NULL, index, '=', COLOR_CLOSE_INDEX, "Close Index",
8682                                                         label, NULL);
8683 }
8684
8685 void packet_index_info(struct timeval *tv, uint16_t index, const char *label,
8686                                                         uint16_t manufacturer)
8687 {
8688         char details[128];
8689
8690         sprintf(details, "(%s)", bt_compidtostr(manufacturer));
8691
8692         print_packet(tv, NULL, index, '=', COLOR_INDEX_INFO, "Index Info",
8693                                                         label, details);
8694 }
8695
8696 void packet_vendor_diag(struct timeval *tv, uint16_t index,
8697                                         uint16_t manufacturer,
8698                                         const void *data, uint16_t size)
8699 {
8700         char extra_str[16];
8701
8702         sprintf(extra_str, "(len %d)", size);
8703
8704         print_packet(tv, NULL, index, '=', COLOR_VENDOR_DIAG,
8705                                         "Vendor Diagnostic", NULL, extra_str);
8706
8707         switch (manufacturer) {
8708         case 15:
8709                 broadcom_lm_diag(data, size);
8710                 break;
8711         default:
8712                 packet_hexdump(data, size);
8713                 break;
8714         }
8715 }
8716
8717 void packet_system_note(struct timeval *tv, struct ucred *cred,
8718                                         uint16_t index, const void *message)
8719 {
8720         print_packet(tv, cred, index, '=', COLOR_INFO, "Note", message, NULL);
8721 }
8722
8723 void packet_user_logging(struct timeval *tv, struct ucred *cred,
8724                                         uint16_t index, uint8_t priority,
8725                                         const char *ident, const char *message)
8726 {
8727         char pid_str[128];
8728         const char *label;
8729         const char *color;
8730
8731         if (priority > priority_level)
8732                 return;
8733
8734         switch (priority) {
8735         case BTSNOOP_PRIORITY_ERR:
8736                 color = COLOR_ERROR;
8737                 break;
8738         case BTSNOOP_PRIORITY_WARNING:
8739                 color = COLOR_WARN;
8740                 break;
8741         case BTSNOOP_PRIORITY_INFO:
8742                 color = COLOR_INFO;
8743                 break;
8744         case BTSNOOP_PRIORITY_DEBUG:
8745                 color = COLOR_DEBUG;
8746                 break;
8747         default:
8748                 color = COLOR_WHITE_BG;
8749                 break;
8750         }
8751
8752         if (cred) {
8753                 char *path = alloca(24);
8754                 char line[128];
8755                 FILE *fp;
8756
8757                 snprintf(path, 23, "/proc/%u/comm", cred->pid);
8758
8759                 fp = fopen(path, "re");
8760                 if (fp) {
8761                         if (fgets(line, sizeof(line), fp)) {
8762                                 line[strcspn(line, "\r\n")] = '\0';
8763                                 snprintf(pid_str, sizeof(pid_str), "%s[%u]",
8764                                                         line, cred->pid);
8765                         } else
8766                                 snprintf(pid_str, sizeof(pid_str), "%u",
8767                                                                 cred->pid);
8768                         fclose(fp);
8769                 } else
8770                         snprintf(pid_str, sizeof(pid_str), "%u", cred->pid);
8771
8772                 label = pid_str;
8773         } else {
8774                 if (ident)
8775                         label = ident;
8776                 else
8777                         label = "Message";
8778         }
8779
8780         print_packet(tv, cred, index, '=', color, label, message, NULL);
8781 }
8782
8783 void packet_hci_command(struct timeval *tv, struct ucred *cred, uint16_t index,
8784                                         const void *data, uint16_t size)
8785 {
8786         const hci_command_hdr *hdr = data;
8787         uint16_t opcode = le16_to_cpu(hdr->opcode);
8788         uint16_t ogf = cmd_opcode_ogf(opcode);
8789         uint16_t ocf = cmd_opcode_ocf(opcode);
8790         struct opcode_data vendor_data;
8791         const struct opcode_data *opcode_data = NULL;
8792         const char *opcode_color, *opcode_str;
8793         char extra_str[25], vendor_str[150];
8794         int i;
8795
8796         if (size < HCI_COMMAND_HDR_SIZE) {
8797                 sprintf(extra_str, "(len %d)", size);
8798                 print_packet(tv, cred, index, '*', COLOR_ERROR,
8799                         "Malformed HCI Command packet", NULL, extra_str);
8800                 packet_hexdump(data, size);
8801                 return;
8802         }
8803
8804         data += HCI_COMMAND_HDR_SIZE;
8805         size -= HCI_COMMAND_HDR_SIZE;
8806
8807         for (i = 0; opcode_table[i].str; i++) {
8808                 if (opcode_table[i].opcode == opcode) {
8809                         opcode_data = &opcode_table[i];
8810                         break;
8811                 }
8812         }
8813
8814         if (opcode_data) {
8815                 if (opcode_data->cmd_func)
8816                         opcode_color = COLOR_HCI_COMMAND;
8817                 else
8818                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
8819                 opcode_str = opcode_data->str;
8820         } else {
8821                 if (ogf == 0x3f) {
8822                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
8823
8824                         if (vnd) {
8825                                 const char *str = current_vendor_str();
8826
8827                                 if (str) {
8828                                         snprintf(vendor_str, sizeof(vendor_str),
8829                                                         "%s %s", str, vnd->str);
8830                                         vendor_data.str = vendor_str;
8831                                 } else
8832                                         vendor_data.str = vnd->str;
8833                                 vendor_data.cmd_func = vnd->cmd_func;
8834                                 vendor_data.cmd_size = vnd->cmd_size;
8835                                 vendor_data.cmd_fixed = vnd->cmd_fixed;
8836
8837                                 opcode_data = &vendor_data;
8838
8839                                 if (opcode_data->cmd_func)
8840                                         opcode_color = COLOR_HCI_COMMAND;
8841                                 else
8842                                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
8843                                 opcode_str = opcode_data->str;
8844                         } else {
8845                                 opcode_color = COLOR_HCI_COMMAND;
8846                                 opcode_str = "Vendor";
8847                         }
8848                 } else {
8849                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
8850                         opcode_str = "Unknown";
8851                 }
8852         }
8853
8854         sprintf(extra_str, "(0x%2.2x|0x%4.4x) plen %d", ogf, ocf, hdr->plen);
8855
8856         print_packet(tv, cred, index, '<', opcode_color, "HCI Command",
8857                                                         opcode_str, extra_str);
8858
8859         if (!opcode_data || !opcode_data->cmd_func) {
8860                 packet_hexdump(data, size);
8861                 return;
8862         }
8863
8864         if (size != hdr->plen) {
8865                 print_text(COLOR_ERROR, "invalid packet size (%u != %u)", size,
8866                                                                 hdr->plen);
8867                 packet_hexdump(data, size);
8868                 return;
8869         }
8870
8871         if (opcode_data->cmd_fixed) {
8872                 if (hdr->plen != opcode_data->cmd_size) {
8873                         print_text(COLOR_ERROR, "invalid packet size");
8874                         packet_hexdump(data, size);
8875                         return;
8876                 }
8877         } else {
8878                 if (hdr->plen < opcode_data->cmd_size) {
8879                         print_text(COLOR_ERROR, "too short packet");
8880                         packet_hexdump(data, size);
8881                         return;
8882                 }
8883         }
8884
8885         opcode_data->cmd_func(data, hdr->plen);
8886 }
8887
8888 void packet_hci_event(struct timeval *tv, struct ucred *cred, uint16_t index,
8889                                         const void *data, uint16_t size)
8890 {
8891         const hci_event_hdr *hdr = data;
8892         const struct event_data *event_data = NULL;
8893         const char *event_color, *event_str;
8894         char extra_str[25];
8895         int i;
8896
8897         if (size < HCI_EVENT_HDR_SIZE) {
8898                 sprintf(extra_str, "(len %d)", size);
8899                 print_packet(tv, cred, index, '*', COLOR_ERROR,
8900                         "Malformed HCI Event packet", NULL, extra_str);
8901                 packet_hexdump(data, size);
8902                 return;
8903         }
8904
8905         data += HCI_EVENT_HDR_SIZE;
8906         size -= HCI_EVENT_HDR_SIZE;
8907
8908         for (i = 0; event_table[i].str; i++) {
8909                 if (event_table[i].event == hdr->evt) {
8910                         event_data = &event_table[i];
8911                         break;
8912                 }
8913         }
8914
8915         if (event_data) {
8916                 if (event_data->func)
8917                         event_color = COLOR_HCI_EVENT;
8918                 else
8919                         event_color = COLOR_HCI_EVENT_UNKNOWN;
8920                 event_str = event_data->str;
8921         } else {
8922                 event_color = COLOR_HCI_EVENT_UNKNOWN;
8923                 event_str = "Unknown";
8924         }
8925
8926         sprintf(extra_str, "(0x%2.2x) plen %d", hdr->evt, hdr->plen);
8927
8928         print_packet(tv, cred, index, '>', event_color, "HCI Event",
8929                                                 event_str, extra_str);
8930
8931         if (!event_data || !event_data->func) {
8932                 packet_hexdump(data, size);
8933                 return;
8934         }
8935
8936         if (size != hdr->plen) {
8937                 print_text(COLOR_ERROR, "invalid packet size (%u != %u)", size,
8938                                                                 hdr->plen);
8939                 packet_hexdump(data, size);
8940                 return;
8941         }
8942
8943         if (event_data->fixed) {
8944                 if (hdr->plen != event_data->size) {
8945                         print_text(COLOR_ERROR, "invalid packet size");
8946                         packet_hexdump(data, size);
8947                         return;
8948                 }
8949         } else {
8950                 if (hdr->plen < event_data->size) {
8951                         print_text(COLOR_ERROR, "too short packet");
8952                         packet_hexdump(data, size);
8953                         return;
8954                 }
8955         }
8956
8957         event_data->func(data, hdr->plen);
8958 }
8959
8960 void packet_hci_acldata(struct timeval *tv, struct ucred *cred, uint16_t index,
8961                                 bool in, const void *data, uint16_t size)
8962 {
8963         const struct bt_hci_acl_hdr *hdr = data;
8964         uint16_t handle = le16_to_cpu(hdr->handle);
8965         uint16_t dlen = le16_to_cpu(hdr->dlen);
8966         uint8_t flags = acl_flags(handle);
8967         char handle_str[16], extra_str[32];
8968
8969         if (size < sizeof(*hdr)) {
8970                 if (in)
8971                         print_packet(tv, cred, index, '*', COLOR_ERROR,
8972                                 "Malformed ACL Data RX packet", NULL, NULL);
8973                 else
8974                         print_packet(tv, cred, index, '*', COLOR_ERROR,
8975                                 "Malformed ACL Data TX packet", NULL, NULL);
8976                 packet_hexdump(data, size);
8977                 return;
8978         }
8979
8980         data += sizeof(*hdr);
8981         size -= sizeof(*hdr);
8982
8983         sprintf(handle_str, "Handle %d", acl_handle(handle));
8984         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, dlen);
8985
8986         print_packet(tv, cred, index, in ? '>' : '<', COLOR_HCI_ACLDATA,
8987                                 in ? "ACL Data RX" : "ACL Data TX",
8988                                                 handle_str, extra_str);
8989
8990         if (size != dlen) {
8991                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
8992                                                                 size, dlen);
8993                 packet_hexdump(data, size);
8994                 return;
8995         }
8996
8997         if (filter_mask & PACKET_FILTER_SHOW_ACL_DATA)
8998                 packet_hexdump(data, size);
8999
9000         l2cap_packet(index, in, acl_handle(handle), flags, data, size);
9001 }
9002
9003 void packet_hci_scodata(struct timeval *tv, struct ucred *cred, uint16_t index,
9004                                 bool in, const void *data, uint16_t size)
9005 {
9006         const hci_sco_hdr *hdr = data;
9007         uint16_t handle = le16_to_cpu(hdr->handle);
9008         uint8_t flags = acl_flags(handle);
9009         char handle_str[16], extra_str[32];
9010
9011         if (size < HCI_SCO_HDR_SIZE) {
9012                 if (in)
9013                         print_packet(tv, cred, index, '*', COLOR_ERROR,
9014                                 "Malformed SCO Data RX packet", NULL, NULL);
9015                 else
9016                         print_packet(tv, cred, index, '*', COLOR_ERROR,
9017                                 "Malformed SCO Data TX packet", NULL, NULL);
9018                 packet_hexdump(data, size);
9019                 return;
9020         }
9021
9022         data += HCI_SCO_HDR_SIZE;
9023         size -= HCI_SCO_HDR_SIZE;
9024
9025         sprintf(handle_str, "Handle %d", acl_handle(handle));
9026         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, hdr->dlen);
9027
9028         print_packet(tv, cred, index, in ? '>' : '<', COLOR_HCI_SCODATA,
9029                                 in ? "SCO Data RX" : "SCO Data TX",
9030                                                 handle_str, extra_str);
9031
9032         if (size != hdr->dlen) {
9033                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
9034                                                         size, hdr->dlen);
9035                 packet_hexdump(data, size);
9036                 return;
9037         }
9038
9039         if (filter_mask & PACKET_FILTER_SHOW_SCO_DATA)
9040                 packet_hexdump(data, size);
9041 }
9042
9043 void packet_todo(void)
9044 {
9045         int i;
9046
9047         printf("HCI commands with missing decodings:\n");
9048
9049         for (i = 0; opcode_table[i].str; i++) {
9050                 if (opcode_table[i].bit < 0)
9051                         continue;
9052
9053                 if (opcode_table[i].cmd_func)
9054                         continue;
9055
9056                 printf("\t%s\n", opcode_table[i].str);
9057         }
9058
9059         printf("HCI events with missing decodings:\n");
9060
9061         for (i = 0; event_table[i].str; i++) {
9062                 if (event_table[i].func)
9063                         continue;
9064
9065                 printf("\t%s\n", event_table[i].str);
9066         }
9067
9068         for (i = 0; le_meta_event_table[i].str; i++) {
9069                 if (le_meta_event_table[i].func)
9070                         continue;
9071
9072                 printf("\t%s\n", le_meta_event_table[i].str);
9073         }
9074 }