monitor/packet.c

   1 // SPDX-License-Identifier: LGPL-2.1-or-later
   2 /*
   3  *
   4  *  BlueZ - Bluetooth protocol stack for Linux
   5  *
   6  *  Copyright (C) 2011-2014  Intel Corporation
   7  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
   8  *  Copyright 2023 NXP
   9  *
  10  *
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 #include <config.h>
  15 #endif
  16
  17 #include <stdio.h>
  18 #include <errno.h>
  19 #include <ctype.h>
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <stdbool.h>
  24 #include <inttypes.h>
  25 #include <time.h>
  26 #include <sys/time.h>
  27 #include <sys/socket.h>
  28
  29 #include "lib/bluetooth.h"
  30 #include "lib/uuid.h"
  31 #include "lib/hci.h"
  32 #include "lib/hci_lib.h"
  33
  34 #include "src/shared/util.h"
  35 #include "src/shared/btsnoop.h"
  36 #include "src/shared/queue.h"
  37 #include "display.h"
  38 #include "bt.h"
  39 #include "ll.h"
  40 #include "hwdb.h"
  41 #include "keys.h"
  42 #include "packet.h"
  43 #include "l2cap.h"
  44 #include "control.h"
  45 #include "vendor.h"
  46 #include "msft.h"
  47 #include "intel.h"
  48 #include "broadcom.h"
  49
  50 #define COLOR_CHANNEL_LABEL             COLOR_WHITE
  51 #define COLOR_FRAME_LABEL               COLOR_WHITE
  52 #define COLOR_INDEX_LABEL               COLOR_WHITE
  53 #define COLOR_TIMESTAMP                 COLOR_YELLOW
  54
  55 #define COLOR_NEW_INDEX                 COLOR_GREEN
  56 #define COLOR_DEL_INDEX                 COLOR_RED
  57 #define COLOR_OPEN_INDEX                COLOR_GREEN
  58 #define COLOR_CLOSE_INDEX               COLOR_RED
  59 #define COLOR_INDEX_INFO                COLOR_GREEN
  60 #define COLOR_VENDOR_DIAG               COLOR_YELLOW
  61 #define COLOR_SYSTEM_NOTE               COLOR_OFF
  62
  63 #define COLOR_HCI_COMMAND               COLOR_BLUE
  64 #define COLOR_HCI_COMMAND_UNKNOWN       COLOR_WHITE_BG
  65 #define COLOR_HCI_EVENT                 COLOR_MAGENTA
  66 #define COLOR_HCI_EVENT_UNKNOWN         COLOR_WHITE_BG
  67 #define COLOR_HCI_ACLDATA               COLOR_CYAN
  68 #define COLOR_HCI_SCODATA               COLOR_YELLOW
  69 #define COLOR_HCI_ISODATA               COLOR_YELLOW
  70
  71 #define COLOR_UNKNOWN_ERROR             COLOR_WHITE_BG
  72 #define COLOR_UNKNOWN_FEATURE_BIT       COLOR_WHITE_BG
  73 #define COLOR_UNKNOWN_COMMAND_BIT       COLOR_WHITE_BG
  74 #define COLOR_UNKNOWN_EVENT_MASK        COLOR_WHITE_BG
  75 #define COLOR_UNKNOWN_LE_STATES         COLOR_WHITE_BG
  76 #define COLOR_UNKNOWN_SERVICE_CLASS     COLOR_WHITE_BG
  77 #define COLOR_UNKNOWN_PKT_TYPE_BIT      COLOR_WHITE_BG
  78
  79 #define COLOR_CTRL_OPEN                 COLOR_GREEN_BOLD
  80 #define COLOR_CTRL_CLOSE                COLOR_RED_BOLD
  81 #define COLOR_CTRL_COMMAND              COLOR_BLUE_BOLD
  82 #define COLOR_CTRL_COMMAND_UNKNOWN      COLOR_WHITE_BG
  83 #define COLOR_CTRL_EVENT                COLOR_MAGENTA_BOLD
  84 #define COLOR_CTRL_EVENT_UNKNOWN        COLOR_WHITE_BG
  85
  86 #define COLOR_UNKNOWN_OPTIONS_BIT       COLOR_WHITE_BG
  87 #define COLOR_UNKNOWN_SETTINGS_BIT      COLOR_WHITE_BG
  88 #define COLOR_UNKNOWN_ADDRESS_TYPE      COLOR_WHITE_BG
  89 #define COLOR_UNKNOWN_DEVICE_FLAG       COLOR_WHITE_BG
  90 #define COLOR_UNKNOWN_EXP_FEATURE_FLAG  COLOR_WHITE_BG
  91 #define COLOR_UNKNOWN_ADV_FLAG          COLOR_WHITE_BG
  92 #define COLOR_UNKNOWN_PHY               COLOR_WHITE_BG
  93 #define COLOR_UNKNOWN_ADDED_DEVICE_FLAG COLOR_WHITE_BG
  94 #define COLOR_UNKNOWN_ADVMON_FEATURES   COLOR_WHITE_BG
  95
  96 #define COLOR_PHY_PACKET                COLOR_BLUE
  97
  98 #define UNKNOWN_MANUFACTURER 0xffff
  99
 100 static time_t time_offset = ((time_t) -1);
 101 static int priority_level = BTSNOOP_PRIORITY_INFO;
 102 static unsigned long filter_mask = 0;
 103 static bool index_filter = false;
 104 static uint16_t index_current = 0;
 105 static uint16_t fallback_manufacturer = UNKNOWN_MANUFACTURER;
 106
 107 #define CTRL_RAW  0x0000
 108 #define CTRL_USER 0x0001
 109 #define CTRL_MGMT 0x0002
 110
 111 #define MAX_CTRL 64
 112
 113 struct ctrl_data {
 114         bool used;
 115         uint32_t cookie;
 116         uint16_t format;
 117         char name[20];
 118 };
 119
 120 static struct ctrl_data ctrl_list[MAX_CTRL];
 121
 122 static void assign_ctrl(uint32_t cookie, uint16_t format, const char *name)
 123 {
 124         int i;
 125
 126         for (i = 0; i < MAX_CTRL; i++) {
 127                 if (!ctrl_list[i].used) {
 128                         ctrl_list[i].used = true;
 129                         ctrl_list[i].cookie = cookie;
 130                         ctrl_list[i].format = format;
 131                         if (name) {
 132                                 strncpy(ctrl_list[i].name, name, 19);
 133                                 ctrl_list[i].name[19] = '\0';
 134                         } else
 135                                 strcpy(ctrl_list[i].name, "null");
 136                         break;
 137                 }
 138         }
 139 }
 140
 141 static void release_ctrl(uint32_t cookie, uint16_t *format, char *name)
 142 {
 143         int i;
 144
 145         if (format)
 146                 *format = 0xffff;
 147
 148         for (i = 0; i < MAX_CTRL; i++) {
 149                 if (ctrl_list[i].used && ctrl_list[i].cookie == cookie) {
 150                         ctrl_list[i].used = false;
 151                         if (format)
 152                                 *format = ctrl_list[i].format;
 153                         if (name)
 154                                 strncpy(name, ctrl_list[i].name, 20);
 155                         break;
 156                 }
 157         }
 158 }
 159
 160 static uint16_t get_format(uint32_t cookie)
 161 {
 162         int i;
 163
 164         for (i = 0; i < MAX_CTRL; i++) {
 165                 if (ctrl_list[i].used && ctrl_list[i].cookie == cookie)
 166                         return ctrl_list[i].format;
 167         }
 168
 169         return 0xffff;
 170 }
 171
 172 #define MAX_CONN 16
 173
 174 static struct packet_conn_data conn_list[MAX_CONN];
 175
 176 static void assign_handle(uint16_t index, uint16_t handle, uint8_t type,
 177                                         uint8_t *dst, uint8_t dst_type)
 178 {
 179         int i;
 180
 181         for (i = 0; i < MAX_CONN; i++) {
 182                 if (conn_list[i].handle == 0x0000) {
 183                         if (hci_devba(index, (bdaddr_t *)conn_list[i].src) < 0)
 184                                 return;
 185
 186                         conn_list[i].index = index;
 187                         conn_list[i].handle = handle;
 188                         conn_list[i].type = type;
 189
 190                         if (!dst)
 191                                 break;
 192
 193                         memcpy(conn_list[i].dst, dst, sizeof(conn_list[i].dst));
 194                         conn_list[i].dst_type = dst_type;
 195                         break;
 196                 }
 197         }
 198 }
 199
 200 static void release_handle(uint16_t handle)
 201 {
 202         int i;
 203
 204         for (i = 0; i < MAX_CONN; i++) {
 205                 struct packet_conn_data *conn = &conn_list[i];
 206
 207                 if (conn->handle == handle) {
 208                         if (conn->destroy)
 209                                 conn->destroy(conn->data);
 210
 211                         queue_destroy(conn->tx_q, free);
 212                         queue_destroy(conn->chan_q, free);
 213                         memset(conn, 0, sizeof(*conn));
 214                         break;
 215                 }
 216         }
 217 }
 218
 219 struct packet_conn_data *packet_get_conn_data(uint16_t handle)
 220 {
 221         int i;
 222
 223         for (i = 0; i < MAX_CONN; i++) {
 224                 if (conn_list[i].handle == handle)
 225                         return &conn_list[i];
 226         }
 227
 228         return NULL;
 229 }
 230
 231 static uint8_t get_type(uint16_t handle)
 232 {
 233         struct packet_conn_data *conn;
 234
 235         conn = packet_get_conn_data(handle);
 236         if (!conn)
 237                 return 0xff;
 238
 239         return conn->type;
 240 }
 241
 242 bool packet_has_filter(unsigned long filter)
 243 {
 244         return filter_mask & filter;
 245 }
 246
 247 void packet_set_filter(unsigned long filter)
 248 {
 249         filter_mask = filter;
 250 }
 251
 252 void packet_add_filter(unsigned long filter)
 253 {
 254         if (index_filter)
 255                 filter &= ~PACKET_FILTER_SHOW_INDEX;
 256
 257         filter_mask |= filter;
 258 }
 259
 260 void packet_del_filter(unsigned long filter)
 261 {
 262         filter_mask &= ~filter;
 263 }
 264
 265 void packet_set_priority(const char *priority)
 266 {
 267         if (!priority)
 268                 return;
 269
 270         if (!strcasecmp(priority, "debug"))
 271                 priority_level = BTSNOOP_PRIORITY_DEBUG;
 272         else
 273                 priority_level = atoi(priority);
 274 }
 275
 276 void packet_select_index(uint16_t index)
 277 {
 278         filter_mask &= ~PACKET_FILTER_SHOW_INDEX;
 279
 280         control_filter_index(index);
 281
 282         index_filter = true;
 283 }
 284
 285 #define print_space(x) printf("%*c", (x), ' ');
 286
 287 #define MAX_INDEX 16
 288
 289 struct index_data {
 290         uint8_t  type;
 291         uint8_t  bdaddr[6];
 292         uint16_t manufacturer;
 293         uint16_t msft_opcode;
 294         uint8_t  msft_evt_prefix[8];
 295         uint8_t  msft_evt_len;
 296         size_t   frame;
 297 };
 298
 299 static struct index_data index_list[MAX_INDEX];
 300
 301 void packet_set_fallback_manufacturer(uint16_t manufacturer)
 302 {
 303         int i;
 304
 305         for (i = 0; i < MAX_INDEX; i++)
 306                 index_list[i].manufacturer = manufacturer;
 307
 308         fallback_manufacturer = manufacturer;
 309 }
 310
 311 void packet_set_msft_evt_prefix(const uint8_t *prefix, uint8_t len)
 312 {
 313         if (index_current < MAX_INDEX && len < 8)
 314                 memcpy(index_list[index_current].msft_evt_prefix, prefix, len);
 315 }
 316
 317 static void cred_pid(struct ucred *cred, char *str, size_t len)
 318 {
 319         char *path = alloca(24);
 320         char line[128];
 321         FILE *fp;
 322
 323         snprintf(path, 23, "/proc/%u/comm", cred->pid);
 324
 325         fp = fopen(path, "re");
 326         if (fp) {
 327                 if (fgets(line, sizeof(line), fp)) {
 328                         line[strcspn(line, "\r\n")] = '\0';
 329                         snprintf(str, len, "%s[%u]", line, cred->pid);
 330                 } else
 331                         snprintf(str, len, "[%u]", cred->pid);
 332                 fclose(fp);
 333         } else
 334                 snprintf(str, len, "[%u]", cred->pid);
 335 }
 336
 337 static void print_packet(struct timeval *tv, struct ucred *cred, char ident,
 338                                         uint16_t index, const char *channel,
 339                                         const char *color, const char *label,
 340                                         const char *text, const char *extra)
 341 {
 342         int col = num_columns();
 343         char line[256], ts_str[96], pid_str[140];
 344         int n, ts_len = 0, ts_pos = 0, len = 0, pos = 0;
 345         static size_t last_frame;
 346
 347         if (channel) {
 348                 if (use_color()) {
 349                         n = sprintf(ts_str + ts_pos, "%s", COLOR_CHANNEL_LABEL);
 350                         if (n > 0)
 351                                 ts_pos += n;
 352                 }
 353
 354                 n = sprintf(ts_str + ts_pos, " {%s}", channel);
 355                 if (n > 0) {
 356                         ts_pos += n;
 357                         ts_len += n;
 358                 }
 359         } else if (index != HCI_DEV_NONE && index < MAX_INDEX &&
 360                                 index_list[index].frame != last_frame) {
 361                 if (use_color()) {
 362                         n = sprintf(ts_str + ts_pos, "%s", COLOR_FRAME_LABEL);
 363                         if (n > 0)
 364                                 ts_pos += n;
 365                 }
 366
 367                 n = sprintf(ts_str + ts_pos, " #%zu", index_list[index].frame);
 368                 if (n > 0) {
 369                         ts_pos += n;
 370                         ts_len += n;
 371                 }
 372                 last_frame = index_list[index].frame;
 373         }
 374
 375         if ((filter_mask & PACKET_FILTER_SHOW_INDEX) &&
 376                                         index != HCI_DEV_NONE) {
 377                 if (use_color()) {
 378                         n = snprintf(ts_str + ts_pos, sizeof(ts_str) - ts_pos,
 379                                      "%s", COLOR_INDEX_LABEL);
 380                         if (n > 0)
 381                                 ts_pos += n;
 382                 }
 383
 384                 n = sprintf(ts_str + ts_pos, " [hci%d]", index);
 385                 if (n > 0) {
 386                         ts_pos += n;
 387                         ts_len += n;
 388                 }
 389         }
 390
 391         if (tv) {
 392                 time_t t = tv->tv_sec;
 393                 struct tm tm;
 394
 395                 localtime_r(&t, &tm);
 396
 397                 if (use_color()) {
 398                         n = sprintf(ts_str + ts_pos, "%s", COLOR_TIMESTAMP);
 399                         if (n > 0)
 400                                 ts_pos += n;
 401                 }
 402
 403                 if (filter_mask & PACKET_FILTER_SHOW_DATE) {
 404                         n = sprintf(ts_str + ts_pos, " %04d-%02d-%02d",
 405                                 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
 406                         if (n > 0) {
 407                                 ts_pos += n;
 408                                 ts_len += n;
 409                         }
 410                 }
 411
 412                 if (filter_mask & PACKET_FILTER_SHOW_TIME) {
 413                         n = sprintf(ts_str + ts_pos, " %02d:%02d:%02d.%06llu",
 414                                 tm.tm_hour, tm.tm_min, tm.tm_sec,
 415                                 (long long)tv->tv_usec);
 416                         if (n > 0) {
 417                                 ts_pos += n;
 418                                 ts_len += n;
 419                         }
 420                 }
 421
 422                 if (filter_mask & PACKET_FILTER_SHOW_TIME_OFFSET) {
 423                         n = sprintf(ts_str + ts_pos, " %llu.%06llu",
 424                                 (long long)(tv->tv_sec - time_offset),
 425                                 (long long)tv->tv_usec);
 426                         if (n > 0) {
 427                                 ts_pos += n;
 428                                 ts_len += n;
 429                         }
 430                 }
 431         }
 432
 433         if (use_color()) {
 434                 sprintf(ts_str + ts_pos, "%s", COLOR_OFF);
 435                 n = sprintf(line + pos, "%s", color);
 436                 if (n > 0)
 437                         pos += n;
 438         }
 439
 440         if (cred && cred->pid) {
 441                 cred_pid(cred, pid_str, sizeof(pid_str));
 442                 n = sprintf(line + pos, "%s: %c %s", pid_str, ident,
 443                                                 label ? label : "");
 444         } else
 445                 n = sprintf(line + pos, "%c %s", ident, label ? label : "");
 446
 447         if (n > 0) {
 448                 pos += n;
 449                 len += n;
 450         }
 451
 452         if (text) {
 453                 int extra_len = extra ? strlen(extra) : 0;
 454                 int max_len = col - len - extra_len - ts_len - 3;
 455
 456                 n = snprintf(line + pos, max_len + 1, "%s%s",
 457                                                 label ? ": " : "", text);
 458                 if (n > max_len) {
 459                         line[pos + max_len - 1] = '.';
 460                         line[pos + max_len - 2] = '.';
 461                         if (line[pos + max_len - 3] == ' ')
 462                                 line[pos + max_len - 3] = '.';
 463
 464                         n = max_len;
 465                 }
 466
 467                 if (n > 0) {
 468                         pos += n;
 469                         len += n;
 470                 }
 471         }
 472
 473         if (use_color()) {
 474                 n = sprintf(line + pos, "%s", COLOR_OFF);
 475                 if (n > 0)
 476                         pos += n;
 477         }
 478
 479         if (extra) {
 480                 n = sprintf(line + pos, " %s", extra);
 481                 if (n > 0)
 482                         len += n;
 483         }
 484
 485         if (ts_len > 0) {
 486                 printf("%s", line);
 487                 if (len < col)
 488                         print_space(col - len - ts_len - 1);
 489                 printf("%s%s\n", use_color() ? COLOR_TIMESTAMP : "", ts_str);
 490         } else
 491                 printf("%s\n", line);
 492 }
 493
 494 static const struct {
 495         uint8_t error;
 496         const char *str;
 497 } error2str_table[] = {
 498         { 0x00, "Success"                                               },
 499         { 0x01, "Unknown HCI Command"                                   },
 500         { 0x02, "Unknown Connection Identifier"                         },
 501         { 0x03, "Hardware Failure"                                      },
 502         { 0x04, "Page Timeout"                                          },
 503         { 0x05, "Authentication Failure"                                },
 504         { 0x06, "PIN or Key Missing"                                    },
 505         { 0x07, "Memory Capacity Exceeded"                              },
 506         { 0x08, "Connection Timeout"                                    },
 507         { 0x09, "Connection Limit Exceeded"                             },
 508         { 0x0a, "Synchronous Connection Limit to a Device Exceeded"     },
 509         { 0x0b, "ACL Connection Already Exists"                         },
 510         { 0x0c, "Command Disallowed"                                    },
 511         { 0x0d, "Connection Rejected due to Limited Resources"          },
 512         { 0x0e, "Connection Rejected due to Security Reasons"           },
 513         { 0x0f, "Connection Rejected due to Unacceptable BD_ADDR"       },
 514         { 0x10, "Connection Accept Timeout Exceeded"                    },
 515         { 0x11, "Unsupported Feature or Parameter Value"                },
 516         { 0x12, "Invalid HCI Command Parameters"                        },
 517         { 0x13, "Remote User Terminated Connection"                     },
 518         { 0x14, "Remote Device Terminated due to Low Resources"         },
 519         { 0x15, "Remote Device Terminated due to Power Off"             },
 520         { 0x16, "Connection Terminated By Local Host"                   },
 521         { 0x17, "Repeated Attempts"                                     },
 522         { 0x18, "Pairing Not Allowed"                                   },
 523         { 0x19, "Unknown LMP PDU"                                       },
 524         { 0x1a, "Unsupported Remote Feature / Unsupported LMP Feature"  },
 525         { 0x1b, "SCO Offset Rejected"                                   },
 526         { 0x1c, "SCO Interval Rejected"                                 },
 527         { 0x1d, "SCO Air Mode Rejected"                                 },
 528         { 0x1e, "Invalid LMP Parameters / Invalid LL Parameters"        },
 529         { 0x1f, "Unspecified Error"                                     },
 530         { 0x20, "Unsupported LMP Parameter Value / "
 531                 "Unsupported LL Parameter Value"                        },
 532         { 0x21, "Role Change Not Allowed"                               },
 533         { 0x22, "LMP Response Timeout / LL Response Timeout"            },
 534         { 0x23, "LMP Error Transaction Collision"                       },
 535         { 0x24, "LMP PDU Not Allowed"                                   },
 536         { 0x25, "Encryption Mode Not Acceptable"                        },
 537         { 0x26, "Link Key cannot be Changed"                            },
 538         { 0x27, "Requested QoS Not Supported"                           },
 539         { 0x28, "Instant Passed"                                        },
 540         { 0x29, "Pairing With Unit Key Not Supported"                   },
 541         { 0x2a, "Different Transaction Collision"                       },
 542         { 0x2b, "Reserved"                                              },
 543         { 0x2c, "QoS Unacceptable Parameter"                            },
 544         { 0x2d, "QoS Rejected"                                          },
 545         { 0x2e, "Channel Classification Not Supported"                  },
 546         { 0x2f, "Insufficient Security"                                 },
 547         { 0x30, "Parameter Out Of Manadatory Range"                     },
 548         { 0x31, "Reserved"                                              },
 549         { 0x32, "Role Switch Pending"                                   },
 550         { 0x33, "Reserved"                                              },
 551         { 0x34, "Reserved Slot Violation"                               },
 552         { 0x35, "Role Switch Failed"                                    },
 553         { 0x36, "Extended Inquiry Response Too Large"                   },
 554         { 0x37, "Secure Simple Pairing Not Supported By Host"           },
 555         { 0x38, "Host Busy - Pairing"                                   },
 556         { 0x39, "Connection Rejected due to No Suitable Channel Found"  },
 557         { 0x3a, "Controller Busy"                                       },
 558         { 0x3b, "Unacceptable Connection Parameters"                    },
 559         { 0x3c, "Advertising Timeout"                                   },
 560         { 0x3d, "Connection Terminated due to MIC Failure"              },
 561         { 0x3e, "Connection Failed to be Established"                   },
 562         { 0x3f, "MAC Connection Failed"                                 },
 563         { 0x40, "Coarse Clock Adjustment Rejected "
 564                 "but Will Try to Adjust Using Clock Dragging"           },
 565         { 0x41, "Type0 Submap Not Defined"                              },
 566         { 0x42, "Unknown Advertising Identifier"                        },
 567         { 0x43, "Limit Reached"                                         },
 568         { 0x44, "Operation Cancelled by Host"                           },
 569         { 0x45, "Packet Too Long"                                       },
 570         { }
 571 };
 572
 573 static void print_error(const char *label, uint8_t error)
 574 {
 575         const char *str = "Unknown";
 576         const char *color_on, *color_off;
 577         bool unknown = true;
 578         int i;
 579
 580         for (i = 0; error2str_table[i].str; i++) {
 581                 if (error2str_table[i].error == error) {
 582                         str = error2str_table[i].str;
 583                         unknown = false;
 584                         break;
 585                 }
 586         }
 587
 588         if (use_color()) {
 589                 if (error) {
 590                         if (unknown)
 591                                 color_on = COLOR_UNKNOWN_ERROR;
 592                         else
 593                                 color_on = COLOR_RED;
 594                 } else
 595                         color_on = COLOR_GREEN;
 596                 color_off = COLOR_OFF;
 597         } else {
 598                 color_on = "";
 599                 color_off = "";
 600         }
 601
 602         print_field("%s: %s%s%s (0x%2.2x)", label,
 603                                 color_on, str, color_off, error);
 604 }
 605
 606 static void print_status(uint8_t status)
 607 {
 608         print_error("Status", status);
 609 }
 610
 611 static void print_reason(uint8_t reason)
 612 {
 613         print_error("Reason", reason);
 614 }
 615
 616 void packet_print_error(const char *label, uint8_t error)
 617 {
 618         print_error(label, error);
 619 }
 620
 621 static void print_enable(const char *label, uint8_t enable)
 622 {
 623         const char *str;
 624
 625         switch (enable) {
 626         case 0x00:
 627                 str = "Disabled";
 628                 break;
 629         case 0x01:
 630                 str = "Enabled";
 631                 break;
 632         default:
 633                 str = "Reserved";
 634                 break;
 635         }
 636
 637         print_field("%s: %s (0x%2.2x)", label, str, enable);
 638 }
 639
 640 static void print_addr_type(const char *label, uint8_t addr_type)
 641 {
 642         const char *str;
 643
 644         switch (addr_type) {
 645         case 0x00:
 646                 str = "Public";
 647                 break;
 648         case 0x01:
 649                 str = "Random";
 650                 break;
 651         default:
 652                 str = "Reserved";
 653                 break;
 654         }
 655
 656         print_field("%s: %s (0x%2.2x)", label, str, addr_type);
 657 }
 658
 659 static void print_own_addr_type(uint8_t addr_type)
 660 {
 661         const char *str;
 662
 663         switch (addr_type) {
 664         case 0x00:
 665         case 0x02:
 666                 str = "Public";
 667                 break;
 668         case 0x01:
 669         case 0x03:
 670                 str = "Random";
 671                 break;
 672         default:
 673                 str = "Reserved";
 674                 break;
 675         }
 676
 677         print_field("Own address type: %s (0x%2.2x)", str, addr_type);
 678 }
 679
 680 static void print_peer_addr_type(const char *label, uint8_t addr_type)
 681 {
 682         const char *str;
 683
 684         switch (addr_type) {
 685         case 0x00:
 686                 str = "Public";
 687                 break;
 688         case 0x01:
 689                 str = "Random";
 690                 break;
 691         case 0x02:
 692                 str = "Resolved Public";
 693                 break;
 694         case 0x03:
 695                 str = "Resolved Random";
 696                 break;
 697         default:
 698                 str = "Reserved";
 699                 break;
 700         }
 701
 702         print_field("%s: %s (0x%2.2x)", label, str, addr_type);
 703 }
 704
 705 static void print_addr_resolve(const char *label, const uint8_t *addr,
 706                                         uint8_t addr_type, bool resolve)
 707 {
 708         const char *str;
 709         char *company;
 710
 711         switch (addr_type) {
 712         case 0x00:
 713         case 0x02:
 714                 if (!hwdb_get_company(addr, &company))
 715                         company = NULL;
 716
 717                 if (company) {
 718                         print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 719                                         " (%s)", label, addr[5], addr[4],
 720                                                         addr[3], addr[2],
 721                                                         addr[1], addr[0],
 722                                                         company);
 723                         free(company);
 724                 } else {
 725                         print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 726                                         " (OUI %2.2X-%2.2X-%2.2X)", label,
 727                                                 addr[5], addr[4], addr[3],
 728                                                 addr[2], addr[1], addr[0],
 729                                                 addr[5], addr[4], addr[3]);
 730                 }
 731                 break;
 732         case 0x01:
 733         case 0x03:
 734                 switch ((addr[5] & 0xc0) >> 6) {
 735                 case 0x00:
 736                         str = "Non-Resolvable";
 737                         break;
 738                 case 0x01:
 739                         str = "Resolvable";
 740                         break;
 741                 case 0x03:
 742                         str = "Static";
 743                         break;
 744                 default:
 745                         str = "Reserved";
 746                         break;
 747                 }
 748
 749                 print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X (%s)",
 750                                         label, addr[5], addr[4], addr[3],
 751                                         addr[2], addr[1], addr[0], str);
 752
 753                 if (resolve && (addr[5] & 0xc0) == 0x40) {
 754                         uint8_t ident[6], ident_type;
 755
 756                         if (keys_resolve_identity(addr, ident, &ident_type)) {
 757                                 print_addr_type("  Identity type", ident_type);
 758                                 print_addr_resolve("  Identity", ident,
 759                                                         ident_type, false);
 760                         }
 761                 }
 762                 break;
 763         default:
 764                 print_field("%s: %2.2X-%2.2X-%2.2X-%2.2X-%2.2X-%2.2X",
 765                                         label, addr[5], addr[4], addr[3],
 766                                         addr[2], addr[1], addr[0]);
 767                 break;
 768         }
 769 }
 770
 771 static void print_addr(const char *label, const uint8_t *addr, uint8_t type)
 772 {
 773         print_addr_resolve(label, addr, type, true);
 774 }
 775
 776 static void print_bdaddr(const uint8_t *bdaddr)
 777 {
 778         print_addr("Address", bdaddr, 0x00);
 779 }
 780
 781 static void print_lt_addr(uint8_t lt_addr)
 782 {
 783         print_field("LT address: %d", lt_addr);
 784 }
 785
 786 static void print_handle_native(uint16_t handle)
 787 {
 788         struct packet_conn_data *conn;
 789         char label[25];
 790
 791         conn = packet_get_conn_data(handle);
 792         if (!conn) {
 793                 print_field("Handle: %d", handle);
 794                 return;
 795         }
 796
 797         sprintf(label, "Handle: %d Address", handle);
 798         print_addr(label, conn->dst, conn->dst_type);
 799 }
 800
 801 static void print_handle(uint16_t handle)
 802 {
 803         print_handle_native(le16_to_cpu(handle));
 804 }
 805
 806 static void print_phy_handle(uint8_t phy_handle)
 807 {
 808         print_field("Physical handle: %d", phy_handle);
 809 }
 810
 811 static const struct bitfield_data pkt_type_table[] = {
 812         {  1, "2-DH1 may not be used"   },
 813         {  2, "3-DH1 may not be used"   },
 814         {  3, "DM1 may be used"         },
 815         {  4, "DH1 may be used"         },
 816         {  8, "2-DH3 may not be used"   },
 817         {  9, "3-DH3 may not be used"   },
 818         { 10, "DM3 may be used"         },
 819         { 11, "DH3 may be used"         },
 820         { 12, "2-DH5 may not be used"   },
 821         { 13, "3-DH5 may not be used"   },
 822         { 14, "DM5 may be used"         },
 823         { 15, "DH5 may be used"         },
 824         { }
 825 };
 826
 827 static void print_pkt_type(uint16_t pkt_type)
 828 {
 829         uint16_t mask = le16_to_cpu(pkt_type);
 830
 831         print_field("Packet type: 0x%4.4x", mask);
 832
 833         mask = print_bitfield(2, mask, pkt_type_table);
 834         if (mask)
 835                 print_text(COLOR_UNKNOWN_PKT_TYPE_BIT,
 836                                 "  Unknown packet types (0x%4.4x)", mask);
 837 }
 838
 839 static const struct bitfield_data pkt_type_sco_table[] = {
 840         {  0, "HV1 may be used"         },
 841         {  1, "HV2 may be used"         },
 842         {  2, "HV3 may be used"         },
 843         {  3, "EV3 may be used"         },
 844         {  4, "EV4 may be used"         },
 845         {  5, "EV5 may be used"         },
 846         {  6, "2-EV3 may not be used"   },
 847         {  7, "3-EV3 may not be used"   },
 848         {  8, "2-EV5 may not be used"   },
 849         {  9, "3-EV5 may not be used"   },
 850         { }
 851 };
 852
 853 static void print_pkt_type_sco(uint16_t pkt_type)
 854 {
 855         uint16_t mask = le16_to_cpu(pkt_type);
 856
 857         print_field("Packet type: 0x%4.4x", mask);
 858
 859         mask = print_bitfield(2, mask, pkt_type_sco_table);
 860         if (mask)
 861                 print_text(COLOR_UNKNOWN_PKT_TYPE_BIT,
 862                                 "  Unknown packet types (0x%4.4x)", mask);
 863 }
 864
 865 static void print_iac(const uint8_t *lap)
 866 {
 867         const char *str = "";
 868
 869         if (lap[2] == 0x9e && lap[1] == 0x8b) {
 870                 switch (lap[0]) {
 871                 case 0x33:
 872                         str = " (General Inquiry)";
 873                         break;
 874                 case 0x00:
 875                         str = " (Limited Inquiry)";
 876                         break;
 877                 }
 878         }
 879
 880         print_field("Access code: 0x%2.2x%2.2x%2.2x%s",
 881                                                 lap[2], lap[1], lap[0], str);
 882 }
 883
 884 static void print_auth_enable(uint8_t enable)
 885 {
 886         const char *str;
 887
 888         switch (enable) {
 889         case 0x00:
 890                 str = "Authentication not required";
 891                 break;
 892         case 0x01:
 893                 str = "Authentication required for all connections";
 894                 break;
 895         default:
 896                 str = "Reserved";
 897                 break;
 898         }
 899
 900         print_field("Enable: %s (0x%2.2x)", str, enable);
 901 }
 902
 903 static void print_encrypt_mode(uint8_t mode)
 904 {
 905         const char *str;
 906
 907         switch (mode) {
 908         case 0x00:
 909                 str = "Encryption not required";
 910                 break;
 911         case 0x01:
 912                 str = "Encryption required for all connections";
 913                 break;
 914         default:
 915                 str = "Reserved";
 916                 break;
 917         }
 918
 919         print_field("Mode: %s (0x%2.2x)", str, mode);
 920 }
 921
 922 static const struct bitfield_data svc_class_table[] = {
 923         { 0, "Positioning (Location identification)"            },
 924         { 1, "Networking (LAN, Ad hoc)"                         },
 925         { 2, "Rendering (Printing, Speaker)"                    },
 926         { 3, "Capturing (Scanner, Microphone)"                  },
 927         { 4, "Object Transfer (v-Inbox, v-Folder)"              },
 928         { 5, "Audio (Speaker, Microphone, Headset)"             },
 929         { 6, "Telephony (Cordless telephony, Modem, Headset)"   },
 930         { 7, "Information (WEB-server, WAP-server)"             },
 931         { }
 932 };
 933
 934 static const struct {
 935         uint8_t val;
 936         const char *str;
 937 } major_class_computer_table[] = {
 938         { 0x00, "Uncategorized, code for device not assigned"   },
 939         { 0x01, "Desktop workstation"                           },
 940         { 0x02, "Server-class computer"                         },
 941         { 0x03, "Laptop"                                        },
 942         { 0x04, "Handheld PC/PDA (clam shell)"                  },
 943         { 0x05, "Palm sized PC/PDA"                             },
 944         { 0x06, "Wearable computer (Watch sized)"               },
 945         { 0x07, "Tablet"                                        },
 946         { }
 947 };
 948
 949 static const char *major_class_computer(uint8_t minor)
 950 {
 951         int i;
 952
 953         for (i = 0; major_class_computer_table[i].str; i++) {
 954                 if (major_class_computer_table[i].val == minor)
 955                         return major_class_computer_table[i].str;
 956         }
 957
 958         return NULL;
 959 }
 960
 961 static const struct {
 962         uint8_t val;
 963         const char *str;
 964 } major_class_phone_table[] = {
 965         { 0x00, "Uncategorized, code for device not assigned"   },
 966         { 0x01, "Cellular"                                      },
 967         { 0x02, "Cordless"                                      },
 968         { 0x03, "Smart phone"                                   },
 969         { 0x04, "Wired modem or voice gateway"                  },
 970         { 0x05, "Common ISDN Access"                            },
 971         { }
 972 };
 973
 974 static const char *major_class_phone(uint8_t minor)
 975 {
 976         int i;
 977
 978         for (i = 0; major_class_phone_table[i].str; i++) {
 979                 if (major_class_phone_table[i].val == minor)
 980                         return major_class_phone_table[i].str;
 981         }
 982
 983         return NULL;
 984 }
 985
 986 static const struct {
 987         uint8_t val;
 988         const char *str;
 989 } major_class_av_table[] = {
 990         { 0x00, "Uncategorized, code for device not assigned"   },
 991         { 0x01, "Wearable Headset Device"                       },
 992         { 0x02, "Hands-free Device"                             },
 993         { 0x04, "Microphone"                                    },
 994         { 0x05, "Loudspeaker"                                   },
 995         { 0x06, "Headphones"                                    },
 996         { 0x07, "Portable Audio"                                },
 997         { 0x08, "Car audio"                                     },
 998         { 0x09, "Set-top box"                                   },
 999         { 0x0a, "HiFi Audio Device"                             },
1000         { 0x0b, "VCR"                                           },
1001         { 0x0c, "Video Camera"                                  },
1002         { 0x0d, "Camcorder"                                     },
1003         { 0x0e, "Video Monitor"                                 },
1004         { 0x0f, "Video Display and Loudspeaker"                 },
1005         { 0x10, "Video Conferencing"                            },
1006         { 0x12, "Gaming/Toy"                                    },
1007         { }
1008 };
1009
1010 static const char *major_class_av(uint8_t minor)
1011 {
1012         int i;
1013
1014         for (i = 0; major_class_av_table[i].str; i++) {
1015                 if (major_class_av_table[i].val == minor)
1016                         return major_class_av_table[i].str;
1017         }
1018
1019         return NULL;
1020 }
1021
1022 static const struct {
1023         uint8_t val;
1024         const char *str;
1025 } major_class_wearable_table[] = {
1026         { 0x01, "Wrist Watch"   },
1027         { 0x02, "Pager"         },
1028         { 0x03, "Jacket"        },
1029         { 0x04, "Helmet"        },
1030         { 0x05, "Glasses"       },
1031         { }
1032 };
1033
1034 static const char *major_class_wearable(uint8_t minor)
1035 {
1036         int i;
1037
1038         for (i = 0; major_class_wearable_table[i].str; i++) {
1039                 if (major_class_wearable_table[i].val == minor)
1040                         return major_class_wearable_table[i].str;
1041         }
1042
1043         return NULL;
1044 }
1045
1046 static const struct {
1047         uint8_t val;
1048         const char *str;
1049         const char *(*func)(uint8_t minor);
1050 } major_class_table[] = {
1051         { 0x00, "Miscellaneous"                                         },
1052         { 0x01, "Computer (desktop, notebook, PDA, organizers)",
1053                                                 major_class_computer    },
1054         { 0x02, "Phone (cellular, cordless, payphone, modem)",
1055                                                 major_class_phone       },
1056         { 0x03, "LAN /Network Access point"                             },
1057         { 0x04, "Audio/Video (headset, speaker, stereo, video, vcr)",
1058                                                 major_class_av          },
1059         { 0x05, "Peripheral (mouse, joystick, keyboards)"               },
1060         { 0x06, "Imaging (printing, scanner, camera, display)"          },
1061         { 0x07, "Wearable",                     major_class_wearable    },
1062         { 0x08, "Toy"                                                   },
1063         { 0x09, "Health"                                                },
1064         { 0x1f, "Uncategorized, specific device code not specified"     },
1065         { }
1066 };
1067
1068 static void print_dev_class(const uint8_t *dev_class)
1069 {
1070         uint8_t mask, major_cls, minor_cls;
1071         const char *major_str = NULL;
1072         const char *minor_str = NULL;
1073         int i;
1074
1075         print_field("Class: 0x%2.2x%2.2x%2.2x",
1076                         dev_class[2], dev_class[1], dev_class[0]);
1077
1078         if ((dev_class[0] & 0x03) != 0x00) {
1079                 print_field("  Format type: 0x%2.2x", dev_class[0] & 0x03);
1080                 print_text(COLOR_ERROR, "  invalid format type");
1081                 return;
1082         }
1083
1084         major_cls = dev_class[1] & 0x1f;
1085         minor_cls = (dev_class[0] & 0xfc) >> 2;
1086
1087         for (i = 0; major_class_table[i].str; i++) {
1088                 if (major_class_table[i].val == major_cls) {
1089                         major_str = major_class_table[i].str;
1090
1091                         if (!major_class_table[i].func)
1092                                 break;
1093
1094                         minor_str = major_class_table[i].func(minor_cls);
1095                         break;
1096                 }
1097         }
1098
1099         if (major_str) {
1100                 print_field("  Major class: %s", major_str);
1101                 if (minor_str)
1102                         print_field("  Minor class: %s", minor_str);
1103                 else
1104                         print_field("  Minor class: 0x%2.2x", minor_cls);
1105         } else {
1106                 print_field("  Major class: 0x%2.2x", major_cls);
1107                 print_field("  Minor class: 0x%2.2x", minor_cls);
1108         }
1109
1110         if (dev_class[1] & 0x20)
1111                 print_field("  Limited Discoverable Mode");
1112
1113         if ((dev_class[1] & 0xc0) != 0x00) {
1114                 print_text(COLOR_ERROR, "  invalid service class");
1115                 return;
1116         }
1117
1118         mask = print_bitfield(2, dev_class[2], svc_class_table);
1119         if (mask)
1120                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
1121                                 "  Unknown service class (0x%2.2x)", mask);
1122 }
1123
1124 static void print_appearance(uint16_t appearance)
1125 {
1126         print_field("Appearance: %s (0x%4.4x)", bt_appear_to_str(appearance),
1127                                                                 appearance);
1128 }
1129
1130 static void print_num_broadcast_retrans(uint8_t num_retrans)
1131 {
1132         print_field("Number of broadcast retransmissions: %u", num_retrans);
1133 }
1134
1135 static void print_hold_mode_activity(uint8_t activity)
1136 {
1137         print_field("Activity: 0x%2.2x", activity);
1138
1139         if (activity == 0x00) {
1140                 print_field("  Maintain current Power State");
1141                 return;
1142         }
1143
1144         if (activity & 0x01)
1145                 print_field("  Suspend Page Scan");
1146         if (activity & 0x02)
1147                 print_field("  Suspend Inquiry Scan");
1148         if (activity & 0x04)
1149                 print_field("  Suspend Periodic Inquiries");
1150 }
1151
1152 static void print_power_type(uint8_t type)
1153 {
1154         const char *str;
1155
1156         switch (type) {
1157         case 0x00:
1158                 str = "Current Transmit Power Level";
1159                 break;
1160         case 0x01:
1161                 str = "Maximum Transmit Power Level";
1162                 break;
1163         default:
1164                 str = "Reserved";
1165                 break;
1166         }
1167
1168         print_field("Type: %s (0x%2.2x)", str, type);
1169 }
1170
1171 static void print_power_level(int8_t level, const char *type)
1172 {
1173         print_field("TX power%s%s%s: %d dbm (0x%2.2x)",
1174                 type ? " (" : "", type ? type : "", type ? ")" : "",
1175                                                         level, (uint8_t) level);
1176 }
1177
1178 static void print_host_flow_control(uint8_t enable)
1179 {
1180         const char *str;
1181
1182         switch (enable) {
1183         case 0x00:
1184                 str = "Off";
1185                 break;
1186         case 0x01:
1187                 str = "ACL Data Packets";
1188                 break;
1189         case 0x02:
1190                 str = "Synchronous Data Packets";
1191                 break;
1192         case 0x03:
1193                 str = "ACL and Synchronous Data Packets";
1194                 break;
1195         default:
1196                 str = "Reserved";
1197                 break;
1198         }
1199
1200         print_field("Flow control: %s (0x%2.2x)", str, enable);
1201 }
1202
1203 static void print_voice_setting(uint16_t setting)
1204 {
1205         uint8_t input_coding = (le16_to_cpu(setting) & 0x0300) >> 8;
1206         uint8_t input_data_format = (le16_to_cpu(setting) & 0xc0) >> 6;
1207         uint8_t air_coding_format = le16_to_cpu(setting) & 0x0003;
1208         const char *str;
1209
1210         print_field("Setting: 0x%4.4x", le16_to_cpu(setting));
1211
1212         switch (input_coding) {
1213         case 0x00:
1214                 str = "Linear";
1215                 break;
1216         case 0x01:
1217                 str = "u-law";
1218                 break;
1219         case 0x02:
1220                 str = "A-law";
1221                 break;
1222         default:
1223                 str = "Reserved";
1224                 break;
1225         }
1226
1227         print_field("  Input Coding: %s", str);
1228
1229         switch (input_data_format) {
1230         case 0x00:
1231                 str = "1's complement";
1232                 break;
1233         case 0x01:
1234                 str = "2's complement";
1235                 break;
1236         case 0x02:
1237                 str = "Sign-Magnitude";
1238                 break;
1239         case 0x03:
1240                 str = "Unsigned";
1241                 break;
1242         default:
1243                 str = "Reserved";
1244                 break;
1245         }
1246
1247         print_field("  Input Data Format: %s", str);
1248
1249         if (input_coding == 0x00) {
1250                 print_field("  Input Sample Size: %s",
1251                         le16_to_cpu(setting) & 0x20 ? "16-bit" : "8-bit");
1252                 print_field("  # of bits padding at MSB: %d",
1253                                         (le16_to_cpu(setting) & 0x1c) >> 2);
1254         }
1255
1256         switch (air_coding_format) {
1257         case 0x00:
1258                 str = "CVSD";
1259                 break;
1260         case 0x01:
1261                 str = "u-law";
1262                 break;
1263         case 0x02:
1264                 str = "A-law";
1265                 break;
1266         case 0x03:
1267                 str = "Transparent Data";
1268                 break;
1269         default:
1270                 str = "Reserved";
1271                 break;
1272         }
1273
1274         print_field("  Air Coding Format: %s", str);
1275 }
1276
1277 static void print_retransmission_effort(uint8_t effort)
1278 {
1279         const char *str;
1280
1281         switch (effort) {
1282         case 0x00:
1283                 str = "No retransmissions";
1284                 break;
1285         case 0x01:
1286                 str = "Optimize for power consumption";
1287                 break;
1288         case 0x02:
1289                 str = "Optimize for link quality";
1290                 break;
1291         case 0xff:
1292                 str = "Don't care";
1293                 break;
1294         default:
1295                 str = "Reserved";
1296                 break;
1297         }
1298
1299         print_field("Retransmission effort: %s (0x%2.2x)", str, effort);
1300 }
1301
1302 static void print_scan_enable(uint8_t scan_enable)
1303 {
1304         const char *str;
1305
1306         switch (scan_enable) {
1307         case 0x00:
1308                 str = "No Scans";
1309                 break;
1310         case 0x01:
1311                 str = "Inquiry Scan";
1312                 break;
1313         case 0x02:
1314                 str = "Page Scan";
1315                 break;
1316         case 0x03:
1317                 str = "Inquiry Scan + Page Scan";
1318                 break;
1319         default:
1320                 str = "Reserved";
1321                 break;
1322         }
1323
1324         print_field("Scan enable: %s (0x%2.2x)", str, scan_enable);
1325 }
1326
1327 static void print_link_policy(uint16_t link_policy)
1328 {
1329         uint16_t policy = le16_to_cpu(link_policy);
1330
1331         print_field("Link policy: 0x%4.4x", policy);
1332
1333         if (policy == 0x0000) {
1334                 print_field("  Disable All Modes");
1335                 return;
1336         }
1337
1338         if (policy & 0x0001)
1339                 print_field("  Enable Role Switch");
1340         if (policy & 0x0002)
1341                 print_field("  Enable Hold Mode");
1342         if (policy & 0x0004)
1343                 print_field("  Enable Sniff Mode");
1344         if (policy & 0x0008)
1345                 print_field("  Enable Park State");
1346 }
1347
1348 static void print_air_mode(uint8_t mode)
1349 {
1350         const char *str;
1351
1352         switch (mode) {
1353         case 0x00:
1354                 str = "u-law log";
1355                 break;
1356         case 0x01:
1357                 str = "A-law log";
1358                 break;
1359         case 0x02:
1360                 str = "CVSD";
1361                 break;
1362         case 0x03:
1363                 str = "Transparent";
1364                 break;
1365         default:
1366                 str = "Reserved";
1367                 break;
1368         }
1369
1370         print_field("Air mode: %s (0x%2.2x)", str, mode);
1371 }
1372
1373 static void print_codec_id(const char *label, uint8_t codec)
1374 {
1375         const char *str;
1376
1377         switch (codec) {
1378         case 0x00:
1379                 str = "u-law log";
1380                 break;
1381         case 0x01:
1382                 str = "A-law log";
1383                 break;
1384         case 0x02:
1385                 str = "CVSD";
1386                 break;
1387         case 0x03:
1388                 str = "Transparent";
1389                 break;
1390         case 0x04:
1391                 str = "Linear PCM";
1392                 break;
1393         case 0x05:
1394                 str = "mSBC";
1395                 break;
1396         case 0x06:
1397                 str = "LC3";
1398                 break;
1399         case 0xff:
1400                 str = "Vendor specific";
1401                 break;
1402         default:
1403                 str = "Reserved";
1404                 break;
1405         }
1406
1407         print_field("%s: %s (0x%2.2x)", label, str, codec);
1408 }
1409
1410 void packet_print_codec_id(const char *label, uint8_t codec)
1411 {
1412         print_codec_id(label, codec);
1413 }
1414
1415 static const struct bitfield_data codec_transport_table[] = {
1416         {  0, "Codec supported over BR/EDR ACL"         },
1417         {  1, "Codec supported over BR/EDR SCO and eSCO"},
1418         {  2, "Codec supported over LE CIS"             },
1419         {  3, "Codec supported over LE BIS"             },
1420         { }
1421 };
1422
1423 static void print_codec(const char *label, const struct bt_hci_codec *codec)
1424 {
1425         uint8_t mask;
1426
1427         print_codec_id(label, codec->id);
1428         print_field("  Logical Transport Type: 0x%02x", codec->transport);
1429         mask = print_bitfield(4, codec->transport, codec_transport_table);
1430         if (mask)
1431                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
1432                                 "  Unknown transport (0x%2.2x)", mask);
1433 }
1434
1435 static void print_inquiry_mode(uint8_t mode)
1436 {
1437         const char *str;
1438
1439         switch (mode) {
1440         case 0x00:
1441                 str = "Standard Inquiry Result";
1442                 break;
1443         case 0x01:
1444                 str = "Inquiry Result with RSSI";
1445                 break;
1446         case 0x02:
1447                 str = "Inquiry Result with RSSI or Extended Inquiry Result";
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_inquiry_scan_type(uint8_t type)
1458 {
1459         const char *str;
1460
1461         switch (type) {
1462         case 0x00:
1463                 str = "Standard Scan";
1464                 break;
1465         case 0x01:
1466                 str = "Interlaced Scan";
1467                 break;
1468         default:
1469                 str = "Reserved";
1470                 break;
1471         }
1472
1473         print_field("Type: %s (0x%2.2x)", str, type);
1474 }
1475
1476 static void print_pscan_type(uint8_t type)
1477 {
1478         const char *str;
1479
1480         switch (type) {
1481         case 0x00:
1482                 str = "Standard Scan";
1483                 break;
1484         case 0x01:
1485                 str = "Interlaced Scan";
1486                 break;
1487         default:
1488                 str = "Reserved";
1489                 break;
1490         }
1491
1492         print_field("Type: %s (0x%2.2x)", str, type);
1493 }
1494
1495 static void print_loopback_mode(uint8_t mode)
1496 {
1497         const char *str;
1498
1499         switch (mode) {
1500         case 0x00:
1501                 str = "No Loopback";
1502                 break;
1503         case 0x01:
1504                 str = "Local Loopback";
1505                 break;
1506         case 0x02:
1507                 str = "Remote Loopback";
1508                 break;
1509         default:
1510                 str = "Reserved";
1511                 break;
1512         }
1513
1514         print_field("Mode: %s (0x%2.2x)", str, mode);
1515 }
1516
1517 static void print_auth_payload_timeout(uint16_t timeout)
1518 {
1519         print_field("Timeout: %d msec (0x%4.4x)",
1520                         le16_to_cpu(timeout) * 10, le16_to_cpu(timeout));
1521 }
1522
1523 static void print_pscan_rep_mode(uint8_t pscan_rep_mode)
1524 {
1525         const char *str;
1526
1527         switch (pscan_rep_mode) {
1528         case 0x00:
1529                 str = "R0";
1530                 break;
1531         case 0x01:
1532                 str = "R1";
1533                 break;
1534         case 0x02:
1535                 str = "R2";
1536                 break;
1537         default:
1538                 str = "Reserved";
1539                 break;
1540         }
1541
1542         print_field("Page scan repetition mode: %s (0x%2.2x)",
1543                                                 str, pscan_rep_mode);
1544 }
1545
1546 static void print_pscan_period_mode(uint8_t pscan_period_mode)
1547 {
1548         const char *str;
1549
1550         switch (pscan_period_mode) {
1551         case 0x00:
1552                 str = "P0";
1553                 break;
1554         case 0x01:
1555                 str = "P1";
1556                 break;
1557         case 0x02:
1558                 str = "P2";
1559                 break;
1560         default:
1561                 str = "Reserved";
1562                 break;
1563         }
1564
1565         print_field("Page period mode: %s (0x%2.2x)", str, pscan_period_mode);
1566 }
1567
1568 static void print_pscan_mode(uint8_t pscan_mode)
1569 {
1570         const char *str;
1571
1572         switch (pscan_mode) {
1573         case 0x00:
1574                 str = "Mandatory";
1575                 break;
1576         case 0x01:
1577                 str = "Optional I";
1578                 break;
1579         case 0x02:
1580                 str = "Optional II";
1581                 break;
1582         case 0x03:
1583                 str = "Optional III";
1584                 break;
1585         default:
1586                 str = "Reserved";
1587                 break;
1588         }
1589
1590         print_field("Page scan mode: %s (0x%2.2x)", str, pscan_mode);
1591 }
1592
1593 static void print_clock_offset(uint16_t clock_offset)
1594 {
1595         print_field("Clock offset: 0x%4.4x", le16_to_cpu(clock_offset));
1596 }
1597
1598 static void print_clock(uint32_t clock)
1599 {
1600         print_field("Clock: 0x%8.8x", le32_to_cpu(clock));
1601 }
1602
1603 static void print_clock_type(uint8_t type)
1604 {
1605         const char *str;
1606
1607         switch (type) {
1608         case 0x00:
1609                 str = "Local clock";
1610                 break;
1611         case 0x01:
1612                 str = "Piconet clock";
1613                 break;
1614         default:
1615                 str = "Reserved";
1616                 break;
1617         }
1618
1619         print_field("Type: %s (0x%2.2x)", str, type);
1620 }
1621
1622 static void print_clock_accuracy(uint16_t accuracy)
1623 {
1624         if (le16_to_cpu(accuracy) == 0xffff)
1625                 print_field("Accuracy: Unknown (0x%4.4x)",
1626                                                 le16_to_cpu(accuracy));
1627         else
1628                 print_field("Accuracy: %.4f msec (0x%4.4x)",
1629                                                 le16_to_cpu(accuracy) * 0.3125,
1630                                                 le16_to_cpu(accuracy));
1631 }
1632
1633 static void print_lpo_allowed(uint8_t lpo_allowed)
1634 {
1635         print_field("LPO allowed: 0x%2.2x", lpo_allowed);
1636 }
1637
1638 static void print_broadcast_fragment(uint8_t fragment)
1639 {
1640         const char *str;
1641
1642         switch (fragment) {
1643         case 0x00:
1644                 str = "Continuation fragment";
1645                 break;
1646         case 0x01:
1647                 str = "Starting fragment";
1648                 break;
1649         case 0x02:
1650                 str = "Ending fragment";
1651                 break;
1652         case 0x03:
1653                 str = "No fragmentation";
1654                 break;
1655         default:
1656                 str = "Reserved";
1657                 break;
1658         }
1659
1660         print_field("Fragment: %s (0x%2.2x)", str, fragment);
1661 }
1662
1663 static void print_link_type(uint8_t link_type)
1664 {
1665         const char *str;
1666
1667         switch (link_type) {
1668         case 0x00:
1669                 str = "SCO";
1670                 break;
1671         case 0x01:
1672                 str = "ACL";
1673                 break;
1674         case 0x02:
1675                 str = "eSCO";
1676                 break;
1677         default:
1678                 str = "Reserved";
1679                 break;
1680         }
1681
1682         print_field("Link type: %s (0x%2.2x)", str, link_type);
1683 }
1684
1685 static void print_encr_mode_change(uint8_t encr_mode, uint16_t handle)
1686 {
1687         const char *str;
1688         uint8_t conn_type;
1689
1690         conn_type = get_type(le16_to_cpu(handle));
1691
1692         switch (encr_mode) {
1693         case 0x00:
1694                 str = "Disabled";
1695                 break;
1696         case 0x01:
1697                 switch (conn_type) {
1698                 case 0x00:
1699                         str = "Enabled with E0";
1700                         break;
1701                 case 0x01:
1702                         str = "Enabled with AES-CCM";
1703                         break;
1704                 default:
1705                         str = "Enabled";
1706                         break;
1707                 }
1708                 break;
1709         case 0x02:
1710                 str = "Enabled with AES-CCM";
1711                 break;
1712         default:
1713                 str = "Reserved";
1714                 break;
1715         }
1716
1717         print_field("Encryption: %s (0x%2.2x)", str, encr_mode);
1718 }
1719
1720 static void print_pin_type(uint8_t pin_type)
1721 {
1722         const char *str;
1723
1724         switch (pin_type) {
1725         case 0x00:
1726                 str = "Variable";
1727                 break;
1728         case 0x01:
1729                 str = "Fixed";
1730                 break;
1731         default:
1732                 str = "Reserved";
1733                 break;
1734         }
1735
1736         print_field("PIN type: %s (0x%2.2x)", str, pin_type);
1737 }
1738
1739 static void print_key_flag(uint8_t key_flag)
1740 {
1741         const char *str;
1742
1743         switch (key_flag) {
1744         case 0x00:
1745                 str = "Semi-permanent";
1746                 break;
1747         case 0x01:
1748                 str = "Temporary";
1749                 break;
1750         default:
1751                 str = "Reserved";
1752                 break;
1753         }
1754
1755         print_field("Key flag: %s (0x%2.2x)", str, key_flag);
1756 }
1757
1758 static void print_key_len(uint8_t key_len)
1759 {
1760         const char *str;
1761
1762         switch (key_len) {
1763         case 32:
1764                 str = "802.11 PAL";
1765                 break;
1766         default:
1767                 str = "Reserved";
1768                 break;
1769         }
1770
1771         print_field("Key length: %s (%d)", str, key_len);
1772 }
1773
1774 static void print_key_type(uint8_t key_type)
1775 {
1776         const char *str;
1777
1778         switch (key_type) {
1779         case 0x00:
1780                 str = "Combination key";
1781                 break;
1782         case 0x01:
1783                 str = "Local Unit key";
1784                 break;
1785         case 0x02:
1786                 str = "Remote Unit key";
1787                 break;
1788         case 0x03:
1789                 str = "Debug Combination key";
1790                 break;
1791         case 0x04:
1792                 str = "Unauthenticated Combination key from P-192";
1793                 break;
1794         case 0x05:
1795                 str = "Authenticated Combination key from P-192";
1796                 break;
1797         case 0x06:
1798                 str = "Changed Combination key";
1799                 break;
1800         case 0x07:
1801                 str = "Unauthenticated Combination key from P-256";
1802                 break;
1803         case 0x08:
1804                 str = "Authenticated Combination key from P-256";
1805                 break;
1806         default:
1807                 str = "Reserved";
1808                 break;
1809         }
1810
1811         print_field("Key type: %s (0x%2.2x)", str, key_type);
1812 }
1813
1814 static void print_key_size(uint8_t key_size)
1815 {
1816         print_field("Key size: %d", key_size);
1817 }
1818
1819 static void print_key(const char *label, const uint8_t *link_key)
1820 {
1821         print_hex_field(label, link_key, 16);
1822 }
1823
1824 static void print_link_key(const uint8_t *link_key)
1825 {
1826         print_key("Link key", link_key);
1827 }
1828
1829 static void print_pin_code(const uint8_t *pin_code, uint8_t pin_len)
1830 {
1831         char str[pin_len + 1];
1832         uint8_t i;
1833
1834         for (i = 0; i < pin_len; i++)
1835                 sprintf(str + i, "%c", (const char) pin_code[i]);
1836
1837         print_field("PIN code: %s", str);
1838 }
1839
1840 static void print_hash_p192(const uint8_t *hash)
1841 {
1842         print_key("Hash C from P-192", hash);
1843 }
1844
1845 static void print_hash_p256(const uint8_t *hash)
1846 {
1847         print_key("Hash C from P-256", hash);
1848 }
1849
1850 static void print_randomizer_p192(const uint8_t *randomizer)
1851 {
1852         print_key("Randomizer R with P-192", randomizer);
1853 }
1854
1855 static void print_randomizer_p256(const uint8_t *randomizer)
1856 {
1857         print_key("Randomizer R with P-256", randomizer);
1858 }
1859
1860 static void print_pk256(const char *label, const uint8_t *key)
1861 {
1862         print_field("%s:", label);
1863         print_hex_field("  X", &key[0], 32);
1864         print_hex_field("  Y", &key[32], 32);
1865 }
1866
1867 static void print_dhkey(const uint8_t *dhkey)
1868 {
1869         print_hex_field("Diffie-Hellman key", dhkey, 32);
1870 }
1871
1872 static void print_passkey(uint32_t passkey)
1873 {
1874         print_field("Passkey: %06d", le32_to_cpu(passkey));
1875 }
1876
1877 static void print_io_capability(uint8_t capability)
1878 {
1879         const char *str;
1880
1881         switch (capability) {
1882         case 0x00:
1883                 str = "DisplayOnly";
1884                 break;
1885         case 0x01:
1886                 str = "DisplayYesNo";
1887                 break;
1888         case 0x02:
1889                 str = "KeyboardOnly";
1890                 break;
1891         case 0x03:
1892                 str = "NoInputNoOutput";
1893                 break;
1894         default:
1895                 str = "Reserved";
1896                 break;
1897         }
1898
1899         print_field("IO capability: %s (0x%2.2x)", str, capability);
1900 }
1901
1902 static void print_oob_data(uint8_t oob_data)
1903 {
1904         const char *str;
1905
1906         switch (oob_data) {
1907         case 0x00:
1908                 str = "Authentication data not present";
1909                 break;
1910         case 0x01:
1911                 str = "P-192 authentication data present";
1912                 break;
1913         case 0x02:
1914                 str = "P-256 authentication data present";
1915                 break;
1916         case 0x03:
1917                 str = "P-192 and P-256 authentication data present";
1918                 break;
1919         default:
1920                 str = "Reserved";
1921                 break;
1922         }
1923
1924         print_field("OOB data: %s (0x%2.2x)", str, oob_data);
1925 }
1926
1927 static void print_oob_data_response(uint8_t oob_data)
1928 {
1929         const char *str;
1930
1931         switch (oob_data) {
1932         case 0x00:
1933                 str = "Authentication data not present";
1934                 break;
1935         case 0x01:
1936                 str = "Authentication data present";
1937                 break;
1938         default:
1939                 str = "Reserved";
1940                 break;
1941         }
1942
1943         print_field("OOB data: %s (0x%2.2x)", str, oob_data);
1944 }
1945
1946 static void print_authentication(uint8_t authentication)
1947 {
1948         const char *str;
1949
1950         switch (authentication) {
1951         case 0x00:
1952                 str = "No Bonding - MITM not required";
1953                 break;
1954         case 0x01:
1955                 str = "No Bonding - MITM required";
1956                 break;
1957         case 0x02:
1958                 str = "Dedicated Bonding - MITM not required";
1959                 break;
1960         case 0x03:
1961                 str = "Dedicated Bonding - MITM required";
1962                 break;
1963         case 0x04:
1964                 str = "General Bonding - MITM not required";
1965                 break;
1966         case 0x05:
1967                 str = "General Bonding - MITM required";
1968                 break;
1969         default:
1970                 str = "Reserved";
1971                 break;
1972         }
1973
1974         print_field("Authentication: %s (0x%2.2x)", str, authentication);
1975 }
1976
1977 void packet_print_io_capability(uint8_t capability)
1978 {
1979         print_io_capability(capability);
1980 }
1981
1982 void packet_print_io_authentication(uint8_t authentication)
1983 {
1984         print_authentication(authentication);
1985 }
1986
1987 static void print_location_domain_aware(uint8_t aware)
1988 {
1989         const char *str;
1990
1991         switch (aware) {
1992         case 0x00:
1993                 str = "Regulatory domain unknown";
1994                 break;
1995         case 0x01:
1996                 str = "Regulatory domain known";
1997                 break;
1998         default:
1999                 str = "Reserved";
2000                 break;
2001         }
2002
2003         print_field("Domain aware: %s (0x%2.2x)", str, aware);
2004 }
2005
2006 static void print_location_domain(const uint8_t *domain)
2007 {
2008         print_field("Domain: %c%c (0x%2.2x%2.2x)",
2009                 (char) domain[0], (char) domain[1], domain[0], domain[1]);
2010 }
2011
2012 static void print_location_domain_options(uint8_t options)
2013 {
2014         print_field("Domain options: %c (0x%2.2x)", (char) options, options);
2015 }
2016
2017 static void print_location_options(uint8_t options)
2018 {
2019         print_field("Options: 0x%2.2x", options);
2020 }
2021
2022 static void print_flow_control_mode(uint8_t mode)
2023 {
2024         const char *str;
2025
2026         switch (mode) {
2027         case 0x00:
2028                 str = "Packet based";
2029                 break;
2030         case 0x01:
2031                 str = "Data block based";
2032                 break;
2033         default:
2034                 str = "Reserved";
2035                 break;
2036         }
2037
2038         print_field("Flow control mode: %s (0x%2.2x)", str, mode);
2039 }
2040
2041 static void print_flow_direction(uint8_t direction)
2042 {
2043         const char *str;
2044
2045         switch (direction) {
2046         case 0x00:
2047                 str = "Outgoing";
2048                 break;
2049         case 0x01:
2050                 str = "Incoming";
2051                 break;
2052         default:
2053                 str = "Reserved";
2054                 break;
2055         }
2056
2057         print_field("Flow direction: %s (0x%2.2x)", str, direction);
2058 }
2059
2060 static void print_service_type(uint8_t service_type)
2061 {
2062         const char *str;
2063
2064         switch (service_type) {
2065         case 0x00:
2066                 str = "No Traffic";
2067                 break;
2068         case 0x01:
2069                 str = "Best Effort";
2070                 break;
2071         case 0x02:
2072                 str = "Guaranteed";
2073                 break;
2074         default:
2075                 str = "Reserved";
2076                 break;
2077         }
2078
2079         print_field("Service type: %s (0x%2.2x)", str, service_type);
2080 }
2081
2082 static void print_flow_spec(const char *label, const uint8_t *data)
2083 {
2084         const char *str;
2085
2086         switch (data[1]) {
2087         case 0x00:
2088                 str = "No traffic";
2089                 break;
2090         case 0x01:
2091                 str = "Best effort";
2092                 break;
2093         case 0x02:
2094                 str = "Guaranteed";
2095                 break;
2096         default:
2097                 str = "Reserved";
2098                 break;
2099         }
2100
2101         print_field("%s flow spec: 0x%2.2x", label, data[0]);
2102         print_field("  Service type: %s (0x%2.2x)", str, data[1]);
2103         print_field("  Maximum SDU size: 0x%4.4x", get_le16(data + 2));
2104         print_field("  SDU inter-arrival time: 0x%8.8x", get_le32(data + 4));
2105         print_field("  Access latency: 0x%8.8x", get_le32(data + 8));
2106         print_field("  Flush timeout: 0x%8.8x", get_le32(data + 12));
2107 }
2108
2109 static void print_amp_status(uint8_t amp_status)
2110 {
2111         const char *str;
2112
2113         switch (amp_status) {
2114         case 0x00:
2115                 str = "Present";
2116                 break;
2117         case 0x01:
2118                 str = "Bluetooth only";
2119                 break;
2120         case 0x02:
2121                 str = "No capacity";
2122                 break;
2123         case 0x03:
2124                 str = "Low capacity";
2125                 break;
2126         case 0x04:
2127                 str = "Medium capacity";
2128                 break;
2129         case 0x05:
2130                 str = "High capacity";
2131                 break;
2132         case 0x06:
2133                 str = "Full capacity";
2134                 break;
2135         default:
2136                 str = "Reserved";
2137                 break;
2138         }
2139
2140         print_field("AMP status: %s (0x%2.2x)", str, amp_status);
2141 }
2142
2143 static void print_num_resp(uint8_t num_resp)
2144 {
2145         print_field("Num responses: %d", num_resp);
2146 }
2147
2148 static void print_num_reports(uint8_t num_reports)
2149 {
2150         print_field("Num reports: %d", num_reports);
2151 }
2152
2153 static void print_adv_event_type(const char *label, uint8_t type)
2154 {
2155         const char *str;
2156
2157         switch (type) {
2158         case 0x00:
2159                 str = "Connectable undirected - ADV_IND";
2160                 break;
2161         case 0x01:
2162                 str = "Connectable directed - ADV_DIRECT_IND";
2163                 break;
2164         case 0x02:
2165                 str = "Scannable undirected - ADV_SCAN_IND";
2166                 break;
2167         case 0x03:
2168                 str = "Non connectable undirected - ADV_NONCONN_IND";
2169                 break;
2170         case 0x04:
2171                 str = "Scan response - SCAN_RSP";
2172                 break;
2173         default:
2174                 str = "Reserved";
2175                 break;
2176         }
2177
2178         print_field("%s: %s (0x%2.2x)", label, str, type);
2179 }
2180
2181 static void print_adv_channel_map(const char *label, uint8_t value)
2182 {
2183         const char *str;
2184
2185         switch (value) {
2186         case 0x01:
2187                 str = "37";
2188                 break;
2189         case 0x02:
2190                 str = "38";
2191                 break;
2192         case 0x03:
2193                 str = "37, 38";
2194                 break;
2195         case 0x04:
2196                 str = "39";
2197                 break;
2198         case 0x05:
2199                 str = "37, 39";
2200                 break;
2201         case 0x06:
2202                 str = "38, 39";
2203                 break;
2204         case 0x07:
2205                 str = "37, 38, 39";
2206                 break;
2207         default:
2208                 str = "Reserved";
2209                 break;
2210         }
2211
2212         print_field("%s: %s (0x%2.2x)", label, str, value);
2213 }
2214
2215 static void print_adv_filter_policy(const char *label, uint8_t value)
2216 {
2217         const char *str;
2218
2219         switch (value) {
2220         case 0x00:
2221                 str = "Allow Scan Request from Any, "
2222                         "Allow Connect Request from Any";
2223                 break;
2224         case 0x01:
2225                 str = "Allow Scan Request from Accept List Only, "
2226                         "Allow Connect Request from Any";
2227                 break;
2228         case 0x02:
2229                 str = "Allow Scan Request from Any, "
2230                         "Allow Connect Request from Accept List Only";
2231                 break;
2232         case 0x03:
2233                 str = "Allow Scan Request from Accept List Only, "
2234                         "Allow Connect Request from Accept List Only";
2235                 break;
2236         default:
2237                 str = "Reserved";
2238                 break;
2239         }
2240
2241         print_field("%s: %s (0x%2.2x)", label, str, value);
2242 }
2243
2244 static void print_rssi(int8_t rssi)
2245 {
2246         packet_print_rssi("RSSI", rssi);
2247 }
2248
2249 static void print_slot_625(const char *label, uint16_t value)
2250 {
2251          print_field("%s: %.3f msec (0x%4.4x)", label,
2252                                 le16_to_cpu(value) * 0.625, le16_to_cpu(value));
2253 }
2254
2255 static void print_slot_125(const char *label, uint16_t value)
2256 {
2257         print_field("%s: %.2f msec (0x%4.4x)", label,
2258                                 le16_to_cpu(value) * 1.25, le16_to_cpu(value));
2259 }
2260
2261 static void print_timeout(uint16_t timeout)
2262 {
2263         print_slot_625("Timeout", timeout);
2264 }
2265
2266 static void print_interval(uint16_t interval)
2267 {
2268         print_slot_625("Interval", interval);
2269 }
2270
2271 static void print_window(uint16_t window)
2272 {
2273         print_slot_625("Window", window);
2274 }
2275
2276 static void print_conn_latency(const char *label, uint16_t value)
2277 {
2278         print_field("%s: %u (0x%4.4x)", label, le16_to_cpu(value),
2279                                                         le16_to_cpu(value));
2280 }
2281
2282 static void print_role(uint8_t role)
2283 {
2284         const char *str;
2285
2286         switch (role) {
2287         case 0x00:
2288                 str = "Central";
2289                 break;
2290         case 0x01:
2291                 str = "Peripheral";
2292                 break;
2293         default:
2294                 str = "Reserved";
2295                 break;
2296         }
2297
2298         print_field("Role: %s (0x%2.2x)", str, role);
2299 }
2300
2301 static void print_mode(uint8_t mode)
2302 {
2303         const char *str;
2304
2305         switch (mode) {
2306         case 0x00:
2307                 str = "Active";
2308                 break;
2309         case 0x01:
2310                 str = "Hold";
2311                 break;
2312         case 0x02:
2313                 str = "Sniff";
2314                 break;
2315         case 0x03:
2316                 str = "Park";
2317                 break;
2318         default:
2319                 str = "Reserved";
2320                 break;
2321         }
2322
2323         print_field("Mode: %s (0x%2.2x)", str, mode);
2324 }
2325
2326 static void print_name(const uint8_t *name)
2327 {
2328         char str[249];
2329
2330         memcpy(str, name, 248);
2331         str[248] = '\0';
2332
2333         print_field("Name: %s", str);
2334 }
2335
2336 static void print_channel_map(const uint8_t *map)
2337 {
2338         unsigned int count = 0, start = 0;
2339         char str[21];
2340         int i, n;
2341
2342         for (i = 0; i < 10; i++)
2343                 sprintf(str + (i * 2), "%2.2x", map[i]);
2344
2345         print_field("Channel map: 0x%s", str);
2346
2347         for (i = 0; i < 10; i++) {
2348                 for (n = 0; n < 8; n++) {
2349                         if (map[i] & (1 << n)) {
2350                                 if (count == 0)
2351                                         start = (i * 8) + n;
2352                                 count++;
2353                                 continue;
2354                         }
2355
2356                         if (count > 1) {
2357                                 print_field("  Channel %u-%u",
2358                                                 start, start + count - 1);
2359                                 count = 0;
2360                         } else if (count > 0) {
2361                                 print_field("  Channel %u", start);
2362                                 count = 0;
2363                         }
2364                 }
2365         }
2366 }
2367
2368 void packet_print_channel_map_lmp(const uint8_t *map)
2369 {
2370         print_channel_map(map);
2371 }
2372
2373 static void print_flush_timeout(uint16_t timeout)
2374 {
2375         if (timeout)
2376                 print_timeout(timeout);
2377         else
2378                 print_field("Timeout: No Automatic Flush");
2379 }
2380
2381 void packet_print_version(const char *label, uint8_t version,
2382                                 const char *sublabel, uint16_t subversion)
2383 {
2384         const char *str;
2385
2386         switch (version) {
2387         case 0x00:
2388                 str = "Bluetooth 1.0b";
2389                 break;
2390         case 0x01:
2391                 str = "Bluetooth 1.1";
2392                 break;
2393         case 0x02:
2394                 str = "Bluetooth 1.2";
2395                 break;
2396         case 0x03:
2397                 str = "Bluetooth 2.0";
2398                 break;
2399         case 0x04:
2400                 str = "Bluetooth 2.1";
2401                 break;
2402         case 0x05:
2403                 str = "Bluetooth 3.0";
2404                 break;
2405         case 0x06:
2406                 str = "Bluetooth 4.0";
2407                 break;
2408         case 0x07:
2409                 str = "Bluetooth 4.1";
2410                 break;
2411         case 0x08:
2412                 str = "Bluetooth 4.2";
2413                 break;
2414         case 0x09:
2415                 str = "Bluetooth 5.0";
2416                 break;
2417         case 0x0a:
2418                 str = "Bluetooth 5.1";
2419                 break;
2420         case 0x0b:
2421                 str = "Bluetooth 5.2";
2422                 break;
2423         case 0x0c:
2424                 str = "Bluetooth 5.3";
2425                 break;
2426         default:
2427                 str = "Reserved";
2428                 break;
2429         }
2430
2431         if (sublabel)
2432                 print_field("%s: %s (0x%2.2x) - %s %d (0x%4.4x)",
2433                                         label, str, version,
2434                                         sublabel, subversion, subversion);
2435         else
2436                 print_field("%s: %s (0x%2.2x)", label, str, version);
2437 }
2438
2439 static void print_hci_version(uint8_t version, uint16_t revision)
2440 {
2441         packet_print_version("HCI version", version,
2442                                 "Revision", le16_to_cpu(revision));
2443 }
2444
2445 static void print_lmp_version(uint8_t version, uint16_t subversion)
2446 {
2447         packet_print_version("LMP version", version,
2448                                 "Subversion", le16_to_cpu(subversion));
2449 }
2450
2451 static void print_pal_version(uint8_t version, uint16_t subversion)
2452 {
2453         const char *str;
2454
2455         switch (version) {
2456         case 0x01:
2457                 str = "Bluetooth 3.0";
2458                 break;
2459         default:
2460                 str = "Reserved";
2461                 break;
2462         }
2463
2464         print_field("PAL version: %s (0x%2.2x) - Subversion %d (0x%4.4x)",
2465                                                 str, version,
2466                                                 le16_to_cpu(subversion),
2467                                                 le16_to_cpu(subversion));
2468 }
2469
2470 void packet_print_company(const char *label, uint16_t company)
2471 {
2472         print_field("%s: %s (%d)", label, bt_compidtostr(company), company);
2473 }
2474
2475 static void print_manufacturer(uint16_t manufacturer)
2476 {
2477         packet_print_company("Manufacturer", le16_to_cpu(manufacturer));
2478 }
2479
2480 static const struct {
2481         uint16_t ver;
2482         const char *str;
2483 } broadcom_uart_subversion_table[] = {
2484         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
2485         { 0x410e, "BCM43341B0"  },      /* 002.001.014 */
2486         { 0x4406, "BCM4324B3"   },      /* 002.004.006 */
2487         { }
2488 };
2489
2490 static const struct {
2491         uint16_t ver;
2492         const char *str;
2493 } broadcom_usb_subversion_table[] = {
2494         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
2495         { 0x2112, "BCM4314A0"   },      /* 001.001.018 */
2496         { 0x2118, "BCM20702A0"  },      /* 001.001.024 */
2497         { 0x2126, "BCM4335A0"   },      /* 001.001.038 */
2498         { 0x220e, "BCM20702A1"  },      /* 001.002.014 */
2499         { 0x230f, "BCM4354A2"   },      /* 001.003.015 */
2500         { 0x4106, "BCM4335B0"   },      /* 002.001.006 */
2501         { 0x410e, "BCM20702B0"  },      /* 002.001.014 */
2502         { 0x6109, "BCM4335C0"   },      /* 003.001.009 */
2503         { 0x610c, "BCM4354"     },      /* 003.001.012 */
2504         { }
2505 };
2506
2507 static void print_manufacturer_broadcom(uint16_t subversion, uint16_t revision)
2508 {
2509         uint16_t ver = le16_to_cpu(subversion);
2510         uint16_t rev = le16_to_cpu(revision);
2511         const char *str = NULL;
2512         int i;
2513
2514         switch ((rev & 0xf000) >> 12) {
2515         case 0:
2516         case 3:
2517                 for (i = 0; broadcom_uart_subversion_table[i].str; i++) {
2518                         if (broadcom_uart_subversion_table[i].ver == ver) {
2519                                 str = broadcom_uart_subversion_table[i].str;
2520                                 break;
2521                         }
2522                 }
2523                 break;
2524         case 1:
2525         case 2:
2526                 for (i = 0; broadcom_usb_subversion_table[i].str; i++) {
2527                         if (broadcom_usb_subversion_table[i].ver == ver) {
2528                                 str = broadcom_usb_subversion_table[i].str;
2529                                 break;
2530                         }
2531                 }
2532                 break;
2533         }
2534
2535         if (str)
2536                 print_field("  Firmware: %3.3u.%3.3u.%3.3u (%s)",
2537                                 (ver & 0xe000) >> 13,
2538                                 (ver & 0x1f00) >> 8, ver & 0x00ff, str);
2539         else
2540                 print_field("  Firmware: %3.3u.%3.3u.%3.3u",
2541                                 (ver & 0xe000) >> 13,
2542                                 (ver & 0x1f00) >> 8, ver & 0x00ff);
2543
2544         if (rev != 0xffff)
2545                 print_field("  Build: %4.4u", rev & 0x0fff);
2546 }
2547
2548 static const char *get_supported_command(int bit);
2549
2550 static void print_commands(const uint8_t *commands)
2551 {
2552         unsigned int count = 0;
2553         int i, n;
2554
2555         for (i = 0; i < 64; i++) {
2556                 for (n = 0; n < 8; n++) {
2557                         if (commands[i] & (1 << n))
2558                                 count++;
2559                 }
2560         }
2561
2562         print_field("Commands: %u entr%s", count, count == 1 ? "y" : "ies");
2563
2564         for (i = 0; i < 64; i++) {
2565                 for (n = 0; n < 8; n++) {
2566                         const char *cmd;
2567
2568                         if (!(commands[i] & (1 << n)))
2569                                 continue;
2570
2571                         cmd = get_supported_command((i * 8) + n);
2572                         if (cmd)
2573                                 print_field("  %s (Octet %d - Bit %d)",
2574                                                                 cmd, i, n);
2575                         else
2576                                 print_text(COLOR_UNKNOWN_COMMAND_BIT,
2577                                                 "  Octet %d - Bit %d ", i, n);
2578                 }
2579         }
2580 }
2581
2582 static const struct bitfield_data features_page0[] = {
2583         {  0, "3 slot packets"                          },
2584         {  1, "5 slot packets"                          },
2585         {  2, "Encryption"                              },
2586         {  3, "Slot offset"                             },
2587         {  4, "Timing accuracy"                         },
2588         {  5, "Role switch"                             },
2589         {  6, "Hold mode"                               },
2590         {  7, "Sniff mode"                              },
2591         {  8, "Park state"                              },
2592         {  9, "Power control requests"                  },
2593         { 10, "Channel quality driven data rate (CQDDR)"},
2594         { 11, "SCO link"                                },
2595         { 12, "HV2 packets"                             },
2596         { 13, "HV3 packets"                             },
2597         { 14, "u-law log synchronous data"              },
2598         { 15, "A-law log synchronous data"              },
2599         { 16, "CVSD synchronous data"                   },
2600         { 17, "Paging parameter negotiation"            },
2601         { 18, "Power control"                           },
2602         { 19, "Transparent synchronous data"            },
2603         { 20, "Flow control lag (least significant bit)"},
2604         { 21, "Flow control lag (middle bit)"           },
2605         { 22, "Flow control lag (most significant bit)" },
2606         { 23, "Broadcast Encryption"                    },
2607         { 25, "Enhanced Data Rate ACL 2 Mbps mode"      },
2608         { 26, "Enhanced Data Rate ACL 3 Mbps mode"      },
2609         { 27, "Enhanced inquiry scan"                   },
2610         { 28, "Interlaced inquiry scan"                 },
2611         { 29, "Interlaced page scan"                    },
2612         { 30, "RSSI with inquiry results"               },
2613         { 31, "Extended SCO link (EV3 packets)"         },
2614         { 32, "EV4 packets"                             },
2615         { 33, "EV5 packets"                             },
2616         { 35, "AFH capable peripheral"                  },
2617         { 36, "AFH classification peripheral"           },
2618         { 37, "BR/EDR Not Supported"                    },
2619         { 38, "LE Supported (Controller)"               },
2620         { 39, "3-slot Enhanced Data Rate ACL packets"   },
2621         { 40, "5-slot Enhanced Data Rate ACL packets"   },
2622         { 41, "Sniff subrating"                         },
2623         { 42, "Pause encryption"                        },
2624         { 43, "AFH capable central"                     },
2625         { 44, "AFH classification central"              },
2626         { 45, "Enhanced Data Rate eSCO 2 Mbps mode"     },
2627         { 46, "Enhanced Data Rate eSCO 3 Mbps mode"     },
2628         { 47, "3-slot Enhanced Data Rate eSCO packets"  },
2629         { 48, "Extended Inquiry Response"               },
2630         { 49, "Simultaneous LE and BR/EDR (Controller)" },
2631         { 51, "Secure Simple Pairing"                   },
2632         { 52, "Encapsulated PDU"                        },
2633         { 53, "Erroneous Data Reporting"                },
2634         { 54, "Non-flushable Packet Boundary Flag"      },
2635         { 56, "Link Supervision Timeout Changed Event"  },
2636         { 57, "Inquiry TX Power Level"                  },
2637         { 58, "Enhanced Power Control"                  },
2638         { 63, "Extended features"                       },
2639         { }
2640 };
2641
2642 static const struct bitfield_data features_page1[] = {
2643         {  0, "Secure Simple Pairing (Host Support)"    },
2644         {  1, "LE Supported (Host)"                     },
2645         {  2, "Simultaneous LE and BR/EDR (Host)"       },
2646         {  3, "Secure Connections (Host Support)"       },
2647         { }
2648 };
2649
2650 static const struct bitfield_data features_page2[] = {
2651         {  0, "Connectionless Peripheral Broadcast - Central"   },
2652         {  1, "Connectionless Peripheral Broadcast - Peripheral"},
2653         {  2, "Synchronization Train"                           },
2654         {  3, "Synchronization Scan"                            },
2655         {  4, "Inquiry Response Notification Event"             },
2656         {  5, "Generalized interlaced scan"                     },
2657         {  6, "Coarse Clock Adjustment"                         },
2658         {  8, "Secure Connections (Controller Support)"         },
2659         {  9, "Ping"                                            },
2660         { 10, "Slot Availability Mask"                          },
2661         { 11, "Train nudging"                                   },
2662         { }
2663 };
2664
2665 static const struct bitfield_data features_le[] = {
2666         {  0, "LE Encryption"                                   },
2667         {  1, "Connection Parameter Request Procedure"          },
2668         {  2, "Extended Reject Indication"                      },
2669         {  3, "Peripheral-initiated Features Exchange"          },
2670         {  4, "LE Ping"                                         },
2671         {  5, "LE Data Packet Length Extension"                 },
2672         {  6, "LL Privacy"                                      },
2673         {  7, "Extended Scanner Filter Policies"                },
2674         {  8, "LE 2M PHY"                                       },
2675         {  9, "Stable Modulation Index - Transmitter"           },
2676         { 10, "Stable Modulation Index - Receiver"              },
2677         { 11, "LE Coded PHY"                                    },
2678         { 12, "LE Extended Advertising"                         },
2679         { 13, "LE Periodic Advertising"                         },
2680         { 14, "Channel Selection Algorithm #2"                  },
2681         { 15, "LE Power Class 1"                                },
2682         { 16, "Minimum Number of Used Channels Procedure"       },
2683         { 17, "Connection CTE Request"                          },
2684         { 18, "Connection CTE Response"                         },
2685         { 19, "Connectionless CTE Transmitter"                  },
2686         { 20, "Connectionless CTE Receiver"                     },
2687         { 21, "Antenna Switching During CTE Transmission (AoD)" },
2688         { 22, "Antenna Switching During CTE Reception (AoA)"    },
2689         { 23, "Receiving Constant Tone Extensions"              },
2690         { 24, "Periodic Advertising Sync Transfer - Sender"     },
2691         { 25, "Periodic Advertising Sync Transfer - Recipient"  },
2692         { 26, "Sleep Clock Accuracy Updates"                    },
2693         { 27, "Remote Public Key Validation"                    },
2694         { 28, "Connected Isochronous Stream - Central"          },
2695         { 29, "Connected Isochronous Stream - Peripheral"       },
2696         { 30, "Isochronous Broadcaster"                         },
2697         { 31, "Synchronized Receiver"                           },
2698         { 32, "Isochronous Channels (Host Support)"             },
2699         { 33, "LE Power Control Request"                        },
2700         { 34, "LE Power Control Request"                        },
2701         { 35, "LE Path Loss Monitoring"                         },
2702         { 36, "Periodic Advertising ADI support"                },
2703         { 37, "Connection Subrating"                            },
2704         { 38, "Connection Subrating (Host Support)"             },
2705         { 39, "Channel Classification"                          },
2706         { }
2707 };
2708
2709 static const struct bitfield_data features_msft[] = {
2710         {  0, "RSSI Monitoring feature for BR/EDR"              },
2711         {  1, "RSSI Monitoring feature for LE connections"      },
2712         {  2, "RSSI Monitoring of LE advertisements"            },
2713         {  3, "Advertising Monitoring of LE advertisements"     },
2714         {  4, "Verifying the validity of P-192 and P-256 keys"  },
2715         {  5, "Continuous Advertising Monitoring"               },
2716         { }
2717 };
2718
2719 static void print_features(uint8_t page, const uint8_t *features_array,
2720                                                                 uint8_t type)
2721 {
2722         const struct bitfield_data *features_table = NULL;
2723         uint64_t mask, features = 0;
2724         char str[41];
2725         int i;
2726
2727         for (i = 0; i < 8; i++) {
2728                 sprintf(str + (i * 5), " 0x%2.2x", features_array[i]);
2729                 features |= ((uint64_t) features_array[i]) << (i * 8);
2730         }
2731
2732         print_field("Features:%s", str);
2733
2734         switch (type) {
2735         case 0x00:
2736                 switch (page) {
2737                 case 0:
2738                         features_table = features_page0;
2739                         break;
2740                 case 1:
2741                         features_table = features_page1;
2742                         break;
2743                 case 2:
2744                         features_table = features_page2;
2745                         break;
2746                 }
2747                 break;
2748         case 0x01:
2749                 switch (page) {
2750                 case 0:
2751                         features_table = features_le;
2752                         break;
2753                 }
2754                 break;
2755         case 0xf0:
2756                 switch (page) {
2757                 case 0:
2758                         features_table = features_msft;
2759                         break;
2760                 }
2761                 break;
2762         }
2763
2764         if (!features_table)
2765                 return;
2766
2767         mask = print_bitfield(2, features, features_table);
2768         if (mask)
2769                 print_text(COLOR_UNKNOWN_FEATURE_BIT, "  Unknown features "
2770                                                 "(0x%16.16" PRIx64 ")", mask);
2771 }
2772
2773 void packet_print_features_lmp(const uint8_t *features, uint8_t page)
2774 {
2775         print_features(page, features, 0x00);
2776 }
2777
2778 void packet_print_features_ll(const uint8_t *features)
2779 {
2780         print_features(0, features, 0x01);
2781 }
2782
2783 void packet_print_features_msft(const uint8_t *features)
2784 {
2785         print_features(0, features, 0xf0);
2786 }
2787
2788 #define LE_STATE_SCAN_ADV               0x0001
2789 #define LE_STATE_CONN_ADV               0x0002
2790 #define LE_STATE_NONCONN_ADV            0x0004
2791 #define LE_STATE_HIGH_DIRECT_ADV        0x0008
2792 #define LE_STATE_LOW_DIRECT_ADV         0x0010
2793 #define LE_STATE_ACTIVE_SCAN            0x0020
2794 #define LE_STATE_PASSIVE_SCAN           0x0040
2795 #define LE_STATE_INITIATING             0x0080
2796 #define LE_STATE_CONN_CENTRAL           0x0100
2797 #define LE_STATE_CONN_PERIPHERAL        0x0200
2798 #define LE_STATE_CENTRAL_CENTRAL        0x0400
2799 #define LE_STATE_PERIPHERAL_PERIPHERAL  0x0800
2800 #define LE_STATE_CENTRAL_PERIPHERAL     0x1000
2801
2802 static const struct bitfield_data le_states_desc_table[] = {
2803         {  0, "Scannable Advertising State"                     },
2804         {  1, "Connectable Advertising State"                   },
2805         {  2, "Non-connectable Advertising State"               },
2806         {  3, "High Duty Cycle Directed Advertising State"      },
2807         {  4, "Low Duty Cycle Directed Advertising State"       },
2808         {  5, "Active Scanning State"                           },
2809         {  6, "Passive Scanning State"                          },
2810         {  7, "Initiating State"                                },
2811         {  8, "Connection State (Central Role)"                 },
2812         {  9, "Connection State (Peripheral Role)"              },
2813         { 10, "Central Role & Central Role"                     },
2814         { 11, "Peripheral Role & Peripheral Role"               },
2815         { 12, "Central Role & Peripheral Role"                  },
2816         { }
2817 };
2818
2819 static const struct {
2820         uint8_t bit;
2821         uint16_t states;
2822 } le_states_comb_table[] = {
2823         {  0, LE_STATE_NONCONN_ADV                                      },
2824         {  1, LE_STATE_SCAN_ADV                                         },
2825         {  2, LE_STATE_CONN_ADV                                         },
2826         {  3, LE_STATE_HIGH_DIRECT_ADV                                  },
2827         {  4, LE_STATE_PASSIVE_SCAN                                     },
2828         {  5, LE_STATE_ACTIVE_SCAN                                      },
2829         {  6, LE_STATE_INITIATING | LE_STATE_CONN_CENTRAL               },
2830         {  7, LE_STATE_CONN_PERIPHERAL                                  },
2831         {  8, LE_STATE_PASSIVE_SCAN | LE_STATE_NONCONN_ADV              },
2832         {  9, LE_STATE_PASSIVE_SCAN | LE_STATE_SCAN_ADV                 },
2833         { 10, LE_STATE_PASSIVE_SCAN | LE_STATE_CONN_ADV                 },
2834         { 11, LE_STATE_PASSIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV          },
2835         { 12, LE_STATE_ACTIVE_SCAN | LE_STATE_NONCONN_ADV               },
2836         { 13, LE_STATE_ACTIVE_SCAN | LE_STATE_SCAN_ADV                  },
2837         { 14, LE_STATE_ACTIVE_SCAN | LE_STATE_CONN_ADV                  },
2838         { 15, LE_STATE_ACTIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV           },
2839         { 16, LE_STATE_INITIATING | LE_STATE_NONCONN_ADV                },
2840         { 17, LE_STATE_INITIATING | LE_STATE_SCAN_ADV                   },
2841         { 18, LE_STATE_CONN_CENTRAL | LE_STATE_NONCONN_ADV              },
2842         { 19, LE_STATE_CONN_CENTRAL | LE_STATE_SCAN_ADV                 },
2843         { 20, LE_STATE_CONN_PERIPHERAL | LE_STATE_NONCONN_ADV           },
2844         { 21, LE_STATE_CONN_PERIPHERAL | LE_STATE_SCAN_ADV              },
2845         { 22, LE_STATE_INITIATING | LE_STATE_PASSIVE_SCAN               },
2846         { 23, LE_STATE_INITIATING | LE_STATE_ACTIVE_SCAN                },
2847         { 24, LE_STATE_CONN_CENTRAL | LE_STATE_PASSIVE_SCAN             },
2848         { 25, LE_STATE_CONN_CENTRAL | LE_STATE_ACTIVE_SCAN              },
2849         { 26, LE_STATE_CONN_PERIPHERAL | LE_STATE_PASSIVE_SCAN          },
2850         { 27, LE_STATE_CONN_PERIPHERAL | LE_STATE_ACTIVE_SCAN           },
2851         { 28, LE_STATE_INITIATING | LE_STATE_CONN_CENTRAL |
2852                                         LE_STATE_CENTRAL_CENTRAL        },
2853         { 29, LE_STATE_LOW_DIRECT_ADV                                   },
2854         { 30, LE_STATE_LOW_DIRECT_ADV | LE_STATE_PASSIVE_SCAN           },
2855         { 31, LE_STATE_LOW_DIRECT_ADV | LE_STATE_ACTIVE_SCAN            },
2856         { 32, LE_STATE_INITIATING | LE_STATE_CONN_ADV |
2857                                         LE_STATE_CENTRAL_PERIPHERAL     },
2858         { 33, LE_STATE_INITIATING | LE_STATE_HIGH_DIRECT_ADV |
2859                                         LE_STATE_CENTRAL_PERIPHERAL     },
2860         { 34, LE_STATE_INITIATING | LE_STATE_LOW_DIRECT_ADV |
2861                                         LE_STATE_CENTRAL_PERIPHERAL     },
2862         { 35, LE_STATE_CONN_CENTRAL | LE_STATE_CONN_ADV |
2863                                         LE_STATE_CENTRAL_PERIPHERAL     },
2864         { 36, LE_STATE_CONN_CENTRAL | LE_STATE_HIGH_DIRECT_ADV |
2865                                         LE_STATE_CENTRAL_PERIPHERAL     },
2866         { 37, LE_STATE_CONN_CENTRAL | LE_STATE_LOW_DIRECT_ADV |
2867                                         LE_STATE_CENTRAL_PERIPHERAL     },
2868         { 38, LE_STATE_CONN_PERIPHERAL | LE_STATE_CONN_ADV |
2869                                         LE_STATE_CENTRAL_PERIPHERAL     },
2870         { 39, LE_STATE_CONN_PERIPHERAL | LE_STATE_HIGH_DIRECT_ADV |
2871                                         LE_STATE_PERIPHERAL_PERIPHERAL  },
2872         { 40, LE_STATE_CONN_PERIPHERAL | LE_STATE_LOW_DIRECT_ADV |
2873                                         LE_STATE_PERIPHERAL_PERIPHERAL  },
2874         { 41, LE_STATE_INITIATING | LE_STATE_CONN_PERIPHERAL |
2875                                         LE_STATE_CENTRAL_PERIPHERAL     },
2876         { }
2877 };
2878
2879 static void print_le_states(const uint8_t *states_array)
2880 {
2881         uint64_t mask, states = 0;
2882         int i = 0;
2883         size_t n = 0;
2884
2885         for (i = 0; i < 8; i++)
2886                 states |= ((uint64_t) states_array[i]) << (i * 8);
2887
2888         print_field("States: 0x%16.16" PRIx64, states);
2889
2890         mask = states;
2891
2892         for (i = 0; le_states_comb_table[i].states; i++) {
2893                 uint64_t val = (((uint64_t) 1) << le_states_comb_table[i].bit);
2894                 const char *str[3] = { NULL, };
2895                 size_t num = 0;
2896
2897                 if (!(states & val))
2898                         continue;
2899
2900                 for (n = 0; n < ARRAY_SIZE(le_states_desc_table); n++) {
2901                         if (le_states_comb_table[i].states & (1 << n))
2902                                 str[num++] = le_states_desc_table[n].str;
2903                 }
2904
2905                 if (num > 0) {
2906                         print_field("  %s", str[0]);
2907                         for (n = 1; n < num; n++)
2908                                 print_field("    and %s", str[n]);
2909                 }
2910
2911                 mask &= ~val;
2912         }
2913
2914         if (mask)
2915                 print_text(COLOR_UNKNOWN_LE_STATES, "  Unknown states "
2916                                                 "(0x%16.16" PRIx64 ")", mask);
2917 }
2918
2919 static void print_le_channel_map(const uint8_t *map)
2920 {
2921         unsigned int count = 0, start = 0;
2922         char str[11];
2923         int i, n;
2924
2925         for (i = 0; i < 5; i++)
2926                 sprintf(str + (i * 2), "%2.2x", map[i]);
2927
2928         print_field("Channel map: 0x%s", str);
2929
2930         for (i = 0; i < 5; i++) {
2931                 for (n = 0; n < 8; n++) {
2932                         if (map[i] & (1 << n)) {
2933                                 if (count == 0)
2934                                         start = (i * 8) + n;
2935                                 count++;
2936                                 continue;
2937                         }
2938
2939                         if (count > 1) {
2940                                 print_field("  Channel %u-%u",
2941                                                 start, start + count - 1);
2942                                 count = 0;
2943                         } else if (count > 0) {
2944                                 print_field("  Channel %u", start);
2945                                 count = 0;
2946                         }
2947                 }
2948         }
2949 }
2950
2951 void packet_print_channel_map_ll(const uint8_t *map)
2952 {
2953         print_le_channel_map(map);
2954 }
2955
2956 static void print_random_number(uint64_t rand)
2957 {
2958         print_field("Random number: 0x%16.16" PRIx64, le64_to_cpu(rand));
2959 }
2960
2961 static void print_encrypted_diversifier(uint16_t ediv)
2962 {
2963         print_field("Encrypted diversifier: 0x%4.4x", le16_to_cpu(ediv));
2964 }
2965
2966 static const struct bitfield_data events_table[] = {
2967         {  0, "Inquiry Complete"                                        },
2968         {  1, "Inquiry Result"                                          },
2969         {  2, "Connection Complete"                                     },
2970         {  3, "Connection Request"                                      },
2971         {  4, "Disconnection Complete"                                  },
2972         {  5, "Authentication Complete"                                 },
2973         {  6, "Remote Name Request Complete"                            },
2974         {  7, "Encryption Change"                                       },
2975         {  8, "Change Connection Link Key Complete"                     },
2976         {  9, "Link Key Type Changed"                                   },
2977         { 10, "Read Remote Supported Features Complete"                 },
2978         { 11, "Read Remote Version Information Complete"                },
2979         { 12, "QoS Setup Complete"                                      },
2980         { 13, "Command Complete"                                        },
2981         { 14, "Command Status"                                          },
2982         { 15, "Hardware Error"                                          },
2983         { 16, "Flush Occurred"                                          },
2984         { 17, "Role Change"                                             },
2985         { 18, "Number of Completed Packets"                             },
2986         { 19, "Mode Change"                                             },
2987         { 20, "Return Link Keys"                                        },
2988         { 21, "PIN Code Request"                                        },
2989         { 22, "Link Key Request"                                        },
2990         { 23, "Link Key Notification"                                   },
2991         { 24, "Loopback Command"                                        },
2992         { 25, "Data Buffer Overflow"                                    },
2993         { 26, "Max Slots Change"                                        },
2994         { 27, "Read Clock Offset Complete"                              },
2995         { 28, "Connection Packet Type Changed"                          },
2996         { 29, "QoS Violation"                                           },
2997         { 30, "Page Scan Mode Change"                                   },
2998         { 31, "Page Scan Repetition Mode Change"                        },
2999         { 32, "Flow Specification Complete"                             },
3000         { 33, "Inquiry Result with RSSI"                                },
3001         { 34, "Read Remote Extended Features Complete"                  },
3002         { 43, "Synchronous Connection Complete"                         },
3003         { 44, "Synchronous Connection Changed"                          },
3004         { 45, "Sniff Subrating"                                         },
3005         { 46, "Extended Inquiry Result"                                 },
3006         { 47, "Encryption Key Refresh Complete"                         },
3007         { 48, "IO Capability Request"                                   },
3008         { 49, "IO Capability Request Reply"                             },
3009         { 50, "User Confirmation Request"                               },
3010         { 51, "User Passkey Request"                                    },
3011         { 52, "Remote OOB Data Request"                                 },
3012         { 53, "Simple Pairing Complete"                                 },
3013         { 55, "Link Supervision Timeout Changed"                        },
3014         { 56, "Enhanced Flush Complete"                                 },
3015         { 58, "User Passkey Notification"                               },
3016         { 59, "Keypress Notification"                                   },
3017         { 60, "Remote Host Supported Features Notification"             },
3018         { 61, "LE Meta"                                                 },
3019         { }
3020 };
3021
3022 static void print_event_mask(const uint8_t *events_array,
3023                                         const struct bitfield_data *table)
3024 {
3025         uint64_t mask, events = 0;
3026         int i;
3027
3028         for (i = 0; i < 8; i++)
3029                 events |= ((uint64_t) events_array[i]) << (i * 8);
3030
3031         print_field("Mask: 0x%16.16" PRIx64, events);
3032
3033         mask = print_bitfield(2, events, table);
3034         if (mask)
3035                 print_text(COLOR_UNKNOWN_EVENT_MASK, "  Unknown mask "
3036                                                 "(0x%16.16" PRIx64 ")", mask);
3037 }
3038
3039 static const struct bitfield_data events_page2_table[] = {
3040         {  0, "Physical Link Complete"                                  },
3041         {  1, "Channel Selected"                                        },
3042         {  2, "Disconnection Physical Link Complete"                    },
3043         {  3, "Physical Link Loss Early Warning"                        },
3044         {  4, "Physical Link Recovery"                                  },
3045         {  5, "Logical Link Complete"                                   },
3046         {  6, "Disconnection Logical Link Complete"                     },
3047         {  7, "Flow Specification Modify Complete"                      },
3048         {  8, "Number of Completed Data Blocks"                         },
3049         {  9, "AMP Start Test"                                          },
3050         { 10, "AMP Test End"                                            },
3051         { 11, "AMP Receiver Report"                                     },
3052         { 12, "Short Range Mode Change Complete"                        },
3053         { 13, "AMP Status Change"                                       },
3054         { 14, "Triggered Clock Capture"                                 },
3055         { 15, "Synchronization Train Complete"                          },
3056         { 16, "Synchronization Train Received"                          },
3057         { 17, "Connectionless Peripheral Broadcast Receive"             },
3058         { 18, "Connectionless Peripheral Broadcast Timeout"             },
3059         { 19, "Truncated Page Complete"                                 },
3060         { 20, "Peripheral Page Response Timeout"                        },
3061         { 21, "Connectionless Peripheral Broadcast Channel Map Change"  },
3062         { 22, "Inquiry Response Notification"                           },
3063         { 23, "Authenticated Payload Timeout Expired"                   },
3064         { 24, "SAM Status Change"                                       },
3065         { }
3066 };
3067
3068 static const struct bitfield_data events_le_table[] = {
3069         {  0, "LE Connection Complete"                  },
3070         {  1, "LE Advertising Report"                   },
3071         {  2, "LE Connection Update Complete"           },
3072         {  3, "LE Read Remote Used Features Complete"   },
3073         {  4, "LE Long Term Key Request"                },
3074         {  5, "LE Remote Connection Parameter Request"  },
3075         {  6, "LE Data Length Change"                   },
3076         {  7, "LE Read Local P-256 Public Key Complete" },
3077         {  8, "LE Generate DHKey Complete"              },
3078         {  9, "LE Enhanced Connection Complete"         },
3079         { 10, "LE Direct Advertising Report"            },
3080         { 11, "LE PHY Update Complete"                  },
3081         { 12, "LE Extended Advertising Report"          },
3082         { 13, "LE Periodic Advertising Sync Established"},
3083         { 14, "LE Periodic Advertising Report"          },
3084         { 15, "LE Periodic Advertising Sync Lost"       },
3085         { 16, "LE Extended Scan Timeout"                },
3086         { 17, "LE Extended Advertising Set Terminated"  },
3087         { 18, "LE Scan Request Received"                },
3088         { 19, "LE Channel Selection Algorithm"          },
3089         { 24, "LE CIS Established"                      },
3090         { 25, "LE CIS Request"                          },
3091         { 26, "LE Create BIG Complete"                  },
3092         { 27, "LE Terminate BIG Complete"               },
3093         { 28, "LE BIG Sync Estabilished Complete"       },
3094         { 29, "LE BIG Sync Lost"                        },
3095         { 30, "LE Request Peer SCA Complete"},
3096         { 31, "LE Path Loss Threshold"          },
3097         { 32, "LE Transmit Power Reporting"     },
3098         { 33, "LE BIG Info Advertising Report"  },
3099         { 34, "LE Subrate Change"                       },
3100         { }
3101 };
3102
3103 static void print_fec(uint8_t fec)
3104 {
3105         const char *str;
3106
3107         switch (fec) {
3108         case 0x00:
3109                 str = "Not required";
3110                 break;
3111         case 0x01:
3112                 str = "Required";
3113                 break;
3114         default:
3115                 str = "Reserved";
3116                 break;
3117         }
3118
3119         print_field("FEC: %s (0x%02x)", str, fec);
3120 }
3121
3122 #define BT_EIR_FLAGS                    0x01
3123 #define BT_EIR_UUID16_SOME              0x02
3124 #define BT_EIR_UUID16_ALL               0x03
3125 #define BT_EIR_UUID32_SOME              0x04
3126 #define BT_EIR_UUID32_ALL               0x05
3127 #define BT_EIR_UUID128_SOME             0x06
3128 #define BT_EIR_UUID128_ALL              0x07
3129 #define BT_EIR_NAME_SHORT               0x08
3130 #define BT_EIR_NAME_COMPLETE            0x09
3131 #define BT_EIR_TX_POWER                 0x0a
3132 #define BT_EIR_CLASS_OF_DEV             0x0d
3133 #define BT_EIR_SSP_HASH_P192            0x0e
3134 #define BT_EIR_SSP_RANDOMIZER_P192      0x0f
3135 #define BT_EIR_DEVICE_ID                0x10
3136 #define BT_EIR_SMP_TK                   0x10
3137 #define BT_EIR_SMP_OOB_FLAGS            0x11
3138 #define BT_EIR_PERIPHERAL_CONN_INTERVAL 0x12
3139 #define BT_EIR_SERVICE_UUID16           0x14
3140 #define BT_EIR_SERVICE_UUID128          0x15
3141 #define BT_EIR_SERVICE_DATA             0x16
3142 #define BT_EIR_PUBLIC_ADDRESS           0x17
3143 #define BT_EIR_RANDOM_ADDRESS           0x18
3144 #define BT_EIR_GAP_APPEARANCE           0x19
3145 #define BT_EIR_ADVERTISING_INTERVAL     0x1a
3146 #define BT_EIR_LE_DEVICE_ADDRESS        0x1b
3147 #define BT_EIR_LE_ROLE                  0x1c
3148 #define BT_EIR_SSP_HASH_P256            0x1d
3149 #define BT_EIR_SSP_RANDOMIZER_P256      0x1e
3150 #define BT_EIR_SERVICE_UUID32           0x1f
3151 #define BT_EIR_SERVICE_DATA32           0x20
3152 #define BT_EIR_SERVICE_DATA128          0x21
3153 #define BT_EIR_LE_SC_CONFIRM_VALUE      0x22
3154 #define BT_EIR_LE_SC_RANDOM_VALUE       0x23
3155 #define BT_EIR_URI                      0x24
3156 #define BT_EIR_INDOOR_POSITIONING       0x25
3157 #define BT_EIR_TRANSPORT_DISCOVERY      0x26
3158 #define BT_EIR_LE_SUPPORTED_FEATURES    0x27
3159 #define BT_EIR_CHANNEL_MAP_UPDATE_IND   0x28
3160 #define BT_EIR_MESH_PROV                0x29
3161 #define BT_EIR_MESH_DATA                0x2a
3162 #define BT_EIR_MESH_BEACON              0x2b
3163 #define BT_EIR_CSIP_RSI                 0x2e
3164 #define BT_EIR_3D_INFO_DATA             0x3d
3165 #define BT_EIR_MANUFACTURER_DATA        0xff
3166
3167 static void print_manufacturer_apple(const void *data, uint8_t data_len)
3168 {
3169         uint8_t type = *((uint8_t *) data);
3170
3171         if (data_len < 1)
3172                 return;
3173
3174         if (type == 0x01) {
3175                 char identifier[100];
3176
3177                 snprintf(identifier, sizeof(identifier) - 1, "%s",
3178                                                 (const char *) (data + 1));
3179
3180                 print_field("  Identifier: %s", identifier);
3181                 return;
3182         }
3183
3184         while (data_len > 0) {
3185                 uint8_t len;
3186                 const char *str;
3187
3188                 type = *((uint8_t *) data);
3189                 data++;
3190                 data_len--;
3191
3192                 if (type == 0x00)
3193                         continue;
3194
3195                 if (data_len < 1)
3196                         break;
3197
3198                 switch (type) {
3199                 case 0x02:
3200                         str = "iBeacon";
3201                         break;
3202                 case 0x05:
3203                         str = "AirDrop";
3204                         break;
3205                 case 0x09:
3206                         str = "Apple TV";
3207                         break;
3208                 default:
3209                         str = "Unknown";
3210                         break;
3211                 }
3212
3213                 print_field("  Type: %s (%u)", str, type);
3214
3215                 len = *((uint8_t *) data);
3216                 data++;
3217                 data_len--;
3218
3219                 if (len < 1)
3220                         continue;
3221
3222                 if (len > data_len)
3223                         break;
3224
3225                 if (type == 0x02 && len == 0x15) {
3226                         const uint8_t *uuid;
3227                         uint16_t minor, major;
3228                         int8_t tx_power;
3229
3230                         uuid = data;
3231                         print_field("  UUID: %8.8x-%4.4x-%4.4x-%4.4x-%8.8x%4.4x",
3232                                 get_le32(&uuid[12]), get_le16(&uuid[10]),
3233                                 get_le16(&uuid[8]), get_le16(&uuid[6]),
3234                                 get_le32(&uuid[2]), get_le16(&uuid[0]));
3235
3236                         major = get_le16(data + 16);
3237                         minor = get_le16(data + 18);
3238                         print_field("  Version: %u.%u", major, minor);
3239
3240                         tx_power = *(int8_t *) (data + 20);
3241                         print_field("  TX power: %d dB", tx_power);
3242                 } else
3243                         print_hex_field("  Data", data, len);
3244
3245                 data += len;
3246                 data_len -= len;
3247         }
3248
3249         packet_hexdump(data, data_len);
3250 }
3251
3252 static void print_manufacturer_data(const void *data, uint8_t data_len)
3253 {
3254         uint16_t company = get_le16(data);
3255
3256         packet_print_company("Company", company);
3257
3258         switch (company) {
3259         case 76:
3260         case 19456:
3261                 print_manufacturer_apple(data + 2, data_len - 2);
3262                 break;
3263         default:
3264                 print_hex_field("  Data", data + 2, data_len - 2);
3265                 break;
3266         }
3267 }
3268
3269 static void print_device_id(const void *data, uint8_t data_len)
3270 {
3271         uint16_t source, vendor, product, version;
3272         char modalias[26], *vendor_str, *product_str;
3273         const char *str;
3274
3275         if (data_len < 8)
3276                 return;
3277
3278         source = get_le16(data);
3279         vendor = get_le16(data + 2);
3280         product = get_le16(data + 4);
3281         version = get_le16(data + 6);
3282
3283         switch (source) {
3284         case 0x0001:
3285                 str = "Bluetooth SIG assigned";
3286                 sprintf(modalias, "bluetooth:v%04Xp%04Xd%04X",
3287                                                 vendor, product, version);
3288                 break;
3289         case 0x0002:
3290                 str = "USB Implementer's Forum assigned";
3291                 sprintf(modalias, "usb:v%04Xp%04Xd%04X",
3292                                                 vendor, product, version);
3293                 break;
3294         default:
3295                 str = "Reserved";
3296                 modalias[0] = '\0';
3297                 break;
3298         }
3299
3300         print_field("Device ID: %s (0x%4.4x)", str, source);
3301
3302         if (!hwdb_get_vendor_model(modalias, &vendor_str, &product_str)) {
3303                 vendor_str = NULL;
3304                 product_str = NULL;
3305         }
3306
3307         if (source != 0x0001) {
3308                 if (vendor_str)
3309                         print_field("  Vendor: %s (0x%4.4x)",
3310                                                 vendor_str, vendor);
3311                 else
3312                         print_field("  Vendor: 0x%4.4x", vendor);
3313         } else
3314                 packet_print_company("  Vendor", vendor);
3315
3316         if (product_str)
3317                 print_field("  Product: %s (0x%4.4x)", product_str, product);
3318         else
3319                 print_field("  Product: 0x%4.4x", product);
3320
3321         print_field("  Version: %u.%u.%u (0x%4.4x)",
3322                                         (version & 0xff00) >> 8,
3323                                         (version & 0x00f0) >> 4,
3324                                         (version & 0x000f), version);
3325
3326         free(vendor_str);
3327         free(product_str);
3328 }
3329
3330 static void print_uuid16_list(const char *label, const void *data,
3331                                                         uint8_t data_len)
3332 {
3333         uint8_t count = data_len / sizeof(uint16_t);
3334         unsigned int i;
3335
3336         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3337
3338         for (i = 0; i < count; i++) {
3339                 uint16_t uuid = get_le16(data + (i * 2));
3340                 print_field("  %s (0x%4.4x)", bt_uuid16_to_str(uuid), uuid);
3341         }
3342 }
3343
3344 static void print_uuid32_list(const char *label, const void *data,
3345                                                         uint8_t data_len)
3346 {
3347         uint8_t count = data_len / sizeof(uint32_t);
3348         unsigned int i;
3349
3350         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3351
3352         for (i = 0; i < count; i++) {
3353                 uint32_t uuid = get_le32(data + (i * 4));
3354                 print_field("  %s (0x%8.8x)", bt_uuid32_to_str(uuid), uuid);
3355         }
3356 }
3357
3358 static void print_uuid128_list(const char *label, const void *data,
3359                                                         uint8_t data_len)
3360 {
3361         uint8_t count = data_len / 16;
3362         unsigned int i;
3363
3364         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3365
3366         for (i = 0; i < count; i++) {
3367                 const uint8_t *uuid = data + (i * 16);
3368
3369                 print_field("  %s", bt_uuid128_to_str(uuid));
3370         }
3371 }
3372
3373 static void *iov_pull(struct iovec *iov, size_t len)
3374 {
3375         void *data;
3376
3377         if (iov->iov_len < len)
3378                 return NULL;
3379
3380         data = iov->iov_base;
3381         iov->iov_base += len;
3382         iov->iov_len -= len;
3383
3384         return data;
3385 }
3386
3387 static struct packet_ltv_decoder*
3388 get_ltv_decoder(struct packet_ltv_decoder *decoder, size_t num, uint8_t type)
3389 {
3390         size_t i;
3391
3392         if (!decoder || !num)
3393                 return NULL;
3394
3395         for (i = 0; i < num; i++) {
3396                 struct packet_ltv_decoder *dec = &decoder[i];
3397
3398                 if (dec->type == type)
3399                         return dec;
3400         }
3401
3402         return NULL;
3403 }
3404
3405 static void print_ltv(const char *label, const uint8_t *data, uint8_t len,
3406                         struct packet_ltv_decoder *decoder, size_t num)
3407 {
3408         struct iovec iov;
3409         int i;
3410
3411         iov.iov_base = (void *) data;
3412         iov.iov_len = len;
3413
3414         for (i = 0; iov.iov_len; i++) {
3415                 uint8_t l, t, *v;
3416                 struct packet_ltv_decoder *dec;
3417
3418                 l = get_u8(iov_pull(&iov, sizeof(l)));
3419                 if (!l) {
3420                         print_field("%s #%d: len 0x%02x", label, i, l);
3421                         break;
3422                 }
3423
3424                 v = iov_pull(&iov, sizeof(*v));
3425                 if (!v)
3426                         break;
3427
3428                 t = get_u8(v);
3429
3430                 print_field("%s #%d: len 0x%02x type 0x%02x", label, i, l, t);
3431
3432                 l -= 1;
3433
3434                 v = iov_pull(&iov, l);
3435                 if (!v)
3436                         break;
3437
3438                 dec = get_ltv_decoder(decoder, num, t);
3439                 if (dec)
3440                         dec->func(v, l);
3441                 else
3442                         print_hex_field(label, v, l);
3443         }
3444
3445         if (iov.iov_len)
3446                 print_hex_field(label, iov.iov_base, iov.iov_len);
3447 }
3448
3449 void packet_print_ltv(const char *label, const uint8_t *data, uint8_t len,
3450                         struct packet_ltv_decoder *decoder, size_t decoder_len)
3451 {
3452         print_ltv(label, data, len, decoder, decoder_len);
3453 }
3454
3455 static void print_base_annoucement(const uint8_t *data, uint8_t data_len)
3456 {
3457         struct iovec iov;
3458         struct bt_hci_le_pa_base_data *base_data;
3459         uint8_t i;
3460
3461         iov.iov_base = (void *) data;
3462         iov.iov_len = data_len;
3463
3464         base_data = iov_pull(&iov, sizeof(*base_data));
3465         if (!base_data)
3466                 goto done;
3467
3468         /* Level 1 - BASE */
3469         print_field("  Presetation Delay: %u", get_le24(base_data->pd));
3470         print_field("  Number of Subgroups: %u", base_data->num_subgroups);
3471
3472         /* Level 2 - Subgroups*/
3473         for (i = 0; i < base_data->num_subgroups; i++) {
3474                 struct bt_hci_le_pa_base_subgroup *subgroup;
3475                 struct bt_hci_lv_data *codec_cfg;
3476                 struct bt_hci_lv_data *metadata;
3477                 uint8_t j;
3478
3479                 print_field("    Subgroup #%u:", i);
3480
3481                 subgroup = iov_pull(&iov, sizeof(*subgroup));
3482                 if (!subgroup)
3483                         goto done;
3484
3485                 print_field("    Number of BIS(s): %u", subgroup->num_bis);
3486                 print_codec_id("    Codec", subgroup->codec.id);
3487
3488                 if (subgroup->codec.id == 0xff) {
3489                         uint16_t id;
3490
3491                         id = le16_to_cpu(subgroup->codec.vid);
3492                         print_field("    Codec Company ID: %s (0x%04x)",
3493                                                 bt_compidtostr(id), id);
3494                         print_field("    Codec Vendor ID: 0x%04x",
3495                                                 subgroup->codec.vid);
3496                 }
3497
3498                 codec_cfg = iov_pull(&iov, sizeof(*codec_cfg));
3499                 if (!codec_cfg)
3500                         goto done;
3501
3502                 if (!iov_pull(&iov, codec_cfg->len))
3503                         goto done;
3504
3505                 print_ltv("    Codec Specific Configuration",
3506                                         codec_cfg->data, codec_cfg->len,
3507                                         NULL, 0);
3508
3509                 metadata = iov_pull(&iov, sizeof(*metadata));
3510                 if (!metadata)
3511                         goto done;
3512
3513                 if (!iov_pull(&iov, metadata->len))
3514                         goto done;
3515
3516                 print_ltv("    Metadata", metadata->data, metadata->len,
3517                                         NULL, 0);
3518
3519                 /* Level 3 - BIS(s)*/
3520                 for (j = 0; j < subgroup->num_bis; j++) {
3521                         struct bt_hci_le_pa_base_bis *bis;
3522
3523                         print_field("      BIS #%u:", j);
3524
3525                         bis = iov_pull(&iov, sizeof(*bis));
3526                         if (!bis)
3527                                 goto done;
3528
3529                         print_field("      Index: %u", bis->index);
3530
3531                         codec_cfg = iov_pull(&iov, sizeof(*codec_cfg));
3532                         if (!codec_cfg)
3533                                 goto done;
3534
3535                         if (!iov_pull(&iov, codec_cfg->len))
3536                                 goto done;
3537
3538                         print_hex_field("      Codec Specific Configuration",
3539                                         codec_cfg->data, codec_cfg->len);
3540                 }
3541         }
3542
3543 done:
3544         if (iov.iov_len)
3545                 print_hex_field("  Data", iov.iov_base, iov.iov_len);
3546 }
3547
3548 static void print_broadcast_annoucement(const uint8_t *data, uint8_t data_len)
3549 {
3550         uint32_t bid;
3551
3552         if (data_len < 3) {
3553                 print_hex_field("  Data", data, data_len);
3554                 return;
3555         }
3556
3557         bid = get_le24(data);
3558         print_field("Broadcast ID: %u (0x%06x)", bid, bid);
3559 }
3560
3561 static const struct service_data_decoder {
3562         uint16_t uuid;
3563         void (*func)(const uint8_t *data, uint8_t data_len);
3564 } service_data_decoders[] = {
3565         { 0x1851, print_base_annoucement },
3566         { 0x1852, print_broadcast_annoucement }
3567 };
3568
3569 static void print_service_data(const uint8_t *data, uint8_t data_len)
3570 {
3571         uint16_t uuid = get_le16(&data[0]);
3572         size_t i;
3573
3574         print_field("Service Data: %s (0x%4.4x)", bt_uuid16_to_str(uuid), uuid);
3575
3576         for (i = 0; i < ARRAY_SIZE(service_data_decoders); i++) {
3577                 const struct service_data_decoder *decoder;
3578
3579                 decoder = &service_data_decoders[i];
3580
3581                 if (decoder->uuid == uuid) {
3582                         decoder->func(&data[2], data_len - 2);
3583                         return;
3584                 }
3585         }
3586
3587         print_hex_field("  Data", &data[2], data_len - 2);
3588 }
3589
3590 static const struct bitfield_data eir_flags_table[] = {
3591         { 0, "LE Limited Discoverable Mode"             },
3592         { 1, "LE General Discoverable Mode"             },
3593         { 2, "BR/EDR Not Supported"                     },
3594         { 3, "Simultaneous LE and BR/EDR (Controller)"  },
3595         { 4, "Simultaneous LE and BR/EDR (Host)"        },
3596         { }
3597 };
3598
3599 static const struct bitfield_data eir_3d_table[] = {
3600         { 0, "Association Notification"                                 },
3601         { 1, "Battery Level Reporting"                                  },
3602         { 2, "Send Battery Level Report on Start-up Synchronization"    },
3603         { 7, "Factory Test Mode"                                        },
3604         { }
3605 };
3606
3607 static const struct bitfield_data mesh_oob_table[] = {
3608         { 0, "Other"                                                    },
3609         { 1, "Electronic / URI"                                         },
3610         { 2, "2D machine-readable code"                                 },
3611         { 3, "Bar code"                                                 },
3612         { 4, "Near Field Communication (NFC)"                           },
3613         { 5, "Number"                                                   },
3614         { 6, "String"                                                   },
3615         { 11, "On box"                                                  },
3616         { 12, "Inside box"                                              },
3617         { 13, "On piece of paper"                                       },
3618         { 14, "Inside manual"                                           },
3619         { 15, "On device"                                               },
3620         { }
3621 };
3622
3623 static void print_mesh_beacon(const uint8_t *data, uint8_t len)
3624 {
3625         uint16_t oob;
3626
3627         print_hex_field("Mesh Beacon", data, len);
3628
3629         if (len < 1)
3630                 return;
3631
3632         switch (data[0]) {
3633         case 0x00:
3634                 print_field("  Unprovisioned Device Beacon (0x00)");
3635                 if (len < 18) {
3636                         packet_hexdump(data + 1, len - 1);
3637                         break;
3638                 }
3639
3640                 print_hex_field("  Device UUID", data + 1, 16);
3641
3642                 oob = get_be16(data + 17);
3643                 print_field("  OOB Information: 0x%4.4x", oob);
3644
3645                 print_bitfield(4, oob, mesh_oob_table);
3646
3647                 if (len < 23) {
3648                         packet_hexdump(data + 18, len - 18);
3649                         break;
3650                 }
3651
3652                 print_field("  URI Hash: 0x%8.8x", get_be32(data + 19));
3653                 packet_hexdump(data + 23, len - 23);
3654                 break;
3655         case 0x01:
3656                 print_field("  Secure Network Beacon (0x01)");
3657                 if (len < 22) {
3658                         packet_hexdump(data + 1, len - 1);
3659                         break;
3660                 }
3661
3662                 print_field("  Flags: 0x%2.2x", data[0]);
3663
3664                 if (data[1] & 0x01)
3665                         print_field("    Key Refresh");
3666
3667                 if (data[1] & 0x02)
3668                         print_field("    IV Update");
3669
3670                 print_hex_field("  Network Id", data + 2, 8);
3671                 print_field("  IV Index: 0x%08x", get_be32(data + 10));
3672                 print_hex_field("  Authentication Value", data + 14, 8);
3673                 packet_hexdump(data + 22, len - 22);
3674                 break;
3675         default:
3676                 print_field("  Invalid Beacon (0x%02x)", data[0]);
3677                 packet_hexdump(data, len);
3678                 break;
3679         }
3680 }
3681
3682 static void print_mesh_prov(const uint8_t *data, uint8_t len)
3683 {
3684         print_hex_field("Mesh Provisioning", data, len);
3685
3686         if (len < 6) {
3687                 packet_hexdump(data, len);
3688                 return;
3689         }
3690
3691         print_field("  Link ID: 0x%08x", get_be32(data));
3692         print_field("  Transaction Number: %u", data[4]);
3693
3694         data += 5;
3695         len -= 5;
3696
3697         switch (data[0] & 0x03) {
3698         case 0x00:
3699                 print_field("  Transaction Start (0x00)");
3700                 if (len < 5) {
3701                         packet_hexdump(data + 1, len - 1);
3702                         return;
3703                 }
3704                 print_field("  SeqN: %u", data[0] & 0xfc >> 2);
3705                 print_field("  TotalLength: %u", get_be16(data + 1));
3706                 print_field("  FCS: 0x%2.2x", data[3]);
3707                 print_hex_field("  Data", data + 4, len - 4);
3708                 packet_hexdump(data + 5, len - 5);
3709                 break;
3710         case 0x01:
3711                 print_field("  Transaction Acknowledgment (0x01)");
3712                 packet_hexdump(data + 1, len - 1);
3713                 break;
3714         case 0x02:
3715                 print_field("  Transaction Continuation (0x02)");
3716                 print_field("  SegmentIndex: %u", data[0] >> 2);
3717                 if (len < 2) {
3718                         packet_hexdump(data + 1, len - 1);
3719                         return;
3720                 }
3721                 print_hex_field("  Data", data + 1, len - 1);
3722                 packet_hexdump(data + 2, len - 2);
3723                 break;
3724         case 0x03:
3725                 print_field("  Provisioning Bearer Control (0x03)");
3726                 switch (data[0] >> 2) {
3727                 case 0x00:
3728                         print_field("  Link Open (0x00)");
3729                         if (len < 17) {
3730                                 packet_hexdump(data + 1, len - 1);
3731                                 break;
3732                         }
3733                         print_hex_field("  Device UUID", data, 16);
3734                         break;
3735                 case 0x01:
3736                         print_field("  Link Ack (0x01)");
3737                         break;
3738                 case 0x02:
3739                         print_field("  Link Close (0x02)");
3740                         if (len < 2) {
3741                                 packet_hexdump(data + 1, len - 1);
3742                                 break;
3743                         }
3744
3745                         switch (data[1]) {
3746                         case 0x00:
3747                                 print_field("  Reason: Success (0x00)");
3748                                 break;
3749                         case 0x01:
3750                                 print_field("  Reason: Timeout (0x01)");
3751                                 break;
3752                         case 0x02:
3753                                 print_field("  Reason: Fail (0x02)");
3754                                 break;
3755                         default:
3756                                 print_field("  Reason: Unrecognized (0x%2.2x)",
3757                                                                 data[1]);
3758                         }
3759                         packet_hexdump(data + 2, len - 2);
3760                         break;
3761                 default:
3762                         packet_hexdump(data + 1, len - 1);
3763                         break;
3764                 }
3765                 break;
3766         default:
3767                 print_field("  Invalid Command (0x%02x)", data[0]);
3768                 packet_hexdump(data, len);
3769                 break;
3770         }
3771 }
3772
3773 static void print_mesh_data(const uint8_t *data, uint8_t len)
3774 {
3775         print_hex_field("Mesh Data", data, len);
3776
3777         if (len < 1)
3778                 return;
3779
3780         print_field("  IVI: %u", data[0] >> 7);
3781         print_field("  NID: 0x%2.2x", data[0] & 0x7f);
3782         packet_hexdump(data + 1, len - 1);
3783 }
3784
3785 static void print_transport_data(const uint8_t *data, uint8_t len)
3786 {
3787         print_field("Transport Discovery Data");
3788
3789         if (len < 3)
3790                 return;
3791
3792         print_field("  Organization: %s (0x%02x)",
3793                         data[0] == 0x01 ? "Bluetooth SIG" : "RFU", data[0]);
3794         print_field("  Flags: 0x%2.2x", data[1]);
3795         print_field("    Role: 0x%2.2x", data[1] & 0x03);
3796
3797         switch (data[1] & 0x03) {
3798         case 0x00:
3799                 print_field("      Not Specified");
3800                 break;
3801         case 0x01:
3802                 print_field("      Seeker Only");
3803                 break;
3804         case 0x02:
3805                 print_field("      Provider Only");
3806                 break;
3807         case 0x03:
3808                 print_field("      Both Seeker an Provider");
3809                 break;
3810         }
3811
3812         print_field("    Transport Data Incomplete: %s (0x%2.2x)",
3813                         data[1] & 0x04 ? "True" : "False", data[1] & 0x04);
3814
3815         print_field("    Transport State: 0x%2.2x", data[1] & 0x18);
3816
3817         switch (data[1] & 0x18) {
3818         case 0x00:
3819                 print_field("      Off");
3820                 break;
3821         case 0x08:
3822                 print_field("      On");
3823                 break;
3824         case 0x10:
3825                 print_field("      Temporary Unavailable");
3826                 break;
3827         case 0x18:
3828                 print_field("      RFU");
3829                 break;
3830         }
3831
3832         print_field("  Length: %u", data[2]);
3833         print_hex_field("  Data", data + 3, len - 3);
3834 }
3835
3836 static void print_eir(const uint8_t *eir, uint8_t eir_len, bool le)
3837 {
3838         uint16_t len = 0;
3839
3840         if (eir_len == 0)
3841                 return;
3842
3843         while (len < eir_len - 1) {
3844                 uint8_t field_len = eir[0];
3845                 const uint8_t *data = &eir[2];
3846                 uint8_t data_len;
3847                 char name[239], label[100];
3848                 uint8_t flags, mask;
3849
3850                 /* Check for the end of EIR */
3851                 if (field_len == 0)
3852                         break;
3853
3854                 len += field_len + 1;
3855
3856                 /* Do not continue EIR Data parsing if got incorrect length */
3857                 if (len > eir_len) {
3858                         len -= field_len + 1;
3859                         break;
3860                 }
3861
3862                 data_len = field_len - 1;
3863
3864                 switch (eir[1]) {
3865                 case BT_EIR_FLAGS:
3866                         flags = *data;
3867
3868                         print_field("Flags: 0x%2.2x", flags);
3869
3870                         mask = print_bitfield(2, flags, eir_flags_table);
3871                         if (mask)
3872                                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
3873                                         "  Unknown flags (0x%2.2x)", mask);
3874                         break;
3875
3876                 case BT_EIR_UUID16_SOME:
3877                         if (data_len < sizeof(uint16_t))
3878                                 break;
3879                         print_uuid16_list("16-bit Service UUIDs (partial)",
3880                                                         data, data_len);
3881                         break;
3882
3883                 case BT_EIR_UUID16_ALL:
3884                         if (data_len < sizeof(uint16_t))
3885                                 break;
3886                         print_uuid16_list("16-bit Service UUIDs (complete)",
3887                                                         data, data_len);
3888                         break;
3889
3890                 case BT_EIR_UUID32_SOME:
3891                         if (data_len < sizeof(uint32_t))
3892                                 break;
3893                         print_uuid32_list("32-bit Service UUIDs (partial)",
3894                                                         data, data_len);
3895                         break;
3896
3897                 case BT_EIR_UUID32_ALL:
3898                         if (data_len < sizeof(uint32_t))
3899                                 break;
3900                         print_uuid32_list("32-bit Service UUIDs (complete)",
3901                                                         data, data_len);
3902                         break;
3903
3904                 case BT_EIR_UUID128_SOME:
3905                         if (data_len < 16)
3906                                 break;
3907                         print_uuid128_list("128-bit Service UUIDs (partial)",
3908                                                                 data, data_len);
3909                         break;
3910
3911                 case BT_EIR_UUID128_ALL:
3912                         if (data_len < 16)
3913                                 break;
3914                         print_uuid128_list("128-bit Service UUIDs (complete)",
3915                                                                 data, data_len);
3916                         break;
3917
3918                 case BT_EIR_NAME_SHORT:
3919                         memset(name, 0, sizeof(name));
3920                         memcpy(name, data, data_len);
3921                         print_field("Name (short): %s", name);
3922                         break;
3923
3924                 case BT_EIR_NAME_COMPLETE:
3925                         memset(name, 0, sizeof(name));
3926                         memcpy(name, data, data_len);
3927                         print_field("Name (complete): %s", name);
3928                         break;
3929
3930                 case BT_EIR_TX_POWER:
3931                         if (data_len < 1)
3932                                 break;
3933                         print_field("TX power: %d dBm", (int8_t) *data);
3934                         break;
3935
3936                 case BT_EIR_CLASS_OF_DEV:
3937                         if (data_len < 3)
3938                                 break;
3939                         print_dev_class(data);
3940                         break;
3941
3942                 case BT_EIR_SSP_HASH_P192:
3943                         if (data_len < 16)
3944                                 break;
3945                         print_hash_p192(data);
3946                         break;
3947
3948                 case BT_EIR_SSP_RANDOMIZER_P192:
3949                         if (data_len < 16)
3950                                 break;
3951                         print_randomizer_p192(data);
3952                         break;
3953
3954                 case BT_EIR_DEVICE_ID:
3955                         /* SMP TK has the same value as Device ID */
3956                         if (le)
3957                                 print_hex_field("SMP TK", data, data_len);
3958                         else if (data_len >= 8)
3959                                 print_device_id(data, data_len);
3960                         break;
3961
3962                 case BT_EIR_SMP_OOB_FLAGS:
3963                         print_field("SMP OOB Flags: 0x%2.2x", *data);
3964                         break;
3965
3966                 case BT_EIR_PERIPHERAL_CONN_INTERVAL:
3967                         if (data_len < 4)
3968                                 break;
3969                         print_field("Peripheral Conn. Interval: "
3970                                                         "0x%4.4x - 0x%4.4x",
3971                                                         get_le16(&data[0]),
3972                                                         get_le16(&data[2]));
3973                         break;
3974
3975                 case BT_EIR_SERVICE_UUID16:
3976                         if (data_len < sizeof(uint16_t))
3977                                 break;
3978                         print_uuid16_list("16-bit Service UUIDs",
3979                                                         data, data_len);
3980                         break;
3981
3982                 case BT_EIR_SERVICE_UUID128:
3983                         if (data_len < 16)
3984                                 break;
3985                         print_uuid128_list("128-bit Service UUIDs",
3986                                                         data, data_len);
3987                         break;
3988
3989                 case BT_EIR_SERVICE_DATA:
3990                         if (data_len < 2)
3991                                 break;
3992                         print_service_data(data, data_len);
3993                         break;
3994
3995                 case BT_EIR_RANDOM_ADDRESS:
3996                         if (data_len < 6)
3997                                 break;
3998                         print_addr("Random Address", data, 0x01);
3999                         break;
4000
4001                 case BT_EIR_PUBLIC_ADDRESS:
4002                         if (data_len < 6)
4003                                 break;
4004                         print_addr("Public Address", data, 0x00);
4005                         break;
4006
4007                 case BT_EIR_GAP_APPEARANCE:
4008                         if (data_len < 2)
4009                                 break;
4010                         print_appearance(get_le16(data));
4011                         break;
4012
4013                 case BT_EIR_SSP_HASH_P256:
4014                         if (data_len < 16)
4015                                 break;
4016                         print_hash_p256(data);
4017                         break;
4018
4019                 case BT_EIR_SSP_RANDOMIZER_P256:
4020                         if (data_len < 16)
4021                                 break;
4022                         print_randomizer_p256(data);
4023                         break;
4024
4025                 case BT_EIR_TRANSPORT_DISCOVERY:
4026                         print_transport_data(data, data_len);
4027                         break;
4028
4029                 case BT_EIR_3D_INFO_DATA:
4030                         print_hex_field("3D Information Data", data, data_len);
4031                         if (data_len < 2)
4032                                 break;
4033
4034                         flags = *data;
4035
4036                         print_field("  Features: 0x%2.2x", flags);
4037
4038                         mask = print_bitfield(4, flags, eir_3d_table);
4039                         if (mask)
4040                                 print_text(COLOR_UNKNOWN_FEATURE_BIT,
4041                                         "      Unknown features (0x%2.2x)", mask);
4042
4043                         print_field("  Path Loss Threshold: %d", data[1]);
4044                         break;
4045
4046                 case BT_EIR_MESH_DATA:
4047                         print_mesh_data(data, data_len);
4048                         break;
4049
4050                 case BT_EIR_MESH_PROV:
4051                         print_mesh_prov(data, data_len);
4052                         break;
4053
4054                 case BT_EIR_MESH_BEACON:
4055                         print_mesh_beacon(data, data_len);
4056                         break;
4057
4058                 case BT_EIR_CSIP_RSI:
4059                         if (data_len < 6)
4060                                 break;
4061                         print_addr("Resolvable Set Identifier", data, 0xff);
4062                         print_field("  Hash: 0x%6x", get_le24(data));
4063                         print_field("  Random: 0x%6x", get_le24(data + 3));
4064                         break;
4065
4066                 case BT_EIR_MANUFACTURER_DATA:
4067                         if (data_len < 2)
4068                                 break;
4069                         print_manufacturer_data(data, data_len);
4070                         break;
4071
4072                 default:
4073                         sprintf(label, "Unknown EIR field 0x%2.2x", eir[1]);
4074                         print_hex_field(label, data, data_len);
4075                         break;
4076                 }
4077
4078                 eir += field_len + 1;
4079         }
4080
4081         if (len < eir_len && eir[0] != 0)
4082                 packet_hexdump(eir, eir_len - len);
4083 }
4084
4085 void packet_print_addr(const char *label, const void *data, uint8_t type)
4086 {
4087         print_addr(label ? : "Address", data, type);
4088 }
4089
4090 void packet_print_handle(uint16_t handle)
4091 {
4092         print_handle_native(handle);
4093 }
4094
4095 void packet_print_rssi(const char *label, int8_t rssi)
4096 {
4097         if ((uint8_t) rssi == 0x99 || rssi == 127)
4098                 print_field("%s: invalid (0x%2.2x)", label, (uint8_t) rssi);
4099         else
4100                 print_field("%s: %d dBm (0x%2.2x)", label, rssi,
4101                                                         (uint8_t) rssi);
4102 }
4103
4104 void packet_print_ad(const void *data, uint8_t size)
4105 {
4106         print_eir(data, size, true);
4107 }
4108
4109 struct broadcast_message {
4110         uint32_t frame_sync_instant;
4111         uint16_t bluetooth_clock_phase;
4112         uint16_t left_open_offset;
4113         uint16_t left_close_offset;
4114         uint16_t right_open_offset;
4115         uint16_t right_close_offset;
4116         uint16_t frame_sync_period;
4117         uint8_t  frame_sync_period_fraction;
4118 } __attribute__ ((packed));
4119
4120 static void print_3d_broadcast(const void *data, uint8_t size)
4121 {
4122         const struct broadcast_message *msg = data;
4123         uint32_t instant;
4124         uint16_t left_open, left_close, right_open, right_close;
4125         uint16_t phase, period;
4126         uint8_t period_frac;
4127         bool mode;
4128
4129         instant = le32_to_cpu(msg->frame_sync_instant);
4130         mode = !!(instant & 0x40000000);
4131         phase = le16_to_cpu(msg->bluetooth_clock_phase);
4132         left_open = le16_to_cpu(msg->left_open_offset);
4133         left_close = le16_to_cpu(msg->left_close_offset);
4134         right_open = le16_to_cpu(msg->right_open_offset);
4135         right_close = le16_to_cpu(msg->right_close_offset);
4136         period = le16_to_cpu(msg->frame_sync_period);
4137         period_frac = msg->frame_sync_period_fraction;
4138
4139         print_field("  Frame sync instant: 0x%8.8x", instant & 0x7fffffff);
4140         print_field("  Video mode: %s (%d)", mode ? "Dual View" : "3D", mode);
4141         print_field("  Bluetooth clock phase: %d usec (0x%4.4x)",
4142                                                 phase, phase);
4143         print_field("  Left lense shutter open offset: %d usec (0x%4.4x)",
4144                                                 left_open, left_open);
4145         print_field("  Left lense shutter close offset: %d usec (0x%4.4x)",
4146                                                 left_close, left_close);
4147         print_field("  Right lense shutter open offset: %d usec (0x%4.4x)",
4148                                                 right_open, right_open);
4149         print_field("  Right lense shutter close offset: %d usec (0x%4.4x)",
4150                                                 right_close, right_close);
4151         print_field("  Frame sync period: %d.%d usec (0x%4.4x 0x%2.2x)",
4152                                                 period, period_frac * 256,
4153                                                 period, period_frac);
4154 }
4155
4156 void packet_hexdump(const unsigned char *buf, uint16_t len)
4157 {
4158         static const char hexdigits[] = "0123456789abcdef";
4159         char str[68];
4160         uint16_t i;
4161
4162         if (!len)
4163                 return;
4164
4165         for (i = 0; i < len; i++) {
4166                 str[((i % 16) * 3) + 0] = hexdigits[buf[i] >> 4];
4167                 str[((i % 16) * 3) + 1] = hexdigits[buf[i] & 0xf];
4168                 str[((i % 16) * 3) + 2] = ' ';
4169                 str[(i % 16) + 49] = isprint(buf[i]) ? buf[i] : '.';
4170
4171                 if ((i + 1) % 16 == 0) {
4172                         str[47] = ' ';
4173                         str[48] = ' ';
4174                         str[65] = '\0';
4175                         print_text(COLOR_WHITE, "%s", str);
4176                         str[0] = ' ';
4177                 }
4178         }
4179
4180         if (i % 16 > 0) {
4181                 uint16_t j;
4182                 for (j = (i % 16); j < 16; j++) {
4183                         str[(j * 3) + 0] = ' ';
4184                         str[(j * 3) + 1] = ' ';
4185                         str[(j * 3) + 2] = ' ';
4186                         str[j + 49] = ' ';
4187                 }
4188                 str[47] = ' ';
4189                 str[48] = ' ';
4190                 str[65] = '\0';
4191                 print_text(COLOR_WHITE, "%s", str);
4192         }
4193 }
4194
4195 void packet_control(struct timeval *tv, struct ucred *cred,
4196                                         uint16_t index, uint16_t opcode,
4197                                         const void *data, uint16_t size)
4198 {
4199         control_message(opcode, data, size);
4200 }
4201
4202 static int addr2str(const uint8_t *addr, char *str)
4203 {
4204         return sprintf(str, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
4205                         addr[5], addr[4], addr[3], addr[2], addr[1], addr[0]);
4206 }
4207
4208 void packet_monitor(struct timeval *tv, struct ucred *cred,
4209                                         uint16_t index, uint16_t opcode,
4210                                         const void *data, uint16_t size)
4211 {
4212         const struct btsnoop_opcode_new_index *ni;
4213         const struct btsnoop_opcode_index_info *ii;
4214         const struct btsnoop_opcode_user_logging *ul;
4215         char str[18], extra_str[24];
4216         uint16_t manufacturer;
4217         const char *ident;
4218
4219         if (index != HCI_DEV_NONE) {
4220                 index_current = index;
4221         }
4222
4223         if (tv && time_offset == ((time_t) -1))
4224                 time_offset = tv->tv_sec;
4225
4226         switch (opcode) {
4227         case BTSNOOP_OPCODE_NEW_INDEX:
4228                 ni = data;
4229
4230                 if (index < MAX_INDEX) {
4231                         index_list[index].type = ni->type;
4232                         memcpy(index_list[index].bdaddr, ni->bdaddr, 6);
4233                         index_list[index].manufacturer = fallback_manufacturer;
4234                         index_list[index].msft_opcode = BT_HCI_CMD_NOP;
4235                 }
4236
4237                 addr2str(ni->bdaddr, str);
4238                 packet_new_index(tv, index, str, ni->type, ni->bus, ni->name);
4239                 break;
4240         case BTSNOOP_OPCODE_DEL_INDEX:
4241                 if (index < MAX_INDEX)
4242                         addr2str(index_list[index].bdaddr, str);
4243                 else
4244                         sprintf(str, "00:00:00:00:00:00");
4245
4246                 packet_del_index(tv, index, str);
4247                 break;
4248         case BTSNOOP_OPCODE_COMMAND_PKT:
4249                 packet_hci_command(tv, cred, index, data, size);
4250                 break;
4251         case BTSNOOP_OPCODE_EVENT_PKT:
4252                 packet_hci_event(tv, cred, index, data, size);
4253                 break;
4254         case BTSNOOP_OPCODE_ACL_TX_PKT:
4255                 packet_hci_acldata(tv, cred, index, false, data, size);
4256                 break;
4257         case BTSNOOP_OPCODE_ACL_RX_PKT:
4258                 packet_hci_acldata(tv, cred, index, true, data, size);
4259                 break;
4260         case BTSNOOP_OPCODE_SCO_TX_PKT:
4261                 packet_hci_scodata(tv, cred, index, false, data, size);
4262                 break;
4263         case BTSNOOP_OPCODE_SCO_RX_PKT:
4264                 packet_hci_scodata(tv, cred, index, true, data, size);
4265                 break;
4266         case BTSNOOP_OPCODE_ISO_TX_PKT:
4267                 packet_hci_isodata(tv, cred, index, false, data, size);
4268                 break;
4269         case BTSNOOP_OPCODE_ISO_RX_PKT:
4270                 packet_hci_isodata(tv, cred, index, true, data, size);
4271                 break;
4272         case BTSNOOP_OPCODE_OPEN_INDEX:
4273                 if (index < MAX_INDEX)
4274                         addr2str(index_list[index].bdaddr, str);
4275                 else
4276                         sprintf(str, "00:00:00:00:00:00");
4277
4278                 packet_open_index(tv, index, str);
4279                 break;
4280         case BTSNOOP_OPCODE_CLOSE_INDEX:
4281                 if (index < MAX_INDEX)
4282                         addr2str(index_list[index].bdaddr, str);
4283                 else
4284                         sprintf(str, "00:00:00:00:00:00");
4285
4286                 packet_close_index(tv, index, str);
4287                 break;
4288         case BTSNOOP_OPCODE_INDEX_INFO:
4289                 ii = data;
4290                 manufacturer = le16_to_cpu(ii->manufacturer);
4291
4292                 if (index < MAX_INDEX) {
4293                         memcpy(index_list[index].bdaddr, ii->bdaddr, 6);
4294                         index_list[index].manufacturer = manufacturer;
4295
4296                         switch (manufacturer) {
4297                         case 2:
4298                                 /*
4299                                  * Intel controllers that support the
4300                                  * Microsoft vendor extension are using
4301                                  * 0xFC1E for VsMsftOpCode.
4302                                  */
4303                                 index_list[index].msft_opcode = 0xFC1E;
4304                                 break;
4305                         case 93:
4306                                 /*
4307                                  * Realtek controllers that support the
4308                                  * Microsoft vendor extenions are using
4309                                  * 0xFCF0 for VsMsftOpCode.
4310                                  */
4311                                 index_list[index].msft_opcode = 0xFCF0;
4312                                 break;
4313                         case 1521:
4314                                 /*
4315                                  * Emulator controllers use Linux Foundation as
4316                                  * manufacturer and support the
4317                                  * Microsoft vendor extenions using
4318                                  * 0xFC1E for VsMsftOpCode.
4319                                  */
4320                                 index_list[index].msft_opcode = 0xFC1E;
4321                                 break;
4322                         }
4323                 }
4324
4325                 addr2str(ii->bdaddr, str);
4326                 packet_index_info(tv, index, str, manufacturer);
4327                 break;
4328         case BTSNOOP_OPCODE_VENDOR_DIAG:
4329                 if (index < MAX_INDEX)
4330                         manufacturer = index_list[index].manufacturer;
4331                 else
4332                         manufacturer = fallback_manufacturer;
4333
4334                 packet_vendor_diag(tv, index, manufacturer, data, size);
4335                 break;
4336         case BTSNOOP_OPCODE_SYSTEM_NOTE:
4337                 packet_system_note(tv, cred, index, data);
4338                 break;
4339         case BTSNOOP_OPCODE_USER_LOGGING:
4340                 ul = data;
4341                 ident = ul->ident_len ? data + sizeof(*ul) : NULL;
4342
4343                 packet_user_logging(tv, cred, index, ul->priority, ident,
4344                                         data + sizeof(*ul) + ul->ident_len,
4345                                         size - (sizeof(*ul) + ul->ident_len));
4346                 break;
4347         case BTSNOOP_OPCODE_CTRL_OPEN:
4348                 control_disable_decoding();
4349                 packet_ctrl_open(tv, cred, index, data, size);
4350                 break;
4351         case BTSNOOP_OPCODE_CTRL_CLOSE:
4352                 packet_ctrl_close(tv, cred, index, data, size);
4353                 break;
4354         case BTSNOOP_OPCODE_CTRL_COMMAND:
4355                 packet_ctrl_command(tv, cred, index, data, size);
4356                 break;
4357         case BTSNOOP_OPCODE_CTRL_EVENT:
4358                 packet_ctrl_event(tv, cred, index, data, size);
4359                 break;
4360         default:
4361                 sprintf(extra_str, "(code %d len %d)", opcode, size);
4362                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
4363                                         "Unknown packet", NULL, extra_str);
4364                 packet_hexdump(data, size);
4365                 break;
4366         }
4367 }
4368
4369 void packet_simulator(struct timeval *tv, uint16_t frequency,
4370                                         const void *data, uint16_t size)
4371 {
4372         char str[10];
4373
4374         if (tv && time_offset == ((time_t) -1))
4375                 time_offset = tv->tv_sec;
4376
4377         sprintf(str, "%u MHz", frequency);
4378
4379         print_packet(tv, NULL, '*', 0, NULL, COLOR_PHY_PACKET,
4380                                         "Physical packet:", NULL, str);
4381
4382         ll_packet(frequency, data, size, false);
4383 }
4384
4385 static void null_cmd(uint16_t index, const void *data, uint8_t size)
4386 {
4387 }
4388
4389 static void status_rsp(uint16_t index, const void *data, uint8_t size)
4390 {
4391         uint8_t status = *((const uint8_t *) data);
4392
4393         print_status(status);
4394 }
4395
4396 static void status_handle_rsp(uint16_t index, const void *data, uint8_t size)
4397 {
4398         uint8_t status = *((const uint8_t *) data);
4399
4400         print_status(status);
4401         print_field("Connection handle: %d", get_u8(data + 1));
4402 }
4403
4404 static void status_bdaddr_rsp(uint16_t index, const void *data, uint8_t size)
4405 {
4406         uint8_t status = *((const uint8_t *) data);
4407
4408         print_status(status);
4409         print_bdaddr(data + 1);
4410 }
4411
4412 static void inquiry_cmd(uint16_t index, const void *data, uint8_t size)
4413 {
4414         const struct bt_hci_cmd_inquiry *cmd = data;
4415
4416         print_iac(cmd->lap);
4417         print_field("Length: %.2fs (0x%2.2x)",
4418                                 cmd->length * 1.28, cmd->length);
4419         print_num_resp(cmd->num_resp);
4420 }
4421
4422 static void periodic_inquiry_cmd(uint16_t index, const void *data, uint8_t size)
4423 {
4424         const struct bt_hci_cmd_periodic_inquiry *cmd = data;
4425
4426         print_field("Max period: %.2fs (0x%2.2x)",
4427                                 cmd->max_period * 1.28, cmd->max_period);
4428         print_field("Min period: %.2fs (0x%2.2x)",
4429                                 cmd->min_period * 1.28, cmd->min_period);
4430         print_iac(cmd->lap);
4431         print_field("Length: %.2fs (0x%2.2x)",
4432                                 cmd->length * 1.28, cmd->length);
4433         print_num_resp(cmd->num_resp);
4434 }
4435
4436 static void create_conn_cmd(uint16_t index, const void *data, uint8_t size)
4437 {
4438         const struct bt_hci_cmd_create_conn *cmd = data;
4439         const char *str;
4440
4441         print_bdaddr(cmd->bdaddr);
4442         print_pkt_type(cmd->pkt_type);
4443         print_pscan_rep_mode(cmd->pscan_rep_mode);
4444         print_pscan_mode(cmd->pscan_mode);
4445         print_clock_offset(cmd->clock_offset);
4446
4447         switch (cmd->role_switch) {
4448         case 0x00:
4449                 str = "Stay central";
4450                 break;
4451         case 0x01:
4452                 str = "Allow peripheral";
4453                 break;
4454         default:
4455                 str = "Reserved";
4456                 break;
4457         }
4458
4459         print_field("Role switch: %s (0x%2.2x)", str, cmd->role_switch);
4460 }
4461
4462 static void disconnect_cmd(uint16_t index, const void *data, uint8_t size)
4463 {
4464         const struct bt_hci_cmd_disconnect *cmd = data;
4465
4466         print_handle(cmd->handle);
4467         print_reason(cmd->reason);
4468 }
4469
4470 static void add_sco_conn_cmd(uint16_t index, const void *data, uint8_t size)
4471 {
4472         const struct bt_hci_cmd_add_sco_conn *cmd = data;
4473
4474         print_handle(cmd->handle);
4475         print_pkt_type_sco(cmd->pkt_type);
4476 }
4477
4478 static void create_conn_cancel_cmd(uint16_t index, const void *data,
4479                                                         uint8_t size)
4480 {
4481         const struct bt_hci_cmd_create_conn_cancel *cmd = data;
4482
4483         print_bdaddr(cmd->bdaddr);
4484 }
4485
4486 static void accept_conn_request_cmd(uint16_t index, const void *data,
4487                                                         uint8_t size)
4488 {
4489         const struct bt_hci_cmd_accept_conn_request *cmd = data;
4490
4491         print_bdaddr(cmd->bdaddr);
4492         print_role(cmd->role);
4493 }
4494
4495 static void reject_conn_request_cmd(uint16_t index, const void *data,
4496                                                         uint8_t size)
4497 {
4498         const struct bt_hci_cmd_reject_conn_request *cmd = data;
4499
4500         print_bdaddr(cmd->bdaddr);
4501         print_reason(cmd->reason);
4502 }
4503
4504 static void link_key_request_reply_cmd(uint16_t index, const void *data,
4505                                                         uint8_t size)
4506 {
4507         const struct bt_hci_cmd_link_key_request_reply *cmd = data;
4508
4509         print_bdaddr(cmd->bdaddr);
4510         print_link_key(cmd->link_key);
4511 }
4512
4513 static void link_key_request_neg_reply_cmd(uint16_t index, const void *data,
4514                                                         uint8_t size)
4515 {
4516         const struct bt_hci_cmd_link_key_request_neg_reply *cmd = data;
4517
4518         print_bdaddr(cmd->bdaddr);
4519 }
4520
4521 static void pin_code_request_reply_cmd(uint16_t index, const void *data,
4522                                                         uint8_t size)
4523 {
4524         const struct bt_hci_cmd_pin_code_request_reply *cmd = data;
4525
4526         print_bdaddr(cmd->bdaddr);
4527         print_field("PIN length: %d", cmd->pin_len);
4528         print_pin_code(cmd->pin_code, cmd->pin_len);
4529 }
4530
4531 static void pin_code_request_neg_reply_cmd(uint16_t index, const void *data,
4532                                                         uint8_t size)
4533 {
4534         const struct bt_hci_cmd_pin_code_request_neg_reply *cmd = data;
4535
4536         print_bdaddr(cmd->bdaddr);
4537 }
4538
4539 static void change_conn_pkt_type_cmd(uint16_t index, const void *data,
4540                                                         uint8_t size)
4541 {
4542         const struct bt_hci_cmd_change_conn_pkt_type *cmd = data;
4543
4544         print_handle(cmd->handle);
4545         print_pkt_type(cmd->pkt_type);
4546 }
4547
4548 static void auth_requested_cmd(uint16_t index, const void *data, uint8_t size)
4549 {
4550         const struct bt_hci_cmd_auth_requested *cmd = data;
4551
4552         print_handle(cmd->handle);
4553 }
4554
4555 static void set_conn_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
4556 {
4557         const struct bt_hci_cmd_set_conn_encrypt *cmd = data;
4558
4559         print_handle(cmd->handle);
4560         print_enable("Encryption", cmd->encr_mode);
4561 }
4562
4563 static void change_conn_link_key_cmd(uint16_t index, const void *data,
4564                                                         uint8_t size)
4565 {
4566         const struct bt_hci_cmd_change_conn_link_key *cmd = data;
4567
4568         print_handle(cmd->handle);
4569 }
4570
4571 static void link_key_selection_cmd(uint16_t index, const void *data,
4572                                                         uint8_t size)
4573 {
4574         const struct bt_hci_cmd_link_key_selection *cmd = data;
4575
4576         print_key_flag(cmd->key_flag);
4577 }
4578
4579 static void remote_name_request_cmd(uint16_t index, const void *data,
4580                                                         uint8_t size)
4581 {
4582         const struct bt_hci_cmd_remote_name_request *cmd = data;
4583
4584         print_bdaddr(cmd->bdaddr);
4585         print_pscan_rep_mode(cmd->pscan_rep_mode);
4586         print_pscan_mode(cmd->pscan_mode);
4587         print_clock_offset(cmd->clock_offset);
4588 }
4589
4590 static void remote_name_request_cancel_cmd(uint16_t index, const void *data,
4591                                                         uint8_t size)
4592 {
4593         const struct bt_hci_cmd_remote_name_request_cancel *cmd = data;
4594
4595         print_bdaddr(cmd->bdaddr);
4596 }
4597
4598 static void read_remote_features_cmd(uint16_t index, const void *data,
4599                                                         uint8_t size)
4600 {
4601         const struct bt_hci_cmd_read_remote_features *cmd = data;
4602
4603         print_handle(cmd->handle);
4604 }
4605
4606 static void read_remote_ext_features_cmd(uint16_t index, const void *data,
4607                                                         uint8_t size)
4608 {
4609         const struct bt_hci_cmd_read_remote_ext_features *cmd = data;
4610
4611         print_handle(cmd->handle);
4612         print_field("Page: %d", cmd->page);
4613 }
4614
4615 static void read_remote_version_cmd(uint16_t index, const void *data,
4616                                                         uint8_t size)
4617 {
4618         const struct bt_hci_cmd_read_remote_version *cmd = data;
4619
4620         print_handle(cmd->handle);
4621 }
4622
4623 static void read_clock_offset_cmd(uint16_t index, const void *data,
4624                                                         uint8_t size)
4625 {
4626         const struct bt_hci_cmd_read_clock_offset *cmd = data;
4627
4628         print_handle(cmd->handle);
4629 }
4630
4631 static void read_lmp_handle_cmd(uint16_t index, const void *data, uint8_t size)
4632 {
4633         const struct bt_hci_cmd_read_lmp_handle *cmd = data;
4634
4635         print_handle(cmd->handle);
4636 }
4637
4638 static void read_lmp_handle_rsp(uint16_t index, const void *data, uint8_t size)
4639 {
4640         const struct bt_hci_rsp_read_lmp_handle *rsp = data;
4641
4642         print_status(rsp->status);
4643         print_handle(rsp->handle);
4644         print_field("LMP handle: %d", rsp->lmp_handle);
4645         print_field("Reserved: %d", le32_to_cpu(rsp->reserved));
4646 }
4647
4648 static void setup_sync_conn_cmd(uint16_t index, const void *data, uint8_t size)
4649 {
4650         const struct bt_hci_cmd_setup_sync_conn *cmd = data;
4651
4652         print_handle(cmd->handle);
4653         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4654         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4655         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4656         print_voice_setting(cmd->voice_setting);
4657         print_retransmission_effort(cmd->retrans_effort);
4658         print_pkt_type_sco(cmd->pkt_type);
4659 }
4660
4661 static void accept_sync_conn_request_cmd(uint16_t index, const void *data,
4662                                                         uint8_t size)
4663 {
4664         const struct bt_hci_cmd_accept_sync_conn_request *cmd = data;
4665
4666         print_bdaddr(cmd->bdaddr);
4667         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4668         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4669         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4670         print_voice_setting(cmd->voice_setting);
4671         print_retransmission_effort(cmd->retrans_effort);
4672         print_pkt_type_sco(cmd->pkt_type);
4673 }
4674
4675 static void reject_sync_conn_request_cmd(uint16_t index, const void *data,
4676                                                         uint8_t size)
4677 {
4678         const struct bt_hci_cmd_reject_sync_conn_request *cmd = data;
4679
4680         print_bdaddr(cmd->bdaddr);
4681         print_reason(cmd->reason);
4682 }
4683
4684 static void io_capability_request_reply_cmd(uint16_t index, const void *data,
4685                                                         uint8_t size)
4686 {
4687         const struct bt_hci_cmd_io_capability_request_reply *cmd = data;
4688
4689         print_bdaddr(cmd->bdaddr);
4690         print_io_capability(cmd->capability);
4691         print_oob_data(cmd->oob_data);
4692         print_authentication(cmd->authentication);
4693 }
4694
4695 static void user_confirm_request_reply_cmd(uint16_t index, const void *data,
4696                                                         uint8_t size)
4697 {
4698         const struct bt_hci_cmd_user_confirm_request_reply *cmd = data;
4699
4700         print_bdaddr(cmd->bdaddr);
4701 }
4702
4703 static void user_confirm_request_neg_reply_cmd(uint16_t index, const void *data,
4704                                                         uint8_t size)
4705 {
4706         const struct bt_hci_cmd_user_confirm_request_neg_reply *cmd = data;
4707
4708         print_bdaddr(cmd->bdaddr);
4709 }
4710
4711 static void user_passkey_request_reply_cmd(uint16_t index, const void *data,
4712                                                         uint8_t size)
4713 {
4714         const struct bt_hci_cmd_user_passkey_request_reply *cmd = data;
4715
4716         print_bdaddr(cmd->bdaddr);
4717         print_passkey(cmd->passkey);
4718 }
4719
4720 static void user_passkey_request_neg_reply_cmd(uint16_t index, const void *data,
4721                                                         uint8_t size)
4722 {
4723         const struct bt_hci_cmd_user_passkey_request_neg_reply *cmd = data;
4724
4725         print_bdaddr(cmd->bdaddr);
4726 }
4727
4728 static void remote_oob_data_request_reply_cmd(uint16_t index, const void *data,
4729                                                         uint8_t size)
4730 {
4731         const struct bt_hci_cmd_remote_oob_data_request_reply *cmd = data;
4732
4733         print_bdaddr(cmd->bdaddr);
4734         print_hash_p192(cmd->hash);
4735         print_randomizer_p192(cmd->randomizer);
4736 }
4737
4738 static void remote_oob_data_request_neg_reply_cmd(uint16_t index,
4739                                                 const void *data, uint8_t size)
4740 {
4741         const struct bt_hci_cmd_remote_oob_data_request_neg_reply *cmd = data;
4742
4743         print_bdaddr(cmd->bdaddr);
4744 }
4745
4746 static void io_capability_request_neg_reply_cmd(uint16_t index,
4747                                                 const void *data, uint8_t size)
4748 {
4749         const struct bt_hci_cmd_io_capability_request_neg_reply *cmd = data;
4750
4751         print_bdaddr(cmd->bdaddr);
4752         print_reason(cmd->reason);
4753 }
4754
4755 static void create_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4756 {
4757         const struct bt_hci_cmd_create_phy_link *cmd = data;
4758
4759         print_phy_handle(cmd->phy_handle);
4760         print_key_len(cmd->key_len);
4761         print_key_type(cmd->key_type);
4762
4763         packet_hexdump(data + 3, size - 3);
4764 }
4765
4766 static void accept_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4767 {
4768         const struct bt_hci_cmd_accept_phy_link *cmd = data;
4769
4770         print_phy_handle(cmd->phy_handle);
4771         print_key_len(cmd->key_len);
4772         print_key_type(cmd->key_type);
4773
4774         packet_hexdump(data + 3, size - 3);
4775 }
4776
4777 static void disconn_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4778 {
4779         const struct bt_hci_cmd_disconn_phy_link *cmd = data;
4780
4781         print_phy_handle(cmd->phy_handle);
4782         print_reason(cmd->reason);
4783 }
4784
4785 static void create_logic_link_cmd(uint16_t index, const void *data,
4786                                                         uint8_t size)
4787 {
4788         const struct bt_hci_cmd_create_logic_link *cmd = data;
4789
4790         print_phy_handle(cmd->phy_handle);
4791         print_flow_spec("TX", cmd->tx_flow_spec);
4792         print_flow_spec("RX", cmd->rx_flow_spec);
4793 }
4794
4795 static void accept_logic_link_cmd(uint16_t index, const void *data,
4796                                                         uint8_t size)
4797 {
4798         const struct bt_hci_cmd_accept_logic_link *cmd = data;
4799
4800         print_phy_handle(cmd->phy_handle);
4801         print_flow_spec("TX", cmd->tx_flow_spec);
4802         print_flow_spec("RX", cmd->rx_flow_spec);
4803 }
4804
4805 static void disconn_logic_link_cmd(uint16_t index, const void *data,
4806                                                         uint8_t size)
4807 {
4808         const struct bt_hci_cmd_disconn_logic_link *cmd = data;
4809
4810         print_handle(cmd->handle);
4811 }
4812
4813 static void logic_link_cancel_cmd(uint16_t index, const void *data,
4814                                                         uint8_t size)
4815 {
4816         const struct bt_hci_cmd_logic_link_cancel *cmd = data;
4817
4818         print_phy_handle(cmd->phy_handle);
4819         print_field("TX flow spec: 0x%2.2x", cmd->flow_spec);
4820 }
4821
4822 static void logic_link_cancel_rsp(uint16_t index, const void *data,
4823                                                         uint8_t size)
4824 {
4825         const struct bt_hci_rsp_logic_link_cancel *rsp = data;
4826
4827         print_status(rsp->status);
4828         print_phy_handle(rsp->phy_handle);
4829         print_field("TX flow spec: 0x%2.2x", rsp->flow_spec);
4830 }
4831
4832 static void flow_spec_modify_cmd(uint16_t index, const void *data, uint8_t size)
4833 {
4834         const struct bt_hci_cmd_flow_spec_modify *cmd = data;
4835
4836         print_handle(cmd->handle);
4837         print_flow_spec("TX", cmd->tx_flow_spec);
4838         print_flow_spec("RX", cmd->rx_flow_spec);
4839 }
4840
4841 static void enhanced_setup_sync_conn_cmd(uint16_t index, const void *data,
4842                                                         uint8_t size)
4843 {
4844         const struct bt_hci_cmd_enhanced_setup_sync_conn *cmd = data;
4845
4846         print_handle(cmd->handle);
4847         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4848         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4849
4850         /* TODO */
4851
4852         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4853         print_pkt_type_sco(cmd->pkt_type);
4854         print_retransmission_effort(cmd->retrans_effort);
4855 }
4856
4857 static void enhanced_accept_sync_conn_request_cmd(uint16_t index,
4858                                                 const void *data,
4859                                                 uint8_t size)
4860 {
4861         const struct bt_hci_cmd_enhanced_accept_sync_conn_request *cmd = data;
4862
4863         print_bdaddr(cmd->bdaddr);
4864         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4865         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4866
4867         /* TODO */
4868
4869         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4870         print_pkt_type_sco(cmd->pkt_type);
4871         print_retransmission_effort(cmd->retrans_effort);
4872 }
4873
4874 static void truncated_page_cmd(uint16_t index, const void *data, uint8_t size)
4875 {
4876         const struct bt_hci_cmd_truncated_page *cmd = data;
4877
4878         print_bdaddr(cmd->bdaddr);
4879         print_pscan_rep_mode(cmd->pscan_rep_mode);
4880         print_clock_offset(cmd->clock_offset);
4881 }
4882
4883 static void truncated_page_cancel_cmd(uint16_t index, const void *data,
4884                                                         uint8_t size)
4885 {
4886         const struct bt_hci_cmd_truncated_page_cancel *cmd = data;
4887
4888         print_bdaddr(cmd->bdaddr);
4889 }
4890
4891 static void set_peripheral_broadcast_cmd(uint16_t index, const void *data,
4892                                                         uint8_t size)
4893 {
4894         const struct bt_hci_cmd_set_peripheral_broadcast *cmd = data;
4895
4896         print_field("Enable: 0x%2.2x", cmd->enable);
4897         print_lt_addr(cmd->lt_addr);
4898         print_lpo_allowed(cmd->lpo_allowed);
4899         print_pkt_type(cmd->pkt_type);
4900         print_slot_625("Min interval", cmd->min_interval);
4901         print_slot_625("Max interval", cmd->max_interval);
4902         print_slot_625("Supervision timeout", cmd->timeout);
4903 }
4904
4905 static void set_peripheral_broadcast_rsp(uint16_t index, const void *data,
4906                                                         uint8_t size)
4907 {
4908         const struct bt_hci_rsp_set_peripheral_broadcast *rsp = data;
4909
4910         print_status(rsp->status);
4911         print_lt_addr(rsp->lt_addr);
4912         print_interval(rsp->interval);
4913 }
4914
4915 static void set_peripheral_broadcast_receive_cmd(uint16_t index,
4916                                                 const void *data, uint8_t size)
4917 {
4918         const struct bt_hci_cmd_set_peripheral_broadcast_receive *cmd = data;
4919
4920         print_field("Enable: 0x%2.2x", cmd->enable);
4921         print_bdaddr(cmd->bdaddr);
4922         print_lt_addr(cmd->lt_addr);
4923         print_interval(cmd->interval);
4924         print_field("Offset: 0x%8.8x", le32_to_cpu(cmd->offset));
4925         print_field("Next broadcast instant: 0x%4.4x",
4926                                         le16_to_cpu(cmd->instant));
4927         print_slot_625("Supervision timeout", cmd->timeout);
4928         print_field("Remote timing accuracy: %d ppm", cmd->accuracy);
4929         print_field("Skip: 0x%2.2x", cmd->skip);
4930         print_pkt_type(cmd->pkt_type);
4931         print_channel_map(cmd->map);
4932 }
4933
4934 static void set_peripheral_broadcast_receive_rsp(uint16_t index,
4935                                                 const void *data, uint8_t size)
4936 {
4937         const struct bt_hci_rsp_set_peripheral_broadcast_receive *rsp = data;
4938
4939         print_status(rsp->status);
4940         print_bdaddr(rsp->bdaddr);
4941         print_lt_addr(rsp->lt_addr);
4942 }
4943
4944 static void receive_sync_train_cmd(uint16_t index, const void *data,
4945                                                         uint8_t size)
4946 {
4947         const struct bt_hci_cmd_receive_sync_train *cmd = data;
4948
4949         print_bdaddr(cmd->bdaddr);
4950         print_timeout(cmd->timeout);
4951         print_window(cmd->window);
4952         print_interval(cmd->interval);
4953 }
4954
4955 static void remote_oob_ext_data_request_reply_cmd(uint16_t index,
4956                                                 const void *data, uint8_t size)
4957 {
4958         const struct bt_hci_cmd_remote_oob_ext_data_request_reply *cmd = data;
4959
4960         print_bdaddr(cmd->bdaddr);
4961         print_hash_p192(cmd->hash192);
4962         print_randomizer_p192(cmd->randomizer192);
4963         print_hash_p256(cmd->hash256);
4964         print_randomizer_p256(cmd->randomizer256);
4965 }
4966
4967 static void hold_mode_cmd(uint16_t index, const void *data, uint8_t size)
4968 {
4969         const struct bt_hci_cmd_hold_mode *cmd = data;
4970
4971         print_handle(cmd->handle);
4972         print_slot_625("Hold max interval", cmd->max_interval);
4973         print_slot_625("Hold min interval", cmd->min_interval);
4974 }
4975
4976 static void sniff_mode_cmd(uint16_t index, const void *data, uint8_t size)
4977 {
4978         const struct bt_hci_cmd_sniff_mode *cmd = data;
4979
4980         print_handle(cmd->handle);
4981         print_slot_625("Sniff max interval", cmd->max_interval);
4982         print_slot_625("Sniff min interval", cmd->min_interval);
4983         print_slot_125("Sniff attempt", cmd->attempt);
4984         print_slot_125("Sniff timeout", cmd->timeout);
4985 }
4986
4987 static void exit_sniff_mode_cmd(uint16_t index, const void *data, uint8_t size)
4988 {
4989         const struct bt_hci_cmd_exit_sniff_mode *cmd = data;
4990
4991         print_handle(cmd->handle);
4992 }
4993
4994 static void park_state_cmd(uint16_t index, const void *data, uint8_t size)
4995 {
4996         const struct bt_hci_cmd_park_state *cmd = data;
4997
4998         print_handle(cmd->handle);
4999         print_slot_625("Beacon max interval", cmd->max_interval);
5000         print_slot_625("Beacon min interval", cmd->min_interval);
5001 }
5002
5003 static void exit_park_state_cmd(uint16_t index, const void *data, uint8_t size)
5004 {
5005         const struct bt_hci_cmd_exit_park_state *cmd = data;
5006
5007         print_handle(cmd->handle);
5008 }
5009
5010 static void qos_setup_cmd(uint16_t index, const void *data, uint8_t size)
5011 {
5012         const struct bt_hci_cmd_qos_setup *cmd = data;
5013
5014         print_handle(cmd->handle);
5015         print_field("Flags: 0x%2.2x", cmd->flags);
5016
5017         print_service_type(cmd->service_type);
5018
5019         print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
5020         print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
5021         print_field("Latency: %d", le32_to_cpu(cmd->latency));
5022         print_field("Delay variation: %d", le32_to_cpu(cmd->delay_variation));
5023 }
5024
5025 static void role_discovery_cmd(uint16_t index, const void *data, uint8_t size)
5026 {
5027         const struct bt_hci_cmd_role_discovery *cmd = data;
5028
5029         print_handle(cmd->handle);
5030 }
5031
5032 static void role_discovery_rsp(uint16_t index, const void *data, uint8_t size)
5033 {
5034         const struct bt_hci_rsp_role_discovery *rsp = data;
5035
5036         print_status(rsp->status);
5037         print_handle(rsp->handle);
5038         print_role(rsp->role);
5039 }
5040
5041 static void switch_role_cmd(uint16_t index, const void *data, uint8_t size)
5042 {
5043         const struct bt_hci_cmd_switch_role *cmd = data;
5044
5045         print_bdaddr(cmd->bdaddr);
5046         print_role(cmd->role);
5047 }
5048
5049 static void read_link_policy_cmd(uint16_t index, const void *data, uint8_t size)
5050 {
5051         const struct bt_hci_cmd_read_link_policy *cmd = data;
5052
5053         print_handle(cmd->handle);
5054 }
5055
5056 static void read_link_policy_rsp(uint16_t index, const void *data, uint8_t size)
5057 {
5058         const struct bt_hci_rsp_read_link_policy *rsp = data;
5059
5060         print_status(rsp->status);
5061         print_handle(rsp->handle);
5062         print_link_policy(rsp->policy);
5063 }
5064
5065 static void write_link_policy_cmd(uint16_t index, const void *data,
5066                                                         uint8_t size)
5067 {
5068         const struct bt_hci_cmd_write_link_policy *cmd = data;
5069
5070         print_handle(cmd->handle);
5071         print_link_policy(cmd->policy);
5072 }
5073
5074 static void write_link_policy_rsp(uint16_t index, const void *data,
5075                                                         uint8_t size)
5076 {
5077         const struct bt_hci_rsp_write_link_policy *rsp = data;
5078
5079         print_status(rsp->status);
5080         print_handle(rsp->handle);
5081 }
5082
5083 static void read_default_link_policy_rsp(uint16_t index, const void *data,
5084                                                         uint8_t size)
5085 {
5086         const struct bt_hci_rsp_read_default_link_policy *rsp = data;
5087
5088         print_status(rsp->status);
5089         print_link_policy(rsp->policy);
5090 }
5091
5092 static void write_default_link_policy_cmd(uint16_t index, const void *data,
5093                                                         uint8_t size)
5094 {
5095         const struct bt_hci_cmd_write_default_link_policy *cmd = data;
5096
5097         print_link_policy(cmd->policy);
5098 }
5099
5100 static void flow_spec_cmd(uint16_t index, const void *data, uint8_t size)
5101 {
5102         const struct bt_hci_cmd_flow_spec *cmd = data;
5103
5104         print_handle(cmd->handle);
5105         print_field("Flags: 0x%2.2x", cmd->flags);
5106
5107         print_flow_direction(cmd->direction);
5108         print_service_type(cmd->service_type);
5109
5110         print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
5111         print_field("Token bucket size: %d",
5112                                         le32_to_cpu(cmd->token_bucket_size));
5113         print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
5114         print_field("Access latency: %d", le32_to_cpu(cmd->access_latency));
5115 }
5116
5117 static void sniff_subrating_cmd(uint16_t index, const void *data, uint8_t size)
5118 {
5119         const struct bt_hci_cmd_sniff_subrating *cmd = data;
5120
5121         print_handle(cmd->handle);
5122         print_slot_625("Max latency", cmd->max_latency);
5123         print_slot_625("Min remote timeout", cmd->min_remote_timeout);
5124         print_slot_625("Min local timeout", cmd->min_local_timeout);
5125 }
5126
5127 static void sniff_subrating_rsp(uint16_t index, const void *data, uint8_t size)
5128 {
5129         const struct bt_hci_rsp_sniff_subrating *rsp = data;
5130
5131         print_status(rsp->status);
5132         print_handle(rsp->handle);
5133 }
5134
5135 static void set_event_mask_cmd(uint16_t index, const void *data, uint8_t size)
5136 {
5137         const struct bt_hci_cmd_set_event_mask *cmd = data;
5138
5139         print_event_mask(cmd->mask, events_table);
5140 }
5141
5142 static void set_event_filter_cmd(uint16_t index, const void *data, uint8_t size)
5143 {
5144         uint8_t type = *((const uint8_t *) data);
5145         uint8_t filter;
5146         const char *str;
5147
5148         switch (type) {
5149         case 0x00:
5150                 str = "Clear All Filters";
5151                 break;
5152         case 0x01:
5153                 str = "Inquiry Result";
5154                 break;
5155         case 0x02:
5156                 str = "Connection Setup";
5157                 break;
5158         default:
5159                 str = "Reserved";
5160                 break;
5161         }
5162
5163         print_field("Type: %s (0x%2.2x)", str, type);
5164
5165         switch (type) {
5166         case 0x00:
5167                 if (size > 1) {
5168                         print_text(COLOR_ERROR, "  invalid parameter size");
5169                         packet_hexdump(data + 1, size - 1);
5170                 }
5171                 break;
5172
5173         case 0x01:
5174                 if (size < 2) {
5175                         print_text(COLOR_ERROR, "  invalid parameter size");
5176                         break;
5177                 }
5178                 filter = *((const uint8_t *) (data + 1));
5179
5180                 switch (filter) {
5181                 case 0x00:
5182                         str = "Return responses from all devices";
5183                         break;
5184                 case 0x01:
5185                         str = "Device with specific Class of Device";
5186                         break;
5187                 case 0x02:
5188                         str = "Device with specific BD_ADDR";
5189                         break;
5190                 default:
5191                         str = "Reserved";
5192                         break;
5193                 }
5194
5195                 print_field("Filter: %s (0x%2.2x)", str, filter);
5196                 packet_hexdump(data + 2, size - 2);
5197                 break;
5198
5199         case 0x02:
5200                 filter = *((const uint8_t *) (data + 1));
5201
5202                 switch (filter) {
5203                 case 0x00:
5204                         str = "Allow connections all devices";
5205                         break;
5206                 case 0x01:
5207                         str = "Allow connections with specific Class of Device";
5208                         break;
5209                 case 0x02:
5210                         str = "Allow connections with specific BD_ADDR";
5211                         break;
5212                 default:
5213                         str = "Reserved";
5214                         break;
5215                 }
5216
5217                 if (size < 2) {
5218                         print_text(COLOR_ERROR, "  invalid parameter size");
5219                         break;
5220                 }
5221
5222                 print_field("Filter: %s (0x%2.2x)", str, filter);
5223                 packet_hexdump(data + 2, size - 2);
5224                 break;
5225
5226         default:
5227                 if (size < 2) {
5228                         print_text(COLOR_ERROR, "  invalid parameter size");
5229                         break;
5230                 }
5231
5232                 filter = *((const uint8_t *) (data + 1));
5233
5234                 print_field("Filter: Reserved (0x%2.2x)", filter);
5235                 packet_hexdump(data + 2, size - 2);
5236                 break;
5237         }
5238 }
5239
5240 static void flush_cmd(uint16_t index, const void *data, uint8_t size)
5241 {
5242         const struct bt_hci_cmd_flush *cmd = data;
5243
5244         print_handle(cmd->handle);
5245 }
5246
5247 static void flush_rsp(uint16_t index, const void *data, uint8_t size)
5248 {
5249         const struct bt_hci_rsp_flush *rsp = data;
5250
5251         print_status(rsp->status);
5252         print_handle(rsp->handle);
5253 }
5254
5255 static void read_pin_type_rsp(uint16_t index, const void *data, uint8_t size)
5256 {
5257         const struct bt_hci_rsp_read_pin_type *rsp = data;
5258
5259         print_status(rsp->status);
5260         print_pin_type(rsp->pin_type);
5261 }
5262
5263 static void write_pin_type_cmd(uint16_t index, const void *data, uint8_t size)
5264 {
5265         const struct bt_hci_cmd_write_pin_type *cmd = data;
5266
5267         print_pin_type(cmd->pin_type);
5268 }
5269
5270 static void read_stored_link_key_cmd(uint16_t index, const void *data,
5271                                                         uint8_t size)
5272 {
5273         const struct bt_hci_cmd_read_stored_link_key *cmd = data;
5274
5275         print_bdaddr(cmd->bdaddr);
5276         print_field("Read all: 0x%2.2x", cmd->read_all);
5277 }
5278
5279 static void read_stored_link_key_rsp(uint16_t index, const void *data,
5280                                                         uint8_t size)
5281 {
5282         const struct bt_hci_rsp_read_stored_link_key *rsp = data;
5283
5284         print_status(rsp->status);
5285         print_field("Max num keys: %d", le16_to_cpu(rsp->max_num_keys));
5286         print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
5287 }
5288
5289 static void write_stored_link_key_cmd(uint16_t index, const void *data,
5290                                                         uint8_t size)
5291 {
5292         const struct bt_hci_cmd_write_stored_link_key *cmd = data;
5293
5294         print_field("Num keys: %d", cmd->num_keys);
5295
5296         packet_hexdump(data + 1, size - 1);
5297 }
5298
5299 static void write_stored_link_key_rsp(uint16_t index, const void *data,
5300                                                         uint8_t size)
5301 {
5302         const struct bt_hci_rsp_write_stored_link_key *rsp = data;
5303
5304         print_status(rsp->status);
5305         print_field("Num keys: %d", rsp->num_keys);
5306 }
5307
5308 static void delete_stored_link_key_cmd(uint16_t index, const void *data,
5309                                                         uint8_t size)
5310 {
5311         const struct bt_hci_cmd_delete_stored_link_key *cmd = data;
5312
5313         print_bdaddr(cmd->bdaddr);
5314         print_field("Delete all: 0x%2.2x", cmd->delete_all);
5315 }
5316
5317 static void delete_stored_link_key_rsp(uint16_t index, const void *data,
5318                                                         uint8_t size)
5319 {
5320         const struct bt_hci_rsp_delete_stored_link_key *rsp = data;
5321
5322         print_status(rsp->status);
5323         print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
5324 }
5325
5326 static void write_local_name_cmd(uint16_t index, const void *data, uint8_t size)
5327 {
5328         const struct bt_hci_cmd_write_local_name *cmd = data;
5329
5330         print_name(cmd->name);
5331 }
5332
5333 static void read_local_name_rsp(uint16_t index, const void *data, uint8_t size)
5334 {
5335         const struct bt_hci_rsp_read_local_name *rsp = data;
5336
5337         print_status(rsp->status);
5338         print_name(rsp->name);
5339 }
5340
5341 static void read_conn_accept_timeout_rsp(uint16_t index, const void *data,
5342                                                         uint8_t size)
5343 {
5344         const struct bt_hci_rsp_read_conn_accept_timeout *rsp = data;
5345
5346         print_status(rsp->status);
5347         print_timeout(rsp->timeout);
5348 }
5349
5350 static void write_conn_accept_timeout_cmd(uint16_t index, const void *data,
5351                                                         uint8_t size)
5352 {
5353         const struct bt_hci_cmd_write_conn_accept_timeout *cmd = data;
5354
5355         print_timeout(cmd->timeout);
5356 }
5357
5358 static void read_page_timeout_rsp(uint16_t index, const void *data,
5359                                                         uint8_t size)
5360 {
5361         const struct bt_hci_rsp_read_page_timeout *rsp = data;
5362
5363         print_status(rsp->status);
5364         print_timeout(rsp->timeout);
5365 }
5366
5367 static void write_page_timeout_cmd(uint16_t index, const void *data,
5368                                                         uint8_t size)
5369 {
5370         const struct bt_hci_cmd_write_page_timeout *cmd = data;
5371
5372         print_timeout(cmd->timeout);
5373 }
5374
5375 static void read_scan_enable_rsp(uint16_t index, const void *data, uint8_t size)
5376 {
5377         const struct bt_hci_rsp_read_scan_enable *rsp = data;
5378
5379         print_status(rsp->status);
5380         print_scan_enable(rsp->enable);
5381 }
5382
5383 static void write_scan_enable_cmd(uint16_t index, const void *data,
5384                                                         uint8_t size)
5385 {
5386         const struct bt_hci_cmd_write_scan_enable *cmd = data;
5387
5388         print_scan_enable(cmd->enable);
5389 }
5390
5391 static void read_page_scan_activity_rsp(uint16_t index, const void *data,
5392                                                         uint8_t size)
5393 {
5394         const struct bt_hci_rsp_read_page_scan_activity *rsp = data;
5395
5396         print_status(rsp->status);
5397         print_interval(rsp->interval);
5398         print_window(rsp->window);
5399 }
5400
5401 static void write_page_scan_activity_cmd(uint16_t index, const void *data,
5402                                                         uint8_t size)
5403 {
5404         const struct bt_hci_cmd_write_page_scan_activity *cmd = data;
5405
5406         print_interval(cmd->interval);
5407         print_window(cmd->window);
5408 }
5409
5410 static void read_inquiry_scan_activity_rsp(uint16_t index, const void *data,
5411                                                         uint8_t size)
5412 {
5413         const struct bt_hci_rsp_read_inquiry_scan_activity *rsp = data;
5414
5415         print_status(rsp->status);
5416         print_interval(rsp->interval);
5417         print_window(rsp->window);
5418 }
5419
5420 static void write_inquiry_scan_activity_cmd(uint16_t index, const void *data,
5421                                                         uint8_t size)
5422 {
5423         const struct bt_hci_cmd_write_inquiry_scan_activity *cmd = data;
5424
5425         print_interval(cmd->interval);
5426         print_window(cmd->window);
5427 }
5428
5429 static void read_auth_enable_rsp(uint16_t index, const void *data, uint8_t size)
5430 {
5431         const struct bt_hci_rsp_read_auth_enable *rsp = data;
5432
5433         print_status(rsp->status);
5434         print_auth_enable(rsp->enable);
5435 }
5436
5437 static void write_auth_enable_cmd(uint16_t index, const void *data,
5438                                                         uint8_t size)
5439 {
5440         const struct bt_hci_cmd_write_auth_enable *cmd = data;
5441
5442         print_auth_enable(cmd->enable);
5443 }
5444
5445 static void read_encrypt_mode_rsp(uint16_t index, const void *data,
5446                                                         uint8_t size)
5447 {
5448         const struct bt_hci_rsp_read_encrypt_mode *rsp = data;
5449
5450         print_status(rsp->status);
5451         print_encrypt_mode(rsp->mode);
5452 }
5453
5454 static void write_encrypt_mode_cmd(uint16_t index, const void *data,
5455                                                         uint8_t size)
5456 {
5457         const struct bt_hci_cmd_write_encrypt_mode *cmd = data;
5458
5459         print_encrypt_mode(cmd->mode);
5460 }
5461
5462 static void read_class_of_dev_rsp(uint16_t index, const void *data,
5463                                                         uint8_t size)
5464 {
5465         const struct bt_hci_rsp_read_class_of_dev *rsp = data;
5466
5467         print_status(rsp->status);
5468         print_dev_class(rsp->dev_class);
5469 }
5470
5471 static void write_class_of_dev_cmd(uint16_t index, const void *data,
5472                                                         uint8_t size)
5473 {
5474         const struct bt_hci_cmd_write_class_of_dev *cmd = data;
5475
5476         print_dev_class(cmd->dev_class);
5477 }
5478
5479 static void read_voice_setting_rsp(uint16_t index, const void *data,
5480                                                         uint8_t size)
5481 {
5482         const struct bt_hci_rsp_read_voice_setting *rsp = data;
5483
5484         print_status(rsp->status);
5485         print_voice_setting(rsp->setting);
5486 }
5487
5488 static void write_voice_setting_cmd(uint16_t index, const void *data,
5489                                                         uint8_t size)
5490 {
5491         const struct bt_hci_cmd_write_voice_setting *cmd = data;
5492
5493         print_voice_setting(cmd->setting);
5494 }
5495
5496 static void read_auto_flush_timeout_cmd(uint16_t index, const void *data,
5497                                                         uint8_t size)
5498 {
5499         const struct bt_hci_cmd_read_auto_flush_timeout *cmd = data;
5500
5501         print_handle(cmd->handle);
5502 }
5503
5504 static void read_auto_flush_timeout_rsp(uint16_t index, const void *data,
5505                                                         uint8_t size)
5506 {
5507         const struct bt_hci_rsp_read_auto_flush_timeout *rsp = data;
5508
5509         print_status(rsp->status);
5510         print_handle(rsp->handle);
5511         print_flush_timeout(rsp->timeout);
5512 }
5513
5514 static void write_auto_flush_timeout_cmd(uint16_t index, const void *data,
5515                                                         uint8_t size)
5516 {
5517         const struct bt_hci_cmd_write_auto_flush_timeout *cmd = data;
5518
5519         print_handle(cmd->handle);
5520         print_flush_timeout(cmd->timeout);
5521 }
5522
5523 static void write_auto_flush_timeout_rsp(uint16_t index, const void *data,
5524                                                         uint8_t size)
5525 {
5526         const struct bt_hci_rsp_write_auto_flush_timeout *rsp = data;
5527
5528         print_status(rsp->status);
5529         print_handle(rsp->handle);
5530 }
5531
5532 static void read_num_broadcast_retrans_rsp(uint16_t index, const void *data,
5533                                                         uint8_t size)
5534 {
5535         const struct bt_hci_rsp_read_num_broadcast_retrans *rsp = data;
5536
5537         print_status(rsp->status);
5538         print_num_broadcast_retrans(rsp->num_retrans);
5539 }
5540
5541 static void write_num_broadcast_retrans_cmd(uint16_t index, const void *data,
5542                                                         uint8_t size)
5543 {
5544         const struct bt_hci_cmd_write_num_broadcast_retrans *cmd = data;
5545
5546         print_num_broadcast_retrans(cmd->num_retrans);
5547 }
5548
5549 static void read_hold_mode_activity_rsp(uint16_t index, const void *data,
5550                                                         uint8_t size)
5551 {
5552         const struct bt_hci_rsp_read_hold_mode_activity *rsp = data;
5553
5554         print_status(rsp->status);
5555         print_hold_mode_activity(rsp->activity);
5556 }
5557
5558 static void write_hold_mode_activity_cmd(uint16_t index, const void *data,
5559                                                         uint8_t size)
5560 {
5561         const struct bt_hci_cmd_write_hold_mode_activity *cmd = data;
5562
5563         print_hold_mode_activity(cmd->activity);
5564 }
5565
5566 static void read_tx_power_cmd(uint16_t index, const void *data, uint8_t size)
5567 {
5568         const struct bt_hci_cmd_read_tx_power *cmd = data;
5569
5570         print_handle(cmd->handle);
5571         print_power_type(cmd->type);
5572 }
5573
5574 static void read_tx_power_rsp(uint16_t index, const void *data, uint8_t size)
5575 {
5576         const struct bt_hci_rsp_read_tx_power *rsp = data;
5577
5578         print_status(rsp->status);
5579         print_handle(rsp->handle);
5580         print_power_level(rsp->level, NULL);
5581 }
5582
5583 static void read_sync_flow_control_rsp(uint16_t index, const void *data,
5584                                                         uint8_t size)
5585 {
5586         const struct bt_hci_rsp_read_sync_flow_control *rsp = data;
5587
5588         print_status(rsp->status);
5589         print_enable("Flow control", rsp->enable);
5590 }
5591
5592 static void write_sync_flow_control_cmd(uint16_t index, const void *data,
5593                                                         uint8_t size)
5594 {
5595         const struct bt_hci_cmd_write_sync_flow_control *cmd = data;
5596
5597         print_enable("Flow control", cmd->enable);
5598 }
5599
5600 static void set_host_flow_control_cmd(uint16_t index, const void *data,
5601                                                         uint8_t size)
5602 {
5603         const struct bt_hci_cmd_set_host_flow_control *cmd = data;
5604
5605         print_host_flow_control(cmd->enable);
5606 }
5607
5608 static void host_buffer_size_cmd(uint16_t index, const void *data, uint8_t size)
5609 {
5610         const struct bt_hci_cmd_host_buffer_size *cmd = data;
5611
5612         print_field("ACL MTU: %-4d ACL max packet: %d",
5613                                         le16_to_cpu(cmd->acl_mtu),
5614                                         le16_to_cpu(cmd->acl_max_pkt));
5615         print_field("SCO MTU: %-4d SCO max packet: %d",
5616                                         cmd->sco_mtu,
5617                                         le16_to_cpu(cmd->sco_max_pkt));
5618 }
5619
5620 static void host_num_completed_packets_cmd(uint16_t index, const void *data,
5621                                                         uint8_t size)
5622 {
5623         const struct bt_hci_cmd_host_num_completed_packets *cmd = data;
5624
5625         print_field("Num handles: %d", cmd->num_handles);
5626         print_handle(cmd->handle);
5627         print_field("Count: %d", le16_to_cpu(cmd->count));
5628
5629         if (size > sizeof(*cmd))
5630                 packet_hexdump(data + sizeof(*cmd), size - sizeof(*cmd));
5631 }
5632
5633 static void read_link_supv_timeout_cmd(uint16_t index, const void *data,
5634                                                         uint8_t size)
5635 {
5636         const struct bt_hci_cmd_read_link_supv_timeout *cmd = data;
5637
5638         print_handle(cmd->handle);
5639 }
5640
5641 static void read_link_supv_timeout_rsp(uint16_t index, const void *data,
5642                                                         uint8_t size)
5643 {
5644         const struct bt_hci_rsp_read_link_supv_timeout *rsp = data;
5645
5646         print_status(rsp->status);
5647         print_handle(rsp->handle);
5648         print_timeout(rsp->timeout);
5649 }
5650
5651 static void write_link_supv_timeout_cmd(uint16_t index, const void *data,
5652                                                         uint8_t size)
5653 {
5654         const struct bt_hci_cmd_write_link_supv_timeout *cmd = data;
5655
5656         print_handle(cmd->handle);
5657         print_timeout(cmd->timeout);
5658 }
5659
5660 static void write_link_supv_timeout_rsp(uint16_t index, const void *data,
5661                                                         uint8_t size)
5662 {
5663         const struct bt_hci_rsp_write_link_supv_timeout *rsp = data;
5664
5665         print_status(rsp->status);
5666         print_handle(rsp->handle);
5667 }
5668
5669 static void read_num_supported_iac_rsp(uint16_t index, const void *data,
5670                                                         uint8_t size)
5671 {
5672         const struct bt_hci_rsp_read_num_supported_iac *rsp = data;
5673
5674         print_status(rsp->status);
5675         print_field("Number of IAC: %d", rsp->num_iac);
5676 }
5677
5678 static void read_current_iac_lap_rsp(uint16_t index, const void *data,
5679                                                         uint8_t size)
5680 {
5681         const struct bt_hci_rsp_read_current_iac_lap *rsp = data;
5682         uint8_t i;
5683
5684         print_status(rsp->status);
5685         print_field("Number of IAC: %d", rsp->num_iac);
5686
5687         for (i = 0; i < rsp->num_iac; i++)
5688                 print_iac(rsp->iac_lap + (i * 3));
5689 }
5690
5691 static void write_current_iac_lap_cmd(uint16_t index, const void *data,
5692                                                         uint8_t size)
5693 {
5694         const struct bt_hci_cmd_write_current_iac_lap *cmd = data;
5695         uint8_t i;
5696
5697         print_field("Number of IAC: %d", cmd->num_iac);
5698
5699         for (i = 0; i < cmd->num_iac; i++)
5700                 print_iac(cmd->iac_lap + (i * 3));
5701 }
5702
5703 static void read_page_scan_period_mode_rsp(uint16_t index, const void *data,
5704                                                         uint8_t size)
5705 {
5706         const struct bt_hci_rsp_read_page_scan_period_mode *rsp = data;
5707
5708         print_status(rsp->status);
5709         print_pscan_period_mode(rsp->mode);
5710 }
5711
5712 static void write_page_scan_period_mode_cmd(uint16_t index, const void *data,
5713                                                         uint8_t size)
5714 {
5715         const struct bt_hci_cmd_write_page_scan_period_mode *cmd = data;
5716
5717         print_pscan_period_mode(cmd->mode);
5718 }
5719
5720 static void read_page_scan_mode_rsp(uint16_t index, const void *data,
5721                                                         uint8_t size)
5722 {
5723         const struct bt_hci_rsp_read_page_scan_mode *rsp = data;
5724
5725         print_status(rsp->status);
5726         print_pscan_mode(rsp->mode);
5727 }
5728
5729 static void write_page_scan_mode_cmd(uint16_t index, const void *data,
5730                                                         uint8_t size)
5731 {
5732         const struct bt_hci_cmd_write_page_scan_mode *cmd = data;
5733
5734         print_pscan_mode(cmd->mode);
5735 }
5736
5737 static void set_afh_host_classification_cmd(uint16_t index, const void *data,
5738                                                         uint8_t size)
5739 {
5740         const struct bt_hci_cmd_set_afh_host_classification *cmd = data;
5741
5742         print_channel_map(cmd->map);
5743 }
5744
5745 static void read_inquiry_scan_type_rsp(uint16_t index, const void *data,
5746                                                         uint8_t size)
5747 {
5748         const struct bt_hci_rsp_read_inquiry_scan_type *rsp = data;
5749
5750         print_status(rsp->status);
5751         print_inquiry_scan_type(rsp->type);
5752 }
5753
5754 static void write_inquiry_scan_type_cmd(uint16_t index, const void *data,
5755                                                         uint8_t size)
5756 {
5757         const struct bt_hci_cmd_write_inquiry_scan_type *cmd = data;
5758
5759         print_inquiry_scan_type(cmd->type);
5760 }
5761
5762 static void read_inquiry_mode_rsp(uint16_t index, const void *data,
5763                                                         uint8_t size)
5764 {
5765         const struct bt_hci_rsp_read_inquiry_mode *rsp = data;
5766
5767         print_status(rsp->status);
5768         print_inquiry_mode(rsp->mode);
5769 }
5770
5771 static void write_inquiry_mode_cmd(uint16_t index, const void *data,
5772                                                         uint8_t size)
5773 {
5774         const struct bt_hci_cmd_write_inquiry_mode *cmd = data;
5775
5776         print_inquiry_mode(cmd->mode);
5777 }
5778
5779 static void read_page_scan_type_rsp(uint16_t index, const void *data,
5780                                                         uint8_t size)
5781 {
5782         const struct bt_hci_rsp_read_page_scan_type *rsp = data;
5783
5784         print_status(rsp->status);
5785         print_pscan_type(rsp->type);
5786 }
5787
5788 static void write_page_scan_type_cmd(uint16_t index, const void *data,
5789                                                         uint8_t size)
5790 {
5791         const struct bt_hci_cmd_write_page_scan_type *cmd = data;
5792
5793         print_pscan_type(cmd->type);
5794 }
5795
5796 static void read_afh_assessment_mode_rsp(uint16_t index, const void *data,
5797                                                         uint8_t size)
5798 {
5799         const struct bt_hci_rsp_read_afh_assessment_mode *rsp = data;
5800
5801         print_status(rsp->status);
5802         print_enable("Mode", rsp->mode);
5803 }
5804
5805 static void write_afh_assessment_mode_cmd(uint16_t index, const void *data,
5806                                                         uint8_t size)
5807 {
5808         const struct bt_hci_cmd_write_afh_assessment_mode *cmd = data;
5809
5810         print_enable("Mode", cmd->mode);
5811 }
5812
5813 static void read_ext_inquiry_response_rsp(uint16_t index, const void *data,
5814                                                         uint8_t size)
5815 {
5816         const struct bt_hci_rsp_read_ext_inquiry_response *rsp = data;
5817
5818         print_status(rsp->status);
5819         print_fec(rsp->fec);
5820         print_eir(rsp->data, sizeof(rsp->data), false);
5821 }
5822
5823 static void write_ext_inquiry_response_cmd(uint16_t index, const void *data,
5824                                                         uint8_t size)
5825 {
5826         const struct bt_hci_cmd_write_ext_inquiry_response *cmd = data;
5827
5828         print_fec(cmd->fec);
5829         print_eir(cmd->data, sizeof(cmd->data), false);
5830 }
5831
5832 static void refresh_encrypt_key_cmd(uint16_t index, const void *data,
5833                                                         uint8_t size)
5834 {
5835         const struct bt_hci_cmd_refresh_encrypt_key *cmd = data;
5836
5837         print_handle(cmd->handle);
5838 }
5839
5840 static void read_simple_pairing_mode_rsp(uint16_t index, const void *data,
5841                                                         uint8_t size)
5842 {
5843         const struct bt_hci_rsp_read_simple_pairing_mode *rsp = data;
5844
5845         print_status(rsp->status);
5846         print_enable("Mode", rsp->mode);
5847 }
5848
5849 static void write_simple_pairing_mode_cmd(uint16_t index, const void *data,
5850                                                         uint8_t size)
5851 {
5852         const struct bt_hci_cmd_write_simple_pairing_mode *cmd = data;
5853
5854         print_enable("Mode", cmd->mode);
5855 }
5856
5857 static void read_local_oob_data_rsp(uint16_t index, const void *data,
5858                                                         uint8_t size)
5859 {
5860         const struct bt_hci_rsp_read_local_oob_data *rsp = data;
5861
5862         print_status(rsp->status);
5863         print_hash_p192(rsp->hash);
5864         print_randomizer_p192(rsp->randomizer);
5865 }
5866
5867 static void read_inquiry_resp_tx_power_rsp(uint16_t index, const void *data,
5868                                                         uint8_t size)
5869 {
5870         const struct bt_hci_rsp_read_inquiry_resp_tx_power *rsp = data;
5871
5872         print_status(rsp->status);
5873         print_power_level(rsp->level, NULL);
5874 }
5875
5876 static void write_inquiry_tx_power_cmd(uint16_t index, const void *data,
5877                                                         uint8_t size)
5878 {
5879         const struct bt_hci_cmd_write_inquiry_tx_power *cmd = data;
5880
5881         print_power_level(cmd->level, NULL);
5882 }
5883
5884 static void read_erroneous_reporting_rsp(uint16_t index, const void *data,
5885                                                         uint8_t size)
5886 {
5887         const struct bt_hci_rsp_read_erroneous_reporting *rsp = data;
5888
5889         print_status(rsp->status);
5890         print_enable("Mode", rsp->mode);
5891 }
5892
5893 static void write_erroneous_reporting_cmd(uint16_t index, const void *data,
5894                                                         uint8_t size)
5895 {
5896         const struct bt_hci_cmd_write_erroneous_reporting *cmd = data;
5897
5898         print_enable("Mode", cmd->mode);
5899 }
5900
5901 static void enhanced_flush_cmd(uint16_t index, const void *data, uint8_t size)
5902 {
5903         const struct bt_hci_cmd_enhanced_flush *cmd = data;
5904         const char *str;
5905
5906         print_handle(cmd->handle);
5907
5908         switch (cmd->type) {
5909         case 0x00:
5910                 str = "Automatic flushable only";
5911                 break;
5912         default:
5913                 str = "Reserved";
5914                 break;
5915         }
5916
5917         print_field("Type: %s (0x%2.2x)", str, cmd->type);
5918 }
5919
5920 static void send_keypress_notify_cmd(uint16_t index, const void *data,
5921                                                         uint8_t size)
5922 {
5923         const struct bt_hci_cmd_send_keypress_notify *cmd = data;
5924         const char *str;
5925
5926         print_bdaddr(cmd->bdaddr);
5927
5928         switch (cmd->type) {
5929         case 0x00:
5930                 str = "Passkey entry started";
5931                 break;
5932         case 0x01:
5933                 str = "Passkey digit entered";
5934                 break;
5935         case 0x02:
5936                 str = "Passkey digit erased";
5937                 break;
5938         case 0x03:
5939                 str = "Passkey cleared";
5940                 break;
5941         case 0x04:
5942                 str = "Passkey entry completed";
5943                 break;
5944         default:
5945                 str = "Reserved";
5946                 break;
5947         }
5948
5949         print_field("Type: %s (0x%2.2x)", str, cmd->type);
5950 }
5951
5952 static void send_keypress_notify_rsp(uint16_t index, const void *data,
5953                                                         uint8_t size)
5954 {
5955         const struct bt_hci_rsp_send_keypress_notify *rsp = data;
5956
5957         print_status(rsp->status);
5958         print_bdaddr(rsp->bdaddr);
5959 }
5960
5961 static void set_event_mask_page2_cmd(uint16_t index, const void *data,
5962                                                         uint8_t size)
5963 {
5964         const struct bt_hci_cmd_set_event_mask_page2 *cmd = data;
5965
5966         print_event_mask(cmd->mask, events_page2_table);
5967 }
5968
5969 static void read_location_data_rsp(uint16_t index, const void *data,
5970                                                         uint8_t size)
5971 {
5972         const struct bt_hci_rsp_read_location_data *rsp = data;
5973
5974         print_status(rsp->status);
5975         print_location_domain_aware(rsp->domain_aware);
5976         print_location_domain(rsp->domain);
5977         print_location_domain_options(rsp->domain_options);
5978         print_location_options(rsp->options);
5979 }
5980
5981 static void write_location_data_cmd(uint16_t index, const void *data,
5982                                                         uint8_t size)
5983 {
5984         const struct bt_hci_cmd_write_location_data *cmd = data;
5985
5986         print_location_domain_aware(cmd->domain_aware);
5987         print_location_domain(cmd->domain);
5988         print_location_domain_options(cmd->domain_options);
5989         print_location_options(cmd->options);
5990 }
5991
5992 static void read_flow_control_mode_rsp(uint16_t index, const void *data,
5993                                                         uint8_t size)
5994 {
5995         const struct bt_hci_rsp_read_flow_control_mode *rsp = data;
5996
5997         print_status(rsp->status);
5998         print_flow_control_mode(rsp->mode);
5999 }
6000
6001 static void write_flow_control_mode_cmd(uint16_t index, const void *data,
6002                                                         uint8_t size)
6003 {
6004         const struct bt_hci_cmd_write_flow_control_mode *cmd = data;
6005
6006         print_flow_control_mode(cmd->mode);
6007 }
6008
6009 static void read_enhanced_tx_power_cmd(uint16_t index, const void *data,
6010                                                         uint8_t size)
6011 {
6012         const struct bt_hci_cmd_read_enhanced_tx_power *cmd = data;
6013
6014         print_handle(cmd->handle);
6015         print_power_type(cmd->type);
6016 }
6017
6018 static void read_enhanced_tx_power_rsp(uint16_t index, const void *data,
6019                                                         uint8_t size)
6020 {
6021         const struct bt_hci_rsp_read_enhanced_tx_power *rsp = data;
6022
6023         print_status(rsp->status);
6024         print_handle(rsp->handle);
6025         print_power_level(rsp->level_gfsk, "GFSK");
6026         print_power_level(rsp->level_dqpsk, "DQPSK");
6027         print_power_level(rsp->level_8dpsk, "8DPSK");
6028 }
6029
6030 static void short_range_mode_cmd(uint16_t index, const void *data, uint8_t size)
6031 {
6032         const struct bt_hci_cmd_short_range_mode *cmd = data;
6033
6034         print_phy_handle(cmd->phy_handle);
6035         print_enable("Short range mode", cmd->mode);
6036 }
6037
6038 static void read_le_host_supported_rsp(uint16_t index, const void *data,
6039                                                         uint8_t size)
6040 {
6041         const struct bt_hci_rsp_read_le_host_supported *rsp = data;
6042
6043         print_status(rsp->status);
6044         print_field("Supported: 0x%2.2x", rsp->supported);
6045         print_field("Simultaneous: 0x%2.2x", rsp->simultaneous);
6046 }
6047
6048 static void write_le_host_supported_cmd(uint16_t index, const void *data,
6049                                                         uint8_t size)
6050 {
6051         const struct bt_hci_cmd_write_le_host_supported *cmd = data;
6052
6053         print_field("Supported: 0x%2.2x", cmd->supported);
6054         print_field("Simultaneous: 0x%2.2x", cmd->simultaneous);
6055 }
6056
6057 static void set_reserved_lt_addr_cmd(uint16_t index, const void *data,
6058                                                         uint8_t size)
6059 {
6060         const struct bt_hci_cmd_set_reserved_lt_addr *cmd = data;
6061
6062         print_lt_addr(cmd->lt_addr);
6063 }
6064
6065 static void set_reserved_lt_addr_rsp(uint16_t index, const void *data,
6066                                                         uint8_t size)
6067 {
6068         const struct bt_hci_rsp_set_reserved_lt_addr *rsp = data;
6069
6070         print_status(rsp->status);
6071         print_lt_addr(rsp->lt_addr);
6072 }
6073
6074 static void delete_reserved_lt_addr_cmd(uint16_t index, const void *data,
6075                                                         uint8_t size)
6076 {
6077         const struct bt_hci_cmd_delete_reserved_lt_addr *cmd = data;
6078
6079         print_lt_addr(cmd->lt_addr);
6080 }
6081
6082 static void delete_reserved_lt_addr_rsp(uint16_t index, const void *data,
6083                                                         uint8_t size)
6084 {
6085         const struct bt_hci_rsp_delete_reserved_lt_addr *rsp = data;
6086
6087         print_status(rsp->status);
6088         print_lt_addr(rsp->lt_addr);
6089 }
6090
6091 static void set_peripheral_broadcast_data_cmd(uint16_t index, const void *data,
6092                                                         uint8_t size)
6093 {
6094         const struct bt_hci_cmd_set_peripheral_broadcast_data *cmd = data;
6095
6096         print_lt_addr(cmd->lt_addr);
6097         print_broadcast_fragment(cmd->fragment);
6098         print_field("Length: %d", cmd->length);
6099
6100         if (size - 3 != cmd->length)
6101                 print_text(COLOR_ERROR, "invalid data size (%d != %d)",
6102                                                 size - 3, cmd->length);
6103
6104         packet_hexdump(data + 3, size - 3);
6105 }
6106
6107 static void set_peripheral_broadcast_data_rsp(uint16_t index, const void *data,
6108                                                         uint8_t size)
6109 {
6110         const struct bt_hci_rsp_set_peripheral_broadcast_data *rsp = data;
6111
6112         print_status(rsp->status);
6113         print_lt_addr(rsp->lt_addr);
6114 }
6115
6116 static void read_sync_train_params_rsp(uint16_t index, const void *data,
6117                                                         uint8_t size)
6118 {
6119         const struct bt_hci_rsp_read_sync_train_params *rsp = data;
6120
6121         print_status(rsp->status);
6122         print_interval(rsp->interval);
6123         print_field("Timeout: %.3f msec (0x%8.8x)",
6124                                         le32_to_cpu(rsp->timeout) * 0.625,
6125                                         le32_to_cpu(rsp->timeout));
6126         print_field("Service data: 0x%2.2x", rsp->service_data);
6127 }
6128
6129 static void write_sync_train_params_cmd(uint16_t index, const void *data,
6130                                                         uint8_t size)
6131 {
6132         const struct bt_hci_cmd_write_sync_train_params *cmd = data;
6133
6134         print_slot_625("Min interval", cmd->min_interval);
6135         print_slot_625("Max interval", cmd->max_interval);
6136         print_field("Timeout: %.3f msec (0x%8.8x)",
6137                                         le32_to_cpu(cmd->timeout) * 0.625,
6138                                         le32_to_cpu(cmd->timeout));
6139         print_field("Service data: 0x%2.2x", cmd->service_data);
6140 }
6141
6142 static void write_sync_train_params_rsp(uint16_t index, const void *data,
6143                                                         uint8_t size)
6144 {
6145         const struct bt_hci_rsp_write_sync_train_params *rsp = data;
6146
6147         print_status(rsp->status);
6148         print_interval(rsp->interval);
6149 }
6150
6151 static void read_secure_conn_support_rsp(uint16_t index, const void *data,
6152                                                         uint8_t size)
6153 {
6154         const struct bt_hci_rsp_read_secure_conn_support *rsp = data;
6155
6156         print_status(rsp->status);
6157         print_enable("Support", rsp->support);
6158 }
6159
6160 static void write_secure_conn_support_cmd(uint16_t index, const void *data,
6161                                                         uint8_t size)
6162 {
6163         const struct bt_hci_cmd_write_secure_conn_support *cmd = data;
6164
6165         print_enable("Support", cmd->support);
6166 }
6167
6168 static void read_auth_payload_timeout_cmd(uint16_t index, const void *data,
6169                                                         uint8_t size)
6170 {
6171         const struct bt_hci_cmd_read_auth_payload_timeout *cmd = data;
6172
6173         print_handle(cmd->handle);
6174 }
6175
6176 static void read_auth_payload_timeout_rsp(uint16_t index, const void *data,
6177                                                         uint8_t size)
6178 {
6179         const struct bt_hci_rsp_read_auth_payload_timeout *rsp = data;
6180
6181         print_status(rsp->status);
6182         print_handle(rsp->handle);
6183         print_auth_payload_timeout(rsp->timeout);
6184 }
6185
6186 static void write_auth_payload_timeout_cmd(uint16_t index, const void *data,
6187                                                         uint8_t size)
6188 {
6189         const struct bt_hci_cmd_write_auth_payload_timeout *cmd = data;
6190
6191         print_handle(cmd->handle);
6192         print_auth_payload_timeout(cmd->timeout);
6193 }
6194
6195 static void write_auth_payload_timeout_rsp(uint16_t index, const void *data,
6196                                                         uint8_t size)
6197 {
6198         const struct bt_hci_rsp_write_auth_payload_timeout *rsp = data;
6199
6200         print_status(rsp->status);
6201         print_handle(rsp->handle);
6202 }
6203
6204 static void read_local_oob_ext_data_rsp(uint16_t index, const void *data,
6205                                                         uint8_t size)
6206 {
6207         const struct bt_hci_rsp_read_local_oob_ext_data *rsp = data;
6208
6209         print_status(rsp->status);
6210         print_hash_p192(rsp->hash192);
6211         print_randomizer_p192(rsp->randomizer192);
6212         print_hash_p256(rsp->hash256);
6213         print_randomizer_p256(rsp->randomizer256);
6214 }
6215
6216 static void read_ext_page_timeout_rsp(uint16_t index, const void *data,
6217                                                         uint8_t size)
6218 {
6219         const struct bt_hci_rsp_read_ext_page_timeout *rsp = data;
6220
6221         print_status(rsp->status);
6222         print_timeout(rsp->timeout);
6223 }
6224
6225 static void write_ext_page_timeout_cmd(uint16_t index, const void *data,
6226                                                         uint8_t size)
6227 {
6228         const struct bt_hci_cmd_write_ext_page_timeout *cmd = data;
6229
6230         print_timeout(cmd->timeout);
6231 }
6232
6233 static void read_ext_inquiry_length_rsp(uint16_t index, const void *data,
6234                                                         uint8_t size)
6235 {
6236         const struct bt_hci_rsp_read_ext_inquiry_length *rsp = data;
6237
6238         print_status(rsp->status);
6239         print_interval(rsp->interval);
6240 }
6241
6242 static void write_ext_inquiry_length_cmd(uint16_t index, const void *data,
6243                                                         uint8_t size)
6244 {
6245         const struct bt_hci_cmd_write_ext_inquiry_length *cmd = data;
6246
6247         print_interval(cmd->interval);
6248 }
6249
6250 static void read_local_version_rsp(uint16_t index, const void *data,
6251                                                         uint8_t size)
6252 {
6253         const struct bt_hci_rsp_read_local_version *rsp = data;
6254         uint16_t manufacturer;
6255
6256         print_status(rsp->status);
6257         print_hci_version(rsp->hci_ver, rsp->hci_rev);
6258
6259         manufacturer = le16_to_cpu(rsp->manufacturer);
6260
6261         if (index_current < MAX_INDEX) {
6262                 switch (index_list[index_current].type) {
6263                 case HCI_PRIMARY:
6264                         print_lmp_version(rsp->lmp_ver, rsp->lmp_subver);
6265                         break;
6266                 case HCI_AMP:
6267                         print_pal_version(rsp->lmp_ver, rsp->lmp_subver);
6268                         break;
6269                 }
6270
6271                 index_list[index_current].manufacturer = manufacturer;
6272         }
6273
6274         print_manufacturer(rsp->manufacturer);
6275
6276         switch (manufacturer) {
6277         case 15:
6278                 print_manufacturer_broadcom(rsp->lmp_subver, rsp->hci_rev);
6279                 break;
6280         }
6281 }
6282
6283 static void read_local_commands_rsp(uint16_t index, const void *data,
6284                                                         uint8_t size)
6285 {
6286         const struct bt_hci_rsp_read_local_commands *rsp = data;
6287
6288         print_status(rsp->status);
6289         print_commands(rsp->commands);
6290 }
6291
6292 static void read_local_features_rsp(uint16_t index, const void *data,
6293                                                         uint8_t size)
6294 {
6295         const struct bt_hci_rsp_read_local_features *rsp = data;
6296
6297         print_status(rsp->status);
6298         print_features(0, rsp->features, 0x00);
6299 }
6300
6301 static void read_local_ext_features_cmd(uint16_t index, const void *data,
6302                                                         uint8_t size)
6303 {
6304         const struct bt_hci_cmd_read_local_ext_features *cmd = data;
6305
6306         print_field("Page: %d", cmd->page);
6307 }
6308
6309 static void read_local_ext_features_rsp(uint16_t index, const void *data,
6310                                                         uint8_t size)
6311 {
6312         const struct bt_hci_rsp_read_local_ext_features *rsp = data;
6313
6314         print_status(rsp->status);
6315         print_field("Page: %d/%d", rsp->page, rsp->max_page);
6316         print_features(rsp->page, rsp->features, 0x00);
6317 }
6318
6319 static void read_buffer_size_rsp(uint16_t index, const void *data, uint8_t size)
6320 {
6321         const struct bt_hci_rsp_read_buffer_size *rsp = data;
6322
6323         print_status(rsp->status);
6324         print_field("ACL MTU: %-4d ACL max packet: %d",
6325                                         le16_to_cpu(rsp->acl_mtu),
6326                                         le16_to_cpu(rsp->acl_max_pkt));
6327         print_field("SCO MTU: %-4d SCO max packet: %d",
6328                                         rsp->sco_mtu,
6329                                         le16_to_cpu(rsp->sco_max_pkt));
6330 }
6331
6332 static void read_country_code_rsp(uint16_t index, const void *data,
6333                                                         uint8_t size)
6334 {
6335         const struct bt_hci_rsp_read_country_code *rsp = data;
6336         const char *str;
6337
6338         print_status(rsp->status);
6339
6340         switch (rsp->code) {
6341         case 0x00:
6342                 str = "North America, Europe*, Japan";
6343                 break;
6344         case 0x01:
6345                 str = "France";
6346                 break;
6347         default:
6348                 str = "Reserved";
6349                 break;
6350         }
6351
6352         print_field("Country code: %s (0x%2.2x)", str, rsp->code);
6353 }
6354
6355 static void read_bd_addr_rsp(uint16_t index, const void *data, uint8_t size)
6356 {
6357         const struct bt_hci_rsp_read_bd_addr *rsp = data;
6358
6359         print_status(rsp->status);
6360         print_bdaddr(rsp->bdaddr);
6361
6362         if (index_current < MAX_INDEX)
6363                 memcpy(index_list[index_current].bdaddr, rsp->bdaddr, 6);
6364 }
6365
6366 static void read_data_block_size_rsp(uint16_t index, const void *data,
6367                                                         uint8_t size)
6368 {
6369         const struct bt_hci_rsp_read_data_block_size *rsp = data;
6370
6371         print_status(rsp->status);
6372         print_field("Max ACL length: %d", le16_to_cpu(rsp->max_acl_len));
6373         print_field("Block length: %d", le16_to_cpu(rsp->block_len));
6374         print_field("Num blocks: %d", le16_to_cpu(rsp->num_blocks));
6375 }
6376
6377 static void read_local_codecs_rsp(uint16_t index, const void *data,
6378                                                         uint8_t size)
6379 {
6380         const struct bt_hci_rsp_read_local_codecs *rsp = data;
6381         uint8_t i, num_vnd_codecs;
6382
6383         if (rsp->num_codecs + 3 > size) {
6384                 print_field("Invalid number of codecs.");
6385                 return;
6386         }
6387
6388         print_status(rsp->status);
6389         print_field("Number of supported codecs: %d", rsp->num_codecs);
6390
6391         for (i = 0; i < rsp->num_codecs; i++)
6392                 print_codec_id("  Codec", rsp->codec[i]);
6393
6394         num_vnd_codecs = rsp->codec[rsp->num_codecs];
6395
6396         print_field("Number of vendor codecs: %d", num_vnd_codecs);
6397
6398         packet_hexdump(data + rsp->num_codecs + 3,
6399                                         size - rsp->num_codecs - 3);
6400 }
6401
6402 static void print_codecs(const void *data, int i)
6403 {
6404         const struct bt_hci_codec *codec = data;
6405
6406         print_codec("  Codec", codec);
6407 }
6408
6409 typedef void (*print_list_func_t)(const void *data, int i);
6410
6411 static void print_list(const void *data, uint8_t size, int num_items,
6412                                 size_t item_size, print_list_func_t func)
6413 {
6414         int i;
6415
6416         for (i = 0; size >= item_size && num_items; i++) {
6417                 if (func)
6418                         func(data, i);
6419                 data += item_size;
6420                 size -= item_size;
6421                 num_items--;
6422         }
6423
6424         if (num_items)
6425                 print_hex_field("", data, size);
6426 }
6427
6428 static void print_vnd_codecs_v2(const void *data, int i)
6429 {
6430         const struct bt_hci_vnd_codec_v2 *codec = data;
6431         uint8_t mask;
6432
6433         packet_print_company("  Company ID", le16_to_cpu(codec->cid));
6434         print_field("  Vendor Codec ID: 0x%4.4x", le16_to_cpu(codec->vid));
6435         print_field("  Logical Transport Type: 0x%02x", codec->transport);
6436         mask = print_bitfield(4, codec->transport, codec_transport_table);
6437         if (mask)
6438                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
6439                                 "  Unknown transport (0x%2.2x)", mask);
6440 }
6441
6442 static void read_local_codecs_rsp_v2(uint16_t index, const void *data,
6443                                                         uint8_t size)
6444 {
6445         const struct bt_hci_rsp_read_local_codecs_v2 *rsp = data;
6446         uint8_t num_vnd_codecs;
6447
6448         if (rsp->num_codecs + 3 > size) {
6449                 print_field("Invalid number of codecs.");
6450                 return;
6451         }
6452
6453         print_status(rsp->status);
6454         print_field("Number of supported codecs: %d", rsp->num_codecs);
6455
6456         size -= sizeof(*rsp);
6457
6458         if (size < rsp->num_codecs * sizeof(*rsp->codec)) {
6459                 print_field("Invalid number of codecs.");
6460                 return;
6461         }
6462
6463         print_list(rsp->codec, size, rsp->num_codecs, sizeof(*rsp->codec),
6464                                                         print_codecs);
6465
6466         size -= rsp->num_codecs * sizeof(*rsp->codec);
6467
6468         if (size < sizeof(uint8_t)) {
6469                 print_field("Invalid number of vendor codecs.");
6470                 return;
6471         }
6472
6473         num_vnd_codecs = rsp->codec[rsp->num_codecs].id;
6474
6475         size -= 1;
6476
6477         print_field("Number of vendor codecs: %d", num_vnd_codecs);
6478
6479         if (size < num_vnd_codecs * sizeof(*rsp->codec)) {
6480                 print_field("Invalid number of vendor codecs.");
6481                 return;
6482         }
6483
6484         print_list(&rsp->codec[rsp->num_codecs] + 1, size, num_vnd_codecs,
6485                         sizeof(struct bt_hci_vnd_codec_v2),
6486                         print_vnd_codecs_v2);
6487 }
6488
6489 static void print_path_direction(const char *prefix, uint8_t dir)
6490 {
6491         const char *str;
6492
6493         switch (dir) {
6494         case 0x00:
6495                 str = "Input (Host to Controller)";
6496                 break;
6497         case 0x01:
6498                 str = "Output (Controller to Host)";
6499                 break;
6500         default:
6501                 str = "Reserved";
6502                 break;
6503         }
6504
6505         print_field("%s: %s (0x%2.2x)", prefix, str, dir);
6506 }
6507
6508 static void print_vnd_codec(const char *label,
6509                                 const struct bt_hci_vnd_codec *codec)
6510 {
6511         uint8_t mask;
6512
6513         print_codec_id(label, codec->id);
6514
6515         if (codec->id == 0xff) {
6516                 packet_print_company("Company Codec ID",
6517                                         le16_to_cpu(codec->cid));
6518                 print_field("Vendor Codec ID: %d", le16_to_cpu(codec->vid));
6519         }
6520
6521         print_field("Logical Transport Type: 0x%02x", codec->transport);
6522         mask = print_bitfield(2, codec->transport, codec_transport_table);
6523         if (mask)
6524                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
6525                                 "  Unknown transport (0x%2.2x)", mask);
6526 }
6527
6528 static void read_local_codec_caps_cmd(uint16_t index, const void *data,
6529                                                         uint8_t size)
6530 {
6531         const struct bt_hci_cmd_read_local_codec_caps *cmd = data;
6532
6533         print_vnd_codec("Codec", &cmd->codec);
6534         print_path_direction("Direction", cmd->dir);
6535 }
6536
6537 static void read_local_codec_caps_rsp(uint16_t index, const void *data,
6538                                                         uint8_t size)
6539 {
6540         const struct bt_hci_rsp_read_local_codec_caps *rsp = data;
6541         uint8_t i;
6542
6543         print_status(rsp->status);
6544         print_field("Number of codec capabilities: %d", rsp->num);
6545
6546         data += sizeof(*rsp);
6547         size -= sizeof(*rsp);
6548
6549         for (i = 0; i < rsp->num; i++) {
6550                 const struct bt_hci_codec_caps *caps = data;
6551
6552                 if (size < sizeof(*caps)) {
6553                         print_field("Invalid capabilities: %u < %zu",
6554                                                 size, sizeof(*caps));
6555                         return;
6556                 }
6557
6558                 print_field(" Capabilities #%u:", i);
6559                 packet_hexdump(caps->data, caps->len);
6560
6561                 data += 1 + caps->len;
6562                 size -= 1 + caps->len;
6563         }
6564 }
6565
6566 static void read_local_ctrl_delay_cmd(uint16_t index, const void *data,
6567                                                         uint8_t size)
6568 {
6569         const struct bt_hci_cmd_read_local_ctrl_delay *cmd = data;
6570
6571         print_vnd_codec("Codec", &cmd->codec);
6572         print_path_direction("Direction", cmd->dir);
6573         print_field("Length Codec Configuration: %u", cmd->codec_cfg_len);
6574 }
6575
6576 static void config_data_path_cmd(uint16_t index, const void *data, uint8_t size)
6577 {
6578         const struct bt_hci_cmd_config_data_path *cmd = data;
6579
6580         print_path_direction("Direction", cmd->dir);
6581         print_field("ID: %u", cmd->id);
6582         print_field("Vendor Specific Config Length: %u", cmd->vnd_config_len);
6583         print_hex_field("Vendor Specific Config", cmd->vnd_config,
6584                                                 cmd->vnd_config_len);
6585 }
6586
6587 static void print_usec_interval(const char *prefix, const uint8_t interval[3])
6588 {
6589         uint32_t value = get_le24(interval);
6590
6591         print_field("%s: %u us (0x%6.6x)", prefix, value, value);
6592 }
6593
6594 static void read_local_ctrl_delay_rsp(uint16_t index, const void *data,
6595                                                         uint8_t size)
6596 {
6597         const struct bt_hci_rsp_read_local_ctrl_delay *rsp = data;
6598
6599         print_status(rsp->status);
6600         print_usec_interval("Minimum Controller delay", rsp->min_delay);
6601         print_usec_interval("Maximum Controller delay", rsp->max_delay);
6602 }
6603
6604 static void read_local_pairing_options_rsp(uint16_t index, const void *data,
6605                                                         uint8_t size)
6606 {
6607         const struct bt_hci_rsp_read_local_pairing_options *rsp = data;
6608
6609         print_status(rsp->status);
6610         print_field("Pairing options: 0x%2.2x", rsp->pairing_options);
6611         print_field("Max encryption key size: %u octets", rsp->max_key_size);
6612 }
6613
6614 static void read_failed_contact_counter_cmd(uint16_t index, const void *data,
6615                                                         uint8_t size)
6616 {
6617         const struct bt_hci_cmd_read_failed_contact_counter *cmd = data;
6618
6619         print_handle(cmd->handle);
6620 }
6621
6622 static void read_failed_contact_counter_rsp(uint16_t index, const void *data,
6623                                                         uint8_t size)
6624 {
6625         const struct bt_hci_rsp_read_failed_contact_counter *rsp = data;
6626
6627         print_status(rsp->status);
6628         print_handle(rsp->handle);
6629         print_field("Counter: %u", le16_to_cpu(rsp->counter));
6630 }
6631
6632 static void reset_failed_contact_counter_cmd(uint16_t index, const void *data,
6633                                                         uint8_t size)
6634 {
6635         const struct bt_hci_cmd_reset_failed_contact_counter *cmd = data;
6636
6637         print_handle(cmd->handle);
6638 }
6639
6640 static void reset_failed_contact_counter_rsp(uint16_t index, const void *data,
6641                                                         uint8_t size)
6642 {
6643         const struct bt_hci_rsp_reset_failed_contact_counter *rsp = data;
6644
6645         print_status(rsp->status);
6646         print_handle(rsp->handle);
6647 }
6648
6649 static void read_link_quality_cmd(uint16_t index, const void *data,
6650                                                         uint8_t size)
6651 {
6652         const struct bt_hci_cmd_read_link_quality *cmd = data;
6653
6654         print_handle(cmd->handle);
6655 }
6656
6657 static void read_link_quality_rsp(uint16_t index, const void *data,
6658                                                         uint8_t size)
6659 {
6660         const struct bt_hci_rsp_read_link_quality *rsp = data;
6661
6662         print_status(rsp->status);
6663         print_handle(rsp->handle);
6664         print_field("Link quality: 0x%2.2x", rsp->link_quality);
6665 }
6666
6667 static void read_rssi_cmd(uint16_t index, const void *data, uint8_t size)
6668 {
6669         const struct bt_hci_cmd_read_rssi *cmd = data;
6670
6671         print_handle(cmd->handle);
6672 }
6673
6674 static void read_rssi_rsp(uint16_t index, const void *data, uint8_t size)
6675 {
6676         const struct bt_hci_rsp_read_rssi *rsp = data;
6677
6678         print_status(rsp->status);
6679         print_handle(rsp->handle);
6680         print_rssi(rsp->rssi);
6681 }
6682
6683 static void read_afh_channel_map_cmd(uint16_t index, const void *data,
6684                                                         uint8_t size)
6685 {
6686         const struct bt_hci_cmd_read_afh_channel_map *cmd = data;
6687
6688         print_handle(cmd->handle);
6689 }
6690
6691 static void read_afh_channel_map_rsp(uint16_t index, const void *data,
6692                                                         uint8_t size)
6693 {
6694         const struct bt_hci_rsp_read_afh_channel_map *rsp = data;
6695
6696         print_status(rsp->status);
6697         print_handle(rsp->handle);
6698         print_enable("Mode", rsp->mode);
6699         print_channel_map(rsp->map);
6700 }
6701
6702 static void read_clock_cmd(uint16_t index, const void *data, uint8_t size)
6703 {
6704         const struct bt_hci_cmd_read_clock *cmd = data;
6705
6706         print_handle(cmd->handle);
6707         print_clock_type(cmd->type);
6708 }
6709
6710 static void read_clock_rsp(uint16_t index, const void *data, uint8_t size)
6711 {
6712         const struct bt_hci_rsp_read_clock *rsp = data;
6713
6714         print_status(rsp->status);
6715         print_handle(rsp->handle);
6716         print_clock(rsp->clock);
6717         print_clock_accuracy(rsp->accuracy);
6718 }
6719
6720 static void read_encrypt_key_size_cmd(uint16_t index, const void *data,
6721                                                         uint8_t size)
6722 {
6723         const struct bt_hci_cmd_read_encrypt_key_size *cmd = data;
6724
6725         print_handle(cmd->handle);
6726 }
6727
6728 static void read_encrypt_key_size_rsp(uint16_t index, const void *data,
6729                                                         uint8_t size)
6730 {
6731         const struct bt_hci_rsp_read_encrypt_key_size *rsp = data;
6732
6733         print_status(rsp->status);
6734         print_handle(rsp->handle);
6735         print_key_size(rsp->key_size);
6736 }
6737
6738 static void read_local_amp_info_rsp(uint16_t index, const void *data,
6739                                                         uint8_t size)
6740 {
6741         const struct bt_hci_rsp_read_local_amp_info *rsp = data;
6742         const char *str;
6743
6744         print_status(rsp->status);
6745         print_amp_status(rsp->amp_status);
6746
6747         print_field("Total bandwidth: %d kbps", le32_to_cpu(rsp->total_bw));
6748         print_field("Max guaranteed bandwidth: %d kbps",
6749                                                 le32_to_cpu(rsp->max_bw));
6750         print_field("Min latency: %d", le32_to_cpu(rsp->min_latency));
6751         print_field("Max PDU size: %d", le32_to_cpu(rsp->max_pdu));
6752
6753         switch (rsp->amp_type) {
6754         case 0x00:
6755                 str = "Primary BR/EDR Controller";
6756                 break;
6757         case 0x01:
6758                 str = "802.11 AMP Controller";
6759                 break;
6760         default:
6761                 str = "Reserved";
6762                 break;
6763         }
6764
6765         print_field("Controller type: %s (0x%2.2x)", str, rsp->amp_type);
6766
6767         print_field("PAL capabilities: 0x%4.4x", le16_to_cpu(rsp->pal_cap));
6768         print_field("Max ASSOC length: %d", le16_to_cpu(rsp->max_assoc_len));
6769         print_field("Max flush timeout: %d", le32_to_cpu(rsp->max_flush_to));
6770         print_field("Best effort flush timeout: %d",
6771                                         le32_to_cpu(rsp->be_flush_to));
6772 }
6773
6774 static void read_local_amp_assoc_cmd(uint16_t index, const void *data,
6775                                                         uint8_t size)
6776 {
6777         const struct bt_hci_cmd_read_local_amp_assoc *cmd = data;
6778
6779         print_phy_handle(cmd->phy_handle);
6780         print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
6781         print_field("Max ASSOC length: %d", le16_to_cpu(cmd->max_assoc_len));
6782 }
6783
6784 static void read_local_amp_assoc_rsp(uint16_t index, const void *data,
6785                                                         uint8_t size)
6786 {
6787         const struct bt_hci_rsp_read_local_amp_assoc *rsp = data;
6788
6789         print_status(rsp->status);
6790         print_phy_handle(rsp->phy_handle);
6791         print_field("Remaining ASSOC length: %d",
6792                                         le16_to_cpu(rsp->remain_assoc_len));
6793
6794         packet_hexdump(data + 4, size - 4);
6795 }
6796
6797 static void write_remote_amp_assoc_cmd(uint16_t index, const void *data,
6798                                                         uint8_t size)
6799 {
6800         const struct bt_hci_cmd_write_remote_amp_assoc *cmd = data;
6801
6802         print_phy_handle(cmd->phy_handle);
6803         print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
6804         print_field("Remaining ASSOC length: %d",
6805                                         le16_to_cpu(cmd->remain_assoc_len));
6806
6807         packet_hexdump(data + 5, size - 5);
6808 }
6809
6810 static void write_remote_amp_assoc_rsp(uint16_t index, const void *data,
6811                                                         uint8_t size)
6812 {
6813         const struct bt_hci_rsp_write_remote_amp_assoc *rsp = data;
6814
6815         print_status(rsp->status);
6816         print_phy_handle(rsp->phy_handle);
6817 }
6818
6819 static void get_mws_transport_config_rsp(uint16_t index, const void *data,
6820                                                         uint8_t size)
6821 {
6822         const struct bt_hci_rsp_get_mws_transport_config *rsp = data;
6823         uint8_t sum_baud_rates = 0;
6824         int i;
6825
6826         print_status(rsp->status);
6827         print_field("Number of transports: %d", rsp->num_transports);
6828
6829         for (i = 0; i < rsp->num_transports; i++) {
6830                 uint8_t transport = rsp->transport[0];
6831                 uint8_t num_baud_rates = rsp->transport[1];
6832                 const char *str;
6833
6834                 switch (transport) {
6835                 case 0x00:
6836                         str = "Disbabled";
6837                         break;
6838                 case 0x01:
6839                         str = "WCI-1";
6840                         break;
6841                 case 0x02:
6842                         str = "WCI-2";
6843                         break;
6844                 default:
6845                         str = "Reserved";
6846                         break;
6847                 }
6848
6849                 print_field("  Transport layer: %s (0x%2.2x)", str, transport);
6850                 print_field("  Number of baud rates: %d", num_baud_rates);
6851
6852                 sum_baud_rates += num_baud_rates;
6853         }
6854
6855         print_field("Baud rate list: %u entr%s", sum_baud_rates,
6856                                         sum_baud_rates == 1 ? "y" : "ies");
6857
6858         for (i = 0; i < sum_baud_rates; i++) {
6859                 uint32_t to_baud_rate, from_baud_rate;
6860
6861                 to_baud_rate = get_le32(data + 2 +
6862                                         rsp->num_transports * 2 + i * 4);
6863                 from_baud_rate = get_le32(data + 2 +
6864                                                 rsp->num_transports * 2 +
6865                                                 sum_baud_rates * 4 + i * 4);
6866
6867                 print_field("  Bluetooth to MWS: %d", to_baud_rate);
6868                 print_field("  MWS to Bluetooth: %d", from_baud_rate);
6869         }
6870
6871         packet_hexdump(data + 2 + rsp->num_transports * 2 + sum_baud_rates * 8,
6872                 size - 2 - rsp->num_transports * 2 - sum_baud_rates * 8);
6873 }
6874
6875 static void set_triggered_clock_capture_cmd(uint16_t index, const void *data,
6876                                                         uint8_t size)
6877 {
6878         const struct bt_hci_cmd_set_triggered_clock_capture *cmd = data;
6879
6880         print_handle(cmd->handle);
6881         print_enable("Capture", cmd->enable);
6882         print_clock_type(cmd->type);
6883         print_lpo_allowed(cmd->lpo_allowed);
6884         print_field("Clock captures to filter: %u", cmd->num_filter);
6885 }
6886
6887 static void read_loopback_mode_rsp(uint16_t index, const void *data,
6888                                                         uint8_t size)
6889 {
6890         const struct bt_hci_rsp_read_loopback_mode *rsp = data;
6891
6892         print_status(rsp->status);
6893         print_loopback_mode(rsp->mode);
6894 }
6895
6896 static void write_loopback_mode_cmd(uint16_t index, const void *data,
6897                                                         uint8_t size)
6898 {
6899         const struct bt_hci_cmd_write_loopback_mode *cmd = data;
6900
6901         print_loopback_mode(cmd->mode);
6902 }
6903
6904 static void write_ssp_debug_mode_cmd(uint16_t index, const void *data,
6905                                                         uint8_t size)
6906 {
6907         const struct bt_hci_cmd_write_ssp_debug_mode *cmd = data;
6908
6909         print_enable("Debug Mode", cmd->mode);
6910 }
6911
6912 static void le_set_event_mask_cmd(uint16_t index, const void *data,
6913                                                         uint8_t size)
6914 {
6915         const struct bt_hci_cmd_le_set_event_mask *cmd = data;
6916
6917         print_event_mask(cmd->mask, events_le_table);
6918 }
6919
6920 static void le_read_buffer_size_rsp(uint16_t index, const void *data,
6921                                                         uint8_t size)
6922 {
6923         const struct bt_hci_rsp_le_read_buffer_size *rsp = data;
6924
6925         print_status(rsp->status);
6926         print_field("Data packet length: %d", le16_to_cpu(rsp->le_mtu));
6927         print_field("Num data packets: %d", rsp->le_max_pkt);
6928 }
6929
6930 static void le_read_local_features_rsp(uint16_t index, const void *data,
6931                                                         uint8_t size)
6932 {
6933         const struct bt_hci_rsp_le_read_local_features *rsp = data;
6934
6935         print_status(rsp->status);
6936         print_features(0, rsp->features, 0x01);
6937 }
6938
6939 static void le_set_random_address_cmd(uint16_t index, const void *data,
6940                                                         uint8_t size)
6941 {
6942         const struct bt_hci_cmd_le_set_random_address *cmd = data;
6943
6944         print_addr("Address", cmd->addr, 0x01);
6945 }
6946
6947 static void le_set_adv_parameters_cmd(uint16_t index, const void *data,
6948                                                         uint8_t size)
6949 {
6950         const struct bt_hci_cmd_le_set_adv_parameters *cmd = data;
6951         const char *str;
6952
6953         print_slot_625("Min advertising interval", cmd->min_interval);
6954         print_slot_625("Max advertising interval", cmd->max_interval);
6955
6956         switch (cmd->type) {
6957         case 0x00:
6958                 str = "Connectable undirected - ADV_IND";
6959                 break;
6960         case 0x01:
6961                 str = "Connectable directed - ADV_DIRECT_IND (high duty cycle)";
6962                 break;
6963         case 0x02:
6964                 str = "Scannable undirected - ADV_SCAN_IND";
6965                 break;
6966         case 0x03:
6967                 str = "Non connectable undirected - ADV_NONCONN_IND";
6968                 break;
6969         case 0x04:
6970                 str = "Connectable directed - ADV_DIRECT_IND (low duty cycle)";
6971                 break;
6972         default:
6973                 str = "Reserved";
6974                 break;
6975         }
6976
6977         print_field("Type: %s (0x%2.2x)", str, cmd->type);
6978
6979         print_own_addr_type(cmd->own_addr_type);
6980         print_addr_type("Direct address type", cmd->direct_addr_type);
6981         print_addr("Direct address", cmd->direct_addr, cmd->direct_addr_type);
6982         print_adv_channel_map("Channel map", cmd->channel_map);
6983         print_adv_filter_policy("Filter policy", cmd->filter_policy);
6984 }
6985
6986 static void le_read_adv_tx_power_rsp(uint16_t index, const void *data,
6987                                                         uint8_t size)
6988 {
6989         const struct bt_hci_rsp_le_read_adv_tx_power *rsp = data;
6990
6991         print_status(rsp->status);
6992         print_power_level(rsp->level, NULL);
6993 }
6994
6995 static void le_set_adv_data_cmd(uint16_t index, const void *data, uint8_t size)
6996 {
6997         const struct bt_hci_cmd_le_set_adv_data *cmd = data;
6998
6999         print_field("Length: %d", cmd->len);
7000         print_eir(cmd->data, cmd->len, true);
7001 }
7002
7003 static void le_set_scan_rsp_data_cmd(uint16_t index, const void *data,
7004                                                         uint8_t size)
7005 {
7006         const struct bt_hci_cmd_le_set_scan_rsp_data *cmd = data;
7007
7008         print_field("Length: %d", cmd->len);
7009         print_eir(cmd->data, cmd->len, true);
7010 }
7011
7012 static void le_set_adv_enable_cmd(uint16_t index, const void *data,
7013                                                         uint8_t size)
7014 {
7015         const struct bt_hci_cmd_le_set_adv_enable *cmd = data;
7016
7017         print_enable("Advertising", cmd->enable);
7018 }
7019
7020 static void print_scan_type(const char *label, uint8_t type)
7021 {
7022         const char *str;
7023
7024         switch (type) {
7025         case 0x00:
7026                 str = "Passive";
7027                 break;
7028         case 0x01:
7029                 str = "Active";
7030                 break;
7031         default:
7032                 str = "Reserved";
7033                 break;
7034         }
7035
7036         print_field("%s: %s (0x%2.2x)", label, str, type);
7037 }
7038
7039 static void print_scan_filter_policy(uint8_t policy)
7040 {
7041         const char *str;
7042
7043         switch (policy) {
7044         case 0x00:
7045                 str = "Accept all advertisement";
7046                 break;
7047         case 0x01:
7048                 str = "Ignore not in accept list";
7049                 break;
7050         case 0x02:
7051                 str = "Accept all advertisement, inc. directed unresolved RPA";
7052                 break;
7053         case 0x03:
7054                 str = "Ignore not in accept list, exc. directed unresolved RPA";
7055                 break;
7056         default:
7057                 str = "Reserved";
7058                 break;
7059         }
7060
7061         print_field("Filter policy: %s (0x%2.2x)", str, policy);
7062 }
7063
7064 static void le_set_scan_parameters_cmd(uint16_t index, const void *data,
7065                                                         uint8_t size)
7066 {
7067         const struct bt_hci_cmd_le_set_scan_parameters *cmd = data;
7068
7069         print_scan_type("Type", cmd->type);
7070         print_interval(cmd->interval);
7071         print_window(cmd->window);
7072         print_own_addr_type(cmd->own_addr_type);
7073         print_scan_filter_policy(cmd->filter_policy);
7074 }
7075
7076 static void le_set_scan_enable_cmd(uint16_t index, const void *data,
7077                                                         uint8_t size)
7078 {
7079         const struct bt_hci_cmd_le_set_scan_enable *cmd = data;
7080
7081         print_enable("Scanning", cmd->enable);
7082         print_enable("Filter duplicates", cmd->filter_dup);
7083 }
7084
7085 static void le_create_conn_cmd(uint16_t index, const void *data, uint8_t size)
7086 {
7087         const struct bt_hci_cmd_le_create_conn *cmd = data;
7088         const char *str;
7089
7090         print_slot_625("Scan interval", cmd->scan_interval);
7091         print_slot_625("Scan window", cmd->scan_window);
7092
7093         switch (cmd->filter_policy) {
7094         case 0x00:
7095                 str = "Accept list is not used";
7096                 break;
7097         case 0x01:
7098                 str = "Accept list is used";
7099                 break;
7100         default:
7101                 str = "Reserved";
7102                 break;
7103         }
7104
7105         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
7106
7107         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
7108         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
7109         print_own_addr_type(cmd->own_addr_type);
7110
7111         print_slot_125("Min connection interval", cmd->min_interval);
7112         print_slot_125("Max connection interval", cmd->max_interval);
7113         print_conn_latency("Connection latency", cmd->latency);
7114         print_field("Supervision timeout: %d msec (0x%4.4x)",
7115                                         le16_to_cpu(cmd->supv_timeout) * 10,
7116                                         le16_to_cpu(cmd->supv_timeout));
7117         print_slot_625("Min connection length", cmd->min_length);
7118         print_slot_625("Max connection length", cmd->max_length);
7119 }
7120
7121 static void le_read_accept_list_size_rsp(uint16_t index, const void *data,
7122                                                         uint8_t size)
7123 {
7124         const struct bt_hci_rsp_le_read_accept_list_size *rsp = data;
7125
7126         print_status(rsp->status);
7127         print_field("Size: %u", rsp->size);
7128 }
7129
7130 static void le_add_to_accept_list_cmd(uint16_t index, const void *data,
7131                                                         uint8_t size)
7132 {
7133         const struct bt_hci_cmd_le_add_to_accept_list *cmd = data;
7134
7135         print_addr_type("Address type", cmd->addr_type);
7136         print_addr("Address", cmd->addr, cmd->addr_type);
7137 }
7138
7139 static void le_remove_from_accept_list_cmd(uint16_t index, const void *data,
7140                                                         uint8_t size)
7141 {
7142         const struct bt_hci_cmd_le_remove_from_accept_list *cmd = data;
7143
7144         print_addr_type("Address type", cmd->addr_type);
7145         print_addr("Address", cmd->addr, cmd->addr_type);
7146 }
7147
7148 static void le_conn_update_cmd(uint16_t index, const void *data, uint8_t size)
7149 {
7150         const struct bt_hci_cmd_le_conn_update *cmd = data;
7151
7152         print_handle(cmd->handle);
7153         print_slot_125("Min connection interval", cmd->min_interval);
7154         print_slot_125("Max connection interval", cmd->max_interval);
7155         print_conn_latency("Connection latency", cmd->latency);
7156         print_field("Supervision timeout: %d msec (0x%4.4x)",
7157                                         le16_to_cpu(cmd->supv_timeout) * 10,
7158                                         le16_to_cpu(cmd->supv_timeout));
7159         print_slot_625("Min connection length", cmd->min_length);
7160         print_slot_625("Max connection length", cmd->max_length);
7161 }
7162
7163 static void le_set_host_classification_cmd(uint16_t index, const void *data,
7164                                                         uint8_t size)
7165 {
7166         const struct bt_hci_cmd_le_set_host_classification *cmd = data;
7167
7168         print_le_channel_map(cmd->map);
7169 }
7170
7171 static void le_read_channel_map_cmd(uint16_t index, const void *data,
7172                                                         uint8_t size)
7173 {
7174         const struct bt_hci_cmd_le_read_channel_map *cmd = data;
7175
7176         print_handle(cmd->handle);
7177 }
7178
7179 static void le_read_channel_map_rsp(uint16_t index, const void *data,
7180                                                         uint8_t size)
7181 {
7182         const struct bt_hci_rsp_le_read_channel_map *rsp = data;
7183
7184         print_status(rsp->status);
7185         print_handle(rsp->handle);
7186         print_le_channel_map(rsp->map);
7187 }
7188
7189 static void le_read_remote_features_cmd(uint16_t index, const void *data,
7190                                                         uint8_t size)
7191 {
7192         const struct bt_hci_cmd_le_read_remote_features *cmd = data;
7193
7194         print_handle(cmd->handle);
7195 }
7196
7197 static void le_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
7198 {
7199         const struct bt_hci_cmd_le_encrypt *cmd = data;
7200
7201         print_key("Key", cmd->key);
7202         print_key("Plaintext data", cmd->plaintext);
7203 }
7204
7205 static void le_encrypt_rsp(uint16_t index, const void *data, uint8_t size)
7206 {
7207         const struct bt_hci_rsp_le_encrypt *rsp = data;
7208
7209         print_status(rsp->status);
7210         print_key("Encrypted data", rsp->data);
7211 }
7212
7213 static void le_rand_rsp(uint16_t index, const void *data, uint8_t size)
7214 {
7215         const struct bt_hci_rsp_le_rand *rsp = data;
7216
7217         print_status(rsp->status);
7218         print_random_number(rsp->number);
7219 }
7220
7221 static void le_start_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
7222 {
7223         const struct bt_hci_cmd_le_start_encrypt *cmd = data;
7224
7225         print_handle(cmd->handle);
7226         print_random_number(cmd->rand);
7227         print_encrypted_diversifier(cmd->ediv);
7228         print_key("Long term key", cmd->ltk);
7229 }
7230
7231 static void le_ltk_req_reply_cmd(uint16_t index, const void *data, uint8_t size)
7232 {
7233         const struct bt_hci_cmd_le_ltk_req_reply *cmd = data;
7234
7235         print_handle(cmd->handle);
7236         print_key("Long term key", cmd->ltk);
7237 }
7238
7239 static void le_ltk_req_reply_rsp(uint16_t index, const void *data, uint8_t size)
7240 {
7241         const struct bt_hci_rsp_le_ltk_req_reply *rsp = data;
7242
7243         print_status(rsp->status);
7244         print_handle(rsp->handle);
7245 }
7246
7247 static void le_ltk_req_neg_reply_cmd(uint16_t index, const void *data,
7248                                                         uint8_t size)
7249 {
7250         const struct bt_hci_cmd_le_ltk_req_neg_reply *cmd = data;
7251
7252         print_handle(cmd->handle);
7253 }
7254
7255 static void le_ltk_req_neg_reply_rsp(uint16_t index, const void *data,
7256                                                         uint8_t size)
7257 {
7258         const struct bt_hci_rsp_le_ltk_req_neg_reply *rsp = data;
7259
7260         print_status(rsp->status);
7261         print_handle(rsp->handle);
7262 }
7263
7264 static void le_read_supported_states_rsp(uint16_t index, const void *data,
7265                                                         uint8_t size)
7266 {
7267         const struct bt_hci_rsp_le_read_supported_states *rsp = data;
7268
7269         print_status(rsp->status);
7270         print_le_states(rsp->states);
7271 }
7272
7273 static void le_receiver_test_cmd(uint16_t index, const void *data, uint8_t size)
7274 {
7275         const struct bt_hci_cmd_le_receiver_test *cmd = data;
7276
7277         print_field("RX frequency: %d MHz (0x%2.2x)",
7278                                 (cmd->frequency * 2) + 2402, cmd->frequency);
7279 }
7280
7281 static void le_transmitter_test_cmd(uint16_t index, const void *data,
7282                                                         uint8_t size)
7283 {
7284         const struct bt_hci_cmd_le_transmitter_test *cmd = data;
7285
7286         print_field("TX frequency: %d MHz (0x%2.2x)",
7287                                 (cmd->frequency * 2) + 2402, cmd->frequency);
7288         print_field("Test data length: %d bytes", cmd->data_len);
7289         print_field("Packet payload: 0x%2.2x", cmd->payload);
7290 }
7291
7292 static void le_test_end_rsp(uint16_t index, const void *data, uint8_t size)
7293 {
7294         const struct bt_hci_rsp_le_test_end *rsp = data;
7295
7296         print_status(rsp->status);
7297         print_field("Number of packets: %d", le16_to_cpu(rsp->num_packets));
7298 }
7299
7300 static void le_conn_param_req_reply_cmd(uint16_t index, const void *data,
7301                                                         uint8_t size)
7302 {
7303         const struct bt_hci_cmd_le_conn_param_req_reply *cmd = data;
7304
7305         print_handle(cmd->handle);
7306         print_slot_125("Min connection interval", cmd->min_interval);
7307         print_slot_125("Max connection interval", cmd->max_interval);
7308         print_conn_latency("Connection latency", cmd->latency);
7309         print_field("Supervision timeout: %d msec (0x%4.4x)",
7310                                         le16_to_cpu(cmd->supv_timeout) * 10,
7311                                         le16_to_cpu(cmd->supv_timeout));
7312         print_slot_625("Min connection length", cmd->min_length);
7313         print_slot_625("Max connection length", cmd->max_length);
7314 }
7315
7316 static void le_conn_param_req_reply_rsp(uint16_t index, const void *data,
7317                                                         uint8_t size)
7318 {
7319         const struct bt_hci_rsp_le_conn_param_req_reply *rsp = data;
7320
7321         print_status(rsp->status);
7322         print_handle(rsp->handle);
7323 }
7324
7325 static void le_conn_param_req_neg_reply_cmd(uint16_t index, const void *data,
7326                                                         uint8_t size)
7327 {
7328         const struct bt_hci_cmd_le_conn_param_req_neg_reply *cmd = data;
7329
7330         print_handle(cmd->handle);
7331         print_reason(cmd->reason);
7332 }
7333
7334 static void le_conn_param_req_neg_reply_rsp(uint16_t index, const void *data,
7335                                                         uint8_t size)
7336 {
7337         const struct bt_hci_rsp_le_conn_param_req_neg_reply *rsp = data;
7338
7339         print_status(rsp->status);
7340         print_handle(rsp->handle);
7341 }
7342
7343 static void le_set_data_length_cmd(uint16_t index, const void *data,
7344                                                         uint8_t size)
7345 {
7346         const struct bt_hci_cmd_le_set_data_length *cmd = data;
7347
7348         print_handle(cmd->handle);
7349         print_field("TX octets: %d", le16_to_cpu(cmd->tx_len));
7350         print_field("TX time: %d", le16_to_cpu(cmd->tx_time));
7351 }
7352
7353 static void le_set_data_length_rsp(uint16_t index, const void *data,
7354                                                         uint8_t size)
7355 {
7356         const struct bt_hci_rsp_le_set_data_length *rsp = data;
7357
7358         print_status(rsp->status);
7359         print_handle(rsp->handle);
7360 }
7361
7362 static void le_read_default_data_length_rsp(uint16_t index, const void *data,
7363                                                         uint8_t size)
7364 {
7365         const struct bt_hci_rsp_le_read_default_data_length *rsp = data;
7366
7367         print_status(rsp->status);
7368         print_field("TX octets: %d", le16_to_cpu(rsp->tx_len));
7369         print_field("TX time: %d", le16_to_cpu(rsp->tx_time));
7370 }
7371
7372 static void le_write_default_data_length_cmd(uint16_t index, const void *data,
7373                                                         uint8_t size)
7374 {
7375         const struct bt_hci_cmd_le_write_default_data_length *cmd = data;
7376
7377         print_field("TX octets: %d", le16_to_cpu(cmd->tx_len));
7378         print_field("TX time: %d", le16_to_cpu(cmd->tx_time));
7379 }
7380
7381 static void le_generate_dhkey_cmd(uint16_t index, const void *data,
7382                                                         uint8_t size)
7383 {
7384         const struct bt_hci_cmd_le_generate_dhkey *cmd = data;
7385
7386         print_pk256("Remote P-256 public key", cmd->remote_pk256);
7387 }
7388
7389 static void le_add_to_resolv_list_cmd(uint16_t index, const void *data,
7390                                                         uint8_t size)
7391 {
7392         const struct bt_hci_cmd_le_add_to_resolv_list *cmd = data;
7393
7394         print_addr_type("Address type", cmd->addr_type);
7395         print_addr("Address", cmd->addr, cmd->addr_type);
7396         print_key("Peer identity resolving key", cmd->peer_irk);
7397         print_key("Local identity resolving key", cmd->local_irk);
7398 }
7399
7400 static void le_remove_from_resolv_list_cmd(uint16_t index, const void *data,
7401                                                         uint8_t size)
7402 {
7403         const struct bt_hci_cmd_le_remove_from_resolv_list *cmd = data;
7404
7405         print_addr_type("Address type", cmd->addr_type);
7406         print_addr("Address", cmd->addr, cmd->addr_type);
7407 }
7408
7409 static void le_read_resolv_list_size_rsp(uint16_t index, const void *data,
7410                                                         uint8_t size)
7411 {
7412         const struct bt_hci_rsp_le_read_resolv_list_size *rsp = data;
7413
7414         print_status(rsp->status);
7415         print_field("Size: %u", rsp->size);
7416 }
7417
7418 static void le_read_peer_resolv_addr_cmd(uint16_t index, const void *data,
7419                                                         uint8_t size)
7420 {
7421         const struct bt_hci_cmd_le_read_peer_resolv_addr *cmd = data;
7422
7423         print_addr_type("Address type", cmd->addr_type);
7424         print_addr("Address", cmd->addr, cmd->addr_type);
7425 }
7426
7427 static void le_read_peer_resolv_addr_rsp(uint16_t index, const void *data,
7428                                                         uint8_t size)
7429 {
7430         const struct bt_hci_rsp_le_read_peer_resolv_addr *rsp = data;
7431
7432         print_status(rsp->status);
7433         print_addr("Address", rsp->addr, 0x01);
7434 }
7435
7436 static void le_read_local_resolv_addr_cmd(uint16_t index, const void *data,
7437                                                         uint8_t size)
7438 {
7439         const struct bt_hci_cmd_le_read_local_resolv_addr *cmd = data;
7440
7441         print_addr_type("Address type", cmd->addr_type);
7442         print_addr("Address", cmd->addr, cmd->addr_type);
7443 }
7444
7445 static void le_read_local_resolv_addr_rsp(uint16_t index, const void *data,
7446                                                         uint8_t size)
7447 {
7448         const struct bt_hci_rsp_le_read_local_resolv_addr *rsp = data;
7449
7450         print_status(rsp->status);
7451         print_addr("Address", rsp->addr, 0x01);
7452 }
7453
7454 static void le_set_resolv_enable_cmd(uint16_t index, const void *data,
7455                                                         uint8_t size)
7456 {
7457         const struct bt_hci_cmd_le_set_resolv_enable *cmd = data;
7458
7459         print_enable("Address resolution", cmd->enable);
7460 }
7461
7462 static void le_set_resolv_timeout_cmd(uint16_t index, const void *data,
7463                                                         uint8_t size)
7464 {
7465         const struct bt_hci_cmd_le_set_resolv_timeout *cmd = data;
7466
7467         print_field("Timeout: %u seconds", le16_to_cpu(cmd->timeout));
7468 }
7469
7470 static void le_read_max_data_length_rsp(uint16_t index, const void *data,
7471                                                         uint8_t size)
7472 {
7473         const struct bt_hci_rsp_le_read_max_data_length *rsp = data;
7474
7475         print_status(rsp->status);
7476         print_field("Max TX octets: %d", le16_to_cpu(rsp->max_tx_len));
7477         print_field("Max TX time: %d", le16_to_cpu(rsp->max_tx_time));
7478         print_field("Max RX octets: %d", le16_to_cpu(rsp->max_rx_len));
7479         print_field("Max RX time: %d", le16_to_cpu(rsp->max_rx_time));
7480 }
7481
7482 static void le_read_phy_cmd(uint16_t index, const void *data, uint8_t size)
7483 {
7484         const struct bt_hci_cmd_le_read_phy *cmd = data;
7485
7486         print_handle(cmd->handle);
7487 }
7488
7489 static void print_le_phy(const char *prefix, uint8_t phy)
7490 {
7491         const char *str;
7492
7493         switch (phy) {
7494         case 0x01:
7495                 str = "LE 1M";
7496                 break;
7497         case 0x02:
7498                 str = "LE 2M";
7499                 break;
7500         case 0x03:
7501                 str = "LE Coded";
7502                 break;
7503         default:
7504                 str = "Reserved";
7505                 break;
7506         }
7507
7508         print_field("%s: %s (0x%2.2x)", prefix, str, phy);
7509 }
7510
7511 static void le_read_phy_rsp(uint16_t index, const void *data, uint8_t size)
7512 {
7513         const struct bt_hci_rsp_le_read_phy *rsp = data;
7514
7515         print_status(rsp->status);
7516         print_handle(rsp->handle);
7517         print_le_phy("TX PHY", rsp->tx_phy);
7518         print_le_phy("RX PHY", rsp->rx_phy);
7519 }
7520
7521 static const struct bitfield_data le_phys[] = {
7522         {  0, "LE 1M"   },
7523         {  1, "LE 2M"   },
7524         {  2, "LE Coded"},
7525         { }
7526 };
7527
7528 static const struct bitfield_data le_phy_preference[] = {
7529         {  0, "No TX PHY preference"    },
7530         {  1, "No RX PHY preference"    },
7531         { }
7532 };
7533
7534 static void print_le_phys_preference(uint8_t all_phys, uint8_t tx_phys,
7535                                                         uint8_t rx_phys)
7536 {
7537         uint8_t mask;
7538
7539         print_field("All PHYs preference: 0x%2.2x", all_phys);
7540
7541         mask = print_bitfield(2, all_phys, le_phy_preference);
7542         if (mask)
7543                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7544                                                         " (0x%2.2x)", mask);
7545
7546         print_field("TX PHYs preference: 0x%2.2x", tx_phys);
7547
7548         mask = print_bitfield(2, tx_phys, le_phys);
7549         if (mask)
7550                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7551                                                         " (0x%2.2x)", mask);
7552
7553         print_field("RX PHYs preference: 0x%2.2x", rx_phys);
7554
7555         mask = print_bitfield(2, rx_phys, le_phys);
7556         if (mask)
7557                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7558                                                         " (0x%2.2x)", mask);
7559 }
7560
7561 static void le_set_default_phy_cmd(uint16_t index, const void *data,
7562                                                         uint8_t size)
7563 {
7564         const struct bt_hci_cmd_le_set_default_phy *cmd = data;
7565
7566         print_le_phys_preference(cmd->all_phys, cmd->tx_phys, cmd->rx_phys);
7567 }
7568
7569 static void le_set_phy_cmd(uint16_t index, const void *data, uint8_t size)
7570 {
7571         const struct bt_hci_cmd_le_set_phy *cmd = data;
7572         const char *str;
7573
7574         print_handle(cmd->handle);
7575         print_le_phys_preference(cmd->all_phys, cmd->tx_phys, cmd->rx_phys);
7576         switch (le16_to_cpu(cmd->phy_opts)) {
7577         case 0x0001:
7578                 str = "S2 coding";
7579                 break;
7580         case 0x0002:
7581                 str = "S8 coding";
7582                 break;
7583         default:
7584                 str = "Reserved";
7585                 break;
7586         }
7587
7588         print_field("PHY options preference: %s (0x%4.4x)", str, cmd->phy_opts);
7589 }
7590
7591 static void le_enhanced_receiver_test_cmd(uint16_t index, const void *data,
7592                                                         uint8_t size)
7593 {
7594         const struct bt_hci_cmd_le_enhanced_receiver_test *cmd = data;
7595         const char *str;
7596
7597         print_field("RX channel frequency: %d MHz (0x%2.2x)",
7598                                 (cmd->rx_channel * 2) + 2402, cmd->rx_channel);
7599         print_le_phy("PHY", cmd->phy);
7600
7601         switch (cmd->modulation_index) {
7602         case 0x00:
7603                 str = "Standard";
7604                 break;
7605         case 0x01:
7606                 str = "Stable";
7607                 break;
7608         default:
7609                 str = "Reserved";
7610                 break;
7611         }
7612
7613         print_field("Modulation index: %s (0x%2.2x)", str,
7614                                                         cmd->modulation_index);
7615 }
7616
7617 static void le_enhanced_transmitter_test_cmd(uint16_t index, const void *data,
7618                                                         uint8_t size)
7619 {
7620         const struct bt_hci_cmd_le_enhanced_transmitter_test *cmd = data;
7621         const char *str;
7622
7623         print_field("TX channel frequency: %d MHz (0x%2.2x)",
7624                                 (cmd->tx_channel * 2) + 2402, cmd->tx_channel);
7625         print_field("Test data length: %d bytes", cmd->data_len);
7626         print_field("Packet payload: 0x%2.2x", cmd->payload);
7627
7628         switch (cmd->phy) {
7629         case 0x01:
7630                 str = "LE 1M";
7631                 break;
7632         case 0x02:
7633                 str = "LE 2M";
7634                 break;
7635         case 0x03:
7636                 str = "LE Coded with S=8";
7637                 break;
7638         case 0x04:
7639                 str = "LE Coded with S=2";
7640                 break;
7641         default:
7642                 str = "Reserved";
7643                 break;
7644         }
7645
7646         print_field("PHY: %s (0x%2.2x)", str, cmd->phy);
7647 }
7648
7649 static void le_set_adv_set_rand_addr(uint16_t index, const void *data,
7650                                                         uint8_t size)
7651 {
7652         const struct bt_hci_cmd_le_set_adv_set_rand_addr *cmd = data;
7653
7654         print_field("Advertising handle: 0x%2.2x", cmd->handle);
7655         print_addr("Advertising random address", cmd->bdaddr, 0x01);
7656 }
7657
7658 static const struct bitfield_data ext_adv_properties_table[] = {
7659         {  0, "Connectable"             },
7660         {  1, "Scannable"               },
7661         {  2, "Directed"        },
7662         {  3, "High Duty Cycle Directed Connectable"    },
7663         {  4, "Use legacy advertising PDUs"     },
7664         {  5, "Anonymous advertising"   },
7665         {  6, "Include TxPower"         },
7666         { }
7667 };
7668
7669 static const char *get_adv_pdu_desc(uint16_t flags)
7670 {
7671         const char *str;
7672
7673         switch (flags) {
7674         case 0x10:
7675                 str = "ADV_NONCONN_IND";
7676                 break;
7677         case 0x12:
7678                 str = "ADV_SCAN_IND";
7679                 break;
7680         case 0x13:
7681                 str = "ADV_IND";
7682                 break;
7683         case 0x15:
7684                 str = "ADV_DIRECT_IND (low duty cycle)";
7685                 break;
7686         case 0x1d:
7687                 str = "ADV_DIRECT_IND (high duty cycle)";
7688                 break;
7689         default:
7690                 str = "Reserved";
7691                 break;
7692         }
7693
7694         return str;
7695 }
7696
7697 static void print_ext_adv_properties(uint16_t flags)
7698 {
7699         uint16_t mask = flags;
7700         const char *property;
7701         int i;
7702
7703         print_field("Properties: 0x%4.4x", flags);
7704
7705         for (i = 0; ext_adv_properties_table[i].str; i++) {
7706                 if (flags & (1 << ext_adv_properties_table[i].bit)) {
7707                         property = ext_adv_properties_table[i].str;
7708
7709                         if (ext_adv_properties_table[i].bit == 4) {
7710                                 print_field("  %s: %s", property,
7711                                                 get_adv_pdu_desc(flags));
7712                         } else {
7713                                 print_field("  %s", property);
7714                         }
7715                         mask &= ~(1 << ext_adv_properties_table[i].bit);
7716                 }
7717         }
7718
7719         if (mask)
7720                 print_text(COLOR_UNKNOWN_ADV_FLAG,
7721                                 "  Unknown advertising properties (0x%4.4x)",
7722                                                                         mask);
7723 }
7724
7725 static void print_ext_slot_625(const char *label, const uint8_t value[3])
7726 {
7727         uint32_t value_cpu = value[0];
7728
7729         value_cpu |= value[1] << 8;
7730         value_cpu |= value[2] << 16;
7731
7732         print_field("%s: %.3f msec (0x%4.4x)", label,
7733                                                 value_cpu * 0.625, value_cpu);
7734 }
7735
7736 static void le_set_ext_adv_params_cmd(uint16_t index, const void *data,
7737                                                         uint8_t size)
7738 {
7739         const struct bt_hci_cmd_le_set_ext_adv_params *cmd = data;
7740         const char *str;
7741
7742         print_field("Handle: 0x%2.2x", cmd->handle);
7743         print_ext_adv_properties(le16_to_cpu(cmd->evt_properties));
7744
7745         print_ext_slot_625("Min advertising interval", cmd->min_interval);
7746         print_ext_slot_625("Max advertising interval", cmd->max_interval);
7747         print_adv_channel_map("Channel map", cmd->channel_map);
7748         print_own_addr_type(cmd->own_addr_type);
7749         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
7750         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
7751         print_adv_filter_policy("Filter policy", cmd->filter_policy);
7752         if (cmd->tx_power == 0x7f)
7753                 print_field("TX power: Host has no preference (0x7f)");
7754         else
7755                 print_power_level(cmd->tx_power, NULL);
7756
7757         switch (cmd->primary_phy) {
7758         case 0x01:
7759                 str = "LE 1M";
7760                 break;
7761         case 0x03:
7762                 str = "LE Coded";
7763                 break;
7764         default:
7765                 str = "Reserved";
7766                 break;
7767         }
7768
7769         print_field("Primary PHY: %s (0x%2.2x)", str, cmd->primary_phy);
7770         print_field("Secondary max skip: 0x%2.2x", cmd->secondary_max_skip);
7771         print_le_phy("Secondary PHY", cmd->secondary_phy);
7772         print_field("SID: 0x%2.2x", cmd->sid);
7773         print_enable("Scan request notifications", cmd->notif_enable);
7774 }
7775
7776 static void le_set_ext_adv_params_rsp(uint16_t index, const void *data,
7777                                                         uint8_t size)
7778 {
7779         const struct bt_hci_rsp_le_set_ext_adv_params *rsp = data;
7780
7781         print_status(rsp->status);
7782         print_power_level(rsp->tx_power, "selected");
7783 }
7784
7785 static void le_set_ext_adv_data_cmd(uint16_t index, const void *data,
7786                                                         uint8_t size)
7787 {
7788         const struct bt_hci_cmd_le_set_ext_adv_data *cmd = data;
7789         const char *str;
7790
7791         print_field("Handle: 0x%2.2x", cmd->handle);
7792
7793         switch (cmd->operation) {
7794         case 0x00:
7795                 str = "Immediate fragment";
7796                 break;
7797         case 0x01:
7798                 str = "First fragment";
7799                 break;
7800         case 0x02:
7801                 str = "Last fragment";
7802                 break;
7803         case 0x03:
7804                 str = "Complete extended advertising data";
7805                 break;
7806         case 0x04:
7807                 str = "Unchanged data";
7808                 break;
7809         default:
7810                 str = "Reserved";
7811                 break;
7812         }
7813
7814         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
7815
7816         switch (cmd->fragment_preference) {
7817         case 0x00:
7818                 str = "Fragment all";
7819                 break;
7820         case 0x01:
7821                 str = "Minimize fragmentation";
7822                 break;
7823         default:
7824                 str = "Reserved";
7825                 break;
7826         }
7827
7828         print_field("Fragment preference: %s (0x%2.2x)", str,
7829                                                 cmd->fragment_preference);
7830         print_field("Data length: 0x%2.2x", cmd->data_len);
7831         packet_print_ad(cmd->data, size - sizeof(*cmd));
7832 }
7833
7834 static void le_set_ext_scan_rsp_data_cmd(uint16_t index, const void *data,
7835                                                         uint8_t size)
7836 {
7837         const struct bt_hci_cmd_le_set_ext_scan_rsp_data *cmd = data;
7838         const char *str;
7839
7840         print_field("Handle: 0x%2.2x", cmd->handle);
7841
7842         switch (cmd->operation) {
7843         case 0x00:
7844                 str = "Immediate fragment";
7845                 break;
7846         case 0x01:
7847                 str = "First fragment";
7848                 break;
7849         case 0x02:
7850                 str = "Last fragment";
7851                 break;
7852         case 0x03:
7853                 str = "Complete scan response data";
7854                 break;
7855         case 0x04:
7856                 str = "Unchanged data";
7857                 break;
7858         default:
7859                 str = "Reserved";
7860                 break;
7861         }
7862
7863         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
7864
7865         switch (cmd->fragment_preference) {
7866         case 0x00:
7867                 str = "Fragment all";
7868                 break;
7869         case 0x01:
7870                 str = "Minimize fragmentation";
7871                 break;
7872         default:
7873                 str = "Reserved";
7874                 break;
7875         }
7876
7877         print_field("Fragment preference: %s (0x%2.2x)", str,
7878                                                 cmd->fragment_preference);
7879         print_field("Data length: 0x%2.2x", cmd->data_len);
7880         packet_print_ad(cmd->data, size - sizeof(*cmd));
7881 }
7882
7883 static void le_set_ext_adv_enable_cmd(uint16_t index, const void *data,
7884                                                         uint8_t size)
7885 {
7886         const struct bt_hci_cmd_le_set_ext_adv_enable *cmd = data;
7887         const struct bt_hci_cmd_ext_adv_set *adv_set;
7888         int i;
7889
7890         print_enable("Extended advertising", cmd->enable);
7891
7892         if (cmd->num_of_sets == 0)
7893                 print_field("Number of sets: Disable all sets (0x%2.2x)",
7894                                                         cmd->num_of_sets);
7895         else if (cmd->num_of_sets > 0x3f)
7896                 print_field("Number of sets: Reserved (0x%2.2x)",
7897                                                         cmd->num_of_sets);
7898         else
7899                 print_field("Number of sets: %u (0x%2.2x)", cmd->num_of_sets,
7900                                                         cmd->num_of_sets);
7901
7902         for (i = 0; i < cmd->num_of_sets; ++i) {
7903                 adv_set = data + 2 + i * sizeof(struct bt_hci_cmd_ext_adv_set);
7904                 print_field("Entry %d", i);
7905                 print_field("  Handle: 0x%2.2x", adv_set->handle);
7906                 print_field("  Duration: %d ms (0x%2.2x)",
7907                                 adv_set->duration * 10, adv_set->duration);
7908                 print_field("  Max ext adv events: %d", adv_set->max_events);
7909         }
7910 }
7911
7912 static void le_read_max_adv_data_len_rsp(uint16_t index, const void *data,
7913                                                         uint8_t size)
7914 {
7915         const struct bt_hci_rsp_le_read_max_adv_data_len *rsp = data;
7916
7917         print_status(rsp->status);
7918         print_field("Max length: %d", rsp->max_len);
7919 }
7920
7921 static void le_read_num_supported_adv_sets_rsp(uint16_t index, const void *data,
7922                                                         uint8_t size)
7923 {
7924         const struct bt_hci_rsp_le_read_num_supported_adv_sets *rsp = data;
7925
7926         print_status(rsp->status);
7927         print_field("Num supported adv sets: %d", rsp->num_of_sets);
7928 }
7929
7930 static void le_remove_adv_set_cmd(uint16_t index, const void *data,
7931                                                         uint8_t size)
7932 {
7933         const struct bt_hci_cmd_le_remove_adv_set *cmd = data;
7934
7935         print_handle(cmd->handle);
7936 }
7937
7938 static const struct bitfield_data pa_properties_table[] = {
7939         {  6, "Include TxPower"         },
7940         { }
7941 };
7942
7943 static void print_pa_properties(uint16_t flags)
7944 {
7945         uint16_t mask;
7946
7947         print_field("Properties: 0x%4.4x", flags);
7948
7949         mask = print_bitfield(2, flags, pa_properties_table);
7950         if (mask)
7951                 print_text(COLOR_UNKNOWN_ADV_FLAG,
7952                                 "  Unknown advertising properties (0x%4.4x)",
7953                                                                         mask);
7954 }
7955
7956 static void le_set_pa_params_cmd(uint16_t index, const void *data, uint8_t size)
7957 {
7958         const struct bt_hci_cmd_le_set_pa_params *cmd = data;
7959
7960         print_handle(cmd->handle);
7961         print_slot_125("Min interval", cmd->min_interval);
7962         print_slot_125("Max interval", cmd->max_interval);
7963         print_pa_properties(cmd->properties);
7964 }
7965
7966 static void le_set_pa_data_cmd(uint16_t index, const void *data, uint8_t size)
7967 {
7968         const struct bt_hci_cmd_le_set_pa_data *cmd = data;
7969         const char *str;
7970
7971         print_handle(cmd->handle);
7972
7973         switch (cmd->operation) {
7974         case 0x00:
7975                 str = "Immediate fragment";
7976                 break;
7977         case 0x01:
7978                 str = "First fragment";
7979                 break;
7980         case 0x02:
7981                 str = "Last fragment";
7982                 break;
7983         case 0x03:
7984                 str = "Complete ext advertising data";
7985                 break;
7986         default:
7987                 str = "Reserved";
7988                 break;
7989         }
7990
7991         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
7992         print_field("Data length: 0x%2.2x", cmd->data_len);
7993         print_eir(cmd->data, cmd->data_len, true);
7994 }
7995
7996 static void le_set_pa_enable_cmd(uint16_t index, const void *data, uint8_t size)
7997 {
7998         const struct bt_hci_cmd_le_set_pa_enable *cmd = data;
7999
8000         print_enable("Periodic advertising", cmd->enable);
8001         print_handle(cmd->handle);
8002 }
8003
8004 static const struct bitfield_data ext_scan_phys_table[] = {
8005         {  0, "LE 1M"           },
8006         {  2, "LE Coded"                },
8007         { }
8008 };
8009
8010 static void print_ext_scan_phys(const void *data, uint8_t flags)
8011 {
8012         const struct bt_hci_le_scan_phy *scan_phy;
8013         uint8_t mask = flags;
8014         int bits_set = 0;
8015         int i;
8016
8017         print_field("PHYs: 0x%2.2x", flags);
8018
8019         for (i = 0; ext_scan_phys_table[i].str; i++) {
8020                 if (flags & (1 << ext_scan_phys_table[i].bit)) {
8021                         scan_phy = data + bits_set * sizeof(*scan_phy);
8022                         mask &= ~(1 << ext_scan_phys_table[i].bit);
8023
8024                         print_field("Entry %d: %s", bits_set,
8025                                                 ext_scan_phys_table[i].str);
8026                         print_scan_type("  Type", scan_phy->type);
8027                         print_slot_625("  Interval", scan_phy->interval);
8028                         print_slot_625("  Window", scan_phy->window);
8029
8030                         ++bits_set;
8031                 }
8032         }
8033
8034         if (mask)
8035                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown scanning PHYs"
8036                                                         " (0x%2.2x)", mask);
8037 }
8038
8039 static void le_set_ext_scan_params_cmd(uint16_t index, const void *data,
8040                                                         uint8_t size)
8041 {
8042         const struct bt_hci_cmd_le_set_ext_scan_params *cmd = data;
8043
8044         print_own_addr_type(cmd->own_addr_type);
8045         print_scan_filter_policy(cmd->filter_policy);
8046         print_ext_scan_phys(cmd->data, cmd->num_phys);
8047 }
8048
8049 static void le_set_ext_scan_enable_cmd(uint16_t index, const void *data,
8050                                                         uint8_t size)
8051 {
8052         const struct bt_hci_cmd_le_set_ext_scan_enable *cmd = data;
8053
8054         print_enable("Extended scan", cmd->enable);
8055         print_enable("Filter duplicates", cmd->filter_dup);
8056
8057         print_field("Duration: %d msec (0x%4.4x)",
8058                                                 le16_to_cpu(cmd->duration) * 10,
8059                                                 le16_to_cpu(cmd->duration));
8060         print_field("Period: %.2f sec (0x%4.4x)",
8061                                                 le16_to_cpu(cmd->period) * 1.28,
8062                                                 le16_to_cpu(cmd->period));
8063 }
8064
8065 static const struct bitfield_data ext_conn_phys_table[] = {
8066         {  0, "LE 1M"           },
8067         {  1, "LE 2M"           },
8068         {  2, "LE Coded"        },
8069         { }
8070 };
8071
8072 static void print_ext_conn_phys(const void *data, uint8_t flags)
8073 {
8074         const struct bt_hci_le_ext_create_conn *entry;
8075         uint8_t mask = flags;
8076         int bits_set = 0;
8077         int i;
8078
8079         print_field("Initiating PHYs: 0x%2.2x", flags);
8080
8081         for (i = 0; ext_conn_phys_table[i].str; i++) {
8082                 if (flags & (1 << ext_conn_phys_table[i].bit)) {
8083                         entry = data + bits_set * sizeof(*entry);
8084                         mask &= ~(1 << ext_conn_phys_table[i].bit);
8085
8086                         print_field("Entry %d: %s", bits_set,
8087                                                 ext_conn_phys_table[i].str);
8088                         print_slot_625("  Scan interval", entry->scan_interval);
8089                         print_slot_625("  Scan window", entry->scan_window);
8090                         print_slot_125("  Min connection interval",
8091                                                         entry->min_interval);
8092                         print_slot_125("  Max connection interval",
8093                                                         entry->max_interval);
8094                         print_conn_latency("  Connection latency",
8095                                                                 entry->latency);
8096                         print_field("  Supervision timeout: %d msec (0x%4.4x)",
8097                                         le16_to_cpu(entry->supv_timeout) * 10,
8098                                         le16_to_cpu(entry->supv_timeout));
8099                         print_slot_625("  Min connection length",
8100                                                         entry->min_length);
8101                         print_slot_625("  Max connection length",
8102                                                         entry->max_length);
8103
8104                         ++bits_set;
8105                 }
8106         }
8107
8108         if (mask)
8109                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown scanning PHYs"
8110                                                         " (0x%2.2x)", mask);
8111 }
8112
8113 static void le_ext_create_conn_cmd(uint16_t index, const void *data,
8114                                                         uint8_t size)
8115 {
8116         const struct bt_hci_cmd_le_ext_create_conn *cmd = data;
8117         const char *str;
8118
8119         switch (cmd->filter_policy) {
8120         case 0x00:
8121                 str = "Accept list is not used";
8122                 break;
8123         case 0x01:
8124                 str = "Accept list is used";
8125                 break;
8126         default:
8127                 str = "Reserved";
8128                 break;
8129         }
8130
8131         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
8132
8133         print_own_addr_type(cmd->own_addr_type);
8134         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
8135         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
8136         print_ext_conn_phys(cmd->data, cmd->phys);
8137 }
8138
8139 static const struct bitfield_data create_sync_cte_type[] = {
8140         {  0, "Do not sync to packets with AoA CTE"     },
8141         {  1, "Do not sync to packets with AoD CTE 1us" },
8142         {  2, "Do not sync to packets with AoD CTE 2us" },
8143         {  3, "Do not sync to packets with type 3 AoD"  },
8144         {  4, "Do not sync to packets without CTE"      },
8145         { },
8146 };
8147
8148 static const struct bitfield_data create_sync_options[] = {
8149         {  0, "Use Periodic Advertiser List"    },
8150         {  1, "Reporting initially disabled"    },
8151         { },
8152 };
8153
8154 static const struct bitfield_data create_sync_options_alt[] = {
8155         {  0, "Use advertising SID, Advertiser Address Type and address"},
8156         {  1, "Reporting initially enabled"                             },
8157         { },
8158 };
8159
8160 static void print_create_sync_cte_type(uint8_t flags)
8161 {
8162         uint8_t mask = flags;
8163
8164         print_field("Sync CTE type: 0x%4.4x", flags);
8165
8166         mask = print_bitfield(2, flags, create_sync_cte_type);
8167
8168         if (mask) {
8169                 print_text(COLOR_UNKNOWN_ADV_FLAG,
8170                                 "Unknown sync CTE type properties (0x%4.4x)",
8171                                                                         mask);
8172         }
8173 }
8174
8175 static void print_create_sync_options(uint8_t flags)
8176 {
8177         uint8_t mask = flags;
8178         int i;
8179
8180         print_field("Options: 0x%4.4x", flags);
8181
8182         for (i = 0; create_sync_options[i].str; i++) {
8183                 if (flags & (1 << create_sync_options[i].bit)) {
8184                         print_field("%s", create_sync_options[i].str);
8185                         mask  &= ~(1 << create_sync_options[i].bit);
8186                 } else {
8187                         print_field("%s", create_sync_options_alt[i].str);
8188                         mask  &= ~(1 << create_sync_options_alt[i].bit);
8189                 }
8190         }
8191
8192         if (mask) {
8193                 print_text(COLOR_UNKNOWN_ADV_FLAG,
8194                                         "  Unknown options (0x%4.4x)", mask);
8195         }
8196 }
8197
8198 static void le_pa_create_sync_cmd(uint16_t index, const void *data,
8199                                                         uint8_t size)
8200 {
8201         const struct bt_hci_cmd_le_pa_create_sync *cmd = data;
8202
8203         print_create_sync_options(cmd->options);
8204         print_field("SID: 0x%2.2x", cmd->sid);
8205         print_addr_type("Adv address type", cmd->addr_type);
8206         print_addr("Adv address", cmd->addr, cmd->addr_type);
8207         print_field("Skip: 0x%4.4x", cmd->skip);
8208         print_field("Sync timeout: %d msec (0x%4.4x)",
8209                                         le16_to_cpu(cmd->sync_timeout) * 10,
8210                                         le16_to_cpu(cmd->sync_timeout));
8211         print_create_sync_cte_type(cmd->sync_cte_type);
8212 }
8213
8214 static void le_pa_term_sync_cmd(uint16_t index, const void *data, uint8_t size)
8215 {
8216         const struct bt_hci_cmd_le_pa_term_sync *cmd = data;
8217
8218         print_field("Sync handle: 0x%4.4x", cmd->sync_handle);
8219 }
8220
8221 static void le_add_dev_pa_list_cmd(uint16_t index, const void *data,
8222                                                         uint8_t size)
8223 {
8224         const struct bt_hci_cmd_le_add_dev_pa_list *cmd = data;
8225
8226         print_addr_type("Adv address type", cmd->addr_type);
8227         print_addr("Adv address", cmd->addr, cmd->addr_type);
8228         print_field("SID: 0x%2.2x", cmd->sid);
8229 }
8230
8231 static void le_remove_dev_pa_list_cmd(uint16_t index, const void *data,
8232                                                         uint8_t size)
8233 {
8234         const struct bt_hci_cmd_le_remove_dev_pa_list *cmd = data;
8235
8236         print_addr_type("Adv address type", cmd->addr_type);
8237         print_addr("Adv address", cmd->addr, cmd->addr_type);
8238         print_field("SID: 0x%2.2x", cmd->sid);
8239 }
8240
8241 static void le_read_pa_list_size_rsp(uint16_t index, const void *data,
8242                                                         uint8_t size)
8243 {
8244         const struct bt_hci_rsp_le_read_dev_pa_list_size *rsp = data;
8245
8246         print_status(rsp->status);
8247         print_field("List size: 0x%2.2x", rsp->list_size);
8248 }
8249
8250 static void le_read_tx_power_rsp(uint16_t index, const void *data,
8251                                                         uint8_t size)
8252 {
8253         const struct bt_hci_rsp_le_read_tx_power *rsp = data;
8254
8255         print_status(rsp->status);
8256         print_field("Min Tx power: %d dBm", rsp->min_tx_power);
8257         print_field("Max Tx power: %d dBm", rsp->max_tx_power);
8258 }
8259
8260 static void le_read_rf_path_comp_rsp(uint16_t index, const void *data,
8261                                                         uint8_t size)
8262 {
8263         const struct bt_hci_rsp_le_read_rf_path_comp *rsp = data;
8264
8265         print_status(rsp->status);
8266         print_field("RF Tx Path Compensation Value: 0x%4.4x",
8267                                                         rsp->rf_tx_path_comp);
8268         print_field("RF Rx Path Compensation Value: 0x%4.4x",
8269                                                         rsp->rf_rx_path_comp);
8270 }
8271
8272 static void le_write_rf_path_comp_cmd(uint16_t index, const void *data,
8273                                                         uint8_t size)
8274 {
8275         const struct bt_hci_cmd_le_write_rf_path_comp *cmd = data;
8276
8277         print_field("RF Tx Path Compensation Value: 0x%4.4x",
8278                                                         cmd->rf_tx_path_comp);
8279         print_field("RF Rx Path Compensation Value: 0x%4.4x",
8280                                                         cmd->rf_rx_path_comp);
8281 }
8282
8283 static void le_set_priv_mode_cmd(uint16_t index, const void *data, uint8_t size)
8284 {
8285         const struct bt_hci_cmd_le_set_priv_mode *cmd = data;
8286         const char *str;
8287
8288         print_addr_type("Peer Identity address type", cmd->peer_id_addr_type);
8289         print_addr("Peer Identity address", cmd->peer_id_addr,
8290                                                         cmd->peer_id_addr_type);
8291
8292         switch (cmd->priv_mode) {
8293         case 0x00:
8294                 str = "Use Network Privacy";
8295                 break;
8296         case 0x01:
8297                 str = "Use Device Privacy";
8298                 break;
8299         default:
8300                 str = "Reserved";
8301                 break;
8302         }
8303
8304         print_field("Privacy Mode: %s (0x%2.2x)", str, cmd->priv_mode);
8305 }
8306
8307 static void le_receiver_test_cmd_v3(uint16_t index, const void *data,
8308                                                         uint8_t size)
8309 {
8310         const struct bt_hci_cmd_le_receiver_test_v3 *cmd = data;
8311         uint8_t i;
8312
8313         print_field("RX Channel: %u MHz (0x%2.2x)", cmd->rx_chan * 2 + 2402,
8314                                                         cmd->rx_chan);
8315
8316         switch (cmd->phy) {
8317         case 0x01:
8318                 print_field("PHY: LE 1M (0x%2.2x)", cmd->phy);
8319                 break;
8320         case 0x02:
8321                 print_field("PHY: LE 2M (0x%2.2x)", cmd->phy);
8322                 break;
8323         case 0x03:
8324                 print_field("PHY: LE Coded (0x%2.2x)", cmd->phy);
8325                 break;
8326         }
8327
8328         print_field("Modulation Index: %s (0x%2.2x)",
8329                 cmd->mod_index ? "stable" : "standard", cmd->mod_index);
8330         print_field("Expected CTE Length: %u us (0x%2.2x)", cmd->cte_len * 8,
8331                                                                 cmd->cte_len);
8332         print_field("Expected CTE Type: %u us slots (0x%2.2x)", cmd->cte_type,
8333                                                                 cmd->cte_type);
8334         print_field("Slot Duration: %u us (0x%2.2x)", cmd->duration,
8335                                                                 cmd->duration);
8336         print_field("Number of Antenna IDs: %u", cmd->num_antenna_id);
8337
8338         if (size < sizeof(*cmd) + cmd->num_antenna_id)
8339                 return;
8340
8341         for (i = 0; i < cmd->num_antenna_id; i++)
8342                 print_field("  Antenna ID: %u", cmd->antenna_ids[i]);
8343 }
8344
8345 static const char *parse_tx_test_payload(uint8_t payload)
8346 {
8347         switch (payload) {
8348         case 0x00:
8349                 return "PRBS9 sequence 11111111100000111101...";
8350         case 0x01:
8351                 return "Repeated 11110000";
8352         case 0x02:
8353                 return "Repeated 10101010";
8354         case 0x03:
8355                 return "PRBS15";
8356         case 0x04:
8357                 return "Repeated 11111111";
8358         case 0x05:
8359                 return "Repeated 00000000";
8360         case 0x06:
8361                 return "Repeated 00001111";
8362         case 0x07:
8363                 return "Repeated 01010101";
8364         default:
8365                 return "Reserved";
8366         }
8367 }
8368
8369 static void le_tx_test_cmd_v3(uint16_t index, const void *data, uint8_t size)
8370 {
8371         const struct bt_hci_cmd_le_tx_test_v3 *cmd = data;
8372         uint8_t i;
8373
8374         print_field("TX Channel: %u MHz (0x%2.2x)", cmd->chan * 2 + 2402,
8375                                                                 cmd->chan);
8376         print_field("Length of Test Data: %u", cmd->data_len);
8377         print_field("Packet Payload: %s (0x%2.2x)",
8378                         parse_tx_test_payload(cmd->payload), cmd->payload);
8379
8380         switch (cmd->phy) {
8381         case 0x01:
8382                 print_field("PHY: LE 1M (0x%2.2x)", cmd->phy);
8383                 break;
8384         case 0x02:
8385                 print_field("PHY: LE 2M (0x%2.2x)", cmd->phy);
8386                 break;
8387         case 0x03:
8388                 print_field("PHY: LE Coded with S=8 (0x%2.2x)", cmd->phy);
8389                 break;
8390         case 0x04:
8391                 print_field("PHY: LE Coded with S=2 (0x%2.2x)", cmd->phy);
8392                 break;
8393         }
8394
8395         print_field("Expected CTE Length: %u us (0x%2.2x)", cmd->cte_len * 8,
8396                                                                 cmd->cte_len);
8397         print_field("Expected CTE Type: %u us slots (0x%2.2x)", cmd->cte_type,
8398                                                                 cmd->cte_type);
8399         print_field("Slot Duration: %u us (0x%2.2x)", cmd->duration,
8400                                                                 cmd->duration);
8401         print_field("Number of Antenna IDs: %u", cmd->num_antenna_id);
8402
8403         if (size < sizeof(*cmd) + cmd->num_antenna_id)
8404                 return;
8405
8406         for (i = 0; i < cmd->num_antenna_id; i++)
8407                 print_field("  Antenna ID: %u", cmd->antenna_ids[i]);
8408 }
8409
8410 static void le_pa_rec_enable(uint16_t index, const void *data, uint8_t size)
8411 {
8412         const struct bt_hci_cmd_le_set_pa_enable *cmd = data;
8413
8414         print_field("Sync handle: %d", cmd->handle);
8415         print_enable("Reporting", cmd->enable);
8416 }
8417
8418 static void le_pa_sync_trans(uint16_t index, const void *data, uint8_t size)
8419 {
8420         const struct bt_hci_cmd_periodic_sync_trans *cmd = data;
8421
8422         print_field("Connection handle: %d", cmd->handle);
8423         print_field("Service data: 0x%4.4x", cmd->service_data);
8424         print_field("Sync handle: %d", cmd->sync_handle);
8425 }
8426
8427 static void le_pa_set_info_trans(uint16_t index, const void *data, uint8_t size)
8428 {
8429         const struct bt_hci_cmd_pa_set_info_trans *cmd = data;
8430
8431         print_field("Connection handle: %d", cmd->handle);
8432         print_field("Service data: 0x%4.4x", cmd->service_data);
8433         print_field("Advertising handle: %d", cmd->adv_handle);
8434 }
8435
8436 static void print_sync_mode(uint8_t mode)
8437 {
8438         const char *str;
8439
8440         switch (mode) {
8441         case 0x00:
8442                 str = "Disabled";
8443                 break;
8444         case 0x01:
8445                 str = "Enabled with report events disabled";
8446                 break;
8447         case 0x02:
8448                 str = "Enabled with report events enabled";
8449                 break;
8450         default:
8451                 str = "RFU";
8452                 break;
8453         }
8454
8455         print_field("Mode: %s (0x%2.2x)", str, mode);
8456 }
8457
8458 static void le_pa_sync_trans_params(uint16_t index, const void *data,
8459                                                         uint8_t size)
8460 {
8461         const struct bt_hci_cmd_pa_sync_trans_params *cmd = data;
8462
8463         print_field("Connection handle: %d", cmd->handle);
8464         print_sync_mode(cmd->mode);
8465         print_field("Skip: 0x%2.2x", cmd->skip);
8466         print_field("Sync timeout: %d msec (0x%4.4x)",
8467                                         le16_to_cpu(cmd->sync_timeout) * 10,
8468                                         le16_to_cpu(cmd->sync_timeout));
8469         print_create_sync_cte_type(cmd->cte_type);
8470 }
8471
8472 static void le_set_default_pa_sync_trans_params(uint16_t index,
8473                                                 const void *data, uint8_t size)
8474 {
8475         const struct bt_hci_cmd_default_pa_sync_trans_params *cmd = data;
8476
8477         print_sync_mode(cmd->mode);
8478         print_field("Skip: 0x%2.2x", cmd->skip);
8479         print_field("Sync timeout: %d msec (0x%4.4x)",
8480                                         le16_to_cpu(cmd->sync_timeout) * 10,
8481                                         le16_to_cpu(cmd->sync_timeout));
8482         print_create_sync_cte_type(cmd->cte_type);
8483 }
8484
8485 static void print_sca(uint8_t sca)
8486 {
8487         switch (sca) {
8488         case 0x00:
8489                 print_field("SCA: 201 - 500 ppm (0x%2.2x)", sca);
8490                 return;
8491         case 0x01:
8492                 print_field("SCA: 151 - 200 ppm (0x%2.2x)", sca);
8493                 return;
8494         case 0x02:
8495                 print_field("SCA: 101 - 150 ppm (0x%2.2x)", sca);
8496                 return;
8497         case 0x03:
8498                 print_field("SCA: 76 - 100 ppm (0x%2.2x)", sca);
8499                 return;
8500         case 0x04:
8501                 print_field("SCA: 51 - 75 ppm (0x%2.2x)", sca);
8502                 return;
8503         case 0x05:
8504                 print_field("SCA: 31 - 50 ppm (0x%2.2x)", sca);
8505                 return;
8506         case 0x06:
8507                 print_field("SCA: 21 - 30 ppm (0x%2.2x)", sca);
8508                 return;
8509         case 0x07:
8510                 print_field("SCA: 0 - 20 ppm (0x%2.2x)", sca);
8511                 return;
8512         default:
8513                 print_field("SCA: Reserved (0x%2.2x)", sca);
8514         }
8515 }
8516
8517 static void print_packing(uint8_t value)
8518 {
8519         switch (value) {
8520         case 0x00:
8521                 print_field("Packing: Sequential (0x%2.2x)", value);
8522                 return;
8523         case 0x01:
8524                 print_field("Packing: Interleaved (0x%2.2x)", value);
8525                 return;
8526         default:
8527                 print_field("Packing: Reserved (0x%2.2x)", value);
8528         }
8529 }
8530
8531 static void print_framing(uint8_t value)
8532 {
8533         switch (value) {
8534         case 0x00:
8535                 print_field("Framing: Unframed (0x%2.2x)", value);
8536                 return;
8537         case 0x01:
8538                 print_field("Framing: Framed (0x%2.2x)", value);
8539                 return;
8540         default:
8541                 print_field("Packing: Reserved (0x%2.2x)", value);
8542         }
8543 }
8544
8545 static void le_read_buffer_size_v2_rsp(uint16_t index, const void *data,
8546                                                         uint8_t size)
8547 {
8548         const struct bt_hci_rsp_le_read_buffer_size_v2 *rsp = data;
8549
8550         print_status(rsp->status);
8551
8552         if (size == 1)
8553                 return;
8554
8555         print_field("ACL MTU: %d", le16_to_cpu(rsp->acl_mtu));
8556         print_field("ACL max packet: %d", rsp->acl_max_pkt);
8557         print_field("ISO MTU: %d", le16_to_cpu(rsp->iso_mtu));
8558         print_field("ISO max packet: %d", rsp->iso_max_pkt);
8559 }
8560
8561 static void le_read_iso_tx_sync_cmd(uint16_t index, const void *data,
8562                                                         uint8_t size)
8563 {
8564         const struct bt_hci_cmd_le_read_iso_tx_sync *cmd = data;
8565
8566         print_field("Handle: %d", le16_to_cpu(cmd->handle));
8567 }
8568
8569 static void le_read_iso_tx_sync_rsp(uint16_t index, const void *data,
8570                                                         uint8_t size)
8571 {
8572         const struct bt_hci_rsp_le_read_iso_tx_sync *rsp = data;
8573         uint32_t offset = 0;
8574
8575         print_status(rsp->status);
8576
8577         if (size == 1)
8578                 return;
8579
8580         print_field("Handle: %d", le16_to_cpu(rsp->handle));
8581         print_field("Sequence Number: %d", le16_to_cpu(rsp->seq));
8582         print_field("Timestamp: %d", le32_to_cpu(rsp->timestamp));
8583
8584         memcpy(&offset, rsp->offset, sizeof(rsp->offset));
8585
8586         print_field("Offset: %d", le32_to_cpu(offset));
8587 }
8588
8589 static void print_cis_params(const void *data, int i)
8590 {
8591         const struct bt_hci_cis_params *cis = data;
8592
8593         print_field("CIS ID: 0x%2.2x", cis->cis_id);
8594         print_field("Central to Peripheral Maximum SDU Size: %u",
8595                                                 le16_to_cpu(cis->c_sdu));
8596         print_field("Peripheral to Central Maximum SDU Size: %u",
8597                                                 le16_to_cpu(cis->p_sdu));
8598         print_le_phy("Central to Peripheral PHY", cis->c_phy);
8599         print_le_phy("Peripheral to Central PHY", cis->p_phy);
8600         print_field("Central to Peripheral Retransmission attempts: 0x%2.2x",
8601                                                         cis->c_rtn);
8602         print_field("Peripheral to Central Retransmission attempts: 0x%2.2x",
8603                                                         cis->p_rtn);
8604 }
8605
8606 static void le_set_cig_params_cmd(uint16_t index, const void *data,
8607                                                         uint8_t size)
8608 {
8609         const struct bt_hci_cmd_le_set_cig_params *cmd = data;
8610
8611         print_field("CIG ID: 0x%2.2x", cmd->cig_id);
8612         print_usec_interval("Central to Peripheral SDU Interval",
8613                                                         cmd->c_interval);
8614         print_usec_interval("Peripheral to Central SDU Interval",
8615                                                         cmd->p_interval);
8616         print_sca(cmd->sca);
8617         print_packing(cmd->packing);
8618         print_framing(cmd->framing);
8619         print_field("Central to Peripheral Maximum Latency: %d ms (0x%4.4x)",
8620                 le16_to_cpu(cmd->c_latency), le16_to_cpu(cmd->c_latency));
8621         print_field("Peripheral to Central Maximum Latency: %d ms (0x%4.4x)",
8622                 le16_to_cpu(cmd->p_latency), le16_to_cpu(cmd->p_latency));
8623         print_field("Number of CIS: %u", cmd->num_cis);
8624
8625         size -= sizeof(*cmd);
8626
8627         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis),
8628                                                 print_cis_params);
8629 }
8630
8631 static void print_cis_params_test(const void *data, int i)
8632 {
8633         const struct bt_hci_cis_params_test *cis = data;
8634
8635         print_field("CIS ID: 0x%2.2x", cis->cis_id);
8636         print_field("NSE: 0x%2.2x", cis->nse);
8637         print_field("Central to Peripheral Maximum SDU: 0x%4.4x",
8638                                                 le16_to_cpu(cis->c_sdu));
8639         print_field("Peripheral to Central Maximum SDU: 0x%4.4x",
8640                                                 le16_to_cpu(cis->p_sdu));
8641         print_field("Central to Peripheral Maximum PDU: 0x%4.4x",
8642                                                 le16_to_cpu(cis->c_pdu));
8643         print_field("Peripheral to Central Maximum PDU: 0x%4.4x",
8644                                                 le16_to_cpu(cis->p_pdu));
8645         print_le_phy("Central to Peripheral PHY", cis->c_phy);
8646         print_le_phy("Peripheral to Central PHY", cis->p_phy);
8647         print_field("Central to Peripheral Burst Number: 0x%2.2x", cis->c_bn);
8648         print_field("Peripheral to Central Burst Number: 0x%2.2x", cis->p_bn);
8649 }
8650
8651 static void le_set_cig_params_test_cmd(uint16_t index, const void *data,
8652                                                         uint8_t size)
8653 {
8654         const struct bt_hci_cmd_le_set_cig_params_test *cmd = data;
8655
8656         print_field("CIG ID: 0x%2.2x", cmd->cig_id);
8657         print_usec_interval("Central to Peripheral SDU Interval",
8658                                                         cmd->c_interval);
8659         print_usec_interval("Peripheral to Central SDU Interval",
8660                                                         cmd->p_interval);
8661         print_field("Central to Peripheral Flush Timeout: 0x%2.2x", cmd->c_ft);
8662         print_field("Peripheral to Central Flush Timeout: 0x%2.2x", cmd->p_ft);
8663         print_field("ISO Interval: %.2f ms (0x%4.4x)",
8664                                 le16_to_cpu(cmd->iso_interval) * 1.25,
8665                                 le16_to_cpu(cmd->iso_interval));
8666         print_sca(cmd->sca);
8667         print_packing(cmd->packing);
8668         print_framing(cmd->framing);
8669         print_field("Number of CIS: %u", cmd->num_cis);
8670
8671         size -= sizeof(*cmd);
8672
8673         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis),
8674                                                 print_cis_params_test);
8675 }
8676
8677 static void print_cig_handle(const void *data, int i)
8678 {
8679         uint16_t handle = get_le16(data);
8680
8681         print_field("Connection Handle #%d: %d", i, handle);
8682 }
8683
8684 static void le_set_cig_params_rsp(uint16_t index, const void *data,
8685                                                         uint8_t size)
8686 {
8687         const struct bt_hci_rsp_le_set_cig_params *rsp = data;
8688
8689         print_status(rsp->status);
8690
8691         if (size == 1)
8692                 return;
8693
8694         print_field("CIG ID: 0x%2.2x", rsp->cig_id);
8695         print_field("Number of Handles: %u", rsp->num_handles);
8696
8697         size -= sizeof(*rsp);
8698
8699         print_list(rsp->handle, size, rsp->num_handles, sizeof(*rsp->handle),
8700                                                 print_cig_handle);
8701 }
8702
8703 static void print_cis(const void *data, int i)
8704 {
8705         const struct bt_hci_cis *cis = data;
8706
8707         print_field("CIS Handle: %d", cis->cis_handle);
8708         print_field("ACL Handle: %d", cis->acl_handle);
8709 }
8710
8711 static void le_create_cis_cmd(uint16_t index, const void *data, uint8_t size)
8712 {
8713         const struct bt_hci_cmd_le_create_cis *cmd = data;
8714
8715         print_field("Number of CIS: %u", cmd->num_cis);
8716
8717         size -= sizeof(*cmd);
8718
8719         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis), print_cis);
8720 }
8721
8722 static void le_remove_cig_cmd(uint16_t index, const void *data, uint8_t size)
8723 {
8724         const struct bt_hci_cmd_le_remove_cig *cmd = data;
8725
8726         print_field("CIG ID: 0x%02x", cmd->cig_id);
8727 }
8728
8729 static void le_remove_cig_rsp(uint16_t index, const void *data, uint8_t size)
8730 {
8731         const struct bt_hci_rsp_le_remove_cig *rsp = data;
8732
8733         print_status(rsp->status);
8734
8735         if (size == 1)
8736                 return;
8737
8738         print_field("CIG ID: 0x%2.2x", rsp->cig_id);
8739 }
8740
8741 static void le_accept_cis_req_cmd(uint16_t index, const void *data,
8742                                                         uint8_t size)
8743 {
8744         const struct bt_hci_cmd_le_accept_cis *cmd = data;
8745
8746         print_field("CIS Handle: %d", le16_to_cpu(cmd->handle));
8747 }
8748
8749 static void le_reject_cis_req_cmd(uint16_t index, const void *data,
8750                                                         uint8_t size)
8751 {
8752         const struct bt_hci_cmd_le_reject_cis *cmd = data;
8753
8754         print_field("CIS Handle: %d", le16_to_cpu(cmd->handle));
8755         print_reason(cmd->reason);
8756 }
8757
8758 static void print_bis(const struct bt_hci_bis *bis)
8759 {
8760         print_usec_interval("SDU Interval", bis->sdu_interval);
8761         print_field("Maximum SDU size: %u", le16_to_cpu(bis->sdu));
8762         print_field("Maximum Latency: %u ms (0x%4.4x)",
8763                         le16_to_cpu(bis->latency), le16_to_cpu(bis->latency));
8764         print_field("RTN: 0x%2.2x", bis->rtn);
8765         print_le_phy("PHY", bis->phy);
8766         print_packing(bis->packing);
8767         print_framing(bis->framing);
8768         print_field("Encryption: 0x%2.2x", bis->encryption);
8769         print_hex_field("Broadcast Code", bis->bcode, 16);
8770 }
8771
8772 static void le_create_big_cmd(uint16_t index, const void *data, uint8_t size)
8773 {
8774         const struct bt_hci_cmd_le_create_big *cmd = data;
8775
8776         print_field("Handle: 0x%2.2x", cmd->handle);
8777         print_field("Advertising Handle: 0x%2.2x", cmd->adv_handle);
8778         print_field("Number of BIS: %u", cmd->num_bis);
8779         print_bis(&cmd->bis);
8780 }
8781
8782 static void print_bis_test(const void *data, int i)
8783 {
8784         const struct bt_hci_bis_test *bis = data;
8785
8786         print_usec_interval("SDU Interval", bis->sdu_interval);
8787         print_field("ISO Interval: %.2f ms (0x%4.4x)",
8788                                 le16_to_cpu(bis->iso_interval) * 1.25,
8789                         le16_to_cpu(bis->iso_interval));
8790         print_field("Number of Subevents: %u", bis->nse);
8791         print_field("Maximum SDU: %u", bis->sdu);
8792         print_field("Maximum PDU: %u", bis->pdu);
8793         print_packing(bis->packing);
8794         print_framing(bis->framing);
8795         print_le_phy("PHY", bis->phy);
8796         print_field("Burst Number: %u", bis->bn);
8797         print_field("Immediate Repetition Count: %u", bis->irc);
8798         print_field("Pre Transmission Offset: 0x%2.2x", bis->pto);
8799         print_field("Encryption: 0x%2.2x", bis->encryption);
8800         print_hex_field("Broadcast Code", bis->bcode, 16);
8801 }
8802
8803 static void le_create_big_cmd_test_cmd(uint16_t index, const void *data,
8804                                                         uint8_t size)
8805 {
8806         const struct bt_hci_cmd_le_create_big_test *cmd = data;
8807
8808         print_field("BIG Handle: 0x%2.2x", cmd->big_handle);
8809         print_field("Advertising Handle: 0x%2.2x", cmd->adv_handle);
8810         print_field("Number of BIS: %u", cmd->num_bis);
8811
8812         size -= sizeof(*cmd);
8813
8814         print_list(cmd->bis, size, cmd->num_bis, sizeof(*cmd->bis),
8815                                                 print_bis_test);
8816 }
8817
8818 static void le_terminate_big_cmd(uint16_t index, const void *data, uint8_t size)
8819 {
8820         const struct bt_hci_cmd_le_term_big *cmd = data;
8821
8822         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8823         print_reason(cmd->reason);
8824 }
8825
8826 static void print_bis_sync(const void *data, int i)
8827 {
8828         const uint8_t *bis_id = data;
8829
8830         print_field("BIS ID: 0x%2.2x", *bis_id);
8831 }
8832
8833 static void le_big_create_sync_cmd(uint16_t index, const void *data,
8834                                                         uint8_t size)
8835 {
8836         const struct bt_hci_cmd_le_big_create_sync *cmd = data;
8837
8838         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8839         print_field("BIG Sync Handle: 0x%4.4x", le16_to_cpu(cmd->sync_handle));
8840         print_field("Encryption: %s (0x%2.2x)",
8841                         cmd->encryption ? "Encrypted" : "Unencrypted",
8842                         cmd->encryption);
8843         print_hex_field("Broadcast Code", cmd->bcode, 16);
8844         print_field("Maximum Number Subevents: 0x%2.2x", cmd->mse);
8845         print_field("Timeout: %d ms (0x%4.4x)", le16_to_cpu(cmd->timeout) * 10,
8846                                         le16_to_cpu(cmd->timeout));
8847         print_field("Number of BIS: %u", cmd->num_bis);
8848
8849         size -= sizeof(*cmd);
8850
8851         print_list(cmd->bis, size, cmd->num_bis, sizeof(*cmd->bis),
8852                                                 print_bis_sync);
8853 }
8854
8855 static void le_big_term_sync_cmd(uint16_t index, const void *data, uint8_t size)
8856 {
8857         const struct bt_hci_cmd_le_big_term_sync *cmd = data;
8858
8859         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8860 }
8861
8862 static void print_iso_path(const char *prefix, uint8_t path)
8863 {
8864         switch (path) {
8865         case 0x00:
8866                 print_field("%s: HCI (0x%2.2x)", prefix, path);
8867                 return;
8868         case 0xff:
8869                 print_field("%s: Disabled (0x%2.2x)", prefix, path);
8870                 return;
8871         default:
8872                 print_field("%s: Logical Channel Number %u", prefix, path);
8873         }
8874 }
8875
8876 static void le_setup_iso_path_cmd(uint16_t index, const void *data,
8877                                                         uint8_t size)
8878 {
8879         const struct bt_hci_cmd_le_setup_iso_path *cmd = data;
8880
8881         print_field("Handle: %d", le16_to_cpu(cmd->handle));
8882         print_path_direction("Data Path Direction", cmd->direction);
8883         print_iso_path("Data Path", cmd->path);
8884         print_codec_id("Coding Format", cmd->codec);
8885         packet_print_company("Company Codec ID", le16_to_cpu(cmd->codec_cid));
8886         print_field("Vendor Codec ID: %d", le16_to_cpu(cmd->codec_vid));
8887         print_usec_interval("Controller Delay", cmd->delay);
8888         print_field("Codec Configuration Length: %d", cmd->codec_cfg_len);
8889         print_hex_field("Codec Configuration", cmd->codec_cfg,
8890                                                 cmd->codec_cfg_len);
8891 }
8892
8893 static void le_setup_iso_path_rsp(uint16_t index, const void *data,
8894                                                         uint8_t size)
8895 {
8896         const struct bt_hci_rsp_le_setup_iso_path *rsp = data;
8897
8898         print_status(rsp->status);
8899
8900         if (size == 1)
8901                 return;
8902
8903         print_field("Handle: %d", le16_to_cpu(rsp->handle));
8904 }
8905
8906 static void le_remove_iso_path_cmd(uint16_t index, const void *data,
8907                                                         uint8_t size)
8908 {
8909         const struct bt_hci_cmd_le_remove_iso_path *cmd = data;
8910
8911         print_field("Connection Handle: %d", le16_to_cpu(cmd->handle));
8912         print_path_direction("Data Path Direction", cmd->direction);
8913 }
8914
8915 static void le_req_peer_sca_cmd(uint16_t index, const void *data, uint8_t size)
8916 {
8917         const struct bt_hci_cmd_le_req_peer_sca *cmd = data;
8918
8919         print_field("Connection Handle: %d", le16_to_cpu(cmd->handle));
8920 }
8921
8922 static void le_set_host_feature_cmd(uint16_t index, const void *data,
8923                                                         uint8_t size)
8924 {
8925         const struct bt_hci_cmd_le_set_host_feature *cmd = data;
8926         uint64_t mask;
8927
8928         print_field("Bit Number: %u", cmd->bit_number);
8929
8930         mask = print_bitfield(2, (((uint64_t) 1) << cmd->bit_number),
8931                                                         features_le);
8932         if (mask)
8933                 print_text(COLOR_UNKNOWN_FEATURE_BIT, "  Unknown features "
8934                                                 "(0x%16.16" PRIx64 ")", mask);
8935
8936         print_field("Bit Value: %u", cmd->bit_value);
8937 }
8938
8939 struct opcode_data {
8940         uint16_t opcode;
8941         int bit;
8942         const char *str;
8943         void (*cmd_func) (uint16_t index, const void *data, uint8_t size);
8944         uint8_t cmd_size;
8945         bool cmd_fixed;
8946         void (*rsp_func) (uint16_t index, const void *data, uint8_t size);
8947         uint8_t rsp_size;
8948         bool rsp_fixed;
8949 };
8950
8951 static const struct opcode_data opcode_table[] = {
8952         { 0x0000,  -1, "NOP" },
8953
8954         /* OGF 1 - Link Control */
8955         { 0x0401,   0, "Inquiry",
8956                                 inquiry_cmd, 5, true },
8957         { 0x0402,   1, "Inquiry Cancel",
8958                                 null_cmd, 0, true,
8959                                 status_rsp, 1, true },
8960         { 0x0403,   2, "Periodic Inquiry Mode",
8961                                 periodic_inquiry_cmd, 9, true,
8962                                 status_rsp, 1, true },
8963         { 0x0404,   3, "Exit Periodic Inquiry Mode",
8964                                 null_cmd, 0, true,
8965                                 status_rsp, 1, true },
8966         { 0x0405,   4, "Create Connection",
8967                                 create_conn_cmd, 13, true },
8968         { 0x0406,   5, "Disconnect",
8969                                 disconnect_cmd, 3, true },
8970         { 0x0407,   6, "Add SCO Connection",
8971                                 add_sco_conn_cmd, 4, true },
8972         { 0x0408,   7, "Create Connection Cancel",
8973                                 create_conn_cancel_cmd, 6, true,
8974                                 status_bdaddr_rsp, 7, true },
8975         { 0x0409,   8, "Accept Connection Request",
8976                                 accept_conn_request_cmd, 7, true },
8977         { 0x040a,   9, "Reject Connection Request",
8978                                 reject_conn_request_cmd, 7, true },
8979         { 0x040b,  10, "Link Key Request Reply",
8980                                 link_key_request_reply_cmd, 22, true,
8981                                 status_bdaddr_rsp, 7, true },
8982         { 0x040c,  11, "Link Key Request Negative Reply",
8983                                 link_key_request_neg_reply_cmd, 6, true,
8984                                 status_bdaddr_rsp, 7, true },
8985         { 0x040d,  12, "PIN Code Request Reply",
8986                                 pin_code_request_reply_cmd, 23, true,
8987                                 status_bdaddr_rsp, 7, true },
8988         { 0x040e,  13, "PIN Code Request Negative Reply",
8989                                 pin_code_request_neg_reply_cmd, 6, true,
8990                                 status_bdaddr_rsp, 7, true },
8991         { 0x040f,  14, "Change Connection Packet Type",
8992                                 change_conn_pkt_type_cmd, 4, true },
8993         { 0x0411,  15, "Authentication Requested",
8994                                 auth_requested_cmd, 2, true },
8995         { 0x0413,  16, "Set Connection Encryption",
8996                                 set_conn_encrypt_cmd, 3, true },
8997         { 0x0415,  17, "Change Connection Link Key",
8998                                 change_conn_link_key_cmd, 2, true },
8999         { 0x0417,  18, "Temporary Link Key",
9000                                 link_key_selection_cmd, 1, true },
9001         { 0x0419,  19, "Remote Name Request",
9002                                 remote_name_request_cmd, 10, true },
9003         { 0x041a,  20, "Remote Name Request Cancel",
9004                                 remote_name_request_cancel_cmd, 6, true,
9005                                 status_bdaddr_rsp, 7, true },
9006         { 0x041b,  21, "Read Remote Supported Features",
9007                                 read_remote_features_cmd, 2, true },
9008         { 0x041c,  22, "Read Remote Extended Features",
9009                                 read_remote_ext_features_cmd, 3, true },
9010         { 0x041d,  23, "Read Remote Version Information",
9011                                 read_remote_version_cmd, 2, true },
9012         { 0x041f,  24, "Read Clock Offset",
9013                                 read_clock_offset_cmd, 2, true },
9014         { 0x0420,  25, "Read LMP Handle",
9015                                 read_lmp_handle_cmd, 2, true,
9016                                 read_lmp_handle_rsp, 8, true },
9017         { 0x0428, 131, "Setup Synchronous Connection",
9018                                 setup_sync_conn_cmd, 17, true },
9019         { 0x0429, 132, "Accept Synchronous Connection Request",
9020                                 accept_sync_conn_request_cmd, 21, true },
9021         { 0x042a, 133, "Reject Synchronous Connection Request",
9022                                 reject_sync_conn_request_cmd, 7, true },
9023         { 0x042b, 151, "IO Capability Request Reply",
9024                                 io_capability_request_reply_cmd, 9, true,
9025                                 status_bdaddr_rsp, 7, true },
9026         { 0x042c, 152, "User Confirmation Request Reply",
9027                                 user_confirm_request_reply_cmd, 6, true,
9028                                 status_bdaddr_rsp, 7, true },
9029         { 0x042d, 153, "User Confirmation Request Neg Reply",
9030                                 user_confirm_request_neg_reply_cmd, 6, true,
9031                                 status_bdaddr_rsp, 7, true },
9032         { 0x042e, 154, "User Passkey Request Reply",
9033                                 user_passkey_request_reply_cmd, 10, true,
9034                                 status_bdaddr_rsp, 7, true },
9035         { 0x042f, 155, "User Passkey Request Negative Reply",
9036                                 user_passkey_request_neg_reply_cmd, 6, true,
9037                                 status_bdaddr_rsp, 7, true },
9038         { 0x0430, 156, "Remote OOB Data Request Reply",
9039                                 remote_oob_data_request_reply_cmd, 38, true,
9040                                 status_bdaddr_rsp, 7, true },
9041         { 0x0433, 159, "Remote OOB Data Request Neg Reply",
9042                                 remote_oob_data_request_neg_reply_cmd, 6, true,
9043                                 status_bdaddr_rsp, 7, true },
9044         { 0x0434, 163, "IO Capability Request Negative Reply",
9045                                 io_capability_request_neg_reply_cmd, 7, true,
9046                                 status_bdaddr_rsp, 7, true },
9047         { 0x0435, 168, "Create Physical Link",
9048                                 create_phy_link_cmd, 3, false },
9049         { 0x0436, 169, "Accept Physical Link",
9050                                 accept_phy_link_cmd, 3, false },
9051         { 0x0437, 170, "Disconnect Physical Link",
9052                                 disconn_phy_link_cmd, 2, true },
9053         { 0x0438, 171, "Create Logical Link",
9054                                 create_logic_link_cmd, 33, true },
9055         { 0x0439, 172, "Accept Logical Link",
9056                                 accept_logic_link_cmd, 33, true },
9057         { 0x043a, 173, "Disconnect Logical Link",
9058                                 disconn_logic_link_cmd, 2, true },
9059         { 0x043b, 174, "Logical Link Cancel",
9060                                 logic_link_cancel_cmd, 2, true,
9061                                 logic_link_cancel_rsp, 3, true },
9062         { 0x043c, 175, "Flow Specifcation Modify",
9063                                 flow_spec_modify_cmd, 34, true },
9064         { 0x043d, 235, "Enhanced Setup Synchronous Connection",
9065                                 enhanced_setup_sync_conn_cmd, 59, true },
9066         { 0x043e, 236, "Enhanced Accept Synchronous Connection Request",
9067                                 enhanced_accept_sync_conn_request_cmd, 63, true },
9068         { 0x043f, 246, "Truncated Page",
9069                                 truncated_page_cmd, 9, true },
9070         { 0x0440, 247, "Truncated Page Cancel",
9071                                 truncated_page_cancel_cmd, 6, true,
9072                                 status_bdaddr_rsp, 7, true },
9073         { 0x0441, 248, "Set Connectionless Peripheral Broadcast",
9074                                 set_peripheral_broadcast_cmd, 11, true,
9075                                 set_peripheral_broadcast_rsp, 4, true },
9076         { 0x0442, 249, "Set Connectionless Peripheral Broadcast Receive",
9077                                 set_peripheral_broadcast_receive_cmd, 34, true,
9078                                 set_peripheral_broadcast_receive_rsp, 8, true },
9079         { 0x0443, 250, "Start Synchronization Train",
9080                                 null_cmd, 0, true },
9081         { 0x0444, 251, "Receive Synchronization Train",
9082                                 receive_sync_train_cmd, 12, true },
9083         { 0x0445, 257, "Remote OOB Extended Data Request Reply",
9084                                 remote_oob_ext_data_request_reply_cmd, 70, true,
9085                                 status_bdaddr_rsp, 7, true },
9086
9087         /* OGF 2 - Link Policy */
9088         { 0x0801,  33, "Hold Mode",
9089                                 hold_mode_cmd, 6, true },
9090         { 0x0803,  34, "Sniff Mode",
9091                                 sniff_mode_cmd, 10, true },
9092         { 0x0804,  35, "Exit Sniff Mode",
9093                                 exit_sniff_mode_cmd, 2, true },
9094         { 0x0805,  36, "Park State",
9095                                 park_state_cmd, 6, true },
9096         { 0x0806,  37, "Exit Park State",
9097                                 exit_park_state_cmd, 2, true },
9098         { 0x0807,  38, "QoS Setup",
9099                                 qos_setup_cmd, 20, true },
9100         { 0x0809,  39, "Role Discovery",
9101                                 role_discovery_cmd, 2, true,
9102                                 role_discovery_rsp, 4, true },
9103         { 0x080b,  40, "Switch Role",
9104                                 switch_role_cmd, 7, true },
9105         { 0x080c,  41, "Read Link Policy Settings",
9106                                 read_link_policy_cmd, 2, true,
9107                                 read_link_policy_rsp, 5, true },
9108         { 0x080d,  42, "Write Link Policy Settings",
9109                                 write_link_policy_cmd, 4, true,
9110                                 write_link_policy_rsp, 3, true },
9111         { 0x080e,  43, "Read Default Link Policy Settings",
9112                                 null_cmd, 0, true,
9113                                 read_default_link_policy_rsp, 3, true },
9114         { 0x080f,  44, "Write Default Link Policy Settings",
9115                                 write_default_link_policy_cmd, 2, true,
9116                                 status_rsp, 1, true },
9117         { 0x0810,  45, "Flow Specification",
9118                                 flow_spec_cmd, 21, true },
9119         { 0x0811, 140, "Sniff Subrating",
9120                                 sniff_subrating_cmd, 8, true,
9121                                 sniff_subrating_rsp, 3, true },
9122
9123         /* OGF 3 - Host Control */
9124         { 0x0c01,  46, "Set Event Mask",
9125                                 set_event_mask_cmd, 8, true,
9126                                 status_rsp, 1, true },
9127         { 0x0c03,  47, "Reset",
9128                                 null_cmd, 0, true,
9129                                 status_rsp, 1, true },
9130         { 0x0c05,  48, "Set Event Filter",
9131                                 set_event_filter_cmd, 1, false,
9132                                 status_rsp, 1, true },
9133         { 0x0c08,  49, "Flush",
9134                                 flush_cmd, 2, true,
9135                                 flush_rsp, 3, true },
9136         { 0x0c09,  50, "Read PIN Type",
9137                                 null_cmd, 0, true,
9138                                 read_pin_type_rsp, 2, true },
9139         { 0x0c0a,  51, "Write PIN Type",
9140                                 write_pin_type_cmd, 1, true,
9141                                 status_rsp, 1, true },
9142         { 0x0c0b,  52, "Create New Unit Key",
9143                                 null_cmd, 0, true,
9144                                 status_rsp, 1, true },
9145         { 0x0c0d,  53, "Read Stored Link Key",
9146                                 read_stored_link_key_cmd, 7, true,
9147                                 read_stored_link_key_rsp, 5, true },
9148         { 0x0c11,  54, "Write Stored Link Key",
9149                                 write_stored_link_key_cmd, 1, false,
9150                                 write_stored_link_key_rsp, 2, true },
9151         { 0x0c12,  55, "Delete Stored Link Key",
9152                                 delete_stored_link_key_cmd, 7, true,
9153                                 delete_stored_link_key_rsp, 3, true },
9154         { 0x0c13,  56, "Write Local Name",
9155                                 write_local_name_cmd, 248, true,
9156                                 status_rsp, 1, true },
9157         { 0x0c14,  57, "Read Local Name",
9158                                 null_cmd, 0, true,
9159                                 read_local_name_rsp, 249, true },
9160         { 0x0c15,  58, "Read Connection Accept Timeout",
9161                                 null_cmd, 0, true,
9162                                 read_conn_accept_timeout_rsp, 3, true },
9163         { 0x0c16,  59, "Write Connection Accept Timeout",
9164                                 write_conn_accept_timeout_cmd, 2, true,
9165                                 status_rsp, 1, true },
9166         { 0x0c17,  60, "Read Page Timeout",
9167                                 null_cmd, 0, true,
9168                                 read_page_timeout_rsp, 3, true },
9169         { 0x0c18,  61, "Write Page Timeout",
9170                                 write_page_timeout_cmd, 2, true,
9171                                 status_rsp, 1, true },
9172         { 0x0c19,  62, "Read Scan Enable",
9173                                 null_cmd, 0, true,
9174                                 read_scan_enable_rsp, 2, true },
9175         { 0x0c1a,  63, "Write Scan Enable",
9176                                 write_scan_enable_cmd, 1, true,
9177                                 status_rsp, 1, true },
9178         { 0x0c1b,  64, "Read Page Scan Activity",
9179                                 null_cmd, 0, true,
9180                                 read_page_scan_activity_rsp, 5, true },
9181         { 0x0c1c,  65, "Write Page Scan Activity",
9182                                 write_page_scan_activity_cmd, 4, true,
9183                                 status_rsp, 1, true },
9184         { 0x0c1d,  66, "Read Inquiry Scan Activity",
9185                                 null_cmd, 0, true,
9186                                 read_inquiry_scan_activity_rsp, 5, true },
9187         { 0x0c1e,  67, "Write Inquiry Scan Activity",
9188                                 write_inquiry_scan_activity_cmd, 4, true,
9189                                 status_rsp, 1, true },
9190         { 0x0c1f,  68, "Read Authentication Enable",
9191                                 null_cmd, 0, true,
9192                                 read_auth_enable_rsp, 2, true },
9193         { 0x0c20,  69, "Write Authentication Enable",
9194                                 write_auth_enable_cmd, 1, true,
9195                                 status_rsp, 1, true },
9196         { 0x0c21,  70, "Read Encryption Mode",
9197                                 null_cmd, 0, true,
9198                                 read_encrypt_mode_rsp, 2, true },
9199         { 0x0c22,  71, "Write Encryption Mode",
9200                                 write_encrypt_mode_cmd, 1, true,
9201                                 status_rsp, 1, true },
9202         { 0x0c23,  72, "Read Class of Device",
9203                                 null_cmd, 0, true,
9204                                 read_class_of_dev_rsp, 4, true },
9205         { 0x0c24,  73, "Write Class of Device",
9206                                 write_class_of_dev_cmd, 3, true,
9207                                 status_rsp, 1, true },
9208         { 0x0c25,  74, "Read Voice Setting",
9209                                 null_cmd, 0, true,
9210                                 read_voice_setting_rsp, 3, true },
9211         { 0x0c26,  75, "Write Voice Setting",
9212                                 write_voice_setting_cmd, 2, true,
9213                                 status_rsp, 1, true },
9214         { 0x0c27,  76, "Read Automatic Flush Timeout",
9215                                 read_auto_flush_timeout_cmd, 2, true,
9216                                 read_auto_flush_timeout_rsp, 5, true },
9217         { 0x0c28,  77, "Write Automatic Flush Timeout",
9218                                 write_auto_flush_timeout_cmd, 4, true,
9219                                 write_auto_flush_timeout_rsp, 3, true },
9220         { 0x0c29,  78, "Read Num Broadcast Retransmissions",
9221                                 null_cmd, 0, true,
9222                                 read_num_broadcast_retrans_rsp, 2, true },
9223         { 0x0c2a,  79, "Write Num Broadcast Retransmissions",
9224                                 write_num_broadcast_retrans_cmd, 1, true,
9225                                 status_rsp, 1, true },
9226         { 0x0c2b,  80, "Read Hold Mode Activity",
9227                                 null_cmd, 0, true,
9228                                 read_hold_mode_activity_rsp, 2, true },
9229         { 0x0c2c,  81, "Write Hold Mode Activity",
9230                                 write_hold_mode_activity_cmd, 1, true,
9231                                 status_rsp, 1, true },
9232         { 0x0c2d,  82, "Read Transmit Power Level",
9233                                 read_tx_power_cmd, 3, true,
9234                                 read_tx_power_rsp, 4, true },
9235         { 0x0c2e,  83, "Read Sync Flow Control Enable",
9236                                 null_cmd, 0, true,
9237                                 read_sync_flow_control_rsp, 2, true },
9238         { 0x0c2f,  84, "Write Sync Flow Control Enable",
9239                                 write_sync_flow_control_cmd, 1, true,
9240                                 status_rsp, 1, true },
9241         { 0x0c31,  85, "Set Controller To Host Flow Control",
9242                                 set_host_flow_control_cmd, 1, true,
9243                                 status_rsp, 1, true },
9244         { 0x0c33,  86, "Host Buffer Size",
9245                                 host_buffer_size_cmd, 7, true,
9246                                 status_rsp, 1, true },
9247         { 0x0c35,  87, "Host Number of Completed Packets",
9248                                 host_num_completed_packets_cmd, 5, false },
9249         { 0x0c36,  88, "Read Link Supervision Timeout",
9250                                 read_link_supv_timeout_cmd, 2, true,
9251                                 read_link_supv_timeout_rsp, 5, true },
9252         { 0x0c37,  89, "Write Link Supervision Timeout",
9253                                 write_link_supv_timeout_cmd, 4, true,
9254                                 write_link_supv_timeout_rsp, 3, true },
9255         { 0x0c38,  90, "Read Number of Supported IAC",
9256                                 null_cmd, 0, true,
9257                                 read_num_supported_iac_rsp, 2, true },
9258         { 0x0c39,  91, "Read Current IAC LAP",
9259                                 null_cmd, 0, true,
9260                                 read_current_iac_lap_rsp, 2, false },
9261         { 0x0c3a,  92, "Write Current IAC LAP",
9262                                 write_current_iac_lap_cmd, 1, false,
9263                                 status_rsp, 1, true },
9264         { 0x0c3b,  93, "Read Page Scan Period Mode",
9265                                 null_cmd, 0, true,
9266                                 read_page_scan_period_mode_rsp, 2, true },
9267         { 0x0c3c,  94, "Write Page Scan Period Mode",
9268                                 write_page_scan_period_mode_cmd, 1, true,
9269                                 status_rsp, 1, true },
9270         { 0x0c3d,  95, "Read Page Scan Mode",
9271                                 null_cmd, 0, true,
9272                                 read_page_scan_mode_rsp, 2, true },
9273         { 0x0c3e,  96, "Write Page Scan Mode",
9274                                 write_page_scan_mode_cmd, 1, true,
9275                                 status_rsp, 1, true },
9276         { 0x0c3f,  97, "Set AFH Host Channel Classification",
9277                                 set_afh_host_classification_cmd, 10, true,
9278                                 status_rsp, 1, true },
9279         { 0x0c42, 100, "Read Inquiry Scan Type",
9280                                 null_cmd, 0, true,
9281                                 read_inquiry_scan_type_rsp, 2, true },
9282         { 0x0c43, 101, "Write Inquiry Scan Type",
9283                                 write_inquiry_scan_type_cmd, 1, true,
9284                                 status_rsp, 1, true },
9285         { 0x0c44, 102, "Read Inquiry Mode",
9286                                 null_cmd, 0, true,
9287                                 read_inquiry_mode_rsp, 2, true },
9288         { 0x0c45, 103, "Write Inquiry Mode",
9289                                 write_inquiry_mode_cmd, 1, true,
9290                                 status_rsp, 1, true },
9291         { 0x0c46, 104, "Read Page Scan Type",
9292                                 null_cmd, 0, true,
9293                                 read_page_scan_type_rsp, 2, true },
9294         { 0x0c47, 105, "Write Page Scan Type",
9295                                 write_page_scan_type_cmd, 1, true,
9296                                 status_rsp, 1, true },
9297         { 0x0c48, 106, "Read AFH Channel Assessment Mode",
9298                                 null_cmd, 0, true,
9299                                 read_afh_assessment_mode_rsp, 2, true },
9300         { 0x0c49, 107, "Write AFH Channel Assessment Mode",
9301                                 write_afh_assessment_mode_cmd, 1, true,
9302                                 status_rsp, 1, true },
9303         { 0x0c51, 136, "Read Extended Inquiry Response",
9304                                 null_cmd, 0, true,
9305                                 read_ext_inquiry_response_rsp, 242, true },
9306         { 0x0c52, 137, "Write Extended Inquiry Response",
9307                                 write_ext_inquiry_response_cmd, 241, true,
9308                                 status_rsp, 1, true },
9309         { 0x0c53, 138, "Refresh Encryption Key",
9310                                 refresh_encrypt_key_cmd, 2, true },
9311         { 0x0c55, 141, "Read Simple Pairing Mode",
9312                                 null_cmd, 0, true,
9313                                 read_simple_pairing_mode_rsp, 2, true },
9314         { 0x0c56, 142, "Write Simple Pairing Mode",
9315                                 write_simple_pairing_mode_cmd, 1, true,
9316                                 status_rsp, 1, true },
9317         { 0x0c57, 143, "Read Local OOB Data",
9318                                 null_cmd, 0, true,
9319                                 read_local_oob_data_rsp, 33, true },
9320         { 0x0c58, 144, "Read Inquiry Response TX Power Level",
9321                                 null_cmd, 0, true,
9322                                 read_inquiry_resp_tx_power_rsp, 2, true },
9323         { 0x0c59, 145, "Write Inquiry Transmit Power Level",
9324                                 write_inquiry_tx_power_cmd, 1, true,
9325                                 status_rsp, 1, true },
9326         { 0x0c5a, 146, "Read Default Erroneous Data Reporting",
9327                                 null_cmd, 0, true,
9328                                 read_erroneous_reporting_rsp, 2, true },
9329         { 0x0c5b, 147, "Write Default Erroneous Data Reporting",
9330                                 write_erroneous_reporting_cmd, 1, true,
9331                                 status_rsp, 1, true },
9332         { 0x0c5f, 158, "Enhanced Flush",
9333                                 enhanced_flush_cmd, 3, true },
9334         { 0x0c60, 162, "Send Keypress Notification",
9335                                 send_keypress_notify_cmd, 7, true,
9336                                 send_keypress_notify_rsp, 7, true },
9337         { 0x0c61, 176, "Read Logical Link Accept Timeout" },
9338         { 0x0c62, 177, "Write Logical Link Accept Timeout" },
9339         { 0x0c63, 178, "Set Event Mask Page 2",
9340                                 set_event_mask_page2_cmd, 8, true,
9341                                 status_rsp, 1, true },
9342         { 0x0c64, 179, "Read Location Data",
9343                                 null_cmd, 0, true,
9344                                 read_location_data_rsp, 6, true },
9345         { 0x0c65, 180, "Write Location Data",
9346                                 write_location_data_cmd, 5, true,
9347                                 status_rsp, 1, true },
9348         { 0x0c66, 184, "Read Flow Control Mode",
9349                                 null_cmd, 0, true,
9350                                 read_flow_control_mode_rsp, 2, true },
9351         { 0x0c67, 185, "Write Flow Control Mode",
9352                                 write_flow_control_mode_cmd, 1, true,
9353                                 status_rsp, 1, true },
9354         { 0x0c68, 192, "Read Enhanced Transmit Power Level",
9355                                 read_enhanced_tx_power_cmd, 3, true,
9356                                 read_enhanced_tx_power_rsp, 6, true },
9357         { 0x0c69, 194, "Read Best Effort Flush Timeout" },
9358         { 0x0c6a, 195, "Write Best Effort Flush Timeout" },
9359         { 0x0c6b, 196, "Short Range Mode",
9360                                 short_range_mode_cmd, 2, true },
9361         { 0x0c6c, 197, "Read LE Host Supported",
9362                                 null_cmd, 0, true,
9363                                 read_le_host_supported_rsp, 3, true },
9364         { 0x0c6d, 198, "Write LE Host Supported",
9365                                 write_le_host_supported_cmd, 2, true,
9366                                 status_rsp, 1, true },
9367         { 0x0c6e, 238, "Set MWS Channel Parameters" },
9368         { 0x0c6f, 239, "Set External Frame Configuration" },
9369         { 0x0c70, 240, "Set MWS Signaling" },
9370         { 0x0c71, 241, "Set MWS Transport Layer" },
9371         { 0x0c72, 242, "Set MWS Scan Frequency Table" },
9372         { 0x0c73, 244, "Set MWS Pattern Configuration" },
9373         { 0x0c74, 252, "Set Reserved LT_ADDR",
9374                                 set_reserved_lt_addr_cmd, 1, true,
9375                                 set_reserved_lt_addr_rsp, 2, true },
9376         { 0x0c75, 253, "Delete Reserved LT_ADDR",
9377                                 delete_reserved_lt_addr_cmd, 1, true,
9378                                 delete_reserved_lt_addr_rsp, 2, true },
9379         { 0x0c76, 254, "Set Connectionless Peripheral Broadcast Data",
9380                                 set_peripheral_broadcast_data_cmd, 3, false,
9381                                 set_peripheral_broadcast_data_rsp, 2, true },
9382         { 0x0c77, 255, "Read Synchronization Train Parameters",
9383                                 null_cmd, 0, true,
9384                                 read_sync_train_params_rsp, 8, true },
9385         { 0x0c78, 256, "Write Synchronization Train Parameters",
9386                                 write_sync_train_params_cmd, 9, true,
9387                                 write_sync_train_params_rsp, 3, true },
9388         { 0x0c79, 258, "Read Secure Connections Host Support",
9389                                 null_cmd, 0, true,
9390                                 read_secure_conn_support_rsp, 2, true },
9391         { 0x0c7a, 259, "Write Secure Connections Host Support",
9392                                 write_secure_conn_support_cmd, 1, true,
9393                                 status_rsp, 1, true },
9394         { 0x0c7b, 260, "Read Authenticated Payload Timeout",
9395                                 read_auth_payload_timeout_cmd, 2, true,
9396                                 read_auth_payload_timeout_rsp, 5, true },
9397         { 0x0c7c, 261, "Write Authenticated Payload Timeout",
9398                                 write_auth_payload_timeout_cmd, 4, true,
9399                                 write_auth_payload_timeout_rsp, 3, true },
9400         { 0x0c7d, 262, "Read Local OOB Extended Data",
9401                                 null_cmd, 0, true,
9402                                 read_local_oob_ext_data_rsp, 65, true },
9403         { 0x0c7e, 264, "Read Extended Page Timeout",
9404                                 null_cmd, 0, true,
9405                                 read_ext_page_timeout_rsp, 3, true },
9406         { 0x0c7f, 265, "Write Extended Page Timeout",
9407                                 write_ext_page_timeout_cmd, 2, true,
9408                                 status_rsp, 1, true },
9409         { 0x0c80, 266, "Read Extended Inquiry Length",
9410                                 null_cmd, 0, true,
9411                                 read_ext_inquiry_length_rsp, 3, true },
9412         { 0x0c81, 267, "Write Extended Inquiry Length",
9413                                 write_ext_inquiry_length_cmd, 2, true,
9414                                 status_rsp, 1, true },
9415
9416         /* OGF 4 - Information Parameter */
9417         { 0x1001, 115, "Read Local Version Information",
9418                                 null_cmd, 0, true,
9419                                 read_local_version_rsp, 9, true },
9420         { 0x1002, 116, "Read Local Supported Commands",
9421                                 null_cmd, 0, true,
9422                                 read_local_commands_rsp, 65, true },
9423         { 0x1003, 117, "Read Local Supported Features",
9424                                 null_cmd, 0, true,
9425                                 read_local_features_rsp, 9, true },
9426         { 0x1004, 118, "Read Local Extended Features",
9427                                 read_local_ext_features_cmd, 1, true,
9428                                 read_local_ext_features_rsp, 11, true },
9429         { 0x1005, 119, "Read Buffer Size",
9430                                 null_cmd, 0, true,
9431                                 read_buffer_size_rsp, 8, true },
9432         { 0x1007, 120, "Read Country Code",
9433                                 null_cmd, 0, true,
9434                                 read_country_code_rsp, 2, true },
9435         { 0x1009, 121, "Read BD ADDR",
9436                                 null_cmd, 0, true,
9437                                 read_bd_addr_rsp, 7, true },
9438         { 0x100a, 186, "Read Data Block Size",
9439                                 null_cmd, 0, true,
9440                                 read_data_block_size_rsp, 7, true },
9441         { 0x100b, 237, "Read Local Supported Codecs",
9442                                 null_cmd, 0, true,
9443                                 read_local_codecs_rsp, 3, false },
9444         { 0x100c, 331, "Read Local Simple Pairing Options",
9445                                 null_cmd, 0, true,
9446                                 read_local_pairing_options_rsp, 3, true },
9447         { BT_HCI_CMD_READ_LOCAL_CODECS_V2, BT_HCI_BIT_READ_LOCAL_CODECS_V2,
9448                 "Read Local Supported Codecs V2",
9449                 null_cmd, 0, true,
9450                 read_local_codecs_rsp_v2,
9451                 sizeof(struct bt_hci_rsp_read_local_codecs_v2), false
9452         },
9453         { BT_HCI_CMD_READ_LOCAL_CODEC_CAPS, BT_HCI_BIT_READ_LOCAL_CODEC_CAPS,
9454                 "Read Local Supported Codec Capabilities",
9455                 read_local_codec_caps_cmd,
9456                 sizeof(struct bt_hci_cmd_read_local_codec_caps), true,
9457                 read_local_codec_caps_rsp,
9458                 sizeof(struct bt_hci_rsp_read_local_codec_caps), false
9459         },
9460         { BT_HCI_CMD_READ_LOCAL_CTRL_DELAY, BT_HCI_BIT_READ_LOCAL_CTRL_DELAY,
9461                 "Read Local Supported Controller Delay",
9462                 read_local_ctrl_delay_cmd,
9463                 sizeof(struct bt_hci_cmd_read_local_ctrl_delay), false,
9464                 read_local_ctrl_delay_rsp,
9465                 sizeof(struct bt_hci_rsp_read_local_ctrl_delay), true
9466         },
9467         { BT_HCI_CMD_CONFIG_DATA_PATH, BT_HCI_BIT_CONFIG_DATA_PATH,
9468                 "Configure Data Path",
9469                 config_data_path_cmd,
9470                 sizeof(struct bt_hci_cmd_config_data_path), false,
9471                 status_rsp, 1, true
9472         },
9473
9474         /* OGF 5 - Status Parameter */
9475         { 0x1401, 122, "Read Failed Contact Counter",
9476                                 read_failed_contact_counter_cmd, 2, true,
9477                                 read_failed_contact_counter_rsp, 5, true },
9478         { 0x1402, 123, "Reset Failed Contact Counter",
9479                                 reset_failed_contact_counter_cmd, 2, true,
9480                                 reset_failed_contact_counter_rsp, 3, true },
9481         { 0x1403, 124, "Read Link Quality",
9482                                 read_link_quality_cmd, 2, true,
9483                                 read_link_quality_rsp, 4, true },
9484         { 0x1405, 125, "Read RSSI",
9485                                 read_rssi_cmd, 2, true,
9486                                 read_rssi_rsp, 4, true },
9487         { 0x1406, 126, "Read AFH Channel Map",
9488                                 read_afh_channel_map_cmd, 2, true,
9489                                 read_afh_channel_map_rsp, 14, true },
9490         { 0x1407, 127, "Read Clock",
9491                                 read_clock_cmd, 3, true,
9492                                 read_clock_rsp, 9, true },
9493         { 0x1408, 164, "Read Encryption Key Size",
9494                                 read_encrypt_key_size_cmd, 2, true,
9495                                 read_encrypt_key_size_rsp, 4, true },
9496         { 0x1409, 181, "Read Local AMP Info",
9497                                 null_cmd, 0, true,
9498                                 read_local_amp_info_rsp, 31, true },
9499         { 0x140a, 182, "Read Local AMP ASSOC",
9500                                 read_local_amp_assoc_cmd, 5, true,
9501                                 read_local_amp_assoc_rsp, 5, false },
9502         { 0x140b, 183, "Write Remote AMP ASSOC",
9503                                 write_remote_amp_assoc_cmd, 6, false,
9504                                 write_remote_amp_assoc_rsp, 2, true },
9505         { 0x140c, 243, "Get MWS Transport Layer Configuration",
9506                                 null_cmd, 0, true,
9507                                 get_mws_transport_config_rsp, 2, false },
9508         { 0x140d, 245, "Set Triggered Clock Capture",
9509                                 set_triggered_clock_capture_cmd, 6, true,
9510                                 status_rsp, 1, true },
9511
9512         /* OGF 6 - Testing */
9513         { 0x1801, 128, "Read Loopback Mode",
9514                                 null_cmd, 0, true,
9515                                 read_loopback_mode_rsp, 2, true },
9516         { 0x1802, 129, "Write Loopback Mode",
9517                                 write_loopback_mode_cmd, 1, true,
9518                                 status_rsp, 1, true },
9519         { 0x1803, 130, "Enable Device Under Test Mode",
9520                                 null_cmd, 0, true,
9521                                 status_rsp, 1, true },
9522         { 0x1804, 157, "Write Simple Pairing Debug Mode",
9523                                 write_ssp_debug_mode_cmd, 1, true,
9524                                 status_rsp, 1, true },
9525         { 0x1807, 189, "Enable AMP Receiver Reports" },
9526         { 0x1808, 190, "AMP Test End" },
9527         { 0x1809, 191, "AMP Test" },
9528         { 0x180a, 263, "Write Secure Connections Test Mode" },
9529
9530         /* OGF 8 - LE Control */
9531         { 0x2001, 200, "LE Set Event Mask",
9532                                 le_set_event_mask_cmd, 8, true,
9533                                 status_rsp, 1, true },
9534         { 0x2002, 201, "LE Read Buffer Size",
9535                                 null_cmd, 0, true,
9536                                 le_read_buffer_size_rsp, 4, true },
9537         { 0x2003, 202, "LE Read Local Supported Features",
9538                                 null_cmd, 0, true,
9539                                 le_read_local_features_rsp, 9, true },
9540         { 0x2005, 204, "LE Set Random Address",
9541                                 le_set_random_address_cmd, 6, true,
9542                                 status_rsp, 1, true },
9543         { 0x2006, 205, "LE Set Advertising Parameters",
9544                                 le_set_adv_parameters_cmd, 15, true,
9545                                 status_rsp, 1, true },
9546         { 0x2007, 206, "LE Read Advertising Channel TX Power",
9547                                 null_cmd, 0, true,
9548                                 le_read_adv_tx_power_rsp, 2, true },
9549         { 0x2008, 207, "LE Set Advertising Data",
9550                                 le_set_adv_data_cmd, 32, true,
9551                                 status_rsp, 1, true },
9552         { 0x2009, 208, "LE Set Scan Response Data",
9553                                 le_set_scan_rsp_data_cmd, 32, true,
9554                                 status_rsp, 1, true },
9555         { 0x200a, 209, "LE Set Advertise Enable",
9556                                 le_set_adv_enable_cmd, 1, true,
9557                                 status_rsp, 1, true },
9558         { 0x200b, 210, "LE Set Scan Parameters",
9559                                 le_set_scan_parameters_cmd, 7, true,
9560                                 status_rsp, 1, true },
9561         { 0x200c, 211, "LE Set Scan Enable",
9562                                 le_set_scan_enable_cmd, 2, true,
9563                                 status_rsp, 1, true },
9564         { 0x200d, 212, "LE Create Connection",
9565                                 le_create_conn_cmd, 25, true },
9566         { 0x200e, 213, "LE Create Connection Cancel",
9567                                 null_cmd, 0, true,
9568                                 status_rsp, 1, true },
9569         { 0x200f, 214, "LE Read Accept List Size",
9570                                 null_cmd, 0, true,
9571                                 le_read_accept_list_size_rsp, 2, true },
9572         { 0x2010, 215, "LE Clear Accept List",
9573                                 null_cmd, 0, true,
9574                                 status_rsp, 1, true },
9575         { 0x2011, 216, "LE Add Device To Accept List",
9576                                 le_add_to_accept_list_cmd, 7, true,
9577                                 status_rsp, 1, true },
9578         { 0x2012, 217, "LE Remove Device From Accept List",
9579                                 le_remove_from_accept_list_cmd, 7, true,
9580                                 status_rsp, 1, true },
9581         { 0x2013, 218, "LE Connection Update",
9582                                 le_conn_update_cmd, 14, true },
9583         { 0x2014, 219, "LE Set Host Channel Classification",
9584                                 le_set_host_classification_cmd, 5, true,
9585                                 status_rsp, 1, true },
9586         { 0x2015, 220, "LE Read Channel Map",
9587                                 le_read_channel_map_cmd, 2, true,
9588                                 le_read_channel_map_rsp, 8, true },
9589         { 0x2016, 221, "LE Read Remote Used Features",
9590                                 le_read_remote_features_cmd, 2, true },
9591         { 0x2017, 222, "LE Encrypt",
9592                                 le_encrypt_cmd, 32, true,
9593                                 le_encrypt_rsp, 17, true },
9594         { 0x2018, 223, "LE Rand",
9595                                 null_cmd, 0, true,
9596                                 le_rand_rsp, 9, true },
9597         { 0x2019, 224, "LE Start Encryption",
9598                                 le_start_encrypt_cmd, 28, true },
9599         { 0x201a, 225, "LE Long Term Key Request Reply",
9600                                 le_ltk_req_reply_cmd, 18, true,
9601                                 le_ltk_req_reply_rsp, 3, true },
9602         { 0x201b, 226, "LE Long Term Key Request Neg Reply",
9603                                 le_ltk_req_neg_reply_cmd, 2, true,
9604                                 le_ltk_req_neg_reply_rsp, 3, true },
9605         { 0x201c, 227, "LE Read Supported States",
9606                                 null_cmd, 0, true,
9607                                 le_read_supported_states_rsp, 9, true },
9608         { 0x201d, 228, "LE Receiver Test",
9609                                 le_receiver_test_cmd, 1, true,
9610                                 status_rsp, 1, true },
9611         { 0x201e, 229, "LE Transmitter Test",
9612                                 le_transmitter_test_cmd, 3, true,
9613                                 status_rsp, 1, true },
9614         { 0x201f, 230, "LE Test End",
9615                                 null_cmd, 0, true,
9616                                 le_test_end_rsp, 3, true },
9617         { 0x2020, 268, "LE Remote Connection Parameter Request Reply",
9618                                 le_conn_param_req_reply_cmd, 14, true,
9619                                 le_conn_param_req_reply_rsp, 3, true },
9620         { 0x2021, 269, "LE Remote Connection Parameter Request Negative Reply",
9621                                 le_conn_param_req_neg_reply_cmd, 3, true,
9622                                 le_conn_param_req_neg_reply_rsp, 3, true },
9623         { 0x2022, 270, "LE Set Data Length",
9624                                 le_set_data_length_cmd, 6, true,
9625                                 le_set_data_length_rsp, 3, true },
9626         { 0x2023, 271, "LE Read Suggested Default Data Length",
9627                                 null_cmd, 0, true,
9628                                 le_read_default_data_length_rsp, 5, true },
9629         { 0x2024, 272, "LE Write Suggested Default Data Length",
9630                                 le_write_default_data_length_cmd, 4, true,
9631                                 status_rsp, 1, true },
9632         { 0x2025, 273, "LE Read Local P-256 Public Key",
9633                                 null_cmd, 0, true },
9634         { 0x2026, 274, "LE Generate DHKey",
9635                                 le_generate_dhkey_cmd, 64, true },
9636         { 0x2027, 275, "LE Add Device To Resolving List",
9637                                 le_add_to_resolv_list_cmd, 39, true,
9638                                 status_rsp, 1, true },
9639         { 0x2028, 276, "LE Remove Device From Resolving List",
9640                                 le_remove_from_resolv_list_cmd, 7, true,
9641                                 status_rsp, 1, true },
9642         { 0x2029, 277, "LE Clear Resolving List",
9643                                 null_cmd, 0, true,
9644                                 status_rsp, 1, true },
9645         { 0x202a, 278, "LE Read Resolving List Size",
9646                                 null_cmd, 0, true,
9647                                 le_read_resolv_list_size_rsp, 2, true },
9648         { 0x202b, 279, "LE Read Peer Resolvable Address",
9649                                 le_read_peer_resolv_addr_cmd, 7, true,
9650                                 le_read_peer_resolv_addr_rsp, 7, true },
9651         { 0x202c, 280, "LE Read Local Resolvable Address",
9652                                 le_read_local_resolv_addr_cmd, 7, true,
9653                                 le_read_local_resolv_addr_rsp, 7, true },
9654         { 0x202d, 281, "LE Set Address Resolution Enable",
9655                                 le_set_resolv_enable_cmd, 1, true,
9656                                 status_rsp, 1, true },
9657         { 0x202e, 282, "LE Set Resolvable Private Address Timeout",
9658                                 le_set_resolv_timeout_cmd, 2, true,
9659                                 status_rsp, 1, true },
9660         { 0x202f, 283, "LE Read Maximum Data Length",
9661                                 null_cmd, 0, true,
9662                                 le_read_max_data_length_rsp, 9, true },
9663         { 0x2030, 284, "LE Read PHY",
9664                                 le_read_phy_cmd, 2, true,
9665                                 le_read_phy_rsp, 5, true},
9666         { 0x2031, 285, "LE Set Default PHY",
9667                                 le_set_default_phy_cmd, 3, true,
9668                                 status_rsp, 1, true },
9669         { 0x2032, 286, "LE Set PHY",
9670                                 le_set_phy_cmd, 7, true},
9671         { 0x2033, 287, "LE Enhanced Receiver Test",
9672                                 le_enhanced_receiver_test_cmd, 3, true,
9673                                 status_rsp, 1, true },
9674         { 0x2034, 288, "LE Enhanced Transmitter Test",
9675                                 le_enhanced_transmitter_test_cmd, 4, true,
9676                                 status_rsp, 1, true },
9677         { 0x2035, 289, "LE Set Advertising Set Random Address",
9678                                 le_set_adv_set_rand_addr, 7, true,
9679                                 status_rsp, 1, true },
9680         { 0x2036, 290, "LE Set Extended Advertising Parameters",
9681                                 le_set_ext_adv_params_cmd, 25, true,
9682                                 le_set_ext_adv_params_rsp, 2, true },
9683         { 0x2037, 291, "LE Set Extended Advertising Data",
9684                                 le_set_ext_adv_data_cmd, 4, false,
9685                                 status_rsp, 1, true },
9686         { 0x2038, 292, "LE Set Extended Scan Response Data",
9687                                 le_set_ext_scan_rsp_data_cmd, 4, false,
9688                                 status_rsp, 1, true },
9689         { 0x2039, 293, "LE Set Extended Advertising Enable",
9690                                 le_set_ext_adv_enable_cmd, 2, false,
9691                                 status_rsp, 1, true },
9692         { 0x203a, 294, "LE Read Maximum Advertising Data Length",
9693                                 null_cmd, 0, true,
9694                                 le_read_max_adv_data_len_rsp, 3, true },
9695         { 0x203b, 295, "LE Read Number of Supported Advertising Sets",
9696                                 null_cmd, 0, true,
9697                                 le_read_num_supported_adv_sets_rsp, 2, true },
9698         { 0x203c, 296, "LE Remove Advertising Set",
9699                                 le_remove_adv_set_cmd, 1, true,
9700                                 status_rsp, 1, true },
9701         { 0x203d, 297, "LE Clear Advertising Sets",
9702                                 null_cmd, 0, true,
9703                                 status_rsp, 1, true },
9704         { 0x203e, 298, "LE Set Periodic Advertising Parameters",
9705                                 le_set_pa_params_cmd, 7, true,
9706                                 status_rsp, 1, true },
9707         { 0x203f, 299, "LE Set Periodic Advertising Data",
9708                                 le_set_pa_data_cmd, 3, false,
9709                                 status_rsp, 1, true },
9710         { 0x2040, 300, "LE Set Periodic Advertising Enable",
9711                                 le_set_pa_enable_cmd, 2, true,
9712                                 status_rsp, 1, true },
9713         { 0x2041, 301, "LE Set Extended Scan Parameters",
9714                                 le_set_ext_scan_params_cmd, 3, false,
9715                                 status_rsp, 1, true },
9716         { 0x2042, 302, "LE Set Extended Scan Enable",
9717                                 le_set_ext_scan_enable_cmd, 6, true,
9718                                 status_rsp, 1, true },
9719         { 0x2043, 303, "LE Extended Create Connection",
9720                                 le_ext_create_conn_cmd, 10, false,
9721                                 status_rsp, 1, true },
9722         { 0x2044, 304, "LE Periodic Advertising Create Sync",
9723                                 le_pa_create_sync_cmd, 14, true,
9724                                 status_rsp, 1, true },
9725         { 0x2045, 305, "LE Periodic Advertising Create Sync Cancel",
9726                                 null_cmd, 0, true,
9727                                 status_rsp, 1, true },
9728         { 0x2046, 306, "LE Periodic Advertising Terminate Sync",
9729                                 le_pa_term_sync_cmd, 2, true,
9730                                 status_rsp, 1, true },
9731         { 0x2047, 307, "LE Add Device To Periodic Advertiser List",
9732                                 le_add_dev_pa_list_cmd, 8, true,
9733                                 status_rsp, 1, true },
9734         { 0x2048, 308, "LE Remove Device From Periodic Advertiser List",
9735                                 le_remove_dev_pa_list_cmd, 8, true,
9736                                 status_rsp, 1, true },
9737         { 0x2049, 309, "LE Clear Periodic Advertiser List",
9738                                 null_cmd, 0, true,
9739                                 status_rsp, 1, true },
9740         { 0x204a, 310, "LE Read Periodic Advertiser List Size",
9741                                 null_cmd, 0, true,
9742                                 le_read_pa_list_size_rsp, 2, true },
9743         { 0x204b, 311, "LE Read Transmit Power",
9744                                 null_cmd, 0, true,
9745                                 le_read_tx_power_rsp, 3, true },
9746         { 0x204c, 312, "LE Read RF Path Compensation",
9747                                 null_cmd, 0, true,
9748                                 le_read_rf_path_comp_rsp, 5, true },
9749         { 0x204d, 313, "LE Write RF Path Compensation",
9750                                 le_write_rf_path_comp_cmd, 4, true,
9751                                 status_rsp, 1, true },
9752         { 0x204e, 314, "LE Set Privacy Mode",
9753                                 le_set_priv_mode_cmd, 8, true,
9754                                 status_rsp, 1, true },
9755         { 0x204f, 315, "LE Receiver Test command [v3]",
9756                                 le_receiver_test_cmd_v3, 7, false,
9757                                 status_rsp, 1, true },
9758         { 0x2050, 316, "LE Transmitter Test command [v3]",
9759                                 le_tx_test_cmd_v3, 9, false,
9760                                 status_rsp, 1, true },
9761         { 0x2059, 325, "LE Periodic Advertising Receive Enable",
9762                                 le_pa_rec_enable, 3, true,
9763                                 status_rsp, 1, true },
9764         { 0x205a, 326, "LE Periodic Advertising Sync Transfer",
9765                                 le_pa_sync_trans, 6, true,
9766                                 status_handle_rsp, 3, true },
9767         { 0x205b, 327, "LE Periodic Advertising Set Info Transfer",
9768                                 le_pa_set_info_trans, 5, true,
9769                                 status_handle_rsp, 3, true },
9770         { 0x205c, 328, "LE Periodic Advertising Sync Transfer Parameters",
9771                                 le_pa_sync_trans_params, 8, true,
9772                                 status_handle_rsp, 3, true},
9773         { 0x205d, 329, "LE Set Default Periodic Advertisng Sync Transfer "
9774                                 "Parameters",
9775                                 le_set_default_pa_sync_trans_params,
9776                                 6, true, status_rsp, 1, true},
9777         { BT_HCI_CMD_LE_READ_BUFFER_SIZE_V2,
9778                                 BT_HCI_BIT_LE_READ_BUFFER_SIZE_V2,
9779                                 "LE Read Buffer v2",
9780                                 null_cmd, 0, true,
9781                                 le_read_buffer_size_v2_rsp,
9782                                 sizeof(
9783                                 struct bt_hci_rsp_le_read_buffer_size_v2),
9784                                 true },
9785         { BT_HCI_CMD_LE_READ_ISO_TX_SYNC,
9786                                 BT_HCI_BIT_LE_READ_ISO_TX_SYNC,
9787                                 "LE Read ISO TX Sync",
9788                                 le_read_iso_tx_sync_cmd,
9789                                 sizeof(struct bt_hci_cmd_le_read_iso_tx_sync),
9790                                 true,
9791                                 le_read_iso_tx_sync_rsp,
9792                                 sizeof(struct bt_hci_rsp_le_read_iso_tx_sync),
9793                                 true },
9794         { BT_HCI_CMD_LE_SET_CIG_PARAMS, BT_HCI_BIT_LE_SET_CIG_PARAMS,
9795                                 "LE Set Connected Isochronous Group Parameters",
9796                                 le_set_cig_params_cmd,
9797                                 sizeof(struct bt_hci_cmd_le_set_cig_params),
9798                                 false,
9799                                 le_set_cig_params_rsp,
9800                                 sizeof(struct bt_hci_rsp_le_set_cig_params),
9801                                 false },
9802         { BT_HCI_CMD_LE_SET_CIG_PARAMS_TEST, BT_HCI_BIT_LE_SET_CIG_PARAMS_TEST,
9803                                 "LE Set Connected Isochronous Group Parameters"
9804                                 " Test", le_set_cig_params_test_cmd,
9805                                 sizeof(
9806                                 struct bt_hci_cmd_le_set_cig_params_test),
9807                                 false,
9808                                 le_set_cig_params_rsp,
9809                                 sizeof(struct bt_hci_rsp_le_set_cig_params),
9810                                 false },
9811         { BT_HCI_CMD_LE_CREATE_CIS, BT_HCI_BIT_LE_CREATE_CIS,
9812                                 "LE Create Connected Isochronous Stream",
9813                                 le_create_cis_cmd,
9814                                 sizeof(struct bt_hci_cmd_le_create_cis),
9815                                 false },
9816         { BT_HCI_CMD_LE_REMOVE_CIG, BT_HCI_BIT_LE_REMOVE_CIG,
9817                                 "LE Remove Connected Isochronous Group",
9818                                 le_remove_cig_cmd,
9819                                 sizeof(struct bt_hci_cmd_le_remove_cig), false,
9820                                 le_remove_cig_rsp,
9821                                 sizeof(struct bt_hci_rsp_le_remove_cig),
9822                                 false },
9823         { BT_HCI_CMD_LE_ACCEPT_CIS, BT_HCI_BIT_LE_ACCEPT_CIS,
9824                                 "LE Accept Connected Isochronous Stream Request",
9825                                 le_accept_cis_req_cmd,
9826                                 sizeof(struct bt_hci_cmd_le_accept_cis), true },
9827         { BT_HCI_CMD_LE_REJECT_CIS, BT_HCI_BIT_LE_REJECT_CIS,
9828                                 "LE Reject Connected Isochronous Stream Request",
9829                                 le_reject_cis_req_cmd,
9830                                 sizeof(struct bt_hci_cmd_le_reject_cis), true,
9831                                 status_rsp, 1, true },
9832         { BT_HCI_CMD_LE_CREATE_BIG, BT_HCI_BIT_LE_CREATE_BIG,
9833                                 "LE Create Broadcast Isochronous Group",
9834                                 le_create_big_cmd },
9835         { BT_HCI_CMD_LE_CREATE_BIG_TEST, BT_HCI_BIT_LE_CREATE_BIG_TEST,
9836                                 "LE Create Broadcast Isochronous Group Test",
9837                                 le_create_big_cmd_test_cmd },
9838         { BT_HCI_CMD_LE_TERM_BIG, BT_HCI_BIT_LE_TERM_BIG,
9839                                 "LE Terminate Broadcast Isochronous Group",
9840                                 le_terminate_big_cmd,
9841                                 sizeof(struct bt_hci_cmd_le_term_big), true,
9842                                 status_rsp, 1, true},
9843         { BT_HCI_CMD_LE_BIG_CREATE_SYNC, BT_HCI_BIT_LE_BIG_CREATE_SYNC,
9844                                 "LE Broadcast Isochronous Group Create Sync",
9845                                 le_big_create_sync_cmd,
9846                                 sizeof(struct bt_hci_cmd_le_big_create_sync),
9847                                 true },
9848         { BT_HCI_CMD_LE_BIG_TERM_SYNC, BT_HCI_BIT_LE_BIG_TERM_SYNC,
9849                                 "LE Broadcast Isochronous Group Terminate Sync",
9850                                 le_big_term_sync_cmd,
9851                                 sizeof(struct bt_hci_cmd_le_big_term_sync),
9852                                 true },
9853         { BT_HCI_CMD_LE_REQ_PEER_SCA, BT_HCI_BIT_LE_REQ_PEER_SCA,
9854                                 "LE Request Peer SCA", le_req_peer_sca_cmd,
9855                                 sizeof(struct bt_hci_cmd_le_req_peer_sca),
9856                                 true },
9857         { BT_HCI_CMD_LE_SETUP_ISO_PATH, BT_HCI_BIT_LE_SETUP_ISO_PATH,
9858                                 "LE Setup Isochronous Data Path",
9859                                 le_setup_iso_path_cmd,
9860                                 sizeof(struct bt_hci_cmd_le_setup_iso_path),
9861                                 true, le_setup_iso_path_rsp,
9862                                 sizeof(struct bt_hci_rsp_le_setup_iso_path),
9863                                 true },
9864         { BT_HCI_CMD_LE_REMOVE_ISO_PATH, BT_HCI_BIT_LE_REMOVE_ISO_PATH,
9865                                 "LE Remove Isochronous Data Path",
9866                                 le_remove_iso_path_cmd,
9867                                 sizeof(struct bt_hci_cmd_le_remove_iso_path),
9868                                 true, status_rsp, 1, true },
9869         { BT_HCI_CMD_LE_ISO_TX_TEST, BT_HCI_BIT_LE_ISO_TX_TEST,
9870                                 "LE Isochronous Transmit Test", NULL, 0,
9871                                 false },
9872         { BT_HCI_CMD_LE_ISO_RX_TEST, BT_HCI_BIT_LE_ISO_RX_TEST,
9873                                 "LE Isochronous Receive Test", NULL, 0,
9874                                 false },
9875         { BT_HCI_CMD_LE_ISO_READ_TEST_COUNTER,
9876                                 BT_HCI_BIT_LE_ISO_READ_TEST_COUNTER,
9877                                 "LE Isochronous Read Test Counters", NULL, 0,
9878                                 false },
9879         { BT_HCI_CMD_LE_ISO_TEST_END, BT_HCI_BIT_LE_ISO_TEST_END,
9880                                 "LE Isochronous Read Test Counters", NULL, 0,
9881                                 false },
9882         { BT_HCI_CMD_LE_SET_HOST_FEATURE, BT_HCI_BIT_LE_SET_HOST_FEATURE,
9883                                 "LE Set Host Feature", le_set_host_feature_cmd,
9884                                 sizeof(struct bt_hci_cmd_le_set_host_feature),
9885                                 true, status_rsp, 1, true },
9886         { }
9887 };
9888
9889 static const char *get_supported_command(int bit)
9890 {
9891         int i;
9892
9893         for (i = 0; opcode_table[i].str; i++) {
9894                 if (opcode_table[i].bit == bit)
9895                         return opcode_table[i].str;
9896         }
9897
9898         return NULL;
9899 }
9900
9901 static const char *current_vendor_str(uint16_t ocf)
9902 {
9903         uint16_t manufacturer, msft_opcode;
9904
9905         if (index_current < MAX_INDEX) {
9906                 manufacturer = index_list[index_current].manufacturer;
9907                 msft_opcode = index_list[index_current].msft_opcode;
9908         } else {
9909                 manufacturer = fallback_manufacturer;
9910                 msft_opcode = BT_HCI_CMD_NOP;
9911         }
9912
9913         if (msft_opcode != BT_HCI_CMD_NOP &&
9914                                 cmd_opcode_ocf(msft_opcode) == ocf)
9915                 return "Microsoft";
9916
9917         switch (manufacturer) {
9918         case 2:
9919                 return "Intel";
9920         case 15:
9921                 return "Broadcom";
9922         case 93:
9923                 return "Realtek";
9924 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9925         default:
9926                 return "Unknown";
9927 #endif
9928         }
9929
9930         return NULL;
9931 }
9932
9933 static const struct vendor_ocf *current_vendor_ocf(uint16_t ocf)
9934 {
9935         uint16_t manufacturer, msft_opcode;
9936
9937         if (index_current < MAX_INDEX) {
9938                 manufacturer = index_list[index_current].manufacturer;
9939                 msft_opcode = index_list[index_current].msft_opcode;
9940         } else {
9941                 manufacturer = fallback_manufacturer;
9942                 msft_opcode = BT_HCI_CMD_NOP;
9943         }
9944
9945         if (msft_opcode != BT_HCI_CMD_NOP &&
9946                                 cmd_opcode_ocf(msft_opcode) == ocf)
9947                 return msft_vendor_ocf();
9948
9949         switch (manufacturer) {
9950         case 2:
9951                 return intel_vendor_ocf(ocf);
9952         case 15:
9953                 return broadcom_vendor_ocf(ocf);
9954 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9955         default:
9956                 return broadcom_vendor_ocf(ocf);
9957 #endif
9958         }
9959
9960         return NULL;
9961 }
9962
9963 static const struct vendor_evt *current_vendor_evt(const void *data,
9964                                                         int *consumed_size)
9965 {
9966         uint16_t manufacturer;
9967         uint8_t evt = *((const uint8_t *) data);
9968
9969         /* A regular vendor event consumes 1 byte. */
9970         *consumed_size = 1;
9971
9972         if (index_current < MAX_INDEX)
9973                 manufacturer = index_list[index_current].manufacturer;
9974         else
9975                 manufacturer = fallback_manufacturer;
9976
9977         switch (manufacturer) {
9978         case 2:
9979                 return intel_vendor_evt(data, consumed_size);
9980         case 15:
9981                 return broadcom_vendor_evt(evt);
9982 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9983         default:
9984                 return broadcom_vendor_evt(evt);
9985 #endif
9986         }
9987
9988         return NULL;
9989 }
9990
9991 static const char *current_vendor_evt_str(void)
9992 {
9993         uint16_t manufacturer;
9994
9995         if (index_current < MAX_INDEX)
9996                 manufacturer = index_list[index_current].manufacturer;
9997         else
9998                 manufacturer = fallback_manufacturer;
9999
10000         switch (manufacturer) {
10001         case 2:
10002                 return "Intel";
10003         case 15:
10004                 return "Broadcom";
10005         case 93:
10006                 return "Realtek";
10007         }
10008
10009         return NULL;
10010 }
10011
10012 static void inquiry_complete_evt(struct timeval *tv, uint16_t index,
10013                                         const void *data, uint8_t size)
10014 {
10015         const struct bt_hci_evt_inquiry_complete *evt = data;
10016
10017         print_status(evt->status);
10018 }
10019
10020 static void inquiry_result_evt(struct timeval *tv, uint16_t index,
10021                                         const void *data, uint8_t size)
10022 {
10023         const struct bt_hci_evt_inquiry_result *evt = data;
10024
10025         print_num_resp(evt->num_resp);
10026         print_bdaddr(evt->bdaddr);
10027         print_pscan_rep_mode(evt->pscan_rep_mode);
10028         print_pscan_period_mode(evt->pscan_period_mode);
10029         print_pscan_mode(evt->pscan_mode);
10030         print_dev_class(evt->dev_class);
10031         print_clock_offset(evt->clock_offset);
10032
10033         if (size > sizeof(*evt))
10034                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
10035 }
10036
10037 static void conn_complete_evt(struct timeval *tv, uint16_t index,
10038                                         const void *data, uint8_t size)
10039 {
10040         const struct bt_hci_evt_conn_complete *evt = data;
10041
10042         print_status(evt->status);
10043         print_handle(evt->handle);
10044         print_bdaddr(evt->bdaddr);
10045         print_link_type(evt->link_type);
10046         print_enable("Encryption", evt->encr_mode);
10047
10048         if (evt->status == 0x00)
10049                 assign_handle(index, le16_to_cpu(evt->handle), 0x00,
10050                                         (void *)evt->bdaddr, BDADDR_BREDR);
10051 }
10052
10053 static void conn_request_evt(struct timeval *tv, uint16_t index,
10054                                         const void *data, uint8_t size)
10055 {
10056         const struct bt_hci_evt_conn_request *evt = data;
10057
10058         print_bdaddr(evt->bdaddr);
10059         print_dev_class(evt->dev_class);
10060         print_link_type(evt->link_type);
10061 }
10062
10063 static void disconnect_complete_evt(struct timeval *tv, uint16_t index,
10064                                         const void *data, uint8_t size)
10065 {
10066         const struct bt_hci_evt_disconnect_complete *evt = data;
10067
10068         print_status(evt->status);
10069         print_handle(evt->handle);
10070         print_reason(evt->reason);
10071
10072         if (evt->status == 0x00)
10073                 release_handle(le16_to_cpu(evt->handle));
10074 }
10075
10076 static void auth_complete_evt(struct timeval *tv, uint16_t index,
10077                                         const void *data, uint8_t size)
10078 {
10079         const struct bt_hci_evt_auth_complete *evt = data;
10080
10081         print_status(evt->status);
10082         print_handle(evt->handle);
10083 }
10084
10085 static void remote_name_request_complete_evt(struct timeval *tv, uint16_t index,
10086                                                 const void *data, uint8_t size)
10087 {
10088         const struct bt_hci_evt_remote_name_request_complete *evt = data;
10089
10090         print_status(evt->status);
10091         print_bdaddr(evt->bdaddr);
10092         print_name(evt->name);
10093 }
10094
10095 static void encrypt_change_evt(struct timeval *tv, uint16_t index,
10096                                         const void *data, uint8_t size)
10097 {
10098         const struct bt_hci_evt_encrypt_change *evt = data;
10099
10100         print_status(evt->status);
10101         print_handle(evt->handle);
10102         print_encr_mode_change(evt->encr_mode, evt->handle);
10103 }
10104
10105 static void change_conn_link_key_complete_evt(struct timeval *tv,
10106                                                 uint16_t index,
10107                                                 const void *data, uint8_t size)
10108 {
10109         const struct bt_hci_evt_change_conn_link_key_complete *evt = data;
10110
10111         print_status(evt->status);
10112         print_handle(evt->handle);
10113 }
10114
10115 static void link_key_type_changed_evt(struct timeval *tv, uint16_t index,
10116                                         const void *data, uint8_t size)
10117 {
10118         const struct bt_hci_evt_link_key_type_changed *evt = data;
10119
10120         print_status(evt->status);
10121         print_handle(evt->handle);
10122         print_key_flag(evt->key_flag);
10123 }
10124
10125 static void remote_features_complete_evt(struct timeval *tv, uint16_t index,
10126                                         const void *data, uint8_t size)
10127 {
10128         const struct bt_hci_evt_remote_features_complete *evt = data;
10129
10130         print_status(evt->status);
10131         print_handle(evt->handle);
10132         print_features(0, evt->features, 0x00);
10133 }
10134
10135 static void remote_version_complete_evt(struct timeval *tv, uint16_t index,
10136                                         const void *data, uint8_t size)
10137 {
10138         const struct bt_hci_evt_remote_version_complete *evt = data;
10139
10140         print_status(evt->status);
10141         print_handle(evt->handle);
10142         print_lmp_version(evt->lmp_ver, evt->lmp_subver);
10143         print_manufacturer(evt->manufacturer);
10144
10145         switch (le16_to_cpu(evt->manufacturer)) {
10146         case 15:
10147                 print_manufacturer_broadcom(evt->lmp_subver, 0xffff);
10148                 break;
10149         }
10150 }
10151
10152 static void qos_setup_complete_evt(struct timeval *tv, uint16_t index,
10153                                         const void *data, uint8_t size)
10154 {
10155         const struct bt_hci_evt_qos_setup_complete *evt = data;
10156
10157         print_status(evt->status);
10158         print_handle(evt->handle);
10159         print_field("Flags: 0x%2.2x", evt->flags);
10160
10161         print_service_type(evt->service_type);
10162
10163         print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
10164         print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
10165         print_field("Latency: %d", le32_to_cpu(evt->latency));
10166         print_field("Delay variation: %d", le32_to_cpu(evt->delay_variation));
10167 }
10168
10169 static void cmd_complete_evt(struct timeval *tv, uint16_t index,
10170                                 const void *data, uint8_t size)
10171 {
10172         const struct bt_hci_evt_cmd_complete *evt = data;
10173         uint16_t opcode = le16_to_cpu(evt->opcode);
10174         uint16_t ogf = cmd_opcode_ogf(opcode);
10175         uint16_t ocf = cmd_opcode_ocf(opcode);
10176         struct opcode_data vendor_data;
10177         const struct opcode_data *opcode_data = NULL;
10178         const char *opcode_color, *opcode_str;
10179         char vendor_str[150];
10180         int i;
10181
10182         for (i = 0; opcode_table[i].str; i++) {
10183                 if (opcode_table[i].opcode == opcode) {
10184                         opcode_data = &opcode_table[i];
10185                         break;
10186                 }
10187         }
10188
10189         if (opcode_data) {
10190                 if (opcode_data->rsp_func)
10191                         opcode_color = COLOR_HCI_COMMAND;
10192                 else
10193                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10194                 opcode_str = opcode_data->str;
10195         } else {
10196                 if (ogf == 0x3f) {
10197                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
10198
10199                         if (vnd) {
10200                                 const char *str = current_vendor_str(ocf);
10201
10202                                 if (str) {
10203                                         snprintf(vendor_str, sizeof(vendor_str),
10204                                                         "%s %s", str, vnd->str);
10205                                         vendor_data.str = vendor_str;
10206                                 } else
10207                                         vendor_data.str = vnd->str;
10208                                 vendor_data.rsp_func = vnd->rsp_func;
10209                                 vendor_data.rsp_size = vnd->rsp_size;
10210                                 vendor_data.rsp_fixed = vnd->rsp_fixed;
10211
10212                                 opcode_data = &vendor_data;
10213
10214                                 if (opcode_data->rsp_func)
10215                                         opcode_color = COLOR_HCI_COMMAND;
10216                                 else
10217                                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10218                                 opcode_str = opcode_data->str;
10219                         } else {
10220                                 opcode_color = COLOR_HCI_COMMAND;
10221                                 opcode_str = "Vendor";
10222                         }
10223                 } else {
10224                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10225                         opcode_str = "Unknown";
10226                 }
10227         }
10228
10229         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
10230                         " (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
10231
10232         if (!opcode_data || !opcode_data->rsp_func) {
10233                 if (size > 3) {
10234                         uint8_t status = *((uint8_t *) (data + 3));
10235
10236                         print_status(status);
10237                         packet_hexdump(data + 4, size - 4);
10238                 }
10239                 return;
10240         }
10241
10242         if (opcode_data->rsp_size > 1 && size - 3 == 1) {
10243                 uint8_t status = *((uint8_t *) (data + 3));
10244
10245                 print_status(status);
10246                 return;
10247         }
10248
10249         if (opcode_data->rsp_fixed) {
10250                 if (size - 3 != opcode_data->rsp_size) {
10251                         print_text(COLOR_ERROR, "invalid packet size");
10252                         packet_hexdump(data + 3, size - 3);
10253                         return;
10254                 }
10255         } else {
10256                 if (size - 3 < opcode_data->rsp_size) {
10257                         print_text(COLOR_ERROR, "too short packet");
10258                         packet_hexdump(data + 3, size - 3);
10259                         return;
10260                 }
10261         }
10262
10263         opcode_data->rsp_func(index, data + 3, size - 3);
10264 }
10265
10266 static void cmd_status_evt(struct timeval *tv, uint16_t index,
10267                                 const void *data, uint8_t size)
10268 {
10269         const struct bt_hci_evt_cmd_status *evt = data;
10270         uint16_t opcode = le16_to_cpu(evt->opcode);
10271         uint16_t ogf = cmd_opcode_ogf(opcode);
10272         uint16_t ocf = cmd_opcode_ocf(opcode);
10273         const struct opcode_data *opcode_data = NULL;
10274         const char *opcode_color, *opcode_str;
10275         char vendor_str[150];
10276         int i;
10277
10278         for (i = 0; opcode_table[i].str; i++) {
10279                 if (opcode_table[i].opcode == opcode) {
10280                         opcode_data = &opcode_table[i];
10281                         break;
10282                 }
10283         }
10284
10285         if (opcode_data) {
10286                 opcode_color = COLOR_HCI_COMMAND;
10287                 opcode_str = opcode_data->str;
10288         } else {
10289                 if (ogf == 0x3f) {
10290                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
10291
10292                         if (vnd) {
10293                                 const char *str = current_vendor_str(ocf);
10294
10295                                 if (str) {
10296                                         snprintf(vendor_str, sizeof(vendor_str),
10297                                                         "%s %s", str, vnd->str);
10298                                         opcode_str = vendor_str;
10299                                 } else
10300                                         opcode_str = vnd->str;
10301
10302                                 opcode_color = COLOR_HCI_COMMAND;
10303                         } else {
10304                                 opcode_color = COLOR_HCI_COMMAND;
10305                                 opcode_str = "Vendor";
10306                         }
10307                 } else {
10308                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10309                         opcode_str = "Unknown";
10310                 }
10311         }
10312
10313         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
10314                         " (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
10315
10316         print_status(evt->status);
10317 }
10318
10319 static void hardware_error_evt(struct timeval *tv, uint16_t index,
10320                                 const void *data, uint8_t size)
10321 {
10322         const struct bt_hci_evt_hardware_error *evt = data;
10323
10324         print_field("Code: 0x%2.2x", evt->code);
10325 }
10326
10327 static void flush_occurred_evt(struct timeval *tv, uint16_t index,
10328                                 const void *data, uint8_t size)
10329 {
10330         const struct bt_hci_evt_flush_occurred *evt = data;
10331
10332         print_handle(evt->handle);
10333 }
10334
10335 static void role_change_evt(struct timeval *tv, uint16_t index,
10336                                 const void *data, uint8_t size)
10337 {
10338         const struct bt_hci_evt_role_change *evt = data;
10339
10340         print_status(evt->status);
10341         print_bdaddr(evt->bdaddr);
10342         print_role(evt->role);
10343 }
10344
10345 void packet_latency_add(struct packet_latency *latency, struct timeval *delta)
10346 {
10347         if ((!timerisset(&latency->min) || timercmp(delta, &latency->min, <))
10348                                 && delta->tv_sec >= 0 && delta->tv_usec >= 0)
10349                 latency->min = *delta;
10350
10351         if (!timerisset(&latency->max) || timercmp(delta, &latency->max, >))
10352                 latency->max = *delta;
10353
10354         if (timerisset(&latency->med)) {
10355                 struct timeval tmp;
10356
10357                 timeradd(&latency->med, delta, &tmp);
10358
10359                 tmp.tv_sec /= 2;
10360                 tmp.tv_usec /= 2;
10361                 if (tmp.tv_sec % 2) {
10362                         tmp.tv_usec += 500000;
10363                         if (tmp.tv_usec >= 1000000) {
10364                                 tmp.tv_sec++;
10365                                 tmp.tv_usec -= 1000000;
10366                         }
10367                 }
10368
10369                 latency->med = tmp;
10370         } else
10371                 latency->med = *delta;
10372 }
10373
10374 static void packet_dequeue_tx(struct timeval *tv, uint16_t handle)
10375 {
10376         struct packet_conn_data *conn;
10377         struct timeval *tx;
10378         struct timeval delta;
10379
10380         conn = packet_get_conn_data(handle);
10381         if (!conn)
10382                 return;
10383
10384         tx = queue_pop_head(conn->tx_q);
10385         if (!tx)
10386                 return;
10387
10388         timersub(tv, tx, &delta);
10389
10390         packet_latency_add(&conn->tx_l, &delta);
10391
10392         print_field("Latency: %lld msec (%lld-%lld msec ~%lld msec)",
10393                         TV_MSEC(delta), TV_MSEC(conn->tx_l.min),
10394                         TV_MSEC(conn->tx_l.max), TV_MSEC(conn->tx_l.med));
10395
10396         l2cap_dequeue_frame(&delta, conn);
10397
10398         free(tx);
10399 }
10400
10401 static void num_completed_packets_evt(struct timeval *tv, uint16_t index,
10402                                         const void *data, uint8_t size)
10403 {
10404         struct iovec iov = { (void *)data, size};
10405         const struct bt_hci_evt_num_completed_packets *evt = data;
10406         int i;
10407
10408         iov_pull(&iov, 1);
10409
10410         print_field("Num handles: %d", evt->num_handles);
10411
10412         for (i = 0; i < evt->num_handles; i++) {
10413                 uint16_t handle;
10414                 uint16_t count;
10415                 int j;
10416
10417                 if (!util_iov_pull_le16(&iov, &handle))
10418                         break;
10419
10420                 print_handle_native(handle);
10421
10422                 if (!util_iov_pull_le16(&iov, &count))
10423                         break;
10424
10425                 print_field("Count: %d", count);
10426
10427                 for (j = 0; j < count; j++)
10428                         packet_dequeue_tx(tv, handle);
10429         }
10430
10431         if (iov.iov_len)
10432                 packet_hexdump(iov.iov_base, iov.iov_len);
10433 }
10434
10435 static void mode_change_evt(struct timeval *tv, uint16_t index,
10436                                         const void *data, uint8_t size)
10437 {
10438         const struct bt_hci_evt_mode_change *evt = data;
10439
10440         print_status(evt->status);
10441         print_handle(evt->handle);
10442         print_mode(evt->mode);
10443         print_interval(evt->interval);
10444 }
10445
10446 static void return_link_keys_evt(struct timeval *tv, uint16_t index,
10447                                         const void *data, uint8_t size)
10448 {
10449         const struct bt_hci_evt_return_link_keys *evt = data;
10450         uint8_t i;
10451
10452         print_field("Num keys: %d", evt->num_keys);
10453
10454         for (i = 0; i < evt->num_keys; i++) {
10455                 print_bdaddr(evt->keys + (i * 22));
10456                 print_link_key(evt->keys + (i * 22) + 6);
10457         }
10458 }
10459
10460 static void pin_code_request_evt(struct timeval *tv, uint16_t index,
10461                                         const void *data, uint8_t size)
10462 {
10463         const struct bt_hci_evt_pin_code_request *evt = data;
10464
10465         print_bdaddr(evt->bdaddr);
10466 }
10467
10468 static void link_key_request_evt(struct timeval *tv, uint16_t index,
10469                                         const void *data, uint8_t size)
10470 {
10471         const struct bt_hci_evt_link_key_request *evt = data;
10472
10473         print_bdaddr(evt->bdaddr);
10474 }
10475
10476 static void link_key_notify_evt(struct timeval *tv, uint16_t index,
10477                                         const void *data, uint8_t size)
10478 {
10479         const struct bt_hci_evt_link_key_notify *evt = data;
10480
10481         print_bdaddr(evt->bdaddr);
10482         print_link_key(evt->link_key);
10483         print_key_type(evt->key_type);
10484 }
10485
10486 static void loopback_command_evt(struct timeval *tv, uint16_t index,
10487                                         const void *data, uint8_t size)
10488 {
10489         packet_hexdump(data, size);
10490 }
10491
10492 static void data_buffer_overflow_evt(struct timeval *tv, uint16_t index,
10493                                         const void *data, uint8_t size)
10494 {
10495         const struct bt_hci_evt_data_buffer_overflow *evt = data;
10496
10497         print_link_type(evt->link_type);
10498 }
10499
10500 static void max_slots_change_evt(struct timeval *tv, uint16_t index,
10501                                         const void *data, uint8_t size)
10502 {
10503         const struct bt_hci_evt_max_slots_change *evt = data;
10504
10505         print_handle(evt->handle);
10506         print_field("Max slots: %d", evt->max_slots);
10507 }
10508
10509 static void clock_offset_complete_evt(struct timeval *tv, uint16_t index,
10510                                         const void *data, uint8_t size)
10511 {
10512         const struct bt_hci_evt_clock_offset_complete *evt = data;
10513
10514         print_status(evt->status);
10515         print_handle(evt->handle);
10516         print_clock_offset(evt->clock_offset);
10517 }
10518
10519 static void conn_pkt_type_changed_evt(struct timeval *tv, uint16_t index,
10520                                         const void *data, uint8_t size)
10521 {
10522         const struct bt_hci_evt_conn_pkt_type_changed *evt = data;
10523
10524         print_status(evt->status);
10525         print_handle(evt->handle);
10526         print_pkt_type(evt->pkt_type);
10527 }
10528
10529 static void qos_violation_evt(struct timeval *tv, uint16_t index,
10530                                         const void *data, uint8_t size)
10531 {
10532         const struct bt_hci_evt_qos_violation *evt = data;
10533
10534         print_handle(evt->handle);
10535 }
10536
10537 static void pscan_mode_change_evt(struct timeval *tv, uint16_t index,
10538                                         const void *data, uint8_t size)
10539 {
10540         const struct bt_hci_evt_pscan_mode_change *evt = data;
10541
10542         print_bdaddr(evt->bdaddr);
10543         print_pscan_mode(evt->pscan_mode);
10544 }
10545
10546 static void pscan_rep_mode_change_evt(struct timeval *tv, uint16_t index,
10547                                         const void *data, uint8_t size)
10548 {
10549         const struct bt_hci_evt_pscan_rep_mode_change *evt = data;
10550
10551         print_bdaddr(evt->bdaddr);
10552         print_pscan_rep_mode(evt->pscan_rep_mode);
10553 }
10554
10555 static void flow_spec_complete_evt(struct timeval *tv, uint16_t index,
10556                                         const void *data, uint8_t size)
10557 {
10558         const struct bt_hci_evt_flow_spec_complete *evt = data;
10559
10560         print_status(evt->status);
10561         print_handle(evt->handle);
10562         print_field("Flags: 0x%2.2x", evt->flags);
10563
10564         print_flow_direction(evt->direction);
10565         print_service_type(evt->service_type);
10566
10567         print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
10568         print_field("Token bucket size: %d",
10569                                         le32_to_cpu(evt->token_bucket_size));
10570         print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
10571         print_field("Access latency: %d", le32_to_cpu(evt->access_latency));
10572 }
10573
10574 static void inquiry_result_with_rssi_evt(struct timeval *tv, uint16_t index,
10575                                         const void *data, uint8_t size)
10576 {
10577         const struct bt_hci_evt_inquiry_result_with_rssi *evt = data;
10578
10579         print_num_resp(evt->num_resp);
10580         print_bdaddr(evt->bdaddr);
10581         print_pscan_rep_mode(evt->pscan_rep_mode);
10582         print_pscan_period_mode(evt->pscan_period_mode);
10583         print_dev_class(evt->dev_class);
10584         print_clock_offset(evt->clock_offset);
10585         print_rssi(evt->rssi);
10586
10587         if (size > sizeof(*evt))
10588                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
10589 }
10590
10591 static void remote_ext_features_complete_evt(struct timeval *tv, uint16_t index,
10592                                         const void *data, uint8_t size)
10593 {
10594         const struct bt_hci_evt_remote_ext_features_complete *evt = data;
10595
10596         print_status(evt->status);
10597         print_handle(evt->handle);
10598         print_field("Page: %d/%d", evt->page, evt->max_page);
10599         print_features(evt->page, evt->features, 0x00);
10600 }
10601
10602 static void sync_conn_complete_evt(struct timeval *tv, uint16_t index,
10603                                         const void *data, uint8_t size)
10604 {
10605         const struct bt_hci_evt_sync_conn_complete *evt = data;
10606
10607         print_status(evt->status);
10608         print_handle(evt->handle);
10609         print_bdaddr(evt->bdaddr);
10610         print_link_type(evt->link_type);
10611         print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
10612         print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
10613         print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
10614         print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
10615         print_air_mode(evt->air_mode);
10616
10617         if (evt->status == 0x00)
10618                 assign_handle(index, le16_to_cpu(evt->handle), evt->link_type,
10619                                         (void *)evt->bdaddr, BDADDR_BREDR);
10620 }
10621
10622 static void sync_conn_changed_evt(struct timeval *tv, uint16_t index,
10623                                         const void *data, uint8_t size)
10624 {
10625         const struct bt_hci_evt_sync_conn_changed *evt = data;
10626
10627         print_status(evt->status);
10628         print_handle(evt->handle);
10629         print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
10630         print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
10631         print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
10632         print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
10633 }
10634
10635 static void sniff_subrating_evt(struct timeval *tv, uint16_t index,
10636                                         const void *data, uint8_t size)
10637 {
10638         const struct bt_hci_evt_sniff_subrating *evt = data;
10639
10640         print_status(evt->status);
10641         print_handle(evt->handle);
10642         print_slot_625("Max transmit latency", evt->max_tx_latency);
10643         print_slot_625("Max receive latency", evt->max_rx_latency);
10644         print_slot_625("Min remote timeout", evt->min_remote_timeout);
10645         print_slot_625("Min local timeout", evt->min_local_timeout);
10646 }
10647
10648 static void ext_inquiry_result_evt(struct timeval *tv, uint16_t index,
10649                                         const void *data, uint8_t size)
10650 {
10651         const struct bt_hci_evt_ext_inquiry_result *evt = data;
10652
10653         print_num_resp(evt->num_resp);
10654         print_bdaddr(evt->bdaddr);
10655         print_pscan_rep_mode(evt->pscan_rep_mode);
10656         print_pscan_period_mode(evt->pscan_period_mode);
10657         print_dev_class(evt->dev_class);
10658         print_clock_offset(evt->clock_offset);
10659         print_rssi(evt->rssi);
10660         print_eir(evt->data, sizeof(evt->data), false);
10661 }
10662
10663 static void encrypt_key_refresh_complete_evt(struct timeval *tv, uint16_t index,
10664                                         const void *data, uint8_t size)
10665 {
10666         const struct bt_hci_evt_encrypt_key_refresh_complete *evt = data;
10667
10668         print_status(evt->status);
10669         print_handle(evt->handle);
10670 }
10671
10672 static void io_capability_request_evt(struct timeval *tv, uint16_t index,
10673                                         const void *data, uint8_t size)
10674 {
10675         const struct bt_hci_evt_io_capability_request *evt = data;
10676
10677         print_bdaddr(evt->bdaddr);
10678 }
10679
10680 static void io_capability_response_evt(struct timeval *tv, uint16_t index,
10681                                         const void *data, uint8_t size)
10682 {
10683         const struct bt_hci_evt_io_capability_response *evt = data;
10684
10685         print_bdaddr(evt->bdaddr);
10686         print_io_capability(evt->capability);
10687         print_oob_data_response(evt->oob_data);
10688         print_authentication(evt->authentication);
10689 }
10690
10691 static void user_confirm_request_evt(struct timeval *tv, uint16_t index,
10692                                         const void *data, uint8_t size)
10693 {
10694         const struct bt_hci_evt_user_confirm_request *evt = data;
10695
10696         print_bdaddr(evt->bdaddr);
10697         print_passkey(evt->passkey);
10698 }
10699
10700 static void user_passkey_request_evt(struct timeval *tv, uint16_t index,
10701                                         const void *data, uint8_t size)
10702 {
10703         const struct bt_hci_evt_user_passkey_request *evt = data;
10704
10705         print_bdaddr(evt->bdaddr);
10706 }
10707
10708 static void remote_oob_data_request_evt(struct timeval *tv, uint16_t index,
10709                                         const void *data, uint8_t size)
10710 {
10711         const struct bt_hci_evt_remote_oob_data_request *evt = data;
10712
10713         print_bdaddr(evt->bdaddr);
10714 }
10715
10716 static void simple_pairing_complete_evt(struct timeval *tv, uint16_t index,
10717                                         const void *data, uint8_t size)
10718 {
10719         const struct bt_hci_evt_simple_pairing_complete *evt = data;
10720
10721         print_status(evt->status);
10722         print_bdaddr(evt->bdaddr);
10723 }
10724
10725 static void link_supv_timeout_changed_evt(struct timeval *tv, uint16_t index,
10726                                         const void *data, uint8_t size)
10727 {
10728         const struct bt_hci_evt_link_supv_timeout_changed *evt = data;
10729
10730         print_handle(evt->handle);
10731         print_timeout(evt->timeout);
10732 }
10733
10734 static void enhanced_flush_complete_evt(struct timeval *tv, uint16_t index,
10735                                         const void *data, uint8_t size)
10736 {
10737         const struct bt_hci_evt_enhanced_flush_complete *evt = data;
10738
10739         print_handle(evt->handle);
10740 }
10741
10742 static void user_passkey_notify_evt(struct timeval *tv, uint16_t index,
10743                                         const void *data, uint8_t size)
10744 {
10745         const struct bt_hci_evt_user_passkey_notify *evt = data;
10746
10747         print_bdaddr(evt->bdaddr);
10748         print_passkey(evt->passkey);
10749 }
10750
10751 static void keypress_notify_evt(struct timeval *tv, uint16_t index,
10752                                         const void *data, uint8_t size)
10753 {
10754         const struct bt_hci_evt_keypress_notify *evt = data;
10755         const char *str;
10756
10757         print_bdaddr(evt->bdaddr);
10758
10759         switch (evt->type) {
10760         case 0x00:
10761                 str = "Passkey entry started";
10762                 break;
10763         case 0x01:
10764                 str = "Passkey digit entered";
10765                 break;
10766         case 0x02:
10767                 str = "Passkey digit erased";
10768                 break;
10769         case 0x03:
10770                 str = "Passkey clared";
10771                 break;
10772         case 0x04:
10773                 str = "Passkey entry completed";
10774                 break;
10775         default:
10776                 str = "Reserved";
10777                 break;
10778         }
10779
10780         print_field("Notification type: %s (0x%2.2x)", str, evt->type);
10781 }
10782
10783 static void remote_host_features_notify_evt(struct timeval *tv, uint16_t index,
10784                                         const void *data, uint8_t size)
10785 {
10786         const struct bt_hci_evt_remote_host_features_notify *evt = data;
10787
10788         print_bdaddr(evt->bdaddr);
10789         print_features(1, evt->features, 0x00);
10790 }
10791
10792 static void phy_link_complete_evt(struct timeval *tv, uint16_t index,
10793                                         const void *data, uint8_t size)
10794 {
10795         const struct bt_hci_evt_phy_link_complete *evt = data;
10796
10797         print_status(evt->status);
10798         print_phy_handle(evt->phy_handle);
10799 }
10800
10801 static void channel_selected_evt(struct timeval *tv, uint16_t index,
10802                                         const void *data, uint8_t size)
10803 {
10804         const struct bt_hci_evt_channel_selected *evt = data;
10805
10806         print_phy_handle(evt->phy_handle);
10807 }
10808
10809 static void disconn_phy_link_complete_evt(struct timeval *tv, uint16_t index,
10810                                         const void *data, uint8_t size)
10811 {
10812         const struct bt_hci_evt_disconn_phy_link_complete *evt = data;
10813
10814         print_status(evt->status);
10815         print_phy_handle(evt->phy_handle);
10816         print_reason(evt->reason);
10817 }
10818
10819 static void phy_link_loss_early_warning_evt(struct timeval *tv, uint16_t index,
10820                                         const void *data, uint8_t size)
10821 {
10822         const struct bt_hci_evt_phy_link_loss_early_warning *evt = data;
10823         const char *str;
10824
10825         print_phy_handle(evt->phy_handle);
10826
10827         switch (evt->reason) {
10828         case 0x00:
10829                 str = "Unknown";
10830                 break;
10831         case 0x01:
10832                 str = "Range related";
10833                 break;
10834         case 0x02:
10835                 str = "Bandwidth related";
10836                 break;
10837         case 0x03:
10838                 str = "Resolving conflict";
10839                 break;
10840         case 0x04:
10841                 str = "Interference";
10842                 break;
10843         default:
10844                 str = "Reserved";
10845                 break;
10846         }
10847
10848         print_field("Reason: %s (0x%2.2x)", str, evt->reason);
10849 }
10850
10851 static void phy_link_recovery_evt(struct timeval *tv, uint16_t index,
10852                                         const void *data, uint8_t size)
10853 {
10854         const struct bt_hci_evt_phy_link_recovery *evt = data;
10855
10856         print_phy_handle(evt->phy_handle);
10857 }
10858
10859 static void logic_link_complete_evt(struct timeval *tv, uint16_t index,
10860                                         const void *data, uint8_t size)
10861 {
10862         const struct bt_hci_evt_logic_link_complete *evt = data;
10863
10864         print_status(evt->status);
10865         print_handle(evt->handle);
10866         print_phy_handle(evt->phy_handle);
10867         print_field("TX flow spec: 0x%2.2x", evt->flow_spec);
10868 }
10869
10870 static void disconn_logic_link_complete_evt(struct timeval *tv, uint16_t index,
10871                                         const void *data, uint8_t size)
10872 {
10873         const struct bt_hci_evt_disconn_logic_link_complete *evt = data;
10874
10875         print_status(evt->status);
10876         print_handle(evt->handle);
10877         print_reason(evt->reason);
10878 }
10879
10880 static void flow_spec_modify_complete_evt(struct timeval *tv, uint16_t index,
10881                                         const void *data, uint8_t size)
10882 {
10883         const struct bt_hci_evt_flow_spec_modify_complete *evt = data;
10884
10885         print_status(evt->status);
10886         print_handle(evt->handle);
10887 }
10888
10889 static void num_completed_data_blocks_evt(struct timeval *tv, uint16_t index,
10890                                         const void *data, uint8_t size)
10891 {
10892         const struct bt_hci_evt_num_completed_data_blocks *evt = data;
10893
10894         print_field("Total num data blocks: %d",
10895                                 le16_to_cpu(evt->total_num_blocks));
10896         print_field("Num handles: %d", evt->num_handles);
10897         print_handle(evt->handle);
10898         print_field("Num packets: %d", evt->num_packets);
10899         print_field("Num blocks: %d", evt->num_blocks);
10900
10901         if (size > sizeof(*evt))
10902                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
10903 }
10904
10905 static void short_range_mode_change_evt(struct timeval *tv, uint16_t index,
10906                                         const void *data, uint8_t size)
10907 {
10908         const struct bt_hci_evt_short_range_mode_change *evt = data;
10909
10910         print_status(evt->status);
10911         print_phy_handle(evt->phy_handle);
10912         print_enable("Short range mode", evt->mode);
10913 }
10914
10915 static void amp_status_change_evt(struct timeval *tv, uint16_t index,
10916                                         const void *data, uint8_t size)
10917 {
10918         const struct bt_hci_evt_amp_status_change *evt = data;
10919
10920         print_status(evt->status);
10921         print_amp_status(evt->amp_status);
10922 }
10923
10924 static void triggered_clock_capture_evt(struct timeval *tv, uint16_t index,
10925                                         const void *data, uint8_t size)
10926 {
10927         const struct bt_hci_evt_triggered_clock_capture *evt = data;
10928
10929         print_handle(evt->handle);
10930         print_clock_type(evt->type);
10931         print_clock(evt->clock);
10932         print_clock_offset(evt->clock_offset);
10933 }
10934
10935 static void sync_train_complete_evt(struct timeval *tv, uint16_t index,
10936                                         const void *data, uint8_t size)
10937 {
10938         const struct bt_hci_evt_sync_train_complete *evt = data;
10939
10940         print_status(evt->status);
10941 }
10942
10943 static void sync_train_received_evt(struct timeval *tv, uint16_t index,
10944                                         const void *data, uint8_t size)
10945 {
10946         const struct bt_hci_evt_sync_train_received *evt = data;
10947
10948         print_status(evt->status);
10949         print_bdaddr(evt->bdaddr);
10950         print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
10951         print_channel_map(evt->map);
10952         print_lt_addr(evt->lt_addr);
10953         print_field("Next broadcast instant: 0x%4.4x",
10954                                         le16_to_cpu(evt->instant));
10955         print_interval(evt->interval);
10956         print_field("Service Data: 0x%2.2x", evt->service_data);
10957 }
10958
10959 static void peripheral_broadcast_receive_evt(struct timeval *tv, uint16_t index,
10960                                         const void *data, uint8_t size)
10961 {
10962         const struct bt_hci_evt_peripheral_broadcast_receive *evt = data;
10963
10964         print_bdaddr(evt->bdaddr);
10965         print_lt_addr(evt->lt_addr);
10966         print_field("Clock: 0x%8.8x", le32_to_cpu(evt->clock));
10967         print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
10968         print_field("Receive status: 0x%2.2x", evt->status);
10969         print_broadcast_fragment(evt->fragment);
10970         print_field("Length: %d", evt->length);
10971
10972         if (size - 18 != evt->length)
10973                 print_text(COLOR_ERROR, "invalid data size (%d != %d)",
10974                                                 size - 18, evt->length);
10975
10976         if (evt->lt_addr == 0x01 && evt->length == 17)
10977                 print_3d_broadcast(data + 18, size - 18);
10978         else
10979                 packet_hexdump(data + 18, size - 18);
10980 }
10981
10982 static void peripheral_broadcast_timeout_evt(struct timeval *tv, uint16_t index,
10983                                         const void *data, uint8_t size)
10984 {
10985         const struct bt_hci_evt_peripheral_broadcast_timeout *evt = data;
10986
10987         print_bdaddr(evt->bdaddr);
10988         print_lt_addr(evt->lt_addr);
10989 }
10990
10991 static void truncated_page_complete_evt(struct timeval *tv, uint16_t index,
10992                                         const void *data, uint8_t size)
10993 {
10994         const struct bt_hci_evt_truncated_page_complete *evt = data;
10995
10996         print_status(evt->status);
10997         print_bdaddr(evt->bdaddr);
10998 }
10999
11000 static void peripheral_page_response_timeout_evt(struct timeval *tv,
11001                                         uint16_t index, const void *data,
11002                                         uint8_t size)
11003 {
11004 }
11005
11006 static void channel_map_change_evt(struct timeval *tv, uint16_t index,
11007                                         const void *data, uint8_t size)
11008 {
11009         const struct bt_hci_evt_channel_map_change *evt = data;
11010
11011         print_channel_map(evt->map);
11012 }
11013
11014 static void inquiry_response_notify_evt(struct timeval *tv, uint16_t index,
11015                                         const void *data, uint8_t size)
11016 {
11017         const struct bt_hci_evt_inquiry_response_notify *evt = data;
11018
11019         print_iac(evt->lap);
11020         print_rssi(evt->rssi);
11021 }
11022
11023 static void auth_payload_timeout_expired_evt(struct timeval *tv, uint16_t index,
11024                                         const void *data, uint8_t size)
11025 {
11026         const struct bt_hci_evt_auth_payload_timeout_expired *evt = data;
11027
11028         print_handle(evt->handle);
11029 }
11030
11031 static void le_conn_complete_evt(struct timeval *tv, uint16_t index,
11032                                         const void *data, uint8_t size)
11033 {
11034         const struct bt_hci_evt_le_conn_complete *evt = data;
11035
11036         print_status(evt->status);
11037         print_handle(evt->handle);
11038         print_role(evt->role);
11039         print_peer_addr_type("Peer address type", evt->peer_addr_type);
11040         print_addr("Peer address", evt->peer_addr, evt->peer_addr_type);
11041         print_slot_125("Connection interval", evt->interval);
11042         print_conn_latency("Connection latency", evt->latency);
11043         print_field("Supervision timeout: %d msec (0x%4.4x)",
11044                                         le16_to_cpu(evt->supv_timeout) * 10,
11045                                         le16_to_cpu(evt->supv_timeout));
11046         print_field("Central clock accuracy: 0x%2.2x", evt->clock_accuracy);
11047
11048         if (evt->status == 0x00)
11049                 assign_handle(index, le16_to_cpu(evt->handle), 0x01,
11050                                 (void *)evt->peer_addr, evt->peer_addr_type);
11051 }
11052
11053 static void le_adv_report_evt(struct timeval *tv, uint16_t index,
11054                                         const void *data, uint8_t size)
11055 {
11056         const struct bt_hci_evt_le_adv_report *evt = data;
11057         uint8_t evt_len;
11058         int8_t *rssi;
11059
11060         print_num_reports(evt->num_reports);
11061
11062 report:
11063         print_adv_event_type("Event type", evt->event_type);
11064         print_peer_addr_type("Address type", evt->addr_type);
11065         print_addr("Address", evt->addr, evt->addr_type);
11066         print_field("Data length: %d", evt->data_len);
11067         print_eir(evt->data, evt->data_len, true);
11068
11069         rssi = (int8_t *) (evt->data + evt->data_len);
11070         print_rssi(*rssi);
11071
11072         evt_len = sizeof(*evt) + evt->data_len + 1;
11073
11074         if (size > evt_len) {
11075                 data += evt_len - 1;
11076                 size -= evt_len - 1;
11077                 evt = data;
11078                 goto report;
11079         }
11080 }
11081
11082 static void le_conn_update_complete_evt(struct timeval *tv, uint16_t index,
11083                                         const void *data, uint8_t size)
11084 {
11085         const struct bt_hci_evt_le_conn_update_complete *evt = data;
11086
11087         print_status(evt->status);
11088         print_handle(evt->handle);
11089         print_slot_125("Connection interval", evt->interval);
11090         print_conn_latency("Connection latency", evt->latency);
11091         print_field("Supervision timeout: %d msec (0x%4.4x)",
11092                                         le16_to_cpu(evt->supv_timeout) * 10,
11093                                         le16_to_cpu(evt->supv_timeout));
11094 }
11095
11096 static void le_remote_features_complete_evt(struct timeval *tv, uint16_t index,
11097                                         const void *data, uint8_t size)
11098 {
11099         const struct bt_hci_evt_le_remote_features_complete *evt = data;
11100
11101         print_status(evt->status);
11102         print_handle(evt->handle);
11103         print_features(0, evt->features, 0x01);
11104 }
11105
11106 static void le_long_term_key_request_evt(struct timeval *tv, uint16_t index,
11107                                         const void *data, uint8_t size)
11108 {
11109         const struct bt_hci_evt_le_long_term_key_request *evt = data;
11110
11111         print_handle(evt->handle);
11112         print_random_number(evt->rand);
11113         print_encrypted_diversifier(evt->ediv);
11114 }
11115
11116 static void le_conn_param_request_evt(struct timeval *tv, uint16_t index,
11117                                       const void *data, uint8_t size)
11118 {
11119         const struct bt_hci_evt_le_conn_param_request *evt = data;
11120
11121         print_handle(evt->handle);
11122         print_slot_125("Min connection interval", evt->min_interval);
11123         print_slot_125("Max connection interval", evt->max_interval);
11124         print_conn_latency("Connection latency", evt->latency);
11125         print_field("Supervision timeout: %d msec (0x%4.4x)",
11126                                         le16_to_cpu(evt->supv_timeout) * 10,
11127                                         le16_to_cpu(evt->supv_timeout));
11128 }
11129
11130 static void le_data_length_change_evt(struct timeval *tv, uint16_t index,
11131                                       const void *data, uint8_t size)
11132 {
11133         const struct bt_hci_evt_le_data_length_change *evt = data;
11134
11135         print_handle(evt->handle);
11136         print_field("Max TX octets: %d", le16_to_cpu(evt->max_tx_len));
11137         print_field("Max TX time: %d", le16_to_cpu(evt->max_tx_time));
11138         print_field("Max RX octets: %d", le16_to_cpu(evt->max_rx_len));
11139         print_field("Max RX time: %d", le16_to_cpu(evt->max_rx_time));
11140 }
11141
11142 static void le_read_local_pk256_complete_evt(struct timeval *tv, uint16_t index,
11143                                         const void *data, uint8_t size)
11144 {
11145         const struct bt_hci_evt_le_read_local_pk256_complete *evt = data;
11146
11147         print_status(evt->status);
11148         print_pk256("Local P-256 public key", evt->local_pk256);
11149 }
11150
11151 static void le_generate_dhkey_complete_evt(struct timeval *tv, uint16_t index,
11152                                         const void *data, uint8_t size)
11153 {
11154         const struct bt_hci_evt_le_generate_dhkey_complete *evt = data;
11155
11156         print_status(evt->status);
11157         print_dhkey(evt->dhkey);
11158 }
11159
11160 static void le_enhanced_conn_complete_evt(struct timeval *tv, uint16_t index,
11161                                         const void *data, uint8_t size)
11162 {
11163         const struct bt_hci_evt_le_enhanced_conn_complete *evt = data;
11164
11165         print_status(evt->status);
11166         print_handle(evt->handle);
11167         print_role(evt->role);
11168         print_peer_addr_type("Peer address type", evt->peer_addr_type);
11169         print_addr("Peer address", evt->peer_addr, evt->peer_addr_type);
11170         print_addr("Local resolvable private address", evt->local_rpa, 0x01);
11171         print_addr("Peer resolvable private address", evt->peer_rpa, 0x01);
11172         print_slot_125("Connection interval", evt->interval);
11173         print_conn_latency("Connection latency", evt->latency);
11174         print_field("Supervision timeout: %d msec (0x%4.4x)",
11175                                         le16_to_cpu(evt->supv_timeout) * 10,
11176                                         le16_to_cpu(evt->supv_timeout));
11177         print_field("Central clock accuracy: 0x%2.2x", evt->clock_accuracy);
11178
11179         if (evt->status == 0x00)
11180                 assign_handle(index, le16_to_cpu(evt->handle), 0x01,
11181                                 (void *)evt->peer_addr, evt->peer_addr_type);
11182 }
11183
11184 static void le_direct_adv_report_evt(struct timeval *tv, uint16_t index,
11185                                         const void *data, uint8_t size)
11186 {
11187         const struct bt_hci_evt_le_direct_adv_report *evt = data;
11188
11189         print_num_reports(evt->num_reports);
11190
11191         print_adv_event_type("Event type", evt->event_type);
11192         print_peer_addr_type("Address type", evt->addr_type);
11193         print_addr("Address", evt->addr, evt->addr_type);
11194         print_addr_type("Direct address type", evt->direct_addr_type);
11195         print_addr("Direct address", evt->direct_addr, evt->direct_addr_type);
11196         print_rssi(evt->rssi);
11197
11198         if (size > sizeof(*evt))
11199                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
11200 }
11201
11202 static void le_phy_update_complete_evt(struct timeval *tv, uint16_t index,
11203                                         const void *data, uint8_t size)
11204 {
11205         const struct bt_hci_evt_le_phy_update_complete *evt = data;
11206
11207         print_status(evt->status);
11208         print_handle(evt->handle);
11209         print_le_phy("TX PHY", evt->tx_phy);
11210         print_le_phy("RX PHY", evt->rx_phy);
11211 }
11212
11213 static const struct bitfield_data ext_adv_report_evt_type[] = {
11214         {  0, "Connectable"             },
11215         {  1, "Scannable"               },
11216         {  2, "Directed"        },
11217         {  3, "Scan response"   },
11218         {  4, "Use legacy advertising PDUs"     },
11219         { }
11220 };
11221
11222 static void print_ext_adv_report_evt_type(const char *indent, uint16_t flags)
11223 {
11224         uint16_t mask = flags;
11225         uint16_t props = flags;
11226         uint8_t data_status;
11227         const char *str;
11228         const char *color_on;
11229         int i;
11230
11231         print_field("%sEvent type: 0x%4.4x", indent, flags);
11232
11233         props &= 0x1f;
11234         print_field("%s  Props: 0x%4.4x", indent, props);
11235         for (i = 0; ext_adv_report_evt_type[i].str; i++) {
11236                 if (flags & (1 << ext_adv_report_evt_type[i].bit)) {
11237                         print_field("%s    %s", indent,
11238                                                 ext_adv_report_evt_type[i].str);
11239                         mask &= ~(1 << ext_adv_report_evt_type[i].bit);
11240                 }
11241         }
11242
11243         data_status = (flags >> 5) & 3;
11244         mask &= ~(data_status << 5);
11245
11246         switch (data_status) {
11247         case 0x00:
11248                 str = "Complete";
11249                 color_on = COLOR_GREEN;
11250                 break;
11251         case 0x01:
11252                 str = "Incomplete, more data to come";
11253                 color_on = COLOR_YELLOW;
11254                 break;
11255         case 0x02:
11256                 str = "Incomplete, data truncated, no more to come";
11257                 color_on = COLOR_RED;
11258                 break;
11259         default:
11260                 str = "Reserved";
11261                 color_on = COLOR_RED;
11262                 break;
11263         }
11264
11265         print_field("%s  Data status: %s%s%s", indent, color_on, str, COLOR_OFF);
11266
11267         if (mask)
11268                 print_text(COLOR_UNKNOWN_ADV_FLAG,
11269                                 "%s  Reserved (0x%4.4x)", indent, mask);
11270 }
11271
11272 static void print_legacy_adv_report_pdu(uint16_t flags)
11273 {
11274         const char *str;
11275
11276         if (!(flags & (1 << 4)))
11277                 return;
11278
11279         switch (flags) {
11280         case 0x10:
11281                 str = "ADV_NONCONN_IND";
11282                 break;
11283         case 0x12:
11284                 str = "ADV_SCAN_IND";
11285                 break;
11286         case 0x13:
11287                 str = "ADV_IND";
11288                 break;
11289         case 0x15:
11290                 str = "ADV_DIRECT_IND";
11291                 break;
11292         case 0x1a:
11293                 str = "SCAN_RSP to an ADV_IND";
11294                 break;
11295         case 0x1b:
11296                 str = "SCAN_RSP to an ADV_SCAN_IND";
11297                 break;
11298         default:
11299                 str = "Reserved";
11300                 break;
11301         }
11302
11303         print_field("  Legacy PDU Type: %s (0x%4.4x)", str, flags);
11304 }
11305
11306 static void le_ext_adv_report_evt(struct timeval *tv, uint16_t index,
11307                                         const void *data, uint8_t size)
11308 {
11309         const struct bt_hci_evt_le_ext_adv_report *evt = data;
11310         const struct bt_hci_le_ext_adv_report *report;
11311         const char *str;
11312         int i;
11313
11314         print_num_reports(evt->num_reports);
11315
11316         data += sizeof(evt->num_reports);
11317
11318         for (i = 0; i < evt->num_reports; ++i) {
11319                 report = data;
11320                 print_field("Entry %d", i);
11321                 print_ext_adv_report_evt_type("  ", report->event_type);
11322                 print_legacy_adv_report_pdu(report->event_type);
11323                 print_peer_addr_type("  Address type", report->addr_type);
11324                 print_addr("  Address", report->addr, report->addr_type);
11325
11326                 switch (report->primary_phy) {
11327                 case 0x01:
11328                         str = "LE 1M";
11329                         break;
11330                 case 0x03:
11331                         str = "LE Coded";
11332                         break;
11333                 default:
11334                         str = "Reserved";
11335                         break;
11336                 }
11337
11338                 print_field("  Primary PHY: %s", str);
11339
11340                 switch (report->secondary_phy) {
11341                 case 0x00:
11342                         str = "No packets";
11343                         break;
11344                 case 0x01:
11345                         str = "LE 1M";
11346                         break;
11347                 case 0x02:
11348                         str = "LE 2M";
11349                         break;
11350                 case 0x03:
11351                         str = "LE Coded";
11352                         break;
11353                 default:
11354                         str = "Reserved";
11355                         break;
11356                 }
11357
11358                 print_field("  Secondary PHY: %s", str);
11359
11360                 if (report->sid == 0xff)
11361                         print_field("  SID: no ADI field (0x%2.2x)",
11362                                                                 report->sid);
11363                 else if (report->sid > 0x0f)
11364                         print_field("  SID: Reserved (0x%2.2x)", report->sid);
11365                 else
11366                         print_field("  SID: 0x%2.2x", report->sid);
11367
11368                 print_field("  TX power: %d dBm", report->tx_power);
11369
11370                 if (report->rssi == 127)
11371                         print_field("  RSSI: not available (0x%2.2x)",
11372                                                         (uint8_t) report->rssi);
11373                 else if (report->rssi >= -127 && report->rssi <= 20)
11374                         print_field("  RSSI: %d dBm (0x%2.2x)",
11375                                         report->rssi, (uint8_t) report->rssi);
11376                 else
11377                         print_field("  RSSI: reserved (0x%2.2x)",
11378                                                         (uint8_t) report->rssi);
11379
11380                 print_slot_125("  Periodic advertising interval",
11381                                                         report->interval);
11382                 print_peer_addr_type("  Direct address type",
11383                                                 report->direct_addr_type);
11384                 print_addr("  Direct address", report->direct_addr,
11385                                                 report->direct_addr_type);
11386                 print_field("  Data length: 0x%2.2x", report->data_len);
11387                 data += sizeof(struct bt_hci_le_ext_adv_report);
11388                 packet_hexdump(data, report->data_len);
11389                 print_eir(data, report->data_len, true);
11390                 data += report->data_len;
11391         }
11392 }
11393
11394 static void le_pa_sync_evt(struct timeval *tv, uint16_t index,
11395                                 const void *data, uint8_t size)
11396 {
11397         const struct bt_hci_evt_le_per_sync_established *evt = data;
11398
11399         print_status(evt->status);
11400         print_field("Sync handle: %d", evt->handle);
11401         if (evt->sid > 0x0f)
11402                 print_field("Advertising SID: Reserved (0x%2.2x)", evt->sid);
11403         else
11404                 print_field("Advertising SID: 0x%2.2x", evt->sid);
11405
11406         print_peer_addr_type("Advertiser address type", evt->addr_type);
11407         print_addr("Advertiser address", evt->addr, evt->addr_type);
11408         print_le_phy("Advertiser PHY", evt->phy);
11409         print_slot_125("Periodic advertising interval", evt->interval);
11410         print_field("Advertiser clock accuracy: 0x%2.2x", evt->clock_accuracy);
11411 }
11412
11413 static void le_pa_report_evt(struct timeval *tv, uint16_t index,
11414                                 const void *data, uint8_t size)
11415 {
11416         const struct bt_hci_le_pa_report *evt = data;
11417         const char *color_on;
11418         const char *str;
11419
11420         print_field("Sync handle: %d", evt->handle);
11421         print_power_level(evt->tx_power, NULL);
11422         if (evt->rssi == 127)
11423                 print_field("RSSI: not available (0x%2.2x)",
11424                                                 (uint8_t) evt->rssi);
11425         else if (evt->rssi >= -127 && evt->rssi <= 20)
11426                 print_field("RSSI: %d dBm (0x%2.2x)",
11427                                 evt->rssi, (uint8_t) evt->rssi);
11428         else
11429                 print_field("RSSI: reserved (0x%2.2x)",
11430                                                 (uint8_t) evt->rssi);
11431
11432         switch (evt->cte_type) {
11433         case 0x00:
11434                 str = "AoA Constant Tone Extension";
11435                 break;
11436         case 0x01:
11437                 str = "AoA Constant Tone Extension with 1us slots";
11438                 break;
11439         case 0x02:
11440                 str = "AoD Constant Tone Extension with 2us slots";
11441                 break;
11442         case 0xff:
11443                 str = "No Constant Tone Extension";
11444                 break;
11445         default:
11446                 str = "Reserved";
11447                 break;
11448         }
11449
11450         print_field("CTE Type: %s (0x%2x)", str, evt->cte_type);
11451
11452         switch (evt->data_status) {
11453         case 0x00:
11454                 str = "Complete";
11455                 color_on = COLOR_GREEN;
11456                 break;
11457         case 0x01:
11458                 str = "Incomplete, more data to come";
11459                 color_on = COLOR_YELLOW;
11460                 break;
11461         case 0x02:
11462                 str = "Incomplete, data truncated, no more to come";
11463                 color_on = COLOR_RED;
11464                 break;
11465         default:
11466                 str = "Reserved";
11467                 color_on = COLOR_RED;
11468                 break;
11469         }
11470
11471         print_field("Data status: %s%s%s", color_on, str, COLOR_OFF);
11472         print_field("Data length: 0x%2.2x", evt->data_len);
11473         packet_hexdump(evt->data, evt->data_len);
11474 }
11475
11476 static void le_pa_sync_lost_evt(struct timeval *tv, uint16_t index,
11477                                         const void *data, uint8_t size)
11478 {
11479         const struct bt_hci_evt_le_per_sync_lost *evt = data;
11480
11481         print_field("Sync handle: %d", evt->handle);
11482 }
11483
11484 static void le_adv_set_term_evt(struct timeval *tv, uint16_t index,
11485                                         const void *data, uint8_t size)
11486 {
11487         const struct bt_hci_evt_le_adv_set_term *evt = data;
11488
11489         print_status(evt->status);
11490         print_field("Handle: %d", evt->handle);
11491         print_field("Connection handle: %d", evt->conn_handle);
11492         print_field("Number of completed extended advertising events: %d",
11493                         evt->num_evts);
11494 }
11495
11496 static void le_scan_req_received_evt(struct timeval *tv, uint16_t index,
11497                                         const void *data, uint8_t size)
11498 {
11499         const struct bt_hci_evt_le_scan_req_received *evt = data;
11500
11501         print_field("Handle: %d", evt->handle);
11502         print_peer_addr_type("Scanner address type", evt->scanner_addr_type);
11503         print_addr("Scanner address", evt->scanner_addr,
11504                                                         evt->scanner_addr_type);
11505 }
11506
11507 static void le_chan_select_alg_evt(struct timeval *tv, uint16_t index,
11508                                         const void *data, uint8_t size)
11509 {
11510         const struct bt_hci_evt_le_chan_select_alg *evt = data;
11511         const char *str;
11512
11513         print_handle(evt->handle);
11514
11515         switch (evt->algorithm) {
11516         case 0x00:
11517                 str = "#1";
11518                 break;
11519         case 0x01:
11520                 str = "#2";
11521                 break;
11522         default:
11523                 str = "Reserved";
11524                 break;
11525         }
11526
11527         print_field("Algorithm: %s (0x%2.2x)", str, evt->algorithm);
11528 }
11529
11530 static void le_cte_request_failed_evt(struct timeval *tv, uint16_t index,
11531                                         const void *data, uint8_t size)
11532 {
11533         const struct bt_hci_evt_le_cte_request_failed *evt = data;
11534
11535         print_status(evt->status);
11536         print_field("Connection handle: %d", evt->handle);
11537 }
11538
11539 static void le_pa_sync_trans_rec_evt(struct timeval *tv, uint16_t index,
11540                                         const void *data, uint8_t size)
11541 {
11542         const struct bt_hci_evt_le_pa_sync_trans_rec *evt = data;
11543
11544         print_status(evt->status);
11545         print_field("Handle: %d", evt->handle);
11546         print_field("Connection handle: %d", evt->handle);
11547         print_field("Service data: 0x%4.4x", evt->service_data);
11548         print_field("Sync handle: %d", evt->sync_handle);
11549         print_field("SID: 0x%2.2x", evt->sid);
11550         print_peer_addr_type("Address type:", evt->addr_type);
11551         print_addr("Address:", evt->addr, evt->addr_type);
11552         print_le_phy("PHY:", evt->phy);
11553         print_field("Periodic advertising Interval: %.3f",
11554                                                         1.25 * evt->interval);
11555         print_clock_accuracy(evt->clock_accuracy);
11556 }
11557
11558 static void le_cis_established_evt(struct timeval *tv, uint16_t index,
11559                                         const void *data, uint8_t size)
11560 {
11561         const struct bt_hci_evt_le_cis_established *evt = data;
11562
11563         print_status(evt->status);
11564         print_field("Connection Handle: %d", le16_to_cpu(evt->conn_handle));
11565         print_usec_interval("CIG Synchronization Delay", evt->cig_sync_delay);
11566         print_usec_interval("CIS Synchronization Delay", evt->cis_sync_delay);
11567         print_usec_interval("Central to Peripheral Latency", evt->c_latency);
11568         print_usec_interval("Peripheral to Central Latency", evt->p_latency);
11569         print_le_phy("Central to Peripheral PHY", evt->c_phy);
11570         print_le_phy("Peripheral to Central PHY", evt->p_phy);
11571         print_field("Number of Subevents: %u", evt->nse);
11572         print_field("Central to Peripheral Burst Number: %u", evt->c_bn);
11573         print_field("Peripheral to Central Burst Number: %u", evt->p_bn);
11574         print_field("Central to Peripheral Flush Timeout: %u", evt->c_ft);
11575         print_field("Peripheral to Central Flush Timeout: %u", evt->p_ft);
11576         print_field("Central to Peripheral MTU: %u", le16_to_cpu(evt->c_mtu));
11577         print_field("Peripheral to Central MTU: %u", le16_to_cpu(evt->p_mtu));
11578         print_slot_125("ISO Interval", evt->interval);
11579
11580         if (!evt->status)
11581                 assign_handle(index, le16_to_cpu(evt->conn_handle), 0x05,
11582                                         NULL, BDADDR_LE_PUBLIC);
11583 }
11584
11585 static void le_req_cis_evt(struct timeval *tv, uint16_t index,
11586                                         const void *data, uint8_t size)
11587 {
11588         const struct bt_hci_evt_le_cis_req *evt = data;
11589
11590         print_field("ACL Handle: %d", le16_to_cpu(evt->acl_handle));
11591         print_field("CIS Handle: %d", le16_to_cpu(evt->cis_handle));
11592         print_field("CIG ID: 0x%2.2x", evt->cig_id);
11593         print_field("CIS ID: 0x%2.2x", evt->cis_id);
11594 }
11595
11596 static void print_bis_handle(const void *data, int i)
11597 {
11598         uint16_t handle = get_le16(data);
11599
11600         print_field("Connection Handle #%d: %d", i, handle);
11601 }
11602
11603 static void le_big_complete_evt(struct timeval *tv, uint16_t index,
11604                                         const void *data, uint8_t size)
11605 {
11606         const struct bt_hci_evt_le_big_complete *evt = data;
11607
11608         print_status(evt->status);
11609         print_field("Handle: 0x%2.2x", evt->handle);
11610         print_usec_interval("BIG Synchronization Delay", evt->sync_delay);
11611         print_usec_interval("Transport Latency", evt->latency);
11612         print_le_phy("PHY", evt->phy);
11613         print_field("NSE: %u", evt->nse);
11614         print_field("BN: %u", evt->bn);
11615         print_field("PTO: %u", evt->pto);
11616         print_field("IRC: %u", evt->irc);
11617         print_field("Maximum PDU: %u", evt->max_pdu);
11618         print_slot_125("ISO Interval", evt->interval);
11619         print_list(evt->bis_handle, size, evt->num_bis,
11620                         sizeof(*evt->bis_handle), print_bis_handle);
11621
11622         if (!evt->status) {
11623                 int i;
11624
11625                 for (i = 0; i < evt->num_bis; i++)
11626                         assign_handle(index, le16_to_cpu(evt->bis_handle[i]),
11627                                         0x05, NULL, BDADDR_LE_PUBLIC);
11628         }
11629 }
11630
11631 static void le_big_terminate_evt(struct timeval *tv, uint16_t index,
11632                                         const void *data, uint8_t size)
11633 {
11634         const struct bt_hci_evt_le_big_terminate *evt = data;
11635
11636         print_field("BIG Handle: 0x%2.2x", evt->handle);
11637         print_reason(evt->reason);
11638 }
11639
11640 static void le_big_sync_estabilished_evt(struct timeval *tv, uint16_t index,
11641                                         const void *data, uint8_t size)
11642 {
11643         const struct bt_hci_evt_le_big_sync_estabilished *evt = data;
11644
11645         print_status(evt->status);
11646         print_field("BIG Handle: 0x%2.2x", evt->handle);
11647         print_usec_interval("Transport Latency", evt->latency);
11648         print_field("NSE: %u", evt->nse);
11649         print_field("BN: %u", evt->bn);
11650         print_field("PTO: %u", evt->bn);
11651         print_field("IRC: %u", evt->irc);
11652         print_field("Maximum PDU: %u", evt->max_pdu);
11653         print_slot_125("ISO Interval", evt->interval);
11654         print_list(evt->bis, size, evt->num_bis, sizeof(*evt->bis),
11655                                                 print_bis_handle);
11656
11657         if (!evt->status) {
11658                 int i;
11659
11660                 for (i = 0; i < evt->num_bis; i++)
11661                         assign_handle(index, le16_to_cpu(evt->bis[i]),
11662                                         0x05, NULL, BDADDR_LE_PUBLIC);
11663         }
11664 }
11665
11666 static void le_big_sync_lost_evt(struct timeval *tv, uint16_t index,
11667                                         const void *data, uint8_t size)
11668 {
11669         const struct bt_hci_evt_le_big_sync_lost *evt = data;
11670
11671         print_field("BIG Handle: 0x%2.2x", evt->big_handle);
11672         print_reason(evt->reason);
11673 }
11674
11675 static void le_req_sca_complete_evt(struct timeval *tv, uint16_t index,
11676                                         const void *data, uint8_t size)
11677 {
11678         const struct bt_hci_evt_le_req_peer_sca_complete *evt = data;
11679
11680         print_status(evt->status);
11681         print_field("Connection Handle: %d", le16_to_cpu(evt->handle));
11682         print_sca(evt->sca);
11683 }
11684
11685 static void le_big_info_evt(struct timeval *tv, uint16_t index,
11686                                         const void *data, uint8_t size)
11687 {
11688         const struct bt_hci_evt_le_big_info_adv_report *evt = data;
11689
11690         print_field("Sync Handle: 0x%4.4x", evt->sync_handle);
11691         print_field("Number BIS: %u", evt->num_bis);
11692         print_field("NSE: %u", evt->nse);
11693         print_slot_125("ISO Interval", evt->iso_interval);
11694         print_field("BN: %u", evt->bn);
11695         print_field("PTO: %u", evt->bn);
11696         print_field("IRC: %u", evt->irc);
11697         print_field("Maximum PDU: %u", evt->max_pdu);
11698         print_usec_interval("SDU Interval", evt->sdu_interval);
11699         print_field("Maximum SDU: %u", evt->max_sdu);
11700         print_le_phy("PHY", evt->phy);
11701         print_framing(evt->framing);
11702         print_field("Encryption: 0x%02x", evt->encryption);
11703 }
11704
11705 struct subevent_data {
11706         uint8_t subevent;
11707         const char *str;
11708         void (*func) (struct timeval *tv, uint16_t index, const void *data,
11709                                                         uint8_t size);
11710         uint8_t size;
11711         bool fixed;
11712 };
11713
11714 static void print_subevent(struct timeval *tv, uint16_t index,
11715                                 const struct subevent_data *subevent_data,
11716                                 const void *data, uint8_t size)
11717 {
11718         const char *subevent_color;
11719
11720         if (subevent_data->func)
11721                 subevent_color = COLOR_HCI_EVENT;
11722         else
11723                 subevent_color = COLOR_HCI_EVENT_UNKNOWN;
11724
11725         print_indent(6, subevent_color, "", subevent_data->str, COLOR_OFF,
11726                                         " (0x%2.2x)", subevent_data->subevent);
11727
11728         if (!subevent_data->func) {
11729                 packet_hexdump(data, size);
11730                 return;
11731         }
11732
11733         if (subevent_data->fixed) {
11734                 if (size != subevent_data->size) {
11735                         print_text(COLOR_ERROR, "invalid packet size");
11736                         packet_hexdump(data, size);
11737                         return;
11738                 }
11739         } else {
11740                 if (size < subevent_data->size) {
11741                         print_text(COLOR_ERROR, "too short packet");
11742                         packet_hexdump(data, size);
11743                         return;
11744                 }
11745         }
11746
11747         subevent_data->func(tv, index, data, size);
11748 }
11749
11750 static const struct subevent_data le_meta_event_table[] = {
11751         { 0x01, "LE Connection Complete",
11752                                 le_conn_complete_evt, 18, true },
11753         { 0x02, "LE Advertising Report",
11754                                 le_adv_report_evt, 1, false },
11755         { 0x03, "LE Connection Update Complete",
11756                                 le_conn_update_complete_evt, 9, true },
11757         { 0x04, "LE Read Remote Used Features",
11758                                 le_remote_features_complete_evt, 11, true },
11759         { 0x05, "LE Long Term Key Request",
11760                                 le_long_term_key_request_evt, 12, true },
11761         { 0x06, "LE Remote Connection Parameter Request",
11762                                 le_conn_param_request_evt, 10, true },
11763         { 0x07, "LE Data Length Change",
11764                                 le_data_length_change_evt, 10, true },
11765         { 0x08, "LE Read Local P-256 Public Key Complete",
11766                                 le_read_local_pk256_complete_evt, 65, true },
11767         { 0x09, "LE Generate DHKey Complete",
11768                                 le_generate_dhkey_complete_evt, 33, true },
11769         { 0x0a, "LE Enhanced Connection Complete",
11770                                 le_enhanced_conn_complete_evt, 30, true },
11771         { 0x0b, "LE Direct Advertising Report",
11772                                 le_direct_adv_report_evt, 1, false },
11773         { 0x0c, "LE PHY Update Complete",
11774                                 le_phy_update_complete_evt, 5, true},
11775         { 0x0d, "LE Extended Advertising Report",
11776                                 le_ext_adv_report_evt, 1, false},
11777         { 0x0e, "LE Periodic Advertising Sync Established",
11778                                 le_pa_sync_evt, 15, true },
11779         { 0x0f, "LE Periodic Advertising Report",
11780                                 le_pa_report_evt, 7, false},
11781         { 0x10, "LE Periodic Advertising Sync Lost",
11782                                 le_pa_sync_lost_evt, 2, true},
11783         { 0x11, "LE Scan Timeout" },
11784         { 0x12, "LE Advertising Set Terminated",
11785                                 le_adv_set_term_evt, 5, true},
11786         { 0x13, "LE Scan Request Received",
11787                                 le_scan_req_received_evt, 8, true},
11788         { 0x14, "LE Channel Selection Algorithm",
11789                                 le_chan_select_alg_evt, 3, true},
11790         { 0x17, "LE CTE Request Failed",
11791                                 le_cte_request_failed_evt, 3, true},
11792         { 0x18, "LE Periodic Advertising Sync Transfer Received",
11793                                         le_pa_sync_trans_rec_evt, 19,
11794                                         true},
11795         { BT_HCI_EVT_LE_CIS_ESTABLISHED,
11796                                 "LE Connected Isochronous Stream Established",
11797                                 le_cis_established_evt,
11798                                 sizeof(struct bt_hci_evt_le_cis_established),
11799                                 true },
11800         { BT_HCI_EVT_LE_CIS_REQ, "LE Connected Isochronous Stream Request",
11801                                 le_req_cis_evt,
11802                                 sizeof(struct bt_hci_evt_le_cis_req),
11803                                 true },
11804         { BT_HCI_EVT_LE_BIG_COMPLETE,
11805                                 "LE Broadcast Isochronous Group Complete",
11806                                 le_big_complete_evt,
11807                                 sizeof(struct bt_hci_evt_le_big_complete) },
11808         { BT_HCI_EVT_LE_BIG_TERMINATE,
11809                                 "LE Broadcast Isochronous Group Terminate",
11810                                 le_big_terminate_evt,
11811                                 sizeof(struct bt_hci_evt_le_big_terminate) },
11812         { BT_HCI_EVT_LE_BIG_SYNC_ESTABILISHED,
11813                                 "LE Broadcast Isochronous Group Sync "
11814                                 "Estabilished", le_big_sync_estabilished_evt,
11815                                 sizeof(struct bt_hci_evt_le_big_sync_lost) },
11816         { BT_HCI_EVT_LE_BIG_SYNC_LOST,
11817                                 "LE Broadcast Isochronous Group Sync Lost",
11818                                 le_big_sync_lost_evt,
11819                                 sizeof(struct bt_hci_evt_le_big_sync_lost) },
11820         { BT_HCI_EVT_LE_REQ_PEER_SCA_COMPLETE,
11821                                 "LE Request Peer SCA Complete",
11822                                 le_req_sca_complete_evt,
11823                                 sizeof(
11824                                 struct bt_hci_evt_le_req_peer_sca_complete)},
11825         { BT_HCI_EVT_LE_BIG_INFO_ADV_REPORT,
11826                 "LE Broadcast Isochronous Group Info Advertising Report",
11827                 le_big_info_evt,
11828                 sizeof(struct bt_hci_evt_le_big_info_adv_report) },
11829         { }
11830 };
11831
11832 static void le_meta_event_evt(struct timeval *tv, uint16_t index,
11833                                 const void *data, uint8_t size)
11834 {
11835         uint8_t subevent = *((const uint8_t *) data);
11836         struct subevent_data unknown;
11837         const struct subevent_data *subevent_data = &unknown;
11838         int i;
11839
11840         unknown.subevent = subevent;
11841         unknown.str = "Unknown";
11842         unknown.func = NULL;
11843         unknown.size = 0;
11844         unknown.fixed = true;
11845
11846         for (i = 0; le_meta_event_table[i].str; i++) {
11847                 if (le_meta_event_table[i].subevent == subevent) {
11848                         subevent_data = &le_meta_event_table[i];
11849                         break;
11850                 }
11851         }
11852
11853         print_subevent(tv, index, subevent_data, data + 1, size - 1);
11854 }
11855
11856 static void vendor_evt(struct timeval *tv, uint16_t index,
11857                                 const void *data, uint8_t size)
11858 {
11859         struct subevent_data vendor_data;
11860         char vendor_str[150];
11861         int consumed_size;
11862         const struct vendor_evt *vnd = current_vendor_evt(data, &consumed_size);
11863
11864         if (vnd) {
11865                 const char *str = current_vendor_evt_str();
11866
11867                 if (str) {
11868                         snprintf(vendor_str, sizeof(vendor_str),
11869                                                 "%s %s", str, vnd->str);
11870                         vendor_data.str = vendor_str;
11871                 } else
11872                         vendor_data.str = vnd->str;
11873                 vendor_data.subevent = vnd->evt;
11874                 vendor_data.func = vnd->evt_func;
11875                 vendor_data.size = vnd->evt_size;
11876                 vendor_data.fixed = vnd->evt_fixed;
11877
11878                 print_subevent(tv, index, &vendor_data, data + consumed_size,
11879                                                         size - consumed_size);
11880         } else {
11881                 uint16_t manufacturer;
11882
11883                 if (index_current < MAX_INDEX)
11884                         manufacturer = index_list[index_current].manufacturer;
11885                 else
11886                         manufacturer = fallback_manufacturer;
11887
11888                 vendor_event(manufacturer, data, size);
11889         }
11890 }
11891
11892 struct event_data {
11893         uint8_t event;
11894         const char *str;
11895         void (*func) (struct timeval *tv, uint16_t index, const void *data,
11896                                                         uint8_t size);
11897         uint8_t size;
11898         bool fixed;
11899 };
11900
11901 static const struct event_data event_table[] = {
11902         { 0x01, "Inquiry Complete",
11903                                 inquiry_complete_evt, 1, true },
11904         { 0x02, "Inquiry Result",
11905                                 inquiry_result_evt, 1, false },
11906         { 0x03, "Connect Complete",
11907                                 conn_complete_evt, 11, true },
11908         { 0x04, "Connect Request",
11909                                 conn_request_evt, 10, true },
11910         { 0x05, "Disconnect Complete",
11911                                 disconnect_complete_evt, 4, true },
11912         { 0x06, "Auth Complete",
11913                                 auth_complete_evt, 3, true },
11914         { 0x07, "Remote Name Req Complete",
11915                                 remote_name_request_complete_evt, 255, true },
11916         { 0x08, "Encryption Change",
11917                                 encrypt_change_evt, 4, true },
11918         { 0x09, "Change Connection Link Key Complete",
11919                                 change_conn_link_key_complete_evt, 3, true },
11920         { 0x0a, "Link Key Type Changed",
11921                                 link_key_type_changed_evt, 4, true },
11922         { 0x0b, "Read Remote Supported Features",
11923                                 remote_features_complete_evt, 11, true },
11924         { 0x0c, "Read Remote Version Complete",
11925                                 remote_version_complete_evt, 8, true },
11926         { 0x0d, "QoS Setup Complete",
11927                                 qos_setup_complete_evt, 21, true },
11928         { 0x0e, "Command Complete",
11929                                 cmd_complete_evt, 3, false },
11930         { 0x0f, "Command Status",
11931                                 cmd_status_evt, 4, true },
11932         { 0x10, "Hardware Error",
11933                                 hardware_error_evt, 1, true },
11934         { 0x11, "Flush Occurred",
11935                                 flush_occurred_evt, 2, true },
11936         { 0x12, "Role Change",
11937                                 role_change_evt, 8, true },
11938         { 0x13, "Number of Completed Packets",
11939                                 num_completed_packets_evt, 1, false },
11940         { 0x14, "Mode Change",
11941                                 mode_change_evt, 6, true },
11942         { 0x15, "Return Link Keys",
11943                                 return_link_keys_evt, 1, false },
11944         { 0x16, "PIN Code Request",
11945                                 pin_code_request_evt, 6, true },
11946         { 0x17, "Link Key Request",
11947                                 link_key_request_evt, 6, true },
11948         { 0x18, "Link Key Notification",
11949                                 link_key_notify_evt, 23, true },
11950         { 0x19, "Loopback Command",
11951                                 loopback_command_evt, 3, false },
11952         { 0x1a, "Data Buffer Overflow",
11953                                 data_buffer_overflow_evt, 1, true },
11954         { 0x1b, "Max Slots Change",
11955                                 max_slots_change_evt, 3, true },
11956         { 0x1c, "Read Clock Offset Complete",
11957                                 clock_offset_complete_evt, 5, true },
11958         { 0x1d, "Connection Packet Type Changed",
11959                                 conn_pkt_type_changed_evt, 5, true },
11960         { 0x1e, "QoS Violation",
11961                                 qos_violation_evt, 2, true },
11962         { 0x1f, "Page Scan Mode Change",
11963                                 pscan_mode_change_evt, 7, true },
11964         { 0x20, "Page Scan Repetition Mode Change",
11965                                 pscan_rep_mode_change_evt, 7, true },
11966         { 0x21, "Flow Specification Complete",
11967                                 flow_spec_complete_evt, 22, true },
11968         { 0x22, "Inquiry Result with RSSI",
11969                                 inquiry_result_with_rssi_evt, 1, false },
11970         { 0x23, "Read Remote Extended Features",
11971                                 remote_ext_features_complete_evt, 13, true },
11972         { 0x2c, "Synchronous Connect Complete",
11973                                 sync_conn_complete_evt, 17, true },
11974         { 0x2d, "Synchronous Connect Changed",
11975                                 sync_conn_changed_evt, 9, true },
11976         { 0x2e, "Sniff Subrating",
11977                                 sniff_subrating_evt, 11, true },
11978         { 0x2f, "Extended Inquiry Result",
11979                                 ext_inquiry_result_evt, 1, false },
11980         { 0x30, "Encryption Key Refresh Complete",
11981                                 encrypt_key_refresh_complete_evt, 3, true },
11982         { 0x31, "IO Capability Request",
11983                                 io_capability_request_evt, 6, true },
11984         { 0x32, "IO Capability Response",
11985                                 io_capability_response_evt, 9, true },
11986         { 0x33, "User Confirmation Request",
11987                                 user_confirm_request_evt, 10, true },
11988         { 0x34, "User Passkey Request",
11989                                 user_passkey_request_evt, 6, true },
11990         { 0x35, "Remote OOB Data Request",
11991                                 remote_oob_data_request_evt, 6, true },
11992         { 0x36, "Simple Pairing Complete",
11993                                 simple_pairing_complete_evt, 7, true },
11994         { 0x38, "Link Supervision Timeout Changed",
11995                                 link_supv_timeout_changed_evt, 4, true },
11996         { 0x39, "Enhanced Flush Complete",
11997                                 enhanced_flush_complete_evt, 2, true },
11998         { 0x3b, "User Passkey Notification",
11999                                 user_passkey_notify_evt, 10, true },
12000         { 0x3c, "Keypress Notification",
12001                                 keypress_notify_evt, 7, true },
12002         { 0x3d, "Remote Host Supported Features",
12003                                 remote_host_features_notify_evt, 14, true },
12004         { 0x3e, "LE Meta Event",
12005                                 le_meta_event_evt, 1, false },
12006         { 0x40, "Physical Link Complete",
12007                                 phy_link_complete_evt, 2, true },
12008         { 0x41, "Channel Selected",
12009                                 channel_selected_evt, 1, true },
12010         { 0x42, "Disconnect Physical Link Complete",
12011                                 disconn_phy_link_complete_evt, 3, true },
12012         { 0x43, "Physical Link Loss Early Warning",
12013                                 phy_link_loss_early_warning_evt, 2, true },
12014         { 0x44, "Physical Link Recovery",
12015                                 phy_link_recovery_evt, 1, true },
12016         { 0x45, "Logical Link Complete",
12017                                 logic_link_complete_evt, 5, true },
12018         { 0x46, "Disconnect Logical Link Complete",
12019                                 disconn_logic_link_complete_evt, 4, true },
12020         { 0x47, "Flow Specification Modify Complete",
12021                                 flow_spec_modify_complete_evt, 3, true },
12022         { 0x48, "Number of Completed Data Blocks",
12023                                 num_completed_data_blocks_evt, 3, false },
12024         { 0x49, "AMP Start Test" },
12025         { 0x4a, "AMP Test End" },
12026         { 0x4b, "AMP Receiver Report" },
12027         { 0x4c, "Short Range Mode Change Complete",
12028                                 short_range_mode_change_evt, 3, true },
12029         { 0x4d, "AMP Status Change",
12030                                 amp_status_change_evt, 2, true },
12031         { 0x4e, "Triggered Clock Capture",
12032                                 triggered_clock_capture_evt, 9, true },
12033         { 0x4f, "Synchronization Train Complete",
12034                                 sync_train_complete_evt, 1, true },
12035         { 0x50, "Synchronization Train Received",
12036                                 sync_train_received_evt, 29, true },
12037         { 0x51, "Connectionless Peripheral Broadcast Receive",
12038                                 peripheral_broadcast_receive_evt, 18, false },
12039         { 0x52, "Connectionless Peripheral Broadcast Timeout",
12040                                 peripheral_broadcast_timeout_evt, 7, true },
12041         { 0x53, "Truncated Page Complete",
12042                                 truncated_page_complete_evt, 7, true },
12043         { 0x54, "Peripheral Page Response Timeout",
12044                                 peripheral_page_response_timeout_evt, 0, true },
12045         { 0x55, "Connectionless Peripheral Broadcast Channel Map Change",
12046                                 channel_map_change_evt, 10, true },
12047         { 0x56, "Inquiry Response Notification",
12048                                 inquiry_response_notify_evt, 4, true },
12049         { 0x57, "Authenticated Payload Timeout Expired",
12050                                 auth_payload_timeout_expired_evt, 2, true },
12051         { 0x58, "SAM Status Change" },
12052         { 0xfe, "Testing" },
12053         { 0xff, "Vendor", vendor_evt, 0, false },
12054         { }
12055 };
12056
12057 void packet_new_index(struct timeval *tv, uint16_t index, const char *label,
12058                                 uint8_t type, uint8_t bus, const char *name)
12059 {
12060         char details[48];
12061
12062         sprintf(details, "(%s,%s,%s)", hci_typetostr(type),
12063                                         hci_bustostr(bus), name);
12064
12065         print_packet(tv, NULL, '=', index, NULL, COLOR_NEW_INDEX,
12066                                         "New Index", label, details);
12067 }
12068
12069 void packet_del_index(struct timeval *tv, uint16_t index, const char *label)
12070 {
12071         print_packet(tv, NULL, '=', index, NULL, COLOR_DEL_INDEX,
12072                                         "Delete Index", label, NULL);
12073 }
12074
12075 void packet_open_index(struct timeval *tv, uint16_t index, const char *label)
12076 {
12077         print_packet(tv, NULL, '=', index, NULL, COLOR_OPEN_INDEX,
12078                                         "Open Index", label, NULL);
12079 }
12080
12081 void packet_close_index(struct timeval *tv, uint16_t index, const char *label)
12082 {
12083         print_packet(tv, NULL, '=', index, NULL, COLOR_CLOSE_INDEX,
12084                                         "Close Index", label, NULL);
12085 }
12086
12087 void packet_index_info(struct timeval *tv, uint16_t index, const char *label,
12088                                                         uint16_t manufacturer)
12089 {
12090         char details[128];
12091
12092         sprintf(details, "(%s)", bt_compidtostr(manufacturer));
12093
12094         print_packet(tv, NULL, '=', index, NULL, COLOR_INDEX_INFO,
12095                                         "Index Info", label, details);
12096 }
12097
12098 void packet_vendor_diag(struct timeval *tv, uint16_t index,
12099                                         uint16_t manufacturer,
12100                                         const void *data, uint16_t size)
12101 {
12102         char extra_str[16];
12103
12104         sprintf(extra_str, "(len %d)", size);
12105
12106         print_packet(tv, NULL, '=', index, NULL, COLOR_VENDOR_DIAG,
12107                                         "Vendor Diagnostic", NULL, extra_str);
12108
12109         switch (manufacturer) {
12110         case 15:
12111                 broadcom_lm_diag(data, size);
12112                 break;
12113         default:
12114                 packet_hexdump(data, size);
12115                 break;
12116         }
12117 }
12118
12119 void packet_system_note(struct timeval *tv, struct ucred *cred,
12120                                         uint16_t index, const void *message)
12121 {
12122         print_packet(tv, cred, '=', index, NULL, COLOR_SYSTEM_NOTE,
12123                                         "Note", message, NULL);
12124 }
12125
12126 struct monitor_l2cap_hdr {
12127         uint16_t cid;
12128         uint16_t psm;
12129 } __attribute__((packed));
12130
12131 static void packet_decode(struct timeval *tv, struct ucred *cred, char dir,
12132                                 uint16_t index, const char *color,
12133                                 const char *label, const void *data,
12134                                 uint16_t size)
12135 {
12136         const struct monitor_l2cap_hdr *hdr = data;
12137
12138         if (size < sizeof(*hdr)) {
12139                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12140                         "Malformed User Data packet", NULL, NULL);
12141         }
12142
12143         print_packet(tv, cred, dir, index, NULL, COLOR_HCI_ACLDATA, label,
12144                                 dir == '>' ? "User Data RX" : "User Data TX",
12145                                 NULL);
12146
12147         /* Discard last byte since it just a filler */
12148         l2cap_frame(index, dir == '>', 0,
12149                         le16_to_cpu(hdr->cid), le16_to_cpu(hdr->psm),
12150                         data + sizeof(*hdr), size - (sizeof(*hdr) + 1));
12151 }
12152
12153 void packet_user_logging(struct timeval *tv, struct ucred *cred,
12154                                         uint16_t index, uint8_t priority,
12155                                         const char *ident, const void *data,
12156                                         uint16_t size)
12157 {
12158         const char *label;
12159         const char *color;
12160
12161         if (priority > priority_level)
12162                 return;
12163
12164         switch (priority) {
12165         case BTSNOOP_PRIORITY_ERR:
12166                 color = COLOR_ERROR;
12167                 break;
12168         case BTSNOOP_PRIORITY_WARNING:
12169                 color = COLOR_WARN;
12170                 break;
12171         case BTSNOOP_PRIORITY_INFO:
12172                 color = COLOR_INFO;
12173                 break;
12174         case BTSNOOP_PRIORITY_DEBUG:
12175                 color = COLOR_DEBUG;
12176                 break;
12177         default:
12178                 color = COLOR_WHITE_BG;
12179                 break;
12180         }
12181
12182         if (cred) {
12183                 label = NULL;
12184         } else {
12185                 if (ident)
12186                         label = ident;
12187                 else
12188                         label = "Message";
12189         }
12190
12191         if (ident && (ident[0] == '<' || ident[0] == '>')) {
12192                 packet_decode(tv, cred, ident[0], index, color,
12193                               label == ident ? &ident[2] : label,
12194                               data, size);
12195                 return;
12196         }
12197
12198         print_packet(tv, cred, '=', index, NULL, color, label, data, NULL);
12199 }
12200
12201 void packet_hci_command(struct timeval *tv, struct ucred *cred, uint16_t index,
12202                                         const void *data, uint16_t size)
12203 {
12204         const hci_command_hdr *hdr = data;
12205         uint16_t opcode = le16_to_cpu(hdr->opcode);
12206         uint16_t ogf = cmd_opcode_ogf(opcode);
12207         uint16_t ocf = cmd_opcode_ocf(opcode);
12208         struct opcode_data vendor_data;
12209         const struct opcode_data *opcode_data = NULL;
12210         const char *opcode_color, *opcode_str;
12211         char extra_str[25], vendor_str[150];
12212         int i;
12213
12214         if (index >= MAX_INDEX) {
12215                 print_field("Invalid index (%d).", index);
12216                 return;
12217         }
12218
12219         index_list[index].frame++;
12220
12221         if (size < HCI_COMMAND_HDR_SIZE || size > BTSNOOP_MAX_PACKET_SIZE) {
12222                 sprintf(extra_str, "(len %d)", size);
12223                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12224                         "Malformed HCI Command packet", NULL, extra_str);
12225                 return;
12226         }
12227
12228         data += HCI_COMMAND_HDR_SIZE;
12229         size -= HCI_COMMAND_HDR_SIZE;
12230
12231         for (i = 0; opcode_table[i].str; i++) {
12232                 if (opcode_table[i].opcode == opcode) {
12233                         opcode_data = &opcode_table[i];
12234                         break;
12235                 }
12236         }
12237
12238         if (opcode_data) {
12239                 if (opcode_data->cmd_func)
12240                         opcode_color = COLOR_HCI_COMMAND;
12241                 else
12242                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12243                 opcode_str = opcode_data->str;
12244         } else {
12245                 if (ogf == 0x3f) {
12246                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
12247
12248                         if (vnd) {
12249                                 const char *str = current_vendor_str(ocf);
12250
12251                                 if (str) {
12252                                         snprintf(vendor_str, sizeof(vendor_str),
12253                                                         "%s %s", str, vnd->str);
12254                                         vendor_data.str = vendor_str;
12255                                 } else
12256                                         vendor_data.str = vnd->str;
12257                                 vendor_data.cmd_func = vnd->cmd_func;
12258                                 vendor_data.cmd_size = vnd->cmd_size;
12259                                 vendor_data.cmd_fixed = vnd->cmd_fixed;
12260
12261                                 opcode_data = &vendor_data;
12262
12263                                 if (opcode_data->cmd_func)
12264                                         opcode_color = COLOR_HCI_COMMAND;
12265                                 else
12266                                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12267                                 opcode_str = opcode_data->str;
12268                         } else {
12269                                 opcode_color = COLOR_HCI_COMMAND;
12270                                 opcode_str = "Vendor";
12271                         }
12272                 } else {
12273                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12274                         opcode_str = "Unknown";
12275                 }
12276         }
12277
12278         sprintf(extra_str, "(0x%2.2x|0x%4.4x) plen %d", ogf, ocf, hdr->plen);
12279
12280         print_packet(tv, cred, '<', index, NULL, opcode_color, "HCI Command",
12281                                                         opcode_str, extra_str);
12282
12283         if (!opcode_data || !opcode_data->cmd_func) {
12284                 packet_hexdump(data, size);
12285                 return;
12286         }
12287
12288         if (size != hdr->plen) {
12289                 print_text(COLOR_ERROR, "invalid packet size (%u != %u)", size,
12290                                                                 hdr->plen);
12291                 packet_hexdump(data, size);
12292                 return;
12293         }
12294
12295         if (opcode_data->cmd_fixed) {
12296                 if (hdr->plen != opcode_data->cmd_size) {
12297                         print_text(COLOR_ERROR, "invalid packet size");
12298                         packet_hexdump(data, size);
12299                         return;
12300                 }
12301         } else {
12302                 if (hdr->plen < opcode_data->cmd_size) {
12303                         print_text(COLOR_ERROR, "too short packet");
12304                         packet_hexdump(data, size);
12305                         return;
12306                 }
12307         }
12308
12309         opcode_data->cmd_func(index, data, hdr->plen);
12310 }
12311
12312 void packet_hci_event(struct timeval *tv, struct ucred *cred, uint16_t index,
12313                                         const void *data, uint16_t size)
12314 {
12315         const hci_event_hdr *hdr = data;
12316         const struct event_data *event_data = NULL;
12317         const char *event_color, *event_str;
12318         char extra_str[25];
12319         int i;
12320
12321         if (index >= MAX_INDEX) {
12322                 print_field("Invalid index (%d).", index);
12323                 return;
12324         }
12325
12326
12327         index_list[index].frame++;
12328
12329         if (size < HCI_EVENT_HDR_SIZE) {
12330                 sprintf(extra_str, "(len %d)", size);
12331                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12332                         "Malformed HCI Event packet", NULL, extra_str);
12333                 packet_hexdump(data, size);
12334                 return;
12335         }
12336
12337         data += HCI_EVENT_HDR_SIZE;
12338         size -= HCI_EVENT_HDR_SIZE;
12339
12340         for (i = 0; event_table[i].str; i++) {
12341                 if (event_table[i].event == hdr->evt) {
12342                         event_data = &event_table[i];
12343                         break;
12344                 }
12345         }
12346
12347         if (event_data) {
12348                 if (event_data->func)
12349                         event_color = COLOR_HCI_EVENT;
12350                 else
12351                         event_color = COLOR_HCI_EVENT_UNKNOWN;
12352                 event_str = event_data->str;
12353         } else {
12354                 event_color = COLOR_HCI_EVENT_UNKNOWN;
12355                 event_str = "Unknown";
12356         }
12357
12358         sprintf(extra_str, "(0x%2.2x) plen %d", hdr->evt, hdr->plen);
12359
12360         print_packet(tv, cred, '>', index, NULL, event_color, "HCI Event",
12361                                                 event_str, extra_str);
12362
12363         if (!event_data || !event_data->func) {
12364                 packet_hexdump(data, size);
12365                 return;
12366         }
12367
12368         if (size != hdr->plen) {
12369                 print_text(COLOR_ERROR, "invalid packet size (%u != %u)", size,
12370                                                                 hdr->plen);
12371                 packet_hexdump(data, size);
12372                 return;
12373         }
12374
12375         if (event_data->fixed) {
12376                 if (hdr->plen != event_data->size) {
12377                         print_text(COLOR_ERROR, "invalid packet size");
12378                         packet_hexdump(data, size);
12379                         return;
12380                 }
12381         } else {
12382                 if (hdr->plen < event_data->size) {
12383                         print_text(COLOR_ERROR, "too short packet");
12384                         packet_hexdump(data, size);
12385                         return;
12386                 }
12387         }
12388
12389         event_data->func(tv, index, data, hdr->plen);
12390 }
12391
12392 static void packet_queue_tx(struct timeval *tv, uint16_t handle)
12393 {
12394         struct packet_conn_data *conn;
12395         struct timeval *tx;
12396
12397         conn = packet_get_conn_data(handle);
12398         if (!conn)
12399                 return;
12400
12401         if (!conn->tx_q)
12402                 conn->tx_q = queue_new();
12403
12404         tx = new0(struct timeval, 1);
12405         memcpy(tx, tv, sizeof(*tv));
12406         queue_push_tail(conn->tx_q, tx);
12407 }
12408
12409 void packet_hci_acldata(struct timeval *tv, struct ucred *cred, uint16_t index,
12410                                 bool in, const void *data, uint16_t size)
12411 {
12412         const struct bt_hci_acl_hdr *hdr = data;
12413         uint16_t handle = le16_to_cpu(hdr->handle);
12414         uint16_t dlen = le16_to_cpu(hdr->dlen);
12415         uint8_t flags = acl_flags(handle);
12416         char handle_str[16], extra_str[32];
12417
12418         if (index >= MAX_INDEX) {
12419                 print_field("Invalid index (%d).", index);
12420                 return;
12421         }
12422
12423         index_list[index].frame++;
12424
12425         if (size < HCI_ACL_HDR_SIZE) {
12426                 if (in)
12427                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12428                                 "Malformed ACL Data RX packet", NULL, NULL);
12429                 else
12430                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12431                                 "Malformed ACL Data TX packet", NULL, NULL);
12432                 packet_hexdump(data, size);
12433                 return;
12434         }
12435
12436         data += HCI_ACL_HDR_SIZE;
12437         size -= HCI_ACL_HDR_SIZE;
12438
12439         sprintf(handle_str, "Handle %d", acl_handle(handle));
12440         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, dlen);
12441
12442         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_ACLDATA,
12443                                 in ? "ACL Data RX" : "ACL Data TX",
12444                                                 handle_str, extra_str);
12445
12446         if (!in)
12447                 packet_queue_tx(tv, acl_handle(handle));
12448
12449         if (size != dlen) {
12450                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12451                                                                 size, dlen);
12452                 packet_hexdump(data, size);
12453                 return;
12454         }
12455
12456         if (filter_mask & PACKET_FILTER_SHOW_ACL_DATA)
12457                 packet_hexdump(data, size);
12458
12459         l2cap_packet(index, in, acl_handle(handle), flags, data, size);
12460 }
12461
12462 void packet_hci_scodata(struct timeval *tv, struct ucred *cred, uint16_t index,
12463                                 bool in, const void *data, uint16_t size)
12464 {
12465         const hci_sco_hdr *hdr = data;
12466         uint16_t handle = le16_to_cpu(hdr->handle);
12467         uint8_t flags = acl_flags(handle);
12468         char handle_str[16], extra_str[32];
12469
12470         index_list[index].frame++;
12471
12472         if (size < HCI_SCO_HDR_SIZE) {
12473                 if (in)
12474                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12475                                 "Malformed SCO Data RX packet", NULL, NULL);
12476                 else
12477                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12478                                 "Malformed SCO Data TX packet", NULL, NULL);
12479                 packet_hexdump(data, size);
12480                 return;
12481         }
12482
12483         data += HCI_SCO_HDR_SIZE;
12484         size -= HCI_SCO_HDR_SIZE;
12485
12486         sprintf(handle_str, "Handle %d", acl_handle(handle));
12487         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, hdr->dlen);
12488
12489         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_SCODATA,
12490                                 in ? "SCO Data RX" : "SCO Data TX",
12491                                                 handle_str, extra_str);
12492
12493         if (!in)
12494                 packet_queue_tx(tv, acl_handle(handle));
12495
12496         if (size != hdr->dlen) {
12497                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12498                                                         size, hdr->dlen);
12499                 packet_hexdump(data, size);
12500                 return;
12501         }
12502
12503         if (filter_mask & PACKET_FILTER_SHOW_SCO_DATA)
12504                 packet_hexdump(data, size);
12505 }
12506
12507 void packet_hci_isodata(struct timeval *tv, struct ucred *cred, uint16_t index,
12508                                 bool in, const void *data, uint16_t size)
12509 {
12510         const struct bt_hci_iso_hdr *hdr = data;
12511         uint16_t handle = le16_to_cpu(hdr->handle);
12512         uint8_t flags = acl_flags(handle);
12513         char handle_str[16], extra_str[32];
12514
12515         if (index >= MAX_INDEX) {
12516                 print_field("Invalid index (%d).", index);
12517                 return;
12518         }
12519
12520         index_list[index].frame++;
12521
12522         if (size < sizeof(*hdr)) {
12523                 if (in)
12524                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12525                                 "Malformed ISO Data RX packet", NULL, NULL);
12526                 else
12527                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12528                                 "Malformed ISO Data TX packet", NULL, NULL);
12529                 packet_hexdump(data, size);
12530                 return;
12531         }
12532
12533         data += sizeof(*hdr);
12534         size -= sizeof(*hdr);
12535
12536         sprintf(handle_str, "Handle %d", acl_handle(handle));
12537         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, hdr->dlen);
12538
12539         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_ISODATA,
12540                                 in ? "ISO Data RX" : "ISO Data TX",
12541                                                 handle_str, extra_str);
12542
12543         if (!in)
12544                 packet_queue_tx(tv, acl_handle(handle));
12545
12546         if (size != hdr->dlen) {
12547                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12548                                                         size, hdr->dlen);
12549                 packet_hexdump(data, size);
12550                 return;
12551         }
12552
12553         if (filter_mask & PACKET_FILTER_SHOW_ISO_DATA)
12554                 packet_hexdump(data, size);
12555 }
12556
12557
12558 void packet_ctrl_open(struct timeval *tv, struct ucred *cred, uint16_t index,
12559                                         const void *data, uint16_t size)
12560 {
12561         uint32_t cookie;
12562         uint16_t format;
12563         char channel[11];
12564
12565         if (size < 6) {
12566                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12567                                 "Malformed Control Open packet", NULL, NULL);
12568                 packet_hexdump(data, size);
12569                 return;
12570         }
12571
12572         cookie = get_le32(data);
12573         format = get_le16(data + 4);
12574
12575         data += 6;
12576         size -= 6;
12577
12578         sprintf(channel, "0x%4.4x", cookie);
12579
12580         if ((format == CTRL_RAW || format == CTRL_USER || format == CTRL_MGMT)
12581                                                                 && size >= 8) {
12582                 uint8_t version;
12583                 uint16_t revision;
12584                 uint32_t flags;
12585                 uint8_t ident_len;
12586                 const char *comm;
12587                 char details[48];
12588                 const char *title;
12589
12590                 version = get_u8(data);
12591                 revision = get_le16(data + 1);
12592                 flags = get_le32(data + 3);
12593                 ident_len = get_u8(data + 7);
12594
12595                 data += 8;
12596                 size -= 8;
12597
12598                 comm = ident_len > 0 ? data : "unknown";
12599
12600                 data += ident_len;
12601                 size -= ident_len;
12602
12603                 assign_ctrl(cookie, format, comm);
12604
12605                 sprintf(details, "%sversion %u.%u",
12606                                 flags & 0x0001 ? "(privileged) " : "",
12607                                 version, revision);
12608
12609                 switch (format) {
12610                 case CTRL_RAW:
12611                         title = "RAW Open";
12612                         break;
12613                 case CTRL_USER:
12614                         title = "USER Open";
12615                         break;
12616                 case CTRL_MGMT:
12617                         title = "MGMT Open";
12618                         break;
12619                 default:
12620                         title = "Control Open";
12621                         break;
12622                 }
12623
12624                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_OPEN,
12625                                                 title, comm, details);
12626         } else {
12627                 char label[7];
12628
12629                 assign_ctrl(cookie, format, NULL);
12630
12631                 sprintf(label, "0x%4.4x", format);
12632
12633                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_OPEN,
12634                                                 "Control Open", label, NULL);
12635         }
12636
12637         packet_hexdump(data, size);
12638 }
12639
12640 void packet_ctrl_close(struct timeval *tv, struct ucred *cred, uint16_t index,
12641                                         const void *data, uint16_t size)
12642 {
12643         uint32_t cookie;
12644         uint16_t format;
12645         char channel[11], label[22];
12646         const char *title;
12647
12648         if (size < 4) {
12649                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12650                                 "Malformed Control Close packet", NULL, NULL);
12651                 packet_hexdump(data, size);
12652                 return;
12653         }
12654
12655         cookie = get_le32(data);
12656
12657         data += 4;
12658         size -= 4;
12659
12660         sprintf(channel, "0x%4.4x", cookie);
12661
12662         release_ctrl(cookie, &format, label);
12663
12664         switch (format) {
12665         case CTRL_RAW:
12666                 title = "RAW Close";
12667                 break;
12668         case CTRL_USER:
12669                 title = "USER Close";
12670                 break;
12671         case CTRL_MGMT:
12672                 title = "MGMT Close";
12673                 break;
12674         default:
12675                 sprintf(label, "0x%4.4x", format);
12676                 title = "Control Close";
12677                 break;
12678         }
12679
12680         print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
12681                                                         title, label, NULL);
12682
12683         packet_hexdump(data, size);
12684 }
12685
12686 static const struct {
12687         uint8_t status;
12688         const char *str;
12689 } mgmt_status_table[] = {
12690         { 0x00, "Success"               },
12691         { 0x01, "Unknown Command"       },
12692         { 0x02, "Not Connected"         },
12693         { 0x03, "Failed"                },
12694         { 0x04, "Connect Failed"        },
12695         { 0x05, "Authentication Failed" },
12696         { 0x06, "Not Paired"            },
12697         { 0x07, "No Resources"          },
12698         { 0x08, "Timeout"               },
12699         { 0x09, "Already Connected"     },
12700         { 0x0a, "Busy"                  },
12701         { 0x0b, "Rejected"              },
12702         { 0x0c, "Not Supported"         },
12703         { 0x0d, "Invalid Parameters"    },
12704         { 0x0e, "Disconnected"          },
12705         { 0x0f, "Not Powered"           },
12706         { 0x10, "Cancelled"             },
12707         { 0x11, "Invalid Index"         },
12708         { 0x12, "RFKilled"              },
12709         { 0x13, "Already Paired"        },
12710         { 0x14, "Permission Denied"     },
12711         { }
12712 };
12713
12714 static void mgmt_print_status(uint8_t status)
12715 {
12716         const char *str = "Unknown";
12717         const char *color_on, *color_off;
12718         bool unknown = true;
12719         int i;
12720
12721         for (i = 0; mgmt_status_table[i].str; i++) {
12722                 if (mgmt_status_table[i].status == status) {
12723                         str = mgmt_status_table[i].str;
12724                         unknown = false;
12725                         break;
12726                 }
12727         }
12728
12729         if (use_color()) {
12730                 if (status) {
12731                         if (unknown)
12732                                 color_on = COLOR_UNKNOWN_ERROR;
12733                         else
12734                                 color_on = COLOR_RED;
12735                 } else
12736                         color_on = COLOR_GREEN;
12737                 color_off = COLOR_OFF;
12738         } else {
12739                 color_on = "";
12740                 color_off = "";
12741         }
12742
12743         print_field("Status: %s%s%s (0x%2.2x)",
12744                                 color_on, str, color_off, status);
12745 }
12746
12747 static void mgmt_print_address(const uint8_t *address, uint8_t type)
12748 {
12749         switch (type) {
12750         case 0x00:
12751                 print_addr_resolve("BR/EDR Address", address, 0x00, false);
12752                 break;
12753         case 0x01:
12754                 print_addr_resolve("LE Address", address, 0x00, false);
12755                 break;
12756         case 0x02:
12757                 print_addr_resolve("LE Address", address, 0x01, false);
12758                 break;
12759         default:
12760                 print_addr_resolve("Address", address, 0xff, false);
12761                 break;
12762         }
12763 }
12764
12765 static const struct bitfield_data mgmt_address_type_table[] = {
12766         {  0, "BR/EDR"          },
12767         {  1, "LE Public"       },
12768         {  2, "LE Random"       },
12769         { }
12770 };
12771
12772 static void mgmt_print_address_type(uint8_t type)
12773 {
12774         uint8_t mask;
12775
12776         print_field("Address type: 0x%2.2x", type);
12777
12778         mask = print_bitfield(2, type, mgmt_address_type_table);
12779         if (mask)
12780                 print_text(COLOR_UNKNOWN_ADDRESS_TYPE, "  Unknown address type"
12781                                                         " (0x%2.2x)", mask);
12782 }
12783
12784 static void mgmt_print_version(uint8_t version)
12785 {
12786         packet_print_version("Version", version, NULL, 0x0000);
12787 }
12788
12789 static void mgmt_print_manufacturer(uint16_t manufacturer)
12790 {
12791         packet_print_company("Manufacturer", manufacturer);
12792 }
12793
12794 static const struct bitfield_data mgmt_options_table[] = {
12795         {  0, "External configuration"                  },
12796         {  1, "Bluetooth public address configuration"  },
12797         { }
12798 };
12799
12800 static void mgmt_print_options(const char *label, uint32_t options)
12801 {
12802         uint32_t mask;
12803
12804         print_field("%s: 0x%8.8x", label, options);
12805
12806         mask = print_bitfield(2, options, mgmt_options_table);
12807         if (mask)
12808                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Unknown options"
12809                                                         " (0x%8.8x)", mask);
12810 }
12811
12812 static const struct bitfield_data mgmt_settings_table[] = {
12813         {  0, "Powered"                 },
12814         {  1, "Connectable"             },
12815         {  2, "Fast Connectable"        },
12816         {  3, "Discoverable"            },
12817         {  4, "Bondable"                },
12818         {  5, "Link Security"           },
12819         {  6, "Secure Simple Pairing"   },
12820         {  7, "BR/EDR"                  },
12821         {  8, "High Speed"              },
12822         {  9, "Low Energy"              },
12823         { 10, "Advertising"             },
12824         { 11, "Secure Connections"      },
12825         { 12, "Debug Keys"              },
12826         { 13, "Privacy"                 },
12827         { 14, "Controller Configuration"},
12828         { 15, "Static Address"          },
12829         { 16, "PHY Configuration"       },
12830         { 17, "Wideband Speech"         },
12831         { 18, "CIS Central"             },
12832         { 19, "CIS Peripheral"          },
12833         { 20, "ISO Broadcaster"         },
12834         { 21, "Sync Receiver"           },
12835         {}
12836 };
12837
12838 static void mgmt_print_settings(const char *label, uint32_t settings)
12839 {
12840         uint32_t mask;
12841
12842         print_field("%s: 0x%8.8x", label, settings);
12843
12844         mask = print_bitfield(2, settings, mgmt_settings_table);
12845         if (mask)
12846                 print_text(COLOR_UNKNOWN_SETTINGS_BIT, "  Unknown settings"
12847                                                         " (0x%8.8x)", mask);
12848 }
12849
12850 static void mgmt_print_name(const void *data)
12851 {
12852         print_field("Name: %s", (char *) data);
12853         print_field("Short name: %s", (char *) (data + 249));
12854 }
12855
12856 static void mgmt_print_io_capability(uint8_t capability)
12857 {
12858         const char *str;
12859
12860         switch (capability) {
12861         case 0x00:
12862                 str = "DisplayOnly";
12863                 break;
12864         case 0x01:
12865                 str = "DisplayYesNo";
12866                 break;
12867         case 0x02:
12868                 str = "KeyboardOnly";
12869                 break;
12870         case 0x03:
12871                 str = "NoInputNoOutput";
12872                 break;
12873         case 0x04:
12874                 str = "KeyboardDisplay";
12875                 break;
12876         default:
12877                 str = "Reserved";
12878                 break;
12879         }
12880
12881         print_field("Capability: %s (0x%2.2x)", str, capability);
12882 }
12883
12884 static const struct bitfield_data mgmt_device_flags_table[] = {
12885         {  0, "Confirm Name"                    },
12886         {  1, "Legacy Pairing"                  },
12887         {  2, "Not Connectable"                 },
12888         {  3, "Connection Locally Initiated"    },
12889         {  4, "Name Request Failed"             },
12890         {  5, "Scan Response"                   },
12891         { }
12892 };
12893
12894 static void mgmt_print_device_flags(uint32_t flags)
12895 {
12896         uint32_t mask;
12897
12898         print_field("Flags: 0x%8.8x", flags);
12899
12900         mask = print_bitfield(2, flags, mgmt_device_flags_table);
12901         if (mask)
12902                 print_text(COLOR_UNKNOWN_DEVICE_FLAG, "  Unknown device flag"
12903                                                         " (0x%8.8x)", mask);
12904 }
12905
12906 static void mgmt_print_device_action(uint8_t action)
12907 {
12908         const char *str;
12909
12910         switch (action) {
12911         case 0x00:
12912                 str = "Background scan for device";
12913                 break;
12914         case 0x01:
12915                 str = "Allow incoming connection";
12916                 break;
12917         case 0x02:
12918                 str = "Auto-connect remote device";
12919                 break;
12920         default:
12921                 str = "Reserved";
12922                 break;
12923         }
12924
12925         print_field("Action: %s (0x%2.2x)", str, action);
12926 }
12927
12928 static const struct bitfield_data mgmt_adv_flags_table[] = {
12929         {  0, "Switch into Connectable mode"            },
12930         {  1, "Advertise as Discoverable"               },
12931         {  2, "Advertise as Limited Discoverable"       },
12932         {  3, "Add Flags field to Advertising Data"     },
12933         {  4, "Add TX Power field to Advertising Data"  },
12934         {  5, "Add Appearance field to Scan Response"   },
12935         {  6, "Add Local Name in Scan Response"         },
12936         {  7, "Advertise in 1M on Secondary channel"    },
12937         {  8, "Advertise in 2M on Secondary channel"    },
12938         {  9, "Advertise in CODED on Secondary channel" },
12939         {  10, "Support setting Tx Power"               },
12940         {  11, "Support HW offload"                     },
12941         {  12, "Use provided duration parameter"        },
12942         {  13, "Use provided timeout parameter"         },
12943         {  14, "Use provided interval parameters"       },
12944         {  15, "Use provided tx power parameter"        },
12945         {  16, "Contain Scan Response Data"             },
12946         { }
12947 };
12948 #define MGMT_ADV_PARAM_DURATION         (1 << 12)
12949 #define MGMT_ADV_PARAM_TIMEOUT          (1 << 13)
12950 #define MGMT_ADV_PARAM_INTERVALS        (1 << 14)
12951 #define MGMT_ADV_PARAM_TX_POWER         (1 << 15)
12952
12953 static void mgmt_print_adv_flags(uint32_t flags)
12954 {
12955         uint32_t mask;
12956
12957         print_field("Flags: 0x%8.8x", flags);
12958
12959         mask = print_bitfield(2, flags, mgmt_adv_flags_table);
12960         if (mask)
12961                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown advertising flag"
12962                                                         " (0x%8.8x)", mask);
12963 }
12964
12965 static void mgmt_print_store_hint(uint8_t hint)
12966 {
12967         const char *str;
12968
12969         switch (hint) {
12970         case 0x00:
12971                 str = "No";
12972                 break;
12973         case 0x01:
12974                 str = "Yes";
12975                 break;
12976         default:
12977                 str = "Reserved";
12978                 break;
12979         }
12980
12981         print_field("Store hint: %s (0x%2.2x)", str, hint);
12982 }
12983
12984 static void mgmt_print_connection_parameter(const void *data)
12985 {
12986         uint8_t address_type = get_u8(data + 6);
12987         uint16_t min_conn_interval = get_le16(data + 7);
12988         uint16_t max_conn_interval = get_le16(data + 9);
12989         uint16_t conn_latency = get_le16(data + 11);
12990         uint16_t supv_timeout = get_le16(data + 13);
12991
12992         mgmt_print_address(data, address_type);
12993         print_field("Min connection interval: %u", min_conn_interval);
12994         print_field("Max connection interval: %u", max_conn_interval);
12995         print_conn_latency("Connection latency", conn_latency);
12996         print_field("Supervision timeout: %u", supv_timeout);
12997 }
12998
12999 static void mgmt_print_link_key(const void *data)
13000 {
13001         uint8_t address_type = get_u8(data + 6);
13002         uint8_t key_type = get_u8(data + 7);
13003         uint8_t pin_len = get_u8(data + 24);
13004
13005         mgmt_print_address(data, address_type);
13006         print_key_type(key_type);
13007         print_link_key(data + 8);
13008         print_field("PIN length: %d", pin_len);
13009 }
13010
13011 static void mgmt_print_long_term_key(const void *data)
13012 {
13013         uint8_t address_type = get_u8(data + 6);
13014         uint8_t key_type = get_u8(data + 7);
13015         uint8_t central = get_u8(data + 8);
13016         uint8_t enc_size = get_u8(data + 9);
13017         const char *str;
13018
13019         mgmt_print_address(data, address_type);
13020
13021         switch (key_type) {
13022         case 0x00:
13023                 str = "Unauthenticated legacy key";
13024                 break;
13025         case 0x01:
13026                 str = "Authenticated legacy key";
13027                 break;
13028         case 0x02:
13029                 str = "Unauthenticated key from P-256";
13030                 break;
13031         case 0x03:
13032                 str = "Authenticated key from P-256";
13033                 break;
13034         case 0x04:
13035                 str = "Debug key from P-256";
13036                 break;
13037         default:
13038                 str = "Reserved";
13039                 break;
13040         }
13041
13042         print_field("Key type: %s (0x%2.2x)", str, key_type);
13043         print_field("Central: 0x%2.2x", central);
13044         print_field("Encryption size: %u", enc_size);
13045         print_hex_field("Diversifier", data + 10, 2);
13046         print_hex_field("Randomizer", data + 12, 8);
13047         print_hex_field("Key", data + 20, 16);
13048 }
13049
13050 static void mgmt_print_identity_resolving_key(const void *data)
13051 {
13052         uint8_t address_type = get_u8(data + 6);
13053
13054         mgmt_print_address(data, address_type);
13055         print_hex_field("Key", data + 7, 16);
13056         keys_add_identity(data, address_type, data + 7);
13057 }
13058
13059 static void mgmt_print_signature_resolving_key(const void *data)
13060 {
13061         uint8_t address_type = get_u8(data + 6);
13062         uint8_t key_type = get_u8(data + 7);
13063         const char *str;
13064
13065         mgmt_print_address(data, address_type);
13066
13067         switch (key_type) {
13068         case 0x00:
13069                 str = "Unauthenticated local CSRK";
13070                 break;
13071         case 0x01:
13072                 str = "Unauthenticated remote CSRK";
13073                 break;
13074         case 0x02:
13075                 str = "Authenticated local CSRK";
13076                 break;
13077         case 0x03:
13078                 str = "Authenticated remote CSRK";
13079                 break;
13080         default:
13081                 str = "Reserved";
13082                 break;
13083         }
13084
13085         print_field("Key type: %s (0x%2.2x)", str, key_type);
13086         print_hex_field("Key", data + 8, 16);
13087 }
13088
13089 static void mgmt_print_oob_data(const void *data)
13090 {
13091         print_hash_p192(data);
13092         print_randomizer_p192(data + 16);
13093         print_hash_p256(data + 32);
13094         print_randomizer_p256(data + 48);
13095 }
13096
13097 static const struct bitfield_data mgmt_exp_feature_flags_table[] = {
13098         {  0, "Active"          },
13099         {  1, "Settings change" },
13100         { }
13101 };
13102
13103 static void mgmt_print_exp_feature(const void *data)
13104 {
13105         uint32_t flags = get_le32(data + 16);
13106         uint32_t mask;
13107
13108         print_field("UUID: %s", bt_uuid128_to_str(data));
13109         print_field("Flags: 0x%8.8x", flags);
13110
13111         mask = print_bitfield(2, flags, mgmt_exp_feature_flags_table);
13112         if (mask)
13113                 print_text(COLOR_UNKNOWN_EXP_FEATURE_FLAG,
13114                                 "  Unknown feature flag (0x%8.8x)", mask);
13115 }
13116
13117 static void mgmt_null_cmd(const void *data, uint16_t size)
13118 {
13119 }
13120
13121 static void mgmt_null_rsp(const void *data, uint16_t size)
13122 {
13123 }
13124
13125 static void mgmt_read_version_info_rsp(const void *data, uint16_t size)
13126 {
13127         uint8_t version;
13128         uint16_t revision;
13129
13130         version = get_u8(data);
13131         revision = get_le16(data + 1);
13132
13133         print_field("Version: %u.%u", version, revision);
13134 }
13135
13136 static void mgmt_print_commands(const void *data, uint16_t num);
13137 static void mgmt_print_events(const void *data, uint16_t num);
13138
13139 static void mgmt_read_supported_commands_rsp(const void *data, uint16_t size)
13140 {
13141         uint16_t num_commands = get_le16(data);
13142         uint16_t num_events = get_le16(data + 2);
13143
13144         if (size - 4 != (num_commands * 2) + (num_events *2)) {
13145                 packet_hexdump(data, size);
13146                 return;
13147         }
13148
13149         mgmt_print_commands(data + 4, num_commands);
13150         mgmt_print_events(data + 4 + num_commands * 2, num_events);
13151 }
13152
13153 static void mgmt_read_index_list_rsp(const void *data, uint16_t size)
13154 {
13155         uint16_t num_controllers = get_le16(data);
13156         int i;
13157
13158         print_field("Controllers: %u", num_controllers);
13159
13160         if (size - 2 != num_controllers * 2) {
13161                 packet_hexdump(data + 2, size - 2);
13162                 return;
13163         }
13164
13165         for (i = 0; i < num_controllers; i++) {
13166                 uint16_t index = get_le16(data + 2 + (i * 2));
13167
13168                 print_field("  hci%u", index);
13169         }
13170 }
13171
13172 static void mgmt_read_controller_info_rsp(const void *data, uint16_t size)
13173 {
13174         uint8_t version = get_u8(data + 6);
13175         uint16_t manufacturer = get_le16(data + 7);
13176         uint32_t supported_settings = get_le32(data + 9);
13177         uint32_t current_settings = get_le32(data + 13);
13178
13179         print_addr_resolve("Address", data, 0x00, false);
13180         mgmt_print_version(version);
13181         mgmt_print_manufacturer(manufacturer);
13182         mgmt_print_settings("Supported settings", supported_settings);
13183         mgmt_print_settings("Current settings", current_settings);
13184         print_dev_class(data + 17);
13185         mgmt_print_name(data + 20);
13186 }
13187
13188 static void mgmt_set_powered_cmd(const void *data, uint16_t size)
13189 {
13190         uint8_t enable = get_u8(data);
13191
13192         print_enable("Powered", enable);
13193 }
13194
13195 static void mgmt_set_discoverable_cmd(const void *data, uint16_t size)
13196 {
13197         uint8_t enable = get_u8(data);
13198         uint16_t timeout = get_le16(data + 1);
13199         const char *str;
13200
13201         switch (enable) {
13202         case 0x00:
13203                 str = "Disabled";
13204                 break;
13205         case 0x01:
13206                 str = "General";
13207                 break;
13208         case 0x02:
13209                 str = "Limited";
13210                 break;
13211         default:
13212                 str = "Reserved";
13213                 break;
13214         }
13215
13216         print_field("Discoverable: %s (0x%2.2x)", str, enable);
13217         print_field("Timeout: %u", timeout);
13218 }
13219
13220 static void mgmt_set_connectable_cmd(const void *data, uint16_t size)
13221 {
13222         uint8_t enable = get_u8(data);
13223
13224         print_enable("Connectable", enable);
13225 }
13226
13227 static void mgmt_set_fast_connectable_cmd(const void *data, uint16_t size)
13228 {
13229         uint8_t enable = get_u8(data);
13230
13231         print_enable("Fast Connectable", enable);
13232 }
13233
13234 static void mgmt_set_bondable_cmd(const void *data, uint16_t size)
13235 {
13236         uint8_t enable = get_u8(data);
13237
13238         print_enable("Bondable", enable);
13239 }
13240
13241 static void mgmt_set_link_security_cmd(const void *data, uint16_t size)
13242 {
13243         uint8_t enable = get_u8(data);
13244
13245         print_enable("Link Security", enable);
13246 }
13247
13248 static void mgmt_set_secure_simple_pairing_cmd(const void *data, uint16_t size)
13249 {
13250         uint8_t enable = get_u8(data);
13251
13252         print_enable("Secure Simple Pairing", enable);
13253 }
13254
13255 static void mgmt_set_high_speed_cmd(const void *data, uint16_t size)
13256 {
13257         uint8_t enable = get_u8(data);
13258
13259         print_enable("High Speed", enable);
13260 }
13261
13262 static void mgmt_set_low_energy_cmd(const void *data, uint16_t size)
13263 {
13264         uint8_t enable = get_u8(data);
13265
13266         print_enable("Low Energy", enable);
13267 }
13268
13269 static void mgmt_new_settings_rsp(const void *data, uint16_t size)
13270 {
13271         uint32_t current_settings = get_le32(data);
13272
13273         mgmt_print_settings("Current settings", current_settings);
13274 }
13275
13276 static void mgmt_set_device_class_cmd(const void *data, uint16_t size)
13277 {
13278         uint8_t major = get_u8(data);
13279         uint8_t minor = get_u8(data + 1);
13280
13281         print_field("Major class: 0x%2.2x", major);
13282         print_field("Minor class: 0x%2.2x", minor);
13283 }
13284
13285 static void mgmt_set_device_class_rsp(const void *data, uint16_t size)
13286 {
13287         print_dev_class(data);
13288 }
13289
13290 static void mgmt_set_local_name_cmd(const void *data, uint16_t size)
13291 {
13292         mgmt_print_name(data);
13293 }
13294
13295 static void mgmt_set_local_name_rsp(const void *data, uint16_t size)
13296 {
13297         mgmt_print_name(data);
13298 }
13299
13300 static void mgmt_add_uuid_cmd(const void *data, uint16_t size)
13301 {
13302         uint8_t service_class = get_u8(data + 16);
13303
13304         print_field("UUID: %s", bt_uuid128_to_str(data));
13305         print_field("Service class: 0x%2.2x", service_class);
13306 }
13307
13308 static void mgmt_add_uuid_rsp(const void *data, uint16_t size)
13309 {
13310         print_dev_class(data);
13311 }
13312
13313 static void mgmt_remove_uuid_cmd(const void *data, uint16_t size)
13314 {
13315         print_field("UUID: %s", bt_uuid128_to_str(data));
13316 }
13317
13318 static void mgmt_remove_uuid_rsp(const void *data, uint16_t size)
13319 {
13320         print_dev_class(data);
13321 }
13322
13323 static void mgmt_load_link_keys_cmd(const void *data, uint16_t size)
13324 {
13325         uint8_t debug_keys = get_u8(data);
13326         uint16_t num_keys = get_le16(data + 1);
13327         int i;
13328
13329         print_enable("Debug keys", debug_keys);
13330         print_field("Keys: %u", num_keys);
13331
13332         if (size - 3 != num_keys * 25) {
13333                 packet_hexdump(data + 3, size - 3);
13334                 return;
13335         }
13336
13337         for (i = 0; i < num_keys; i++)
13338                 mgmt_print_link_key(data + 3 + (i * 25));
13339 }
13340
13341 static void mgmt_load_long_term_keys_cmd(const void *data, uint16_t size)
13342 {
13343         uint16_t num_keys = get_le16(data);
13344         int i;
13345
13346         print_field("Keys: %u", num_keys);
13347
13348         if (size - 2 != num_keys * 36) {
13349                 packet_hexdump(data + 2, size - 2);
13350                 return;
13351         }
13352
13353         for (i = 0; i < num_keys; i++)
13354                 mgmt_print_long_term_key(data + 2 + (i * 36));
13355 }
13356
13357 static void mgmt_disconnect_cmd(const void *data, uint16_t size)
13358 {
13359         uint8_t address_type = get_u8(data + 6);
13360
13361         mgmt_print_address(data, address_type);
13362 }
13363
13364 static void mgmt_disconnect_rsp(const void *data, uint16_t size)
13365 {
13366         uint8_t address_type = get_u8(data + 6);
13367
13368         mgmt_print_address(data, address_type);
13369 }
13370
13371 static void mgmt_get_connections_rsp(const void *data, uint16_t size)
13372 {
13373         uint16_t num_connections = get_le16(data);
13374         int i;
13375
13376         print_field("Connections: %u", num_connections);
13377
13378         if (size - 2 != num_connections * 7) {
13379                 packet_hexdump(data + 2, size - 2);
13380                 return;
13381         }
13382
13383         for (i = 0; i < num_connections; i++) {
13384                 uint8_t address_type = get_u8(data + 2 + (i * 7) + 6);
13385
13386                 mgmt_print_address(data + 2 + (i * 7), address_type);
13387         }
13388 }
13389
13390 static void mgmt_pin_code_reply_cmd(const void *data, uint16_t size)
13391 {
13392         uint8_t address_type = get_u8(data + 6);
13393         uint8_t pin_len = get_u8(data + 7);
13394
13395         mgmt_print_address(data, address_type);
13396         print_field("PIN length: %u", pin_len);
13397         print_hex_field("PIN code", data + 8, 16);
13398 }
13399
13400 static void mgmt_pin_code_reply_rsp(const void *data, uint16_t size)
13401 {
13402         uint8_t address_type = get_u8(data + 6);
13403
13404         mgmt_print_address(data, address_type);
13405 }
13406
13407 static void mgmt_pin_code_neg_reply_cmd(const void *data, uint16_t size)
13408 {
13409         uint8_t address_type = get_u8(data + 6);
13410
13411         mgmt_print_address(data, address_type);
13412 }
13413
13414 static void mgmt_pin_code_neg_reply_rsp(const void *data, uint16_t size)
13415 {
13416         uint8_t address_type = get_u8(data + 6);
13417
13418         mgmt_print_address(data, address_type);
13419 }
13420
13421 static void mgmt_set_io_capability_cmd(const void *data, uint16_t size)
13422 {
13423         uint8_t capability = get_u8(data);
13424
13425         mgmt_print_io_capability(capability);
13426 }
13427
13428 static void mgmt_pair_device_cmd(const void *data, uint16_t size)
13429 {
13430         uint8_t address_type = get_u8(data + 6);
13431         uint8_t capability = get_u8(data + 7);
13432
13433         mgmt_print_address(data, address_type);
13434         mgmt_print_io_capability(capability);
13435 }
13436
13437 static void mgmt_pair_device_rsp(const void *data, uint16_t size)
13438 {
13439         uint8_t address_type = get_u8(data + 6);
13440
13441         mgmt_print_address(data, address_type);
13442 }
13443
13444 static void mgmt_cancel_pair_device_cmd(const void *data, uint16_t size)
13445 {
13446         uint8_t address_type = get_u8(data + 6);
13447
13448         mgmt_print_address(data, address_type);
13449 }
13450
13451 static void mgmt_cancel_pair_device_rsp(const void *data, uint16_t size)
13452 {
13453         uint8_t address_type = get_u8(data + 6);
13454
13455         mgmt_print_address(data, address_type);
13456 }
13457
13458 static void mgmt_unpair_device_cmd(const void *data, uint16_t size)
13459 {
13460         uint8_t address_type = get_u8(data + 6);
13461         uint8_t disconnect = get_u8(data + 7);
13462
13463         mgmt_print_address(data, address_type);
13464         print_enable("Disconnect", disconnect);
13465 }
13466
13467 static void mgmt_unpair_device_rsp(const void *data, uint16_t size)
13468 {
13469         uint8_t address_type = get_u8(data + 6);
13470
13471         mgmt_print_address(data, address_type);
13472 }
13473
13474 static void mgmt_user_confirmation_reply_cmd(const void *data, uint16_t size)
13475 {
13476         uint8_t address_type = get_u8(data + 6);
13477
13478         mgmt_print_address(data, address_type);
13479 }
13480
13481 static void mgmt_user_confirmation_reply_rsp(const void *data, uint16_t size)
13482 {
13483         uint8_t address_type = get_u8(data + 6);
13484
13485         mgmt_print_address(data, address_type);
13486 }
13487
13488 static void mgmt_user_confirmation_neg_reply_cmd(const void *data, uint16_t size)
13489 {
13490         uint8_t address_type = get_u8(data + 6);
13491
13492         mgmt_print_address(data, address_type);
13493 }
13494
13495 static void mgmt_user_confirmation_neg_reply_rsp(const void *data, uint16_t size)
13496 {
13497         uint8_t address_type = get_u8(data + 6);
13498
13499         mgmt_print_address(data, address_type);
13500 }
13501
13502 static void mgmt_user_passkey_reply_cmd(const void *data, uint16_t size)
13503 {
13504         uint8_t address_type = get_u8(data + 6);
13505         uint32_t passkey = get_le32(data + 7);
13506
13507         mgmt_print_address(data, address_type);
13508         print_field("Passkey: 0x%4.4x", passkey);
13509 }
13510
13511 static void mgmt_user_passkey_reply_rsp(const void *data, uint16_t size)
13512 {
13513         uint8_t address_type = get_u8(data + 6);
13514
13515         mgmt_print_address(data, address_type);
13516 }
13517
13518 static void mgmt_user_passkey_neg_reply_cmd(const void *data, uint16_t size)
13519 {
13520         uint8_t address_type = get_u8(data + 6);
13521
13522         mgmt_print_address(data, address_type);
13523 }
13524
13525 static void mgmt_user_passkey_neg_reply_rsp(const void *data, uint16_t size)
13526 {
13527         uint8_t address_type = get_u8(data + 6);
13528
13529         mgmt_print_address(data, address_type);
13530 }
13531
13532 static void mgmt_read_local_oob_data_rsp(const void *data, uint16_t size)
13533 {
13534         mgmt_print_oob_data(data);
13535 }
13536
13537 static void mgmt_add_remote_oob_data_cmd(const void *data, uint16_t size)
13538 {
13539         uint8_t address_type = get_u8(data + 6);
13540
13541         mgmt_print_address(data, address_type);
13542         mgmt_print_oob_data(data + 7);
13543 }
13544
13545 static void mgmt_add_remote_oob_data_rsp(const void *data, uint16_t size)
13546 {
13547         uint8_t address_type = get_u8(data + 6);
13548
13549         mgmt_print_address(data, address_type);
13550 }
13551
13552 static void mgmt_remove_remote_oob_data_cmd(const void *data, uint16_t size)
13553 {
13554         uint8_t address_type = get_u8(data + 6);
13555
13556         mgmt_print_address(data, address_type);
13557 }
13558
13559 static void mgmt_remove_remote_oob_data_rsp(const void *data, uint16_t size)
13560 {
13561         uint8_t address_type = get_u8(data + 6);
13562
13563         mgmt_print_address(data, address_type);
13564 }
13565
13566 static void mgmt_start_discovery_cmd(const void *data, uint16_t size)
13567 {
13568         uint8_t type = get_u8(data);
13569
13570         mgmt_print_address_type(type);
13571 }
13572
13573 static void mgmt_start_discovery_rsp(const void *data, uint16_t size)
13574 {
13575         uint8_t type = get_u8(data);
13576
13577         mgmt_print_address_type(type);
13578 }
13579
13580 static void mgmt_stop_discovery_cmd(const void *data, uint16_t size)
13581 {
13582         uint8_t type = get_u8(data);
13583
13584         mgmt_print_address_type(type);
13585 }
13586
13587 static void mgmt_stop_discovery_rsp(const void *data, uint16_t size)
13588 {
13589         uint8_t type = get_u8(data);
13590
13591         mgmt_print_address_type(type);
13592 }
13593
13594 static void mgmt_confirm_name_cmd(const void *data, uint16_t size)
13595 {
13596         uint8_t address_type = get_u8(data + 6);
13597         uint8_t name_known = get_u8(data + 7);
13598         const char *str;
13599
13600         mgmt_print_address(data, address_type);
13601
13602         switch (name_known) {
13603         case 0x00:
13604                 str = "No";
13605                 break;
13606         case 0x01:
13607                 str = "Yes";
13608                 break;
13609         default:
13610                 str = "Reserved";
13611                 break;
13612         }
13613
13614         print_field("Name known: %s (0x%2.2x)", str, name_known);
13615 }
13616
13617 static void mgmt_confirm_name_rsp(const void *data, uint16_t size)
13618 {
13619         uint8_t address_type = get_u8(data + 6);
13620
13621         mgmt_print_address(data, address_type);
13622 }
13623
13624 static void mgmt_block_device_cmd(const void *data, uint16_t size)
13625 {
13626         uint8_t address_type = get_u8(data + 6);
13627
13628         mgmt_print_address(data, address_type);
13629 }
13630
13631 static void mgmt_block_device_rsp(const void *data, uint16_t size)
13632 {
13633         uint8_t address_type = get_u8(data + 6);
13634
13635         mgmt_print_address(data, address_type);
13636 }
13637
13638 static void mgmt_unblock_device_cmd(const void *data, uint16_t size)
13639 {
13640         uint8_t address_type = get_u8(data + 6);
13641
13642         mgmt_print_address(data, address_type);
13643 }
13644
13645 static void mgmt_unblock_device_rsp(const void *data, uint16_t size)
13646 {
13647         uint8_t address_type = get_u8(data + 6);
13648
13649         mgmt_print_address(data, address_type);
13650 }
13651
13652 static void mgmt_set_device_id_cmd(const void *data, uint16_t size)
13653 {
13654         print_device_id(data, size);
13655 }
13656
13657 static void mgmt_set_advertising_cmd(const void *data, uint16_t size)
13658 {
13659         uint8_t enable = get_u8(data);
13660         const char *str;
13661
13662         switch (enable) {
13663         case 0x00:
13664                 str = "Disabled";
13665                 break;
13666         case 0x01:
13667                 str = "Enabled";
13668                 break;
13669         case 0x02:
13670                 str = "Connectable";
13671                 break;
13672         default:
13673                 str = "Reserved";
13674                 break;
13675         }
13676
13677         print_field("Advertising: %s (0x%2.2x)", str, enable);
13678 }
13679
13680 static void mgmt_set_bredr_cmd(const void *data, uint16_t size)
13681 {
13682         uint8_t enable = get_u8(data);
13683
13684         print_enable("BR/EDR", enable);
13685 }
13686
13687 static void mgmt_set_static_address_cmd(const void *data, uint16_t size)
13688 {
13689         print_addr_resolve("Address", data, 0x01, false);
13690 }
13691
13692 static void mgmt_set_scan_parameters_cmd(const void *data, uint16_t size)
13693 {
13694         uint16_t interval = get_le16(data);
13695         uint16_t window = get_le16(data + 2);
13696
13697         print_field("Interval: %u (0x%2.2x)", interval, interval);
13698         print_field("Window: %u (0x%2.2x)", window, window);
13699 }
13700
13701 static void mgmt_set_secure_connections_cmd(const void *data, uint16_t size)
13702 {
13703         uint8_t enable = get_u8(data);
13704         const char *str;
13705
13706         switch (enable) {
13707         case 0x00:
13708                 str = "Disabled";
13709                 break;
13710         case 0x01:
13711                 str = "Enabled";
13712                 break;
13713         case 0x02:
13714                 str = "Only";
13715                 break;
13716         default:
13717                 str = "Reserved";
13718                 break;
13719         }
13720
13721         print_field("Secure Connections: %s (0x%2.2x)", str, enable);
13722 }
13723
13724 static void mgmt_set_debug_keys_cmd(const void *data, uint16_t size)
13725 {
13726         uint8_t enable = get_u8(data);
13727         const char *str;
13728
13729         switch (enable) {
13730         case 0x00:
13731                 str = "Disabled";
13732                 break;
13733         case 0x01:
13734                 str = "Enabled";
13735                 break;
13736         case 0x02:
13737                 str = "Generate";
13738                 break;
13739         default:
13740                 str = "Reserved";
13741                 break;
13742         }
13743
13744         print_field("Debug Keys: %s (0x%2.2x)", str, enable);
13745 }
13746
13747 static void mgmt_set_privacy_cmd(const void *data, uint16_t size)
13748 {
13749         uint8_t enable = get_u8(data);
13750         const char *str;
13751
13752         switch (enable) {
13753         case 0x00:
13754                 str = "Disabled";
13755                 break;
13756         case 0x01:
13757                 str = "Enabled";
13758                 break;
13759         case 0x02:
13760                 str = "Limited";
13761                 break;
13762         default:
13763                 str = "Reserved";
13764                 break;
13765         }
13766
13767         print_field("Privacy: %s (0x%2.2x)", str, enable);
13768         print_hex_field("Key", data + 1, 16);
13769 }
13770
13771 static void mgmt_load_identity_resolving_keys_cmd(const void *data, uint16_t size)
13772 {
13773         uint16_t num_keys = get_le16(data);
13774         int i;
13775
13776         print_field("Keys: %u", num_keys);
13777
13778         if (size - 2 != num_keys * 23) {
13779                 packet_hexdump(data + 2, size - 2);
13780                 return;
13781         }
13782
13783         for (i = 0; i < num_keys; i++)
13784                 mgmt_print_identity_resolving_key(data + 2 + (i * 23));
13785 }
13786
13787 static void mgmt_get_connection_information_cmd(const void *data, uint16_t size)
13788 {
13789         uint8_t address_type = get_u8(data + 6);
13790
13791         mgmt_print_address(data, address_type);
13792 }
13793
13794 static void mgmt_get_connection_information_rsp(const void *data, uint16_t size)
13795 {
13796         uint8_t address_type = get_u8(data + 6);
13797         int8_t rssi = get_s8(data + 7);
13798         int8_t tx_power = get_s8(data + 8);
13799         int8_t max_tx_power = get_s8(data + 9);
13800
13801         mgmt_print_address(data, address_type);
13802         print_rssi(rssi);
13803         print_power_level(tx_power, NULL);
13804         print_power_level(max_tx_power, "max");
13805 }
13806
13807 static void mgmt_get_clock_information_cmd(const void *data, uint16_t size)
13808 {
13809         uint8_t address_type = get_u8(data + 6);
13810
13811         mgmt_print_address(data, address_type);
13812 }
13813
13814 static void mgmt_get_clock_information_rsp(const void *data, uint16_t size)
13815 {
13816         uint8_t address_type = get_u8(data + 6);
13817         uint32_t local_clock = get_le32(data + 7);
13818         uint32_t piconet_clock = get_le32(data + 11);
13819         uint16_t accuracy = get_le16(data + 15);
13820
13821         mgmt_print_address(data, address_type);
13822         print_field("Local clock: 0x%8.8x", local_clock);
13823         print_field("Piconet clock: 0x%8.8x", piconet_clock);
13824         print_field("Accuracy: 0x%4.4x", accuracy);
13825 }
13826
13827 static void mgmt_add_device_cmd(const void *data, uint16_t size)
13828 {
13829         uint8_t address_type = get_u8(data + 6);
13830         uint8_t action = get_u8(data + 7);
13831
13832         mgmt_print_address(data, address_type);
13833         mgmt_print_device_action(action);
13834 }
13835
13836 static void mgmt_add_device_rsp(const void *data, uint16_t size)
13837 {
13838         uint8_t address_type = get_u8(data + 6);
13839
13840         mgmt_print_address(data, address_type);
13841 }
13842
13843 static void mgmt_remove_device_cmd(const void *data, uint16_t size)
13844 {
13845         uint8_t address_type = get_u8(data + 6);
13846
13847         mgmt_print_address(data, address_type);
13848 }
13849
13850 static void mgmt_remove_device_rsp(const void *data, uint16_t size)
13851 {
13852         uint8_t address_type = get_u8(data + 6);
13853
13854         mgmt_print_address(data, address_type);
13855 }
13856
13857 static void mgmt_load_connection_parameters_cmd(const void *data, uint16_t size)
13858 {
13859         uint16_t num_parameters = get_le16(data);
13860         int i;
13861
13862         print_field("Parameters: %u", num_parameters);
13863
13864         if (size - 2 != num_parameters * 15) {
13865                 packet_hexdump(data + 2, size - 2);
13866                 return;
13867         }
13868
13869         for (i = 0; i < num_parameters; i++)
13870                 mgmt_print_connection_parameter(data + 2 + (i * 15));
13871 }
13872
13873 static void mgmt_read_unconf_index_list_rsp(const void *data, uint16_t size)
13874 {
13875         uint16_t num_controllers = get_le16(data);
13876         int i;
13877
13878         print_field("Controllers: %u", num_controllers);
13879
13880         if (size - 2 != num_controllers * 2) {
13881                 packet_hexdump(data + 2, size - 2);
13882                 return;
13883         }
13884
13885         for (i = 0; i < num_controllers; i++) {
13886                 uint16_t index = get_le16(data + 2 + (i * 2));
13887
13888                 print_field("  hci%u", index);
13889         }
13890 }
13891
13892 static void mgmt_read_controller_conf_info_rsp(const void *data, uint16_t size)
13893 {
13894         uint16_t manufacturer = get_le16(data);
13895         uint32_t supported_options = get_le32(data + 2);
13896         uint32_t missing_options = get_le32(data + 6);
13897
13898         mgmt_print_manufacturer(manufacturer);
13899         mgmt_print_options("Supported options", supported_options);
13900         mgmt_print_options("Missing options", missing_options);
13901 }
13902
13903 static void mgmt_set_external_configuration_cmd(const void *data, uint16_t size)
13904 {
13905         uint8_t enable = get_u8(data);
13906
13907         print_enable("Configuration", enable);
13908 }
13909
13910 static void mgmt_set_public_address_cmd(const void *data, uint16_t size)
13911 {
13912         print_addr_resolve("Address", data, 0x00, false);
13913 }
13914
13915 static void mgmt_new_options_rsp(const void *data, uint16_t size)
13916 {
13917         uint32_t missing_options = get_le32(data);
13918
13919         mgmt_print_options("Missing options", missing_options);
13920 }
13921
13922 static void mgmt_start_service_discovery_cmd(const void *data, uint16_t size)
13923 {
13924         uint8_t type = get_u8(data);
13925         int8_t rssi = get_s8(data + 1);
13926         uint16_t num_uuids = get_le16(data + 2);
13927         int i;
13928
13929         mgmt_print_address_type(type);
13930         print_rssi(rssi);
13931         print_field("UUIDs: %u", num_uuids);
13932
13933         if (size - 4 != num_uuids * 16) {
13934                 packet_hexdump(data + 4, size - 4);
13935                 return;
13936         }
13937
13938         for (i = 0; i < num_uuids; i++)
13939                 print_field("UUID: %s", bt_uuid128_to_str(data + 4 + (i * 16)));
13940 }
13941
13942 static void mgmt_start_service_discovery_rsp(const void *data, uint16_t size)
13943 {
13944         uint8_t type = get_u8(data);
13945
13946         mgmt_print_address_type(type);
13947 }
13948
13949 static void mgmt_read_ext_index_list_rsp(const void *data, uint16_t size)
13950 {
13951         uint16_t num_controllers = get_le16(data);
13952         int i;
13953
13954         print_field("Controllers: %u", num_controllers);
13955
13956         if (size - 2 != num_controllers * 4) {
13957                 packet_hexdump(data + 2, size - 2);
13958                 return;
13959         }
13960
13961         for (i = 0; i < num_controllers; i++) {
13962                 uint16_t index = get_le16(data + 2 + (i * 4));
13963                 uint8_t type = get_u8(data + 4 + (i * 4));
13964                 uint8_t bus = get_u8(data + 5 + (i * 4));
13965                 const char *str;
13966
13967                 switch (type) {
13968                 case 0x00:
13969                         str = "Primary";
13970                         break;
13971                 case 0x01:
13972                         str = "Unconfigured";
13973                         break;
13974                 case 0x02:
13975                         str = "AMP";
13976                         break;
13977                 default:
13978                         str = "Reserved";
13979                         break;
13980                 }
13981
13982                 print_field("  hci%u (%s,%s)", index, str, hci_bustostr(bus));
13983         }
13984 }
13985
13986 static void mgmt_read_local_oob_ext_data_cmd(const void *data, uint16_t size)
13987 {
13988         uint8_t type = get_u8(data);
13989
13990         mgmt_print_address_type(type);
13991 }
13992
13993 static void mgmt_read_local_oob_ext_data_rsp(const void *data, uint16_t size)
13994 {
13995         uint8_t type = get_u8(data);
13996         uint16_t data_len = get_le16(data + 1);
13997
13998         mgmt_print_address_type(type);
13999         print_field("Data length: %u", data_len);
14000         print_eir(data + 3, size - 3, true);
14001 }
14002
14003 static void mgmt_read_advertising_features_rsp(const void *data, uint16_t size)
14004 {
14005         uint32_t flags = get_le32(data);
14006         uint8_t adv_data_len = get_u8(data + 4);
14007         uint8_t scan_rsp_len = get_u8(data + 5);
14008         uint8_t max_instances = get_u8(data + 6);
14009         uint8_t num_instances = get_u8(data + 7);
14010         int i;
14011
14012         mgmt_print_adv_flags(flags);
14013         print_field("Advertising data length: %u", adv_data_len);
14014         print_field("Scan response length: %u", scan_rsp_len);
14015         print_field("Max instances: %u", max_instances);
14016         print_field("Instances: %u", num_instances);
14017
14018         if (size - 8 != num_instances) {
14019                 packet_hexdump(data + 8, size - 8);
14020                 return;
14021         }
14022
14023         for (i = 0; i < num_instances; i++) {
14024                 uint8_t instance = get_u8(data + 8 + i);
14025
14026                 print_field("  %u", instance);
14027         }
14028 }
14029
14030 static void mgmt_add_advertising_cmd(const void *data, uint16_t size)
14031 {
14032         uint8_t instance = get_u8(data);
14033         uint32_t flags = get_le32(data + 1);
14034         uint16_t duration = get_le16(data + 5);
14035         uint16_t timeout = get_le16(data + 7);
14036         uint8_t adv_data_len = get_u8(data + 9);
14037         uint8_t scan_rsp_len = get_u8(data + 10);
14038
14039         print_field("Instance: %u", instance);
14040         mgmt_print_adv_flags(flags);
14041         print_field("Duration: %u", duration);
14042         print_field("Timeout: %u", timeout);
14043         print_field("Advertising data length: %u", adv_data_len);
14044         print_eir(data + 11, adv_data_len, false);
14045         print_field("Scan response length: %u", scan_rsp_len);
14046         print_eir(data + 11 + adv_data_len, scan_rsp_len, false);
14047 }
14048
14049 static void mgmt_add_advertising_rsp(const void *data, uint16_t size)
14050 {
14051         uint8_t instance = get_u8(data);
14052
14053         print_field("Instance: %u", instance);
14054 }
14055
14056 static void mgmt_remove_advertising_cmd(const void *data, uint16_t size)
14057 {
14058         uint8_t instance = get_u8(data);
14059
14060         print_field("Instance: %u", instance);
14061 }
14062
14063 static void mgmt_remove_advertising_rsp(const void *data, uint16_t size)
14064 {
14065         uint8_t instance = get_u8(data);
14066
14067         print_field("Instance: %u", instance);
14068 }
14069
14070 static void mgmt_get_advertising_size_info_cmd(const void *data, uint16_t size)
14071 {
14072         uint8_t instance = get_u8(data);
14073         uint32_t flags = get_le32(data + 1);
14074
14075         print_field("Instance: %u", instance);
14076         mgmt_print_adv_flags(flags);
14077 }
14078
14079 static void mgmt_get_advertising_size_info_rsp(const void *data, uint16_t size)
14080 {
14081         uint8_t instance = get_u8(data);
14082         uint32_t flags = get_le32(data + 1);
14083         uint8_t adv_data_len = get_u8(data + 5);
14084         uint8_t scan_rsp_len = get_u8(data + 6);
14085
14086         print_field("Instance: %u", instance);
14087         mgmt_print_adv_flags(flags);
14088         print_field("Advertising data length: %u", adv_data_len);
14089         print_field("Scan response length: %u", scan_rsp_len);
14090 }
14091
14092 static void mgmt_start_limited_discovery_cmd(const void *data, uint16_t size)
14093 {
14094         uint8_t type = get_u8(data);
14095
14096         mgmt_print_address_type(type);
14097 }
14098
14099 static void mgmt_start_limited_discovery_rsp(const void *data, uint16_t size)
14100 {
14101         uint8_t type = get_u8(data);
14102
14103         mgmt_print_address_type(type);
14104 }
14105
14106 static void mgmt_read_ext_controller_info_rsp(const void *data, uint16_t size)
14107 {
14108         uint8_t version = get_u8(data + 6);
14109         uint16_t manufacturer = get_le16(data + 7);
14110         uint32_t supported_settings = get_le32(data + 9);
14111         uint32_t current_settings = get_le32(data + 13);
14112         uint16_t data_len = get_le16(data + 17);
14113
14114         print_addr_resolve("Address", data, 0x00, false);
14115         mgmt_print_version(version);
14116         mgmt_print_manufacturer(manufacturer);
14117         mgmt_print_settings("Supported settings", supported_settings);
14118         mgmt_print_settings("Current settings", current_settings);
14119         print_field("Data length: %u", data_len);
14120         print_eir(data + 19, size - 19, false);
14121 }
14122
14123 static void mgmt_set_apperance_cmd(const void *data, uint16_t size)
14124 {
14125         uint16_t appearance = get_le16(data);
14126
14127         print_appearance(appearance);
14128 }
14129
14130 static const struct bitfield_data mgmt_phy_table[] = {
14131         {  0, "BR 1M 1SLOT"     },
14132         {  1, "BR 1M 3SLOT"     },
14133         {  2, "BR 1M 5SLOT"     },
14134         {  3, "EDR 2M 1SLOT"    },
14135         {  4, "EDR 2M 3SLOT"    },
14136         {  5, "EDR 2M 5SLOT"    },
14137         {  6, "EDR 3M 1SLOT"    },
14138         {  7, "EDR 3M 3SLOT"    },
14139         {  8, "EDR 3M 5SLOT"    },
14140         {  9, "LE 1M TX"        },
14141         {  10, "LE 1M RX"       },
14142         {  11, "LE 2M TX"       },
14143         {  12, "LE 2M RX"       },
14144         {  13, "LE CODED TX"    },
14145         {  14, "LE CODED RX"    },
14146         { }
14147 };
14148
14149 static void mgmt_print_phys(const char *label, uint16_t phys)
14150 {
14151         uint16_t mask;
14152
14153         print_field("%s: 0x%4.4x", label, phys);
14154
14155         mask = print_bitfield(2, phys, mgmt_phy_table);
14156         if (mask)
14157                 print_text(COLOR_UNKNOWN_PHY, "  Unknown PHYs"
14158                                                         " (0x%8.8x)", mask);
14159 }
14160
14161 static void mgmt_get_phy_rsp(const void *data, uint16_t size)
14162 {
14163         uint32_t supported_phys = get_le32(data);
14164         uint32_t configurable_phys = get_le32(data + 4);
14165         uint32_t selected_phys = get_le32(data + 8);
14166
14167         mgmt_print_phys("Supported PHYs", supported_phys);
14168         mgmt_print_phys("Configurable PHYs", configurable_phys);
14169         mgmt_print_phys("Selected PHYs", selected_phys);
14170 }
14171
14172 static void mgmt_set_phy_cmd(const void *data, uint16_t size)
14173 {
14174         uint32_t selected_phys = get_le32(data);
14175
14176         mgmt_print_phys("Selected PHYs", selected_phys);
14177 }
14178
14179 static void mgmt_read_exp_features_info_rsp(const void *data, uint16_t size)
14180 {
14181         uint16_t num_features = get_le16(data);
14182         int i;
14183
14184         print_field("Features: %u", num_features);
14185
14186         if (size - 2 != num_features * 20) {
14187                 packet_hexdump(data + 2, size - 2);
14188                 return;
14189         }
14190
14191         for (i = 0; i < num_features; i++)
14192                 mgmt_print_exp_feature(data + 2 + (i * 20));
14193 }
14194
14195 static void mgmt_set_exp_feature_cmd(const void *data, uint16_t size)
14196 {
14197         uint8_t enable = get_u8(data + 16);
14198
14199         print_field("UUID: %s", bt_uuid128_to_str(data));
14200         print_enable("Action", enable);
14201 }
14202
14203 static void mgmt_set_exp_feature_rsp(const void *data, uint16_t size)
14204 {
14205         mgmt_print_exp_feature(data);
14206 }
14207
14208 static const struct bitfield_data mgmt_added_device_flags_table[] = {
14209         { 0, "Remote Wakeup"            },
14210         { 1, "Device Privacy Mode"      },
14211         { }
14212 };
14213
14214 static void mgmt_print_added_device_flags(char *label, uint32_t flags)
14215 {
14216         uint32_t mask;
14217
14218         print_field("%s: 0x%8.8x", label, flags);
14219         mask = print_bitfield(2, flags, mgmt_added_device_flags_table);
14220         if (mask)
14221                 print_text(COLOR_UNKNOWN_ADDED_DEVICE_FLAG,
14222                            "  Unknown Flags (0x%8.8x)", mask);
14223 }
14224
14225 static void mgmt_get_device_flags_cmd(const void *data, uint16_t size)
14226 {
14227         uint8_t type = get_u8(data + 6);
14228
14229         mgmt_print_address(data, type);
14230 }
14231
14232 static void mgmt_get_device_flags_rsp(const void *data, uint16_t size)
14233 {
14234         uint8_t type = get_u8(data + 6);
14235         uint32_t supported_flags = get_le32(data + 7);
14236         uint32_t current_flags = get_le32(data + 11);
14237
14238         mgmt_print_address(data, type);
14239         mgmt_print_added_device_flags("Supported Flags", supported_flags);
14240         mgmt_print_added_device_flags("Current Flags", current_flags);
14241 }
14242
14243 static void mgmt_set_device_flags_cmd(const void *data, uint16_t size)
14244 {
14245         uint8_t type = get_u8(data + 6);
14246         uint32_t current_flags = get_le32(data + 7);
14247
14248         mgmt_print_address(data, type);
14249         mgmt_print_added_device_flags("Current Flags", current_flags);
14250 }
14251
14252 static void mgmt_set_device_flags_rsp(const void *data, uint16_t size)
14253 {
14254         uint8_t type = get_u8(data + 6);
14255
14256         mgmt_print_address(data, type);
14257 }
14258 static void mgmt_add_ext_adv_params_cmd(const void *data, uint16_t size)
14259 {
14260         uint8_t instance = get_u8(data);
14261         uint32_t flags = get_le32(data + 1);
14262         uint16_t duration = get_le16(data + 5);
14263         uint16_t timeout = get_le16(data + 7);
14264         uint8_t *min_interval = (uint8_t *)(data + 9);
14265         uint8_t *max_interval = (uint8_t *)(data + 13);
14266         int8_t tx_power = get_s8(data + 17);
14267
14268         print_field("Instance: %u", instance);
14269         mgmt_print_adv_flags(flags);
14270         print_field("Duration: %u", duration);
14271         print_field("Timeout: %u", timeout);
14272         print_ext_slot_625("Min advertising interval", min_interval);
14273         print_ext_slot_625("Max advertising interval", max_interval);
14274         print_power_level(tx_power, NULL);
14275 }
14276
14277 static void mgmt_add_ext_adv_params_rsp(const void *data, uint16_t size)
14278 {
14279         uint8_t instance = get_u8(data);
14280         int8_t tx_power = get_s8(data + 1);
14281         uint8_t max_adv_data_len = get_u8(data+2);
14282         uint8_t max_scan_rsp_len = get_u8(data+3);
14283
14284         print_field("Instance: %u", instance);
14285         print_power_level(tx_power, NULL);
14286         print_field("Available adv data len: %u", max_adv_data_len);
14287         print_field("Available scan rsp data len: %u", max_scan_rsp_len);
14288 }
14289
14290 static void mgmt_add_ext_adv_data_cmd(const void *data, uint16_t size)
14291 {
14292         uint8_t instance = get_u8(data);
14293         uint8_t adv_data_len = get_u8(data + 1);
14294         uint8_t scan_rsp_len = get_u8(data + 2);
14295
14296         print_field("Instance: %u", instance);
14297         print_field("Advertising data length: %u", adv_data_len);
14298         print_eir(data + 3, adv_data_len, false);
14299         print_field("Scan response length: %u", scan_rsp_len);
14300         print_eir(data + 3 + adv_data_len, scan_rsp_len, false);
14301 }
14302
14303 static void mgmt_add_ext_adv_data_rsp(const void *data, uint16_t size)
14304 {
14305         uint8_t instance = get_u8(data);
14306
14307         print_field("Instance: %u", instance);
14308 }
14309
14310 static const struct bitfield_data mgmt_adv_monitor_features_table[] = {
14311         { 1, "OR Patterns"      },
14312         { }
14313 };
14314
14315 static void mgmt_print_adv_monitor_features(char *label, uint32_t flags)
14316 {
14317         uint32_t mask;
14318
14319         print_field("%s: 0x%8.8x", label, flags);
14320         mask = print_bitfield(2, flags, mgmt_adv_monitor_features_table);
14321         if (mask)
14322                 print_text(COLOR_UNKNOWN_ADVMON_FEATURES,
14323                            "  Unknown Flags (0x%8.8x)", mask);
14324 }
14325
14326 static void mgmt_print_adv_monitor_handles(const void *data, uint8_t len)
14327 {
14328         uint8_t idx = 0;
14329
14330         while (idx + 2 <= len) {
14331                 print_field("  Handle: %d", get_le16(data + idx));
14332                 idx += 2;
14333         }
14334 }
14335
14336 static void mgmt_read_adv_monitor_features_rsp(const void *data, uint16_t size)
14337 {
14338         uint32_t supported_features = get_le32(data);
14339         uint32_t enabled_features = get_le32(data + 4);
14340         uint16_t max_num_handles = get_le16(data + 8);
14341         uint8_t max_num_patterns = get_u8(data + 10);
14342         uint16_t num_handles = get_le16(data + 11);
14343
14344         mgmt_print_adv_monitor_features("Supported Features",
14345                                                         supported_features);
14346         mgmt_print_adv_monitor_features("Enabled Features",
14347                                                         enabled_features);
14348         print_field("Max number of handles: %d", max_num_handles);
14349         print_field("Max number of patterns: %d", max_num_patterns);
14350         print_field("Number of handles: %d", num_handles);
14351         mgmt_print_adv_monitor_handles(data + 13, size - 13);
14352 }
14353
14354 static void mgmt_print_adv_monitor_patterns(const void *data, uint8_t len)
14355 {
14356         uint8_t data_idx = 0, pattern_idx = 1;
14357
14358         /* Reference: struct mgmt_adv_pattern in lib/mgmt.h. */
14359         while (data_idx + 34 <= len) {
14360                 uint8_t ad_type = get_u8(data);
14361                 uint8_t offset = get_u8(data + 1);
14362                 uint8_t length = get_u8(data + 2);
14363
14364                 print_field("  Pattern %d:", pattern_idx);
14365                 print_field("    AD type: %d", ad_type);
14366                 print_field("    Offset: %d", offset);
14367                 print_field("    Length: %d", length);
14368                 if (length <= 31)
14369                         print_hex_field("    Value ", data + 3, length);
14370                 else
14371                         print_text(COLOR_ERROR, "    invalid length");
14372
14373                 pattern_idx += 1;
14374                 data_idx += 34;
14375                 data += 34;
14376         }
14377 }
14378
14379 static void mgmt_add_adv_monitor_patterns_cmd(const void *data, uint16_t size)
14380 {
14381         uint8_t pattern_count = get_u8(data);
14382
14383         print_field("Number of patterns: %d", pattern_count);
14384         mgmt_print_adv_monitor_patterns(data + 1, size - 1);
14385 }
14386
14387 static void mgmt_add_adv_monitor_patterns_rssi_cmd(const void *data,
14388                                                                 uint16_t size)
14389 {
14390         int8_t high_rssi = get_s8(data);
14391         uint16_t high_rssi_timeout = get_le16(data + 1);
14392         int8_t low_rssi = get_s8(data + 3);
14393         uint16_t low_rssi_timeout = get_le16(data + 4);
14394         uint8_t sampling_period = get_u8(data + 6);
14395         uint8_t pattern_count = get_u8(data + 7);
14396
14397         print_field("RSSI data:");
14398         print_field("  high threshold: %d dBm", high_rssi);
14399         print_field("  high timeout: %d seconds", high_rssi_timeout);
14400         print_field("  low threshold: %d dBm", low_rssi);
14401         print_field("  low timeout: %d seconds", low_rssi_timeout);
14402
14403         if (sampling_period == 0)
14404                 print_field("  sampling: propagate all (0x00)");
14405         else if (sampling_period == 0xff)
14406                 print_field("  sampling: just once (0xFF)");
14407         else
14408                 print_field("  sampling: every %d ms", 100 * sampling_period);
14409
14410         print_field("Number of patterns: %d", pattern_count);
14411         mgmt_print_adv_monitor_patterns(data + 8, size - 8);
14412 }
14413
14414 static void mgmt_add_adv_monitor_patterns_rsp(const void *data, uint16_t size)
14415 {
14416         uint16_t handle = get_le16(data);
14417
14418         print_field("Handle: %d", handle);
14419 }
14420
14421 static void mgmt_remove_adv_monitor_patterns_cmd(const void *data,
14422                                                                 uint16_t size)
14423 {
14424         uint16_t handle = get_le16(data);
14425
14426         print_field("Handle: %d", handle);
14427 }
14428
14429 static void mgmt_remove_adv_monitor_patterns_rsp(const void *data,
14430                                                                 uint16_t size)
14431 {
14432         uint16_t handle = get_le16(data);
14433
14434         print_field("Handle: %d", handle);
14435 }
14436
14437 static void mgmt_set_mesh_receiver_cmd(const void *data, uint16_t size)
14438 {
14439         uint8_t enable = get_u8(data);
14440         uint16_t window = get_le16(data + 1);
14441         uint16_t period = get_le16(data + 3);
14442         uint8_t num_ad_types = get_u8(data + 5);
14443         const uint8_t *ad_types = data + 6;
14444
14445         print_field("Enable: %d", enable);
14446         print_field("Window: %d", window);
14447         print_field("Period: %d", period);
14448         print_field("Num AD Types: %d", num_ad_types);
14449         size -= 6;
14450
14451         while (size--)
14452                 print_field("  AD Type: %d", *ad_types++);
14453 }
14454
14455 static void mgmt_read_mesh_features_rsp(const void *data, uint16_t size)
14456 {
14457         uint16_t index = get_le16(data);
14458         uint8_t max_handles = get_u8(data + 2);
14459         uint8_t used_handles = get_u8(data + 3);
14460         const uint8_t *handles = data + 4;
14461
14462         print_field("Index: %d", index);
14463         print_field("Max Handles: %d", max_handles);
14464         print_field("Used Handles: %d", used_handles);
14465         size -= 4;
14466
14467         while (size--)
14468                 print_field("  Used Handle: %d", *handles++);
14469 }
14470
14471 static void mgmt_mesh_send_cmd(const void *data, uint16_t size)
14472 {
14473         const uint8_t *addr = data;
14474         uint8_t addr_type = get_u8(data + 6);
14475         uint64_t instant = get_le64(data + 7);
14476         uint16_t delay = get_le16(data + 15);
14477         uint8_t cnt = get_u8(data + 17);
14478         uint8_t adv_data_len = get_u8(data + 18);
14479
14480         data += 19;
14481         size -= 19;
14482         print_bdaddr(addr);
14483         print_field("Addr Type: %d", addr_type);
14484         print_field("Instant: 0x%16.16" PRIx64, instant);
14485         print_field("Delay: %d", delay);
14486         print_field("Count: %d", cnt);
14487         print_field("Data Length: %d", adv_data_len);
14488         print_hex_field("Data", data, size);
14489 }
14490
14491 static void mgmt_mesh_send_rsp(const void *data, uint16_t size)
14492 {
14493         uint8_t handle = get_u8(data);
14494
14495         print_field("Handle: %d", handle);
14496 }
14497
14498 static void mgmt_mesh_send_cancel_cmd(const void *data, uint16_t size)
14499 {
14500         uint8_t handle = get_u8(data);
14501
14502         print_field("Handle: %d", handle);
14503 }
14504
14505 struct mgmt_data {
14506         uint16_t opcode;
14507         const char *str;
14508         void (*func) (const void *data, uint16_t size);
14509         uint16_t size;
14510         bool fixed;
14511         void (*rsp_func) (const void *data, uint16_t size);
14512         uint16_t rsp_size;
14513         bool rsp_fixed;
14514 };
14515
14516 static const struct mgmt_data mgmt_command_table[] = {
14517         { 0x0001, "Read Management Version Information",
14518                                 mgmt_null_cmd, 0, true,
14519                                 mgmt_read_version_info_rsp, 3, true },
14520         { 0x0002, "Read Management Supported Commands",
14521                                 mgmt_null_cmd, 0, true,
14522                                 mgmt_read_supported_commands_rsp, 4, false },
14523         { 0x0003, "Read Controller Index List",
14524                                 mgmt_null_cmd, 0, true,
14525                                 mgmt_read_index_list_rsp, 2, false },
14526         { 0x0004, "Read Controller Information",
14527                                 mgmt_null_cmd, 0, true,
14528                                 mgmt_read_controller_info_rsp, 280, true },
14529         { 0x0005, "Set Powered",
14530                                 mgmt_set_powered_cmd, 1, true,
14531                                 mgmt_new_settings_rsp, 4, true },
14532         { 0x0006, "Set Discoverable",
14533                                 mgmt_set_discoverable_cmd, 3, true,
14534                                 mgmt_new_settings_rsp, 4, true },
14535         { 0x0007, "Set Connectable",
14536                                 mgmt_set_connectable_cmd, 1, true,
14537                                 mgmt_new_settings_rsp, 4, true },
14538         { 0x0008, "Set Fast Connectable",
14539                                 mgmt_set_fast_connectable_cmd, 1, true,
14540                                 mgmt_new_settings_rsp, 4, true },
14541         { 0x0009, "Set Bondable",
14542                                 mgmt_set_bondable_cmd, 1, true,
14543                                 mgmt_new_settings_rsp, 4, true },
14544         { 0x000a, "Set Link Security",
14545                                 mgmt_set_link_security_cmd, 1, true,
14546                                 mgmt_new_settings_rsp, 4, true },
14547         { 0x000b, "Set Secure Simple Pairing",
14548                                 mgmt_set_secure_simple_pairing_cmd, 1, true,
14549                                 mgmt_new_settings_rsp, 4, true },
14550         { 0x000c, "Set High Speed",
14551                                 mgmt_set_high_speed_cmd, 1, true,
14552                                 mgmt_new_settings_rsp, 4, true },
14553         { 0x000d, "Set Low Energy",
14554                                 mgmt_set_low_energy_cmd, 1, true,
14555                                 mgmt_new_settings_rsp, 4, true },
14556         { 0x000e, "Set Device Class",
14557                                 mgmt_set_device_class_cmd, 2, true,
14558                                 mgmt_set_device_class_rsp, 3, true },
14559         { 0x000f, "Set Local Name",
14560                                 mgmt_set_local_name_cmd, 260, true,
14561                                 mgmt_set_local_name_rsp, 260, true },
14562         { 0x0010, "Add UUID",
14563                                 mgmt_add_uuid_cmd, 17, true,
14564                                 mgmt_add_uuid_rsp, 3, true },
14565         { 0x0011, "Remove UUID",
14566                                 mgmt_remove_uuid_cmd, 16, true,
14567                                 mgmt_remove_uuid_rsp, 3, true },
14568         { 0x0012, "Load Link Keys",
14569                                 mgmt_load_link_keys_cmd, 3, false,
14570                                 mgmt_null_rsp, 0, true },
14571         { 0x0013, "Load Long Term Keys",
14572                                 mgmt_load_long_term_keys_cmd, 2, false,
14573                                 mgmt_null_rsp, 0, true },
14574         { 0x0014, "Disconnect",
14575                                 mgmt_disconnect_cmd, 7, true,
14576                                 mgmt_disconnect_rsp, 7, true },
14577         { 0x0015, "Get Connections",
14578                                 mgmt_null_cmd, 0, true,
14579                                 mgmt_get_connections_rsp, 2, false },
14580         { 0x0016, "PIN Code Reply",
14581                                 mgmt_pin_code_reply_cmd, 24, true,
14582                                 mgmt_pin_code_reply_rsp, 7, true },
14583         { 0x0017, "PIN Code Negative Reply",
14584                                 mgmt_pin_code_neg_reply_cmd, 7, true,
14585                                 mgmt_pin_code_neg_reply_rsp, 7, true },
14586         { 0x0018, "Set IO Capability",
14587                                 mgmt_set_io_capability_cmd, 1, true,
14588                                 mgmt_null_rsp, 0, true },
14589         { 0x0019, "Pair Device",
14590                                 mgmt_pair_device_cmd, 8, true,
14591                                 mgmt_pair_device_rsp, 7, true },
14592         { 0x001a, "Cancel Pair Device",
14593                                 mgmt_cancel_pair_device_cmd, 7, true,
14594                                 mgmt_cancel_pair_device_rsp, 7, true },
14595         { 0x001b, "Unpair Device",
14596                                 mgmt_unpair_device_cmd, 8, true,
14597                                 mgmt_unpair_device_rsp, 7, true },
14598         { 0x001c, "User Confirmation Reply",
14599                                 mgmt_user_confirmation_reply_cmd, 7, true,
14600                                 mgmt_user_confirmation_reply_rsp, 7, true },
14601         { 0x001d, "User Confirmation Negative Reply",
14602                                 mgmt_user_confirmation_neg_reply_cmd, 7, true,
14603                                 mgmt_user_confirmation_neg_reply_rsp, 7, true },
14604         { 0x001e, "User Passkey Reply",
14605                                 mgmt_user_passkey_reply_cmd, 11, true,
14606                                 mgmt_user_passkey_reply_rsp, 7, true },
14607         { 0x001f, "User Passkey Negative Reply",
14608                                 mgmt_user_passkey_neg_reply_cmd, 7, true,
14609                                 mgmt_user_passkey_neg_reply_rsp, 7, true },
14610         { 0x0020, "Read Local Out Of Band Data",
14611                                 mgmt_null_cmd, 0, true,
14612                                 mgmt_read_local_oob_data_rsp, 64, true },
14613         { 0x0021, "Add Remote Out Of Band Data",
14614                                 mgmt_add_remote_oob_data_cmd, 71, true,
14615                                 mgmt_add_remote_oob_data_rsp, 7, true },
14616         { 0x0022, "Remove Remote Out Of Band Data",
14617                                 mgmt_remove_remote_oob_data_cmd, 7, true,
14618                                 mgmt_remove_remote_oob_data_rsp, 7, true },
14619         { 0x0023, "Start Discovery",
14620                                 mgmt_start_discovery_cmd, 1, true,
14621                                 mgmt_start_discovery_rsp, 1, true },
14622         { 0x0024, "Stop Discovery",
14623                                 mgmt_stop_discovery_cmd, 1, true,
14624                                 mgmt_stop_discovery_rsp, 1, true },
14625         { 0x0025, "Confirm Name",
14626                                 mgmt_confirm_name_cmd, 8, true,
14627                                 mgmt_confirm_name_rsp, 7, true },
14628         { 0x0026, "Block Device",
14629                                 mgmt_block_device_cmd, 7, true,
14630                                 mgmt_block_device_rsp, 7, true },
14631         { 0x0027, "Unblock Device",
14632                                 mgmt_unblock_device_cmd, 7, true,
14633                                 mgmt_unblock_device_rsp, 7, true },
14634         { 0x0028, "Set Device ID",
14635                                 mgmt_set_device_id_cmd, 8, true,
14636                                 mgmt_null_rsp, 0, true },
14637         { 0x0029, "Set Advertising",
14638                                 mgmt_set_advertising_cmd, 1, true,
14639                                 mgmt_new_settings_rsp, 4, true },
14640         { 0x002a, "Set BR/EDR",
14641                                 mgmt_set_bredr_cmd, 1, true,
14642                                 mgmt_new_settings_rsp, 4, true },
14643         { 0x002b, "Set Static Address",
14644                                 mgmt_set_static_address_cmd, 6, true,
14645                                 mgmt_new_settings_rsp, 4, true },
14646         { 0x002c, "Set Scan Parameters",
14647                                 mgmt_set_scan_parameters_cmd, 4, true,
14648                                 mgmt_null_rsp, 0, true },
14649         { 0x002d, "Set Secure Connections",
14650                                 mgmt_set_secure_connections_cmd, 1, true,
14651                                 mgmt_new_settings_rsp, 4, true },
14652         { 0x002e, "Set Debug Keys",
14653                                 mgmt_set_debug_keys_cmd, 1, true,
14654                                 mgmt_new_settings_rsp, 4, true },
14655         { 0x002f, "Set Privacy",
14656                                 mgmt_set_privacy_cmd, 17, true,
14657                                 mgmt_new_settings_rsp, 4, true },
14658         { 0x0030, "Load Identity Resolving Keys",
14659                                 mgmt_load_identity_resolving_keys_cmd, 2, false,
14660                                 mgmt_null_rsp, 0, true },
14661         { 0x0031, "Get Connection Information",
14662                                 mgmt_get_connection_information_cmd, 7, true,
14663                                 mgmt_get_connection_information_rsp, 10, true },
14664         { 0x0032, "Get Clock Information",
14665                                 mgmt_get_clock_information_cmd, 7, true,
14666                                 mgmt_get_clock_information_rsp, 17, true },
14667         { 0x0033, "Add Device",
14668                                 mgmt_add_device_cmd, 8, true,
14669                                 mgmt_add_device_rsp, 7, true },
14670         { 0x0034, "Remove Device",
14671                                 mgmt_remove_device_cmd, 7, true,
14672                                 mgmt_remove_device_rsp, 7, true },
14673         { 0x0035, "Load Connection Parameters",
14674                                 mgmt_load_connection_parameters_cmd, 2, false,
14675                                 mgmt_null_rsp, 0, true },
14676         { 0x0036, "Read Unconfigured Controller Index List",
14677                                 mgmt_null_cmd, 0, true,
14678                                 mgmt_read_unconf_index_list_rsp, 2, false },
14679         { 0x0037, "Read Controller Configuration Information",
14680                                 mgmt_null_cmd, 0, true,
14681                                 mgmt_read_controller_conf_info_rsp, 10, true },
14682         { 0x0038, "Set External Configuration",
14683                                 mgmt_set_external_configuration_cmd, 1, true,
14684                                 mgmt_new_options_rsp, 4, true },
14685         { 0x0039, "Set Public Address",
14686                                 mgmt_set_public_address_cmd, 6, true,
14687                                 mgmt_new_options_rsp, 4, true },
14688         { 0x003a, "Start Service Discovery",
14689                                 mgmt_start_service_discovery_cmd, 3, false,
14690                                 mgmt_start_service_discovery_rsp, 1, true },
14691         { 0x003b, "Read Local Out Of Band Extended Data",
14692                                 mgmt_read_local_oob_ext_data_cmd, 1, true,
14693                                 mgmt_read_local_oob_ext_data_rsp, 3, false },
14694         { 0x003c, "Read Extended Controller Index List",
14695                                 mgmt_null_cmd, 0, true,
14696                                 mgmt_read_ext_index_list_rsp, 2, false },
14697         { 0x003d, "Read Advertising Features",
14698                                 mgmt_null_cmd, 0, true,
14699                                 mgmt_read_advertising_features_rsp, 8, false },
14700         { 0x003e, "Add Advertising",
14701                                 mgmt_add_advertising_cmd, 11, false,
14702                                 mgmt_add_advertising_rsp, 1, true },
14703         { 0x003f, "Remove Advertising",
14704                                 mgmt_remove_advertising_cmd, 1, true,
14705                                 mgmt_remove_advertising_rsp, 1, true },
14706         { 0x0040, "Get Advertising Size Information",
14707                                 mgmt_get_advertising_size_info_cmd, 5, true,
14708                                 mgmt_get_advertising_size_info_rsp, 7, true },
14709         { 0x0041, "Start Limited Discovery",
14710                                 mgmt_start_limited_discovery_cmd, 1, true,
14711                                 mgmt_start_limited_discovery_rsp, 1, true },
14712         { 0x0042, "Read Extended Controller Information",
14713                                 mgmt_null_cmd, 0, true,
14714                                 mgmt_read_ext_controller_info_rsp, 19, false },
14715         { 0x0043, "Set Appearance",
14716                                 mgmt_set_apperance_cmd, 2, true,
14717                                 mgmt_null_rsp, 0, true },
14718         { 0x0044, "Get PHY Configuration",
14719                                 mgmt_null_cmd, 0, true,
14720                                 mgmt_get_phy_rsp, 12, true },
14721         { 0x0045, "Set PHY Configuration",
14722                                 mgmt_set_phy_cmd, 4, true,
14723                                 mgmt_null_rsp, 0, true },
14724         { 0x0046, "Load Blocked Keys" },
14725         { 0x0047, "Set Wideband Speech" },
14726         { 0x0048, "Read Controller Capabilities" },
14727         { 0x0049, "Read Experimental Features Information",
14728                                 mgmt_null_cmd, 0, true,
14729                                 mgmt_read_exp_features_info_rsp, 2, false },
14730         { 0x004a, "Set Experimental Feature",
14731                                 mgmt_set_exp_feature_cmd, 17, true,
14732                                 mgmt_set_exp_feature_rsp, 20, true },
14733         { 0x004b, "Read Default System Configuration" },
14734         { 0x004c, "Set Default System Configuration" },
14735         { 0x004d, "Read Default Runtime Configuration" },
14736         { 0x004e, "Set Default Runtime Configuration" },
14737         { 0x004f, "Get Device Flags",
14738                                 mgmt_get_device_flags_cmd, 7, true,
14739                                 mgmt_get_device_flags_rsp, 15, true},
14740         { 0x0050, "Set Device Flags",
14741                                 mgmt_set_device_flags_cmd, 11, true,
14742                                 mgmt_set_device_flags_rsp, 7, true},
14743         { 0x0051, "Read Advertisement Monitor Features",
14744                                 mgmt_null_cmd, 0, true,
14745                                 mgmt_read_adv_monitor_features_rsp, 13, false},
14746         { 0x0052, "Add Advertisement Patterns Monitor",
14747                                 mgmt_add_adv_monitor_patterns_cmd, 1, false,
14748                                 mgmt_add_adv_monitor_patterns_rsp, 2, true},
14749         { 0x0053, "Remove Advertisement Monitor",
14750                                 mgmt_remove_adv_monitor_patterns_cmd, 2, true,
14751                                 mgmt_remove_adv_monitor_patterns_rsp, 2, true},
14752         { 0x0054, "Add Extended Advertising Parameters",
14753                                 mgmt_add_ext_adv_params_cmd, 18, false,
14754                                 mgmt_add_ext_adv_params_rsp, 4, true },
14755         { 0x0055, "Add Extended Advertising Data",
14756                                 mgmt_add_ext_adv_data_cmd, 3, false,
14757                                 mgmt_add_ext_adv_data_rsp, 1, true },
14758         { 0x0056, "Add Advertisement Patterns Monitor With RSSI Threshold",
14759                                 mgmt_add_adv_monitor_patterns_rssi_cmd, 8,
14760                                                                         false,
14761                                 mgmt_add_adv_monitor_patterns_rsp, 2, true},
14762         { 0x0057, "Set Mesh Receiver",
14763                                 mgmt_set_mesh_receiver_cmd, 6, false,
14764                                 mgmt_null_rsp, 0, true},
14765         { 0x0058, "Read Mesh Features",
14766                                 mgmt_null_cmd, 0, true,
14767                                 mgmt_read_mesh_features_rsp, 4, false},
14768         { 0x0059, "Mesh Send",
14769                                 mgmt_mesh_send_cmd, 19, false,
14770                                 mgmt_mesh_send_rsp, 1, true},
14771         { 0x0056, "Mesh Send Cancel",
14772                                 mgmt_mesh_send_cancel_cmd, 1, true,
14773                                 mgmt_null_rsp, 0, true},
14774         { }
14775 };
14776
14777 static void mgmt_null_evt(const void *data, uint16_t size)
14778 {
14779 }
14780
14781 static void mgmt_command_complete_evt(const void *data, uint16_t size)
14782 {
14783         uint16_t opcode;
14784         uint8_t status;
14785         const struct mgmt_data *mgmt_data = NULL;
14786         const char *mgmt_color, *mgmt_str;
14787         int i;
14788
14789         opcode = get_le16(data);
14790         status = get_u8(data + 2);
14791
14792         data += 3;
14793         size -= 3;
14794
14795         for (i = 0; mgmt_command_table[i].str; i++) {
14796                 if (mgmt_command_table[i].opcode == opcode) {
14797                         mgmt_data = &mgmt_command_table[i];
14798                         break;
14799                 }
14800         }
14801
14802         if (mgmt_data) {
14803                 if (mgmt_data->rsp_func)
14804                         mgmt_color = COLOR_CTRL_COMMAND;
14805                 else
14806                         mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14807                 mgmt_str = mgmt_data->str;
14808         } else {
14809                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14810                 mgmt_str = "Unknown";
14811         }
14812
14813         print_indent(6, mgmt_color, "", mgmt_str, COLOR_OFF,
14814                                         " (0x%4.4x) plen %u", opcode, size);
14815
14816         mgmt_print_status(status);
14817
14818         if (!mgmt_data || !mgmt_data->rsp_func) {
14819                 packet_hexdump(data, size);
14820                 return;
14821         }
14822
14823         if (mgmt_data->rsp_fixed) {
14824                 if (size != mgmt_data->rsp_size) {
14825                         print_text(COLOR_ERROR, "invalid packet size");
14826                         packet_hexdump(data, size);
14827                         return;
14828                 }
14829         } else {
14830                 if (size < mgmt_data->rsp_size) {
14831                         print_text(COLOR_ERROR, "too short packet");
14832                         packet_hexdump(data, size);
14833                         return;
14834                 }
14835         }
14836
14837         mgmt_data->rsp_func(data, size);
14838 }
14839
14840 static void mgmt_command_status_evt(const void *data, uint16_t size)
14841 {
14842         uint16_t opcode;
14843         uint8_t status;
14844         const struct mgmt_data *mgmt_data = NULL;
14845         const char *mgmt_color, *mgmt_str;
14846         int i;
14847
14848         opcode = get_le16(data);
14849         status = get_u8(data + 2);
14850
14851         for (i = 0; mgmt_command_table[i].str; i++) {
14852                 if (mgmt_command_table[i].opcode == opcode) {
14853                         mgmt_data = &mgmt_command_table[i];
14854                         break;
14855                 }
14856         }
14857
14858         if (mgmt_data) {
14859                 mgmt_color = COLOR_CTRL_COMMAND;
14860                 mgmt_str = mgmt_data->str;
14861         } else {
14862                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14863                 mgmt_str = "Unknown";
14864         }
14865
14866         print_indent(6, mgmt_color, "", mgmt_str, COLOR_OFF,
14867                                                 " (0x%4.4x)", opcode);
14868
14869         mgmt_print_status(status);
14870 }
14871
14872 static void mgmt_controller_error_evt(const void *data, uint16_t size)
14873 {
14874         uint8_t error = get_u8(data);
14875
14876         print_field("Error: 0x%2.2x", error);
14877 }
14878
14879 static void mgmt_new_settings_evt(const void *data, uint16_t size)
14880 {
14881         uint32_t settings = get_le32(data);
14882
14883         mgmt_print_settings("Current settings", settings);
14884 }
14885
14886 static void mgmt_class_of_dev_changed_evt(const void *data, uint16_t size)
14887 {
14888         print_dev_class(data);
14889 }
14890
14891 static void mgmt_local_name_changed_evt(const void *data, uint16_t size)
14892 {
14893         mgmt_print_name(data);
14894 }
14895
14896 static void mgmt_new_link_key_evt(const void *data, uint16_t size)
14897 {
14898         uint8_t store_hint = get_u8(data);
14899
14900         mgmt_print_store_hint(store_hint);
14901         mgmt_print_link_key(data + 1);
14902 }
14903
14904 static void mgmt_new_long_term_key_evt(const void *data, uint16_t size)
14905 {
14906         uint8_t store_hint = get_u8(data);
14907
14908         mgmt_print_store_hint(store_hint);
14909         mgmt_print_long_term_key(data + 1);
14910 }
14911
14912 static void mgmt_device_connected_evt(const void *data, uint16_t size)
14913 {
14914         uint8_t address_type = get_u8(data + 6);
14915         uint32_t flags = get_le32(data + 7);
14916         uint16_t data_len = get_le16(data + 11);
14917
14918         mgmt_print_address(data, address_type);
14919         mgmt_print_device_flags(flags);
14920         print_field("Data length: %u", data_len);
14921         print_eir(data + 13, size - 13, false);
14922 }
14923
14924 static void mgmt_device_disconnected_evt(const void *data, uint16_t size)
14925 {
14926         uint8_t address_type = get_u8(data + 6);
14927         uint8_t reason = get_u8(data + 7);
14928         const char *str;
14929
14930         mgmt_print_address(data, address_type);
14931
14932         switch (reason) {
14933         case 0x00:
14934                 str = "Unspecified";
14935                 break;
14936         case 0x01:
14937                 str = "Connection timeout";
14938                 break;
14939         case 0x02:
14940                 str = "Connection terminated by local host";
14941                 break;
14942         case 0x03:
14943                 str = "Connection terminated by remote host";
14944                 break;
14945         case 0x04:
14946                 str = "Connection terminated due to authentication failure";
14947                 break;
14948         case 0x05:
14949                 str = "Connection terminated by local host for suspend";
14950                 break;
14951         default:
14952                 str = "Reserved";
14953                 break;
14954         }
14955
14956         print_field("Reason: %s (0x%2.2x)", str, reason);
14957 }
14958
14959 static void mgmt_connect_failed_evt(const void *data, uint16_t size)
14960 {
14961         uint8_t address_type = get_u8(data + 6);
14962         uint8_t status = get_u8(data + 7);
14963
14964         mgmt_print_address(data, address_type);
14965         mgmt_print_status(status);
14966 }
14967
14968 static void mgmt_pin_code_request_evt(const void *data, uint16_t size)
14969 {
14970         uint8_t address_type = get_u8(data + 6);
14971         uint8_t secure_pin = get_u8(data + 7);
14972
14973         mgmt_print_address(data, address_type);
14974         print_field("Secure PIN: 0x%2.2x", secure_pin);
14975 }
14976
14977 static void mgmt_user_confirmation_request_evt(const void *data, uint16_t size)
14978 {
14979         uint8_t address_type = get_u8(data + 6);
14980         uint8_t confirm_hint = get_u8(data + 7);
14981         uint32_t value = get_le32(data + 8);
14982
14983         mgmt_print_address(data, address_type);
14984         print_field("Confirm hint: 0x%2.2x", confirm_hint);
14985         print_field("Value: 0x%8.8x", value);
14986 }
14987
14988 static void mgmt_user_passkey_request_evt(const void *data, uint16_t size)
14989 {
14990         uint8_t address_type = get_u8(data + 6);
14991
14992         mgmt_print_address(data, address_type);
14993 }
14994
14995 static void mgmt_authentication_failed_evt(const void *data, uint16_t size)
14996 {
14997         uint8_t address_type = get_u8(data + 6);
14998         uint8_t status = get_u8(data + 7);
14999
15000         mgmt_print_address(data, address_type);
15001         mgmt_print_status(status);
15002 }
15003
15004 static void mgmt_device_found_evt(const void *data, uint16_t size)
15005 {
15006         uint8_t address_type = get_u8(data + 6);
15007         int8_t rssi = get_s8(data + 7);
15008         uint32_t flags = get_le32(data + 8);
15009         uint16_t data_len = get_le16(data + 12);
15010
15011         mgmt_print_address(data, address_type);
15012         print_rssi(rssi);
15013         mgmt_print_device_flags(flags);
15014         print_field("Data length: %u", data_len);
15015         print_eir(data + 14, size - 14, false);
15016 }
15017
15018 static void mgmt_discovering_evt(const void *data, uint16_t size)
15019 {
15020         uint8_t type = get_u8(data);
15021         uint8_t enable = get_u8(data + 1);
15022
15023         mgmt_print_address_type(type);
15024         print_enable("Discovery", enable);
15025 }
15026
15027 static void mgmt_device_blocked_evt(const void *data, uint16_t size)
15028 {
15029         uint8_t address_type = get_u8(data + 6);
15030
15031         mgmt_print_address(data, address_type);
15032 }
15033
15034 static void mgmt_device_unblocked_evt(const void *data, uint16_t size)
15035 {
15036         uint8_t address_type = get_u8(data + 6);
15037
15038         mgmt_print_address(data, address_type);
15039 }
15040
15041 static void mgmt_device_unpaired_evt(const void *data, uint16_t size)
15042 {
15043         uint8_t address_type = get_u8(data + 6);
15044
15045         mgmt_print_address(data, address_type);
15046 }
15047
15048 static void mgmt_passkey_notify_evt(const void *data, uint16_t size)
15049 {
15050         uint8_t address_type = get_u8(data + 6);
15051         uint32_t passkey = get_le32(data + 7);
15052         uint8_t entered = get_u8(data + 11);
15053
15054         mgmt_print_address(data, address_type);
15055         print_field("Passkey: 0x%8.8x", passkey);
15056         print_field("Entered: %u", entered);
15057 }
15058
15059 static void mgmt_new_identity_resolving_key_evt(const void *data, uint16_t size)
15060 {
15061         uint8_t store_hint = get_u8(data);
15062
15063         mgmt_print_store_hint(store_hint);
15064         print_addr_resolve("Random address", data + 1, 0x01, false);
15065         mgmt_print_identity_resolving_key(data + 7);
15066 }
15067
15068 static void mgmt_new_signature_resolving_key_evt(const void *data, uint16_t size)
15069 {
15070         uint8_t store_hint = get_u8(data);
15071
15072         mgmt_print_store_hint(store_hint);
15073         mgmt_print_signature_resolving_key(data + 1);
15074 }
15075
15076 static void mgmt_device_added_evt(const void *data, uint16_t size)
15077 {
15078         uint8_t address_type = get_u8(data + 6);
15079         uint8_t action = get_u8(data + 7);
15080
15081         mgmt_print_address(data, address_type);
15082         mgmt_print_device_action(action);
15083 }
15084
15085 static void mgmt_device_removed_evt(const void *data, uint16_t size)
15086 {
15087         uint8_t address_type = get_u8(data + 6);
15088
15089         mgmt_print_address(data, address_type);
15090 }
15091
15092 static void mgmt_new_connection_parameter_evt(const void *data, uint16_t size)
15093 {
15094         uint8_t store_hint = get_u8(data);
15095
15096         mgmt_print_store_hint(store_hint);
15097         mgmt_print_connection_parameter(data + 1);
15098 }
15099
15100 static void mgmt_new_conf_options_evt(const void *data, uint16_t size)
15101 {
15102         uint32_t missing_options = get_le32(data);
15103
15104         mgmt_print_options("Missing options", missing_options);
15105 }
15106
15107 static void mgmt_ext_index_added_evt(const void *data, uint16_t size)
15108 {
15109         uint8_t type = get_u8(data);
15110         uint8_t bus = get_u8(data + 1);
15111
15112         print_field("type 0x%2.2x - bus 0x%2.2x", type, bus);
15113 }
15114
15115 static void mgmt_ext_index_removed_evt(const void *data, uint16_t size)
15116 {
15117         uint8_t type = get_u8(data);
15118         uint8_t bus = get_u8(data + 1);
15119
15120         print_field("type 0x%2.2x - bus 0x%2.2x", type, bus);
15121 }
15122
15123 static void mgmt_local_oob_ext_data_updated_evt(const void *data, uint16_t size)
15124 {
15125         uint8_t type = get_u8(data);
15126         uint16_t data_len = get_le16(data + 1);
15127
15128         mgmt_print_address_type(type);
15129         print_field("Data length: %u", data_len);
15130         print_eir(data + 3, size - 3, true);
15131 }
15132
15133 static void mgmt_advertising_added_evt(const void *data, uint16_t size)
15134 {
15135         uint8_t instance = get_u8(data);
15136
15137         print_field("Instance: %u", instance);
15138 }
15139
15140 static void mgmt_advertising_removed_evt(const void *data, uint16_t size)
15141 {
15142         uint8_t instance = get_u8(data);
15143
15144         print_field("Instance: %u", instance);
15145 }
15146
15147 static void mgmt_ext_controller_info_changed_evt(const void *data, uint16_t size)
15148 {
15149         uint16_t data_len = get_le16(data);
15150
15151         print_field("Data length: %u", data_len);
15152         print_eir(data + 2, size - 2, false);
15153 }
15154
15155 static void mgmt_phy_changed_evt(const void *data, uint16_t size)
15156 {
15157         uint32_t selected_phys = get_le32(data);
15158
15159         mgmt_print_phys("Selected PHYs", selected_phys);
15160 }
15161
15162 static void mgmt_exp_feature_changed_evt(const void *data, uint16_t size)
15163 {
15164         mgmt_print_exp_feature(data);
15165 }
15166
15167 static void mgmt_device_flags_changed_evt(const void *data, uint16_t size)
15168 {
15169         uint8_t type = get_u8(data + 6);
15170         uint32_t supported_flags = get_le32(data + 7);
15171         uint32_t current_flags = get_le32(data + 11);
15172
15173         mgmt_print_address(data, type);
15174         mgmt_print_added_device_flags("Supported Flags", supported_flags);
15175         mgmt_print_added_device_flags("Current Flags", current_flags);
15176 }
15177
15178 static void mgmt_adv_monitor_added_evt(const void *data, uint16_t size)
15179 {
15180         uint16_t handle = get_le16(data);
15181
15182         print_field("Handle: %d", handle);
15183 }
15184
15185 static void mgmt_adv_monitor_removed_evt(const void *data, uint16_t size)
15186 {
15187         uint16_t handle = get_le16(data);
15188
15189         print_field("Handle: %d", handle);
15190 }
15191
15192 static void mgmt_controller_suspend_evt(const void *data, uint16_t size)
15193 {
15194         uint8_t state = get_u8(data);
15195         char *str;
15196
15197         switch (state) {
15198         case 0x0:
15199                 str = "Controller running (failed to suspend)";
15200                 break;
15201         case 0x1:
15202                 str = "Disconnected and not scanning";
15203                 break;
15204         case 0x2:
15205                 str = "Page scanning and/or passive scanning";
15206                 break;
15207         default:
15208                 str = "Unknown suspend state";
15209                 break;
15210         }
15211
15212         print_field("Suspend state: %s (%d)", str, state);
15213 }
15214
15215 static void mgmt_controller_resume_evt(const void *data, uint16_t size)
15216 {
15217         uint8_t addr_type = get_u8(data + 6);
15218         uint8_t wake_reason = get_u8(data + 7);
15219         char *str;
15220
15221         switch (wake_reason) {
15222         case 0x0:
15223                 str = "Resume from non-Bluetooth wake source";
15224                 break;
15225         case 0x1:
15226                 str = "Wake due to unexpected event";
15227                 break;
15228         case 0x2:
15229                 str = "Remote wake due to peer device connection";
15230                 break;
15231         default:
15232                 str = "Unknown wake reason";
15233                 break;
15234         }
15235
15236         print_field("Wake reason: %s (%d)", str, wake_reason);
15237         mgmt_print_address(data, addr_type);
15238 }
15239
15240 static void mgmt_adv_monitor_device_found_evt(const void *data, uint16_t size)
15241 {
15242         uint16_t handle = get_le16(data);
15243         const uint8_t *addr = data + 2;
15244         uint8_t addr_type = get_u8(data + 8);
15245         int8_t rssi = get_s8(data + 9);
15246         uint32_t flags = get_le32(data + 10);
15247         uint16_t ad_data_len = get_le16(data + 14);
15248         const uint8_t *ad_data = data + 16;
15249
15250         print_field("Handle: %d", handle);
15251         print_bdaddr(addr);
15252         print_field("Addr Type: %d", addr_type);
15253         print_field("RSSI: %d", rssi);
15254         mgmt_print_device_flags(flags);
15255         print_field("AD Data Len: %d", ad_data_len);
15256         size -= 16;
15257         print_hex_field("AD Data", ad_data, size);
15258 }
15259
15260 static void mgmt_adv_monitor_device_lost_evt(const void *data, uint16_t size)
15261 {
15262         uint16_t handle = get_le16(data);
15263         const uint8_t *addr = data + 2;
15264         uint8_t addr_type = get_u8(data + 8);
15265
15266         print_field("Handle: %d", handle);
15267         print_bdaddr(addr);
15268         print_field("Addr Type: %d", addr_type);
15269 }
15270
15271 static void mgmt_mesh_device_found_evt(const void *data, uint16_t size)
15272 {
15273         const uint8_t *addr = data;
15274         uint8_t addr_type = get_u8(data + 6);
15275         int8_t rssi = get_s8(data + 7);
15276         uint64_t instant = get_le64(data + 8);
15277         uint32_t flags = get_le32(data + 16);
15278         uint16_t eir_len = get_le16(data + 20);
15279         const uint8_t *eir_data = data + 22;
15280
15281         print_bdaddr(addr);
15282         print_field("Addr Type: %d", addr_type);
15283         print_field("RSSI: %d", rssi);
15284         print_field("Instant: 0x%16.16" PRIx64, instant);
15285         mgmt_print_device_flags(flags);
15286         print_field("EIR Length: %d", eir_len);
15287         size -= 22;
15288         print_hex_field("EIR Data", eir_data, size);
15289 }
15290
15291 static void mgmt_mesh_packet_cmplt_evt(const void *data, uint16_t size)
15292 {
15293         uint8_t handle = get_u8(data);
15294
15295         print_field("Handle: %d", handle);
15296 }
15297
15298 static const struct mgmt_data mgmt_event_table[] = {
15299         { 0x0001, "Command Complete",
15300                         mgmt_command_complete_evt, 3, false },
15301         { 0x0002, "Command Status",
15302                         mgmt_command_status_evt, 3, true },
15303         { 0x0003, "Controller Error",
15304                         mgmt_controller_error_evt, 1, true },
15305         { 0x0004, "Index Added",
15306                         mgmt_null_evt, 0, true },
15307         { 0x0005, "Index Removed",
15308                         mgmt_null_evt, 0, true },
15309         { 0x0006, "New Settings",
15310                         mgmt_new_settings_evt, 4, true },
15311         { 0x0007, "Class Of Device Changed",
15312                         mgmt_class_of_dev_changed_evt, 3, true },
15313         { 0x0008, "Local Name Changed",
15314                         mgmt_local_name_changed_evt, 260, true },
15315         { 0x0009, "New Link Key",
15316                         mgmt_new_link_key_evt, 26, true },
15317         { 0x000a, "New Long Term Key",
15318                         mgmt_new_long_term_key_evt, 37, true },
15319         { 0x000b, "Device Connected",
15320                         mgmt_device_connected_evt, 13, false },
15321         { 0x000c, "Device Disconnected",
15322                         mgmt_device_disconnected_evt, 8, true },
15323         { 0x000d, "Connect Failed",
15324                         mgmt_connect_failed_evt, 8, true },
15325         { 0x000e, "PIN Code Request",
15326                         mgmt_pin_code_request_evt, 8, true },
15327         { 0x000f, "User Confirmation Request",
15328                         mgmt_user_confirmation_request_evt, 12, true },
15329         { 0x0010, "User Passkey Request",
15330                         mgmt_user_passkey_request_evt, 7, true },
15331         { 0x0011, "Authentication Failed",
15332                         mgmt_authentication_failed_evt, 8, true },
15333         { 0x0012, "Device Found",
15334                         mgmt_device_found_evt, 14, false },
15335         { 0x0013, "Discovering",
15336                         mgmt_discovering_evt, 2, true },
15337         { 0x0014, "Device Blocked",
15338                         mgmt_device_blocked_evt, 7, true },
15339         { 0x0015, "Device Unblocked",
15340                         mgmt_device_unblocked_evt, 7, true },
15341         { 0x0016, "Device Unpaired",
15342                         mgmt_device_unpaired_evt, 7, true },
15343         { 0x0017, "Passkey Notify",
15344                         mgmt_passkey_notify_evt, 12, true },
15345         { 0x0018, "New Identity Resolving Key",
15346                         mgmt_new_identity_resolving_key_evt, 30, true },
15347         { 0x0019, "New Signature Resolving Key",
15348                         mgmt_new_signature_resolving_key_evt, 25, true },
15349         { 0x001a, "Device Added",
15350                         mgmt_device_added_evt, 8, true },
15351         { 0x001b, "Device Removed",
15352                         mgmt_device_removed_evt, 7, true },
15353         { 0x001c, "New Connection Parameter",
15354                         mgmt_new_connection_parameter_evt, 16, true },
15355         { 0x001d, "Unconfigured Index Added",
15356                         mgmt_null_evt, 0, true },
15357         { 0x001e, "Unconfigured Index Removed",
15358                         mgmt_null_evt, 0, true },
15359         { 0x001f, "New Configuration Options",
15360                         mgmt_new_conf_options_evt, 4, true },
15361         { 0x0020, "Extended Index Added",
15362                         mgmt_ext_index_added_evt, 2, true },
15363         { 0x0021, "Extended Index Removed",
15364                         mgmt_ext_index_removed_evt, 2, true },
15365         { 0x0022, "Local Out Of Band Extended Data Updated",
15366                         mgmt_local_oob_ext_data_updated_evt, 3, false },
15367         { 0x0023, "Advertising Added",
15368                         mgmt_advertising_added_evt, 1, true },
15369         { 0x0024, "Advertising Removed",
15370                         mgmt_advertising_removed_evt, 1, true },
15371         { 0x0025, "Extended Controller Information Changed",
15372                         mgmt_ext_controller_info_changed_evt, 2, false },
15373         { 0x0026, "PHY Configuration Changed",
15374                         mgmt_phy_changed_evt, 4, true },
15375         { 0x0027, "Experimental Feature Changed",
15376                         mgmt_exp_feature_changed_evt, 20, true },
15377         { 0x002a, "Device Flags Changed",
15378                         mgmt_device_flags_changed_evt, 15, true },
15379         { 0x002b, "Advertisement Monitor Added",
15380                         mgmt_adv_monitor_added_evt, 2, true },
15381         { 0x002c, "Advertisement Monitor Removed",
15382                         mgmt_adv_monitor_removed_evt, 2, true },
15383         { 0x002d, "Controller Suspended",
15384                         mgmt_controller_suspend_evt, 1, true },
15385         { 0x002e, "Controller Resumed",
15386                         mgmt_controller_resume_evt, 8, true },
15387         { 0x002f, "ADV Monitor Device Found",
15388                         mgmt_adv_monitor_device_found_evt, 16, false },
15389         { 0x0030, "ADV Monitor Device Lost",
15390                         mgmt_adv_monitor_device_lost_evt, 9, true },
15391         { 0x0031, "Mesh Device Found",
15392                         mgmt_mesh_device_found_evt, 22, false },
15393         { 0x0032, "Mesh Packet Complete",
15394                         mgmt_mesh_packet_cmplt_evt, 1, true },
15395         { }
15396 };
15397
15398 static void mgmt_print_commands(const void *data, uint16_t num)
15399 {
15400         int i;
15401
15402         print_field("Commands: %u", num);
15403
15404         for (i = 0; i < num; i++) {
15405                 uint16_t opcode = get_le16(data + (i * 2));
15406                 const char *str = NULL;
15407                 int n;
15408
15409                 for (n = 0; mgmt_command_table[n].str; n++) {
15410                         if (mgmt_command_table[n].opcode == opcode) {
15411                                 str = mgmt_command_table[n].str;
15412                                 break;
15413                         }
15414                 }
15415
15416                 print_field("  %s (0x%4.4x)", str ?: "Reserved", opcode);
15417         }
15418 }
15419
15420 static void mgmt_print_events(const void *data, uint16_t num)
15421 {
15422         int i;
15423
15424         print_field("Events: %u", num);
15425
15426         for (i = 0; i < num; i++) {
15427                 uint16_t opcode = get_le16(data + (i * 2));
15428                 const char *str = NULL;
15429                 int n;
15430
15431                 for (n = 0; mgmt_event_table[n].str; n++) {
15432                         if (mgmt_event_table[n].opcode == opcode) {
15433                                 str = mgmt_event_table[n].str;
15434                                 break;
15435                         }
15436                 }
15437
15438                 print_field("  %s (0x%4.4x)", str ?: "Reserved", opcode);
15439         }
15440 }
15441
15442 void packet_ctrl_command(struct timeval *tv, struct ucred *cred, uint16_t index,
15443                                         const void *data, uint16_t size)
15444 {
15445         uint32_t cookie;
15446         uint16_t format, opcode;
15447         const struct mgmt_data *mgmt_data = NULL;
15448         const char *mgmt_color, *mgmt_str;
15449         char channel[11], extra_str[25];
15450         int i;
15451
15452         if (size < 4) {
15453                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15454                                 "Malformed Control Command packet", NULL, NULL);
15455                 packet_hexdump(data, size);
15456                 return;
15457         }
15458
15459         cookie = get_le32(data);
15460
15461         data += 4;
15462         size -= 4;
15463
15464         sprintf(channel, "0x%4.4x", cookie);
15465
15466         format = get_format(cookie);
15467
15468         if (format != CTRL_MGMT) {
15469                 char label[7];
15470
15471                 sprintf(label, "0x%4.4x", format);
15472
15473                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
15474                                                 "Control Command", label, NULL);
15475                 packet_hexdump(data, size);
15476                 return;
15477         }
15478
15479         if (size < 2) {
15480                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15481                                 "Malformed MGMT Command packet", NULL, NULL);
15482                 packet_hexdump(data, size);
15483                 return;
15484         }
15485
15486         opcode = get_le16(data);
15487
15488         data += 2;
15489         size -= 2;
15490
15491         for (i = 0; mgmt_command_table[i].str; i++) {
15492                 if (mgmt_command_table[i].opcode == opcode) {
15493                         mgmt_data = &mgmt_command_table[i];
15494                         break;
15495                 }
15496         }
15497
15498         if (mgmt_data) {
15499                 if (mgmt_data->func)
15500                         mgmt_color = COLOR_CTRL_COMMAND;
15501                 else
15502                         mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
15503                 mgmt_str = mgmt_data->str;
15504         } else {
15505                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
15506                 mgmt_str = "Unknown";
15507         }
15508
15509         sprintf(extra_str, "(0x%4.4x) plen %d", opcode, size);
15510
15511         print_packet(tv, cred, '@', index, channel, mgmt_color,
15512                                         "MGMT Command", mgmt_str, extra_str);
15513
15514         if (!mgmt_data || !mgmt_data->func) {
15515                 packet_hexdump(data, size);
15516                 return;
15517         }
15518
15519         if (mgmt_data->fixed) {
15520                 if (size != mgmt_data->size) {
15521                         print_text(COLOR_ERROR, "invalid packet size");
15522                         packet_hexdump(data, size);
15523                         return;
15524                 }
15525         } else {
15526                 if (size < mgmt_data->size) {
15527                         print_text(COLOR_ERROR, "too short packet");
15528                         packet_hexdump(data, size);
15529                         return;
15530                 }
15531         }
15532
15533         mgmt_data->func(data, size);
15534 }
15535
15536 void packet_ctrl_event(struct timeval *tv, struct ucred *cred, uint16_t index,
15537                                         const void *data, uint16_t size)
15538 {
15539         uint32_t cookie;
15540         uint16_t format, opcode;
15541         const struct mgmt_data *mgmt_data = NULL;
15542         const char *mgmt_color, *mgmt_str;
15543         char channel[11], extra_str[25];
15544         int i;
15545
15546         if (size < 4) {
15547                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15548                                 "Malformed Control Event packet", NULL, NULL);
15549                 packet_hexdump(data, size);
15550                 return;
15551         }
15552
15553         cookie = get_le32(data);
15554
15555         data += 4;
15556         size -= 4;
15557
15558         sprintf(channel, "0x%4.4x", cookie);
15559
15560         format = get_format(cookie);
15561
15562         if (format != CTRL_MGMT) {
15563                 char label[7];
15564
15565                 sprintf(label, "0x%4.4x", format);
15566
15567                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
15568                                                 "Control Event", label, NULL);
15569                 packet_hexdump(data, size);
15570                 return;
15571         }
15572
15573         if (size < 2) {
15574                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15575                                 "Malformed MGMT Event packet", NULL, NULL);
15576                 packet_hexdump(data, size);
15577                 return;
15578         }
15579
15580         opcode = get_le16(data);
15581
15582         data += 2;
15583         size -= 2;
15584
15585         for (i = 0; mgmt_event_table[i].str; i++) {
15586                 if (mgmt_event_table[i].opcode == opcode) {
15587                         mgmt_data = &mgmt_event_table[i];
15588                         break;
15589                 }
15590         }
15591
15592         if (mgmt_data) {
15593                 if (mgmt_data->func)
15594                         mgmt_color = COLOR_CTRL_EVENT;
15595                 else
15596                         mgmt_color = COLOR_CTRL_EVENT_UNKNOWN;
15597                 mgmt_str = mgmt_data->str;
15598         } else {
15599                 mgmt_color = COLOR_CTRL_EVENT_UNKNOWN;
15600                 mgmt_str = "Unknown";
15601         }
15602
15603         sprintf(extra_str, "(0x%4.4x) plen %d", opcode, size);
15604
15605         print_packet(tv, cred, '@', index, channel, mgmt_color,
15606                                         "MGMT Event", mgmt_str, extra_str);
15607
15608         if (!mgmt_data || !mgmt_data->func) {
15609                 packet_hexdump(data, size);
15610                 return;
15611         }
15612
15613         if (mgmt_data->fixed) {
15614                 if (size != mgmt_data->size) {
15615                         print_text(COLOR_ERROR, "invalid packet size");
15616                         packet_hexdump(data, size);
15617                         return;
15618                 }
15619         } else {
15620                 if (size < mgmt_data->size) {
15621                         print_text(COLOR_ERROR, "too short packet");
15622                         packet_hexdump(data, size);
15623                         return;
15624                 }
15625         }
15626
15627         mgmt_data->func(data, size);
15628 }
15629
15630 void packet_todo(void)
15631 {
15632         int i;
15633
15634         printf("HCI commands with missing decodings:\n");
15635
15636         for (i = 0; opcode_table[i].str; i++) {
15637                 if (opcode_table[i].bit < 0)
15638                         continue;
15639
15640                 if (opcode_table[i].cmd_func)
15641                         continue;
15642
15643                 printf("\t%s\n", opcode_table[i].str);
15644         }
15645
15646         printf("HCI events with missing decodings:\n");
15647
15648         for (i = 0; event_table[i].str; i++) {
15649                 if (event_table[i].func)
15650                         continue;
15651
15652                 printf("\t%s\n", event_table[i].str);
15653         }
15654
15655         for (i = 0; le_meta_event_table[i].str; i++) {
15656                 if (le_meta_event_table[i].func)
15657                         continue;
15658
15659                 printf("\t%s\n", le_meta_event_table[i].str);
15660         }
15661 }
15662
15663 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15664 void print_le_set_adv_parameters_cmd(const void *data, uint8_t size)
15665 {
15666         uint16_t dummy = 0;
15667         le_set_adv_parameters_cmd(dummy, data, size);
15668 }
15669
15670 void print_le_set_random_address_cmd(const void *data, uint8_t size)
15671 {
15672         uint16_t dummy = 0;
15673         le_set_random_address_cmd(dummy, data, size);
15674 }
15675
15676 void print_le_set_adv_data_cmd(const void *data, uint8_t size)
15677 {
15678         uint16_t dummy = 0;
15679         le_set_adv_data_cmd(dummy, data, size);
15680 }
15681
15682 void print_le_set_scan_rsp_data_cmd(const void *data, uint8_t size)
15683 {
15684         uint16_t dummy = 0;
15685         le_set_scan_rsp_data_cmd(dummy, data, size);
15686 }
15687
15688 void print_le_set_adv_enable_cmd(const void *data, uint8_t size)
15689 {
15690         uint16_t dummy = 0;
15691         le_set_adv_enable_cmd(dummy, data, size);
15692 }
15693 #endif