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          [0 ... MAX_CONN - 1].handle = 0xffff
 176 };
 177
 178 static struct packet_conn_data *lookup_parent(uint16_t handle)
 179 {
 180         int i;
 181
 182         for (i = 0; i < MAX_CONN; i++) {
 183                 if (conn_list[i].link == handle)
 184                         return &conn_list[i];
 185         }
 186
 187         return NULL;
 188 }
 189
 190 static void assign_handle(uint16_t index, uint16_t handle, uint8_t type,
 191                                         uint8_t *dst, uint8_t dst_type)
 192 {
 193         int i;
 194
 195         for (i = 0; i < MAX_CONN; i++) {
 196                 if (conn_list[i].handle == 0xffff) {
 197                         hci_devba(index, (bdaddr_t *)conn_list[i].src);
 198
 199                         conn_list[i].index = index;
 200                         conn_list[i].handle = handle;
 201                         conn_list[i].type = type;
 202
 203                         if (!dst) {
 204                                 struct packet_conn_data *p;
 205
 206                                 /* If destination is not set attempt to use the
 207                                  * parent one if that exists.
 208                                  */
 209                                 p = lookup_parent(handle);
 210                                 if (p) {
 211                                         memcpy(conn_list[i].dst, p->dst,
 212                                                 sizeof(conn_list[i].dst));
 213                                         conn_list[i].dst_type = p->dst_type;
 214                                 }
 215
 216                                 break;
 217                         }
 218
 219                         memcpy(conn_list[i].dst, dst, sizeof(conn_list[i].dst));
 220                         conn_list[i].dst_type = dst_type;
 221                         break;
 222                 }
 223         }
 224 }
 225
 226 static void release_handle(uint16_t handle)
 227 {
 228         int i;
 229
 230         for (i = 0; i < MAX_CONN; i++) {
 231                 struct packet_conn_data *conn = &conn_list[i];
 232
 233                 if (conn->handle == handle) {
 234                         if (conn->destroy)
 235                                 conn->destroy(conn->data);
 236
 237                         queue_destroy(conn->tx_q, free);
 238                         queue_destroy(conn->chan_q, free);
 239                         memset(conn, 0, sizeof(*conn));
 240                         conn->handle = 0xffff;
 241                         break;
 242                 }
 243         }
 244 }
 245
 246 struct packet_conn_data *packet_get_conn_data(uint16_t handle)
 247 {
 248         int i;
 249
 250         for (i = 0; i < MAX_CONN; i++) {
 251                 if (conn_list[i].handle == handle)
 252                         return &conn_list[i];
 253         }
 254
 255         return NULL;
 256 }
 257
 258 static uint8_t get_type(uint16_t handle)
 259 {
 260         struct packet_conn_data *conn;
 261
 262         conn = packet_get_conn_data(handle);
 263         if (!conn)
 264                 return 0xff;
 265
 266         return conn->type;
 267 }
 268
 269 bool packet_has_filter(unsigned long filter)
 270 {
 271         return filter_mask & filter;
 272 }
 273
 274 void packet_set_filter(unsigned long filter)
 275 {
 276         filter_mask = filter;
 277 }
 278
 279 void packet_add_filter(unsigned long filter)
 280 {
 281         if (index_filter)
 282                 filter &= ~PACKET_FILTER_SHOW_INDEX;
 283
 284         filter_mask |= filter;
 285 }
 286
 287 void packet_del_filter(unsigned long filter)
 288 {
 289         filter_mask &= ~filter;
 290 }
 291
 292 void packet_set_priority(const char *priority)
 293 {
 294         if (!priority)
 295                 return;
 296
 297         if (!strcasecmp(priority, "debug"))
 298                 priority_level = BTSNOOP_PRIORITY_DEBUG;
 299         else
 300                 priority_level = atoi(priority);
 301 }
 302
 303 void packet_select_index(uint16_t index)
 304 {
 305         filter_mask &= ~PACKET_FILTER_SHOW_INDEX;
 306
 307         control_filter_index(index);
 308
 309         index_filter = true;
 310 }
 311
 312 #define print_space(x) printf("%*c", (x), ' ');
 313
 314 #define MAX_INDEX 16
 315
 316 struct index_data {
 317         uint8_t  type;
 318         uint8_t  bdaddr[6];
 319         uint16_t manufacturer;
 320         uint16_t msft_opcode;
 321         uint8_t  msft_evt_prefix[8];
 322         uint8_t  msft_evt_len;
 323         size_t   frame;
 324 };
 325
 326 static struct index_data index_list[MAX_INDEX];
 327
 328 void packet_set_fallback_manufacturer(uint16_t manufacturer)
 329 {
 330         int i;
 331
 332         for (i = 0; i < MAX_INDEX; i++)
 333                 index_list[i].manufacturer = manufacturer;
 334
 335         fallback_manufacturer = manufacturer;
 336 }
 337
 338 void packet_set_msft_evt_prefix(const uint8_t *prefix, uint8_t len)
 339 {
 340         if (index_current < MAX_INDEX && len < 8)
 341                 memcpy(index_list[index_current].msft_evt_prefix, prefix, len);
 342 }
 343
 344 static void cred_pid(struct ucred *cred, char *str, size_t len)
 345 {
 346         char *path = alloca(24);
 347         char line[128];
 348         FILE *fp;
 349
 350         snprintf(path, 23, "/proc/%u/comm", cred->pid);
 351
 352         fp = fopen(path, "re");
 353         if (fp) {
 354                 if (fgets(line, sizeof(line), fp)) {
 355                         line[strcspn(line, "\r\n")] = '\0';
 356                         snprintf(str, len, "%s[%u]", line, cred->pid);
 357                 } else
 358                         snprintf(str, len, "[%u]", cred->pid);
 359                 fclose(fp);
 360         } else
 361                 snprintf(str, len, "[%u]", cred->pid);
 362 }
 363
 364 static void print_packet(struct timeval *tv, struct ucred *cred, char ident,
 365                                         uint16_t index, const char *channel,
 366                                         const char *color, const char *label,
 367                                         const char *text, const char *extra)
 368 {
 369         int col = num_columns();
 370         char line[256], ts_str[96], pid_str[140];
 371         int n, ts_len = 0, ts_pos = 0, len = 0, pos = 0;
 372         static size_t last_frame;
 373
 374         if (channel) {
 375                 if (use_color()) {
 376                         n = sprintf(ts_str + ts_pos, "%s", COLOR_CHANNEL_LABEL);
 377                         if (n > 0)
 378                                 ts_pos += n;
 379                 }
 380
 381                 n = sprintf(ts_str + ts_pos, " {%s}", channel);
 382                 if (n > 0) {
 383                         ts_pos += n;
 384                         ts_len += n;
 385                 }
 386         } else if (index != HCI_DEV_NONE && index < MAX_INDEX &&
 387                                 index_list[index].frame != last_frame) {
 388                 if (use_color()) {
 389                         n = sprintf(ts_str + ts_pos, "%s", COLOR_FRAME_LABEL);
 390                         if (n > 0)
 391                                 ts_pos += n;
 392                 }
 393
 394                 n = sprintf(ts_str + ts_pos, " #%zu", index_list[index].frame);
 395                 if (n > 0) {
 396                         ts_pos += n;
 397                         ts_len += n;
 398                 }
 399                 last_frame = index_list[index].frame;
 400         }
 401
 402         if ((filter_mask & PACKET_FILTER_SHOW_INDEX) &&
 403                                         index != HCI_DEV_NONE) {
 404                 if (use_color()) {
 405                         n = snprintf(ts_str + ts_pos, sizeof(ts_str) - ts_pos,
 406                                      "%s", COLOR_INDEX_LABEL);
 407                         if (n > 0)
 408                                 ts_pos += n;
 409                 }
 410
 411                 n = sprintf(ts_str + ts_pos, " [hci%d]", index);
 412                 if (n > 0) {
 413                         ts_pos += n;
 414                         ts_len += n;
 415                 }
 416         }
 417
 418         if (tv) {
 419                 time_t t = tv->tv_sec;
 420                 struct tm tm;
 421
 422                 localtime_r(&t, &tm);
 423
 424                 if (use_color()) {
 425                         n = sprintf(ts_str + ts_pos, "%s", COLOR_TIMESTAMP);
 426                         if (n > 0)
 427                                 ts_pos += n;
 428                 }
 429
 430                 if (filter_mask & PACKET_FILTER_SHOW_DATE) {
 431                         n = sprintf(ts_str + ts_pos, " %04d-%02d-%02d",
 432                                 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
 433                         if (n > 0) {
 434                                 ts_pos += n;
 435                                 ts_len += n;
 436                         }
 437                 }
 438
 439                 if (filter_mask & PACKET_FILTER_SHOW_TIME) {
 440                         n = sprintf(ts_str + ts_pos, " %02d:%02d:%02d.%06llu",
 441                                 tm.tm_hour, tm.tm_min, tm.tm_sec,
 442                                 (long long)tv->tv_usec);
 443                         if (n > 0) {
 444                                 ts_pos += n;
 445                                 ts_len += n;
 446                         }
 447                 }
 448
 449                 if (filter_mask & PACKET_FILTER_SHOW_TIME_OFFSET) {
 450                         n = sprintf(ts_str + ts_pos, " %llu.%06llu",
 451                                 (long long)(tv->tv_sec - time_offset),
 452                                 (long long)tv->tv_usec);
 453                         if (n > 0) {
 454                                 ts_pos += n;
 455                                 ts_len += n;
 456                         }
 457                 }
 458         }
 459
 460         if (use_color()) {
 461                 sprintf(ts_str + ts_pos, "%s", COLOR_OFF);
 462                 n = sprintf(line + pos, "%s", color);
 463                 if (n > 0)
 464                         pos += n;
 465         }
 466
 467         if (cred && cred->pid) {
 468                 cred_pid(cred, pid_str, sizeof(pid_str));
 469                 n = sprintf(line + pos, "%s: %c %s", pid_str, ident,
 470                                                 label ? label : "");
 471         } else
 472                 n = sprintf(line + pos, "%c %s", ident, label ? label : "");
 473
 474         if (n > 0) {
 475                 pos += n;
 476                 len += n;
 477         }
 478
 479         if (text) {
 480                 int extra_len = extra ? strlen(extra) : 0;
 481                 int max_len = col - len - extra_len - ts_len - 3;
 482
 483                 n = snprintf(line + pos, max_len + 1, "%s%s",
 484                                                 label ? ": " : "", text);
 485                 if (n > max_len) {
 486                         line[pos + max_len - 1] = '.';
 487                         line[pos + max_len - 2] = '.';
 488                         if (line[pos + max_len - 3] == ' ')
 489                                 line[pos + max_len - 3] = '.';
 490
 491                         n = max_len;
 492                 }
 493
 494                 if (n > 0) {
 495                         pos += n;
 496                         len += n;
 497                 }
 498         }
 499
 500         if (use_color()) {
 501                 n = sprintf(line + pos, "%s", COLOR_OFF);
 502                 if (n > 0)
 503                         pos += n;
 504         }
 505
 506         if (extra) {
 507                 n = sprintf(line + pos, " %s", extra);
 508                 if (n > 0)
 509                         len += n;
 510         }
 511
 512         if (ts_len > 0) {
 513                 printf("%s", line);
 514                 if (len < col)
 515                         print_space(col - len - ts_len - 1);
 516                 printf("%s%s\n", use_color() ? COLOR_TIMESTAMP : "", ts_str);
 517         } else
 518                 printf("%s\n", line);
 519 }
 520
 521 static const struct {
 522         uint8_t error;
 523         const char *str;
 524 } error2str_table[] = {
 525         { 0x00, "Success"                                               },
 526         { 0x01, "Unknown HCI Command"                                   },
 527         { 0x02, "Unknown Connection Identifier"                         },
 528         { 0x03, "Hardware Failure"                                      },
 529         { 0x04, "Page Timeout"                                          },
 530         { 0x05, "Authentication Failure"                                },
 531         { 0x06, "PIN or Key Missing"                                    },
 532         { 0x07, "Memory Capacity Exceeded"                              },
 533         { 0x08, "Connection Timeout"                                    },
 534         { 0x09, "Connection Limit Exceeded"                             },
 535         { 0x0a, "Synchronous Connection Limit to a Device Exceeded"     },
 536         { 0x0b, "ACL Connection Already Exists"                         },
 537         { 0x0c, "Command Disallowed"                                    },
 538         { 0x0d, "Connection Rejected due to Limited Resources"          },
 539         { 0x0e, "Connection Rejected due to Security Reasons"           },
 540         { 0x0f, "Connection Rejected due to Unacceptable BD_ADDR"       },
 541         { 0x10, "Connection Accept Timeout Exceeded"                    },
 542         { 0x11, "Unsupported Feature or Parameter Value"                },
 543         { 0x12, "Invalid HCI Command Parameters"                        },
 544         { 0x13, "Remote User Terminated Connection"                     },
 545         { 0x14, "Remote Device Terminated due to Low Resources"         },
 546         { 0x15, "Remote Device Terminated due to Power Off"             },
 547         { 0x16, "Connection Terminated By Local Host"                   },
 548         { 0x17, "Repeated Attempts"                                     },
 549         { 0x18, "Pairing Not Allowed"                                   },
 550         { 0x19, "Unknown LMP PDU"                                       },
 551         { 0x1a, "Unsupported Remote Feature / Unsupported LMP Feature"  },
 552         { 0x1b, "SCO Offset Rejected"                                   },
 553         { 0x1c, "SCO Interval Rejected"                                 },
 554         { 0x1d, "SCO Air Mode Rejected"                                 },
 555         { 0x1e, "Invalid LMP Parameters / Invalid LL Parameters"        },
 556         { 0x1f, "Unspecified Error"                                     },
 557         { 0x20, "Unsupported LMP Parameter Value / "
 558                 "Unsupported LL Parameter Value"                        },
 559         { 0x21, "Role Change Not Allowed"                               },
 560         { 0x22, "LMP Response Timeout / LL Response Timeout"            },
 561         { 0x23, "LMP Error Transaction Collision"                       },
 562         { 0x24, "LMP PDU Not Allowed"                                   },
 563         { 0x25, "Encryption Mode Not Acceptable"                        },
 564         { 0x26, "Link Key cannot be Changed"                            },
 565         { 0x27, "Requested QoS Not Supported"                           },
 566         { 0x28, "Instant Passed"                                        },
 567         { 0x29, "Pairing With Unit Key Not Supported"                   },
 568         { 0x2a, "Different Transaction Collision"                       },
 569         { 0x2b, "Reserved"                                              },
 570         { 0x2c, "QoS Unacceptable Parameter"                            },
 571         { 0x2d, "QoS Rejected"                                          },
 572         { 0x2e, "Channel Classification Not Supported"                  },
 573         { 0x2f, "Insufficient Security"                                 },
 574         { 0x30, "Parameter Out Of Manadatory Range"                     },
 575         { 0x31, "Reserved"                                              },
 576         { 0x32, "Role Switch Pending"                                   },
 577         { 0x33, "Reserved"                                              },
 578         { 0x34, "Reserved Slot Violation"                               },
 579         { 0x35, "Role Switch Failed"                                    },
 580         { 0x36, "Extended Inquiry Response Too Large"                   },
 581         { 0x37, "Secure Simple Pairing Not Supported By Host"           },
 582         { 0x38, "Host Busy - Pairing"                                   },
 583         { 0x39, "Connection Rejected due to No Suitable Channel Found"  },
 584         { 0x3a, "Controller Busy"                                       },
 585         { 0x3b, "Unacceptable Connection Parameters"                    },
 586         { 0x3c, "Advertising Timeout"                                   },
 587         { 0x3d, "Connection Terminated due to MIC Failure"              },
 588         { 0x3e, "Connection Failed to be Established"                   },
 589         { 0x3f, "MAC Connection Failed"                                 },
 590         { 0x40, "Coarse Clock Adjustment Rejected "
 591                 "but Will Try to Adjust Using Clock Dragging"           },
 592         { 0x41, "Type0 Submap Not Defined"                              },
 593         { 0x42, "Unknown Advertising Identifier"                        },
 594         { 0x43, "Limit Reached"                                         },
 595         { 0x44, "Operation Cancelled by Host"                           },
 596         { 0x45, "Packet Too Long"                                       },
 597         { }
 598 };
 599
 600 static void print_error(const char *label, uint8_t error)
 601 {
 602         const char *str = "Unknown";
 603         const char *color_on, *color_off;
 604         bool unknown = true;
 605         int i;
 606
 607         for (i = 0; error2str_table[i].str; i++) {
 608                 if (error2str_table[i].error == error) {
 609                         str = error2str_table[i].str;
 610                         unknown = false;
 611                         break;
 612                 }
 613         }
 614
 615         if (use_color()) {
 616                 if (error) {
 617                         if (unknown)
 618                                 color_on = COLOR_UNKNOWN_ERROR;
 619                         else
 620                                 color_on = COLOR_RED;
 621                 } else
 622                         color_on = COLOR_GREEN;
 623                 color_off = COLOR_OFF;
 624         } else {
 625                 color_on = "";
 626                 color_off = "";
 627         }
 628
 629         print_field("%s: %s%s%s (0x%2.2x)", label,
 630                                 color_on, str, color_off, error);
 631 }
 632
 633 static void print_status(uint8_t status)
 634 {
 635         print_error("Status", status);
 636 }
 637
 638 static void print_reason(uint8_t reason)
 639 {
 640         print_error("Reason", reason);
 641 }
 642
 643 void packet_print_error(const char *label, uint8_t error)
 644 {
 645         print_error(label, error);
 646 }
 647
 648 static void print_enable(const char *label, uint8_t enable)
 649 {
 650         const char *str;
 651
 652         switch (enable) {
 653         case 0x00:
 654                 str = "Disabled";
 655                 break;
 656         case 0x01:
 657                 str = "Enabled";
 658                 break;
 659         default:
 660                 str = "Reserved";
 661                 break;
 662         }
 663
 664         print_field("%s: %s (0x%2.2x)", label, str, enable);
 665 }
 666
 667 static void print_addr_type(const char *label, uint8_t addr_type)
 668 {
 669         const char *str;
 670
 671         switch (addr_type) {
 672         case 0x00:
 673                 str = "Public";
 674                 break;
 675         case 0x01:
 676                 str = "Random";
 677                 break;
 678         default:
 679                 str = "Reserved";
 680                 break;
 681         }
 682
 683         print_field("%s: %s (0x%2.2x)", label, str, addr_type);
 684 }
 685
 686 static void print_own_addr_type(uint8_t addr_type)
 687 {
 688         const char *str;
 689
 690         switch (addr_type) {
 691         case 0x00:
 692         case 0x02:
 693                 str = "Public";
 694                 break;
 695         case 0x01:
 696         case 0x03:
 697                 str = "Random";
 698                 break;
 699         default:
 700                 str = "Reserved";
 701                 break;
 702         }
 703
 704         print_field("Own address type: %s (0x%2.2x)", str, addr_type);
 705 }
 706
 707 static void print_peer_addr_type(const char *label, uint8_t addr_type)
 708 {
 709         const char *str;
 710
 711         switch (addr_type) {
 712         case 0x00:
 713                 str = "Public";
 714                 break;
 715         case 0x01:
 716                 str = "Random";
 717                 break;
 718         case 0x02:
 719                 str = "Resolved Public";
 720                 break;
 721         case 0x03:
 722                 str = "Resolved Random";
 723                 break;
 724         default:
 725                 str = "Reserved";
 726                 break;
 727         }
 728
 729         print_field("%s: %s (0x%2.2x)", label, str, addr_type);
 730 }
 731
 732 static void print_addr_resolve(const char *label, const uint8_t *addr,
 733                                         uint8_t addr_type, bool resolve)
 734 {
 735         const char *str;
 736         char *company;
 737
 738         switch (addr_type) {
 739         case 0x00:
 740         case 0x02:
 741                 if (!hwdb_get_company(addr, &company))
 742                         company = NULL;
 743
 744                 if (company) {
 745                         print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 746                                         " (%s)", label, addr[5], addr[4],
 747                                                         addr[3], addr[2],
 748                                                         addr[1], addr[0],
 749                                                         company);
 750                         free(company);
 751                 } else {
 752                         print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 753                                         " (OUI %2.2X-%2.2X-%2.2X)", label,
 754                                                 addr[5], addr[4], addr[3],
 755                                                 addr[2], addr[1], addr[0],
 756                                                 addr[5], addr[4], addr[3]);
 757                 }
 758                 break;
 759         case 0x01:
 760         case 0x03:
 761                 switch ((addr[5] & 0xc0) >> 6) {
 762                 case 0x00:
 763                         str = "Non-Resolvable";
 764                         break;
 765                 case 0x01:
 766                         str = "Resolvable";
 767                         break;
 768                 case 0x03:
 769                         str = "Static";
 770                         break;
 771                 default:
 772                         str = "Reserved";
 773                         break;
 774                 }
 775
 776                 print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X (%s)",
 777                                         label, addr[5], addr[4], addr[3],
 778                                         addr[2], addr[1], addr[0], str);
 779
 780                 if (resolve && (addr[5] & 0xc0) == 0x40) {
 781                         uint8_t ident[6], ident_type;
 782
 783                         if (keys_resolve_identity(addr, ident, &ident_type)) {
 784                                 print_addr_type("  Identity type", ident_type);
 785                                 print_addr_resolve("  Identity", ident,
 786                                                         ident_type, false);
 787                         }
 788                 }
 789                 break;
 790         default:
 791                 print_field("%s: %2.2X-%2.2X-%2.2X-%2.2X-%2.2X-%2.2X",
 792                                         label, addr[5], addr[4], addr[3],
 793                                         addr[2], addr[1], addr[0]);
 794                 break;
 795         }
 796 }
 797
 798 static void print_addr(const char *label, const uint8_t *addr, uint8_t type)
 799 {
 800         print_addr_resolve(label, addr, type, true);
 801 }
 802
 803 static void print_bdaddr(const uint8_t *bdaddr)
 804 {
 805         print_addr("Address", bdaddr, 0x00);
 806 }
 807
 808 static void print_lt_addr(uint8_t lt_addr)
 809 {
 810         print_field("LT address: %d", lt_addr);
 811 }
 812
 813 static void print_handle_native(uint16_t handle)
 814 {
 815         struct packet_conn_data *conn;
 816         char label[25];
 817
 818         conn = packet_get_conn_data(handle);
 819         if (!conn) {
 820                 print_field("Handle: %d", handle);
 821                 return;
 822         }
 823
 824         sprintf(label, "Handle: %d Address", handle);
 825         print_addr(label, conn->dst, conn->dst_type);
 826 }
 827
 828 static void print_handle(uint16_t handle)
 829 {
 830         print_handle_native(le16_to_cpu(handle));
 831 }
 832
 833 static void print_phy_handle(uint8_t phy_handle)
 834 {
 835         print_field("Physical handle: %d", phy_handle);
 836 }
 837
 838 static const struct bitfield_data pkt_type_table[] = {
 839         {  1, "2-DH1 may not be used"   },
 840         {  2, "3-DH1 may not be used"   },
 841         {  3, "DM1 may be used"         },
 842         {  4, "DH1 may be used"         },
 843         {  8, "2-DH3 may not be used"   },
 844         {  9, "3-DH3 may not be used"   },
 845         { 10, "DM3 may be used"         },
 846         { 11, "DH3 may be used"         },
 847         { 12, "2-DH5 may not be used"   },
 848         { 13, "3-DH5 may not be used"   },
 849         { 14, "DM5 may be used"         },
 850         { 15, "DH5 may be used"         },
 851         { }
 852 };
 853
 854 static void print_pkt_type(uint16_t pkt_type)
 855 {
 856         uint16_t mask = le16_to_cpu(pkt_type);
 857
 858         print_field("Packet type: 0x%4.4x", mask);
 859
 860         mask = print_bitfield(2, mask, pkt_type_table);
 861         if (mask)
 862                 print_text(COLOR_UNKNOWN_PKT_TYPE_BIT,
 863                                 "  Unknown packet types (0x%4.4x)", mask);
 864 }
 865
 866 static const struct bitfield_data pkt_type_sco_table[] = {
 867         {  0, "HV1 may be used"         },
 868         {  1, "HV2 may be used"         },
 869         {  2, "HV3 may be used"         },
 870         {  3, "EV3 may be used"         },
 871         {  4, "EV4 may be used"         },
 872         {  5, "EV5 may be used"         },
 873         {  6, "2-EV3 may not be used"   },
 874         {  7, "3-EV3 may not be used"   },
 875         {  8, "2-EV5 may not be used"   },
 876         {  9, "3-EV5 may not be used"   },
 877         { }
 878 };
 879
 880 static void print_pkt_type_sco(uint16_t pkt_type)
 881 {
 882         uint16_t mask = le16_to_cpu(pkt_type);
 883
 884         print_field("Packet type: 0x%4.4x", mask);
 885
 886         mask = print_bitfield(2, mask, pkt_type_sco_table);
 887         if (mask)
 888                 print_text(COLOR_UNKNOWN_PKT_TYPE_BIT,
 889                                 "  Unknown packet types (0x%4.4x)", mask);
 890 }
 891
 892 static void print_iac(const uint8_t *lap)
 893 {
 894         const char *str = "";
 895
 896         if (lap[2] == 0x9e && lap[1] == 0x8b) {
 897                 switch (lap[0]) {
 898                 case 0x33:
 899                         str = " (General Inquiry)";
 900                         break;
 901                 case 0x00:
 902                         str = " (Limited Inquiry)";
 903                         break;
 904                 }
 905         }
 906
 907         print_field("Access code: 0x%2.2x%2.2x%2.2x%s",
 908                                                 lap[2], lap[1], lap[0], str);
 909 }
 910
 911 static void print_auth_enable(uint8_t enable)
 912 {
 913         const char *str;
 914
 915         switch (enable) {
 916         case 0x00:
 917                 str = "Authentication not required";
 918                 break;
 919         case 0x01:
 920                 str = "Authentication required for all connections";
 921                 break;
 922         default:
 923                 str = "Reserved";
 924                 break;
 925         }
 926
 927         print_field("Enable: %s (0x%2.2x)", str, enable);
 928 }
 929
 930 static void print_encrypt_mode(uint8_t mode)
 931 {
 932         const char *str;
 933
 934         switch (mode) {
 935         case 0x00:
 936                 str = "Encryption not required";
 937                 break;
 938         case 0x01:
 939                 str = "Encryption required for all connections";
 940                 break;
 941         default:
 942                 str = "Reserved";
 943                 break;
 944         }
 945
 946         print_field("Mode: %s (0x%2.2x)", str, mode);
 947 }
 948
 949 static const struct bitfield_data svc_class_table[] = {
 950         { 0, "Positioning (Location identification)"            },
 951         { 1, "Networking (LAN, Ad hoc)"                         },
 952         { 2, "Rendering (Printing, Speaker)"                    },
 953         { 3, "Capturing (Scanner, Microphone)"                  },
 954         { 4, "Object Transfer (v-Inbox, v-Folder)"              },
 955         { 5, "Audio (Speaker, Microphone, Headset)"             },
 956         { 6, "Telephony (Cordless telephony, Modem, Headset)"   },
 957         { 7, "Information (WEB-server, WAP-server)"             },
 958         { }
 959 };
 960
 961 static const struct {
 962         uint8_t val;
 963         const char *str;
 964 } major_class_computer_table[] = {
 965         { 0x00, "Uncategorized, code for device not assigned"   },
 966         { 0x01, "Desktop workstation"                           },
 967         { 0x02, "Server-class computer"                         },
 968         { 0x03, "Laptop"                                        },
 969         { 0x04, "Handheld PC/PDA (clam shell)"                  },
 970         { 0x05, "Palm sized PC/PDA"                             },
 971         { 0x06, "Wearable computer (Watch sized)"               },
 972         { 0x07, "Tablet"                                        },
 973         { }
 974 };
 975
 976 static const char *major_class_computer(uint8_t minor)
 977 {
 978         int i;
 979
 980         for (i = 0; major_class_computer_table[i].str; i++) {
 981                 if (major_class_computer_table[i].val == minor)
 982                         return major_class_computer_table[i].str;
 983         }
 984
 985         return NULL;
 986 }
 987
 988 static const struct {
 989         uint8_t val;
 990         const char *str;
 991 } major_class_phone_table[] = {
 992         { 0x00, "Uncategorized, code for device not assigned"   },
 993         { 0x01, "Cellular"                                      },
 994         { 0x02, "Cordless"                                      },
 995         { 0x03, "Smart phone"                                   },
 996         { 0x04, "Wired modem or voice gateway"                  },
 997         { 0x05, "Common ISDN Access"                            },
 998         { }
 999 };
1000
1001 static const char *major_class_phone(uint8_t minor)
1002 {
1003         int i;
1004
1005         for (i = 0; major_class_phone_table[i].str; i++) {
1006                 if (major_class_phone_table[i].val == minor)
1007                         return major_class_phone_table[i].str;
1008         }
1009
1010         return NULL;
1011 }
1012
1013 static const struct {
1014         uint8_t val;
1015         const char *str;
1016 } major_class_av_table[] = {
1017         { 0x00, "Uncategorized, code for device not assigned"   },
1018         { 0x01, "Wearable Headset Device"                       },
1019         { 0x02, "Hands-free Device"                             },
1020         { 0x04, "Microphone"                                    },
1021         { 0x05, "Loudspeaker"                                   },
1022         { 0x06, "Headphones"                                    },
1023         { 0x07, "Portable Audio"                                },
1024         { 0x08, "Car audio"                                     },
1025         { 0x09, "Set-top box"                                   },
1026         { 0x0a, "HiFi Audio Device"                             },
1027         { 0x0b, "VCR"                                           },
1028         { 0x0c, "Video Camera"                                  },
1029         { 0x0d, "Camcorder"                                     },
1030         { 0x0e, "Video Monitor"                                 },
1031         { 0x0f, "Video Display and Loudspeaker"                 },
1032         { 0x10, "Video Conferencing"                            },
1033         { 0x12, "Gaming/Toy"                                    },
1034         { }
1035 };
1036
1037 static const char *major_class_av(uint8_t minor)
1038 {
1039         int i;
1040
1041         for (i = 0; major_class_av_table[i].str; i++) {
1042                 if (major_class_av_table[i].val == minor)
1043                         return major_class_av_table[i].str;
1044         }
1045
1046         return NULL;
1047 }
1048
1049 static const struct {
1050         uint8_t val;
1051         const char *str;
1052 } major_class_wearable_table[] = {
1053         { 0x01, "Wrist Watch"   },
1054         { 0x02, "Pager"         },
1055         { 0x03, "Jacket"        },
1056         { 0x04, "Helmet"        },
1057         { 0x05, "Glasses"       },
1058         { }
1059 };
1060
1061 static const char *major_class_wearable(uint8_t minor)
1062 {
1063         int i;
1064
1065         for (i = 0; major_class_wearable_table[i].str; i++) {
1066                 if (major_class_wearable_table[i].val == minor)
1067                         return major_class_wearable_table[i].str;
1068         }
1069
1070         return NULL;
1071 }
1072
1073 static const struct {
1074         uint8_t val;
1075         const char *str;
1076         const char *(*func)(uint8_t minor);
1077 } major_class_table[] = {
1078         { 0x00, "Miscellaneous"                                         },
1079         { 0x01, "Computer (desktop, notebook, PDA, organizers)",
1080                                                 major_class_computer    },
1081         { 0x02, "Phone (cellular, cordless, payphone, modem)",
1082                                                 major_class_phone       },
1083         { 0x03, "LAN /Network Access point"                             },
1084         { 0x04, "Audio/Video (headset, speaker, stereo, video, vcr)",
1085                                                 major_class_av          },
1086         { 0x05, "Peripheral (mouse, joystick, keyboards)"               },
1087         { 0x06, "Imaging (printing, scanner, camera, display)"          },
1088         { 0x07, "Wearable",                     major_class_wearable    },
1089         { 0x08, "Toy"                                                   },
1090         { 0x09, "Health"                                                },
1091         { 0x1f, "Uncategorized, specific device code not specified"     },
1092         { }
1093 };
1094
1095 static void print_dev_class(const uint8_t *dev_class)
1096 {
1097         uint8_t mask, major_cls, minor_cls;
1098         const char *major_str = NULL;
1099         const char *minor_str = NULL;
1100         int i;
1101
1102         print_field("Class: 0x%2.2x%2.2x%2.2x",
1103                         dev_class[2], dev_class[1], dev_class[0]);
1104
1105         if ((dev_class[0] & 0x03) != 0x00) {
1106                 print_field("  Format type: 0x%2.2x", dev_class[0] & 0x03);
1107                 print_text(COLOR_ERROR, "  invalid format type");
1108                 return;
1109         }
1110
1111         major_cls = dev_class[1] & 0x1f;
1112         minor_cls = (dev_class[0] & 0xfc) >> 2;
1113
1114         for (i = 0; major_class_table[i].str; i++) {
1115                 if (major_class_table[i].val == major_cls) {
1116                         major_str = major_class_table[i].str;
1117
1118                         if (!major_class_table[i].func)
1119                                 break;
1120
1121                         minor_str = major_class_table[i].func(minor_cls);
1122                         break;
1123                 }
1124         }
1125
1126         if (major_str) {
1127                 print_field("  Major class: %s", major_str);
1128                 if (minor_str)
1129                         print_field("  Minor class: %s", minor_str);
1130                 else
1131                         print_field("  Minor class: 0x%2.2x", minor_cls);
1132         } else {
1133                 print_field("  Major class: 0x%2.2x", major_cls);
1134                 print_field("  Minor class: 0x%2.2x", minor_cls);
1135         }
1136
1137         if (dev_class[1] & 0x20)
1138                 print_field("  Limited Discoverable Mode");
1139
1140         if ((dev_class[1] & 0xc0) != 0x00) {
1141                 print_text(COLOR_ERROR, "  invalid service class");
1142                 return;
1143         }
1144
1145         mask = print_bitfield(2, dev_class[2], svc_class_table);
1146         if (mask)
1147                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
1148                                 "  Unknown service class (0x%2.2x)", mask);
1149 }
1150
1151 static void print_appearance(uint16_t appearance)
1152 {
1153         print_field("Appearance: %s (0x%4.4x)", bt_appear_to_str(appearance),
1154                                                                 appearance);
1155 }
1156
1157 static void print_num_broadcast_retrans(uint8_t num_retrans)
1158 {
1159         print_field("Number of broadcast retransmissions: %u", num_retrans);
1160 }
1161
1162 static void print_hold_mode_activity(uint8_t activity)
1163 {
1164         print_field("Activity: 0x%2.2x", activity);
1165
1166         if (activity == 0x00) {
1167                 print_field("  Maintain current Power State");
1168                 return;
1169         }
1170
1171         if (activity & 0x01)
1172                 print_field("  Suspend Page Scan");
1173         if (activity & 0x02)
1174                 print_field("  Suspend Inquiry Scan");
1175         if (activity & 0x04)
1176                 print_field("  Suspend Periodic Inquiries");
1177 }
1178
1179 static void print_power_type(uint8_t type)
1180 {
1181         const char *str;
1182
1183         switch (type) {
1184         case 0x00:
1185                 str = "Current Transmit Power Level";
1186                 break;
1187         case 0x01:
1188                 str = "Maximum Transmit Power Level";
1189                 break;
1190         default:
1191                 str = "Reserved";
1192                 break;
1193         }
1194
1195         print_field("Type: %s (0x%2.2x)", str, type);
1196 }
1197
1198 static void print_power_level(int8_t level, const char *type)
1199 {
1200         print_field("TX power%s%s%s: %d dbm (0x%2.2x)",
1201                 type ? " (" : "", type ? type : "", type ? ")" : "",
1202                                                         level, (uint8_t) level);
1203 }
1204
1205 static void print_host_flow_control(uint8_t enable)
1206 {
1207         const char *str;
1208
1209         switch (enable) {
1210         case 0x00:
1211                 str = "Off";
1212                 break;
1213         case 0x01:
1214                 str = "ACL Data Packets";
1215                 break;
1216         case 0x02:
1217                 str = "Synchronous Data Packets";
1218                 break;
1219         case 0x03:
1220                 str = "ACL and Synchronous Data Packets";
1221                 break;
1222         default:
1223                 str = "Reserved";
1224                 break;
1225         }
1226
1227         print_field("Flow control: %s (0x%2.2x)", str, enable);
1228 }
1229
1230 static void print_voice_setting(uint16_t setting)
1231 {
1232         uint8_t input_coding = (le16_to_cpu(setting) & 0x0300) >> 8;
1233         uint8_t input_data_format = (le16_to_cpu(setting) & 0xc0) >> 6;
1234         uint8_t air_coding_format = le16_to_cpu(setting) & 0x0003;
1235         const char *str;
1236
1237         print_field("Setting: 0x%4.4x", le16_to_cpu(setting));
1238
1239         switch (input_coding) {
1240         case 0x00:
1241                 str = "Linear";
1242                 break;
1243         case 0x01:
1244                 str = "u-law";
1245                 break;
1246         case 0x02:
1247                 str = "A-law";
1248                 break;
1249         default:
1250                 str = "Reserved";
1251                 break;
1252         }
1253
1254         print_field("  Input Coding: %s", str);
1255
1256         switch (input_data_format) {
1257         case 0x00:
1258                 str = "1's complement";
1259                 break;
1260         case 0x01:
1261                 str = "2's complement";
1262                 break;
1263         case 0x02:
1264                 str = "Sign-Magnitude";
1265                 break;
1266         case 0x03:
1267                 str = "Unsigned";
1268                 break;
1269         default:
1270                 str = "Reserved";
1271                 break;
1272         }
1273
1274         print_field("  Input Data Format: %s", str);
1275
1276         if (input_coding == 0x00) {
1277                 print_field("  Input Sample Size: %s",
1278                         le16_to_cpu(setting) & 0x20 ? "16-bit" : "8-bit");
1279                 print_field("  # of bits padding at MSB: %d",
1280                                         (le16_to_cpu(setting) & 0x1c) >> 2);
1281         }
1282
1283         switch (air_coding_format) {
1284         case 0x00:
1285                 str = "CVSD";
1286                 break;
1287         case 0x01:
1288                 str = "u-law";
1289                 break;
1290         case 0x02:
1291                 str = "A-law";
1292                 break;
1293         case 0x03:
1294                 str = "Transparent Data";
1295                 break;
1296         default:
1297                 str = "Reserved";
1298                 break;
1299         }
1300
1301         print_field("  Air Coding Format: %s", str);
1302 }
1303
1304 static void print_retransmission_effort(uint8_t effort)
1305 {
1306         const char *str;
1307
1308         switch (effort) {
1309         case 0x00:
1310                 str = "No retransmissions";
1311                 break;
1312         case 0x01:
1313                 str = "Optimize for power consumption";
1314                 break;
1315         case 0x02:
1316                 str = "Optimize for link quality";
1317                 break;
1318         case 0xff:
1319                 str = "Don't care";
1320                 break;
1321         default:
1322                 str = "Reserved";
1323                 break;
1324         }
1325
1326         print_field("Retransmission effort: %s (0x%2.2x)", str, effort);
1327 }
1328
1329 static void print_scan_enable(uint8_t scan_enable)
1330 {
1331         const char *str;
1332
1333         switch (scan_enable) {
1334         case 0x00:
1335                 str = "No Scans";
1336                 break;
1337         case 0x01:
1338                 str = "Inquiry Scan";
1339                 break;
1340         case 0x02:
1341                 str = "Page Scan";
1342                 break;
1343         case 0x03:
1344                 str = "Inquiry Scan + Page Scan";
1345                 break;
1346         default:
1347                 str = "Reserved";
1348                 break;
1349         }
1350
1351         print_field("Scan enable: %s (0x%2.2x)", str, scan_enable);
1352 }
1353
1354 static void print_link_policy(uint16_t link_policy)
1355 {
1356         uint16_t policy = le16_to_cpu(link_policy);
1357
1358         print_field("Link policy: 0x%4.4x", policy);
1359
1360         if (policy == 0x0000) {
1361                 print_field("  Disable All Modes");
1362                 return;
1363         }
1364
1365         if (policy & 0x0001)
1366                 print_field("  Enable Role Switch");
1367         if (policy & 0x0002)
1368                 print_field("  Enable Hold Mode");
1369         if (policy & 0x0004)
1370                 print_field("  Enable Sniff Mode");
1371         if (policy & 0x0008)
1372                 print_field("  Enable Park State");
1373 }
1374
1375 static void print_air_mode(uint8_t mode)
1376 {
1377         const char *str;
1378
1379         switch (mode) {
1380         case 0x00:
1381                 str = "u-law log";
1382                 break;
1383         case 0x01:
1384                 str = "A-law log";
1385                 break;
1386         case 0x02:
1387                 str = "CVSD";
1388                 break;
1389         case 0x03:
1390                 str = "Transparent";
1391                 break;
1392         default:
1393                 str = "Reserved";
1394                 break;
1395         }
1396
1397         print_field("Air mode: %s (0x%2.2x)", str, mode);
1398 }
1399
1400 static void print_codec_id(const char *label, uint8_t codec)
1401 {
1402         const char *str;
1403
1404         switch (codec) {
1405         case 0x00:
1406                 str = "u-law log";
1407                 break;
1408         case 0x01:
1409                 str = "A-law log";
1410                 break;
1411         case 0x02:
1412                 str = "CVSD";
1413                 break;
1414         case 0x03:
1415                 str = "Transparent";
1416                 break;
1417         case 0x04:
1418                 str = "Linear PCM";
1419                 break;
1420         case 0x05:
1421                 str = "mSBC";
1422                 break;
1423         case 0x06:
1424                 str = "LC3";
1425                 break;
1426         case 0xff:
1427                 str = "Vendor specific";
1428                 break;
1429         default:
1430                 str = "Reserved";
1431                 break;
1432         }
1433
1434         print_field("%s: %s (0x%2.2x)", label, str, codec);
1435 }
1436
1437 void packet_print_codec_id(const char *label, uint8_t codec)
1438 {
1439         print_codec_id(label, codec);
1440 }
1441
1442 static const struct bitfield_data codec_transport_table[] = {
1443         {  0, "Codec supported over BR/EDR ACL"         },
1444         {  1, "Codec supported over BR/EDR SCO and eSCO"},
1445         {  2, "Codec supported over LE CIS"             },
1446         {  3, "Codec supported over LE BIS"             },
1447         { }
1448 };
1449
1450 static void print_codec(const char *label, const struct bt_hci_codec *codec)
1451 {
1452         uint8_t mask;
1453
1454         print_codec_id(label, codec->id);
1455         print_field("  Logical Transport Type: 0x%02x", codec->transport);
1456         mask = print_bitfield(4, codec->transport, codec_transport_table);
1457         if (mask)
1458                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
1459                                 "  Unknown transport (0x%2.2x)", mask);
1460 }
1461
1462 static void print_inquiry_mode(uint8_t mode)
1463 {
1464         const char *str;
1465
1466         switch (mode) {
1467         case 0x00:
1468                 str = "Standard Inquiry Result";
1469                 break;
1470         case 0x01:
1471                 str = "Inquiry Result with RSSI";
1472                 break;
1473         case 0x02:
1474                 str = "Inquiry Result with RSSI or Extended Inquiry Result";
1475                 break;
1476         default:
1477                 str = "Reserved";
1478                 break;
1479         }
1480
1481         print_field("Mode: %s (0x%2.2x)", str, mode);
1482 }
1483
1484 static void print_inquiry_scan_type(uint8_t type)
1485 {
1486         const char *str;
1487
1488         switch (type) {
1489         case 0x00:
1490                 str = "Standard Scan";
1491                 break;
1492         case 0x01:
1493                 str = "Interlaced Scan";
1494                 break;
1495         default:
1496                 str = "Reserved";
1497                 break;
1498         }
1499
1500         print_field("Type: %s (0x%2.2x)", str, type);
1501 }
1502
1503 static void print_pscan_type(uint8_t type)
1504 {
1505         const char *str;
1506
1507         switch (type) {
1508         case 0x00:
1509                 str = "Standard Scan";
1510                 break;
1511         case 0x01:
1512                 str = "Interlaced Scan";
1513                 break;
1514         default:
1515                 str = "Reserved";
1516                 break;
1517         }
1518
1519         print_field("Type: %s (0x%2.2x)", str, type);
1520 }
1521
1522 static void print_loopback_mode(uint8_t mode)
1523 {
1524         const char *str;
1525
1526         switch (mode) {
1527         case 0x00:
1528                 str = "No Loopback";
1529                 break;
1530         case 0x01:
1531                 str = "Local Loopback";
1532                 break;
1533         case 0x02:
1534                 str = "Remote Loopback";
1535                 break;
1536         default:
1537                 str = "Reserved";
1538                 break;
1539         }
1540
1541         print_field("Mode: %s (0x%2.2x)", str, mode);
1542 }
1543
1544 static void print_auth_payload_timeout(uint16_t timeout)
1545 {
1546         print_field("Timeout: %d msec (0x%4.4x)",
1547                         le16_to_cpu(timeout) * 10, le16_to_cpu(timeout));
1548 }
1549
1550 static void print_pscan_rep_mode(uint8_t pscan_rep_mode)
1551 {
1552         const char *str;
1553
1554         switch (pscan_rep_mode) {
1555         case 0x00:
1556                 str = "R0";
1557                 break;
1558         case 0x01:
1559                 str = "R1";
1560                 break;
1561         case 0x02:
1562                 str = "R2";
1563                 break;
1564         default:
1565                 str = "Reserved";
1566                 break;
1567         }
1568
1569         print_field("Page scan repetition mode: %s (0x%2.2x)",
1570                                                 str, pscan_rep_mode);
1571 }
1572
1573 static void print_pscan_period_mode(uint8_t pscan_period_mode)
1574 {
1575         const char *str;
1576
1577         switch (pscan_period_mode) {
1578         case 0x00:
1579                 str = "P0";
1580                 break;
1581         case 0x01:
1582                 str = "P1";
1583                 break;
1584         case 0x02:
1585                 str = "P2";
1586                 break;
1587         default:
1588                 str = "Reserved";
1589                 break;
1590         }
1591
1592         print_field("Page period mode: %s (0x%2.2x)", str, pscan_period_mode);
1593 }
1594
1595 static void print_pscan_mode(uint8_t pscan_mode)
1596 {
1597         const char *str;
1598
1599         switch (pscan_mode) {
1600         case 0x00:
1601                 str = "Mandatory";
1602                 break;
1603         case 0x01:
1604                 str = "Optional I";
1605                 break;
1606         case 0x02:
1607                 str = "Optional II";
1608                 break;
1609         case 0x03:
1610                 str = "Optional III";
1611                 break;
1612         default:
1613                 str = "Reserved";
1614                 break;
1615         }
1616
1617         print_field("Page scan mode: %s (0x%2.2x)", str, pscan_mode);
1618 }
1619
1620 static void print_clock_offset(uint16_t clock_offset)
1621 {
1622         print_field("Clock offset: 0x%4.4x", le16_to_cpu(clock_offset));
1623 }
1624
1625 static void print_clock(uint32_t clock)
1626 {
1627         print_field("Clock: 0x%8.8x", le32_to_cpu(clock));
1628 }
1629
1630 static void print_clock_type(uint8_t type)
1631 {
1632         const char *str;
1633
1634         switch (type) {
1635         case 0x00:
1636                 str = "Local clock";
1637                 break;
1638         case 0x01:
1639                 str = "Piconet clock";
1640                 break;
1641         default:
1642                 str = "Reserved";
1643                 break;
1644         }
1645
1646         print_field("Type: %s (0x%2.2x)", str, type);
1647 }
1648
1649 static void print_clock_accuracy(uint16_t accuracy)
1650 {
1651         if (le16_to_cpu(accuracy) == 0xffff)
1652                 print_field("Accuracy: Unknown (0x%4.4x)",
1653                                                 le16_to_cpu(accuracy));
1654         else
1655                 print_field("Accuracy: %.4f msec (0x%4.4x)",
1656                                                 le16_to_cpu(accuracy) * 0.3125,
1657                                                 le16_to_cpu(accuracy));
1658 }
1659
1660 static void print_lpo_allowed(uint8_t lpo_allowed)
1661 {
1662         print_field("LPO allowed: 0x%2.2x", lpo_allowed);
1663 }
1664
1665 static void print_broadcast_fragment(uint8_t fragment)
1666 {
1667         const char *str;
1668
1669         switch (fragment) {
1670         case 0x00:
1671                 str = "Continuation fragment";
1672                 break;
1673         case 0x01:
1674                 str = "Starting fragment";
1675                 break;
1676         case 0x02:
1677                 str = "Ending fragment";
1678                 break;
1679         case 0x03:
1680                 str = "No fragmentation";
1681                 break;
1682         default:
1683                 str = "Reserved";
1684                 break;
1685         }
1686
1687         print_field("Fragment: %s (0x%2.2x)", str, fragment);
1688 }
1689
1690 static void print_link_type(uint8_t link_type)
1691 {
1692         const char *str;
1693
1694         switch (link_type) {
1695         case 0x00:
1696                 str = "SCO";
1697                 break;
1698         case 0x01:
1699                 str = "ACL";
1700                 break;
1701         case 0x02:
1702                 str = "eSCO";
1703                 break;
1704         default:
1705                 str = "Reserved";
1706                 break;
1707         }
1708
1709         print_field("Link type: %s (0x%2.2x)", str, link_type);
1710 }
1711
1712 static void print_encr_mode_change(uint8_t encr_mode, uint16_t handle)
1713 {
1714         const char *str;
1715         uint8_t conn_type;
1716
1717         conn_type = get_type(le16_to_cpu(handle));
1718
1719         switch (encr_mode) {
1720         case 0x00:
1721                 str = "Disabled";
1722                 break;
1723         case 0x01:
1724                 switch (conn_type) {
1725                 case 0x00:
1726                         str = "Enabled with E0";
1727                         break;
1728                 case 0x01:
1729                         str = "Enabled with AES-CCM";
1730                         break;
1731                 default:
1732                         str = "Enabled";
1733                         break;
1734                 }
1735                 break;
1736         case 0x02:
1737                 str = "Enabled with AES-CCM";
1738                 break;
1739         default:
1740                 str = "Reserved";
1741                 break;
1742         }
1743
1744         print_field("Encryption: %s (0x%2.2x)", str, encr_mode);
1745 }
1746
1747 static void print_pin_type(uint8_t pin_type)
1748 {
1749         const char *str;
1750
1751         switch (pin_type) {
1752         case 0x00:
1753                 str = "Variable";
1754                 break;
1755         case 0x01:
1756                 str = "Fixed";
1757                 break;
1758         default:
1759                 str = "Reserved";
1760                 break;
1761         }
1762
1763         print_field("PIN type: %s (0x%2.2x)", str, pin_type);
1764 }
1765
1766 static void print_key_flag(uint8_t key_flag)
1767 {
1768         const char *str;
1769
1770         switch (key_flag) {
1771         case 0x00:
1772                 str = "Semi-permanent";
1773                 break;
1774         case 0x01:
1775                 str = "Temporary";
1776                 break;
1777         default:
1778                 str = "Reserved";
1779                 break;
1780         }
1781
1782         print_field("Key flag: %s (0x%2.2x)", str, key_flag);
1783 }
1784
1785 static void print_key_len(uint8_t key_len)
1786 {
1787         const char *str;
1788
1789         switch (key_len) {
1790         case 32:
1791                 str = "802.11 PAL";
1792                 break;
1793         default:
1794                 str = "Reserved";
1795                 break;
1796         }
1797
1798         print_field("Key length: %s (%d)", str, key_len);
1799 }
1800
1801 static void print_key_type(uint8_t key_type)
1802 {
1803         const char *str;
1804
1805         switch (key_type) {
1806         case 0x00:
1807                 str = "Combination key";
1808                 break;
1809         case 0x01:
1810                 str = "Local Unit key";
1811                 break;
1812         case 0x02:
1813                 str = "Remote Unit key";
1814                 break;
1815         case 0x03:
1816                 str = "Debug Combination key";
1817                 break;
1818         case 0x04:
1819                 str = "Unauthenticated Combination key from P-192";
1820                 break;
1821         case 0x05:
1822                 str = "Authenticated Combination key from P-192";
1823                 break;
1824         case 0x06:
1825                 str = "Changed Combination key";
1826                 break;
1827         case 0x07:
1828                 str = "Unauthenticated Combination key from P-256";
1829                 break;
1830         case 0x08:
1831                 str = "Authenticated Combination key from P-256";
1832                 break;
1833         default:
1834                 str = "Reserved";
1835                 break;
1836         }
1837
1838         print_field("Key type: %s (0x%2.2x)", str, key_type);
1839 }
1840
1841 static void print_key_size(uint8_t key_size)
1842 {
1843         print_field("Key size: %d", key_size);
1844 }
1845
1846 static void print_key(const char *label, const uint8_t *link_key)
1847 {
1848         print_hex_field(label, link_key, 16);
1849 }
1850
1851 static void print_link_key(const uint8_t *link_key)
1852 {
1853         print_key("Link key", link_key);
1854 }
1855
1856 static void print_pin_code(const uint8_t *pin_code, uint8_t pin_len)
1857 {
1858         char str[pin_len + 1];
1859         uint8_t i;
1860
1861         for (i = 0; i < pin_len; i++)
1862                 sprintf(str + i, "%c", (const char) pin_code[i]);
1863
1864         print_field("PIN code: %s", str);
1865 }
1866
1867 static void print_hash_p192(const uint8_t *hash)
1868 {
1869         print_key("Hash C from P-192", hash);
1870 }
1871
1872 static void print_hash_p256(const uint8_t *hash)
1873 {
1874         print_key("Hash C from P-256", hash);
1875 }
1876
1877 static void print_randomizer_p192(const uint8_t *randomizer)
1878 {
1879         print_key("Randomizer R with P-192", randomizer);
1880 }
1881
1882 static void print_randomizer_p256(const uint8_t *randomizer)
1883 {
1884         print_key("Randomizer R with P-256", randomizer);
1885 }
1886
1887 static void print_pk256(const char *label, const uint8_t *key)
1888 {
1889         print_field("%s:", label);
1890         print_hex_field("  X", &key[0], 32);
1891         print_hex_field("  Y", &key[32], 32);
1892 }
1893
1894 static void print_dhkey(const uint8_t *dhkey)
1895 {
1896         print_hex_field("Diffie-Hellman key", dhkey, 32);
1897 }
1898
1899 static void print_passkey(uint32_t passkey)
1900 {
1901         print_field("Passkey: %06d", le32_to_cpu(passkey));
1902 }
1903
1904 static void print_io_capability(uint8_t capability)
1905 {
1906         const char *str;
1907
1908         switch (capability) {
1909         case 0x00:
1910                 str = "DisplayOnly";
1911                 break;
1912         case 0x01:
1913                 str = "DisplayYesNo";
1914                 break;
1915         case 0x02:
1916                 str = "KeyboardOnly";
1917                 break;
1918         case 0x03:
1919                 str = "NoInputNoOutput";
1920                 break;
1921         default:
1922                 str = "Reserved";
1923                 break;
1924         }
1925
1926         print_field("IO capability: %s (0x%2.2x)", str, capability);
1927 }
1928
1929 static void print_oob_data(uint8_t oob_data)
1930 {
1931         const char *str;
1932
1933         switch (oob_data) {
1934         case 0x00:
1935                 str = "Authentication data not present";
1936                 break;
1937         case 0x01:
1938                 str = "P-192 authentication data present";
1939                 break;
1940         case 0x02:
1941                 str = "P-256 authentication data present";
1942                 break;
1943         case 0x03:
1944                 str = "P-192 and P-256 authentication data present";
1945                 break;
1946         default:
1947                 str = "Reserved";
1948                 break;
1949         }
1950
1951         print_field("OOB data: %s (0x%2.2x)", str, oob_data);
1952 }
1953
1954 static void print_oob_data_response(uint8_t oob_data)
1955 {
1956         const char *str;
1957
1958         switch (oob_data) {
1959         case 0x00:
1960                 str = "Authentication data not present";
1961                 break;
1962         case 0x01:
1963                 str = "Authentication data present";
1964                 break;
1965         default:
1966                 str = "Reserved";
1967                 break;
1968         }
1969
1970         print_field("OOB data: %s (0x%2.2x)", str, oob_data);
1971 }
1972
1973 static void print_authentication(uint8_t authentication)
1974 {
1975         const char *str;
1976
1977         switch (authentication) {
1978         case 0x00:
1979                 str = "No Bonding - MITM not required";
1980                 break;
1981         case 0x01:
1982                 str = "No Bonding - MITM required";
1983                 break;
1984         case 0x02:
1985                 str = "Dedicated Bonding - MITM not required";
1986                 break;
1987         case 0x03:
1988                 str = "Dedicated Bonding - MITM required";
1989                 break;
1990         case 0x04:
1991                 str = "General Bonding - MITM not required";
1992                 break;
1993         case 0x05:
1994                 str = "General Bonding - MITM required";
1995                 break;
1996         default:
1997                 str = "Reserved";
1998                 break;
1999         }
2000
2001         print_field("Authentication: %s (0x%2.2x)", str, authentication);
2002 }
2003
2004 void packet_print_io_capability(uint8_t capability)
2005 {
2006         print_io_capability(capability);
2007 }
2008
2009 void packet_print_io_authentication(uint8_t authentication)
2010 {
2011         print_authentication(authentication);
2012 }
2013
2014 static void print_location_domain_aware(uint8_t aware)
2015 {
2016         const char *str;
2017
2018         switch (aware) {
2019         case 0x00:
2020                 str = "Regulatory domain unknown";
2021                 break;
2022         case 0x01:
2023                 str = "Regulatory domain known";
2024                 break;
2025         default:
2026                 str = "Reserved";
2027                 break;
2028         }
2029
2030         print_field("Domain aware: %s (0x%2.2x)", str, aware);
2031 }
2032
2033 static void print_location_domain(const uint8_t *domain)
2034 {
2035         print_field("Domain: %c%c (0x%2.2x%2.2x)",
2036                 (char) domain[0], (char) domain[1], domain[0], domain[1]);
2037 }
2038
2039 static void print_location_domain_options(uint8_t options)
2040 {
2041         print_field("Domain options: %c (0x%2.2x)", (char) options, options);
2042 }
2043
2044 static void print_location_options(uint8_t options)
2045 {
2046         print_field("Options: 0x%2.2x", options);
2047 }
2048
2049 static void print_flow_control_mode(uint8_t mode)
2050 {
2051         const char *str;
2052
2053         switch (mode) {
2054         case 0x00:
2055                 str = "Packet based";
2056                 break;
2057         case 0x01:
2058                 str = "Data block based";
2059                 break;
2060         default:
2061                 str = "Reserved";
2062                 break;
2063         }
2064
2065         print_field("Flow control mode: %s (0x%2.2x)", str, mode);
2066 }
2067
2068 static void print_flow_direction(uint8_t direction)
2069 {
2070         const char *str;
2071
2072         switch (direction) {
2073         case 0x00:
2074                 str = "Outgoing";
2075                 break;
2076         case 0x01:
2077                 str = "Incoming";
2078                 break;
2079         default:
2080                 str = "Reserved";
2081                 break;
2082         }
2083
2084         print_field("Flow direction: %s (0x%2.2x)", str, direction);
2085 }
2086
2087 static void print_service_type(uint8_t service_type)
2088 {
2089         const char *str;
2090
2091         switch (service_type) {
2092         case 0x00:
2093                 str = "No Traffic";
2094                 break;
2095         case 0x01:
2096                 str = "Best Effort";
2097                 break;
2098         case 0x02:
2099                 str = "Guaranteed";
2100                 break;
2101         default:
2102                 str = "Reserved";
2103                 break;
2104         }
2105
2106         print_field("Service type: %s (0x%2.2x)", str, service_type);
2107 }
2108
2109 static void print_flow_spec(const char *label, const uint8_t *data)
2110 {
2111         const char *str;
2112
2113         switch (data[1]) {
2114         case 0x00:
2115                 str = "No traffic";
2116                 break;
2117         case 0x01:
2118                 str = "Best effort";
2119                 break;
2120         case 0x02:
2121                 str = "Guaranteed";
2122                 break;
2123         default:
2124                 str = "Reserved";
2125                 break;
2126         }
2127
2128         print_field("%s flow spec: 0x%2.2x", label, data[0]);
2129         print_field("  Service type: %s (0x%2.2x)", str, data[1]);
2130         print_field("  Maximum SDU size: 0x%4.4x", get_le16(data + 2));
2131         print_field("  SDU inter-arrival time: 0x%8.8x", get_le32(data + 4));
2132         print_field("  Access latency: 0x%8.8x", get_le32(data + 8));
2133         print_field("  Flush timeout: 0x%8.8x", get_le32(data + 12));
2134 }
2135
2136 static void print_amp_status(uint8_t amp_status)
2137 {
2138         const char *str;
2139
2140         switch (amp_status) {
2141         case 0x00:
2142                 str = "Present";
2143                 break;
2144         case 0x01:
2145                 str = "Bluetooth only";
2146                 break;
2147         case 0x02:
2148                 str = "No capacity";
2149                 break;
2150         case 0x03:
2151                 str = "Low capacity";
2152                 break;
2153         case 0x04:
2154                 str = "Medium capacity";
2155                 break;
2156         case 0x05:
2157                 str = "High capacity";
2158                 break;
2159         case 0x06:
2160                 str = "Full capacity";
2161                 break;
2162         default:
2163                 str = "Reserved";
2164                 break;
2165         }
2166
2167         print_field("AMP status: %s (0x%2.2x)", str, amp_status);
2168 }
2169
2170 static void print_num_resp(uint8_t num_resp)
2171 {
2172         print_field("Num responses: %d", num_resp);
2173 }
2174
2175 static void print_num_reports(uint8_t num_reports)
2176 {
2177         print_field("Num reports: %d", num_reports);
2178 }
2179
2180 static void print_adv_event_type(const char *label, uint8_t type)
2181 {
2182         const char *str;
2183
2184         switch (type) {
2185         case 0x00:
2186                 str = "Connectable undirected - ADV_IND";
2187                 break;
2188         case 0x01:
2189                 str = "Connectable directed - ADV_DIRECT_IND";
2190                 break;
2191         case 0x02:
2192                 str = "Scannable undirected - ADV_SCAN_IND";
2193                 break;
2194         case 0x03:
2195                 str = "Non connectable undirected - ADV_NONCONN_IND";
2196                 break;
2197         case 0x04:
2198                 str = "Scan response - SCAN_RSP";
2199                 break;
2200         default:
2201                 str = "Reserved";
2202                 break;
2203         }
2204
2205         print_field("%s: %s (0x%2.2x)", label, str, type);
2206 }
2207
2208 static void print_adv_channel_map(const char *label, uint8_t value)
2209 {
2210         const char *str;
2211
2212         switch (value) {
2213         case 0x01:
2214                 str = "37";
2215                 break;
2216         case 0x02:
2217                 str = "38";
2218                 break;
2219         case 0x03:
2220                 str = "37, 38";
2221                 break;
2222         case 0x04:
2223                 str = "39";
2224                 break;
2225         case 0x05:
2226                 str = "37, 39";
2227                 break;
2228         case 0x06:
2229                 str = "38, 39";
2230                 break;
2231         case 0x07:
2232                 str = "37, 38, 39";
2233                 break;
2234         default:
2235                 str = "Reserved";
2236                 break;
2237         }
2238
2239         print_field("%s: %s (0x%2.2x)", label, str, value);
2240 }
2241
2242 static void print_adv_filter_policy(const char *label, uint8_t value)
2243 {
2244         const char *str;
2245
2246         switch (value) {
2247         case 0x00:
2248                 str = "Allow Scan Request from Any, "
2249                         "Allow Connect Request from Any";
2250                 break;
2251         case 0x01:
2252                 str = "Allow Scan Request from Accept List Only, "
2253                         "Allow Connect Request from Any";
2254                 break;
2255         case 0x02:
2256                 str = "Allow Scan Request from Any, "
2257                         "Allow Connect Request from Accept List Only";
2258                 break;
2259         case 0x03:
2260                 str = "Allow Scan Request from Accept List Only, "
2261                         "Allow Connect Request from Accept List Only";
2262                 break;
2263         default:
2264                 str = "Reserved";
2265                 break;
2266         }
2267
2268         print_field("%s: %s (0x%2.2x)", label, str, value);
2269 }
2270
2271 static void print_rssi(int8_t rssi)
2272 {
2273         packet_print_rssi("RSSI", rssi);
2274 }
2275
2276 static void print_slot_625(const char *label, uint16_t value)
2277 {
2278          print_field("%s: %.3f msec (0x%4.4x)", label,
2279                                 le16_to_cpu(value) * 0.625, le16_to_cpu(value));
2280 }
2281
2282 static void print_slot_125(const char *label, uint16_t value)
2283 {
2284         print_field("%s: %.2f msec (0x%4.4x)", label,
2285                                 le16_to_cpu(value) * 1.25, le16_to_cpu(value));
2286 }
2287
2288 static void print_timeout(uint16_t timeout)
2289 {
2290         print_slot_625("Timeout", timeout);
2291 }
2292
2293 static void print_interval(uint16_t interval)
2294 {
2295         print_slot_625("Interval", interval);
2296 }
2297
2298 static void print_window(uint16_t window)
2299 {
2300         print_slot_625("Window", window);
2301 }
2302
2303 static void print_conn_latency(const char *label, uint16_t value)
2304 {
2305         print_field("%s: %u (0x%4.4x)", label, le16_to_cpu(value),
2306                                                         le16_to_cpu(value));
2307 }
2308
2309 static void print_role(uint8_t role)
2310 {
2311         const char *str;
2312
2313         switch (role) {
2314         case 0x00:
2315                 str = "Central";
2316                 break;
2317         case 0x01:
2318                 str = "Peripheral";
2319                 break;
2320         default:
2321                 str = "Reserved";
2322                 break;
2323         }
2324
2325         print_field("Role: %s (0x%2.2x)", str, role);
2326 }
2327
2328 static void print_mode(uint8_t mode)
2329 {
2330         const char *str;
2331
2332         switch (mode) {
2333         case 0x00:
2334                 str = "Active";
2335                 break;
2336         case 0x01:
2337                 str = "Hold";
2338                 break;
2339         case 0x02:
2340                 str = "Sniff";
2341                 break;
2342         case 0x03:
2343                 str = "Park";
2344                 break;
2345         default:
2346                 str = "Reserved";
2347                 break;
2348         }
2349
2350         print_field("Mode: %s (0x%2.2x)", str, mode);
2351 }
2352
2353 static void print_name(const uint8_t *name)
2354 {
2355         char str[249];
2356
2357         memcpy(str, name, 248);
2358         str[248] = '\0';
2359
2360         print_field("Name: %s", str);
2361 }
2362
2363 static void print_channel_map(const uint8_t *map)
2364 {
2365         unsigned int count = 0, start = 0;
2366         char str[21];
2367         int i, n;
2368
2369         for (i = 0; i < 10; i++)
2370                 sprintf(str + (i * 2), "%2.2x", map[i]);
2371
2372         print_field("Channel map: 0x%s", str);
2373
2374         for (i = 0; i < 10; i++) {
2375                 for (n = 0; n < 8; n++) {
2376                         if (map[i] & (1 << n)) {
2377                                 if (count == 0)
2378                                         start = (i * 8) + n;
2379                                 count++;
2380                                 continue;
2381                         }
2382
2383                         if (count > 1) {
2384                                 print_field("  Channel %u-%u",
2385                                                 start, start + count - 1);
2386                                 count = 0;
2387                         } else if (count > 0) {
2388                                 print_field("  Channel %u", start);
2389                                 count = 0;
2390                         }
2391                 }
2392         }
2393 }
2394
2395 void packet_print_channel_map_lmp(const uint8_t *map)
2396 {
2397         print_channel_map(map);
2398 }
2399
2400 static void print_flush_timeout(uint16_t timeout)
2401 {
2402         if (timeout)
2403                 print_timeout(timeout);
2404         else
2405                 print_field("Timeout: No Automatic Flush");
2406 }
2407
2408 void packet_print_version(const char *label, uint8_t version,
2409                                 const char *sublabel, uint16_t subversion)
2410 {
2411         const char *str;
2412
2413         switch (version) {
2414         case 0x00:
2415                 str = "Bluetooth 1.0b";
2416                 break;
2417         case 0x01:
2418                 str = "Bluetooth 1.1";
2419                 break;
2420         case 0x02:
2421                 str = "Bluetooth 1.2";
2422                 break;
2423         case 0x03:
2424                 str = "Bluetooth 2.0";
2425                 break;
2426         case 0x04:
2427                 str = "Bluetooth 2.1";
2428                 break;
2429         case 0x05:
2430                 str = "Bluetooth 3.0";
2431                 break;
2432         case 0x06:
2433                 str = "Bluetooth 4.0";
2434                 break;
2435         case 0x07:
2436                 str = "Bluetooth 4.1";
2437                 break;
2438         case 0x08:
2439                 str = "Bluetooth 4.2";
2440                 break;
2441         case 0x09:
2442                 str = "Bluetooth 5.0";
2443                 break;
2444         case 0x0a:
2445                 str = "Bluetooth 5.1";
2446                 break;
2447         case 0x0b:
2448                 str = "Bluetooth 5.2";
2449                 break;
2450         case 0x0c:
2451                 str = "Bluetooth 5.3";
2452                 break;
2453         default:
2454                 str = "Reserved";
2455                 break;
2456         }
2457
2458         if (sublabel)
2459                 print_field("%s: %s (0x%2.2x) - %s %d (0x%4.4x)",
2460                                         label, str, version,
2461                                         sublabel, subversion, subversion);
2462         else
2463                 print_field("%s: %s (0x%2.2x)", label, str, version);
2464 }
2465
2466 static void print_hci_version(uint8_t version, uint16_t revision)
2467 {
2468         packet_print_version("HCI version", version,
2469                                 "Revision", le16_to_cpu(revision));
2470 }
2471
2472 static void print_lmp_version(uint8_t version, uint16_t subversion)
2473 {
2474         packet_print_version("LMP version", version,
2475                                 "Subversion", le16_to_cpu(subversion));
2476 }
2477
2478 static void print_pal_version(uint8_t version, uint16_t subversion)
2479 {
2480         const char *str;
2481
2482         switch (version) {
2483         case 0x01:
2484                 str = "Bluetooth 3.0";
2485                 break;
2486         default:
2487                 str = "Reserved";
2488                 break;
2489         }
2490
2491         print_field("PAL version: %s (0x%2.2x) - Subversion %d (0x%4.4x)",
2492                                                 str, version,
2493                                                 le16_to_cpu(subversion),
2494                                                 le16_to_cpu(subversion));
2495 }
2496
2497 void packet_print_company(const char *label, uint16_t company)
2498 {
2499         print_field("%s: %s (%d)", label, bt_compidtostr(company), company);
2500 }
2501
2502 static void print_manufacturer(uint16_t manufacturer)
2503 {
2504         packet_print_company("Manufacturer", le16_to_cpu(manufacturer));
2505 }
2506
2507 static const struct {
2508         uint16_t ver;
2509         const char *str;
2510 } broadcom_uart_subversion_table[] = {
2511         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
2512         { 0x410e, "BCM43341B0"  },      /* 002.001.014 */
2513         { 0x4406, "BCM4324B3"   },      /* 002.004.006 */
2514         { }
2515 };
2516
2517 static const struct {
2518         uint16_t ver;
2519         const char *str;
2520 } broadcom_usb_subversion_table[] = {
2521         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
2522         { 0x2112, "BCM4314A0"   },      /* 001.001.018 */
2523         { 0x2118, "BCM20702A0"  },      /* 001.001.024 */
2524         { 0x2126, "BCM4335A0"   },      /* 001.001.038 */
2525         { 0x220e, "BCM20702A1"  },      /* 001.002.014 */
2526         { 0x230f, "BCM4354A2"   },      /* 001.003.015 */
2527         { 0x4106, "BCM4335B0"   },      /* 002.001.006 */
2528         { 0x410e, "BCM20702B0"  },      /* 002.001.014 */
2529         { 0x6109, "BCM4335C0"   },      /* 003.001.009 */
2530         { 0x610c, "BCM4354"     },      /* 003.001.012 */
2531         { }
2532 };
2533
2534 static void print_manufacturer_broadcom(uint16_t subversion, uint16_t revision)
2535 {
2536         uint16_t ver = le16_to_cpu(subversion);
2537         uint16_t rev = le16_to_cpu(revision);
2538         const char *str = NULL;
2539         int i;
2540
2541         switch ((rev & 0xf000) >> 12) {
2542         case 0:
2543         case 3:
2544                 for (i = 0; broadcom_uart_subversion_table[i].str; i++) {
2545                         if (broadcom_uart_subversion_table[i].ver == ver) {
2546                                 str = broadcom_uart_subversion_table[i].str;
2547                                 break;
2548                         }
2549                 }
2550                 break;
2551         case 1:
2552         case 2:
2553                 for (i = 0; broadcom_usb_subversion_table[i].str; i++) {
2554                         if (broadcom_usb_subversion_table[i].ver == ver) {
2555                                 str = broadcom_usb_subversion_table[i].str;
2556                                 break;
2557                         }
2558                 }
2559                 break;
2560         }
2561
2562         if (str)
2563                 print_field("  Firmware: %3.3u.%3.3u.%3.3u (%s)",
2564                                 (ver & 0xe000) >> 13,
2565                                 (ver & 0x1f00) >> 8, ver & 0x00ff, str);
2566         else
2567                 print_field("  Firmware: %3.3u.%3.3u.%3.3u",
2568                                 (ver & 0xe000) >> 13,
2569                                 (ver & 0x1f00) >> 8, ver & 0x00ff);
2570
2571         if (rev != 0xffff)
2572                 print_field("  Build: %4.4u", rev & 0x0fff);
2573 }
2574
2575 static const char *get_supported_command(int bit);
2576
2577 static void print_commands(const uint8_t *commands)
2578 {
2579         unsigned int count = 0;
2580         int i, n;
2581
2582         for (i = 0; i < 64; i++) {
2583                 for (n = 0; n < 8; n++) {
2584                         if (commands[i] & (1 << n))
2585                                 count++;
2586                 }
2587         }
2588
2589         print_field("Commands: %u entr%s", count, count == 1 ? "y" : "ies");
2590
2591         for (i = 0; i < 64; i++) {
2592                 for (n = 0; n < 8; n++) {
2593                         const char *cmd;
2594
2595                         if (!(commands[i] & (1 << n)))
2596                                 continue;
2597
2598                         cmd = get_supported_command((i * 8) + n);
2599                         if (cmd)
2600                                 print_field("  %s (Octet %d - Bit %d)",
2601                                                                 cmd, i, n);
2602                         else
2603                                 print_text(COLOR_UNKNOWN_COMMAND_BIT,
2604                                                 "  Octet %d - Bit %d ", i, n);
2605                 }
2606         }
2607 }
2608
2609 static const struct bitfield_data features_page0[] = {
2610         {  0, "3 slot packets"                          },
2611         {  1, "5 slot packets"                          },
2612         {  2, "Encryption"                              },
2613         {  3, "Slot offset"                             },
2614         {  4, "Timing accuracy"                         },
2615         {  5, "Role switch"                             },
2616         {  6, "Hold mode"                               },
2617         {  7, "Sniff mode"                              },
2618         {  8, "Park state"                              },
2619         {  9, "Power control requests"                  },
2620         { 10, "Channel quality driven data rate (CQDDR)"},
2621         { 11, "SCO link"                                },
2622         { 12, "HV2 packets"                             },
2623         { 13, "HV3 packets"                             },
2624         { 14, "u-law log synchronous data"              },
2625         { 15, "A-law log synchronous data"              },
2626         { 16, "CVSD synchronous data"                   },
2627         { 17, "Paging parameter negotiation"            },
2628         { 18, "Power control"                           },
2629         { 19, "Transparent synchronous data"            },
2630         { 20, "Flow control lag (least significant bit)"},
2631         { 21, "Flow control lag (middle bit)"           },
2632         { 22, "Flow control lag (most significant bit)" },
2633         { 23, "Broadcast Encryption"                    },
2634         { 25, "Enhanced Data Rate ACL 2 Mbps mode"      },
2635         { 26, "Enhanced Data Rate ACL 3 Mbps mode"      },
2636         { 27, "Enhanced inquiry scan"                   },
2637         { 28, "Interlaced inquiry scan"                 },
2638         { 29, "Interlaced page scan"                    },
2639         { 30, "RSSI with inquiry results"               },
2640         { 31, "Extended SCO link (EV3 packets)"         },
2641         { 32, "EV4 packets"                             },
2642         { 33, "EV5 packets"                             },
2643         { 35, "AFH capable peripheral"                  },
2644         { 36, "AFH classification peripheral"           },
2645         { 37, "BR/EDR Not Supported"                    },
2646         { 38, "LE Supported (Controller)"               },
2647         { 39, "3-slot Enhanced Data Rate ACL packets"   },
2648         { 40, "5-slot Enhanced Data Rate ACL packets"   },
2649         { 41, "Sniff subrating"                         },
2650         { 42, "Pause encryption"                        },
2651         { 43, "AFH capable central"                     },
2652         { 44, "AFH classification central"              },
2653         { 45, "Enhanced Data Rate eSCO 2 Mbps mode"     },
2654         { 46, "Enhanced Data Rate eSCO 3 Mbps mode"     },
2655         { 47, "3-slot Enhanced Data Rate eSCO packets"  },
2656         { 48, "Extended Inquiry Response"               },
2657         { 49, "Simultaneous LE and BR/EDR (Controller)" },
2658         { 51, "Secure Simple Pairing"                   },
2659         { 52, "Encapsulated PDU"                        },
2660         { 53, "Erroneous Data Reporting"                },
2661         { 54, "Non-flushable Packet Boundary Flag"      },
2662         { 56, "Link Supervision Timeout Changed Event"  },
2663         { 57, "Inquiry TX Power Level"                  },
2664         { 58, "Enhanced Power Control"                  },
2665         { 63, "Extended features"                       },
2666         { }
2667 };
2668
2669 static const struct bitfield_data features_page1[] = {
2670         {  0, "Secure Simple Pairing (Host Support)"    },
2671         {  1, "LE Supported (Host)"                     },
2672         {  2, "Simultaneous LE and BR/EDR (Host)"       },
2673         {  3, "Secure Connections (Host Support)"       },
2674         { }
2675 };
2676
2677 static const struct bitfield_data features_page2[] = {
2678         {  0, "Connectionless Peripheral Broadcast - Central"   },
2679         {  1, "Connectionless Peripheral Broadcast - Peripheral"},
2680         {  2, "Synchronization Train"                           },
2681         {  3, "Synchronization Scan"                            },
2682         {  4, "Inquiry Response Notification Event"             },
2683         {  5, "Generalized interlaced scan"                     },
2684         {  6, "Coarse Clock Adjustment"                         },
2685         {  8, "Secure Connections (Controller Support)"         },
2686         {  9, "Ping"                                            },
2687         { 10, "Slot Availability Mask"                          },
2688         { 11, "Train nudging"                                   },
2689         { }
2690 };
2691
2692 static const struct bitfield_data features_le[] = {
2693         {  0, "LE Encryption"                                   },
2694         {  1, "Connection Parameter Request Procedure"          },
2695         {  2, "Extended Reject Indication"                      },
2696         {  3, "Peripheral-initiated Features Exchange"          },
2697         {  4, "LE Ping"                                         },
2698         {  5, "LE Data Packet Length Extension"                 },
2699         {  6, "LL Privacy"                                      },
2700         {  7, "Extended Scanner Filter Policies"                },
2701         {  8, "LE 2M PHY"                                       },
2702         {  9, "Stable Modulation Index - Transmitter"           },
2703         { 10, "Stable Modulation Index - Receiver"              },
2704         { 11, "LE Coded PHY"                                    },
2705         { 12, "LE Extended Advertising"                         },
2706         { 13, "LE Periodic Advertising"                         },
2707         { 14, "Channel Selection Algorithm #2"                  },
2708         { 15, "LE Power Class 1"                                },
2709         { 16, "Minimum Number of Used Channels Procedure"       },
2710         { 17, "Connection CTE Request"                          },
2711         { 18, "Connection CTE Response"                         },
2712         { 19, "Connectionless CTE Transmitter"                  },
2713         { 20, "Connectionless CTE Receiver"                     },
2714         { 21, "Antenna Switching During CTE Transmission (AoD)" },
2715         { 22, "Antenna Switching During CTE Reception (AoA)"    },
2716         { 23, "Receiving Constant Tone Extensions"              },
2717         { 24, "Periodic Advertising Sync Transfer - Sender"     },
2718         { 25, "Periodic Advertising Sync Transfer - Recipient"  },
2719         { 26, "Sleep Clock Accuracy Updates"                    },
2720         { 27, "Remote Public Key Validation"                    },
2721         { 28, "Connected Isochronous Stream - Central"          },
2722         { 29, "Connected Isochronous Stream - Peripheral"       },
2723         { 30, "Isochronous Broadcaster"                         },
2724         { 31, "Synchronized Receiver"                           },
2725         { 32, "Connected Isochronous Stream (Host Support)"     },
2726         { 33, "LE Power Control Request"                        },
2727         { 34, "LE Power Control Request"                        },
2728         { 35, "LE Path Loss Monitoring"                         },
2729         { 36, "Periodic Advertising ADI support"                },
2730         { 37, "Connection Subrating"                            },
2731         { 38, "Connection Subrating (Host Support)"             },
2732         { 39, "Channel Classification"                          },
2733         { }
2734 };
2735
2736 static const struct bitfield_data features_msft[] = {
2737         {  0, "RSSI Monitoring feature for BR/EDR"              },
2738         {  1, "RSSI Monitoring feature for LE connections"      },
2739         {  2, "RSSI Monitoring of LE advertisements"            },
2740         {  3, "Advertising Monitoring of LE advertisements"     },
2741         {  4, "Verifying the validity of P-192 and P-256 keys"  },
2742         {  5, "Continuous Advertising Monitoring"               },
2743         { }
2744 };
2745
2746 static void print_features(uint8_t page, const uint8_t *features_array,
2747                                                                 uint8_t type)
2748 {
2749         const struct bitfield_data *features_table = NULL;
2750         uint64_t mask, features = 0;
2751         char str[41];
2752         int i;
2753
2754         for (i = 0; i < 8; i++) {
2755                 sprintf(str + (i * 5), " 0x%2.2x", features_array[i]);
2756                 features |= ((uint64_t) features_array[i]) << (i * 8);
2757         }
2758
2759         print_field("Features:%s", str);
2760
2761         switch (type) {
2762         case 0x00:
2763                 switch (page) {
2764                 case 0:
2765                         features_table = features_page0;
2766                         break;
2767                 case 1:
2768                         features_table = features_page1;
2769                         break;
2770                 case 2:
2771                         features_table = features_page2;
2772                         break;
2773                 }
2774                 break;
2775         case 0x01:
2776                 switch (page) {
2777                 case 0:
2778                         features_table = features_le;
2779                         break;
2780                 }
2781                 break;
2782         case 0xf0:
2783                 switch (page) {
2784                 case 0:
2785                         features_table = features_msft;
2786                         break;
2787                 }
2788                 break;
2789         }
2790
2791         if (!features_table)
2792                 return;
2793
2794         mask = print_bitfield(2, features, features_table);
2795         if (mask)
2796                 print_text(COLOR_UNKNOWN_FEATURE_BIT, "  Unknown features "
2797                                                 "(0x%16.16" PRIx64 ")", mask);
2798 }
2799
2800 void packet_print_features_lmp(const uint8_t *features, uint8_t page)
2801 {
2802         print_features(page, features, 0x00);
2803 }
2804
2805 void packet_print_features_ll(const uint8_t *features)
2806 {
2807         print_features(0, features, 0x01);
2808 }
2809
2810 void packet_print_features_msft(const uint8_t *features)
2811 {
2812         print_features(0, features, 0xf0);
2813 }
2814
2815 #define LE_STATE_SCAN_ADV               0x0001
2816 #define LE_STATE_CONN_ADV               0x0002
2817 #define LE_STATE_NONCONN_ADV            0x0004
2818 #define LE_STATE_HIGH_DIRECT_ADV        0x0008
2819 #define LE_STATE_LOW_DIRECT_ADV         0x0010
2820 #define LE_STATE_ACTIVE_SCAN            0x0020
2821 #define LE_STATE_PASSIVE_SCAN           0x0040
2822 #define LE_STATE_INITIATING             0x0080
2823 #define LE_STATE_CONN_CENTRAL           0x0100
2824 #define LE_STATE_CONN_PERIPHERAL        0x0200
2825 #define LE_STATE_CENTRAL_CENTRAL        0x0400
2826 #define LE_STATE_PERIPHERAL_PERIPHERAL  0x0800
2827 #define LE_STATE_CENTRAL_PERIPHERAL     0x1000
2828
2829 static const struct bitfield_data le_states_desc_table[] = {
2830         {  0, "Scannable Advertising State"                     },
2831         {  1, "Connectable Advertising State"                   },
2832         {  2, "Non-connectable Advertising State"               },
2833         {  3, "High Duty Cycle Directed Advertising State"      },
2834         {  4, "Low Duty Cycle Directed Advertising State"       },
2835         {  5, "Active Scanning State"                           },
2836         {  6, "Passive Scanning State"                          },
2837         {  7, "Initiating State"                                },
2838         {  8, "Connection State (Central Role)"                 },
2839         {  9, "Connection State (Peripheral Role)"              },
2840         { 10, "Central Role & Central Role"                     },
2841         { 11, "Peripheral Role & Peripheral Role"               },
2842         { 12, "Central Role & Peripheral Role"                  },
2843         { }
2844 };
2845
2846 static const struct {
2847         uint8_t bit;
2848         uint16_t states;
2849 } le_states_comb_table[] = {
2850         {  0, LE_STATE_NONCONN_ADV                                      },
2851         {  1, LE_STATE_SCAN_ADV                                         },
2852         {  2, LE_STATE_CONN_ADV                                         },
2853         {  3, LE_STATE_HIGH_DIRECT_ADV                                  },
2854         {  4, LE_STATE_PASSIVE_SCAN                                     },
2855         {  5, LE_STATE_ACTIVE_SCAN                                      },
2856         {  6, LE_STATE_INITIATING | LE_STATE_CONN_CENTRAL               },
2857         {  7, LE_STATE_CONN_PERIPHERAL                                  },
2858         {  8, LE_STATE_PASSIVE_SCAN | LE_STATE_NONCONN_ADV              },
2859         {  9, LE_STATE_PASSIVE_SCAN | LE_STATE_SCAN_ADV                 },
2860         { 10, LE_STATE_PASSIVE_SCAN | LE_STATE_CONN_ADV                 },
2861         { 11, LE_STATE_PASSIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV          },
2862         { 12, LE_STATE_ACTIVE_SCAN | LE_STATE_NONCONN_ADV               },
2863         { 13, LE_STATE_ACTIVE_SCAN | LE_STATE_SCAN_ADV                  },
2864         { 14, LE_STATE_ACTIVE_SCAN | LE_STATE_CONN_ADV                  },
2865         { 15, LE_STATE_ACTIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV           },
2866         { 16, LE_STATE_INITIATING | LE_STATE_NONCONN_ADV                },
2867         { 17, LE_STATE_INITIATING | LE_STATE_SCAN_ADV                   },
2868         { 18, LE_STATE_CONN_CENTRAL | LE_STATE_NONCONN_ADV              },
2869         { 19, LE_STATE_CONN_CENTRAL | LE_STATE_SCAN_ADV                 },
2870         { 20, LE_STATE_CONN_PERIPHERAL | LE_STATE_NONCONN_ADV           },
2871         { 21, LE_STATE_CONN_PERIPHERAL | LE_STATE_SCAN_ADV              },
2872         { 22, LE_STATE_INITIATING | LE_STATE_PASSIVE_SCAN               },
2873         { 23, LE_STATE_INITIATING | LE_STATE_ACTIVE_SCAN                },
2874         { 24, LE_STATE_CONN_CENTRAL | LE_STATE_PASSIVE_SCAN             },
2875         { 25, LE_STATE_CONN_CENTRAL | LE_STATE_ACTIVE_SCAN              },
2876         { 26, LE_STATE_CONN_PERIPHERAL | LE_STATE_PASSIVE_SCAN          },
2877         { 27, LE_STATE_CONN_PERIPHERAL | LE_STATE_ACTIVE_SCAN           },
2878         { 28, LE_STATE_INITIATING | LE_STATE_CONN_CENTRAL |
2879                                         LE_STATE_CENTRAL_CENTRAL        },
2880         { 29, LE_STATE_LOW_DIRECT_ADV                                   },
2881         { 30, LE_STATE_LOW_DIRECT_ADV | LE_STATE_PASSIVE_SCAN           },
2882         { 31, LE_STATE_LOW_DIRECT_ADV | LE_STATE_ACTIVE_SCAN            },
2883         { 32, LE_STATE_INITIATING | LE_STATE_CONN_ADV |
2884                                         LE_STATE_CENTRAL_PERIPHERAL     },
2885         { 33, LE_STATE_INITIATING | LE_STATE_HIGH_DIRECT_ADV |
2886                                         LE_STATE_CENTRAL_PERIPHERAL     },
2887         { 34, LE_STATE_INITIATING | LE_STATE_LOW_DIRECT_ADV |
2888                                         LE_STATE_CENTRAL_PERIPHERAL     },
2889         { 35, LE_STATE_CONN_CENTRAL | LE_STATE_CONN_ADV |
2890                                         LE_STATE_CENTRAL_PERIPHERAL     },
2891         { 36, LE_STATE_CONN_CENTRAL | LE_STATE_HIGH_DIRECT_ADV |
2892                                         LE_STATE_CENTRAL_PERIPHERAL     },
2893         { 37, LE_STATE_CONN_CENTRAL | LE_STATE_LOW_DIRECT_ADV |
2894                                         LE_STATE_CENTRAL_PERIPHERAL     },
2895         { 38, LE_STATE_CONN_PERIPHERAL | LE_STATE_CONN_ADV |
2896                                         LE_STATE_CENTRAL_PERIPHERAL     },
2897         { 39, LE_STATE_CONN_PERIPHERAL | LE_STATE_HIGH_DIRECT_ADV |
2898                                         LE_STATE_PERIPHERAL_PERIPHERAL  },
2899         { 40, LE_STATE_CONN_PERIPHERAL | LE_STATE_LOW_DIRECT_ADV |
2900                                         LE_STATE_PERIPHERAL_PERIPHERAL  },
2901         { 41, LE_STATE_INITIATING | LE_STATE_CONN_PERIPHERAL |
2902                                         LE_STATE_CENTRAL_PERIPHERAL     },
2903         { }
2904 };
2905
2906 static void print_le_states(const uint8_t *states_array)
2907 {
2908         uint64_t mask, states = 0;
2909         int i = 0;
2910         size_t n = 0;
2911
2912         for (i = 0; i < 8; i++)
2913                 states |= ((uint64_t) states_array[i]) << (i * 8);
2914
2915         print_field("States: 0x%16.16" PRIx64, states);
2916
2917         mask = states;
2918
2919         for (i = 0; le_states_comb_table[i].states; i++) {
2920                 uint64_t val = (((uint64_t) 1) << le_states_comb_table[i].bit);
2921                 const char *str[3] = { NULL, };
2922                 size_t num = 0;
2923
2924                 if (!(states & val))
2925                         continue;
2926
2927                 for (n = 0; n < ARRAY_SIZE(le_states_desc_table); n++) {
2928                         if (le_states_comb_table[i].states & (1 << n))
2929                                 str[num++] = le_states_desc_table[n].str;
2930                 }
2931
2932                 if (num > 0) {
2933                         print_field("  %s", str[0]);
2934                         for (n = 1; n < num; n++)
2935                                 print_field("    and %s", str[n]);
2936                 }
2937
2938                 mask &= ~val;
2939         }
2940
2941         if (mask)
2942                 print_text(COLOR_UNKNOWN_LE_STATES, "  Unknown states "
2943                                                 "(0x%16.16" PRIx64 ")", mask);
2944 }
2945
2946 static void print_le_channel_map(const uint8_t *map)
2947 {
2948         unsigned int count = 0, start = 0;
2949         char str[11];
2950         int i, n;
2951
2952         for (i = 0; i < 5; i++)
2953                 sprintf(str + (i * 2), "%2.2x", map[i]);
2954
2955         print_field("Channel map: 0x%s", str);
2956
2957         for (i = 0; i < 5; i++) {
2958                 for (n = 0; n < 8; n++) {
2959                         if (map[i] & (1 << n)) {
2960                                 if (count == 0)
2961                                         start = (i * 8) + n;
2962                                 count++;
2963                                 continue;
2964                         }
2965
2966                         if (count > 1) {
2967                                 print_field("  Channel %u-%u",
2968                                                 start, start + count - 1);
2969                                 count = 0;
2970                         } else if (count > 0) {
2971                                 print_field("  Channel %u", start);
2972                                 count = 0;
2973                         }
2974                 }
2975         }
2976 }
2977
2978 void packet_print_channel_map_ll(const uint8_t *map)
2979 {
2980         print_le_channel_map(map);
2981 }
2982
2983 static void print_random_number(uint64_t rand)
2984 {
2985         print_field("Random number: 0x%16.16" PRIx64, le64_to_cpu(rand));
2986 }
2987
2988 static void print_encrypted_diversifier(uint16_t ediv)
2989 {
2990         print_field("Encrypted diversifier: 0x%4.4x", le16_to_cpu(ediv));
2991 }
2992
2993 static const struct bitfield_data events_table[] = {
2994         {  0, "Inquiry Complete"                                        },
2995         {  1, "Inquiry Result"                                          },
2996         {  2, "Connection Complete"                                     },
2997         {  3, "Connection Request"                                      },
2998         {  4, "Disconnection Complete"                                  },
2999         {  5, "Authentication Complete"                                 },
3000         {  6, "Remote Name Request Complete"                            },
3001         {  7, "Encryption Change"                                       },
3002         {  8, "Change Connection Link Key Complete"                     },
3003         {  9, "Link Key Type Changed"                                   },
3004         { 10, "Read Remote Supported Features Complete"                 },
3005         { 11, "Read Remote Version Information Complete"                },
3006         { 12, "QoS Setup Complete"                                      },
3007         { 13, "Command Complete"                                        },
3008         { 14, "Command Status"                                          },
3009         { 15, "Hardware Error"                                          },
3010         { 16, "Flush Occurred"                                          },
3011         { 17, "Role Change"                                             },
3012         { 18, "Number of Completed Packets"                             },
3013         { 19, "Mode Change"                                             },
3014         { 20, "Return Link Keys"                                        },
3015         { 21, "PIN Code Request"                                        },
3016         { 22, "Link Key Request"                                        },
3017         { 23, "Link Key Notification"                                   },
3018         { 24, "Loopback Command"                                        },
3019         { 25, "Data Buffer Overflow"                                    },
3020         { 26, "Max Slots Change"                                        },
3021         { 27, "Read Clock Offset Complete"                              },
3022         { 28, "Connection Packet Type Changed"                          },
3023         { 29, "QoS Violation"                                           },
3024         { 30, "Page Scan Mode Change"                                   },
3025         { 31, "Page Scan Repetition Mode Change"                        },
3026         { 32, "Flow Specification Complete"                             },
3027         { 33, "Inquiry Result with RSSI"                                },
3028         { 34, "Read Remote Extended Features Complete"                  },
3029         { 43, "Synchronous Connection Complete"                         },
3030         { 44, "Synchronous Connection Changed"                          },
3031         { 45, "Sniff Subrating"                                         },
3032         { 46, "Extended Inquiry Result"                                 },
3033         { 47, "Encryption Key Refresh Complete"                         },
3034         { 48, "IO Capability Request"                                   },
3035         { 49, "IO Capability Request Reply"                             },
3036         { 50, "User Confirmation Request"                               },
3037         { 51, "User Passkey Request"                                    },
3038         { 52, "Remote OOB Data Request"                                 },
3039         { 53, "Simple Pairing Complete"                                 },
3040         { 55, "Link Supervision Timeout Changed"                        },
3041         { 56, "Enhanced Flush Complete"                                 },
3042         { 58, "User Passkey Notification"                               },
3043         { 59, "Keypress Notification"                                   },
3044         { 60, "Remote Host Supported Features Notification"             },
3045         { 61, "LE Meta"                                                 },
3046         { }
3047 };
3048
3049 static void print_event_mask(const uint8_t *events_array,
3050                                         const struct bitfield_data *table)
3051 {
3052         uint64_t mask, events = 0;
3053         int i;
3054
3055         for (i = 0; i < 8; i++)
3056                 events |= ((uint64_t) events_array[i]) << (i * 8);
3057
3058         print_field("Mask: 0x%16.16" PRIx64, events);
3059
3060         mask = print_bitfield(2, events, table);
3061         if (mask)
3062                 print_text(COLOR_UNKNOWN_EVENT_MASK, "  Unknown mask "
3063                                                 "(0x%16.16" PRIx64 ")", mask);
3064 }
3065
3066 static const struct bitfield_data events_page2_table[] = {
3067         {  0, "Physical Link Complete"                                  },
3068         {  1, "Channel Selected"                                        },
3069         {  2, "Disconnection Physical Link Complete"                    },
3070         {  3, "Physical Link Loss Early Warning"                        },
3071         {  4, "Physical Link Recovery"                                  },
3072         {  5, "Logical Link Complete"                                   },
3073         {  6, "Disconnection Logical Link Complete"                     },
3074         {  7, "Flow Specification Modify Complete"                      },
3075         {  8, "Number of Completed Data Blocks"                         },
3076         {  9, "AMP Start Test"                                          },
3077         { 10, "AMP Test End"                                            },
3078         { 11, "AMP Receiver Report"                                     },
3079         { 12, "Short Range Mode Change Complete"                        },
3080         { 13, "AMP Status Change"                                       },
3081         { 14, "Triggered Clock Capture"                                 },
3082         { 15, "Synchronization Train Complete"                          },
3083         { 16, "Synchronization Train Received"                          },
3084         { 17, "Connectionless Peripheral Broadcast Receive"             },
3085         { 18, "Connectionless Peripheral Broadcast Timeout"             },
3086         { 19, "Truncated Page Complete"                                 },
3087         { 20, "Peripheral Page Response Timeout"                        },
3088         { 21, "Connectionless Peripheral Broadcast Channel Map Change"  },
3089         { 22, "Inquiry Response Notification"                           },
3090         { 23, "Authenticated Payload Timeout Expired"                   },
3091         { 24, "SAM Status Change"                                       },
3092         { }
3093 };
3094
3095 static const struct bitfield_data events_le_table[] = {
3096         {  0, "LE Connection Complete"                  },
3097         {  1, "LE Advertising Report"                   },
3098         {  2, "LE Connection Update Complete"           },
3099         {  3, "LE Read Remote Used Features Complete"   },
3100         {  4, "LE Long Term Key Request"                },
3101         {  5, "LE Remote Connection Parameter Request"  },
3102         {  6, "LE Data Length Change"                   },
3103         {  7, "LE Read Local P-256 Public Key Complete" },
3104         {  8, "LE Generate DHKey Complete"              },
3105         {  9, "LE Enhanced Connection Complete"         },
3106         { 10, "LE Direct Advertising Report"            },
3107         { 11, "LE PHY Update Complete"                  },
3108         { 12, "LE Extended Advertising Report"          },
3109         { 13, "LE Periodic Advertising Sync Established"},
3110         { 14, "LE Periodic Advertising Report"          },
3111         { 15, "LE Periodic Advertising Sync Lost"       },
3112         { 16, "LE Extended Scan Timeout"                },
3113         { 17, "LE Extended Advertising Set Terminated"  },
3114         { 18, "LE Scan Request Received"                },
3115         { 19, "LE Channel Selection Algorithm"          },
3116         { 20, "LE Connectionless IQ Report"             },
3117         { 21, "LE Connection IQ Report"                 },
3118         { 22, "LE CTE Request Failed"                   },
3119         { 23, "LE Periodic Advertising Sync Transfer Rvc"},
3120         { 24, "LE CIS Established"                      },
3121         { 25, "LE CIS Request"                          },
3122         { 26, "LE Create BIG Complete"                  },
3123         { 27, "LE Terminate BIG Complete"               },
3124         { 28, "LE BIG Sync Estabilished Complete"       },
3125         { 29, "LE BIG Sync Lost"                        },
3126         { 30, "LE Request Peer SCA Complete"},
3127         { 31, "LE Path Loss Threshold"          },
3128         { 32, "LE Transmit Power Reporting"     },
3129         { 33, "LE BIG Info Advertising Report"  },
3130         { 34, "LE Subrate Change"                       },
3131         { }
3132 };
3133
3134 static void print_fec(uint8_t fec)
3135 {
3136         const char *str;
3137
3138         switch (fec) {
3139         case 0x00:
3140                 str = "Not required";
3141                 break;
3142         case 0x01:
3143                 str = "Required";
3144                 break;
3145         default:
3146                 str = "Reserved";
3147                 break;
3148         }
3149
3150         print_field("FEC: %s (0x%02x)", str, fec);
3151 }
3152
3153 #define BT_EIR_FLAGS                    0x01
3154 #define BT_EIR_UUID16_SOME              0x02
3155 #define BT_EIR_UUID16_ALL               0x03
3156 #define BT_EIR_UUID32_SOME              0x04
3157 #define BT_EIR_UUID32_ALL               0x05
3158 #define BT_EIR_UUID128_SOME             0x06
3159 #define BT_EIR_UUID128_ALL              0x07
3160 #define BT_EIR_NAME_SHORT               0x08
3161 #define BT_EIR_NAME_COMPLETE            0x09
3162 #define BT_EIR_TX_POWER                 0x0a
3163 #define BT_EIR_CLASS_OF_DEV             0x0d
3164 #define BT_EIR_SSP_HASH_P192            0x0e
3165 #define BT_EIR_SSP_RANDOMIZER_P192      0x0f
3166 #define BT_EIR_DEVICE_ID                0x10
3167 #define BT_EIR_SMP_TK                   0x10
3168 #define BT_EIR_SMP_OOB_FLAGS            0x11
3169 #define BT_EIR_PERIPHERAL_CONN_INTERVAL 0x12
3170 #define BT_EIR_SERVICE_UUID16           0x14
3171 #define BT_EIR_SERVICE_UUID128          0x15
3172 #define BT_EIR_SERVICE_DATA             0x16
3173 #define BT_EIR_PUBLIC_ADDRESS           0x17
3174 #define BT_EIR_RANDOM_ADDRESS           0x18
3175 #define BT_EIR_GAP_APPEARANCE           0x19
3176 #define BT_EIR_ADVERTISING_INTERVAL     0x1a
3177 #define BT_EIR_LE_DEVICE_ADDRESS        0x1b
3178 #define BT_EIR_LE_ROLE                  0x1c
3179 #define BT_EIR_SSP_HASH_P256            0x1d
3180 #define BT_EIR_SSP_RANDOMIZER_P256      0x1e
3181 #define BT_EIR_SERVICE_UUID32           0x1f
3182 #define BT_EIR_SERVICE_DATA32           0x20
3183 #define BT_EIR_SERVICE_DATA128          0x21
3184 #define BT_EIR_LE_SC_CONFIRM_VALUE      0x22
3185 #define BT_EIR_LE_SC_RANDOM_VALUE       0x23
3186 #define BT_EIR_URI                      0x24
3187 #define BT_EIR_INDOOR_POSITIONING       0x25
3188 #define BT_EIR_TRANSPORT_DISCOVERY      0x26
3189 #define BT_EIR_LE_SUPPORTED_FEATURES    0x27
3190 #define BT_EIR_CHANNEL_MAP_UPDATE_IND   0x28
3191 #define BT_EIR_MESH_PROV                0x29
3192 #define BT_EIR_MESH_DATA                0x2a
3193 #define BT_EIR_MESH_BEACON              0x2b
3194 #define BT_EIR_CSIP_RSI                 0x2e
3195 #define BT_EIR_3D_INFO_DATA             0x3d
3196 #define BT_EIR_MANUFACTURER_DATA        0xff
3197
3198 static void print_manufacturer_apple(const void *data, uint8_t data_len)
3199 {
3200         uint8_t type = *((uint8_t *) data);
3201
3202         if (data_len < 1)
3203                 return;
3204
3205         if (type == 0x01) {
3206                 char identifier[100];
3207
3208                 snprintf(identifier, sizeof(identifier) - 1, "%s",
3209                                                 (const char *) (data + 1));
3210
3211                 print_field("  Identifier: %s", identifier);
3212                 return;
3213         }
3214
3215         while (data_len > 0) {
3216                 uint8_t len;
3217                 const char *str;
3218
3219                 type = *((uint8_t *) data);
3220                 data++;
3221                 data_len--;
3222
3223                 if (type == 0x00)
3224                         continue;
3225
3226                 if (data_len < 1)
3227                         break;
3228
3229                 switch (type) {
3230                 case 0x02:
3231                         str = "iBeacon";
3232                         break;
3233                 case 0x05:
3234                         str = "AirDrop";
3235                         break;
3236                 case 0x09:
3237                         str = "Apple TV";
3238                         break;
3239                 default:
3240                         str = "Unknown";
3241                         break;
3242                 }
3243
3244                 print_field("  Type: %s (%u)", str, type);
3245
3246                 len = *((uint8_t *) data);
3247                 data++;
3248                 data_len--;
3249
3250                 if (len < 1)
3251                         continue;
3252
3253                 if (len > data_len)
3254                         break;
3255
3256                 if (type == 0x02 && len == 0x15) {
3257                         const uint8_t *uuid;
3258                         uint16_t minor, major;
3259                         int8_t tx_power;
3260
3261                         uuid = data;
3262                         print_field("  UUID: %8.8x-%4.4x-%4.4x-%4.4x-%8.8x%4.4x",
3263                                 get_le32(&uuid[12]), get_le16(&uuid[10]),
3264                                 get_le16(&uuid[8]), get_le16(&uuid[6]),
3265                                 get_le32(&uuid[2]), get_le16(&uuid[0]));
3266
3267                         major = get_le16(data + 16);
3268                         minor = get_le16(data + 18);
3269                         print_field("  Version: %u.%u", major, minor);
3270
3271                         tx_power = *(int8_t *) (data + 20);
3272                         print_field("  TX power: %d dB", tx_power);
3273                 } else
3274                         print_hex_field("  Data", data, len);
3275
3276                 data += len;
3277                 data_len -= len;
3278         }
3279
3280         packet_hexdump(data, data_len);
3281 }
3282
3283 static void print_manufacturer_data(const void *data, uint8_t data_len)
3284 {
3285         uint16_t company = get_le16(data);
3286
3287         packet_print_company("Company", company);
3288
3289         switch (company) {
3290         case 76:
3291         case 19456:
3292                 print_manufacturer_apple(data + 2, data_len - 2);
3293                 break;
3294         default:
3295                 print_hex_field("  Data", data + 2, data_len - 2);
3296                 break;
3297         }
3298 }
3299
3300 static void print_device_id(const void *data, uint8_t data_len)
3301 {
3302         uint16_t source, vendor, product, version;
3303         char modalias[26], *vendor_str, *product_str;
3304         const char *str;
3305
3306         if (data_len < 8)
3307                 return;
3308
3309         source = get_le16(data);
3310         vendor = get_le16(data + 2);
3311         product = get_le16(data + 4);
3312         version = get_le16(data + 6);
3313
3314         switch (source) {
3315         case 0x0001:
3316                 str = "Bluetooth SIG assigned";
3317                 sprintf(modalias, "bluetooth:v%04Xp%04Xd%04X",
3318                                                 vendor, product, version);
3319                 break;
3320         case 0x0002:
3321                 str = "USB Implementer's Forum assigned";
3322                 sprintf(modalias, "usb:v%04Xp%04Xd%04X",
3323                                                 vendor, product, version);
3324                 break;
3325         default:
3326                 str = "Reserved";
3327                 modalias[0] = '\0';
3328                 break;
3329         }
3330
3331         print_field("Device ID: %s (0x%4.4x)", str, source);
3332
3333         if (!hwdb_get_vendor_model(modalias, &vendor_str, &product_str)) {
3334                 vendor_str = NULL;
3335                 product_str = NULL;
3336         }
3337
3338         if (source != 0x0001) {
3339                 if (vendor_str)
3340                         print_field("  Vendor: %s (0x%4.4x)",
3341                                                 vendor_str, vendor);
3342                 else
3343                         print_field("  Vendor: 0x%4.4x", vendor);
3344         } else
3345                 packet_print_company("  Vendor", vendor);
3346
3347         if (product_str)
3348                 print_field("  Product: %s (0x%4.4x)", product_str, product);
3349         else
3350                 print_field("  Product: 0x%4.4x", product);
3351
3352         print_field("  Version: %u.%u.%u (0x%4.4x)",
3353                                         (version & 0xff00) >> 8,
3354                                         (version & 0x00f0) >> 4,
3355                                         (version & 0x000f), version);
3356
3357         free(vendor_str);
3358         free(product_str);
3359 }
3360
3361 static void print_uuid16_list(const char *label, const void *data,
3362                                                         uint8_t data_len)
3363 {
3364         uint8_t count = data_len / sizeof(uint16_t);
3365         unsigned int i;
3366
3367         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3368
3369         for (i = 0; i < count; i++) {
3370                 uint16_t uuid = get_le16(data + (i * 2));
3371                 print_field("  %s (0x%4.4x)", bt_uuid16_to_str(uuid), uuid);
3372         }
3373 }
3374
3375 static void print_uuid32_list(const char *label, const void *data,
3376                                                         uint8_t data_len)
3377 {
3378         uint8_t count = data_len / sizeof(uint32_t);
3379         unsigned int i;
3380
3381         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3382
3383         for (i = 0; i < count; i++) {
3384                 uint32_t uuid = get_le32(data + (i * 4));
3385                 print_field("  %s (0x%8.8x)", bt_uuid32_to_str(uuid), uuid);
3386         }
3387 }
3388
3389 static void print_uuid128_list(const char *label, const void *data,
3390                                                         uint8_t data_len)
3391 {
3392         uint8_t count = data_len / 16;
3393         unsigned int i;
3394
3395         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3396
3397         for (i = 0; i < count; i++) {
3398                 const uint8_t *uuid = data + (i * 16);
3399
3400                 print_field("  %s", bt_uuid128_to_str(uuid));
3401         }
3402 }
3403
3404 static void *iov_pull(struct iovec *iov, size_t len)
3405 {
3406         void *data;
3407
3408         if (iov->iov_len < len)
3409                 return NULL;
3410
3411         data = iov->iov_base;
3412         iov->iov_base += len;
3413         iov->iov_len -= len;
3414
3415         return data;
3416 }
3417
3418 static struct packet_ltv_decoder*
3419 get_ltv_decoder(struct packet_ltv_decoder *decoder, size_t num, uint8_t type)
3420 {
3421         size_t i;
3422
3423         if (!decoder || !num)
3424                 return NULL;
3425
3426         for (i = 0; i < num; i++) {
3427                 struct packet_ltv_decoder *dec = &decoder[i];
3428
3429                 if (dec->type == type)
3430                         return dec;
3431         }
3432
3433         return NULL;
3434 }
3435
3436 static void print_ltv(const char *label, const uint8_t *data, uint8_t len,
3437                         struct packet_ltv_decoder *decoder, size_t num)
3438 {
3439         struct iovec iov;
3440         int i;
3441
3442         iov.iov_base = (void *) data;
3443         iov.iov_len = len;
3444
3445         for (i = 0; iov.iov_len; i++) {
3446                 uint8_t l, t, *v;
3447                 struct packet_ltv_decoder *dec;
3448
3449                 l = get_u8(iov_pull(&iov, sizeof(l)));
3450                 if (!l) {
3451                         print_field("%s #%d: len 0x%02x", label, i, l);
3452                         break;
3453                 }
3454
3455                 v = iov_pull(&iov, sizeof(*v));
3456                 if (!v)
3457                         break;
3458
3459                 t = get_u8(v);
3460
3461                 print_field("%s #%d: len 0x%02x type 0x%02x", label, i, l, t);
3462
3463                 l -= 1;
3464
3465                 v = iov_pull(&iov, l);
3466                 if (!v)
3467                         break;
3468
3469                 dec = get_ltv_decoder(decoder, num, t);
3470                 if (dec)
3471                         dec->func(v, l);
3472                 else
3473                         print_hex_field(label, v, l);
3474         }
3475
3476         if (iov.iov_len)
3477                 print_hex_field(label, iov.iov_base, iov.iov_len);
3478 }
3479
3480 void packet_print_ltv(const char *label, const uint8_t *data, uint8_t len,
3481                         struct packet_ltv_decoder *decoder, size_t decoder_len)
3482 {
3483         print_ltv(label, data, len, decoder, decoder_len);
3484 }
3485
3486 static void print_base_annoucement(const uint8_t *data, uint8_t data_len)
3487 {
3488         struct iovec iov;
3489         struct bt_hci_le_pa_base_data *base_data;
3490         uint8_t i;
3491
3492         iov.iov_base = (void *) data;
3493         iov.iov_len = data_len;
3494
3495         base_data = iov_pull(&iov, sizeof(*base_data));
3496         if (!base_data)
3497                 goto done;
3498
3499         /* Level 1 - BASE */
3500         print_field("  Presetation Delay: %u", get_le24(base_data->pd));
3501         print_field("  Number of Subgroups: %u", base_data->num_subgroups);
3502
3503         /* Level 2 - Subgroups*/
3504         for (i = 0; i < base_data->num_subgroups; i++) {
3505                 struct bt_hci_le_pa_base_subgroup *subgroup;
3506                 struct bt_hci_lv_data *codec_cfg;
3507                 struct bt_hci_lv_data *metadata;
3508                 uint8_t j;
3509
3510                 print_field("    Subgroup #%u:", i);
3511
3512                 subgroup = iov_pull(&iov, sizeof(*subgroup));
3513                 if (!subgroup)
3514                         goto done;
3515
3516                 print_field("    Number of BIS(s): %u", subgroup->num_bis);
3517                 print_codec_id("    Codec", subgroup->codec.id);
3518
3519                 if (subgroup->codec.id == 0xff) {
3520                         uint16_t id;
3521
3522                         id = le16_to_cpu(subgroup->codec.vid);
3523                         print_field("    Codec Company ID: %s (0x%04x)",
3524                                                 bt_compidtostr(id), id);
3525                         print_field("    Codec Vendor ID: 0x%04x",
3526                                                 subgroup->codec.vid);
3527                 }
3528
3529                 codec_cfg = iov_pull(&iov, sizeof(*codec_cfg));
3530                 if (!codec_cfg)
3531                         goto done;
3532
3533                 if (!iov_pull(&iov, codec_cfg->len))
3534                         goto done;
3535
3536                 print_ltv("    Codec Specific Configuration",
3537                                         codec_cfg->data, codec_cfg->len,
3538                                         NULL, 0);
3539
3540                 metadata = iov_pull(&iov, sizeof(*metadata));
3541                 if (!metadata)
3542                         goto done;
3543
3544                 if (!iov_pull(&iov, metadata->len))
3545                         goto done;
3546
3547                 print_ltv("    Metadata", metadata->data, metadata->len,
3548                                         NULL, 0);
3549
3550                 /* Level 3 - BIS(s)*/
3551                 for (j = 0; j < subgroup->num_bis; j++) {
3552                         struct bt_hci_le_pa_base_bis *bis;
3553
3554                         print_field("      BIS #%u:", j);
3555
3556                         bis = iov_pull(&iov, sizeof(*bis));
3557                         if (!bis)
3558                                 goto done;
3559
3560                         print_field("      Index: %u", bis->index);
3561
3562                         codec_cfg = iov_pull(&iov, sizeof(*codec_cfg));
3563                         if (!codec_cfg)
3564                                 goto done;
3565
3566                         if (!iov_pull(&iov, codec_cfg->len))
3567                                 goto done;
3568
3569                         print_hex_field("      Codec Specific Configuration",
3570                                         codec_cfg->data, codec_cfg->len);
3571                 }
3572         }
3573
3574 done:
3575         if (iov.iov_len)
3576                 print_hex_field("  Data", iov.iov_base, iov.iov_len);
3577 }
3578
3579 static void print_broadcast_annoucement(const uint8_t *data, uint8_t data_len)
3580 {
3581         uint32_t bid;
3582
3583         if (data_len < 3) {
3584                 print_hex_field("  Data", data, data_len);
3585                 return;
3586         }
3587
3588         bid = get_le24(data);
3589         print_field("Broadcast ID: %u (0x%06x)", bid, bid);
3590 }
3591
3592 static const struct service_data_decoder {
3593         uint16_t uuid;
3594         void (*func)(const uint8_t *data, uint8_t data_len);
3595 } service_data_decoders[] = {
3596         { 0x1851, print_base_annoucement },
3597         { 0x1852, print_broadcast_annoucement }
3598 };
3599
3600 static void print_service_data(const uint8_t *data, uint8_t data_len)
3601 {
3602         uint16_t uuid = get_le16(&data[0]);
3603         size_t i;
3604
3605         print_field("Service Data: %s (0x%4.4x)", bt_uuid16_to_str(uuid), uuid);
3606
3607         for (i = 0; i < ARRAY_SIZE(service_data_decoders); i++) {
3608                 const struct service_data_decoder *decoder;
3609
3610                 decoder = &service_data_decoders[i];
3611
3612                 if (decoder->uuid == uuid) {
3613                         decoder->func(&data[2], data_len - 2);
3614                         return;
3615                 }
3616         }
3617
3618         print_hex_field("  Data", &data[2], data_len - 2);
3619 }
3620
3621 static const struct bitfield_data eir_flags_table[] = {
3622         { 0, "LE Limited Discoverable Mode"             },
3623         { 1, "LE General Discoverable Mode"             },
3624         { 2, "BR/EDR Not Supported"                     },
3625         { 3, "Simultaneous LE and BR/EDR (Controller)"  },
3626         { 4, "Simultaneous LE and BR/EDR (Host)"        },
3627         { }
3628 };
3629
3630 static const struct bitfield_data eir_3d_table[] = {
3631         { 0, "Association Notification"                                 },
3632         { 1, "Battery Level Reporting"                                  },
3633         { 2, "Send Battery Level Report on Start-up Synchronization"    },
3634         { 7, "Factory Test Mode"                                        },
3635         { }
3636 };
3637
3638 static const struct bitfield_data mesh_oob_table[] = {
3639         { 0, "Other"                                                    },
3640         { 1, "Electronic / URI"                                         },
3641         { 2, "2D machine-readable code"                                 },
3642         { 3, "Bar code"                                                 },
3643         { 4, "Near Field Communication (NFC)"                           },
3644         { 5, "Number"                                                   },
3645         { 6, "String"                                                   },
3646         { 11, "On box"                                                  },
3647         { 12, "Inside box"                                              },
3648         { 13, "On piece of paper"                                       },
3649         { 14, "Inside manual"                                           },
3650         { 15, "On device"                                               },
3651         { }
3652 };
3653
3654 static void print_mesh_beacon(const uint8_t *data, uint8_t len)
3655 {
3656         uint16_t oob;
3657
3658         print_hex_field("Mesh Beacon", data, len);
3659
3660         if (len < 1)
3661                 return;
3662
3663         switch (data[0]) {
3664         case 0x00:
3665                 print_field("  Unprovisioned Device Beacon (0x00)");
3666                 if (len < 18) {
3667                         packet_hexdump(data + 1, len - 1);
3668                         break;
3669                 }
3670
3671                 print_hex_field("  Device UUID", data + 1, 16);
3672
3673                 oob = get_be16(data + 17);
3674                 print_field("  OOB Information: 0x%4.4x", oob);
3675
3676                 print_bitfield(4, oob, mesh_oob_table);
3677
3678                 if (len < 23) {
3679                         packet_hexdump(data + 18, len - 18);
3680                         break;
3681                 }
3682
3683                 print_field("  URI Hash: 0x%8.8x", get_be32(data + 19));
3684                 packet_hexdump(data + 23, len - 23);
3685                 break;
3686         case 0x01:
3687                 print_field("  Secure Network Beacon (0x01)");
3688                 if (len < 22) {
3689                         packet_hexdump(data + 1, len - 1);
3690                         break;
3691                 }
3692
3693                 print_field("  Flags: 0x%2.2x", data[0]);
3694
3695                 if (data[1] & 0x01)
3696                         print_field("    Key Refresh");
3697
3698                 if (data[1] & 0x02)
3699                         print_field("    IV Update");
3700
3701                 print_hex_field("  Network Id", data + 2, 8);
3702                 print_field("  IV Index: 0x%08x", get_be32(data + 10));
3703                 print_hex_field("  Authentication Value", data + 14, 8);
3704                 packet_hexdump(data + 22, len - 22);
3705                 break;
3706         default:
3707                 print_field("  Invalid Beacon (0x%02x)", data[0]);
3708                 packet_hexdump(data, len);
3709                 break;
3710         }
3711 }
3712
3713 static void print_mesh_prov(const uint8_t *data, uint8_t len)
3714 {
3715         print_hex_field("Mesh Provisioning", data, len);
3716
3717         if (len < 6) {
3718                 packet_hexdump(data, len);
3719                 return;
3720         }
3721
3722         print_field("  Link ID: 0x%08x", get_be32(data));
3723         print_field("  Transaction Number: %u", data[4]);
3724
3725         data += 5;
3726         len -= 5;
3727
3728         switch (data[0] & 0x03) {
3729         case 0x00:
3730                 print_field("  Transaction Start (0x00)");
3731                 if (len < 5) {
3732                         packet_hexdump(data + 1, len - 1);
3733                         return;
3734                 }
3735                 print_field("  SeqN: %u", data[0] & 0xfc >> 2);
3736                 print_field("  TotalLength: %u", get_be16(data + 1));
3737                 print_field("  FCS: 0x%2.2x", data[3]);
3738                 print_hex_field("  Data", data + 4, len - 4);
3739                 packet_hexdump(data + 5, len - 5);
3740                 break;
3741         case 0x01:
3742                 print_field("  Transaction Acknowledgment (0x01)");
3743                 packet_hexdump(data + 1, len - 1);
3744                 break;
3745         case 0x02:
3746                 print_field("  Transaction Continuation (0x02)");
3747                 print_field("  SegmentIndex: %u", data[0] >> 2);
3748                 if (len < 2) {
3749                         packet_hexdump(data + 1, len - 1);
3750                         return;
3751                 }
3752                 print_hex_field("  Data", data + 1, len - 1);
3753                 packet_hexdump(data + 2, len - 2);
3754                 break;
3755         case 0x03:
3756                 print_field("  Provisioning Bearer Control (0x03)");
3757                 switch (data[0] >> 2) {
3758                 case 0x00:
3759                         print_field("  Link Open (0x00)");
3760                         if (len < 17) {
3761                                 packet_hexdump(data + 1, len - 1);
3762                                 break;
3763                         }
3764                         print_hex_field("  Device UUID", data, 16);
3765                         break;
3766                 case 0x01:
3767                         print_field("  Link Ack (0x01)");
3768                         break;
3769                 case 0x02:
3770                         print_field("  Link Close (0x02)");
3771                         if (len < 2) {
3772                                 packet_hexdump(data + 1, len - 1);
3773                                 break;
3774                         }
3775
3776                         switch (data[1]) {
3777                         case 0x00:
3778                                 print_field("  Reason: Success (0x00)");
3779                                 break;
3780                         case 0x01:
3781                                 print_field("  Reason: Timeout (0x01)");
3782                                 break;
3783                         case 0x02:
3784                                 print_field("  Reason: Fail (0x02)");
3785                                 break;
3786                         default:
3787                                 print_field("  Reason: Unrecognized (0x%2.2x)",
3788                                                                 data[1]);
3789                         }
3790                         packet_hexdump(data + 2, len - 2);
3791                         break;
3792                 default:
3793                         packet_hexdump(data + 1, len - 1);
3794                         break;
3795                 }
3796                 break;
3797         default:
3798                 print_field("  Invalid Command (0x%02x)", data[0]);
3799                 packet_hexdump(data, len);
3800                 break;
3801         }
3802 }
3803
3804 static void print_mesh_data(const uint8_t *data, uint8_t len)
3805 {
3806         print_hex_field("Mesh Data", data, len);
3807
3808         if (len < 1)
3809                 return;
3810
3811         print_field("  IVI: %u", data[0] >> 7);
3812         print_field("  NID: 0x%2.2x", data[0] & 0x7f);
3813         packet_hexdump(data + 1, len - 1);
3814 }
3815
3816 static void print_transport_data(const uint8_t *data, uint8_t len)
3817 {
3818         print_field("Transport Discovery Data");
3819
3820         if (len < 3)
3821                 return;
3822
3823         print_field("  Organization: %s (0x%02x)",
3824                         data[0] == 0x01 ? "Bluetooth SIG" : "RFU", data[0]);
3825         print_field("  Flags: 0x%2.2x", data[1]);
3826         print_field("    Role: 0x%2.2x", data[1] & 0x03);
3827
3828         switch (data[1] & 0x03) {
3829         case 0x00:
3830                 print_field("      Not Specified");
3831                 break;
3832         case 0x01:
3833                 print_field("      Seeker Only");
3834                 break;
3835         case 0x02:
3836                 print_field("      Provider Only");
3837                 break;
3838         case 0x03:
3839                 print_field("      Both Seeker an Provider");
3840                 break;
3841         }
3842
3843         print_field("    Transport Data Incomplete: %s (0x%2.2x)",
3844                         data[1] & 0x04 ? "True" : "False", data[1] & 0x04);
3845
3846         print_field("    Transport State: 0x%2.2x", data[1] & 0x18);
3847
3848         switch (data[1] & 0x18) {
3849         case 0x00:
3850                 print_field("      Off");
3851                 break;
3852         case 0x08:
3853                 print_field("      On");
3854                 break;
3855         case 0x10:
3856                 print_field("      Temporary Unavailable");
3857                 break;
3858         case 0x18:
3859                 print_field("      RFU");
3860                 break;
3861         }
3862
3863         print_field("  Length: %u", data[2]);
3864         print_hex_field("  Data", data + 3, len - 3);
3865 }
3866
3867 static void print_eir(const uint8_t *eir, uint8_t eir_len, bool le)
3868 {
3869         uint16_t len = 0;
3870
3871         if (eir_len == 0)
3872                 return;
3873
3874         while (len < eir_len - 1) {
3875                 uint8_t field_len = eir[0];
3876                 const uint8_t *data = &eir[2];
3877                 uint8_t data_len;
3878                 char name[239], label[100];
3879                 uint8_t flags, mask;
3880
3881                 /* Check for the end of EIR */
3882                 if (field_len == 0)
3883                         break;
3884
3885                 len += field_len + 1;
3886
3887                 /* Do not continue EIR Data parsing if got incorrect length */
3888                 if (len > eir_len) {
3889                         len -= field_len + 1;
3890                         break;
3891                 }
3892
3893                 data_len = field_len - 1;
3894
3895                 switch (eir[1]) {
3896                 case BT_EIR_FLAGS:
3897                         flags = *data;
3898
3899                         print_field("Flags: 0x%2.2x", flags);
3900
3901                         mask = print_bitfield(2, flags, eir_flags_table);
3902                         if (mask)
3903                                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
3904                                         "  Unknown flags (0x%2.2x)", mask);
3905                         break;
3906
3907                 case BT_EIR_UUID16_SOME:
3908                         if (data_len < sizeof(uint16_t))
3909                                 break;
3910                         print_uuid16_list("16-bit Service UUIDs (partial)",
3911                                                         data, data_len);
3912                         break;
3913
3914                 case BT_EIR_UUID16_ALL:
3915                         if (data_len < sizeof(uint16_t))
3916                                 break;
3917                         print_uuid16_list("16-bit Service UUIDs (complete)",
3918                                                         data, data_len);
3919                         break;
3920
3921                 case BT_EIR_UUID32_SOME:
3922                         if (data_len < sizeof(uint32_t))
3923                                 break;
3924                         print_uuid32_list("32-bit Service UUIDs (partial)",
3925                                                         data, data_len);
3926                         break;
3927
3928                 case BT_EIR_UUID32_ALL:
3929                         if (data_len < sizeof(uint32_t))
3930                                 break;
3931                         print_uuid32_list("32-bit Service UUIDs (complete)",
3932                                                         data, data_len);
3933                         break;
3934
3935                 case BT_EIR_UUID128_SOME:
3936                         if (data_len < 16)
3937                                 break;
3938                         print_uuid128_list("128-bit Service UUIDs (partial)",
3939                                                                 data, data_len);
3940                         break;
3941
3942                 case BT_EIR_UUID128_ALL:
3943                         if (data_len < 16)
3944                                 break;
3945                         print_uuid128_list("128-bit Service UUIDs (complete)",
3946                                                                 data, data_len);
3947                         break;
3948
3949                 case BT_EIR_NAME_SHORT:
3950                         memset(name, 0, sizeof(name));
3951                         memcpy(name, data, data_len);
3952                         print_field("Name (short): %s", name);
3953                         break;
3954
3955                 case BT_EIR_NAME_COMPLETE:
3956                         memset(name, 0, sizeof(name));
3957                         memcpy(name, data, data_len);
3958                         print_field("Name (complete): %s", name);
3959                         break;
3960
3961                 case BT_EIR_TX_POWER:
3962                         if (data_len < 1)
3963                                 break;
3964                         print_field("TX power: %d dBm", (int8_t) *data);
3965                         break;
3966
3967                 case BT_EIR_CLASS_OF_DEV:
3968                         if (data_len < 3)
3969                                 break;
3970                         print_dev_class(data);
3971                         break;
3972
3973                 case BT_EIR_SSP_HASH_P192:
3974                         if (data_len < 16)
3975                                 break;
3976                         print_hash_p192(data);
3977                         break;
3978
3979                 case BT_EIR_SSP_RANDOMIZER_P192:
3980                         if (data_len < 16)
3981                                 break;
3982                         print_randomizer_p192(data);
3983                         break;
3984
3985                 case BT_EIR_DEVICE_ID:
3986                         /* SMP TK has the same value as Device ID */
3987                         if (le)
3988                                 print_hex_field("SMP TK", data, data_len);
3989                         else if (data_len >= 8)
3990                                 print_device_id(data, data_len);
3991                         break;
3992
3993                 case BT_EIR_SMP_OOB_FLAGS:
3994                         print_field("SMP OOB Flags: 0x%2.2x", *data);
3995                         break;
3996
3997                 case BT_EIR_PERIPHERAL_CONN_INTERVAL:
3998                         if (data_len < 4)
3999                                 break;
4000                         print_field("Peripheral Conn. Interval: "
4001                                                         "0x%4.4x - 0x%4.4x",
4002                                                         get_le16(&data[0]),
4003                                                         get_le16(&data[2]));
4004                         break;
4005
4006                 case BT_EIR_SERVICE_UUID16:
4007                         if (data_len < sizeof(uint16_t))
4008                                 break;
4009                         print_uuid16_list("16-bit Service UUIDs",
4010                                                         data, data_len);
4011                         break;
4012
4013                 case BT_EIR_SERVICE_UUID128:
4014                         if (data_len < 16)
4015                                 break;
4016                         print_uuid128_list("128-bit Service UUIDs",
4017                                                         data, data_len);
4018                         break;
4019
4020                 case BT_EIR_SERVICE_DATA:
4021                         if (data_len < 2)
4022                                 break;
4023                         print_service_data(data, data_len);
4024                         break;
4025
4026                 case BT_EIR_SERVICE_DATA128:
4027                         if (data_len <= 16)
4028                                 break;
4029
4030                         print_field("Service Data UUID 128: %s ",
4031                                                 bt_uuid128_to_str(&data[0]));
4032
4033                         if (data_len > 16)
4034                                 print_hex_field("  Data", &data[16],
4035                                                                 data_len - 16);
4036
4037                         break;
4038                 case BT_EIR_RANDOM_ADDRESS:
4039                         if (data_len < 6)
4040                                 break;
4041                         print_addr("Random Address", data, 0x01);
4042                         break;
4043
4044                 case BT_EIR_PUBLIC_ADDRESS:
4045                         if (data_len < 6)
4046                                 break;
4047                         print_addr("Public Address", data, 0x00);
4048                         break;
4049
4050                 case BT_EIR_GAP_APPEARANCE:
4051                         if (data_len < 2)
4052                                 break;
4053                         print_appearance(get_le16(data));
4054                         break;
4055
4056                 case BT_EIR_SSP_HASH_P256:
4057                         if (data_len < 16)
4058                                 break;
4059                         print_hash_p256(data);
4060                         break;
4061
4062                 case BT_EIR_SSP_RANDOMIZER_P256:
4063                         if (data_len < 16)
4064                                 break;
4065                         print_randomizer_p256(data);
4066                         break;
4067
4068                 case BT_EIR_TRANSPORT_DISCOVERY:
4069                         print_transport_data(data, data_len);
4070                         break;
4071
4072                 case BT_EIR_3D_INFO_DATA:
4073                         print_hex_field("3D Information Data", data, data_len);
4074                         if (data_len < 2)
4075                                 break;
4076
4077                         flags = *data;
4078
4079                         print_field("  Features: 0x%2.2x", flags);
4080
4081                         mask = print_bitfield(4, flags, eir_3d_table);
4082                         if (mask)
4083                                 print_text(COLOR_UNKNOWN_FEATURE_BIT,
4084                                         "      Unknown features (0x%2.2x)", mask);
4085
4086                         print_field("  Path Loss Threshold: %d", data[1]);
4087                         break;
4088
4089                 case BT_EIR_MESH_DATA:
4090                         print_mesh_data(data, data_len);
4091                         break;
4092
4093                 case BT_EIR_MESH_PROV:
4094                         print_mesh_prov(data, data_len);
4095                         break;
4096
4097                 case BT_EIR_MESH_BEACON:
4098                         print_mesh_beacon(data, data_len);
4099                         break;
4100
4101                 case BT_EIR_CSIP_RSI:
4102                         if (data_len < 6)
4103                                 break;
4104                         print_addr("Resolvable Set Identifier", data, 0xff);
4105                         print_field("  Hash: 0x%6x", get_le24(data));
4106                         print_field("  Random: 0x%6x", get_le24(data + 3));
4107                         break;
4108
4109                 case BT_EIR_MANUFACTURER_DATA:
4110                         if (data_len < 2)
4111                                 break;
4112                         print_manufacturer_data(data, data_len);
4113                         break;
4114
4115                 default:
4116                         sprintf(label, "Unknown EIR field 0x%2.2x", eir[1]);
4117                         print_hex_field(label, data, data_len);
4118                         break;
4119                 }
4120
4121                 eir += field_len + 1;
4122         }
4123
4124         if (len < eir_len && eir[0] != 0)
4125                 packet_hexdump(eir, eir_len - len);
4126 }
4127
4128 void packet_print_addr(const char *label, const void *data, uint8_t type)
4129 {
4130         print_addr(label ? : "Address", data, type);
4131 }
4132
4133 void packet_print_handle(uint16_t handle)
4134 {
4135         print_handle_native(handle);
4136 }
4137
4138 void packet_print_rssi(const char *label, int8_t rssi)
4139 {
4140         if ((uint8_t) rssi == 0x99 || rssi == 127)
4141                 print_field("%s: invalid (0x%2.2x)", label, (uint8_t) rssi);
4142         else
4143                 print_field("%s: %d dBm (0x%2.2x)", label, rssi,
4144                                                         (uint8_t) rssi);
4145 }
4146
4147 void packet_print_ad(const void *data, uint8_t size)
4148 {
4149         print_eir(data, size, true);
4150 }
4151
4152 struct broadcast_message {
4153         uint32_t frame_sync_instant;
4154         uint16_t bluetooth_clock_phase;
4155         uint16_t left_open_offset;
4156         uint16_t left_close_offset;
4157         uint16_t right_open_offset;
4158         uint16_t right_close_offset;
4159         uint16_t frame_sync_period;
4160         uint8_t  frame_sync_period_fraction;
4161 } __attribute__ ((packed));
4162
4163 static void print_3d_broadcast(const void *data, uint8_t size)
4164 {
4165         const struct broadcast_message *msg = data;
4166         uint32_t instant;
4167         uint16_t left_open, left_close, right_open, right_close;
4168         uint16_t phase, period;
4169         uint8_t period_frac;
4170         bool mode;
4171
4172         instant = le32_to_cpu(msg->frame_sync_instant);
4173         mode = !!(instant & 0x40000000);
4174         phase = le16_to_cpu(msg->bluetooth_clock_phase);
4175         left_open = le16_to_cpu(msg->left_open_offset);
4176         left_close = le16_to_cpu(msg->left_close_offset);
4177         right_open = le16_to_cpu(msg->right_open_offset);
4178         right_close = le16_to_cpu(msg->right_close_offset);
4179         period = le16_to_cpu(msg->frame_sync_period);
4180         period_frac = msg->frame_sync_period_fraction;
4181
4182         print_field("  Frame sync instant: 0x%8.8x", instant & 0x7fffffff);
4183         print_field("  Video mode: %s (%d)", mode ? "Dual View" : "3D", mode);
4184         print_field("  Bluetooth clock phase: %d usec (0x%4.4x)",
4185                                                 phase, phase);
4186         print_field("  Left lense shutter open offset: %d usec (0x%4.4x)",
4187                                                 left_open, left_open);
4188         print_field("  Left lense shutter close offset: %d usec (0x%4.4x)",
4189                                                 left_close, left_close);
4190         print_field("  Right lense shutter open offset: %d usec (0x%4.4x)",
4191                                                 right_open, right_open);
4192         print_field("  Right lense shutter close offset: %d usec (0x%4.4x)",
4193                                                 right_close, right_close);
4194         print_field("  Frame sync period: %d.%d usec (0x%4.4x 0x%2.2x)",
4195                                                 period, period_frac * 256,
4196                                                 period, period_frac);
4197 }
4198
4199 void packet_hexdump(const unsigned char *buf, uint16_t len)
4200 {
4201         static const char hexdigits[] = "0123456789abcdef";
4202         char str[68];
4203         uint16_t i;
4204
4205         if (!len)
4206                 return;
4207
4208         for (i = 0; i < len; i++) {
4209                 str[((i % 16) * 3) + 0] = hexdigits[buf[i] >> 4];
4210                 str[((i % 16) * 3) + 1] = hexdigits[buf[i] & 0xf];
4211                 str[((i % 16) * 3) + 2] = ' ';
4212                 str[(i % 16) + 49] = isprint(buf[i]) ? buf[i] : '.';
4213
4214                 if ((i + 1) % 16 == 0) {
4215                         str[47] = ' ';
4216                         str[48] = ' ';
4217                         str[65] = '\0';
4218                         print_text(COLOR_WHITE, "%s", str);
4219                         str[0] = ' ';
4220                 }
4221         }
4222
4223         if (i % 16 > 0) {
4224                 uint16_t j;
4225                 for (j = (i % 16); j < 16; j++) {
4226                         str[(j * 3) + 0] = ' ';
4227                         str[(j * 3) + 1] = ' ';
4228                         str[(j * 3) + 2] = ' ';
4229                         str[j + 49] = ' ';
4230                 }
4231                 str[47] = ' ';
4232                 str[48] = ' ';
4233                 str[65] = '\0';
4234                 print_text(COLOR_WHITE, "%s", str);
4235         }
4236 }
4237
4238 void packet_control(struct timeval *tv, struct ucred *cred,
4239                                         uint16_t index, uint16_t opcode,
4240                                         const void *data, uint16_t size)
4241 {
4242         control_message(opcode, data, size);
4243 }
4244
4245 static int addr2str(const uint8_t *addr, char *str)
4246 {
4247         return sprintf(str, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
4248                         addr[5], addr[4], addr[3], addr[2], addr[1], addr[0]);
4249 }
4250
4251 void packet_monitor(struct timeval *tv, struct ucred *cred,
4252                                         uint16_t index, uint16_t opcode,
4253                                         const void *data, uint16_t size)
4254 {
4255         const struct btsnoop_opcode_new_index *ni;
4256         const struct btsnoop_opcode_index_info *ii;
4257         const struct btsnoop_opcode_user_logging *ul;
4258         char str[18], extra_str[24];
4259         uint16_t manufacturer;
4260         const char *ident;
4261
4262         if (index != HCI_DEV_NONE) {
4263                 index_current = index;
4264         }
4265
4266         if (tv && time_offset == ((time_t) -1))
4267                 time_offset = tv->tv_sec;
4268
4269         switch (opcode) {
4270         case BTSNOOP_OPCODE_NEW_INDEX:
4271                 ni = data;
4272
4273                 if (index < MAX_INDEX) {
4274                         index_list[index].type = ni->type;
4275                         memcpy(index_list[index].bdaddr, ni->bdaddr, 6);
4276                         index_list[index].manufacturer = fallback_manufacturer;
4277                         index_list[index].msft_opcode = BT_HCI_CMD_NOP;
4278                 }
4279
4280                 addr2str(ni->bdaddr, str);
4281                 packet_new_index(tv, index, str, ni->type, ni->bus, ni->name);
4282                 break;
4283         case BTSNOOP_OPCODE_DEL_INDEX:
4284                 if (index < MAX_INDEX)
4285                         addr2str(index_list[index].bdaddr, str);
4286                 else
4287                         sprintf(str, "00:00:00:00:00:00");
4288
4289                 packet_del_index(tv, index, str);
4290                 break;
4291         case BTSNOOP_OPCODE_COMMAND_PKT:
4292                 packet_hci_command(tv, cred, index, data, size);
4293                 break;
4294         case BTSNOOP_OPCODE_EVENT_PKT:
4295                 packet_hci_event(tv, cred, index, data, size);
4296                 break;
4297         case BTSNOOP_OPCODE_ACL_TX_PKT:
4298                 packet_hci_acldata(tv, cred, index, false, data, size);
4299                 break;
4300         case BTSNOOP_OPCODE_ACL_RX_PKT:
4301                 packet_hci_acldata(tv, cred, index, true, data, size);
4302                 break;
4303         case BTSNOOP_OPCODE_SCO_TX_PKT:
4304                 packet_hci_scodata(tv, cred, index, false, data, size);
4305                 break;
4306         case BTSNOOP_OPCODE_SCO_RX_PKT:
4307                 packet_hci_scodata(tv, cred, index, true, data, size);
4308                 break;
4309         case BTSNOOP_OPCODE_ISO_TX_PKT:
4310                 packet_hci_isodata(tv, cred, index, false, data, size);
4311                 break;
4312         case BTSNOOP_OPCODE_ISO_RX_PKT:
4313                 packet_hci_isodata(tv, cred, index, true, data, size);
4314                 break;
4315         case BTSNOOP_OPCODE_OPEN_INDEX:
4316                 if (index < MAX_INDEX)
4317                         addr2str(index_list[index].bdaddr, str);
4318                 else
4319                         sprintf(str, "00:00:00:00:00:00");
4320
4321                 packet_open_index(tv, index, str);
4322                 break;
4323         case BTSNOOP_OPCODE_CLOSE_INDEX:
4324                 if (index < MAX_INDEX)
4325                         addr2str(index_list[index].bdaddr, str);
4326                 else
4327                         sprintf(str, "00:00:00:00:00:00");
4328
4329                 packet_close_index(tv, index, str);
4330                 break;
4331         case BTSNOOP_OPCODE_INDEX_INFO:
4332                 ii = data;
4333                 manufacturer = le16_to_cpu(ii->manufacturer);
4334
4335                 if (index < MAX_INDEX) {
4336                         memcpy(index_list[index].bdaddr, ii->bdaddr, 6);
4337                         index_list[index].manufacturer = manufacturer;
4338
4339                         switch (manufacturer) {
4340                         case 2:
4341                                 /*
4342                                  * Intel controllers that support the
4343                                  * Microsoft vendor extension are using
4344                                  * 0xFC1E for VsMsftOpCode.
4345                                  */
4346                                 index_list[index].msft_opcode = 0xFC1E;
4347                                 break;
4348                         case 93:
4349                                 /*
4350                                  * Realtek controllers that support the
4351                                  * Microsoft vendor extenions are using
4352                                  * 0xFCF0 for VsMsftOpCode.
4353                                  */
4354                                 index_list[index].msft_opcode = 0xFCF0;
4355                                 break;
4356                         case 1521:
4357                                 /*
4358                                  * Emulator controllers use Linux Foundation as
4359                                  * manufacturer and support the
4360                                  * Microsoft vendor extenions using
4361                                  * 0xFC1E for VsMsftOpCode.
4362                                  */
4363                                 index_list[index].msft_opcode = 0xFC1E;
4364                                 break;
4365                         }
4366                 }
4367
4368                 addr2str(ii->bdaddr, str);
4369                 packet_index_info(tv, index, str, manufacturer);
4370                 break;
4371         case BTSNOOP_OPCODE_VENDOR_DIAG:
4372                 if (index < MAX_INDEX)
4373                         manufacturer = index_list[index].manufacturer;
4374                 else
4375                         manufacturer = fallback_manufacturer;
4376
4377                 packet_vendor_diag(tv, index, manufacturer, data, size);
4378                 break;
4379         case BTSNOOP_OPCODE_SYSTEM_NOTE:
4380                 packet_system_note(tv, cred, index, data);
4381                 break;
4382         case BTSNOOP_OPCODE_USER_LOGGING:
4383                 ul = data;
4384                 ident = ul->ident_len ? data + sizeof(*ul) : NULL;
4385
4386                 packet_user_logging(tv, cred, index, ul->priority, ident,
4387                                         data + sizeof(*ul) + ul->ident_len,
4388                                         size - (sizeof(*ul) + ul->ident_len));
4389                 break;
4390         case BTSNOOP_OPCODE_CTRL_OPEN:
4391                 control_disable_decoding();
4392                 packet_ctrl_open(tv, cred, index, data, size);
4393                 break;
4394         case BTSNOOP_OPCODE_CTRL_CLOSE:
4395                 packet_ctrl_close(tv, cred, index, data, size);
4396                 break;
4397         case BTSNOOP_OPCODE_CTRL_COMMAND:
4398                 packet_ctrl_command(tv, cred, index, data, size);
4399                 break;
4400         case BTSNOOP_OPCODE_CTRL_EVENT:
4401                 packet_ctrl_event(tv, cred, index, data, size);
4402                 break;
4403         default:
4404                 sprintf(extra_str, "(code %d len %d)", opcode, size);
4405                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
4406                                         "Unknown packet", NULL, extra_str);
4407                 packet_hexdump(data, size);
4408                 break;
4409         }
4410 }
4411
4412 void packet_simulator(struct timeval *tv, uint16_t frequency,
4413                                         const void *data, uint16_t size)
4414 {
4415         char str[10];
4416
4417         if (tv && time_offset == ((time_t) -1))
4418                 time_offset = tv->tv_sec;
4419
4420         sprintf(str, "%u MHz", frequency);
4421
4422         print_packet(tv, NULL, '*', 0, NULL, COLOR_PHY_PACKET,
4423                                         "Physical packet:", NULL, str);
4424
4425         ll_packet(frequency, data, size, false);
4426 }
4427
4428 static void null_cmd(uint16_t index, const void *data, uint8_t size)
4429 {
4430 }
4431
4432 static void status_rsp(uint16_t index, const void *data, uint8_t size)
4433 {
4434         uint8_t status = *((const uint8_t *) data);
4435
4436         print_status(status);
4437 }
4438
4439 static void status_handle_rsp(uint16_t index, const void *data, uint8_t size)
4440 {
4441         uint8_t status = *((const uint8_t *) data);
4442
4443         print_status(status);
4444         print_field("Connection handle: %d", get_u8(data + 1));
4445 }
4446
4447 static void status_bdaddr_rsp(uint16_t index, const void *data, uint8_t size)
4448 {
4449         uint8_t status = *((const uint8_t *) data);
4450
4451         print_status(status);
4452         print_bdaddr(data + 1);
4453 }
4454
4455 static void inquiry_cmd(uint16_t index, const void *data, uint8_t size)
4456 {
4457         const struct bt_hci_cmd_inquiry *cmd = data;
4458
4459         print_iac(cmd->lap);
4460         print_field("Length: %.2fs (0x%2.2x)",
4461                                 cmd->length * 1.28, cmd->length);
4462         print_num_resp(cmd->num_resp);
4463 }
4464
4465 static void periodic_inquiry_cmd(uint16_t index, const void *data, uint8_t size)
4466 {
4467         const struct bt_hci_cmd_periodic_inquiry *cmd = data;
4468
4469         print_field("Max period: %.2fs (0x%2.2x)",
4470                                 cmd->max_period * 1.28, cmd->max_period);
4471         print_field("Min period: %.2fs (0x%2.2x)",
4472                                 cmd->min_period * 1.28, cmd->min_period);
4473         print_iac(cmd->lap);
4474         print_field("Length: %.2fs (0x%2.2x)",
4475                                 cmd->length * 1.28, cmd->length);
4476         print_num_resp(cmd->num_resp);
4477 }
4478
4479 static void create_conn_cmd(uint16_t index, const void *data, uint8_t size)
4480 {
4481         const struct bt_hci_cmd_create_conn *cmd = data;
4482         const char *str;
4483
4484         print_bdaddr(cmd->bdaddr);
4485         print_pkt_type(cmd->pkt_type);
4486         print_pscan_rep_mode(cmd->pscan_rep_mode);
4487         print_pscan_mode(cmd->pscan_mode);
4488         print_clock_offset(cmd->clock_offset);
4489
4490         switch (cmd->role_switch) {
4491         case 0x00:
4492                 str = "Stay central";
4493                 break;
4494         case 0x01:
4495                 str = "Allow peripheral";
4496                 break;
4497         default:
4498                 str = "Reserved";
4499                 break;
4500         }
4501
4502         print_field("Role switch: %s (0x%2.2x)", str, cmd->role_switch);
4503 }
4504
4505 static void disconnect_cmd(uint16_t index, const void *data, uint8_t size)
4506 {
4507         const struct bt_hci_cmd_disconnect *cmd = data;
4508
4509         print_handle(cmd->handle);
4510         print_reason(cmd->reason);
4511 }
4512
4513 static void add_sco_conn_cmd(uint16_t index, const void *data, uint8_t size)
4514 {
4515         const struct bt_hci_cmd_add_sco_conn *cmd = data;
4516
4517         print_handle(cmd->handle);
4518         print_pkt_type_sco(cmd->pkt_type);
4519 }
4520
4521 static void create_conn_cancel_cmd(uint16_t index, const void *data,
4522                                                         uint8_t size)
4523 {
4524         const struct bt_hci_cmd_create_conn_cancel *cmd = data;
4525
4526         print_bdaddr(cmd->bdaddr);
4527 }
4528
4529 static void accept_conn_request_cmd(uint16_t index, const void *data,
4530                                                         uint8_t size)
4531 {
4532         const struct bt_hci_cmd_accept_conn_request *cmd = data;
4533
4534         print_bdaddr(cmd->bdaddr);
4535         print_role(cmd->role);
4536 }
4537
4538 static void reject_conn_request_cmd(uint16_t index, const void *data,
4539                                                         uint8_t size)
4540 {
4541         const struct bt_hci_cmd_reject_conn_request *cmd = data;
4542
4543         print_bdaddr(cmd->bdaddr);
4544         print_reason(cmd->reason);
4545 }
4546
4547 static void link_key_request_reply_cmd(uint16_t index, const void *data,
4548                                                         uint8_t size)
4549 {
4550         const struct bt_hci_cmd_link_key_request_reply *cmd = data;
4551
4552         print_bdaddr(cmd->bdaddr);
4553         print_link_key(cmd->link_key);
4554 }
4555
4556 static void link_key_request_neg_reply_cmd(uint16_t index, const void *data,
4557                                                         uint8_t size)
4558 {
4559         const struct bt_hci_cmd_link_key_request_neg_reply *cmd = data;
4560
4561         print_bdaddr(cmd->bdaddr);
4562 }
4563
4564 static void pin_code_request_reply_cmd(uint16_t index, const void *data,
4565                                                         uint8_t size)
4566 {
4567         const struct bt_hci_cmd_pin_code_request_reply *cmd = data;
4568
4569         print_bdaddr(cmd->bdaddr);
4570         print_field("PIN length: %d", cmd->pin_len);
4571         print_pin_code(cmd->pin_code, cmd->pin_len);
4572 }
4573
4574 static void pin_code_request_neg_reply_cmd(uint16_t index, const void *data,
4575                                                         uint8_t size)
4576 {
4577         const struct bt_hci_cmd_pin_code_request_neg_reply *cmd = data;
4578
4579         print_bdaddr(cmd->bdaddr);
4580 }
4581
4582 static void change_conn_pkt_type_cmd(uint16_t index, const void *data,
4583                                                         uint8_t size)
4584 {
4585         const struct bt_hci_cmd_change_conn_pkt_type *cmd = data;
4586
4587         print_handle(cmd->handle);
4588         print_pkt_type(cmd->pkt_type);
4589 }
4590
4591 static void auth_requested_cmd(uint16_t index, const void *data, uint8_t size)
4592 {
4593         const struct bt_hci_cmd_auth_requested *cmd = data;
4594
4595         print_handle(cmd->handle);
4596 }
4597
4598 static void set_conn_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
4599 {
4600         const struct bt_hci_cmd_set_conn_encrypt *cmd = data;
4601
4602         print_handle(cmd->handle);
4603         print_enable("Encryption", cmd->encr_mode);
4604 }
4605
4606 static void change_conn_link_key_cmd(uint16_t index, const void *data,
4607                                                         uint8_t size)
4608 {
4609         const struct bt_hci_cmd_change_conn_link_key *cmd = data;
4610
4611         print_handle(cmd->handle);
4612 }
4613
4614 static void link_key_selection_cmd(uint16_t index, const void *data,
4615                                                         uint8_t size)
4616 {
4617         const struct bt_hci_cmd_link_key_selection *cmd = data;
4618
4619         print_key_flag(cmd->key_flag);
4620 }
4621
4622 static void remote_name_request_cmd(uint16_t index, const void *data,
4623                                                         uint8_t size)
4624 {
4625         const struct bt_hci_cmd_remote_name_request *cmd = data;
4626
4627         print_bdaddr(cmd->bdaddr);
4628         print_pscan_rep_mode(cmd->pscan_rep_mode);
4629         print_pscan_mode(cmd->pscan_mode);
4630         print_clock_offset(cmd->clock_offset);
4631 }
4632
4633 static void remote_name_request_cancel_cmd(uint16_t index, const void *data,
4634                                                         uint8_t size)
4635 {
4636         const struct bt_hci_cmd_remote_name_request_cancel *cmd = data;
4637
4638         print_bdaddr(cmd->bdaddr);
4639 }
4640
4641 static void read_remote_features_cmd(uint16_t index, const void *data,
4642                                                         uint8_t size)
4643 {
4644         const struct bt_hci_cmd_read_remote_features *cmd = data;
4645
4646         print_handle(cmd->handle);
4647 }
4648
4649 static void read_remote_ext_features_cmd(uint16_t index, const void *data,
4650                                                         uint8_t size)
4651 {
4652         const struct bt_hci_cmd_read_remote_ext_features *cmd = data;
4653
4654         print_handle(cmd->handle);
4655         print_field("Page: %d", cmd->page);
4656 }
4657
4658 static void read_remote_version_cmd(uint16_t index, const void *data,
4659                                                         uint8_t size)
4660 {
4661         const struct bt_hci_cmd_read_remote_version *cmd = data;
4662
4663         print_handle(cmd->handle);
4664 }
4665
4666 static void read_clock_offset_cmd(uint16_t index, const void *data,
4667                                                         uint8_t size)
4668 {
4669         const struct bt_hci_cmd_read_clock_offset *cmd = data;
4670
4671         print_handle(cmd->handle);
4672 }
4673
4674 static void read_lmp_handle_cmd(uint16_t index, const void *data, uint8_t size)
4675 {
4676         const struct bt_hci_cmd_read_lmp_handle *cmd = data;
4677
4678         print_handle(cmd->handle);
4679 }
4680
4681 static void read_lmp_handle_rsp(uint16_t index, const void *data, uint8_t size)
4682 {
4683         const struct bt_hci_rsp_read_lmp_handle *rsp = data;
4684
4685         print_status(rsp->status);
4686         print_handle(rsp->handle);
4687         print_field("LMP handle: %d", rsp->lmp_handle);
4688         print_field("Reserved: %d", le32_to_cpu(rsp->reserved));
4689 }
4690
4691 static void setup_sync_conn_cmd(uint16_t index, const void *data, uint8_t size)
4692 {
4693         const struct bt_hci_cmd_setup_sync_conn *cmd = data;
4694
4695         print_handle(cmd->handle);
4696         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4697         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4698         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4699         print_voice_setting(cmd->voice_setting);
4700         print_retransmission_effort(cmd->retrans_effort);
4701         print_pkt_type_sco(cmd->pkt_type);
4702 }
4703
4704 static void accept_sync_conn_request_cmd(uint16_t index, const void *data,
4705                                                         uint8_t size)
4706 {
4707         const struct bt_hci_cmd_accept_sync_conn_request *cmd = data;
4708
4709         print_bdaddr(cmd->bdaddr);
4710         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4711         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4712         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4713         print_voice_setting(cmd->voice_setting);
4714         print_retransmission_effort(cmd->retrans_effort);
4715         print_pkt_type_sco(cmd->pkt_type);
4716 }
4717
4718 static void reject_sync_conn_request_cmd(uint16_t index, const void *data,
4719                                                         uint8_t size)
4720 {
4721         const struct bt_hci_cmd_reject_sync_conn_request *cmd = data;
4722
4723         print_bdaddr(cmd->bdaddr);
4724         print_reason(cmd->reason);
4725 }
4726
4727 static void io_capability_request_reply_cmd(uint16_t index, const void *data,
4728                                                         uint8_t size)
4729 {
4730         const struct bt_hci_cmd_io_capability_request_reply *cmd = data;
4731
4732         print_bdaddr(cmd->bdaddr);
4733         print_io_capability(cmd->capability);
4734         print_oob_data(cmd->oob_data);
4735         print_authentication(cmd->authentication);
4736 }
4737
4738 static void user_confirm_request_reply_cmd(uint16_t index, const void *data,
4739                                                         uint8_t size)
4740 {
4741         const struct bt_hci_cmd_user_confirm_request_reply *cmd = data;
4742
4743         print_bdaddr(cmd->bdaddr);
4744 }
4745
4746 static void user_confirm_request_neg_reply_cmd(uint16_t index, const void *data,
4747                                                         uint8_t size)
4748 {
4749         const struct bt_hci_cmd_user_confirm_request_neg_reply *cmd = data;
4750
4751         print_bdaddr(cmd->bdaddr);
4752 }
4753
4754 static void user_passkey_request_reply_cmd(uint16_t index, const void *data,
4755                                                         uint8_t size)
4756 {
4757         const struct bt_hci_cmd_user_passkey_request_reply *cmd = data;
4758
4759         print_bdaddr(cmd->bdaddr);
4760         print_passkey(cmd->passkey);
4761 }
4762
4763 static void user_passkey_request_neg_reply_cmd(uint16_t index, const void *data,
4764                                                         uint8_t size)
4765 {
4766         const struct bt_hci_cmd_user_passkey_request_neg_reply *cmd = data;
4767
4768         print_bdaddr(cmd->bdaddr);
4769 }
4770
4771 static void remote_oob_data_request_reply_cmd(uint16_t index, const void *data,
4772                                                         uint8_t size)
4773 {
4774         const struct bt_hci_cmd_remote_oob_data_request_reply *cmd = data;
4775
4776         print_bdaddr(cmd->bdaddr);
4777         print_hash_p192(cmd->hash);
4778         print_randomizer_p192(cmd->randomizer);
4779 }
4780
4781 static void remote_oob_data_request_neg_reply_cmd(uint16_t index,
4782                                                 const void *data, uint8_t size)
4783 {
4784         const struct bt_hci_cmd_remote_oob_data_request_neg_reply *cmd = data;
4785
4786         print_bdaddr(cmd->bdaddr);
4787 }
4788
4789 static void io_capability_request_neg_reply_cmd(uint16_t index,
4790                                                 const void *data, uint8_t size)
4791 {
4792         const struct bt_hci_cmd_io_capability_request_neg_reply *cmd = data;
4793
4794         print_bdaddr(cmd->bdaddr);
4795         print_reason(cmd->reason);
4796 }
4797
4798 static void create_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4799 {
4800         const struct bt_hci_cmd_create_phy_link *cmd = data;
4801
4802         print_phy_handle(cmd->phy_handle);
4803         print_key_len(cmd->key_len);
4804         print_key_type(cmd->key_type);
4805
4806         packet_hexdump(data + 3, size - 3);
4807 }
4808
4809 static void accept_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4810 {
4811         const struct bt_hci_cmd_accept_phy_link *cmd = data;
4812
4813         print_phy_handle(cmd->phy_handle);
4814         print_key_len(cmd->key_len);
4815         print_key_type(cmd->key_type);
4816
4817         packet_hexdump(data + 3, size - 3);
4818 }
4819
4820 static void disconn_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4821 {
4822         const struct bt_hci_cmd_disconn_phy_link *cmd = data;
4823
4824         print_phy_handle(cmd->phy_handle);
4825         print_reason(cmd->reason);
4826 }
4827
4828 static void create_logic_link_cmd(uint16_t index, const void *data,
4829                                                         uint8_t size)
4830 {
4831         const struct bt_hci_cmd_create_logic_link *cmd = data;
4832
4833         print_phy_handle(cmd->phy_handle);
4834         print_flow_spec("TX", cmd->tx_flow_spec);
4835         print_flow_spec("RX", cmd->rx_flow_spec);
4836 }
4837
4838 static void accept_logic_link_cmd(uint16_t index, const void *data,
4839                                                         uint8_t size)
4840 {
4841         const struct bt_hci_cmd_accept_logic_link *cmd = data;
4842
4843         print_phy_handle(cmd->phy_handle);
4844         print_flow_spec("TX", cmd->tx_flow_spec);
4845         print_flow_spec("RX", cmd->rx_flow_spec);
4846 }
4847
4848 static void disconn_logic_link_cmd(uint16_t index, const void *data,
4849                                                         uint8_t size)
4850 {
4851         const struct bt_hci_cmd_disconn_logic_link *cmd = data;
4852
4853         print_handle(cmd->handle);
4854 }
4855
4856 static void logic_link_cancel_cmd(uint16_t index, const void *data,
4857                                                         uint8_t size)
4858 {
4859         const struct bt_hci_cmd_logic_link_cancel *cmd = data;
4860
4861         print_phy_handle(cmd->phy_handle);
4862         print_field("TX flow spec: 0x%2.2x", cmd->flow_spec);
4863 }
4864
4865 static void logic_link_cancel_rsp(uint16_t index, const void *data,
4866                                                         uint8_t size)
4867 {
4868         const struct bt_hci_rsp_logic_link_cancel *rsp = data;
4869
4870         print_status(rsp->status);
4871         print_phy_handle(rsp->phy_handle);
4872         print_field("TX flow spec: 0x%2.2x", rsp->flow_spec);
4873 }
4874
4875 static void flow_spec_modify_cmd(uint16_t index, const void *data, uint8_t size)
4876 {
4877         const struct bt_hci_cmd_flow_spec_modify *cmd = data;
4878
4879         print_handle(cmd->handle);
4880         print_flow_spec("TX", cmd->tx_flow_spec);
4881         print_flow_spec("RX", cmd->rx_flow_spec);
4882 }
4883
4884 static void enhanced_setup_sync_conn_cmd(uint16_t index, const void *data,
4885                                                         uint8_t size)
4886 {
4887         const struct bt_hci_cmd_enhanced_setup_sync_conn *cmd = data;
4888
4889         print_handle(cmd->handle);
4890         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4891         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4892
4893         /* TODO */
4894
4895         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4896         print_pkt_type_sco(cmd->pkt_type);
4897         print_retransmission_effort(cmd->retrans_effort);
4898 }
4899
4900 static void enhanced_accept_sync_conn_request_cmd(uint16_t index,
4901                                                 const void *data,
4902                                                 uint8_t size)
4903 {
4904         const struct bt_hci_cmd_enhanced_accept_sync_conn_request *cmd = data;
4905
4906         print_bdaddr(cmd->bdaddr);
4907         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4908         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4909
4910         /* TODO */
4911
4912         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4913         print_pkt_type_sco(cmd->pkt_type);
4914         print_retransmission_effort(cmd->retrans_effort);
4915 }
4916
4917 static void truncated_page_cmd(uint16_t index, const void *data, uint8_t size)
4918 {
4919         const struct bt_hci_cmd_truncated_page *cmd = data;
4920
4921         print_bdaddr(cmd->bdaddr);
4922         print_pscan_rep_mode(cmd->pscan_rep_mode);
4923         print_clock_offset(cmd->clock_offset);
4924 }
4925
4926 static void truncated_page_cancel_cmd(uint16_t index, const void *data,
4927                                                         uint8_t size)
4928 {
4929         const struct bt_hci_cmd_truncated_page_cancel *cmd = data;
4930
4931         print_bdaddr(cmd->bdaddr);
4932 }
4933
4934 static void set_peripheral_broadcast_cmd(uint16_t index, const void *data,
4935                                                         uint8_t size)
4936 {
4937         const struct bt_hci_cmd_set_peripheral_broadcast *cmd = data;
4938
4939         print_field("Enable: 0x%2.2x", cmd->enable);
4940         print_lt_addr(cmd->lt_addr);
4941         print_lpo_allowed(cmd->lpo_allowed);
4942         print_pkt_type(cmd->pkt_type);
4943         print_slot_625("Min interval", cmd->min_interval);
4944         print_slot_625("Max interval", cmd->max_interval);
4945         print_slot_625("Supervision timeout", cmd->timeout);
4946 }
4947
4948 static void set_peripheral_broadcast_rsp(uint16_t index, const void *data,
4949                                                         uint8_t size)
4950 {
4951         const struct bt_hci_rsp_set_peripheral_broadcast *rsp = data;
4952
4953         print_status(rsp->status);
4954         print_lt_addr(rsp->lt_addr);
4955         print_interval(rsp->interval);
4956 }
4957
4958 static void set_peripheral_broadcast_receive_cmd(uint16_t index,
4959                                                 const void *data, uint8_t size)
4960 {
4961         const struct bt_hci_cmd_set_peripheral_broadcast_receive *cmd = data;
4962
4963         print_field("Enable: 0x%2.2x", cmd->enable);
4964         print_bdaddr(cmd->bdaddr);
4965         print_lt_addr(cmd->lt_addr);
4966         print_interval(cmd->interval);
4967         print_field("Offset: 0x%8.8x", le32_to_cpu(cmd->offset));
4968         print_field("Next broadcast instant: 0x%4.4x",
4969                                         le16_to_cpu(cmd->instant));
4970         print_slot_625("Supervision timeout", cmd->timeout);
4971         print_field("Remote timing accuracy: %d ppm", cmd->accuracy);
4972         print_field("Skip: 0x%2.2x", cmd->skip);
4973         print_pkt_type(cmd->pkt_type);
4974         print_channel_map(cmd->map);
4975 }
4976
4977 static void set_peripheral_broadcast_receive_rsp(uint16_t index,
4978                                                 const void *data, uint8_t size)
4979 {
4980         const struct bt_hci_rsp_set_peripheral_broadcast_receive *rsp = data;
4981
4982         print_status(rsp->status);
4983         print_bdaddr(rsp->bdaddr);
4984         print_lt_addr(rsp->lt_addr);
4985 }
4986
4987 static void receive_sync_train_cmd(uint16_t index, const void *data,
4988                                                         uint8_t size)
4989 {
4990         const struct bt_hci_cmd_receive_sync_train *cmd = data;
4991
4992         print_bdaddr(cmd->bdaddr);
4993         print_timeout(cmd->timeout);
4994         print_window(cmd->window);
4995         print_interval(cmd->interval);
4996 }
4997
4998 static void remote_oob_ext_data_request_reply_cmd(uint16_t index,
4999                                                 const void *data, uint8_t size)
5000 {
5001         const struct bt_hci_cmd_remote_oob_ext_data_request_reply *cmd = data;
5002
5003         print_bdaddr(cmd->bdaddr);
5004         print_hash_p192(cmd->hash192);
5005         print_randomizer_p192(cmd->randomizer192);
5006         print_hash_p256(cmd->hash256);
5007         print_randomizer_p256(cmd->randomizer256);
5008 }
5009
5010 static void hold_mode_cmd(uint16_t index, const void *data, uint8_t size)
5011 {
5012         const struct bt_hci_cmd_hold_mode *cmd = data;
5013
5014         print_handle(cmd->handle);
5015         print_slot_625("Hold max interval", cmd->max_interval);
5016         print_slot_625("Hold min interval", cmd->min_interval);
5017 }
5018
5019 static void sniff_mode_cmd(uint16_t index, const void *data, uint8_t size)
5020 {
5021         const struct bt_hci_cmd_sniff_mode *cmd = data;
5022
5023         print_handle(cmd->handle);
5024         print_slot_625("Sniff max interval", cmd->max_interval);
5025         print_slot_625("Sniff min interval", cmd->min_interval);
5026         print_slot_125("Sniff attempt", cmd->attempt);
5027         print_slot_125("Sniff timeout", cmd->timeout);
5028 }
5029
5030 static void exit_sniff_mode_cmd(uint16_t index, const void *data, uint8_t size)
5031 {
5032         const struct bt_hci_cmd_exit_sniff_mode *cmd = data;
5033
5034         print_handle(cmd->handle);
5035 }
5036
5037 static void park_state_cmd(uint16_t index, const void *data, uint8_t size)
5038 {
5039         const struct bt_hci_cmd_park_state *cmd = data;
5040
5041         print_handle(cmd->handle);
5042         print_slot_625("Beacon max interval", cmd->max_interval);
5043         print_slot_625("Beacon min interval", cmd->min_interval);
5044 }
5045
5046 static void exit_park_state_cmd(uint16_t index, const void *data, uint8_t size)
5047 {
5048         const struct bt_hci_cmd_exit_park_state *cmd = data;
5049
5050         print_handle(cmd->handle);
5051 }
5052
5053 static void qos_setup_cmd(uint16_t index, const void *data, uint8_t size)
5054 {
5055         const struct bt_hci_cmd_qos_setup *cmd = data;
5056
5057         print_handle(cmd->handle);
5058         print_field("Flags: 0x%2.2x", cmd->flags);
5059
5060         print_service_type(cmd->service_type);
5061
5062         print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
5063         print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
5064         print_field("Latency: %d", le32_to_cpu(cmd->latency));
5065         print_field("Delay variation: %d", le32_to_cpu(cmd->delay_variation));
5066 }
5067
5068 static void role_discovery_cmd(uint16_t index, const void *data, uint8_t size)
5069 {
5070         const struct bt_hci_cmd_role_discovery *cmd = data;
5071
5072         print_handle(cmd->handle);
5073 }
5074
5075 static void role_discovery_rsp(uint16_t index, const void *data, uint8_t size)
5076 {
5077         const struct bt_hci_rsp_role_discovery *rsp = data;
5078
5079         print_status(rsp->status);
5080         print_handle(rsp->handle);
5081         print_role(rsp->role);
5082 }
5083
5084 static void switch_role_cmd(uint16_t index, const void *data, uint8_t size)
5085 {
5086         const struct bt_hci_cmd_switch_role *cmd = data;
5087
5088         print_bdaddr(cmd->bdaddr);
5089         print_role(cmd->role);
5090 }
5091
5092 static void read_link_policy_cmd(uint16_t index, const void *data, uint8_t size)
5093 {
5094         const struct bt_hci_cmd_read_link_policy *cmd = data;
5095
5096         print_handle(cmd->handle);
5097 }
5098
5099 static void read_link_policy_rsp(uint16_t index, const void *data, uint8_t size)
5100 {
5101         const struct bt_hci_rsp_read_link_policy *rsp = data;
5102
5103         print_status(rsp->status);
5104         print_handle(rsp->handle);
5105         print_link_policy(rsp->policy);
5106 }
5107
5108 static void write_link_policy_cmd(uint16_t index, const void *data,
5109                                                         uint8_t size)
5110 {
5111         const struct bt_hci_cmd_write_link_policy *cmd = data;
5112
5113         print_handle(cmd->handle);
5114         print_link_policy(cmd->policy);
5115 }
5116
5117 static void write_link_policy_rsp(uint16_t index, const void *data,
5118                                                         uint8_t size)
5119 {
5120         const struct bt_hci_rsp_write_link_policy *rsp = data;
5121
5122         print_status(rsp->status);
5123         print_handle(rsp->handle);
5124 }
5125
5126 static void read_default_link_policy_rsp(uint16_t index, const void *data,
5127                                                         uint8_t size)
5128 {
5129         const struct bt_hci_rsp_read_default_link_policy *rsp = data;
5130
5131         print_status(rsp->status);
5132         print_link_policy(rsp->policy);
5133 }
5134
5135 static void write_default_link_policy_cmd(uint16_t index, const void *data,
5136                                                         uint8_t size)
5137 {
5138         const struct bt_hci_cmd_write_default_link_policy *cmd = data;
5139
5140         print_link_policy(cmd->policy);
5141 }
5142
5143 static void flow_spec_cmd(uint16_t index, const void *data, uint8_t size)
5144 {
5145         const struct bt_hci_cmd_flow_spec *cmd = data;
5146
5147         print_handle(cmd->handle);
5148         print_field("Flags: 0x%2.2x", cmd->flags);
5149
5150         print_flow_direction(cmd->direction);
5151         print_service_type(cmd->service_type);
5152
5153         print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
5154         print_field("Token bucket size: %d",
5155                                         le32_to_cpu(cmd->token_bucket_size));
5156         print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
5157         print_field("Access latency: %d", le32_to_cpu(cmd->access_latency));
5158 }
5159
5160 static void sniff_subrating_cmd(uint16_t index, const void *data, uint8_t size)
5161 {
5162         const struct bt_hci_cmd_sniff_subrating *cmd = data;
5163
5164         print_handle(cmd->handle);
5165         print_slot_625("Max latency", cmd->max_latency);
5166         print_slot_625("Min remote timeout", cmd->min_remote_timeout);
5167         print_slot_625("Min local timeout", cmd->min_local_timeout);
5168 }
5169
5170 static void sniff_subrating_rsp(uint16_t index, const void *data, uint8_t size)
5171 {
5172         const struct bt_hci_rsp_sniff_subrating *rsp = data;
5173
5174         print_status(rsp->status);
5175         print_handle(rsp->handle);
5176 }
5177
5178 static void set_event_mask_cmd(uint16_t index, const void *data, uint8_t size)
5179 {
5180         const struct bt_hci_cmd_set_event_mask *cmd = data;
5181
5182         print_event_mask(cmd->mask, events_table);
5183 }
5184
5185 static void set_event_filter_cmd(uint16_t index, const void *data, uint8_t size)
5186 {
5187         uint8_t type = *((const uint8_t *) data);
5188         uint8_t filter;
5189         const char *str;
5190
5191         switch (type) {
5192         case 0x00:
5193                 str = "Clear All Filters";
5194                 break;
5195         case 0x01:
5196                 str = "Inquiry Result";
5197                 break;
5198         case 0x02:
5199                 str = "Connection Setup";
5200                 break;
5201         default:
5202                 str = "Reserved";
5203                 break;
5204         }
5205
5206         print_field("Type: %s (0x%2.2x)", str, type);
5207
5208         switch (type) {
5209         case 0x00:
5210                 if (size > 1) {
5211                         print_text(COLOR_ERROR, "  invalid parameter size");
5212                         packet_hexdump(data + 1, size - 1);
5213                 }
5214                 break;
5215
5216         case 0x01:
5217                 if (size < 2) {
5218                         print_text(COLOR_ERROR, "  invalid parameter size");
5219                         break;
5220                 }
5221                 filter = *((const uint8_t *) (data + 1));
5222
5223                 switch (filter) {
5224                 case 0x00:
5225                         str = "Return responses from all devices";
5226                         break;
5227                 case 0x01:
5228                         str = "Device with specific Class of Device";
5229                         break;
5230                 case 0x02:
5231                         str = "Device with specific BD_ADDR";
5232                         break;
5233                 default:
5234                         str = "Reserved";
5235                         break;
5236                 }
5237
5238                 print_field("Filter: %s (0x%2.2x)", str, filter);
5239                 packet_hexdump(data + 2, size - 2);
5240                 break;
5241
5242         case 0x02:
5243                 filter = *((const uint8_t *) (data + 1));
5244
5245                 switch (filter) {
5246                 case 0x00:
5247                         str = "Allow connections all devices";
5248                         break;
5249                 case 0x01:
5250                         str = "Allow connections with specific Class of Device";
5251                         break;
5252                 case 0x02:
5253                         str = "Allow connections with specific BD_ADDR";
5254                         break;
5255                 default:
5256                         str = "Reserved";
5257                         break;
5258                 }
5259
5260                 if (size < 2) {
5261                         print_text(COLOR_ERROR, "  invalid parameter size");
5262                         break;
5263                 }
5264
5265                 print_field("Filter: %s (0x%2.2x)", str, filter);
5266                 packet_hexdump(data + 2, size - 2);
5267                 break;
5268
5269         default:
5270                 if (size < 2) {
5271                         print_text(COLOR_ERROR, "  invalid parameter size");
5272                         break;
5273                 }
5274
5275                 filter = *((const uint8_t *) (data + 1));
5276
5277                 print_field("Filter: Reserved (0x%2.2x)", filter);
5278                 packet_hexdump(data + 2, size - 2);
5279                 break;
5280         }
5281 }
5282
5283 static void flush_cmd(uint16_t index, const void *data, uint8_t size)
5284 {
5285         const struct bt_hci_cmd_flush *cmd = data;
5286
5287         print_handle(cmd->handle);
5288 }
5289
5290 static void flush_rsp(uint16_t index, const void *data, uint8_t size)
5291 {
5292         const struct bt_hci_rsp_flush *rsp = data;
5293
5294         print_status(rsp->status);
5295         print_handle(rsp->handle);
5296 }
5297
5298 static void read_pin_type_rsp(uint16_t index, const void *data, uint8_t size)
5299 {
5300         const struct bt_hci_rsp_read_pin_type *rsp = data;
5301
5302         print_status(rsp->status);
5303         print_pin_type(rsp->pin_type);
5304 }
5305
5306 static void write_pin_type_cmd(uint16_t index, const void *data, uint8_t size)
5307 {
5308         const struct bt_hci_cmd_write_pin_type *cmd = data;
5309
5310         print_pin_type(cmd->pin_type);
5311 }
5312
5313 static void read_stored_link_key_cmd(uint16_t index, const void *data,
5314                                                         uint8_t size)
5315 {
5316         const struct bt_hci_cmd_read_stored_link_key *cmd = data;
5317
5318         print_bdaddr(cmd->bdaddr);
5319         print_field("Read all: 0x%2.2x", cmd->read_all);
5320 }
5321
5322 static void read_stored_link_key_rsp(uint16_t index, const void *data,
5323                                                         uint8_t size)
5324 {
5325         const struct bt_hci_rsp_read_stored_link_key *rsp = data;
5326
5327         print_status(rsp->status);
5328         print_field("Max num keys: %d", le16_to_cpu(rsp->max_num_keys));
5329         print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
5330 }
5331
5332 static void write_stored_link_key_cmd(uint16_t index, const void *data,
5333                                                         uint8_t size)
5334 {
5335         const struct bt_hci_cmd_write_stored_link_key *cmd = data;
5336
5337         print_field("Num keys: %d", cmd->num_keys);
5338
5339         packet_hexdump(data + 1, size - 1);
5340 }
5341
5342 static void write_stored_link_key_rsp(uint16_t index, const void *data,
5343                                                         uint8_t size)
5344 {
5345         const struct bt_hci_rsp_write_stored_link_key *rsp = data;
5346
5347         print_status(rsp->status);
5348         print_field("Num keys: %d", rsp->num_keys);
5349 }
5350
5351 static void delete_stored_link_key_cmd(uint16_t index, const void *data,
5352                                                         uint8_t size)
5353 {
5354         const struct bt_hci_cmd_delete_stored_link_key *cmd = data;
5355
5356         print_bdaddr(cmd->bdaddr);
5357         print_field("Delete all: 0x%2.2x", cmd->delete_all);
5358 }
5359
5360 static void delete_stored_link_key_rsp(uint16_t index, const void *data,
5361                                                         uint8_t size)
5362 {
5363         const struct bt_hci_rsp_delete_stored_link_key *rsp = data;
5364
5365         print_status(rsp->status);
5366         print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
5367 }
5368
5369 static void write_local_name_cmd(uint16_t index, const void *data, uint8_t size)
5370 {
5371         const struct bt_hci_cmd_write_local_name *cmd = data;
5372
5373         print_name(cmd->name);
5374 }
5375
5376 static void read_local_name_rsp(uint16_t index, const void *data, uint8_t size)
5377 {
5378         const struct bt_hci_rsp_read_local_name *rsp = data;
5379
5380         print_status(rsp->status);
5381         print_name(rsp->name);
5382 }
5383
5384 static void read_conn_accept_timeout_rsp(uint16_t index, const void *data,
5385                                                         uint8_t size)
5386 {
5387         const struct bt_hci_rsp_read_conn_accept_timeout *rsp = data;
5388
5389         print_status(rsp->status);
5390         print_timeout(rsp->timeout);
5391 }
5392
5393 static void write_conn_accept_timeout_cmd(uint16_t index, const void *data,
5394                                                         uint8_t size)
5395 {
5396         const struct bt_hci_cmd_write_conn_accept_timeout *cmd = data;
5397
5398         print_timeout(cmd->timeout);
5399 }
5400
5401 static void read_page_timeout_rsp(uint16_t index, const void *data,
5402                                                         uint8_t size)
5403 {
5404         const struct bt_hci_rsp_read_page_timeout *rsp = data;
5405
5406         print_status(rsp->status);
5407         print_timeout(rsp->timeout);
5408 }
5409
5410 static void write_page_timeout_cmd(uint16_t index, const void *data,
5411                                                         uint8_t size)
5412 {
5413         const struct bt_hci_cmd_write_page_timeout *cmd = data;
5414
5415         print_timeout(cmd->timeout);
5416 }
5417
5418 static void read_scan_enable_rsp(uint16_t index, const void *data, uint8_t size)
5419 {
5420         const struct bt_hci_rsp_read_scan_enable *rsp = data;
5421
5422         print_status(rsp->status);
5423         print_scan_enable(rsp->enable);
5424 }
5425
5426 static void write_scan_enable_cmd(uint16_t index, const void *data,
5427                                                         uint8_t size)
5428 {
5429         const struct bt_hci_cmd_write_scan_enable *cmd = data;
5430
5431         print_scan_enable(cmd->enable);
5432 }
5433
5434 static void read_page_scan_activity_rsp(uint16_t index, const void *data,
5435                                                         uint8_t size)
5436 {
5437         const struct bt_hci_rsp_read_page_scan_activity *rsp = data;
5438
5439         print_status(rsp->status);
5440         print_interval(rsp->interval);
5441         print_window(rsp->window);
5442 }
5443
5444 static void write_page_scan_activity_cmd(uint16_t index, const void *data,
5445                                                         uint8_t size)
5446 {
5447         const struct bt_hci_cmd_write_page_scan_activity *cmd = data;
5448
5449         print_interval(cmd->interval);
5450         print_window(cmd->window);
5451 }
5452
5453 static void read_inquiry_scan_activity_rsp(uint16_t index, const void *data,
5454                                                         uint8_t size)
5455 {
5456         const struct bt_hci_rsp_read_inquiry_scan_activity *rsp = data;
5457
5458         print_status(rsp->status);
5459         print_interval(rsp->interval);
5460         print_window(rsp->window);
5461 }
5462
5463 static void write_inquiry_scan_activity_cmd(uint16_t index, const void *data,
5464                                                         uint8_t size)
5465 {
5466         const struct bt_hci_cmd_write_inquiry_scan_activity *cmd = data;
5467
5468         print_interval(cmd->interval);
5469         print_window(cmd->window);
5470 }
5471
5472 static void read_auth_enable_rsp(uint16_t index, const void *data, uint8_t size)
5473 {
5474         const struct bt_hci_rsp_read_auth_enable *rsp = data;
5475
5476         print_status(rsp->status);
5477         print_auth_enable(rsp->enable);
5478 }
5479
5480 static void write_auth_enable_cmd(uint16_t index, const void *data,
5481                                                         uint8_t size)
5482 {
5483         const struct bt_hci_cmd_write_auth_enable *cmd = data;
5484
5485         print_auth_enable(cmd->enable);
5486 }
5487
5488 static void read_encrypt_mode_rsp(uint16_t index, const void *data,
5489                                                         uint8_t size)
5490 {
5491         const struct bt_hci_rsp_read_encrypt_mode *rsp = data;
5492
5493         print_status(rsp->status);
5494         print_encrypt_mode(rsp->mode);
5495 }
5496
5497 static void write_encrypt_mode_cmd(uint16_t index, const void *data,
5498                                                         uint8_t size)
5499 {
5500         const struct bt_hci_cmd_write_encrypt_mode *cmd = data;
5501
5502         print_encrypt_mode(cmd->mode);
5503 }
5504
5505 static void read_class_of_dev_rsp(uint16_t index, const void *data,
5506                                                         uint8_t size)
5507 {
5508         const struct bt_hci_rsp_read_class_of_dev *rsp = data;
5509
5510         print_status(rsp->status);
5511         print_dev_class(rsp->dev_class);
5512 }
5513
5514 static void write_class_of_dev_cmd(uint16_t index, const void *data,
5515                                                         uint8_t size)
5516 {
5517         const struct bt_hci_cmd_write_class_of_dev *cmd = data;
5518
5519         print_dev_class(cmd->dev_class);
5520 }
5521
5522 static void read_voice_setting_rsp(uint16_t index, const void *data,
5523                                                         uint8_t size)
5524 {
5525         const struct bt_hci_rsp_read_voice_setting *rsp = data;
5526
5527         print_status(rsp->status);
5528         print_voice_setting(rsp->setting);
5529 }
5530
5531 static void write_voice_setting_cmd(uint16_t index, const void *data,
5532                                                         uint8_t size)
5533 {
5534         const struct bt_hci_cmd_write_voice_setting *cmd = data;
5535
5536         print_voice_setting(cmd->setting);
5537 }
5538
5539 static void read_auto_flush_timeout_cmd(uint16_t index, const void *data,
5540                                                         uint8_t size)
5541 {
5542         const struct bt_hci_cmd_read_auto_flush_timeout *cmd = data;
5543
5544         print_handle(cmd->handle);
5545 }
5546
5547 static void read_auto_flush_timeout_rsp(uint16_t index, const void *data,
5548                                                         uint8_t size)
5549 {
5550         const struct bt_hci_rsp_read_auto_flush_timeout *rsp = data;
5551
5552         print_status(rsp->status);
5553         print_handle(rsp->handle);
5554         print_flush_timeout(rsp->timeout);
5555 }
5556
5557 static void write_auto_flush_timeout_cmd(uint16_t index, const void *data,
5558                                                         uint8_t size)
5559 {
5560         const struct bt_hci_cmd_write_auto_flush_timeout *cmd = data;
5561
5562         print_handle(cmd->handle);
5563         print_flush_timeout(cmd->timeout);
5564 }
5565
5566 static void write_auto_flush_timeout_rsp(uint16_t index, const void *data,
5567                                                         uint8_t size)
5568 {
5569         const struct bt_hci_rsp_write_auto_flush_timeout *rsp = data;
5570
5571         print_status(rsp->status);
5572         print_handle(rsp->handle);
5573 }
5574
5575 static void read_num_broadcast_retrans_rsp(uint16_t index, const void *data,
5576                                                         uint8_t size)
5577 {
5578         const struct bt_hci_rsp_read_num_broadcast_retrans *rsp = data;
5579
5580         print_status(rsp->status);
5581         print_num_broadcast_retrans(rsp->num_retrans);
5582 }
5583
5584 static void write_num_broadcast_retrans_cmd(uint16_t index, const void *data,
5585                                                         uint8_t size)
5586 {
5587         const struct bt_hci_cmd_write_num_broadcast_retrans *cmd = data;
5588
5589         print_num_broadcast_retrans(cmd->num_retrans);
5590 }
5591
5592 static void read_hold_mode_activity_rsp(uint16_t index, const void *data,
5593                                                         uint8_t size)
5594 {
5595         const struct bt_hci_rsp_read_hold_mode_activity *rsp = data;
5596
5597         print_status(rsp->status);
5598         print_hold_mode_activity(rsp->activity);
5599 }
5600
5601 static void write_hold_mode_activity_cmd(uint16_t index, const void *data,
5602                                                         uint8_t size)
5603 {
5604         const struct bt_hci_cmd_write_hold_mode_activity *cmd = data;
5605
5606         print_hold_mode_activity(cmd->activity);
5607 }
5608
5609 static void read_tx_power_cmd(uint16_t index, const void *data, uint8_t size)
5610 {
5611         const struct bt_hci_cmd_read_tx_power *cmd = data;
5612
5613         print_handle(cmd->handle);
5614         print_power_type(cmd->type);
5615 }
5616
5617 static void read_tx_power_rsp(uint16_t index, const void *data, uint8_t size)
5618 {
5619         const struct bt_hci_rsp_read_tx_power *rsp = data;
5620
5621         print_status(rsp->status);
5622         print_handle(rsp->handle);
5623         print_power_level(rsp->level, NULL);
5624 }
5625
5626 static void read_sync_flow_control_rsp(uint16_t index, const void *data,
5627                                                         uint8_t size)
5628 {
5629         const struct bt_hci_rsp_read_sync_flow_control *rsp = data;
5630
5631         print_status(rsp->status);
5632         print_enable("Flow control", rsp->enable);
5633 }
5634
5635 static void write_sync_flow_control_cmd(uint16_t index, const void *data,
5636                                                         uint8_t size)
5637 {
5638         const struct bt_hci_cmd_write_sync_flow_control *cmd = data;
5639
5640         print_enable("Flow control", cmd->enable);
5641 }
5642
5643 static void set_host_flow_control_cmd(uint16_t index, const void *data,
5644                                                         uint8_t size)
5645 {
5646         const struct bt_hci_cmd_set_host_flow_control *cmd = data;
5647
5648         print_host_flow_control(cmd->enable);
5649 }
5650
5651 static void host_buffer_size_cmd(uint16_t index, const void *data, uint8_t size)
5652 {
5653         const struct bt_hci_cmd_host_buffer_size *cmd = data;
5654
5655         print_field("ACL MTU: %-4d ACL max packet: %d",
5656                                         le16_to_cpu(cmd->acl_mtu),
5657                                         le16_to_cpu(cmd->acl_max_pkt));
5658         print_field("SCO MTU: %-4d SCO max packet: %d",
5659                                         cmd->sco_mtu,
5660                                         le16_to_cpu(cmd->sco_max_pkt));
5661 }
5662
5663 static void host_num_completed_packets_cmd(uint16_t index, const void *data,
5664                                                         uint8_t size)
5665 {
5666         const struct bt_hci_cmd_host_num_completed_packets *cmd = data;
5667
5668         print_field("Num handles: %d", cmd->num_handles);
5669         print_handle(cmd->handle);
5670         print_field("Count: %d", le16_to_cpu(cmd->count));
5671
5672         if (size > sizeof(*cmd))
5673                 packet_hexdump(data + sizeof(*cmd), size - sizeof(*cmd));
5674 }
5675
5676 static void read_link_supv_timeout_cmd(uint16_t index, const void *data,
5677                                                         uint8_t size)
5678 {
5679         const struct bt_hci_cmd_read_link_supv_timeout *cmd = data;
5680
5681         print_handle(cmd->handle);
5682 }
5683
5684 static void read_link_supv_timeout_rsp(uint16_t index, const void *data,
5685                                                         uint8_t size)
5686 {
5687         const struct bt_hci_rsp_read_link_supv_timeout *rsp = data;
5688
5689         print_status(rsp->status);
5690         print_handle(rsp->handle);
5691         print_timeout(rsp->timeout);
5692 }
5693
5694 static void write_link_supv_timeout_cmd(uint16_t index, const void *data,
5695                                                         uint8_t size)
5696 {
5697         const struct bt_hci_cmd_write_link_supv_timeout *cmd = data;
5698
5699         print_handle(cmd->handle);
5700         print_timeout(cmd->timeout);
5701 }
5702
5703 static void write_link_supv_timeout_rsp(uint16_t index, const void *data,
5704                                                         uint8_t size)
5705 {
5706         const struct bt_hci_rsp_write_link_supv_timeout *rsp = data;
5707
5708         print_status(rsp->status);
5709         print_handle(rsp->handle);
5710 }
5711
5712 static void read_num_supported_iac_rsp(uint16_t index, const void *data,
5713                                                         uint8_t size)
5714 {
5715         const struct bt_hci_rsp_read_num_supported_iac *rsp = data;
5716
5717         print_status(rsp->status);
5718         print_field("Number of IAC: %d", rsp->num_iac);
5719 }
5720
5721 static void read_current_iac_lap_rsp(uint16_t index, const void *data,
5722                                                         uint8_t size)
5723 {
5724         const struct bt_hci_rsp_read_current_iac_lap *rsp = data;
5725         uint8_t i;
5726
5727         print_status(rsp->status);
5728         print_field("Number of IAC: %d", rsp->num_iac);
5729
5730         for (i = 0; i < rsp->num_iac; i++)
5731                 print_iac(rsp->iac_lap + (i * 3));
5732 }
5733
5734 static void write_current_iac_lap_cmd(uint16_t index, const void *data,
5735                                                         uint8_t size)
5736 {
5737         const struct bt_hci_cmd_write_current_iac_lap *cmd = data;
5738         uint8_t i;
5739
5740         print_field("Number of IAC: %d", cmd->num_iac);
5741
5742         for (i = 0; i < cmd->num_iac; i++)
5743                 print_iac(cmd->iac_lap + (i * 3));
5744 }
5745
5746 static void read_page_scan_period_mode_rsp(uint16_t index, const void *data,
5747                                                         uint8_t size)
5748 {
5749         const struct bt_hci_rsp_read_page_scan_period_mode *rsp = data;
5750
5751         print_status(rsp->status);
5752         print_pscan_period_mode(rsp->mode);
5753 }
5754
5755 static void write_page_scan_period_mode_cmd(uint16_t index, const void *data,
5756                                                         uint8_t size)
5757 {
5758         const struct bt_hci_cmd_write_page_scan_period_mode *cmd = data;
5759
5760         print_pscan_period_mode(cmd->mode);
5761 }
5762
5763 static void read_page_scan_mode_rsp(uint16_t index, const void *data,
5764                                                         uint8_t size)
5765 {
5766         const struct bt_hci_rsp_read_page_scan_mode *rsp = data;
5767
5768         print_status(rsp->status);
5769         print_pscan_mode(rsp->mode);
5770 }
5771
5772 static void write_page_scan_mode_cmd(uint16_t index, const void *data,
5773                                                         uint8_t size)
5774 {
5775         const struct bt_hci_cmd_write_page_scan_mode *cmd = data;
5776
5777         print_pscan_mode(cmd->mode);
5778 }
5779
5780 static void set_afh_host_classification_cmd(uint16_t index, const void *data,
5781                                                         uint8_t size)
5782 {
5783         const struct bt_hci_cmd_set_afh_host_classification *cmd = data;
5784
5785         print_channel_map(cmd->map);
5786 }
5787
5788 static void read_inquiry_scan_type_rsp(uint16_t index, const void *data,
5789                                                         uint8_t size)
5790 {
5791         const struct bt_hci_rsp_read_inquiry_scan_type *rsp = data;
5792
5793         print_status(rsp->status);
5794         print_inquiry_scan_type(rsp->type);
5795 }
5796
5797 static void write_inquiry_scan_type_cmd(uint16_t index, const void *data,
5798                                                         uint8_t size)
5799 {
5800         const struct bt_hci_cmd_write_inquiry_scan_type *cmd = data;
5801
5802         print_inquiry_scan_type(cmd->type);
5803 }
5804
5805 static void read_inquiry_mode_rsp(uint16_t index, const void *data,
5806                                                         uint8_t size)
5807 {
5808         const struct bt_hci_rsp_read_inquiry_mode *rsp = data;
5809
5810         print_status(rsp->status);
5811         print_inquiry_mode(rsp->mode);
5812 }
5813
5814 static void write_inquiry_mode_cmd(uint16_t index, const void *data,
5815                                                         uint8_t size)
5816 {
5817         const struct bt_hci_cmd_write_inquiry_mode *cmd = data;
5818
5819         print_inquiry_mode(cmd->mode);
5820 }
5821
5822 static void read_page_scan_type_rsp(uint16_t index, const void *data,
5823                                                         uint8_t size)
5824 {
5825         const struct bt_hci_rsp_read_page_scan_type *rsp = data;
5826
5827         print_status(rsp->status);
5828         print_pscan_type(rsp->type);
5829 }
5830
5831 static void write_page_scan_type_cmd(uint16_t index, const void *data,
5832                                                         uint8_t size)
5833 {
5834         const struct bt_hci_cmd_write_page_scan_type *cmd = data;
5835
5836         print_pscan_type(cmd->type);
5837 }
5838
5839 static void read_afh_assessment_mode_rsp(uint16_t index, const void *data,
5840                                                         uint8_t size)
5841 {
5842         const struct bt_hci_rsp_read_afh_assessment_mode *rsp = data;
5843
5844         print_status(rsp->status);
5845         print_enable("Mode", rsp->mode);
5846 }
5847
5848 static void write_afh_assessment_mode_cmd(uint16_t index, const void *data,
5849                                                         uint8_t size)
5850 {
5851         const struct bt_hci_cmd_write_afh_assessment_mode *cmd = data;
5852
5853         print_enable("Mode", cmd->mode);
5854 }
5855
5856 static void read_ext_inquiry_response_rsp(uint16_t index, const void *data,
5857                                                         uint8_t size)
5858 {
5859         const struct bt_hci_rsp_read_ext_inquiry_response *rsp = data;
5860
5861         print_status(rsp->status);
5862         print_fec(rsp->fec);
5863         print_eir(rsp->data, sizeof(rsp->data), false);
5864 }
5865
5866 static void write_ext_inquiry_response_cmd(uint16_t index, const void *data,
5867                                                         uint8_t size)
5868 {
5869         const struct bt_hci_cmd_write_ext_inquiry_response *cmd = data;
5870
5871         print_fec(cmd->fec);
5872         print_eir(cmd->data, sizeof(cmd->data), false);
5873 }
5874
5875 static void refresh_encrypt_key_cmd(uint16_t index, const void *data,
5876                                                         uint8_t size)
5877 {
5878         const struct bt_hci_cmd_refresh_encrypt_key *cmd = data;
5879
5880         print_handle(cmd->handle);
5881 }
5882
5883 static void read_simple_pairing_mode_rsp(uint16_t index, const void *data,
5884                                                         uint8_t size)
5885 {
5886         const struct bt_hci_rsp_read_simple_pairing_mode *rsp = data;
5887
5888         print_status(rsp->status);
5889         print_enable("Mode", rsp->mode);
5890 }
5891
5892 static void write_simple_pairing_mode_cmd(uint16_t index, const void *data,
5893                                                         uint8_t size)
5894 {
5895         const struct bt_hci_cmd_write_simple_pairing_mode *cmd = data;
5896
5897         print_enable("Mode", cmd->mode);
5898 }
5899
5900 static void read_local_oob_data_rsp(uint16_t index, const void *data,
5901                                                         uint8_t size)
5902 {
5903         const struct bt_hci_rsp_read_local_oob_data *rsp = data;
5904
5905         print_status(rsp->status);
5906         print_hash_p192(rsp->hash);
5907         print_randomizer_p192(rsp->randomizer);
5908 }
5909
5910 static void read_inquiry_resp_tx_power_rsp(uint16_t index, const void *data,
5911                                                         uint8_t size)
5912 {
5913         const struct bt_hci_rsp_read_inquiry_resp_tx_power *rsp = data;
5914
5915         print_status(rsp->status);
5916         print_power_level(rsp->level, NULL);
5917 }
5918
5919 static void write_inquiry_tx_power_cmd(uint16_t index, const void *data,
5920                                                         uint8_t size)
5921 {
5922         const struct bt_hci_cmd_write_inquiry_tx_power *cmd = data;
5923
5924         print_power_level(cmd->level, NULL);
5925 }
5926
5927 static void read_erroneous_reporting_rsp(uint16_t index, const void *data,
5928                                                         uint8_t size)
5929 {
5930         const struct bt_hci_rsp_read_erroneous_reporting *rsp = data;
5931
5932         print_status(rsp->status);
5933         print_enable("Mode", rsp->mode);
5934 }
5935
5936 static void write_erroneous_reporting_cmd(uint16_t index, const void *data,
5937                                                         uint8_t size)
5938 {
5939         const struct bt_hci_cmd_write_erroneous_reporting *cmd = data;
5940
5941         print_enable("Mode", cmd->mode);
5942 }
5943
5944 static void enhanced_flush_cmd(uint16_t index, const void *data, uint8_t size)
5945 {
5946         const struct bt_hci_cmd_enhanced_flush *cmd = data;
5947         const char *str;
5948
5949         print_handle(cmd->handle);
5950
5951         switch (cmd->type) {
5952         case 0x00:
5953                 str = "Automatic flushable only";
5954                 break;
5955         default:
5956                 str = "Reserved";
5957                 break;
5958         }
5959
5960         print_field("Type: %s (0x%2.2x)", str, cmd->type);
5961 }
5962
5963 static void send_keypress_notify_cmd(uint16_t index, const void *data,
5964                                                         uint8_t size)
5965 {
5966         const struct bt_hci_cmd_send_keypress_notify *cmd = data;
5967         const char *str;
5968
5969         print_bdaddr(cmd->bdaddr);
5970
5971         switch (cmd->type) {
5972         case 0x00:
5973                 str = "Passkey entry started";
5974                 break;
5975         case 0x01:
5976                 str = "Passkey digit entered";
5977                 break;
5978         case 0x02:
5979                 str = "Passkey digit erased";
5980                 break;
5981         case 0x03:
5982                 str = "Passkey cleared";
5983                 break;
5984         case 0x04:
5985                 str = "Passkey entry completed";
5986                 break;
5987         default:
5988                 str = "Reserved";
5989                 break;
5990         }
5991
5992         print_field("Type: %s (0x%2.2x)", str, cmd->type);
5993 }
5994
5995 static void send_keypress_notify_rsp(uint16_t index, const void *data,
5996                                                         uint8_t size)
5997 {
5998         const struct bt_hci_rsp_send_keypress_notify *rsp = data;
5999
6000         print_status(rsp->status);
6001         print_bdaddr(rsp->bdaddr);
6002 }
6003
6004 static void set_event_mask_page2_cmd(uint16_t index, const void *data,
6005                                                         uint8_t size)
6006 {
6007         const struct bt_hci_cmd_set_event_mask_page2 *cmd = data;
6008
6009         print_event_mask(cmd->mask, events_page2_table);
6010 }
6011
6012 static void read_location_data_rsp(uint16_t index, const void *data,
6013                                                         uint8_t size)
6014 {
6015         const struct bt_hci_rsp_read_location_data *rsp = data;
6016
6017         print_status(rsp->status);
6018         print_location_domain_aware(rsp->domain_aware);
6019         print_location_domain(rsp->domain);
6020         print_location_domain_options(rsp->domain_options);
6021         print_location_options(rsp->options);
6022 }
6023
6024 static void write_location_data_cmd(uint16_t index, const void *data,
6025                                                         uint8_t size)
6026 {
6027         const struct bt_hci_cmd_write_location_data *cmd = data;
6028
6029         print_location_domain_aware(cmd->domain_aware);
6030         print_location_domain(cmd->domain);
6031         print_location_domain_options(cmd->domain_options);
6032         print_location_options(cmd->options);
6033 }
6034
6035 static void read_flow_control_mode_rsp(uint16_t index, const void *data,
6036                                                         uint8_t size)
6037 {
6038         const struct bt_hci_rsp_read_flow_control_mode *rsp = data;
6039
6040         print_status(rsp->status);
6041         print_flow_control_mode(rsp->mode);
6042 }
6043
6044 static void write_flow_control_mode_cmd(uint16_t index, const void *data,
6045                                                         uint8_t size)
6046 {
6047         const struct bt_hci_cmd_write_flow_control_mode *cmd = data;
6048
6049         print_flow_control_mode(cmd->mode);
6050 }
6051
6052 static void read_enhanced_tx_power_cmd(uint16_t index, const void *data,
6053                                                         uint8_t size)
6054 {
6055         const struct bt_hci_cmd_read_enhanced_tx_power *cmd = data;
6056
6057         print_handle(cmd->handle);
6058         print_power_type(cmd->type);
6059 }
6060
6061 static void read_enhanced_tx_power_rsp(uint16_t index, const void *data,
6062                                                         uint8_t size)
6063 {
6064         const struct bt_hci_rsp_read_enhanced_tx_power *rsp = data;
6065
6066         print_status(rsp->status);
6067         print_handle(rsp->handle);
6068         print_power_level(rsp->level_gfsk, "GFSK");
6069         print_power_level(rsp->level_dqpsk, "DQPSK");
6070         print_power_level(rsp->level_8dpsk, "8DPSK");
6071 }
6072
6073 static void short_range_mode_cmd(uint16_t index, const void *data, uint8_t size)
6074 {
6075         const struct bt_hci_cmd_short_range_mode *cmd = data;
6076
6077         print_phy_handle(cmd->phy_handle);
6078         print_enable("Short range mode", cmd->mode);
6079 }
6080
6081 static void read_le_host_supported_rsp(uint16_t index, const void *data,
6082                                                         uint8_t size)
6083 {
6084         const struct bt_hci_rsp_read_le_host_supported *rsp = data;
6085
6086         print_status(rsp->status);
6087         print_field("Supported: 0x%2.2x", rsp->supported);
6088         print_field("Simultaneous: 0x%2.2x", rsp->simultaneous);
6089 }
6090
6091 static void write_le_host_supported_cmd(uint16_t index, const void *data,
6092                                                         uint8_t size)
6093 {
6094         const struct bt_hci_cmd_write_le_host_supported *cmd = data;
6095
6096         print_field("Supported: 0x%2.2x", cmd->supported);
6097         print_field("Simultaneous: 0x%2.2x", cmd->simultaneous);
6098 }
6099
6100 static void set_reserved_lt_addr_cmd(uint16_t index, const void *data,
6101                                                         uint8_t size)
6102 {
6103         const struct bt_hci_cmd_set_reserved_lt_addr *cmd = data;
6104
6105         print_lt_addr(cmd->lt_addr);
6106 }
6107
6108 static void set_reserved_lt_addr_rsp(uint16_t index, const void *data,
6109                                                         uint8_t size)
6110 {
6111         const struct bt_hci_rsp_set_reserved_lt_addr *rsp = data;
6112
6113         print_status(rsp->status);
6114         print_lt_addr(rsp->lt_addr);
6115 }
6116
6117 static void delete_reserved_lt_addr_cmd(uint16_t index, const void *data,
6118                                                         uint8_t size)
6119 {
6120         const struct bt_hci_cmd_delete_reserved_lt_addr *cmd = data;
6121
6122         print_lt_addr(cmd->lt_addr);
6123 }
6124
6125 static void delete_reserved_lt_addr_rsp(uint16_t index, const void *data,
6126                                                         uint8_t size)
6127 {
6128         const struct bt_hci_rsp_delete_reserved_lt_addr *rsp = data;
6129
6130         print_status(rsp->status);
6131         print_lt_addr(rsp->lt_addr);
6132 }
6133
6134 static void set_peripheral_broadcast_data_cmd(uint16_t index, const void *data,
6135                                                         uint8_t size)
6136 {
6137         const struct bt_hci_cmd_set_peripheral_broadcast_data *cmd = data;
6138
6139         print_lt_addr(cmd->lt_addr);
6140         print_broadcast_fragment(cmd->fragment);
6141         print_field("Length: %d", cmd->length);
6142
6143         if (size - 3 != cmd->length)
6144                 print_text(COLOR_ERROR, "invalid data size (%d != %d)",
6145                                                 size - 3, cmd->length);
6146
6147         packet_hexdump(data + 3, size - 3);
6148 }
6149
6150 static void set_peripheral_broadcast_data_rsp(uint16_t index, const void *data,
6151                                                         uint8_t size)
6152 {
6153         const struct bt_hci_rsp_set_peripheral_broadcast_data *rsp = data;
6154
6155         print_status(rsp->status);
6156         print_lt_addr(rsp->lt_addr);
6157 }
6158
6159 static void read_sync_train_params_rsp(uint16_t index, const void *data,
6160                                                         uint8_t size)
6161 {
6162         const struct bt_hci_rsp_read_sync_train_params *rsp = data;
6163
6164         print_status(rsp->status);
6165         print_interval(rsp->interval);
6166         print_field("Timeout: %.3f msec (0x%8.8x)",
6167                                         le32_to_cpu(rsp->timeout) * 0.625,
6168                                         le32_to_cpu(rsp->timeout));
6169         print_field("Service data: 0x%2.2x", rsp->service_data);
6170 }
6171
6172 static void write_sync_train_params_cmd(uint16_t index, const void *data,
6173                                                         uint8_t size)
6174 {
6175         const struct bt_hci_cmd_write_sync_train_params *cmd = data;
6176
6177         print_slot_625("Min interval", cmd->min_interval);
6178         print_slot_625("Max interval", cmd->max_interval);
6179         print_field("Timeout: %.3f msec (0x%8.8x)",
6180                                         le32_to_cpu(cmd->timeout) * 0.625,
6181                                         le32_to_cpu(cmd->timeout));
6182         print_field("Service data: 0x%2.2x", cmd->service_data);
6183 }
6184
6185 static void write_sync_train_params_rsp(uint16_t index, const void *data,
6186                                                         uint8_t size)
6187 {
6188         const struct bt_hci_rsp_write_sync_train_params *rsp = data;
6189
6190         print_status(rsp->status);
6191         print_interval(rsp->interval);
6192 }
6193
6194 static void read_secure_conn_support_rsp(uint16_t index, const void *data,
6195                                                         uint8_t size)
6196 {
6197         const struct bt_hci_rsp_read_secure_conn_support *rsp = data;
6198
6199         print_status(rsp->status);
6200         print_enable("Support", rsp->support);
6201 }
6202
6203 static void write_secure_conn_support_cmd(uint16_t index, const void *data,
6204                                                         uint8_t size)
6205 {
6206         const struct bt_hci_cmd_write_secure_conn_support *cmd = data;
6207
6208         print_enable("Support", cmd->support);
6209 }
6210
6211 static void read_auth_payload_timeout_cmd(uint16_t index, const void *data,
6212                                                         uint8_t size)
6213 {
6214         const struct bt_hci_cmd_read_auth_payload_timeout *cmd = data;
6215
6216         print_handle(cmd->handle);
6217 }
6218
6219 static void read_auth_payload_timeout_rsp(uint16_t index, const void *data,
6220                                                         uint8_t size)
6221 {
6222         const struct bt_hci_rsp_read_auth_payload_timeout *rsp = data;
6223
6224         print_status(rsp->status);
6225         print_handle(rsp->handle);
6226         print_auth_payload_timeout(rsp->timeout);
6227 }
6228
6229 static void write_auth_payload_timeout_cmd(uint16_t index, const void *data,
6230                                                         uint8_t size)
6231 {
6232         const struct bt_hci_cmd_write_auth_payload_timeout *cmd = data;
6233
6234         print_handle(cmd->handle);
6235         print_auth_payload_timeout(cmd->timeout);
6236 }
6237
6238 static void write_auth_payload_timeout_rsp(uint16_t index, const void *data,
6239                                                         uint8_t size)
6240 {
6241         const struct bt_hci_rsp_write_auth_payload_timeout *rsp = data;
6242
6243         print_status(rsp->status);
6244         print_handle(rsp->handle);
6245 }
6246
6247 static void read_local_oob_ext_data_rsp(uint16_t index, const void *data,
6248                                                         uint8_t size)
6249 {
6250         const struct bt_hci_rsp_read_local_oob_ext_data *rsp = data;
6251
6252         print_status(rsp->status);
6253         print_hash_p192(rsp->hash192);
6254         print_randomizer_p192(rsp->randomizer192);
6255         print_hash_p256(rsp->hash256);
6256         print_randomizer_p256(rsp->randomizer256);
6257 }
6258
6259 static void read_ext_page_timeout_rsp(uint16_t index, const void *data,
6260                                                         uint8_t size)
6261 {
6262         const struct bt_hci_rsp_read_ext_page_timeout *rsp = data;
6263
6264         print_status(rsp->status);
6265         print_timeout(rsp->timeout);
6266 }
6267
6268 static void write_ext_page_timeout_cmd(uint16_t index, const void *data,
6269                                                         uint8_t size)
6270 {
6271         const struct bt_hci_cmd_write_ext_page_timeout *cmd = data;
6272
6273         print_timeout(cmd->timeout);
6274 }
6275
6276 static void read_ext_inquiry_length_rsp(uint16_t index, const void *data,
6277                                                         uint8_t size)
6278 {
6279         const struct bt_hci_rsp_read_ext_inquiry_length *rsp = data;
6280
6281         print_status(rsp->status);
6282         print_interval(rsp->interval);
6283 }
6284
6285 static void write_ext_inquiry_length_cmd(uint16_t index, const void *data,
6286                                                         uint8_t size)
6287 {
6288         const struct bt_hci_cmd_write_ext_inquiry_length *cmd = data;
6289
6290         print_interval(cmd->interval);
6291 }
6292
6293 static void read_local_version_rsp(uint16_t index, const void *data,
6294                                                         uint8_t size)
6295 {
6296         const struct bt_hci_rsp_read_local_version *rsp = data;
6297         uint16_t manufacturer;
6298
6299         print_status(rsp->status);
6300         print_hci_version(rsp->hci_ver, rsp->hci_rev);
6301
6302         manufacturer = le16_to_cpu(rsp->manufacturer);
6303
6304         if (index_current < MAX_INDEX) {
6305                 switch (index_list[index_current].type) {
6306                 case HCI_PRIMARY:
6307                         print_lmp_version(rsp->lmp_ver, rsp->lmp_subver);
6308                         break;
6309                 case HCI_AMP:
6310                         print_pal_version(rsp->lmp_ver, rsp->lmp_subver);
6311                         break;
6312                 }
6313
6314                 index_list[index_current].manufacturer = manufacturer;
6315         }
6316
6317         print_manufacturer(rsp->manufacturer);
6318
6319         switch (manufacturer) {
6320         case 15:
6321                 print_manufacturer_broadcom(rsp->lmp_subver, rsp->hci_rev);
6322                 break;
6323         }
6324 }
6325
6326 static void read_local_commands_rsp(uint16_t index, const void *data,
6327                                                         uint8_t size)
6328 {
6329         const struct bt_hci_rsp_read_local_commands *rsp = data;
6330
6331         print_status(rsp->status);
6332         print_commands(rsp->commands);
6333 }
6334
6335 static void read_local_features_rsp(uint16_t index, const void *data,
6336                                                         uint8_t size)
6337 {
6338         const struct bt_hci_rsp_read_local_features *rsp = data;
6339
6340         print_status(rsp->status);
6341         print_features(0, rsp->features, 0x00);
6342 }
6343
6344 static void read_local_ext_features_cmd(uint16_t index, const void *data,
6345                                                         uint8_t size)
6346 {
6347         const struct bt_hci_cmd_read_local_ext_features *cmd = data;
6348
6349         print_field("Page: %d", cmd->page);
6350 }
6351
6352 static void read_local_ext_features_rsp(uint16_t index, const void *data,
6353                                                         uint8_t size)
6354 {
6355         const struct bt_hci_rsp_read_local_ext_features *rsp = data;
6356
6357         print_status(rsp->status);
6358         print_field("Page: %d/%d", rsp->page, rsp->max_page);
6359         print_features(rsp->page, rsp->features, 0x00);
6360 }
6361
6362 static void read_buffer_size_rsp(uint16_t index, const void *data, uint8_t size)
6363 {
6364         const struct bt_hci_rsp_read_buffer_size *rsp = data;
6365
6366         print_status(rsp->status);
6367         print_field("ACL MTU: %-4d ACL max packet: %d",
6368                                         le16_to_cpu(rsp->acl_mtu),
6369                                         le16_to_cpu(rsp->acl_max_pkt));
6370         print_field("SCO MTU: %-4d SCO max packet: %d",
6371                                         rsp->sco_mtu,
6372                                         le16_to_cpu(rsp->sco_max_pkt));
6373 }
6374
6375 static void read_country_code_rsp(uint16_t index, const void *data,
6376                                                         uint8_t size)
6377 {
6378         const struct bt_hci_rsp_read_country_code *rsp = data;
6379         const char *str;
6380
6381         print_status(rsp->status);
6382
6383         switch (rsp->code) {
6384         case 0x00:
6385                 str = "North America, Europe*, Japan";
6386                 break;
6387         case 0x01:
6388                 str = "France";
6389                 break;
6390         default:
6391                 str = "Reserved";
6392                 break;
6393         }
6394
6395         print_field("Country code: %s (0x%2.2x)", str, rsp->code);
6396 }
6397
6398 static void read_bd_addr_rsp(uint16_t index, const void *data, uint8_t size)
6399 {
6400         const struct bt_hci_rsp_read_bd_addr *rsp = data;
6401
6402         print_status(rsp->status);
6403         print_bdaddr(rsp->bdaddr);
6404
6405         if (index_current < MAX_INDEX)
6406                 memcpy(index_list[index_current].bdaddr, rsp->bdaddr, 6);
6407 }
6408
6409 static void read_data_block_size_rsp(uint16_t index, const void *data,
6410                                                         uint8_t size)
6411 {
6412         const struct bt_hci_rsp_read_data_block_size *rsp = data;
6413
6414         print_status(rsp->status);
6415         print_field("Max ACL length: %d", le16_to_cpu(rsp->max_acl_len));
6416         print_field("Block length: %d", le16_to_cpu(rsp->block_len));
6417         print_field("Num blocks: %d", le16_to_cpu(rsp->num_blocks));
6418 }
6419
6420 static void read_local_codecs_rsp(uint16_t index, const void *data,
6421                                                         uint8_t size)
6422 {
6423         const struct bt_hci_rsp_read_local_codecs *rsp = data;
6424         uint8_t i, num_vnd_codecs;
6425
6426         if (rsp->num_codecs + 3 > size) {
6427                 print_field("Invalid number of codecs.");
6428                 return;
6429         }
6430
6431         print_status(rsp->status);
6432         print_field("Number of supported codecs: %d", rsp->num_codecs);
6433
6434         for (i = 0; i < rsp->num_codecs; i++)
6435                 print_codec_id("  Codec", rsp->codec[i]);
6436
6437         num_vnd_codecs = rsp->codec[rsp->num_codecs];
6438
6439         print_field("Number of vendor codecs: %d", num_vnd_codecs);
6440
6441         packet_hexdump(data + rsp->num_codecs + 3,
6442                                         size - rsp->num_codecs - 3);
6443 }
6444
6445 static void print_codecs(const void *data, int i)
6446 {
6447         const struct bt_hci_codec *codec = data;
6448
6449         print_codec("  Codec", codec);
6450 }
6451
6452 typedef void (*print_list_func_t)(const void *data, int i);
6453
6454 static void print_list(const void *data, uint8_t size, int num_items,
6455                                 size_t item_size, print_list_func_t func)
6456 {
6457         int i;
6458
6459         for (i = 0; size >= item_size && num_items; i++) {
6460                 if (func)
6461                         func(data, i);
6462                 data += item_size;
6463                 size -= item_size;
6464                 num_items--;
6465         }
6466
6467         if (num_items)
6468                 print_hex_field("", data, size);
6469 }
6470
6471 static void print_vnd_codecs_v2(const void *data, int i)
6472 {
6473         const struct bt_hci_vnd_codec_v2 *codec = data;
6474         uint8_t mask;
6475
6476         packet_print_company("  Company ID", le16_to_cpu(codec->cid));
6477         print_field("  Vendor Codec ID: 0x%4.4x", le16_to_cpu(codec->vid));
6478         print_field("  Logical Transport Type: 0x%02x", codec->transport);
6479         mask = print_bitfield(4, codec->transport, codec_transport_table);
6480         if (mask)
6481                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
6482                                 "  Unknown transport (0x%2.2x)", mask);
6483 }
6484
6485 static void read_local_codecs_rsp_v2(uint16_t index, const void *data,
6486                                                         uint8_t size)
6487 {
6488         const struct bt_hci_rsp_read_local_codecs_v2 *rsp = data;
6489         uint8_t num_vnd_codecs;
6490
6491         if (rsp->num_codecs + 3 > size) {
6492                 print_field("Invalid number of codecs.");
6493                 return;
6494         }
6495
6496         print_status(rsp->status);
6497         print_field("Number of supported codecs: %d", rsp->num_codecs);
6498
6499         size -= sizeof(*rsp);
6500
6501         if (size < rsp->num_codecs * sizeof(*rsp->codec)) {
6502                 print_field("Invalid number of codecs.");
6503                 return;
6504         }
6505
6506         print_list(rsp->codec, size, rsp->num_codecs, sizeof(*rsp->codec),
6507                                                         print_codecs);
6508
6509         size -= rsp->num_codecs * sizeof(*rsp->codec);
6510
6511         if (size < sizeof(uint8_t)) {
6512                 print_field("Invalid number of vendor codecs.");
6513                 return;
6514         }
6515
6516         num_vnd_codecs = rsp->codec[rsp->num_codecs].id;
6517
6518         size -= 1;
6519
6520         print_field("Number of vendor codecs: %d", num_vnd_codecs);
6521
6522         if (size < num_vnd_codecs * sizeof(*rsp->codec)) {
6523                 print_field("Invalid number of vendor codecs.");
6524                 return;
6525         }
6526
6527         print_list(&rsp->codec[rsp->num_codecs] + 1, size, num_vnd_codecs,
6528                         sizeof(struct bt_hci_vnd_codec_v2),
6529                         print_vnd_codecs_v2);
6530 }
6531
6532 static void print_path_direction(const char *prefix, uint8_t dir)
6533 {
6534         const char *str;
6535
6536         switch (dir) {
6537         case 0x00:
6538                 str = "Input (Host to Controller)";
6539                 break;
6540         case 0x01:
6541                 str = "Output (Controller to Host)";
6542                 break;
6543         default:
6544                 str = "Reserved";
6545                 break;
6546         }
6547
6548         print_field("%s: %s (0x%2.2x)", prefix, str, dir);
6549 }
6550
6551 static void print_vnd_codec(const char *label,
6552                                 const struct bt_hci_vnd_codec *codec)
6553 {
6554         uint8_t mask;
6555
6556         print_codec_id(label, codec->id);
6557
6558         if (codec->id == 0xff) {
6559                 packet_print_company("Company Codec ID",
6560                                         le16_to_cpu(codec->cid));
6561                 print_field("Vendor Codec ID: %d", le16_to_cpu(codec->vid));
6562         }
6563
6564         print_field("Logical Transport Type: 0x%02x", codec->transport);
6565         mask = print_bitfield(2, codec->transport, codec_transport_table);
6566         if (mask)
6567                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
6568                                 "  Unknown transport (0x%2.2x)", mask);
6569 }
6570
6571 static void read_local_codec_caps_cmd(uint16_t index, const void *data,
6572                                                         uint8_t size)
6573 {
6574         const struct bt_hci_cmd_read_local_codec_caps *cmd = data;
6575
6576         print_vnd_codec("Codec", &cmd->codec);
6577         print_path_direction("Direction", cmd->dir);
6578 }
6579
6580 static void read_local_codec_caps_rsp(uint16_t index, const void *data,
6581                                                         uint8_t size)
6582 {
6583         const struct bt_hci_rsp_read_local_codec_caps *rsp = data;
6584         uint8_t i;
6585
6586         print_status(rsp->status);
6587         print_field("Number of codec capabilities: %d", rsp->num);
6588
6589         data += sizeof(*rsp);
6590         size -= sizeof(*rsp);
6591
6592         for (i = 0; i < rsp->num; i++) {
6593                 const struct bt_hci_codec_caps *caps = data;
6594
6595                 if (size < sizeof(*caps)) {
6596                         print_field("Invalid capabilities: %u < %zu",
6597                                                 size, sizeof(*caps));
6598                         return;
6599                 }
6600
6601                 print_field(" Capabilities #%u:", i);
6602                 packet_hexdump(caps->data, caps->len);
6603
6604                 data += 1 + caps->len;
6605                 size -= 1 + caps->len;
6606         }
6607 }
6608
6609 static void read_local_ctrl_delay_cmd(uint16_t index, const void *data,
6610                                                         uint8_t size)
6611 {
6612         const struct bt_hci_cmd_read_local_ctrl_delay *cmd = data;
6613
6614         print_vnd_codec("Codec", &cmd->codec);
6615         print_path_direction("Direction", cmd->dir);
6616         print_field("Length Codec Configuration: %u", cmd->codec_cfg_len);
6617 }
6618
6619 static void config_data_path_cmd(uint16_t index, const void *data, uint8_t size)
6620 {
6621         const struct bt_hci_cmd_config_data_path *cmd = data;
6622
6623         print_path_direction("Direction", cmd->dir);
6624         print_field("ID: %u", cmd->id);
6625         print_field("Vendor Specific Config Length: %u", cmd->vnd_config_len);
6626         print_hex_field("Vendor Specific Config", cmd->vnd_config,
6627                                                 cmd->vnd_config_len);
6628 }
6629
6630 static void print_usec_interval(const char *prefix, const uint8_t interval[3])
6631 {
6632         uint32_t value = get_le24(interval);
6633
6634         print_field("%s: %u us (0x%6.6x)", prefix, value, value);
6635 }
6636
6637 static void read_local_ctrl_delay_rsp(uint16_t index, const void *data,
6638                                                         uint8_t size)
6639 {
6640         const struct bt_hci_rsp_read_local_ctrl_delay *rsp = data;
6641
6642         print_status(rsp->status);
6643         print_usec_interval("Minimum Controller delay", rsp->min_delay);
6644         print_usec_interval("Maximum Controller delay", rsp->max_delay);
6645 }
6646
6647 static void read_local_pairing_options_rsp(uint16_t index, const void *data,
6648                                                         uint8_t size)
6649 {
6650         const struct bt_hci_rsp_read_local_pairing_options *rsp = data;
6651
6652         print_status(rsp->status);
6653         print_field("Pairing options: 0x%2.2x", rsp->pairing_options);
6654         print_field("Max encryption key size: %u octets", rsp->max_key_size);
6655 }
6656
6657 static void read_failed_contact_counter_cmd(uint16_t index, const void *data,
6658                                                         uint8_t size)
6659 {
6660         const struct bt_hci_cmd_read_failed_contact_counter *cmd = data;
6661
6662         print_handle(cmd->handle);
6663 }
6664
6665 static void read_failed_contact_counter_rsp(uint16_t index, const void *data,
6666                                                         uint8_t size)
6667 {
6668         const struct bt_hci_rsp_read_failed_contact_counter *rsp = data;
6669
6670         print_status(rsp->status);
6671         print_handle(rsp->handle);
6672         print_field("Counter: %u", le16_to_cpu(rsp->counter));
6673 }
6674
6675 static void reset_failed_contact_counter_cmd(uint16_t index, const void *data,
6676                                                         uint8_t size)
6677 {
6678         const struct bt_hci_cmd_reset_failed_contact_counter *cmd = data;
6679
6680         print_handle(cmd->handle);
6681 }
6682
6683 static void reset_failed_contact_counter_rsp(uint16_t index, const void *data,
6684                                                         uint8_t size)
6685 {
6686         const struct bt_hci_rsp_reset_failed_contact_counter *rsp = data;
6687
6688         print_status(rsp->status);
6689         print_handle(rsp->handle);
6690 }
6691
6692 static void read_link_quality_cmd(uint16_t index, const void *data,
6693                                                         uint8_t size)
6694 {
6695         const struct bt_hci_cmd_read_link_quality *cmd = data;
6696
6697         print_handle(cmd->handle);
6698 }
6699
6700 static void read_link_quality_rsp(uint16_t index, const void *data,
6701                                                         uint8_t size)
6702 {
6703         const struct bt_hci_rsp_read_link_quality *rsp = data;
6704
6705         print_status(rsp->status);
6706         print_handle(rsp->handle);
6707         print_field("Link quality: 0x%2.2x", rsp->link_quality);
6708 }
6709
6710 static void read_rssi_cmd(uint16_t index, const void *data, uint8_t size)
6711 {
6712         const struct bt_hci_cmd_read_rssi *cmd = data;
6713
6714         print_handle(cmd->handle);
6715 }
6716
6717 static void read_rssi_rsp(uint16_t index, const void *data, uint8_t size)
6718 {
6719         const struct bt_hci_rsp_read_rssi *rsp = data;
6720
6721         print_status(rsp->status);
6722         print_handle(rsp->handle);
6723         print_rssi(rsp->rssi);
6724 }
6725
6726 static void read_afh_channel_map_cmd(uint16_t index, const void *data,
6727                                                         uint8_t size)
6728 {
6729         const struct bt_hci_cmd_read_afh_channel_map *cmd = data;
6730
6731         print_handle(cmd->handle);
6732 }
6733
6734 static void read_afh_channel_map_rsp(uint16_t index, const void *data,
6735                                                         uint8_t size)
6736 {
6737         const struct bt_hci_rsp_read_afh_channel_map *rsp = data;
6738
6739         print_status(rsp->status);
6740         print_handle(rsp->handle);
6741         print_enable("Mode", rsp->mode);
6742         print_channel_map(rsp->map);
6743 }
6744
6745 static void read_clock_cmd(uint16_t index, const void *data, uint8_t size)
6746 {
6747         const struct bt_hci_cmd_read_clock *cmd = data;
6748
6749         print_handle(cmd->handle);
6750         print_clock_type(cmd->type);
6751 }
6752
6753 static void read_clock_rsp(uint16_t index, const void *data, uint8_t size)
6754 {
6755         const struct bt_hci_rsp_read_clock *rsp = data;
6756
6757         print_status(rsp->status);
6758         print_handle(rsp->handle);
6759         print_clock(rsp->clock);
6760         print_clock_accuracy(rsp->accuracy);
6761 }
6762
6763 static void read_encrypt_key_size_cmd(uint16_t index, const void *data,
6764                                                         uint8_t size)
6765 {
6766         const struct bt_hci_cmd_read_encrypt_key_size *cmd = data;
6767
6768         print_handle(cmd->handle);
6769 }
6770
6771 static void read_encrypt_key_size_rsp(uint16_t index, const void *data,
6772                                                         uint8_t size)
6773 {
6774         const struct bt_hci_rsp_read_encrypt_key_size *rsp = data;
6775
6776         print_status(rsp->status);
6777         print_handle(rsp->handle);
6778         print_key_size(rsp->key_size);
6779 }
6780
6781 static void read_local_amp_info_rsp(uint16_t index, const void *data,
6782                                                         uint8_t size)
6783 {
6784         const struct bt_hci_rsp_read_local_amp_info *rsp = data;
6785         const char *str;
6786
6787         print_status(rsp->status);
6788         print_amp_status(rsp->amp_status);
6789
6790         print_field("Total bandwidth: %d kbps", le32_to_cpu(rsp->total_bw));
6791         print_field("Max guaranteed bandwidth: %d kbps",
6792                                                 le32_to_cpu(rsp->max_bw));
6793         print_field("Min latency: %d", le32_to_cpu(rsp->min_latency));
6794         print_field("Max PDU size: %d", le32_to_cpu(rsp->max_pdu));
6795
6796         switch (rsp->amp_type) {
6797         case 0x00:
6798                 str = "Primary BR/EDR Controller";
6799                 break;
6800         case 0x01:
6801                 str = "802.11 AMP Controller";
6802                 break;
6803         default:
6804                 str = "Reserved";
6805                 break;
6806         }
6807
6808         print_field("Controller type: %s (0x%2.2x)", str, rsp->amp_type);
6809
6810         print_field("PAL capabilities: 0x%4.4x", le16_to_cpu(rsp->pal_cap));
6811         print_field("Max ASSOC length: %d", le16_to_cpu(rsp->max_assoc_len));
6812         print_field("Max flush timeout: %d", le32_to_cpu(rsp->max_flush_to));
6813         print_field("Best effort flush timeout: %d",
6814                                         le32_to_cpu(rsp->be_flush_to));
6815 }
6816
6817 static void read_local_amp_assoc_cmd(uint16_t index, const void *data,
6818                                                         uint8_t size)
6819 {
6820         const struct bt_hci_cmd_read_local_amp_assoc *cmd = data;
6821
6822         print_phy_handle(cmd->phy_handle);
6823         print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
6824         print_field("Max ASSOC length: %d", le16_to_cpu(cmd->max_assoc_len));
6825 }
6826
6827 static void read_local_amp_assoc_rsp(uint16_t index, const void *data,
6828                                                         uint8_t size)
6829 {
6830         const struct bt_hci_rsp_read_local_amp_assoc *rsp = data;
6831
6832         print_status(rsp->status);
6833         print_phy_handle(rsp->phy_handle);
6834         print_field("Remaining ASSOC length: %d",
6835                                         le16_to_cpu(rsp->remain_assoc_len));
6836
6837         packet_hexdump(data + 4, size - 4);
6838 }
6839
6840 static void write_remote_amp_assoc_cmd(uint16_t index, const void *data,
6841                                                         uint8_t size)
6842 {
6843         const struct bt_hci_cmd_write_remote_amp_assoc *cmd = data;
6844
6845         print_phy_handle(cmd->phy_handle);
6846         print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
6847         print_field("Remaining ASSOC length: %d",
6848                                         le16_to_cpu(cmd->remain_assoc_len));
6849
6850         packet_hexdump(data + 5, size - 5);
6851 }
6852
6853 static void write_remote_amp_assoc_rsp(uint16_t index, const void *data,
6854                                                         uint8_t size)
6855 {
6856         const struct bt_hci_rsp_write_remote_amp_assoc *rsp = data;
6857
6858         print_status(rsp->status);
6859         print_phy_handle(rsp->phy_handle);
6860 }
6861
6862 static void get_mws_transport_config_rsp(uint16_t index, const void *data,
6863                                                         uint8_t size)
6864 {
6865         const struct bt_hci_rsp_get_mws_transport_config *rsp = data;
6866         uint8_t sum_baud_rates = 0;
6867         int i;
6868
6869         print_status(rsp->status);
6870         print_field("Number of transports: %d", rsp->num_transports);
6871
6872         for (i = 0; i < rsp->num_transports; i++) {
6873                 uint8_t transport = rsp->transport[0];
6874                 uint8_t num_baud_rates = rsp->transport[1];
6875                 const char *str;
6876
6877                 switch (transport) {
6878                 case 0x00:
6879                         str = "Disbabled";
6880                         break;
6881                 case 0x01:
6882                         str = "WCI-1";
6883                         break;
6884                 case 0x02:
6885                         str = "WCI-2";
6886                         break;
6887                 default:
6888                         str = "Reserved";
6889                         break;
6890                 }
6891
6892                 print_field("  Transport layer: %s (0x%2.2x)", str, transport);
6893                 print_field("  Number of baud rates: %d", num_baud_rates);
6894
6895                 sum_baud_rates += num_baud_rates;
6896         }
6897
6898         print_field("Baud rate list: %u entr%s", sum_baud_rates,
6899                                         sum_baud_rates == 1 ? "y" : "ies");
6900
6901         for (i = 0; i < sum_baud_rates; i++) {
6902                 uint32_t to_baud_rate, from_baud_rate;
6903
6904                 to_baud_rate = get_le32(data + 2 +
6905                                         rsp->num_transports * 2 + i * 4);
6906                 from_baud_rate = get_le32(data + 2 +
6907                                                 rsp->num_transports * 2 +
6908                                                 sum_baud_rates * 4 + i * 4);
6909
6910                 print_field("  Bluetooth to MWS: %d", to_baud_rate);
6911                 print_field("  MWS to Bluetooth: %d", from_baud_rate);
6912         }
6913
6914         packet_hexdump(data + 2 + rsp->num_transports * 2 + sum_baud_rates * 8,
6915                 size - 2 - rsp->num_transports * 2 - sum_baud_rates * 8);
6916 }
6917
6918 static void set_triggered_clock_capture_cmd(uint16_t index, const void *data,
6919                                                         uint8_t size)
6920 {
6921         const struct bt_hci_cmd_set_triggered_clock_capture *cmd = data;
6922
6923         print_handle(cmd->handle);
6924         print_enable("Capture", cmd->enable);
6925         print_clock_type(cmd->type);
6926         print_lpo_allowed(cmd->lpo_allowed);
6927         print_field("Clock captures to filter: %u", cmd->num_filter);
6928 }
6929
6930 static void read_loopback_mode_rsp(uint16_t index, const void *data,
6931                                                         uint8_t size)
6932 {
6933         const struct bt_hci_rsp_read_loopback_mode *rsp = data;
6934
6935         print_status(rsp->status);
6936         print_loopback_mode(rsp->mode);
6937 }
6938
6939 static void write_loopback_mode_cmd(uint16_t index, const void *data,
6940                                                         uint8_t size)
6941 {
6942         const struct bt_hci_cmd_write_loopback_mode *cmd = data;
6943
6944         print_loopback_mode(cmd->mode);
6945 }
6946
6947 static void write_ssp_debug_mode_cmd(uint16_t index, const void *data,
6948                                                         uint8_t size)
6949 {
6950         const struct bt_hci_cmd_write_ssp_debug_mode *cmd = data;
6951
6952         print_enable("Debug Mode", cmd->mode);
6953 }
6954
6955 static void le_set_event_mask_cmd(uint16_t index, const void *data,
6956                                                         uint8_t size)
6957 {
6958         const struct bt_hci_cmd_le_set_event_mask *cmd = data;
6959
6960         print_event_mask(cmd->mask, events_le_table);
6961 }
6962
6963 static void le_read_buffer_size_rsp(uint16_t index, const void *data,
6964                                                         uint8_t size)
6965 {
6966         const struct bt_hci_rsp_le_read_buffer_size *rsp = data;
6967
6968         print_status(rsp->status);
6969         print_field("Data packet length: %d", le16_to_cpu(rsp->le_mtu));
6970         print_field("Num data packets: %d", rsp->le_max_pkt);
6971 }
6972
6973 static void le_read_local_features_rsp(uint16_t index, const void *data,
6974                                                         uint8_t size)
6975 {
6976         const struct bt_hci_rsp_le_read_local_features *rsp = data;
6977
6978         print_status(rsp->status);
6979         print_features(0, rsp->features, 0x01);
6980 }
6981
6982 static void le_set_random_address_cmd(uint16_t index, const void *data,
6983                                                         uint8_t size)
6984 {
6985         const struct bt_hci_cmd_le_set_random_address *cmd = data;
6986
6987         print_addr("Address", cmd->addr, 0x01);
6988 }
6989
6990 static void le_set_adv_parameters_cmd(uint16_t index, const void *data,
6991                                                         uint8_t size)
6992 {
6993         const struct bt_hci_cmd_le_set_adv_parameters *cmd = data;
6994         const char *str;
6995
6996         print_slot_625("Min advertising interval", cmd->min_interval);
6997         print_slot_625("Max advertising interval", cmd->max_interval);
6998
6999         switch (cmd->type) {
7000         case 0x00:
7001                 str = "Connectable undirected - ADV_IND";
7002                 break;
7003         case 0x01:
7004                 str = "Connectable directed - ADV_DIRECT_IND (high duty cycle)";
7005                 break;
7006         case 0x02:
7007                 str = "Scannable undirected - ADV_SCAN_IND";
7008                 break;
7009         case 0x03:
7010                 str = "Non connectable undirected - ADV_NONCONN_IND";
7011                 break;
7012         case 0x04:
7013                 str = "Connectable directed - ADV_DIRECT_IND (low duty cycle)";
7014                 break;
7015         default:
7016                 str = "Reserved";
7017                 break;
7018         }
7019
7020         print_field("Type: %s (0x%2.2x)", str, cmd->type);
7021
7022         print_own_addr_type(cmd->own_addr_type);
7023         print_addr_type("Direct address type", cmd->direct_addr_type);
7024         print_addr("Direct address", cmd->direct_addr, cmd->direct_addr_type);
7025         print_adv_channel_map("Channel map", cmd->channel_map);
7026         print_adv_filter_policy("Filter policy", cmd->filter_policy);
7027 }
7028
7029 static void le_read_adv_tx_power_rsp(uint16_t index, const void *data,
7030                                                         uint8_t size)
7031 {
7032         const struct bt_hci_rsp_le_read_adv_tx_power *rsp = data;
7033
7034         print_status(rsp->status);
7035         print_power_level(rsp->level, NULL);
7036 }
7037
7038 static void le_set_adv_data_cmd(uint16_t index, const void *data, uint8_t size)
7039 {
7040         const struct bt_hci_cmd_le_set_adv_data *cmd = data;
7041
7042         print_field("Length: %d", cmd->len);
7043         print_eir(cmd->data, cmd->len, true);
7044 }
7045
7046 static void le_set_scan_rsp_data_cmd(uint16_t index, const void *data,
7047                                                         uint8_t size)
7048 {
7049         const struct bt_hci_cmd_le_set_scan_rsp_data *cmd = data;
7050
7051         print_field("Length: %d", cmd->len);
7052         print_eir(cmd->data, cmd->len, true);
7053 }
7054
7055 static void le_set_adv_enable_cmd(uint16_t index, const void *data,
7056                                                         uint8_t size)
7057 {
7058         const struct bt_hci_cmd_le_set_adv_enable *cmd = data;
7059
7060         print_enable("Advertising", cmd->enable);
7061 }
7062
7063 static void print_scan_type(const char *label, uint8_t type)
7064 {
7065         const char *str;
7066
7067         switch (type) {
7068         case 0x00:
7069                 str = "Passive";
7070                 break;
7071         case 0x01:
7072                 str = "Active";
7073                 break;
7074         default:
7075                 str = "Reserved";
7076                 break;
7077         }
7078
7079         print_field("%s: %s (0x%2.2x)", label, str, type);
7080 }
7081
7082 static void print_scan_filter_policy(uint8_t policy)
7083 {
7084         const char *str;
7085
7086         switch (policy) {
7087         case 0x00:
7088                 str = "Accept all advertisement";
7089                 break;
7090         case 0x01:
7091                 str = "Ignore not in accept list";
7092                 break;
7093         case 0x02:
7094                 str = "Accept all advertisement, inc. directed unresolved RPA";
7095                 break;
7096         case 0x03:
7097                 str = "Ignore not in accept list, exc. directed unresolved RPA";
7098                 break;
7099         default:
7100                 str = "Reserved";
7101                 break;
7102         }
7103
7104         print_field("Filter policy: %s (0x%2.2x)", str, policy);
7105 }
7106
7107 static void le_set_scan_parameters_cmd(uint16_t index, const void *data,
7108                                                         uint8_t size)
7109 {
7110         const struct bt_hci_cmd_le_set_scan_parameters *cmd = data;
7111
7112         print_scan_type("Type", cmd->type);
7113         print_interval(cmd->interval);
7114         print_window(cmd->window);
7115         print_own_addr_type(cmd->own_addr_type);
7116         print_scan_filter_policy(cmd->filter_policy);
7117 }
7118
7119 static void le_set_scan_enable_cmd(uint16_t index, const void *data,
7120                                                         uint8_t size)
7121 {
7122         const struct bt_hci_cmd_le_set_scan_enable *cmd = data;
7123
7124         print_enable("Scanning", cmd->enable);
7125         print_enable("Filter duplicates", cmd->filter_dup);
7126 }
7127
7128 static void le_create_conn_cmd(uint16_t index, const void *data, uint8_t size)
7129 {
7130         const struct bt_hci_cmd_le_create_conn *cmd = data;
7131         const char *str;
7132
7133         print_slot_625("Scan interval", cmd->scan_interval);
7134         print_slot_625("Scan window", cmd->scan_window);
7135
7136         switch (cmd->filter_policy) {
7137         case 0x00:
7138                 str = "Accept list is not used";
7139                 break;
7140         case 0x01:
7141                 str = "Accept list is used";
7142                 break;
7143         default:
7144                 str = "Reserved";
7145                 break;
7146         }
7147
7148         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
7149
7150         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
7151         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
7152         print_own_addr_type(cmd->own_addr_type);
7153
7154         print_slot_125("Min connection interval", cmd->min_interval);
7155         print_slot_125("Max connection interval", cmd->max_interval);
7156         print_conn_latency("Connection latency", cmd->latency);
7157         print_field("Supervision timeout: %d msec (0x%4.4x)",
7158                                         le16_to_cpu(cmd->supv_timeout) * 10,
7159                                         le16_to_cpu(cmd->supv_timeout));
7160         print_slot_625("Min connection length", cmd->min_length);
7161         print_slot_625("Max connection length", cmd->max_length);
7162 }
7163
7164 static void le_read_accept_list_size_rsp(uint16_t index, const void *data,
7165                                                         uint8_t size)
7166 {
7167         const struct bt_hci_rsp_le_read_accept_list_size *rsp = data;
7168
7169         print_status(rsp->status);
7170         print_field("Size: %u", rsp->size);
7171 }
7172
7173 static void le_add_to_accept_list_cmd(uint16_t index, const void *data,
7174                                                         uint8_t size)
7175 {
7176         const struct bt_hci_cmd_le_add_to_accept_list *cmd = data;
7177
7178         print_addr_type("Address type", cmd->addr_type);
7179         print_addr("Address", cmd->addr, cmd->addr_type);
7180 }
7181
7182 static void le_remove_from_accept_list_cmd(uint16_t index, const void *data,
7183                                                         uint8_t size)
7184 {
7185         const struct bt_hci_cmd_le_remove_from_accept_list *cmd = data;
7186
7187         print_addr_type("Address type", cmd->addr_type);
7188         print_addr("Address", cmd->addr, cmd->addr_type);
7189 }
7190
7191 static void le_conn_update_cmd(uint16_t index, const void *data, uint8_t size)
7192 {
7193         const struct bt_hci_cmd_le_conn_update *cmd = data;
7194
7195         print_handle(cmd->handle);
7196         print_slot_125("Min connection interval", cmd->min_interval);
7197         print_slot_125("Max connection interval", cmd->max_interval);
7198         print_conn_latency("Connection latency", cmd->latency);
7199         print_field("Supervision timeout: %d msec (0x%4.4x)",
7200                                         le16_to_cpu(cmd->supv_timeout) * 10,
7201                                         le16_to_cpu(cmd->supv_timeout));
7202         print_slot_625("Min connection length", cmd->min_length);
7203         print_slot_625("Max connection length", cmd->max_length);
7204 }
7205
7206 static void le_set_host_classification_cmd(uint16_t index, const void *data,
7207                                                         uint8_t size)
7208 {
7209         const struct bt_hci_cmd_le_set_host_classification *cmd = data;
7210
7211         print_le_channel_map(cmd->map);
7212 }
7213
7214 static void le_read_channel_map_cmd(uint16_t index, const void *data,
7215                                                         uint8_t size)
7216 {
7217         const struct bt_hci_cmd_le_read_channel_map *cmd = data;
7218
7219         print_handle(cmd->handle);
7220 }
7221
7222 static void le_read_channel_map_rsp(uint16_t index, const void *data,
7223                                                         uint8_t size)
7224 {
7225         const struct bt_hci_rsp_le_read_channel_map *rsp = data;
7226
7227         print_status(rsp->status);
7228         print_handle(rsp->handle);
7229         print_le_channel_map(rsp->map);
7230 }
7231
7232 static void le_read_remote_features_cmd(uint16_t index, const void *data,
7233                                                         uint8_t size)
7234 {
7235         const struct bt_hci_cmd_le_read_remote_features *cmd = data;
7236
7237         print_handle(cmd->handle);
7238 }
7239
7240 static void le_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
7241 {
7242         const struct bt_hci_cmd_le_encrypt *cmd = data;
7243
7244         print_key("Key", cmd->key);
7245         print_key("Plaintext data", cmd->plaintext);
7246 }
7247
7248 static void le_encrypt_rsp(uint16_t index, const void *data, uint8_t size)
7249 {
7250         const struct bt_hci_rsp_le_encrypt *rsp = data;
7251
7252         print_status(rsp->status);
7253         print_key("Encrypted data", rsp->data);
7254 }
7255
7256 static void le_rand_rsp(uint16_t index, const void *data, uint8_t size)
7257 {
7258         const struct bt_hci_rsp_le_rand *rsp = data;
7259
7260         print_status(rsp->status);
7261         print_random_number(rsp->number);
7262 }
7263
7264 static void le_start_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
7265 {
7266         const struct bt_hci_cmd_le_start_encrypt *cmd = data;
7267
7268         print_handle(cmd->handle);
7269         print_random_number(cmd->rand);
7270         print_encrypted_diversifier(cmd->ediv);
7271         print_key("Long term key", cmd->ltk);
7272 }
7273
7274 static void le_ltk_req_reply_cmd(uint16_t index, const void *data, uint8_t size)
7275 {
7276         const struct bt_hci_cmd_le_ltk_req_reply *cmd = data;
7277
7278         print_handle(cmd->handle);
7279         print_key("Long term key", cmd->ltk);
7280 }
7281
7282 static void le_ltk_req_reply_rsp(uint16_t index, const void *data, uint8_t size)
7283 {
7284         const struct bt_hci_rsp_le_ltk_req_reply *rsp = data;
7285
7286         print_status(rsp->status);
7287         print_handle(rsp->handle);
7288 }
7289
7290 static void le_ltk_req_neg_reply_cmd(uint16_t index, const void *data,
7291                                                         uint8_t size)
7292 {
7293         const struct bt_hci_cmd_le_ltk_req_neg_reply *cmd = data;
7294
7295         print_handle(cmd->handle);
7296 }
7297
7298 static void le_ltk_req_neg_reply_rsp(uint16_t index, const void *data,
7299                                                         uint8_t size)
7300 {
7301         const struct bt_hci_rsp_le_ltk_req_neg_reply *rsp = data;
7302
7303         print_status(rsp->status);
7304         print_handle(rsp->handle);
7305 }
7306
7307 static void le_read_supported_states_rsp(uint16_t index, const void *data,
7308                                                         uint8_t size)
7309 {
7310         const struct bt_hci_rsp_le_read_supported_states *rsp = data;
7311
7312         print_status(rsp->status);
7313         print_le_states(rsp->states);
7314 }
7315
7316 static void le_receiver_test_cmd(uint16_t index, const void *data, uint8_t size)
7317 {
7318         const struct bt_hci_cmd_le_receiver_test *cmd = data;
7319
7320         print_field("RX frequency: %d MHz (0x%2.2x)",
7321                                 (cmd->frequency * 2) + 2402, cmd->frequency);
7322 }
7323
7324 static void le_transmitter_test_cmd(uint16_t index, const void *data,
7325                                                         uint8_t size)
7326 {
7327         const struct bt_hci_cmd_le_transmitter_test *cmd = data;
7328
7329         print_field("TX frequency: %d MHz (0x%2.2x)",
7330                                 (cmd->frequency * 2) + 2402, cmd->frequency);
7331         print_field("Test data length: %d bytes", cmd->data_len);
7332         print_field("Packet payload: 0x%2.2x", cmd->payload);
7333 }
7334
7335 static void le_test_end_rsp(uint16_t index, const void *data, uint8_t size)
7336 {
7337         const struct bt_hci_rsp_le_test_end *rsp = data;
7338
7339         print_status(rsp->status);
7340         print_field("Number of packets: %d", le16_to_cpu(rsp->num_packets));
7341 }
7342
7343 static void le_conn_param_req_reply_cmd(uint16_t index, const void *data,
7344                                                         uint8_t size)
7345 {
7346         const struct bt_hci_cmd_le_conn_param_req_reply *cmd = data;
7347
7348         print_handle(cmd->handle);
7349         print_slot_125("Min connection interval", cmd->min_interval);
7350         print_slot_125("Max connection interval", cmd->max_interval);
7351         print_conn_latency("Connection latency", cmd->latency);
7352         print_field("Supervision timeout: %d msec (0x%4.4x)",
7353                                         le16_to_cpu(cmd->supv_timeout) * 10,
7354                                         le16_to_cpu(cmd->supv_timeout));
7355         print_slot_625("Min connection length", cmd->min_length);
7356         print_slot_625("Max connection length", cmd->max_length);
7357 }
7358
7359 static void le_conn_param_req_reply_rsp(uint16_t index, const void *data,
7360                                                         uint8_t size)
7361 {
7362         const struct bt_hci_rsp_le_conn_param_req_reply *rsp = data;
7363
7364         print_status(rsp->status);
7365         print_handle(rsp->handle);
7366 }
7367
7368 static void le_conn_param_req_neg_reply_cmd(uint16_t index, const void *data,
7369                                                         uint8_t size)
7370 {
7371         const struct bt_hci_cmd_le_conn_param_req_neg_reply *cmd = data;
7372
7373         print_handle(cmd->handle);
7374         print_reason(cmd->reason);
7375 }
7376
7377 static void le_conn_param_req_neg_reply_rsp(uint16_t index, const void *data,
7378                                                         uint8_t size)
7379 {
7380         const struct bt_hci_rsp_le_conn_param_req_neg_reply *rsp = data;
7381
7382         print_status(rsp->status);
7383         print_handle(rsp->handle);
7384 }
7385
7386 static void le_set_data_length_cmd(uint16_t index, const void *data,
7387                                                         uint8_t size)
7388 {
7389         const struct bt_hci_cmd_le_set_data_length *cmd = data;
7390
7391         print_handle(cmd->handle);
7392         print_field("TX octets: %d", le16_to_cpu(cmd->tx_len));
7393         print_field("TX time: %d", le16_to_cpu(cmd->tx_time));
7394 }
7395
7396 static void le_set_data_length_rsp(uint16_t index, const void *data,
7397                                                         uint8_t size)
7398 {
7399         const struct bt_hci_rsp_le_set_data_length *rsp = data;
7400
7401         print_status(rsp->status);
7402         print_handle(rsp->handle);
7403 }
7404
7405 static void le_read_default_data_length_rsp(uint16_t index, const void *data,
7406                                                         uint8_t size)
7407 {
7408         const struct bt_hci_rsp_le_read_default_data_length *rsp = data;
7409
7410         print_status(rsp->status);
7411         print_field("TX octets: %d", le16_to_cpu(rsp->tx_len));
7412         print_field("TX time: %d", le16_to_cpu(rsp->tx_time));
7413 }
7414
7415 static void le_write_default_data_length_cmd(uint16_t index, const void *data,
7416                                                         uint8_t size)
7417 {
7418         const struct bt_hci_cmd_le_write_default_data_length *cmd = data;
7419
7420         print_field("TX octets: %d", le16_to_cpu(cmd->tx_len));
7421         print_field("TX time: %d", le16_to_cpu(cmd->tx_time));
7422 }
7423
7424 static void le_generate_dhkey_cmd(uint16_t index, const void *data,
7425                                                         uint8_t size)
7426 {
7427         const struct bt_hci_cmd_le_generate_dhkey *cmd = data;
7428
7429         print_pk256("Remote P-256 public key", cmd->remote_pk256);
7430 }
7431
7432 static void le_add_to_resolv_list_cmd(uint16_t index, const void *data,
7433                                                         uint8_t size)
7434 {
7435         const struct bt_hci_cmd_le_add_to_resolv_list *cmd = data;
7436
7437         print_addr_type("Address type", cmd->addr_type);
7438         print_addr("Address", cmd->addr, cmd->addr_type);
7439         print_key("Peer identity resolving key", cmd->peer_irk);
7440         print_key("Local identity resolving key", cmd->local_irk);
7441 }
7442
7443 static void le_remove_from_resolv_list_cmd(uint16_t index, const void *data,
7444                                                         uint8_t size)
7445 {
7446         const struct bt_hci_cmd_le_remove_from_resolv_list *cmd = data;
7447
7448         print_addr_type("Address type", cmd->addr_type);
7449         print_addr("Address", cmd->addr, cmd->addr_type);
7450 }
7451
7452 static void le_read_resolv_list_size_rsp(uint16_t index, const void *data,
7453                                                         uint8_t size)
7454 {
7455         const struct bt_hci_rsp_le_read_resolv_list_size *rsp = data;
7456
7457         print_status(rsp->status);
7458         print_field("Size: %u", rsp->size);
7459 }
7460
7461 static void le_read_peer_resolv_addr_cmd(uint16_t index, const void *data,
7462                                                         uint8_t size)
7463 {
7464         const struct bt_hci_cmd_le_read_peer_resolv_addr *cmd = data;
7465
7466         print_addr_type("Address type", cmd->addr_type);
7467         print_addr("Address", cmd->addr, cmd->addr_type);
7468 }
7469
7470 static void le_read_peer_resolv_addr_rsp(uint16_t index, const void *data,
7471                                                         uint8_t size)
7472 {
7473         const struct bt_hci_rsp_le_read_peer_resolv_addr *rsp = data;
7474
7475         print_status(rsp->status);
7476         print_addr("Address", rsp->addr, 0x01);
7477 }
7478
7479 static void le_read_local_resolv_addr_cmd(uint16_t index, const void *data,
7480                                                         uint8_t size)
7481 {
7482         const struct bt_hci_cmd_le_read_local_resolv_addr *cmd = data;
7483
7484         print_addr_type("Address type", cmd->addr_type);
7485         print_addr("Address", cmd->addr, cmd->addr_type);
7486 }
7487
7488 static void le_read_local_resolv_addr_rsp(uint16_t index, const void *data,
7489                                                         uint8_t size)
7490 {
7491         const struct bt_hci_rsp_le_read_local_resolv_addr *rsp = data;
7492
7493         print_status(rsp->status);
7494         print_addr("Address", rsp->addr, 0x01);
7495 }
7496
7497 static void le_set_resolv_enable_cmd(uint16_t index, const void *data,
7498                                                         uint8_t size)
7499 {
7500         const struct bt_hci_cmd_le_set_resolv_enable *cmd = data;
7501
7502         print_enable("Address resolution", cmd->enable);
7503 }
7504
7505 static void le_set_resolv_timeout_cmd(uint16_t index, const void *data,
7506                                                         uint8_t size)
7507 {
7508         const struct bt_hci_cmd_le_set_resolv_timeout *cmd = data;
7509
7510         print_field("Timeout: %u seconds", le16_to_cpu(cmd->timeout));
7511 }
7512
7513 static void le_read_max_data_length_rsp(uint16_t index, const void *data,
7514                                                         uint8_t size)
7515 {
7516         const struct bt_hci_rsp_le_read_max_data_length *rsp = data;
7517
7518         print_status(rsp->status);
7519         print_field("Max TX octets: %d", le16_to_cpu(rsp->max_tx_len));
7520         print_field("Max TX time: %d", le16_to_cpu(rsp->max_tx_time));
7521         print_field("Max RX octets: %d", le16_to_cpu(rsp->max_rx_len));
7522         print_field("Max RX time: %d", le16_to_cpu(rsp->max_rx_time));
7523 }
7524
7525 static void le_read_phy_cmd(uint16_t index, const void *data, uint8_t size)
7526 {
7527         const struct bt_hci_cmd_le_read_phy *cmd = data;
7528
7529         print_handle(cmd->handle);
7530 }
7531
7532 static void print_le_phy(const char *prefix, uint8_t phy)
7533 {
7534         const char *str;
7535
7536         switch (phy) {
7537         case 0x01:
7538                 str = "LE 1M";
7539                 break;
7540         case 0x02:
7541                 str = "LE 2M";
7542                 break;
7543         case 0x03:
7544                 str = "LE Coded";
7545                 break;
7546         default:
7547                 str = "Reserved";
7548                 break;
7549         }
7550
7551         print_field("%s: %s (0x%2.2x)", prefix, str, phy);
7552 }
7553
7554 static void le_read_phy_rsp(uint16_t index, const void *data, uint8_t size)
7555 {
7556         const struct bt_hci_rsp_le_read_phy *rsp = data;
7557
7558         print_status(rsp->status);
7559         print_handle(rsp->handle);
7560         print_le_phy("TX PHY", rsp->tx_phy);
7561         print_le_phy("RX PHY", rsp->rx_phy);
7562 }
7563
7564 static const struct bitfield_data le_phys[] = {
7565         {  0, "LE 1M"   },
7566         {  1, "LE 2M"   },
7567         {  2, "LE Coded"},
7568         { }
7569 };
7570
7571 static const struct bitfield_data le_phy_preference[] = {
7572         {  0, "No TX PHY preference"    },
7573         {  1, "No RX PHY preference"    },
7574         { }
7575 };
7576
7577 static void print_le_phys_preference(uint8_t all_phys, uint8_t tx_phys,
7578                                                         uint8_t rx_phys)
7579 {
7580         uint8_t mask;
7581
7582         print_field("All PHYs preference: 0x%2.2x", all_phys);
7583
7584         mask = print_bitfield(2, all_phys, le_phy_preference);
7585         if (mask)
7586                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7587                                                         " (0x%2.2x)", mask);
7588
7589         print_field("TX PHYs preference: 0x%2.2x", tx_phys);
7590
7591         mask = print_bitfield(2, tx_phys, le_phys);
7592         if (mask)
7593                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7594                                                         " (0x%2.2x)", mask);
7595
7596         print_field("RX PHYs preference: 0x%2.2x", rx_phys);
7597
7598         mask = print_bitfield(2, rx_phys, le_phys);
7599         if (mask)
7600                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7601                                                         " (0x%2.2x)", mask);
7602 }
7603
7604 static void le_set_default_phy_cmd(uint16_t index, const void *data,
7605                                                         uint8_t size)
7606 {
7607         const struct bt_hci_cmd_le_set_default_phy *cmd = data;
7608
7609         print_le_phys_preference(cmd->all_phys, cmd->tx_phys, cmd->rx_phys);
7610 }
7611
7612 static void le_set_phy_cmd(uint16_t index, const void *data, uint8_t size)
7613 {
7614         const struct bt_hci_cmd_le_set_phy *cmd = data;
7615         const char *str;
7616
7617         print_handle(cmd->handle);
7618         print_le_phys_preference(cmd->all_phys, cmd->tx_phys, cmd->rx_phys);
7619         switch (le16_to_cpu(cmd->phy_opts)) {
7620         case 0x0001:
7621                 str = "S2 coding";
7622                 break;
7623         case 0x0002:
7624                 str = "S8 coding";
7625                 break;
7626         default:
7627                 str = "Reserved";
7628                 break;
7629         }
7630
7631         print_field("PHY options preference: %s (0x%4.4x)", str, cmd->phy_opts);
7632 }
7633
7634 static void le_enhanced_receiver_test_cmd(uint16_t index, const void *data,
7635                                                         uint8_t size)
7636 {
7637         const struct bt_hci_cmd_le_enhanced_receiver_test *cmd = data;
7638         const char *str;
7639
7640         print_field("RX channel frequency: %d MHz (0x%2.2x)",
7641                                 (cmd->rx_channel * 2) + 2402, cmd->rx_channel);
7642         print_le_phy("PHY", cmd->phy);
7643
7644         switch (cmd->modulation_index) {
7645         case 0x00:
7646                 str = "Standard";
7647                 break;
7648         case 0x01:
7649                 str = "Stable";
7650                 break;
7651         default:
7652                 str = "Reserved";
7653                 break;
7654         }
7655
7656         print_field("Modulation index: %s (0x%2.2x)", str,
7657                                                         cmd->modulation_index);
7658 }
7659
7660 static void le_enhanced_transmitter_test_cmd(uint16_t index, const void *data,
7661                                                         uint8_t size)
7662 {
7663         const struct bt_hci_cmd_le_enhanced_transmitter_test *cmd = data;
7664         const char *str;
7665
7666         print_field("TX channel frequency: %d MHz (0x%2.2x)",
7667                                 (cmd->tx_channel * 2) + 2402, cmd->tx_channel);
7668         print_field("Test data length: %d bytes", cmd->data_len);
7669         print_field("Packet payload: 0x%2.2x", cmd->payload);
7670
7671         switch (cmd->phy) {
7672         case 0x01:
7673                 str = "LE 1M";
7674                 break;
7675         case 0x02:
7676                 str = "LE 2M";
7677                 break;
7678         case 0x03:
7679                 str = "LE Coded with S=8";
7680                 break;
7681         case 0x04:
7682                 str = "LE Coded with S=2";
7683                 break;
7684         default:
7685                 str = "Reserved";
7686                 break;
7687         }
7688
7689         print_field("PHY: %s (0x%2.2x)", str, cmd->phy);
7690 }
7691
7692 static void le_set_adv_set_rand_addr(uint16_t index, const void *data,
7693                                                         uint8_t size)
7694 {
7695         const struct bt_hci_cmd_le_set_adv_set_rand_addr *cmd = data;
7696
7697         print_field("Advertising handle: 0x%2.2x", cmd->handle);
7698         print_addr("Advertising random address", cmd->bdaddr, 0x01);
7699 }
7700
7701 static const struct bitfield_data ext_adv_properties_table[] = {
7702         {  0, "Connectable"             },
7703         {  1, "Scannable"               },
7704         {  2, "Directed"        },
7705         {  3, "High Duty Cycle Directed Connectable"    },
7706         {  4, "Use legacy advertising PDUs"     },
7707         {  5, "Anonymous advertising"   },
7708         {  6, "Include TxPower"         },
7709         { }
7710 };
7711
7712 static const char *get_adv_pdu_desc(uint16_t flags)
7713 {
7714         const char *str;
7715
7716         switch (flags) {
7717         case 0x10:
7718                 str = "ADV_NONCONN_IND";
7719                 break;
7720         case 0x12:
7721                 str = "ADV_SCAN_IND";
7722                 break;
7723         case 0x13:
7724                 str = "ADV_IND";
7725                 break;
7726         case 0x15:
7727                 str = "ADV_DIRECT_IND (low duty cycle)";
7728                 break;
7729         case 0x1d:
7730                 str = "ADV_DIRECT_IND (high duty cycle)";
7731                 break;
7732         default:
7733                 str = "Reserved";
7734                 break;
7735         }
7736
7737         return str;
7738 }
7739
7740 static void print_ext_adv_properties(uint16_t flags)
7741 {
7742         uint16_t mask = flags;
7743         const char *property;
7744         int i;
7745
7746         print_field("Properties: 0x%4.4x", flags);
7747
7748         for (i = 0; ext_adv_properties_table[i].str; i++) {
7749                 if (flags & (1 << ext_adv_properties_table[i].bit)) {
7750                         property = ext_adv_properties_table[i].str;
7751
7752                         if (ext_adv_properties_table[i].bit == 4) {
7753                                 print_field("  %s: %s", property,
7754                                                 get_adv_pdu_desc(flags));
7755                         } else {
7756                                 print_field("  %s", property);
7757                         }
7758                         mask &= ~(1 << ext_adv_properties_table[i].bit);
7759                 }
7760         }
7761
7762         if (mask)
7763                 print_text(COLOR_UNKNOWN_ADV_FLAG,
7764                                 "  Unknown advertising properties (0x%4.4x)",
7765                                                                         mask);
7766 }
7767
7768 static void print_ext_slot_625(const char *label, const uint8_t value[3])
7769 {
7770         uint32_t value_cpu = value[0];
7771
7772         value_cpu |= value[1] << 8;
7773         value_cpu |= value[2] << 16;
7774
7775         print_field("%s: %.3f msec (0x%4.4x)", label,
7776                                                 value_cpu * 0.625, value_cpu);
7777 }
7778
7779 static void le_set_ext_adv_params_cmd(uint16_t index, const void *data,
7780                                                         uint8_t size)
7781 {
7782         const struct bt_hci_cmd_le_set_ext_adv_params *cmd = data;
7783         const char *str;
7784
7785         print_field("Handle: 0x%2.2x", cmd->handle);
7786         print_ext_adv_properties(le16_to_cpu(cmd->evt_properties));
7787
7788         print_ext_slot_625("Min advertising interval", cmd->min_interval);
7789         print_ext_slot_625("Max advertising interval", cmd->max_interval);
7790         print_adv_channel_map("Channel map", cmd->channel_map);
7791         print_own_addr_type(cmd->own_addr_type);
7792         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
7793         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
7794         print_adv_filter_policy("Filter policy", cmd->filter_policy);
7795         if (cmd->tx_power == 0x7f)
7796                 print_field("TX power: Host has no preference (0x7f)");
7797         else
7798                 print_power_level(cmd->tx_power, NULL);
7799
7800         switch (cmd->primary_phy) {
7801         case 0x01:
7802                 str = "LE 1M";
7803                 break;
7804         case 0x03:
7805                 str = "LE Coded";
7806                 break;
7807         default:
7808                 str = "Reserved";
7809                 break;
7810         }
7811
7812         print_field("Primary PHY: %s (0x%2.2x)", str, cmd->primary_phy);
7813         print_field("Secondary max skip: 0x%2.2x", cmd->secondary_max_skip);
7814         print_le_phy("Secondary PHY", cmd->secondary_phy);
7815         print_field("SID: 0x%2.2x", cmd->sid);
7816         print_enable("Scan request notifications", cmd->notif_enable);
7817 }
7818
7819 static void le_set_ext_adv_params_rsp(uint16_t index, const void *data,
7820                                                         uint8_t size)
7821 {
7822         const struct bt_hci_rsp_le_set_ext_adv_params *rsp = data;
7823
7824         print_status(rsp->status);
7825         print_power_level(rsp->tx_power, "selected");
7826 }
7827
7828 static void le_set_ext_adv_data_cmd(uint16_t index, const void *data,
7829                                                         uint8_t size)
7830 {
7831         const struct bt_hci_cmd_le_set_ext_adv_data *cmd = data;
7832         const char *str;
7833
7834         print_field("Handle: 0x%2.2x", cmd->handle);
7835
7836         switch (cmd->operation) {
7837         case 0x00:
7838                 str = "Immediate fragment";
7839                 break;
7840         case 0x01:
7841                 str = "First fragment";
7842                 break;
7843         case 0x02:
7844                 str = "Last fragment";
7845                 break;
7846         case 0x03:
7847                 str = "Complete extended advertising data";
7848                 break;
7849         case 0x04:
7850                 str = "Unchanged data";
7851                 break;
7852         default:
7853                 str = "Reserved";
7854                 break;
7855         }
7856
7857         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
7858
7859         switch (cmd->fragment_preference) {
7860         case 0x00:
7861                 str = "Fragment all";
7862                 break;
7863         case 0x01:
7864                 str = "Minimize fragmentation";
7865                 break;
7866         default:
7867                 str = "Reserved";
7868                 break;
7869         }
7870
7871         print_field("Fragment preference: %s (0x%2.2x)", str,
7872                                                 cmd->fragment_preference);
7873         print_field("Data length: 0x%2.2x", cmd->data_len);
7874         packet_print_ad(cmd->data, size - sizeof(*cmd));
7875 }
7876
7877 static void le_set_ext_scan_rsp_data_cmd(uint16_t index, const void *data,
7878                                                         uint8_t size)
7879 {
7880         const struct bt_hci_cmd_le_set_ext_scan_rsp_data *cmd = data;
7881         const char *str;
7882
7883         print_field("Handle: 0x%2.2x", cmd->handle);
7884
7885         switch (cmd->operation) {
7886         case 0x00:
7887                 str = "Immediate fragment";
7888                 break;
7889         case 0x01:
7890                 str = "First fragment";
7891                 break;
7892         case 0x02:
7893                 str = "Last fragment";
7894                 break;
7895         case 0x03:
7896                 str = "Complete scan response data";
7897                 break;
7898         case 0x04:
7899                 str = "Unchanged data";
7900                 break;
7901         default:
7902                 str = "Reserved";
7903                 break;
7904         }
7905
7906         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
7907
7908         switch (cmd->fragment_preference) {
7909         case 0x00:
7910                 str = "Fragment all";
7911                 break;
7912         case 0x01:
7913                 str = "Minimize fragmentation";
7914                 break;
7915         default:
7916                 str = "Reserved";
7917                 break;
7918         }
7919
7920         print_field("Fragment preference: %s (0x%2.2x)", str,
7921                                                 cmd->fragment_preference);
7922         print_field("Data length: 0x%2.2x", cmd->data_len);
7923         packet_print_ad(cmd->data, size - sizeof(*cmd));
7924 }
7925
7926 static void le_set_ext_adv_enable_cmd(uint16_t index, const void *data,
7927                                                         uint8_t size)
7928 {
7929         const struct bt_hci_cmd_le_set_ext_adv_enable *cmd = data;
7930         const struct bt_hci_cmd_ext_adv_set *adv_set;
7931         int i;
7932
7933         print_enable("Extended advertising", cmd->enable);
7934
7935         if (cmd->num_of_sets == 0)
7936                 print_field("Number of sets: Disable all sets (0x%2.2x)",
7937                                                         cmd->num_of_sets);
7938         else if (cmd->num_of_sets > 0x3f)
7939                 print_field("Number of sets: Reserved (0x%2.2x)",
7940                                                         cmd->num_of_sets);
7941         else
7942                 print_field("Number of sets: %u (0x%2.2x)", cmd->num_of_sets,
7943                                                         cmd->num_of_sets);
7944
7945         for (i = 0; i < cmd->num_of_sets; ++i) {
7946                 adv_set = data + 2 + i * sizeof(struct bt_hci_cmd_ext_adv_set);
7947                 print_field("Entry %d", i);
7948                 print_field("  Handle: 0x%2.2x", adv_set->handle);
7949                 print_field("  Duration: %d ms (0x%2.2x)",
7950                                 adv_set->duration * 10, adv_set->duration);
7951                 print_field("  Max ext adv events: %d", adv_set->max_events);
7952         }
7953 }
7954
7955 static void le_read_max_adv_data_len_rsp(uint16_t index, const void *data,
7956                                                         uint8_t size)
7957 {
7958         const struct bt_hci_rsp_le_read_max_adv_data_len *rsp = data;
7959
7960         print_status(rsp->status);
7961         print_field("Max length: %d", rsp->max_len);
7962 }
7963
7964 static void le_read_num_supported_adv_sets_rsp(uint16_t index, const void *data,
7965                                                         uint8_t size)
7966 {
7967         const struct bt_hci_rsp_le_read_num_supported_adv_sets *rsp = data;
7968
7969         print_status(rsp->status);
7970         print_field("Num supported adv sets: %d", rsp->num_of_sets);
7971 }
7972
7973 static void le_remove_adv_set_cmd(uint16_t index, const void *data,
7974                                                         uint8_t size)
7975 {
7976         const struct bt_hci_cmd_le_remove_adv_set *cmd = data;
7977
7978         print_handle(cmd->handle);
7979 }
7980
7981 static const struct bitfield_data pa_properties_table[] = {
7982         {  6, "Include TxPower"         },
7983         { }
7984 };
7985
7986 static void print_pa_properties(uint16_t flags)
7987 {
7988         uint16_t mask;
7989
7990         print_field("Properties: 0x%4.4x", flags);
7991
7992         mask = print_bitfield(2, flags, pa_properties_table);
7993         if (mask)
7994                 print_text(COLOR_UNKNOWN_ADV_FLAG,
7995                                 "  Unknown advertising properties (0x%4.4x)",
7996                                                                         mask);
7997 }
7998
7999 static void le_set_pa_params_cmd(uint16_t index, const void *data, uint8_t size)
8000 {
8001         const struct bt_hci_cmd_le_set_pa_params *cmd = data;
8002
8003         print_handle(cmd->handle);
8004         print_slot_125("Min interval", cmd->min_interval);
8005         print_slot_125("Max interval", cmd->max_interval);
8006         print_pa_properties(cmd->properties);
8007 }
8008
8009 static void le_set_pa_data_cmd(uint16_t index, const void *data, uint8_t size)
8010 {
8011         const struct bt_hci_cmd_le_set_pa_data *cmd = data;
8012         const char *str;
8013
8014         print_handle(cmd->handle);
8015
8016         switch (cmd->operation) {
8017         case 0x00:
8018                 str = "Immediate fragment";
8019                 break;
8020         case 0x01:
8021                 str = "First fragment";
8022                 break;
8023         case 0x02:
8024                 str = "Last fragment";
8025                 break;
8026         case 0x03:
8027                 str = "Complete ext advertising data";
8028                 break;
8029         default:
8030                 str = "Reserved";
8031                 break;
8032         }
8033
8034         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
8035         print_field("Data length: 0x%2.2x", cmd->data_len);
8036         print_eir(cmd->data, cmd->data_len, true);
8037 }
8038
8039 static void le_set_pa_enable_cmd(uint16_t index, const void *data, uint8_t size)
8040 {
8041         const struct bt_hci_cmd_le_set_pa_enable *cmd = data;
8042
8043         print_enable("Periodic advertising", cmd->enable);
8044         print_handle(cmd->handle);
8045 }
8046
8047 static const struct bitfield_data ext_scan_phys_table[] = {
8048         {  0, "LE 1M"           },
8049         {  2, "LE Coded"                },
8050         { }
8051 };
8052
8053 static void print_ext_scan_phys(const void *data, uint8_t flags)
8054 {
8055         const struct bt_hci_le_scan_phy *scan_phy;
8056         uint8_t mask = flags;
8057         int bits_set = 0;
8058         int i;
8059
8060         print_field("PHYs: 0x%2.2x", flags);
8061
8062         for (i = 0; ext_scan_phys_table[i].str; i++) {
8063                 if (flags & (1 << ext_scan_phys_table[i].bit)) {
8064                         scan_phy = data + bits_set * sizeof(*scan_phy);
8065                         mask &= ~(1 << ext_scan_phys_table[i].bit);
8066
8067                         print_field("Entry %d: %s", bits_set,
8068                                                 ext_scan_phys_table[i].str);
8069                         print_scan_type("  Type", scan_phy->type);
8070                         print_slot_625("  Interval", scan_phy->interval);
8071                         print_slot_625("  Window", scan_phy->window);
8072
8073                         ++bits_set;
8074                 }
8075         }
8076
8077         if (mask)
8078                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown scanning PHYs"
8079                                                         " (0x%2.2x)", mask);
8080 }
8081
8082 static void le_set_ext_scan_params_cmd(uint16_t index, const void *data,
8083                                                         uint8_t size)
8084 {
8085         const struct bt_hci_cmd_le_set_ext_scan_params *cmd = data;
8086
8087         print_own_addr_type(cmd->own_addr_type);
8088         print_scan_filter_policy(cmd->filter_policy);
8089         print_ext_scan_phys(cmd->data, cmd->num_phys);
8090 }
8091
8092 static void le_set_ext_scan_enable_cmd(uint16_t index, const void *data,
8093                                                         uint8_t size)
8094 {
8095         const struct bt_hci_cmd_le_set_ext_scan_enable *cmd = data;
8096
8097         print_enable("Extended scan", cmd->enable);
8098         print_enable("Filter duplicates", cmd->filter_dup);
8099
8100         print_field("Duration: %d msec (0x%4.4x)",
8101                                                 le16_to_cpu(cmd->duration) * 10,
8102                                                 le16_to_cpu(cmd->duration));
8103         print_field("Period: %.2f sec (0x%4.4x)",
8104                                                 le16_to_cpu(cmd->period) * 1.28,
8105                                                 le16_to_cpu(cmd->period));
8106 }
8107
8108 static const struct bitfield_data ext_conn_phys_table[] = {
8109         {  0, "LE 1M"           },
8110         {  1, "LE 2M"           },
8111         {  2, "LE Coded"        },
8112         { }
8113 };
8114
8115 static void print_ext_conn_phys(const void *data, uint8_t flags)
8116 {
8117         const struct bt_hci_le_ext_create_conn *entry;
8118         uint8_t mask = flags;
8119         int bits_set = 0;
8120         int i;
8121
8122         print_field("Initiating PHYs: 0x%2.2x", flags);
8123
8124         for (i = 0; ext_conn_phys_table[i].str; i++) {
8125                 if (flags & (1 << ext_conn_phys_table[i].bit)) {
8126                         entry = data + bits_set * sizeof(*entry);
8127                         mask &= ~(1 << ext_conn_phys_table[i].bit);
8128
8129                         print_field("Entry %d: %s", bits_set,
8130                                                 ext_conn_phys_table[i].str);
8131                         print_slot_625("  Scan interval", entry->scan_interval);
8132                         print_slot_625("  Scan window", entry->scan_window);
8133                         print_slot_125("  Min connection interval",
8134                                                         entry->min_interval);
8135                         print_slot_125("  Max connection interval",
8136                                                         entry->max_interval);
8137                         print_conn_latency("  Connection latency",
8138                                                                 entry->latency);
8139                         print_field("  Supervision timeout: %d msec (0x%4.4x)",
8140                                         le16_to_cpu(entry->supv_timeout) * 10,
8141                                         le16_to_cpu(entry->supv_timeout));
8142                         print_slot_625("  Min connection length",
8143                                                         entry->min_length);
8144                         print_slot_625("  Max connection length",
8145                                                         entry->max_length);
8146
8147                         ++bits_set;
8148                 }
8149         }
8150
8151         if (mask)
8152                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown scanning PHYs"
8153                                                         " (0x%2.2x)", mask);
8154 }
8155
8156 static void le_ext_create_conn_cmd(uint16_t index, const void *data,
8157                                                         uint8_t size)
8158 {
8159         const struct bt_hci_cmd_le_ext_create_conn *cmd = data;
8160         const char *str;
8161
8162         switch (cmd->filter_policy) {
8163         case 0x00:
8164                 str = "Accept list is not used";
8165                 break;
8166         case 0x01:
8167                 str = "Accept list is used";
8168                 break;
8169         default:
8170                 str = "Reserved";
8171                 break;
8172         }
8173
8174         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
8175
8176         print_own_addr_type(cmd->own_addr_type);
8177         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
8178         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
8179         print_ext_conn_phys(cmd->data, cmd->phys);
8180 }
8181
8182 static const struct bitfield_data create_sync_cte_type[] = {
8183         {  0, "Do not sync to packets with AoA CTE"     },
8184         {  1, "Do not sync to packets with AoD CTE 1us" },
8185         {  2, "Do not sync to packets with AoD CTE 2us" },
8186         {  3, "Do not sync to packets with type 3 AoD"  },
8187         {  4, "Do not sync to packets without CTE"      },
8188         { },
8189 };
8190
8191 static const struct bitfield_data create_sync_options[] = {
8192         {  0, "Use Periodic Advertiser List"    },
8193         {  1, "Reporting initially disabled"    },
8194         { },
8195 };
8196
8197 static const struct bitfield_data create_sync_options_alt[] = {
8198         {  0, "Use advertising SID, Advertiser Address Type and address"},
8199         {  1, "Reporting initially enabled"                             },
8200         { },
8201 };
8202
8203 static void print_create_sync_cte_type(uint8_t flags)
8204 {
8205         uint8_t mask = flags;
8206
8207         print_field("Sync CTE type: 0x%4.4x", flags);
8208
8209         mask = print_bitfield(2, flags, create_sync_cte_type);
8210
8211         if (mask) {
8212                 print_text(COLOR_UNKNOWN_ADV_FLAG,
8213                                 "Unknown sync CTE type properties (0x%4.4x)",
8214                                                                         mask);
8215         }
8216 }
8217
8218 static void print_create_sync_options(uint8_t flags)
8219 {
8220         uint8_t mask = flags;
8221         int i;
8222
8223         print_field("Options: 0x%4.4x", flags);
8224
8225         for (i = 0; create_sync_options[i].str; i++) {
8226                 if (flags & (1 << create_sync_options[i].bit)) {
8227                         print_field("%s", create_sync_options[i].str);
8228                         mask  &= ~(1 << create_sync_options[i].bit);
8229                 } else {
8230                         print_field("%s", create_sync_options_alt[i].str);
8231                         mask  &= ~(1 << create_sync_options_alt[i].bit);
8232                 }
8233         }
8234
8235         if (mask) {
8236                 print_text(COLOR_UNKNOWN_ADV_FLAG,
8237                                         "  Unknown options (0x%4.4x)", mask);
8238         }
8239 }
8240
8241 static void le_pa_create_sync_cmd(uint16_t index, const void *data,
8242                                                         uint8_t size)
8243 {
8244         const struct bt_hci_cmd_le_pa_create_sync *cmd = data;
8245
8246         print_create_sync_options(cmd->options);
8247         print_field("SID: 0x%2.2x", cmd->sid);
8248         print_addr_type("Adv address type", cmd->addr_type);
8249         print_addr("Adv address", cmd->addr, cmd->addr_type);
8250         print_field("Skip: 0x%4.4x", cmd->skip);
8251         print_field("Sync timeout: %d msec (0x%4.4x)",
8252                                         le16_to_cpu(cmd->sync_timeout) * 10,
8253                                         le16_to_cpu(cmd->sync_timeout));
8254         print_create_sync_cte_type(cmd->sync_cte_type);
8255 }
8256
8257 static void le_pa_term_sync_cmd(uint16_t index, const void *data, uint8_t size)
8258 {
8259         const struct bt_hci_cmd_le_pa_term_sync *cmd = data;
8260
8261         print_field("Sync handle: 0x%4.4x", cmd->sync_handle);
8262 }
8263
8264 static void le_add_dev_pa_list_cmd(uint16_t index, const void *data,
8265                                                         uint8_t size)
8266 {
8267         const struct bt_hci_cmd_le_add_dev_pa_list *cmd = data;
8268
8269         print_addr_type("Adv address type", cmd->addr_type);
8270         print_addr("Adv address", cmd->addr, cmd->addr_type);
8271         print_field("SID: 0x%2.2x", cmd->sid);
8272 }
8273
8274 static void le_remove_dev_pa_list_cmd(uint16_t index, const void *data,
8275                                                         uint8_t size)
8276 {
8277         const struct bt_hci_cmd_le_remove_dev_pa_list *cmd = data;
8278
8279         print_addr_type("Adv address type", cmd->addr_type);
8280         print_addr("Adv address", cmd->addr, cmd->addr_type);
8281         print_field("SID: 0x%2.2x", cmd->sid);
8282 }
8283
8284 static void le_read_pa_list_size_rsp(uint16_t index, const void *data,
8285                                                         uint8_t size)
8286 {
8287         const struct bt_hci_rsp_le_read_dev_pa_list_size *rsp = data;
8288
8289         print_status(rsp->status);
8290         print_field("List size: 0x%2.2x", rsp->list_size);
8291 }
8292
8293 static void le_read_tx_power_rsp(uint16_t index, const void *data,
8294                                                         uint8_t size)
8295 {
8296         const struct bt_hci_rsp_le_read_tx_power *rsp = data;
8297
8298         print_status(rsp->status);
8299         print_field("Min Tx power: %d dBm", rsp->min_tx_power);
8300         print_field("Max Tx power: %d dBm", rsp->max_tx_power);
8301 }
8302
8303 static void le_read_rf_path_comp_rsp(uint16_t index, const void *data,
8304                                                         uint8_t size)
8305 {
8306         const struct bt_hci_rsp_le_read_rf_path_comp *rsp = data;
8307
8308         print_status(rsp->status);
8309         print_field("RF Tx Path Compensation Value: 0x%4.4x",
8310                                                         rsp->rf_tx_path_comp);
8311         print_field("RF Rx Path Compensation Value: 0x%4.4x",
8312                                                         rsp->rf_rx_path_comp);
8313 }
8314
8315 static void le_write_rf_path_comp_cmd(uint16_t index, const void *data,
8316                                                         uint8_t size)
8317 {
8318         const struct bt_hci_cmd_le_write_rf_path_comp *cmd = data;
8319
8320         print_field("RF Tx Path Compensation Value: 0x%4.4x",
8321                                                         cmd->rf_tx_path_comp);
8322         print_field("RF Rx Path Compensation Value: 0x%4.4x",
8323                                                         cmd->rf_rx_path_comp);
8324 }
8325
8326 static void le_set_priv_mode_cmd(uint16_t index, const void *data, uint8_t size)
8327 {
8328         const struct bt_hci_cmd_le_set_priv_mode *cmd = data;
8329         const char *str;
8330
8331         print_addr_type("Peer Identity address type", cmd->peer_id_addr_type);
8332         print_addr("Peer Identity address", cmd->peer_id_addr,
8333                                                         cmd->peer_id_addr_type);
8334
8335         switch (cmd->priv_mode) {
8336         case 0x00:
8337                 str = "Use Network Privacy";
8338                 break;
8339         case 0x01:
8340                 str = "Use Device Privacy";
8341                 break;
8342         default:
8343                 str = "Reserved";
8344                 break;
8345         }
8346
8347         print_field("Privacy Mode: %s (0x%2.2x)", str, cmd->priv_mode);
8348 }
8349
8350 static void le_receiver_test_cmd_v3(uint16_t index, const void *data,
8351                                                         uint8_t size)
8352 {
8353         const struct bt_hci_cmd_le_receiver_test_v3 *cmd = data;
8354         uint8_t i;
8355
8356         print_field("RX Channel: %u MHz (0x%2.2x)", cmd->rx_chan * 2 + 2402,
8357                                                         cmd->rx_chan);
8358
8359         switch (cmd->phy) {
8360         case 0x01:
8361                 print_field("PHY: LE 1M (0x%2.2x)", cmd->phy);
8362                 break;
8363         case 0x02:
8364                 print_field("PHY: LE 2M (0x%2.2x)", cmd->phy);
8365                 break;
8366         case 0x03:
8367                 print_field("PHY: LE Coded (0x%2.2x)", cmd->phy);
8368                 break;
8369         }
8370
8371         print_field("Modulation Index: %s (0x%2.2x)",
8372                 cmd->mod_index ? "stable" : "standard", cmd->mod_index);
8373         print_field("Expected CTE Length: %u us (0x%2.2x)", cmd->cte_len * 8,
8374                                                                 cmd->cte_len);
8375         print_field("Expected CTE Type: %u us slots (0x%2.2x)", cmd->cte_type,
8376                                                                 cmd->cte_type);
8377         print_field("Slot Duration: %u us (0x%2.2x)", cmd->duration,
8378                                                                 cmd->duration);
8379         print_field("Number of Antenna IDs: %u", cmd->num_antenna_id);
8380
8381         if (size < sizeof(*cmd) + cmd->num_antenna_id)
8382                 return;
8383
8384         for (i = 0; i < cmd->num_antenna_id; i++)
8385                 print_field("  Antenna ID: %u", cmd->antenna_ids[i]);
8386 }
8387
8388 static const char *parse_tx_test_payload(uint8_t payload)
8389 {
8390         switch (payload) {
8391         case 0x00:
8392                 return "PRBS9 sequence 11111111100000111101...";
8393         case 0x01:
8394                 return "Repeated 11110000";
8395         case 0x02:
8396                 return "Repeated 10101010";
8397         case 0x03:
8398                 return "PRBS15";
8399         case 0x04:
8400                 return "Repeated 11111111";
8401         case 0x05:
8402                 return "Repeated 00000000";
8403         case 0x06:
8404                 return "Repeated 00001111";
8405         case 0x07:
8406                 return "Repeated 01010101";
8407         default:
8408                 return "Reserved";
8409         }
8410 }
8411
8412 static void le_tx_test_cmd_v3(uint16_t index, const void *data, uint8_t size)
8413 {
8414         const struct bt_hci_cmd_le_tx_test_v3 *cmd = data;
8415         uint8_t i;
8416
8417         print_field("TX Channel: %u MHz (0x%2.2x)", cmd->chan * 2 + 2402,
8418                                                                 cmd->chan);
8419         print_field("Length of Test Data: %u", cmd->data_len);
8420         print_field("Packet Payload: %s (0x%2.2x)",
8421                         parse_tx_test_payload(cmd->payload), cmd->payload);
8422
8423         switch (cmd->phy) {
8424         case 0x01:
8425                 print_field("PHY: LE 1M (0x%2.2x)", cmd->phy);
8426                 break;
8427         case 0x02:
8428                 print_field("PHY: LE 2M (0x%2.2x)", cmd->phy);
8429                 break;
8430         case 0x03:
8431                 print_field("PHY: LE Coded with S=8 (0x%2.2x)", cmd->phy);
8432                 break;
8433         case 0x04:
8434                 print_field("PHY: LE Coded with S=2 (0x%2.2x)", cmd->phy);
8435                 break;
8436         }
8437
8438         print_field("Expected CTE Length: %u us (0x%2.2x)", cmd->cte_len * 8,
8439                                                                 cmd->cte_len);
8440         print_field("Expected CTE Type: %u us slots (0x%2.2x)", cmd->cte_type,
8441                                                                 cmd->cte_type);
8442         print_field("Slot Duration: %u us (0x%2.2x)", cmd->duration,
8443                                                                 cmd->duration);
8444         print_field("Number of Antenna IDs: %u", cmd->num_antenna_id);
8445
8446         if (size < sizeof(*cmd) + cmd->num_antenna_id)
8447                 return;
8448
8449         for (i = 0; i < cmd->num_antenna_id; i++)
8450                 print_field("  Antenna ID: %u", cmd->antenna_ids[i]);
8451 }
8452
8453 static void le_pa_rec_enable(uint16_t index, const void *data, uint8_t size)
8454 {
8455         const struct bt_hci_cmd_le_set_pa_enable *cmd = data;
8456
8457         print_field("Sync handle: %d", cmd->handle);
8458         print_enable("Reporting", cmd->enable);
8459 }
8460
8461 static void le_pa_sync_trans(uint16_t index, const void *data, uint8_t size)
8462 {
8463         const struct bt_hci_cmd_periodic_sync_trans *cmd = data;
8464
8465         print_field("Connection handle: %d", cmd->handle);
8466         print_field("Service data: 0x%4.4x", cmd->service_data);
8467         print_field("Sync handle: %d", cmd->sync_handle);
8468 }
8469
8470 static void le_pa_set_info_trans(uint16_t index, const void *data, uint8_t size)
8471 {
8472         const struct bt_hci_cmd_pa_set_info_trans *cmd = data;
8473
8474         print_field("Connection handle: %d", cmd->handle);
8475         print_field("Service data: 0x%4.4x", cmd->service_data);
8476         print_field("Advertising handle: %d", cmd->adv_handle);
8477 }
8478
8479 static void print_sync_mode(uint8_t mode)
8480 {
8481         const char *str;
8482
8483         switch (mode) {
8484         case 0x00:
8485                 str = "Disabled";
8486                 break;
8487         case 0x01:
8488                 str = "Enabled with report events disabled";
8489                 break;
8490         case 0x02:
8491                 str = "Enabled with report events enabled";
8492                 break;
8493         default:
8494                 str = "RFU";
8495                 break;
8496         }
8497
8498         print_field("Mode: %s (0x%2.2x)", str, mode);
8499 }
8500
8501 static void le_pa_sync_trans_params(uint16_t index, const void *data,
8502                                                         uint8_t size)
8503 {
8504         const struct bt_hci_cmd_pa_sync_trans_params *cmd = data;
8505
8506         print_field("Connection handle: %d", cmd->handle);
8507         print_sync_mode(cmd->mode);
8508         print_field("Skip: 0x%2.2x", cmd->skip);
8509         print_field("Sync timeout: %d msec (0x%4.4x)",
8510                                         le16_to_cpu(cmd->sync_timeout) * 10,
8511                                         le16_to_cpu(cmd->sync_timeout));
8512         print_create_sync_cte_type(cmd->cte_type);
8513 }
8514
8515 static void le_set_default_pa_sync_trans_params(uint16_t index,
8516                                                 const void *data, uint8_t size)
8517 {
8518         const struct bt_hci_cmd_default_pa_sync_trans_params *cmd = data;
8519
8520         print_sync_mode(cmd->mode);
8521         print_field("Skip: 0x%2.2x", cmd->skip);
8522         print_field("Sync timeout: %d msec (0x%4.4x)",
8523                                         le16_to_cpu(cmd->sync_timeout) * 10,
8524                                         le16_to_cpu(cmd->sync_timeout));
8525         print_create_sync_cte_type(cmd->cte_type);
8526 }
8527
8528 static void print_sca(uint8_t sca)
8529 {
8530         switch (sca) {
8531         case 0x00:
8532                 print_field("SCA: 201 - 500 ppm (0x%2.2x)", sca);
8533                 return;
8534         case 0x01:
8535                 print_field("SCA: 151 - 200 ppm (0x%2.2x)", sca);
8536                 return;
8537         case 0x02:
8538                 print_field("SCA: 101 - 150 ppm (0x%2.2x)", sca);
8539                 return;
8540         case 0x03:
8541                 print_field("SCA: 76 - 100 ppm (0x%2.2x)", sca);
8542                 return;
8543         case 0x04:
8544                 print_field("SCA: 51 - 75 ppm (0x%2.2x)", sca);
8545                 return;
8546         case 0x05:
8547                 print_field("SCA: 31 - 50 ppm (0x%2.2x)", sca);
8548                 return;
8549         case 0x06:
8550                 print_field("SCA: 21 - 30 ppm (0x%2.2x)", sca);
8551                 return;
8552         case 0x07:
8553                 print_field("SCA: 0 - 20 ppm (0x%2.2x)", sca);
8554                 return;
8555         default:
8556                 print_field("SCA: Reserved (0x%2.2x)", sca);
8557         }
8558 }
8559
8560 static void print_packing(uint8_t value)
8561 {
8562         switch (value) {
8563         case 0x00:
8564                 print_field("Packing: Sequential (0x%2.2x)", value);
8565                 return;
8566         case 0x01:
8567                 print_field("Packing: Interleaved (0x%2.2x)", value);
8568                 return;
8569         default:
8570                 print_field("Packing: Reserved (0x%2.2x)", value);
8571         }
8572 }
8573
8574 static void print_framing(uint8_t value)
8575 {
8576         switch (value) {
8577         case 0x00:
8578                 print_field("Framing: Unframed (0x%2.2x)", value);
8579                 return;
8580         case 0x01:
8581                 print_field("Framing: Framed (0x%2.2x)", value);
8582                 return;
8583         default:
8584                 print_field("Packing: Reserved (0x%2.2x)", value);
8585         }
8586 }
8587
8588 static void le_read_buffer_size_v2_rsp(uint16_t index, const void *data,
8589                                                         uint8_t size)
8590 {
8591         const struct bt_hci_rsp_le_read_buffer_size_v2 *rsp = data;
8592
8593         print_status(rsp->status);
8594
8595         if (size == 1)
8596                 return;
8597
8598         print_field("ACL MTU: %d", le16_to_cpu(rsp->acl_mtu));
8599         print_field("ACL max packet: %d", rsp->acl_max_pkt);
8600         print_field("ISO MTU: %d", le16_to_cpu(rsp->iso_mtu));
8601         print_field("ISO max packet: %d", rsp->iso_max_pkt);
8602 }
8603
8604 static void le_read_iso_tx_sync_cmd(uint16_t index, const void *data,
8605                                                         uint8_t size)
8606 {
8607         const struct bt_hci_cmd_le_read_iso_tx_sync *cmd = data;
8608
8609         print_field("Handle: %d", le16_to_cpu(cmd->handle));
8610 }
8611
8612 static void le_read_iso_tx_sync_rsp(uint16_t index, const void *data,
8613                                                         uint8_t size)
8614 {
8615         const struct bt_hci_rsp_le_read_iso_tx_sync *rsp = data;
8616         uint32_t offset = 0;
8617
8618         print_status(rsp->status);
8619
8620         if (size == 1)
8621                 return;
8622
8623         print_field("Handle: %d", le16_to_cpu(rsp->handle));
8624         print_field("Sequence Number: %d", le16_to_cpu(rsp->seq));
8625         print_field("Timestamp: %d", le32_to_cpu(rsp->timestamp));
8626
8627         memcpy(&offset, rsp->offset, sizeof(rsp->offset));
8628
8629         print_field("Offset: %d", le32_to_cpu(offset));
8630 }
8631
8632 static void print_cis_params(const void *data, int i)
8633 {
8634         const struct bt_hci_cis_params *cis = data;
8635
8636         print_field("CIS ID: 0x%2.2x", cis->cis_id);
8637         print_field("Central to Peripheral Maximum SDU Size: %u",
8638                                                 le16_to_cpu(cis->c_sdu));
8639         print_field("Peripheral to Central Maximum SDU Size: %u",
8640                                                 le16_to_cpu(cis->p_sdu));
8641         print_le_phy("Central to Peripheral PHY", cis->c_phy);
8642         print_le_phy("Peripheral to Central PHY", cis->p_phy);
8643         print_field("Central to Peripheral Retransmission attempts: 0x%2.2x",
8644                                                         cis->c_rtn);
8645         print_field("Peripheral to Central Retransmission attempts: 0x%2.2x",
8646                                                         cis->p_rtn);
8647 }
8648
8649 static void le_set_cig_params_cmd(uint16_t index, const void *data,
8650                                                         uint8_t size)
8651 {
8652         const struct bt_hci_cmd_le_set_cig_params *cmd = data;
8653
8654         print_field("CIG ID: 0x%2.2x", cmd->cig_id);
8655         print_usec_interval("Central to Peripheral SDU Interval",
8656                                                         cmd->c_interval);
8657         print_usec_interval("Peripheral to Central SDU Interval",
8658                                                         cmd->p_interval);
8659         print_sca(cmd->sca);
8660         print_packing(cmd->packing);
8661         print_framing(cmd->framing);
8662         print_field("Central to Peripheral Maximum Latency: %d ms (0x%4.4x)",
8663                 le16_to_cpu(cmd->c_latency), le16_to_cpu(cmd->c_latency));
8664         print_field("Peripheral to Central Maximum Latency: %d ms (0x%4.4x)",
8665                 le16_to_cpu(cmd->p_latency), le16_to_cpu(cmd->p_latency));
8666         print_field("Number of CIS: %u", cmd->num_cis);
8667
8668         size -= sizeof(*cmd);
8669
8670         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis),
8671                                                 print_cis_params);
8672 }
8673
8674 static void print_cis_params_test(const void *data, int i)
8675 {
8676         const struct bt_hci_cis_params_test *cis = data;
8677
8678         print_field("CIS ID: 0x%2.2x", cis->cis_id);
8679         print_field("NSE: 0x%2.2x", cis->nse);
8680         print_field("Central to Peripheral Maximum SDU: 0x%4.4x",
8681                                                 le16_to_cpu(cis->c_sdu));
8682         print_field("Peripheral to Central Maximum SDU: 0x%4.4x",
8683                                                 le16_to_cpu(cis->p_sdu));
8684         print_field("Central to Peripheral Maximum PDU: 0x%4.4x",
8685                                                 le16_to_cpu(cis->c_pdu));
8686         print_field("Peripheral to Central Maximum PDU: 0x%4.4x",
8687                                                 le16_to_cpu(cis->p_pdu));
8688         print_le_phy("Central to Peripheral PHY", cis->c_phy);
8689         print_le_phy("Peripheral to Central PHY", cis->p_phy);
8690         print_field("Central to Peripheral Burst Number: 0x%2.2x", cis->c_bn);
8691         print_field("Peripheral to Central Burst Number: 0x%2.2x", cis->p_bn);
8692 }
8693
8694 static void le_set_cig_params_test_cmd(uint16_t index, const void *data,
8695                                                         uint8_t size)
8696 {
8697         const struct bt_hci_cmd_le_set_cig_params_test *cmd = data;
8698
8699         print_field("CIG ID: 0x%2.2x", cmd->cig_id);
8700         print_usec_interval("Central to Peripheral SDU Interval",
8701                                                         cmd->c_interval);
8702         print_usec_interval("Peripheral to Central SDU Interval",
8703                                                         cmd->p_interval);
8704         print_field("Central to Peripheral Flush Timeout: 0x%2.2x", cmd->c_ft);
8705         print_field("Peripheral to Central Flush Timeout: 0x%2.2x", cmd->p_ft);
8706         print_field("ISO Interval: %.2f ms (0x%4.4x)",
8707                                 le16_to_cpu(cmd->iso_interval) * 1.25,
8708                                 le16_to_cpu(cmd->iso_interval));
8709         print_sca(cmd->sca);
8710         print_packing(cmd->packing);
8711         print_framing(cmd->framing);
8712         print_field("Number of CIS: %u", cmd->num_cis);
8713
8714         size -= sizeof(*cmd);
8715
8716         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis),
8717                                                 print_cis_params_test);
8718 }
8719
8720 static void print_cig_handle(const void *data, int i)
8721 {
8722         uint16_t handle = get_le16(data);
8723
8724         print_field("Connection Handle #%d: %d", i, handle);
8725 }
8726
8727 static void le_set_cig_params_rsp(uint16_t index, const void *data,
8728                                                         uint8_t size)
8729 {
8730         const struct bt_hci_rsp_le_set_cig_params *rsp = data;
8731
8732         print_status(rsp->status);
8733
8734         if (size == 1)
8735                 return;
8736
8737         print_field("CIG ID: 0x%2.2x", rsp->cig_id);
8738         print_field("Number of Handles: %u", rsp->num_handles);
8739
8740         size -= sizeof(*rsp);
8741
8742         print_list(rsp->handle, size, rsp->num_handles, sizeof(*rsp->handle),
8743                                                 print_cig_handle);
8744 }
8745
8746 static void print_cis(const void *data, int i)
8747 {
8748         const struct bt_hci_cis *cis = data;
8749         struct packet_conn_data *conn;
8750
8751         print_field("CIS Handle: %d", cis->cis_handle);
8752         print_field("ACL Handle: %d", cis->acl_handle);
8753
8754         conn = packet_get_conn_data(cis->acl_handle);
8755         if (conn)
8756                 conn->link = cis->cis_handle;
8757 }
8758
8759 static void le_create_cis_cmd(uint16_t index, const void *data, uint8_t size)
8760 {
8761         const struct bt_hci_cmd_le_create_cis *cmd = data;
8762
8763         print_field("Number of CIS: %u", cmd->num_cis);
8764
8765         size -= sizeof(*cmd);
8766
8767         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis), print_cis);
8768 }
8769
8770 static void le_remove_cig_cmd(uint16_t index, const void *data, uint8_t size)
8771 {
8772         const struct bt_hci_cmd_le_remove_cig *cmd = data;
8773
8774         print_field("CIG ID: 0x%02x", cmd->cig_id);
8775 }
8776
8777 static void le_remove_cig_rsp(uint16_t index, const void *data, uint8_t size)
8778 {
8779         const struct bt_hci_rsp_le_remove_cig *rsp = data;
8780
8781         print_status(rsp->status);
8782
8783         if (size == 1)
8784                 return;
8785
8786         print_field("CIG ID: 0x%2.2x", rsp->cig_id);
8787 }
8788
8789 static void le_accept_cis_req_cmd(uint16_t index, const void *data,
8790                                                         uint8_t size)
8791 {
8792         const struct bt_hci_cmd_le_accept_cis *cmd = data;
8793
8794         print_field("CIS Handle: %d", le16_to_cpu(cmd->handle));
8795 }
8796
8797 static void le_reject_cis_req_cmd(uint16_t index, const void *data,
8798                                                         uint8_t size)
8799 {
8800         const struct bt_hci_cmd_le_reject_cis *cmd = data;
8801
8802         print_field("CIS Handle: %d", le16_to_cpu(cmd->handle));
8803         print_reason(cmd->reason);
8804 }
8805
8806 static void print_bis(const struct bt_hci_bis *bis)
8807 {
8808         print_usec_interval("SDU Interval", bis->sdu_interval);
8809         print_field("Maximum SDU size: %u", le16_to_cpu(bis->sdu));
8810         print_field("Maximum Latency: %u ms (0x%4.4x)",
8811                         le16_to_cpu(bis->latency), le16_to_cpu(bis->latency));
8812         print_field("RTN: 0x%2.2x", bis->rtn);
8813         print_le_phy("PHY", bis->phy);
8814         print_packing(bis->packing);
8815         print_framing(bis->framing);
8816         print_field("Encryption: 0x%2.2x", bis->encryption);
8817         print_hex_field("Broadcast Code", bis->bcode, 16);
8818 }
8819
8820 static void le_create_big_cmd(uint16_t index, const void *data, uint8_t size)
8821 {
8822         const struct bt_hci_cmd_le_create_big *cmd = data;
8823
8824         print_field("Handle: 0x%2.2x", cmd->handle);
8825         print_field("Advertising Handle: 0x%2.2x", cmd->adv_handle);
8826         print_field("Number of BIS: %u", cmd->num_bis);
8827         print_bis(&cmd->bis);
8828 }
8829
8830 static void print_bis_test(const void *data, int i)
8831 {
8832         const struct bt_hci_bis_test *bis = data;
8833
8834         print_usec_interval("SDU Interval", bis->sdu_interval);
8835         print_field("ISO Interval: %.2f ms (0x%4.4x)",
8836                                 le16_to_cpu(bis->iso_interval) * 1.25,
8837                         le16_to_cpu(bis->iso_interval));
8838         print_field("Number of Subevents: %u", bis->nse);
8839         print_field("Maximum SDU: %u", bis->sdu);
8840         print_field("Maximum PDU: %u", bis->pdu);
8841         print_packing(bis->packing);
8842         print_framing(bis->framing);
8843         print_le_phy("PHY", bis->phy);
8844         print_field("Burst Number: %u", bis->bn);
8845         print_field("Immediate Repetition Count: %u", bis->irc);
8846         print_field("Pre Transmission Offset: 0x%2.2x", bis->pto);
8847         print_field("Encryption: 0x%2.2x", bis->encryption);
8848         print_hex_field("Broadcast Code", bis->bcode, 16);
8849 }
8850
8851 static void le_create_big_cmd_test_cmd(uint16_t index, const void *data,
8852                                                         uint8_t size)
8853 {
8854         const struct bt_hci_cmd_le_create_big_test *cmd = data;
8855
8856         print_field("BIG Handle: 0x%2.2x", cmd->big_handle);
8857         print_field("Advertising Handle: 0x%2.2x", cmd->adv_handle);
8858         print_field("Number of BIS: %u", cmd->num_bis);
8859
8860         size -= sizeof(*cmd);
8861
8862         print_list(cmd->bis, size, cmd->num_bis, sizeof(*cmd->bis),
8863                                                 print_bis_test);
8864 }
8865
8866 static void le_terminate_big_cmd(uint16_t index, const void *data, uint8_t size)
8867 {
8868         const struct bt_hci_cmd_le_term_big *cmd = data;
8869
8870         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8871         print_reason(cmd->reason);
8872 }
8873
8874 static void print_bis_sync(const void *data, int i)
8875 {
8876         const uint8_t *bis_id = data;
8877
8878         print_field("BIS ID: 0x%2.2x", *bis_id);
8879 }
8880
8881 static void le_big_create_sync_cmd(uint16_t index, const void *data,
8882                                                         uint8_t size)
8883 {
8884         const struct bt_hci_cmd_le_big_create_sync *cmd = data;
8885
8886         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8887         print_field("BIG Sync Handle: 0x%4.4x", le16_to_cpu(cmd->sync_handle));
8888         print_field("Encryption: %s (0x%2.2x)",
8889                         cmd->encryption ? "Encrypted" : "Unencrypted",
8890                         cmd->encryption);
8891         print_hex_field("Broadcast Code", cmd->bcode, 16);
8892         print_field("Maximum Number Subevents: 0x%2.2x", cmd->mse);
8893         print_field("Timeout: %d ms (0x%4.4x)", le16_to_cpu(cmd->timeout) * 10,
8894                                         le16_to_cpu(cmd->timeout));
8895         print_field("Number of BIS: %u", cmd->num_bis);
8896
8897         size -= sizeof(*cmd);
8898
8899         print_list(cmd->bis, size, cmd->num_bis, sizeof(*cmd->bis),
8900                                                 print_bis_sync);
8901 }
8902
8903 static void le_big_term_sync_cmd(uint16_t index, const void *data, uint8_t size)
8904 {
8905         const struct bt_hci_cmd_le_big_term_sync *cmd = data;
8906
8907         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8908 }
8909
8910 static void print_iso_path(const char *prefix, uint8_t path)
8911 {
8912         switch (path) {
8913         case 0x00:
8914                 print_field("%s: HCI (0x%2.2x)", prefix, path);
8915                 return;
8916         case 0xff:
8917                 print_field("%s: Disabled (0x%2.2x)", prefix, path);
8918                 return;
8919         default:
8920                 print_field("%s: Logical Channel Number %u", prefix, path);
8921         }
8922 }
8923
8924 static void le_setup_iso_path_cmd(uint16_t index, const void *data,
8925                                                         uint8_t size)
8926 {
8927         const struct bt_hci_cmd_le_setup_iso_path *cmd = data;
8928
8929         print_field("Handle: %d", le16_to_cpu(cmd->handle));
8930         print_path_direction("Data Path Direction", cmd->direction);
8931         print_iso_path("Data Path", cmd->path);
8932         print_codec_id("Coding Format", cmd->codec);
8933         packet_print_company("Company Codec ID", le16_to_cpu(cmd->codec_cid));
8934         print_field("Vendor Codec ID: %d", le16_to_cpu(cmd->codec_vid));
8935         print_usec_interval("Controller Delay", cmd->delay);
8936         print_field("Codec Configuration Length: %d", cmd->codec_cfg_len);
8937         print_hex_field("Codec Configuration", cmd->codec_cfg,
8938                                                 cmd->codec_cfg_len);
8939 }
8940
8941 static void le_setup_iso_path_rsp(uint16_t index, const void *data,
8942                                                         uint8_t size)
8943 {
8944         const struct bt_hci_rsp_le_setup_iso_path *rsp = data;
8945
8946         print_status(rsp->status);
8947
8948         if (size == 1)
8949                 return;
8950
8951         print_field("Handle: %d", le16_to_cpu(rsp->handle));
8952 }
8953
8954 static void le_remove_iso_path_cmd(uint16_t index, const void *data,
8955                                                         uint8_t size)
8956 {
8957         const struct bt_hci_cmd_le_remove_iso_path *cmd = data;
8958
8959         print_field("Connection Handle: %d", le16_to_cpu(cmd->handle));
8960         print_path_direction("Data Path Direction", cmd->direction);
8961 }
8962
8963 static void le_req_peer_sca_cmd(uint16_t index, const void *data, uint8_t size)
8964 {
8965         const struct bt_hci_cmd_le_req_peer_sca *cmd = data;
8966
8967         print_field("Connection Handle: %d", le16_to_cpu(cmd->handle));
8968 }
8969
8970 static void le_set_host_feature_cmd(uint16_t index, const void *data,
8971                                                         uint8_t size)
8972 {
8973         const struct bt_hci_cmd_le_set_host_feature *cmd = data;
8974         uint64_t mask;
8975
8976         print_field("Bit Number: %u", cmd->bit_number);
8977
8978         mask = print_bitfield(2, (((uint64_t) 1) << cmd->bit_number),
8979                                                         features_le);
8980         if (mask)
8981                 print_text(COLOR_UNKNOWN_FEATURE_BIT, "  Unknown features "
8982                                                 "(0x%16.16" PRIx64 ")", mask);
8983
8984         print_field("Bit Value: %u", cmd->bit_value);
8985 }
8986
8987 static void le_read_iso_link_quality_cmd(uint16_t index, const void *data,
8988                                                         uint8_t size)
8989 {
8990         const struct bt_hci_cmd_le_read_iso_link_quality *cmd = data;
8991
8992         print_field("Handle: %d", le16_to_cpu(cmd->handle));
8993 }
8994
8995 static void status_le_read_iso_link_quality_rsp(uint16_t index,
8996                                                         const void *data,
8997                                                         uint8_t size)
8998 {
8999         const struct bt_hci_rsp_le_read_iso_link_quality *rsp = data;
9000
9001         print_status(rsp->status);
9002
9003         if (size == 1)
9004                 return;
9005
9006         print_field("Handle: %d", le16_to_cpu(rsp->handle));
9007         print_field("TX unacked packets %d", rsp->tx_unacked_packets);
9008         print_field("TX flushed packets %d", rsp->tx_flushed_packets);
9009         print_field("TX last subevent packets %d",
9010                                         rsp->tx_last_subevent_packets);
9011         print_field("TX retransmitted packets %d",
9012                                                 rsp->retransmitted_packets);
9013         print_field("TX crc error packets %d", rsp->crc_error_packets);
9014         print_field("RX unreceived packets %d", rsp->rx_unreceived_packets);
9015         print_field("Duplicated packets %d", rsp->duplicated_packets);
9016 }
9017
9018 struct opcode_data {
9019         uint16_t opcode;
9020         int bit;
9021         const char *str;
9022         void (*cmd_func) (uint16_t index, const void *data, uint8_t size);
9023         uint8_t cmd_size;
9024         bool cmd_fixed;
9025         void (*rsp_func) (uint16_t index, const void *data, uint8_t size);
9026         uint8_t rsp_size;
9027         bool rsp_fixed;
9028 };
9029
9030 static const struct opcode_data opcode_table[] = {
9031         { 0x0000,  -1, "NOP" },
9032
9033         /* OGF 1 - Link Control */
9034         { 0x0401,   0, "Inquiry",
9035                                 inquiry_cmd, 5, true },
9036         { 0x0402,   1, "Inquiry Cancel",
9037                                 null_cmd, 0, true,
9038                                 status_rsp, 1, true },
9039         { 0x0403,   2, "Periodic Inquiry Mode",
9040                                 periodic_inquiry_cmd, 9, true,
9041                                 status_rsp, 1, true },
9042         { 0x0404,   3, "Exit Periodic Inquiry Mode",
9043                                 null_cmd, 0, true,
9044                                 status_rsp, 1, true },
9045         { 0x0405,   4, "Create Connection",
9046                                 create_conn_cmd, 13, true },
9047         { 0x0406,   5, "Disconnect",
9048                                 disconnect_cmd, 3, true },
9049         { 0x0407,   6, "Add SCO Connection",
9050                                 add_sco_conn_cmd, 4, true },
9051         { 0x0408,   7, "Create Connection Cancel",
9052                                 create_conn_cancel_cmd, 6, true,
9053                                 status_bdaddr_rsp, 7, true },
9054         { 0x0409,   8, "Accept Connection Request",
9055                                 accept_conn_request_cmd, 7, true },
9056         { 0x040a,   9, "Reject Connection Request",
9057                                 reject_conn_request_cmd, 7, true },
9058         { 0x040b,  10, "Link Key Request Reply",
9059                                 link_key_request_reply_cmd, 22, true,
9060                                 status_bdaddr_rsp, 7, true },
9061         { 0x040c,  11, "Link Key Request Negative Reply",
9062                                 link_key_request_neg_reply_cmd, 6, true,
9063                                 status_bdaddr_rsp, 7, true },
9064         { 0x040d,  12, "PIN Code Request Reply",
9065                                 pin_code_request_reply_cmd, 23, true,
9066                                 status_bdaddr_rsp, 7, true },
9067         { 0x040e,  13, "PIN Code Request Negative Reply",
9068                                 pin_code_request_neg_reply_cmd, 6, true,
9069                                 status_bdaddr_rsp, 7, true },
9070         { 0x040f,  14, "Change Connection Packet Type",
9071                                 change_conn_pkt_type_cmd, 4, true },
9072         { 0x0411,  15, "Authentication Requested",
9073                                 auth_requested_cmd, 2, true },
9074         { 0x0413,  16, "Set Connection Encryption",
9075                                 set_conn_encrypt_cmd, 3, true },
9076         { 0x0415,  17, "Change Connection Link Key",
9077                                 change_conn_link_key_cmd, 2, true },
9078         { 0x0417,  18, "Temporary Link Key",
9079                                 link_key_selection_cmd, 1, true },
9080         { 0x0419,  19, "Remote Name Request",
9081                                 remote_name_request_cmd, 10, true },
9082         { 0x041a,  20, "Remote Name Request Cancel",
9083                                 remote_name_request_cancel_cmd, 6, true,
9084                                 status_bdaddr_rsp, 7, true },
9085         { 0x041b,  21, "Read Remote Supported Features",
9086                                 read_remote_features_cmd, 2, true },
9087         { 0x041c,  22, "Read Remote Extended Features",
9088                                 read_remote_ext_features_cmd, 3, true },
9089         { 0x041d,  23, "Read Remote Version Information",
9090                                 read_remote_version_cmd, 2, true },
9091         { 0x041f,  24, "Read Clock Offset",
9092                                 read_clock_offset_cmd, 2, true },
9093         { 0x0420,  25, "Read LMP Handle",
9094                                 read_lmp_handle_cmd, 2, true,
9095                                 read_lmp_handle_rsp, 8, true },
9096         { 0x0428, 131, "Setup Synchronous Connection",
9097                                 setup_sync_conn_cmd, 17, true },
9098         { 0x0429, 132, "Accept Synchronous Connection Request",
9099                                 accept_sync_conn_request_cmd, 21, true },
9100         { 0x042a, 133, "Reject Synchronous Connection Request",
9101                                 reject_sync_conn_request_cmd, 7, true },
9102         { 0x042b, 151, "IO Capability Request Reply",
9103                                 io_capability_request_reply_cmd, 9, true,
9104                                 status_bdaddr_rsp, 7, true },
9105         { 0x042c, 152, "User Confirmation Request Reply",
9106                                 user_confirm_request_reply_cmd, 6, true,
9107                                 status_bdaddr_rsp, 7, true },
9108         { 0x042d, 153, "User Confirmation Request Neg Reply",
9109                                 user_confirm_request_neg_reply_cmd, 6, true,
9110                                 status_bdaddr_rsp, 7, true },
9111         { 0x042e, 154, "User Passkey Request Reply",
9112                                 user_passkey_request_reply_cmd, 10, true,
9113                                 status_bdaddr_rsp, 7, true },
9114         { 0x042f, 155, "User Passkey Request Negative Reply",
9115                                 user_passkey_request_neg_reply_cmd, 6, true,
9116                                 status_bdaddr_rsp, 7, true },
9117         { 0x0430, 156, "Remote OOB Data Request Reply",
9118                                 remote_oob_data_request_reply_cmd, 38, true,
9119                                 status_bdaddr_rsp, 7, true },
9120         { 0x0433, 159, "Remote OOB Data Request Neg Reply",
9121                                 remote_oob_data_request_neg_reply_cmd, 6, true,
9122                                 status_bdaddr_rsp, 7, true },
9123         { 0x0434, 163, "IO Capability Request Negative Reply",
9124                                 io_capability_request_neg_reply_cmd, 7, true,
9125                                 status_bdaddr_rsp, 7, true },
9126         { 0x0435, 168, "Create Physical Link",
9127                                 create_phy_link_cmd, 3, false },
9128         { 0x0436, 169, "Accept Physical Link",
9129                                 accept_phy_link_cmd, 3, false },
9130         { 0x0437, 170, "Disconnect Physical Link",
9131                                 disconn_phy_link_cmd, 2, true },
9132         { 0x0438, 171, "Create Logical Link",
9133                                 create_logic_link_cmd, 33, true },
9134         { 0x0439, 172, "Accept Logical Link",
9135                                 accept_logic_link_cmd, 33, true },
9136         { 0x043a, 173, "Disconnect Logical Link",
9137                                 disconn_logic_link_cmd, 2, true },
9138         { 0x043b, 174, "Logical Link Cancel",
9139                                 logic_link_cancel_cmd, 2, true,
9140                                 logic_link_cancel_rsp, 3, true },
9141         { 0x043c, 175, "Flow Specifcation Modify",
9142                                 flow_spec_modify_cmd, 34, true },
9143         { 0x043d, 235, "Enhanced Setup Synchronous Connection",
9144                                 enhanced_setup_sync_conn_cmd, 59, true },
9145         { 0x043e, 236, "Enhanced Accept Synchronous Connection Request",
9146                                 enhanced_accept_sync_conn_request_cmd, 63, true },
9147         { 0x043f, 246, "Truncated Page",
9148                                 truncated_page_cmd, 9, true },
9149         { 0x0440, 247, "Truncated Page Cancel",
9150                                 truncated_page_cancel_cmd, 6, true,
9151                                 status_bdaddr_rsp, 7, true },
9152         { 0x0441, 248, "Set Connectionless Peripheral Broadcast",
9153                                 set_peripheral_broadcast_cmd, 11, true,
9154                                 set_peripheral_broadcast_rsp, 4, true },
9155         { 0x0442, 249, "Set Connectionless Peripheral Broadcast Receive",
9156                                 set_peripheral_broadcast_receive_cmd, 34, true,
9157                                 set_peripheral_broadcast_receive_rsp, 8, true },
9158         { 0x0443, 250, "Start Synchronization Train",
9159                                 null_cmd, 0, true },
9160         { 0x0444, 251, "Receive Synchronization Train",
9161                                 receive_sync_train_cmd, 12, true },
9162         { 0x0445, 257, "Remote OOB Extended Data Request Reply",
9163                                 remote_oob_ext_data_request_reply_cmd, 70, true,
9164                                 status_bdaddr_rsp, 7, true },
9165
9166         /* OGF 2 - Link Policy */
9167         { 0x0801,  33, "Hold Mode",
9168                                 hold_mode_cmd, 6, true },
9169         { 0x0803,  34, "Sniff Mode",
9170                                 sniff_mode_cmd, 10, true },
9171         { 0x0804,  35, "Exit Sniff Mode",
9172                                 exit_sniff_mode_cmd, 2, true },
9173         { 0x0805,  36, "Park State",
9174                                 park_state_cmd, 6, true },
9175         { 0x0806,  37, "Exit Park State",
9176                                 exit_park_state_cmd, 2, true },
9177         { 0x0807,  38, "QoS Setup",
9178                                 qos_setup_cmd, 20, true },
9179         { 0x0809,  39, "Role Discovery",
9180                                 role_discovery_cmd, 2, true,
9181                                 role_discovery_rsp, 4, true },
9182         { 0x080b,  40, "Switch Role",
9183                                 switch_role_cmd, 7, true },
9184         { 0x080c,  41, "Read Link Policy Settings",
9185                                 read_link_policy_cmd, 2, true,
9186                                 read_link_policy_rsp, 5, true },
9187         { 0x080d,  42, "Write Link Policy Settings",
9188                                 write_link_policy_cmd, 4, true,
9189                                 write_link_policy_rsp, 3, true },
9190         { 0x080e,  43, "Read Default Link Policy Settings",
9191                                 null_cmd, 0, true,
9192                                 read_default_link_policy_rsp, 3, true },
9193         { 0x080f,  44, "Write Default Link Policy Settings",
9194                                 write_default_link_policy_cmd, 2, true,
9195                                 status_rsp, 1, true },
9196         { 0x0810,  45, "Flow Specification",
9197                                 flow_spec_cmd, 21, true },
9198         { 0x0811, 140, "Sniff Subrating",
9199                                 sniff_subrating_cmd, 8, true,
9200                                 sniff_subrating_rsp, 3, true },
9201
9202         /* OGF 3 - Host Control */
9203         { 0x0c01,  46, "Set Event Mask",
9204                                 set_event_mask_cmd, 8, true,
9205                                 status_rsp, 1, true },
9206         { 0x0c03,  47, "Reset",
9207                                 null_cmd, 0, true,
9208                                 status_rsp, 1, true },
9209         { 0x0c05,  48, "Set Event Filter",
9210                                 set_event_filter_cmd, 1, false,
9211                                 status_rsp, 1, true },
9212         { 0x0c08,  49, "Flush",
9213                                 flush_cmd, 2, true,
9214                                 flush_rsp, 3, true },
9215         { 0x0c09,  50, "Read PIN Type",
9216                                 null_cmd, 0, true,
9217                                 read_pin_type_rsp, 2, true },
9218         { 0x0c0a,  51, "Write PIN Type",
9219                                 write_pin_type_cmd, 1, true,
9220                                 status_rsp, 1, true },
9221         { 0x0c0b,  52, "Create New Unit Key",
9222                                 null_cmd, 0, true,
9223                                 status_rsp, 1, true },
9224         { 0x0c0d,  53, "Read Stored Link Key",
9225                                 read_stored_link_key_cmd, 7, true,
9226                                 read_stored_link_key_rsp, 5, true },
9227         { 0x0c11,  54, "Write Stored Link Key",
9228                                 write_stored_link_key_cmd, 1, false,
9229                                 write_stored_link_key_rsp, 2, true },
9230         { 0x0c12,  55, "Delete Stored Link Key",
9231                                 delete_stored_link_key_cmd, 7, true,
9232                                 delete_stored_link_key_rsp, 3, true },
9233         { 0x0c13,  56, "Write Local Name",
9234                                 write_local_name_cmd, 248, true,
9235                                 status_rsp, 1, true },
9236         { 0x0c14,  57, "Read Local Name",
9237                                 null_cmd, 0, true,
9238                                 read_local_name_rsp, 249, true },
9239         { 0x0c15,  58, "Read Connection Accept Timeout",
9240                                 null_cmd, 0, true,
9241                                 read_conn_accept_timeout_rsp, 3, true },
9242         { 0x0c16,  59, "Write Connection Accept Timeout",
9243                                 write_conn_accept_timeout_cmd, 2, true,
9244                                 status_rsp, 1, true },
9245         { 0x0c17,  60, "Read Page Timeout",
9246                                 null_cmd, 0, true,
9247                                 read_page_timeout_rsp, 3, true },
9248         { 0x0c18,  61, "Write Page Timeout",
9249                                 write_page_timeout_cmd, 2, true,
9250                                 status_rsp, 1, true },
9251         { 0x0c19,  62, "Read Scan Enable",
9252                                 null_cmd, 0, true,
9253                                 read_scan_enable_rsp, 2, true },
9254         { 0x0c1a,  63, "Write Scan Enable",
9255                                 write_scan_enable_cmd, 1, true,
9256                                 status_rsp, 1, true },
9257         { 0x0c1b,  64, "Read Page Scan Activity",
9258                                 null_cmd, 0, true,
9259                                 read_page_scan_activity_rsp, 5, true },
9260         { 0x0c1c,  65, "Write Page Scan Activity",
9261                                 write_page_scan_activity_cmd, 4, true,
9262                                 status_rsp, 1, true },
9263         { 0x0c1d,  66, "Read Inquiry Scan Activity",
9264                                 null_cmd, 0, true,
9265                                 read_inquiry_scan_activity_rsp, 5, true },
9266         { 0x0c1e,  67, "Write Inquiry Scan Activity",
9267                                 write_inquiry_scan_activity_cmd, 4, true,
9268                                 status_rsp, 1, true },
9269         { 0x0c1f,  68, "Read Authentication Enable",
9270                                 null_cmd, 0, true,
9271                                 read_auth_enable_rsp, 2, true },
9272         { 0x0c20,  69, "Write Authentication Enable",
9273                                 write_auth_enable_cmd, 1, true,
9274                                 status_rsp, 1, true },
9275         { 0x0c21,  70, "Read Encryption Mode",
9276                                 null_cmd, 0, true,
9277                                 read_encrypt_mode_rsp, 2, true },
9278         { 0x0c22,  71, "Write Encryption Mode",
9279                                 write_encrypt_mode_cmd, 1, true,
9280                                 status_rsp, 1, true },
9281         { 0x0c23,  72, "Read Class of Device",
9282                                 null_cmd, 0, true,
9283                                 read_class_of_dev_rsp, 4, true },
9284         { 0x0c24,  73, "Write Class of Device",
9285                                 write_class_of_dev_cmd, 3, true,
9286                                 status_rsp, 1, true },
9287         { 0x0c25,  74, "Read Voice Setting",
9288                                 null_cmd, 0, true,
9289                                 read_voice_setting_rsp, 3, true },
9290         { 0x0c26,  75, "Write Voice Setting",
9291                                 write_voice_setting_cmd, 2, true,
9292                                 status_rsp, 1, true },
9293         { 0x0c27,  76, "Read Automatic Flush Timeout",
9294                                 read_auto_flush_timeout_cmd, 2, true,
9295                                 read_auto_flush_timeout_rsp, 5, true },
9296         { 0x0c28,  77, "Write Automatic Flush Timeout",
9297                                 write_auto_flush_timeout_cmd, 4, true,
9298                                 write_auto_flush_timeout_rsp, 3, true },
9299         { 0x0c29,  78, "Read Num Broadcast Retransmissions",
9300                                 null_cmd, 0, true,
9301                                 read_num_broadcast_retrans_rsp, 2, true },
9302         { 0x0c2a,  79, "Write Num Broadcast Retransmissions",
9303                                 write_num_broadcast_retrans_cmd, 1, true,
9304                                 status_rsp, 1, true },
9305         { 0x0c2b,  80, "Read Hold Mode Activity",
9306                                 null_cmd, 0, true,
9307                                 read_hold_mode_activity_rsp, 2, true },
9308         { 0x0c2c,  81, "Write Hold Mode Activity",
9309                                 write_hold_mode_activity_cmd, 1, true,
9310                                 status_rsp, 1, true },
9311         { 0x0c2d,  82, "Read Transmit Power Level",
9312                                 read_tx_power_cmd, 3, true,
9313                                 read_tx_power_rsp, 4, true },
9314         { 0x0c2e,  83, "Read Sync Flow Control Enable",
9315                                 null_cmd, 0, true,
9316                                 read_sync_flow_control_rsp, 2, true },
9317         { 0x0c2f,  84, "Write Sync Flow Control Enable",
9318                                 write_sync_flow_control_cmd, 1, true,
9319                                 status_rsp, 1, true },
9320         { 0x0c31,  85, "Set Controller To Host Flow Control",
9321                                 set_host_flow_control_cmd, 1, true,
9322                                 status_rsp, 1, true },
9323         { 0x0c33,  86, "Host Buffer Size",
9324                                 host_buffer_size_cmd, 7, true,
9325                                 status_rsp, 1, true },
9326         { 0x0c35,  87, "Host Number of Completed Packets",
9327                                 host_num_completed_packets_cmd, 5, false },
9328         { 0x0c36,  88, "Read Link Supervision Timeout",
9329                                 read_link_supv_timeout_cmd, 2, true,
9330                                 read_link_supv_timeout_rsp, 5, true },
9331         { 0x0c37,  89, "Write Link Supervision Timeout",
9332                                 write_link_supv_timeout_cmd, 4, true,
9333                                 write_link_supv_timeout_rsp, 3, true },
9334         { 0x0c38,  90, "Read Number of Supported IAC",
9335                                 null_cmd, 0, true,
9336                                 read_num_supported_iac_rsp, 2, true },
9337         { 0x0c39,  91, "Read Current IAC LAP",
9338                                 null_cmd, 0, true,
9339                                 read_current_iac_lap_rsp, 2, false },
9340         { 0x0c3a,  92, "Write Current IAC LAP",
9341                                 write_current_iac_lap_cmd, 1, false,
9342                                 status_rsp, 1, true },
9343         { 0x0c3b,  93, "Read Page Scan Period Mode",
9344                                 null_cmd, 0, true,
9345                                 read_page_scan_period_mode_rsp, 2, true },
9346         { 0x0c3c,  94, "Write Page Scan Period Mode",
9347                                 write_page_scan_period_mode_cmd, 1, true,
9348                                 status_rsp, 1, true },
9349         { 0x0c3d,  95, "Read Page Scan Mode",
9350                                 null_cmd, 0, true,
9351                                 read_page_scan_mode_rsp, 2, true },
9352         { 0x0c3e,  96, "Write Page Scan Mode",
9353                                 write_page_scan_mode_cmd, 1, true,
9354                                 status_rsp, 1, true },
9355         { 0x0c3f,  97, "Set AFH Host Channel Classification",
9356                                 set_afh_host_classification_cmd, 10, true,
9357                                 status_rsp, 1, true },
9358         { 0x0c42, 100, "Read Inquiry Scan Type",
9359                                 null_cmd, 0, true,
9360                                 read_inquiry_scan_type_rsp, 2, true },
9361         { 0x0c43, 101, "Write Inquiry Scan Type",
9362                                 write_inquiry_scan_type_cmd, 1, true,
9363                                 status_rsp, 1, true },
9364         { 0x0c44, 102, "Read Inquiry Mode",
9365                                 null_cmd, 0, true,
9366                                 read_inquiry_mode_rsp, 2, true },
9367         { 0x0c45, 103, "Write Inquiry Mode",
9368                                 write_inquiry_mode_cmd, 1, true,
9369                                 status_rsp, 1, true },
9370         { 0x0c46, 104, "Read Page Scan Type",
9371                                 null_cmd, 0, true,
9372                                 read_page_scan_type_rsp, 2, true },
9373         { 0x0c47, 105, "Write Page Scan Type",
9374                                 write_page_scan_type_cmd, 1, true,
9375                                 status_rsp, 1, true },
9376         { 0x0c48, 106, "Read AFH Channel Assessment Mode",
9377                                 null_cmd, 0, true,
9378                                 read_afh_assessment_mode_rsp, 2, true },
9379         { 0x0c49, 107, "Write AFH Channel Assessment Mode",
9380                                 write_afh_assessment_mode_cmd, 1, true,
9381                                 status_rsp, 1, true },
9382         { 0x0c51, 136, "Read Extended Inquiry Response",
9383                                 null_cmd, 0, true,
9384                                 read_ext_inquiry_response_rsp, 242, true },
9385         { 0x0c52, 137, "Write Extended Inquiry Response",
9386                                 write_ext_inquiry_response_cmd, 241, true,
9387                                 status_rsp, 1, true },
9388         { 0x0c53, 138, "Refresh Encryption Key",
9389                                 refresh_encrypt_key_cmd, 2, true },
9390         { 0x0c55, 141, "Read Simple Pairing Mode",
9391                                 null_cmd, 0, true,
9392                                 read_simple_pairing_mode_rsp, 2, true },
9393         { 0x0c56, 142, "Write Simple Pairing Mode",
9394                                 write_simple_pairing_mode_cmd, 1, true,
9395                                 status_rsp, 1, true },
9396         { 0x0c57, 143, "Read Local OOB Data",
9397                                 null_cmd, 0, true,
9398                                 read_local_oob_data_rsp, 33, true },
9399         { 0x0c58, 144, "Read Inquiry Response TX Power Level",
9400                                 null_cmd, 0, true,
9401                                 read_inquiry_resp_tx_power_rsp, 2, true },
9402         { 0x0c59, 145, "Write Inquiry Transmit Power Level",
9403                                 write_inquiry_tx_power_cmd, 1, true,
9404                                 status_rsp, 1, true },
9405         { 0x0c5a, 146, "Read Default Erroneous Data Reporting",
9406                                 null_cmd, 0, true,
9407                                 read_erroneous_reporting_rsp, 2, true },
9408         { 0x0c5b, 147, "Write Default Erroneous Data Reporting",
9409                                 write_erroneous_reporting_cmd, 1, true,
9410                                 status_rsp, 1, true },
9411         { 0x0c5f, 158, "Enhanced Flush",
9412                                 enhanced_flush_cmd, 3, true },
9413         { 0x0c60, 162, "Send Keypress Notification",
9414                                 send_keypress_notify_cmd, 7, true,
9415                                 send_keypress_notify_rsp, 7, true },
9416         { 0x0c61, 176, "Read Logical Link Accept Timeout" },
9417         { 0x0c62, 177, "Write Logical Link Accept Timeout" },
9418         { 0x0c63, 178, "Set Event Mask Page 2",
9419                                 set_event_mask_page2_cmd, 8, true,
9420                                 status_rsp, 1, true },
9421         { 0x0c64, 179, "Read Location Data",
9422                                 null_cmd, 0, true,
9423                                 read_location_data_rsp, 6, true },
9424         { 0x0c65, 180, "Write Location Data",
9425                                 write_location_data_cmd, 5, true,
9426                                 status_rsp, 1, true },
9427         { 0x0c66, 184, "Read Flow Control Mode",
9428                                 null_cmd, 0, true,
9429                                 read_flow_control_mode_rsp, 2, true },
9430         { 0x0c67, 185, "Write Flow Control Mode",
9431                                 write_flow_control_mode_cmd, 1, true,
9432                                 status_rsp, 1, true },
9433         { 0x0c68, 192, "Read Enhanced Transmit Power Level",
9434                                 read_enhanced_tx_power_cmd, 3, true,
9435                                 read_enhanced_tx_power_rsp, 6, true },
9436         { 0x0c69, 194, "Read Best Effort Flush Timeout" },
9437         { 0x0c6a, 195, "Write Best Effort Flush Timeout" },
9438         { 0x0c6b, 196, "Short Range Mode",
9439                                 short_range_mode_cmd, 2, true },
9440         { 0x0c6c, 197, "Read LE Host Supported",
9441                                 null_cmd, 0, true,
9442                                 read_le_host_supported_rsp, 3, true },
9443         { 0x0c6d, 198, "Write LE Host Supported",
9444                                 write_le_host_supported_cmd, 2, true,
9445                                 status_rsp, 1, true },
9446         { 0x0c6e, 238, "Set MWS Channel Parameters" },
9447         { 0x0c6f, 239, "Set External Frame Configuration" },
9448         { 0x0c70, 240, "Set MWS Signaling" },
9449         { 0x0c71, 241, "Set MWS Transport Layer" },
9450         { 0x0c72, 242, "Set MWS Scan Frequency Table" },
9451         { 0x0c73, 244, "Set MWS Pattern Configuration" },
9452         { 0x0c74, 252, "Set Reserved LT_ADDR",
9453                                 set_reserved_lt_addr_cmd, 1, true,
9454                                 set_reserved_lt_addr_rsp, 2, true },
9455         { 0x0c75, 253, "Delete Reserved LT_ADDR",
9456                                 delete_reserved_lt_addr_cmd, 1, true,
9457                                 delete_reserved_lt_addr_rsp, 2, true },
9458         { 0x0c76, 254, "Set Connectionless Peripheral Broadcast Data",
9459                                 set_peripheral_broadcast_data_cmd, 3, false,
9460                                 set_peripheral_broadcast_data_rsp, 2, true },
9461         { 0x0c77, 255, "Read Synchronization Train Parameters",
9462                                 null_cmd, 0, true,
9463                                 read_sync_train_params_rsp, 8, true },
9464         { 0x0c78, 256, "Write Synchronization Train Parameters",
9465                                 write_sync_train_params_cmd, 9, true,
9466                                 write_sync_train_params_rsp, 3, true },
9467         { 0x0c79, 258, "Read Secure Connections Host Support",
9468                                 null_cmd, 0, true,
9469                                 read_secure_conn_support_rsp, 2, true },
9470         { 0x0c7a, 259, "Write Secure Connections Host Support",
9471                                 write_secure_conn_support_cmd, 1, true,
9472                                 status_rsp, 1, true },
9473         { 0x0c7b, 260, "Read Authenticated Payload Timeout",
9474                                 read_auth_payload_timeout_cmd, 2, true,
9475                                 read_auth_payload_timeout_rsp, 5, true },
9476         { 0x0c7c, 261, "Write Authenticated Payload Timeout",
9477                                 write_auth_payload_timeout_cmd, 4, true,
9478                                 write_auth_payload_timeout_rsp, 3, true },
9479         { 0x0c7d, 262, "Read Local OOB Extended Data",
9480                                 null_cmd, 0, true,
9481                                 read_local_oob_ext_data_rsp, 65, true },
9482         { 0x0c7e, 264, "Read Extended Page Timeout",
9483                                 null_cmd, 0, true,
9484                                 read_ext_page_timeout_rsp, 3, true },
9485         { 0x0c7f, 265, "Write Extended Page Timeout",
9486                                 write_ext_page_timeout_cmd, 2, true,
9487                                 status_rsp, 1, true },
9488         { 0x0c80, 266, "Read Extended Inquiry Length",
9489                                 null_cmd, 0, true,
9490                                 read_ext_inquiry_length_rsp, 3, true },
9491         { 0x0c81, 267, "Write Extended Inquiry Length",
9492                                 write_ext_inquiry_length_cmd, 2, true,
9493                                 status_rsp, 1, true },
9494
9495         /* OGF 4 - Information Parameter */
9496         { 0x1001, 115, "Read Local Version Information",
9497                                 null_cmd, 0, true,
9498                                 read_local_version_rsp, 9, true },
9499         { 0x1002, 116, "Read Local Supported Commands",
9500                                 null_cmd, 0, true,
9501                                 read_local_commands_rsp, 65, true },
9502         { 0x1003, 117, "Read Local Supported Features",
9503                                 null_cmd, 0, true,
9504                                 read_local_features_rsp, 9, true },
9505         { 0x1004, 118, "Read Local Extended Features",
9506                                 read_local_ext_features_cmd, 1, true,
9507                                 read_local_ext_features_rsp, 11, true },
9508         { 0x1005, 119, "Read Buffer Size",
9509                                 null_cmd, 0, true,
9510                                 read_buffer_size_rsp, 8, true },
9511         { 0x1007, 120, "Read Country Code",
9512                                 null_cmd, 0, true,
9513                                 read_country_code_rsp, 2, true },
9514         { 0x1009, 121, "Read BD ADDR",
9515                                 null_cmd, 0, true,
9516                                 read_bd_addr_rsp, 7, true },
9517         { 0x100a, 186, "Read Data Block Size",
9518                                 null_cmd, 0, true,
9519                                 read_data_block_size_rsp, 7, true },
9520         { 0x100b, 237, "Read Local Supported Codecs",
9521                                 null_cmd, 0, true,
9522                                 read_local_codecs_rsp, 3, false },
9523         { 0x100c, 331, "Read Local Simple Pairing Options",
9524                                 null_cmd, 0, true,
9525                                 read_local_pairing_options_rsp, 3, true },
9526         { BT_HCI_CMD_READ_LOCAL_CODECS_V2, BT_HCI_BIT_READ_LOCAL_CODECS_V2,
9527                 "Read Local Supported Codecs V2",
9528                 null_cmd, 0, true,
9529                 read_local_codecs_rsp_v2,
9530                 sizeof(struct bt_hci_rsp_read_local_codecs_v2), false
9531         },
9532         { BT_HCI_CMD_READ_LOCAL_CODEC_CAPS, BT_HCI_BIT_READ_LOCAL_CODEC_CAPS,
9533                 "Read Local Supported Codec Capabilities",
9534                 read_local_codec_caps_cmd,
9535                 sizeof(struct bt_hci_cmd_read_local_codec_caps), true,
9536                 read_local_codec_caps_rsp,
9537                 sizeof(struct bt_hci_rsp_read_local_codec_caps), false
9538         },
9539         { BT_HCI_CMD_READ_LOCAL_CTRL_DELAY, BT_HCI_BIT_READ_LOCAL_CTRL_DELAY,
9540                 "Read Local Supported Controller Delay",
9541                 read_local_ctrl_delay_cmd,
9542                 sizeof(struct bt_hci_cmd_read_local_ctrl_delay), false,
9543                 read_local_ctrl_delay_rsp,
9544                 sizeof(struct bt_hci_rsp_read_local_ctrl_delay), true
9545         },
9546         { BT_HCI_CMD_CONFIG_DATA_PATH, BT_HCI_BIT_CONFIG_DATA_PATH,
9547                 "Configure Data Path",
9548                 config_data_path_cmd,
9549                 sizeof(struct bt_hci_cmd_config_data_path), false,
9550                 status_rsp, 1, true
9551         },
9552
9553         /* OGF 5 - Status Parameter */
9554         { 0x1401, 122, "Read Failed Contact Counter",
9555                                 read_failed_contact_counter_cmd, 2, true,
9556                                 read_failed_contact_counter_rsp, 5, true },
9557         { 0x1402, 123, "Reset Failed Contact Counter",
9558                                 reset_failed_contact_counter_cmd, 2, true,
9559                                 reset_failed_contact_counter_rsp, 3, true },
9560         { 0x1403, 124, "Read Link Quality",
9561                                 read_link_quality_cmd, 2, true,
9562                                 read_link_quality_rsp, 4, true },
9563         { 0x1405, 125, "Read RSSI",
9564                                 read_rssi_cmd, 2, true,
9565                                 read_rssi_rsp, 4, true },
9566         { 0x1406, 126, "Read AFH Channel Map",
9567                                 read_afh_channel_map_cmd, 2, true,
9568                                 read_afh_channel_map_rsp, 14, true },
9569         { 0x1407, 127, "Read Clock",
9570                                 read_clock_cmd, 3, true,
9571                                 read_clock_rsp, 9, true },
9572         { 0x1408, 164, "Read Encryption Key Size",
9573                                 read_encrypt_key_size_cmd, 2, true,
9574                                 read_encrypt_key_size_rsp, 4, true },
9575         { 0x1409, 181, "Read Local AMP Info",
9576                                 null_cmd, 0, true,
9577                                 read_local_amp_info_rsp, 31, true },
9578         { 0x140a, 182, "Read Local AMP ASSOC",
9579                                 read_local_amp_assoc_cmd, 5, true,
9580                                 read_local_amp_assoc_rsp, 5, false },
9581         { 0x140b, 183, "Write Remote AMP ASSOC",
9582                                 write_remote_amp_assoc_cmd, 6, false,
9583                                 write_remote_amp_assoc_rsp, 2, true },
9584         { 0x140c, 243, "Get MWS Transport Layer Configuration",
9585                                 null_cmd, 0, true,
9586                                 get_mws_transport_config_rsp, 2, false },
9587         { 0x140d, 245, "Set Triggered Clock Capture",
9588                                 set_triggered_clock_capture_cmd, 6, true,
9589                                 status_rsp, 1, true },
9590
9591         /* OGF 6 - Testing */
9592         { 0x1801, 128, "Read Loopback Mode",
9593                                 null_cmd, 0, true,
9594                                 read_loopback_mode_rsp, 2, true },
9595         { 0x1802, 129, "Write Loopback Mode",
9596                                 write_loopback_mode_cmd, 1, true,
9597                                 status_rsp, 1, true },
9598         { 0x1803, 130, "Enable Device Under Test Mode",
9599                                 null_cmd, 0, true,
9600                                 status_rsp, 1, true },
9601         { 0x1804, 157, "Write Simple Pairing Debug Mode",
9602                                 write_ssp_debug_mode_cmd, 1, true,
9603                                 status_rsp, 1, true },
9604         { 0x1807, 189, "Enable AMP Receiver Reports" },
9605         { 0x1808, 190, "AMP Test End" },
9606         { 0x1809, 191, "AMP Test" },
9607         { 0x180a, 263, "Write Secure Connections Test Mode" },
9608
9609         /* OGF 8 - LE Control */
9610         { 0x2001, 200, "LE Set Event Mask",
9611                                 le_set_event_mask_cmd, 8, true,
9612                                 status_rsp, 1, true },
9613         { 0x2002, 201, "LE Read Buffer Size",
9614                                 null_cmd, 0, true,
9615                                 le_read_buffer_size_rsp, 4, true },
9616         { 0x2003, 202, "LE Read Local Supported Features",
9617                                 null_cmd, 0, true,
9618                                 le_read_local_features_rsp, 9, true },
9619         { 0x2005, 204, "LE Set Random Address",
9620                                 le_set_random_address_cmd, 6, true,
9621                                 status_rsp, 1, true },
9622         { 0x2006, 205, "LE Set Advertising Parameters",
9623                                 le_set_adv_parameters_cmd, 15, true,
9624                                 status_rsp, 1, true },
9625         { 0x2007, 206, "LE Read Advertising Channel TX Power",
9626                                 null_cmd, 0, true,
9627                                 le_read_adv_tx_power_rsp, 2, true },
9628         { 0x2008, 207, "LE Set Advertising Data",
9629                                 le_set_adv_data_cmd, 32, true,
9630                                 status_rsp, 1, true },
9631         { 0x2009, 208, "LE Set Scan Response Data",
9632                                 le_set_scan_rsp_data_cmd, 32, true,
9633                                 status_rsp, 1, true },
9634         { 0x200a, 209, "LE Set Advertise Enable",
9635                                 le_set_adv_enable_cmd, 1, true,
9636                                 status_rsp, 1, true },
9637         { 0x200b, 210, "LE Set Scan Parameters",
9638                                 le_set_scan_parameters_cmd, 7, true,
9639                                 status_rsp, 1, true },
9640         { 0x200c, 211, "LE Set Scan Enable",
9641                                 le_set_scan_enable_cmd, 2, true,
9642                                 status_rsp, 1, true },
9643         { 0x200d, 212, "LE Create Connection",
9644                                 le_create_conn_cmd, 25, true },
9645         { 0x200e, 213, "LE Create Connection Cancel",
9646                                 null_cmd, 0, true,
9647                                 status_rsp, 1, true },
9648         { 0x200f, 214, "LE Read Accept List Size",
9649                                 null_cmd, 0, true,
9650                                 le_read_accept_list_size_rsp, 2, true },
9651         { 0x2010, 215, "LE Clear Accept List",
9652                                 null_cmd, 0, true,
9653                                 status_rsp, 1, true },
9654         { 0x2011, 216, "LE Add Device To Accept List",
9655                                 le_add_to_accept_list_cmd, 7, true,
9656                                 status_rsp, 1, true },
9657         { 0x2012, 217, "LE Remove Device From Accept List",
9658                                 le_remove_from_accept_list_cmd, 7, true,
9659                                 status_rsp, 1, true },
9660         { 0x2013, 218, "LE Connection Update",
9661                                 le_conn_update_cmd, 14, true },
9662         { 0x2014, 219, "LE Set Host Channel Classification",
9663                                 le_set_host_classification_cmd, 5, true,
9664                                 status_rsp, 1, true },
9665         { 0x2015, 220, "LE Read Channel Map",
9666                                 le_read_channel_map_cmd, 2, true,
9667                                 le_read_channel_map_rsp, 8, true },
9668         { 0x2016, 221, "LE Read Remote Used Features",
9669                                 le_read_remote_features_cmd, 2, true },
9670         { 0x2017, 222, "LE Encrypt",
9671                                 le_encrypt_cmd, 32, true,
9672                                 le_encrypt_rsp, 17, true },
9673         { 0x2018, 223, "LE Rand",
9674                                 null_cmd, 0, true,
9675                                 le_rand_rsp, 9, true },
9676         { 0x2019, 224, "LE Start Encryption",
9677                                 le_start_encrypt_cmd, 28, true },
9678         { 0x201a, 225, "LE Long Term Key Request Reply",
9679                                 le_ltk_req_reply_cmd, 18, true,
9680                                 le_ltk_req_reply_rsp, 3, true },
9681         { 0x201b, 226, "LE Long Term Key Request Neg Reply",
9682                                 le_ltk_req_neg_reply_cmd, 2, true,
9683                                 le_ltk_req_neg_reply_rsp, 3, true },
9684         { 0x201c, 227, "LE Read Supported States",
9685                                 null_cmd, 0, true,
9686                                 le_read_supported_states_rsp, 9, true },
9687         { 0x201d, 228, "LE Receiver Test",
9688                                 le_receiver_test_cmd, 1, true,
9689                                 status_rsp, 1, true },
9690         { 0x201e, 229, "LE Transmitter Test",
9691                                 le_transmitter_test_cmd, 3, true,
9692                                 status_rsp, 1, true },
9693         { 0x201f, 230, "LE Test End",
9694                                 null_cmd, 0, true,
9695                                 le_test_end_rsp, 3, true },
9696         { 0x2020, 268, "LE Remote Connection Parameter Request Reply",
9697                                 le_conn_param_req_reply_cmd, 14, true,
9698                                 le_conn_param_req_reply_rsp, 3, true },
9699         { 0x2021, 269, "LE Remote Connection Parameter Request Negative Reply",
9700                                 le_conn_param_req_neg_reply_cmd, 3, true,
9701                                 le_conn_param_req_neg_reply_rsp, 3, true },
9702         { 0x2022, 270, "LE Set Data Length",
9703                                 le_set_data_length_cmd, 6, true,
9704                                 le_set_data_length_rsp, 3, true },
9705         { 0x2023, 271, "LE Read Suggested Default Data Length",
9706                                 null_cmd, 0, true,
9707                                 le_read_default_data_length_rsp, 5, true },
9708         { 0x2024, 272, "LE Write Suggested Default Data Length",
9709                                 le_write_default_data_length_cmd, 4, true,
9710                                 status_rsp, 1, true },
9711         { 0x2025, 273, "LE Read Local P-256 Public Key",
9712                                 null_cmd, 0, true },
9713         { 0x2026, 274, "LE Generate DHKey",
9714                                 le_generate_dhkey_cmd, 64, true },
9715         { 0x2027, 275, "LE Add Device To Resolving List",
9716                                 le_add_to_resolv_list_cmd, 39, true,
9717                                 status_rsp, 1, true },
9718         { 0x2028, 276, "LE Remove Device From Resolving List",
9719                                 le_remove_from_resolv_list_cmd, 7, true,
9720                                 status_rsp, 1, true },
9721         { 0x2029, 277, "LE Clear Resolving List",
9722                                 null_cmd, 0, true,
9723                                 status_rsp, 1, true },
9724         { 0x202a, 278, "LE Read Resolving List Size",
9725                                 null_cmd, 0, true,
9726                                 le_read_resolv_list_size_rsp, 2, true },
9727         { 0x202b, 279, "LE Read Peer Resolvable Address",
9728                                 le_read_peer_resolv_addr_cmd, 7, true,
9729                                 le_read_peer_resolv_addr_rsp, 7, true },
9730         { 0x202c, 280, "LE Read Local Resolvable Address",
9731                                 le_read_local_resolv_addr_cmd, 7, true,
9732                                 le_read_local_resolv_addr_rsp, 7, true },
9733         { 0x202d, 281, "LE Set Address Resolution Enable",
9734                                 le_set_resolv_enable_cmd, 1, true,
9735                                 status_rsp, 1, true },
9736         { 0x202e, 282, "LE Set Resolvable Private Address Timeout",
9737                                 le_set_resolv_timeout_cmd, 2, true,
9738                                 status_rsp, 1, true },
9739         { 0x202f, 283, "LE Read Maximum Data Length",
9740                                 null_cmd, 0, true,
9741                                 le_read_max_data_length_rsp, 9, true },
9742         { 0x2030, 284, "LE Read PHY",
9743                                 le_read_phy_cmd, 2, true,
9744                                 le_read_phy_rsp, 5, true},
9745         { 0x2031, 285, "LE Set Default PHY",
9746                                 le_set_default_phy_cmd, 3, true,
9747                                 status_rsp, 1, true },
9748         { 0x2032, 286, "LE Set PHY",
9749                                 le_set_phy_cmd, 7, true},
9750         { 0x2033, 287, "LE Enhanced Receiver Test",
9751                                 le_enhanced_receiver_test_cmd, 3, true,
9752                                 status_rsp, 1, true },
9753         { 0x2034, 288, "LE Enhanced Transmitter Test",
9754                                 le_enhanced_transmitter_test_cmd, 4, true,
9755                                 status_rsp, 1, true },
9756         { 0x2035, 289, "LE Set Advertising Set Random Address",
9757                                 le_set_adv_set_rand_addr, 7, true,
9758                                 status_rsp, 1, true },
9759         { 0x2036, 290, "LE Set Extended Advertising Parameters",
9760                                 le_set_ext_adv_params_cmd, 25, true,
9761                                 le_set_ext_adv_params_rsp, 2, true },
9762         { 0x2037, 291, "LE Set Extended Advertising Data",
9763                                 le_set_ext_adv_data_cmd, 4, false,
9764                                 status_rsp, 1, true },
9765         { 0x2038, 292, "LE Set Extended Scan Response Data",
9766                                 le_set_ext_scan_rsp_data_cmd, 4, false,
9767                                 status_rsp, 1, true },
9768         { 0x2039, 293, "LE Set Extended Advertising Enable",
9769                                 le_set_ext_adv_enable_cmd, 2, false,
9770                                 status_rsp, 1, true },
9771         { 0x203a, 294, "LE Read Maximum Advertising Data Length",
9772                                 null_cmd, 0, true,
9773                                 le_read_max_adv_data_len_rsp, 3, true },
9774         { 0x203b, 295, "LE Read Number of Supported Advertising Sets",
9775                                 null_cmd, 0, true,
9776                                 le_read_num_supported_adv_sets_rsp, 2, true },
9777         { 0x203c, 296, "LE Remove Advertising Set",
9778                                 le_remove_adv_set_cmd, 1, true,
9779                                 status_rsp, 1, true },
9780         { 0x203d, 297, "LE Clear Advertising Sets",
9781                                 null_cmd, 0, true,
9782                                 status_rsp, 1, true },
9783         { 0x203e, 298, "LE Set Periodic Advertising Parameters",
9784                                 le_set_pa_params_cmd, 7, true,
9785                                 status_rsp, 1, true },
9786         { 0x203f, 299, "LE Set Periodic Advertising Data",
9787                                 le_set_pa_data_cmd, 3, false,
9788                                 status_rsp, 1, true },
9789         { 0x2040, 300, "LE Set Periodic Advertising Enable",
9790                                 le_set_pa_enable_cmd, 2, true,
9791                                 status_rsp, 1, true },
9792         { 0x2041, 301, "LE Set Extended Scan Parameters",
9793                                 le_set_ext_scan_params_cmd, 3, false,
9794                                 status_rsp, 1, true },
9795         { 0x2042, 302, "LE Set Extended Scan Enable",
9796                                 le_set_ext_scan_enable_cmd, 6, true,
9797                                 status_rsp, 1, true },
9798         { 0x2043, 303, "LE Extended Create Connection",
9799                                 le_ext_create_conn_cmd, 10, false,
9800                                 status_rsp, 1, true },
9801         { 0x2044, 304, "LE Periodic Advertising Create Sync",
9802                                 le_pa_create_sync_cmd, 14, true,
9803                                 status_rsp, 1, true },
9804         { 0x2045, 305, "LE Periodic Advertising Create Sync Cancel",
9805                                 null_cmd, 0, true,
9806                                 status_rsp, 1, true },
9807         { 0x2046, 306, "LE Periodic Advertising Terminate Sync",
9808                                 le_pa_term_sync_cmd, 2, true,
9809                                 status_rsp, 1, true },
9810         { 0x2047, 307, "LE Add Device To Periodic Advertiser List",
9811                                 le_add_dev_pa_list_cmd, 8, true,
9812                                 status_rsp, 1, true },
9813         { 0x2048, 308, "LE Remove Device From Periodic Advertiser List",
9814                                 le_remove_dev_pa_list_cmd, 8, true,
9815                                 status_rsp, 1, true },
9816         { 0x2049, 309, "LE Clear Periodic Advertiser List",
9817                                 null_cmd, 0, true,
9818                                 status_rsp, 1, true },
9819         { 0x204a, 310, "LE Read Periodic Advertiser List Size",
9820                                 null_cmd, 0, true,
9821                                 le_read_pa_list_size_rsp, 2, true },
9822         { 0x204b, 311, "LE Read Transmit Power",
9823                                 null_cmd, 0, true,
9824                                 le_read_tx_power_rsp, 3, true },
9825         { 0x204c, 312, "LE Read RF Path Compensation",
9826                                 null_cmd, 0, true,
9827                                 le_read_rf_path_comp_rsp, 5, true },
9828         { 0x204d, 313, "LE Write RF Path Compensation",
9829                                 le_write_rf_path_comp_cmd, 4, true,
9830                                 status_rsp, 1, true },
9831         { 0x204e, 314, "LE Set Privacy Mode",
9832                                 le_set_priv_mode_cmd, 8, true,
9833                                 status_rsp, 1, true },
9834         { 0x204f, 315, "LE Receiver Test command [v3]",
9835                                 le_receiver_test_cmd_v3, 7, false,
9836                                 status_rsp, 1, true },
9837         { 0x2050, 316, "LE Transmitter Test command [v3]",
9838                                 le_tx_test_cmd_v3, 9, false,
9839                                 status_rsp, 1, true },
9840         { 0x2059, 325, "LE Periodic Advertising Receive Enable",
9841                                 le_pa_rec_enable, 3, true,
9842                                 status_rsp, 1, true },
9843         { 0x205a, 326, "LE Periodic Advertising Sync Transfer",
9844                                 le_pa_sync_trans, 6, true,
9845                                 status_handle_rsp, 3, true },
9846         { 0x205b, 327, "LE Periodic Advertising Set Info Transfer",
9847                                 le_pa_set_info_trans, 5, true,
9848                                 status_handle_rsp, 3, true },
9849         { 0x205c, 328, "LE Periodic Advertising Sync Transfer Parameters",
9850                                 le_pa_sync_trans_params, 8, true,
9851                                 status_handle_rsp, 3, true},
9852         { 0x205d, 329, "LE Set Default Periodic Advertisng Sync Transfer "
9853                                 "Parameters",
9854                                 le_set_default_pa_sync_trans_params,
9855                                 6, true, status_rsp, 1, true},
9856         { BT_HCI_CMD_LE_READ_BUFFER_SIZE_V2,
9857                                 BT_HCI_BIT_LE_READ_BUFFER_SIZE_V2,
9858                                 "LE Read Buffer v2",
9859                                 null_cmd, 0, true,
9860                                 le_read_buffer_size_v2_rsp,
9861                                 sizeof(
9862                                 struct bt_hci_rsp_le_read_buffer_size_v2),
9863                                 true },
9864         { BT_HCI_CMD_LE_READ_ISO_TX_SYNC,
9865                                 BT_HCI_BIT_LE_READ_ISO_TX_SYNC,
9866                                 "LE Read ISO TX Sync",
9867                                 le_read_iso_tx_sync_cmd,
9868                                 sizeof(struct bt_hci_cmd_le_read_iso_tx_sync),
9869                                 true,
9870                                 le_read_iso_tx_sync_rsp,
9871                                 sizeof(struct bt_hci_rsp_le_read_iso_tx_sync),
9872                                 true },
9873         { BT_HCI_CMD_LE_SET_CIG_PARAMS, BT_HCI_BIT_LE_SET_CIG_PARAMS,
9874                                 "LE Set Connected Isochronous Group Parameters",
9875                                 le_set_cig_params_cmd,
9876                                 sizeof(struct bt_hci_cmd_le_set_cig_params),
9877                                 false,
9878                                 le_set_cig_params_rsp,
9879                                 sizeof(struct bt_hci_rsp_le_set_cig_params),
9880                                 false },
9881         { BT_HCI_CMD_LE_SET_CIG_PARAMS_TEST, BT_HCI_BIT_LE_SET_CIG_PARAMS_TEST,
9882                                 "LE Set Connected Isochronous Group Parameters"
9883                                 " Test", le_set_cig_params_test_cmd,
9884                                 sizeof(
9885                                 struct bt_hci_cmd_le_set_cig_params_test),
9886                                 false,
9887                                 le_set_cig_params_rsp,
9888                                 sizeof(struct bt_hci_rsp_le_set_cig_params),
9889                                 false },
9890         { BT_HCI_CMD_LE_CREATE_CIS, BT_HCI_BIT_LE_CREATE_CIS,
9891                                 "LE Create Connected Isochronous Stream",
9892                                 le_create_cis_cmd,
9893                                 sizeof(struct bt_hci_cmd_le_create_cis),
9894                                 false },
9895         { BT_HCI_CMD_LE_REMOVE_CIG, BT_HCI_BIT_LE_REMOVE_CIG,
9896                                 "LE Remove Connected Isochronous Group",
9897                                 le_remove_cig_cmd,
9898                                 sizeof(struct bt_hci_cmd_le_remove_cig), false,
9899                                 le_remove_cig_rsp,
9900                                 sizeof(struct bt_hci_rsp_le_remove_cig),
9901                                 false },
9902         { BT_HCI_CMD_LE_ACCEPT_CIS, BT_HCI_BIT_LE_ACCEPT_CIS,
9903                                 "LE Accept Connected Isochronous Stream Request",
9904                                 le_accept_cis_req_cmd,
9905                                 sizeof(struct bt_hci_cmd_le_accept_cis), true },
9906         { BT_HCI_CMD_LE_REJECT_CIS, BT_HCI_BIT_LE_REJECT_CIS,
9907                                 "LE Reject Connected Isochronous Stream Request",
9908                                 le_reject_cis_req_cmd,
9909                                 sizeof(struct bt_hci_cmd_le_reject_cis), true,
9910                                 status_rsp, 1, true },
9911         { BT_HCI_CMD_LE_CREATE_BIG, BT_HCI_BIT_LE_CREATE_BIG,
9912                                 "LE Create Broadcast Isochronous Group",
9913                                 le_create_big_cmd },
9914         { BT_HCI_CMD_LE_CREATE_BIG_TEST, BT_HCI_BIT_LE_CREATE_BIG_TEST,
9915                                 "LE Create Broadcast Isochronous Group Test",
9916                                 le_create_big_cmd_test_cmd },
9917         { BT_HCI_CMD_LE_TERM_BIG, BT_HCI_BIT_LE_TERM_BIG,
9918                                 "LE Terminate Broadcast Isochronous Group",
9919                                 le_terminate_big_cmd,
9920                                 sizeof(struct bt_hci_cmd_le_term_big), true,
9921                                 status_rsp, 1, true},
9922         { BT_HCI_CMD_LE_BIG_CREATE_SYNC, BT_HCI_BIT_LE_BIG_CREATE_SYNC,
9923                                 "LE Broadcast Isochronous Group Create Sync",
9924                                 le_big_create_sync_cmd,
9925                                 sizeof(struct bt_hci_cmd_le_big_create_sync),
9926                                 true },
9927         { BT_HCI_CMD_LE_BIG_TERM_SYNC, BT_HCI_BIT_LE_BIG_TERM_SYNC,
9928                                 "LE Broadcast Isochronous Group Terminate Sync",
9929                                 le_big_term_sync_cmd,
9930                                 sizeof(struct bt_hci_cmd_le_big_term_sync),
9931                                 true },
9932         { BT_HCI_CMD_LE_REQ_PEER_SCA, BT_HCI_BIT_LE_REQ_PEER_SCA,
9933                                 "LE Request Peer SCA", le_req_peer_sca_cmd,
9934                                 sizeof(struct bt_hci_cmd_le_req_peer_sca),
9935                                 true },
9936         { BT_HCI_CMD_LE_SETUP_ISO_PATH, BT_HCI_BIT_LE_SETUP_ISO_PATH,
9937                                 "LE Setup Isochronous Data Path",
9938                                 le_setup_iso_path_cmd,
9939                                 sizeof(struct bt_hci_cmd_le_setup_iso_path),
9940                                 true, le_setup_iso_path_rsp,
9941                                 sizeof(struct bt_hci_rsp_le_setup_iso_path),
9942                                 true },
9943         { BT_HCI_CMD_LE_REMOVE_ISO_PATH, BT_HCI_BIT_LE_REMOVE_ISO_PATH,
9944                                 "LE Remove Isochronous Data Path",
9945                                 le_remove_iso_path_cmd,
9946                                 sizeof(struct bt_hci_cmd_le_remove_iso_path),
9947                                 true, status_handle_rsp,
9948                                 sizeof(struct bt_hci_rsp_le_remove_iso_path),
9949                                 true },
9950         { BT_HCI_CMD_LE_ISO_TX_TEST, BT_HCI_BIT_LE_ISO_TX_TEST,
9951                                 "LE Isochronous Transmit Test", NULL, 0,
9952                                 false },
9953         { BT_HCI_CMD_LE_ISO_RX_TEST, BT_HCI_BIT_LE_ISO_RX_TEST,
9954                                 "LE Isochronous Receive Test", NULL, 0,
9955                                 false },
9956         { BT_HCI_CMD_LE_ISO_READ_TEST_COUNTER,
9957                                 BT_HCI_BIT_LE_ISO_READ_TEST_COUNTER,
9958                                 "LE Isochronous Read Test Counters", NULL, 0,
9959                                 false },
9960         { BT_HCI_CMD_LE_ISO_TEST_END, BT_HCI_BIT_LE_ISO_TEST_END,
9961                                 "LE Isochronous Read Test Counters", NULL, 0,
9962                                 false },
9963         { BT_HCI_CMD_LE_SET_HOST_FEATURE, BT_HCI_BIT_LE_SET_HOST_FEATURE,
9964                                 "LE Set Host Feature", le_set_host_feature_cmd,
9965                                 sizeof(struct bt_hci_cmd_le_set_host_feature),
9966                                 true, status_rsp, 1, true },
9967         { BT_HCI_CMD_LE_READ_ISO_LINK_QUALITY,
9968                                 BT_HCI_BIT_LE_READ_ISO_LINK_QUALITY,
9969                                 "LE Read ISO link quality",
9970                                 le_read_iso_link_quality_cmd,
9971                                 sizeof(
9972                                 struct bt_hci_cmd_le_read_iso_link_quality),
9973                                 true, status_le_read_iso_link_quality_rsp,
9974                                 sizeof(
9975                                 struct bt_hci_rsp_le_read_iso_link_quality),
9976                                 true },
9977         { }
9978 };
9979
9980 static const char *get_supported_command(int bit)
9981 {
9982         int i;
9983
9984         for (i = 0; opcode_table[i].str; i++) {
9985                 if (opcode_table[i].bit == bit)
9986                         return opcode_table[i].str;
9987         }
9988
9989         return NULL;
9990 }
9991
9992 static const char *current_vendor_str(uint16_t ocf)
9993 {
9994         uint16_t manufacturer, msft_opcode;
9995
9996         if (index_current < MAX_INDEX) {
9997                 manufacturer = index_list[index_current].manufacturer;
9998                 msft_opcode = index_list[index_current].msft_opcode;
9999         } else {
10000                 manufacturer = fallback_manufacturer;
10001                 msft_opcode = BT_HCI_CMD_NOP;
10002         }
10003
10004         if (msft_opcode != BT_HCI_CMD_NOP &&
10005                                 cmd_opcode_ocf(msft_opcode) == ocf)
10006                 return "Microsoft";
10007
10008         switch (manufacturer) {
10009         case 2:
10010                 return "Intel";
10011         case 15:
10012                 return "Broadcom";
10013         case 93:
10014                 return "Realtek";
10015 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10016         default:
10017                 return "Unknown";
10018 #endif
10019         }
10020
10021         return NULL;
10022 }
10023
10024 static const struct vendor_ocf *current_vendor_ocf(uint16_t ocf)
10025 {
10026         uint16_t manufacturer, msft_opcode;
10027
10028         if (index_current < MAX_INDEX) {
10029                 manufacturer = index_list[index_current].manufacturer;
10030                 msft_opcode = index_list[index_current].msft_opcode;
10031         } else {
10032                 manufacturer = fallback_manufacturer;
10033                 msft_opcode = BT_HCI_CMD_NOP;
10034         }
10035
10036         if (msft_opcode != BT_HCI_CMD_NOP &&
10037                                 cmd_opcode_ocf(msft_opcode) == ocf)
10038                 return msft_vendor_ocf();
10039
10040         switch (manufacturer) {
10041         case 2:
10042                 return intel_vendor_ocf(ocf);
10043         case 15:
10044                 return broadcom_vendor_ocf(ocf);
10045 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10046         default:
10047                 return broadcom_vendor_ocf(ocf);
10048 #endif
10049         }
10050
10051         return NULL;
10052 }
10053
10054 static const struct vendor_evt *current_vendor_evt(const void *data,
10055                                                         int *consumed_size)
10056 {
10057         uint16_t manufacturer;
10058         uint8_t evt = *((const uint8_t *) data);
10059
10060         /* A regular vendor event consumes 1 byte. */
10061         *consumed_size = 1;
10062
10063         if (index_current < MAX_INDEX)
10064                 manufacturer = index_list[index_current].manufacturer;
10065         else
10066                 manufacturer = fallback_manufacturer;
10067
10068         switch (manufacturer) {
10069         case 2:
10070                 return intel_vendor_evt(data, consumed_size);
10071         case 15:
10072                 return broadcom_vendor_evt(evt);
10073 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10074         default:
10075                 return broadcom_vendor_evt(evt);
10076 #endif
10077         }
10078
10079         return NULL;
10080 }
10081
10082 static const char *current_vendor_evt_str(void)
10083 {
10084         uint16_t manufacturer;
10085
10086         if (index_current < MAX_INDEX)
10087                 manufacturer = index_list[index_current].manufacturer;
10088         else
10089                 manufacturer = fallback_manufacturer;
10090
10091         switch (manufacturer) {
10092         case 2:
10093                 return "Intel";
10094         case 15:
10095                 return "Broadcom";
10096         case 93:
10097                 return "Realtek";
10098         }
10099
10100         return NULL;
10101 }
10102
10103 static void inquiry_complete_evt(struct timeval *tv, uint16_t index,
10104                                         const void *data, uint8_t size)
10105 {
10106         const struct bt_hci_evt_inquiry_complete *evt = data;
10107
10108         print_status(evt->status);
10109 }
10110
10111 static void inquiry_result_evt(struct timeval *tv, uint16_t index,
10112                                         const void *data, uint8_t size)
10113 {
10114         const struct bt_hci_evt_inquiry_result *evt = data;
10115
10116         print_num_resp(evt->num_resp);
10117         print_bdaddr(evt->bdaddr);
10118         print_pscan_rep_mode(evt->pscan_rep_mode);
10119         print_pscan_period_mode(evt->pscan_period_mode);
10120         print_pscan_mode(evt->pscan_mode);
10121         print_dev_class(evt->dev_class);
10122         print_clock_offset(evt->clock_offset);
10123
10124         if (size > sizeof(*evt))
10125                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
10126 }
10127
10128 static void conn_complete_evt(struct timeval *tv, uint16_t index,
10129                                         const void *data, uint8_t size)
10130 {
10131         const struct bt_hci_evt_conn_complete *evt = data;
10132
10133         print_status(evt->status);
10134         print_handle(evt->handle);
10135         print_bdaddr(evt->bdaddr);
10136         print_link_type(evt->link_type);
10137         print_enable("Encryption", evt->encr_mode);
10138
10139         if (evt->status == 0x00)
10140                 assign_handle(index, le16_to_cpu(evt->handle), 0x00,
10141                                         (void *)evt->bdaddr, BDADDR_BREDR);
10142 }
10143
10144 static void conn_request_evt(struct timeval *tv, uint16_t index,
10145                                         const void *data, uint8_t size)
10146 {
10147         const struct bt_hci_evt_conn_request *evt = data;
10148
10149         print_bdaddr(evt->bdaddr);
10150         print_dev_class(evt->dev_class);
10151         print_link_type(evt->link_type);
10152 }
10153
10154 static void disconnect_complete_evt(struct timeval *tv, uint16_t index,
10155                                         const void *data, uint8_t size)
10156 {
10157         const struct bt_hci_evt_disconnect_complete *evt = data;
10158
10159         print_status(evt->status);
10160         print_handle(evt->handle);
10161         print_reason(evt->reason);
10162
10163         if (evt->status == 0x00)
10164                 release_handle(le16_to_cpu(evt->handle));
10165 }
10166
10167 static void auth_complete_evt(struct timeval *tv, uint16_t index,
10168                                         const void *data, uint8_t size)
10169 {
10170         const struct bt_hci_evt_auth_complete *evt = data;
10171
10172         print_status(evt->status);
10173         print_handle(evt->handle);
10174 }
10175
10176 static void remote_name_request_complete_evt(struct timeval *tv, uint16_t index,
10177                                                 const void *data, uint8_t size)
10178 {
10179         const struct bt_hci_evt_remote_name_request_complete *evt = data;
10180
10181         print_status(evt->status);
10182         print_bdaddr(evt->bdaddr);
10183         print_name(evt->name);
10184 }
10185
10186 static void encrypt_change_evt(struct timeval *tv, uint16_t index,
10187                                         const void *data, uint8_t size)
10188 {
10189         const struct bt_hci_evt_encrypt_change *evt = data;
10190
10191         print_status(evt->status);
10192         print_handle(evt->handle);
10193         print_encr_mode_change(evt->encr_mode, evt->handle);
10194 }
10195
10196 static void change_conn_link_key_complete_evt(struct timeval *tv,
10197                                                 uint16_t index,
10198                                                 const void *data, uint8_t size)
10199 {
10200         const struct bt_hci_evt_change_conn_link_key_complete *evt = data;
10201
10202         print_status(evt->status);
10203         print_handle(evt->handle);
10204 }
10205
10206 static void link_key_type_changed_evt(struct timeval *tv, uint16_t index,
10207                                         const void *data, uint8_t size)
10208 {
10209         const struct bt_hci_evt_link_key_type_changed *evt = data;
10210
10211         print_status(evt->status);
10212         print_handle(evt->handle);
10213         print_key_flag(evt->key_flag);
10214 }
10215
10216 static void remote_features_complete_evt(struct timeval *tv, uint16_t index,
10217                                         const void *data, uint8_t size)
10218 {
10219         const struct bt_hci_evt_remote_features_complete *evt = data;
10220
10221         print_status(evt->status);
10222         print_handle(evt->handle);
10223         print_features(0, evt->features, 0x00);
10224 }
10225
10226 static void remote_version_complete_evt(struct timeval *tv, uint16_t index,
10227                                         const void *data, uint8_t size)
10228 {
10229         const struct bt_hci_evt_remote_version_complete *evt = data;
10230
10231         print_status(evt->status);
10232         print_handle(evt->handle);
10233         print_lmp_version(evt->lmp_ver, evt->lmp_subver);
10234         print_manufacturer(evt->manufacturer);
10235
10236         switch (le16_to_cpu(evt->manufacturer)) {
10237         case 15:
10238                 print_manufacturer_broadcom(evt->lmp_subver, 0xffff);
10239                 break;
10240         }
10241 }
10242
10243 static void qos_setup_complete_evt(struct timeval *tv, uint16_t index,
10244                                         const void *data, uint8_t size)
10245 {
10246         const struct bt_hci_evt_qos_setup_complete *evt = data;
10247
10248         print_status(evt->status);
10249         print_handle(evt->handle);
10250         print_field("Flags: 0x%2.2x", evt->flags);
10251
10252         print_service_type(evt->service_type);
10253
10254         print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
10255         print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
10256         print_field("Latency: %d", le32_to_cpu(evt->latency));
10257         print_field("Delay variation: %d", le32_to_cpu(evt->delay_variation));
10258 }
10259
10260 static void cmd_complete_evt(struct timeval *tv, uint16_t index,
10261                                 const void *data, uint8_t size)
10262 {
10263         const struct bt_hci_evt_cmd_complete *evt = data;
10264         uint16_t opcode = le16_to_cpu(evt->opcode);
10265         uint16_t ogf = cmd_opcode_ogf(opcode);
10266         uint16_t ocf = cmd_opcode_ocf(opcode);
10267         struct opcode_data vendor_data;
10268         const struct opcode_data *opcode_data = NULL;
10269         const char *opcode_color, *opcode_str;
10270         char vendor_str[150];
10271         int i;
10272
10273         for (i = 0; opcode_table[i].str; i++) {
10274                 if (opcode_table[i].opcode == opcode) {
10275                         opcode_data = &opcode_table[i];
10276                         break;
10277                 }
10278         }
10279
10280         if (opcode_data) {
10281                 if (opcode_data->rsp_func)
10282                         opcode_color = COLOR_HCI_COMMAND;
10283                 else
10284                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10285                 opcode_str = opcode_data->str;
10286         } else {
10287                 if (ogf == 0x3f) {
10288                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
10289
10290                         if (vnd) {
10291                                 const char *str = current_vendor_str(ocf);
10292
10293                                 if (str) {
10294                                         snprintf(vendor_str, sizeof(vendor_str),
10295                                                         "%s %s", str, vnd->str);
10296                                         vendor_data.str = vendor_str;
10297                                 } else
10298                                         vendor_data.str = vnd->str;
10299                                 vendor_data.rsp_func = vnd->rsp_func;
10300                                 vendor_data.rsp_size = vnd->rsp_size;
10301                                 vendor_data.rsp_fixed = vnd->rsp_fixed;
10302
10303                                 opcode_data = &vendor_data;
10304
10305                                 if (opcode_data->rsp_func)
10306                                         opcode_color = COLOR_HCI_COMMAND;
10307                                 else
10308                                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10309                                 opcode_str = opcode_data->str;
10310                         } else {
10311                                 opcode_color = COLOR_HCI_COMMAND;
10312                                 opcode_str = "Vendor";
10313                         }
10314                 } else {
10315                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10316                         opcode_str = "Unknown";
10317                 }
10318         }
10319
10320         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
10321                         " (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
10322
10323         if (!opcode_data || !opcode_data->rsp_func) {
10324                 if (size > 3) {
10325                         uint8_t status = *((uint8_t *) (data + 3));
10326
10327                         print_status(status);
10328                         packet_hexdump(data + 4, size - 4);
10329                 }
10330                 return;
10331         }
10332
10333         if (opcode_data->rsp_size > 1 && size - 3 == 1) {
10334                 uint8_t status = *((uint8_t *) (data + 3));
10335
10336                 print_status(status);
10337                 return;
10338         }
10339
10340         if (opcode_data->rsp_fixed) {
10341                 if (size - 3 != opcode_data->rsp_size) {
10342                         print_text(COLOR_ERROR, "invalid packet size");
10343                         packet_hexdump(data + 3, size - 3);
10344                         return;
10345                 }
10346         } else {
10347                 if (size - 3 < opcode_data->rsp_size) {
10348                         print_text(COLOR_ERROR, "too short packet");
10349                         packet_hexdump(data + 3, size - 3);
10350                         return;
10351                 }
10352         }
10353
10354         opcode_data->rsp_func(index, data + 3, size - 3);
10355 }
10356
10357 static void cmd_status_evt(struct timeval *tv, uint16_t index,
10358                                 const void *data, uint8_t size)
10359 {
10360         const struct bt_hci_evt_cmd_status *evt = data;
10361         uint16_t opcode = le16_to_cpu(evt->opcode);
10362         uint16_t ogf = cmd_opcode_ogf(opcode);
10363         uint16_t ocf = cmd_opcode_ocf(opcode);
10364         const struct opcode_data *opcode_data = NULL;
10365         const char *opcode_color, *opcode_str;
10366         char vendor_str[150];
10367         int i;
10368
10369         for (i = 0; opcode_table[i].str; i++) {
10370                 if (opcode_table[i].opcode == opcode) {
10371                         opcode_data = &opcode_table[i];
10372                         break;
10373                 }
10374         }
10375
10376         if (opcode_data) {
10377                 opcode_color = COLOR_HCI_COMMAND;
10378                 opcode_str = opcode_data->str;
10379         } else {
10380                 if (ogf == 0x3f) {
10381                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
10382
10383                         if (vnd) {
10384                                 const char *str = current_vendor_str(ocf);
10385
10386                                 if (str) {
10387                                         snprintf(vendor_str, sizeof(vendor_str),
10388                                                         "%s %s", str, vnd->str);
10389                                         opcode_str = vendor_str;
10390                                 } else
10391                                         opcode_str = vnd->str;
10392
10393                                 opcode_color = COLOR_HCI_COMMAND;
10394                         } else {
10395                                 opcode_color = COLOR_HCI_COMMAND;
10396                                 opcode_str = "Vendor";
10397                         }
10398                 } else {
10399                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10400                         opcode_str = "Unknown";
10401                 }
10402         }
10403
10404         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
10405                         " (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
10406
10407         print_status(evt->status);
10408 }
10409
10410 static void hardware_error_evt(struct timeval *tv, uint16_t index,
10411                                 const void *data, uint8_t size)
10412 {
10413         const struct bt_hci_evt_hardware_error *evt = data;
10414
10415         print_field("Code: 0x%2.2x", evt->code);
10416 }
10417
10418 static void flush_occurred_evt(struct timeval *tv, uint16_t index,
10419                                 const void *data, uint8_t size)
10420 {
10421         const struct bt_hci_evt_flush_occurred *evt = data;
10422
10423         print_handle(evt->handle);
10424 }
10425
10426 static void role_change_evt(struct timeval *tv, uint16_t index,
10427                                 const void *data, uint8_t size)
10428 {
10429         const struct bt_hci_evt_role_change *evt = data;
10430
10431         print_status(evt->status);
10432         print_bdaddr(evt->bdaddr);
10433         print_role(evt->role);
10434 }
10435
10436 void packet_latency_add(struct packet_latency *latency, struct timeval *delta)
10437 {
10438         timeradd(&latency->total, delta, &latency->total);
10439
10440         if ((!timerisset(&latency->min) || timercmp(delta, &latency->min, <))
10441                                 && delta->tv_sec >= 0 && delta->tv_usec >= 0)
10442                 latency->min = *delta;
10443
10444         if (!timerisset(&latency->max) || timercmp(delta, &latency->max, >))
10445                 latency->max = *delta;
10446
10447         if (timerisset(&latency->med)) {
10448                 struct timeval tmp;
10449
10450                 timeradd(&latency->med, delta, &tmp);
10451
10452                 tmp.tv_sec /= 2;
10453                 tmp.tv_usec /= 2;
10454                 if (tmp.tv_sec % 2) {
10455                         tmp.tv_usec += 500000;
10456                         if (tmp.tv_usec >= 1000000) {
10457                                 tmp.tv_sec++;
10458                                 tmp.tv_usec -= 1000000;
10459                         }
10460                 }
10461
10462                 latency->med = tmp;
10463         } else
10464                 latency->med = *delta;
10465 }
10466
10467 static void packet_dequeue_tx(struct timeval *tv, uint16_t handle)
10468 {
10469         struct packet_conn_data *conn;
10470         struct packet_frame *frame;
10471         struct timeval delta;
10472
10473         conn = packet_get_conn_data(handle);
10474         if (!conn)
10475                 return;
10476
10477         frame = queue_pop_head(conn->tx_q);
10478         if (!frame)
10479                 return;
10480
10481         timersub(tv, &frame->tv, &delta);
10482
10483         packet_latency_add(&conn->tx_l, &delta);
10484
10485         if (TV_MSEC(delta)) {
10486                 print_field("#%zu: len %zu (%lld Kb/s)", frame->num, frame->len,
10487                                 frame->len * 8 / TV_MSEC(delta));
10488                 print_field("Latency: %lld msec (%lld-%lld msec ~%lld msec)",
10489                                 TV_MSEC(delta), TV_MSEC(conn->tx_l.min),
10490                                 TV_MSEC(conn->tx_l.max),
10491                                 TV_MSEC(conn->tx_l.med));
10492         }
10493
10494         l2cap_dequeue_frame(&delta, conn);
10495
10496         free(frame);
10497 }
10498
10499 static void num_completed_packets_evt(struct timeval *tv, uint16_t index,
10500                                         const void *data, uint8_t size)
10501 {
10502         struct iovec iov = { (void *)data, size};
10503         const struct bt_hci_evt_num_completed_packets *evt = data;
10504         int i;
10505
10506         iov_pull(&iov, 1);
10507
10508         print_field("Num handles: %d", evt->num_handles);
10509
10510         for (i = 0; i < evt->num_handles; i++) {
10511                 uint16_t handle;
10512                 uint16_t count;
10513                 int j;
10514
10515                 if (!util_iov_pull_le16(&iov, &handle))
10516                         break;
10517
10518                 print_handle_native(handle);
10519
10520                 if (!util_iov_pull_le16(&iov, &count))
10521                         break;
10522
10523                 print_field("Count: %d", count);
10524
10525                 for (j = 0; j < count; j++)
10526                         packet_dequeue_tx(tv, handle);
10527         }
10528
10529         if (iov.iov_len)
10530                 packet_hexdump(iov.iov_base, iov.iov_len);
10531 }
10532
10533 static void mode_change_evt(struct timeval *tv, uint16_t index,
10534                                         const void *data, uint8_t size)
10535 {
10536         const struct bt_hci_evt_mode_change *evt = data;
10537
10538         print_status(evt->status);
10539         print_handle(evt->handle);
10540         print_mode(evt->mode);
10541         print_interval(evt->interval);
10542 }
10543
10544 static void return_link_keys_evt(struct timeval *tv, uint16_t index,
10545                                         const void *data, uint8_t size)
10546 {
10547         const struct bt_hci_evt_return_link_keys *evt = data;
10548         uint8_t i;
10549
10550         print_field("Num keys: %d", evt->num_keys);
10551
10552         for (i = 0; i < evt->num_keys; i++) {
10553                 print_bdaddr(evt->keys + (i * 22));
10554                 print_link_key(evt->keys + (i * 22) + 6);
10555         }
10556 }
10557
10558 static void pin_code_request_evt(struct timeval *tv, uint16_t index,
10559                                         const void *data, uint8_t size)
10560 {
10561         const struct bt_hci_evt_pin_code_request *evt = data;
10562
10563         print_bdaddr(evt->bdaddr);
10564 }
10565
10566 static void link_key_request_evt(struct timeval *tv, uint16_t index,
10567                                         const void *data, uint8_t size)
10568 {
10569         const struct bt_hci_evt_link_key_request *evt = data;
10570
10571         print_bdaddr(evt->bdaddr);
10572 }
10573
10574 static void link_key_notify_evt(struct timeval *tv, uint16_t index,
10575                                         const void *data, uint8_t size)
10576 {
10577         const struct bt_hci_evt_link_key_notify *evt = data;
10578
10579         print_bdaddr(evt->bdaddr);
10580         print_link_key(evt->link_key);
10581         print_key_type(evt->key_type);
10582 }
10583
10584 static void loopback_command_evt(struct timeval *tv, uint16_t index,
10585                                         const void *data, uint8_t size)
10586 {
10587         packet_hexdump(data, size);
10588 }
10589
10590 static void data_buffer_overflow_evt(struct timeval *tv, uint16_t index,
10591                                         const void *data, uint8_t size)
10592 {
10593         const struct bt_hci_evt_data_buffer_overflow *evt = data;
10594
10595         print_link_type(evt->link_type);
10596 }
10597
10598 static void max_slots_change_evt(struct timeval *tv, uint16_t index,
10599                                         const void *data, uint8_t size)
10600 {
10601         const struct bt_hci_evt_max_slots_change *evt = data;
10602
10603         print_handle(evt->handle);
10604         print_field("Max slots: %d", evt->max_slots);
10605 }
10606
10607 static void clock_offset_complete_evt(struct timeval *tv, uint16_t index,
10608                                         const void *data, uint8_t size)
10609 {
10610         const struct bt_hci_evt_clock_offset_complete *evt = data;
10611
10612         print_status(evt->status);
10613         print_handle(evt->handle);
10614         print_clock_offset(evt->clock_offset);
10615 }
10616
10617 static void conn_pkt_type_changed_evt(struct timeval *tv, uint16_t index,
10618                                         const void *data, uint8_t size)
10619 {
10620         const struct bt_hci_evt_conn_pkt_type_changed *evt = data;
10621
10622         print_status(evt->status);
10623         print_handle(evt->handle);
10624         print_pkt_type(evt->pkt_type);
10625 }
10626
10627 static void qos_violation_evt(struct timeval *tv, uint16_t index,
10628                                         const void *data, uint8_t size)
10629 {
10630         const struct bt_hci_evt_qos_violation *evt = data;
10631
10632         print_handle(evt->handle);
10633 }
10634
10635 static void pscan_mode_change_evt(struct timeval *tv, uint16_t index,
10636                                         const void *data, uint8_t size)
10637 {
10638         const struct bt_hci_evt_pscan_mode_change *evt = data;
10639
10640         print_bdaddr(evt->bdaddr);
10641         print_pscan_mode(evt->pscan_mode);
10642 }
10643
10644 static void pscan_rep_mode_change_evt(struct timeval *tv, uint16_t index,
10645                                         const void *data, uint8_t size)
10646 {
10647         const struct bt_hci_evt_pscan_rep_mode_change *evt = data;
10648
10649         print_bdaddr(evt->bdaddr);
10650         print_pscan_rep_mode(evt->pscan_rep_mode);
10651 }
10652
10653 static void flow_spec_complete_evt(struct timeval *tv, uint16_t index,
10654                                         const void *data, uint8_t size)
10655 {
10656         const struct bt_hci_evt_flow_spec_complete *evt = data;
10657
10658         print_status(evt->status);
10659         print_handle(evt->handle);
10660         print_field("Flags: 0x%2.2x", evt->flags);
10661
10662         print_flow_direction(evt->direction);
10663         print_service_type(evt->service_type);
10664
10665         print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
10666         print_field("Token bucket size: %d",
10667                                         le32_to_cpu(evt->token_bucket_size));
10668         print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
10669         print_field("Access latency: %d", le32_to_cpu(evt->access_latency));
10670 }
10671
10672 static void inquiry_result_with_rssi_evt(struct timeval *tv, uint16_t index,
10673                                         const void *data, uint8_t size)
10674 {
10675         const struct bt_hci_evt_inquiry_result_with_rssi *evt = data;
10676
10677         print_num_resp(evt->num_resp);
10678         print_bdaddr(evt->bdaddr);
10679         print_pscan_rep_mode(evt->pscan_rep_mode);
10680         print_pscan_period_mode(evt->pscan_period_mode);
10681         print_dev_class(evt->dev_class);
10682         print_clock_offset(evt->clock_offset);
10683         print_rssi(evt->rssi);
10684
10685         if (size > sizeof(*evt))
10686                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
10687 }
10688
10689 static void remote_ext_features_complete_evt(struct timeval *tv, uint16_t index,
10690                                         const void *data, uint8_t size)
10691 {
10692         const struct bt_hci_evt_remote_ext_features_complete *evt = data;
10693
10694         print_status(evt->status);
10695         print_handle(evt->handle);
10696         print_field("Page: %d/%d", evt->page, evt->max_page);
10697         print_features(evt->page, evt->features, 0x00);
10698 }
10699
10700 static void sync_conn_complete_evt(struct timeval *tv, uint16_t index,
10701                                         const void *data, uint8_t size)
10702 {
10703         const struct bt_hci_evt_sync_conn_complete *evt = data;
10704
10705         print_status(evt->status);
10706         print_handle(evt->handle);
10707         print_bdaddr(evt->bdaddr);
10708         print_link_type(evt->link_type);
10709         print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
10710         print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
10711         print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
10712         print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
10713         print_air_mode(evt->air_mode);
10714
10715         if (evt->status == 0x00)
10716                 assign_handle(index, le16_to_cpu(evt->handle), evt->link_type,
10717                                         (void *)evt->bdaddr, BDADDR_BREDR);
10718 }
10719
10720 static void sync_conn_changed_evt(struct timeval *tv, uint16_t index,
10721                                         const void *data, uint8_t size)
10722 {
10723         const struct bt_hci_evt_sync_conn_changed *evt = data;
10724
10725         print_status(evt->status);
10726         print_handle(evt->handle);
10727         print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
10728         print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
10729         print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
10730         print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
10731 }
10732
10733 static void sniff_subrating_evt(struct timeval *tv, uint16_t index,
10734                                         const void *data, uint8_t size)
10735 {
10736         const struct bt_hci_evt_sniff_subrating *evt = data;
10737
10738         print_status(evt->status);
10739         print_handle(evt->handle);
10740         print_slot_625("Max transmit latency", evt->max_tx_latency);
10741         print_slot_625("Max receive latency", evt->max_rx_latency);
10742         print_slot_625("Min remote timeout", evt->min_remote_timeout);
10743         print_slot_625("Min local timeout", evt->min_local_timeout);
10744 }
10745
10746 static void ext_inquiry_result_evt(struct timeval *tv, uint16_t index,
10747                                         const void *data, uint8_t size)
10748 {
10749         const struct bt_hci_evt_ext_inquiry_result *evt = data;
10750
10751         print_num_resp(evt->num_resp);
10752         print_bdaddr(evt->bdaddr);
10753         print_pscan_rep_mode(evt->pscan_rep_mode);
10754         print_pscan_period_mode(evt->pscan_period_mode);
10755         print_dev_class(evt->dev_class);
10756         print_clock_offset(evt->clock_offset);
10757         print_rssi(evt->rssi);
10758         print_eir(evt->data, sizeof(evt->data), false);
10759 }
10760
10761 static void encrypt_key_refresh_complete_evt(struct timeval *tv, uint16_t index,
10762                                         const void *data, uint8_t size)
10763 {
10764         const struct bt_hci_evt_encrypt_key_refresh_complete *evt = data;
10765
10766         print_status(evt->status);
10767         print_handle(evt->handle);
10768 }
10769
10770 static void io_capability_request_evt(struct timeval *tv, uint16_t index,
10771                                         const void *data, uint8_t size)
10772 {
10773         const struct bt_hci_evt_io_capability_request *evt = data;
10774
10775         print_bdaddr(evt->bdaddr);
10776 }
10777
10778 static void io_capability_response_evt(struct timeval *tv, uint16_t index,
10779                                         const void *data, uint8_t size)
10780 {
10781         const struct bt_hci_evt_io_capability_response *evt = data;
10782
10783         print_bdaddr(evt->bdaddr);
10784         print_io_capability(evt->capability);
10785         print_oob_data_response(evt->oob_data);
10786         print_authentication(evt->authentication);
10787 }
10788
10789 static void user_confirm_request_evt(struct timeval *tv, uint16_t index,
10790                                         const void *data, uint8_t size)
10791 {
10792         const struct bt_hci_evt_user_confirm_request *evt = data;
10793
10794         print_bdaddr(evt->bdaddr);
10795         print_passkey(evt->passkey);
10796 }
10797
10798 static void user_passkey_request_evt(struct timeval *tv, uint16_t index,
10799                                         const void *data, uint8_t size)
10800 {
10801         const struct bt_hci_evt_user_passkey_request *evt = data;
10802
10803         print_bdaddr(evt->bdaddr);
10804 }
10805
10806 static void remote_oob_data_request_evt(struct timeval *tv, uint16_t index,
10807                                         const void *data, uint8_t size)
10808 {
10809         const struct bt_hci_evt_remote_oob_data_request *evt = data;
10810
10811         print_bdaddr(evt->bdaddr);
10812 }
10813
10814 static void simple_pairing_complete_evt(struct timeval *tv, uint16_t index,
10815                                         const void *data, uint8_t size)
10816 {
10817         const struct bt_hci_evt_simple_pairing_complete *evt = data;
10818
10819         print_status(evt->status);
10820         print_bdaddr(evt->bdaddr);
10821 }
10822
10823 static void link_supv_timeout_changed_evt(struct timeval *tv, uint16_t index,
10824                                         const void *data, uint8_t size)
10825 {
10826         const struct bt_hci_evt_link_supv_timeout_changed *evt = data;
10827
10828         print_handle(evt->handle);
10829         print_timeout(evt->timeout);
10830 }
10831
10832 static void enhanced_flush_complete_evt(struct timeval *tv, uint16_t index,
10833                                         const void *data, uint8_t size)
10834 {
10835         const struct bt_hci_evt_enhanced_flush_complete *evt = data;
10836
10837         print_handle(evt->handle);
10838 }
10839
10840 static void user_passkey_notify_evt(struct timeval *tv, uint16_t index,
10841                                         const void *data, uint8_t size)
10842 {
10843         const struct bt_hci_evt_user_passkey_notify *evt = data;
10844
10845         print_bdaddr(evt->bdaddr);
10846         print_passkey(evt->passkey);
10847 }
10848
10849 static void keypress_notify_evt(struct timeval *tv, uint16_t index,
10850                                         const void *data, uint8_t size)
10851 {
10852         const struct bt_hci_evt_keypress_notify *evt = data;
10853         const char *str;
10854
10855         print_bdaddr(evt->bdaddr);
10856
10857         switch (evt->type) {
10858         case 0x00:
10859                 str = "Passkey entry started";
10860                 break;
10861         case 0x01:
10862                 str = "Passkey digit entered";
10863                 break;
10864         case 0x02:
10865                 str = "Passkey digit erased";
10866                 break;
10867         case 0x03:
10868                 str = "Passkey clared";
10869                 break;
10870         case 0x04:
10871                 str = "Passkey entry completed";
10872                 break;
10873         default:
10874                 str = "Reserved";
10875                 break;
10876         }
10877
10878         print_field("Notification type: %s (0x%2.2x)", str, evt->type);
10879 }
10880
10881 static void remote_host_features_notify_evt(struct timeval *tv, uint16_t index,
10882                                         const void *data, uint8_t size)
10883 {
10884         const struct bt_hci_evt_remote_host_features_notify *evt = data;
10885
10886         print_bdaddr(evt->bdaddr);
10887         print_features(1, evt->features, 0x00);
10888 }
10889
10890 static void phy_link_complete_evt(struct timeval *tv, uint16_t index,
10891                                         const void *data, uint8_t size)
10892 {
10893         const struct bt_hci_evt_phy_link_complete *evt = data;
10894
10895         print_status(evt->status);
10896         print_phy_handle(evt->phy_handle);
10897 }
10898
10899 static void channel_selected_evt(struct timeval *tv, uint16_t index,
10900                                         const void *data, uint8_t size)
10901 {
10902         const struct bt_hci_evt_channel_selected *evt = data;
10903
10904         print_phy_handle(evt->phy_handle);
10905 }
10906
10907 static void disconn_phy_link_complete_evt(struct timeval *tv, uint16_t index,
10908                                         const void *data, uint8_t size)
10909 {
10910         const struct bt_hci_evt_disconn_phy_link_complete *evt = data;
10911
10912         print_status(evt->status);
10913         print_phy_handle(evt->phy_handle);
10914         print_reason(evt->reason);
10915 }
10916
10917 static void phy_link_loss_early_warning_evt(struct timeval *tv, uint16_t index,
10918                                         const void *data, uint8_t size)
10919 {
10920         const struct bt_hci_evt_phy_link_loss_early_warning *evt = data;
10921         const char *str;
10922
10923         print_phy_handle(evt->phy_handle);
10924
10925         switch (evt->reason) {
10926         case 0x00:
10927                 str = "Unknown";
10928                 break;
10929         case 0x01:
10930                 str = "Range related";
10931                 break;
10932         case 0x02:
10933                 str = "Bandwidth related";
10934                 break;
10935         case 0x03:
10936                 str = "Resolving conflict";
10937                 break;
10938         case 0x04:
10939                 str = "Interference";
10940                 break;
10941         default:
10942                 str = "Reserved";
10943                 break;
10944         }
10945
10946         print_field("Reason: %s (0x%2.2x)", str, evt->reason);
10947 }
10948
10949 static void phy_link_recovery_evt(struct timeval *tv, uint16_t index,
10950                                         const void *data, uint8_t size)
10951 {
10952         const struct bt_hci_evt_phy_link_recovery *evt = data;
10953
10954         print_phy_handle(evt->phy_handle);
10955 }
10956
10957 static void logic_link_complete_evt(struct timeval *tv, uint16_t index,
10958                                         const void *data, uint8_t size)
10959 {
10960         const struct bt_hci_evt_logic_link_complete *evt = data;
10961
10962         print_status(evt->status);
10963         print_handle(evt->handle);
10964         print_phy_handle(evt->phy_handle);
10965         print_field("TX flow spec: 0x%2.2x", evt->flow_spec);
10966 }
10967
10968 static void disconn_logic_link_complete_evt(struct timeval *tv, uint16_t index,
10969                                         const void *data, uint8_t size)
10970 {
10971         const struct bt_hci_evt_disconn_logic_link_complete *evt = data;
10972
10973         print_status(evt->status);
10974         print_handle(evt->handle);
10975         print_reason(evt->reason);
10976 }
10977
10978 static void flow_spec_modify_complete_evt(struct timeval *tv, uint16_t index,
10979                                         const void *data, uint8_t size)
10980 {
10981         const struct bt_hci_evt_flow_spec_modify_complete *evt = data;
10982
10983         print_status(evt->status);
10984         print_handle(evt->handle);
10985 }
10986
10987 static void num_completed_data_blocks_evt(struct timeval *tv, uint16_t index,
10988                                         const void *data, uint8_t size)
10989 {
10990         const struct bt_hci_evt_num_completed_data_blocks *evt = data;
10991
10992         print_field("Total num data blocks: %d",
10993                                 le16_to_cpu(evt->total_num_blocks));
10994         print_field("Num handles: %d", evt->num_handles);
10995         print_handle(evt->handle);
10996         print_field("Num packets: %d", evt->num_packets);
10997         print_field("Num blocks: %d", evt->num_blocks);
10998
10999         if (size > sizeof(*evt))
11000                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
11001 }
11002
11003 static void short_range_mode_change_evt(struct timeval *tv, uint16_t index,
11004                                         const void *data, uint8_t size)
11005 {
11006         const struct bt_hci_evt_short_range_mode_change *evt = data;
11007
11008         print_status(evt->status);
11009         print_phy_handle(evt->phy_handle);
11010         print_enable("Short range mode", evt->mode);
11011 }
11012
11013 static void amp_status_change_evt(struct timeval *tv, uint16_t index,
11014                                         const void *data, uint8_t size)
11015 {
11016         const struct bt_hci_evt_amp_status_change *evt = data;
11017
11018         print_status(evt->status);
11019         print_amp_status(evt->amp_status);
11020 }
11021
11022 static void triggered_clock_capture_evt(struct timeval *tv, uint16_t index,
11023                                         const void *data, uint8_t size)
11024 {
11025         const struct bt_hci_evt_triggered_clock_capture *evt = data;
11026
11027         print_handle(evt->handle);
11028         print_clock_type(evt->type);
11029         print_clock(evt->clock);
11030         print_clock_offset(evt->clock_offset);
11031 }
11032
11033 static void sync_train_complete_evt(struct timeval *tv, uint16_t index,
11034                                         const void *data, uint8_t size)
11035 {
11036         const struct bt_hci_evt_sync_train_complete *evt = data;
11037
11038         print_status(evt->status);
11039 }
11040
11041 static void sync_train_received_evt(struct timeval *tv, uint16_t index,
11042                                         const void *data, uint8_t size)
11043 {
11044         const struct bt_hci_evt_sync_train_received *evt = data;
11045
11046         print_status(evt->status);
11047         print_bdaddr(evt->bdaddr);
11048         print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
11049         print_channel_map(evt->map);
11050         print_lt_addr(evt->lt_addr);
11051         print_field("Next broadcast instant: 0x%4.4x",
11052                                         le16_to_cpu(evt->instant));
11053         print_interval(evt->interval);
11054         print_field("Service Data: 0x%2.2x", evt->service_data);
11055 }
11056
11057 static void peripheral_broadcast_receive_evt(struct timeval *tv, uint16_t index,
11058                                         const void *data, uint8_t size)
11059 {
11060         const struct bt_hci_evt_peripheral_broadcast_receive *evt = data;
11061
11062         print_bdaddr(evt->bdaddr);
11063         print_lt_addr(evt->lt_addr);
11064         print_field("Clock: 0x%8.8x", le32_to_cpu(evt->clock));
11065         print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
11066         print_field("Receive status: 0x%2.2x", evt->status);
11067         print_broadcast_fragment(evt->fragment);
11068         print_field("Length: %d", evt->length);
11069
11070         if (size - 18 != evt->length)
11071                 print_text(COLOR_ERROR, "invalid data size (%d != %d)",
11072                                                 size - 18, evt->length);
11073
11074         if (evt->lt_addr == 0x01 && evt->length == 17)
11075                 print_3d_broadcast(data + 18, size - 18);
11076         else
11077                 packet_hexdump(data + 18, size - 18);
11078 }
11079
11080 static void peripheral_broadcast_timeout_evt(struct timeval *tv, uint16_t index,
11081                                         const void *data, uint8_t size)
11082 {
11083         const struct bt_hci_evt_peripheral_broadcast_timeout *evt = data;
11084
11085         print_bdaddr(evt->bdaddr);
11086         print_lt_addr(evt->lt_addr);
11087 }
11088
11089 static void truncated_page_complete_evt(struct timeval *tv, uint16_t index,
11090                                         const void *data, uint8_t size)
11091 {
11092         const struct bt_hci_evt_truncated_page_complete *evt = data;
11093
11094         print_status(evt->status);
11095         print_bdaddr(evt->bdaddr);
11096 }
11097
11098 static void peripheral_page_response_timeout_evt(struct timeval *tv,
11099                                         uint16_t index, const void *data,
11100                                         uint8_t size)
11101 {
11102 }
11103
11104 static void channel_map_change_evt(struct timeval *tv, uint16_t index,
11105                                         const void *data, uint8_t size)
11106 {
11107         const struct bt_hci_evt_channel_map_change *evt = data;
11108
11109         print_channel_map(evt->map);
11110 }
11111
11112 static void inquiry_response_notify_evt(struct timeval *tv, uint16_t index,
11113                                         const void *data, uint8_t size)
11114 {
11115         const struct bt_hci_evt_inquiry_response_notify *evt = data;
11116
11117         print_iac(evt->lap);
11118         print_rssi(evt->rssi);
11119 }
11120
11121 static void auth_payload_timeout_expired_evt(struct timeval *tv, uint16_t index,
11122                                         const void *data, uint8_t size)
11123 {
11124         const struct bt_hci_evt_auth_payload_timeout_expired *evt = data;
11125
11126         print_handle(evt->handle);
11127 }
11128
11129 static void le_conn_complete_evt(struct timeval *tv, uint16_t index,
11130                                         const void *data, uint8_t size)
11131 {
11132         const struct bt_hci_evt_le_conn_complete *evt = data;
11133
11134         print_status(evt->status);
11135         print_handle(evt->handle);
11136         print_role(evt->role);
11137         print_peer_addr_type("Peer address type", evt->peer_addr_type);
11138         print_addr("Peer address", evt->peer_addr, evt->peer_addr_type);
11139         print_slot_125("Connection interval", evt->interval);
11140         print_conn_latency("Connection latency", evt->latency);
11141         print_field("Supervision timeout: %d msec (0x%4.4x)",
11142                                         le16_to_cpu(evt->supv_timeout) * 10,
11143                                         le16_to_cpu(evt->supv_timeout));
11144         print_field("Central clock accuracy: 0x%2.2x", evt->clock_accuracy);
11145
11146         if (evt->status == 0x00)
11147                 assign_handle(index, le16_to_cpu(evt->handle), 0x01,
11148                                 (void *)evt->peer_addr, evt->peer_addr_type);
11149 }
11150
11151 static void le_adv_report_evt(struct timeval *tv, uint16_t index,
11152                                         const void *data, uint8_t size)
11153 {
11154         const struct bt_hci_evt_le_adv_report *evt = data;
11155         uint8_t evt_len;
11156         int8_t *rssi;
11157
11158         print_num_reports(evt->num_reports);
11159
11160 report:
11161         print_adv_event_type("Event type", evt->event_type);
11162         print_peer_addr_type("Address type", evt->addr_type);
11163         print_addr("Address", evt->addr, evt->addr_type);
11164         print_field("Data length: %d", evt->data_len);
11165         print_eir(evt->data, evt->data_len, true);
11166
11167         rssi = (int8_t *) (evt->data + evt->data_len);
11168         print_rssi(*rssi);
11169
11170         evt_len = sizeof(*evt) + evt->data_len + 1;
11171
11172         if (size > evt_len) {
11173                 data += evt_len - 1;
11174                 size -= evt_len - 1;
11175                 evt = data;
11176                 goto report;
11177         }
11178 }
11179
11180 static void le_conn_update_complete_evt(struct timeval *tv, uint16_t index,
11181                                         const void *data, uint8_t size)
11182 {
11183         const struct bt_hci_evt_le_conn_update_complete *evt = data;
11184
11185         print_status(evt->status);
11186         print_handle(evt->handle);
11187         print_slot_125("Connection interval", evt->interval);
11188         print_conn_latency("Connection latency", evt->latency);
11189         print_field("Supervision timeout: %d msec (0x%4.4x)",
11190                                         le16_to_cpu(evt->supv_timeout) * 10,
11191                                         le16_to_cpu(evt->supv_timeout));
11192 }
11193
11194 static void le_remote_features_complete_evt(struct timeval *tv, uint16_t index,
11195                                         const void *data, uint8_t size)
11196 {
11197         const struct bt_hci_evt_le_remote_features_complete *evt = data;
11198
11199         print_status(evt->status);
11200         print_handle(evt->handle);
11201         print_features(0, evt->features, 0x01);
11202 }
11203
11204 static void le_long_term_key_request_evt(struct timeval *tv, uint16_t index,
11205                                         const void *data, uint8_t size)
11206 {
11207         const struct bt_hci_evt_le_long_term_key_request *evt = data;
11208
11209         print_handle(evt->handle);
11210         print_random_number(evt->rand);
11211         print_encrypted_diversifier(evt->ediv);
11212 }
11213
11214 static void le_conn_param_request_evt(struct timeval *tv, uint16_t index,
11215                                       const void *data, uint8_t size)
11216 {
11217         const struct bt_hci_evt_le_conn_param_request *evt = data;
11218
11219         print_handle(evt->handle);
11220         print_slot_125("Min connection interval", evt->min_interval);
11221         print_slot_125("Max connection interval", evt->max_interval);
11222         print_conn_latency("Connection latency", evt->latency);
11223         print_field("Supervision timeout: %d msec (0x%4.4x)",
11224                                         le16_to_cpu(evt->supv_timeout) * 10,
11225                                         le16_to_cpu(evt->supv_timeout));
11226 }
11227
11228 static void le_data_length_change_evt(struct timeval *tv, uint16_t index,
11229                                       const void *data, uint8_t size)
11230 {
11231         const struct bt_hci_evt_le_data_length_change *evt = data;
11232
11233         print_handle(evt->handle);
11234         print_field("Max TX octets: %d", le16_to_cpu(evt->max_tx_len));
11235         print_field("Max TX time: %d", le16_to_cpu(evt->max_tx_time));
11236         print_field("Max RX octets: %d", le16_to_cpu(evt->max_rx_len));
11237         print_field("Max RX time: %d", le16_to_cpu(evt->max_rx_time));
11238 }
11239
11240 static void le_read_local_pk256_complete_evt(struct timeval *tv, uint16_t index,
11241                                         const void *data, uint8_t size)
11242 {
11243         const struct bt_hci_evt_le_read_local_pk256_complete *evt = data;
11244
11245         print_status(evt->status);
11246         print_pk256("Local P-256 public key", evt->local_pk256);
11247 }
11248
11249 static void le_generate_dhkey_complete_evt(struct timeval *tv, uint16_t index,
11250                                         const void *data, uint8_t size)
11251 {
11252         const struct bt_hci_evt_le_generate_dhkey_complete *evt = data;
11253
11254         print_status(evt->status);
11255         print_dhkey(evt->dhkey);
11256 }
11257
11258 static void le_enhanced_conn_complete_evt(struct timeval *tv, uint16_t index,
11259                                         const void *data, uint8_t size)
11260 {
11261         const struct bt_hci_evt_le_enhanced_conn_complete *evt = data;
11262
11263         print_status(evt->status);
11264         print_handle(evt->handle);
11265         print_role(evt->role);
11266         print_peer_addr_type("Peer address type", evt->peer_addr_type);
11267         print_addr("Peer address", evt->peer_addr, evt->peer_addr_type);
11268         print_addr("Local resolvable private address", evt->local_rpa, 0x01);
11269         print_addr("Peer resolvable private address", evt->peer_rpa, 0x01);
11270         print_slot_125("Connection interval", evt->interval);
11271         print_conn_latency("Connection latency", evt->latency);
11272         print_field("Supervision timeout: %d msec (0x%4.4x)",
11273                                         le16_to_cpu(evt->supv_timeout) * 10,
11274                                         le16_to_cpu(evt->supv_timeout));
11275         print_field("Central clock accuracy: 0x%2.2x", evt->clock_accuracy);
11276
11277         if (evt->status == 0x00)
11278                 assign_handle(index, le16_to_cpu(evt->handle), 0x01,
11279                                 (void *)evt->peer_addr, evt->peer_addr_type);
11280 }
11281
11282 static void le_direct_adv_report_evt(struct timeval *tv, uint16_t index,
11283                                         const void *data, uint8_t size)
11284 {
11285         const struct bt_hci_evt_le_direct_adv_report *evt = data;
11286
11287         print_num_reports(evt->num_reports);
11288
11289         print_adv_event_type("Event type", evt->event_type);
11290         print_peer_addr_type("Address type", evt->addr_type);
11291         print_addr("Address", evt->addr, evt->addr_type);
11292         print_addr_type("Direct address type", evt->direct_addr_type);
11293         print_addr("Direct address", evt->direct_addr, evt->direct_addr_type);
11294         print_rssi(evt->rssi);
11295
11296         if (size > sizeof(*evt))
11297                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
11298 }
11299
11300 static void le_phy_update_complete_evt(struct timeval *tv, uint16_t index,
11301                                         const void *data, uint8_t size)
11302 {
11303         const struct bt_hci_evt_le_phy_update_complete *evt = data;
11304
11305         print_status(evt->status);
11306         print_handle(evt->handle);
11307         print_le_phy("TX PHY", evt->tx_phy);
11308         print_le_phy("RX PHY", evt->rx_phy);
11309 }
11310
11311 static const struct bitfield_data ext_adv_report_evt_type[] = {
11312         {  0, "Connectable"             },
11313         {  1, "Scannable"               },
11314         {  2, "Directed"        },
11315         {  3, "Scan response"   },
11316         {  4, "Use legacy advertising PDUs"     },
11317         { }
11318 };
11319
11320 static void print_ext_adv_report_evt_type(const char *indent, uint16_t flags)
11321 {
11322         uint16_t mask = flags;
11323         uint16_t props = flags;
11324         uint8_t data_status;
11325         const char *str;
11326         const char *color_on;
11327         int i;
11328
11329         print_field("%sEvent type: 0x%4.4x", indent, flags);
11330
11331         props &= 0x1f;
11332         print_field("%s  Props: 0x%4.4x", indent, props);
11333         for (i = 0; ext_adv_report_evt_type[i].str; i++) {
11334                 if (flags & (1 << ext_adv_report_evt_type[i].bit)) {
11335                         print_field("%s    %s", indent,
11336                                                 ext_adv_report_evt_type[i].str);
11337                         mask &= ~(1 << ext_adv_report_evt_type[i].bit);
11338                 }
11339         }
11340
11341         data_status = (flags >> 5) & 3;
11342         mask &= ~(data_status << 5);
11343
11344         switch (data_status) {
11345         case 0x00:
11346                 str = "Complete";
11347                 color_on = COLOR_GREEN;
11348                 break;
11349         case 0x01:
11350                 str = "Incomplete, more data to come";
11351                 color_on = COLOR_YELLOW;
11352                 break;
11353         case 0x02:
11354                 str = "Incomplete, data truncated, no more to come";
11355                 color_on = COLOR_RED;
11356                 break;
11357         default:
11358                 str = "Reserved";
11359                 color_on = COLOR_RED;
11360                 break;
11361         }
11362
11363         print_field("%s  Data status: %s%s%s", indent, color_on, str, COLOR_OFF);
11364
11365         if (mask)
11366                 print_text(COLOR_UNKNOWN_ADV_FLAG,
11367                                 "%s  Reserved (0x%4.4x)", indent, mask);
11368 }
11369
11370 static void print_legacy_adv_report_pdu(uint16_t flags)
11371 {
11372         const char *str;
11373
11374         if (!(flags & (1 << 4)))
11375                 return;
11376
11377         switch (flags) {
11378         case 0x10:
11379                 str = "ADV_NONCONN_IND";
11380                 break;
11381         case 0x12:
11382                 str = "ADV_SCAN_IND";
11383                 break;
11384         case 0x13:
11385                 str = "ADV_IND";
11386                 break;
11387         case 0x15:
11388                 str = "ADV_DIRECT_IND";
11389                 break;
11390         case 0x1a:
11391                 str = "SCAN_RSP to an ADV_IND";
11392                 break;
11393         case 0x1b:
11394                 str = "SCAN_RSP to an ADV_SCAN_IND";
11395                 break;
11396         default:
11397                 str = "Reserved";
11398                 break;
11399         }
11400
11401         print_field("  Legacy PDU Type: %s (0x%4.4x)", str, flags);
11402 }
11403
11404 static void le_ext_adv_report_evt(struct timeval *tv, uint16_t index,
11405                                         const void *data, uint8_t size)
11406 {
11407         const struct bt_hci_evt_le_ext_adv_report *evt = data;
11408         const struct bt_hci_le_ext_adv_report *report;
11409         const char *str;
11410         int i;
11411
11412         print_num_reports(evt->num_reports);
11413
11414         data += sizeof(evt->num_reports);
11415
11416         for (i = 0; i < evt->num_reports; ++i) {
11417                 report = data;
11418                 print_field("Entry %d", i);
11419                 print_ext_adv_report_evt_type("  ", report->event_type);
11420                 print_legacy_adv_report_pdu(report->event_type);
11421                 print_peer_addr_type("  Address type", report->addr_type);
11422                 print_addr("  Address", report->addr, report->addr_type);
11423
11424                 switch (report->primary_phy) {
11425                 case 0x01:
11426                         str = "LE 1M";
11427                         break;
11428                 case 0x03:
11429                         str = "LE Coded";
11430                         break;
11431                 default:
11432                         str = "Reserved";
11433                         break;
11434                 }
11435
11436                 print_field("  Primary PHY: %s", str);
11437
11438                 switch (report->secondary_phy) {
11439                 case 0x00:
11440                         str = "No packets";
11441                         break;
11442                 case 0x01:
11443                         str = "LE 1M";
11444                         break;
11445                 case 0x02:
11446                         str = "LE 2M";
11447                         break;
11448                 case 0x03:
11449                         str = "LE Coded";
11450                         break;
11451                 default:
11452                         str = "Reserved";
11453                         break;
11454                 }
11455
11456                 print_field("  Secondary PHY: %s", str);
11457
11458                 if (report->sid == 0xff)
11459                         print_field("  SID: no ADI field (0x%2.2x)",
11460                                                                 report->sid);
11461                 else if (report->sid > 0x0f)
11462                         print_field("  SID: Reserved (0x%2.2x)", report->sid);
11463                 else
11464                         print_field("  SID: 0x%2.2x", report->sid);
11465
11466                 print_field("  TX power: %d dBm", report->tx_power);
11467
11468                 if (report->rssi == 127)
11469                         print_field("  RSSI: not available (0x%2.2x)",
11470                                                         (uint8_t) report->rssi);
11471                 else if (report->rssi >= -127 && report->rssi <= 20)
11472                         print_field("  RSSI: %d dBm (0x%2.2x)",
11473                                         report->rssi, (uint8_t) report->rssi);
11474                 else
11475                         print_field("  RSSI: reserved (0x%2.2x)",
11476                                                         (uint8_t) report->rssi);
11477
11478                 print_slot_125("  Periodic advertising interval",
11479                                                         report->interval);
11480                 print_peer_addr_type("  Direct address type",
11481                                                 report->direct_addr_type);
11482                 print_addr("  Direct address", report->direct_addr,
11483                                                 report->direct_addr_type);
11484                 print_field("  Data length: 0x%2.2x", report->data_len);
11485                 data += sizeof(struct bt_hci_le_ext_adv_report);
11486                 packet_hexdump(data, report->data_len);
11487                 print_eir(data, report->data_len, true);
11488                 data += report->data_len;
11489         }
11490 }
11491
11492 static void le_pa_sync_evt(struct timeval *tv, uint16_t index,
11493                                 const void *data, uint8_t size)
11494 {
11495         const struct bt_hci_evt_le_per_sync_established *evt = data;
11496
11497         print_status(evt->status);
11498         print_field("Sync handle: %d", evt->handle);
11499         if (evt->sid > 0x0f)
11500                 print_field("Advertising SID: Reserved (0x%2.2x)", evt->sid);
11501         else
11502                 print_field("Advertising SID: 0x%2.2x", evt->sid);
11503
11504         print_peer_addr_type("Advertiser address type", evt->addr_type);
11505         print_addr("Advertiser address", evt->addr, evt->addr_type);
11506         print_le_phy("Advertiser PHY", evt->phy);
11507         print_slot_125("Periodic advertising interval", evt->interval);
11508         print_field("Advertiser clock accuracy: 0x%2.2x", evt->clock_accuracy);
11509 }
11510
11511 static void le_pa_report_evt(struct timeval *tv, uint16_t index,
11512                                 const void *data, uint8_t size)
11513 {
11514         const struct bt_hci_le_pa_report *evt = data;
11515         const char *color_on;
11516         const char *str;
11517
11518         print_field("Sync handle: %d", evt->handle);
11519         print_power_level(evt->tx_power, NULL);
11520         if (evt->rssi == 127)
11521                 print_field("RSSI: not available (0x%2.2x)",
11522                                                 (uint8_t) evt->rssi);
11523         else if (evt->rssi >= -127 && evt->rssi <= 20)
11524                 print_field("RSSI: %d dBm (0x%2.2x)",
11525                                 evt->rssi, (uint8_t) evt->rssi);
11526         else
11527                 print_field("RSSI: reserved (0x%2.2x)",
11528                                                 (uint8_t) evt->rssi);
11529
11530         switch (evt->cte_type) {
11531         case 0x00:
11532                 str = "AoA Constant Tone Extension";
11533                 break;
11534         case 0x01:
11535                 str = "AoA Constant Tone Extension with 1us slots";
11536                 break;
11537         case 0x02:
11538                 str = "AoD Constant Tone Extension with 2us slots";
11539                 break;
11540         case 0xff:
11541                 str = "No Constant Tone Extension";
11542                 break;
11543         default:
11544                 str = "Reserved";
11545                 break;
11546         }
11547
11548         print_field("CTE Type: %s (0x%2x)", str, evt->cte_type);
11549
11550         switch (evt->data_status) {
11551         case 0x00:
11552                 str = "Complete";
11553                 color_on = COLOR_GREEN;
11554                 break;
11555         case 0x01:
11556                 str = "Incomplete, more data to come";
11557                 color_on = COLOR_YELLOW;
11558                 break;
11559         case 0x02:
11560                 str = "Incomplete, data truncated, no more to come";
11561                 color_on = COLOR_RED;
11562                 break;
11563         default:
11564                 str = "Reserved";
11565                 color_on = COLOR_RED;
11566                 break;
11567         }
11568
11569         print_field("Data status: %s%s%s", color_on, str, COLOR_OFF);
11570         print_field("Data length: 0x%2.2x", evt->data_len);
11571         packet_hexdump(evt->data, evt->data_len);
11572 }
11573
11574 static void le_pa_sync_lost_evt(struct timeval *tv, uint16_t index,
11575                                         const void *data, uint8_t size)
11576 {
11577         const struct bt_hci_evt_le_per_sync_lost *evt = data;
11578
11579         print_field("Sync handle: %d", evt->handle);
11580 }
11581
11582 static void le_adv_set_term_evt(struct timeval *tv, uint16_t index,
11583                                         const void *data, uint8_t size)
11584 {
11585         const struct bt_hci_evt_le_adv_set_term *evt = data;
11586
11587         print_status(evt->status);
11588         print_field("Handle: %d", evt->handle);
11589         print_field("Connection handle: %d", evt->conn_handle);
11590         print_field("Number of completed extended advertising events: %d",
11591                         evt->num_evts);
11592 }
11593
11594 static void le_scan_req_received_evt(struct timeval *tv, uint16_t index,
11595                                         const void *data, uint8_t size)
11596 {
11597         const struct bt_hci_evt_le_scan_req_received *evt = data;
11598
11599         print_field("Handle: %d", evt->handle);
11600         print_peer_addr_type("Scanner address type", evt->scanner_addr_type);
11601         print_addr("Scanner address", evt->scanner_addr,
11602                                                         evt->scanner_addr_type);
11603 }
11604
11605 static void le_chan_select_alg_evt(struct timeval *tv, uint16_t index,
11606                                         const void *data, uint8_t size)
11607 {
11608         const struct bt_hci_evt_le_chan_select_alg *evt = data;
11609         const char *str;
11610
11611         print_handle(evt->handle);
11612
11613         switch (evt->algorithm) {
11614         case 0x00:
11615                 str = "#1";
11616                 break;
11617         case 0x01:
11618                 str = "#2";
11619                 break;
11620         default:
11621                 str = "Reserved";
11622                 break;
11623         }
11624
11625         print_field("Algorithm: %s (0x%2.2x)", str, evt->algorithm);
11626 }
11627
11628 static void le_cte_request_failed_evt(struct timeval *tv, uint16_t index,
11629                                         const void *data, uint8_t size)
11630 {
11631         const struct bt_hci_evt_le_cte_request_failed *evt = data;
11632
11633         print_status(evt->status);
11634         print_field("Connection handle: %d", evt->handle);
11635 }
11636
11637 static void le_pa_sync_trans_rec_evt(struct timeval *tv, uint16_t index,
11638                                         const void *data, uint8_t size)
11639 {
11640         const struct bt_hci_evt_le_pa_sync_trans_rec *evt = data;
11641
11642         print_status(evt->status);
11643         print_field("Handle: %d", evt->handle);
11644         print_field("Connection handle: %d", evt->handle);
11645         print_field("Service data: 0x%4.4x", evt->service_data);
11646         print_field("Sync handle: %d", evt->sync_handle);
11647         print_field("SID: 0x%2.2x", evt->sid);
11648         print_peer_addr_type("Address type:", evt->addr_type);
11649         print_addr("Address:", evt->addr, evt->addr_type);
11650         print_le_phy("PHY:", evt->phy);
11651         print_field("Periodic advertising Interval: %.3f",
11652                                                         1.25 * evt->interval);
11653         print_clock_accuracy(evt->clock_accuracy);
11654 }
11655
11656 static void le_cis_established_evt(struct timeval *tv, uint16_t index,
11657                                         const void *data, uint8_t size)
11658 {
11659         const struct bt_hci_evt_le_cis_established *evt = data;
11660
11661         print_status(evt->status);
11662         print_field("Connection Handle: %d", le16_to_cpu(evt->conn_handle));
11663         print_usec_interval("CIG Synchronization Delay", evt->cig_sync_delay);
11664         print_usec_interval("CIS Synchronization Delay", evt->cis_sync_delay);
11665         print_usec_interval("Central to Peripheral Latency", evt->c_latency);
11666         print_usec_interval("Peripheral to Central Latency", evt->p_latency);
11667         print_le_phy("Central to Peripheral PHY", evt->c_phy);
11668         print_le_phy("Peripheral to Central PHY", evt->p_phy);
11669         print_field("Number of Subevents: %u", evt->nse);
11670         print_field("Central to Peripheral Burst Number: %u", evt->c_bn);
11671         print_field("Peripheral to Central Burst Number: %u", evt->p_bn);
11672         print_field("Central to Peripheral Flush Timeout: %u", evt->c_ft);
11673         print_field("Peripheral to Central Flush Timeout: %u", evt->p_ft);
11674         print_field("Central to Peripheral MTU: %u", le16_to_cpu(evt->c_mtu));
11675         print_field("Peripheral to Central MTU: %u", le16_to_cpu(evt->p_mtu));
11676         print_slot_125("ISO Interval", evt->interval);
11677
11678         if (!evt->status)
11679                 assign_handle(index, le16_to_cpu(evt->conn_handle), 0x05,
11680                                         NULL, BDADDR_LE_PUBLIC);
11681 }
11682
11683 static void le_req_cis_evt(struct timeval *tv, uint16_t index,
11684                                         const void *data, uint8_t size)
11685 {
11686         const struct bt_hci_evt_le_cis_req *evt = data;
11687         struct packet_conn_data *conn;
11688
11689         print_field("ACL Handle: %d", le16_to_cpu(evt->acl_handle));
11690         print_field("CIS Handle: %d", le16_to_cpu(evt->cis_handle));
11691         print_field("CIG ID: 0x%2.2x", evt->cig_id);
11692         print_field("CIS ID: 0x%2.2x", evt->cis_id);
11693
11694         conn = packet_get_conn_data(evt->acl_handle);
11695         if (conn)
11696                 conn->link = evt->cis_handle;
11697 }
11698
11699 static void print_bis_handle(const void *data, int i)
11700 {
11701         uint16_t handle = get_le16(data);
11702
11703         print_field("Connection Handle #%d: %d", i, handle);
11704 }
11705
11706 static void le_big_complete_evt(struct timeval *tv, uint16_t index,
11707                                         const void *data, uint8_t size)
11708 {
11709         const struct bt_hci_evt_le_big_complete *evt = data;
11710
11711         print_status(evt->status);
11712         print_field("Handle: 0x%2.2x", evt->handle);
11713         print_usec_interval("BIG Synchronization Delay", evt->sync_delay);
11714         print_usec_interval("Transport Latency", evt->latency);
11715         print_le_phy("PHY", evt->phy);
11716         print_field("NSE: %u", evt->nse);
11717         print_field("BN: %u", evt->bn);
11718         print_field("PTO: %u", evt->pto);
11719         print_field("IRC: %u", evt->irc);
11720         print_field("Maximum PDU: %u", evt->max_pdu);
11721         print_slot_125("ISO Interval", evt->interval);
11722         print_list(evt->bis_handle, size, evt->num_bis,
11723                         sizeof(*evt->bis_handle), print_bis_handle);
11724
11725         if (!evt->status) {
11726                 int i;
11727
11728                 for (i = 0; i < evt->num_bis; i++)
11729                         assign_handle(index, le16_to_cpu(evt->bis_handle[i]),
11730                                         0x05, NULL, BDADDR_LE_PUBLIC);
11731         }
11732 }
11733
11734 static void le_big_terminate_evt(struct timeval *tv, uint16_t index,
11735                                         const void *data, uint8_t size)
11736 {
11737         const struct bt_hci_evt_le_big_terminate *evt = data;
11738
11739         print_field("BIG Handle: 0x%2.2x", evt->handle);
11740         print_reason(evt->reason);
11741 }
11742
11743 static void le_big_sync_estabilished_evt(struct timeval *tv, uint16_t index,
11744                                         const void *data, uint8_t size)
11745 {
11746         const struct bt_hci_evt_le_big_sync_estabilished *evt = data;
11747
11748         print_status(evt->status);
11749         print_field("BIG Handle: 0x%2.2x", evt->handle);
11750         print_usec_interval("Transport Latency", evt->latency);
11751         print_field("NSE: %u", evt->nse);
11752         print_field("BN: %u", evt->bn);
11753         print_field("PTO: %u", evt->bn);
11754         print_field("IRC: %u", evt->irc);
11755         print_field("Maximum PDU: %u", evt->max_pdu);
11756         print_slot_125("ISO Interval", evt->interval);
11757         print_list(evt->bis, size, evt->num_bis, sizeof(*evt->bis),
11758                                                 print_bis_handle);
11759
11760         if (!evt->status) {
11761                 int i;
11762
11763                 for (i = 0; i < evt->num_bis; i++)
11764                         assign_handle(index, le16_to_cpu(evt->bis[i]),
11765                                         0x05, NULL, BDADDR_LE_PUBLIC);
11766         }
11767 }
11768
11769 static void le_big_sync_lost_evt(struct timeval *tv, uint16_t index,
11770                                         const void *data, uint8_t size)
11771 {
11772         const struct bt_hci_evt_le_big_sync_lost *evt = data;
11773
11774         print_field("BIG Handle: 0x%2.2x", evt->big_handle);
11775         print_reason(evt->reason);
11776 }
11777
11778 static void le_req_sca_complete_evt(struct timeval *tv, uint16_t index,
11779                                         const void *data, uint8_t size)
11780 {
11781         const struct bt_hci_evt_le_req_peer_sca_complete *evt = data;
11782
11783         print_status(evt->status);
11784         print_field("Connection Handle: %d", le16_to_cpu(evt->handle));
11785         print_sca(evt->sca);
11786 }
11787
11788 static void le_big_info_evt(struct timeval *tv, uint16_t index,
11789                                         const void *data, uint8_t size)
11790 {
11791         const struct bt_hci_evt_le_big_info_adv_report *evt = data;
11792
11793         print_field("Sync Handle: 0x%4.4x", evt->sync_handle);
11794         print_field("Number BIS: %u", evt->num_bis);
11795         print_field("NSE: %u", evt->nse);
11796         print_slot_125("ISO Interval", evt->iso_interval);
11797         print_field("BN: %u", evt->bn);
11798         print_field("PTO: %u", evt->bn);
11799         print_field("IRC: %u", evt->irc);
11800         print_field("Maximum PDU: %u", evt->max_pdu);
11801         print_usec_interval("SDU Interval", evt->sdu_interval);
11802         print_field("Maximum SDU: %u", evt->max_sdu);
11803         print_le_phy("PHY", evt->phy);
11804         print_framing(evt->framing);
11805         print_field("Encryption: 0x%02x", evt->encryption);
11806 }
11807
11808 struct subevent_data {
11809         uint8_t subevent;
11810         const char *str;
11811         void (*func) (struct timeval *tv, uint16_t index, const void *data,
11812                                                         uint8_t size);
11813         uint8_t size;
11814         bool fixed;
11815 };
11816
11817 static void print_subevent(struct timeval *tv, uint16_t index,
11818                                 const struct subevent_data *subevent_data,
11819                                 const void *data, uint8_t size)
11820 {
11821         const char *subevent_color;
11822
11823         if (subevent_data->func)
11824                 subevent_color = COLOR_HCI_EVENT;
11825         else
11826                 subevent_color = COLOR_HCI_EVENT_UNKNOWN;
11827
11828         print_indent(6, subevent_color, "", subevent_data->str, COLOR_OFF,
11829                                         " (0x%2.2x)", subevent_data->subevent);
11830
11831         if (!subevent_data->func) {
11832                 packet_hexdump(data, size);
11833                 return;
11834         }
11835
11836         if (subevent_data->fixed) {
11837                 if (size != subevent_data->size) {
11838                         print_text(COLOR_ERROR, "invalid packet size");
11839                         packet_hexdump(data, size);
11840                         return;
11841                 }
11842         } else {
11843                 if (size < subevent_data->size) {
11844                         print_text(COLOR_ERROR, "too short packet");
11845                         packet_hexdump(data, size);
11846                         return;
11847                 }
11848         }
11849
11850         subevent_data->func(tv, index, data, size);
11851 }
11852
11853 static const struct subevent_data le_meta_event_table[] = {
11854         { 0x01, "LE Connection Complete",
11855                                 le_conn_complete_evt, 18, true },
11856         { 0x02, "LE Advertising Report",
11857                                 le_adv_report_evt, 1, false },
11858         { 0x03, "LE Connection Update Complete",
11859                                 le_conn_update_complete_evt, 9, true },
11860         { 0x04, "LE Read Remote Used Features",
11861                                 le_remote_features_complete_evt, 11, true },
11862         { 0x05, "LE Long Term Key Request",
11863                                 le_long_term_key_request_evt, 12, true },
11864         { 0x06, "LE Remote Connection Parameter Request",
11865                                 le_conn_param_request_evt, 10, true },
11866         { 0x07, "LE Data Length Change",
11867                                 le_data_length_change_evt, 10, true },
11868         { 0x08, "LE Read Local P-256 Public Key Complete",
11869                                 le_read_local_pk256_complete_evt, 65, true },
11870         { 0x09, "LE Generate DHKey Complete",
11871                                 le_generate_dhkey_complete_evt, 33, true },
11872         { 0x0a, "LE Enhanced Connection Complete",
11873                                 le_enhanced_conn_complete_evt, 30, true },
11874         { 0x0b, "LE Direct Advertising Report",
11875                                 le_direct_adv_report_evt, 1, false },
11876         { 0x0c, "LE PHY Update Complete",
11877                                 le_phy_update_complete_evt, 5, true},
11878         { 0x0d, "LE Extended Advertising Report",
11879                                 le_ext_adv_report_evt, 1, false},
11880         { 0x0e, "LE Periodic Advertising Sync Established",
11881                                 le_pa_sync_evt, 15, true },
11882         { 0x0f, "LE Periodic Advertising Report",
11883                                 le_pa_report_evt, 7, false},
11884         { 0x10, "LE Periodic Advertising Sync Lost",
11885                                 le_pa_sync_lost_evt, 2, true},
11886         { 0x11, "LE Scan Timeout" },
11887         { 0x12, "LE Advertising Set Terminated",
11888                                 le_adv_set_term_evt, 5, true},
11889         { 0x13, "LE Scan Request Received",
11890                                 le_scan_req_received_evt, 8, true},
11891         { 0x14, "LE Channel Selection Algorithm",
11892                                 le_chan_select_alg_evt, 3, true},
11893         { 0x17, "LE CTE Request Failed",
11894                                 le_cte_request_failed_evt, 3, true},
11895         { 0x18, "LE Periodic Advertising Sync Transfer Received",
11896                                         le_pa_sync_trans_rec_evt, 19,
11897                                         true},
11898         { BT_HCI_EVT_LE_CIS_ESTABLISHED,
11899                                 "LE Connected Isochronous Stream Established",
11900                                 le_cis_established_evt,
11901                                 sizeof(struct bt_hci_evt_le_cis_established),
11902                                 true },
11903         { BT_HCI_EVT_LE_CIS_REQ, "LE Connected Isochronous Stream Request",
11904                                 le_req_cis_evt,
11905                                 sizeof(struct bt_hci_evt_le_cis_req),
11906                                 true },
11907         { BT_HCI_EVT_LE_BIG_COMPLETE,
11908                                 "LE Broadcast Isochronous Group Complete",
11909                                 le_big_complete_evt,
11910                                 sizeof(struct bt_hci_evt_le_big_complete) },
11911         { BT_HCI_EVT_LE_BIG_TERMINATE,
11912                                 "LE Broadcast Isochronous Group Terminate",
11913                                 le_big_terminate_evt,
11914                                 sizeof(struct bt_hci_evt_le_big_terminate) },
11915         { BT_HCI_EVT_LE_BIG_SYNC_ESTABILISHED,
11916                                 "LE Broadcast Isochronous Group Sync "
11917                                 "Estabilished", le_big_sync_estabilished_evt,
11918                                 sizeof(struct bt_hci_evt_le_big_sync_lost) },
11919         { BT_HCI_EVT_LE_BIG_SYNC_LOST,
11920                                 "LE Broadcast Isochronous Group Sync Lost",
11921                                 le_big_sync_lost_evt,
11922                                 sizeof(struct bt_hci_evt_le_big_sync_lost) },
11923         { BT_HCI_EVT_LE_REQ_PEER_SCA_COMPLETE,
11924                                 "LE Request Peer SCA Complete",
11925                                 le_req_sca_complete_evt,
11926                                 sizeof(
11927                                 struct bt_hci_evt_le_req_peer_sca_complete)},
11928         { BT_HCI_EVT_LE_BIG_INFO_ADV_REPORT,
11929                 "LE Broadcast Isochronous Group Info Advertising Report",
11930                 le_big_info_evt,
11931                 sizeof(struct bt_hci_evt_le_big_info_adv_report) },
11932         { }
11933 };
11934
11935 static void le_meta_event_evt(struct timeval *tv, uint16_t index,
11936                                 const void *data, uint8_t size)
11937 {
11938         uint8_t subevent = *((const uint8_t *) data);
11939         struct subevent_data unknown;
11940         const struct subevent_data *subevent_data = &unknown;
11941         int i;
11942
11943         unknown.subevent = subevent;
11944         unknown.str = "Unknown";
11945         unknown.func = NULL;
11946         unknown.size = 0;
11947         unknown.fixed = true;
11948
11949         for (i = 0; le_meta_event_table[i].str; i++) {
11950                 if (le_meta_event_table[i].subevent == subevent) {
11951                         subevent_data = &le_meta_event_table[i];
11952                         break;
11953                 }
11954         }
11955
11956         print_subevent(tv, index, subevent_data, data + 1, size - 1);
11957 }
11958
11959 static void vendor_evt(struct timeval *tv, uint16_t index,
11960                                 const void *data, uint8_t size)
11961 {
11962         struct subevent_data vendor_data;
11963         char vendor_str[150];
11964         int consumed_size;
11965         const struct vendor_evt *vnd = current_vendor_evt(data, &consumed_size);
11966
11967         if (vnd) {
11968                 const char *str = current_vendor_evt_str();
11969
11970                 if (str) {
11971                         snprintf(vendor_str, sizeof(vendor_str),
11972                                                 "%s %s", str, vnd->str);
11973                         vendor_data.str = vendor_str;
11974                 } else
11975                         vendor_data.str = vnd->str;
11976                 vendor_data.subevent = vnd->evt;
11977                 vendor_data.func = vnd->evt_func;
11978                 vendor_data.size = vnd->evt_size;
11979                 vendor_data.fixed = vnd->evt_fixed;
11980
11981                 print_subevent(tv, index, &vendor_data, data + consumed_size,
11982                                                         size - consumed_size);
11983         } else {
11984                 uint16_t manufacturer;
11985
11986                 if (index_current < MAX_INDEX)
11987                         manufacturer = index_list[index_current].manufacturer;
11988                 else
11989                         manufacturer = fallback_manufacturer;
11990
11991                 vendor_event(manufacturer, data, size);
11992         }
11993 }
11994
11995 struct event_data {
11996         uint8_t event;
11997         const char *str;
11998         void (*func) (struct timeval *tv, uint16_t index, const void *data,
11999                                                         uint8_t size);
12000         uint8_t size;
12001         bool fixed;
12002 };
12003
12004 static const struct event_data event_table[] = {
12005         { 0x01, "Inquiry Complete",
12006                                 inquiry_complete_evt, 1, true },
12007         { 0x02, "Inquiry Result",
12008                                 inquiry_result_evt, 1, false },
12009         { 0x03, "Connect Complete",
12010                                 conn_complete_evt, 11, true },
12011         { 0x04, "Connect Request",
12012                                 conn_request_evt, 10, true },
12013         { 0x05, "Disconnect Complete",
12014                                 disconnect_complete_evt, 4, true },
12015         { 0x06, "Auth Complete",
12016                                 auth_complete_evt, 3, true },
12017         { 0x07, "Remote Name Req Complete",
12018                                 remote_name_request_complete_evt, 255, true },
12019         { 0x08, "Encryption Change",
12020                                 encrypt_change_evt, 4, true },
12021         { 0x09, "Change Connection Link Key Complete",
12022                                 change_conn_link_key_complete_evt, 3, true },
12023         { 0x0a, "Link Key Type Changed",
12024                                 link_key_type_changed_evt, 4, true },
12025         { 0x0b, "Read Remote Supported Features",
12026                                 remote_features_complete_evt, 11, true },
12027         { 0x0c, "Read Remote Version Complete",
12028                                 remote_version_complete_evt, 8, true },
12029         { 0x0d, "QoS Setup Complete",
12030                                 qos_setup_complete_evt, 21, true },
12031         { 0x0e, "Command Complete",
12032                                 cmd_complete_evt, 3, false },
12033         { 0x0f, "Command Status",
12034                                 cmd_status_evt, 4, true },
12035         { 0x10, "Hardware Error",
12036                                 hardware_error_evt, 1, true },
12037         { 0x11, "Flush Occurred",
12038                                 flush_occurred_evt, 2, true },
12039         { 0x12, "Role Change",
12040                                 role_change_evt, 8, true },
12041         { 0x13, "Number of Completed Packets",
12042                                 num_completed_packets_evt, 1, false },
12043         { 0x14, "Mode Change",
12044                                 mode_change_evt, 6, true },
12045         { 0x15, "Return Link Keys",
12046                                 return_link_keys_evt, 1, false },
12047         { 0x16, "PIN Code Request",
12048                                 pin_code_request_evt, 6, true },
12049         { 0x17, "Link Key Request",
12050                                 link_key_request_evt, 6, true },
12051         { 0x18, "Link Key Notification",
12052                                 link_key_notify_evt, 23, true },
12053         { 0x19, "Loopback Command",
12054                                 loopback_command_evt, 3, false },
12055         { 0x1a, "Data Buffer Overflow",
12056                                 data_buffer_overflow_evt, 1, true },
12057         { 0x1b, "Max Slots Change",
12058                                 max_slots_change_evt, 3, true },
12059         { 0x1c, "Read Clock Offset Complete",
12060                                 clock_offset_complete_evt, 5, true },
12061         { 0x1d, "Connection Packet Type Changed",
12062                                 conn_pkt_type_changed_evt, 5, true },
12063         { 0x1e, "QoS Violation",
12064                                 qos_violation_evt, 2, true },
12065         { 0x1f, "Page Scan Mode Change",
12066                                 pscan_mode_change_evt, 7, true },
12067         { 0x20, "Page Scan Repetition Mode Change",
12068                                 pscan_rep_mode_change_evt, 7, true },
12069         { 0x21, "Flow Specification Complete",
12070                                 flow_spec_complete_evt, 22, true },
12071         { 0x22, "Inquiry Result with RSSI",
12072                                 inquiry_result_with_rssi_evt, 1, false },
12073         { 0x23, "Read Remote Extended Features",
12074                                 remote_ext_features_complete_evt, 13, true },
12075         { 0x2c, "Synchronous Connect Complete",
12076                                 sync_conn_complete_evt, 17, true },
12077         { 0x2d, "Synchronous Connect Changed",
12078                                 sync_conn_changed_evt, 9, true },
12079         { 0x2e, "Sniff Subrating",
12080                                 sniff_subrating_evt, 11, true },
12081         { 0x2f, "Extended Inquiry Result",
12082                                 ext_inquiry_result_evt, 1, false },
12083         { 0x30, "Encryption Key Refresh Complete",
12084                                 encrypt_key_refresh_complete_evt, 3, true },
12085         { 0x31, "IO Capability Request",
12086                                 io_capability_request_evt, 6, true },
12087         { 0x32, "IO Capability Response",
12088                                 io_capability_response_evt, 9, true },
12089         { 0x33, "User Confirmation Request",
12090                                 user_confirm_request_evt, 10, true },
12091         { 0x34, "User Passkey Request",
12092                                 user_passkey_request_evt, 6, true },
12093         { 0x35, "Remote OOB Data Request",
12094                                 remote_oob_data_request_evt, 6, true },
12095         { 0x36, "Simple Pairing Complete",
12096                                 simple_pairing_complete_evt, 7, true },
12097         { 0x38, "Link Supervision Timeout Changed",
12098                                 link_supv_timeout_changed_evt, 4, true },
12099         { 0x39, "Enhanced Flush Complete",
12100                                 enhanced_flush_complete_evt, 2, true },
12101         { 0x3b, "User Passkey Notification",
12102                                 user_passkey_notify_evt, 10, true },
12103         { 0x3c, "Keypress Notification",
12104                                 keypress_notify_evt, 7, true },
12105         { 0x3d, "Remote Host Supported Features",
12106                                 remote_host_features_notify_evt, 14, true },
12107         { 0x3e, "LE Meta Event",
12108                                 le_meta_event_evt, 1, false },
12109         { 0x40, "Physical Link Complete",
12110                                 phy_link_complete_evt, 2, true },
12111         { 0x41, "Channel Selected",
12112                                 channel_selected_evt, 1, true },
12113         { 0x42, "Disconnect Physical Link Complete",
12114                                 disconn_phy_link_complete_evt, 3, true },
12115         { 0x43, "Physical Link Loss Early Warning",
12116                                 phy_link_loss_early_warning_evt, 2, true },
12117         { 0x44, "Physical Link Recovery",
12118                                 phy_link_recovery_evt, 1, true },
12119         { 0x45, "Logical Link Complete",
12120                                 logic_link_complete_evt, 5, true },
12121         { 0x46, "Disconnect Logical Link Complete",
12122                                 disconn_logic_link_complete_evt, 4, true },
12123         { 0x47, "Flow Specification Modify Complete",
12124                                 flow_spec_modify_complete_evt, 3, true },
12125         { 0x48, "Number of Completed Data Blocks",
12126                                 num_completed_data_blocks_evt, 3, false },
12127         { 0x49, "AMP Start Test" },
12128         { 0x4a, "AMP Test End" },
12129         { 0x4b, "AMP Receiver Report" },
12130         { 0x4c, "Short Range Mode Change Complete",
12131                                 short_range_mode_change_evt, 3, true },
12132         { 0x4d, "AMP Status Change",
12133                                 amp_status_change_evt, 2, true },
12134         { 0x4e, "Triggered Clock Capture",
12135                                 triggered_clock_capture_evt, 9, true },
12136         { 0x4f, "Synchronization Train Complete",
12137                                 sync_train_complete_evt, 1, true },
12138         { 0x50, "Synchronization Train Received",
12139                                 sync_train_received_evt, 29, true },
12140         { 0x51, "Connectionless Peripheral Broadcast Receive",
12141                                 peripheral_broadcast_receive_evt, 18, false },
12142         { 0x52, "Connectionless Peripheral Broadcast Timeout",
12143                                 peripheral_broadcast_timeout_evt, 7, true },
12144         { 0x53, "Truncated Page Complete",
12145                                 truncated_page_complete_evt, 7, true },
12146         { 0x54, "Peripheral Page Response Timeout",
12147                                 peripheral_page_response_timeout_evt, 0, true },
12148         { 0x55, "Connectionless Peripheral Broadcast Channel Map Change",
12149                                 channel_map_change_evt, 10, true },
12150         { 0x56, "Inquiry Response Notification",
12151                                 inquiry_response_notify_evt, 4, true },
12152         { 0x57, "Authenticated Payload Timeout Expired",
12153                                 auth_payload_timeout_expired_evt, 2, true },
12154         { 0x58, "SAM Status Change" },
12155         { 0xfe, "Testing" },
12156         { 0xff, "Vendor", vendor_evt, 0, false },
12157         { }
12158 };
12159
12160 void packet_new_index(struct timeval *tv, uint16_t index, const char *label,
12161                                 uint8_t type, uint8_t bus, const char *name)
12162 {
12163         char details[48];
12164
12165         sprintf(details, "(%s,%s,%s)", hci_typetostr(type),
12166                                         hci_bustostr(bus), name);
12167
12168         print_packet(tv, NULL, '=', index, NULL, COLOR_NEW_INDEX,
12169                                         "New Index", label, details);
12170 }
12171
12172 void packet_del_index(struct timeval *tv, uint16_t index, const char *label)
12173 {
12174         print_packet(tv, NULL, '=', index, NULL, COLOR_DEL_INDEX,
12175                                         "Delete Index", label, NULL);
12176 }
12177
12178 void packet_open_index(struct timeval *tv, uint16_t index, const char *label)
12179 {
12180         print_packet(tv, NULL, '=', index, NULL, COLOR_OPEN_INDEX,
12181                                         "Open Index", label, NULL);
12182 }
12183
12184 void packet_close_index(struct timeval *tv, uint16_t index, const char *label)
12185 {
12186         print_packet(tv, NULL, '=', index, NULL, COLOR_CLOSE_INDEX,
12187                                         "Close Index", label, NULL);
12188 }
12189
12190 void packet_index_info(struct timeval *tv, uint16_t index, const char *label,
12191                                                         uint16_t manufacturer)
12192 {
12193         char details[128];
12194
12195         sprintf(details, "(%s)", bt_compidtostr(manufacturer));
12196
12197         print_packet(tv, NULL, '=', index, NULL, COLOR_INDEX_INFO,
12198                                         "Index Info", label, details);
12199 }
12200
12201 void packet_vendor_diag(struct timeval *tv, uint16_t index,
12202                                         uint16_t manufacturer,
12203                                         const void *data, uint16_t size)
12204 {
12205         char extra_str[16];
12206
12207         sprintf(extra_str, "(len %d)", size);
12208
12209         print_packet(tv, NULL, '=', index, NULL, COLOR_VENDOR_DIAG,
12210                                         "Vendor Diagnostic", NULL, extra_str);
12211
12212         switch (manufacturer) {
12213         case 15:
12214                 broadcom_lm_diag(data, size);
12215                 break;
12216         default:
12217                 packet_hexdump(data, size);
12218                 break;
12219         }
12220 }
12221
12222 void packet_system_note(struct timeval *tv, struct ucred *cred,
12223                                         uint16_t index, const void *message)
12224 {
12225         print_packet(tv, cred, '=', index, NULL, COLOR_SYSTEM_NOTE,
12226                                         "Note", message, NULL);
12227 }
12228
12229 struct monitor_l2cap_hdr {
12230         uint16_t cid;
12231         uint16_t psm;
12232 } __attribute__((packed));
12233
12234 static void packet_decode(struct timeval *tv, struct ucred *cred, char dir,
12235                                 uint16_t index, const char *color,
12236                                 const char *label, const void *data,
12237                                 uint16_t size)
12238 {
12239         const struct monitor_l2cap_hdr *hdr = data;
12240
12241         if (size < sizeof(*hdr)) {
12242                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12243                         "Malformed User Data packet", NULL, NULL);
12244         }
12245
12246         print_packet(tv, cred, dir, index, NULL, COLOR_HCI_ACLDATA, label,
12247                                 dir == '>' ? "User Data RX" : "User Data TX",
12248                                 NULL);
12249
12250         /* Discard last byte since it just a filler */
12251         l2cap_frame(index, dir == '>', 0,
12252                         le16_to_cpu(hdr->cid), le16_to_cpu(hdr->psm),
12253                         data + sizeof(*hdr), size - (sizeof(*hdr) + 1));
12254 }
12255
12256 void packet_user_logging(struct timeval *tv, struct ucred *cred,
12257                                         uint16_t index, uint8_t priority,
12258                                         const char *ident, const void *data,
12259                                         uint16_t size)
12260 {
12261         const char *label;
12262         const char *color;
12263
12264         if (priority > priority_level)
12265                 return;
12266
12267         switch (priority) {
12268         case BTSNOOP_PRIORITY_ERR:
12269                 color = COLOR_ERROR;
12270                 break;
12271         case BTSNOOP_PRIORITY_WARNING:
12272                 color = COLOR_WARN;
12273                 break;
12274         case BTSNOOP_PRIORITY_INFO:
12275                 color = COLOR_INFO;
12276                 break;
12277         case BTSNOOP_PRIORITY_DEBUG:
12278                 color = COLOR_DEBUG;
12279                 break;
12280         default:
12281                 color = COLOR_WHITE_BG;
12282                 break;
12283         }
12284
12285         if (cred) {
12286                 label = NULL;
12287         } else {
12288                 if (ident)
12289                         label = ident;
12290                 else
12291                         label = "Message";
12292         }
12293
12294         if (ident && (ident[0] == '<' || ident[0] == '>')) {
12295                 packet_decode(tv, cred, ident[0], index, color,
12296                               label == ident ? &ident[2] : label,
12297                               data, size);
12298                 return;
12299         }
12300
12301         print_packet(tv, cred, '=', index, NULL, color, label, data, NULL);
12302 }
12303
12304 void packet_hci_command(struct timeval *tv, struct ucred *cred, uint16_t index,
12305                                         const void *data, uint16_t size)
12306 {
12307         const hci_command_hdr *hdr = data;
12308         uint16_t opcode = le16_to_cpu(hdr->opcode);
12309         uint16_t ogf = cmd_opcode_ogf(opcode);
12310         uint16_t ocf = cmd_opcode_ocf(opcode);
12311         struct opcode_data vendor_data;
12312         const struct opcode_data *opcode_data = NULL;
12313         const char *opcode_color, *opcode_str;
12314         char extra_str[25], vendor_str[150];
12315         int i;
12316
12317         if (index >= MAX_INDEX) {
12318                 print_field("Invalid index (%d).", index);
12319                 return;
12320         }
12321
12322         index_list[index].frame++;
12323
12324         if (size < HCI_COMMAND_HDR_SIZE || size > BTSNOOP_MAX_PACKET_SIZE) {
12325                 sprintf(extra_str, "(len %d)", size);
12326                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12327                         "Malformed HCI Command packet", NULL, extra_str);
12328                 return;
12329         }
12330
12331         data += HCI_COMMAND_HDR_SIZE;
12332         size -= HCI_COMMAND_HDR_SIZE;
12333
12334         for (i = 0; opcode_table[i].str; i++) {
12335                 if (opcode_table[i].opcode == opcode) {
12336                         opcode_data = &opcode_table[i];
12337                         break;
12338                 }
12339         }
12340
12341         if (opcode_data) {
12342                 if (opcode_data->cmd_func)
12343                         opcode_color = COLOR_HCI_COMMAND;
12344                 else
12345                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12346                 opcode_str = opcode_data->str;
12347         } else {
12348                 if (ogf == 0x3f) {
12349                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
12350
12351                         if (vnd) {
12352                                 const char *str = current_vendor_str(ocf);
12353
12354                                 if (str) {
12355                                         snprintf(vendor_str, sizeof(vendor_str),
12356                                                         "%s %s", str, vnd->str);
12357                                         vendor_data.str = vendor_str;
12358                                 } else
12359                                         vendor_data.str = vnd->str;
12360                                 vendor_data.cmd_func = vnd->cmd_func;
12361                                 vendor_data.cmd_size = vnd->cmd_size;
12362                                 vendor_data.cmd_fixed = vnd->cmd_fixed;
12363
12364                                 opcode_data = &vendor_data;
12365
12366                                 if (opcode_data->cmd_func)
12367                                         opcode_color = COLOR_HCI_COMMAND;
12368                                 else
12369                                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12370                                 opcode_str = opcode_data->str;
12371                         } else {
12372                                 opcode_color = COLOR_HCI_COMMAND;
12373                                 opcode_str = "Vendor";
12374                         }
12375                 } else {
12376                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12377                         opcode_str = "Unknown";
12378                 }
12379         }
12380
12381         sprintf(extra_str, "(0x%2.2x|0x%4.4x) plen %d", ogf, ocf, hdr->plen);
12382
12383         print_packet(tv, cred, '<', index, NULL, opcode_color, "HCI Command",
12384                                                         opcode_str, extra_str);
12385
12386         if (!opcode_data || !opcode_data->cmd_func) {
12387                 packet_hexdump(data, size);
12388                 return;
12389         }
12390
12391         if (size != hdr->plen) {
12392                 print_text(COLOR_ERROR, "invalid packet size (%u != %u)", size,
12393                                                                 hdr->plen);
12394                 packet_hexdump(data, size);
12395                 return;
12396         }
12397
12398         if (opcode_data->cmd_fixed) {
12399                 if (hdr->plen != opcode_data->cmd_size) {
12400                         print_text(COLOR_ERROR, "invalid packet size");
12401                         packet_hexdump(data, size);
12402                         return;
12403                 }
12404         } else {
12405                 if (hdr->plen < opcode_data->cmd_size) {
12406                         print_text(COLOR_ERROR, "too short packet");
12407                         packet_hexdump(data, size);
12408                         return;
12409                 }
12410         }
12411
12412         opcode_data->cmd_func(index, data, hdr->plen);
12413 }
12414
12415 void packet_hci_event(struct timeval *tv, struct ucred *cred, uint16_t index,
12416                                         const void *data, uint16_t size)
12417 {
12418         const hci_event_hdr *hdr = data;
12419         const struct event_data *event_data = NULL;
12420         const char *event_color, *event_str;
12421         char extra_str[25];
12422         int i;
12423
12424         if (index >= MAX_INDEX) {
12425                 print_field("Invalid index (%d).", index);
12426                 return;
12427         }
12428
12429
12430         index_list[index].frame++;
12431
12432         if (size < HCI_EVENT_HDR_SIZE) {
12433                 sprintf(extra_str, "(len %d)", size);
12434                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12435                         "Malformed HCI Event packet", NULL, extra_str);
12436                 packet_hexdump(data, size);
12437                 return;
12438         }
12439
12440         data += HCI_EVENT_HDR_SIZE;
12441         size -= HCI_EVENT_HDR_SIZE;
12442
12443         for (i = 0; event_table[i].str; i++) {
12444                 if (event_table[i].event == hdr->evt) {
12445                         event_data = &event_table[i];
12446                         break;
12447                 }
12448         }
12449
12450         if (event_data) {
12451                 if (event_data->func)
12452                         event_color = COLOR_HCI_EVENT;
12453                 else
12454                         event_color = COLOR_HCI_EVENT_UNKNOWN;
12455                 event_str = event_data->str;
12456         } else {
12457                 event_color = COLOR_HCI_EVENT_UNKNOWN;
12458                 event_str = "Unknown";
12459         }
12460
12461         sprintf(extra_str, "(0x%2.2x) plen %d", hdr->evt, hdr->plen);
12462
12463         print_packet(tv, cred, '>', index, NULL, event_color, "HCI Event",
12464                                                 event_str, extra_str);
12465
12466         if (!event_data || !event_data->func) {
12467                 packet_hexdump(data, size);
12468                 return;
12469         }
12470
12471         if (size != hdr->plen) {
12472                 print_text(COLOR_ERROR, "invalid packet size (%u != %u)", size,
12473                                                                 hdr->plen);
12474                 packet_hexdump(data, size);
12475                 return;
12476         }
12477
12478         if (event_data->fixed) {
12479                 if (hdr->plen != event_data->size) {
12480                         print_text(COLOR_ERROR, "invalid packet size");
12481                         packet_hexdump(data, size);
12482                         return;
12483                 }
12484         } else {
12485                 if (hdr->plen < event_data->size) {
12486                         print_text(COLOR_ERROR, "too short packet");
12487                         packet_hexdump(data, size);
12488                         return;
12489                 }
12490         }
12491
12492         event_data->func(tv, index, data, hdr->plen);
12493 }
12494
12495 static void packet_enqueue_tx(struct timeval *tv, uint16_t handle,
12496                                 size_t num, uint16_t len)
12497 {
12498         struct packet_conn_data *conn;
12499         struct packet_frame *frame;
12500
12501         conn = packet_get_conn_data(handle);
12502         if (!conn)
12503                 return;
12504
12505         if (!conn->tx_q)
12506                 conn->tx_q = queue_new();
12507
12508         frame = new0(struct packet_frame, 1);
12509         if (tv)
12510                 memcpy(&frame->tv, tv, sizeof(*tv));
12511         frame->num = num;
12512         frame->len = len;
12513         queue_push_tail(conn->tx_q, frame);
12514 }
12515
12516 void packet_hci_acldata(struct timeval *tv, struct ucred *cred, uint16_t index,
12517                                 bool in, const void *data, uint16_t size)
12518 {
12519         const struct bt_hci_acl_hdr *hdr = data;
12520         uint16_t handle = le16_to_cpu(hdr->handle);
12521         uint16_t dlen = le16_to_cpu(hdr->dlen);
12522         uint8_t flags = acl_flags(handle);
12523         char handle_str[16], extra_str[32];
12524
12525         if (index >= MAX_INDEX) {
12526                 print_field("Invalid index (%d).", index);
12527                 return;
12528         }
12529
12530         index_list[index].frame++;
12531
12532         if (size < HCI_ACL_HDR_SIZE) {
12533                 if (in)
12534                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12535                                 "Malformed ACL Data RX packet", NULL, NULL);
12536                 else
12537                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12538                                 "Malformed ACL Data TX packet", NULL, NULL);
12539                 packet_hexdump(data, size);
12540                 return;
12541         }
12542
12543         data += HCI_ACL_HDR_SIZE;
12544         size -= HCI_ACL_HDR_SIZE;
12545
12546         sprintf(handle_str, "Handle %d", acl_handle(handle));
12547         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, dlen);
12548
12549         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_ACLDATA,
12550                                 in ? "ACL Data RX" : "ACL Data TX",
12551                                                 handle_str, extra_str);
12552
12553         if (!in)
12554                 packet_enqueue_tx(tv, acl_handle(handle),
12555                                         index_list[index].frame, dlen);
12556
12557         if (size != dlen) {
12558                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12559                                                                 size, dlen);
12560                 packet_hexdump(data, size);
12561                 return;
12562         }
12563
12564         if (filter_mask & PACKET_FILTER_SHOW_ACL_DATA)
12565                 packet_hexdump(data, size);
12566
12567         l2cap_packet(index, in, acl_handle(handle), flags, data, size);
12568 }
12569
12570 void packet_hci_scodata(struct timeval *tv, struct ucred *cred, uint16_t index,
12571                                 bool in, const void *data, uint16_t size)
12572 {
12573         const hci_sco_hdr *hdr = data;
12574         uint16_t handle = le16_to_cpu(hdr->handle);
12575         uint8_t flags = acl_flags(handle);
12576         char handle_str[16], extra_str[32];
12577
12578         index_list[index].frame++;
12579
12580         if (size < HCI_SCO_HDR_SIZE) {
12581                 if (in)
12582                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12583                                 "Malformed SCO Data RX packet", NULL, NULL);
12584                 else
12585                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12586                                 "Malformed SCO Data TX packet", NULL, NULL);
12587                 packet_hexdump(data, size);
12588                 return;
12589         }
12590
12591         data += HCI_SCO_HDR_SIZE;
12592         size -= HCI_SCO_HDR_SIZE;
12593
12594         sprintf(handle_str, "Handle %d", acl_handle(handle));
12595         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, hdr->dlen);
12596
12597         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_SCODATA,
12598                                 in ? "SCO Data RX" : "SCO Data TX",
12599                                                 handle_str, extra_str);
12600
12601         if (!in)
12602                 packet_enqueue_tx(tv, acl_handle(handle),
12603                                         index_list[index].frame, hdr->dlen);
12604
12605         if (size != hdr->dlen) {
12606                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12607                                                         size, hdr->dlen);
12608                 packet_hexdump(data, size);
12609                 return;
12610         }
12611
12612         if (filter_mask & PACKET_FILTER_SHOW_SCO_DATA)
12613                 packet_hexdump(data, size);
12614 }
12615
12616 void packet_hci_isodata(struct timeval *tv, struct ucred *cred, uint16_t index,
12617                                 bool in, const void *data, uint16_t size)
12618 {
12619         const struct bt_hci_iso_hdr *hdr = data;
12620         uint16_t handle = le16_to_cpu(hdr->handle);
12621         uint8_t flags = acl_flags(handle);
12622         char handle_str[16], extra_str[32];
12623
12624         if (index >= MAX_INDEX) {
12625                 print_field("Invalid index (%d).", index);
12626                 return;
12627         }
12628
12629         index_list[index].frame++;
12630
12631         if (size < sizeof(*hdr)) {
12632                 if (in)
12633                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12634                                 "Malformed ISO Data RX packet", NULL, NULL);
12635                 else
12636                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12637                                 "Malformed ISO Data TX packet", NULL, NULL);
12638                 packet_hexdump(data, size);
12639                 return;
12640         }
12641
12642         data += sizeof(*hdr);
12643         size -= sizeof(*hdr);
12644
12645         sprintf(handle_str, "Handle %d", acl_handle(handle));
12646         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, hdr->dlen);
12647
12648         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_ISODATA,
12649                                 in ? "ISO Data RX" : "ISO Data TX",
12650                                                 handle_str, extra_str);
12651
12652         if (!in)
12653                 packet_enqueue_tx(tv, acl_handle(handle),
12654                                         index_list[index].frame, hdr->dlen);
12655
12656         if (size != hdr->dlen) {
12657                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12658                                                         size, hdr->dlen);
12659                 packet_hexdump(data, size);
12660                 return;
12661         }
12662
12663         if (filter_mask & PACKET_FILTER_SHOW_ISO_DATA)
12664                 packet_hexdump(data, size);
12665 }
12666
12667
12668 void packet_ctrl_open(struct timeval *tv, struct ucred *cred, uint16_t index,
12669                                         const void *data, uint16_t size)
12670 {
12671         uint32_t cookie;
12672         uint16_t format;
12673         char channel[11];
12674
12675         if (size < 6) {
12676                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12677                                 "Malformed Control Open packet", NULL, NULL);
12678                 packet_hexdump(data, size);
12679                 return;
12680         }
12681
12682         cookie = get_le32(data);
12683         format = get_le16(data + 4);
12684
12685         data += 6;
12686         size -= 6;
12687
12688         sprintf(channel, "0x%4.4x", cookie);
12689
12690         if ((format == CTRL_RAW || format == CTRL_USER || format == CTRL_MGMT)
12691                                                                 && size >= 8) {
12692                 uint8_t version;
12693                 uint16_t revision;
12694                 uint32_t flags;
12695                 uint8_t ident_len;
12696                 const char *comm;
12697                 char details[48];
12698                 const char *title;
12699
12700                 version = get_u8(data);
12701                 revision = get_le16(data + 1);
12702                 flags = get_le32(data + 3);
12703                 ident_len = get_u8(data + 7);
12704
12705                 data += 8;
12706                 size -= 8;
12707
12708                 comm = ident_len > 0 ? data : "unknown";
12709
12710                 data += ident_len;
12711                 size -= ident_len;
12712
12713                 assign_ctrl(cookie, format, comm);
12714
12715                 sprintf(details, "%sversion %u.%u",
12716                                 flags & 0x0001 ? "(privileged) " : "",
12717                                 version, revision);
12718
12719                 switch (format) {
12720                 case CTRL_RAW:
12721                         title = "RAW Open";
12722                         break;
12723                 case CTRL_USER:
12724                         title = "USER Open";
12725                         break;
12726                 case CTRL_MGMT:
12727                         title = "MGMT Open";
12728                         break;
12729                 default:
12730                         title = "Control Open";
12731                         break;
12732                 }
12733
12734                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_OPEN,
12735                                                 title, comm, details);
12736         } else {
12737                 char label[7];
12738
12739                 assign_ctrl(cookie, format, NULL);
12740
12741                 sprintf(label, "0x%4.4x", format);
12742
12743                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_OPEN,
12744                                                 "Control Open", label, NULL);
12745         }
12746
12747         packet_hexdump(data, size);
12748 }
12749
12750 void packet_ctrl_close(struct timeval *tv, struct ucred *cred, uint16_t index,
12751                                         const void *data, uint16_t size)
12752 {
12753         uint32_t cookie;
12754         uint16_t format;
12755         char channel[11], label[22];
12756         const char *title;
12757
12758         if (size < 4) {
12759                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12760                                 "Malformed Control Close packet", NULL, NULL);
12761                 packet_hexdump(data, size);
12762                 return;
12763         }
12764
12765         cookie = get_le32(data);
12766
12767         data += 4;
12768         size -= 4;
12769
12770         sprintf(channel, "0x%4.4x", cookie);
12771
12772         release_ctrl(cookie, &format, label);
12773
12774         switch (format) {
12775         case CTRL_RAW:
12776                 title = "RAW Close";
12777                 break;
12778         case CTRL_USER:
12779                 title = "USER Close";
12780                 break;
12781         case CTRL_MGMT:
12782                 title = "MGMT Close";
12783                 break;
12784         default:
12785                 sprintf(label, "0x%4.4x", format);
12786                 title = "Control Close";
12787                 break;
12788         }
12789
12790         print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
12791                                                         title, label, NULL);
12792
12793         packet_hexdump(data, size);
12794 }
12795
12796 static const struct {
12797         uint8_t status;
12798         const char *str;
12799 } mgmt_status_table[] = {
12800         { 0x00, "Success"               },
12801         { 0x01, "Unknown Command"       },
12802         { 0x02, "Not Connected"         },
12803         { 0x03, "Failed"                },
12804         { 0x04, "Connect Failed"        },
12805         { 0x05, "Authentication Failed" },
12806         { 0x06, "Not Paired"            },
12807         { 0x07, "No Resources"          },
12808         { 0x08, "Timeout"               },
12809         { 0x09, "Already Connected"     },
12810         { 0x0a, "Busy"                  },
12811         { 0x0b, "Rejected"              },
12812         { 0x0c, "Not Supported"         },
12813         { 0x0d, "Invalid Parameters"    },
12814         { 0x0e, "Disconnected"          },
12815         { 0x0f, "Not Powered"           },
12816         { 0x10, "Cancelled"             },
12817         { 0x11, "Invalid Index"         },
12818         { 0x12, "RFKilled"              },
12819         { 0x13, "Already Paired"        },
12820         { 0x14, "Permission Denied"     },
12821         { }
12822 };
12823
12824 static void mgmt_print_status(uint8_t status)
12825 {
12826         const char *str = "Unknown";
12827         const char *color_on, *color_off;
12828         bool unknown = true;
12829         int i;
12830
12831         for (i = 0; mgmt_status_table[i].str; i++) {
12832                 if (mgmt_status_table[i].status == status) {
12833                         str = mgmt_status_table[i].str;
12834                         unknown = false;
12835                         break;
12836                 }
12837         }
12838
12839         if (use_color()) {
12840                 if (status) {
12841                         if (unknown)
12842                                 color_on = COLOR_UNKNOWN_ERROR;
12843                         else
12844                                 color_on = COLOR_RED;
12845                 } else
12846                         color_on = COLOR_GREEN;
12847                 color_off = COLOR_OFF;
12848         } else {
12849                 color_on = "";
12850                 color_off = "";
12851         }
12852
12853         print_field("Status: %s%s%s (0x%2.2x)",
12854                                 color_on, str, color_off, status);
12855 }
12856
12857 static void mgmt_print_address(const uint8_t *address, uint8_t type)
12858 {
12859         switch (type) {
12860         case 0x00:
12861                 print_addr_resolve("BR/EDR Address", address, 0x00, false);
12862                 break;
12863         case 0x01:
12864                 print_addr_resolve("LE Address", address, 0x00, false);
12865                 break;
12866         case 0x02:
12867                 print_addr_resolve("LE Address", address, 0x01, false);
12868                 break;
12869         default:
12870                 print_addr_resolve("Address", address, 0xff, false);
12871                 break;
12872         }
12873 }
12874
12875 static const struct bitfield_data mgmt_address_type_table[] = {
12876         {  0, "BR/EDR"          },
12877         {  1, "LE Public"       },
12878         {  2, "LE Random"       },
12879         { }
12880 };
12881
12882 static void mgmt_print_address_type(uint8_t type)
12883 {
12884         uint8_t mask;
12885
12886         print_field("Address type: 0x%2.2x", type);
12887
12888         mask = print_bitfield(2, type, mgmt_address_type_table);
12889         if (mask)
12890                 print_text(COLOR_UNKNOWN_ADDRESS_TYPE, "  Unknown address type"
12891                                                         " (0x%2.2x)", mask);
12892 }
12893
12894 static void mgmt_print_version(uint8_t version)
12895 {
12896         packet_print_version("Version", version, NULL, 0x0000);
12897 }
12898
12899 static void mgmt_print_manufacturer(uint16_t manufacturer)
12900 {
12901         packet_print_company("Manufacturer", manufacturer);
12902 }
12903
12904 static const struct bitfield_data mgmt_options_table[] = {
12905         {  0, "External configuration"                  },
12906         {  1, "Bluetooth public address configuration"  },
12907         { }
12908 };
12909
12910 static void mgmt_print_options(const char *label, uint32_t options)
12911 {
12912         uint32_t mask;
12913
12914         print_field("%s: 0x%8.8x", label, options);
12915
12916         mask = print_bitfield(2, options, mgmt_options_table);
12917         if (mask)
12918                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Unknown options"
12919                                                         " (0x%8.8x)", mask);
12920 }
12921
12922 static const struct bitfield_data mgmt_settings_table[] = {
12923         {  0, "Powered"                 },
12924         {  1, "Connectable"             },
12925         {  2, "Fast Connectable"        },
12926         {  3, "Discoverable"            },
12927         {  4, "Bondable"                },
12928         {  5, "Link Security"           },
12929         {  6, "Secure Simple Pairing"   },
12930         {  7, "BR/EDR"                  },
12931         {  8, "High Speed"              },
12932         {  9, "Low Energy"              },
12933         { 10, "Advertising"             },
12934         { 11, "Secure Connections"      },
12935         { 12, "Debug Keys"              },
12936         { 13, "Privacy"                 },
12937         { 14, "Controller Configuration"},
12938         { 15, "Static Address"          },
12939         { 16, "PHY Configuration"       },
12940         { 17, "Wideband Speech"         },
12941         { 18, "CIS Central"             },
12942         { 19, "CIS Peripheral"          },
12943         { 20, "ISO Broadcaster"         },
12944         { 21, "Sync Receiver"           },
12945         {}
12946 };
12947
12948 static void mgmt_print_settings(const char *label, uint32_t settings)
12949 {
12950         uint32_t mask;
12951
12952         print_field("%s: 0x%8.8x", label, settings);
12953
12954         mask = print_bitfield(2, settings, mgmt_settings_table);
12955         if (mask)
12956                 print_text(COLOR_UNKNOWN_SETTINGS_BIT, "  Unknown settings"
12957                                                         " (0x%8.8x)", mask);
12958 }
12959
12960 static void mgmt_print_name(const void *data)
12961 {
12962         print_field("Name: %s", (char *) data);
12963         print_field("Short name: %s", (char *) (data + 249));
12964 }
12965
12966 static void mgmt_print_io_capability(uint8_t capability)
12967 {
12968         const char *str;
12969
12970         switch (capability) {
12971         case 0x00:
12972                 str = "DisplayOnly";
12973                 break;
12974         case 0x01:
12975                 str = "DisplayYesNo";
12976                 break;
12977         case 0x02:
12978                 str = "KeyboardOnly";
12979                 break;
12980         case 0x03:
12981                 str = "NoInputNoOutput";
12982                 break;
12983         case 0x04:
12984                 str = "KeyboardDisplay";
12985                 break;
12986         default:
12987                 str = "Reserved";
12988                 break;
12989         }
12990
12991         print_field("Capability: %s (0x%2.2x)", str, capability);
12992 }
12993
12994 static const struct bitfield_data mgmt_device_flags_table[] = {
12995         {  0, "Confirm Name"                    },
12996         {  1, "Legacy Pairing"                  },
12997         {  2, "Not Connectable"                 },
12998         {  3, "Connection Locally Initiated"    },
12999         {  4, "Name Request Failed"             },
13000         {  5, "Scan Response"                   },
13001         { }
13002 };
13003
13004 static void mgmt_print_device_flags(uint32_t flags)
13005 {
13006         uint32_t mask;
13007
13008         print_field("Flags: 0x%8.8x", flags);
13009
13010         mask = print_bitfield(2, flags, mgmt_device_flags_table);
13011         if (mask)
13012                 print_text(COLOR_UNKNOWN_DEVICE_FLAG, "  Unknown device flag"
13013                                                         " (0x%8.8x)", mask);
13014 }
13015
13016 static void mgmt_print_device_action(uint8_t action)
13017 {
13018         const char *str;
13019
13020         switch (action) {
13021         case 0x00:
13022                 str = "Background scan for device";
13023                 break;
13024         case 0x01:
13025                 str = "Allow incoming connection";
13026                 break;
13027         case 0x02:
13028                 str = "Auto-connect remote device";
13029                 break;
13030         default:
13031                 str = "Reserved";
13032                 break;
13033         }
13034
13035         print_field("Action: %s (0x%2.2x)", str, action);
13036 }
13037
13038 static const struct bitfield_data mgmt_adv_flags_table[] = {
13039         {  0, "Switch into Connectable mode"            },
13040         {  1, "Advertise as Discoverable"               },
13041         {  2, "Advertise as Limited Discoverable"       },
13042         {  3, "Add Flags field to Advertising Data"     },
13043         {  4, "Add TX Power field to Advertising Data"  },
13044         {  5, "Add Appearance field to Scan Response"   },
13045         {  6, "Add Local Name in Scan Response"         },
13046         {  7, "Advertise in 1M on Secondary channel"    },
13047         {  8, "Advertise in 2M on Secondary channel"    },
13048         {  9, "Advertise in CODED on Secondary channel" },
13049         {  10, "Support setting Tx Power"               },
13050         {  11, "Support HW offload"                     },
13051         {  12, "Use provided duration parameter"        },
13052         {  13, "Use provided timeout parameter"         },
13053         {  14, "Use provided interval parameters"       },
13054         {  15, "Use provided tx power parameter"        },
13055         {  16, "Contain Scan Response Data"             },
13056         { }
13057 };
13058 #define MGMT_ADV_PARAM_DURATION         (1 << 12)
13059 #define MGMT_ADV_PARAM_TIMEOUT          (1 << 13)
13060 #define MGMT_ADV_PARAM_INTERVALS        (1 << 14)
13061 #define MGMT_ADV_PARAM_TX_POWER         (1 << 15)
13062
13063 static void mgmt_print_adv_flags(uint32_t flags)
13064 {
13065         uint32_t mask;
13066
13067         print_field("Flags: 0x%8.8x", flags);
13068
13069         mask = print_bitfield(2, flags, mgmt_adv_flags_table);
13070         if (mask)
13071                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown advertising flag"
13072                                                         " (0x%8.8x)", mask);
13073 }
13074
13075 static void mgmt_print_store_hint(uint8_t hint)
13076 {
13077         const char *str;
13078
13079         switch (hint) {
13080         case 0x00:
13081                 str = "No";
13082                 break;
13083         case 0x01:
13084                 str = "Yes";
13085                 break;
13086         default:
13087                 str = "Reserved";
13088                 break;
13089         }
13090
13091         print_field("Store hint: %s (0x%2.2x)", str, hint);
13092 }
13093
13094 static void mgmt_print_connection_parameter(const void *data)
13095 {
13096         uint8_t address_type = get_u8(data + 6);
13097         uint16_t min_conn_interval = get_le16(data + 7);
13098         uint16_t max_conn_interval = get_le16(data + 9);
13099         uint16_t conn_latency = get_le16(data + 11);
13100         uint16_t supv_timeout = get_le16(data + 13);
13101
13102         mgmt_print_address(data, address_type);
13103         print_field("Min connection interval: %u", min_conn_interval);
13104         print_field("Max connection interval: %u", max_conn_interval);
13105         print_conn_latency("Connection latency", conn_latency);
13106         print_field("Supervision timeout: %u", supv_timeout);
13107 }
13108
13109 static void mgmt_print_link_key(const void *data)
13110 {
13111         uint8_t address_type = get_u8(data + 6);
13112         uint8_t key_type = get_u8(data + 7);
13113         uint8_t pin_len = get_u8(data + 24);
13114
13115         mgmt_print_address(data, address_type);
13116         print_key_type(key_type);
13117         print_link_key(data + 8);
13118         print_field("PIN length: %d", pin_len);
13119 }
13120
13121 static void mgmt_print_long_term_key(const void *data)
13122 {
13123         uint8_t address_type = get_u8(data + 6);
13124         uint8_t key_type = get_u8(data + 7);
13125         uint8_t central = get_u8(data + 8);
13126         uint8_t enc_size = get_u8(data + 9);
13127         const char *str;
13128
13129         mgmt_print_address(data, address_type);
13130
13131         switch (key_type) {
13132         case 0x00:
13133                 str = "Unauthenticated legacy key";
13134                 break;
13135         case 0x01:
13136                 str = "Authenticated legacy key";
13137                 break;
13138         case 0x02:
13139                 str = "Unauthenticated key from P-256";
13140                 break;
13141         case 0x03:
13142                 str = "Authenticated key from P-256";
13143                 break;
13144         case 0x04:
13145                 str = "Debug key from P-256";
13146                 break;
13147         default:
13148                 str = "Reserved";
13149                 break;
13150         }
13151
13152         print_field("Key type: %s (0x%2.2x)", str, key_type);
13153         print_field("Central: 0x%2.2x", central);
13154         print_field("Encryption size: %u", enc_size);
13155         print_hex_field("Diversifier", data + 10, 2);
13156         print_hex_field("Randomizer", data + 12, 8);
13157         print_hex_field("Key", data + 20, 16);
13158 }
13159
13160 static void mgmt_print_identity_resolving_key(const void *data)
13161 {
13162         uint8_t address_type = get_u8(data + 6);
13163
13164         mgmt_print_address(data, address_type);
13165         print_hex_field("Key", data + 7, 16);
13166         keys_add_identity(data, address_type, data + 7);
13167 }
13168
13169 static void mgmt_print_signature_resolving_key(const void *data)
13170 {
13171         uint8_t address_type = get_u8(data + 6);
13172         uint8_t key_type = get_u8(data + 7);
13173         const char *str;
13174
13175         mgmt_print_address(data, address_type);
13176
13177         switch (key_type) {
13178         case 0x00:
13179                 str = "Unauthenticated local CSRK";
13180                 break;
13181         case 0x01:
13182                 str = "Unauthenticated remote CSRK";
13183                 break;
13184         case 0x02:
13185                 str = "Authenticated local CSRK";
13186                 break;
13187         case 0x03:
13188                 str = "Authenticated remote CSRK";
13189                 break;
13190         default:
13191                 str = "Reserved";
13192                 break;
13193         }
13194
13195         print_field("Key type: %s (0x%2.2x)", str, key_type);
13196         print_hex_field("Key", data + 8, 16);
13197 }
13198
13199 static void mgmt_print_oob_data(const void *data)
13200 {
13201         print_hash_p192(data);
13202         print_randomizer_p192(data + 16);
13203         print_hash_p256(data + 32);
13204         print_randomizer_p256(data + 48);
13205 }
13206
13207 static const struct bitfield_data mgmt_exp_feature_flags_table[] = {
13208         {  0, "Active"          },
13209         {  1, "Settings change" },
13210         { }
13211 };
13212
13213 static void mgmt_print_exp_feature(const void *data)
13214 {
13215         uint32_t flags = get_le32(data + 16);
13216         uint32_t mask;
13217
13218         print_field("UUID: %s", bt_uuid128_to_str(data));
13219         print_field("Flags: 0x%8.8x", flags);
13220
13221         mask = print_bitfield(2, flags, mgmt_exp_feature_flags_table);
13222         if (mask)
13223                 print_text(COLOR_UNKNOWN_EXP_FEATURE_FLAG,
13224                                 "  Unknown feature flag (0x%8.8x)", mask);
13225 }
13226
13227 static void mgmt_null_cmd(const void *data, uint16_t size)
13228 {
13229 }
13230
13231 static void mgmt_null_rsp(const void *data, uint16_t size)
13232 {
13233 }
13234
13235 static void mgmt_read_version_info_rsp(const void *data, uint16_t size)
13236 {
13237         uint8_t version;
13238         uint16_t revision;
13239
13240         version = get_u8(data);
13241         revision = get_le16(data + 1);
13242
13243         print_field("Version: %u.%u", version, revision);
13244 }
13245
13246 static void mgmt_print_commands(const void *data, uint16_t num);
13247 static void mgmt_print_events(const void *data, uint16_t num);
13248
13249 static void mgmt_read_supported_commands_rsp(const void *data, uint16_t size)
13250 {
13251         uint16_t num_commands = get_le16(data);
13252         uint16_t num_events = get_le16(data + 2);
13253
13254         if (size - 4 != (num_commands * 2) + (num_events *2)) {
13255                 packet_hexdump(data, size);
13256                 return;
13257         }
13258
13259         mgmt_print_commands(data + 4, num_commands);
13260         mgmt_print_events(data + 4 + num_commands * 2, num_events);
13261 }
13262
13263 static void mgmt_read_index_list_rsp(const void *data, uint16_t size)
13264 {
13265         uint16_t num_controllers = get_le16(data);
13266         int i;
13267
13268         print_field("Controllers: %u", num_controllers);
13269
13270         if (size - 2 != num_controllers * 2) {
13271                 packet_hexdump(data + 2, size - 2);
13272                 return;
13273         }
13274
13275         for (i = 0; i < num_controllers; i++) {
13276                 uint16_t index = get_le16(data + 2 + (i * 2));
13277
13278                 print_field("  hci%u", index);
13279         }
13280 }
13281
13282 static void mgmt_read_controller_info_rsp(const void *data, uint16_t size)
13283 {
13284         uint8_t version = get_u8(data + 6);
13285         uint16_t manufacturer = get_le16(data + 7);
13286         uint32_t supported_settings = get_le32(data + 9);
13287         uint32_t current_settings = get_le32(data + 13);
13288
13289         print_addr_resolve("Address", data, 0x00, false);
13290         mgmt_print_version(version);
13291         mgmt_print_manufacturer(manufacturer);
13292         mgmt_print_settings("Supported settings", supported_settings);
13293         mgmt_print_settings("Current settings", current_settings);
13294         print_dev_class(data + 17);
13295         mgmt_print_name(data + 20);
13296 }
13297
13298 static void mgmt_set_powered_cmd(const void *data, uint16_t size)
13299 {
13300         uint8_t enable = get_u8(data);
13301
13302         print_enable("Powered", enable);
13303 }
13304
13305 static void mgmt_set_discoverable_cmd(const void *data, uint16_t size)
13306 {
13307         uint8_t enable = get_u8(data);
13308         uint16_t timeout = get_le16(data + 1);
13309         const char *str;
13310
13311         switch (enable) {
13312         case 0x00:
13313                 str = "Disabled";
13314                 break;
13315         case 0x01:
13316                 str = "General";
13317                 break;
13318         case 0x02:
13319                 str = "Limited";
13320                 break;
13321         default:
13322                 str = "Reserved";
13323                 break;
13324         }
13325
13326         print_field("Discoverable: %s (0x%2.2x)", str, enable);
13327         print_field("Timeout: %u", timeout);
13328 }
13329
13330 static void mgmt_set_connectable_cmd(const void *data, uint16_t size)
13331 {
13332         uint8_t enable = get_u8(data);
13333
13334         print_enable("Connectable", enable);
13335 }
13336
13337 static void mgmt_set_fast_connectable_cmd(const void *data, uint16_t size)
13338 {
13339         uint8_t enable = get_u8(data);
13340
13341         print_enable("Fast Connectable", enable);
13342 }
13343
13344 static void mgmt_set_bondable_cmd(const void *data, uint16_t size)
13345 {
13346         uint8_t enable = get_u8(data);
13347
13348         print_enable("Bondable", enable);
13349 }
13350
13351 static void mgmt_set_link_security_cmd(const void *data, uint16_t size)
13352 {
13353         uint8_t enable = get_u8(data);
13354
13355         print_enable("Link Security", enable);
13356 }
13357
13358 static void mgmt_set_secure_simple_pairing_cmd(const void *data, uint16_t size)
13359 {
13360         uint8_t enable = get_u8(data);
13361
13362         print_enable("Secure Simple Pairing", enable);
13363 }
13364
13365 static void mgmt_set_high_speed_cmd(const void *data, uint16_t size)
13366 {
13367         uint8_t enable = get_u8(data);
13368
13369         print_enable("High Speed", enable);
13370 }
13371
13372 static void mgmt_set_low_energy_cmd(const void *data, uint16_t size)
13373 {
13374         uint8_t enable = get_u8(data);
13375
13376         print_enable("Low Energy", enable);
13377 }
13378
13379 static void mgmt_new_settings_rsp(const void *data, uint16_t size)
13380 {
13381         uint32_t current_settings = get_le32(data);
13382
13383         mgmt_print_settings("Current settings", current_settings);
13384 }
13385
13386 static void mgmt_set_device_class_cmd(const void *data, uint16_t size)
13387 {
13388         uint8_t major = get_u8(data);
13389         uint8_t minor = get_u8(data + 1);
13390
13391         print_field("Major class: 0x%2.2x", major);
13392         print_field("Minor class: 0x%2.2x", minor);
13393 }
13394
13395 static void mgmt_set_device_class_rsp(const void *data, uint16_t size)
13396 {
13397         print_dev_class(data);
13398 }
13399
13400 static void mgmt_set_local_name_cmd(const void *data, uint16_t size)
13401 {
13402         mgmt_print_name(data);
13403 }
13404
13405 static void mgmt_set_local_name_rsp(const void *data, uint16_t size)
13406 {
13407         mgmt_print_name(data);
13408 }
13409
13410 static void mgmt_add_uuid_cmd(const void *data, uint16_t size)
13411 {
13412         uint8_t service_class = get_u8(data + 16);
13413
13414         print_field("UUID: %s", bt_uuid128_to_str(data));
13415         print_field("Service class: 0x%2.2x", service_class);
13416 }
13417
13418 static void mgmt_add_uuid_rsp(const void *data, uint16_t size)
13419 {
13420         print_dev_class(data);
13421 }
13422
13423 static void mgmt_remove_uuid_cmd(const void *data, uint16_t size)
13424 {
13425         print_field("UUID: %s", bt_uuid128_to_str(data));
13426 }
13427
13428 static void mgmt_remove_uuid_rsp(const void *data, uint16_t size)
13429 {
13430         print_dev_class(data);
13431 }
13432
13433 static void mgmt_load_link_keys_cmd(const void *data, uint16_t size)
13434 {
13435         uint8_t debug_keys = get_u8(data);
13436         uint16_t num_keys = get_le16(data + 1);
13437         int i;
13438
13439         print_enable("Debug keys", debug_keys);
13440         print_field("Keys: %u", num_keys);
13441
13442         if (size - 3 != num_keys * 25) {
13443                 packet_hexdump(data + 3, size - 3);
13444                 return;
13445         }
13446
13447         for (i = 0; i < num_keys; i++)
13448                 mgmt_print_link_key(data + 3 + (i * 25));
13449 }
13450
13451 static void mgmt_load_long_term_keys_cmd(const void *data, uint16_t size)
13452 {
13453         uint16_t num_keys = get_le16(data);
13454         int i;
13455
13456         print_field("Keys: %u", num_keys);
13457
13458         if (size - 2 != num_keys * 36) {
13459                 packet_hexdump(data + 2, size - 2);
13460                 return;
13461         }
13462
13463         for (i = 0; i < num_keys; i++)
13464                 mgmt_print_long_term_key(data + 2 + (i * 36));
13465 }
13466
13467 static void mgmt_disconnect_cmd(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_disconnect_rsp(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_get_connections_rsp(const void *data, uint16_t size)
13482 {
13483         uint16_t num_connections = get_le16(data);
13484         int i;
13485
13486         print_field("Connections: %u", num_connections);
13487
13488         if (size - 2 != num_connections * 7) {
13489                 packet_hexdump(data + 2, size - 2);
13490                 return;
13491         }
13492
13493         for (i = 0; i < num_connections; i++) {
13494                 uint8_t address_type = get_u8(data + 2 + (i * 7) + 6);
13495
13496                 mgmt_print_address(data + 2 + (i * 7), address_type);
13497         }
13498 }
13499
13500 static void mgmt_pin_code_reply_cmd(const void *data, uint16_t size)
13501 {
13502         uint8_t address_type = get_u8(data + 6);
13503         uint8_t pin_len = get_u8(data + 7);
13504
13505         mgmt_print_address(data, address_type);
13506         print_field("PIN length: %u", pin_len);
13507         print_hex_field("PIN code", data + 8, 16);
13508 }
13509
13510 static void mgmt_pin_code_reply_rsp(const void *data, uint16_t size)
13511 {
13512         uint8_t address_type = get_u8(data + 6);
13513
13514         mgmt_print_address(data, address_type);
13515 }
13516
13517 static void mgmt_pin_code_neg_reply_cmd(const void *data, uint16_t size)
13518 {
13519         uint8_t address_type = get_u8(data + 6);
13520
13521         mgmt_print_address(data, address_type);
13522 }
13523
13524 static void mgmt_pin_code_neg_reply_rsp(const void *data, uint16_t size)
13525 {
13526         uint8_t address_type = get_u8(data + 6);
13527
13528         mgmt_print_address(data, address_type);
13529 }
13530
13531 static void mgmt_set_io_capability_cmd(const void *data, uint16_t size)
13532 {
13533         uint8_t capability = get_u8(data);
13534
13535         mgmt_print_io_capability(capability);
13536 }
13537
13538 static void mgmt_pair_device_cmd(const void *data, uint16_t size)
13539 {
13540         uint8_t address_type = get_u8(data + 6);
13541         uint8_t capability = get_u8(data + 7);
13542
13543         mgmt_print_address(data, address_type);
13544         mgmt_print_io_capability(capability);
13545 }
13546
13547 static void mgmt_pair_device_rsp(const void *data, uint16_t size)
13548 {
13549         uint8_t address_type = get_u8(data + 6);
13550
13551         mgmt_print_address(data, address_type);
13552 }
13553
13554 static void mgmt_cancel_pair_device_cmd(const void *data, uint16_t size)
13555 {
13556         uint8_t address_type = get_u8(data + 6);
13557
13558         mgmt_print_address(data, address_type);
13559 }
13560
13561 static void mgmt_cancel_pair_device_rsp(const void *data, uint16_t size)
13562 {
13563         uint8_t address_type = get_u8(data + 6);
13564
13565         mgmt_print_address(data, address_type);
13566 }
13567
13568 static void mgmt_unpair_device_cmd(const void *data, uint16_t size)
13569 {
13570         uint8_t address_type = get_u8(data + 6);
13571         uint8_t disconnect = get_u8(data + 7);
13572
13573         mgmt_print_address(data, address_type);
13574         print_enable("Disconnect", disconnect);
13575 }
13576
13577 static void mgmt_unpair_device_rsp(const void *data, uint16_t size)
13578 {
13579         uint8_t address_type = get_u8(data + 6);
13580
13581         mgmt_print_address(data, address_type);
13582 }
13583
13584 static void mgmt_user_confirmation_reply_cmd(const void *data, uint16_t size)
13585 {
13586         uint8_t address_type = get_u8(data + 6);
13587
13588         mgmt_print_address(data, address_type);
13589 }
13590
13591 static void mgmt_user_confirmation_reply_rsp(const void *data, uint16_t size)
13592 {
13593         uint8_t address_type = get_u8(data + 6);
13594
13595         mgmt_print_address(data, address_type);
13596 }
13597
13598 static void mgmt_user_confirmation_neg_reply_cmd(const void *data, uint16_t size)
13599 {
13600         uint8_t address_type = get_u8(data + 6);
13601
13602         mgmt_print_address(data, address_type);
13603 }
13604
13605 static void mgmt_user_confirmation_neg_reply_rsp(const void *data, uint16_t size)
13606 {
13607         uint8_t address_type = get_u8(data + 6);
13608
13609         mgmt_print_address(data, address_type);
13610 }
13611
13612 static void mgmt_user_passkey_reply_cmd(const void *data, uint16_t size)
13613 {
13614         uint8_t address_type = get_u8(data + 6);
13615         uint32_t passkey = get_le32(data + 7);
13616
13617         mgmt_print_address(data, address_type);
13618         print_field("Passkey: 0x%4.4x", passkey);
13619 }
13620
13621 static void mgmt_user_passkey_reply_rsp(const void *data, uint16_t size)
13622 {
13623         uint8_t address_type = get_u8(data + 6);
13624
13625         mgmt_print_address(data, address_type);
13626 }
13627
13628 static void mgmt_user_passkey_neg_reply_cmd(const void *data, uint16_t size)
13629 {
13630         uint8_t address_type = get_u8(data + 6);
13631
13632         mgmt_print_address(data, address_type);
13633 }
13634
13635 static void mgmt_user_passkey_neg_reply_rsp(const void *data, uint16_t size)
13636 {
13637         uint8_t address_type = get_u8(data + 6);
13638
13639         mgmt_print_address(data, address_type);
13640 }
13641
13642 static void mgmt_read_local_oob_data_rsp(const void *data, uint16_t size)
13643 {
13644         mgmt_print_oob_data(data);
13645 }
13646
13647 static void mgmt_add_remote_oob_data_cmd(const void *data, uint16_t size)
13648 {
13649         uint8_t address_type = get_u8(data + 6);
13650
13651         mgmt_print_address(data, address_type);
13652         mgmt_print_oob_data(data + 7);
13653 }
13654
13655 static void mgmt_add_remote_oob_data_rsp(const void *data, uint16_t size)
13656 {
13657         uint8_t address_type = get_u8(data + 6);
13658
13659         mgmt_print_address(data, address_type);
13660 }
13661
13662 static void mgmt_remove_remote_oob_data_cmd(const void *data, uint16_t size)
13663 {
13664         uint8_t address_type = get_u8(data + 6);
13665
13666         mgmt_print_address(data, address_type);
13667 }
13668
13669 static void mgmt_remove_remote_oob_data_rsp(const void *data, uint16_t size)
13670 {
13671         uint8_t address_type = get_u8(data + 6);
13672
13673         mgmt_print_address(data, address_type);
13674 }
13675
13676 static void mgmt_start_discovery_cmd(const void *data, uint16_t size)
13677 {
13678         uint8_t type = get_u8(data);
13679
13680         mgmt_print_address_type(type);
13681 }
13682
13683 static void mgmt_start_discovery_rsp(const void *data, uint16_t size)
13684 {
13685         uint8_t type = get_u8(data);
13686
13687         mgmt_print_address_type(type);
13688 }
13689
13690 static void mgmt_stop_discovery_cmd(const void *data, uint16_t size)
13691 {
13692         uint8_t type = get_u8(data);
13693
13694         mgmt_print_address_type(type);
13695 }
13696
13697 static void mgmt_stop_discovery_rsp(const void *data, uint16_t size)
13698 {
13699         uint8_t type = get_u8(data);
13700
13701         mgmt_print_address_type(type);
13702 }
13703
13704 static void mgmt_confirm_name_cmd(const void *data, uint16_t size)
13705 {
13706         uint8_t address_type = get_u8(data + 6);
13707         uint8_t name_known = get_u8(data + 7);
13708         const char *str;
13709
13710         mgmt_print_address(data, address_type);
13711
13712         switch (name_known) {
13713         case 0x00:
13714                 str = "No";
13715                 break;
13716         case 0x01:
13717                 str = "Yes";
13718                 break;
13719         default:
13720                 str = "Reserved";
13721                 break;
13722         }
13723
13724         print_field("Name known: %s (0x%2.2x)", str, name_known);
13725 }
13726
13727 static void mgmt_confirm_name_rsp(const void *data, uint16_t size)
13728 {
13729         uint8_t address_type = get_u8(data + 6);
13730
13731         mgmt_print_address(data, address_type);
13732 }
13733
13734 static void mgmt_block_device_cmd(const void *data, uint16_t size)
13735 {
13736         uint8_t address_type = get_u8(data + 6);
13737
13738         mgmt_print_address(data, address_type);
13739 }
13740
13741 static void mgmt_block_device_rsp(const void *data, uint16_t size)
13742 {
13743         uint8_t address_type = get_u8(data + 6);
13744
13745         mgmt_print_address(data, address_type);
13746 }
13747
13748 static void mgmt_unblock_device_cmd(const void *data, uint16_t size)
13749 {
13750         uint8_t address_type = get_u8(data + 6);
13751
13752         mgmt_print_address(data, address_type);
13753 }
13754
13755 static void mgmt_unblock_device_rsp(const void *data, uint16_t size)
13756 {
13757         uint8_t address_type = get_u8(data + 6);
13758
13759         mgmt_print_address(data, address_type);
13760 }
13761
13762 static void mgmt_set_device_id_cmd(const void *data, uint16_t size)
13763 {
13764         print_device_id(data, size);
13765 }
13766
13767 static void mgmt_set_advertising_cmd(const void *data, uint16_t size)
13768 {
13769         uint8_t enable = get_u8(data);
13770         const char *str;
13771
13772         switch (enable) {
13773         case 0x00:
13774                 str = "Disabled";
13775                 break;
13776         case 0x01:
13777                 str = "Enabled";
13778                 break;
13779         case 0x02:
13780                 str = "Connectable";
13781                 break;
13782         default:
13783                 str = "Reserved";
13784                 break;
13785         }
13786
13787         print_field("Advertising: %s (0x%2.2x)", str, enable);
13788 }
13789
13790 static void mgmt_set_bredr_cmd(const void *data, uint16_t size)
13791 {
13792         uint8_t enable = get_u8(data);
13793
13794         print_enable("BR/EDR", enable);
13795 }
13796
13797 static void mgmt_set_static_address_cmd(const void *data, uint16_t size)
13798 {
13799         print_addr_resolve("Address", data, 0x01, false);
13800 }
13801
13802 static void mgmt_set_scan_parameters_cmd(const void *data, uint16_t size)
13803 {
13804         uint16_t interval = get_le16(data);
13805         uint16_t window = get_le16(data + 2);
13806
13807         print_field("Interval: %u (0x%2.2x)", interval, interval);
13808         print_field("Window: %u (0x%2.2x)", window, window);
13809 }
13810
13811 static void mgmt_set_secure_connections_cmd(const void *data, uint16_t size)
13812 {
13813         uint8_t enable = get_u8(data);
13814         const char *str;
13815
13816         switch (enable) {
13817         case 0x00:
13818                 str = "Disabled";
13819                 break;
13820         case 0x01:
13821                 str = "Enabled";
13822                 break;
13823         case 0x02:
13824                 str = "Only";
13825                 break;
13826         default:
13827                 str = "Reserved";
13828                 break;
13829         }
13830
13831         print_field("Secure Connections: %s (0x%2.2x)", str, enable);
13832 }
13833
13834 static void mgmt_set_debug_keys_cmd(const void *data, uint16_t size)
13835 {
13836         uint8_t enable = get_u8(data);
13837         const char *str;
13838
13839         switch (enable) {
13840         case 0x00:
13841                 str = "Disabled";
13842                 break;
13843         case 0x01:
13844                 str = "Enabled";
13845                 break;
13846         case 0x02:
13847                 str = "Generate";
13848                 break;
13849         default:
13850                 str = "Reserved";
13851                 break;
13852         }
13853
13854         print_field("Debug Keys: %s (0x%2.2x)", str, enable);
13855 }
13856
13857 static void mgmt_set_privacy_cmd(const void *data, uint16_t size)
13858 {
13859         uint8_t enable = get_u8(data);
13860         const char *str;
13861
13862         switch (enable) {
13863         case 0x00:
13864                 str = "Disabled";
13865                 break;
13866         case 0x01:
13867                 str = "Enabled";
13868                 break;
13869         case 0x02:
13870                 str = "Limited";
13871                 break;
13872         default:
13873                 str = "Reserved";
13874                 break;
13875         }
13876
13877         print_field("Privacy: %s (0x%2.2x)", str, enable);
13878         print_hex_field("Key", data + 1, 16);
13879 }
13880
13881 static void mgmt_load_identity_resolving_keys_cmd(const void *data, uint16_t size)
13882 {
13883         uint16_t num_keys = get_le16(data);
13884         int i;
13885
13886         print_field("Keys: %u", num_keys);
13887
13888         if (size - 2 != num_keys * 23) {
13889                 packet_hexdump(data + 2, size - 2);
13890                 return;
13891         }
13892
13893         for (i = 0; i < num_keys; i++)
13894                 mgmt_print_identity_resolving_key(data + 2 + (i * 23));
13895 }
13896
13897 static void mgmt_get_connection_information_cmd(const void *data, uint16_t size)
13898 {
13899         uint8_t address_type = get_u8(data + 6);
13900
13901         mgmt_print_address(data, address_type);
13902 }
13903
13904 static void mgmt_get_connection_information_rsp(const void *data, uint16_t size)
13905 {
13906         uint8_t address_type = get_u8(data + 6);
13907         int8_t rssi = get_s8(data + 7);
13908         int8_t tx_power = get_s8(data + 8);
13909         int8_t max_tx_power = get_s8(data + 9);
13910
13911         mgmt_print_address(data, address_type);
13912         print_rssi(rssi);
13913         print_power_level(tx_power, NULL);
13914         print_power_level(max_tx_power, "max");
13915 }
13916
13917 static void mgmt_get_clock_information_cmd(const void *data, uint16_t size)
13918 {
13919         uint8_t address_type = get_u8(data + 6);
13920
13921         mgmt_print_address(data, address_type);
13922 }
13923
13924 static void mgmt_get_clock_information_rsp(const void *data, uint16_t size)
13925 {
13926         uint8_t address_type = get_u8(data + 6);
13927         uint32_t local_clock = get_le32(data + 7);
13928         uint32_t piconet_clock = get_le32(data + 11);
13929         uint16_t accuracy = get_le16(data + 15);
13930
13931         mgmt_print_address(data, address_type);
13932         print_field("Local clock: 0x%8.8x", local_clock);
13933         print_field("Piconet clock: 0x%8.8x", piconet_clock);
13934         print_field("Accuracy: 0x%4.4x", accuracy);
13935 }
13936
13937 static void mgmt_add_device_cmd(const void *data, uint16_t size)
13938 {
13939         uint8_t address_type = get_u8(data + 6);
13940         uint8_t action = get_u8(data + 7);
13941
13942         mgmt_print_address(data, address_type);
13943         mgmt_print_device_action(action);
13944 }
13945
13946 static void mgmt_add_device_rsp(const void *data, uint16_t size)
13947 {
13948         uint8_t address_type = get_u8(data + 6);
13949
13950         mgmt_print_address(data, address_type);
13951 }
13952
13953 static void mgmt_remove_device_cmd(const void *data, uint16_t size)
13954 {
13955         uint8_t address_type = get_u8(data + 6);
13956
13957         mgmt_print_address(data, address_type);
13958 }
13959
13960 static void mgmt_remove_device_rsp(const void *data, uint16_t size)
13961 {
13962         uint8_t address_type = get_u8(data + 6);
13963
13964         mgmt_print_address(data, address_type);
13965 }
13966
13967 static void mgmt_load_connection_parameters_cmd(const void *data, uint16_t size)
13968 {
13969         uint16_t num_parameters = get_le16(data);
13970         int i;
13971
13972         print_field("Parameters: %u", num_parameters);
13973
13974         if (size - 2 != num_parameters * 15) {
13975                 packet_hexdump(data + 2, size - 2);
13976                 return;
13977         }
13978
13979         for (i = 0; i < num_parameters; i++)
13980                 mgmt_print_connection_parameter(data + 2 + (i * 15));
13981 }
13982
13983 static void mgmt_read_unconf_index_list_rsp(const void *data, uint16_t size)
13984 {
13985         uint16_t num_controllers = get_le16(data);
13986         int i;
13987
13988         print_field("Controllers: %u", num_controllers);
13989
13990         if (size - 2 != num_controllers * 2) {
13991                 packet_hexdump(data + 2, size - 2);
13992                 return;
13993         }
13994
13995         for (i = 0; i < num_controllers; i++) {
13996                 uint16_t index = get_le16(data + 2 + (i * 2));
13997
13998                 print_field("  hci%u", index);
13999         }
14000 }
14001
14002 static void mgmt_read_controller_conf_info_rsp(const void *data, uint16_t size)
14003 {
14004         uint16_t manufacturer = get_le16(data);
14005         uint32_t supported_options = get_le32(data + 2);
14006         uint32_t missing_options = get_le32(data + 6);
14007
14008         mgmt_print_manufacturer(manufacturer);
14009         mgmt_print_options("Supported options", supported_options);
14010         mgmt_print_options("Missing options", missing_options);
14011 }
14012
14013 static void mgmt_set_external_configuration_cmd(const void *data, uint16_t size)
14014 {
14015         uint8_t enable = get_u8(data);
14016
14017         print_enable("Configuration", enable);
14018 }
14019
14020 static void mgmt_set_public_address_cmd(const void *data, uint16_t size)
14021 {
14022         print_addr_resolve("Address", data, 0x00, false);
14023 }
14024
14025 static void mgmt_new_options_rsp(const void *data, uint16_t size)
14026 {
14027         uint32_t missing_options = get_le32(data);
14028
14029         mgmt_print_options("Missing options", missing_options);
14030 }
14031
14032 static void mgmt_start_service_discovery_cmd(const void *data, uint16_t size)
14033 {
14034         uint8_t type = get_u8(data);
14035         int8_t rssi = get_s8(data + 1);
14036         uint16_t num_uuids = get_le16(data + 2);
14037         int i;
14038
14039         mgmt_print_address_type(type);
14040         print_rssi(rssi);
14041         print_field("UUIDs: %u", num_uuids);
14042
14043         if (size - 4 != num_uuids * 16) {
14044                 packet_hexdump(data + 4, size - 4);
14045                 return;
14046         }
14047
14048         for (i = 0; i < num_uuids; i++)
14049                 print_field("UUID: %s", bt_uuid128_to_str(data + 4 + (i * 16)));
14050 }
14051
14052 static void mgmt_start_service_discovery_rsp(const void *data, uint16_t size)
14053 {
14054         uint8_t type = get_u8(data);
14055
14056         mgmt_print_address_type(type);
14057 }
14058
14059 static void mgmt_read_ext_index_list_rsp(const void *data, uint16_t size)
14060 {
14061         uint16_t num_controllers = get_le16(data);
14062         int i;
14063
14064         print_field("Controllers: %u", num_controllers);
14065
14066         if (size - 2 != num_controllers * 4) {
14067                 packet_hexdump(data + 2, size - 2);
14068                 return;
14069         }
14070
14071         for (i = 0; i < num_controllers; i++) {
14072                 uint16_t index = get_le16(data + 2 + (i * 4));
14073                 uint8_t type = get_u8(data + 4 + (i * 4));
14074                 uint8_t bus = get_u8(data + 5 + (i * 4));
14075                 const char *str;
14076
14077                 switch (type) {
14078                 case 0x00:
14079                         str = "Primary";
14080                         break;
14081                 case 0x01:
14082                         str = "Unconfigured";
14083                         break;
14084                 case 0x02:
14085                         str = "AMP";
14086                         break;
14087                 default:
14088                         str = "Reserved";
14089                         break;
14090                 }
14091
14092                 print_field("  hci%u (%s,%s)", index, str, hci_bustostr(bus));
14093         }
14094 }
14095
14096 static void mgmt_read_local_oob_ext_data_cmd(const void *data, uint16_t size)
14097 {
14098         uint8_t type = get_u8(data);
14099
14100         mgmt_print_address_type(type);
14101 }
14102
14103 static void mgmt_read_local_oob_ext_data_rsp(const void *data, uint16_t size)
14104 {
14105         uint8_t type = get_u8(data);
14106         uint16_t data_len = get_le16(data + 1);
14107
14108         mgmt_print_address_type(type);
14109         print_field("Data length: %u", data_len);
14110         print_eir(data + 3, size - 3, true);
14111 }
14112
14113 static void mgmt_read_advertising_features_rsp(const void *data, uint16_t size)
14114 {
14115         uint32_t flags = get_le32(data);
14116         uint8_t adv_data_len = get_u8(data + 4);
14117         uint8_t scan_rsp_len = get_u8(data + 5);
14118         uint8_t max_instances = get_u8(data + 6);
14119         uint8_t num_instances = get_u8(data + 7);
14120         int i;
14121
14122         mgmt_print_adv_flags(flags);
14123         print_field("Advertising data length: %u", adv_data_len);
14124         print_field("Scan response length: %u", scan_rsp_len);
14125         print_field("Max instances: %u", max_instances);
14126         print_field("Instances: %u", num_instances);
14127
14128         if (size - 8 != num_instances) {
14129                 packet_hexdump(data + 8, size - 8);
14130                 return;
14131         }
14132
14133         for (i = 0; i < num_instances; i++) {
14134                 uint8_t instance = get_u8(data + 8 + i);
14135
14136                 print_field("  %u", instance);
14137         }
14138 }
14139
14140 static void mgmt_add_advertising_cmd(const void *data, uint16_t size)
14141 {
14142         uint8_t instance = get_u8(data);
14143         uint32_t flags = get_le32(data + 1);
14144         uint16_t duration = get_le16(data + 5);
14145         uint16_t timeout = get_le16(data + 7);
14146         uint8_t adv_data_len = get_u8(data + 9);
14147         uint8_t scan_rsp_len = get_u8(data + 10);
14148
14149         print_field("Instance: %u", instance);
14150         mgmt_print_adv_flags(flags);
14151         print_field("Duration: %u", duration);
14152         print_field("Timeout: %u", timeout);
14153         print_field("Advertising data length: %u", adv_data_len);
14154         print_eir(data + 11, adv_data_len, false);
14155         print_field("Scan response length: %u", scan_rsp_len);
14156         print_eir(data + 11 + adv_data_len, scan_rsp_len, false);
14157 }
14158
14159 static void mgmt_add_advertising_rsp(const void *data, uint16_t size)
14160 {
14161         uint8_t instance = get_u8(data);
14162
14163         print_field("Instance: %u", instance);
14164 }
14165
14166 static void mgmt_remove_advertising_cmd(const void *data, uint16_t size)
14167 {
14168         uint8_t instance = get_u8(data);
14169
14170         print_field("Instance: %u", instance);
14171 }
14172
14173 static void mgmt_remove_advertising_rsp(const void *data, uint16_t size)
14174 {
14175         uint8_t instance = get_u8(data);
14176
14177         print_field("Instance: %u", instance);
14178 }
14179
14180 static void mgmt_get_advertising_size_info_cmd(const void *data, uint16_t size)
14181 {
14182         uint8_t instance = get_u8(data);
14183         uint32_t flags = get_le32(data + 1);
14184
14185         print_field("Instance: %u", instance);
14186         mgmt_print_adv_flags(flags);
14187 }
14188
14189 static void mgmt_get_advertising_size_info_rsp(const void *data, uint16_t size)
14190 {
14191         uint8_t instance = get_u8(data);
14192         uint32_t flags = get_le32(data + 1);
14193         uint8_t adv_data_len = get_u8(data + 5);
14194         uint8_t scan_rsp_len = get_u8(data + 6);
14195
14196         print_field("Instance: %u", instance);
14197         mgmt_print_adv_flags(flags);
14198         print_field("Advertising data length: %u", adv_data_len);
14199         print_field("Scan response length: %u", scan_rsp_len);
14200 }
14201
14202 static void mgmt_start_limited_discovery_cmd(const void *data, uint16_t size)
14203 {
14204         uint8_t type = get_u8(data);
14205
14206         mgmt_print_address_type(type);
14207 }
14208
14209 static void mgmt_start_limited_discovery_rsp(const void *data, uint16_t size)
14210 {
14211         uint8_t type = get_u8(data);
14212
14213         mgmt_print_address_type(type);
14214 }
14215
14216 static void mgmt_read_ext_controller_info_rsp(const void *data, uint16_t size)
14217 {
14218         uint8_t version = get_u8(data + 6);
14219         uint16_t manufacturer = get_le16(data + 7);
14220         uint32_t supported_settings = get_le32(data + 9);
14221         uint32_t current_settings = get_le32(data + 13);
14222         uint16_t data_len = get_le16(data + 17);
14223
14224         print_addr_resolve("Address", data, 0x00, false);
14225         mgmt_print_version(version);
14226         mgmt_print_manufacturer(manufacturer);
14227         mgmt_print_settings("Supported settings", supported_settings);
14228         mgmt_print_settings("Current settings", current_settings);
14229         print_field("Data length: %u", data_len);
14230         print_eir(data + 19, size - 19, false);
14231 }
14232
14233 static void mgmt_set_apperance_cmd(const void *data, uint16_t size)
14234 {
14235         uint16_t appearance = get_le16(data);
14236
14237         print_appearance(appearance);
14238 }
14239
14240 static const struct bitfield_data mgmt_phy_table[] = {
14241         {  0, "BR 1M 1SLOT"     },
14242         {  1, "BR 1M 3SLOT"     },
14243         {  2, "BR 1M 5SLOT"     },
14244         {  3, "EDR 2M 1SLOT"    },
14245         {  4, "EDR 2M 3SLOT"    },
14246         {  5, "EDR 2M 5SLOT"    },
14247         {  6, "EDR 3M 1SLOT"    },
14248         {  7, "EDR 3M 3SLOT"    },
14249         {  8, "EDR 3M 5SLOT"    },
14250         {  9, "LE 1M TX"        },
14251         {  10, "LE 1M RX"       },
14252         {  11, "LE 2M TX"       },
14253         {  12, "LE 2M RX"       },
14254         {  13, "LE CODED TX"    },
14255         {  14, "LE CODED RX"    },
14256         { }
14257 };
14258
14259 static void mgmt_print_phys(const char *label, uint16_t phys)
14260 {
14261         uint16_t mask;
14262
14263         print_field("%s: 0x%4.4x", label, phys);
14264
14265         mask = print_bitfield(2, phys, mgmt_phy_table);
14266         if (mask)
14267                 print_text(COLOR_UNKNOWN_PHY, "  Unknown PHYs"
14268                                                         " (0x%8.8x)", mask);
14269 }
14270
14271 static void mgmt_get_phy_rsp(const void *data, uint16_t size)
14272 {
14273         uint32_t supported_phys = get_le32(data);
14274         uint32_t configurable_phys = get_le32(data + 4);
14275         uint32_t selected_phys = get_le32(data + 8);
14276
14277         mgmt_print_phys("Supported PHYs", supported_phys);
14278         mgmt_print_phys("Configurable PHYs", configurable_phys);
14279         mgmt_print_phys("Selected PHYs", selected_phys);
14280 }
14281
14282 static void mgmt_set_phy_cmd(const void *data, uint16_t size)
14283 {
14284         uint32_t selected_phys = get_le32(data);
14285
14286         mgmt_print_phys("Selected PHYs", selected_phys);
14287 }
14288
14289 static void mgmt_read_exp_features_info_rsp(const void *data, uint16_t size)
14290 {
14291         uint16_t num_features = get_le16(data);
14292         int i;
14293
14294         print_field("Features: %u", num_features);
14295
14296         if (size - 2 != num_features * 20) {
14297                 packet_hexdump(data + 2, size - 2);
14298                 return;
14299         }
14300
14301         for (i = 0; i < num_features; i++)
14302                 mgmt_print_exp_feature(data + 2 + (i * 20));
14303 }
14304
14305 static void mgmt_set_exp_feature_cmd(const void *data, uint16_t size)
14306 {
14307         uint8_t enable = get_u8(data + 16);
14308
14309         print_field("UUID: %s", bt_uuid128_to_str(data));
14310         print_enable("Action", enable);
14311 }
14312
14313 static void mgmt_set_exp_feature_rsp(const void *data, uint16_t size)
14314 {
14315         mgmt_print_exp_feature(data);
14316 }
14317
14318 static const struct bitfield_data mgmt_added_device_flags_table[] = {
14319         { 0, "Remote Wakeup"            },
14320         { 1, "Device Privacy Mode"      },
14321         { }
14322 };
14323
14324 static void mgmt_print_added_device_flags(char *label, uint32_t flags)
14325 {
14326         uint32_t mask;
14327
14328         print_field("%s: 0x%8.8x", label, flags);
14329         mask = print_bitfield(2, flags, mgmt_added_device_flags_table);
14330         if (mask)
14331                 print_text(COLOR_UNKNOWN_ADDED_DEVICE_FLAG,
14332                            "  Unknown Flags (0x%8.8x)", mask);
14333 }
14334
14335 static void mgmt_get_device_flags_cmd(const void *data, uint16_t size)
14336 {
14337         uint8_t type = get_u8(data + 6);
14338
14339         mgmt_print_address(data, type);
14340 }
14341
14342 static void mgmt_get_device_flags_rsp(const void *data, uint16_t size)
14343 {
14344         uint8_t type = get_u8(data + 6);
14345         uint32_t supported_flags = get_le32(data + 7);
14346         uint32_t current_flags = get_le32(data + 11);
14347
14348         mgmt_print_address(data, type);
14349         mgmt_print_added_device_flags("Supported Flags", supported_flags);
14350         mgmt_print_added_device_flags("Current Flags", current_flags);
14351 }
14352
14353 static void mgmt_set_device_flags_cmd(const void *data, uint16_t size)
14354 {
14355         uint8_t type = get_u8(data + 6);
14356         uint32_t current_flags = get_le32(data + 7);
14357
14358         mgmt_print_address(data, type);
14359         mgmt_print_added_device_flags("Current Flags", current_flags);
14360 }
14361
14362 static void mgmt_set_device_flags_rsp(const void *data, uint16_t size)
14363 {
14364         uint8_t type = get_u8(data + 6);
14365
14366         mgmt_print_address(data, type);
14367 }
14368 static void mgmt_add_ext_adv_params_cmd(const void *data, uint16_t size)
14369 {
14370         uint8_t instance = get_u8(data);
14371         uint32_t flags = get_le32(data + 1);
14372         uint16_t duration = get_le16(data + 5);
14373         uint16_t timeout = get_le16(data + 7);
14374         uint8_t *min_interval = (uint8_t *)(data + 9);
14375         uint8_t *max_interval = (uint8_t *)(data + 13);
14376         int8_t tx_power = get_s8(data + 17);
14377
14378         print_field("Instance: %u", instance);
14379         mgmt_print_adv_flags(flags);
14380         print_field("Duration: %u", duration);
14381         print_field("Timeout: %u", timeout);
14382         print_ext_slot_625("Min advertising interval", min_interval);
14383         print_ext_slot_625("Max advertising interval", max_interval);
14384         print_power_level(tx_power, NULL);
14385 }
14386
14387 static void mgmt_add_ext_adv_params_rsp(const void *data, uint16_t size)
14388 {
14389         uint8_t instance = get_u8(data);
14390         int8_t tx_power = get_s8(data + 1);
14391         uint8_t max_adv_data_len = get_u8(data+2);
14392         uint8_t max_scan_rsp_len = get_u8(data+3);
14393
14394         print_field("Instance: %u", instance);
14395         print_power_level(tx_power, NULL);
14396         print_field("Available adv data len: %u", max_adv_data_len);
14397         print_field("Available scan rsp data len: %u", max_scan_rsp_len);
14398 }
14399
14400 static void mgmt_add_ext_adv_data_cmd(const void *data, uint16_t size)
14401 {
14402         uint8_t instance = get_u8(data);
14403         uint8_t adv_data_len = get_u8(data + 1);
14404         uint8_t scan_rsp_len = get_u8(data + 2);
14405
14406         print_field("Instance: %u", instance);
14407         print_field("Advertising data length: %u", adv_data_len);
14408         print_eir(data + 3, adv_data_len, false);
14409         print_field("Scan response length: %u", scan_rsp_len);
14410         print_eir(data + 3 + adv_data_len, scan_rsp_len, false);
14411 }
14412
14413 static void mgmt_add_ext_adv_data_rsp(const void *data, uint16_t size)
14414 {
14415         uint8_t instance = get_u8(data);
14416
14417         print_field("Instance: %u", instance);
14418 }
14419
14420 static const struct bitfield_data mgmt_adv_monitor_features_table[] = {
14421         { 1, "OR Patterns"      },
14422         { }
14423 };
14424
14425 static void mgmt_print_adv_monitor_features(char *label, uint32_t flags)
14426 {
14427         uint32_t mask;
14428
14429         print_field("%s: 0x%8.8x", label, flags);
14430         mask = print_bitfield(2, flags, mgmt_adv_monitor_features_table);
14431         if (mask)
14432                 print_text(COLOR_UNKNOWN_ADVMON_FEATURES,
14433                            "  Unknown Flags (0x%8.8x)", mask);
14434 }
14435
14436 static void mgmt_print_adv_monitor_handles(const void *data, uint8_t len)
14437 {
14438         uint8_t idx = 0;
14439
14440         while (idx + 2 <= len) {
14441                 print_field("  Handle: %d", get_le16(data + idx));
14442                 idx += 2;
14443         }
14444 }
14445
14446 static void mgmt_read_adv_monitor_features_rsp(const void *data, uint16_t size)
14447 {
14448         uint32_t supported_features = get_le32(data);
14449         uint32_t enabled_features = get_le32(data + 4);
14450         uint16_t max_num_handles = get_le16(data + 8);
14451         uint8_t max_num_patterns = get_u8(data + 10);
14452         uint16_t num_handles = get_le16(data + 11);
14453
14454         mgmt_print_adv_monitor_features("Supported Features",
14455                                                         supported_features);
14456         mgmt_print_adv_monitor_features("Enabled Features",
14457                                                         enabled_features);
14458         print_field("Max number of handles: %d", max_num_handles);
14459         print_field("Max number of patterns: %d", max_num_patterns);
14460         print_field("Number of handles: %d", num_handles);
14461         mgmt_print_adv_monitor_handles(data + 13, size - 13);
14462 }
14463
14464 static void mgmt_print_adv_monitor_patterns(const void *data, uint8_t len)
14465 {
14466         uint8_t data_idx = 0, pattern_idx = 1;
14467
14468         /* Reference: struct mgmt_adv_pattern in lib/mgmt.h. */
14469         while (data_idx + 34 <= len) {
14470                 uint8_t ad_type = get_u8(data);
14471                 uint8_t offset = get_u8(data + 1);
14472                 uint8_t length = get_u8(data + 2);
14473
14474                 print_field("  Pattern %d:", pattern_idx);
14475                 print_field("    AD type: %d", ad_type);
14476                 print_field("    Offset: %d", offset);
14477                 print_field("    Length: %d", length);
14478                 if (length <= 31)
14479                         print_hex_field("    Value ", data + 3, length);
14480                 else
14481                         print_text(COLOR_ERROR, "    invalid length");
14482
14483                 pattern_idx += 1;
14484                 data_idx += 34;
14485                 data += 34;
14486         }
14487 }
14488
14489 static void mgmt_add_adv_monitor_patterns_cmd(const void *data, uint16_t size)
14490 {
14491         uint8_t pattern_count = get_u8(data);
14492
14493         print_field("Number of patterns: %d", pattern_count);
14494         mgmt_print_adv_monitor_patterns(data + 1, size - 1);
14495 }
14496
14497 static void mgmt_add_adv_monitor_patterns_rssi_cmd(const void *data,
14498                                                                 uint16_t size)
14499 {
14500         int8_t high_rssi = get_s8(data);
14501         uint16_t high_rssi_timeout = get_le16(data + 1);
14502         int8_t low_rssi = get_s8(data + 3);
14503         uint16_t low_rssi_timeout = get_le16(data + 4);
14504         uint8_t sampling_period = get_u8(data + 6);
14505         uint8_t pattern_count = get_u8(data + 7);
14506
14507         print_field("RSSI data:");
14508         print_field("  high threshold: %d dBm", high_rssi);
14509         print_field("  high timeout: %d seconds", high_rssi_timeout);
14510         print_field("  low threshold: %d dBm", low_rssi);
14511         print_field("  low timeout: %d seconds", low_rssi_timeout);
14512
14513         if (sampling_period == 0)
14514                 print_field("  sampling: propagate all (0x00)");
14515         else if (sampling_period == 0xff)
14516                 print_field("  sampling: just once (0xFF)");
14517         else
14518                 print_field("  sampling: every %d ms", 100 * sampling_period);
14519
14520         print_field("Number of patterns: %d", pattern_count);
14521         mgmt_print_adv_monitor_patterns(data + 8, size - 8);
14522 }
14523
14524 static void mgmt_add_adv_monitor_patterns_rsp(const void *data, uint16_t size)
14525 {
14526         uint16_t handle = get_le16(data);
14527
14528         print_field("Handle: %d", handle);
14529 }
14530
14531 static void mgmt_remove_adv_monitor_patterns_cmd(const void *data,
14532                                                                 uint16_t size)
14533 {
14534         uint16_t handle = get_le16(data);
14535
14536         print_field("Handle: %d", handle);
14537 }
14538
14539 static void mgmt_remove_adv_monitor_patterns_rsp(const void *data,
14540                                                                 uint16_t size)
14541 {
14542         uint16_t handle = get_le16(data);
14543
14544         print_field("Handle: %d", handle);
14545 }
14546
14547 static void mgmt_set_mesh_receiver_cmd(const void *data, uint16_t size)
14548 {
14549         uint8_t enable = get_u8(data);
14550         uint16_t window = get_le16(data + 1);
14551         uint16_t period = get_le16(data + 3);
14552         uint8_t num_ad_types = get_u8(data + 5);
14553         const uint8_t *ad_types = data + 6;
14554
14555         print_field("Enable: %d", enable);
14556         print_field("Window: %d", window);
14557         print_field("Period: %d", period);
14558         print_field("Num AD Types: %d", num_ad_types);
14559         size -= 6;
14560
14561         while (size--)
14562                 print_field("  AD Type: %d", *ad_types++);
14563 }
14564
14565 static void mgmt_read_mesh_features_rsp(const void *data, uint16_t size)
14566 {
14567         uint16_t index = get_le16(data);
14568         uint8_t max_handles = get_u8(data + 2);
14569         uint8_t used_handles = get_u8(data + 3);
14570         const uint8_t *handles = data + 4;
14571
14572         print_field("Index: %d", index);
14573         print_field("Max Handles: %d", max_handles);
14574         print_field("Used Handles: %d", used_handles);
14575         size -= 4;
14576
14577         while (size--)
14578                 print_field("  Used Handle: %d", *handles++);
14579 }
14580
14581 static void mgmt_mesh_send_cmd(const void *data, uint16_t size)
14582 {
14583         const uint8_t *addr = data;
14584         uint8_t addr_type = get_u8(data + 6);
14585         uint64_t instant = get_le64(data + 7);
14586         uint16_t delay = get_le16(data + 15);
14587         uint8_t cnt = get_u8(data + 17);
14588         uint8_t adv_data_len = get_u8(data + 18);
14589
14590         data += 19;
14591         size -= 19;
14592         print_bdaddr(addr);
14593         print_field("Addr Type: %d", addr_type);
14594         print_field("Instant: 0x%16.16" PRIx64, instant);
14595         print_field("Delay: %d", delay);
14596         print_field("Count: %d", cnt);
14597         print_field("Data Length: %d", adv_data_len);
14598         print_hex_field("Data", data, size);
14599 }
14600
14601 static void mgmt_mesh_send_rsp(const void *data, uint16_t size)
14602 {
14603         uint8_t handle = get_u8(data);
14604
14605         print_field("Handle: %d", handle);
14606 }
14607
14608 static void mgmt_mesh_send_cancel_cmd(const void *data, uint16_t size)
14609 {
14610         uint8_t handle = get_u8(data);
14611
14612         print_field("Handle: %d", handle);
14613 }
14614
14615 struct mgmt_data {
14616         uint16_t opcode;
14617         const char *str;
14618         void (*func) (const void *data, uint16_t size);
14619         uint16_t size;
14620         bool fixed;
14621         void (*rsp_func) (const void *data, uint16_t size);
14622         uint16_t rsp_size;
14623         bool rsp_fixed;
14624 };
14625
14626 static const struct mgmt_data mgmt_command_table[] = {
14627         { 0x0001, "Read Management Version Information",
14628                                 mgmt_null_cmd, 0, true,
14629                                 mgmt_read_version_info_rsp, 3, true },
14630         { 0x0002, "Read Management Supported Commands",
14631                                 mgmt_null_cmd, 0, true,
14632                                 mgmt_read_supported_commands_rsp, 4, false },
14633         { 0x0003, "Read Controller Index List",
14634                                 mgmt_null_cmd, 0, true,
14635                                 mgmt_read_index_list_rsp, 2, false },
14636         { 0x0004, "Read Controller Information",
14637                                 mgmt_null_cmd, 0, true,
14638                                 mgmt_read_controller_info_rsp, 280, true },
14639         { 0x0005, "Set Powered",
14640                                 mgmt_set_powered_cmd, 1, true,
14641                                 mgmt_new_settings_rsp, 4, true },
14642         { 0x0006, "Set Discoverable",
14643                                 mgmt_set_discoverable_cmd, 3, true,
14644                                 mgmt_new_settings_rsp, 4, true },
14645         { 0x0007, "Set Connectable",
14646                                 mgmt_set_connectable_cmd, 1, true,
14647                                 mgmt_new_settings_rsp, 4, true },
14648         { 0x0008, "Set Fast Connectable",
14649                                 mgmt_set_fast_connectable_cmd, 1, true,
14650                                 mgmt_new_settings_rsp, 4, true },
14651         { 0x0009, "Set Bondable",
14652                                 mgmt_set_bondable_cmd, 1, true,
14653                                 mgmt_new_settings_rsp, 4, true },
14654         { 0x000a, "Set Link Security",
14655                                 mgmt_set_link_security_cmd, 1, true,
14656                                 mgmt_new_settings_rsp, 4, true },
14657         { 0x000b, "Set Secure Simple Pairing",
14658                                 mgmt_set_secure_simple_pairing_cmd, 1, true,
14659                                 mgmt_new_settings_rsp, 4, true },
14660         { 0x000c, "Set High Speed",
14661                                 mgmt_set_high_speed_cmd, 1, true,
14662                                 mgmt_new_settings_rsp, 4, true },
14663         { 0x000d, "Set Low Energy",
14664                                 mgmt_set_low_energy_cmd, 1, true,
14665                                 mgmt_new_settings_rsp, 4, true },
14666         { 0x000e, "Set Device Class",
14667                                 mgmt_set_device_class_cmd, 2, true,
14668                                 mgmt_set_device_class_rsp, 3, true },
14669         { 0x000f, "Set Local Name",
14670                                 mgmt_set_local_name_cmd, 260, true,
14671                                 mgmt_set_local_name_rsp, 260, true },
14672         { 0x0010, "Add UUID",
14673                                 mgmt_add_uuid_cmd, 17, true,
14674                                 mgmt_add_uuid_rsp, 3, true },
14675         { 0x0011, "Remove UUID",
14676                                 mgmt_remove_uuid_cmd, 16, true,
14677                                 mgmt_remove_uuid_rsp, 3, true },
14678         { 0x0012, "Load Link Keys",
14679                                 mgmt_load_link_keys_cmd, 3, false,
14680                                 mgmt_null_rsp, 0, true },
14681         { 0x0013, "Load Long Term Keys",
14682                                 mgmt_load_long_term_keys_cmd, 2, false,
14683                                 mgmt_null_rsp, 0, true },
14684         { 0x0014, "Disconnect",
14685                                 mgmt_disconnect_cmd, 7, true,
14686                                 mgmt_disconnect_rsp, 7, true },
14687         { 0x0015, "Get Connections",
14688                                 mgmt_null_cmd, 0, true,
14689                                 mgmt_get_connections_rsp, 2, false },
14690         { 0x0016, "PIN Code Reply",
14691                                 mgmt_pin_code_reply_cmd, 24, true,
14692                                 mgmt_pin_code_reply_rsp, 7, true },
14693         { 0x0017, "PIN Code Negative Reply",
14694                                 mgmt_pin_code_neg_reply_cmd, 7, true,
14695                                 mgmt_pin_code_neg_reply_rsp, 7, true },
14696         { 0x0018, "Set IO Capability",
14697                                 mgmt_set_io_capability_cmd, 1, true,
14698                                 mgmt_null_rsp, 0, true },
14699         { 0x0019, "Pair Device",
14700                                 mgmt_pair_device_cmd, 8, true,
14701                                 mgmt_pair_device_rsp, 7, true },
14702         { 0x001a, "Cancel Pair Device",
14703                                 mgmt_cancel_pair_device_cmd, 7, true,
14704                                 mgmt_cancel_pair_device_rsp, 7, true },
14705         { 0x001b, "Unpair Device",
14706                                 mgmt_unpair_device_cmd, 8, true,
14707                                 mgmt_unpair_device_rsp, 7, true },
14708         { 0x001c, "User Confirmation Reply",
14709                                 mgmt_user_confirmation_reply_cmd, 7, true,
14710                                 mgmt_user_confirmation_reply_rsp, 7, true },
14711         { 0x001d, "User Confirmation Negative Reply",
14712                                 mgmt_user_confirmation_neg_reply_cmd, 7, true,
14713                                 mgmt_user_confirmation_neg_reply_rsp, 7, true },
14714         { 0x001e, "User Passkey Reply",
14715                                 mgmt_user_passkey_reply_cmd, 11, true,
14716                                 mgmt_user_passkey_reply_rsp, 7, true },
14717         { 0x001f, "User Passkey Negative Reply",
14718                                 mgmt_user_passkey_neg_reply_cmd, 7, true,
14719                                 mgmt_user_passkey_neg_reply_rsp, 7, true },
14720         { 0x0020, "Read Local Out Of Band Data",
14721                                 mgmt_null_cmd, 0, true,
14722                                 mgmt_read_local_oob_data_rsp, 64, true },
14723         { 0x0021, "Add Remote Out Of Band Data",
14724                                 mgmt_add_remote_oob_data_cmd, 71, true,
14725                                 mgmt_add_remote_oob_data_rsp, 7, true },
14726         { 0x0022, "Remove Remote Out Of Band Data",
14727                                 mgmt_remove_remote_oob_data_cmd, 7, true,
14728                                 mgmt_remove_remote_oob_data_rsp, 7, true },
14729         { 0x0023, "Start Discovery",
14730                                 mgmt_start_discovery_cmd, 1, true,
14731                                 mgmt_start_discovery_rsp, 1, true },
14732         { 0x0024, "Stop Discovery",
14733                                 mgmt_stop_discovery_cmd, 1, true,
14734                                 mgmt_stop_discovery_rsp, 1, true },
14735         { 0x0025, "Confirm Name",
14736                                 mgmt_confirm_name_cmd, 8, true,
14737                                 mgmt_confirm_name_rsp, 7, true },
14738         { 0x0026, "Block Device",
14739                                 mgmt_block_device_cmd, 7, true,
14740                                 mgmt_block_device_rsp, 7, true },
14741         { 0x0027, "Unblock Device",
14742                                 mgmt_unblock_device_cmd, 7, true,
14743                                 mgmt_unblock_device_rsp, 7, true },
14744         { 0x0028, "Set Device ID",
14745                                 mgmt_set_device_id_cmd, 8, true,
14746                                 mgmt_null_rsp, 0, true },
14747         { 0x0029, "Set Advertising",
14748                                 mgmt_set_advertising_cmd, 1, true,
14749                                 mgmt_new_settings_rsp, 4, true },
14750         { 0x002a, "Set BR/EDR",
14751                                 mgmt_set_bredr_cmd, 1, true,
14752                                 mgmt_new_settings_rsp, 4, true },
14753         { 0x002b, "Set Static Address",
14754                                 mgmt_set_static_address_cmd, 6, true,
14755                                 mgmt_new_settings_rsp, 4, true },
14756         { 0x002c, "Set Scan Parameters",
14757                                 mgmt_set_scan_parameters_cmd, 4, true,
14758                                 mgmt_null_rsp, 0, true },
14759         { 0x002d, "Set Secure Connections",
14760                                 mgmt_set_secure_connections_cmd, 1, true,
14761                                 mgmt_new_settings_rsp, 4, true },
14762         { 0x002e, "Set Debug Keys",
14763                                 mgmt_set_debug_keys_cmd, 1, true,
14764                                 mgmt_new_settings_rsp, 4, true },
14765         { 0x002f, "Set Privacy",
14766                                 mgmt_set_privacy_cmd, 17, true,
14767                                 mgmt_new_settings_rsp, 4, true },
14768         { 0x0030, "Load Identity Resolving Keys",
14769                                 mgmt_load_identity_resolving_keys_cmd, 2, false,
14770                                 mgmt_null_rsp, 0, true },
14771         { 0x0031, "Get Connection Information",
14772                                 mgmt_get_connection_information_cmd, 7, true,
14773                                 mgmt_get_connection_information_rsp, 10, true },
14774         { 0x0032, "Get Clock Information",
14775                                 mgmt_get_clock_information_cmd, 7, true,
14776                                 mgmt_get_clock_information_rsp, 17, true },
14777         { 0x0033, "Add Device",
14778                                 mgmt_add_device_cmd, 8, true,
14779                                 mgmt_add_device_rsp, 7, true },
14780         { 0x0034, "Remove Device",
14781                                 mgmt_remove_device_cmd, 7, true,
14782                                 mgmt_remove_device_rsp, 7, true },
14783         { 0x0035, "Load Connection Parameters",
14784                                 mgmt_load_connection_parameters_cmd, 2, false,
14785                                 mgmt_null_rsp, 0, true },
14786         { 0x0036, "Read Unconfigured Controller Index List",
14787                                 mgmt_null_cmd, 0, true,
14788                                 mgmt_read_unconf_index_list_rsp, 2, false },
14789         { 0x0037, "Read Controller Configuration Information",
14790                                 mgmt_null_cmd, 0, true,
14791                                 mgmt_read_controller_conf_info_rsp, 10, true },
14792         { 0x0038, "Set External Configuration",
14793                                 mgmt_set_external_configuration_cmd, 1, true,
14794                                 mgmt_new_options_rsp, 4, true },
14795         { 0x0039, "Set Public Address",
14796                                 mgmt_set_public_address_cmd, 6, true,
14797                                 mgmt_new_options_rsp, 4, true },
14798         { 0x003a, "Start Service Discovery",
14799                                 mgmt_start_service_discovery_cmd, 3, false,
14800                                 mgmt_start_service_discovery_rsp, 1, true },
14801         { 0x003b, "Read Local Out Of Band Extended Data",
14802                                 mgmt_read_local_oob_ext_data_cmd, 1, true,
14803                                 mgmt_read_local_oob_ext_data_rsp, 3, false },
14804         { 0x003c, "Read Extended Controller Index List",
14805                                 mgmt_null_cmd, 0, true,
14806                                 mgmt_read_ext_index_list_rsp, 2, false },
14807         { 0x003d, "Read Advertising Features",
14808                                 mgmt_null_cmd, 0, true,
14809                                 mgmt_read_advertising_features_rsp, 8, false },
14810         { 0x003e, "Add Advertising",
14811                                 mgmt_add_advertising_cmd, 11, false,
14812                                 mgmt_add_advertising_rsp, 1, true },
14813         { 0x003f, "Remove Advertising",
14814                                 mgmt_remove_advertising_cmd, 1, true,
14815                                 mgmt_remove_advertising_rsp, 1, true },
14816         { 0x0040, "Get Advertising Size Information",
14817                                 mgmt_get_advertising_size_info_cmd, 5, true,
14818                                 mgmt_get_advertising_size_info_rsp, 7, true },
14819         { 0x0041, "Start Limited Discovery",
14820                                 mgmt_start_limited_discovery_cmd, 1, true,
14821                                 mgmt_start_limited_discovery_rsp, 1, true },
14822         { 0x0042, "Read Extended Controller Information",
14823                                 mgmt_null_cmd, 0, true,
14824                                 mgmt_read_ext_controller_info_rsp, 19, false },
14825         { 0x0043, "Set Appearance",
14826                                 mgmt_set_apperance_cmd, 2, true,
14827                                 mgmt_null_rsp, 0, true },
14828         { 0x0044, "Get PHY Configuration",
14829                                 mgmt_null_cmd, 0, true,
14830                                 mgmt_get_phy_rsp, 12, true },
14831         { 0x0045, "Set PHY Configuration",
14832                                 mgmt_set_phy_cmd, 4, true,
14833                                 mgmt_null_rsp, 0, true },
14834         { 0x0046, "Load Blocked Keys" },
14835         { 0x0047, "Set Wideband Speech" },
14836         { 0x0048, "Read Controller Capabilities" },
14837         { 0x0049, "Read Experimental Features Information",
14838                                 mgmt_null_cmd, 0, true,
14839                                 mgmt_read_exp_features_info_rsp, 2, false },
14840         { 0x004a, "Set Experimental Feature",
14841                                 mgmt_set_exp_feature_cmd, 17, true,
14842                                 mgmt_set_exp_feature_rsp, 20, true },
14843         { 0x004b, "Read Default System Configuration" },
14844         { 0x004c, "Set Default System Configuration" },
14845         { 0x004d, "Read Default Runtime Configuration" },
14846         { 0x004e, "Set Default Runtime Configuration" },
14847         { 0x004f, "Get Device Flags",
14848                                 mgmt_get_device_flags_cmd, 7, true,
14849                                 mgmt_get_device_flags_rsp, 15, true},
14850         { 0x0050, "Set Device Flags",
14851                                 mgmt_set_device_flags_cmd, 11, true,
14852                                 mgmt_set_device_flags_rsp, 7, true},
14853         { 0x0051, "Read Advertisement Monitor Features",
14854                                 mgmt_null_cmd, 0, true,
14855                                 mgmt_read_adv_monitor_features_rsp, 13, false},
14856         { 0x0052, "Add Advertisement Patterns Monitor",
14857                                 mgmt_add_adv_monitor_patterns_cmd, 1, false,
14858                                 mgmt_add_adv_monitor_patterns_rsp, 2, true},
14859         { 0x0053, "Remove Advertisement Monitor",
14860                                 mgmt_remove_adv_monitor_patterns_cmd, 2, true,
14861                                 mgmt_remove_adv_monitor_patterns_rsp, 2, true},
14862         { 0x0054, "Add Extended Advertising Parameters",
14863                                 mgmt_add_ext_adv_params_cmd, 18, false,
14864                                 mgmt_add_ext_adv_params_rsp, 4, true },
14865         { 0x0055, "Add Extended Advertising Data",
14866                                 mgmt_add_ext_adv_data_cmd, 3, false,
14867                                 mgmt_add_ext_adv_data_rsp, 1, true },
14868         { 0x0056, "Add Advertisement Patterns Monitor With RSSI Threshold",
14869                                 mgmt_add_adv_monitor_patterns_rssi_cmd, 8,
14870                                                                         false,
14871                                 mgmt_add_adv_monitor_patterns_rsp, 2, true},
14872         { 0x0057, "Set Mesh Receiver",
14873                                 mgmt_set_mesh_receiver_cmd, 6, false,
14874                                 mgmt_null_rsp, 0, true},
14875         { 0x0058, "Read Mesh Features",
14876                                 mgmt_null_cmd, 0, true,
14877                                 mgmt_read_mesh_features_rsp, 4, false},
14878         { 0x0059, "Mesh Send",
14879                                 mgmt_mesh_send_cmd, 19, false,
14880                                 mgmt_mesh_send_rsp, 1, true},
14881         { 0x0056, "Mesh Send Cancel",
14882                                 mgmt_mesh_send_cancel_cmd, 1, true,
14883                                 mgmt_null_rsp, 0, true},
14884         { }
14885 };
14886
14887 static void mgmt_null_evt(const void *data, uint16_t size)
14888 {
14889 }
14890
14891 static void mgmt_command_complete_evt(const void *data, uint16_t size)
14892 {
14893         uint16_t opcode;
14894         uint8_t status;
14895         const struct mgmt_data *mgmt_data = NULL;
14896         const char *mgmt_color, *mgmt_str;
14897         int i;
14898
14899         opcode = get_le16(data);
14900         status = get_u8(data + 2);
14901
14902         data += 3;
14903         size -= 3;
14904
14905         for (i = 0; mgmt_command_table[i].str; i++) {
14906                 if (mgmt_command_table[i].opcode == opcode) {
14907                         mgmt_data = &mgmt_command_table[i];
14908                         break;
14909                 }
14910         }
14911
14912         if (mgmt_data) {
14913                 if (mgmt_data->rsp_func)
14914                         mgmt_color = COLOR_CTRL_COMMAND;
14915                 else
14916                         mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14917                 mgmt_str = mgmt_data->str;
14918         } else {
14919                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14920                 mgmt_str = "Unknown";
14921         }
14922
14923         print_indent(6, mgmt_color, "", mgmt_str, COLOR_OFF,
14924                                         " (0x%4.4x) plen %u", opcode, size);
14925
14926         mgmt_print_status(status);
14927
14928         if (!mgmt_data || !mgmt_data->rsp_func) {
14929                 packet_hexdump(data, size);
14930                 return;
14931         }
14932
14933         if (mgmt_data->rsp_fixed) {
14934                 if (size != mgmt_data->rsp_size) {
14935                         print_text(COLOR_ERROR, "invalid packet size");
14936                         packet_hexdump(data, size);
14937                         return;
14938                 }
14939         } else {
14940                 if (size < mgmt_data->rsp_size) {
14941                         print_text(COLOR_ERROR, "too short packet");
14942                         packet_hexdump(data, size);
14943                         return;
14944                 }
14945         }
14946
14947         mgmt_data->rsp_func(data, size);
14948 }
14949
14950 static void mgmt_command_status_evt(const void *data, uint16_t size)
14951 {
14952         uint16_t opcode;
14953         uint8_t status;
14954         const struct mgmt_data *mgmt_data = NULL;
14955         const char *mgmt_color, *mgmt_str;
14956         int i;
14957
14958         opcode = get_le16(data);
14959         status = get_u8(data + 2);
14960
14961         for (i = 0; mgmt_command_table[i].str; i++) {
14962                 if (mgmt_command_table[i].opcode == opcode) {
14963                         mgmt_data = &mgmt_command_table[i];
14964                         break;
14965                 }
14966         }
14967
14968         if (mgmt_data) {
14969                 mgmt_color = COLOR_CTRL_COMMAND;
14970                 mgmt_str = mgmt_data->str;
14971         } else {
14972                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14973                 mgmt_str = "Unknown";
14974         }
14975
14976         print_indent(6, mgmt_color, "", mgmt_str, COLOR_OFF,
14977                                                 " (0x%4.4x)", opcode);
14978
14979         mgmt_print_status(status);
14980 }
14981
14982 static void mgmt_controller_error_evt(const void *data, uint16_t size)
14983 {
14984         uint8_t error = get_u8(data);
14985
14986         print_field("Error: 0x%2.2x", error);
14987 }
14988
14989 static void mgmt_new_settings_evt(const void *data, uint16_t size)
14990 {
14991         uint32_t settings = get_le32(data);
14992
14993         mgmt_print_settings("Current settings", settings);
14994 }
14995
14996 static void mgmt_class_of_dev_changed_evt(const void *data, uint16_t size)
14997 {
14998         print_dev_class(data);
14999 }
15000
15001 static void mgmt_local_name_changed_evt(const void *data, uint16_t size)
15002 {
15003         mgmt_print_name(data);
15004 }
15005
15006 static void mgmt_new_link_key_evt(const void *data, uint16_t size)
15007 {
15008         uint8_t store_hint = get_u8(data);
15009
15010         mgmt_print_store_hint(store_hint);
15011         mgmt_print_link_key(data + 1);
15012 }
15013
15014 static void mgmt_new_long_term_key_evt(const void *data, uint16_t size)
15015 {
15016         uint8_t store_hint = get_u8(data);
15017
15018         mgmt_print_store_hint(store_hint);
15019         mgmt_print_long_term_key(data + 1);
15020 }
15021
15022 static void mgmt_device_connected_evt(const void *data, uint16_t size)
15023 {
15024         uint8_t address_type = get_u8(data + 6);
15025         uint32_t flags = get_le32(data + 7);
15026         uint16_t data_len = get_le16(data + 11);
15027
15028         mgmt_print_address(data, address_type);
15029         mgmt_print_device_flags(flags);
15030         print_field("Data length: %u", data_len);
15031         print_eir(data + 13, size - 13, false);
15032 }
15033
15034 static void mgmt_device_disconnected_evt(const void *data, uint16_t size)
15035 {
15036         uint8_t address_type = get_u8(data + 6);
15037         uint8_t reason = get_u8(data + 7);
15038         const char *str;
15039
15040         mgmt_print_address(data, address_type);
15041
15042         switch (reason) {
15043         case 0x00:
15044                 str = "Unspecified";
15045                 break;
15046         case 0x01:
15047                 str = "Connection timeout";
15048                 break;
15049         case 0x02:
15050                 str = "Connection terminated by local host";
15051                 break;
15052         case 0x03:
15053                 str = "Connection terminated by remote host";
15054                 break;
15055         case 0x04:
15056                 str = "Connection terminated due to authentication failure";
15057                 break;
15058         case 0x05:
15059                 str = "Connection terminated by local host for suspend";
15060                 break;
15061         default:
15062                 str = "Reserved";
15063                 break;
15064         }
15065
15066         print_field("Reason: %s (0x%2.2x)", str, reason);
15067 }
15068
15069 static void mgmt_connect_failed_evt(const void *data, uint16_t size)
15070 {
15071         uint8_t address_type = get_u8(data + 6);
15072         uint8_t status = get_u8(data + 7);
15073
15074         mgmt_print_address(data, address_type);
15075         mgmt_print_status(status);
15076 }
15077
15078 static void mgmt_pin_code_request_evt(const void *data, uint16_t size)
15079 {
15080         uint8_t address_type = get_u8(data + 6);
15081         uint8_t secure_pin = get_u8(data + 7);
15082
15083         mgmt_print_address(data, address_type);
15084         print_field("Secure PIN: 0x%2.2x", secure_pin);
15085 }
15086
15087 static void mgmt_user_confirmation_request_evt(const void *data, uint16_t size)
15088 {
15089         uint8_t address_type = get_u8(data + 6);
15090         uint8_t confirm_hint = get_u8(data + 7);
15091         uint32_t value = get_le32(data + 8);
15092
15093         mgmt_print_address(data, address_type);
15094         print_field("Confirm hint: 0x%2.2x", confirm_hint);
15095         print_field("Value: 0x%8.8x", value);
15096 }
15097
15098 static void mgmt_user_passkey_request_evt(const void *data, uint16_t size)
15099 {
15100         uint8_t address_type = get_u8(data + 6);
15101
15102         mgmt_print_address(data, address_type);
15103 }
15104
15105 static void mgmt_authentication_failed_evt(const void *data, uint16_t size)
15106 {
15107         uint8_t address_type = get_u8(data + 6);
15108         uint8_t status = get_u8(data + 7);
15109
15110         mgmt_print_address(data, address_type);
15111         mgmt_print_status(status);
15112 }
15113
15114 static void mgmt_device_found_evt(const void *data, uint16_t size)
15115 {
15116         uint8_t address_type = get_u8(data + 6);
15117         int8_t rssi = get_s8(data + 7);
15118         uint32_t flags = get_le32(data + 8);
15119         uint16_t data_len = get_le16(data + 12);
15120
15121         mgmt_print_address(data, address_type);
15122         print_rssi(rssi);
15123         mgmt_print_device_flags(flags);
15124         print_field("Data length: %u", data_len);
15125         print_eir(data + 14, size - 14, false);
15126 }
15127
15128 static void mgmt_discovering_evt(const void *data, uint16_t size)
15129 {
15130         uint8_t type = get_u8(data);
15131         uint8_t enable = get_u8(data + 1);
15132
15133         mgmt_print_address_type(type);
15134         print_enable("Discovery", enable);
15135 }
15136
15137 static void mgmt_device_blocked_evt(const void *data, uint16_t size)
15138 {
15139         uint8_t address_type = get_u8(data + 6);
15140
15141         mgmt_print_address(data, address_type);
15142 }
15143
15144 static void mgmt_device_unblocked_evt(const void *data, uint16_t size)
15145 {
15146         uint8_t address_type = get_u8(data + 6);
15147
15148         mgmt_print_address(data, address_type);
15149 }
15150
15151 static void mgmt_device_unpaired_evt(const void *data, uint16_t size)
15152 {
15153         uint8_t address_type = get_u8(data + 6);
15154
15155         mgmt_print_address(data, address_type);
15156 }
15157
15158 static void mgmt_passkey_notify_evt(const void *data, uint16_t size)
15159 {
15160         uint8_t address_type = get_u8(data + 6);
15161         uint32_t passkey = get_le32(data + 7);
15162         uint8_t entered = get_u8(data + 11);
15163
15164         mgmt_print_address(data, address_type);
15165         print_field("Passkey: 0x%8.8x", passkey);
15166         print_field("Entered: %u", entered);
15167 }
15168
15169 static void mgmt_new_identity_resolving_key_evt(const void *data, uint16_t size)
15170 {
15171         uint8_t store_hint = get_u8(data);
15172
15173         mgmt_print_store_hint(store_hint);
15174         print_addr_resolve("Random address", data + 1, 0x01, false);
15175         mgmt_print_identity_resolving_key(data + 7);
15176 }
15177
15178 static void mgmt_new_signature_resolving_key_evt(const void *data, uint16_t size)
15179 {
15180         uint8_t store_hint = get_u8(data);
15181
15182         mgmt_print_store_hint(store_hint);
15183         mgmt_print_signature_resolving_key(data + 1);
15184 }
15185
15186 static void mgmt_device_added_evt(const void *data, uint16_t size)
15187 {
15188         uint8_t address_type = get_u8(data + 6);
15189         uint8_t action = get_u8(data + 7);
15190
15191         mgmt_print_address(data, address_type);
15192         mgmt_print_device_action(action);
15193 }
15194
15195 static void mgmt_device_removed_evt(const void *data, uint16_t size)
15196 {
15197         uint8_t address_type = get_u8(data + 6);
15198
15199         mgmt_print_address(data, address_type);
15200 }
15201
15202 static void mgmt_new_connection_parameter_evt(const void *data, uint16_t size)
15203 {
15204         uint8_t store_hint = get_u8(data);
15205
15206         mgmt_print_store_hint(store_hint);
15207         mgmt_print_connection_parameter(data + 1);
15208 }
15209
15210 static void mgmt_new_conf_options_evt(const void *data, uint16_t size)
15211 {
15212         uint32_t missing_options = get_le32(data);
15213
15214         mgmt_print_options("Missing options", missing_options);
15215 }
15216
15217 static void mgmt_ext_index_added_evt(const void *data, uint16_t size)
15218 {
15219         uint8_t type = get_u8(data);
15220         uint8_t bus = get_u8(data + 1);
15221
15222         print_field("type 0x%2.2x - bus 0x%2.2x", type, bus);
15223 }
15224
15225 static void mgmt_ext_index_removed_evt(const void *data, uint16_t size)
15226 {
15227         uint8_t type = get_u8(data);
15228         uint8_t bus = get_u8(data + 1);
15229
15230         print_field("type 0x%2.2x - bus 0x%2.2x", type, bus);
15231 }
15232
15233 static void mgmt_local_oob_ext_data_updated_evt(const void *data, uint16_t size)
15234 {
15235         uint8_t type = get_u8(data);
15236         uint16_t data_len = get_le16(data + 1);
15237
15238         mgmt_print_address_type(type);
15239         print_field("Data length: %u", data_len);
15240         print_eir(data + 3, size - 3, true);
15241 }
15242
15243 static void mgmt_advertising_added_evt(const void *data, uint16_t size)
15244 {
15245         uint8_t instance = get_u8(data);
15246
15247         print_field("Instance: %u", instance);
15248 }
15249
15250 static void mgmt_advertising_removed_evt(const void *data, uint16_t size)
15251 {
15252         uint8_t instance = get_u8(data);
15253
15254         print_field("Instance: %u", instance);
15255 }
15256
15257 static void mgmt_ext_controller_info_changed_evt(const void *data, uint16_t size)
15258 {
15259         uint16_t data_len = get_le16(data);
15260
15261         print_field("Data length: %u", data_len);
15262         print_eir(data + 2, size - 2, false);
15263 }
15264
15265 static void mgmt_phy_changed_evt(const void *data, uint16_t size)
15266 {
15267         uint32_t selected_phys = get_le32(data);
15268
15269         mgmt_print_phys("Selected PHYs", selected_phys);
15270 }
15271
15272 static void mgmt_exp_feature_changed_evt(const void *data, uint16_t size)
15273 {
15274         mgmt_print_exp_feature(data);
15275 }
15276
15277 static void mgmt_device_flags_changed_evt(const void *data, uint16_t size)
15278 {
15279         uint8_t type = get_u8(data + 6);
15280         uint32_t supported_flags = get_le32(data + 7);
15281         uint32_t current_flags = get_le32(data + 11);
15282
15283         mgmt_print_address(data, type);
15284         mgmt_print_added_device_flags("Supported Flags", supported_flags);
15285         mgmt_print_added_device_flags("Current Flags", current_flags);
15286 }
15287
15288 static void mgmt_adv_monitor_added_evt(const void *data, uint16_t size)
15289 {
15290         uint16_t handle = get_le16(data);
15291
15292         print_field("Handle: %d", handle);
15293 }
15294
15295 static void mgmt_adv_monitor_removed_evt(const void *data, uint16_t size)
15296 {
15297         uint16_t handle = get_le16(data);
15298
15299         print_field("Handle: %d", handle);
15300 }
15301
15302 static void mgmt_controller_suspend_evt(const void *data, uint16_t size)
15303 {
15304         uint8_t state = get_u8(data);
15305         char *str;
15306
15307         switch (state) {
15308         case 0x0:
15309                 str = "Controller running (failed to suspend)";
15310                 break;
15311         case 0x1:
15312                 str = "Disconnected and not scanning";
15313                 break;
15314         case 0x2:
15315                 str = "Page scanning and/or passive scanning";
15316                 break;
15317         default:
15318                 str = "Unknown suspend state";
15319                 break;
15320         }
15321
15322         print_field("Suspend state: %s (%d)", str, state);
15323 }
15324
15325 static void mgmt_controller_resume_evt(const void *data, uint16_t size)
15326 {
15327         uint8_t addr_type = get_u8(data + 6);
15328         uint8_t wake_reason = get_u8(data + 7);
15329         char *str;
15330
15331         switch (wake_reason) {
15332         case 0x0:
15333                 str = "Resume from non-Bluetooth wake source";
15334                 break;
15335         case 0x1:
15336                 str = "Wake due to unexpected event";
15337                 break;
15338         case 0x2:
15339                 str = "Remote wake due to peer device connection";
15340                 break;
15341         default:
15342                 str = "Unknown wake reason";
15343                 break;
15344         }
15345
15346         print_field("Wake reason: %s (%d)", str, wake_reason);
15347         mgmt_print_address(data, addr_type);
15348 }
15349
15350 static void mgmt_adv_monitor_device_found_evt(const void *data, uint16_t size)
15351 {
15352         uint16_t handle = get_le16(data);
15353         const uint8_t *addr = data + 2;
15354         uint8_t addr_type = get_u8(data + 8);
15355         int8_t rssi = get_s8(data + 9);
15356         uint32_t flags = get_le32(data + 10);
15357         uint16_t ad_data_len = get_le16(data + 14);
15358         const uint8_t *ad_data = data + 16;
15359
15360         print_field("Handle: %d", handle);
15361         print_bdaddr(addr);
15362         print_field("Addr Type: %d", addr_type);
15363         print_field("RSSI: %d", rssi);
15364         mgmt_print_device_flags(flags);
15365         print_field("AD Data Len: %d", ad_data_len);
15366         size -= 16;
15367         print_hex_field("AD Data", ad_data, size);
15368 }
15369
15370 static void mgmt_adv_monitor_device_lost_evt(const void *data, uint16_t size)
15371 {
15372         uint16_t handle = get_le16(data);
15373         const uint8_t *addr = data + 2;
15374         uint8_t addr_type = get_u8(data + 8);
15375
15376         print_field("Handle: %d", handle);
15377         print_bdaddr(addr);
15378         print_field("Addr Type: %d", addr_type);
15379 }
15380
15381 static void mgmt_mesh_device_found_evt(const void *data, uint16_t size)
15382 {
15383         const uint8_t *addr = data;
15384         uint8_t addr_type = get_u8(data + 6);
15385         int8_t rssi = get_s8(data + 7);
15386         uint64_t instant = get_le64(data + 8);
15387         uint32_t flags = get_le32(data + 16);
15388         uint16_t eir_len = get_le16(data + 20);
15389         const uint8_t *eir_data = data + 22;
15390
15391         print_bdaddr(addr);
15392         print_field("Addr Type: %d", addr_type);
15393         print_field("RSSI: %d", rssi);
15394         print_field("Instant: 0x%16.16" PRIx64, instant);
15395         mgmt_print_device_flags(flags);
15396         print_field("EIR Length: %d", eir_len);
15397         size -= 22;
15398         print_hex_field("EIR Data", eir_data, size);
15399 }
15400
15401 static void mgmt_mesh_packet_cmplt_evt(const void *data, uint16_t size)
15402 {
15403         uint8_t handle = get_u8(data);
15404
15405         print_field("Handle: %d", handle);
15406 }
15407
15408 static const struct mgmt_data mgmt_event_table[] = {
15409         { 0x0001, "Command Complete",
15410                         mgmt_command_complete_evt, 3, false },
15411         { 0x0002, "Command Status",
15412                         mgmt_command_status_evt, 3, true },
15413         { 0x0003, "Controller Error",
15414                         mgmt_controller_error_evt, 1, true },
15415         { 0x0004, "Index Added",
15416                         mgmt_null_evt, 0, true },
15417         { 0x0005, "Index Removed",
15418                         mgmt_null_evt, 0, true },
15419         { 0x0006, "New Settings",
15420                         mgmt_new_settings_evt, 4, true },
15421         { 0x0007, "Class Of Device Changed",
15422                         mgmt_class_of_dev_changed_evt, 3, true },
15423         { 0x0008, "Local Name Changed",
15424                         mgmt_local_name_changed_evt, 260, true },
15425         { 0x0009, "New Link Key",
15426                         mgmt_new_link_key_evt, 26, true },
15427         { 0x000a, "New Long Term Key",
15428                         mgmt_new_long_term_key_evt, 37, true },
15429         { 0x000b, "Device Connected",
15430                         mgmt_device_connected_evt, 13, false },
15431         { 0x000c, "Device Disconnected",
15432                         mgmt_device_disconnected_evt, 8, true },
15433         { 0x000d, "Connect Failed",
15434                         mgmt_connect_failed_evt, 8, true },
15435         { 0x000e, "PIN Code Request",
15436                         mgmt_pin_code_request_evt, 8, true },
15437         { 0x000f, "User Confirmation Request",
15438                         mgmt_user_confirmation_request_evt, 12, true },
15439         { 0x0010, "User Passkey Request",
15440                         mgmt_user_passkey_request_evt, 7, true },
15441         { 0x0011, "Authentication Failed",
15442                         mgmt_authentication_failed_evt, 8, true },
15443         { 0x0012, "Device Found",
15444                         mgmt_device_found_evt, 14, false },
15445         { 0x0013, "Discovering",
15446                         mgmt_discovering_evt, 2, true },
15447         { 0x0014, "Device Blocked",
15448                         mgmt_device_blocked_evt, 7, true },
15449         { 0x0015, "Device Unblocked",
15450                         mgmt_device_unblocked_evt, 7, true },
15451         { 0x0016, "Device Unpaired",
15452                         mgmt_device_unpaired_evt, 7, true },
15453         { 0x0017, "Passkey Notify",
15454                         mgmt_passkey_notify_evt, 12, true },
15455         { 0x0018, "New Identity Resolving Key",
15456                         mgmt_new_identity_resolving_key_evt, 30, true },
15457         { 0x0019, "New Signature Resolving Key",
15458                         mgmt_new_signature_resolving_key_evt, 25, true },
15459         { 0x001a, "Device Added",
15460                         mgmt_device_added_evt, 8, true },
15461         { 0x001b, "Device Removed",
15462                         mgmt_device_removed_evt, 7, true },
15463         { 0x001c, "New Connection Parameter",
15464                         mgmt_new_connection_parameter_evt, 16, true },
15465         { 0x001d, "Unconfigured Index Added",
15466                         mgmt_null_evt, 0, true },
15467         { 0x001e, "Unconfigured Index Removed",
15468                         mgmt_null_evt, 0, true },
15469         { 0x001f, "New Configuration Options",
15470                         mgmt_new_conf_options_evt, 4, true },
15471         { 0x0020, "Extended Index Added",
15472                         mgmt_ext_index_added_evt, 2, true },
15473         { 0x0021, "Extended Index Removed",
15474                         mgmt_ext_index_removed_evt, 2, true },
15475         { 0x0022, "Local Out Of Band Extended Data Updated",
15476                         mgmt_local_oob_ext_data_updated_evt, 3, false },
15477         { 0x0023, "Advertising Added",
15478                         mgmt_advertising_added_evt, 1, true },
15479         { 0x0024, "Advertising Removed",
15480                         mgmt_advertising_removed_evt, 1, true },
15481         { 0x0025, "Extended Controller Information Changed",
15482                         mgmt_ext_controller_info_changed_evt, 2, false },
15483         { 0x0026, "PHY Configuration Changed",
15484                         mgmt_phy_changed_evt, 4, true },
15485         { 0x0027, "Experimental Feature Changed",
15486                         mgmt_exp_feature_changed_evt, 20, true },
15487         { 0x002a, "Device Flags Changed",
15488                         mgmt_device_flags_changed_evt, 15, true },
15489         { 0x002b, "Advertisement Monitor Added",
15490                         mgmt_adv_monitor_added_evt, 2, true },
15491         { 0x002c, "Advertisement Monitor Removed",
15492                         mgmt_adv_monitor_removed_evt, 2, true },
15493         { 0x002d, "Controller Suspended",
15494                         mgmt_controller_suspend_evt, 1, true },
15495         { 0x002e, "Controller Resumed",
15496                         mgmt_controller_resume_evt, 8, true },
15497         { 0x002f, "ADV Monitor Device Found",
15498                         mgmt_adv_monitor_device_found_evt, 16, false },
15499         { 0x0030, "ADV Monitor Device Lost",
15500                         mgmt_adv_monitor_device_lost_evt, 9, true },
15501         { 0x0031, "Mesh Device Found",
15502                         mgmt_mesh_device_found_evt, 22, false },
15503         { 0x0032, "Mesh Packet Complete",
15504                         mgmt_mesh_packet_cmplt_evt, 1, true },
15505         { }
15506 };
15507
15508 static void mgmt_print_commands(const void *data, uint16_t num)
15509 {
15510         int i;
15511
15512         print_field("Commands: %u", num);
15513
15514         for (i = 0; i < num; i++) {
15515                 uint16_t opcode = get_le16(data + (i * 2));
15516                 const char *str = NULL;
15517                 int n;
15518
15519                 for (n = 0; mgmt_command_table[n].str; n++) {
15520                         if (mgmt_command_table[n].opcode == opcode) {
15521                                 str = mgmt_command_table[n].str;
15522                                 break;
15523                         }
15524                 }
15525
15526                 print_field("  %s (0x%4.4x)", str ?: "Reserved", opcode);
15527         }
15528 }
15529
15530 static void mgmt_print_events(const void *data, uint16_t num)
15531 {
15532         int i;
15533
15534         print_field("Events: %u", num);
15535
15536         for (i = 0; i < num; i++) {
15537                 uint16_t opcode = get_le16(data + (i * 2));
15538                 const char *str = NULL;
15539                 int n;
15540
15541                 for (n = 0; mgmt_event_table[n].str; n++) {
15542                         if (mgmt_event_table[n].opcode == opcode) {
15543                                 str = mgmt_event_table[n].str;
15544                                 break;
15545                         }
15546                 }
15547
15548                 print_field("  %s (0x%4.4x)", str ?: "Reserved", opcode);
15549         }
15550 }
15551
15552 void packet_ctrl_command(struct timeval *tv, struct ucred *cred, uint16_t index,
15553                                         const void *data, uint16_t size)
15554 {
15555         uint32_t cookie;
15556         uint16_t format, opcode;
15557         const struct mgmt_data *mgmt_data = NULL;
15558         const char *mgmt_color, *mgmt_str;
15559         char channel[11], extra_str[25];
15560         int i;
15561
15562         if (size < 4) {
15563                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15564                                 "Malformed Control Command packet", NULL, NULL);
15565                 packet_hexdump(data, size);
15566                 return;
15567         }
15568
15569         cookie = get_le32(data);
15570
15571         data += 4;
15572         size -= 4;
15573
15574         sprintf(channel, "0x%4.4x", cookie);
15575
15576         format = get_format(cookie);
15577
15578         if (format != CTRL_MGMT) {
15579                 char label[7];
15580
15581                 sprintf(label, "0x%4.4x", format);
15582
15583                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
15584                                                 "Control Command", label, NULL);
15585                 packet_hexdump(data, size);
15586                 return;
15587         }
15588
15589         if (size < 2) {
15590                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15591                                 "Malformed MGMT Command packet", NULL, NULL);
15592                 packet_hexdump(data, size);
15593                 return;
15594         }
15595
15596         opcode = get_le16(data);
15597
15598         data += 2;
15599         size -= 2;
15600
15601         for (i = 0; mgmt_command_table[i].str; i++) {
15602                 if (mgmt_command_table[i].opcode == opcode) {
15603                         mgmt_data = &mgmt_command_table[i];
15604                         break;
15605                 }
15606         }
15607
15608         if (mgmt_data) {
15609                 if (mgmt_data->func)
15610                         mgmt_color = COLOR_CTRL_COMMAND;
15611                 else
15612                         mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
15613                 mgmt_str = mgmt_data->str;
15614         } else {
15615                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
15616                 mgmt_str = "Unknown";
15617         }
15618
15619         sprintf(extra_str, "(0x%4.4x) plen %d", opcode, size);
15620
15621         print_packet(tv, cred, '@', index, channel, mgmt_color,
15622                                         "MGMT Command", mgmt_str, extra_str);
15623
15624         if (!mgmt_data || !mgmt_data->func) {
15625                 packet_hexdump(data, size);
15626                 return;
15627         }
15628
15629         if (mgmt_data->fixed) {
15630                 if (size != mgmt_data->size) {
15631                         print_text(COLOR_ERROR, "invalid packet size");
15632                         packet_hexdump(data, size);
15633                         return;
15634                 }
15635         } else {
15636                 if (size < mgmt_data->size) {
15637                         print_text(COLOR_ERROR, "too short packet");
15638                         packet_hexdump(data, size);
15639                         return;
15640                 }
15641         }
15642
15643         mgmt_data->func(data, size);
15644 }
15645
15646 void packet_ctrl_event(struct timeval *tv, struct ucred *cred, uint16_t index,
15647                                         const void *data, uint16_t size)
15648 {
15649         uint32_t cookie;
15650         uint16_t format, opcode;
15651         const struct mgmt_data *mgmt_data = NULL;
15652         const char *mgmt_color, *mgmt_str;
15653         char channel[11], extra_str[25];
15654         int i;
15655
15656         if (size < 4) {
15657                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15658                                 "Malformed Control Event packet", NULL, NULL);
15659                 packet_hexdump(data, size);
15660                 return;
15661         }
15662
15663         cookie = get_le32(data);
15664
15665         data += 4;
15666         size -= 4;
15667
15668         sprintf(channel, "0x%4.4x", cookie);
15669
15670         format = get_format(cookie);
15671
15672         if (format != CTRL_MGMT) {
15673                 char label[7];
15674
15675                 sprintf(label, "0x%4.4x", format);
15676
15677                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
15678                                                 "Control Event", label, NULL);
15679                 packet_hexdump(data, size);
15680                 return;
15681         }
15682
15683         if (size < 2) {
15684                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15685                                 "Malformed MGMT Event packet", NULL, NULL);
15686                 packet_hexdump(data, size);
15687                 return;
15688         }
15689
15690         opcode = get_le16(data);
15691
15692         data += 2;
15693         size -= 2;
15694
15695         for (i = 0; mgmt_event_table[i].str; i++) {
15696                 if (mgmt_event_table[i].opcode == opcode) {
15697                         mgmt_data = &mgmt_event_table[i];
15698                         break;
15699                 }
15700         }
15701
15702         if (mgmt_data) {
15703                 if (mgmt_data->func)
15704                         mgmt_color = COLOR_CTRL_EVENT;
15705                 else
15706                         mgmt_color = COLOR_CTRL_EVENT_UNKNOWN;
15707                 mgmt_str = mgmt_data->str;
15708         } else {
15709                 mgmt_color = COLOR_CTRL_EVENT_UNKNOWN;
15710                 mgmt_str = "Unknown";
15711         }
15712
15713         sprintf(extra_str, "(0x%4.4x) plen %d", opcode, size);
15714
15715         print_packet(tv, cred, '@', index, channel, mgmt_color,
15716                                         "MGMT Event", mgmt_str, extra_str);
15717
15718         if (!mgmt_data || !mgmt_data->func) {
15719                 packet_hexdump(data, size);
15720                 return;
15721         }
15722
15723         if (mgmt_data->fixed) {
15724                 if (size != mgmt_data->size) {
15725                         print_text(COLOR_ERROR, "invalid packet size");
15726                         packet_hexdump(data, size);
15727                         return;
15728                 }
15729         } else {
15730                 if (size < mgmt_data->size) {
15731                         print_text(COLOR_ERROR, "too short packet");
15732                         packet_hexdump(data, size);
15733                         return;
15734                 }
15735         }
15736
15737         mgmt_data->func(data, size);
15738 }
15739
15740 void packet_todo(void)
15741 {
15742         int i;
15743
15744         printf("HCI commands with missing decodings:\n");
15745
15746         for (i = 0; opcode_table[i].str; i++) {
15747                 if (opcode_table[i].bit < 0)
15748                         continue;
15749
15750                 if (opcode_table[i].cmd_func)
15751                         continue;
15752
15753                 printf("\t%s\n", opcode_table[i].str);
15754         }
15755
15756         printf("HCI events with missing decodings:\n");
15757
15758         for (i = 0; event_table[i].str; i++) {
15759                 if (event_table[i].func)
15760                         continue;
15761
15762                 printf("\t%s\n", event_table[i].str);
15763         }
15764
15765         for (i = 0; le_meta_event_table[i].str; i++) {
15766                 if (le_meta_event_table[i].func)
15767                         continue;
15768
15769                 printf("\t%s\n", le_meta_event_table[i].str);
15770         }
15771 }
15772
15773 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15774 void print_le_set_adv_parameters_cmd(const void *data, uint8_t size)
15775 {
15776         uint16_t dummy = 0;
15777         le_set_adv_parameters_cmd(dummy, data, size);
15778 }
15779
15780 void print_le_set_random_address_cmd(const void *data, uint8_t size)
15781 {
15782         uint16_t dummy = 0;
15783         le_set_random_address_cmd(dummy, data, size);
15784 }
15785
15786 void print_le_set_adv_data_cmd(const void *data, uint8_t size)
15787 {
15788         uint16_t dummy = 0;
15789         le_set_adv_data_cmd(dummy, data, size);
15790 }
15791
15792 void print_le_set_scan_rsp_data_cmd(const void *data, uint8_t size)
15793 {
15794         uint16_t dummy = 0;
15795         le_set_scan_rsp_data_cmd(dummy, data, size);
15796 }
15797
15798 void print_le_set_adv_enable_cmd(const void *data, uint8_t size)
15799 {
15800         uint16_t dummy = 0;
15801         le_set_adv_enable_cmd(dummy, data, size);
15802 }
15803 #endif