monitor/packet.c

   1 // SPDX-License-Identifier: LGPL-2.1-or-later
   2 /*
   3  *
   4  *  BlueZ - Bluetooth protocol stack for Linux
   5  *
   6  *  Copyright (C) 2011-2014  Intel Corporation
   7  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
   8  *  Copyright 2023 NXP
   9  *
  10  *
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 #include <config.h>
  15 #endif
  16
  17 #include <stdio.h>
  18 #include <errno.h>
  19 #include <ctype.h>
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <stdbool.h>
  24 #include <inttypes.h>
  25 #include <time.h>
  26 #include <sys/time.h>
  27 #include <sys/socket.h>
  28
  29 #include "lib/bluetooth.h"
  30 #include "lib/uuid.h"
  31 #include "lib/hci.h"
  32 #include "lib/hci_lib.h"
  33
  34 #include "src/shared/util.h"
  35 #include "src/shared/btsnoop.h"
  36 #include "src/shared/queue.h"
  37 #include "display.h"
  38 #include "bt.h"
  39 #include "ll.h"
  40 #include "hwdb.h"
  41 #include "keys.h"
  42 #include "packet.h"
  43 #include "l2cap.h"
  44 #include "control.h"
  45 #include "vendor.h"
  46 #include "msft.h"
  47 #include "intel.h"
  48 #include "broadcom.h"
  49
  50 #define COLOR_CHANNEL_LABEL             COLOR_WHITE
  51 #define COLOR_FRAME_LABEL               COLOR_WHITE
  52 #define COLOR_INDEX_LABEL               COLOR_WHITE
  53 #define COLOR_TIMESTAMP                 COLOR_YELLOW
  54
  55 #define COLOR_NEW_INDEX                 COLOR_GREEN
  56 #define COLOR_DEL_INDEX                 COLOR_RED
  57 #define COLOR_OPEN_INDEX                COLOR_GREEN
  58 #define COLOR_CLOSE_INDEX               COLOR_RED
  59 #define COLOR_INDEX_INFO                COLOR_GREEN
  60 #define COLOR_VENDOR_DIAG               COLOR_YELLOW
  61 #define COLOR_SYSTEM_NOTE               COLOR_OFF
  62
  63 #define COLOR_HCI_COMMAND               COLOR_BLUE
  64 #define COLOR_HCI_COMMAND_UNKNOWN       COLOR_WHITE_BG
  65 #define COLOR_HCI_EVENT                 COLOR_MAGENTA
  66 #define COLOR_HCI_EVENT_UNKNOWN         COLOR_WHITE_BG
  67 #define COLOR_HCI_ACLDATA               COLOR_CYAN
  68 #define COLOR_HCI_SCODATA               COLOR_YELLOW
  69 #define COLOR_HCI_ISODATA               COLOR_YELLOW
  70
  71 #define COLOR_UNKNOWN_ERROR             COLOR_WHITE_BG
  72 #define COLOR_UNKNOWN_FEATURE_BIT       COLOR_WHITE_BG
  73 #define COLOR_UNKNOWN_COMMAND_BIT       COLOR_WHITE_BG
  74 #define COLOR_UNKNOWN_EVENT_MASK        COLOR_WHITE_BG
  75 #define COLOR_UNKNOWN_LE_STATES         COLOR_WHITE_BG
  76 #define COLOR_UNKNOWN_SERVICE_CLASS     COLOR_WHITE_BG
  77 #define COLOR_UNKNOWN_PKT_TYPE_BIT      COLOR_WHITE_BG
  78
  79 #define COLOR_CTRL_OPEN                 COLOR_GREEN_BOLD
  80 #define COLOR_CTRL_CLOSE                COLOR_RED_BOLD
  81 #define COLOR_CTRL_COMMAND              COLOR_BLUE_BOLD
  82 #define COLOR_CTRL_COMMAND_UNKNOWN      COLOR_WHITE_BG
  83 #define COLOR_CTRL_EVENT                COLOR_MAGENTA_BOLD
  84 #define COLOR_CTRL_EVENT_UNKNOWN        COLOR_WHITE_BG
  85
  86 #define COLOR_UNKNOWN_OPTIONS_BIT       COLOR_WHITE_BG
  87 #define COLOR_UNKNOWN_SETTINGS_BIT      COLOR_WHITE_BG
  88 #define COLOR_UNKNOWN_ADDRESS_TYPE      COLOR_WHITE_BG
  89 #define COLOR_UNKNOWN_DEVICE_FLAG       COLOR_WHITE_BG
  90 #define COLOR_UNKNOWN_EXP_FEATURE_FLAG  COLOR_WHITE_BG
  91 #define COLOR_UNKNOWN_ADV_FLAG          COLOR_WHITE_BG
  92 #define COLOR_UNKNOWN_PHY               COLOR_WHITE_BG
  93 #define COLOR_UNKNOWN_ADDED_DEVICE_FLAG COLOR_WHITE_BG
  94 #define COLOR_UNKNOWN_ADVMON_FEATURES   COLOR_WHITE_BG
  95
  96 #define COLOR_PHY_PACKET                COLOR_BLUE
  97
  98 #define UNKNOWN_MANUFACTURER 0xffff
  99
 100 static time_t time_offset = ((time_t) -1);
 101 static int priority_level = BTSNOOP_PRIORITY_INFO;
 102 static unsigned long filter_mask = 0;
 103 static bool index_filter = false;
 104 static uint16_t index_current = 0;
 105 static uint16_t fallback_manufacturer = UNKNOWN_MANUFACTURER;
 106
 107 #define CTRL_RAW  0x0000
 108 #define CTRL_USER 0x0001
 109 #define CTRL_MGMT 0x0002
 110
 111 #define MAX_CTRL 64
 112
 113 struct ctrl_data {
 114         bool used;
 115         uint32_t cookie;
 116         uint16_t format;
 117         char name[20];
 118 };
 119
 120 static struct ctrl_data ctrl_list[MAX_CTRL];
 121
 122 static void assign_ctrl(uint32_t cookie, uint16_t format, const char *name)
 123 {
 124         int i;
 125
 126         for (i = 0; i < MAX_CTRL; i++) {
 127                 if (!ctrl_list[i].used) {
 128                         ctrl_list[i].used = true;
 129                         ctrl_list[i].cookie = cookie;
 130                         ctrl_list[i].format = format;
 131                         if (name) {
 132                                 strncpy(ctrl_list[i].name, name, 19);
 133                                 ctrl_list[i].name[19] = '\0';
 134                         } else
 135                                 strcpy(ctrl_list[i].name, "null");
 136                         break;
 137                 }
 138         }
 139 }
 140
 141 static void release_ctrl(uint32_t cookie, uint16_t *format, char *name)
 142 {
 143         int i;
 144
 145         if (format)
 146                 *format = 0xffff;
 147
 148         for (i = 0; i < MAX_CTRL; i++) {
 149                 if (ctrl_list[i].used && ctrl_list[i].cookie == cookie) {
 150                         ctrl_list[i].used = false;
 151                         if (format)
 152                                 *format = ctrl_list[i].format;
 153                         if (name)
 154                                 strncpy(name, ctrl_list[i].name, 20);
 155                         break;
 156                 }
 157         }
 158 }
 159
 160 static uint16_t get_format(uint32_t cookie)
 161 {
 162         int i;
 163
 164         for (i = 0; i < MAX_CTRL; i++) {
 165                 if (ctrl_list[i].used && ctrl_list[i].cookie == cookie)
 166                         return ctrl_list[i].format;
 167         }
 168
 169         return 0xffff;
 170 }
 171
 172 #define MAX_CONN 16
 173
 174 static struct packet_conn_data conn_list[MAX_CONN];
 175
 176 static struct packet_conn_data *lookup_parent(uint16_t handle)
 177 {
 178         int i;
 179
 180         for (i = 0; i < MAX_CONN; i++) {
 181                 if (conn_list[i].link == handle)
 182                         return &conn_list[i];
 183         }
 184
 185         return NULL;
 186 }
 187
 188 static void assign_handle(uint16_t index, uint16_t handle, uint8_t type,
 189                                         uint8_t *dst, uint8_t dst_type)
 190 {
 191         int i;
 192
 193         for (i = 0; i < MAX_CONN; i++) {
 194                 if (conn_list[i].handle == 0x0000) {
 195                         hci_devba(index, (bdaddr_t *)conn_list[i].src);
 196
 197                         conn_list[i].index = index;
 198                         conn_list[i].handle = handle;
 199                         conn_list[i].type = type;
 200
 201                         if (!dst) {
 202                                 struct packet_conn_data *p;
 203
 204                                 /* If destination is not set attempt to use the
 205                                  * parent one if that exists.
 206                                  */
 207                                 p = lookup_parent(handle);
 208                                 if (p) {
 209                                         memcpy(conn_list[i].dst, p->dst,
 210                                                 sizeof(conn_list[i].dst));
 211                                         conn_list[i].dst_type = p->dst_type;
 212                                 }
 213
 214                                 break;
 215                         }
 216
 217                         memcpy(conn_list[i].dst, dst, sizeof(conn_list[i].dst));
 218                         conn_list[i].dst_type = dst_type;
 219                         break;
 220                 }
 221         }
 222 }
 223
 224 static void release_handle(uint16_t handle)
 225 {
 226         int i;
 227
 228         for (i = 0; i < MAX_CONN; i++) {
 229                 struct packet_conn_data *conn = &conn_list[i];
 230
 231                 if (conn->handle == handle) {
 232                         if (conn->destroy)
 233                                 conn->destroy(conn->data);
 234
 235                         queue_destroy(conn->tx_q, free);
 236                         queue_destroy(conn->chan_q, free);
 237                         memset(conn, 0, sizeof(*conn));
 238                         break;
 239                 }
 240         }
 241 }
 242
 243 struct packet_conn_data *packet_get_conn_data(uint16_t handle)
 244 {
 245         int i;
 246
 247         for (i = 0; i < MAX_CONN; i++) {
 248                 if (conn_list[i].handle == handle)
 249                         return &conn_list[i];
 250         }
 251
 252         return NULL;
 253 }
 254
 255 static uint8_t get_type(uint16_t handle)
 256 {
 257         struct packet_conn_data *conn;
 258
 259         conn = packet_get_conn_data(handle);
 260         if (!conn)
 261                 return 0xff;
 262
 263         return conn->type;
 264 }
 265
 266 bool packet_has_filter(unsigned long filter)
 267 {
 268         return filter_mask & filter;
 269 }
 270
 271 void packet_set_filter(unsigned long filter)
 272 {
 273         filter_mask = filter;
 274 }
 275
 276 void packet_add_filter(unsigned long filter)
 277 {
 278         if (index_filter)
 279                 filter &= ~PACKET_FILTER_SHOW_INDEX;
 280
 281         filter_mask |= filter;
 282 }
 283
 284 void packet_del_filter(unsigned long filter)
 285 {
 286         filter_mask &= ~filter;
 287 }
 288
 289 void packet_set_priority(const char *priority)
 290 {
 291         if (!priority)
 292                 return;
 293
 294         if (!strcasecmp(priority, "debug"))
 295                 priority_level = BTSNOOP_PRIORITY_DEBUG;
 296         else
 297                 priority_level = atoi(priority);
 298 }
 299
 300 void packet_select_index(uint16_t index)
 301 {
 302         filter_mask &= ~PACKET_FILTER_SHOW_INDEX;
 303
 304         control_filter_index(index);
 305
 306         index_filter = true;
 307 }
 308
 309 #define print_space(x) printf("%*c", (x), ' ');
 310
 311 #define MAX_INDEX 16
 312
 313 struct index_data {
 314         uint8_t  type;
 315         uint8_t  bdaddr[6];
 316         uint16_t manufacturer;
 317         uint16_t msft_opcode;
 318         uint8_t  msft_evt_prefix[8];
 319         uint8_t  msft_evt_len;
 320         size_t   frame;
 321 };
 322
 323 static struct index_data index_list[MAX_INDEX];
 324
 325 void packet_set_fallback_manufacturer(uint16_t manufacturer)
 326 {
 327         int i;
 328
 329         for (i = 0; i < MAX_INDEX; i++)
 330                 index_list[i].manufacturer = manufacturer;
 331
 332         fallback_manufacturer = manufacturer;
 333 }
 334
 335 void packet_set_msft_evt_prefix(const uint8_t *prefix, uint8_t len)
 336 {
 337         if (index_current < MAX_INDEX && len < 8)
 338                 memcpy(index_list[index_current].msft_evt_prefix, prefix, len);
 339 }
 340
 341 static void cred_pid(struct ucred *cred, char *str, size_t len)
 342 {
 343         char *path = alloca(24);
 344         char line[128];
 345         FILE *fp;
 346
 347         snprintf(path, 23, "/proc/%u/comm", cred->pid);
 348
 349         fp = fopen(path, "re");
 350         if (fp) {
 351                 if (fgets(line, sizeof(line), fp)) {
 352                         line[strcspn(line, "\r\n")] = '\0';
 353                         snprintf(str, len, "%s[%u]", line, cred->pid);
 354                 } else
 355                         snprintf(str, len, "[%u]", cred->pid);
 356                 fclose(fp);
 357         } else
 358                 snprintf(str, len, "[%u]", cred->pid);
 359 }
 360
 361 static void print_packet(struct timeval *tv, struct ucred *cred, char ident,
 362                                         uint16_t index, const char *channel,
 363                                         const char *color, const char *label,
 364                                         const char *text, const char *extra)
 365 {
 366         int col = num_columns();
 367         char line[256], ts_str[96], pid_str[140];
 368         int n, ts_len = 0, ts_pos = 0, len = 0, pos = 0;
 369         static size_t last_frame;
 370
 371         if (channel) {
 372                 if (use_color()) {
 373                         n = sprintf(ts_str + ts_pos, "%s", COLOR_CHANNEL_LABEL);
 374                         if (n > 0)
 375                                 ts_pos += n;
 376                 }
 377
 378                 n = sprintf(ts_str + ts_pos, " {%s}", channel);
 379                 if (n > 0) {
 380                         ts_pos += n;
 381                         ts_len += n;
 382                 }
 383         } else if (index != HCI_DEV_NONE && index < MAX_INDEX &&
 384                                 index_list[index].frame != last_frame) {
 385                 if (use_color()) {
 386                         n = sprintf(ts_str + ts_pos, "%s", COLOR_FRAME_LABEL);
 387                         if (n > 0)
 388                                 ts_pos += n;
 389                 }
 390
 391                 n = sprintf(ts_str + ts_pos, " #%zu", index_list[index].frame);
 392                 if (n > 0) {
 393                         ts_pos += n;
 394                         ts_len += n;
 395                 }
 396                 last_frame = index_list[index].frame;
 397         }
 398
 399         if ((filter_mask & PACKET_FILTER_SHOW_INDEX) &&
 400                                         index != HCI_DEV_NONE) {
 401                 if (use_color()) {
 402                         n = snprintf(ts_str + ts_pos, sizeof(ts_str) - ts_pos,
 403                                      "%s", COLOR_INDEX_LABEL);
 404                         if (n > 0)
 405                                 ts_pos += n;
 406                 }
 407
 408                 n = sprintf(ts_str + ts_pos, " [hci%d]", index);
 409                 if (n > 0) {
 410                         ts_pos += n;
 411                         ts_len += n;
 412                 }
 413         }
 414
 415         if (tv) {
 416                 time_t t = tv->tv_sec;
 417                 struct tm tm;
 418
 419                 localtime_r(&t, &tm);
 420
 421                 if (use_color()) {
 422                         n = sprintf(ts_str + ts_pos, "%s", COLOR_TIMESTAMP);
 423                         if (n > 0)
 424                                 ts_pos += n;
 425                 }
 426
 427                 if (filter_mask & PACKET_FILTER_SHOW_DATE) {
 428                         n = sprintf(ts_str + ts_pos, " %04d-%02d-%02d",
 429                                 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
 430                         if (n > 0) {
 431                                 ts_pos += n;
 432                                 ts_len += n;
 433                         }
 434                 }
 435
 436                 if (filter_mask & PACKET_FILTER_SHOW_TIME) {
 437                         n = sprintf(ts_str + ts_pos, " %02d:%02d:%02d.%06llu",
 438                                 tm.tm_hour, tm.tm_min, tm.tm_sec,
 439                                 (long long)tv->tv_usec);
 440                         if (n > 0) {
 441                                 ts_pos += n;
 442                                 ts_len += n;
 443                         }
 444                 }
 445
 446                 if (filter_mask & PACKET_FILTER_SHOW_TIME_OFFSET) {
 447                         n = sprintf(ts_str + ts_pos, " %llu.%06llu",
 448                                 (long long)(tv->tv_sec - time_offset),
 449                                 (long long)tv->tv_usec);
 450                         if (n > 0) {
 451                                 ts_pos += n;
 452                                 ts_len += n;
 453                         }
 454                 }
 455         }
 456
 457         if (use_color()) {
 458                 sprintf(ts_str + ts_pos, "%s", COLOR_OFF);
 459                 n = sprintf(line + pos, "%s", color);
 460                 if (n > 0)
 461                         pos += n;
 462         }
 463
 464         if (cred && cred->pid) {
 465                 cred_pid(cred, pid_str, sizeof(pid_str));
 466                 n = sprintf(line + pos, "%s: %c %s", pid_str, ident,
 467                                                 label ? label : "");
 468         } else
 469                 n = sprintf(line + pos, "%c %s", ident, label ? label : "");
 470
 471         if (n > 0) {
 472                 pos += n;
 473                 len += n;
 474         }
 475
 476         if (text) {
 477                 int extra_len = extra ? strlen(extra) : 0;
 478                 int max_len = col - len - extra_len - ts_len - 3;
 479
 480                 n = snprintf(line + pos, max_len + 1, "%s%s",
 481                                                 label ? ": " : "", text);
 482                 if (n > max_len) {
 483                         line[pos + max_len - 1] = '.';
 484                         line[pos + max_len - 2] = '.';
 485                         if (line[pos + max_len - 3] == ' ')
 486                                 line[pos + max_len - 3] = '.';
 487
 488                         n = max_len;
 489                 }
 490
 491                 if (n > 0) {
 492                         pos += n;
 493                         len += n;
 494                 }
 495         }
 496
 497         if (use_color()) {
 498                 n = sprintf(line + pos, "%s", COLOR_OFF);
 499                 if (n > 0)
 500                         pos += n;
 501         }
 502
 503         if (extra) {
 504                 n = sprintf(line + pos, " %s", extra);
 505                 if (n > 0)
 506                         len += n;
 507         }
 508
 509         if (ts_len > 0) {
 510                 printf("%s", line);
 511                 if (len < col)
 512                         print_space(col - len - ts_len - 1);
 513                 printf("%s%s\n", use_color() ? COLOR_TIMESTAMP : "", ts_str);
 514         } else
 515                 printf("%s\n", line);
 516 }
 517
 518 static const struct {
 519         uint8_t error;
 520         const char *str;
 521 } error2str_table[] = {
 522         { 0x00, "Success"                                               },
 523         { 0x01, "Unknown HCI Command"                                   },
 524         { 0x02, "Unknown Connection Identifier"                         },
 525         { 0x03, "Hardware Failure"                                      },
 526         { 0x04, "Page Timeout"                                          },
 527         { 0x05, "Authentication Failure"                                },
 528         { 0x06, "PIN or Key Missing"                                    },
 529         { 0x07, "Memory Capacity Exceeded"                              },
 530         { 0x08, "Connection Timeout"                                    },
 531         { 0x09, "Connection Limit Exceeded"                             },
 532         { 0x0a, "Synchronous Connection Limit to a Device Exceeded"     },
 533         { 0x0b, "ACL Connection Already Exists"                         },
 534         { 0x0c, "Command Disallowed"                                    },
 535         { 0x0d, "Connection Rejected due to Limited Resources"          },
 536         { 0x0e, "Connection Rejected due to Security Reasons"           },
 537         { 0x0f, "Connection Rejected due to Unacceptable BD_ADDR"       },
 538         { 0x10, "Connection Accept Timeout Exceeded"                    },
 539         { 0x11, "Unsupported Feature or Parameter Value"                },
 540         { 0x12, "Invalid HCI Command Parameters"                        },
 541         { 0x13, "Remote User Terminated Connection"                     },
 542         { 0x14, "Remote Device Terminated due to Low Resources"         },
 543         { 0x15, "Remote Device Terminated due to Power Off"             },
 544         { 0x16, "Connection Terminated By Local Host"                   },
 545         { 0x17, "Repeated Attempts"                                     },
 546         { 0x18, "Pairing Not Allowed"                                   },
 547         { 0x19, "Unknown LMP PDU"                                       },
 548         { 0x1a, "Unsupported Remote Feature / Unsupported LMP Feature"  },
 549         { 0x1b, "SCO Offset Rejected"                                   },
 550         { 0x1c, "SCO Interval Rejected"                                 },
 551         { 0x1d, "SCO Air Mode Rejected"                                 },
 552         { 0x1e, "Invalid LMP Parameters / Invalid LL Parameters"        },
 553         { 0x1f, "Unspecified Error"                                     },
 554         { 0x20, "Unsupported LMP Parameter Value / "
 555                 "Unsupported LL Parameter Value"                        },
 556         { 0x21, "Role Change Not Allowed"                               },
 557         { 0x22, "LMP Response Timeout / LL Response Timeout"            },
 558         { 0x23, "LMP Error Transaction Collision"                       },
 559         { 0x24, "LMP PDU Not Allowed"                                   },
 560         { 0x25, "Encryption Mode Not Acceptable"                        },
 561         { 0x26, "Link Key cannot be Changed"                            },
 562         { 0x27, "Requested QoS Not Supported"                           },
 563         { 0x28, "Instant Passed"                                        },
 564         { 0x29, "Pairing With Unit Key Not Supported"                   },
 565         { 0x2a, "Different Transaction Collision"                       },
 566         { 0x2b, "Reserved"                                              },
 567         { 0x2c, "QoS Unacceptable Parameter"                            },
 568         { 0x2d, "QoS Rejected"                                          },
 569         { 0x2e, "Channel Classification Not Supported"                  },
 570         { 0x2f, "Insufficient Security"                                 },
 571         { 0x30, "Parameter Out Of Manadatory Range"                     },
 572         { 0x31, "Reserved"                                              },
 573         { 0x32, "Role Switch Pending"                                   },
 574         { 0x33, "Reserved"                                              },
 575         { 0x34, "Reserved Slot Violation"                               },
 576         { 0x35, "Role Switch Failed"                                    },
 577         { 0x36, "Extended Inquiry Response Too Large"                   },
 578         { 0x37, "Secure Simple Pairing Not Supported By Host"           },
 579         { 0x38, "Host Busy - Pairing"                                   },
 580         { 0x39, "Connection Rejected due to No Suitable Channel Found"  },
 581         { 0x3a, "Controller Busy"                                       },
 582         { 0x3b, "Unacceptable Connection Parameters"                    },
 583         { 0x3c, "Advertising Timeout"                                   },
 584         { 0x3d, "Connection Terminated due to MIC Failure"              },
 585         { 0x3e, "Connection Failed to be Established"                   },
 586         { 0x3f, "MAC Connection Failed"                                 },
 587         { 0x40, "Coarse Clock Adjustment Rejected "
 588                 "but Will Try to Adjust Using Clock Dragging"           },
 589         { 0x41, "Type0 Submap Not Defined"                              },
 590         { 0x42, "Unknown Advertising Identifier"                        },
 591         { 0x43, "Limit Reached"                                         },
 592         { 0x44, "Operation Cancelled by Host"                           },
 593         { 0x45, "Packet Too Long"                                       },
 594         { }
 595 };
 596
 597 static void print_error(const char *label, uint8_t error)
 598 {
 599         const char *str = "Unknown";
 600         const char *color_on, *color_off;
 601         bool unknown = true;
 602         int i;
 603
 604         for (i = 0; error2str_table[i].str; i++) {
 605                 if (error2str_table[i].error == error) {
 606                         str = error2str_table[i].str;
 607                         unknown = false;
 608                         break;
 609                 }
 610         }
 611
 612         if (use_color()) {
 613                 if (error) {
 614                         if (unknown)
 615                                 color_on = COLOR_UNKNOWN_ERROR;
 616                         else
 617                                 color_on = COLOR_RED;
 618                 } else
 619                         color_on = COLOR_GREEN;
 620                 color_off = COLOR_OFF;
 621         } else {
 622                 color_on = "";
 623                 color_off = "";
 624         }
 625
 626         print_field("%s: %s%s%s (0x%2.2x)", label,
 627                                 color_on, str, color_off, error);
 628 }
 629
 630 static void print_status(uint8_t status)
 631 {
 632         print_error("Status", status);
 633 }
 634
 635 static void print_reason(uint8_t reason)
 636 {
 637         print_error("Reason", reason);
 638 }
 639
 640 void packet_print_error(const char *label, uint8_t error)
 641 {
 642         print_error(label, error);
 643 }
 644
 645 static void print_enable(const char *label, uint8_t enable)
 646 {
 647         const char *str;
 648
 649         switch (enable) {
 650         case 0x00:
 651                 str = "Disabled";
 652                 break;
 653         case 0x01:
 654                 str = "Enabled";
 655                 break;
 656         default:
 657                 str = "Reserved";
 658                 break;
 659         }
 660
 661         print_field("%s: %s (0x%2.2x)", label, str, enable);
 662 }
 663
 664 static void print_addr_type(const char *label, uint8_t addr_type)
 665 {
 666         const char *str;
 667
 668         switch (addr_type) {
 669         case 0x00:
 670                 str = "Public";
 671                 break;
 672         case 0x01:
 673                 str = "Random";
 674                 break;
 675         default:
 676                 str = "Reserved";
 677                 break;
 678         }
 679
 680         print_field("%s: %s (0x%2.2x)", label, str, addr_type);
 681 }
 682
 683 static void print_own_addr_type(uint8_t addr_type)
 684 {
 685         const char *str;
 686
 687         switch (addr_type) {
 688         case 0x00:
 689         case 0x02:
 690                 str = "Public";
 691                 break;
 692         case 0x01:
 693         case 0x03:
 694                 str = "Random";
 695                 break;
 696         default:
 697                 str = "Reserved";
 698                 break;
 699         }
 700
 701         print_field("Own address type: %s (0x%2.2x)", str, addr_type);
 702 }
 703
 704 static void print_peer_addr_type(const char *label, uint8_t addr_type)
 705 {
 706         const char *str;
 707
 708         switch (addr_type) {
 709         case 0x00:
 710                 str = "Public";
 711                 break;
 712         case 0x01:
 713                 str = "Random";
 714                 break;
 715         case 0x02:
 716                 str = "Resolved Public";
 717                 break;
 718         case 0x03:
 719                 str = "Resolved Random";
 720                 break;
 721         default:
 722                 str = "Reserved";
 723                 break;
 724         }
 725
 726         print_field("%s: %s (0x%2.2x)", label, str, addr_type);
 727 }
 728
 729 static void print_addr_resolve(const char *label, const uint8_t *addr,
 730                                         uint8_t addr_type, bool resolve)
 731 {
 732         const char *str;
 733         char *company;
 734
 735         switch (addr_type) {
 736         case 0x00:
 737         case 0x02:
 738                 if (!hwdb_get_company(addr, &company))
 739                         company = NULL;
 740
 741                 if (company) {
 742                         print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 743                                         " (%s)", label, addr[5], addr[4],
 744                                                         addr[3], addr[2],
 745                                                         addr[1], addr[0],
 746                                                         company);
 747                         free(company);
 748                 } else {
 749                         print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 750                                         " (OUI %2.2X-%2.2X-%2.2X)", label,
 751                                                 addr[5], addr[4], addr[3],
 752                                                 addr[2], addr[1], addr[0],
 753                                                 addr[5], addr[4], addr[3]);
 754                 }
 755                 break;
 756         case 0x01:
 757         case 0x03:
 758                 switch ((addr[5] & 0xc0) >> 6) {
 759                 case 0x00:
 760                         str = "Non-Resolvable";
 761                         break;
 762                 case 0x01:
 763                         str = "Resolvable";
 764                         break;
 765                 case 0x03:
 766                         str = "Static";
 767                         break;
 768                 default:
 769                         str = "Reserved";
 770                         break;
 771                 }
 772
 773                 print_field("%s: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X (%s)",
 774                                         label, addr[5], addr[4], addr[3],
 775                                         addr[2], addr[1], addr[0], str);
 776
 777                 if (resolve && (addr[5] & 0xc0) == 0x40) {
 778                         uint8_t ident[6], ident_type;
 779
 780                         if (keys_resolve_identity(addr, ident, &ident_type)) {
 781                                 print_addr_type("  Identity type", ident_type);
 782                                 print_addr_resolve("  Identity", ident,
 783                                                         ident_type, false);
 784                         }
 785                 }
 786                 break;
 787         default:
 788                 print_field("%s: %2.2X-%2.2X-%2.2X-%2.2X-%2.2X-%2.2X",
 789                                         label, addr[5], addr[4], addr[3],
 790                                         addr[2], addr[1], addr[0]);
 791                 break;
 792         }
 793 }
 794
 795 static void print_addr(const char *label, const uint8_t *addr, uint8_t type)
 796 {
 797         print_addr_resolve(label, addr, type, true);
 798 }
 799
 800 static void print_bdaddr(const uint8_t *bdaddr)
 801 {
 802         print_addr("Address", bdaddr, 0x00);
 803 }
 804
 805 static void print_lt_addr(uint8_t lt_addr)
 806 {
 807         print_field("LT address: %d", lt_addr);
 808 }
 809
 810 static void print_handle_native(uint16_t handle)
 811 {
 812         struct packet_conn_data *conn;
 813         char label[25];
 814
 815         conn = packet_get_conn_data(handle);
 816         if (!conn) {
 817                 print_field("Handle: %d", handle);
 818                 return;
 819         }
 820
 821         sprintf(label, "Handle: %d Address", handle);
 822         print_addr(label, conn->dst, conn->dst_type);
 823 }
 824
 825 static void print_handle(uint16_t handle)
 826 {
 827         print_handle_native(le16_to_cpu(handle));
 828 }
 829
 830 static void print_phy_handle(uint8_t phy_handle)
 831 {
 832         print_field("Physical handle: %d", phy_handle);
 833 }
 834
 835 static const struct bitfield_data pkt_type_table[] = {
 836         {  1, "2-DH1 may not be used"   },
 837         {  2, "3-DH1 may not be used"   },
 838         {  3, "DM1 may be used"         },
 839         {  4, "DH1 may be used"         },
 840         {  8, "2-DH3 may not be used"   },
 841         {  9, "3-DH3 may not be used"   },
 842         { 10, "DM3 may be used"         },
 843         { 11, "DH3 may be used"         },
 844         { 12, "2-DH5 may not be used"   },
 845         { 13, "3-DH5 may not be used"   },
 846         { 14, "DM5 may be used"         },
 847         { 15, "DH5 may be used"         },
 848         { }
 849 };
 850
 851 static void print_pkt_type(uint16_t pkt_type)
 852 {
 853         uint16_t mask = le16_to_cpu(pkt_type);
 854
 855         print_field("Packet type: 0x%4.4x", mask);
 856
 857         mask = print_bitfield(2, mask, pkt_type_table);
 858         if (mask)
 859                 print_text(COLOR_UNKNOWN_PKT_TYPE_BIT,
 860                                 "  Unknown packet types (0x%4.4x)", mask);
 861 }
 862
 863 static const struct bitfield_data pkt_type_sco_table[] = {
 864         {  0, "HV1 may be used"         },
 865         {  1, "HV2 may be used"         },
 866         {  2, "HV3 may be used"         },
 867         {  3, "EV3 may be used"         },
 868         {  4, "EV4 may be used"         },
 869         {  5, "EV5 may be used"         },
 870         {  6, "2-EV3 may not be used"   },
 871         {  7, "3-EV3 may not be used"   },
 872         {  8, "2-EV5 may not be used"   },
 873         {  9, "3-EV5 may not be used"   },
 874         { }
 875 };
 876
 877 static void print_pkt_type_sco(uint16_t pkt_type)
 878 {
 879         uint16_t mask = le16_to_cpu(pkt_type);
 880
 881         print_field("Packet type: 0x%4.4x", mask);
 882
 883         mask = print_bitfield(2, mask, pkt_type_sco_table);
 884         if (mask)
 885                 print_text(COLOR_UNKNOWN_PKT_TYPE_BIT,
 886                                 "  Unknown packet types (0x%4.4x)", mask);
 887 }
 888
 889 static void print_iac(const uint8_t *lap)
 890 {
 891         const char *str = "";
 892
 893         if (lap[2] == 0x9e && lap[1] == 0x8b) {
 894                 switch (lap[0]) {
 895                 case 0x33:
 896                         str = " (General Inquiry)";
 897                         break;
 898                 case 0x00:
 899                         str = " (Limited Inquiry)";
 900                         break;
 901                 }
 902         }
 903
 904         print_field("Access code: 0x%2.2x%2.2x%2.2x%s",
 905                                                 lap[2], lap[1], lap[0], str);
 906 }
 907
 908 static void print_auth_enable(uint8_t enable)
 909 {
 910         const char *str;
 911
 912         switch (enable) {
 913         case 0x00:
 914                 str = "Authentication not required";
 915                 break;
 916         case 0x01:
 917                 str = "Authentication required for all connections";
 918                 break;
 919         default:
 920                 str = "Reserved";
 921                 break;
 922         }
 923
 924         print_field("Enable: %s (0x%2.2x)", str, enable);
 925 }
 926
 927 static void print_encrypt_mode(uint8_t mode)
 928 {
 929         const char *str;
 930
 931         switch (mode) {
 932         case 0x00:
 933                 str = "Encryption not required";
 934                 break;
 935         case 0x01:
 936                 str = "Encryption required for all connections";
 937                 break;
 938         default:
 939                 str = "Reserved";
 940                 break;
 941         }
 942
 943         print_field("Mode: %s (0x%2.2x)", str, mode);
 944 }
 945
 946 static const struct bitfield_data svc_class_table[] = {
 947         { 0, "Positioning (Location identification)"            },
 948         { 1, "Networking (LAN, Ad hoc)"                         },
 949         { 2, "Rendering (Printing, Speaker)"                    },
 950         { 3, "Capturing (Scanner, Microphone)"                  },
 951         { 4, "Object Transfer (v-Inbox, v-Folder)"              },
 952         { 5, "Audio (Speaker, Microphone, Headset)"             },
 953         { 6, "Telephony (Cordless telephony, Modem, Headset)"   },
 954         { 7, "Information (WEB-server, WAP-server)"             },
 955         { }
 956 };
 957
 958 static const struct {
 959         uint8_t val;
 960         const char *str;
 961 } major_class_computer_table[] = {
 962         { 0x00, "Uncategorized, code for device not assigned"   },
 963         { 0x01, "Desktop workstation"                           },
 964         { 0x02, "Server-class computer"                         },
 965         { 0x03, "Laptop"                                        },
 966         { 0x04, "Handheld PC/PDA (clam shell)"                  },
 967         { 0x05, "Palm sized PC/PDA"                             },
 968         { 0x06, "Wearable computer (Watch sized)"               },
 969         { 0x07, "Tablet"                                        },
 970         { }
 971 };
 972
 973 static const char *major_class_computer(uint8_t minor)
 974 {
 975         int i;
 976
 977         for (i = 0; major_class_computer_table[i].str; i++) {
 978                 if (major_class_computer_table[i].val == minor)
 979                         return major_class_computer_table[i].str;
 980         }
 981
 982         return NULL;
 983 }
 984
 985 static const struct {
 986         uint8_t val;
 987         const char *str;
 988 } major_class_phone_table[] = {
 989         { 0x00, "Uncategorized, code for device not assigned"   },
 990         { 0x01, "Cellular"                                      },
 991         { 0x02, "Cordless"                                      },
 992         { 0x03, "Smart phone"                                   },
 993         { 0x04, "Wired modem or voice gateway"                  },
 994         { 0x05, "Common ISDN Access"                            },
 995         { }
 996 };
 997
 998 static const char *major_class_phone(uint8_t minor)
 999 {
1000         int i;
1001
1002         for (i = 0; major_class_phone_table[i].str; i++) {
1003                 if (major_class_phone_table[i].val == minor)
1004                         return major_class_phone_table[i].str;
1005         }
1006
1007         return NULL;
1008 }
1009
1010 static const struct {
1011         uint8_t val;
1012         const char *str;
1013 } major_class_av_table[] = {
1014         { 0x00, "Uncategorized, code for device not assigned"   },
1015         { 0x01, "Wearable Headset Device"                       },
1016         { 0x02, "Hands-free Device"                             },
1017         { 0x04, "Microphone"                                    },
1018         { 0x05, "Loudspeaker"                                   },
1019         { 0x06, "Headphones"                                    },
1020         { 0x07, "Portable Audio"                                },
1021         { 0x08, "Car audio"                                     },
1022         { 0x09, "Set-top box"                                   },
1023         { 0x0a, "HiFi Audio Device"                             },
1024         { 0x0b, "VCR"                                           },
1025         { 0x0c, "Video Camera"                                  },
1026         { 0x0d, "Camcorder"                                     },
1027         { 0x0e, "Video Monitor"                                 },
1028         { 0x0f, "Video Display and Loudspeaker"                 },
1029         { 0x10, "Video Conferencing"                            },
1030         { 0x12, "Gaming/Toy"                                    },
1031         { }
1032 };
1033
1034 static const char *major_class_av(uint8_t minor)
1035 {
1036         int i;
1037
1038         for (i = 0; major_class_av_table[i].str; i++) {
1039                 if (major_class_av_table[i].val == minor)
1040                         return major_class_av_table[i].str;
1041         }
1042
1043         return NULL;
1044 }
1045
1046 static const struct {
1047         uint8_t val;
1048         const char *str;
1049 } major_class_wearable_table[] = {
1050         { 0x01, "Wrist Watch"   },
1051         { 0x02, "Pager"         },
1052         { 0x03, "Jacket"        },
1053         { 0x04, "Helmet"        },
1054         { 0x05, "Glasses"       },
1055         { }
1056 };
1057
1058 static const char *major_class_wearable(uint8_t minor)
1059 {
1060         int i;
1061
1062         for (i = 0; major_class_wearable_table[i].str; i++) {
1063                 if (major_class_wearable_table[i].val == minor)
1064                         return major_class_wearable_table[i].str;
1065         }
1066
1067         return NULL;
1068 }
1069
1070 static const struct {
1071         uint8_t val;
1072         const char *str;
1073         const char *(*func)(uint8_t minor);
1074 } major_class_table[] = {
1075         { 0x00, "Miscellaneous"                                         },
1076         { 0x01, "Computer (desktop, notebook, PDA, organizers)",
1077                                                 major_class_computer    },
1078         { 0x02, "Phone (cellular, cordless, payphone, modem)",
1079                                                 major_class_phone       },
1080         { 0x03, "LAN /Network Access point"                             },
1081         { 0x04, "Audio/Video (headset, speaker, stereo, video, vcr)",
1082                                                 major_class_av          },
1083         { 0x05, "Peripheral (mouse, joystick, keyboards)"               },
1084         { 0x06, "Imaging (printing, scanner, camera, display)"          },
1085         { 0x07, "Wearable",                     major_class_wearable    },
1086         { 0x08, "Toy"                                                   },
1087         { 0x09, "Health"                                                },
1088         { 0x1f, "Uncategorized, specific device code not specified"     },
1089         { }
1090 };
1091
1092 static void print_dev_class(const uint8_t *dev_class)
1093 {
1094         uint8_t mask, major_cls, minor_cls;
1095         const char *major_str = NULL;
1096         const char *minor_str = NULL;
1097         int i;
1098
1099         print_field("Class: 0x%2.2x%2.2x%2.2x",
1100                         dev_class[2], dev_class[1], dev_class[0]);
1101
1102         if ((dev_class[0] & 0x03) != 0x00) {
1103                 print_field("  Format type: 0x%2.2x", dev_class[0] & 0x03);
1104                 print_text(COLOR_ERROR, "  invalid format type");
1105                 return;
1106         }
1107
1108         major_cls = dev_class[1] & 0x1f;
1109         minor_cls = (dev_class[0] & 0xfc) >> 2;
1110
1111         for (i = 0; major_class_table[i].str; i++) {
1112                 if (major_class_table[i].val == major_cls) {
1113                         major_str = major_class_table[i].str;
1114
1115                         if (!major_class_table[i].func)
1116                                 break;
1117
1118                         minor_str = major_class_table[i].func(minor_cls);
1119                         break;
1120                 }
1121         }
1122
1123         if (major_str) {
1124                 print_field("  Major class: %s", major_str);
1125                 if (minor_str)
1126                         print_field("  Minor class: %s", minor_str);
1127                 else
1128                         print_field("  Minor class: 0x%2.2x", minor_cls);
1129         } else {
1130                 print_field("  Major class: 0x%2.2x", major_cls);
1131                 print_field("  Minor class: 0x%2.2x", minor_cls);
1132         }
1133
1134         if (dev_class[1] & 0x20)
1135                 print_field("  Limited Discoverable Mode");
1136
1137         if ((dev_class[1] & 0xc0) != 0x00) {
1138                 print_text(COLOR_ERROR, "  invalid service class");
1139                 return;
1140         }
1141
1142         mask = print_bitfield(2, dev_class[2], svc_class_table);
1143         if (mask)
1144                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
1145                                 "  Unknown service class (0x%2.2x)", mask);
1146 }
1147
1148 static void print_appearance(uint16_t appearance)
1149 {
1150         print_field("Appearance: %s (0x%4.4x)", bt_appear_to_str(appearance),
1151                                                                 appearance);
1152 }
1153
1154 static void print_num_broadcast_retrans(uint8_t num_retrans)
1155 {
1156         print_field("Number of broadcast retransmissions: %u", num_retrans);
1157 }
1158
1159 static void print_hold_mode_activity(uint8_t activity)
1160 {
1161         print_field("Activity: 0x%2.2x", activity);
1162
1163         if (activity == 0x00) {
1164                 print_field("  Maintain current Power State");
1165                 return;
1166         }
1167
1168         if (activity & 0x01)
1169                 print_field("  Suspend Page Scan");
1170         if (activity & 0x02)
1171                 print_field("  Suspend Inquiry Scan");
1172         if (activity & 0x04)
1173                 print_field("  Suspend Periodic Inquiries");
1174 }
1175
1176 static void print_power_type(uint8_t type)
1177 {
1178         const char *str;
1179
1180         switch (type) {
1181         case 0x00:
1182                 str = "Current Transmit Power Level";
1183                 break;
1184         case 0x01:
1185                 str = "Maximum Transmit Power Level";
1186                 break;
1187         default:
1188                 str = "Reserved";
1189                 break;
1190         }
1191
1192         print_field("Type: %s (0x%2.2x)", str, type);
1193 }
1194
1195 static void print_power_level(int8_t level, const char *type)
1196 {
1197         print_field("TX power%s%s%s: %d dbm (0x%2.2x)",
1198                 type ? " (" : "", type ? type : "", type ? ")" : "",
1199                                                         level, (uint8_t) level);
1200 }
1201
1202 static void print_host_flow_control(uint8_t enable)
1203 {
1204         const char *str;
1205
1206         switch (enable) {
1207         case 0x00:
1208                 str = "Off";
1209                 break;
1210         case 0x01:
1211                 str = "ACL Data Packets";
1212                 break;
1213         case 0x02:
1214                 str = "Synchronous Data Packets";
1215                 break;
1216         case 0x03:
1217                 str = "ACL and Synchronous Data Packets";
1218                 break;
1219         default:
1220                 str = "Reserved";
1221                 break;
1222         }
1223
1224         print_field("Flow control: %s (0x%2.2x)", str, enable);
1225 }
1226
1227 static void print_voice_setting(uint16_t setting)
1228 {
1229         uint8_t input_coding = (le16_to_cpu(setting) & 0x0300) >> 8;
1230         uint8_t input_data_format = (le16_to_cpu(setting) & 0xc0) >> 6;
1231         uint8_t air_coding_format = le16_to_cpu(setting) & 0x0003;
1232         const char *str;
1233
1234         print_field("Setting: 0x%4.4x", le16_to_cpu(setting));
1235
1236         switch (input_coding) {
1237         case 0x00:
1238                 str = "Linear";
1239                 break;
1240         case 0x01:
1241                 str = "u-law";
1242                 break;
1243         case 0x02:
1244                 str = "A-law";
1245                 break;
1246         default:
1247                 str = "Reserved";
1248                 break;
1249         }
1250
1251         print_field("  Input Coding: %s", str);
1252
1253         switch (input_data_format) {
1254         case 0x00:
1255                 str = "1's complement";
1256                 break;
1257         case 0x01:
1258                 str = "2's complement";
1259                 break;
1260         case 0x02:
1261                 str = "Sign-Magnitude";
1262                 break;
1263         case 0x03:
1264                 str = "Unsigned";
1265                 break;
1266         default:
1267                 str = "Reserved";
1268                 break;
1269         }
1270
1271         print_field("  Input Data Format: %s", str);
1272
1273         if (input_coding == 0x00) {
1274                 print_field("  Input Sample Size: %s",
1275                         le16_to_cpu(setting) & 0x20 ? "16-bit" : "8-bit");
1276                 print_field("  # of bits padding at MSB: %d",
1277                                         (le16_to_cpu(setting) & 0x1c) >> 2);
1278         }
1279
1280         switch (air_coding_format) {
1281         case 0x00:
1282                 str = "CVSD";
1283                 break;
1284         case 0x01:
1285                 str = "u-law";
1286                 break;
1287         case 0x02:
1288                 str = "A-law";
1289                 break;
1290         case 0x03:
1291                 str = "Transparent Data";
1292                 break;
1293         default:
1294                 str = "Reserved";
1295                 break;
1296         }
1297
1298         print_field("  Air Coding Format: %s", str);
1299 }
1300
1301 static void print_retransmission_effort(uint8_t effort)
1302 {
1303         const char *str;
1304
1305         switch (effort) {
1306         case 0x00:
1307                 str = "No retransmissions";
1308                 break;
1309         case 0x01:
1310                 str = "Optimize for power consumption";
1311                 break;
1312         case 0x02:
1313                 str = "Optimize for link quality";
1314                 break;
1315         case 0xff:
1316                 str = "Don't care";
1317                 break;
1318         default:
1319                 str = "Reserved";
1320                 break;
1321         }
1322
1323         print_field("Retransmission effort: %s (0x%2.2x)", str, effort);
1324 }
1325
1326 static void print_scan_enable(uint8_t scan_enable)
1327 {
1328         const char *str;
1329
1330         switch (scan_enable) {
1331         case 0x00:
1332                 str = "No Scans";
1333                 break;
1334         case 0x01:
1335                 str = "Inquiry Scan";
1336                 break;
1337         case 0x02:
1338                 str = "Page Scan";
1339                 break;
1340         case 0x03:
1341                 str = "Inquiry Scan + Page Scan";
1342                 break;
1343         default:
1344                 str = "Reserved";
1345                 break;
1346         }
1347
1348         print_field("Scan enable: %s (0x%2.2x)", str, scan_enable);
1349 }
1350
1351 static void print_link_policy(uint16_t link_policy)
1352 {
1353         uint16_t policy = le16_to_cpu(link_policy);
1354
1355         print_field("Link policy: 0x%4.4x", policy);
1356
1357         if (policy == 0x0000) {
1358                 print_field("  Disable All Modes");
1359                 return;
1360         }
1361
1362         if (policy & 0x0001)
1363                 print_field("  Enable Role Switch");
1364         if (policy & 0x0002)
1365                 print_field("  Enable Hold Mode");
1366         if (policy & 0x0004)
1367                 print_field("  Enable Sniff Mode");
1368         if (policy & 0x0008)
1369                 print_field("  Enable Park State");
1370 }
1371
1372 static void print_air_mode(uint8_t mode)
1373 {
1374         const char *str;
1375
1376         switch (mode) {
1377         case 0x00:
1378                 str = "u-law log";
1379                 break;
1380         case 0x01:
1381                 str = "A-law log";
1382                 break;
1383         case 0x02:
1384                 str = "CVSD";
1385                 break;
1386         case 0x03:
1387                 str = "Transparent";
1388                 break;
1389         default:
1390                 str = "Reserved";
1391                 break;
1392         }
1393
1394         print_field("Air mode: %s (0x%2.2x)", str, mode);
1395 }
1396
1397 static void print_codec_id(const char *label, uint8_t codec)
1398 {
1399         const char *str;
1400
1401         switch (codec) {
1402         case 0x00:
1403                 str = "u-law log";
1404                 break;
1405         case 0x01:
1406                 str = "A-law log";
1407                 break;
1408         case 0x02:
1409                 str = "CVSD";
1410                 break;
1411         case 0x03:
1412                 str = "Transparent";
1413                 break;
1414         case 0x04:
1415                 str = "Linear PCM";
1416                 break;
1417         case 0x05:
1418                 str = "mSBC";
1419                 break;
1420         case 0x06:
1421                 str = "LC3";
1422                 break;
1423         case 0xff:
1424                 str = "Vendor specific";
1425                 break;
1426         default:
1427                 str = "Reserved";
1428                 break;
1429         }
1430
1431         print_field("%s: %s (0x%2.2x)", label, str, codec);
1432 }
1433
1434 void packet_print_codec_id(const char *label, uint8_t codec)
1435 {
1436         print_codec_id(label, codec);
1437 }
1438
1439 static const struct bitfield_data codec_transport_table[] = {
1440         {  0, "Codec supported over BR/EDR ACL"         },
1441         {  1, "Codec supported over BR/EDR SCO and eSCO"},
1442         {  2, "Codec supported over LE CIS"             },
1443         {  3, "Codec supported over LE BIS"             },
1444         { }
1445 };
1446
1447 static void print_codec(const char *label, const struct bt_hci_codec *codec)
1448 {
1449         uint8_t mask;
1450
1451         print_codec_id(label, codec->id);
1452         print_field("  Logical Transport Type: 0x%02x", codec->transport);
1453         mask = print_bitfield(4, codec->transport, codec_transport_table);
1454         if (mask)
1455                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
1456                                 "  Unknown transport (0x%2.2x)", mask);
1457 }
1458
1459 static void print_inquiry_mode(uint8_t mode)
1460 {
1461         const char *str;
1462
1463         switch (mode) {
1464         case 0x00:
1465                 str = "Standard Inquiry Result";
1466                 break;
1467         case 0x01:
1468                 str = "Inquiry Result with RSSI";
1469                 break;
1470         case 0x02:
1471                 str = "Inquiry Result with RSSI or Extended Inquiry Result";
1472                 break;
1473         default:
1474                 str = "Reserved";
1475                 break;
1476         }
1477
1478         print_field("Mode: %s (0x%2.2x)", str, mode);
1479 }
1480
1481 static void print_inquiry_scan_type(uint8_t type)
1482 {
1483         const char *str;
1484
1485         switch (type) {
1486         case 0x00:
1487                 str = "Standard Scan";
1488                 break;
1489         case 0x01:
1490                 str = "Interlaced Scan";
1491                 break;
1492         default:
1493                 str = "Reserved";
1494                 break;
1495         }
1496
1497         print_field("Type: %s (0x%2.2x)", str, type);
1498 }
1499
1500 static void print_pscan_type(uint8_t type)
1501 {
1502         const char *str;
1503
1504         switch (type) {
1505         case 0x00:
1506                 str = "Standard Scan";
1507                 break;
1508         case 0x01:
1509                 str = "Interlaced Scan";
1510                 break;
1511         default:
1512                 str = "Reserved";
1513                 break;
1514         }
1515
1516         print_field("Type: %s (0x%2.2x)", str, type);
1517 }
1518
1519 static void print_loopback_mode(uint8_t mode)
1520 {
1521         const char *str;
1522
1523         switch (mode) {
1524         case 0x00:
1525                 str = "No Loopback";
1526                 break;
1527         case 0x01:
1528                 str = "Local Loopback";
1529                 break;
1530         case 0x02:
1531                 str = "Remote Loopback";
1532                 break;
1533         default:
1534                 str = "Reserved";
1535                 break;
1536         }
1537
1538         print_field("Mode: %s (0x%2.2x)", str, mode);
1539 }
1540
1541 static void print_auth_payload_timeout(uint16_t timeout)
1542 {
1543         print_field("Timeout: %d msec (0x%4.4x)",
1544                         le16_to_cpu(timeout) * 10, le16_to_cpu(timeout));
1545 }
1546
1547 static void print_pscan_rep_mode(uint8_t pscan_rep_mode)
1548 {
1549         const char *str;
1550
1551         switch (pscan_rep_mode) {
1552         case 0x00:
1553                 str = "R0";
1554                 break;
1555         case 0x01:
1556                 str = "R1";
1557                 break;
1558         case 0x02:
1559                 str = "R2";
1560                 break;
1561         default:
1562                 str = "Reserved";
1563                 break;
1564         }
1565
1566         print_field("Page scan repetition mode: %s (0x%2.2x)",
1567                                                 str, pscan_rep_mode);
1568 }
1569
1570 static void print_pscan_period_mode(uint8_t pscan_period_mode)
1571 {
1572         const char *str;
1573
1574         switch (pscan_period_mode) {
1575         case 0x00:
1576                 str = "P0";
1577                 break;
1578         case 0x01:
1579                 str = "P1";
1580                 break;
1581         case 0x02:
1582                 str = "P2";
1583                 break;
1584         default:
1585                 str = "Reserved";
1586                 break;
1587         }
1588
1589         print_field("Page period mode: %s (0x%2.2x)", str, pscan_period_mode);
1590 }
1591
1592 static void print_pscan_mode(uint8_t pscan_mode)
1593 {
1594         const char *str;
1595
1596         switch (pscan_mode) {
1597         case 0x00:
1598                 str = "Mandatory";
1599                 break;
1600         case 0x01:
1601                 str = "Optional I";
1602                 break;
1603         case 0x02:
1604                 str = "Optional II";
1605                 break;
1606         case 0x03:
1607                 str = "Optional III";
1608                 break;
1609         default:
1610                 str = "Reserved";
1611                 break;
1612         }
1613
1614         print_field("Page scan mode: %s (0x%2.2x)", str, pscan_mode);
1615 }
1616
1617 static void print_clock_offset(uint16_t clock_offset)
1618 {
1619         print_field("Clock offset: 0x%4.4x", le16_to_cpu(clock_offset));
1620 }
1621
1622 static void print_clock(uint32_t clock)
1623 {
1624         print_field("Clock: 0x%8.8x", le32_to_cpu(clock));
1625 }
1626
1627 static void print_clock_type(uint8_t type)
1628 {
1629         const char *str;
1630
1631         switch (type) {
1632         case 0x00:
1633                 str = "Local clock";
1634                 break;
1635         case 0x01:
1636                 str = "Piconet clock";
1637                 break;
1638         default:
1639                 str = "Reserved";
1640                 break;
1641         }
1642
1643         print_field("Type: %s (0x%2.2x)", str, type);
1644 }
1645
1646 static void print_clock_accuracy(uint16_t accuracy)
1647 {
1648         if (le16_to_cpu(accuracy) == 0xffff)
1649                 print_field("Accuracy: Unknown (0x%4.4x)",
1650                                                 le16_to_cpu(accuracy));
1651         else
1652                 print_field("Accuracy: %.4f msec (0x%4.4x)",
1653                                                 le16_to_cpu(accuracy) * 0.3125,
1654                                                 le16_to_cpu(accuracy));
1655 }
1656
1657 static void print_lpo_allowed(uint8_t lpo_allowed)
1658 {
1659         print_field("LPO allowed: 0x%2.2x", lpo_allowed);
1660 }
1661
1662 static void print_broadcast_fragment(uint8_t fragment)
1663 {
1664         const char *str;
1665
1666         switch (fragment) {
1667         case 0x00:
1668                 str = "Continuation fragment";
1669                 break;
1670         case 0x01:
1671                 str = "Starting fragment";
1672                 break;
1673         case 0x02:
1674                 str = "Ending fragment";
1675                 break;
1676         case 0x03:
1677                 str = "No fragmentation";
1678                 break;
1679         default:
1680                 str = "Reserved";
1681                 break;
1682         }
1683
1684         print_field("Fragment: %s (0x%2.2x)", str, fragment);
1685 }
1686
1687 static void print_link_type(uint8_t link_type)
1688 {
1689         const char *str;
1690
1691         switch (link_type) {
1692         case 0x00:
1693                 str = "SCO";
1694                 break;
1695         case 0x01:
1696                 str = "ACL";
1697                 break;
1698         case 0x02:
1699                 str = "eSCO";
1700                 break;
1701         default:
1702                 str = "Reserved";
1703                 break;
1704         }
1705
1706         print_field("Link type: %s (0x%2.2x)", str, link_type);
1707 }
1708
1709 static void print_encr_mode_change(uint8_t encr_mode, uint16_t handle)
1710 {
1711         const char *str;
1712         uint8_t conn_type;
1713
1714         conn_type = get_type(le16_to_cpu(handle));
1715
1716         switch (encr_mode) {
1717         case 0x00:
1718                 str = "Disabled";
1719                 break;
1720         case 0x01:
1721                 switch (conn_type) {
1722                 case 0x00:
1723                         str = "Enabled with E0";
1724                         break;
1725                 case 0x01:
1726                         str = "Enabled with AES-CCM";
1727                         break;
1728                 default:
1729                         str = "Enabled";
1730                         break;
1731                 }
1732                 break;
1733         case 0x02:
1734                 str = "Enabled with AES-CCM";
1735                 break;
1736         default:
1737                 str = "Reserved";
1738                 break;
1739         }
1740
1741         print_field("Encryption: %s (0x%2.2x)", str, encr_mode);
1742 }
1743
1744 static void print_pin_type(uint8_t pin_type)
1745 {
1746         const char *str;
1747
1748         switch (pin_type) {
1749         case 0x00:
1750                 str = "Variable";
1751                 break;
1752         case 0x01:
1753                 str = "Fixed";
1754                 break;
1755         default:
1756                 str = "Reserved";
1757                 break;
1758         }
1759
1760         print_field("PIN type: %s (0x%2.2x)", str, pin_type);
1761 }
1762
1763 static void print_key_flag(uint8_t key_flag)
1764 {
1765         const char *str;
1766
1767         switch (key_flag) {
1768         case 0x00:
1769                 str = "Semi-permanent";
1770                 break;
1771         case 0x01:
1772                 str = "Temporary";
1773                 break;
1774         default:
1775                 str = "Reserved";
1776                 break;
1777         }
1778
1779         print_field("Key flag: %s (0x%2.2x)", str, key_flag);
1780 }
1781
1782 static void print_key_len(uint8_t key_len)
1783 {
1784         const char *str;
1785
1786         switch (key_len) {
1787         case 32:
1788                 str = "802.11 PAL";
1789                 break;
1790         default:
1791                 str = "Reserved";
1792                 break;
1793         }
1794
1795         print_field("Key length: %s (%d)", str, key_len);
1796 }
1797
1798 static void print_key_type(uint8_t key_type)
1799 {
1800         const char *str;
1801
1802         switch (key_type) {
1803         case 0x00:
1804                 str = "Combination key";
1805                 break;
1806         case 0x01:
1807                 str = "Local Unit key";
1808                 break;
1809         case 0x02:
1810                 str = "Remote Unit key";
1811                 break;
1812         case 0x03:
1813                 str = "Debug Combination key";
1814                 break;
1815         case 0x04:
1816                 str = "Unauthenticated Combination key from P-192";
1817                 break;
1818         case 0x05:
1819                 str = "Authenticated Combination key from P-192";
1820                 break;
1821         case 0x06:
1822                 str = "Changed Combination key";
1823                 break;
1824         case 0x07:
1825                 str = "Unauthenticated Combination key from P-256";
1826                 break;
1827         case 0x08:
1828                 str = "Authenticated Combination key from P-256";
1829                 break;
1830         default:
1831                 str = "Reserved";
1832                 break;
1833         }
1834
1835         print_field("Key type: %s (0x%2.2x)", str, key_type);
1836 }
1837
1838 static void print_key_size(uint8_t key_size)
1839 {
1840         print_field("Key size: %d", key_size);
1841 }
1842
1843 static void print_key(const char *label, const uint8_t *link_key)
1844 {
1845         print_hex_field(label, link_key, 16);
1846 }
1847
1848 static void print_link_key(const uint8_t *link_key)
1849 {
1850         print_key("Link key", link_key);
1851 }
1852
1853 static void print_pin_code(const uint8_t *pin_code, uint8_t pin_len)
1854 {
1855         char str[pin_len + 1];
1856         uint8_t i;
1857
1858         for (i = 0; i < pin_len; i++)
1859                 sprintf(str + i, "%c", (const char) pin_code[i]);
1860
1861         print_field("PIN code: %s", str);
1862 }
1863
1864 static void print_hash_p192(const uint8_t *hash)
1865 {
1866         print_key("Hash C from P-192", hash);
1867 }
1868
1869 static void print_hash_p256(const uint8_t *hash)
1870 {
1871         print_key("Hash C from P-256", hash);
1872 }
1873
1874 static void print_randomizer_p192(const uint8_t *randomizer)
1875 {
1876         print_key("Randomizer R with P-192", randomizer);
1877 }
1878
1879 static void print_randomizer_p256(const uint8_t *randomizer)
1880 {
1881         print_key("Randomizer R with P-256", randomizer);
1882 }
1883
1884 static void print_pk256(const char *label, const uint8_t *key)
1885 {
1886         print_field("%s:", label);
1887         print_hex_field("  X", &key[0], 32);
1888         print_hex_field("  Y", &key[32], 32);
1889 }
1890
1891 static void print_dhkey(const uint8_t *dhkey)
1892 {
1893         print_hex_field("Diffie-Hellman key", dhkey, 32);
1894 }
1895
1896 static void print_passkey(uint32_t passkey)
1897 {
1898         print_field("Passkey: %06d", le32_to_cpu(passkey));
1899 }
1900
1901 static void print_io_capability(uint8_t capability)
1902 {
1903         const char *str;
1904
1905         switch (capability) {
1906         case 0x00:
1907                 str = "DisplayOnly";
1908                 break;
1909         case 0x01:
1910                 str = "DisplayYesNo";
1911                 break;
1912         case 0x02:
1913                 str = "KeyboardOnly";
1914                 break;
1915         case 0x03:
1916                 str = "NoInputNoOutput";
1917                 break;
1918         default:
1919                 str = "Reserved";
1920                 break;
1921         }
1922
1923         print_field("IO capability: %s (0x%2.2x)", str, capability);
1924 }
1925
1926 static void print_oob_data(uint8_t oob_data)
1927 {
1928         const char *str;
1929
1930         switch (oob_data) {
1931         case 0x00:
1932                 str = "Authentication data not present";
1933                 break;
1934         case 0x01:
1935                 str = "P-192 authentication data present";
1936                 break;
1937         case 0x02:
1938                 str = "P-256 authentication data present";
1939                 break;
1940         case 0x03:
1941                 str = "P-192 and P-256 authentication data present";
1942                 break;
1943         default:
1944                 str = "Reserved";
1945                 break;
1946         }
1947
1948         print_field("OOB data: %s (0x%2.2x)", str, oob_data);
1949 }
1950
1951 static void print_oob_data_response(uint8_t oob_data)
1952 {
1953         const char *str;
1954
1955         switch (oob_data) {
1956         case 0x00:
1957                 str = "Authentication data not present";
1958                 break;
1959         case 0x01:
1960                 str = "Authentication data present";
1961                 break;
1962         default:
1963                 str = "Reserved";
1964                 break;
1965         }
1966
1967         print_field("OOB data: %s (0x%2.2x)", str, oob_data);
1968 }
1969
1970 static void print_authentication(uint8_t authentication)
1971 {
1972         const char *str;
1973
1974         switch (authentication) {
1975         case 0x00:
1976                 str = "No Bonding - MITM not required";
1977                 break;
1978         case 0x01:
1979                 str = "No Bonding - MITM required";
1980                 break;
1981         case 0x02:
1982                 str = "Dedicated Bonding - MITM not required";
1983                 break;
1984         case 0x03:
1985                 str = "Dedicated Bonding - MITM required";
1986                 break;
1987         case 0x04:
1988                 str = "General Bonding - MITM not required";
1989                 break;
1990         case 0x05:
1991                 str = "General Bonding - MITM required";
1992                 break;
1993         default:
1994                 str = "Reserved";
1995                 break;
1996         }
1997
1998         print_field("Authentication: %s (0x%2.2x)", str, authentication);
1999 }
2000
2001 void packet_print_io_capability(uint8_t capability)
2002 {
2003         print_io_capability(capability);
2004 }
2005
2006 void packet_print_io_authentication(uint8_t authentication)
2007 {
2008         print_authentication(authentication);
2009 }
2010
2011 static void print_location_domain_aware(uint8_t aware)
2012 {
2013         const char *str;
2014
2015         switch (aware) {
2016         case 0x00:
2017                 str = "Regulatory domain unknown";
2018                 break;
2019         case 0x01:
2020                 str = "Regulatory domain known";
2021                 break;
2022         default:
2023                 str = "Reserved";
2024                 break;
2025         }
2026
2027         print_field("Domain aware: %s (0x%2.2x)", str, aware);
2028 }
2029
2030 static void print_location_domain(const uint8_t *domain)
2031 {
2032         print_field("Domain: %c%c (0x%2.2x%2.2x)",
2033                 (char) domain[0], (char) domain[1], domain[0], domain[1]);
2034 }
2035
2036 static void print_location_domain_options(uint8_t options)
2037 {
2038         print_field("Domain options: %c (0x%2.2x)", (char) options, options);
2039 }
2040
2041 static void print_location_options(uint8_t options)
2042 {
2043         print_field("Options: 0x%2.2x", options);
2044 }
2045
2046 static void print_flow_control_mode(uint8_t mode)
2047 {
2048         const char *str;
2049
2050         switch (mode) {
2051         case 0x00:
2052                 str = "Packet based";
2053                 break;
2054         case 0x01:
2055                 str = "Data block based";
2056                 break;
2057         default:
2058                 str = "Reserved";
2059                 break;
2060         }
2061
2062         print_field("Flow control mode: %s (0x%2.2x)", str, mode);
2063 }
2064
2065 static void print_flow_direction(uint8_t direction)
2066 {
2067         const char *str;
2068
2069         switch (direction) {
2070         case 0x00:
2071                 str = "Outgoing";
2072                 break;
2073         case 0x01:
2074                 str = "Incoming";
2075                 break;
2076         default:
2077                 str = "Reserved";
2078                 break;
2079         }
2080
2081         print_field("Flow direction: %s (0x%2.2x)", str, direction);
2082 }
2083
2084 static void print_service_type(uint8_t service_type)
2085 {
2086         const char *str;
2087
2088         switch (service_type) {
2089         case 0x00:
2090                 str = "No Traffic";
2091                 break;
2092         case 0x01:
2093                 str = "Best Effort";
2094                 break;
2095         case 0x02:
2096                 str = "Guaranteed";
2097                 break;
2098         default:
2099                 str = "Reserved";
2100                 break;
2101         }
2102
2103         print_field("Service type: %s (0x%2.2x)", str, service_type);
2104 }
2105
2106 static void print_flow_spec(const char *label, const uint8_t *data)
2107 {
2108         const char *str;
2109
2110         switch (data[1]) {
2111         case 0x00:
2112                 str = "No traffic";
2113                 break;
2114         case 0x01:
2115                 str = "Best effort";
2116                 break;
2117         case 0x02:
2118                 str = "Guaranteed";
2119                 break;
2120         default:
2121                 str = "Reserved";
2122                 break;
2123         }
2124
2125         print_field("%s flow spec: 0x%2.2x", label, data[0]);
2126         print_field("  Service type: %s (0x%2.2x)", str, data[1]);
2127         print_field("  Maximum SDU size: 0x%4.4x", get_le16(data + 2));
2128         print_field("  SDU inter-arrival time: 0x%8.8x", get_le32(data + 4));
2129         print_field("  Access latency: 0x%8.8x", get_le32(data + 8));
2130         print_field("  Flush timeout: 0x%8.8x", get_le32(data + 12));
2131 }
2132
2133 static void print_amp_status(uint8_t amp_status)
2134 {
2135         const char *str;
2136
2137         switch (amp_status) {
2138         case 0x00:
2139                 str = "Present";
2140                 break;
2141         case 0x01:
2142                 str = "Bluetooth only";
2143                 break;
2144         case 0x02:
2145                 str = "No capacity";
2146                 break;
2147         case 0x03:
2148                 str = "Low capacity";
2149                 break;
2150         case 0x04:
2151                 str = "Medium capacity";
2152                 break;
2153         case 0x05:
2154                 str = "High capacity";
2155                 break;
2156         case 0x06:
2157                 str = "Full capacity";
2158                 break;
2159         default:
2160                 str = "Reserved";
2161                 break;
2162         }
2163
2164         print_field("AMP status: %s (0x%2.2x)", str, amp_status);
2165 }
2166
2167 static void print_num_resp(uint8_t num_resp)
2168 {
2169         print_field("Num responses: %d", num_resp);
2170 }
2171
2172 static void print_num_reports(uint8_t num_reports)
2173 {
2174         print_field("Num reports: %d", num_reports);
2175 }
2176
2177 static void print_adv_event_type(const char *label, uint8_t type)
2178 {
2179         const char *str;
2180
2181         switch (type) {
2182         case 0x00:
2183                 str = "Connectable undirected - ADV_IND";
2184                 break;
2185         case 0x01:
2186                 str = "Connectable directed - ADV_DIRECT_IND";
2187                 break;
2188         case 0x02:
2189                 str = "Scannable undirected - ADV_SCAN_IND";
2190                 break;
2191         case 0x03:
2192                 str = "Non connectable undirected - ADV_NONCONN_IND";
2193                 break;
2194         case 0x04:
2195                 str = "Scan response - SCAN_RSP";
2196                 break;
2197         default:
2198                 str = "Reserved";
2199                 break;
2200         }
2201
2202         print_field("%s: %s (0x%2.2x)", label, str, type);
2203 }
2204
2205 static void print_adv_channel_map(const char *label, uint8_t value)
2206 {
2207         const char *str;
2208
2209         switch (value) {
2210         case 0x01:
2211                 str = "37";
2212                 break;
2213         case 0x02:
2214                 str = "38";
2215                 break;
2216         case 0x03:
2217                 str = "37, 38";
2218                 break;
2219         case 0x04:
2220                 str = "39";
2221                 break;
2222         case 0x05:
2223                 str = "37, 39";
2224                 break;
2225         case 0x06:
2226                 str = "38, 39";
2227                 break;
2228         case 0x07:
2229                 str = "37, 38, 39";
2230                 break;
2231         default:
2232                 str = "Reserved";
2233                 break;
2234         }
2235
2236         print_field("%s: %s (0x%2.2x)", label, str, value);
2237 }
2238
2239 static void print_adv_filter_policy(const char *label, uint8_t value)
2240 {
2241         const char *str;
2242
2243         switch (value) {
2244         case 0x00:
2245                 str = "Allow Scan Request from Any, "
2246                         "Allow Connect Request from Any";
2247                 break;
2248         case 0x01:
2249                 str = "Allow Scan Request from Accept List Only, "
2250                         "Allow Connect Request from Any";
2251                 break;
2252         case 0x02:
2253                 str = "Allow Scan Request from Any, "
2254                         "Allow Connect Request from Accept List Only";
2255                 break;
2256         case 0x03:
2257                 str = "Allow Scan Request from Accept List Only, "
2258                         "Allow Connect Request from Accept List Only";
2259                 break;
2260         default:
2261                 str = "Reserved";
2262                 break;
2263         }
2264
2265         print_field("%s: %s (0x%2.2x)", label, str, value);
2266 }
2267
2268 static void print_rssi(int8_t rssi)
2269 {
2270         packet_print_rssi("RSSI", rssi);
2271 }
2272
2273 static void print_slot_625(const char *label, uint16_t value)
2274 {
2275          print_field("%s: %.3f msec (0x%4.4x)", label,
2276                                 le16_to_cpu(value) * 0.625, le16_to_cpu(value));
2277 }
2278
2279 static void print_slot_125(const char *label, uint16_t value)
2280 {
2281         print_field("%s: %.2f msec (0x%4.4x)", label,
2282                                 le16_to_cpu(value) * 1.25, le16_to_cpu(value));
2283 }
2284
2285 static void print_timeout(uint16_t timeout)
2286 {
2287         print_slot_625("Timeout", timeout);
2288 }
2289
2290 static void print_interval(uint16_t interval)
2291 {
2292         print_slot_625("Interval", interval);
2293 }
2294
2295 static void print_window(uint16_t window)
2296 {
2297         print_slot_625("Window", window);
2298 }
2299
2300 static void print_conn_latency(const char *label, uint16_t value)
2301 {
2302         print_field("%s: %u (0x%4.4x)", label, le16_to_cpu(value),
2303                                                         le16_to_cpu(value));
2304 }
2305
2306 static void print_role(uint8_t role)
2307 {
2308         const char *str;
2309
2310         switch (role) {
2311         case 0x00:
2312                 str = "Central";
2313                 break;
2314         case 0x01:
2315                 str = "Peripheral";
2316                 break;
2317         default:
2318                 str = "Reserved";
2319                 break;
2320         }
2321
2322         print_field("Role: %s (0x%2.2x)", str, role);
2323 }
2324
2325 static void print_mode(uint8_t mode)
2326 {
2327         const char *str;
2328
2329         switch (mode) {
2330         case 0x00:
2331                 str = "Active";
2332                 break;
2333         case 0x01:
2334                 str = "Hold";
2335                 break;
2336         case 0x02:
2337                 str = "Sniff";
2338                 break;
2339         case 0x03:
2340                 str = "Park";
2341                 break;
2342         default:
2343                 str = "Reserved";
2344                 break;
2345         }
2346
2347         print_field("Mode: %s (0x%2.2x)", str, mode);
2348 }
2349
2350 static void print_name(const uint8_t *name)
2351 {
2352         char str[249];
2353
2354         memcpy(str, name, 248);
2355         str[248] = '\0';
2356
2357         print_field("Name: %s", str);
2358 }
2359
2360 static void print_channel_map(const uint8_t *map)
2361 {
2362         unsigned int count = 0, start = 0;
2363         char str[21];
2364         int i, n;
2365
2366         for (i = 0; i < 10; i++)
2367                 sprintf(str + (i * 2), "%2.2x", map[i]);
2368
2369         print_field("Channel map: 0x%s", str);
2370
2371         for (i = 0; i < 10; i++) {
2372                 for (n = 0; n < 8; n++) {
2373                         if (map[i] & (1 << n)) {
2374                                 if (count == 0)
2375                                         start = (i * 8) + n;
2376                                 count++;
2377                                 continue;
2378                         }
2379
2380                         if (count > 1) {
2381                                 print_field("  Channel %u-%u",
2382                                                 start, start + count - 1);
2383                                 count = 0;
2384                         } else if (count > 0) {
2385                                 print_field("  Channel %u", start);
2386                                 count = 0;
2387                         }
2388                 }
2389         }
2390 }
2391
2392 void packet_print_channel_map_lmp(const uint8_t *map)
2393 {
2394         print_channel_map(map);
2395 }
2396
2397 static void print_flush_timeout(uint16_t timeout)
2398 {
2399         if (timeout)
2400                 print_timeout(timeout);
2401         else
2402                 print_field("Timeout: No Automatic Flush");
2403 }
2404
2405 void packet_print_version(const char *label, uint8_t version,
2406                                 const char *sublabel, uint16_t subversion)
2407 {
2408         const char *str;
2409
2410         switch (version) {
2411         case 0x00:
2412                 str = "Bluetooth 1.0b";
2413                 break;
2414         case 0x01:
2415                 str = "Bluetooth 1.1";
2416                 break;
2417         case 0x02:
2418                 str = "Bluetooth 1.2";
2419                 break;
2420         case 0x03:
2421                 str = "Bluetooth 2.0";
2422                 break;
2423         case 0x04:
2424                 str = "Bluetooth 2.1";
2425                 break;
2426         case 0x05:
2427                 str = "Bluetooth 3.0";
2428                 break;
2429         case 0x06:
2430                 str = "Bluetooth 4.0";
2431                 break;
2432         case 0x07:
2433                 str = "Bluetooth 4.1";
2434                 break;
2435         case 0x08:
2436                 str = "Bluetooth 4.2";
2437                 break;
2438         case 0x09:
2439                 str = "Bluetooth 5.0";
2440                 break;
2441         case 0x0a:
2442                 str = "Bluetooth 5.1";
2443                 break;
2444         case 0x0b:
2445                 str = "Bluetooth 5.2";
2446                 break;
2447         case 0x0c:
2448                 str = "Bluetooth 5.3";
2449                 break;
2450         default:
2451                 str = "Reserved";
2452                 break;
2453         }
2454
2455         if (sublabel)
2456                 print_field("%s: %s (0x%2.2x) - %s %d (0x%4.4x)",
2457                                         label, str, version,
2458                                         sublabel, subversion, subversion);
2459         else
2460                 print_field("%s: %s (0x%2.2x)", label, str, version);
2461 }
2462
2463 static void print_hci_version(uint8_t version, uint16_t revision)
2464 {
2465         packet_print_version("HCI version", version,
2466                                 "Revision", le16_to_cpu(revision));
2467 }
2468
2469 static void print_lmp_version(uint8_t version, uint16_t subversion)
2470 {
2471         packet_print_version("LMP version", version,
2472                                 "Subversion", le16_to_cpu(subversion));
2473 }
2474
2475 static void print_pal_version(uint8_t version, uint16_t subversion)
2476 {
2477         const char *str;
2478
2479         switch (version) {
2480         case 0x01:
2481                 str = "Bluetooth 3.0";
2482                 break;
2483         default:
2484                 str = "Reserved";
2485                 break;
2486         }
2487
2488         print_field("PAL version: %s (0x%2.2x) - Subversion %d (0x%4.4x)",
2489                                                 str, version,
2490                                                 le16_to_cpu(subversion),
2491                                                 le16_to_cpu(subversion));
2492 }
2493
2494 void packet_print_company(const char *label, uint16_t company)
2495 {
2496         print_field("%s: %s (%d)", label, bt_compidtostr(company), company);
2497 }
2498
2499 static void print_manufacturer(uint16_t manufacturer)
2500 {
2501         packet_print_company("Manufacturer", le16_to_cpu(manufacturer));
2502 }
2503
2504 static const struct {
2505         uint16_t ver;
2506         const char *str;
2507 } broadcom_uart_subversion_table[] = {
2508         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
2509         { 0x410e, "BCM43341B0"  },      /* 002.001.014 */
2510         { 0x4406, "BCM4324B3"   },      /* 002.004.006 */
2511         { }
2512 };
2513
2514 static const struct {
2515         uint16_t ver;
2516         const char *str;
2517 } broadcom_usb_subversion_table[] = {
2518         { 0x210b, "BCM43142A0"  },      /* 001.001.011 */
2519         { 0x2112, "BCM4314A0"   },      /* 001.001.018 */
2520         { 0x2118, "BCM20702A0"  },      /* 001.001.024 */
2521         { 0x2126, "BCM4335A0"   },      /* 001.001.038 */
2522         { 0x220e, "BCM20702A1"  },      /* 001.002.014 */
2523         { 0x230f, "BCM4354A2"   },      /* 001.003.015 */
2524         { 0x4106, "BCM4335B0"   },      /* 002.001.006 */
2525         { 0x410e, "BCM20702B0"  },      /* 002.001.014 */
2526         { 0x6109, "BCM4335C0"   },      /* 003.001.009 */
2527         { 0x610c, "BCM4354"     },      /* 003.001.012 */
2528         { }
2529 };
2530
2531 static void print_manufacturer_broadcom(uint16_t subversion, uint16_t revision)
2532 {
2533         uint16_t ver = le16_to_cpu(subversion);
2534         uint16_t rev = le16_to_cpu(revision);
2535         const char *str = NULL;
2536         int i;
2537
2538         switch ((rev & 0xf000) >> 12) {
2539         case 0:
2540         case 3:
2541                 for (i = 0; broadcom_uart_subversion_table[i].str; i++) {
2542                         if (broadcom_uart_subversion_table[i].ver == ver) {
2543                                 str = broadcom_uart_subversion_table[i].str;
2544                                 break;
2545                         }
2546                 }
2547                 break;
2548         case 1:
2549         case 2:
2550                 for (i = 0; broadcom_usb_subversion_table[i].str; i++) {
2551                         if (broadcom_usb_subversion_table[i].ver == ver) {
2552                                 str = broadcom_usb_subversion_table[i].str;
2553                                 break;
2554                         }
2555                 }
2556                 break;
2557         }
2558
2559         if (str)
2560                 print_field("  Firmware: %3.3u.%3.3u.%3.3u (%s)",
2561                                 (ver & 0xe000) >> 13,
2562                                 (ver & 0x1f00) >> 8, ver & 0x00ff, str);
2563         else
2564                 print_field("  Firmware: %3.3u.%3.3u.%3.3u",
2565                                 (ver & 0xe000) >> 13,
2566                                 (ver & 0x1f00) >> 8, ver & 0x00ff);
2567
2568         if (rev != 0xffff)
2569                 print_field("  Build: %4.4u", rev & 0x0fff);
2570 }
2571
2572 static const char *get_supported_command(int bit);
2573
2574 static void print_commands(const uint8_t *commands)
2575 {
2576         unsigned int count = 0;
2577         int i, n;
2578
2579         for (i = 0; i < 64; i++) {
2580                 for (n = 0; n < 8; n++) {
2581                         if (commands[i] & (1 << n))
2582                                 count++;
2583                 }
2584         }
2585
2586         print_field("Commands: %u entr%s", count, count == 1 ? "y" : "ies");
2587
2588         for (i = 0; i < 64; i++) {
2589                 for (n = 0; n < 8; n++) {
2590                         const char *cmd;
2591
2592                         if (!(commands[i] & (1 << n)))
2593                                 continue;
2594
2595                         cmd = get_supported_command((i * 8) + n);
2596                         if (cmd)
2597                                 print_field("  %s (Octet %d - Bit %d)",
2598                                                                 cmd, i, n);
2599                         else
2600                                 print_text(COLOR_UNKNOWN_COMMAND_BIT,
2601                                                 "  Octet %d - Bit %d ", i, n);
2602                 }
2603         }
2604 }
2605
2606 static const struct bitfield_data features_page0[] = {
2607         {  0, "3 slot packets"                          },
2608         {  1, "5 slot packets"                          },
2609         {  2, "Encryption"                              },
2610         {  3, "Slot offset"                             },
2611         {  4, "Timing accuracy"                         },
2612         {  5, "Role switch"                             },
2613         {  6, "Hold mode"                               },
2614         {  7, "Sniff mode"                              },
2615         {  8, "Park state"                              },
2616         {  9, "Power control requests"                  },
2617         { 10, "Channel quality driven data rate (CQDDR)"},
2618         { 11, "SCO link"                                },
2619         { 12, "HV2 packets"                             },
2620         { 13, "HV3 packets"                             },
2621         { 14, "u-law log synchronous data"              },
2622         { 15, "A-law log synchronous data"              },
2623         { 16, "CVSD synchronous data"                   },
2624         { 17, "Paging parameter negotiation"            },
2625         { 18, "Power control"                           },
2626         { 19, "Transparent synchronous data"            },
2627         { 20, "Flow control lag (least significant bit)"},
2628         { 21, "Flow control lag (middle bit)"           },
2629         { 22, "Flow control lag (most significant bit)" },
2630         { 23, "Broadcast Encryption"                    },
2631         { 25, "Enhanced Data Rate ACL 2 Mbps mode"      },
2632         { 26, "Enhanced Data Rate ACL 3 Mbps mode"      },
2633         { 27, "Enhanced inquiry scan"                   },
2634         { 28, "Interlaced inquiry scan"                 },
2635         { 29, "Interlaced page scan"                    },
2636         { 30, "RSSI with inquiry results"               },
2637         { 31, "Extended SCO link (EV3 packets)"         },
2638         { 32, "EV4 packets"                             },
2639         { 33, "EV5 packets"                             },
2640         { 35, "AFH capable peripheral"                  },
2641         { 36, "AFH classification peripheral"           },
2642         { 37, "BR/EDR Not Supported"                    },
2643         { 38, "LE Supported (Controller)"               },
2644         { 39, "3-slot Enhanced Data Rate ACL packets"   },
2645         { 40, "5-slot Enhanced Data Rate ACL packets"   },
2646         { 41, "Sniff subrating"                         },
2647         { 42, "Pause encryption"                        },
2648         { 43, "AFH capable central"                     },
2649         { 44, "AFH classification central"              },
2650         { 45, "Enhanced Data Rate eSCO 2 Mbps mode"     },
2651         { 46, "Enhanced Data Rate eSCO 3 Mbps mode"     },
2652         { 47, "3-slot Enhanced Data Rate eSCO packets"  },
2653         { 48, "Extended Inquiry Response"               },
2654         { 49, "Simultaneous LE and BR/EDR (Controller)" },
2655         { 51, "Secure Simple Pairing"                   },
2656         { 52, "Encapsulated PDU"                        },
2657         { 53, "Erroneous Data Reporting"                },
2658         { 54, "Non-flushable Packet Boundary Flag"      },
2659         { 56, "Link Supervision Timeout Changed Event"  },
2660         { 57, "Inquiry TX Power Level"                  },
2661         { 58, "Enhanced Power Control"                  },
2662         { 63, "Extended features"                       },
2663         { }
2664 };
2665
2666 static const struct bitfield_data features_page1[] = {
2667         {  0, "Secure Simple Pairing (Host Support)"    },
2668         {  1, "LE Supported (Host)"                     },
2669         {  2, "Simultaneous LE and BR/EDR (Host)"       },
2670         {  3, "Secure Connections (Host Support)"       },
2671         { }
2672 };
2673
2674 static const struct bitfield_data features_page2[] = {
2675         {  0, "Connectionless Peripheral Broadcast - Central"   },
2676         {  1, "Connectionless Peripheral Broadcast - Peripheral"},
2677         {  2, "Synchronization Train"                           },
2678         {  3, "Synchronization Scan"                            },
2679         {  4, "Inquiry Response Notification Event"             },
2680         {  5, "Generalized interlaced scan"                     },
2681         {  6, "Coarse Clock Adjustment"                         },
2682         {  8, "Secure Connections (Controller Support)"         },
2683         {  9, "Ping"                                            },
2684         { 10, "Slot Availability Mask"                          },
2685         { 11, "Train nudging"                                   },
2686         { }
2687 };
2688
2689 static const struct bitfield_data features_le[] = {
2690         {  0, "LE Encryption"                                   },
2691         {  1, "Connection Parameter Request Procedure"          },
2692         {  2, "Extended Reject Indication"                      },
2693         {  3, "Peripheral-initiated Features Exchange"          },
2694         {  4, "LE Ping"                                         },
2695         {  5, "LE Data Packet Length Extension"                 },
2696         {  6, "LL Privacy"                                      },
2697         {  7, "Extended Scanner Filter Policies"                },
2698         {  8, "LE 2M PHY"                                       },
2699         {  9, "Stable Modulation Index - Transmitter"           },
2700         { 10, "Stable Modulation Index - Receiver"              },
2701         { 11, "LE Coded PHY"                                    },
2702         { 12, "LE Extended Advertising"                         },
2703         { 13, "LE Periodic Advertising"                         },
2704         { 14, "Channel Selection Algorithm #2"                  },
2705         { 15, "LE Power Class 1"                                },
2706         { 16, "Minimum Number of Used Channels Procedure"       },
2707         { 17, "Connection CTE Request"                          },
2708         { 18, "Connection CTE Response"                         },
2709         { 19, "Connectionless CTE Transmitter"                  },
2710         { 20, "Connectionless CTE Receiver"                     },
2711         { 21, "Antenna Switching During CTE Transmission (AoD)" },
2712         { 22, "Antenna Switching During CTE Reception (AoA)"    },
2713         { 23, "Receiving Constant Tone Extensions"              },
2714         { 24, "Periodic Advertising Sync Transfer - Sender"     },
2715         { 25, "Periodic Advertising Sync Transfer - Recipient"  },
2716         { 26, "Sleep Clock Accuracy Updates"                    },
2717         { 27, "Remote Public Key Validation"                    },
2718         { 28, "Connected Isochronous Stream - Central"          },
2719         { 29, "Connected Isochronous Stream - Peripheral"       },
2720         { 30, "Isochronous Broadcaster"                         },
2721         { 31, "Synchronized Receiver"                           },
2722         { 32, "Isochronous Channels (Host Support)"             },
2723         { 33, "LE Power Control Request"                        },
2724         { 34, "LE Power Control Request"                        },
2725         { 35, "LE Path Loss Monitoring"                         },
2726         { 36, "Periodic Advertising ADI support"                },
2727         { 37, "Connection Subrating"                            },
2728         { 38, "Connection Subrating (Host Support)"             },
2729         { 39, "Channel Classification"                          },
2730         { }
2731 };
2732
2733 static const struct bitfield_data features_msft[] = {
2734         {  0, "RSSI Monitoring feature for BR/EDR"              },
2735         {  1, "RSSI Monitoring feature for LE connections"      },
2736         {  2, "RSSI Monitoring of LE advertisements"            },
2737         {  3, "Advertising Monitoring of LE advertisements"     },
2738         {  4, "Verifying the validity of P-192 and P-256 keys"  },
2739         {  5, "Continuous Advertising Monitoring"               },
2740         { }
2741 };
2742
2743 static void print_features(uint8_t page, const uint8_t *features_array,
2744                                                                 uint8_t type)
2745 {
2746         const struct bitfield_data *features_table = NULL;
2747         uint64_t mask, features = 0;
2748         char str[41];
2749         int i;
2750
2751         for (i = 0; i < 8; i++) {
2752                 sprintf(str + (i * 5), " 0x%2.2x", features_array[i]);
2753                 features |= ((uint64_t) features_array[i]) << (i * 8);
2754         }
2755
2756         print_field("Features:%s", str);
2757
2758         switch (type) {
2759         case 0x00:
2760                 switch (page) {
2761                 case 0:
2762                         features_table = features_page0;
2763                         break;
2764                 case 1:
2765                         features_table = features_page1;
2766                         break;
2767                 case 2:
2768                         features_table = features_page2;
2769                         break;
2770                 }
2771                 break;
2772         case 0x01:
2773                 switch (page) {
2774                 case 0:
2775                         features_table = features_le;
2776                         break;
2777                 }
2778                 break;
2779         case 0xf0:
2780                 switch (page) {
2781                 case 0:
2782                         features_table = features_msft;
2783                         break;
2784                 }
2785                 break;
2786         }
2787
2788         if (!features_table)
2789                 return;
2790
2791         mask = print_bitfield(2, features, features_table);
2792         if (mask)
2793                 print_text(COLOR_UNKNOWN_FEATURE_BIT, "  Unknown features "
2794                                                 "(0x%16.16" PRIx64 ")", mask);
2795 }
2796
2797 void packet_print_features_lmp(const uint8_t *features, uint8_t page)
2798 {
2799         print_features(page, features, 0x00);
2800 }
2801
2802 void packet_print_features_ll(const uint8_t *features)
2803 {
2804         print_features(0, features, 0x01);
2805 }
2806
2807 void packet_print_features_msft(const uint8_t *features)
2808 {
2809         print_features(0, features, 0xf0);
2810 }
2811
2812 #define LE_STATE_SCAN_ADV               0x0001
2813 #define LE_STATE_CONN_ADV               0x0002
2814 #define LE_STATE_NONCONN_ADV            0x0004
2815 #define LE_STATE_HIGH_DIRECT_ADV        0x0008
2816 #define LE_STATE_LOW_DIRECT_ADV         0x0010
2817 #define LE_STATE_ACTIVE_SCAN            0x0020
2818 #define LE_STATE_PASSIVE_SCAN           0x0040
2819 #define LE_STATE_INITIATING             0x0080
2820 #define LE_STATE_CONN_CENTRAL           0x0100
2821 #define LE_STATE_CONN_PERIPHERAL        0x0200
2822 #define LE_STATE_CENTRAL_CENTRAL        0x0400
2823 #define LE_STATE_PERIPHERAL_PERIPHERAL  0x0800
2824 #define LE_STATE_CENTRAL_PERIPHERAL     0x1000
2825
2826 static const struct bitfield_data le_states_desc_table[] = {
2827         {  0, "Scannable Advertising State"                     },
2828         {  1, "Connectable Advertising State"                   },
2829         {  2, "Non-connectable Advertising State"               },
2830         {  3, "High Duty Cycle Directed Advertising State"      },
2831         {  4, "Low Duty Cycle Directed Advertising State"       },
2832         {  5, "Active Scanning State"                           },
2833         {  6, "Passive Scanning State"                          },
2834         {  7, "Initiating State"                                },
2835         {  8, "Connection State (Central Role)"                 },
2836         {  9, "Connection State (Peripheral Role)"              },
2837         { 10, "Central Role & Central Role"                     },
2838         { 11, "Peripheral Role & Peripheral Role"               },
2839         { 12, "Central Role & Peripheral Role"                  },
2840         { }
2841 };
2842
2843 static const struct {
2844         uint8_t bit;
2845         uint16_t states;
2846 } le_states_comb_table[] = {
2847         {  0, LE_STATE_NONCONN_ADV                                      },
2848         {  1, LE_STATE_SCAN_ADV                                         },
2849         {  2, LE_STATE_CONN_ADV                                         },
2850         {  3, LE_STATE_HIGH_DIRECT_ADV                                  },
2851         {  4, LE_STATE_PASSIVE_SCAN                                     },
2852         {  5, LE_STATE_ACTIVE_SCAN                                      },
2853         {  6, LE_STATE_INITIATING | LE_STATE_CONN_CENTRAL               },
2854         {  7, LE_STATE_CONN_PERIPHERAL                                  },
2855         {  8, LE_STATE_PASSIVE_SCAN | LE_STATE_NONCONN_ADV              },
2856         {  9, LE_STATE_PASSIVE_SCAN | LE_STATE_SCAN_ADV                 },
2857         { 10, LE_STATE_PASSIVE_SCAN | LE_STATE_CONN_ADV                 },
2858         { 11, LE_STATE_PASSIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV          },
2859         { 12, LE_STATE_ACTIVE_SCAN | LE_STATE_NONCONN_ADV               },
2860         { 13, LE_STATE_ACTIVE_SCAN | LE_STATE_SCAN_ADV                  },
2861         { 14, LE_STATE_ACTIVE_SCAN | LE_STATE_CONN_ADV                  },
2862         { 15, LE_STATE_ACTIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV           },
2863         { 16, LE_STATE_INITIATING | LE_STATE_NONCONN_ADV                },
2864         { 17, LE_STATE_INITIATING | LE_STATE_SCAN_ADV                   },
2865         { 18, LE_STATE_CONN_CENTRAL | LE_STATE_NONCONN_ADV              },
2866         { 19, LE_STATE_CONN_CENTRAL | LE_STATE_SCAN_ADV                 },
2867         { 20, LE_STATE_CONN_PERIPHERAL | LE_STATE_NONCONN_ADV           },
2868         { 21, LE_STATE_CONN_PERIPHERAL | LE_STATE_SCAN_ADV              },
2869         { 22, LE_STATE_INITIATING | LE_STATE_PASSIVE_SCAN               },
2870         { 23, LE_STATE_INITIATING | LE_STATE_ACTIVE_SCAN                },
2871         { 24, LE_STATE_CONN_CENTRAL | LE_STATE_PASSIVE_SCAN             },
2872         { 25, LE_STATE_CONN_CENTRAL | LE_STATE_ACTIVE_SCAN              },
2873         { 26, LE_STATE_CONN_PERIPHERAL | LE_STATE_PASSIVE_SCAN          },
2874         { 27, LE_STATE_CONN_PERIPHERAL | LE_STATE_ACTIVE_SCAN           },
2875         { 28, LE_STATE_INITIATING | LE_STATE_CONN_CENTRAL |
2876                                         LE_STATE_CENTRAL_CENTRAL        },
2877         { 29, LE_STATE_LOW_DIRECT_ADV                                   },
2878         { 30, LE_STATE_LOW_DIRECT_ADV | LE_STATE_PASSIVE_SCAN           },
2879         { 31, LE_STATE_LOW_DIRECT_ADV | LE_STATE_ACTIVE_SCAN            },
2880         { 32, LE_STATE_INITIATING | LE_STATE_CONN_ADV |
2881                                         LE_STATE_CENTRAL_PERIPHERAL     },
2882         { 33, LE_STATE_INITIATING | LE_STATE_HIGH_DIRECT_ADV |
2883                                         LE_STATE_CENTRAL_PERIPHERAL     },
2884         { 34, LE_STATE_INITIATING | LE_STATE_LOW_DIRECT_ADV |
2885                                         LE_STATE_CENTRAL_PERIPHERAL     },
2886         { 35, LE_STATE_CONN_CENTRAL | LE_STATE_CONN_ADV |
2887                                         LE_STATE_CENTRAL_PERIPHERAL     },
2888         { 36, LE_STATE_CONN_CENTRAL | LE_STATE_HIGH_DIRECT_ADV |
2889                                         LE_STATE_CENTRAL_PERIPHERAL     },
2890         { 37, LE_STATE_CONN_CENTRAL | LE_STATE_LOW_DIRECT_ADV |
2891                                         LE_STATE_CENTRAL_PERIPHERAL     },
2892         { 38, LE_STATE_CONN_PERIPHERAL | LE_STATE_CONN_ADV |
2893                                         LE_STATE_CENTRAL_PERIPHERAL     },
2894         { 39, LE_STATE_CONN_PERIPHERAL | LE_STATE_HIGH_DIRECT_ADV |
2895                                         LE_STATE_PERIPHERAL_PERIPHERAL  },
2896         { 40, LE_STATE_CONN_PERIPHERAL | LE_STATE_LOW_DIRECT_ADV |
2897                                         LE_STATE_PERIPHERAL_PERIPHERAL  },
2898         { 41, LE_STATE_INITIATING | LE_STATE_CONN_PERIPHERAL |
2899                                         LE_STATE_CENTRAL_PERIPHERAL     },
2900         { }
2901 };
2902
2903 static void print_le_states(const uint8_t *states_array)
2904 {
2905         uint64_t mask, states = 0;
2906         int i = 0;
2907         size_t n = 0;
2908
2909         for (i = 0; i < 8; i++)
2910                 states |= ((uint64_t) states_array[i]) << (i * 8);
2911
2912         print_field("States: 0x%16.16" PRIx64, states);
2913
2914         mask = states;
2915
2916         for (i = 0; le_states_comb_table[i].states; i++) {
2917                 uint64_t val = (((uint64_t) 1) << le_states_comb_table[i].bit);
2918                 const char *str[3] = { NULL, };
2919                 size_t num = 0;
2920
2921                 if (!(states & val))
2922                         continue;
2923
2924                 for (n = 0; n < ARRAY_SIZE(le_states_desc_table); n++) {
2925                         if (le_states_comb_table[i].states & (1 << n))
2926                                 str[num++] = le_states_desc_table[n].str;
2927                 }
2928
2929                 if (num > 0) {
2930                         print_field("  %s", str[0]);
2931                         for (n = 1; n < num; n++)
2932                                 print_field("    and %s", str[n]);
2933                 }
2934
2935                 mask &= ~val;
2936         }
2937
2938         if (mask)
2939                 print_text(COLOR_UNKNOWN_LE_STATES, "  Unknown states "
2940                                                 "(0x%16.16" PRIx64 ")", mask);
2941 }
2942
2943 static void print_le_channel_map(const uint8_t *map)
2944 {
2945         unsigned int count = 0, start = 0;
2946         char str[11];
2947         int i, n;
2948
2949         for (i = 0; i < 5; i++)
2950                 sprintf(str + (i * 2), "%2.2x", map[i]);
2951
2952         print_field("Channel map: 0x%s", str);
2953
2954         for (i = 0; i < 5; i++) {
2955                 for (n = 0; n < 8; n++) {
2956                         if (map[i] & (1 << n)) {
2957                                 if (count == 0)
2958                                         start = (i * 8) + n;
2959                                 count++;
2960                                 continue;
2961                         }
2962
2963                         if (count > 1) {
2964                                 print_field("  Channel %u-%u",
2965                                                 start, start + count - 1);
2966                                 count = 0;
2967                         } else if (count > 0) {
2968                                 print_field("  Channel %u", start);
2969                                 count = 0;
2970                         }
2971                 }
2972         }
2973 }
2974
2975 void packet_print_channel_map_ll(const uint8_t *map)
2976 {
2977         print_le_channel_map(map);
2978 }
2979
2980 static void print_random_number(uint64_t rand)
2981 {
2982         print_field("Random number: 0x%16.16" PRIx64, le64_to_cpu(rand));
2983 }
2984
2985 static void print_encrypted_diversifier(uint16_t ediv)
2986 {
2987         print_field("Encrypted diversifier: 0x%4.4x", le16_to_cpu(ediv));
2988 }
2989
2990 static const struct bitfield_data events_table[] = {
2991         {  0, "Inquiry Complete"                                        },
2992         {  1, "Inquiry Result"                                          },
2993         {  2, "Connection Complete"                                     },
2994         {  3, "Connection Request"                                      },
2995         {  4, "Disconnection Complete"                                  },
2996         {  5, "Authentication Complete"                                 },
2997         {  6, "Remote Name Request Complete"                            },
2998         {  7, "Encryption Change"                                       },
2999         {  8, "Change Connection Link Key Complete"                     },
3000         {  9, "Link Key Type Changed"                                   },
3001         { 10, "Read Remote Supported Features Complete"                 },
3002         { 11, "Read Remote Version Information Complete"                },
3003         { 12, "QoS Setup Complete"                                      },
3004         { 13, "Command Complete"                                        },
3005         { 14, "Command Status"                                          },
3006         { 15, "Hardware Error"                                          },
3007         { 16, "Flush Occurred"                                          },
3008         { 17, "Role Change"                                             },
3009         { 18, "Number of Completed Packets"                             },
3010         { 19, "Mode Change"                                             },
3011         { 20, "Return Link Keys"                                        },
3012         { 21, "PIN Code Request"                                        },
3013         { 22, "Link Key Request"                                        },
3014         { 23, "Link Key Notification"                                   },
3015         { 24, "Loopback Command"                                        },
3016         { 25, "Data Buffer Overflow"                                    },
3017         { 26, "Max Slots Change"                                        },
3018         { 27, "Read Clock Offset Complete"                              },
3019         { 28, "Connection Packet Type Changed"                          },
3020         { 29, "QoS Violation"                                           },
3021         { 30, "Page Scan Mode Change"                                   },
3022         { 31, "Page Scan Repetition Mode Change"                        },
3023         { 32, "Flow Specification Complete"                             },
3024         { 33, "Inquiry Result with RSSI"                                },
3025         { 34, "Read Remote Extended Features Complete"                  },
3026         { 43, "Synchronous Connection Complete"                         },
3027         { 44, "Synchronous Connection Changed"                          },
3028         { 45, "Sniff Subrating"                                         },
3029         { 46, "Extended Inquiry Result"                                 },
3030         { 47, "Encryption Key Refresh Complete"                         },
3031         { 48, "IO Capability Request"                                   },
3032         { 49, "IO Capability Request Reply"                             },
3033         { 50, "User Confirmation Request"                               },
3034         { 51, "User Passkey Request"                                    },
3035         { 52, "Remote OOB Data Request"                                 },
3036         { 53, "Simple Pairing Complete"                                 },
3037         { 55, "Link Supervision Timeout Changed"                        },
3038         { 56, "Enhanced Flush Complete"                                 },
3039         { 58, "User Passkey Notification"                               },
3040         { 59, "Keypress Notification"                                   },
3041         { 60, "Remote Host Supported Features Notification"             },
3042         { 61, "LE Meta"                                                 },
3043         { }
3044 };
3045
3046 static void print_event_mask(const uint8_t *events_array,
3047                                         const struct bitfield_data *table)
3048 {
3049         uint64_t mask, events = 0;
3050         int i;
3051
3052         for (i = 0; i < 8; i++)
3053                 events |= ((uint64_t) events_array[i]) << (i * 8);
3054
3055         print_field("Mask: 0x%16.16" PRIx64, events);
3056
3057         mask = print_bitfield(2, events, table);
3058         if (mask)
3059                 print_text(COLOR_UNKNOWN_EVENT_MASK, "  Unknown mask "
3060                                                 "(0x%16.16" PRIx64 ")", mask);
3061 }
3062
3063 static const struct bitfield_data events_page2_table[] = {
3064         {  0, "Physical Link Complete"                                  },
3065         {  1, "Channel Selected"                                        },
3066         {  2, "Disconnection Physical Link Complete"                    },
3067         {  3, "Physical Link Loss Early Warning"                        },
3068         {  4, "Physical Link Recovery"                                  },
3069         {  5, "Logical Link Complete"                                   },
3070         {  6, "Disconnection Logical Link Complete"                     },
3071         {  7, "Flow Specification Modify Complete"                      },
3072         {  8, "Number of Completed Data Blocks"                         },
3073         {  9, "AMP Start Test"                                          },
3074         { 10, "AMP Test End"                                            },
3075         { 11, "AMP Receiver Report"                                     },
3076         { 12, "Short Range Mode Change Complete"                        },
3077         { 13, "AMP Status Change"                                       },
3078         { 14, "Triggered Clock Capture"                                 },
3079         { 15, "Synchronization Train Complete"                          },
3080         { 16, "Synchronization Train Received"                          },
3081         { 17, "Connectionless Peripheral Broadcast Receive"             },
3082         { 18, "Connectionless Peripheral Broadcast Timeout"             },
3083         { 19, "Truncated Page Complete"                                 },
3084         { 20, "Peripheral Page Response Timeout"                        },
3085         { 21, "Connectionless Peripheral Broadcast Channel Map Change"  },
3086         { 22, "Inquiry Response Notification"                           },
3087         { 23, "Authenticated Payload Timeout Expired"                   },
3088         { 24, "SAM Status Change"                                       },
3089         { }
3090 };
3091
3092 static const struct bitfield_data events_le_table[] = {
3093         {  0, "LE Connection Complete"                  },
3094         {  1, "LE Advertising Report"                   },
3095         {  2, "LE Connection Update Complete"           },
3096         {  3, "LE Read Remote Used Features Complete"   },
3097         {  4, "LE Long Term Key Request"                },
3098         {  5, "LE Remote Connection Parameter Request"  },
3099         {  6, "LE Data Length Change"                   },
3100         {  7, "LE Read Local P-256 Public Key Complete" },
3101         {  8, "LE Generate DHKey Complete"              },
3102         {  9, "LE Enhanced Connection Complete"         },
3103         { 10, "LE Direct Advertising Report"            },
3104         { 11, "LE PHY Update Complete"                  },
3105         { 12, "LE Extended Advertising Report"          },
3106         { 13, "LE Periodic Advertising Sync Established"},
3107         { 14, "LE Periodic Advertising Report"          },
3108         { 15, "LE Periodic Advertising Sync Lost"       },
3109         { 16, "LE Extended Scan Timeout"                },
3110         { 17, "LE Extended Advertising Set Terminated"  },
3111         { 18, "LE Scan Request Received"                },
3112         { 19, "LE Channel Selection Algorithm"          },
3113         { 20, "LE Connectionless IQ Report"             },
3114         { 21, "LE Connection IQ Report"                 },
3115         { 22, "LE CTE Request Failed"                   },
3116         { 23, "LE Periodic Advertising Sync Transfer Rvc"},
3117         { 24, "LE CIS Established"                      },
3118         { 25, "LE CIS Request"                          },
3119         { 26, "LE Create BIG Complete"                  },
3120         { 27, "LE Terminate BIG Complete"               },
3121         { 28, "LE BIG Sync Estabilished Complete"       },
3122         { 29, "LE BIG Sync Lost"                        },
3123         { 30, "LE Request Peer SCA Complete"},
3124         { 31, "LE Path Loss Threshold"          },
3125         { 32, "LE Transmit Power Reporting"     },
3126         { 33, "LE BIG Info Advertising Report"  },
3127         { 34, "LE Subrate Change"                       },
3128         { }
3129 };
3130
3131 static void print_fec(uint8_t fec)
3132 {
3133         const char *str;
3134
3135         switch (fec) {
3136         case 0x00:
3137                 str = "Not required";
3138                 break;
3139         case 0x01:
3140                 str = "Required";
3141                 break;
3142         default:
3143                 str = "Reserved";
3144                 break;
3145         }
3146
3147         print_field("FEC: %s (0x%02x)", str, fec);
3148 }
3149
3150 #define BT_EIR_FLAGS                    0x01
3151 #define BT_EIR_UUID16_SOME              0x02
3152 #define BT_EIR_UUID16_ALL               0x03
3153 #define BT_EIR_UUID32_SOME              0x04
3154 #define BT_EIR_UUID32_ALL               0x05
3155 #define BT_EIR_UUID128_SOME             0x06
3156 #define BT_EIR_UUID128_ALL              0x07
3157 #define BT_EIR_NAME_SHORT               0x08
3158 #define BT_EIR_NAME_COMPLETE            0x09
3159 #define BT_EIR_TX_POWER                 0x0a
3160 #define BT_EIR_CLASS_OF_DEV             0x0d
3161 #define BT_EIR_SSP_HASH_P192            0x0e
3162 #define BT_EIR_SSP_RANDOMIZER_P192      0x0f
3163 #define BT_EIR_DEVICE_ID                0x10
3164 #define BT_EIR_SMP_TK                   0x10
3165 #define BT_EIR_SMP_OOB_FLAGS            0x11
3166 #define BT_EIR_PERIPHERAL_CONN_INTERVAL 0x12
3167 #define BT_EIR_SERVICE_UUID16           0x14
3168 #define BT_EIR_SERVICE_UUID128          0x15
3169 #define BT_EIR_SERVICE_DATA             0x16
3170 #define BT_EIR_PUBLIC_ADDRESS           0x17
3171 #define BT_EIR_RANDOM_ADDRESS           0x18
3172 #define BT_EIR_GAP_APPEARANCE           0x19
3173 #define BT_EIR_ADVERTISING_INTERVAL     0x1a
3174 #define BT_EIR_LE_DEVICE_ADDRESS        0x1b
3175 #define BT_EIR_LE_ROLE                  0x1c
3176 #define BT_EIR_SSP_HASH_P256            0x1d
3177 #define BT_EIR_SSP_RANDOMIZER_P256      0x1e
3178 #define BT_EIR_SERVICE_UUID32           0x1f
3179 #define BT_EIR_SERVICE_DATA32           0x20
3180 #define BT_EIR_SERVICE_DATA128          0x21
3181 #define BT_EIR_LE_SC_CONFIRM_VALUE      0x22
3182 #define BT_EIR_LE_SC_RANDOM_VALUE       0x23
3183 #define BT_EIR_URI                      0x24
3184 #define BT_EIR_INDOOR_POSITIONING       0x25
3185 #define BT_EIR_TRANSPORT_DISCOVERY      0x26
3186 #define BT_EIR_LE_SUPPORTED_FEATURES    0x27
3187 #define BT_EIR_CHANNEL_MAP_UPDATE_IND   0x28
3188 #define BT_EIR_MESH_PROV                0x29
3189 #define BT_EIR_MESH_DATA                0x2a
3190 #define BT_EIR_MESH_BEACON              0x2b
3191 #define BT_EIR_CSIP_RSI                 0x2e
3192 #define BT_EIR_3D_INFO_DATA             0x3d
3193 #define BT_EIR_MANUFACTURER_DATA        0xff
3194
3195 static void print_manufacturer_apple(const void *data, uint8_t data_len)
3196 {
3197         uint8_t type = *((uint8_t *) data);
3198
3199         if (data_len < 1)
3200                 return;
3201
3202         if (type == 0x01) {
3203                 char identifier[100];
3204
3205                 snprintf(identifier, sizeof(identifier) - 1, "%s",
3206                                                 (const char *) (data + 1));
3207
3208                 print_field("  Identifier: %s", identifier);
3209                 return;
3210         }
3211
3212         while (data_len > 0) {
3213                 uint8_t len;
3214                 const char *str;
3215
3216                 type = *((uint8_t *) data);
3217                 data++;
3218                 data_len--;
3219
3220                 if (type == 0x00)
3221                         continue;
3222
3223                 if (data_len < 1)
3224                         break;
3225
3226                 switch (type) {
3227                 case 0x02:
3228                         str = "iBeacon";
3229                         break;
3230                 case 0x05:
3231                         str = "AirDrop";
3232                         break;
3233                 case 0x09:
3234                         str = "Apple TV";
3235                         break;
3236                 default:
3237                         str = "Unknown";
3238                         break;
3239                 }
3240
3241                 print_field("  Type: %s (%u)", str, type);
3242
3243                 len = *((uint8_t *) data);
3244                 data++;
3245                 data_len--;
3246
3247                 if (len < 1)
3248                         continue;
3249
3250                 if (len > data_len)
3251                         break;
3252
3253                 if (type == 0x02 && len == 0x15) {
3254                         const uint8_t *uuid;
3255                         uint16_t minor, major;
3256                         int8_t tx_power;
3257
3258                         uuid = data;
3259                         print_field("  UUID: %8.8x-%4.4x-%4.4x-%4.4x-%8.8x%4.4x",
3260                                 get_le32(&uuid[12]), get_le16(&uuid[10]),
3261                                 get_le16(&uuid[8]), get_le16(&uuid[6]),
3262                                 get_le32(&uuid[2]), get_le16(&uuid[0]));
3263
3264                         major = get_le16(data + 16);
3265                         minor = get_le16(data + 18);
3266                         print_field("  Version: %u.%u", major, minor);
3267
3268                         tx_power = *(int8_t *) (data + 20);
3269                         print_field("  TX power: %d dB", tx_power);
3270                 } else
3271                         print_hex_field("  Data", data, len);
3272
3273                 data += len;
3274                 data_len -= len;
3275         }
3276
3277         packet_hexdump(data, data_len);
3278 }
3279
3280 static void print_manufacturer_data(const void *data, uint8_t data_len)
3281 {
3282         uint16_t company = get_le16(data);
3283
3284         packet_print_company("Company", company);
3285
3286         switch (company) {
3287         case 76:
3288         case 19456:
3289                 print_manufacturer_apple(data + 2, data_len - 2);
3290                 break;
3291         default:
3292                 print_hex_field("  Data", data + 2, data_len - 2);
3293                 break;
3294         }
3295 }
3296
3297 static void print_device_id(const void *data, uint8_t data_len)
3298 {
3299         uint16_t source, vendor, product, version;
3300         char modalias[26], *vendor_str, *product_str;
3301         const char *str;
3302
3303         if (data_len < 8)
3304                 return;
3305
3306         source = get_le16(data);
3307         vendor = get_le16(data + 2);
3308         product = get_le16(data + 4);
3309         version = get_le16(data + 6);
3310
3311         switch (source) {
3312         case 0x0001:
3313                 str = "Bluetooth SIG assigned";
3314                 sprintf(modalias, "bluetooth:v%04Xp%04Xd%04X",
3315                                                 vendor, product, version);
3316                 break;
3317         case 0x0002:
3318                 str = "USB Implementer's Forum assigned";
3319                 sprintf(modalias, "usb:v%04Xp%04Xd%04X",
3320                                                 vendor, product, version);
3321                 break;
3322         default:
3323                 str = "Reserved";
3324                 modalias[0] = '\0';
3325                 break;
3326         }
3327
3328         print_field("Device ID: %s (0x%4.4x)", str, source);
3329
3330         if (!hwdb_get_vendor_model(modalias, &vendor_str, &product_str)) {
3331                 vendor_str = NULL;
3332                 product_str = NULL;
3333         }
3334
3335         if (source != 0x0001) {
3336                 if (vendor_str)
3337                         print_field("  Vendor: %s (0x%4.4x)",
3338                                                 vendor_str, vendor);
3339                 else
3340                         print_field("  Vendor: 0x%4.4x", vendor);
3341         } else
3342                 packet_print_company("  Vendor", vendor);
3343
3344         if (product_str)
3345                 print_field("  Product: %s (0x%4.4x)", product_str, product);
3346         else
3347                 print_field("  Product: 0x%4.4x", product);
3348
3349         print_field("  Version: %u.%u.%u (0x%4.4x)",
3350                                         (version & 0xff00) >> 8,
3351                                         (version & 0x00f0) >> 4,
3352                                         (version & 0x000f), version);
3353
3354         free(vendor_str);
3355         free(product_str);
3356 }
3357
3358 static void print_uuid16_list(const char *label, const void *data,
3359                                                         uint8_t data_len)
3360 {
3361         uint8_t count = data_len / sizeof(uint16_t);
3362         unsigned int i;
3363
3364         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3365
3366         for (i = 0; i < count; i++) {
3367                 uint16_t uuid = get_le16(data + (i * 2));
3368                 print_field("  %s (0x%4.4x)", bt_uuid16_to_str(uuid), uuid);
3369         }
3370 }
3371
3372 static void print_uuid32_list(const char *label, const void *data,
3373                                                         uint8_t data_len)
3374 {
3375         uint8_t count = data_len / sizeof(uint32_t);
3376         unsigned int i;
3377
3378         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3379
3380         for (i = 0; i < count; i++) {
3381                 uint32_t uuid = get_le32(data + (i * 4));
3382                 print_field("  %s (0x%8.8x)", bt_uuid32_to_str(uuid), uuid);
3383         }
3384 }
3385
3386 static void print_uuid128_list(const char *label, const void *data,
3387                                                         uint8_t data_len)
3388 {
3389         uint8_t count = data_len / 16;
3390         unsigned int i;
3391
3392         print_field("%s: %u entr%s", label, count, count == 1 ? "y" : "ies");
3393
3394         for (i = 0; i < count; i++) {
3395                 const uint8_t *uuid = data + (i * 16);
3396
3397                 print_field("  %s", bt_uuid128_to_str(uuid));
3398         }
3399 }
3400
3401 static void *iov_pull(struct iovec *iov, size_t len)
3402 {
3403         void *data;
3404
3405         if (iov->iov_len < len)
3406                 return NULL;
3407
3408         data = iov->iov_base;
3409         iov->iov_base += len;
3410         iov->iov_len -= len;
3411
3412         return data;
3413 }
3414
3415 static struct packet_ltv_decoder*
3416 get_ltv_decoder(struct packet_ltv_decoder *decoder, size_t num, uint8_t type)
3417 {
3418         size_t i;
3419
3420         if (!decoder || !num)
3421                 return NULL;
3422
3423         for (i = 0; i < num; i++) {
3424                 struct packet_ltv_decoder *dec = &decoder[i];
3425
3426                 if (dec->type == type)
3427                         return dec;
3428         }
3429
3430         return NULL;
3431 }
3432
3433 static void print_ltv(const char *label, const uint8_t *data, uint8_t len,
3434                         struct packet_ltv_decoder *decoder, size_t num)
3435 {
3436         struct iovec iov;
3437         int i;
3438
3439         iov.iov_base = (void *) data;
3440         iov.iov_len = len;
3441
3442         for (i = 0; iov.iov_len; i++) {
3443                 uint8_t l, t, *v;
3444                 struct packet_ltv_decoder *dec;
3445
3446                 l = get_u8(iov_pull(&iov, sizeof(l)));
3447                 if (!l) {
3448                         print_field("%s #%d: len 0x%02x", label, i, l);
3449                         break;
3450                 }
3451
3452                 v = iov_pull(&iov, sizeof(*v));
3453                 if (!v)
3454                         break;
3455
3456                 t = get_u8(v);
3457
3458                 print_field("%s #%d: len 0x%02x type 0x%02x", label, i, l, t);
3459
3460                 l -= 1;
3461
3462                 v = iov_pull(&iov, l);
3463                 if (!v)
3464                         break;
3465
3466                 dec = get_ltv_decoder(decoder, num, t);
3467                 if (dec)
3468                         dec->func(v, l);
3469                 else
3470                         print_hex_field(label, v, l);
3471         }
3472
3473         if (iov.iov_len)
3474                 print_hex_field(label, iov.iov_base, iov.iov_len);
3475 }
3476
3477 void packet_print_ltv(const char *label, const uint8_t *data, uint8_t len,
3478                         struct packet_ltv_decoder *decoder, size_t decoder_len)
3479 {
3480         print_ltv(label, data, len, decoder, decoder_len);
3481 }
3482
3483 static void print_base_annoucement(const uint8_t *data, uint8_t data_len)
3484 {
3485         struct iovec iov;
3486         struct bt_hci_le_pa_base_data *base_data;
3487         uint8_t i;
3488
3489         iov.iov_base = (void *) data;
3490         iov.iov_len = data_len;
3491
3492         base_data = iov_pull(&iov, sizeof(*base_data));
3493         if (!base_data)
3494                 goto done;
3495
3496         /* Level 1 - BASE */
3497         print_field("  Presetation Delay: %u", get_le24(base_data->pd));
3498         print_field("  Number of Subgroups: %u", base_data->num_subgroups);
3499
3500         /* Level 2 - Subgroups*/
3501         for (i = 0; i < base_data->num_subgroups; i++) {
3502                 struct bt_hci_le_pa_base_subgroup *subgroup;
3503                 struct bt_hci_lv_data *codec_cfg;
3504                 struct bt_hci_lv_data *metadata;
3505                 uint8_t j;
3506
3507                 print_field("    Subgroup #%u:", i);
3508
3509                 subgroup = iov_pull(&iov, sizeof(*subgroup));
3510                 if (!subgroup)
3511                         goto done;
3512
3513                 print_field("    Number of BIS(s): %u", subgroup->num_bis);
3514                 print_codec_id("    Codec", subgroup->codec.id);
3515
3516                 if (subgroup->codec.id == 0xff) {
3517                         uint16_t id;
3518
3519                         id = le16_to_cpu(subgroup->codec.vid);
3520                         print_field("    Codec Company ID: %s (0x%04x)",
3521                                                 bt_compidtostr(id), id);
3522                         print_field("    Codec Vendor ID: 0x%04x",
3523                                                 subgroup->codec.vid);
3524                 }
3525
3526                 codec_cfg = iov_pull(&iov, sizeof(*codec_cfg));
3527                 if (!codec_cfg)
3528                         goto done;
3529
3530                 if (!iov_pull(&iov, codec_cfg->len))
3531                         goto done;
3532
3533                 print_ltv("    Codec Specific Configuration",
3534                                         codec_cfg->data, codec_cfg->len,
3535                                         NULL, 0);
3536
3537                 metadata = iov_pull(&iov, sizeof(*metadata));
3538                 if (!metadata)
3539                         goto done;
3540
3541                 if (!iov_pull(&iov, metadata->len))
3542                         goto done;
3543
3544                 print_ltv("    Metadata", metadata->data, metadata->len,
3545                                         NULL, 0);
3546
3547                 /* Level 3 - BIS(s)*/
3548                 for (j = 0; j < subgroup->num_bis; j++) {
3549                         struct bt_hci_le_pa_base_bis *bis;
3550
3551                         print_field("      BIS #%u:", j);
3552
3553                         bis = iov_pull(&iov, sizeof(*bis));
3554                         if (!bis)
3555                                 goto done;
3556
3557                         print_field("      Index: %u", bis->index);
3558
3559                         codec_cfg = iov_pull(&iov, sizeof(*codec_cfg));
3560                         if (!codec_cfg)
3561                                 goto done;
3562
3563                         if (!iov_pull(&iov, codec_cfg->len))
3564                                 goto done;
3565
3566                         print_hex_field("      Codec Specific Configuration",
3567                                         codec_cfg->data, codec_cfg->len);
3568                 }
3569         }
3570
3571 done:
3572         if (iov.iov_len)
3573                 print_hex_field("  Data", iov.iov_base, iov.iov_len);
3574 }
3575
3576 static void print_broadcast_annoucement(const uint8_t *data, uint8_t data_len)
3577 {
3578         uint32_t bid;
3579
3580         if (data_len < 3) {
3581                 print_hex_field("  Data", data, data_len);
3582                 return;
3583         }
3584
3585         bid = get_le24(data);
3586         print_field("Broadcast ID: %u (0x%06x)", bid, bid);
3587 }
3588
3589 static const struct service_data_decoder {
3590         uint16_t uuid;
3591         void (*func)(const uint8_t *data, uint8_t data_len);
3592 } service_data_decoders[] = {
3593         { 0x1851, print_base_annoucement },
3594         { 0x1852, print_broadcast_annoucement }
3595 };
3596
3597 static void print_service_data(const uint8_t *data, uint8_t data_len)
3598 {
3599         uint16_t uuid = get_le16(&data[0]);
3600         size_t i;
3601
3602         print_field("Service Data: %s (0x%4.4x)", bt_uuid16_to_str(uuid), uuid);
3603
3604         for (i = 0; i < ARRAY_SIZE(service_data_decoders); i++) {
3605                 const struct service_data_decoder *decoder;
3606
3607                 decoder = &service_data_decoders[i];
3608
3609                 if (decoder->uuid == uuid) {
3610                         decoder->func(&data[2], data_len - 2);
3611                         return;
3612                 }
3613         }
3614
3615         print_hex_field("  Data", &data[2], data_len - 2);
3616 }
3617
3618 static const struct bitfield_data eir_flags_table[] = {
3619         { 0, "LE Limited Discoverable Mode"             },
3620         { 1, "LE General Discoverable Mode"             },
3621         { 2, "BR/EDR Not Supported"                     },
3622         { 3, "Simultaneous LE and BR/EDR (Controller)"  },
3623         { 4, "Simultaneous LE and BR/EDR (Host)"        },
3624         { }
3625 };
3626
3627 static const struct bitfield_data eir_3d_table[] = {
3628         { 0, "Association Notification"                                 },
3629         { 1, "Battery Level Reporting"                                  },
3630         { 2, "Send Battery Level Report on Start-up Synchronization"    },
3631         { 7, "Factory Test Mode"                                        },
3632         { }
3633 };
3634
3635 static const struct bitfield_data mesh_oob_table[] = {
3636         { 0, "Other"                                                    },
3637         { 1, "Electronic / URI"                                         },
3638         { 2, "2D machine-readable code"                                 },
3639         { 3, "Bar code"                                                 },
3640         { 4, "Near Field Communication (NFC)"                           },
3641         { 5, "Number"                                                   },
3642         { 6, "String"                                                   },
3643         { 11, "On box"                                                  },
3644         { 12, "Inside box"                                              },
3645         { 13, "On piece of paper"                                       },
3646         { 14, "Inside manual"                                           },
3647         { 15, "On device"                                               },
3648         { }
3649 };
3650
3651 static void print_mesh_beacon(const uint8_t *data, uint8_t len)
3652 {
3653         uint16_t oob;
3654
3655         print_hex_field("Mesh Beacon", data, len);
3656
3657         if (len < 1)
3658                 return;
3659
3660         switch (data[0]) {
3661         case 0x00:
3662                 print_field("  Unprovisioned Device Beacon (0x00)");
3663                 if (len < 18) {
3664                         packet_hexdump(data + 1, len - 1);
3665                         break;
3666                 }
3667
3668                 print_hex_field("  Device UUID", data + 1, 16);
3669
3670                 oob = get_be16(data + 17);
3671                 print_field("  OOB Information: 0x%4.4x", oob);
3672
3673                 print_bitfield(4, oob, mesh_oob_table);
3674
3675                 if (len < 23) {
3676                         packet_hexdump(data + 18, len - 18);
3677                         break;
3678                 }
3679
3680                 print_field("  URI Hash: 0x%8.8x", get_be32(data + 19));
3681                 packet_hexdump(data + 23, len - 23);
3682                 break;
3683         case 0x01:
3684                 print_field("  Secure Network Beacon (0x01)");
3685                 if (len < 22) {
3686                         packet_hexdump(data + 1, len - 1);
3687                         break;
3688                 }
3689
3690                 print_field("  Flags: 0x%2.2x", data[0]);
3691
3692                 if (data[1] & 0x01)
3693                         print_field("    Key Refresh");
3694
3695                 if (data[1] & 0x02)
3696                         print_field("    IV Update");
3697
3698                 print_hex_field("  Network Id", data + 2, 8);
3699                 print_field("  IV Index: 0x%08x", get_be32(data + 10));
3700                 print_hex_field("  Authentication Value", data + 14, 8);
3701                 packet_hexdump(data + 22, len - 22);
3702                 break;
3703         default:
3704                 print_field("  Invalid Beacon (0x%02x)", data[0]);
3705                 packet_hexdump(data, len);
3706                 break;
3707         }
3708 }
3709
3710 static void print_mesh_prov(const uint8_t *data, uint8_t len)
3711 {
3712         print_hex_field("Mesh Provisioning", data, len);
3713
3714         if (len < 6) {
3715                 packet_hexdump(data, len);
3716                 return;
3717         }
3718
3719         print_field("  Link ID: 0x%08x", get_be32(data));
3720         print_field("  Transaction Number: %u", data[4]);
3721
3722         data += 5;
3723         len -= 5;
3724
3725         switch (data[0] & 0x03) {
3726         case 0x00:
3727                 print_field("  Transaction Start (0x00)");
3728                 if (len < 5) {
3729                         packet_hexdump(data + 1, len - 1);
3730                         return;
3731                 }
3732                 print_field("  SeqN: %u", data[0] & 0xfc >> 2);
3733                 print_field("  TotalLength: %u", get_be16(data + 1));
3734                 print_field("  FCS: 0x%2.2x", data[3]);
3735                 print_hex_field("  Data", data + 4, len - 4);
3736                 packet_hexdump(data + 5, len - 5);
3737                 break;
3738         case 0x01:
3739                 print_field("  Transaction Acknowledgment (0x01)");
3740                 packet_hexdump(data + 1, len - 1);
3741                 break;
3742         case 0x02:
3743                 print_field("  Transaction Continuation (0x02)");
3744                 print_field("  SegmentIndex: %u", data[0] >> 2);
3745                 if (len < 2) {
3746                         packet_hexdump(data + 1, len - 1);
3747                         return;
3748                 }
3749                 print_hex_field("  Data", data + 1, len - 1);
3750                 packet_hexdump(data + 2, len - 2);
3751                 break;
3752         case 0x03:
3753                 print_field("  Provisioning Bearer Control (0x03)");
3754                 switch (data[0] >> 2) {
3755                 case 0x00:
3756                         print_field("  Link Open (0x00)");
3757                         if (len < 17) {
3758                                 packet_hexdump(data + 1, len - 1);
3759                                 break;
3760                         }
3761                         print_hex_field("  Device UUID", data, 16);
3762                         break;
3763                 case 0x01:
3764                         print_field("  Link Ack (0x01)");
3765                         break;
3766                 case 0x02:
3767                         print_field("  Link Close (0x02)");
3768                         if (len < 2) {
3769                                 packet_hexdump(data + 1, len - 1);
3770                                 break;
3771                         }
3772
3773                         switch (data[1]) {
3774                         case 0x00:
3775                                 print_field("  Reason: Success (0x00)");
3776                                 break;
3777                         case 0x01:
3778                                 print_field("  Reason: Timeout (0x01)");
3779                                 break;
3780                         case 0x02:
3781                                 print_field("  Reason: Fail (0x02)");
3782                                 break;
3783                         default:
3784                                 print_field("  Reason: Unrecognized (0x%2.2x)",
3785                                                                 data[1]);
3786                         }
3787                         packet_hexdump(data + 2, len - 2);
3788                         break;
3789                 default:
3790                         packet_hexdump(data + 1, len - 1);
3791                         break;
3792                 }
3793                 break;
3794         default:
3795                 print_field("  Invalid Command (0x%02x)", data[0]);
3796                 packet_hexdump(data, len);
3797                 break;
3798         }
3799 }
3800
3801 static void print_mesh_data(const uint8_t *data, uint8_t len)
3802 {
3803         print_hex_field("Mesh Data", data, len);
3804
3805         if (len < 1)
3806                 return;
3807
3808         print_field("  IVI: %u", data[0] >> 7);
3809         print_field("  NID: 0x%2.2x", data[0] & 0x7f);
3810         packet_hexdump(data + 1, len - 1);
3811 }
3812
3813 static void print_transport_data(const uint8_t *data, uint8_t len)
3814 {
3815         print_field("Transport Discovery Data");
3816
3817         if (len < 3)
3818                 return;
3819
3820         print_field("  Organization: %s (0x%02x)",
3821                         data[0] == 0x01 ? "Bluetooth SIG" : "RFU", data[0]);
3822         print_field("  Flags: 0x%2.2x", data[1]);
3823         print_field("    Role: 0x%2.2x", data[1] & 0x03);
3824
3825         switch (data[1] & 0x03) {
3826         case 0x00:
3827                 print_field("      Not Specified");
3828                 break;
3829         case 0x01:
3830                 print_field("      Seeker Only");
3831                 break;
3832         case 0x02:
3833                 print_field("      Provider Only");
3834                 break;
3835         case 0x03:
3836                 print_field("      Both Seeker an Provider");
3837                 break;
3838         }
3839
3840         print_field("    Transport Data Incomplete: %s (0x%2.2x)",
3841                         data[1] & 0x04 ? "True" : "False", data[1] & 0x04);
3842
3843         print_field("    Transport State: 0x%2.2x", data[1] & 0x18);
3844
3845         switch (data[1] & 0x18) {
3846         case 0x00:
3847                 print_field("      Off");
3848                 break;
3849         case 0x08:
3850                 print_field("      On");
3851                 break;
3852         case 0x10:
3853                 print_field("      Temporary Unavailable");
3854                 break;
3855         case 0x18:
3856                 print_field("      RFU");
3857                 break;
3858         }
3859
3860         print_field("  Length: %u", data[2]);
3861         print_hex_field("  Data", data + 3, len - 3);
3862 }
3863
3864 static void print_eir(const uint8_t *eir, uint8_t eir_len, bool le)
3865 {
3866         uint16_t len = 0;
3867
3868         if (eir_len == 0)
3869                 return;
3870
3871         while (len < eir_len - 1) {
3872                 uint8_t field_len = eir[0];
3873                 const uint8_t *data = &eir[2];
3874                 uint8_t data_len;
3875                 char name[239], label[100];
3876                 uint8_t flags, mask;
3877
3878                 /* Check for the end of EIR */
3879                 if (field_len == 0)
3880                         break;
3881
3882                 len += field_len + 1;
3883
3884                 /* Do not continue EIR Data parsing if got incorrect length */
3885                 if (len > eir_len) {
3886                         len -= field_len + 1;
3887                         break;
3888                 }
3889
3890                 data_len = field_len - 1;
3891
3892                 switch (eir[1]) {
3893                 case BT_EIR_FLAGS:
3894                         flags = *data;
3895
3896                         print_field("Flags: 0x%2.2x", flags);
3897
3898                         mask = print_bitfield(2, flags, eir_flags_table);
3899                         if (mask)
3900                                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
3901                                         "  Unknown flags (0x%2.2x)", mask);
3902                         break;
3903
3904                 case BT_EIR_UUID16_SOME:
3905                         if (data_len < sizeof(uint16_t))
3906                                 break;
3907                         print_uuid16_list("16-bit Service UUIDs (partial)",
3908                                                         data, data_len);
3909                         break;
3910
3911                 case BT_EIR_UUID16_ALL:
3912                         if (data_len < sizeof(uint16_t))
3913                                 break;
3914                         print_uuid16_list("16-bit Service UUIDs (complete)",
3915                                                         data, data_len);
3916                         break;
3917
3918                 case BT_EIR_UUID32_SOME:
3919                         if (data_len < sizeof(uint32_t))
3920                                 break;
3921                         print_uuid32_list("32-bit Service UUIDs (partial)",
3922                                                         data, data_len);
3923                         break;
3924
3925                 case BT_EIR_UUID32_ALL:
3926                         if (data_len < sizeof(uint32_t))
3927                                 break;
3928                         print_uuid32_list("32-bit Service UUIDs (complete)",
3929                                                         data, data_len);
3930                         break;
3931
3932                 case BT_EIR_UUID128_SOME:
3933                         if (data_len < 16)
3934                                 break;
3935                         print_uuid128_list("128-bit Service UUIDs (partial)",
3936                                                                 data, data_len);
3937                         break;
3938
3939                 case BT_EIR_UUID128_ALL:
3940                         if (data_len < 16)
3941                                 break;
3942                         print_uuid128_list("128-bit Service UUIDs (complete)",
3943                                                                 data, data_len);
3944                         break;
3945
3946                 case BT_EIR_NAME_SHORT:
3947                         memset(name, 0, sizeof(name));
3948                         memcpy(name, data, data_len);
3949                         print_field("Name (short): %s", name);
3950                         break;
3951
3952                 case BT_EIR_NAME_COMPLETE:
3953                         memset(name, 0, sizeof(name));
3954                         memcpy(name, data, data_len);
3955                         print_field("Name (complete): %s", name);
3956                         break;
3957
3958                 case BT_EIR_TX_POWER:
3959                         if (data_len < 1)
3960                                 break;
3961                         print_field("TX power: %d dBm", (int8_t) *data);
3962                         break;
3963
3964                 case BT_EIR_CLASS_OF_DEV:
3965                         if (data_len < 3)
3966                                 break;
3967                         print_dev_class(data);
3968                         break;
3969
3970                 case BT_EIR_SSP_HASH_P192:
3971                         if (data_len < 16)
3972                                 break;
3973                         print_hash_p192(data);
3974                         break;
3975
3976                 case BT_EIR_SSP_RANDOMIZER_P192:
3977                         if (data_len < 16)
3978                                 break;
3979                         print_randomizer_p192(data);
3980                         break;
3981
3982                 case BT_EIR_DEVICE_ID:
3983                         /* SMP TK has the same value as Device ID */
3984                         if (le)
3985                                 print_hex_field("SMP TK", data, data_len);
3986                         else if (data_len >= 8)
3987                                 print_device_id(data, data_len);
3988                         break;
3989
3990                 case BT_EIR_SMP_OOB_FLAGS:
3991                         print_field("SMP OOB Flags: 0x%2.2x", *data);
3992                         break;
3993
3994                 case BT_EIR_PERIPHERAL_CONN_INTERVAL:
3995                         if (data_len < 4)
3996                                 break;
3997                         print_field("Peripheral Conn. Interval: "
3998                                                         "0x%4.4x - 0x%4.4x",
3999                                                         get_le16(&data[0]),
4000                                                         get_le16(&data[2]));
4001                         break;
4002
4003                 case BT_EIR_SERVICE_UUID16:
4004                         if (data_len < sizeof(uint16_t))
4005                                 break;
4006                         print_uuid16_list("16-bit Service UUIDs",
4007                                                         data, data_len);
4008                         break;
4009
4010                 case BT_EIR_SERVICE_UUID128:
4011                         if (data_len < 16)
4012                                 break;
4013                         print_uuid128_list("128-bit Service UUIDs",
4014                                                         data, data_len);
4015                         break;
4016
4017                 case BT_EIR_SERVICE_DATA:
4018                         if (data_len < 2)
4019                                 break;
4020                         print_service_data(data, data_len);
4021                         break;
4022
4023                 case BT_EIR_SERVICE_DATA128:
4024                         if (data_len <= 16)
4025                                 break;
4026
4027                         print_field("Service Data UUID 128: %s ",
4028                                                 bt_uuid128_to_str(&data[0]));
4029
4030                         if (data_len > 16)
4031                                 print_hex_field("  Data", &data[16],
4032                                                                 data_len - 16);
4033
4034                         break;
4035                 case BT_EIR_RANDOM_ADDRESS:
4036                         if (data_len < 6)
4037                                 break;
4038                         print_addr("Random Address", data, 0x01);
4039                         break;
4040
4041                 case BT_EIR_PUBLIC_ADDRESS:
4042                         if (data_len < 6)
4043                                 break;
4044                         print_addr("Public Address", data, 0x00);
4045                         break;
4046
4047                 case BT_EIR_GAP_APPEARANCE:
4048                         if (data_len < 2)
4049                                 break;
4050                         print_appearance(get_le16(data));
4051                         break;
4052
4053                 case BT_EIR_SSP_HASH_P256:
4054                         if (data_len < 16)
4055                                 break;
4056                         print_hash_p256(data);
4057                         break;
4058
4059                 case BT_EIR_SSP_RANDOMIZER_P256:
4060                         if (data_len < 16)
4061                                 break;
4062                         print_randomizer_p256(data);
4063                         break;
4064
4065                 case BT_EIR_TRANSPORT_DISCOVERY:
4066                         print_transport_data(data, data_len);
4067                         break;
4068
4069                 case BT_EIR_3D_INFO_DATA:
4070                         print_hex_field("3D Information Data", data, data_len);
4071                         if (data_len < 2)
4072                                 break;
4073
4074                         flags = *data;
4075
4076                         print_field("  Features: 0x%2.2x", flags);
4077
4078                         mask = print_bitfield(4, flags, eir_3d_table);
4079                         if (mask)
4080                                 print_text(COLOR_UNKNOWN_FEATURE_BIT,
4081                                         "      Unknown features (0x%2.2x)", mask);
4082
4083                         print_field("  Path Loss Threshold: %d", data[1]);
4084                         break;
4085
4086                 case BT_EIR_MESH_DATA:
4087                         print_mesh_data(data, data_len);
4088                         break;
4089
4090                 case BT_EIR_MESH_PROV:
4091                         print_mesh_prov(data, data_len);
4092                         break;
4093
4094                 case BT_EIR_MESH_BEACON:
4095                         print_mesh_beacon(data, data_len);
4096                         break;
4097
4098                 case BT_EIR_CSIP_RSI:
4099                         if (data_len < 6)
4100                                 break;
4101                         print_addr("Resolvable Set Identifier", data, 0xff);
4102                         print_field("  Hash: 0x%6x", get_le24(data));
4103                         print_field("  Random: 0x%6x", get_le24(data + 3));
4104                         break;
4105
4106                 case BT_EIR_MANUFACTURER_DATA:
4107                         if (data_len < 2)
4108                                 break;
4109                         print_manufacturer_data(data, data_len);
4110                         break;
4111
4112                 default:
4113                         sprintf(label, "Unknown EIR field 0x%2.2x", eir[1]);
4114                         print_hex_field(label, data, data_len);
4115                         break;
4116                 }
4117
4118                 eir += field_len + 1;
4119         }
4120
4121         if (len < eir_len && eir[0] != 0)
4122                 packet_hexdump(eir, eir_len - len);
4123 }
4124
4125 void packet_print_addr(const char *label, const void *data, uint8_t type)
4126 {
4127         print_addr(label ? : "Address", data, type);
4128 }
4129
4130 void packet_print_handle(uint16_t handle)
4131 {
4132         print_handle_native(handle);
4133 }
4134
4135 void packet_print_rssi(const char *label, int8_t rssi)
4136 {
4137         if ((uint8_t) rssi == 0x99 || rssi == 127)
4138                 print_field("%s: invalid (0x%2.2x)", label, (uint8_t) rssi);
4139         else
4140                 print_field("%s: %d dBm (0x%2.2x)", label, rssi,
4141                                                         (uint8_t) rssi);
4142 }
4143
4144 void packet_print_ad(const void *data, uint8_t size)
4145 {
4146         print_eir(data, size, true);
4147 }
4148
4149 struct broadcast_message {
4150         uint32_t frame_sync_instant;
4151         uint16_t bluetooth_clock_phase;
4152         uint16_t left_open_offset;
4153         uint16_t left_close_offset;
4154         uint16_t right_open_offset;
4155         uint16_t right_close_offset;
4156         uint16_t frame_sync_period;
4157         uint8_t  frame_sync_period_fraction;
4158 } __attribute__ ((packed));
4159
4160 static void print_3d_broadcast(const void *data, uint8_t size)
4161 {
4162         const struct broadcast_message *msg = data;
4163         uint32_t instant;
4164         uint16_t left_open, left_close, right_open, right_close;
4165         uint16_t phase, period;
4166         uint8_t period_frac;
4167         bool mode;
4168
4169         instant = le32_to_cpu(msg->frame_sync_instant);
4170         mode = !!(instant & 0x40000000);
4171         phase = le16_to_cpu(msg->bluetooth_clock_phase);
4172         left_open = le16_to_cpu(msg->left_open_offset);
4173         left_close = le16_to_cpu(msg->left_close_offset);
4174         right_open = le16_to_cpu(msg->right_open_offset);
4175         right_close = le16_to_cpu(msg->right_close_offset);
4176         period = le16_to_cpu(msg->frame_sync_period);
4177         period_frac = msg->frame_sync_period_fraction;
4178
4179         print_field("  Frame sync instant: 0x%8.8x", instant & 0x7fffffff);
4180         print_field("  Video mode: %s (%d)", mode ? "Dual View" : "3D", mode);
4181         print_field("  Bluetooth clock phase: %d usec (0x%4.4x)",
4182                                                 phase, phase);
4183         print_field("  Left lense shutter open offset: %d usec (0x%4.4x)",
4184                                                 left_open, left_open);
4185         print_field("  Left lense shutter close offset: %d usec (0x%4.4x)",
4186                                                 left_close, left_close);
4187         print_field("  Right lense shutter open offset: %d usec (0x%4.4x)",
4188                                                 right_open, right_open);
4189         print_field("  Right lense shutter close offset: %d usec (0x%4.4x)",
4190                                                 right_close, right_close);
4191         print_field("  Frame sync period: %d.%d usec (0x%4.4x 0x%2.2x)",
4192                                                 period, period_frac * 256,
4193                                                 period, period_frac);
4194 }
4195
4196 void packet_hexdump(const unsigned char *buf, uint16_t len)
4197 {
4198         static const char hexdigits[] = "0123456789abcdef";
4199         char str[68];
4200         uint16_t i;
4201
4202         if (!len)
4203                 return;
4204
4205         for (i = 0; i < len; i++) {
4206                 str[((i % 16) * 3) + 0] = hexdigits[buf[i] >> 4];
4207                 str[((i % 16) * 3) + 1] = hexdigits[buf[i] & 0xf];
4208                 str[((i % 16) * 3) + 2] = ' ';
4209                 str[(i % 16) + 49] = isprint(buf[i]) ? buf[i] : '.';
4210
4211                 if ((i + 1) % 16 == 0) {
4212                         str[47] = ' ';
4213                         str[48] = ' ';
4214                         str[65] = '\0';
4215                         print_text(COLOR_WHITE, "%s", str);
4216                         str[0] = ' ';
4217                 }
4218         }
4219
4220         if (i % 16 > 0) {
4221                 uint16_t j;
4222                 for (j = (i % 16); j < 16; j++) {
4223                         str[(j * 3) + 0] = ' ';
4224                         str[(j * 3) + 1] = ' ';
4225                         str[(j * 3) + 2] = ' ';
4226                         str[j + 49] = ' ';
4227                 }
4228                 str[47] = ' ';
4229                 str[48] = ' ';
4230                 str[65] = '\0';
4231                 print_text(COLOR_WHITE, "%s", str);
4232         }
4233 }
4234
4235 void packet_control(struct timeval *tv, struct ucred *cred,
4236                                         uint16_t index, uint16_t opcode,
4237                                         const void *data, uint16_t size)
4238 {
4239         control_message(opcode, data, size);
4240 }
4241
4242 static int addr2str(const uint8_t *addr, char *str)
4243 {
4244         return sprintf(str, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
4245                         addr[5], addr[4], addr[3], addr[2], addr[1], addr[0]);
4246 }
4247
4248 void packet_monitor(struct timeval *tv, struct ucred *cred,
4249                                         uint16_t index, uint16_t opcode,
4250                                         const void *data, uint16_t size)
4251 {
4252         const struct btsnoop_opcode_new_index *ni;
4253         const struct btsnoop_opcode_index_info *ii;
4254         const struct btsnoop_opcode_user_logging *ul;
4255         char str[18], extra_str[24];
4256         uint16_t manufacturer;
4257         const char *ident;
4258
4259         if (index != HCI_DEV_NONE) {
4260                 index_current = index;
4261         }
4262
4263         if (tv && time_offset == ((time_t) -1))
4264                 time_offset = tv->tv_sec;
4265
4266         switch (opcode) {
4267         case BTSNOOP_OPCODE_NEW_INDEX:
4268                 ni = data;
4269
4270                 if (index < MAX_INDEX) {
4271                         index_list[index].type = ni->type;
4272                         memcpy(index_list[index].bdaddr, ni->bdaddr, 6);
4273                         index_list[index].manufacturer = fallback_manufacturer;
4274                         index_list[index].msft_opcode = BT_HCI_CMD_NOP;
4275                 }
4276
4277                 addr2str(ni->bdaddr, str);
4278                 packet_new_index(tv, index, str, ni->type, ni->bus, ni->name);
4279                 break;
4280         case BTSNOOP_OPCODE_DEL_INDEX:
4281                 if (index < MAX_INDEX)
4282                         addr2str(index_list[index].bdaddr, str);
4283                 else
4284                         sprintf(str, "00:00:00:00:00:00");
4285
4286                 packet_del_index(tv, index, str);
4287                 break;
4288         case BTSNOOP_OPCODE_COMMAND_PKT:
4289                 packet_hci_command(tv, cred, index, data, size);
4290                 break;
4291         case BTSNOOP_OPCODE_EVENT_PKT:
4292                 packet_hci_event(tv, cred, index, data, size);
4293                 break;
4294         case BTSNOOP_OPCODE_ACL_TX_PKT:
4295                 packet_hci_acldata(tv, cred, index, false, data, size);
4296                 break;
4297         case BTSNOOP_OPCODE_ACL_RX_PKT:
4298                 packet_hci_acldata(tv, cred, index, true, data, size);
4299                 break;
4300         case BTSNOOP_OPCODE_SCO_TX_PKT:
4301                 packet_hci_scodata(tv, cred, index, false, data, size);
4302                 break;
4303         case BTSNOOP_OPCODE_SCO_RX_PKT:
4304                 packet_hci_scodata(tv, cred, index, true, data, size);
4305                 break;
4306         case BTSNOOP_OPCODE_ISO_TX_PKT:
4307                 packet_hci_isodata(tv, cred, index, false, data, size);
4308                 break;
4309         case BTSNOOP_OPCODE_ISO_RX_PKT:
4310                 packet_hci_isodata(tv, cred, index, true, data, size);
4311                 break;
4312         case BTSNOOP_OPCODE_OPEN_INDEX:
4313                 if (index < MAX_INDEX)
4314                         addr2str(index_list[index].bdaddr, str);
4315                 else
4316                         sprintf(str, "00:00:00:00:00:00");
4317
4318                 packet_open_index(tv, index, str);
4319                 break;
4320         case BTSNOOP_OPCODE_CLOSE_INDEX:
4321                 if (index < MAX_INDEX)
4322                         addr2str(index_list[index].bdaddr, str);
4323                 else
4324                         sprintf(str, "00:00:00:00:00:00");
4325
4326                 packet_close_index(tv, index, str);
4327                 break;
4328         case BTSNOOP_OPCODE_INDEX_INFO:
4329                 ii = data;
4330                 manufacturer = le16_to_cpu(ii->manufacturer);
4331
4332                 if (index < MAX_INDEX) {
4333                         memcpy(index_list[index].bdaddr, ii->bdaddr, 6);
4334                         index_list[index].manufacturer = manufacturer;
4335
4336                         switch (manufacturer) {
4337                         case 2:
4338                                 /*
4339                                  * Intel controllers that support the
4340                                  * Microsoft vendor extension are using
4341                                  * 0xFC1E for VsMsftOpCode.
4342                                  */
4343                                 index_list[index].msft_opcode = 0xFC1E;
4344                                 break;
4345                         case 93:
4346                                 /*
4347                                  * Realtek controllers that support the
4348                                  * Microsoft vendor extenions are using
4349                                  * 0xFCF0 for VsMsftOpCode.
4350                                  */
4351                                 index_list[index].msft_opcode = 0xFCF0;
4352                                 break;
4353                         case 1521:
4354                                 /*
4355                                  * Emulator controllers use Linux Foundation as
4356                                  * manufacturer and support the
4357                                  * Microsoft vendor extenions using
4358                                  * 0xFC1E for VsMsftOpCode.
4359                                  */
4360                                 index_list[index].msft_opcode = 0xFC1E;
4361                                 break;
4362                         }
4363                 }
4364
4365                 addr2str(ii->bdaddr, str);
4366                 packet_index_info(tv, index, str, manufacturer);
4367                 break;
4368         case BTSNOOP_OPCODE_VENDOR_DIAG:
4369                 if (index < MAX_INDEX)
4370                         manufacturer = index_list[index].manufacturer;
4371                 else
4372                         manufacturer = fallback_manufacturer;
4373
4374                 packet_vendor_diag(tv, index, manufacturer, data, size);
4375                 break;
4376         case BTSNOOP_OPCODE_SYSTEM_NOTE:
4377                 packet_system_note(tv, cred, index, data);
4378                 break;
4379         case BTSNOOP_OPCODE_USER_LOGGING:
4380                 ul = data;
4381                 ident = ul->ident_len ? data + sizeof(*ul) : NULL;
4382
4383                 packet_user_logging(tv, cred, index, ul->priority, ident,
4384                                         data + sizeof(*ul) + ul->ident_len,
4385                                         size - (sizeof(*ul) + ul->ident_len));
4386                 break;
4387         case BTSNOOP_OPCODE_CTRL_OPEN:
4388                 control_disable_decoding();
4389                 packet_ctrl_open(tv, cred, index, data, size);
4390                 break;
4391         case BTSNOOP_OPCODE_CTRL_CLOSE:
4392                 packet_ctrl_close(tv, cred, index, data, size);
4393                 break;
4394         case BTSNOOP_OPCODE_CTRL_COMMAND:
4395                 packet_ctrl_command(tv, cred, index, data, size);
4396                 break;
4397         case BTSNOOP_OPCODE_CTRL_EVENT:
4398                 packet_ctrl_event(tv, cred, index, data, size);
4399                 break;
4400         default:
4401                 sprintf(extra_str, "(code %d len %d)", opcode, size);
4402                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
4403                                         "Unknown packet", NULL, extra_str);
4404                 packet_hexdump(data, size);
4405                 break;
4406         }
4407 }
4408
4409 void packet_simulator(struct timeval *tv, uint16_t frequency,
4410                                         const void *data, uint16_t size)
4411 {
4412         char str[10];
4413
4414         if (tv && time_offset == ((time_t) -1))
4415                 time_offset = tv->tv_sec;
4416
4417         sprintf(str, "%u MHz", frequency);
4418
4419         print_packet(tv, NULL, '*', 0, NULL, COLOR_PHY_PACKET,
4420                                         "Physical packet:", NULL, str);
4421
4422         ll_packet(frequency, data, size, false);
4423 }
4424
4425 static void null_cmd(uint16_t index, const void *data, uint8_t size)
4426 {
4427 }
4428
4429 static void status_rsp(uint16_t index, const void *data, uint8_t size)
4430 {
4431         uint8_t status = *((const uint8_t *) data);
4432
4433         print_status(status);
4434 }
4435
4436 static void status_handle_rsp(uint16_t index, const void *data, uint8_t size)
4437 {
4438         uint8_t status = *((const uint8_t *) data);
4439
4440         print_status(status);
4441         print_field("Connection handle: %d", get_u8(data + 1));
4442 }
4443
4444 static void status_bdaddr_rsp(uint16_t index, const void *data, uint8_t size)
4445 {
4446         uint8_t status = *((const uint8_t *) data);
4447
4448         print_status(status);
4449         print_bdaddr(data + 1);
4450 }
4451
4452 static void inquiry_cmd(uint16_t index, const void *data, uint8_t size)
4453 {
4454         const struct bt_hci_cmd_inquiry *cmd = data;
4455
4456         print_iac(cmd->lap);
4457         print_field("Length: %.2fs (0x%2.2x)",
4458                                 cmd->length * 1.28, cmd->length);
4459         print_num_resp(cmd->num_resp);
4460 }
4461
4462 static void periodic_inquiry_cmd(uint16_t index, const void *data, uint8_t size)
4463 {
4464         const struct bt_hci_cmd_periodic_inquiry *cmd = data;
4465
4466         print_field("Max period: %.2fs (0x%2.2x)",
4467                                 cmd->max_period * 1.28, cmd->max_period);
4468         print_field("Min period: %.2fs (0x%2.2x)",
4469                                 cmd->min_period * 1.28, cmd->min_period);
4470         print_iac(cmd->lap);
4471         print_field("Length: %.2fs (0x%2.2x)",
4472                                 cmd->length * 1.28, cmd->length);
4473         print_num_resp(cmd->num_resp);
4474 }
4475
4476 static void create_conn_cmd(uint16_t index, const void *data, uint8_t size)
4477 {
4478         const struct bt_hci_cmd_create_conn *cmd = data;
4479         const char *str;
4480
4481         print_bdaddr(cmd->bdaddr);
4482         print_pkt_type(cmd->pkt_type);
4483         print_pscan_rep_mode(cmd->pscan_rep_mode);
4484         print_pscan_mode(cmd->pscan_mode);
4485         print_clock_offset(cmd->clock_offset);
4486
4487         switch (cmd->role_switch) {
4488         case 0x00:
4489                 str = "Stay central";
4490                 break;
4491         case 0x01:
4492                 str = "Allow peripheral";
4493                 break;
4494         default:
4495                 str = "Reserved";
4496                 break;
4497         }
4498
4499         print_field("Role switch: %s (0x%2.2x)", str, cmd->role_switch);
4500 }
4501
4502 static void disconnect_cmd(uint16_t index, const void *data, uint8_t size)
4503 {
4504         const struct bt_hci_cmd_disconnect *cmd = data;
4505
4506         print_handle(cmd->handle);
4507         print_reason(cmd->reason);
4508 }
4509
4510 static void add_sco_conn_cmd(uint16_t index, const void *data, uint8_t size)
4511 {
4512         const struct bt_hci_cmd_add_sco_conn *cmd = data;
4513
4514         print_handle(cmd->handle);
4515         print_pkt_type_sco(cmd->pkt_type);
4516 }
4517
4518 static void create_conn_cancel_cmd(uint16_t index, const void *data,
4519                                                         uint8_t size)
4520 {
4521         const struct bt_hci_cmd_create_conn_cancel *cmd = data;
4522
4523         print_bdaddr(cmd->bdaddr);
4524 }
4525
4526 static void accept_conn_request_cmd(uint16_t index, const void *data,
4527                                                         uint8_t size)
4528 {
4529         const struct bt_hci_cmd_accept_conn_request *cmd = data;
4530
4531         print_bdaddr(cmd->bdaddr);
4532         print_role(cmd->role);
4533 }
4534
4535 static void reject_conn_request_cmd(uint16_t index, const void *data,
4536                                                         uint8_t size)
4537 {
4538         const struct bt_hci_cmd_reject_conn_request *cmd = data;
4539
4540         print_bdaddr(cmd->bdaddr);
4541         print_reason(cmd->reason);
4542 }
4543
4544 static void link_key_request_reply_cmd(uint16_t index, const void *data,
4545                                                         uint8_t size)
4546 {
4547         const struct bt_hci_cmd_link_key_request_reply *cmd = data;
4548
4549         print_bdaddr(cmd->bdaddr);
4550         print_link_key(cmd->link_key);
4551 }
4552
4553 static void link_key_request_neg_reply_cmd(uint16_t index, const void *data,
4554                                                         uint8_t size)
4555 {
4556         const struct bt_hci_cmd_link_key_request_neg_reply *cmd = data;
4557
4558         print_bdaddr(cmd->bdaddr);
4559 }
4560
4561 static void pin_code_request_reply_cmd(uint16_t index, const void *data,
4562                                                         uint8_t size)
4563 {
4564         const struct bt_hci_cmd_pin_code_request_reply *cmd = data;
4565
4566         print_bdaddr(cmd->bdaddr);
4567         print_field("PIN length: %d", cmd->pin_len);
4568         print_pin_code(cmd->pin_code, cmd->pin_len);
4569 }
4570
4571 static void pin_code_request_neg_reply_cmd(uint16_t index, const void *data,
4572                                                         uint8_t size)
4573 {
4574         const struct bt_hci_cmd_pin_code_request_neg_reply *cmd = data;
4575
4576         print_bdaddr(cmd->bdaddr);
4577 }
4578
4579 static void change_conn_pkt_type_cmd(uint16_t index, const void *data,
4580                                                         uint8_t size)
4581 {
4582         const struct bt_hci_cmd_change_conn_pkt_type *cmd = data;
4583
4584         print_handle(cmd->handle);
4585         print_pkt_type(cmd->pkt_type);
4586 }
4587
4588 static void auth_requested_cmd(uint16_t index, const void *data, uint8_t size)
4589 {
4590         const struct bt_hci_cmd_auth_requested *cmd = data;
4591
4592         print_handle(cmd->handle);
4593 }
4594
4595 static void set_conn_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
4596 {
4597         const struct bt_hci_cmd_set_conn_encrypt *cmd = data;
4598
4599         print_handle(cmd->handle);
4600         print_enable("Encryption", cmd->encr_mode);
4601 }
4602
4603 static void change_conn_link_key_cmd(uint16_t index, const void *data,
4604                                                         uint8_t size)
4605 {
4606         const struct bt_hci_cmd_change_conn_link_key *cmd = data;
4607
4608         print_handle(cmd->handle);
4609 }
4610
4611 static void link_key_selection_cmd(uint16_t index, const void *data,
4612                                                         uint8_t size)
4613 {
4614         const struct bt_hci_cmd_link_key_selection *cmd = data;
4615
4616         print_key_flag(cmd->key_flag);
4617 }
4618
4619 static void remote_name_request_cmd(uint16_t index, const void *data,
4620                                                         uint8_t size)
4621 {
4622         const struct bt_hci_cmd_remote_name_request *cmd = data;
4623
4624         print_bdaddr(cmd->bdaddr);
4625         print_pscan_rep_mode(cmd->pscan_rep_mode);
4626         print_pscan_mode(cmd->pscan_mode);
4627         print_clock_offset(cmd->clock_offset);
4628 }
4629
4630 static void remote_name_request_cancel_cmd(uint16_t index, const void *data,
4631                                                         uint8_t size)
4632 {
4633         const struct bt_hci_cmd_remote_name_request_cancel *cmd = data;
4634
4635         print_bdaddr(cmd->bdaddr);
4636 }
4637
4638 static void read_remote_features_cmd(uint16_t index, const void *data,
4639                                                         uint8_t size)
4640 {
4641         const struct bt_hci_cmd_read_remote_features *cmd = data;
4642
4643         print_handle(cmd->handle);
4644 }
4645
4646 static void read_remote_ext_features_cmd(uint16_t index, const void *data,
4647                                                         uint8_t size)
4648 {
4649         const struct bt_hci_cmd_read_remote_ext_features *cmd = data;
4650
4651         print_handle(cmd->handle);
4652         print_field("Page: %d", cmd->page);
4653 }
4654
4655 static void read_remote_version_cmd(uint16_t index, const void *data,
4656                                                         uint8_t size)
4657 {
4658         const struct bt_hci_cmd_read_remote_version *cmd = data;
4659
4660         print_handle(cmd->handle);
4661 }
4662
4663 static void read_clock_offset_cmd(uint16_t index, const void *data,
4664                                                         uint8_t size)
4665 {
4666         const struct bt_hci_cmd_read_clock_offset *cmd = data;
4667
4668         print_handle(cmd->handle);
4669 }
4670
4671 static void read_lmp_handle_cmd(uint16_t index, const void *data, uint8_t size)
4672 {
4673         const struct bt_hci_cmd_read_lmp_handle *cmd = data;
4674
4675         print_handle(cmd->handle);
4676 }
4677
4678 static void read_lmp_handle_rsp(uint16_t index, const void *data, uint8_t size)
4679 {
4680         const struct bt_hci_rsp_read_lmp_handle *rsp = data;
4681
4682         print_status(rsp->status);
4683         print_handle(rsp->handle);
4684         print_field("LMP handle: %d", rsp->lmp_handle);
4685         print_field("Reserved: %d", le32_to_cpu(rsp->reserved));
4686 }
4687
4688 static void setup_sync_conn_cmd(uint16_t index, const void *data, uint8_t size)
4689 {
4690         const struct bt_hci_cmd_setup_sync_conn *cmd = data;
4691
4692         print_handle(cmd->handle);
4693         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4694         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4695         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4696         print_voice_setting(cmd->voice_setting);
4697         print_retransmission_effort(cmd->retrans_effort);
4698         print_pkt_type_sco(cmd->pkt_type);
4699 }
4700
4701 static void accept_sync_conn_request_cmd(uint16_t index, const void *data,
4702                                                         uint8_t size)
4703 {
4704         const struct bt_hci_cmd_accept_sync_conn_request *cmd = data;
4705
4706         print_bdaddr(cmd->bdaddr);
4707         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4708         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4709         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4710         print_voice_setting(cmd->voice_setting);
4711         print_retransmission_effort(cmd->retrans_effort);
4712         print_pkt_type_sco(cmd->pkt_type);
4713 }
4714
4715 static void reject_sync_conn_request_cmd(uint16_t index, const void *data,
4716                                                         uint8_t size)
4717 {
4718         const struct bt_hci_cmd_reject_sync_conn_request *cmd = data;
4719
4720         print_bdaddr(cmd->bdaddr);
4721         print_reason(cmd->reason);
4722 }
4723
4724 static void io_capability_request_reply_cmd(uint16_t index, const void *data,
4725                                                         uint8_t size)
4726 {
4727         const struct bt_hci_cmd_io_capability_request_reply *cmd = data;
4728
4729         print_bdaddr(cmd->bdaddr);
4730         print_io_capability(cmd->capability);
4731         print_oob_data(cmd->oob_data);
4732         print_authentication(cmd->authentication);
4733 }
4734
4735 static void user_confirm_request_reply_cmd(uint16_t index, const void *data,
4736                                                         uint8_t size)
4737 {
4738         const struct bt_hci_cmd_user_confirm_request_reply *cmd = data;
4739
4740         print_bdaddr(cmd->bdaddr);
4741 }
4742
4743 static void user_confirm_request_neg_reply_cmd(uint16_t index, const void *data,
4744                                                         uint8_t size)
4745 {
4746         const struct bt_hci_cmd_user_confirm_request_neg_reply *cmd = data;
4747
4748         print_bdaddr(cmd->bdaddr);
4749 }
4750
4751 static void user_passkey_request_reply_cmd(uint16_t index, const void *data,
4752                                                         uint8_t size)
4753 {
4754         const struct bt_hci_cmd_user_passkey_request_reply *cmd = data;
4755
4756         print_bdaddr(cmd->bdaddr);
4757         print_passkey(cmd->passkey);
4758 }
4759
4760 static void user_passkey_request_neg_reply_cmd(uint16_t index, const void *data,
4761                                                         uint8_t size)
4762 {
4763         const struct bt_hci_cmd_user_passkey_request_neg_reply *cmd = data;
4764
4765         print_bdaddr(cmd->bdaddr);
4766 }
4767
4768 static void remote_oob_data_request_reply_cmd(uint16_t index, const void *data,
4769                                                         uint8_t size)
4770 {
4771         const struct bt_hci_cmd_remote_oob_data_request_reply *cmd = data;
4772
4773         print_bdaddr(cmd->bdaddr);
4774         print_hash_p192(cmd->hash);
4775         print_randomizer_p192(cmd->randomizer);
4776 }
4777
4778 static void remote_oob_data_request_neg_reply_cmd(uint16_t index,
4779                                                 const void *data, uint8_t size)
4780 {
4781         const struct bt_hci_cmd_remote_oob_data_request_neg_reply *cmd = data;
4782
4783         print_bdaddr(cmd->bdaddr);
4784 }
4785
4786 static void io_capability_request_neg_reply_cmd(uint16_t index,
4787                                                 const void *data, uint8_t size)
4788 {
4789         const struct bt_hci_cmd_io_capability_request_neg_reply *cmd = data;
4790
4791         print_bdaddr(cmd->bdaddr);
4792         print_reason(cmd->reason);
4793 }
4794
4795 static void create_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4796 {
4797         const struct bt_hci_cmd_create_phy_link *cmd = data;
4798
4799         print_phy_handle(cmd->phy_handle);
4800         print_key_len(cmd->key_len);
4801         print_key_type(cmd->key_type);
4802
4803         packet_hexdump(data + 3, size - 3);
4804 }
4805
4806 static void accept_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4807 {
4808         const struct bt_hci_cmd_accept_phy_link *cmd = data;
4809
4810         print_phy_handle(cmd->phy_handle);
4811         print_key_len(cmd->key_len);
4812         print_key_type(cmd->key_type);
4813
4814         packet_hexdump(data + 3, size - 3);
4815 }
4816
4817 static void disconn_phy_link_cmd(uint16_t index, const void *data, uint8_t size)
4818 {
4819         const struct bt_hci_cmd_disconn_phy_link *cmd = data;
4820
4821         print_phy_handle(cmd->phy_handle);
4822         print_reason(cmd->reason);
4823 }
4824
4825 static void create_logic_link_cmd(uint16_t index, const void *data,
4826                                                         uint8_t size)
4827 {
4828         const struct bt_hci_cmd_create_logic_link *cmd = data;
4829
4830         print_phy_handle(cmd->phy_handle);
4831         print_flow_spec("TX", cmd->tx_flow_spec);
4832         print_flow_spec("RX", cmd->rx_flow_spec);
4833 }
4834
4835 static void accept_logic_link_cmd(uint16_t index, const void *data,
4836                                                         uint8_t size)
4837 {
4838         const struct bt_hci_cmd_accept_logic_link *cmd = data;
4839
4840         print_phy_handle(cmd->phy_handle);
4841         print_flow_spec("TX", cmd->tx_flow_spec);
4842         print_flow_spec("RX", cmd->rx_flow_spec);
4843 }
4844
4845 static void disconn_logic_link_cmd(uint16_t index, const void *data,
4846                                                         uint8_t size)
4847 {
4848         const struct bt_hci_cmd_disconn_logic_link *cmd = data;
4849
4850         print_handle(cmd->handle);
4851 }
4852
4853 static void logic_link_cancel_cmd(uint16_t index, const void *data,
4854                                                         uint8_t size)
4855 {
4856         const struct bt_hci_cmd_logic_link_cancel *cmd = data;
4857
4858         print_phy_handle(cmd->phy_handle);
4859         print_field("TX flow spec: 0x%2.2x", cmd->flow_spec);
4860 }
4861
4862 static void logic_link_cancel_rsp(uint16_t index, const void *data,
4863                                                         uint8_t size)
4864 {
4865         const struct bt_hci_rsp_logic_link_cancel *rsp = data;
4866
4867         print_status(rsp->status);
4868         print_phy_handle(rsp->phy_handle);
4869         print_field("TX flow spec: 0x%2.2x", rsp->flow_spec);
4870 }
4871
4872 static void flow_spec_modify_cmd(uint16_t index, const void *data, uint8_t size)
4873 {
4874         const struct bt_hci_cmd_flow_spec_modify *cmd = data;
4875
4876         print_handle(cmd->handle);
4877         print_flow_spec("TX", cmd->tx_flow_spec);
4878         print_flow_spec("RX", cmd->rx_flow_spec);
4879 }
4880
4881 static void enhanced_setup_sync_conn_cmd(uint16_t index, const void *data,
4882                                                         uint8_t size)
4883 {
4884         const struct bt_hci_cmd_enhanced_setup_sync_conn *cmd = data;
4885
4886         print_handle(cmd->handle);
4887         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4888         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4889
4890         /* TODO */
4891
4892         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4893         print_pkt_type_sco(cmd->pkt_type);
4894         print_retransmission_effort(cmd->retrans_effort);
4895 }
4896
4897 static void enhanced_accept_sync_conn_request_cmd(uint16_t index,
4898                                                 const void *data,
4899                                                 uint8_t size)
4900 {
4901         const struct bt_hci_cmd_enhanced_accept_sync_conn_request *cmd = data;
4902
4903         print_bdaddr(cmd->bdaddr);
4904         print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
4905         print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
4906
4907         /* TODO */
4908
4909         print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
4910         print_pkt_type_sco(cmd->pkt_type);
4911         print_retransmission_effort(cmd->retrans_effort);
4912 }
4913
4914 static void truncated_page_cmd(uint16_t index, const void *data, uint8_t size)
4915 {
4916         const struct bt_hci_cmd_truncated_page *cmd = data;
4917
4918         print_bdaddr(cmd->bdaddr);
4919         print_pscan_rep_mode(cmd->pscan_rep_mode);
4920         print_clock_offset(cmd->clock_offset);
4921 }
4922
4923 static void truncated_page_cancel_cmd(uint16_t index, const void *data,
4924                                                         uint8_t size)
4925 {
4926         const struct bt_hci_cmd_truncated_page_cancel *cmd = data;
4927
4928         print_bdaddr(cmd->bdaddr);
4929 }
4930
4931 static void set_peripheral_broadcast_cmd(uint16_t index, const void *data,
4932                                                         uint8_t size)
4933 {
4934         const struct bt_hci_cmd_set_peripheral_broadcast *cmd = data;
4935
4936         print_field("Enable: 0x%2.2x", cmd->enable);
4937         print_lt_addr(cmd->lt_addr);
4938         print_lpo_allowed(cmd->lpo_allowed);
4939         print_pkt_type(cmd->pkt_type);
4940         print_slot_625("Min interval", cmd->min_interval);
4941         print_slot_625("Max interval", cmd->max_interval);
4942         print_slot_625("Supervision timeout", cmd->timeout);
4943 }
4944
4945 static void set_peripheral_broadcast_rsp(uint16_t index, const void *data,
4946                                                         uint8_t size)
4947 {
4948         const struct bt_hci_rsp_set_peripheral_broadcast *rsp = data;
4949
4950         print_status(rsp->status);
4951         print_lt_addr(rsp->lt_addr);
4952         print_interval(rsp->interval);
4953 }
4954
4955 static void set_peripheral_broadcast_receive_cmd(uint16_t index,
4956                                                 const void *data, uint8_t size)
4957 {
4958         const struct bt_hci_cmd_set_peripheral_broadcast_receive *cmd = data;
4959
4960         print_field("Enable: 0x%2.2x", cmd->enable);
4961         print_bdaddr(cmd->bdaddr);
4962         print_lt_addr(cmd->lt_addr);
4963         print_interval(cmd->interval);
4964         print_field("Offset: 0x%8.8x", le32_to_cpu(cmd->offset));
4965         print_field("Next broadcast instant: 0x%4.4x",
4966                                         le16_to_cpu(cmd->instant));
4967         print_slot_625("Supervision timeout", cmd->timeout);
4968         print_field("Remote timing accuracy: %d ppm", cmd->accuracy);
4969         print_field("Skip: 0x%2.2x", cmd->skip);
4970         print_pkt_type(cmd->pkt_type);
4971         print_channel_map(cmd->map);
4972 }
4973
4974 static void set_peripheral_broadcast_receive_rsp(uint16_t index,
4975                                                 const void *data, uint8_t size)
4976 {
4977         const struct bt_hci_rsp_set_peripheral_broadcast_receive *rsp = data;
4978
4979         print_status(rsp->status);
4980         print_bdaddr(rsp->bdaddr);
4981         print_lt_addr(rsp->lt_addr);
4982 }
4983
4984 static void receive_sync_train_cmd(uint16_t index, const void *data,
4985                                                         uint8_t size)
4986 {
4987         const struct bt_hci_cmd_receive_sync_train *cmd = data;
4988
4989         print_bdaddr(cmd->bdaddr);
4990         print_timeout(cmd->timeout);
4991         print_window(cmd->window);
4992         print_interval(cmd->interval);
4993 }
4994
4995 static void remote_oob_ext_data_request_reply_cmd(uint16_t index,
4996                                                 const void *data, uint8_t size)
4997 {
4998         const struct bt_hci_cmd_remote_oob_ext_data_request_reply *cmd = data;
4999
5000         print_bdaddr(cmd->bdaddr);
5001         print_hash_p192(cmd->hash192);
5002         print_randomizer_p192(cmd->randomizer192);
5003         print_hash_p256(cmd->hash256);
5004         print_randomizer_p256(cmd->randomizer256);
5005 }
5006
5007 static void hold_mode_cmd(uint16_t index, const void *data, uint8_t size)
5008 {
5009         const struct bt_hci_cmd_hold_mode *cmd = data;
5010
5011         print_handle(cmd->handle);
5012         print_slot_625("Hold max interval", cmd->max_interval);
5013         print_slot_625("Hold min interval", cmd->min_interval);
5014 }
5015
5016 static void sniff_mode_cmd(uint16_t index, const void *data, uint8_t size)
5017 {
5018         const struct bt_hci_cmd_sniff_mode *cmd = data;
5019
5020         print_handle(cmd->handle);
5021         print_slot_625("Sniff max interval", cmd->max_interval);
5022         print_slot_625("Sniff min interval", cmd->min_interval);
5023         print_slot_125("Sniff attempt", cmd->attempt);
5024         print_slot_125("Sniff timeout", cmd->timeout);
5025 }
5026
5027 static void exit_sniff_mode_cmd(uint16_t index, const void *data, uint8_t size)
5028 {
5029         const struct bt_hci_cmd_exit_sniff_mode *cmd = data;
5030
5031         print_handle(cmd->handle);
5032 }
5033
5034 static void park_state_cmd(uint16_t index, const void *data, uint8_t size)
5035 {
5036         const struct bt_hci_cmd_park_state *cmd = data;
5037
5038         print_handle(cmd->handle);
5039         print_slot_625("Beacon max interval", cmd->max_interval);
5040         print_slot_625("Beacon min interval", cmd->min_interval);
5041 }
5042
5043 static void exit_park_state_cmd(uint16_t index, const void *data, uint8_t size)
5044 {
5045         const struct bt_hci_cmd_exit_park_state *cmd = data;
5046
5047         print_handle(cmd->handle);
5048 }
5049
5050 static void qos_setup_cmd(uint16_t index, const void *data, uint8_t size)
5051 {
5052         const struct bt_hci_cmd_qos_setup *cmd = data;
5053
5054         print_handle(cmd->handle);
5055         print_field("Flags: 0x%2.2x", cmd->flags);
5056
5057         print_service_type(cmd->service_type);
5058
5059         print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
5060         print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
5061         print_field("Latency: %d", le32_to_cpu(cmd->latency));
5062         print_field("Delay variation: %d", le32_to_cpu(cmd->delay_variation));
5063 }
5064
5065 static void role_discovery_cmd(uint16_t index, const void *data, uint8_t size)
5066 {
5067         const struct bt_hci_cmd_role_discovery *cmd = data;
5068
5069         print_handle(cmd->handle);
5070 }
5071
5072 static void role_discovery_rsp(uint16_t index, const void *data, uint8_t size)
5073 {
5074         const struct bt_hci_rsp_role_discovery *rsp = data;
5075
5076         print_status(rsp->status);
5077         print_handle(rsp->handle);
5078         print_role(rsp->role);
5079 }
5080
5081 static void switch_role_cmd(uint16_t index, const void *data, uint8_t size)
5082 {
5083         const struct bt_hci_cmd_switch_role *cmd = data;
5084
5085         print_bdaddr(cmd->bdaddr);
5086         print_role(cmd->role);
5087 }
5088
5089 static void read_link_policy_cmd(uint16_t index, const void *data, uint8_t size)
5090 {
5091         const struct bt_hci_cmd_read_link_policy *cmd = data;
5092
5093         print_handle(cmd->handle);
5094 }
5095
5096 static void read_link_policy_rsp(uint16_t index, const void *data, uint8_t size)
5097 {
5098         const struct bt_hci_rsp_read_link_policy *rsp = data;
5099
5100         print_status(rsp->status);
5101         print_handle(rsp->handle);
5102         print_link_policy(rsp->policy);
5103 }
5104
5105 static void write_link_policy_cmd(uint16_t index, const void *data,
5106                                                         uint8_t size)
5107 {
5108         const struct bt_hci_cmd_write_link_policy *cmd = data;
5109
5110         print_handle(cmd->handle);
5111         print_link_policy(cmd->policy);
5112 }
5113
5114 static void write_link_policy_rsp(uint16_t index, const void *data,
5115                                                         uint8_t size)
5116 {
5117         const struct bt_hci_rsp_write_link_policy *rsp = data;
5118
5119         print_status(rsp->status);
5120         print_handle(rsp->handle);
5121 }
5122
5123 static void read_default_link_policy_rsp(uint16_t index, const void *data,
5124                                                         uint8_t size)
5125 {
5126         const struct bt_hci_rsp_read_default_link_policy *rsp = data;
5127
5128         print_status(rsp->status);
5129         print_link_policy(rsp->policy);
5130 }
5131
5132 static void write_default_link_policy_cmd(uint16_t index, const void *data,
5133                                                         uint8_t size)
5134 {
5135         const struct bt_hci_cmd_write_default_link_policy *cmd = data;
5136
5137         print_link_policy(cmd->policy);
5138 }
5139
5140 static void flow_spec_cmd(uint16_t index, const void *data, uint8_t size)
5141 {
5142         const struct bt_hci_cmd_flow_spec *cmd = data;
5143
5144         print_handle(cmd->handle);
5145         print_field("Flags: 0x%2.2x", cmd->flags);
5146
5147         print_flow_direction(cmd->direction);
5148         print_service_type(cmd->service_type);
5149
5150         print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
5151         print_field("Token bucket size: %d",
5152                                         le32_to_cpu(cmd->token_bucket_size));
5153         print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
5154         print_field("Access latency: %d", le32_to_cpu(cmd->access_latency));
5155 }
5156
5157 static void sniff_subrating_cmd(uint16_t index, const void *data, uint8_t size)
5158 {
5159         const struct bt_hci_cmd_sniff_subrating *cmd = data;
5160
5161         print_handle(cmd->handle);
5162         print_slot_625("Max latency", cmd->max_latency);
5163         print_slot_625("Min remote timeout", cmd->min_remote_timeout);
5164         print_slot_625("Min local timeout", cmd->min_local_timeout);
5165 }
5166
5167 static void sniff_subrating_rsp(uint16_t index, const void *data, uint8_t size)
5168 {
5169         const struct bt_hci_rsp_sniff_subrating *rsp = data;
5170
5171         print_status(rsp->status);
5172         print_handle(rsp->handle);
5173 }
5174
5175 static void set_event_mask_cmd(uint16_t index, const void *data, uint8_t size)
5176 {
5177         const struct bt_hci_cmd_set_event_mask *cmd = data;
5178
5179         print_event_mask(cmd->mask, events_table);
5180 }
5181
5182 static void set_event_filter_cmd(uint16_t index, const void *data, uint8_t size)
5183 {
5184         uint8_t type = *((const uint8_t *) data);
5185         uint8_t filter;
5186         const char *str;
5187
5188         switch (type) {
5189         case 0x00:
5190                 str = "Clear All Filters";
5191                 break;
5192         case 0x01:
5193                 str = "Inquiry Result";
5194                 break;
5195         case 0x02:
5196                 str = "Connection Setup";
5197                 break;
5198         default:
5199                 str = "Reserved";
5200                 break;
5201         }
5202
5203         print_field("Type: %s (0x%2.2x)", str, type);
5204
5205         switch (type) {
5206         case 0x00:
5207                 if (size > 1) {
5208                         print_text(COLOR_ERROR, "  invalid parameter size");
5209                         packet_hexdump(data + 1, size - 1);
5210                 }
5211                 break;
5212
5213         case 0x01:
5214                 if (size < 2) {
5215                         print_text(COLOR_ERROR, "  invalid parameter size");
5216                         break;
5217                 }
5218                 filter = *((const uint8_t *) (data + 1));
5219
5220                 switch (filter) {
5221                 case 0x00:
5222                         str = "Return responses from all devices";
5223                         break;
5224                 case 0x01:
5225                         str = "Device with specific Class of Device";
5226                         break;
5227                 case 0x02:
5228                         str = "Device with specific BD_ADDR";
5229                         break;
5230                 default:
5231                         str = "Reserved";
5232                         break;
5233                 }
5234
5235                 print_field("Filter: %s (0x%2.2x)", str, filter);
5236                 packet_hexdump(data + 2, size - 2);
5237                 break;
5238
5239         case 0x02:
5240                 filter = *((const uint8_t *) (data + 1));
5241
5242                 switch (filter) {
5243                 case 0x00:
5244                         str = "Allow connections all devices";
5245                         break;
5246                 case 0x01:
5247                         str = "Allow connections with specific Class of Device";
5248                         break;
5249                 case 0x02:
5250                         str = "Allow connections with specific BD_ADDR";
5251                         break;
5252                 default:
5253                         str = "Reserved";
5254                         break;
5255                 }
5256
5257                 if (size < 2) {
5258                         print_text(COLOR_ERROR, "  invalid parameter size");
5259                         break;
5260                 }
5261
5262                 print_field("Filter: %s (0x%2.2x)", str, filter);
5263                 packet_hexdump(data + 2, size - 2);
5264                 break;
5265
5266         default:
5267                 if (size < 2) {
5268                         print_text(COLOR_ERROR, "  invalid parameter size");
5269                         break;
5270                 }
5271
5272                 filter = *((const uint8_t *) (data + 1));
5273
5274                 print_field("Filter: Reserved (0x%2.2x)", filter);
5275                 packet_hexdump(data + 2, size - 2);
5276                 break;
5277         }
5278 }
5279
5280 static void flush_cmd(uint16_t index, const void *data, uint8_t size)
5281 {
5282         const struct bt_hci_cmd_flush *cmd = data;
5283
5284         print_handle(cmd->handle);
5285 }
5286
5287 static void flush_rsp(uint16_t index, const void *data, uint8_t size)
5288 {
5289         const struct bt_hci_rsp_flush *rsp = data;
5290
5291         print_status(rsp->status);
5292         print_handle(rsp->handle);
5293 }
5294
5295 static void read_pin_type_rsp(uint16_t index, const void *data, uint8_t size)
5296 {
5297         const struct bt_hci_rsp_read_pin_type *rsp = data;
5298
5299         print_status(rsp->status);
5300         print_pin_type(rsp->pin_type);
5301 }
5302
5303 static void write_pin_type_cmd(uint16_t index, const void *data, uint8_t size)
5304 {
5305         const struct bt_hci_cmd_write_pin_type *cmd = data;
5306
5307         print_pin_type(cmd->pin_type);
5308 }
5309
5310 static void read_stored_link_key_cmd(uint16_t index, const void *data,
5311                                                         uint8_t size)
5312 {
5313         const struct bt_hci_cmd_read_stored_link_key *cmd = data;
5314
5315         print_bdaddr(cmd->bdaddr);
5316         print_field("Read all: 0x%2.2x", cmd->read_all);
5317 }
5318
5319 static void read_stored_link_key_rsp(uint16_t index, const void *data,
5320                                                         uint8_t size)
5321 {
5322         const struct bt_hci_rsp_read_stored_link_key *rsp = data;
5323
5324         print_status(rsp->status);
5325         print_field("Max num keys: %d", le16_to_cpu(rsp->max_num_keys));
5326         print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
5327 }
5328
5329 static void write_stored_link_key_cmd(uint16_t index, const void *data,
5330                                                         uint8_t size)
5331 {
5332         const struct bt_hci_cmd_write_stored_link_key *cmd = data;
5333
5334         print_field("Num keys: %d", cmd->num_keys);
5335
5336         packet_hexdump(data + 1, size - 1);
5337 }
5338
5339 static void write_stored_link_key_rsp(uint16_t index, const void *data,
5340                                                         uint8_t size)
5341 {
5342         const struct bt_hci_rsp_write_stored_link_key *rsp = data;
5343
5344         print_status(rsp->status);
5345         print_field("Num keys: %d", rsp->num_keys);
5346 }
5347
5348 static void delete_stored_link_key_cmd(uint16_t index, const void *data,
5349                                                         uint8_t size)
5350 {
5351         const struct bt_hci_cmd_delete_stored_link_key *cmd = data;
5352
5353         print_bdaddr(cmd->bdaddr);
5354         print_field("Delete all: 0x%2.2x", cmd->delete_all);
5355 }
5356
5357 static void delete_stored_link_key_rsp(uint16_t index, const void *data,
5358                                                         uint8_t size)
5359 {
5360         const struct bt_hci_rsp_delete_stored_link_key *rsp = data;
5361
5362         print_status(rsp->status);
5363         print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
5364 }
5365
5366 static void write_local_name_cmd(uint16_t index, const void *data, uint8_t size)
5367 {
5368         const struct bt_hci_cmd_write_local_name *cmd = data;
5369
5370         print_name(cmd->name);
5371 }
5372
5373 static void read_local_name_rsp(uint16_t index, const void *data, uint8_t size)
5374 {
5375         const struct bt_hci_rsp_read_local_name *rsp = data;
5376
5377         print_status(rsp->status);
5378         print_name(rsp->name);
5379 }
5380
5381 static void read_conn_accept_timeout_rsp(uint16_t index, const void *data,
5382                                                         uint8_t size)
5383 {
5384         const struct bt_hci_rsp_read_conn_accept_timeout *rsp = data;
5385
5386         print_status(rsp->status);
5387         print_timeout(rsp->timeout);
5388 }
5389
5390 static void write_conn_accept_timeout_cmd(uint16_t index, const void *data,
5391                                                         uint8_t size)
5392 {
5393         const struct bt_hci_cmd_write_conn_accept_timeout *cmd = data;
5394
5395         print_timeout(cmd->timeout);
5396 }
5397
5398 static void read_page_timeout_rsp(uint16_t index, const void *data,
5399                                                         uint8_t size)
5400 {
5401         const struct bt_hci_rsp_read_page_timeout *rsp = data;
5402
5403         print_status(rsp->status);
5404         print_timeout(rsp->timeout);
5405 }
5406
5407 static void write_page_timeout_cmd(uint16_t index, const void *data,
5408                                                         uint8_t size)
5409 {
5410         const struct bt_hci_cmd_write_page_timeout *cmd = data;
5411
5412         print_timeout(cmd->timeout);
5413 }
5414
5415 static void read_scan_enable_rsp(uint16_t index, const void *data, uint8_t size)
5416 {
5417         const struct bt_hci_rsp_read_scan_enable *rsp = data;
5418
5419         print_status(rsp->status);
5420         print_scan_enable(rsp->enable);
5421 }
5422
5423 static void write_scan_enable_cmd(uint16_t index, const void *data,
5424                                                         uint8_t size)
5425 {
5426         const struct bt_hci_cmd_write_scan_enable *cmd = data;
5427
5428         print_scan_enable(cmd->enable);
5429 }
5430
5431 static void read_page_scan_activity_rsp(uint16_t index, const void *data,
5432                                                         uint8_t size)
5433 {
5434         const struct bt_hci_rsp_read_page_scan_activity *rsp = data;
5435
5436         print_status(rsp->status);
5437         print_interval(rsp->interval);
5438         print_window(rsp->window);
5439 }
5440
5441 static void write_page_scan_activity_cmd(uint16_t index, const void *data,
5442                                                         uint8_t size)
5443 {
5444         const struct bt_hci_cmd_write_page_scan_activity *cmd = data;
5445
5446         print_interval(cmd->interval);
5447         print_window(cmd->window);
5448 }
5449
5450 static void read_inquiry_scan_activity_rsp(uint16_t index, const void *data,
5451                                                         uint8_t size)
5452 {
5453         const struct bt_hci_rsp_read_inquiry_scan_activity *rsp = data;
5454
5455         print_status(rsp->status);
5456         print_interval(rsp->interval);
5457         print_window(rsp->window);
5458 }
5459
5460 static void write_inquiry_scan_activity_cmd(uint16_t index, const void *data,
5461                                                         uint8_t size)
5462 {
5463         const struct bt_hci_cmd_write_inquiry_scan_activity *cmd = data;
5464
5465         print_interval(cmd->interval);
5466         print_window(cmd->window);
5467 }
5468
5469 static void read_auth_enable_rsp(uint16_t index, const void *data, uint8_t size)
5470 {
5471         const struct bt_hci_rsp_read_auth_enable *rsp = data;
5472
5473         print_status(rsp->status);
5474         print_auth_enable(rsp->enable);
5475 }
5476
5477 static void write_auth_enable_cmd(uint16_t index, const void *data,
5478                                                         uint8_t size)
5479 {
5480         const struct bt_hci_cmd_write_auth_enable *cmd = data;
5481
5482         print_auth_enable(cmd->enable);
5483 }
5484
5485 static void read_encrypt_mode_rsp(uint16_t index, const void *data,
5486                                                         uint8_t size)
5487 {
5488         const struct bt_hci_rsp_read_encrypt_mode *rsp = data;
5489
5490         print_status(rsp->status);
5491         print_encrypt_mode(rsp->mode);
5492 }
5493
5494 static void write_encrypt_mode_cmd(uint16_t index, const void *data,
5495                                                         uint8_t size)
5496 {
5497         const struct bt_hci_cmd_write_encrypt_mode *cmd = data;
5498
5499         print_encrypt_mode(cmd->mode);
5500 }
5501
5502 static void read_class_of_dev_rsp(uint16_t index, const void *data,
5503                                                         uint8_t size)
5504 {
5505         const struct bt_hci_rsp_read_class_of_dev *rsp = data;
5506
5507         print_status(rsp->status);
5508         print_dev_class(rsp->dev_class);
5509 }
5510
5511 static void write_class_of_dev_cmd(uint16_t index, const void *data,
5512                                                         uint8_t size)
5513 {
5514         const struct bt_hci_cmd_write_class_of_dev *cmd = data;
5515
5516         print_dev_class(cmd->dev_class);
5517 }
5518
5519 static void read_voice_setting_rsp(uint16_t index, const void *data,
5520                                                         uint8_t size)
5521 {
5522         const struct bt_hci_rsp_read_voice_setting *rsp = data;
5523
5524         print_status(rsp->status);
5525         print_voice_setting(rsp->setting);
5526 }
5527
5528 static void write_voice_setting_cmd(uint16_t index, const void *data,
5529                                                         uint8_t size)
5530 {
5531         const struct bt_hci_cmd_write_voice_setting *cmd = data;
5532
5533         print_voice_setting(cmd->setting);
5534 }
5535
5536 static void read_auto_flush_timeout_cmd(uint16_t index, const void *data,
5537                                                         uint8_t size)
5538 {
5539         const struct bt_hci_cmd_read_auto_flush_timeout *cmd = data;
5540
5541         print_handle(cmd->handle);
5542 }
5543
5544 static void read_auto_flush_timeout_rsp(uint16_t index, const void *data,
5545                                                         uint8_t size)
5546 {
5547         const struct bt_hci_rsp_read_auto_flush_timeout *rsp = data;
5548
5549         print_status(rsp->status);
5550         print_handle(rsp->handle);
5551         print_flush_timeout(rsp->timeout);
5552 }
5553
5554 static void write_auto_flush_timeout_cmd(uint16_t index, const void *data,
5555                                                         uint8_t size)
5556 {
5557         const struct bt_hci_cmd_write_auto_flush_timeout *cmd = data;
5558
5559         print_handle(cmd->handle);
5560         print_flush_timeout(cmd->timeout);
5561 }
5562
5563 static void write_auto_flush_timeout_rsp(uint16_t index, const void *data,
5564                                                         uint8_t size)
5565 {
5566         const struct bt_hci_rsp_write_auto_flush_timeout *rsp = data;
5567
5568         print_status(rsp->status);
5569         print_handle(rsp->handle);
5570 }
5571
5572 static void read_num_broadcast_retrans_rsp(uint16_t index, const void *data,
5573                                                         uint8_t size)
5574 {
5575         const struct bt_hci_rsp_read_num_broadcast_retrans *rsp = data;
5576
5577         print_status(rsp->status);
5578         print_num_broadcast_retrans(rsp->num_retrans);
5579 }
5580
5581 static void write_num_broadcast_retrans_cmd(uint16_t index, const void *data,
5582                                                         uint8_t size)
5583 {
5584         const struct bt_hci_cmd_write_num_broadcast_retrans *cmd = data;
5585
5586         print_num_broadcast_retrans(cmd->num_retrans);
5587 }
5588
5589 static void read_hold_mode_activity_rsp(uint16_t index, const void *data,
5590                                                         uint8_t size)
5591 {
5592         const struct bt_hci_rsp_read_hold_mode_activity *rsp = data;
5593
5594         print_status(rsp->status);
5595         print_hold_mode_activity(rsp->activity);
5596 }
5597
5598 static void write_hold_mode_activity_cmd(uint16_t index, const void *data,
5599                                                         uint8_t size)
5600 {
5601         const struct bt_hci_cmd_write_hold_mode_activity *cmd = data;
5602
5603         print_hold_mode_activity(cmd->activity);
5604 }
5605
5606 static void read_tx_power_cmd(uint16_t index, const void *data, uint8_t size)
5607 {
5608         const struct bt_hci_cmd_read_tx_power *cmd = data;
5609
5610         print_handle(cmd->handle);
5611         print_power_type(cmd->type);
5612 }
5613
5614 static void read_tx_power_rsp(uint16_t index, const void *data, uint8_t size)
5615 {
5616         const struct bt_hci_rsp_read_tx_power *rsp = data;
5617
5618         print_status(rsp->status);
5619         print_handle(rsp->handle);
5620         print_power_level(rsp->level, NULL);
5621 }
5622
5623 static void read_sync_flow_control_rsp(uint16_t index, const void *data,
5624                                                         uint8_t size)
5625 {
5626         const struct bt_hci_rsp_read_sync_flow_control *rsp = data;
5627
5628         print_status(rsp->status);
5629         print_enable("Flow control", rsp->enable);
5630 }
5631
5632 static void write_sync_flow_control_cmd(uint16_t index, const void *data,
5633                                                         uint8_t size)
5634 {
5635         const struct bt_hci_cmd_write_sync_flow_control *cmd = data;
5636
5637         print_enable("Flow control", cmd->enable);
5638 }
5639
5640 static void set_host_flow_control_cmd(uint16_t index, const void *data,
5641                                                         uint8_t size)
5642 {
5643         const struct bt_hci_cmd_set_host_flow_control *cmd = data;
5644
5645         print_host_flow_control(cmd->enable);
5646 }
5647
5648 static void host_buffer_size_cmd(uint16_t index, const void *data, uint8_t size)
5649 {
5650         const struct bt_hci_cmd_host_buffer_size *cmd = data;
5651
5652         print_field("ACL MTU: %-4d ACL max packet: %d",
5653                                         le16_to_cpu(cmd->acl_mtu),
5654                                         le16_to_cpu(cmd->acl_max_pkt));
5655         print_field("SCO MTU: %-4d SCO max packet: %d",
5656                                         cmd->sco_mtu,
5657                                         le16_to_cpu(cmd->sco_max_pkt));
5658 }
5659
5660 static void host_num_completed_packets_cmd(uint16_t index, const void *data,
5661                                                         uint8_t size)
5662 {
5663         const struct bt_hci_cmd_host_num_completed_packets *cmd = data;
5664
5665         print_field("Num handles: %d", cmd->num_handles);
5666         print_handle(cmd->handle);
5667         print_field("Count: %d", le16_to_cpu(cmd->count));
5668
5669         if (size > sizeof(*cmd))
5670                 packet_hexdump(data + sizeof(*cmd), size - sizeof(*cmd));
5671 }
5672
5673 static void read_link_supv_timeout_cmd(uint16_t index, const void *data,
5674                                                         uint8_t size)
5675 {
5676         const struct bt_hci_cmd_read_link_supv_timeout *cmd = data;
5677
5678         print_handle(cmd->handle);
5679 }
5680
5681 static void read_link_supv_timeout_rsp(uint16_t index, const void *data,
5682                                                         uint8_t size)
5683 {
5684         const struct bt_hci_rsp_read_link_supv_timeout *rsp = data;
5685
5686         print_status(rsp->status);
5687         print_handle(rsp->handle);
5688         print_timeout(rsp->timeout);
5689 }
5690
5691 static void write_link_supv_timeout_cmd(uint16_t index, const void *data,
5692                                                         uint8_t size)
5693 {
5694         const struct bt_hci_cmd_write_link_supv_timeout *cmd = data;
5695
5696         print_handle(cmd->handle);
5697         print_timeout(cmd->timeout);
5698 }
5699
5700 static void write_link_supv_timeout_rsp(uint16_t index, const void *data,
5701                                                         uint8_t size)
5702 {
5703         const struct bt_hci_rsp_write_link_supv_timeout *rsp = data;
5704
5705         print_status(rsp->status);
5706         print_handle(rsp->handle);
5707 }
5708
5709 static void read_num_supported_iac_rsp(uint16_t index, const void *data,
5710                                                         uint8_t size)
5711 {
5712         const struct bt_hci_rsp_read_num_supported_iac *rsp = data;
5713
5714         print_status(rsp->status);
5715         print_field("Number of IAC: %d", rsp->num_iac);
5716 }
5717
5718 static void read_current_iac_lap_rsp(uint16_t index, const void *data,
5719                                                         uint8_t size)
5720 {
5721         const struct bt_hci_rsp_read_current_iac_lap *rsp = data;
5722         uint8_t i;
5723
5724         print_status(rsp->status);
5725         print_field("Number of IAC: %d", rsp->num_iac);
5726
5727         for (i = 0; i < rsp->num_iac; i++)
5728                 print_iac(rsp->iac_lap + (i * 3));
5729 }
5730
5731 static void write_current_iac_lap_cmd(uint16_t index, const void *data,
5732                                                         uint8_t size)
5733 {
5734         const struct bt_hci_cmd_write_current_iac_lap *cmd = data;
5735         uint8_t i;
5736
5737         print_field("Number of IAC: %d", cmd->num_iac);
5738
5739         for (i = 0; i < cmd->num_iac; i++)
5740                 print_iac(cmd->iac_lap + (i * 3));
5741 }
5742
5743 static void read_page_scan_period_mode_rsp(uint16_t index, const void *data,
5744                                                         uint8_t size)
5745 {
5746         const struct bt_hci_rsp_read_page_scan_period_mode *rsp = data;
5747
5748         print_status(rsp->status);
5749         print_pscan_period_mode(rsp->mode);
5750 }
5751
5752 static void write_page_scan_period_mode_cmd(uint16_t index, const void *data,
5753                                                         uint8_t size)
5754 {
5755         const struct bt_hci_cmd_write_page_scan_period_mode *cmd = data;
5756
5757         print_pscan_period_mode(cmd->mode);
5758 }
5759
5760 static void read_page_scan_mode_rsp(uint16_t index, const void *data,
5761                                                         uint8_t size)
5762 {
5763         const struct bt_hci_rsp_read_page_scan_mode *rsp = data;
5764
5765         print_status(rsp->status);
5766         print_pscan_mode(rsp->mode);
5767 }
5768
5769 static void write_page_scan_mode_cmd(uint16_t index, const void *data,
5770                                                         uint8_t size)
5771 {
5772         const struct bt_hci_cmd_write_page_scan_mode *cmd = data;
5773
5774         print_pscan_mode(cmd->mode);
5775 }
5776
5777 static void set_afh_host_classification_cmd(uint16_t index, const void *data,
5778                                                         uint8_t size)
5779 {
5780         const struct bt_hci_cmd_set_afh_host_classification *cmd = data;
5781
5782         print_channel_map(cmd->map);
5783 }
5784
5785 static void read_inquiry_scan_type_rsp(uint16_t index, const void *data,
5786                                                         uint8_t size)
5787 {
5788         const struct bt_hci_rsp_read_inquiry_scan_type *rsp = data;
5789
5790         print_status(rsp->status);
5791         print_inquiry_scan_type(rsp->type);
5792 }
5793
5794 static void write_inquiry_scan_type_cmd(uint16_t index, const void *data,
5795                                                         uint8_t size)
5796 {
5797         const struct bt_hci_cmd_write_inquiry_scan_type *cmd = data;
5798
5799         print_inquiry_scan_type(cmd->type);
5800 }
5801
5802 static void read_inquiry_mode_rsp(uint16_t index, const void *data,
5803                                                         uint8_t size)
5804 {
5805         const struct bt_hci_rsp_read_inquiry_mode *rsp = data;
5806
5807         print_status(rsp->status);
5808         print_inquiry_mode(rsp->mode);
5809 }
5810
5811 static void write_inquiry_mode_cmd(uint16_t index, const void *data,
5812                                                         uint8_t size)
5813 {
5814         const struct bt_hci_cmd_write_inquiry_mode *cmd = data;
5815
5816         print_inquiry_mode(cmd->mode);
5817 }
5818
5819 static void read_page_scan_type_rsp(uint16_t index, const void *data,
5820                                                         uint8_t size)
5821 {
5822         const struct bt_hci_rsp_read_page_scan_type *rsp = data;
5823
5824         print_status(rsp->status);
5825         print_pscan_type(rsp->type);
5826 }
5827
5828 static void write_page_scan_type_cmd(uint16_t index, const void *data,
5829                                                         uint8_t size)
5830 {
5831         const struct bt_hci_cmd_write_page_scan_type *cmd = data;
5832
5833         print_pscan_type(cmd->type);
5834 }
5835
5836 static void read_afh_assessment_mode_rsp(uint16_t index, const void *data,
5837                                                         uint8_t size)
5838 {
5839         const struct bt_hci_rsp_read_afh_assessment_mode *rsp = data;
5840
5841         print_status(rsp->status);
5842         print_enable("Mode", rsp->mode);
5843 }
5844
5845 static void write_afh_assessment_mode_cmd(uint16_t index, const void *data,
5846                                                         uint8_t size)
5847 {
5848         const struct bt_hci_cmd_write_afh_assessment_mode *cmd = data;
5849
5850         print_enable("Mode", cmd->mode);
5851 }
5852
5853 static void read_ext_inquiry_response_rsp(uint16_t index, const void *data,
5854                                                         uint8_t size)
5855 {
5856         const struct bt_hci_rsp_read_ext_inquiry_response *rsp = data;
5857
5858         print_status(rsp->status);
5859         print_fec(rsp->fec);
5860         print_eir(rsp->data, sizeof(rsp->data), false);
5861 }
5862
5863 static void write_ext_inquiry_response_cmd(uint16_t index, const void *data,
5864                                                         uint8_t size)
5865 {
5866         const struct bt_hci_cmd_write_ext_inquiry_response *cmd = data;
5867
5868         print_fec(cmd->fec);
5869         print_eir(cmd->data, sizeof(cmd->data), false);
5870 }
5871
5872 static void refresh_encrypt_key_cmd(uint16_t index, const void *data,
5873                                                         uint8_t size)
5874 {
5875         const struct bt_hci_cmd_refresh_encrypt_key *cmd = data;
5876
5877         print_handle(cmd->handle);
5878 }
5879
5880 static void read_simple_pairing_mode_rsp(uint16_t index, const void *data,
5881                                                         uint8_t size)
5882 {
5883         const struct bt_hci_rsp_read_simple_pairing_mode *rsp = data;
5884
5885         print_status(rsp->status);
5886         print_enable("Mode", rsp->mode);
5887 }
5888
5889 static void write_simple_pairing_mode_cmd(uint16_t index, const void *data,
5890                                                         uint8_t size)
5891 {
5892         const struct bt_hci_cmd_write_simple_pairing_mode *cmd = data;
5893
5894         print_enable("Mode", cmd->mode);
5895 }
5896
5897 static void read_local_oob_data_rsp(uint16_t index, const void *data,
5898                                                         uint8_t size)
5899 {
5900         const struct bt_hci_rsp_read_local_oob_data *rsp = data;
5901
5902         print_status(rsp->status);
5903         print_hash_p192(rsp->hash);
5904         print_randomizer_p192(rsp->randomizer);
5905 }
5906
5907 static void read_inquiry_resp_tx_power_rsp(uint16_t index, const void *data,
5908                                                         uint8_t size)
5909 {
5910         const struct bt_hci_rsp_read_inquiry_resp_tx_power *rsp = data;
5911
5912         print_status(rsp->status);
5913         print_power_level(rsp->level, NULL);
5914 }
5915
5916 static void write_inquiry_tx_power_cmd(uint16_t index, const void *data,
5917                                                         uint8_t size)
5918 {
5919         const struct bt_hci_cmd_write_inquiry_tx_power *cmd = data;
5920
5921         print_power_level(cmd->level, NULL);
5922 }
5923
5924 static void read_erroneous_reporting_rsp(uint16_t index, const void *data,
5925                                                         uint8_t size)
5926 {
5927         const struct bt_hci_rsp_read_erroneous_reporting *rsp = data;
5928
5929         print_status(rsp->status);
5930         print_enable("Mode", rsp->mode);
5931 }
5932
5933 static void write_erroneous_reporting_cmd(uint16_t index, const void *data,
5934                                                         uint8_t size)
5935 {
5936         const struct bt_hci_cmd_write_erroneous_reporting *cmd = data;
5937
5938         print_enable("Mode", cmd->mode);
5939 }
5940
5941 static void enhanced_flush_cmd(uint16_t index, const void *data, uint8_t size)
5942 {
5943         const struct bt_hci_cmd_enhanced_flush *cmd = data;
5944         const char *str;
5945
5946         print_handle(cmd->handle);
5947
5948         switch (cmd->type) {
5949         case 0x00:
5950                 str = "Automatic flushable only";
5951                 break;
5952         default:
5953                 str = "Reserved";
5954                 break;
5955         }
5956
5957         print_field("Type: %s (0x%2.2x)", str, cmd->type);
5958 }
5959
5960 static void send_keypress_notify_cmd(uint16_t index, const void *data,
5961                                                         uint8_t size)
5962 {
5963         const struct bt_hci_cmd_send_keypress_notify *cmd = data;
5964         const char *str;
5965
5966         print_bdaddr(cmd->bdaddr);
5967
5968         switch (cmd->type) {
5969         case 0x00:
5970                 str = "Passkey entry started";
5971                 break;
5972         case 0x01:
5973                 str = "Passkey digit entered";
5974                 break;
5975         case 0x02:
5976                 str = "Passkey digit erased";
5977                 break;
5978         case 0x03:
5979                 str = "Passkey cleared";
5980                 break;
5981         case 0x04:
5982                 str = "Passkey entry completed";
5983                 break;
5984         default:
5985                 str = "Reserved";
5986                 break;
5987         }
5988
5989         print_field("Type: %s (0x%2.2x)", str, cmd->type);
5990 }
5991
5992 static void send_keypress_notify_rsp(uint16_t index, const void *data,
5993                                                         uint8_t size)
5994 {
5995         const struct bt_hci_rsp_send_keypress_notify *rsp = data;
5996
5997         print_status(rsp->status);
5998         print_bdaddr(rsp->bdaddr);
5999 }
6000
6001 static void set_event_mask_page2_cmd(uint16_t index, const void *data,
6002                                                         uint8_t size)
6003 {
6004         const struct bt_hci_cmd_set_event_mask_page2 *cmd = data;
6005
6006         print_event_mask(cmd->mask, events_page2_table);
6007 }
6008
6009 static void read_location_data_rsp(uint16_t index, const void *data,
6010                                                         uint8_t size)
6011 {
6012         const struct bt_hci_rsp_read_location_data *rsp = data;
6013
6014         print_status(rsp->status);
6015         print_location_domain_aware(rsp->domain_aware);
6016         print_location_domain(rsp->domain);
6017         print_location_domain_options(rsp->domain_options);
6018         print_location_options(rsp->options);
6019 }
6020
6021 static void write_location_data_cmd(uint16_t index, const void *data,
6022                                                         uint8_t size)
6023 {
6024         const struct bt_hci_cmd_write_location_data *cmd = data;
6025
6026         print_location_domain_aware(cmd->domain_aware);
6027         print_location_domain(cmd->domain);
6028         print_location_domain_options(cmd->domain_options);
6029         print_location_options(cmd->options);
6030 }
6031
6032 static void read_flow_control_mode_rsp(uint16_t index, const void *data,
6033                                                         uint8_t size)
6034 {
6035         const struct bt_hci_rsp_read_flow_control_mode *rsp = data;
6036
6037         print_status(rsp->status);
6038         print_flow_control_mode(rsp->mode);
6039 }
6040
6041 static void write_flow_control_mode_cmd(uint16_t index, const void *data,
6042                                                         uint8_t size)
6043 {
6044         const struct bt_hci_cmd_write_flow_control_mode *cmd = data;
6045
6046         print_flow_control_mode(cmd->mode);
6047 }
6048
6049 static void read_enhanced_tx_power_cmd(uint16_t index, const void *data,
6050                                                         uint8_t size)
6051 {
6052         const struct bt_hci_cmd_read_enhanced_tx_power *cmd = data;
6053
6054         print_handle(cmd->handle);
6055         print_power_type(cmd->type);
6056 }
6057
6058 static void read_enhanced_tx_power_rsp(uint16_t index, const void *data,
6059                                                         uint8_t size)
6060 {
6061         const struct bt_hci_rsp_read_enhanced_tx_power *rsp = data;
6062
6063         print_status(rsp->status);
6064         print_handle(rsp->handle);
6065         print_power_level(rsp->level_gfsk, "GFSK");
6066         print_power_level(rsp->level_dqpsk, "DQPSK");
6067         print_power_level(rsp->level_8dpsk, "8DPSK");
6068 }
6069
6070 static void short_range_mode_cmd(uint16_t index, const void *data, uint8_t size)
6071 {
6072         const struct bt_hci_cmd_short_range_mode *cmd = data;
6073
6074         print_phy_handle(cmd->phy_handle);
6075         print_enable("Short range mode", cmd->mode);
6076 }
6077
6078 static void read_le_host_supported_rsp(uint16_t index, const void *data,
6079                                                         uint8_t size)
6080 {
6081         const struct bt_hci_rsp_read_le_host_supported *rsp = data;
6082
6083         print_status(rsp->status);
6084         print_field("Supported: 0x%2.2x", rsp->supported);
6085         print_field("Simultaneous: 0x%2.2x", rsp->simultaneous);
6086 }
6087
6088 static void write_le_host_supported_cmd(uint16_t index, const void *data,
6089                                                         uint8_t size)
6090 {
6091         const struct bt_hci_cmd_write_le_host_supported *cmd = data;
6092
6093         print_field("Supported: 0x%2.2x", cmd->supported);
6094         print_field("Simultaneous: 0x%2.2x", cmd->simultaneous);
6095 }
6096
6097 static void set_reserved_lt_addr_cmd(uint16_t index, const void *data,
6098                                                         uint8_t size)
6099 {
6100         const struct bt_hci_cmd_set_reserved_lt_addr *cmd = data;
6101
6102         print_lt_addr(cmd->lt_addr);
6103 }
6104
6105 static void set_reserved_lt_addr_rsp(uint16_t index, const void *data,
6106                                                         uint8_t size)
6107 {
6108         const struct bt_hci_rsp_set_reserved_lt_addr *rsp = data;
6109
6110         print_status(rsp->status);
6111         print_lt_addr(rsp->lt_addr);
6112 }
6113
6114 static void delete_reserved_lt_addr_cmd(uint16_t index, const void *data,
6115                                                         uint8_t size)
6116 {
6117         const struct bt_hci_cmd_delete_reserved_lt_addr *cmd = data;
6118
6119         print_lt_addr(cmd->lt_addr);
6120 }
6121
6122 static void delete_reserved_lt_addr_rsp(uint16_t index, const void *data,
6123                                                         uint8_t size)
6124 {
6125         const struct bt_hci_rsp_delete_reserved_lt_addr *rsp = data;
6126
6127         print_status(rsp->status);
6128         print_lt_addr(rsp->lt_addr);
6129 }
6130
6131 static void set_peripheral_broadcast_data_cmd(uint16_t index, const void *data,
6132                                                         uint8_t size)
6133 {
6134         const struct bt_hci_cmd_set_peripheral_broadcast_data *cmd = data;
6135
6136         print_lt_addr(cmd->lt_addr);
6137         print_broadcast_fragment(cmd->fragment);
6138         print_field("Length: %d", cmd->length);
6139
6140         if (size - 3 != cmd->length)
6141                 print_text(COLOR_ERROR, "invalid data size (%d != %d)",
6142                                                 size - 3, cmd->length);
6143
6144         packet_hexdump(data + 3, size - 3);
6145 }
6146
6147 static void set_peripheral_broadcast_data_rsp(uint16_t index, const void *data,
6148                                                         uint8_t size)
6149 {
6150         const struct bt_hci_rsp_set_peripheral_broadcast_data *rsp = data;
6151
6152         print_status(rsp->status);
6153         print_lt_addr(rsp->lt_addr);
6154 }
6155
6156 static void read_sync_train_params_rsp(uint16_t index, const void *data,
6157                                                         uint8_t size)
6158 {
6159         const struct bt_hci_rsp_read_sync_train_params *rsp = data;
6160
6161         print_status(rsp->status);
6162         print_interval(rsp->interval);
6163         print_field("Timeout: %.3f msec (0x%8.8x)",
6164                                         le32_to_cpu(rsp->timeout) * 0.625,
6165                                         le32_to_cpu(rsp->timeout));
6166         print_field("Service data: 0x%2.2x", rsp->service_data);
6167 }
6168
6169 static void write_sync_train_params_cmd(uint16_t index, const void *data,
6170                                                         uint8_t size)
6171 {
6172         const struct bt_hci_cmd_write_sync_train_params *cmd = data;
6173
6174         print_slot_625("Min interval", cmd->min_interval);
6175         print_slot_625("Max interval", cmd->max_interval);
6176         print_field("Timeout: %.3f msec (0x%8.8x)",
6177                                         le32_to_cpu(cmd->timeout) * 0.625,
6178                                         le32_to_cpu(cmd->timeout));
6179         print_field("Service data: 0x%2.2x", cmd->service_data);
6180 }
6181
6182 static void write_sync_train_params_rsp(uint16_t index, const void *data,
6183                                                         uint8_t size)
6184 {
6185         const struct bt_hci_rsp_write_sync_train_params *rsp = data;
6186
6187         print_status(rsp->status);
6188         print_interval(rsp->interval);
6189 }
6190
6191 static void read_secure_conn_support_rsp(uint16_t index, const void *data,
6192                                                         uint8_t size)
6193 {
6194         const struct bt_hci_rsp_read_secure_conn_support *rsp = data;
6195
6196         print_status(rsp->status);
6197         print_enable("Support", rsp->support);
6198 }
6199
6200 static void write_secure_conn_support_cmd(uint16_t index, const void *data,
6201                                                         uint8_t size)
6202 {
6203         const struct bt_hci_cmd_write_secure_conn_support *cmd = data;
6204
6205         print_enable("Support", cmd->support);
6206 }
6207
6208 static void read_auth_payload_timeout_cmd(uint16_t index, const void *data,
6209                                                         uint8_t size)
6210 {
6211         const struct bt_hci_cmd_read_auth_payload_timeout *cmd = data;
6212
6213         print_handle(cmd->handle);
6214 }
6215
6216 static void read_auth_payload_timeout_rsp(uint16_t index, const void *data,
6217                                                         uint8_t size)
6218 {
6219         const struct bt_hci_rsp_read_auth_payload_timeout *rsp = data;
6220
6221         print_status(rsp->status);
6222         print_handle(rsp->handle);
6223         print_auth_payload_timeout(rsp->timeout);
6224 }
6225
6226 static void write_auth_payload_timeout_cmd(uint16_t index, const void *data,
6227                                                         uint8_t size)
6228 {
6229         const struct bt_hci_cmd_write_auth_payload_timeout *cmd = data;
6230
6231         print_handle(cmd->handle);
6232         print_auth_payload_timeout(cmd->timeout);
6233 }
6234
6235 static void write_auth_payload_timeout_rsp(uint16_t index, const void *data,
6236                                                         uint8_t size)
6237 {
6238         const struct bt_hci_rsp_write_auth_payload_timeout *rsp = data;
6239
6240         print_status(rsp->status);
6241         print_handle(rsp->handle);
6242 }
6243
6244 static void read_local_oob_ext_data_rsp(uint16_t index, const void *data,
6245                                                         uint8_t size)
6246 {
6247         const struct bt_hci_rsp_read_local_oob_ext_data *rsp = data;
6248
6249         print_status(rsp->status);
6250         print_hash_p192(rsp->hash192);
6251         print_randomizer_p192(rsp->randomizer192);
6252         print_hash_p256(rsp->hash256);
6253         print_randomizer_p256(rsp->randomizer256);
6254 }
6255
6256 static void read_ext_page_timeout_rsp(uint16_t index, const void *data,
6257                                                         uint8_t size)
6258 {
6259         const struct bt_hci_rsp_read_ext_page_timeout *rsp = data;
6260
6261         print_status(rsp->status);
6262         print_timeout(rsp->timeout);
6263 }
6264
6265 static void write_ext_page_timeout_cmd(uint16_t index, const void *data,
6266                                                         uint8_t size)
6267 {
6268         const struct bt_hci_cmd_write_ext_page_timeout *cmd = data;
6269
6270         print_timeout(cmd->timeout);
6271 }
6272
6273 static void read_ext_inquiry_length_rsp(uint16_t index, const void *data,
6274                                                         uint8_t size)
6275 {
6276         const struct bt_hci_rsp_read_ext_inquiry_length *rsp = data;
6277
6278         print_status(rsp->status);
6279         print_interval(rsp->interval);
6280 }
6281
6282 static void write_ext_inquiry_length_cmd(uint16_t index, const void *data,
6283                                                         uint8_t size)
6284 {
6285         const struct bt_hci_cmd_write_ext_inquiry_length *cmd = data;
6286
6287         print_interval(cmd->interval);
6288 }
6289
6290 static void read_local_version_rsp(uint16_t index, const void *data,
6291                                                         uint8_t size)
6292 {
6293         const struct bt_hci_rsp_read_local_version *rsp = data;
6294         uint16_t manufacturer;
6295
6296         print_status(rsp->status);
6297         print_hci_version(rsp->hci_ver, rsp->hci_rev);
6298
6299         manufacturer = le16_to_cpu(rsp->manufacturer);
6300
6301         if (index_current < MAX_INDEX) {
6302                 switch (index_list[index_current].type) {
6303                 case HCI_PRIMARY:
6304                         print_lmp_version(rsp->lmp_ver, rsp->lmp_subver);
6305                         break;
6306                 case HCI_AMP:
6307                         print_pal_version(rsp->lmp_ver, rsp->lmp_subver);
6308                         break;
6309                 }
6310
6311                 index_list[index_current].manufacturer = manufacturer;
6312         }
6313
6314         print_manufacturer(rsp->manufacturer);
6315
6316         switch (manufacturer) {
6317         case 15:
6318                 print_manufacturer_broadcom(rsp->lmp_subver, rsp->hci_rev);
6319                 break;
6320         }
6321 }
6322
6323 static void read_local_commands_rsp(uint16_t index, const void *data,
6324                                                         uint8_t size)
6325 {
6326         const struct bt_hci_rsp_read_local_commands *rsp = data;
6327
6328         print_status(rsp->status);
6329         print_commands(rsp->commands);
6330 }
6331
6332 static void read_local_features_rsp(uint16_t index, const void *data,
6333                                                         uint8_t size)
6334 {
6335         const struct bt_hci_rsp_read_local_features *rsp = data;
6336
6337         print_status(rsp->status);
6338         print_features(0, rsp->features, 0x00);
6339 }
6340
6341 static void read_local_ext_features_cmd(uint16_t index, const void *data,
6342                                                         uint8_t size)
6343 {
6344         const struct bt_hci_cmd_read_local_ext_features *cmd = data;
6345
6346         print_field("Page: %d", cmd->page);
6347 }
6348
6349 static void read_local_ext_features_rsp(uint16_t index, const void *data,
6350                                                         uint8_t size)
6351 {
6352         const struct bt_hci_rsp_read_local_ext_features *rsp = data;
6353
6354         print_status(rsp->status);
6355         print_field("Page: %d/%d", rsp->page, rsp->max_page);
6356         print_features(rsp->page, rsp->features, 0x00);
6357 }
6358
6359 static void read_buffer_size_rsp(uint16_t index, const void *data, uint8_t size)
6360 {
6361         const struct bt_hci_rsp_read_buffer_size *rsp = data;
6362
6363         print_status(rsp->status);
6364         print_field("ACL MTU: %-4d ACL max packet: %d",
6365                                         le16_to_cpu(rsp->acl_mtu),
6366                                         le16_to_cpu(rsp->acl_max_pkt));
6367         print_field("SCO MTU: %-4d SCO max packet: %d",
6368                                         rsp->sco_mtu,
6369                                         le16_to_cpu(rsp->sco_max_pkt));
6370 }
6371
6372 static void read_country_code_rsp(uint16_t index, const void *data,
6373                                                         uint8_t size)
6374 {
6375         const struct bt_hci_rsp_read_country_code *rsp = data;
6376         const char *str;
6377
6378         print_status(rsp->status);
6379
6380         switch (rsp->code) {
6381         case 0x00:
6382                 str = "North America, Europe*, Japan";
6383                 break;
6384         case 0x01:
6385                 str = "France";
6386                 break;
6387         default:
6388                 str = "Reserved";
6389                 break;
6390         }
6391
6392         print_field("Country code: %s (0x%2.2x)", str, rsp->code);
6393 }
6394
6395 static void read_bd_addr_rsp(uint16_t index, const void *data, uint8_t size)
6396 {
6397         const struct bt_hci_rsp_read_bd_addr *rsp = data;
6398
6399         print_status(rsp->status);
6400         print_bdaddr(rsp->bdaddr);
6401
6402         if (index_current < MAX_INDEX)
6403                 memcpy(index_list[index_current].bdaddr, rsp->bdaddr, 6);
6404 }
6405
6406 static void read_data_block_size_rsp(uint16_t index, const void *data,
6407                                                         uint8_t size)
6408 {
6409         const struct bt_hci_rsp_read_data_block_size *rsp = data;
6410
6411         print_status(rsp->status);
6412         print_field("Max ACL length: %d", le16_to_cpu(rsp->max_acl_len));
6413         print_field("Block length: %d", le16_to_cpu(rsp->block_len));
6414         print_field("Num blocks: %d", le16_to_cpu(rsp->num_blocks));
6415 }
6416
6417 static void read_local_codecs_rsp(uint16_t index, const void *data,
6418                                                         uint8_t size)
6419 {
6420         const struct bt_hci_rsp_read_local_codecs *rsp = data;
6421         uint8_t i, num_vnd_codecs;
6422
6423         if (rsp->num_codecs + 3 > size) {
6424                 print_field("Invalid number of codecs.");
6425                 return;
6426         }
6427
6428         print_status(rsp->status);
6429         print_field("Number of supported codecs: %d", rsp->num_codecs);
6430
6431         for (i = 0; i < rsp->num_codecs; i++)
6432                 print_codec_id("  Codec", rsp->codec[i]);
6433
6434         num_vnd_codecs = rsp->codec[rsp->num_codecs];
6435
6436         print_field("Number of vendor codecs: %d", num_vnd_codecs);
6437
6438         packet_hexdump(data + rsp->num_codecs + 3,
6439                                         size - rsp->num_codecs - 3);
6440 }
6441
6442 static void print_codecs(const void *data, int i)
6443 {
6444         const struct bt_hci_codec *codec = data;
6445
6446         print_codec("  Codec", codec);
6447 }
6448
6449 typedef void (*print_list_func_t)(const void *data, int i);
6450
6451 static void print_list(const void *data, uint8_t size, int num_items,
6452                                 size_t item_size, print_list_func_t func)
6453 {
6454         int i;
6455
6456         for (i = 0; size >= item_size && num_items; i++) {
6457                 if (func)
6458                         func(data, i);
6459                 data += item_size;
6460                 size -= item_size;
6461                 num_items--;
6462         }
6463
6464         if (num_items)
6465                 print_hex_field("", data, size);
6466 }
6467
6468 static void print_vnd_codecs_v2(const void *data, int i)
6469 {
6470         const struct bt_hci_vnd_codec_v2 *codec = data;
6471         uint8_t mask;
6472
6473         packet_print_company("  Company ID", le16_to_cpu(codec->cid));
6474         print_field("  Vendor Codec ID: 0x%4.4x", le16_to_cpu(codec->vid));
6475         print_field("  Logical Transport Type: 0x%02x", codec->transport);
6476         mask = print_bitfield(4, codec->transport, codec_transport_table);
6477         if (mask)
6478                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
6479                                 "  Unknown transport (0x%2.2x)", mask);
6480 }
6481
6482 static void read_local_codecs_rsp_v2(uint16_t index, const void *data,
6483                                                         uint8_t size)
6484 {
6485         const struct bt_hci_rsp_read_local_codecs_v2 *rsp = data;
6486         uint8_t num_vnd_codecs;
6487
6488         if (rsp->num_codecs + 3 > size) {
6489                 print_field("Invalid number of codecs.");
6490                 return;
6491         }
6492
6493         print_status(rsp->status);
6494         print_field("Number of supported codecs: %d", rsp->num_codecs);
6495
6496         size -= sizeof(*rsp);
6497
6498         if (size < rsp->num_codecs * sizeof(*rsp->codec)) {
6499                 print_field("Invalid number of codecs.");
6500                 return;
6501         }
6502
6503         print_list(rsp->codec, size, rsp->num_codecs, sizeof(*rsp->codec),
6504                                                         print_codecs);
6505
6506         size -= rsp->num_codecs * sizeof(*rsp->codec);
6507
6508         if (size < sizeof(uint8_t)) {
6509                 print_field("Invalid number of vendor codecs.");
6510                 return;
6511         }
6512
6513         num_vnd_codecs = rsp->codec[rsp->num_codecs].id;
6514
6515         size -= 1;
6516
6517         print_field("Number of vendor codecs: %d", num_vnd_codecs);
6518
6519         if (size < num_vnd_codecs * sizeof(*rsp->codec)) {
6520                 print_field("Invalid number of vendor codecs.");
6521                 return;
6522         }
6523
6524         print_list(&rsp->codec[rsp->num_codecs] + 1, size, num_vnd_codecs,
6525                         sizeof(struct bt_hci_vnd_codec_v2),
6526                         print_vnd_codecs_v2);
6527 }
6528
6529 static void print_path_direction(const char *prefix, uint8_t dir)
6530 {
6531         const char *str;
6532
6533         switch (dir) {
6534         case 0x00:
6535                 str = "Input (Host to Controller)";
6536                 break;
6537         case 0x01:
6538                 str = "Output (Controller to Host)";
6539                 break;
6540         default:
6541                 str = "Reserved";
6542                 break;
6543         }
6544
6545         print_field("%s: %s (0x%2.2x)", prefix, str, dir);
6546 }
6547
6548 static void print_vnd_codec(const char *label,
6549                                 const struct bt_hci_vnd_codec *codec)
6550 {
6551         uint8_t mask;
6552
6553         print_codec_id(label, codec->id);
6554
6555         if (codec->id == 0xff) {
6556                 packet_print_company("Company Codec ID",
6557                                         le16_to_cpu(codec->cid));
6558                 print_field("Vendor Codec ID: %d", le16_to_cpu(codec->vid));
6559         }
6560
6561         print_field("Logical Transport Type: 0x%02x", codec->transport);
6562         mask = print_bitfield(2, codec->transport, codec_transport_table);
6563         if (mask)
6564                 print_text(COLOR_UNKNOWN_SERVICE_CLASS,
6565                                 "  Unknown transport (0x%2.2x)", mask);
6566 }
6567
6568 static void read_local_codec_caps_cmd(uint16_t index, const void *data,
6569                                                         uint8_t size)
6570 {
6571         const struct bt_hci_cmd_read_local_codec_caps *cmd = data;
6572
6573         print_vnd_codec("Codec", &cmd->codec);
6574         print_path_direction("Direction", cmd->dir);
6575 }
6576
6577 static void read_local_codec_caps_rsp(uint16_t index, const void *data,
6578                                                         uint8_t size)
6579 {
6580         const struct bt_hci_rsp_read_local_codec_caps *rsp = data;
6581         uint8_t i;
6582
6583         print_status(rsp->status);
6584         print_field("Number of codec capabilities: %d", rsp->num);
6585
6586         data += sizeof(*rsp);
6587         size -= sizeof(*rsp);
6588
6589         for (i = 0; i < rsp->num; i++) {
6590                 const struct bt_hci_codec_caps *caps = data;
6591
6592                 if (size < sizeof(*caps)) {
6593                         print_field("Invalid capabilities: %u < %zu",
6594                                                 size, sizeof(*caps));
6595                         return;
6596                 }
6597
6598                 print_field(" Capabilities #%u:", i);
6599                 packet_hexdump(caps->data, caps->len);
6600
6601                 data += 1 + caps->len;
6602                 size -= 1 + caps->len;
6603         }
6604 }
6605
6606 static void read_local_ctrl_delay_cmd(uint16_t index, const void *data,
6607                                                         uint8_t size)
6608 {
6609         const struct bt_hci_cmd_read_local_ctrl_delay *cmd = data;
6610
6611         print_vnd_codec("Codec", &cmd->codec);
6612         print_path_direction("Direction", cmd->dir);
6613         print_field("Length Codec Configuration: %u", cmd->codec_cfg_len);
6614 }
6615
6616 static void config_data_path_cmd(uint16_t index, const void *data, uint8_t size)
6617 {
6618         const struct bt_hci_cmd_config_data_path *cmd = data;
6619
6620         print_path_direction("Direction", cmd->dir);
6621         print_field("ID: %u", cmd->id);
6622         print_field("Vendor Specific Config Length: %u", cmd->vnd_config_len);
6623         print_hex_field("Vendor Specific Config", cmd->vnd_config,
6624                                                 cmd->vnd_config_len);
6625 }
6626
6627 static void print_usec_interval(const char *prefix, const uint8_t interval[3])
6628 {
6629         uint32_t value = get_le24(interval);
6630
6631         print_field("%s: %u us (0x%6.6x)", prefix, value, value);
6632 }
6633
6634 static void read_local_ctrl_delay_rsp(uint16_t index, const void *data,
6635                                                         uint8_t size)
6636 {
6637         const struct bt_hci_rsp_read_local_ctrl_delay *rsp = data;
6638
6639         print_status(rsp->status);
6640         print_usec_interval("Minimum Controller delay", rsp->min_delay);
6641         print_usec_interval("Maximum Controller delay", rsp->max_delay);
6642 }
6643
6644 static void read_local_pairing_options_rsp(uint16_t index, const void *data,
6645                                                         uint8_t size)
6646 {
6647         const struct bt_hci_rsp_read_local_pairing_options *rsp = data;
6648
6649         print_status(rsp->status);
6650         print_field("Pairing options: 0x%2.2x", rsp->pairing_options);
6651         print_field("Max encryption key size: %u octets", rsp->max_key_size);
6652 }
6653
6654 static void read_failed_contact_counter_cmd(uint16_t index, const void *data,
6655                                                         uint8_t size)
6656 {
6657         const struct bt_hci_cmd_read_failed_contact_counter *cmd = data;
6658
6659         print_handle(cmd->handle);
6660 }
6661
6662 static void read_failed_contact_counter_rsp(uint16_t index, const void *data,
6663                                                         uint8_t size)
6664 {
6665         const struct bt_hci_rsp_read_failed_contact_counter *rsp = data;
6666
6667         print_status(rsp->status);
6668         print_handle(rsp->handle);
6669         print_field("Counter: %u", le16_to_cpu(rsp->counter));
6670 }
6671
6672 static void reset_failed_contact_counter_cmd(uint16_t index, const void *data,
6673                                                         uint8_t size)
6674 {
6675         const struct bt_hci_cmd_reset_failed_contact_counter *cmd = data;
6676
6677         print_handle(cmd->handle);
6678 }
6679
6680 static void reset_failed_contact_counter_rsp(uint16_t index, const void *data,
6681                                                         uint8_t size)
6682 {
6683         const struct bt_hci_rsp_reset_failed_contact_counter *rsp = data;
6684
6685         print_status(rsp->status);
6686         print_handle(rsp->handle);
6687 }
6688
6689 static void read_link_quality_cmd(uint16_t index, const void *data,
6690                                                         uint8_t size)
6691 {
6692         const struct bt_hci_cmd_read_link_quality *cmd = data;
6693
6694         print_handle(cmd->handle);
6695 }
6696
6697 static void read_link_quality_rsp(uint16_t index, const void *data,
6698                                                         uint8_t size)
6699 {
6700         const struct bt_hci_rsp_read_link_quality *rsp = data;
6701
6702         print_status(rsp->status);
6703         print_handle(rsp->handle);
6704         print_field("Link quality: 0x%2.2x", rsp->link_quality);
6705 }
6706
6707 static void read_rssi_cmd(uint16_t index, const void *data, uint8_t size)
6708 {
6709         const struct bt_hci_cmd_read_rssi *cmd = data;
6710
6711         print_handle(cmd->handle);
6712 }
6713
6714 static void read_rssi_rsp(uint16_t index, const void *data, uint8_t size)
6715 {
6716         const struct bt_hci_rsp_read_rssi *rsp = data;
6717
6718         print_status(rsp->status);
6719         print_handle(rsp->handle);
6720         print_rssi(rsp->rssi);
6721 }
6722
6723 static void read_afh_channel_map_cmd(uint16_t index, const void *data,
6724                                                         uint8_t size)
6725 {
6726         const struct bt_hci_cmd_read_afh_channel_map *cmd = data;
6727
6728         print_handle(cmd->handle);
6729 }
6730
6731 static void read_afh_channel_map_rsp(uint16_t index, const void *data,
6732                                                         uint8_t size)
6733 {
6734         const struct bt_hci_rsp_read_afh_channel_map *rsp = data;
6735
6736         print_status(rsp->status);
6737         print_handle(rsp->handle);
6738         print_enable("Mode", rsp->mode);
6739         print_channel_map(rsp->map);
6740 }
6741
6742 static void read_clock_cmd(uint16_t index, const void *data, uint8_t size)
6743 {
6744         const struct bt_hci_cmd_read_clock *cmd = data;
6745
6746         print_handle(cmd->handle);
6747         print_clock_type(cmd->type);
6748 }
6749
6750 static void read_clock_rsp(uint16_t index, const void *data, uint8_t size)
6751 {
6752         const struct bt_hci_rsp_read_clock *rsp = data;
6753
6754         print_status(rsp->status);
6755         print_handle(rsp->handle);
6756         print_clock(rsp->clock);
6757         print_clock_accuracy(rsp->accuracy);
6758 }
6759
6760 static void read_encrypt_key_size_cmd(uint16_t index, const void *data,
6761                                                         uint8_t size)
6762 {
6763         const struct bt_hci_cmd_read_encrypt_key_size *cmd = data;
6764
6765         print_handle(cmd->handle);
6766 }
6767
6768 static void read_encrypt_key_size_rsp(uint16_t index, const void *data,
6769                                                         uint8_t size)
6770 {
6771         const struct bt_hci_rsp_read_encrypt_key_size *rsp = data;
6772
6773         print_status(rsp->status);
6774         print_handle(rsp->handle);
6775         print_key_size(rsp->key_size);
6776 }
6777
6778 static void read_local_amp_info_rsp(uint16_t index, const void *data,
6779                                                         uint8_t size)
6780 {
6781         const struct bt_hci_rsp_read_local_amp_info *rsp = data;
6782         const char *str;
6783
6784         print_status(rsp->status);
6785         print_amp_status(rsp->amp_status);
6786
6787         print_field("Total bandwidth: %d kbps", le32_to_cpu(rsp->total_bw));
6788         print_field("Max guaranteed bandwidth: %d kbps",
6789                                                 le32_to_cpu(rsp->max_bw));
6790         print_field("Min latency: %d", le32_to_cpu(rsp->min_latency));
6791         print_field("Max PDU size: %d", le32_to_cpu(rsp->max_pdu));
6792
6793         switch (rsp->amp_type) {
6794         case 0x00:
6795                 str = "Primary BR/EDR Controller";
6796                 break;
6797         case 0x01:
6798                 str = "802.11 AMP Controller";
6799                 break;
6800         default:
6801                 str = "Reserved";
6802                 break;
6803         }
6804
6805         print_field("Controller type: %s (0x%2.2x)", str, rsp->amp_type);
6806
6807         print_field("PAL capabilities: 0x%4.4x", le16_to_cpu(rsp->pal_cap));
6808         print_field("Max ASSOC length: %d", le16_to_cpu(rsp->max_assoc_len));
6809         print_field("Max flush timeout: %d", le32_to_cpu(rsp->max_flush_to));
6810         print_field("Best effort flush timeout: %d",
6811                                         le32_to_cpu(rsp->be_flush_to));
6812 }
6813
6814 static void read_local_amp_assoc_cmd(uint16_t index, const void *data,
6815                                                         uint8_t size)
6816 {
6817         const struct bt_hci_cmd_read_local_amp_assoc *cmd = data;
6818
6819         print_phy_handle(cmd->phy_handle);
6820         print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
6821         print_field("Max ASSOC length: %d", le16_to_cpu(cmd->max_assoc_len));
6822 }
6823
6824 static void read_local_amp_assoc_rsp(uint16_t index, const void *data,
6825                                                         uint8_t size)
6826 {
6827         const struct bt_hci_rsp_read_local_amp_assoc *rsp = data;
6828
6829         print_status(rsp->status);
6830         print_phy_handle(rsp->phy_handle);
6831         print_field("Remaining ASSOC length: %d",
6832                                         le16_to_cpu(rsp->remain_assoc_len));
6833
6834         packet_hexdump(data + 4, size - 4);
6835 }
6836
6837 static void write_remote_amp_assoc_cmd(uint16_t index, const void *data,
6838                                                         uint8_t size)
6839 {
6840         const struct bt_hci_cmd_write_remote_amp_assoc *cmd = data;
6841
6842         print_phy_handle(cmd->phy_handle);
6843         print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
6844         print_field("Remaining ASSOC length: %d",
6845                                         le16_to_cpu(cmd->remain_assoc_len));
6846
6847         packet_hexdump(data + 5, size - 5);
6848 }
6849
6850 static void write_remote_amp_assoc_rsp(uint16_t index, const void *data,
6851                                                         uint8_t size)
6852 {
6853         const struct bt_hci_rsp_write_remote_amp_assoc *rsp = data;
6854
6855         print_status(rsp->status);
6856         print_phy_handle(rsp->phy_handle);
6857 }
6858
6859 static void get_mws_transport_config_rsp(uint16_t index, const void *data,
6860                                                         uint8_t size)
6861 {
6862         const struct bt_hci_rsp_get_mws_transport_config *rsp = data;
6863         uint8_t sum_baud_rates = 0;
6864         int i;
6865
6866         print_status(rsp->status);
6867         print_field("Number of transports: %d", rsp->num_transports);
6868
6869         for (i = 0; i < rsp->num_transports; i++) {
6870                 uint8_t transport = rsp->transport[0];
6871                 uint8_t num_baud_rates = rsp->transport[1];
6872                 const char *str;
6873
6874                 switch (transport) {
6875                 case 0x00:
6876                         str = "Disbabled";
6877                         break;
6878                 case 0x01:
6879                         str = "WCI-1";
6880                         break;
6881                 case 0x02:
6882                         str = "WCI-2";
6883                         break;
6884                 default:
6885                         str = "Reserved";
6886                         break;
6887                 }
6888
6889                 print_field("  Transport layer: %s (0x%2.2x)", str, transport);
6890                 print_field("  Number of baud rates: %d", num_baud_rates);
6891
6892                 sum_baud_rates += num_baud_rates;
6893         }
6894
6895         print_field("Baud rate list: %u entr%s", sum_baud_rates,
6896                                         sum_baud_rates == 1 ? "y" : "ies");
6897
6898         for (i = 0; i < sum_baud_rates; i++) {
6899                 uint32_t to_baud_rate, from_baud_rate;
6900
6901                 to_baud_rate = get_le32(data + 2 +
6902                                         rsp->num_transports * 2 + i * 4);
6903                 from_baud_rate = get_le32(data + 2 +
6904                                                 rsp->num_transports * 2 +
6905                                                 sum_baud_rates * 4 + i * 4);
6906
6907                 print_field("  Bluetooth to MWS: %d", to_baud_rate);
6908                 print_field("  MWS to Bluetooth: %d", from_baud_rate);
6909         }
6910
6911         packet_hexdump(data + 2 + rsp->num_transports * 2 + sum_baud_rates * 8,
6912                 size - 2 - rsp->num_transports * 2 - sum_baud_rates * 8);
6913 }
6914
6915 static void set_triggered_clock_capture_cmd(uint16_t index, const void *data,
6916                                                         uint8_t size)
6917 {
6918         const struct bt_hci_cmd_set_triggered_clock_capture *cmd = data;
6919
6920         print_handle(cmd->handle);
6921         print_enable("Capture", cmd->enable);
6922         print_clock_type(cmd->type);
6923         print_lpo_allowed(cmd->lpo_allowed);
6924         print_field("Clock captures to filter: %u", cmd->num_filter);
6925 }
6926
6927 static void read_loopback_mode_rsp(uint16_t index, const void *data,
6928                                                         uint8_t size)
6929 {
6930         const struct bt_hci_rsp_read_loopback_mode *rsp = data;
6931
6932         print_status(rsp->status);
6933         print_loopback_mode(rsp->mode);
6934 }
6935
6936 static void write_loopback_mode_cmd(uint16_t index, const void *data,
6937                                                         uint8_t size)
6938 {
6939         const struct bt_hci_cmd_write_loopback_mode *cmd = data;
6940
6941         print_loopback_mode(cmd->mode);
6942 }
6943
6944 static void write_ssp_debug_mode_cmd(uint16_t index, const void *data,
6945                                                         uint8_t size)
6946 {
6947         const struct bt_hci_cmd_write_ssp_debug_mode *cmd = data;
6948
6949         print_enable("Debug Mode", cmd->mode);
6950 }
6951
6952 static void le_set_event_mask_cmd(uint16_t index, const void *data,
6953                                                         uint8_t size)
6954 {
6955         const struct bt_hci_cmd_le_set_event_mask *cmd = data;
6956
6957         print_event_mask(cmd->mask, events_le_table);
6958 }
6959
6960 static void le_read_buffer_size_rsp(uint16_t index, const void *data,
6961                                                         uint8_t size)
6962 {
6963         const struct bt_hci_rsp_le_read_buffer_size *rsp = data;
6964
6965         print_status(rsp->status);
6966         print_field("Data packet length: %d", le16_to_cpu(rsp->le_mtu));
6967         print_field("Num data packets: %d", rsp->le_max_pkt);
6968 }
6969
6970 static void le_read_local_features_rsp(uint16_t index, const void *data,
6971                                                         uint8_t size)
6972 {
6973         const struct bt_hci_rsp_le_read_local_features *rsp = data;
6974
6975         print_status(rsp->status);
6976         print_features(0, rsp->features, 0x01);
6977 }
6978
6979 static void le_set_random_address_cmd(uint16_t index, const void *data,
6980                                                         uint8_t size)
6981 {
6982         const struct bt_hci_cmd_le_set_random_address *cmd = data;
6983
6984         print_addr("Address", cmd->addr, 0x01);
6985 }
6986
6987 static void le_set_adv_parameters_cmd(uint16_t index, const void *data,
6988                                                         uint8_t size)
6989 {
6990         const struct bt_hci_cmd_le_set_adv_parameters *cmd = data;
6991         const char *str;
6992
6993         print_slot_625("Min advertising interval", cmd->min_interval);
6994         print_slot_625("Max advertising interval", cmd->max_interval);
6995
6996         switch (cmd->type) {
6997         case 0x00:
6998                 str = "Connectable undirected - ADV_IND";
6999                 break;
7000         case 0x01:
7001                 str = "Connectable directed - ADV_DIRECT_IND (high duty cycle)";
7002                 break;
7003         case 0x02:
7004                 str = "Scannable undirected - ADV_SCAN_IND";
7005                 break;
7006         case 0x03:
7007                 str = "Non connectable undirected - ADV_NONCONN_IND";
7008                 break;
7009         case 0x04:
7010                 str = "Connectable directed - ADV_DIRECT_IND (low duty cycle)";
7011                 break;
7012         default:
7013                 str = "Reserved";
7014                 break;
7015         }
7016
7017         print_field("Type: %s (0x%2.2x)", str, cmd->type);
7018
7019         print_own_addr_type(cmd->own_addr_type);
7020         print_addr_type("Direct address type", cmd->direct_addr_type);
7021         print_addr("Direct address", cmd->direct_addr, cmd->direct_addr_type);
7022         print_adv_channel_map("Channel map", cmd->channel_map);
7023         print_adv_filter_policy("Filter policy", cmd->filter_policy);
7024 }
7025
7026 static void le_read_adv_tx_power_rsp(uint16_t index, const void *data,
7027                                                         uint8_t size)
7028 {
7029         const struct bt_hci_rsp_le_read_adv_tx_power *rsp = data;
7030
7031         print_status(rsp->status);
7032         print_power_level(rsp->level, NULL);
7033 }
7034
7035 static void le_set_adv_data_cmd(uint16_t index, const void *data, uint8_t size)
7036 {
7037         const struct bt_hci_cmd_le_set_adv_data *cmd = data;
7038
7039         print_field("Length: %d", cmd->len);
7040         print_eir(cmd->data, cmd->len, true);
7041 }
7042
7043 static void le_set_scan_rsp_data_cmd(uint16_t index, const void *data,
7044                                                         uint8_t size)
7045 {
7046         const struct bt_hci_cmd_le_set_scan_rsp_data *cmd = data;
7047
7048         print_field("Length: %d", cmd->len);
7049         print_eir(cmd->data, cmd->len, true);
7050 }
7051
7052 static void le_set_adv_enable_cmd(uint16_t index, const void *data,
7053                                                         uint8_t size)
7054 {
7055         const struct bt_hci_cmd_le_set_adv_enable *cmd = data;
7056
7057         print_enable("Advertising", cmd->enable);
7058 }
7059
7060 static void print_scan_type(const char *label, uint8_t type)
7061 {
7062         const char *str;
7063
7064         switch (type) {
7065         case 0x00:
7066                 str = "Passive";
7067                 break;
7068         case 0x01:
7069                 str = "Active";
7070                 break;
7071         default:
7072                 str = "Reserved";
7073                 break;
7074         }
7075
7076         print_field("%s: %s (0x%2.2x)", label, str, type);
7077 }
7078
7079 static void print_scan_filter_policy(uint8_t policy)
7080 {
7081         const char *str;
7082
7083         switch (policy) {
7084         case 0x00:
7085                 str = "Accept all advertisement";
7086                 break;
7087         case 0x01:
7088                 str = "Ignore not in accept list";
7089                 break;
7090         case 0x02:
7091                 str = "Accept all advertisement, inc. directed unresolved RPA";
7092                 break;
7093         case 0x03:
7094                 str = "Ignore not in accept list, exc. directed unresolved RPA";
7095                 break;
7096         default:
7097                 str = "Reserved";
7098                 break;
7099         }
7100
7101         print_field("Filter policy: %s (0x%2.2x)", str, policy);
7102 }
7103
7104 static void le_set_scan_parameters_cmd(uint16_t index, const void *data,
7105                                                         uint8_t size)
7106 {
7107         const struct bt_hci_cmd_le_set_scan_parameters *cmd = data;
7108
7109         print_scan_type("Type", cmd->type);
7110         print_interval(cmd->interval);
7111         print_window(cmd->window);
7112         print_own_addr_type(cmd->own_addr_type);
7113         print_scan_filter_policy(cmd->filter_policy);
7114 }
7115
7116 static void le_set_scan_enable_cmd(uint16_t index, const void *data,
7117                                                         uint8_t size)
7118 {
7119         const struct bt_hci_cmd_le_set_scan_enable *cmd = data;
7120
7121         print_enable("Scanning", cmd->enable);
7122         print_enable("Filter duplicates", cmd->filter_dup);
7123 }
7124
7125 static void le_create_conn_cmd(uint16_t index, const void *data, uint8_t size)
7126 {
7127         const struct bt_hci_cmd_le_create_conn *cmd = data;
7128         const char *str;
7129
7130         print_slot_625("Scan interval", cmd->scan_interval);
7131         print_slot_625("Scan window", cmd->scan_window);
7132
7133         switch (cmd->filter_policy) {
7134         case 0x00:
7135                 str = "Accept list is not used";
7136                 break;
7137         case 0x01:
7138                 str = "Accept list is used";
7139                 break;
7140         default:
7141                 str = "Reserved";
7142                 break;
7143         }
7144
7145         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
7146
7147         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
7148         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
7149         print_own_addr_type(cmd->own_addr_type);
7150
7151         print_slot_125("Min connection interval", cmd->min_interval);
7152         print_slot_125("Max connection interval", cmd->max_interval);
7153         print_conn_latency("Connection latency", cmd->latency);
7154         print_field("Supervision timeout: %d msec (0x%4.4x)",
7155                                         le16_to_cpu(cmd->supv_timeout) * 10,
7156                                         le16_to_cpu(cmd->supv_timeout));
7157         print_slot_625("Min connection length", cmd->min_length);
7158         print_slot_625("Max connection length", cmd->max_length);
7159 }
7160
7161 static void le_read_accept_list_size_rsp(uint16_t index, const void *data,
7162                                                         uint8_t size)
7163 {
7164         const struct bt_hci_rsp_le_read_accept_list_size *rsp = data;
7165
7166         print_status(rsp->status);
7167         print_field("Size: %u", rsp->size);
7168 }
7169
7170 static void le_add_to_accept_list_cmd(uint16_t index, const void *data,
7171                                                         uint8_t size)
7172 {
7173         const struct bt_hci_cmd_le_add_to_accept_list *cmd = data;
7174
7175         print_addr_type("Address type", cmd->addr_type);
7176         print_addr("Address", cmd->addr, cmd->addr_type);
7177 }
7178
7179 static void le_remove_from_accept_list_cmd(uint16_t index, const void *data,
7180                                                         uint8_t size)
7181 {
7182         const struct bt_hci_cmd_le_remove_from_accept_list *cmd = data;
7183
7184         print_addr_type("Address type", cmd->addr_type);
7185         print_addr("Address", cmd->addr, cmd->addr_type);
7186 }
7187
7188 static void le_conn_update_cmd(uint16_t index, const void *data, uint8_t size)
7189 {
7190         const struct bt_hci_cmd_le_conn_update *cmd = data;
7191
7192         print_handle(cmd->handle);
7193         print_slot_125("Min connection interval", cmd->min_interval);
7194         print_slot_125("Max connection interval", cmd->max_interval);
7195         print_conn_latency("Connection latency", cmd->latency);
7196         print_field("Supervision timeout: %d msec (0x%4.4x)",
7197                                         le16_to_cpu(cmd->supv_timeout) * 10,
7198                                         le16_to_cpu(cmd->supv_timeout));
7199         print_slot_625("Min connection length", cmd->min_length);
7200         print_slot_625("Max connection length", cmd->max_length);
7201 }
7202
7203 static void le_set_host_classification_cmd(uint16_t index, const void *data,
7204                                                         uint8_t size)
7205 {
7206         const struct bt_hci_cmd_le_set_host_classification *cmd = data;
7207
7208         print_le_channel_map(cmd->map);
7209 }
7210
7211 static void le_read_channel_map_cmd(uint16_t index, const void *data,
7212                                                         uint8_t size)
7213 {
7214         const struct bt_hci_cmd_le_read_channel_map *cmd = data;
7215
7216         print_handle(cmd->handle);
7217 }
7218
7219 static void le_read_channel_map_rsp(uint16_t index, const void *data,
7220                                                         uint8_t size)
7221 {
7222         const struct bt_hci_rsp_le_read_channel_map *rsp = data;
7223
7224         print_status(rsp->status);
7225         print_handle(rsp->handle);
7226         print_le_channel_map(rsp->map);
7227 }
7228
7229 static void le_read_remote_features_cmd(uint16_t index, const void *data,
7230                                                         uint8_t size)
7231 {
7232         const struct bt_hci_cmd_le_read_remote_features *cmd = data;
7233
7234         print_handle(cmd->handle);
7235 }
7236
7237 static void le_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
7238 {
7239         const struct bt_hci_cmd_le_encrypt *cmd = data;
7240
7241         print_key("Key", cmd->key);
7242         print_key("Plaintext data", cmd->plaintext);
7243 }
7244
7245 static void le_encrypt_rsp(uint16_t index, const void *data, uint8_t size)
7246 {
7247         const struct bt_hci_rsp_le_encrypt *rsp = data;
7248
7249         print_status(rsp->status);
7250         print_key("Encrypted data", rsp->data);
7251 }
7252
7253 static void le_rand_rsp(uint16_t index, const void *data, uint8_t size)
7254 {
7255         const struct bt_hci_rsp_le_rand *rsp = data;
7256
7257         print_status(rsp->status);
7258         print_random_number(rsp->number);
7259 }
7260
7261 static void le_start_encrypt_cmd(uint16_t index, const void *data, uint8_t size)
7262 {
7263         const struct bt_hci_cmd_le_start_encrypt *cmd = data;
7264
7265         print_handle(cmd->handle);
7266         print_random_number(cmd->rand);
7267         print_encrypted_diversifier(cmd->ediv);
7268         print_key("Long term key", cmd->ltk);
7269 }
7270
7271 static void le_ltk_req_reply_cmd(uint16_t index, const void *data, uint8_t size)
7272 {
7273         const struct bt_hci_cmd_le_ltk_req_reply *cmd = data;
7274
7275         print_handle(cmd->handle);
7276         print_key("Long term key", cmd->ltk);
7277 }
7278
7279 static void le_ltk_req_reply_rsp(uint16_t index, const void *data, uint8_t size)
7280 {
7281         const struct bt_hci_rsp_le_ltk_req_reply *rsp = data;
7282
7283         print_status(rsp->status);
7284         print_handle(rsp->handle);
7285 }
7286
7287 static void le_ltk_req_neg_reply_cmd(uint16_t index, const void *data,
7288                                                         uint8_t size)
7289 {
7290         const struct bt_hci_cmd_le_ltk_req_neg_reply *cmd = data;
7291
7292         print_handle(cmd->handle);
7293 }
7294
7295 static void le_ltk_req_neg_reply_rsp(uint16_t index, const void *data,
7296                                                         uint8_t size)
7297 {
7298         const struct bt_hci_rsp_le_ltk_req_neg_reply *rsp = data;
7299
7300         print_status(rsp->status);
7301         print_handle(rsp->handle);
7302 }
7303
7304 static void le_read_supported_states_rsp(uint16_t index, const void *data,
7305                                                         uint8_t size)
7306 {
7307         const struct bt_hci_rsp_le_read_supported_states *rsp = data;
7308
7309         print_status(rsp->status);
7310         print_le_states(rsp->states);
7311 }
7312
7313 static void le_receiver_test_cmd(uint16_t index, const void *data, uint8_t size)
7314 {
7315         const struct bt_hci_cmd_le_receiver_test *cmd = data;
7316
7317         print_field("RX frequency: %d MHz (0x%2.2x)",
7318                                 (cmd->frequency * 2) + 2402, cmd->frequency);
7319 }
7320
7321 static void le_transmitter_test_cmd(uint16_t index, const void *data,
7322                                                         uint8_t size)
7323 {
7324         const struct bt_hci_cmd_le_transmitter_test *cmd = data;
7325
7326         print_field("TX frequency: %d MHz (0x%2.2x)",
7327                                 (cmd->frequency * 2) + 2402, cmd->frequency);
7328         print_field("Test data length: %d bytes", cmd->data_len);
7329         print_field("Packet payload: 0x%2.2x", cmd->payload);
7330 }
7331
7332 static void le_test_end_rsp(uint16_t index, const void *data, uint8_t size)
7333 {
7334         const struct bt_hci_rsp_le_test_end *rsp = data;
7335
7336         print_status(rsp->status);
7337         print_field("Number of packets: %d", le16_to_cpu(rsp->num_packets));
7338 }
7339
7340 static void le_conn_param_req_reply_cmd(uint16_t index, const void *data,
7341                                                         uint8_t size)
7342 {
7343         const struct bt_hci_cmd_le_conn_param_req_reply *cmd = data;
7344
7345         print_handle(cmd->handle);
7346         print_slot_125("Min connection interval", cmd->min_interval);
7347         print_slot_125("Max connection interval", cmd->max_interval);
7348         print_conn_latency("Connection latency", cmd->latency);
7349         print_field("Supervision timeout: %d msec (0x%4.4x)",
7350                                         le16_to_cpu(cmd->supv_timeout) * 10,
7351                                         le16_to_cpu(cmd->supv_timeout));
7352         print_slot_625("Min connection length", cmd->min_length);
7353         print_slot_625("Max connection length", cmd->max_length);
7354 }
7355
7356 static void le_conn_param_req_reply_rsp(uint16_t index, const void *data,
7357                                                         uint8_t size)
7358 {
7359         const struct bt_hci_rsp_le_conn_param_req_reply *rsp = data;
7360
7361         print_status(rsp->status);
7362         print_handle(rsp->handle);
7363 }
7364
7365 static void le_conn_param_req_neg_reply_cmd(uint16_t index, const void *data,
7366                                                         uint8_t size)
7367 {
7368         const struct bt_hci_cmd_le_conn_param_req_neg_reply *cmd = data;
7369
7370         print_handle(cmd->handle);
7371         print_reason(cmd->reason);
7372 }
7373
7374 static void le_conn_param_req_neg_reply_rsp(uint16_t index, const void *data,
7375                                                         uint8_t size)
7376 {
7377         const struct bt_hci_rsp_le_conn_param_req_neg_reply *rsp = data;
7378
7379         print_status(rsp->status);
7380         print_handle(rsp->handle);
7381 }
7382
7383 static void le_set_data_length_cmd(uint16_t index, const void *data,
7384                                                         uint8_t size)
7385 {
7386         const struct bt_hci_cmd_le_set_data_length *cmd = data;
7387
7388         print_handle(cmd->handle);
7389         print_field("TX octets: %d", le16_to_cpu(cmd->tx_len));
7390         print_field("TX time: %d", le16_to_cpu(cmd->tx_time));
7391 }
7392
7393 static void le_set_data_length_rsp(uint16_t index, const void *data,
7394                                                         uint8_t size)
7395 {
7396         const struct bt_hci_rsp_le_set_data_length *rsp = data;
7397
7398         print_status(rsp->status);
7399         print_handle(rsp->handle);
7400 }
7401
7402 static void le_read_default_data_length_rsp(uint16_t index, const void *data,
7403                                                         uint8_t size)
7404 {
7405         const struct bt_hci_rsp_le_read_default_data_length *rsp = data;
7406
7407         print_status(rsp->status);
7408         print_field("TX octets: %d", le16_to_cpu(rsp->tx_len));
7409         print_field("TX time: %d", le16_to_cpu(rsp->tx_time));
7410 }
7411
7412 static void le_write_default_data_length_cmd(uint16_t index, const void *data,
7413                                                         uint8_t size)
7414 {
7415         const struct bt_hci_cmd_le_write_default_data_length *cmd = data;
7416
7417         print_field("TX octets: %d", le16_to_cpu(cmd->tx_len));
7418         print_field("TX time: %d", le16_to_cpu(cmd->tx_time));
7419 }
7420
7421 static void le_generate_dhkey_cmd(uint16_t index, const void *data,
7422                                                         uint8_t size)
7423 {
7424         const struct bt_hci_cmd_le_generate_dhkey *cmd = data;
7425
7426         print_pk256("Remote P-256 public key", cmd->remote_pk256);
7427 }
7428
7429 static void le_add_to_resolv_list_cmd(uint16_t index, const void *data,
7430                                                         uint8_t size)
7431 {
7432         const struct bt_hci_cmd_le_add_to_resolv_list *cmd = data;
7433
7434         print_addr_type("Address type", cmd->addr_type);
7435         print_addr("Address", cmd->addr, cmd->addr_type);
7436         print_key("Peer identity resolving key", cmd->peer_irk);
7437         print_key("Local identity resolving key", cmd->local_irk);
7438 }
7439
7440 static void le_remove_from_resolv_list_cmd(uint16_t index, const void *data,
7441                                                         uint8_t size)
7442 {
7443         const struct bt_hci_cmd_le_remove_from_resolv_list *cmd = data;
7444
7445         print_addr_type("Address type", cmd->addr_type);
7446         print_addr("Address", cmd->addr, cmd->addr_type);
7447 }
7448
7449 static void le_read_resolv_list_size_rsp(uint16_t index, const void *data,
7450                                                         uint8_t size)
7451 {
7452         const struct bt_hci_rsp_le_read_resolv_list_size *rsp = data;
7453
7454         print_status(rsp->status);
7455         print_field("Size: %u", rsp->size);
7456 }
7457
7458 static void le_read_peer_resolv_addr_cmd(uint16_t index, const void *data,
7459                                                         uint8_t size)
7460 {
7461         const struct bt_hci_cmd_le_read_peer_resolv_addr *cmd = data;
7462
7463         print_addr_type("Address type", cmd->addr_type);
7464         print_addr("Address", cmd->addr, cmd->addr_type);
7465 }
7466
7467 static void le_read_peer_resolv_addr_rsp(uint16_t index, const void *data,
7468                                                         uint8_t size)
7469 {
7470         const struct bt_hci_rsp_le_read_peer_resolv_addr *rsp = data;
7471
7472         print_status(rsp->status);
7473         print_addr("Address", rsp->addr, 0x01);
7474 }
7475
7476 static void le_read_local_resolv_addr_cmd(uint16_t index, const void *data,
7477                                                         uint8_t size)
7478 {
7479         const struct bt_hci_cmd_le_read_local_resolv_addr *cmd = data;
7480
7481         print_addr_type("Address type", cmd->addr_type);
7482         print_addr("Address", cmd->addr, cmd->addr_type);
7483 }
7484
7485 static void le_read_local_resolv_addr_rsp(uint16_t index, const void *data,
7486                                                         uint8_t size)
7487 {
7488         const struct bt_hci_rsp_le_read_local_resolv_addr *rsp = data;
7489
7490         print_status(rsp->status);
7491         print_addr("Address", rsp->addr, 0x01);
7492 }
7493
7494 static void le_set_resolv_enable_cmd(uint16_t index, const void *data,
7495                                                         uint8_t size)
7496 {
7497         const struct bt_hci_cmd_le_set_resolv_enable *cmd = data;
7498
7499         print_enable("Address resolution", cmd->enable);
7500 }
7501
7502 static void le_set_resolv_timeout_cmd(uint16_t index, const void *data,
7503                                                         uint8_t size)
7504 {
7505         const struct bt_hci_cmd_le_set_resolv_timeout *cmd = data;
7506
7507         print_field("Timeout: %u seconds", le16_to_cpu(cmd->timeout));
7508 }
7509
7510 static void le_read_max_data_length_rsp(uint16_t index, const void *data,
7511                                                         uint8_t size)
7512 {
7513         const struct bt_hci_rsp_le_read_max_data_length *rsp = data;
7514
7515         print_status(rsp->status);
7516         print_field("Max TX octets: %d", le16_to_cpu(rsp->max_tx_len));
7517         print_field("Max TX time: %d", le16_to_cpu(rsp->max_tx_time));
7518         print_field("Max RX octets: %d", le16_to_cpu(rsp->max_rx_len));
7519         print_field("Max RX time: %d", le16_to_cpu(rsp->max_rx_time));
7520 }
7521
7522 static void le_read_phy_cmd(uint16_t index, const void *data, uint8_t size)
7523 {
7524         const struct bt_hci_cmd_le_read_phy *cmd = data;
7525
7526         print_handle(cmd->handle);
7527 }
7528
7529 static void print_le_phy(const char *prefix, uint8_t phy)
7530 {
7531         const char *str;
7532
7533         switch (phy) {
7534         case 0x01:
7535                 str = "LE 1M";
7536                 break;
7537         case 0x02:
7538                 str = "LE 2M";
7539                 break;
7540         case 0x03:
7541                 str = "LE Coded";
7542                 break;
7543         default:
7544                 str = "Reserved";
7545                 break;
7546         }
7547
7548         print_field("%s: %s (0x%2.2x)", prefix, str, phy);
7549 }
7550
7551 static void le_read_phy_rsp(uint16_t index, const void *data, uint8_t size)
7552 {
7553         const struct bt_hci_rsp_le_read_phy *rsp = data;
7554
7555         print_status(rsp->status);
7556         print_handle(rsp->handle);
7557         print_le_phy("TX PHY", rsp->tx_phy);
7558         print_le_phy("RX PHY", rsp->rx_phy);
7559 }
7560
7561 static const struct bitfield_data le_phys[] = {
7562         {  0, "LE 1M"   },
7563         {  1, "LE 2M"   },
7564         {  2, "LE Coded"},
7565         { }
7566 };
7567
7568 static const struct bitfield_data le_phy_preference[] = {
7569         {  0, "No TX PHY preference"    },
7570         {  1, "No RX PHY preference"    },
7571         { }
7572 };
7573
7574 static void print_le_phys_preference(uint8_t all_phys, uint8_t tx_phys,
7575                                                         uint8_t rx_phys)
7576 {
7577         uint8_t mask;
7578
7579         print_field("All PHYs preference: 0x%2.2x", all_phys);
7580
7581         mask = print_bitfield(2, all_phys, le_phy_preference);
7582         if (mask)
7583                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7584                                                         " (0x%2.2x)", mask);
7585
7586         print_field("TX PHYs preference: 0x%2.2x", tx_phys);
7587
7588         mask = print_bitfield(2, tx_phys, le_phys);
7589         if (mask)
7590                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7591                                                         " (0x%2.2x)", mask);
7592
7593         print_field("RX PHYs preference: 0x%2.2x", rx_phys);
7594
7595         mask = print_bitfield(2, rx_phys, le_phys);
7596         if (mask)
7597                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
7598                                                         " (0x%2.2x)", mask);
7599 }
7600
7601 static void le_set_default_phy_cmd(uint16_t index, const void *data,
7602                                                         uint8_t size)
7603 {
7604         const struct bt_hci_cmd_le_set_default_phy *cmd = data;
7605
7606         print_le_phys_preference(cmd->all_phys, cmd->tx_phys, cmd->rx_phys);
7607 }
7608
7609 static void le_set_phy_cmd(uint16_t index, const void *data, uint8_t size)
7610 {
7611         const struct bt_hci_cmd_le_set_phy *cmd = data;
7612         const char *str;
7613
7614         print_handle(cmd->handle);
7615         print_le_phys_preference(cmd->all_phys, cmd->tx_phys, cmd->rx_phys);
7616         switch (le16_to_cpu(cmd->phy_opts)) {
7617         case 0x0001:
7618                 str = "S2 coding";
7619                 break;
7620         case 0x0002:
7621                 str = "S8 coding";
7622                 break;
7623         default:
7624                 str = "Reserved";
7625                 break;
7626         }
7627
7628         print_field("PHY options preference: %s (0x%4.4x)", str, cmd->phy_opts);
7629 }
7630
7631 static void le_enhanced_receiver_test_cmd(uint16_t index, const void *data,
7632                                                         uint8_t size)
7633 {
7634         const struct bt_hci_cmd_le_enhanced_receiver_test *cmd = data;
7635         const char *str;
7636
7637         print_field("RX channel frequency: %d MHz (0x%2.2x)",
7638                                 (cmd->rx_channel * 2) + 2402, cmd->rx_channel);
7639         print_le_phy("PHY", cmd->phy);
7640
7641         switch (cmd->modulation_index) {
7642         case 0x00:
7643                 str = "Standard";
7644                 break;
7645         case 0x01:
7646                 str = "Stable";
7647                 break;
7648         default:
7649                 str = "Reserved";
7650                 break;
7651         }
7652
7653         print_field("Modulation index: %s (0x%2.2x)", str,
7654                                                         cmd->modulation_index);
7655 }
7656
7657 static void le_enhanced_transmitter_test_cmd(uint16_t index, const void *data,
7658                                                         uint8_t size)
7659 {
7660         const struct bt_hci_cmd_le_enhanced_transmitter_test *cmd = data;
7661         const char *str;
7662
7663         print_field("TX channel frequency: %d MHz (0x%2.2x)",
7664                                 (cmd->tx_channel * 2) + 2402, cmd->tx_channel);
7665         print_field("Test data length: %d bytes", cmd->data_len);
7666         print_field("Packet payload: 0x%2.2x", cmd->payload);
7667
7668         switch (cmd->phy) {
7669         case 0x01:
7670                 str = "LE 1M";
7671                 break;
7672         case 0x02:
7673                 str = "LE 2M";
7674                 break;
7675         case 0x03:
7676                 str = "LE Coded with S=8";
7677                 break;
7678         case 0x04:
7679                 str = "LE Coded with S=2";
7680                 break;
7681         default:
7682                 str = "Reserved";
7683                 break;
7684         }
7685
7686         print_field("PHY: %s (0x%2.2x)", str, cmd->phy);
7687 }
7688
7689 static void le_set_adv_set_rand_addr(uint16_t index, const void *data,
7690                                                         uint8_t size)
7691 {
7692         const struct bt_hci_cmd_le_set_adv_set_rand_addr *cmd = data;
7693
7694         print_field("Advertising handle: 0x%2.2x", cmd->handle);
7695         print_addr("Advertising random address", cmd->bdaddr, 0x01);
7696 }
7697
7698 static const struct bitfield_data ext_adv_properties_table[] = {
7699         {  0, "Connectable"             },
7700         {  1, "Scannable"               },
7701         {  2, "Directed"        },
7702         {  3, "High Duty Cycle Directed Connectable"    },
7703         {  4, "Use legacy advertising PDUs"     },
7704         {  5, "Anonymous advertising"   },
7705         {  6, "Include TxPower"         },
7706         { }
7707 };
7708
7709 static const char *get_adv_pdu_desc(uint16_t flags)
7710 {
7711         const char *str;
7712
7713         switch (flags) {
7714         case 0x10:
7715                 str = "ADV_NONCONN_IND";
7716                 break;
7717         case 0x12:
7718                 str = "ADV_SCAN_IND";
7719                 break;
7720         case 0x13:
7721                 str = "ADV_IND";
7722                 break;
7723         case 0x15:
7724                 str = "ADV_DIRECT_IND (low duty cycle)";
7725                 break;
7726         case 0x1d:
7727                 str = "ADV_DIRECT_IND (high duty cycle)";
7728                 break;
7729         default:
7730                 str = "Reserved";
7731                 break;
7732         }
7733
7734         return str;
7735 }
7736
7737 static void print_ext_adv_properties(uint16_t flags)
7738 {
7739         uint16_t mask = flags;
7740         const char *property;
7741         int i;
7742
7743         print_field("Properties: 0x%4.4x", flags);
7744
7745         for (i = 0; ext_adv_properties_table[i].str; i++) {
7746                 if (flags & (1 << ext_adv_properties_table[i].bit)) {
7747                         property = ext_adv_properties_table[i].str;
7748
7749                         if (ext_adv_properties_table[i].bit == 4) {
7750                                 print_field("  %s: %s", property,
7751                                                 get_adv_pdu_desc(flags));
7752                         } else {
7753                                 print_field("  %s", property);
7754                         }
7755                         mask &= ~(1 << ext_adv_properties_table[i].bit);
7756                 }
7757         }
7758
7759         if (mask)
7760                 print_text(COLOR_UNKNOWN_ADV_FLAG,
7761                                 "  Unknown advertising properties (0x%4.4x)",
7762                                                                         mask);
7763 }
7764
7765 static void print_ext_slot_625(const char *label, const uint8_t value[3])
7766 {
7767         uint32_t value_cpu = value[0];
7768
7769         value_cpu |= value[1] << 8;
7770         value_cpu |= value[2] << 16;
7771
7772         print_field("%s: %.3f msec (0x%4.4x)", label,
7773                                                 value_cpu * 0.625, value_cpu);
7774 }
7775
7776 static void le_set_ext_adv_params_cmd(uint16_t index, const void *data,
7777                                                         uint8_t size)
7778 {
7779         const struct bt_hci_cmd_le_set_ext_adv_params *cmd = data;
7780         const char *str;
7781
7782         print_field("Handle: 0x%2.2x", cmd->handle);
7783         print_ext_adv_properties(le16_to_cpu(cmd->evt_properties));
7784
7785         print_ext_slot_625("Min advertising interval", cmd->min_interval);
7786         print_ext_slot_625("Max advertising interval", cmd->max_interval);
7787         print_adv_channel_map("Channel map", cmd->channel_map);
7788         print_own_addr_type(cmd->own_addr_type);
7789         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
7790         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
7791         print_adv_filter_policy("Filter policy", cmd->filter_policy);
7792         if (cmd->tx_power == 0x7f)
7793                 print_field("TX power: Host has no preference (0x7f)");
7794         else
7795                 print_power_level(cmd->tx_power, NULL);
7796
7797         switch (cmd->primary_phy) {
7798         case 0x01:
7799                 str = "LE 1M";
7800                 break;
7801         case 0x03:
7802                 str = "LE Coded";
7803                 break;
7804         default:
7805                 str = "Reserved";
7806                 break;
7807         }
7808
7809         print_field("Primary PHY: %s (0x%2.2x)", str, cmd->primary_phy);
7810         print_field("Secondary max skip: 0x%2.2x", cmd->secondary_max_skip);
7811         print_le_phy("Secondary PHY", cmd->secondary_phy);
7812         print_field("SID: 0x%2.2x", cmd->sid);
7813         print_enable("Scan request notifications", cmd->notif_enable);
7814 }
7815
7816 static void le_set_ext_adv_params_rsp(uint16_t index, const void *data,
7817                                                         uint8_t size)
7818 {
7819         const struct bt_hci_rsp_le_set_ext_adv_params *rsp = data;
7820
7821         print_status(rsp->status);
7822         print_power_level(rsp->tx_power, "selected");
7823 }
7824
7825 static void le_set_ext_adv_data_cmd(uint16_t index, const void *data,
7826                                                         uint8_t size)
7827 {
7828         const struct bt_hci_cmd_le_set_ext_adv_data *cmd = data;
7829         const char *str;
7830
7831         print_field("Handle: 0x%2.2x", cmd->handle);
7832
7833         switch (cmd->operation) {
7834         case 0x00:
7835                 str = "Immediate fragment";
7836                 break;
7837         case 0x01:
7838                 str = "First fragment";
7839                 break;
7840         case 0x02:
7841                 str = "Last fragment";
7842                 break;
7843         case 0x03:
7844                 str = "Complete extended advertising data";
7845                 break;
7846         case 0x04:
7847                 str = "Unchanged data";
7848                 break;
7849         default:
7850                 str = "Reserved";
7851                 break;
7852         }
7853
7854         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
7855
7856         switch (cmd->fragment_preference) {
7857         case 0x00:
7858                 str = "Fragment all";
7859                 break;
7860         case 0x01:
7861                 str = "Minimize fragmentation";
7862                 break;
7863         default:
7864                 str = "Reserved";
7865                 break;
7866         }
7867
7868         print_field("Fragment preference: %s (0x%2.2x)", str,
7869                                                 cmd->fragment_preference);
7870         print_field("Data length: 0x%2.2x", cmd->data_len);
7871         packet_print_ad(cmd->data, size - sizeof(*cmd));
7872 }
7873
7874 static void le_set_ext_scan_rsp_data_cmd(uint16_t index, const void *data,
7875                                                         uint8_t size)
7876 {
7877         const struct bt_hci_cmd_le_set_ext_scan_rsp_data *cmd = data;
7878         const char *str;
7879
7880         print_field("Handle: 0x%2.2x", cmd->handle);
7881
7882         switch (cmd->operation) {
7883         case 0x00:
7884                 str = "Immediate fragment";
7885                 break;
7886         case 0x01:
7887                 str = "First fragment";
7888                 break;
7889         case 0x02:
7890                 str = "Last fragment";
7891                 break;
7892         case 0x03:
7893                 str = "Complete scan response data";
7894                 break;
7895         case 0x04:
7896                 str = "Unchanged data";
7897                 break;
7898         default:
7899                 str = "Reserved";
7900                 break;
7901         }
7902
7903         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
7904
7905         switch (cmd->fragment_preference) {
7906         case 0x00:
7907                 str = "Fragment all";
7908                 break;
7909         case 0x01:
7910                 str = "Minimize fragmentation";
7911                 break;
7912         default:
7913                 str = "Reserved";
7914                 break;
7915         }
7916
7917         print_field("Fragment preference: %s (0x%2.2x)", str,
7918                                                 cmd->fragment_preference);
7919         print_field("Data length: 0x%2.2x", cmd->data_len);
7920         packet_print_ad(cmd->data, size - sizeof(*cmd));
7921 }
7922
7923 static void le_set_ext_adv_enable_cmd(uint16_t index, const void *data,
7924                                                         uint8_t size)
7925 {
7926         const struct bt_hci_cmd_le_set_ext_adv_enable *cmd = data;
7927         const struct bt_hci_cmd_ext_adv_set *adv_set;
7928         int i;
7929
7930         print_enable("Extended advertising", cmd->enable);
7931
7932         if (cmd->num_of_sets == 0)
7933                 print_field("Number of sets: Disable all sets (0x%2.2x)",
7934                                                         cmd->num_of_sets);
7935         else if (cmd->num_of_sets > 0x3f)
7936                 print_field("Number of sets: Reserved (0x%2.2x)",
7937                                                         cmd->num_of_sets);
7938         else
7939                 print_field("Number of sets: %u (0x%2.2x)", cmd->num_of_sets,
7940                                                         cmd->num_of_sets);
7941
7942         for (i = 0; i < cmd->num_of_sets; ++i) {
7943                 adv_set = data + 2 + i * sizeof(struct bt_hci_cmd_ext_adv_set);
7944                 print_field("Entry %d", i);
7945                 print_field("  Handle: 0x%2.2x", adv_set->handle);
7946                 print_field("  Duration: %d ms (0x%2.2x)",
7947                                 adv_set->duration * 10, adv_set->duration);
7948                 print_field("  Max ext adv events: %d", adv_set->max_events);
7949         }
7950 }
7951
7952 static void le_read_max_adv_data_len_rsp(uint16_t index, const void *data,
7953                                                         uint8_t size)
7954 {
7955         const struct bt_hci_rsp_le_read_max_adv_data_len *rsp = data;
7956
7957         print_status(rsp->status);
7958         print_field("Max length: %d", rsp->max_len);
7959 }
7960
7961 static void le_read_num_supported_adv_sets_rsp(uint16_t index, const void *data,
7962                                                         uint8_t size)
7963 {
7964         const struct bt_hci_rsp_le_read_num_supported_adv_sets *rsp = data;
7965
7966         print_status(rsp->status);
7967         print_field("Num supported adv sets: %d", rsp->num_of_sets);
7968 }
7969
7970 static void le_remove_adv_set_cmd(uint16_t index, const void *data,
7971                                                         uint8_t size)
7972 {
7973         const struct bt_hci_cmd_le_remove_adv_set *cmd = data;
7974
7975         print_handle(cmd->handle);
7976 }
7977
7978 static const struct bitfield_data pa_properties_table[] = {
7979         {  6, "Include TxPower"         },
7980         { }
7981 };
7982
7983 static void print_pa_properties(uint16_t flags)
7984 {
7985         uint16_t mask;
7986
7987         print_field("Properties: 0x%4.4x", flags);
7988
7989         mask = print_bitfield(2, flags, pa_properties_table);
7990         if (mask)
7991                 print_text(COLOR_UNKNOWN_ADV_FLAG,
7992                                 "  Unknown advertising properties (0x%4.4x)",
7993                                                                         mask);
7994 }
7995
7996 static void le_set_pa_params_cmd(uint16_t index, const void *data, uint8_t size)
7997 {
7998         const struct bt_hci_cmd_le_set_pa_params *cmd = data;
7999
8000         print_handle(cmd->handle);
8001         print_slot_125("Min interval", cmd->min_interval);
8002         print_slot_125("Max interval", cmd->max_interval);
8003         print_pa_properties(cmd->properties);
8004 }
8005
8006 static void le_set_pa_data_cmd(uint16_t index, const void *data, uint8_t size)
8007 {
8008         const struct bt_hci_cmd_le_set_pa_data *cmd = data;
8009         const char *str;
8010
8011         print_handle(cmd->handle);
8012
8013         switch (cmd->operation) {
8014         case 0x00:
8015                 str = "Immediate fragment";
8016                 break;
8017         case 0x01:
8018                 str = "First fragment";
8019                 break;
8020         case 0x02:
8021                 str = "Last fragment";
8022                 break;
8023         case 0x03:
8024                 str = "Complete ext advertising data";
8025                 break;
8026         default:
8027                 str = "Reserved";
8028                 break;
8029         }
8030
8031         print_field("Operation: %s (0x%2.2x)", str, cmd->operation);
8032         print_field("Data length: 0x%2.2x", cmd->data_len);
8033         print_eir(cmd->data, cmd->data_len, true);
8034 }
8035
8036 static void le_set_pa_enable_cmd(uint16_t index, const void *data, uint8_t size)
8037 {
8038         const struct bt_hci_cmd_le_set_pa_enable *cmd = data;
8039
8040         print_enable("Periodic advertising", cmd->enable);
8041         print_handle(cmd->handle);
8042 }
8043
8044 static const struct bitfield_data ext_scan_phys_table[] = {
8045         {  0, "LE 1M"           },
8046         {  2, "LE Coded"                },
8047         { }
8048 };
8049
8050 static void print_ext_scan_phys(const void *data, uint8_t flags)
8051 {
8052         const struct bt_hci_le_scan_phy *scan_phy;
8053         uint8_t mask = flags;
8054         int bits_set = 0;
8055         int i;
8056
8057         print_field("PHYs: 0x%2.2x", flags);
8058
8059         for (i = 0; ext_scan_phys_table[i].str; i++) {
8060                 if (flags & (1 << ext_scan_phys_table[i].bit)) {
8061                         scan_phy = data + bits_set * sizeof(*scan_phy);
8062                         mask &= ~(1 << ext_scan_phys_table[i].bit);
8063
8064                         print_field("Entry %d: %s", bits_set,
8065                                                 ext_scan_phys_table[i].str);
8066                         print_scan_type("  Type", scan_phy->type);
8067                         print_slot_625("  Interval", scan_phy->interval);
8068                         print_slot_625("  Window", scan_phy->window);
8069
8070                         ++bits_set;
8071                 }
8072         }
8073
8074         if (mask)
8075                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown scanning PHYs"
8076                                                         " (0x%2.2x)", mask);
8077 }
8078
8079 static void le_set_ext_scan_params_cmd(uint16_t index, const void *data,
8080                                                         uint8_t size)
8081 {
8082         const struct bt_hci_cmd_le_set_ext_scan_params *cmd = data;
8083
8084         print_own_addr_type(cmd->own_addr_type);
8085         print_scan_filter_policy(cmd->filter_policy);
8086         print_ext_scan_phys(cmd->data, cmd->num_phys);
8087 }
8088
8089 static void le_set_ext_scan_enable_cmd(uint16_t index, const void *data,
8090                                                         uint8_t size)
8091 {
8092         const struct bt_hci_cmd_le_set_ext_scan_enable *cmd = data;
8093
8094         print_enable("Extended scan", cmd->enable);
8095         print_enable("Filter duplicates", cmd->filter_dup);
8096
8097         print_field("Duration: %d msec (0x%4.4x)",
8098                                                 le16_to_cpu(cmd->duration) * 10,
8099                                                 le16_to_cpu(cmd->duration));
8100         print_field("Period: %.2f sec (0x%4.4x)",
8101                                                 le16_to_cpu(cmd->period) * 1.28,
8102                                                 le16_to_cpu(cmd->period));
8103 }
8104
8105 static const struct bitfield_data ext_conn_phys_table[] = {
8106         {  0, "LE 1M"           },
8107         {  1, "LE 2M"           },
8108         {  2, "LE Coded"        },
8109         { }
8110 };
8111
8112 static void print_ext_conn_phys(const void *data, uint8_t flags)
8113 {
8114         const struct bt_hci_le_ext_create_conn *entry;
8115         uint8_t mask = flags;
8116         int bits_set = 0;
8117         int i;
8118
8119         print_field("Initiating PHYs: 0x%2.2x", flags);
8120
8121         for (i = 0; ext_conn_phys_table[i].str; i++) {
8122                 if (flags & (1 << ext_conn_phys_table[i].bit)) {
8123                         entry = data + bits_set * sizeof(*entry);
8124                         mask &= ~(1 << ext_conn_phys_table[i].bit);
8125
8126                         print_field("Entry %d: %s", bits_set,
8127                                                 ext_conn_phys_table[i].str);
8128                         print_slot_625("  Scan interval", entry->scan_interval);
8129                         print_slot_625("  Scan window", entry->scan_window);
8130                         print_slot_125("  Min connection interval",
8131                                                         entry->min_interval);
8132                         print_slot_125("  Max connection interval",
8133                                                         entry->max_interval);
8134                         print_conn_latency("  Connection latency",
8135                                                                 entry->latency);
8136                         print_field("  Supervision timeout: %d msec (0x%4.4x)",
8137                                         le16_to_cpu(entry->supv_timeout) * 10,
8138                                         le16_to_cpu(entry->supv_timeout));
8139                         print_slot_625("  Min connection length",
8140                                                         entry->min_length);
8141                         print_slot_625("  Max connection length",
8142                                                         entry->max_length);
8143
8144                         ++bits_set;
8145                 }
8146         }
8147
8148         if (mask)
8149                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown scanning PHYs"
8150                                                         " (0x%2.2x)", mask);
8151 }
8152
8153 static void le_ext_create_conn_cmd(uint16_t index, const void *data,
8154                                                         uint8_t size)
8155 {
8156         const struct bt_hci_cmd_le_ext_create_conn *cmd = data;
8157         const char *str;
8158
8159         switch (cmd->filter_policy) {
8160         case 0x00:
8161                 str = "Accept list is not used";
8162                 break;
8163         case 0x01:
8164                 str = "Accept list is used";
8165                 break;
8166         default:
8167                 str = "Reserved";
8168                 break;
8169         }
8170
8171         print_field("Filter policy: %s (0x%2.2x)", str, cmd->filter_policy);
8172
8173         print_own_addr_type(cmd->own_addr_type);
8174         print_peer_addr_type("Peer address type", cmd->peer_addr_type);
8175         print_addr("Peer address", cmd->peer_addr, cmd->peer_addr_type);
8176         print_ext_conn_phys(cmd->data, cmd->phys);
8177 }
8178
8179 static const struct bitfield_data create_sync_cte_type[] = {
8180         {  0, "Do not sync to packets with AoA CTE"     },
8181         {  1, "Do not sync to packets with AoD CTE 1us" },
8182         {  2, "Do not sync to packets with AoD CTE 2us" },
8183         {  3, "Do not sync to packets with type 3 AoD"  },
8184         {  4, "Do not sync to packets without CTE"      },
8185         { },
8186 };
8187
8188 static const struct bitfield_data create_sync_options[] = {
8189         {  0, "Use Periodic Advertiser List"    },
8190         {  1, "Reporting initially disabled"    },
8191         { },
8192 };
8193
8194 static const struct bitfield_data create_sync_options_alt[] = {
8195         {  0, "Use advertising SID, Advertiser Address Type and address"},
8196         {  1, "Reporting initially enabled"                             },
8197         { },
8198 };
8199
8200 static void print_create_sync_cte_type(uint8_t flags)
8201 {
8202         uint8_t mask = flags;
8203
8204         print_field("Sync CTE type: 0x%4.4x", flags);
8205
8206         mask = print_bitfield(2, flags, create_sync_cte_type);
8207
8208         if (mask) {
8209                 print_text(COLOR_UNKNOWN_ADV_FLAG,
8210                                 "Unknown sync CTE type properties (0x%4.4x)",
8211                                                                         mask);
8212         }
8213 }
8214
8215 static void print_create_sync_options(uint8_t flags)
8216 {
8217         uint8_t mask = flags;
8218         int i;
8219
8220         print_field("Options: 0x%4.4x", flags);
8221
8222         for (i = 0; create_sync_options[i].str; i++) {
8223                 if (flags & (1 << create_sync_options[i].bit)) {
8224                         print_field("%s", create_sync_options[i].str);
8225                         mask  &= ~(1 << create_sync_options[i].bit);
8226                 } else {
8227                         print_field("%s", create_sync_options_alt[i].str);
8228                         mask  &= ~(1 << create_sync_options_alt[i].bit);
8229                 }
8230         }
8231
8232         if (mask) {
8233                 print_text(COLOR_UNKNOWN_ADV_FLAG,
8234                                         "  Unknown options (0x%4.4x)", mask);
8235         }
8236 }
8237
8238 static void le_pa_create_sync_cmd(uint16_t index, const void *data,
8239                                                         uint8_t size)
8240 {
8241         const struct bt_hci_cmd_le_pa_create_sync *cmd = data;
8242
8243         print_create_sync_options(cmd->options);
8244         print_field("SID: 0x%2.2x", cmd->sid);
8245         print_addr_type("Adv address type", cmd->addr_type);
8246         print_addr("Adv address", cmd->addr, cmd->addr_type);
8247         print_field("Skip: 0x%4.4x", cmd->skip);
8248         print_field("Sync timeout: %d msec (0x%4.4x)",
8249                                         le16_to_cpu(cmd->sync_timeout) * 10,
8250                                         le16_to_cpu(cmd->sync_timeout));
8251         print_create_sync_cte_type(cmd->sync_cte_type);
8252 }
8253
8254 static void le_pa_term_sync_cmd(uint16_t index, const void *data, uint8_t size)
8255 {
8256         const struct bt_hci_cmd_le_pa_term_sync *cmd = data;
8257
8258         print_field("Sync handle: 0x%4.4x", cmd->sync_handle);
8259 }
8260
8261 static void le_add_dev_pa_list_cmd(uint16_t index, const void *data,
8262                                                         uint8_t size)
8263 {
8264         const struct bt_hci_cmd_le_add_dev_pa_list *cmd = data;
8265
8266         print_addr_type("Adv address type", cmd->addr_type);
8267         print_addr("Adv address", cmd->addr, cmd->addr_type);
8268         print_field("SID: 0x%2.2x", cmd->sid);
8269 }
8270
8271 static void le_remove_dev_pa_list_cmd(uint16_t index, const void *data,
8272                                                         uint8_t size)
8273 {
8274         const struct bt_hci_cmd_le_remove_dev_pa_list *cmd = data;
8275
8276         print_addr_type("Adv address type", cmd->addr_type);
8277         print_addr("Adv address", cmd->addr, cmd->addr_type);
8278         print_field("SID: 0x%2.2x", cmd->sid);
8279 }
8280
8281 static void le_read_pa_list_size_rsp(uint16_t index, const void *data,
8282                                                         uint8_t size)
8283 {
8284         const struct bt_hci_rsp_le_read_dev_pa_list_size *rsp = data;
8285
8286         print_status(rsp->status);
8287         print_field("List size: 0x%2.2x", rsp->list_size);
8288 }
8289
8290 static void le_read_tx_power_rsp(uint16_t index, const void *data,
8291                                                         uint8_t size)
8292 {
8293         const struct bt_hci_rsp_le_read_tx_power *rsp = data;
8294
8295         print_status(rsp->status);
8296         print_field("Min Tx power: %d dBm", rsp->min_tx_power);
8297         print_field("Max Tx power: %d dBm", rsp->max_tx_power);
8298 }
8299
8300 static void le_read_rf_path_comp_rsp(uint16_t index, const void *data,
8301                                                         uint8_t size)
8302 {
8303         const struct bt_hci_rsp_le_read_rf_path_comp *rsp = data;
8304
8305         print_status(rsp->status);
8306         print_field("RF Tx Path Compensation Value: 0x%4.4x",
8307                                                         rsp->rf_tx_path_comp);
8308         print_field("RF Rx Path Compensation Value: 0x%4.4x",
8309                                                         rsp->rf_rx_path_comp);
8310 }
8311
8312 static void le_write_rf_path_comp_cmd(uint16_t index, const void *data,
8313                                                         uint8_t size)
8314 {
8315         const struct bt_hci_cmd_le_write_rf_path_comp *cmd = data;
8316
8317         print_field("RF Tx Path Compensation Value: 0x%4.4x",
8318                                                         cmd->rf_tx_path_comp);
8319         print_field("RF Rx Path Compensation Value: 0x%4.4x",
8320                                                         cmd->rf_rx_path_comp);
8321 }
8322
8323 static void le_set_priv_mode_cmd(uint16_t index, const void *data, uint8_t size)
8324 {
8325         const struct bt_hci_cmd_le_set_priv_mode *cmd = data;
8326         const char *str;
8327
8328         print_addr_type("Peer Identity address type", cmd->peer_id_addr_type);
8329         print_addr("Peer Identity address", cmd->peer_id_addr,
8330                                                         cmd->peer_id_addr_type);
8331
8332         switch (cmd->priv_mode) {
8333         case 0x00:
8334                 str = "Use Network Privacy";
8335                 break;
8336         case 0x01:
8337                 str = "Use Device Privacy";
8338                 break;
8339         default:
8340                 str = "Reserved";
8341                 break;
8342         }
8343
8344         print_field("Privacy Mode: %s (0x%2.2x)", str, cmd->priv_mode);
8345 }
8346
8347 static void le_receiver_test_cmd_v3(uint16_t index, const void *data,
8348                                                         uint8_t size)
8349 {
8350         const struct bt_hci_cmd_le_receiver_test_v3 *cmd = data;
8351         uint8_t i;
8352
8353         print_field("RX Channel: %u MHz (0x%2.2x)", cmd->rx_chan * 2 + 2402,
8354                                                         cmd->rx_chan);
8355
8356         switch (cmd->phy) {
8357         case 0x01:
8358                 print_field("PHY: LE 1M (0x%2.2x)", cmd->phy);
8359                 break;
8360         case 0x02:
8361                 print_field("PHY: LE 2M (0x%2.2x)", cmd->phy);
8362                 break;
8363         case 0x03:
8364                 print_field("PHY: LE Coded (0x%2.2x)", cmd->phy);
8365                 break;
8366         }
8367
8368         print_field("Modulation Index: %s (0x%2.2x)",
8369                 cmd->mod_index ? "stable" : "standard", cmd->mod_index);
8370         print_field("Expected CTE Length: %u us (0x%2.2x)", cmd->cte_len * 8,
8371                                                                 cmd->cte_len);
8372         print_field("Expected CTE Type: %u us slots (0x%2.2x)", cmd->cte_type,
8373                                                                 cmd->cte_type);
8374         print_field("Slot Duration: %u us (0x%2.2x)", cmd->duration,
8375                                                                 cmd->duration);
8376         print_field("Number of Antenna IDs: %u", cmd->num_antenna_id);
8377
8378         if (size < sizeof(*cmd) + cmd->num_antenna_id)
8379                 return;
8380
8381         for (i = 0; i < cmd->num_antenna_id; i++)
8382                 print_field("  Antenna ID: %u", cmd->antenna_ids[i]);
8383 }
8384
8385 static const char *parse_tx_test_payload(uint8_t payload)
8386 {
8387         switch (payload) {
8388         case 0x00:
8389                 return "PRBS9 sequence 11111111100000111101...";
8390         case 0x01:
8391                 return "Repeated 11110000";
8392         case 0x02:
8393                 return "Repeated 10101010";
8394         case 0x03:
8395                 return "PRBS15";
8396         case 0x04:
8397                 return "Repeated 11111111";
8398         case 0x05:
8399                 return "Repeated 00000000";
8400         case 0x06:
8401                 return "Repeated 00001111";
8402         case 0x07:
8403                 return "Repeated 01010101";
8404         default:
8405                 return "Reserved";
8406         }
8407 }
8408
8409 static void le_tx_test_cmd_v3(uint16_t index, const void *data, uint8_t size)
8410 {
8411         const struct bt_hci_cmd_le_tx_test_v3 *cmd = data;
8412         uint8_t i;
8413
8414         print_field("TX Channel: %u MHz (0x%2.2x)", cmd->chan * 2 + 2402,
8415                                                                 cmd->chan);
8416         print_field("Length of Test Data: %u", cmd->data_len);
8417         print_field("Packet Payload: %s (0x%2.2x)",
8418                         parse_tx_test_payload(cmd->payload), cmd->payload);
8419
8420         switch (cmd->phy) {
8421         case 0x01:
8422                 print_field("PHY: LE 1M (0x%2.2x)", cmd->phy);
8423                 break;
8424         case 0x02:
8425                 print_field("PHY: LE 2M (0x%2.2x)", cmd->phy);
8426                 break;
8427         case 0x03:
8428                 print_field("PHY: LE Coded with S=8 (0x%2.2x)", cmd->phy);
8429                 break;
8430         case 0x04:
8431                 print_field("PHY: LE Coded with S=2 (0x%2.2x)", cmd->phy);
8432                 break;
8433         }
8434
8435         print_field("Expected CTE Length: %u us (0x%2.2x)", cmd->cte_len * 8,
8436                                                                 cmd->cte_len);
8437         print_field("Expected CTE Type: %u us slots (0x%2.2x)", cmd->cte_type,
8438                                                                 cmd->cte_type);
8439         print_field("Slot Duration: %u us (0x%2.2x)", cmd->duration,
8440                                                                 cmd->duration);
8441         print_field("Number of Antenna IDs: %u", cmd->num_antenna_id);
8442
8443         if (size < sizeof(*cmd) + cmd->num_antenna_id)
8444                 return;
8445
8446         for (i = 0; i < cmd->num_antenna_id; i++)
8447                 print_field("  Antenna ID: %u", cmd->antenna_ids[i]);
8448 }
8449
8450 static void le_pa_rec_enable(uint16_t index, const void *data, uint8_t size)
8451 {
8452         const struct bt_hci_cmd_le_set_pa_enable *cmd = data;
8453
8454         print_field("Sync handle: %d", cmd->handle);
8455         print_enable("Reporting", cmd->enable);
8456 }
8457
8458 static void le_pa_sync_trans(uint16_t index, const void *data, uint8_t size)
8459 {
8460         const struct bt_hci_cmd_periodic_sync_trans *cmd = data;
8461
8462         print_field("Connection handle: %d", cmd->handle);
8463         print_field("Service data: 0x%4.4x", cmd->service_data);
8464         print_field("Sync handle: %d", cmd->sync_handle);
8465 }
8466
8467 static void le_pa_set_info_trans(uint16_t index, const void *data, uint8_t size)
8468 {
8469         const struct bt_hci_cmd_pa_set_info_trans *cmd = data;
8470
8471         print_field("Connection handle: %d", cmd->handle);
8472         print_field("Service data: 0x%4.4x", cmd->service_data);
8473         print_field("Advertising handle: %d", cmd->adv_handle);
8474 }
8475
8476 static void print_sync_mode(uint8_t mode)
8477 {
8478         const char *str;
8479
8480         switch (mode) {
8481         case 0x00:
8482                 str = "Disabled";
8483                 break;
8484         case 0x01:
8485                 str = "Enabled with report events disabled";
8486                 break;
8487         case 0x02:
8488                 str = "Enabled with report events enabled";
8489                 break;
8490         default:
8491                 str = "RFU";
8492                 break;
8493         }
8494
8495         print_field("Mode: %s (0x%2.2x)", str, mode);
8496 }
8497
8498 static void le_pa_sync_trans_params(uint16_t index, const void *data,
8499                                                         uint8_t size)
8500 {
8501         const struct bt_hci_cmd_pa_sync_trans_params *cmd = data;
8502
8503         print_field("Connection handle: %d", cmd->handle);
8504         print_sync_mode(cmd->mode);
8505         print_field("Skip: 0x%2.2x", cmd->skip);
8506         print_field("Sync timeout: %d msec (0x%4.4x)",
8507                                         le16_to_cpu(cmd->sync_timeout) * 10,
8508                                         le16_to_cpu(cmd->sync_timeout));
8509         print_create_sync_cte_type(cmd->cte_type);
8510 }
8511
8512 static void le_set_default_pa_sync_trans_params(uint16_t index,
8513                                                 const void *data, uint8_t size)
8514 {
8515         const struct bt_hci_cmd_default_pa_sync_trans_params *cmd = data;
8516
8517         print_sync_mode(cmd->mode);
8518         print_field("Skip: 0x%2.2x", cmd->skip);
8519         print_field("Sync timeout: %d msec (0x%4.4x)",
8520                                         le16_to_cpu(cmd->sync_timeout) * 10,
8521                                         le16_to_cpu(cmd->sync_timeout));
8522         print_create_sync_cte_type(cmd->cte_type);
8523 }
8524
8525 static void print_sca(uint8_t sca)
8526 {
8527         switch (sca) {
8528         case 0x00:
8529                 print_field("SCA: 201 - 500 ppm (0x%2.2x)", sca);
8530                 return;
8531         case 0x01:
8532                 print_field("SCA: 151 - 200 ppm (0x%2.2x)", sca);
8533                 return;
8534         case 0x02:
8535                 print_field("SCA: 101 - 150 ppm (0x%2.2x)", sca);
8536                 return;
8537         case 0x03:
8538                 print_field("SCA: 76 - 100 ppm (0x%2.2x)", sca);
8539                 return;
8540         case 0x04:
8541                 print_field("SCA: 51 - 75 ppm (0x%2.2x)", sca);
8542                 return;
8543         case 0x05:
8544                 print_field("SCA: 31 - 50 ppm (0x%2.2x)", sca);
8545                 return;
8546         case 0x06:
8547                 print_field("SCA: 21 - 30 ppm (0x%2.2x)", sca);
8548                 return;
8549         case 0x07:
8550                 print_field("SCA: 0 - 20 ppm (0x%2.2x)", sca);
8551                 return;
8552         default:
8553                 print_field("SCA: Reserved (0x%2.2x)", sca);
8554         }
8555 }
8556
8557 static void print_packing(uint8_t value)
8558 {
8559         switch (value) {
8560         case 0x00:
8561                 print_field("Packing: Sequential (0x%2.2x)", value);
8562                 return;
8563         case 0x01:
8564                 print_field("Packing: Interleaved (0x%2.2x)", value);
8565                 return;
8566         default:
8567                 print_field("Packing: Reserved (0x%2.2x)", value);
8568         }
8569 }
8570
8571 static void print_framing(uint8_t value)
8572 {
8573         switch (value) {
8574         case 0x00:
8575                 print_field("Framing: Unframed (0x%2.2x)", value);
8576                 return;
8577         case 0x01:
8578                 print_field("Framing: Framed (0x%2.2x)", value);
8579                 return;
8580         default:
8581                 print_field("Packing: Reserved (0x%2.2x)", value);
8582         }
8583 }
8584
8585 static void le_read_buffer_size_v2_rsp(uint16_t index, const void *data,
8586                                                         uint8_t size)
8587 {
8588         const struct bt_hci_rsp_le_read_buffer_size_v2 *rsp = data;
8589
8590         print_status(rsp->status);
8591
8592         if (size == 1)
8593                 return;
8594
8595         print_field("ACL MTU: %d", le16_to_cpu(rsp->acl_mtu));
8596         print_field("ACL max packet: %d", rsp->acl_max_pkt);
8597         print_field("ISO MTU: %d", le16_to_cpu(rsp->iso_mtu));
8598         print_field("ISO max packet: %d", rsp->iso_max_pkt);
8599 }
8600
8601 static void le_read_iso_tx_sync_cmd(uint16_t index, const void *data,
8602                                                         uint8_t size)
8603 {
8604         const struct bt_hci_cmd_le_read_iso_tx_sync *cmd = data;
8605
8606         print_field("Handle: %d", le16_to_cpu(cmd->handle));
8607 }
8608
8609 static void le_read_iso_tx_sync_rsp(uint16_t index, const void *data,
8610                                                         uint8_t size)
8611 {
8612         const struct bt_hci_rsp_le_read_iso_tx_sync *rsp = data;
8613         uint32_t offset = 0;
8614
8615         print_status(rsp->status);
8616
8617         if (size == 1)
8618                 return;
8619
8620         print_field("Handle: %d", le16_to_cpu(rsp->handle));
8621         print_field("Sequence Number: %d", le16_to_cpu(rsp->seq));
8622         print_field("Timestamp: %d", le32_to_cpu(rsp->timestamp));
8623
8624         memcpy(&offset, rsp->offset, sizeof(rsp->offset));
8625
8626         print_field("Offset: %d", le32_to_cpu(offset));
8627 }
8628
8629 static void print_cis_params(const void *data, int i)
8630 {
8631         const struct bt_hci_cis_params *cis = data;
8632
8633         print_field("CIS ID: 0x%2.2x", cis->cis_id);
8634         print_field("Central to Peripheral Maximum SDU Size: %u",
8635                                                 le16_to_cpu(cis->c_sdu));
8636         print_field("Peripheral to Central Maximum SDU Size: %u",
8637                                                 le16_to_cpu(cis->p_sdu));
8638         print_le_phy("Central to Peripheral PHY", cis->c_phy);
8639         print_le_phy("Peripheral to Central PHY", cis->p_phy);
8640         print_field("Central to Peripheral Retransmission attempts: 0x%2.2x",
8641                                                         cis->c_rtn);
8642         print_field("Peripheral to Central Retransmission attempts: 0x%2.2x",
8643                                                         cis->p_rtn);
8644 }
8645
8646 static void le_set_cig_params_cmd(uint16_t index, const void *data,
8647                                                         uint8_t size)
8648 {
8649         const struct bt_hci_cmd_le_set_cig_params *cmd = data;
8650
8651         print_field("CIG ID: 0x%2.2x", cmd->cig_id);
8652         print_usec_interval("Central to Peripheral SDU Interval",
8653                                                         cmd->c_interval);
8654         print_usec_interval("Peripheral to Central SDU Interval",
8655                                                         cmd->p_interval);
8656         print_sca(cmd->sca);
8657         print_packing(cmd->packing);
8658         print_framing(cmd->framing);
8659         print_field("Central to Peripheral Maximum Latency: %d ms (0x%4.4x)",
8660                 le16_to_cpu(cmd->c_latency), le16_to_cpu(cmd->c_latency));
8661         print_field("Peripheral to Central Maximum Latency: %d ms (0x%4.4x)",
8662                 le16_to_cpu(cmd->p_latency), le16_to_cpu(cmd->p_latency));
8663         print_field("Number of CIS: %u", cmd->num_cis);
8664
8665         size -= sizeof(*cmd);
8666
8667         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis),
8668                                                 print_cis_params);
8669 }
8670
8671 static void print_cis_params_test(const void *data, int i)
8672 {
8673         const struct bt_hci_cis_params_test *cis = data;
8674
8675         print_field("CIS ID: 0x%2.2x", cis->cis_id);
8676         print_field("NSE: 0x%2.2x", cis->nse);
8677         print_field("Central to Peripheral Maximum SDU: 0x%4.4x",
8678                                                 le16_to_cpu(cis->c_sdu));
8679         print_field("Peripheral to Central Maximum SDU: 0x%4.4x",
8680                                                 le16_to_cpu(cis->p_sdu));
8681         print_field("Central to Peripheral Maximum PDU: 0x%4.4x",
8682                                                 le16_to_cpu(cis->c_pdu));
8683         print_field("Peripheral to Central Maximum PDU: 0x%4.4x",
8684                                                 le16_to_cpu(cis->p_pdu));
8685         print_le_phy("Central to Peripheral PHY", cis->c_phy);
8686         print_le_phy("Peripheral to Central PHY", cis->p_phy);
8687         print_field("Central to Peripheral Burst Number: 0x%2.2x", cis->c_bn);
8688         print_field("Peripheral to Central Burst Number: 0x%2.2x", cis->p_bn);
8689 }
8690
8691 static void le_set_cig_params_test_cmd(uint16_t index, const void *data,
8692                                                         uint8_t size)
8693 {
8694         const struct bt_hci_cmd_le_set_cig_params_test *cmd = data;
8695
8696         print_field("CIG ID: 0x%2.2x", cmd->cig_id);
8697         print_usec_interval("Central to Peripheral SDU Interval",
8698                                                         cmd->c_interval);
8699         print_usec_interval("Peripheral to Central SDU Interval",
8700                                                         cmd->p_interval);
8701         print_field("Central to Peripheral Flush Timeout: 0x%2.2x", cmd->c_ft);
8702         print_field("Peripheral to Central Flush Timeout: 0x%2.2x", cmd->p_ft);
8703         print_field("ISO Interval: %.2f ms (0x%4.4x)",
8704                                 le16_to_cpu(cmd->iso_interval) * 1.25,
8705                                 le16_to_cpu(cmd->iso_interval));
8706         print_sca(cmd->sca);
8707         print_packing(cmd->packing);
8708         print_framing(cmd->framing);
8709         print_field("Number of CIS: %u", cmd->num_cis);
8710
8711         size -= sizeof(*cmd);
8712
8713         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis),
8714                                                 print_cis_params_test);
8715 }
8716
8717 static void print_cig_handle(const void *data, int i)
8718 {
8719         uint16_t handle = get_le16(data);
8720
8721         print_field("Connection Handle #%d: %d", i, handle);
8722 }
8723
8724 static void le_set_cig_params_rsp(uint16_t index, const void *data,
8725                                                         uint8_t size)
8726 {
8727         const struct bt_hci_rsp_le_set_cig_params *rsp = data;
8728
8729         print_status(rsp->status);
8730
8731         if (size == 1)
8732                 return;
8733
8734         print_field("CIG ID: 0x%2.2x", rsp->cig_id);
8735         print_field("Number of Handles: %u", rsp->num_handles);
8736
8737         size -= sizeof(*rsp);
8738
8739         print_list(rsp->handle, size, rsp->num_handles, sizeof(*rsp->handle),
8740                                                 print_cig_handle);
8741 }
8742
8743 static void print_cis(const void *data, int i)
8744 {
8745         const struct bt_hci_cis *cis = data;
8746         struct packet_conn_data *conn;
8747
8748         print_field("CIS Handle: %d", cis->cis_handle);
8749         print_field("ACL Handle: %d", cis->acl_handle);
8750
8751         conn = packet_get_conn_data(cis->acl_handle);
8752         if (conn)
8753                 conn->link = cis->cis_handle;
8754 }
8755
8756 static void le_create_cis_cmd(uint16_t index, const void *data, uint8_t size)
8757 {
8758         const struct bt_hci_cmd_le_create_cis *cmd = data;
8759
8760         print_field("Number of CIS: %u", cmd->num_cis);
8761
8762         size -= sizeof(*cmd);
8763
8764         print_list(cmd->cis, size, cmd->num_cis, sizeof(*cmd->cis), print_cis);
8765 }
8766
8767 static void le_remove_cig_cmd(uint16_t index, const void *data, uint8_t size)
8768 {
8769         const struct bt_hci_cmd_le_remove_cig *cmd = data;
8770
8771         print_field("CIG ID: 0x%02x", cmd->cig_id);
8772 }
8773
8774 static void le_remove_cig_rsp(uint16_t index, const void *data, uint8_t size)
8775 {
8776         const struct bt_hci_rsp_le_remove_cig *rsp = data;
8777
8778         print_status(rsp->status);
8779
8780         if (size == 1)
8781                 return;
8782
8783         print_field("CIG ID: 0x%2.2x", rsp->cig_id);
8784 }
8785
8786 static void le_accept_cis_req_cmd(uint16_t index, const void *data,
8787                                                         uint8_t size)
8788 {
8789         const struct bt_hci_cmd_le_accept_cis *cmd = data;
8790
8791         print_field("CIS Handle: %d", le16_to_cpu(cmd->handle));
8792 }
8793
8794 static void le_reject_cis_req_cmd(uint16_t index, const void *data,
8795                                                         uint8_t size)
8796 {
8797         const struct bt_hci_cmd_le_reject_cis *cmd = data;
8798
8799         print_field("CIS Handle: %d", le16_to_cpu(cmd->handle));
8800         print_reason(cmd->reason);
8801 }
8802
8803 static void print_bis(const struct bt_hci_bis *bis)
8804 {
8805         print_usec_interval("SDU Interval", bis->sdu_interval);
8806         print_field("Maximum SDU size: %u", le16_to_cpu(bis->sdu));
8807         print_field("Maximum Latency: %u ms (0x%4.4x)",
8808                         le16_to_cpu(bis->latency), le16_to_cpu(bis->latency));
8809         print_field("RTN: 0x%2.2x", bis->rtn);
8810         print_le_phy("PHY", bis->phy);
8811         print_packing(bis->packing);
8812         print_framing(bis->framing);
8813         print_field("Encryption: 0x%2.2x", bis->encryption);
8814         print_hex_field("Broadcast Code", bis->bcode, 16);
8815 }
8816
8817 static void le_create_big_cmd(uint16_t index, const void *data, uint8_t size)
8818 {
8819         const struct bt_hci_cmd_le_create_big *cmd = data;
8820
8821         print_field("Handle: 0x%2.2x", cmd->handle);
8822         print_field("Advertising Handle: 0x%2.2x", cmd->adv_handle);
8823         print_field("Number of BIS: %u", cmd->num_bis);
8824         print_bis(&cmd->bis);
8825 }
8826
8827 static void print_bis_test(const void *data, int i)
8828 {
8829         const struct bt_hci_bis_test *bis = data;
8830
8831         print_usec_interval("SDU Interval", bis->sdu_interval);
8832         print_field("ISO Interval: %.2f ms (0x%4.4x)",
8833                                 le16_to_cpu(bis->iso_interval) * 1.25,
8834                         le16_to_cpu(bis->iso_interval));
8835         print_field("Number of Subevents: %u", bis->nse);
8836         print_field("Maximum SDU: %u", bis->sdu);
8837         print_field("Maximum PDU: %u", bis->pdu);
8838         print_packing(bis->packing);
8839         print_framing(bis->framing);
8840         print_le_phy("PHY", bis->phy);
8841         print_field("Burst Number: %u", bis->bn);
8842         print_field("Immediate Repetition Count: %u", bis->irc);
8843         print_field("Pre Transmission Offset: 0x%2.2x", bis->pto);
8844         print_field("Encryption: 0x%2.2x", bis->encryption);
8845         print_hex_field("Broadcast Code", bis->bcode, 16);
8846 }
8847
8848 static void le_create_big_cmd_test_cmd(uint16_t index, const void *data,
8849                                                         uint8_t size)
8850 {
8851         const struct bt_hci_cmd_le_create_big_test *cmd = data;
8852
8853         print_field("BIG Handle: 0x%2.2x", cmd->big_handle);
8854         print_field("Advertising Handle: 0x%2.2x", cmd->adv_handle);
8855         print_field("Number of BIS: %u", cmd->num_bis);
8856
8857         size -= sizeof(*cmd);
8858
8859         print_list(cmd->bis, size, cmd->num_bis, sizeof(*cmd->bis),
8860                                                 print_bis_test);
8861 }
8862
8863 static void le_terminate_big_cmd(uint16_t index, const void *data, uint8_t size)
8864 {
8865         const struct bt_hci_cmd_le_term_big *cmd = data;
8866
8867         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8868         print_reason(cmd->reason);
8869 }
8870
8871 static void print_bis_sync(const void *data, int i)
8872 {
8873         const uint8_t *bis_id = data;
8874
8875         print_field("BIS ID: 0x%2.2x", *bis_id);
8876 }
8877
8878 static void le_big_create_sync_cmd(uint16_t index, const void *data,
8879                                                         uint8_t size)
8880 {
8881         const struct bt_hci_cmd_le_big_create_sync *cmd = data;
8882
8883         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8884         print_field("BIG Sync Handle: 0x%4.4x", le16_to_cpu(cmd->sync_handle));
8885         print_field("Encryption: %s (0x%2.2x)",
8886                         cmd->encryption ? "Encrypted" : "Unencrypted",
8887                         cmd->encryption);
8888         print_hex_field("Broadcast Code", cmd->bcode, 16);
8889         print_field("Maximum Number Subevents: 0x%2.2x", cmd->mse);
8890         print_field("Timeout: %d ms (0x%4.4x)", le16_to_cpu(cmd->timeout) * 10,
8891                                         le16_to_cpu(cmd->timeout));
8892         print_field("Number of BIS: %u", cmd->num_bis);
8893
8894         size -= sizeof(*cmd);
8895
8896         print_list(cmd->bis, size, cmd->num_bis, sizeof(*cmd->bis),
8897                                                 print_bis_sync);
8898 }
8899
8900 static void le_big_term_sync_cmd(uint16_t index, const void *data, uint8_t size)
8901 {
8902         const struct bt_hci_cmd_le_big_term_sync *cmd = data;
8903
8904         print_field("BIG Handle: 0x%2.2x", cmd->handle);
8905 }
8906
8907 static void print_iso_path(const char *prefix, uint8_t path)
8908 {
8909         switch (path) {
8910         case 0x00:
8911                 print_field("%s: HCI (0x%2.2x)", prefix, path);
8912                 return;
8913         case 0xff:
8914                 print_field("%s: Disabled (0x%2.2x)", prefix, path);
8915                 return;
8916         default:
8917                 print_field("%s: Logical Channel Number %u", prefix, path);
8918         }
8919 }
8920
8921 static void le_setup_iso_path_cmd(uint16_t index, const void *data,
8922                                                         uint8_t size)
8923 {
8924         const struct bt_hci_cmd_le_setup_iso_path *cmd = data;
8925
8926         print_field("Handle: %d", le16_to_cpu(cmd->handle));
8927         print_path_direction("Data Path Direction", cmd->direction);
8928         print_iso_path("Data Path", cmd->path);
8929         print_codec_id("Coding Format", cmd->codec);
8930         packet_print_company("Company Codec ID", le16_to_cpu(cmd->codec_cid));
8931         print_field("Vendor Codec ID: %d", le16_to_cpu(cmd->codec_vid));
8932         print_usec_interval("Controller Delay", cmd->delay);
8933         print_field("Codec Configuration Length: %d", cmd->codec_cfg_len);
8934         print_hex_field("Codec Configuration", cmd->codec_cfg,
8935                                                 cmd->codec_cfg_len);
8936 }
8937
8938 static void le_setup_iso_path_rsp(uint16_t index, const void *data,
8939                                                         uint8_t size)
8940 {
8941         const struct bt_hci_rsp_le_setup_iso_path *rsp = data;
8942
8943         print_status(rsp->status);
8944
8945         if (size == 1)
8946                 return;
8947
8948         print_field("Handle: %d", le16_to_cpu(rsp->handle));
8949 }
8950
8951 static void le_remove_iso_path_cmd(uint16_t index, const void *data,
8952                                                         uint8_t size)
8953 {
8954         const struct bt_hci_cmd_le_remove_iso_path *cmd = data;
8955
8956         print_field("Connection Handle: %d", le16_to_cpu(cmd->handle));
8957         print_path_direction("Data Path Direction", cmd->direction);
8958 }
8959
8960 static void le_req_peer_sca_cmd(uint16_t index, const void *data, uint8_t size)
8961 {
8962         const struct bt_hci_cmd_le_req_peer_sca *cmd = data;
8963
8964         print_field("Connection Handle: %d", le16_to_cpu(cmd->handle));
8965 }
8966
8967 static void le_set_host_feature_cmd(uint16_t index, const void *data,
8968                                                         uint8_t size)
8969 {
8970         const struct bt_hci_cmd_le_set_host_feature *cmd = data;
8971         uint64_t mask;
8972
8973         print_field("Bit Number: %u", cmd->bit_number);
8974
8975         mask = print_bitfield(2, (((uint64_t) 1) << cmd->bit_number),
8976                                                         features_le);
8977         if (mask)
8978                 print_text(COLOR_UNKNOWN_FEATURE_BIT, "  Unknown features "
8979                                                 "(0x%16.16" PRIx64 ")", mask);
8980
8981         print_field("Bit Value: %u", cmd->bit_value);
8982 }
8983
8984 static void le_read_iso_link_quality_cmd(uint16_t index, const void *data,
8985                                                         uint8_t size)
8986 {
8987         const struct bt_hci_cmd_le_read_iso_link_quality *cmd = data;
8988
8989         print_field("Handle: %d", le16_to_cpu(cmd->handle));
8990 }
8991
8992 static void status_le_read_iso_link_quality_rsp(uint16_t index,
8993                                                         const void *data,
8994                                                         uint8_t size)
8995 {
8996         const struct bt_hci_rsp_le_read_iso_link_quality *rsp = data;
8997
8998         print_status(rsp->status);
8999
9000         if (size == 1)
9001                 return;
9002
9003         print_field("Handle: %d", le16_to_cpu(rsp->handle));
9004         print_field("TX unacked packets %d", rsp->tx_unacked_packets);
9005         print_field("TX flushed packets %d", rsp->tx_flushed_packets);
9006         print_field("TX last subevent packets %d",
9007                                         rsp->tx_last_subevent_packets);
9008         print_field("TX retransmitted packets %d",
9009                                                 rsp->retransmitted_packets);
9010         print_field("TX crc error packets %d", rsp->crc_error_packets);
9011         print_field("RX unreceived packets %d", rsp->rx_unreceived_packets);
9012         print_field("Duplicated packets %d", rsp->duplicated_packets);
9013 }
9014
9015 struct opcode_data {
9016         uint16_t opcode;
9017         int bit;
9018         const char *str;
9019         void (*cmd_func) (uint16_t index, const void *data, uint8_t size);
9020         uint8_t cmd_size;
9021         bool cmd_fixed;
9022         void (*rsp_func) (uint16_t index, const void *data, uint8_t size);
9023         uint8_t rsp_size;
9024         bool rsp_fixed;
9025 };
9026
9027 static const struct opcode_data opcode_table[] = {
9028         { 0x0000,  -1, "NOP" },
9029
9030         /* OGF 1 - Link Control */
9031         { 0x0401,   0, "Inquiry",
9032                                 inquiry_cmd, 5, true },
9033         { 0x0402,   1, "Inquiry Cancel",
9034                                 null_cmd, 0, true,
9035                                 status_rsp, 1, true },
9036         { 0x0403,   2, "Periodic Inquiry Mode",
9037                                 periodic_inquiry_cmd, 9, true,
9038                                 status_rsp, 1, true },
9039         { 0x0404,   3, "Exit Periodic Inquiry Mode",
9040                                 null_cmd, 0, true,
9041                                 status_rsp, 1, true },
9042         { 0x0405,   4, "Create Connection",
9043                                 create_conn_cmd, 13, true },
9044         { 0x0406,   5, "Disconnect",
9045                                 disconnect_cmd, 3, true },
9046         { 0x0407,   6, "Add SCO Connection",
9047                                 add_sco_conn_cmd, 4, true },
9048         { 0x0408,   7, "Create Connection Cancel",
9049                                 create_conn_cancel_cmd, 6, true,
9050                                 status_bdaddr_rsp, 7, true },
9051         { 0x0409,   8, "Accept Connection Request",
9052                                 accept_conn_request_cmd, 7, true },
9053         { 0x040a,   9, "Reject Connection Request",
9054                                 reject_conn_request_cmd, 7, true },
9055         { 0x040b,  10, "Link Key Request Reply",
9056                                 link_key_request_reply_cmd, 22, true,
9057                                 status_bdaddr_rsp, 7, true },
9058         { 0x040c,  11, "Link Key Request Negative Reply",
9059                                 link_key_request_neg_reply_cmd, 6, true,
9060                                 status_bdaddr_rsp, 7, true },
9061         { 0x040d,  12, "PIN Code Request Reply",
9062                                 pin_code_request_reply_cmd, 23, true,
9063                                 status_bdaddr_rsp, 7, true },
9064         { 0x040e,  13, "PIN Code Request Negative Reply",
9065                                 pin_code_request_neg_reply_cmd, 6, true,
9066                                 status_bdaddr_rsp, 7, true },
9067         { 0x040f,  14, "Change Connection Packet Type",
9068                                 change_conn_pkt_type_cmd, 4, true },
9069         { 0x0411,  15, "Authentication Requested",
9070                                 auth_requested_cmd, 2, true },
9071         { 0x0413,  16, "Set Connection Encryption",
9072                                 set_conn_encrypt_cmd, 3, true },
9073         { 0x0415,  17, "Change Connection Link Key",
9074                                 change_conn_link_key_cmd, 2, true },
9075         { 0x0417,  18, "Temporary Link Key",
9076                                 link_key_selection_cmd, 1, true },
9077         { 0x0419,  19, "Remote Name Request",
9078                                 remote_name_request_cmd, 10, true },
9079         { 0x041a,  20, "Remote Name Request Cancel",
9080                                 remote_name_request_cancel_cmd, 6, true,
9081                                 status_bdaddr_rsp, 7, true },
9082         { 0x041b,  21, "Read Remote Supported Features",
9083                                 read_remote_features_cmd, 2, true },
9084         { 0x041c,  22, "Read Remote Extended Features",
9085                                 read_remote_ext_features_cmd, 3, true },
9086         { 0x041d,  23, "Read Remote Version Information",
9087                                 read_remote_version_cmd, 2, true },
9088         { 0x041f,  24, "Read Clock Offset",
9089                                 read_clock_offset_cmd, 2, true },
9090         { 0x0420,  25, "Read LMP Handle",
9091                                 read_lmp_handle_cmd, 2, true,
9092                                 read_lmp_handle_rsp, 8, true },
9093         { 0x0428, 131, "Setup Synchronous Connection",
9094                                 setup_sync_conn_cmd, 17, true },
9095         { 0x0429, 132, "Accept Synchronous Connection Request",
9096                                 accept_sync_conn_request_cmd, 21, true },
9097         { 0x042a, 133, "Reject Synchronous Connection Request",
9098                                 reject_sync_conn_request_cmd, 7, true },
9099         { 0x042b, 151, "IO Capability Request Reply",
9100                                 io_capability_request_reply_cmd, 9, true,
9101                                 status_bdaddr_rsp, 7, true },
9102         { 0x042c, 152, "User Confirmation Request Reply",
9103                                 user_confirm_request_reply_cmd, 6, true,
9104                                 status_bdaddr_rsp, 7, true },
9105         { 0x042d, 153, "User Confirmation Request Neg Reply",
9106                                 user_confirm_request_neg_reply_cmd, 6, true,
9107                                 status_bdaddr_rsp, 7, true },
9108         { 0x042e, 154, "User Passkey Request Reply",
9109                                 user_passkey_request_reply_cmd, 10, true,
9110                                 status_bdaddr_rsp, 7, true },
9111         { 0x042f, 155, "User Passkey Request Negative Reply",
9112                                 user_passkey_request_neg_reply_cmd, 6, true,
9113                                 status_bdaddr_rsp, 7, true },
9114         { 0x0430, 156, "Remote OOB Data Request Reply",
9115                                 remote_oob_data_request_reply_cmd, 38, true,
9116                                 status_bdaddr_rsp, 7, true },
9117         { 0x0433, 159, "Remote OOB Data Request Neg Reply",
9118                                 remote_oob_data_request_neg_reply_cmd, 6, true,
9119                                 status_bdaddr_rsp, 7, true },
9120         { 0x0434, 163, "IO Capability Request Negative Reply",
9121                                 io_capability_request_neg_reply_cmd, 7, true,
9122                                 status_bdaddr_rsp, 7, true },
9123         { 0x0435, 168, "Create Physical Link",
9124                                 create_phy_link_cmd, 3, false },
9125         { 0x0436, 169, "Accept Physical Link",
9126                                 accept_phy_link_cmd, 3, false },
9127         { 0x0437, 170, "Disconnect Physical Link",
9128                                 disconn_phy_link_cmd, 2, true },
9129         { 0x0438, 171, "Create Logical Link",
9130                                 create_logic_link_cmd, 33, true },
9131         { 0x0439, 172, "Accept Logical Link",
9132                                 accept_logic_link_cmd, 33, true },
9133         { 0x043a, 173, "Disconnect Logical Link",
9134                                 disconn_logic_link_cmd, 2, true },
9135         { 0x043b, 174, "Logical Link Cancel",
9136                                 logic_link_cancel_cmd, 2, true,
9137                                 logic_link_cancel_rsp, 3, true },
9138         { 0x043c, 175, "Flow Specifcation Modify",
9139                                 flow_spec_modify_cmd, 34, true },
9140         { 0x043d, 235, "Enhanced Setup Synchronous Connection",
9141                                 enhanced_setup_sync_conn_cmd, 59, true },
9142         { 0x043e, 236, "Enhanced Accept Synchronous Connection Request",
9143                                 enhanced_accept_sync_conn_request_cmd, 63, true },
9144         { 0x043f, 246, "Truncated Page",
9145                                 truncated_page_cmd, 9, true },
9146         { 0x0440, 247, "Truncated Page Cancel",
9147                                 truncated_page_cancel_cmd, 6, true,
9148                                 status_bdaddr_rsp, 7, true },
9149         { 0x0441, 248, "Set Connectionless Peripheral Broadcast",
9150                                 set_peripheral_broadcast_cmd, 11, true,
9151                                 set_peripheral_broadcast_rsp, 4, true },
9152         { 0x0442, 249, "Set Connectionless Peripheral Broadcast Receive",
9153                                 set_peripheral_broadcast_receive_cmd, 34, true,
9154                                 set_peripheral_broadcast_receive_rsp, 8, true },
9155         { 0x0443, 250, "Start Synchronization Train",
9156                                 null_cmd, 0, true },
9157         { 0x0444, 251, "Receive Synchronization Train",
9158                                 receive_sync_train_cmd, 12, true },
9159         { 0x0445, 257, "Remote OOB Extended Data Request Reply",
9160                                 remote_oob_ext_data_request_reply_cmd, 70, true,
9161                                 status_bdaddr_rsp, 7, true },
9162
9163         /* OGF 2 - Link Policy */
9164         { 0x0801,  33, "Hold Mode",
9165                                 hold_mode_cmd, 6, true },
9166         { 0x0803,  34, "Sniff Mode",
9167                                 sniff_mode_cmd, 10, true },
9168         { 0x0804,  35, "Exit Sniff Mode",
9169                                 exit_sniff_mode_cmd, 2, true },
9170         { 0x0805,  36, "Park State",
9171                                 park_state_cmd, 6, true },
9172         { 0x0806,  37, "Exit Park State",
9173                                 exit_park_state_cmd, 2, true },
9174         { 0x0807,  38, "QoS Setup",
9175                                 qos_setup_cmd, 20, true },
9176         { 0x0809,  39, "Role Discovery",
9177                                 role_discovery_cmd, 2, true,
9178                                 role_discovery_rsp, 4, true },
9179         { 0x080b,  40, "Switch Role",
9180                                 switch_role_cmd, 7, true },
9181         { 0x080c,  41, "Read Link Policy Settings",
9182                                 read_link_policy_cmd, 2, true,
9183                                 read_link_policy_rsp, 5, true },
9184         { 0x080d,  42, "Write Link Policy Settings",
9185                                 write_link_policy_cmd, 4, true,
9186                                 write_link_policy_rsp, 3, true },
9187         { 0x080e,  43, "Read Default Link Policy Settings",
9188                                 null_cmd, 0, true,
9189                                 read_default_link_policy_rsp, 3, true },
9190         { 0x080f,  44, "Write Default Link Policy Settings",
9191                                 write_default_link_policy_cmd, 2, true,
9192                                 status_rsp, 1, true },
9193         { 0x0810,  45, "Flow Specification",
9194                                 flow_spec_cmd, 21, true },
9195         { 0x0811, 140, "Sniff Subrating",
9196                                 sniff_subrating_cmd, 8, true,
9197                                 sniff_subrating_rsp, 3, true },
9198
9199         /* OGF 3 - Host Control */
9200         { 0x0c01,  46, "Set Event Mask",
9201                                 set_event_mask_cmd, 8, true,
9202                                 status_rsp, 1, true },
9203         { 0x0c03,  47, "Reset",
9204                                 null_cmd, 0, true,
9205                                 status_rsp, 1, true },
9206         { 0x0c05,  48, "Set Event Filter",
9207                                 set_event_filter_cmd, 1, false,
9208                                 status_rsp, 1, true },
9209         { 0x0c08,  49, "Flush",
9210                                 flush_cmd, 2, true,
9211                                 flush_rsp, 3, true },
9212         { 0x0c09,  50, "Read PIN Type",
9213                                 null_cmd, 0, true,
9214                                 read_pin_type_rsp, 2, true },
9215         { 0x0c0a,  51, "Write PIN Type",
9216                                 write_pin_type_cmd, 1, true,
9217                                 status_rsp, 1, true },
9218         { 0x0c0b,  52, "Create New Unit Key",
9219                                 null_cmd, 0, true,
9220                                 status_rsp, 1, true },
9221         { 0x0c0d,  53, "Read Stored Link Key",
9222                                 read_stored_link_key_cmd, 7, true,
9223                                 read_stored_link_key_rsp, 5, true },
9224         { 0x0c11,  54, "Write Stored Link Key",
9225                                 write_stored_link_key_cmd, 1, false,
9226                                 write_stored_link_key_rsp, 2, true },
9227         { 0x0c12,  55, "Delete Stored Link Key",
9228                                 delete_stored_link_key_cmd, 7, true,
9229                                 delete_stored_link_key_rsp, 3, true },
9230         { 0x0c13,  56, "Write Local Name",
9231                                 write_local_name_cmd, 248, true,
9232                                 status_rsp, 1, true },
9233         { 0x0c14,  57, "Read Local Name",
9234                                 null_cmd, 0, true,
9235                                 read_local_name_rsp, 249, true },
9236         { 0x0c15,  58, "Read Connection Accept Timeout",
9237                                 null_cmd, 0, true,
9238                                 read_conn_accept_timeout_rsp, 3, true },
9239         { 0x0c16,  59, "Write Connection Accept Timeout",
9240                                 write_conn_accept_timeout_cmd, 2, true,
9241                                 status_rsp, 1, true },
9242         { 0x0c17,  60, "Read Page Timeout",
9243                                 null_cmd, 0, true,
9244                                 read_page_timeout_rsp, 3, true },
9245         { 0x0c18,  61, "Write Page Timeout",
9246                                 write_page_timeout_cmd, 2, true,
9247                                 status_rsp, 1, true },
9248         { 0x0c19,  62, "Read Scan Enable",
9249                                 null_cmd, 0, true,
9250                                 read_scan_enable_rsp, 2, true },
9251         { 0x0c1a,  63, "Write Scan Enable",
9252                                 write_scan_enable_cmd, 1, true,
9253                                 status_rsp, 1, true },
9254         { 0x0c1b,  64, "Read Page Scan Activity",
9255                                 null_cmd, 0, true,
9256                                 read_page_scan_activity_rsp, 5, true },
9257         { 0x0c1c,  65, "Write Page Scan Activity",
9258                                 write_page_scan_activity_cmd, 4, true,
9259                                 status_rsp, 1, true },
9260         { 0x0c1d,  66, "Read Inquiry Scan Activity",
9261                                 null_cmd, 0, true,
9262                                 read_inquiry_scan_activity_rsp, 5, true },
9263         { 0x0c1e,  67, "Write Inquiry Scan Activity",
9264                                 write_inquiry_scan_activity_cmd, 4, true,
9265                                 status_rsp, 1, true },
9266         { 0x0c1f,  68, "Read Authentication Enable",
9267                                 null_cmd, 0, true,
9268                                 read_auth_enable_rsp, 2, true },
9269         { 0x0c20,  69, "Write Authentication Enable",
9270                                 write_auth_enable_cmd, 1, true,
9271                                 status_rsp, 1, true },
9272         { 0x0c21,  70, "Read Encryption Mode",
9273                                 null_cmd, 0, true,
9274                                 read_encrypt_mode_rsp, 2, true },
9275         { 0x0c22,  71, "Write Encryption Mode",
9276                                 write_encrypt_mode_cmd, 1, true,
9277                                 status_rsp, 1, true },
9278         { 0x0c23,  72, "Read Class of Device",
9279                                 null_cmd, 0, true,
9280                                 read_class_of_dev_rsp, 4, true },
9281         { 0x0c24,  73, "Write Class of Device",
9282                                 write_class_of_dev_cmd, 3, true,
9283                                 status_rsp, 1, true },
9284         { 0x0c25,  74, "Read Voice Setting",
9285                                 null_cmd, 0, true,
9286                                 read_voice_setting_rsp, 3, true },
9287         { 0x0c26,  75, "Write Voice Setting",
9288                                 write_voice_setting_cmd, 2, true,
9289                                 status_rsp, 1, true },
9290         { 0x0c27,  76, "Read Automatic Flush Timeout",
9291                                 read_auto_flush_timeout_cmd, 2, true,
9292                                 read_auto_flush_timeout_rsp, 5, true },
9293         { 0x0c28,  77, "Write Automatic Flush Timeout",
9294                                 write_auto_flush_timeout_cmd, 4, true,
9295                                 write_auto_flush_timeout_rsp, 3, true },
9296         { 0x0c29,  78, "Read Num Broadcast Retransmissions",
9297                                 null_cmd, 0, true,
9298                                 read_num_broadcast_retrans_rsp, 2, true },
9299         { 0x0c2a,  79, "Write Num Broadcast Retransmissions",
9300                                 write_num_broadcast_retrans_cmd, 1, true,
9301                                 status_rsp, 1, true },
9302         { 0x0c2b,  80, "Read Hold Mode Activity",
9303                                 null_cmd, 0, true,
9304                                 read_hold_mode_activity_rsp, 2, true },
9305         { 0x0c2c,  81, "Write Hold Mode Activity",
9306                                 write_hold_mode_activity_cmd, 1, true,
9307                                 status_rsp, 1, true },
9308         { 0x0c2d,  82, "Read Transmit Power Level",
9309                                 read_tx_power_cmd, 3, true,
9310                                 read_tx_power_rsp, 4, true },
9311         { 0x0c2e,  83, "Read Sync Flow Control Enable",
9312                                 null_cmd, 0, true,
9313                                 read_sync_flow_control_rsp, 2, true },
9314         { 0x0c2f,  84, "Write Sync Flow Control Enable",
9315                                 write_sync_flow_control_cmd, 1, true,
9316                                 status_rsp, 1, true },
9317         { 0x0c31,  85, "Set Controller To Host Flow Control",
9318                                 set_host_flow_control_cmd, 1, true,
9319                                 status_rsp, 1, true },
9320         { 0x0c33,  86, "Host Buffer Size",
9321                                 host_buffer_size_cmd, 7, true,
9322                                 status_rsp, 1, true },
9323         { 0x0c35,  87, "Host Number of Completed Packets",
9324                                 host_num_completed_packets_cmd, 5, false },
9325         { 0x0c36,  88, "Read Link Supervision Timeout",
9326                                 read_link_supv_timeout_cmd, 2, true,
9327                                 read_link_supv_timeout_rsp, 5, true },
9328         { 0x0c37,  89, "Write Link Supervision Timeout",
9329                                 write_link_supv_timeout_cmd, 4, true,
9330                                 write_link_supv_timeout_rsp, 3, true },
9331         { 0x0c38,  90, "Read Number of Supported IAC",
9332                                 null_cmd, 0, true,
9333                                 read_num_supported_iac_rsp, 2, true },
9334         { 0x0c39,  91, "Read Current IAC LAP",
9335                                 null_cmd, 0, true,
9336                                 read_current_iac_lap_rsp, 2, false },
9337         { 0x0c3a,  92, "Write Current IAC LAP",
9338                                 write_current_iac_lap_cmd, 1, false,
9339                                 status_rsp, 1, true },
9340         { 0x0c3b,  93, "Read Page Scan Period Mode",
9341                                 null_cmd, 0, true,
9342                                 read_page_scan_period_mode_rsp, 2, true },
9343         { 0x0c3c,  94, "Write Page Scan Period Mode",
9344                                 write_page_scan_period_mode_cmd, 1, true,
9345                                 status_rsp, 1, true },
9346         { 0x0c3d,  95, "Read Page Scan Mode",
9347                                 null_cmd, 0, true,
9348                                 read_page_scan_mode_rsp, 2, true },
9349         { 0x0c3e,  96, "Write Page Scan Mode",
9350                                 write_page_scan_mode_cmd, 1, true,
9351                                 status_rsp, 1, true },
9352         { 0x0c3f,  97, "Set AFH Host Channel Classification",
9353                                 set_afh_host_classification_cmd, 10, true,
9354                                 status_rsp, 1, true },
9355         { 0x0c42, 100, "Read Inquiry Scan Type",
9356                                 null_cmd, 0, true,
9357                                 read_inquiry_scan_type_rsp, 2, true },
9358         { 0x0c43, 101, "Write Inquiry Scan Type",
9359                                 write_inquiry_scan_type_cmd, 1, true,
9360                                 status_rsp, 1, true },
9361         { 0x0c44, 102, "Read Inquiry Mode",
9362                                 null_cmd, 0, true,
9363                                 read_inquiry_mode_rsp, 2, true },
9364         { 0x0c45, 103, "Write Inquiry Mode",
9365                                 write_inquiry_mode_cmd, 1, true,
9366                                 status_rsp, 1, true },
9367         { 0x0c46, 104, "Read Page Scan Type",
9368                                 null_cmd, 0, true,
9369                                 read_page_scan_type_rsp, 2, true },
9370         { 0x0c47, 105, "Write Page Scan Type",
9371                                 write_page_scan_type_cmd, 1, true,
9372                                 status_rsp, 1, true },
9373         { 0x0c48, 106, "Read AFH Channel Assessment Mode",
9374                                 null_cmd, 0, true,
9375                                 read_afh_assessment_mode_rsp, 2, true },
9376         { 0x0c49, 107, "Write AFH Channel Assessment Mode",
9377                                 write_afh_assessment_mode_cmd, 1, true,
9378                                 status_rsp, 1, true },
9379         { 0x0c51, 136, "Read Extended Inquiry Response",
9380                                 null_cmd, 0, true,
9381                                 read_ext_inquiry_response_rsp, 242, true },
9382         { 0x0c52, 137, "Write Extended Inquiry Response",
9383                                 write_ext_inquiry_response_cmd, 241, true,
9384                                 status_rsp, 1, true },
9385         { 0x0c53, 138, "Refresh Encryption Key",
9386                                 refresh_encrypt_key_cmd, 2, true },
9387         { 0x0c55, 141, "Read Simple Pairing Mode",
9388                                 null_cmd, 0, true,
9389                                 read_simple_pairing_mode_rsp, 2, true },
9390         { 0x0c56, 142, "Write Simple Pairing Mode",
9391                                 write_simple_pairing_mode_cmd, 1, true,
9392                                 status_rsp, 1, true },
9393         { 0x0c57, 143, "Read Local OOB Data",
9394                                 null_cmd, 0, true,
9395                                 read_local_oob_data_rsp, 33, true },
9396         { 0x0c58, 144, "Read Inquiry Response TX Power Level",
9397                                 null_cmd, 0, true,
9398                                 read_inquiry_resp_tx_power_rsp, 2, true },
9399         { 0x0c59, 145, "Write Inquiry Transmit Power Level",
9400                                 write_inquiry_tx_power_cmd, 1, true,
9401                                 status_rsp, 1, true },
9402         { 0x0c5a, 146, "Read Default Erroneous Data Reporting",
9403                                 null_cmd, 0, true,
9404                                 read_erroneous_reporting_rsp, 2, true },
9405         { 0x0c5b, 147, "Write Default Erroneous Data Reporting",
9406                                 write_erroneous_reporting_cmd, 1, true,
9407                                 status_rsp, 1, true },
9408         { 0x0c5f, 158, "Enhanced Flush",
9409                                 enhanced_flush_cmd, 3, true },
9410         { 0x0c60, 162, "Send Keypress Notification",
9411                                 send_keypress_notify_cmd, 7, true,
9412                                 send_keypress_notify_rsp, 7, true },
9413         { 0x0c61, 176, "Read Logical Link Accept Timeout" },
9414         { 0x0c62, 177, "Write Logical Link Accept Timeout" },
9415         { 0x0c63, 178, "Set Event Mask Page 2",
9416                                 set_event_mask_page2_cmd, 8, true,
9417                                 status_rsp, 1, true },
9418         { 0x0c64, 179, "Read Location Data",
9419                                 null_cmd, 0, true,
9420                                 read_location_data_rsp, 6, true },
9421         { 0x0c65, 180, "Write Location Data",
9422                                 write_location_data_cmd, 5, true,
9423                                 status_rsp, 1, true },
9424         { 0x0c66, 184, "Read Flow Control Mode",
9425                                 null_cmd, 0, true,
9426                                 read_flow_control_mode_rsp, 2, true },
9427         { 0x0c67, 185, "Write Flow Control Mode",
9428                                 write_flow_control_mode_cmd, 1, true,
9429                                 status_rsp, 1, true },
9430         { 0x0c68, 192, "Read Enhanced Transmit Power Level",
9431                                 read_enhanced_tx_power_cmd, 3, true,
9432                                 read_enhanced_tx_power_rsp, 6, true },
9433         { 0x0c69, 194, "Read Best Effort Flush Timeout" },
9434         { 0x0c6a, 195, "Write Best Effort Flush Timeout" },
9435         { 0x0c6b, 196, "Short Range Mode",
9436                                 short_range_mode_cmd, 2, true },
9437         { 0x0c6c, 197, "Read LE Host Supported",
9438                                 null_cmd, 0, true,
9439                                 read_le_host_supported_rsp, 3, true },
9440         { 0x0c6d, 198, "Write LE Host Supported",
9441                                 write_le_host_supported_cmd, 2, true,
9442                                 status_rsp, 1, true },
9443         { 0x0c6e, 238, "Set MWS Channel Parameters" },
9444         { 0x0c6f, 239, "Set External Frame Configuration" },
9445         { 0x0c70, 240, "Set MWS Signaling" },
9446         { 0x0c71, 241, "Set MWS Transport Layer" },
9447         { 0x0c72, 242, "Set MWS Scan Frequency Table" },
9448         { 0x0c73, 244, "Set MWS Pattern Configuration" },
9449         { 0x0c74, 252, "Set Reserved LT_ADDR",
9450                                 set_reserved_lt_addr_cmd, 1, true,
9451                                 set_reserved_lt_addr_rsp, 2, true },
9452         { 0x0c75, 253, "Delete Reserved LT_ADDR",
9453                                 delete_reserved_lt_addr_cmd, 1, true,
9454                                 delete_reserved_lt_addr_rsp, 2, true },
9455         { 0x0c76, 254, "Set Connectionless Peripheral Broadcast Data",
9456                                 set_peripheral_broadcast_data_cmd, 3, false,
9457                                 set_peripheral_broadcast_data_rsp, 2, true },
9458         { 0x0c77, 255, "Read Synchronization Train Parameters",
9459                                 null_cmd, 0, true,
9460                                 read_sync_train_params_rsp, 8, true },
9461         { 0x0c78, 256, "Write Synchronization Train Parameters",
9462                                 write_sync_train_params_cmd, 9, true,
9463                                 write_sync_train_params_rsp, 3, true },
9464         { 0x0c79, 258, "Read Secure Connections Host Support",
9465                                 null_cmd, 0, true,
9466                                 read_secure_conn_support_rsp, 2, true },
9467         { 0x0c7a, 259, "Write Secure Connections Host Support",
9468                                 write_secure_conn_support_cmd, 1, true,
9469                                 status_rsp, 1, true },
9470         { 0x0c7b, 260, "Read Authenticated Payload Timeout",
9471                                 read_auth_payload_timeout_cmd, 2, true,
9472                                 read_auth_payload_timeout_rsp, 5, true },
9473         { 0x0c7c, 261, "Write Authenticated Payload Timeout",
9474                                 write_auth_payload_timeout_cmd, 4, true,
9475                                 write_auth_payload_timeout_rsp, 3, true },
9476         { 0x0c7d, 262, "Read Local OOB Extended Data",
9477                                 null_cmd, 0, true,
9478                                 read_local_oob_ext_data_rsp, 65, true },
9479         { 0x0c7e, 264, "Read Extended Page Timeout",
9480                                 null_cmd, 0, true,
9481                                 read_ext_page_timeout_rsp, 3, true },
9482         { 0x0c7f, 265, "Write Extended Page Timeout",
9483                                 write_ext_page_timeout_cmd, 2, true,
9484                                 status_rsp, 1, true },
9485         { 0x0c80, 266, "Read Extended Inquiry Length",
9486                                 null_cmd, 0, true,
9487                                 read_ext_inquiry_length_rsp, 3, true },
9488         { 0x0c81, 267, "Write Extended Inquiry Length",
9489                                 write_ext_inquiry_length_cmd, 2, true,
9490                                 status_rsp, 1, true },
9491
9492         /* OGF 4 - Information Parameter */
9493         { 0x1001, 115, "Read Local Version Information",
9494                                 null_cmd, 0, true,
9495                                 read_local_version_rsp, 9, true },
9496         { 0x1002, 116, "Read Local Supported Commands",
9497                                 null_cmd, 0, true,
9498                                 read_local_commands_rsp, 65, true },
9499         { 0x1003, 117, "Read Local Supported Features",
9500                                 null_cmd, 0, true,
9501                                 read_local_features_rsp, 9, true },
9502         { 0x1004, 118, "Read Local Extended Features",
9503                                 read_local_ext_features_cmd, 1, true,
9504                                 read_local_ext_features_rsp, 11, true },
9505         { 0x1005, 119, "Read Buffer Size",
9506                                 null_cmd, 0, true,
9507                                 read_buffer_size_rsp, 8, true },
9508         { 0x1007, 120, "Read Country Code",
9509                                 null_cmd, 0, true,
9510                                 read_country_code_rsp, 2, true },
9511         { 0x1009, 121, "Read BD ADDR",
9512                                 null_cmd, 0, true,
9513                                 read_bd_addr_rsp, 7, true },
9514         { 0x100a, 186, "Read Data Block Size",
9515                                 null_cmd, 0, true,
9516                                 read_data_block_size_rsp, 7, true },
9517         { 0x100b, 237, "Read Local Supported Codecs",
9518                                 null_cmd, 0, true,
9519                                 read_local_codecs_rsp, 3, false },
9520         { 0x100c, 331, "Read Local Simple Pairing Options",
9521                                 null_cmd, 0, true,
9522                                 read_local_pairing_options_rsp, 3, true },
9523         { BT_HCI_CMD_READ_LOCAL_CODECS_V2, BT_HCI_BIT_READ_LOCAL_CODECS_V2,
9524                 "Read Local Supported Codecs V2",
9525                 null_cmd, 0, true,
9526                 read_local_codecs_rsp_v2,
9527                 sizeof(struct bt_hci_rsp_read_local_codecs_v2), false
9528         },
9529         { BT_HCI_CMD_READ_LOCAL_CODEC_CAPS, BT_HCI_BIT_READ_LOCAL_CODEC_CAPS,
9530                 "Read Local Supported Codec Capabilities",
9531                 read_local_codec_caps_cmd,
9532                 sizeof(struct bt_hci_cmd_read_local_codec_caps), true,
9533                 read_local_codec_caps_rsp,
9534                 sizeof(struct bt_hci_rsp_read_local_codec_caps), false
9535         },
9536         { BT_HCI_CMD_READ_LOCAL_CTRL_DELAY, BT_HCI_BIT_READ_LOCAL_CTRL_DELAY,
9537                 "Read Local Supported Controller Delay",
9538                 read_local_ctrl_delay_cmd,
9539                 sizeof(struct bt_hci_cmd_read_local_ctrl_delay), false,
9540                 read_local_ctrl_delay_rsp,
9541                 sizeof(struct bt_hci_rsp_read_local_ctrl_delay), true
9542         },
9543         { BT_HCI_CMD_CONFIG_DATA_PATH, BT_HCI_BIT_CONFIG_DATA_PATH,
9544                 "Configure Data Path",
9545                 config_data_path_cmd,
9546                 sizeof(struct bt_hci_cmd_config_data_path), false,
9547                 status_rsp, 1, true
9548         },
9549
9550         /* OGF 5 - Status Parameter */
9551         { 0x1401, 122, "Read Failed Contact Counter",
9552                                 read_failed_contact_counter_cmd, 2, true,
9553                                 read_failed_contact_counter_rsp, 5, true },
9554         { 0x1402, 123, "Reset Failed Contact Counter",
9555                                 reset_failed_contact_counter_cmd, 2, true,
9556                                 reset_failed_contact_counter_rsp, 3, true },
9557         { 0x1403, 124, "Read Link Quality",
9558                                 read_link_quality_cmd, 2, true,
9559                                 read_link_quality_rsp, 4, true },
9560         { 0x1405, 125, "Read RSSI",
9561                                 read_rssi_cmd, 2, true,
9562                                 read_rssi_rsp, 4, true },
9563         { 0x1406, 126, "Read AFH Channel Map",
9564                                 read_afh_channel_map_cmd, 2, true,
9565                                 read_afh_channel_map_rsp, 14, true },
9566         { 0x1407, 127, "Read Clock",
9567                                 read_clock_cmd, 3, true,
9568                                 read_clock_rsp, 9, true },
9569         { 0x1408, 164, "Read Encryption Key Size",
9570                                 read_encrypt_key_size_cmd, 2, true,
9571                                 read_encrypt_key_size_rsp, 4, true },
9572         { 0x1409, 181, "Read Local AMP Info",
9573                                 null_cmd, 0, true,
9574                                 read_local_amp_info_rsp, 31, true },
9575         { 0x140a, 182, "Read Local AMP ASSOC",
9576                                 read_local_amp_assoc_cmd, 5, true,
9577                                 read_local_amp_assoc_rsp, 5, false },
9578         { 0x140b, 183, "Write Remote AMP ASSOC",
9579                                 write_remote_amp_assoc_cmd, 6, false,
9580                                 write_remote_amp_assoc_rsp, 2, true },
9581         { 0x140c, 243, "Get MWS Transport Layer Configuration",
9582                                 null_cmd, 0, true,
9583                                 get_mws_transport_config_rsp, 2, false },
9584         { 0x140d, 245, "Set Triggered Clock Capture",
9585                                 set_triggered_clock_capture_cmd, 6, true,
9586                                 status_rsp, 1, true },
9587
9588         /* OGF 6 - Testing */
9589         { 0x1801, 128, "Read Loopback Mode",
9590                                 null_cmd, 0, true,
9591                                 read_loopback_mode_rsp, 2, true },
9592         { 0x1802, 129, "Write Loopback Mode",
9593                                 write_loopback_mode_cmd, 1, true,
9594                                 status_rsp, 1, true },
9595         { 0x1803, 130, "Enable Device Under Test Mode",
9596                                 null_cmd, 0, true,
9597                                 status_rsp, 1, true },
9598         { 0x1804, 157, "Write Simple Pairing Debug Mode",
9599                                 write_ssp_debug_mode_cmd, 1, true,
9600                                 status_rsp, 1, true },
9601         { 0x1807, 189, "Enable AMP Receiver Reports" },
9602         { 0x1808, 190, "AMP Test End" },
9603         { 0x1809, 191, "AMP Test" },
9604         { 0x180a, 263, "Write Secure Connections Test Mode" },
9605
9606         /* OGF 8 - LE Control */
9607         { 0x2001, 200, "LE Set Event Mask",
9608                                 le_set_event_mask_cmd, 8, true,
9609                                 status_rsp, 1, true },
9610         { 0x2002, 201, "LE Read Buffer Size",
9611                                 null_cmd, 0, true,
9612                                 le_read_buffer_size_rsp, 4, true },
9613         { 0x2003, 202, "LE Read Local Supported Features",
9614                                 null_cmd, 0, true,
9615                                 le_read_local_features_rsp, 9, true },
9616         { 0x2005, 204, "LE Set Random Address",
9617                                 le_set_random_address_cmd, 6, true,
9618                                 status_rsp, 1, true },
9619         { 0x2006, 205, "LE Set Advertising Parameters",
9620                                 le_set_adv_parameters_cmd, 15, true,
9621                                 status_rsp, 1, true },
9622         { 0x2007, 206, "LE Read Advertising Channel TX Power",
9623                                 null_cmd, 0, true,
9624                                 le_read_adv_tx_power_rsp, 2, true },
9625         { 0x2008, 207, "LE Set Advertising Data",
9626                                 le_set_adv_data_cmd, 32, true,
9627                                 status_rsp, 1, true },
9628         { 0x2009, 208, "LE Set Scan Response Data",
9629                                 le_set_scan_rsp_data_cmd, 32, true,
9630                                 status_rsp, 1, true },
9631         { 0x200a, 209, "LE Set Advertise Enable",
9632                                 le_set_adv_enable_cmd, 1, true,
9633                                 status_rsp, 1, true },
9634         { 0x200b, 210, "LE Set Scan Parameters",
9635                                 le_set_scan_parameters_cmd, 7, true,
9636                                 status_rsp, 1, true },
9637         { 0x200c, 211, "LE Set Scan Enable",
9638                                 le_set_scan_enable_cmd, 2, true,
9639                                 status_rsp, 1, true },
9640         { 0x200d, 212, "LE Create Connection",
9641                                 le_create_conn_cmd, 25, true },
9642         { 0x200e, 213, "LE Create Connection Cancel",
9643                                 null_cmd, 0, true,
9644                                 status_rsp, 1, true },
9645         { 0x200f, 214, "LE Read Accept List Size",
9646                                 null_cmd, 0, true,
9647                                 le_read_accept_list_size_rsp, 2, true },
9648         { 0x2010, 215, "LE Clear Accept List",
9649                                 null_cmd, 0, true,
9650                                 status_rsp, 1, true },
9651         { 0x2011, 216, "LE Add Device To Accept List",
9652                                 le_add_to_accept_list_cmd, 7, true,
9653                                 status_rsp, 1, true },
9654         { 0x2012, 217, "LE Remove Device From Accept List",
9655                                 le_remove_from_accept_list_cmd, 7, true,
9656                                 status_rsp, 1, true },
9657         { 0x2013, 218, "LE Connection Update",
9658                                 le_conn_update_cmd, 14, true },
9659         { 0x2014, 219, "LE Set Host Channel Classification",
9660                                 le_set_host_classification_cmd, 5, true,
9661                                 status_rsp, 1, true },
9662         { 0x2015, 220, "LE Read Channel Map",
9663                                 le_read_channel_map_cmd, 2, true,
9664                                 le_read_channel_map_rsp, 8, true },
9665         { 0x2016, 221, "LE Read Remote Used Features",
9666                                 le_read_remote_features_cmd, 2, true },
9667         { 0x2017, 222, "LE Encrypt",
9668                                 le_encrypt_cmd, 32, true,
9669                                 le_encrypt_rsp, 17, true },
9670         { 0x2018, 223, "LE Rand",
9671                                 null_cmd, 0, true,
9672                                 le_rand_rsp, 9, true },
9673         { 0x2019, 224, "LE Start Encryption",
9674                                 le_start_encrypt_cmd, 28, true },
9675         { 0x201a, 225, "LE Long Term Key Request Reply",
9676                                 le_ltk_req_reply_cmd, 18, true,
9677                                 le_ltk_req_reply_rsp, 3, true },
9678         { 0x201b, 226, "LE Long Term Key Request Neg Reply",
9679                                 le_ltk_req_neg_reply_cmd, 2, true,
9680                                 le_ltk_req_neg_reply_rsp, 3, true },
9681         { 0x201c, 227, "LE Read Supported States",
9682                                 null_cmd, 0, true,
9683                                 le_read_supported_states_rsp, 9, true },
9684         { 0x201d, 228, "LE Receiver Test",
9685                                 le_receiver_test_cmd, 1, true,
9686                                 status_rsp, 1, true },
9687         { 0x201e, 229, "LE Transmitter Test",
9688                                 le_transmitter_test_cmd, 3, true,
9689                                 status_rsp, 1, true },
9690         { 0x201f, 230, "LE Test End",
9691                                 null_cmd, 0, true,
9692                                 le_test_end_rsp, 3, true },
9693         { 0x2020, 268, "LE Remote Connection Parameter Request Reply",
9694                                 le_conn_param_req_reply_cmd, 14, true,
9695                                 le_conn_param_req_reply_rsp, 3, true },
9696         { 0x2021, 269, "LE Remote Connection Parameter Request Negative Reply",
9697                                 le_conn_param_req_neg_reply_cmd, 3, true,
9698                                 le_conn_param_req_neg_reply_rsp, 3, true },
9699         { 0x2022, 270, "LE Set Data Length",
9700                                 le_set_data_length_cmd, 6, true,
9701                                 le_set_data_length_rsp, 3, true },
9702         { 0x2023, 271, "LE Read Suggested Default Data Length",
9703                                 null_cmd, 0, true,
9704                                 le_read_default_data_length_rsp, 5, true },
9705         { 0x2024, 272, "LE Write Suggested Default Data Length",
9706                                 le_write_default_data_length_cmd, 4, true,
9707                                 status_rsp, 1, true },
9708         { 0x2025, 273, "LE Read Local P-256 Public Key",
9709                                 null_cmd, 0, true },
9710         { 0x2026, 274, "LE Generate DHKey",
9711                                 le_generate_dhkey_cmd, 64, true },
9712         { 0x2027, 275, "LE Add Device To Resolving List",
9713                                 le_add_to_resolv_list_cmd, 39, true,
9714                                 status_rsp, 1, true },
9715         { 0x2028, 276, "LE Remove Device From Resolving List",
9716                                 le_remove_from_resolv_list_cmd, 7, true,
9717                                 status_rsp, 1, true },
9718         { 0x2029, 277, "LE Clear Resolving List",
9719                                 null_cmd, 0, true,
9720                                 status_rsp, 1, true },
9721         { 0x202a, 278, "LE Read Resolving List Size",
9722                                 null_cmd, 0, true,
9723                                 le_read_resolv_list_size_rsp, 2, true },
9724         { 0x202b, 279, "LE Read Peer Resolvable Address",
9725                                 le_read_peer_resolv_addr_cmd, 7, true,
9726                                 le_read_peer_resolv_addr_rsp, 7, true },
9727         { 0x202c, 280, "LE Read Local Resolvable Address",
9728                                 le_read_local_resolv_addr_cmd, 7, true,
9729                                 le_read_local_resolv_addr_rsp, 7, true },
9730         { 0x202d, 281, "LE Set Address Resolution Enable",
9731                                 le_set_resolv_enable_cmd, 1, true,
9732                                 status_rsp, 1, true },
9733         { 0x202e, 282, "LE Set Resolvable Private Address Timeout",
9734                                 le_set_resolv_timeout_cmd, 2, true,
9735                                 status_rsp, 1, true },
9736         { 0x202f, 283, "LE Read Maximum Data Length",
9737                                 null_cmd, 0, true,
9738                                 le_read_max_data_length_rsp, 9, true },
9739         { 0x2030, 284, "LE Read PHY",
9740                                 le_read_phy_cmd, 2, true,
9741                                 le_read_phy_rsp, 5, true},
9742         { 0x2031, 285, "LE Set Default PHY",
9743                                 le_set_default_phy_cmd, 3, true,
9744                                 status_rsp, 1, true },
9745         { 0x2032, 286, "LE Set PHY",
9746                                 le_set_phy_cmd, 7, true},
9747         { 0x2033, 287, "LE Enhanced Receiver Test",
9748                                 le_enhanced_receiver_test_cmd, 3, true,
9749                                 status_rsp, 1, true },
9750         { 0x2034, 288, "LE Enhanced Transmitter Test",
9751                                 le_enhanced_transmitter_test_cmd, 4, true,
9752                                 status_rsp, 1, true },
9753         { 0x2035, 289, "LE Set Advertising Set Random Address",
9754                                 le_set_adv_set_rand_addr, 7, true,
9755                                 status_rsp, 1, true },
9756         { 0x2036, 290, "LE Set Extended Advertising Parameters",
9757                                 le_set_ext_adv_params_cmd, 25, true,
9758                                 le_set_ext_adv_params_rsp, 2, true },
9759         { 0x2037, 291, "LE Set Extended Advertising Data",
9760                                 le_set_ext_adv_data_cmd, 4, false,
9761                                 status_rsp, 1, true },
9762         { 0x2038, 292, "LE Set Extended Scan Response Data",
9763                                 le_set_ext_scan_rsp_data_cmd, 4, false,
9764                                 status_rsp, 1, true },
9765         { 0x2039, 293, "LE Set Extended Advertising Enable",
9766                                 le_set_ext_adv_enable_cmd, 2, false,
9767                                 status_rsp, 1, true },
9768         { 0x203a, 294, "LE Read Maximum Advertising Data Length",
9769                                 null_cmd, 0, true,
9770                                 le_read_max_adv_data_len_rsp, 3, true },
9771         { 0x203b, 295, "LE Read Number of Supported Advertising Sets",
9772                                 null_cmd, 0, true,
9773                                 le_read_num_supported_adv_sets_rsp, 2, true },
9774         { 0x203c, 296, "LE Remove Advertising Set",
9775                                 le_remove_adv_set_cmd, 1, true,
9776                                 status_rsp, 1, true },
9777         { 0x203d, 297, "LE Clear Advertising Sets",
9778                                 null_cmd, 0, true,
9779                                 status_rsp, 1, true },
9780         { 0x203e, 298, "LE Set Periodic Advertising Parameters",
9781                                 le_set_pa_params_cmd, 7, true,
9782                                 status_rsp, 1, true },
9783         { 0x203f, 299, "LE Set Periodic Advertising Data",
9784                                 le_set_pa_data_cmd, 3, false,
9785                                 status_rsp, 1, true },
9786         { 0x2040, 300, "LE Set Periodic Advertising Enable",
9787                                 le_set_pa_enable_cmd, 2, true,
9788                                 status_rsp, 1, true },
9789         { 0x2041, 301, "LE Set Extended Scan Parameters",
9790                                 le_set_ext_scan_params_cmd, 3, false,
9791                                 status_rsp, 1, true },
9792         { 0x2042, 302, "LE Set Extended Scan Enable",
9793                                 le_set_ext_scan_enable_cmd, 6, true,
9794                                 status_rsp, 1, true },
9795         { 0x2043, 303, "LE Extended Create Connection",
9796                                 le_ext_create_conn_cmd, 10, false,
9797                                 status_rsp, 1, true },
9798         { 0x2044, 304, "LE Periodic Advertising Create Sync",
9799                                 le_pa_create_sync_cmd, 14, true,
9800                                 status_rsp, 1, true },
9801         { 0x2045, 305, "LE Periodic Advertising Create Sync Cancel",
9802                                 null_cmd, 0, true,
9803                                 status_rsp, 1, true },
9804         { 0x2046, 306, "LE Periodic Advertising Terminate Sync",
9805                                 le_pa_term_sync_cmd, 2, true,
9806                                 status_rsp, 1, true },
9807         { 0x2047, 307, "LE Add Device To Periodic Advertiser List",
9808                                 le_add_dev_pa_list_cmd, 8, true,
9809                                 status_rsp, 1, true },
9810         { 0x2048, 308, "LE Remove Device From Periodic Advertiser List",
9811                                 le_remove_dev_pa_list_cmd, 8, true,
9812                                 status_rsp, 1, true },
9813         { 0x2049, 309, "LE Clear Periodic Advertiser List",
9814                                 null_cmd, 0, true,
9815                                 status_rsp, 1, true },
9816         { 0x204a, 310, "LE Read Periodic Advertiser List Size",
9817                                 null_cmd, 0, true,
9818                                 le_read_pa_list_size_rsp, 2, true },
9819         { 0x204b, 311, "LE Read Transmit Power",
9820                                 null_cmd, 0, true,
9821                                 le_read_tx_power_rsp, 3, true },
9822         { 0x204c, 312, "LE Read RF Path Compensation",
9823                                 null_cmd, 0, true,
9824                                 le_read_rf_path_comp_rsp, 5, true },
9825         { 0x204d, 313, "LE Write RF Path Compensation",
9826                                 le_write_rf_path_comp_cmd, 4, true,
9827                                 status_rsp, 1, true },
9828         { 0x204e, 314, "LE Set Privacy Mode",
9829                                 le_set_priv_mode_cmd, 8, true,
9830                                 status_rsp, 1, true },
9831         { 0x204f, 315, "LE Receiver Test command [v3]",
9832                                 le_receiver_test_cmd_v3, 7, false,
9833                                 status_rsp, 1, true },
9834         { 0x2050, 316, "LE Transmitter Test command [v3]",
9835                                 le_tx_test_cmd_v3, 9, false,
9836                                 status_rsp, 1, true },
9837         { 0x2059, 325, "LE Periodic Advertising Receive Enable",
9838                                 le_pa_rec_enable, 3, true,
9839                                 status_rsp, 1, true },
9840         { 0x205a, 326, "LE Periodic Advertising Sync Transfer",
9841                                 le_pa_sync_trans, 6, true,
9842                                 status_handle_rsp, 3, true },
9843         { 0x205b, 327, "LE Periodic Advertising Set Info Transfer",
9844                                 le_pa_set_info_trans, 5, true,
9845                                 status_handle_rsp, 3, true },
9846         { 0x205c, 328, "LE Periodic Advertising Sync Transfer Parameters",
9847                                 le_pa_sync_trans_params, 8, true,
9848                                 status_handle_rsp, 3, true},
9849         { 0x205d, 329, "LE Set Default Periodic Advertisng Sync Transfer "
9850                                 "Parameters",
9851                                 le_set_default_pa_sync_trans_params,
9852                                 6, true, status_rsp, 1, true},
9853         { BT_HCI_CMD_LE_READ_BUFFER_SIZE_V2,
9854                                 BT_HCI_BIT_LE_READ_BUFFER_SIZE_V2,
9855                                 "LE Read Buffer v2",
9856                                 null_cmd, 0, true,
9857                                 le_read_buffer_size_v2_rsp,
9858                                 sizeof(
9859                                 struct bt_hci_rsp_le_read_buffer_size_v2),
9860                                 true },
9861         { BT_HCI_CMD_LE_READ_ISO_TX_SYNC,
9862                                 BT_HCI_BIT_LE_READ_ISO_TX_SYNC,
9863                                 "LE Read ISO TX Sync",
9864                                 le_read_iso_tx_sync_cmd,
9865                                 sizeof(struct bt_hci_cmd_le_read_iso_tx_sync),
9866                                 true,
9867                                 le_read_iso_tx_sync_rsp,
9868                                 sizeof(struct bt_hci_rsp_le_read_iso_tx_sync),
9869                                 true },
9870         { BT_HCI_CMD_LE_SET_CIG_PARAMS, BT_HCI_BIT_LE_SET_CIG_PARAMS,
9871                                 "LE Set Connected Isochronous Group Parameters",
9872                                 le_set_cig_params_cmd,
9873                                 sizeof(struct bt_hci_cmd_le_set_cig_params),
9874                                 false,
9875                                 le_set_cig_params_rsp,
9876                                 sizeof(struct bt_hci_rsp_le_set_cig_params),
9877                                 false },
9878         { BT_HCI_CMD_LE_SET_CIG_PARAMS_TEST, BT_HCI_BIT_LE_SET_CIG_PARAMS_TEST,
9879                                 "LE Set Connected Isochronous Group Parameters"
9880                                 " Test", le_set_cig_params_test_cmd,
9881                                 sizeof(
9882                                 struct bt_hci_cmd_le_set_cig_params_test),
9883                                 false,
9884                                 le_set_cig_params_rsp,
9885                                 sizeof(struct bt_hci_rsp_le_set_cig_params),
9886                                 false },
9887         { BT_HCI_CMD_LE_CREATE_CIS, BT_HCI_BIT_LE_CREATE_CIS,
9888                                 "LE Create Connected Isochronous Stream",
9889                                 le_create_cis_cmd,
9890                                 sizeof(struct bt_hci_cmd_le_create_cis),
9891                                 false },
9892         { BT_HCI_CMD_LE_REMOVE_CIG, BT_HCI_BIT_LE_REMOVE_CIG,
9893                                 "LE Remove Connected Isochronous Group",
9894                                 le_remove_cig_cmd,
9895                                 sizeof(struct bt_hci_cmd_le_remove_cig), false,
9896                                 le_remove_cig_rsp,
9897                                 sizeof(struct bt_hci_rsp_le_remove_cig),
9898                                 false },
9899         { BT_HCI_CMD_LE_ACCEPT_CIS, BT_HCI_BIT_LE_ACCEPT_CIS,
9900                                 "LE Accept Connected Isochronous Stream Request",
9901                                 le_accept_cis_req_cmd,
9902                                 sizeof(struct bt_hci_cmd_le_accept_cis), true },
9903         { BT_HCI_CMD_LE_REJECT_CIS, BT_HCI_BIT_LE_REJECT_CIS,
9904                                 "LE Reject Connected Isochronous Stream Request",
9905                                 le_reject_cis_req_cmd,
9906                                 sizeof(struct bt_hci_cmd_le_reject_cis), true,
9907                                 status_rsp, 1, true },
9908         { BT_HCI_CMD_LE_CREATE_BIG, BT_HCI_BIT_LE_CREATE_BIG,
9909                                 "LE Create Broadcast Isochronous Group",
9910                                 le_create_big_cmd },
9911         { BT_HCI_CMD_LE_CREATE_BIG_TEST, BT_HCI_BIT_LE_CREATE_BIG_TEST,
9912                                 "LE Create Broadcast Isochronous Group Test",
9913                                 le_create_big_cmd_test_cmd },
9914         { BT_HCI_CMD_LE_TERM_BIG, BT_HCI_BIT_LE_TERM_BIG,
9915                                 "LE Terminate Broadcast Isochronous Group",
9916                                 le_terminate_big_cmd,
9917                                 sizeof(struct bt_hci_cmd_le_term_big), true,
9918                                 status_rsp, 1, true},
9919         { BT_HCI_CMD_LE_BIG_CREATE_SYNC, BT_HCI_BIT_LE_BIG_CREATE_SYNC,
9920                                 "LE Broadcast Isochronous Group Create Sync",
9921                                 le_big_create_sync_cmd,
9922                                 sizeof(struct bt_hci_cmd_le_big_create_sync),
9923                                 true },
9924         { BT_HCI_CMD_LE_BIG_TERM_SYNC, BT_HCI_BIT_LE_BIG_TERM_SYNC,
9925                                 "LE Broadcast Isochronous Group Terminate Sync",
9926                                 le_big_term_sync_cmd,
9927                                 sizeof(struct bt_hci_cmd_le_big_term_sync),
9928                                 true },
9929         { BT_HCI_CMD_LE_REQ_PEER_SCA, BT_HCI_BIT_LE_REQ_PEER_SCA,
9930                                 "LE Request Peer SCA", le_req_peer_sca_cmd,
9931                                 sizeof(struct bt_hci_cmd_le_req_peer_sca),
9932                                 true },
9933         { BT_HCI_CMD_LE_SETUP_ISO_PATH, BT_HCI_BIT_LE_SETUP_ISO_PATH,
9934                                 "LE Setup Isochronous Data Path",
9935                                 le_setup_iso_path_cmd,
9936                                 sizeof(struct bt_hci_cmd_le_setup_iso_path),
9937                                 true, le_setup_iso_path_rsp,
9938                                 sizeof(struct bt_hci_rsp_le_setup_iso_path),
9939                                 true },
9940         { BT_HCI_CMD_LE_REMOVE_ISO_PATH, BT_HCI_BIT_LE_REMOVE_ISO_PATH,
9941                                 "LE Remove Isochronous Data Path",
9942                                 le_remove_iso_path_cmd,
9943                                 sizeof(struct bt_hci_cmd_le_remove_iso_path),
9944                                 true, status_handle_rsp,
9945                                 sizeof(struct bt_hci_rsp_le_remove_iso_path),
9946                                 true },
9947         { BT_HCI_CMD_LE_ISO_TX_TEST, BT_HCI_BIT_LE_ISO_TX_TEST,
9948                                 "LE Isochronous Transmit Test", NULL, 0,
9949                                 false },
9950         { BT_HCI_CMD_LE_ISO_RX_TEST, BT_HCI_BIT_LE_ISO_RX_TEST,
9951                                 "LE Isochronous Receive Test", NULL, 0,
9952                                 false },
9953         { BT_HCI_CMD_LE_ISO_READ_TEST_COUNTER,
9954                                 BT_HCI_BIT_LE_ISO_READ_TEST_COUNTER,
9955                                 "LE Isochronous Read Test Counters", NULL, 0,
9956                                 false },
9957         { BT_HCI_CMD_LE_ISO_TEST_END, BT_HCI_BIT_LE_ISO_TEST_END,
9958                                 "LE Isochronous Read Test Counters", NULL, 0,
9959                                 false },
9960         { BT_HCI_CMD_LE_SET_HOST_FEATURE, BT_HCI_BIT_LE_SET_HOST_FEATURE,
9961                                 "LE Set Host Feature", le_set_host_feature_cmd,
9962                                 sizeof(struct bt_hci_cmd_le_set_host_feature),
9963                                 true, status_rsp, 1, true },
9964         { BT_HCI_CMD_LE_READ_ISO_LINK_QUALITY,
9965                                 BT_HCI_BIT_LE_READ_ISO_LINK_QUALITY,
9966                                 "LE Read ISO link quality",
9967                                 le_read_iso_link_quality_cmd,
9968                                 sizeof(
9969                                 struct bt_hci_cmd_le_read_iso_link_quality),
9970                                 true, status_le_read_iso_link_quality_rsp,
9971                                 sizeof(
9972                                 struct bt_hci_rsp_le_read_iso_link_quality),
9973                                 true },
9974         { }
9975 };
9976
9977 static const char *get_supported_command(int bit)
9978 {
9979         int i;
9980
9981         for (i = 0; opcode_table[i].str; i++) {
9982                 if (opcode_table[i].bit == bit)
9983                         return opcode_table[i].str;
9984         }
9985
9986         return NULL;
9987 }
9988
9989 static const char *current_vendor_str(uint16_t ocf)
9990 {
9991         uint16_t manufacturer, msft_opcode;
9992
9993         if (index_current < MAX_INDEX) {
9994                 manufacturer = index_list[index_current].manufacturer;
9995                 msft_opcode = index_list[index_current].msft_opcode;
9996         } else {
9997                 manufacturer = fallback_manufacturer;
9998                 msft_opcode = BT_HCI_CMD_NOP;
9999         }
10000
10001         if (msft_opcode != BT_HCI_CMD_NOP &&
10002                                 cmd_opcode_ocf(msft_opcode) == ocf)
10003                 return "Microsoft";
10004
10005         switch (manufacturer) {
10006         case 2:
10007                 return "Intel";
10008         case 15:
10009                 return "Broadcom";
10010         case 93:
10011                 return "Realtek";
10012 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10013         default:
10014                 return "Unknown";
10015 #endif
10016         }
10017
10018         return NULL;
10019 }
10020
10021 static const struct vendor_ocf *current_vendor_ocf(uint16_t ocf)
10022 {
10023         uint16_t manufacturer, msft_opcode;
10024
10025         if (index_current < MAX_INDEX) {
10026                 manufacturer = index_list[index_current].manufacturer;
10027                 msft_opcode = index_list[index_current].msft_opcode;
10028         } else {
10029                 manufacturer = fallback_manufacturer;
10030                 msft_opcode = BT_HCI_CMD_NOP;
10031         }
10032
10033         if (msft_opcode != BT_HCI_CMD_NOP &&
10034                                 cmd_opcode_ocf(msft_opcode) == ocf)
10035                 return msft_vendor_ocf();
10036
10037         switch (manufacturer) {
10038         case 2:
10039                 return intel_vendor_ocf(ocf);
10040         case 15:
10041                 return broadcom_vendor_ocf(ocf);
10042 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10043         default:
10044                 return broadcom_vendor_ocf(ocf);
10045 #endif
10046         }
10047
10048         return NULL;
10049 }
10050
10051 static const struct vendor_evt *current_vendor_evt(const void *data,
10052                                                         int *consumed_size)
10053 {
10054         uint16_t manufacturer;
10055         uint8_t evt = *((const uint8_t *) data);
10056
10057         /* A regular vendor event consumes 1 byte. */
10058         *consumed_size = 1;
10059
10060         if (index_current < MAX_INDEX)
10061                 manufacturer = index_list[index_current].manufacturer;
10062         else
10063                 manufacturer = fallback_manufacturer;
10064
10065         switch (manufacturer) {
10066         case 2:
10067                 return intel_vendor_evt(data, consumed_size);
10068         case 15:
10069                 return broadcom_vendor_evt(evt);
10070 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10071         default:
10072                 return broadcom_vendor_evt(evt);
10073 #endif
10074         }
10075
10076         return NULL;
10077 }
10078
10079 static const char *current_vendor_evt_str(void)
10080 {
10081         uint16_t manufacturer;
10082
10083         if (index_current < MAX_INDEX)
10084                 manufacturer = index_list[index_current].manufacturer;
10085         else
10086                 manufacturer = fallback_manufacturer;
10087
10088         switch (manufacturer) {
10089         case 2:
10090                 return "Intel";
10091         case 15:
10092                 return "Broadcom";
10093         case 93:
10094                 return "Realtek";
10095         }
10096
10097         return NULL;
10098 }
10099
10100 static void inquiry_complete_evt(struct timeval *tv, uint16_t index,
10101                                         const void *data, uint8_t size)
10102 {
10103         const struct bt_hci_evt_inquiry_complete *evt = data;
10104
10105         print_status(evt->status);
10106 }
10107
10108 static void inquiry_result_evt(struct timeval *tv, uint16_t index,
10109                                         const void *data, uint8_t size)
10110 {
10111         const struct bt_hci_evt_inquiry_result *evt = data;
10112
10113         print_num_resp(evt->num_resp);
10114         print_bdaddr(evt->bdaddr);
10115         print_pscan_rep_mode(evt->pscan_rep_mode);
10116         print_pscan_period_mode(evt->pscan_period_mode);
10117         print_pscan_mode(evt->pscan_mode);
10118         print_dev_class(evt->dev_class);
10119         print_clock_offset(evt->clock_offset);
10120
10121         if (size > sizeof(*evt))
10122                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
10123 }
10124
10125 static void conn_complete_evt(struct timeval *tv, uint16_t index,
10126                                         const void *data, uint8_t size)
10127 {
10128         const struct bt_hci_evt_conn_complete *evt = data;
10129
10130         print_status(evt->status);
10131         print_handle(evt->handle);
10132         print_bdaddr(evt->bdaddr);
10133         print_link_type(evt->link_type);
10134         print_enable("Encryption", evt->encr_mode);
10135
10136         if (evt->status == 0x00)
10137                 assign_handle(index, le16_to_cpu(evt->handle), 0x00,
10138                                         (void *)evt->bdaddr, BDADDR_BREDR);
10139 }
10140
10141 static void conn_request_evt(struct timeval *tv, uint16_t index,
10142                                         const void *data, uint8_t size)
10143 {
10144         const struct bt_hci_evt_conn_request *evt = data;
10145
10146         print_bdaddr(evt->bdaddr);
10147         print_dev_class(evt->dev_class);
10148         print_link_type(evt->link_type);
10149 }
10150
10151 static void disconnect_complete_evt(struct timeval *tv, uint16_t index,
10152                                         const void *data, uint8_t size)
10153 {
10154         const struct bt_hci_evt_disconnect_complete *evt = data;
10155
10156         print_status(evt->status);
10157         print_handle(evt->handle);
10158         print_reason(evt->reason);
10159
10160         if (evt->status == 0x00)
10161                 release_handle(le16_to_cpu(evt->handle));
10162 }
10163
10164 static void auth_complete_evt(struct timeval *tv, uint16_t index,
10165                                         const void *data, uint8_t size)
10166 {
10167         const struct bt_hci_evt_auth_complete *evt = data;
10168
10169         print_status(evt->status);
10170         print_handle(evt->handle);
10171 }
10172
10173 static void remote_name_request_complete_evt(struct timeval *tv, uint16_t index,
10174                                                 const void *data, uint8_t size)
10175 {
10176         const struct bt_hci_evt_remote_name_request_complete *evt = data;
10177
10178         print_status(evt->status);
10179         print_bdaddr(evt->bdaddr);
10180         print_name(evt->name);
10181 }
10182
10183 static void encrypt_change_evt(struct timeval *tv, uint16_t index,
10184                                         const void *data, uint8_t size)
10185 {
10186         const struct bt_hci_evt_encrypt_change *evt = data;
10187
10188         print_status(evt->status);
10189         print_handle(evt->handle);
10190         print_encr_mode_change(evt->encr_mode, evt->handle);
10191 }
10192
10193 static void change_conn_link_key_complete_evt(struct timeval *tv,
10194                                                 uint16_t index,
10195                                                 const void *data, uint8_t size)
10196 {
10197         const struct bt_hci_evt_change_conn_link_key_complete *evt = data;
10198
10199         print_status(evt->status);
10200         print_handle(evt->handle);
10201 }
10202
10203 static void link_key_type_changed_evt(struct timeval *tv, uint16_t index,
10204                                         const void *data, uint8_t size)
10205 {
10206         const struct bt_hci_evt_link_key_type_changed *evt = data;
10207
10208         print_status(evt->status);
10209         print_handle(evt->handle);
10210         print_key_flag(evt->key_flag);
10211 }
10212
10213 static void remote_features_complete_evt(struct timeval *tv, uint16_t index,
10214                                         const void *data, uint8_t size)
10215 {
10216         const struct bt_hci_evt_remote_features_complete *evt = data;
10217
10218         print_status(evt->status);
10219         print_handle(evt->handle);
10220         print_features(0, evt->features, 0x00);
10221 }
10222
10223 static void remote_version_complete_evt(struct timeval *tv, uint16_t index,
10224                                         const void *data, uint8_t size)
10225 {
10226         const struct bt_hci_evt_remote_version_complete *evt = data;
10227
10228         print_status(evt->status);
10229         print_handle(evt->handle);
10230         print_lmp_version(evt->lmp_ver, evt->lmp_subver);
10231         print_manufacturer(evt->manufacturer);
10232
10233         switch (le16_to_cpu(evt->manufacturer)) {
10234         case 15:
10235                 print_manufacturer_broadcom(evt->lmp_subver, 0xffff);
10236                 break;
10237         }
10238 }
10239
10240 static void qos_setup_complete_evt(struct timeval *tv, uint16_t index,
10241                                         const void *data, uint8_t size)
10242 {
10243         const struct bt_hci_evt_qos_setup_complete *evt = data;
10244
10245         print_status(evt->status);
10246         print_handle(evt->handle);
10247         print_field("Flags: 0x%2.2x", evt->flags);
10248
10249         print_service_type(evt->service_type);
10250
10251         print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
10252         print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
10253         print_field("Latency: %d", le32_to_cpu(evt->latency));
10254         print_field("Delay variation: %d", le32_to_cpu(evt->delay_variation));
10255 }
10256
10257 static void cmd_complete_evt(struct timeval *tv, uint16_t index,
10258                                 const void *data, uint8_t size)
10259 {
10260         const struct bt_hci_evt_cmd_complete *evt = data;
10261         uint16_t opcode = le16_to_cpu(evt->opcode);
10262         uint16_t ogf = cmd_opcode_ogf(opcode);
10263         uint16_t ocf = cmd_opcode_ocf(opcode);
10264         struct opcode_data vendor_data;
10265         const struct opcode_data *opcode_data = NULL;
10266         const char *opcode_color, *opcode_str;
10267         char vendor_str[150];
10268         int i;
10269
10270         for (i = 0; opcode_table[i].str; i++) {
10271                 if (opcode_table[i].opcode == opcode) {
10272                         opcode_data = &opcode_table[i];
10273                         break;
10274                 }
10275         }
10276
10277         if (opcode_data) {
10278                 if (opcode_data->rsp_func)
10279                         opcode_color = COLOR_HCI_COMMAND;
10280                 else
10281                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10282                 opcode_str = opcode_data->str;
10283         } else {
10284                 if (ogf == 0x3f) {
10285                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
10286
10287                         if (vnd) {
10288                                 const char *str = current_vendor_str(ocf);
10289
10290                                 if (str) {
10291                                         snprintf(vendor_str, sizeof(vendor_str),
10292                                                         "%s %s", str, vnd->str);
10293                                         vendor_data.str = vendor_str;
10294                                 } else
10295                                         vendor_data.str = vnd->str;
10296                                 vendor_data.rsp_func = vnd->rsp_func;
10297                                 vendor_data.rsp_size = vnd->rsp_size;
10298                                 vendor_data.rsp_fixed = vnd->rsp_fixed;
10299
10300                                 opcode_data = &vendor_data;
10301
10302                                 if (opcode_data->rsp_func)
10303                                         opcode_color = COLOR_HCI_COMMAND;
10304                                 else
10305                                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10306                                 opcode_str = opcode_data->str;
10307                         } else {
10308                                 opcode_color = COLOR_HCI_COMMAND;
10309                                 opcode_str = "Vendor";
10310                         }
10311                 } else {
10312                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10313                         opcode_str = "Unknown";
10314                 }
10315         }
10316
10317         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
10318                         " (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
10319
10320         if (!opcode_data || !opcode_data->rsp_func) {
10321                 if (size > 3) {
10322                         uint8_t status = *((uint8_t *) (data + 3));
10323
10324                         print_status(status);
10325                         packet_hexdump(data + 4, size - 4);
10326                 }
10327                 return;
10328         }
10329
10330         if (opcode_data->rsp_size > 1 && size - 3 == 1) {
10331                 uint8_t status = *((uint8_t *) (data + 3));
10332
10333                 print_status(status);
10334                 return;
10335         }
10336
10337         if (opcode_data->rsp_fixed) {
10338                 if (size - 3 != opcode_data->rsp_size) {
10339                         print_text(COLOR_ERROR, "invalid packet size");
10340                         packet_hexdump(data + 3, size - 3);
10341                         return;
10342                 }
10343         } else {
10344                 if (size - 3 < opcode_data->rsp_size) {
10345                         print_text(COLOR_ERROR, "too short packet");
10346                         packet_hexdump(data + 3, size - 3);
10347                         return;
10348                 }
10349         }
10350
10351         opcode_data->rsp_func(index, data + 3, size - 3);
10352 }
10353
10354 static void cmd_status_evt(struct timeval *tv, uint16_t index,
10355                                 const void *data, uint8_t size)
10356 {
10357         const struct bt_hci_evt_cmd_status *evt = data;
10358         uint16_t opcode = le16_to_cpu(evt->opcode);
10359         uint16_t ogf = cmd_opcode_ogf(opcode);
10360         uint16_t ocf = cmd_opcode_ocf(opcode);
10361         const struct opcode_data *opcode_data = NULL;
10362         const char *opcode_color, *opcode_str;
10363         char vendor_str[150];
10364         int i;
10365
10366         for (i = 0; opcode_table[i].str; i++) {
10367                 if (opcode_table[i].opcode == opcode) {
10368                         opcode_data = &opcode_table[i];
10369                         break;
10370                 }
10371         }
10372
10373         if (opcode_data) {
10374                 opcode_color = COLOR_HCI_COMMAND;
10375                 opcode_str = opcode_data->str;
10376         } else {
10377                 if (ogf == 0x3f) {
10378                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
10379
10380                         if (vnd) {
10381                                 const char *str = current_vendor_str(ocf);
10382
10383                                 if (str) {
10384                                         snprintf(vendor_str, sizeof(vendor_str),
10385                                                         "%s %s", str, vnd->str);
10386                                         opcode_str = vendor_str;
10387                                 } else
10388                                         opcode_str = vnd->str;
10389
10390                                 opcode_color = COLOR_HCI_COMMAND;
10391                         } else {
10392                                 opcode_color = COLOR_HCI_COMMAND;
10393                                 opcode_str = "Vendor";
10394                         }
10395                 } else {
10396                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
10397                         opcode_str = "Unknown";
10398                 }
10399         }
10400
10401         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
10402                         " (0x%2.2x|0x%4.4x) ncmd %d", ogf, ocf, evt->ncmd);
10403
10404         print_status(evt->status);
10405 }
10406
10407 static void hardware_error_evt(struct timeval *tv, uint16_t index,
10408                                 const void *data, uint8_t size)
10409 {
10410         const struct bt_hci_evt_hardware_error *evt = data;
10411
10412         print_field("Code: 0x%2.2x", evt->code);
10413 }
10414
10415 static void flush_occurred_evt(struct timeval *tv, uint16_t index,
10416                                 const void *data, uint8_t size)
10417 {
10418         const struct bt_hci_evt_flush_occurred *evt = data;
10419
10420         print_handle(evt->handle);
10421 }
10422
10423 static void role_change_evt(struct timeval *tv, uint16_t index,
10424                                 const void *data, uint8_t size)
10425 {
10426         const struct bt_hci_evt_role_change *evt = data;
10427
10428         print_status(evt->status);
10429         print_bdaddr(evt->bdaddr);
10430         print_role(evt->role);
10431 }
10432
10433 void packet_latency_add(struct packet_latency *latency, struct timeval *delta)
10434 {
10435         timeradd(&latency->total, delta, &latency->total);
10436
10437         if ((!timerisset(&latency->min) || timercmp(delta, &latency->min, <))
10438                                 && delta->tv_sec >= 0 && delta->tv_usec >= 0)
10439                 latency->min = *delta;
10440
10441         if (!timerisset(&latency->max) || timercmp(delta, &latency->max, >))
10442                 latency->max = *delta;
10443
10444         if (timerisset(&latency->med)) {
10445                 struct timeval tmp;
10446
10447                 timeradd(&latency->med, delta, &tmp);
10448
10449                 tmp.tv_sec /= 2;
10450                 tmp.tv_usec /= 2;
10451                 if (tmp.tv_sec % 2) {
10452                         tmp.tv_usec += 500000;
10453                         if (tmp.tv_usec >= 1000000) {
10454                                 tmp.tv_sec++;
10455                                 tmp.tv_usec -= 1000000;
10456                         }
10457                 }
10458
10459                 latency->med = tmp;
10460         } else
10461                 latency->med = *delta;
10462 }
10463
10464 static void packet_dequeue_tx(struct timeval *tv, uint16_t handle)
10465 {
10466         struct packet_conn_data *conn;
10467         struct packet_frame *frame;
10468         struct timeval delta;
10469
10470         conn = packet_get_conn_data(handle);
10471         if (!conn)
10472                 return;
10473
10474         frame = queue_pop_head(conn->tx_q);
10475         if (!frame)
10476                 return;
10477
10478         timersub(tv, &frame->tv, &delta);
10479
10480         packet_latency_add(&conn->tx_l, &delta);
10481
10482         if (TV_MSEC(delta)) {
10483                 print_field("#%zu: len %zu (%lld Kb/s)", frame->num, frame->len,
10484                                 frame->len * 8 / TV_MSEC(delta));
10485                 print_field("Latency: %lld msec (%lld-%lld msec ~%lld msec)",
10486                                 TV_MSEC(delta), TV_MSEC(conn->tx_l.min),
10487                                 TV_MSEC(conn->tx_l.max),
10488                                 TV_MSEC(conn->tx_l.med));
10489         }
10490
10491         l2cap_dequeue_frame(&delta, conn);
10492
10493         free(frame);
10494 }
10495
10496 static void num_completed_packets_evt(struct timeval *tv, uint16_t index,
10497                                         const void *data, uint8_t size)
10498 {
10499         struct iovec iov = { (void *)data, size};
10500         const struct bt_hci_evt_num_completed_packets *evt = data;
10501         int i;
10502
10503         iov_pull(&iov, 1);
10504
10505         print_field("Num handles: %d", evt->num_handles);
10506
10507         for (i = 0; i < evt->num_handles; i++) {
10508                 uint16_t handle;
10509                 uint16_t count;
10510                 int j;
10511
10512                 if (!util_iov_pull_le16(&iov, &handle))
10513                         break;
10514
10515                 print_handle_native(handle);
10516
10517                 if (!util_iov_pull_le16(&iov, &count))
10518                         break;
10519
10520                 print_field("Count: %d", count);
10521
10522                 for (j = 0; j < count; j++)
10523                         packet_dequeue_tx(tv, handle);
10524         }
10525
10526         if (iov.iov_len)
10527                 packet_hexdump(iov.iov_base, iov.iov_len);
10528 }
10529
10530 static void mode_change_evt(struct timeval *tv, uint16_t index,
10531                                         const void *data, uint8_t size)
10532 {
10533         const struct bt_hci_evt_mode_change *evt = data;
10534
10535         print_status(evt->status);
10536         print_handle(evt->handle);
10537         print_mode(evt->mode);
10538         print_interval(evt->interval);
10539 }
10540
10541 static void return_link_keys_evt(struct timeval *tv, uint16_t index,
10542                                         const void *data, uint8_t size)
10543 {
10544         const struct bt_hci_evt_return_link_keys *evt = data;
10545         uint8_t i;
10546
10547         print_field("Num keys: %d", evt->num_keys);
10548
10549         for (i = 0; i < evt->num_keys; i++) {
10550                 print_bdaddr(evt->keys + (i * 22));
10551                 print_link_key(evt->keys + (i * 22) + 6);
10552         }
10553 }
10554
10555 static void pin_code_request_evt(struct timeval *tv, uint16_t index,
10556                                         const void *data, uint8_t size)
10557 {
10558         const struct bt_hci_evt_pin_code_request *evt = data;
10559
10560         print_bdaddr(evt->bdaddr);
10561 }
10562
10563 static void link_key_request_evt(struct timeval *tv, uint16_t index,
10564                                         const void *data, uint8_t size)
10565 {
10566         const struct bt_hci_evt_link_key_request *evt = data;
10567
10568         print_bdaddr(evt->bdaddr);
10569 }
10570
10571 static void link_key_notify_evt(struct timeval *tv, uint16_t index,
10572                                         const void *data, uint8_t size)
10573 {
10574         const struct bt_hci_evt_link_key_notify *evt = data;
10575
10576         print_bdaddr(evt->bdaddr);
10577         print_link_key(evt->link_key);
10578         print_key_type(evt->key_type);
10579 }
10580
10581 static void loopback_command_evt(struct timeval *tv, uint16_t index,
10582                                         const void *data, uint8_t size)
10583 {
10584         packet_hexdump(data, size);
10585 }
10586
10587 static void data_buffer_overflow_evt(struct timeval *tv, uint16_t index,
10588                                         const void *data, uint8_t size)
10589 {
10590         const struct bt_hci_evt_data_buffer_overflow *evt = data;
10591
10592         print_link_type(evt->link_type);
10593 }
10594
10595 static void max_slots_change_evt(struct timeval *tv, uint16_t index,
10596                                         const void *data, uint8_t size)
10597 {
10598         const struct bt_hci_evt_max_slots_change *evt = data;
10599
10600         print_handle(evt->handle);
10601         print_field("Max slots: %d", evt->max_slots);
10602 }
10603
10604 static void clock_offset_complete_evt(struct timeval *tv, uint16_t index,
10605                                         const void *data, uint8_t size)
10606 {
10607         const struct bt_hci_evt_clock_offset_complete *evt = data;
10608
10609         print_status(evt->status);
10610         print_handle(evt->handle);
10611         print_clock_offset(evt->clock_offset);
10612 }
10613
10614 static void conn_pkt_type_changed_evt(struct timeval *tv, uint16_t index,
10615                                         const void *data, uint8_t size)
10616 {
10617         const struct bt_hci_evt_conn_pkt_type_changed *evt = data;
10618
10619         print_status(evt->status);
10620         print_handle(evt->handle);
10621         print_pkt_type(evt->pkt_type);
10622 }
10623
10624 static void qos_violation_evt(struct timeval *tv, uint16_t index,
10625                                         const void *data, uint8_t size)
10626 {
10627         const struct bt_hci_evt_qos_violation *evt = data;
10628
10629         print_handle(evt->handle);
10630 }
10631
10632 static void pscan_mode_change_evt(struct timeval *tv, uint16_t index,
10633                                         const void *data, uint8_t size)
10634 {
10635         const struct bt_hci_evt_pscan_mode_change *evt = data;
10636
10637         print_bdaddr(evt->bdaddr);
10638         print_pscan_mode(evt->pscan_mode);
10639 }
10640
10641 static void pscan_rep_mode_change_evt(struct timeval *tv, uint16_t index,
10642                                         const void *data, uint8_t size)
10643 {
10644         const struct bt_hci_evt_pscan_rep_mode_change *evt = data;
10645
10646         print_bdaddr(evt->bdaddr);
10647         print_pscan_rep_mode(evt->pscan_rep_mode);
10648 }
10649
10650 static void flow_spec_complete_evt(struct timeval *tv, uint16_t index,
10651                                         const void *data, uint8_t size)
10652 {
10653         const struct bt_hci_evt_flow_spec_complete *evt = data;
10654
10655         print_status(evt->status);
10656         print_handle(evt->handle);
10657         print_field("Flags: 0x%2.2x", evt->flags);
10658
10659         print_flow_direction(evt->direction);
10660         print_service_type(evt->service_type);
10661
10662         print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
10663         print_field("Token bucket size: %d",
10664                                         le32_to_cpu(evt->token_bucket_size));
10665         print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
10666         print_field("Access latency: %d", le32_to_cpu(evt->access_latency));
10667 }
10668
10669 static void inquiry_result_with_rssi_evt(struct timeval *tv, uint16_t index,
10670                                         const void *data, uint8_t size)
10671 {
10672         const struct bt_hci_evt_inquiry_result_with_rssi *evt = data;
10673
10674         print_num_resp(evt->num_resp);
10675         print_bdaddr(evt->bdaddr);
10676         print_pscan_rep_mode(evt->pscan_rep_mode);
10677         print_pscan_period_mode(evt->pscan_period_mode);
10678         print_dev_class(evt->dev_class);
10679         print_clock_offset(evt->clock_offset);
10680         print_rssi(evt->rssi);
10681
10682         if (size > sizeof(*evt))
10683                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
10684 }
10685
10686 static void remote_ext_features_complete_evt(struct timeval *tv, uint16_t index,
10687                                         const void *data, uint8_t size)
10688 {
10689         const struct bt_hci_evt_remote_ext_features_complete *evt = data;
10690
10691         print_status(evt->status);
10692         print_handle(evt->handle);
10693         print_field("Page: %d/%d", evt->page, evt->max_page);
10694         print_features(evt->page, evt->features, 0x00);
10695 }
10696
10697 static void sync_conn_complete_evt(struct timeval *tv, uint16_t index,
10698                                         const void *data, uint8_t size)
10699 {
10700         const struct bt_hci_evt_sync_conn_complete *evt = data;
10701
10702         print_status(evt->status);
10703         print_handle(evt->handle);
10704         print_bdaddr(evt->bdaddr);
10705         print_link_type(evt->link_type);
10706         print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
10707         print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
10708         print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
10709         print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
10710         print_air_mode(evt->air_mode);
10711
10712         if (evt->status == 0x00)
10713                 assign_handle(index, le16_to_cpu(evt->handle), evt->link_type,
10714                                         (void *)evt->bdaddr, BDADDR_BREDR);
10715 }
10716
10717 static void sync_conn_changed_evt(struct timeval *tv, uint16_t index,
10718                                         const void *data, uint8_t size)
10719 {
10720         const struct bt_hci_evt_sync_conn_changed *evt = data;
10721
10722         print_status(evt->status);
10723         print_handle(evt->handle);
10724         print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
10725         print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
10726         print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
10727         print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
10728 }
10729
10730 static void sniff_subrating_evt(struct timeval *tv, uint16_t index,
10731                                         const void *data, uint8_t size)
10732 {
10733         const struct bt_hci_evt_sniff_subrating *evt = data;
10734
10735         print_status(evt->status);
10736         print_handle(evt->handle);
10737         print_slot_625("Max transmit latency", evt->max_tx_latency);
10738         print_slot_625("Max receive latency", evt->max_rx_latency);
10739         print_slot_625("Min remote timeout", evt->min_remote_timeout);
10740         print_slot_625("Min local timeout", evt->min_local_timeout);
10741 }
10742
10743 static void ext_inquiry_result_evt(struct timeval *tv, uint16_t index,
10744                                         const void *data, uint8_t size)
10745 {
10746         const struct bt_hci_evt_ext_inquiry_result *evt = data;
10747
10748         print_num_resp(evt->num_resp);
10749         print_bdaddr(evt->bdaddr);
10750         print_pscan_rep_mode(evt->pscan_rep_mode);
10751         print_pscan_period_mode(evt->pscan_period_mode);
10752         print_dev_class(evt->dev_class);
10753         print_clock_offset(evt->clock_offset);
10754         print_rssi(evt->rssi);
10755         print_eir(evt->data, sizeof(evt->data), false);
10756 }
10757
10758 static void encrypt_key_refresh_complete_evt(struct timeval *tv, uint16_t index,
10759                                         const void *data, uint8_t size)
10760 {
10761         const struct bt_hci_evt_encrypt_key_refresh_complete *evt = data;
10762
10763         print_status(evt->status);
10764         print_handle(evt->handle);
10765 }
10766
10767 static void io_capability_request_evt(struct timeval *tv, uint16_t index,
10768                                         const void *data, uint8_t size)
10769 {
10770         const struct bt_hci_evt_io_capability_request *evt = data;
10771
10772         print_bdaddr(evt->bdaddr);
10773 }
10774
10775 static void io_capability_response_evt(struct timeval *tv, uint16_t index,
10776                                         const void *data, uint8_t size)
10777 {
10778         const struct bt_hci_evt_io_capability_response *evt = data;
10779
10780         print_bdaddr(evt->bdaddr);
10781         print_io_capability(evt->capability);
10782         print_oob_data_response(evt->oob_data);
10783         print_authentication(evt->authentication);
10784 }
10785
10786 static void user_confirm_request_evt(struct timeval *tv, uint16_t index,
10787                                         const void *data, uint8_t size)
10788 {
10789         const struct bt_hci_evt_user_confirm_request *evt = data;
10790
10791         print_bdaddr(evt->bdaddr);
10792         print_passkey(evt->passkey);
10793 }
10794
10795 static void user_passkey_request_evt(struct timeval *tv, uint16_t index,
10796                                         const void *data, uint8_t size)
10797 {
10798         const struct bt_hci_evt_user_passkey_request *evt = data;
10799
10800         print_bdaddr(evt->bdaddr);
10801 }
10802
10803 static void remote_oob_data_request_evt(struct timeval *tv, uint16_t index,
10804                                         const void *data, uint8_t size)
10805 {
10806         const struct bt_hci_evt_remote_oob_data_request *evt = data;
10807
10808         print_bdaddr(evt->bdaddr);
10809 }
10810
10811 static void simple_pairing_complete_evt(struct timeval *tv, uint16_t index,
10812                                         const void *data, uint8_t size)
10813 {
10814         const struct bt_hci_evt_simple_pairing_complete *evt = data;
10815
10816         print_status(evt->status);
10817         print_bdaddr(evt->bdaddr);
10818 }
10819
10820 static void link_supv_timeout_changed_evt(struct timeval *tv, uint16_t index,
10821                                         const void *data, uint8_t size)
10822 {
10823         const struct bt_hci_evt_link_supv_timeout_changed *evt = data;
10824
10825         print_handle(evt->handle);
10826         print_timeout(evt->timeout);
10827 }
10828
10829 static void enhanced_flush_complete_evt(struct timeval *tv, uint16_t index,
10830                                         const void *data, uint8_t size)
10831 {
10832         const struct bt_hci_evt_enhanced_flush_complete *evt = data;
10833
10834         print_handle(evt->handle);
10835 }
10836
10837 static void user_passkey_notify_evt(struct timeval *tv, uint16_t index,
10838                                         const void *data, uint8_t size)
10839 {
10840         const struct bt_hci_evt_user_passkey_notify *evt = data;
10841
10842         print_bdaddr(evt->bdaddr);
10843         print_passkey(evt->passkey);
10844 }
10845
10846 static void keypress_notify_evt(struct timeval *tv, uint16_t index,
10847                                         const void *data, uint8_t size)
10848 {
10849         const struct bt_hci_evt_keypress_notify *evt = data;
10850         const char *str;
10851
10852         print_bdaddr(evt->bdaddr);
10853
10854         switch (evt->type) {
10855         case 0x00:
10856                 str = "Passkey entry started";
10857                 break;
10858         case 0x01:
10859                 str = "Passkey digit entered";
10860                 break;
10861         case 0x02:
10862                 str = "Passkey digit erased";
10863                 break;
10864         case 0x03:
10865                 str = "Passkey clared";
10866                 break;
10867         case 0x04:
10868                 str = "Passkey entry completed";
10869                 break;
10870         default:
10871                 str = "Reserved";
10872                 break;
10873         }
10874
10875         print_field("Notification type: %s (0x%2.2x)", str, evt->type);
10876 }
10877
10878 static void remote_host_features_notify_evt(struct timeval *tv, uint16_t index,
10879                                         const void *data, uint8_t size)
10880 {
10881         const struct bt_hci_evt_remote_host_features_notify *evt = data;
10882
10883         print_bdaddr(evt->bdaddr);
10884         print_features(1, evt->features, 0x00);
10885 }
10886
10887 static void phy_link_complete_evt(struct timeval *tv, uint16_t index,
10888                                         const void *data, uint8_t size)
10889 {
10890         const struct bt_hci_evt_phy_link_complete *evt = data;
10891
10892         print_status(evt->status);
10893         print_phy_handle(evt->phy_handle);
10894 }
10895
10896 static void channel_selected_evt(struct timeval *tv, uint16_t index,
10897                                         const void *data, uint8_t size)
10898 {
10899         const struct bt_hci_evt_channel_selected *evt = data;
10900
10901         print_phy_handle(evt->phy_handle);
10902 }
10903
10904 static void disconn_phy_link_complete_evt(struct timeval *tv, uint16_t index,
10905                                         const void *data, uint8_t size)
10906 {
10907         const struct bt_hci_evt_disconn_phy_link_complete *evt = data;
10908
10909         print_status(evt->status);
10910         print_phy_handle(evt->phy_handle);
10911         print_reason(evt->reason);
10912 }
10913
10914 static void phy_link_loss_early_warning_evt(struct timeval *tv, uint16_t index,
10915                                         const void *data, uint8_t size)
10916 {
10917         const struct bt_hci_evt_phy_link_loss_early_warning *evt = data;
10918         const char *str;
10919
10920         print_phy_handle(evt->phy_handle);
10921
10922         switch (evt->reason) {
10923         case 0x00:
10924                 str = "Unknown";
10925                 break;
10926         case 0x01:
10927                 str = "Range related";
10928                 break;
10929         case 0x02:
10930                 str = "Bandwidth related";
10931                 break;
10932         case 0x03:
10933                 str = "Resolving conflict";
10934                 break;
10935         case 0x04:
10936                 str = "Interference";
10937                 break;
10938         default:
10939                 str = "Reserved";
10940                 break;
10941         }
10942
10943         print_field("Reason: %s (0x%2.2x)", str, evt->reason);
10944 }
10945
10946 static void phy_link_recovery_evt(struct timeval *tv, uint16_t index,
10947                                         const void *data, uint8_t size)
10948 {
10949         const struct bt_hci_evt_phy_link_recovery *evt = data;
10950
10951         print_phy_handle(evt->phy_handle);
10952 }
10953
10954 static void logic_link_complete_evt(struct timeval *tv, uint16_t index,
10955                                         const void *data, uint8_t size)
10956 {
10957         const struct bt_hci_evt_logic_link_complete *evt = data;
10958
10959         print_status(evt->status);
10960         print_handle(evt->handle);
10961         print_phy_handle(evt->phy_handle);
10962         print_field("TX flow spec: 0x%2.2x", evt->flow_spec);
10963 }
10964
10965 static void disconn_logic_link_complete_evt(struct timeval *tv, uint16_t index,
10966                                         const void *data, uint8_t size)
10967 {
10968         const struct bt_hci_evt_disconn_logic_link_complete *evt = data;
10969
10970         print_status(evt->status);
10971         print_handle(evt->handle);
10972         print_reason(evt->reason);
10973 }
10974
10975 static void flow_spec_modify_complete_evt(struct timeval *tv, uint16_t index,
10976                                         const void *data, uint8_t size)
10977 {
10978         const struct bt_hci_evt_flow_spec_modify_complete *evt = data;
10979
10980         print_status(evt->status);
10981         print_handle(evt->handle);
10982 }
10983
10984 static void num_completed_data_blocks_evt(struct timeval *tv, uint16_t index,
10985                                         const void *data, uint8_t size)
10986 {
10987         const struct bt_hci_evt_num_completed_data_blocks *evt = data;
10988
10989         print_field("Total num data blocks: %d",
10990                                 le16_to_cpu(evt->total_num_blocks));
10991         print_field("Num handles: %d", evt->num_handles);
10992         print_handle(evt->handle);
10993         print_field("Num packets: %d", evt->num_packets);
10994         print_field("Num blocks: %d", evt->num_blocks);
10995
10996         if (size > sizeof(*evt))
10997                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
10998 }
10999
11000 static void short_range_mode_change_evt(struct timeval *tv, uint16_t index,
11001                                         const void *data, uint8_t size)
11002 {
11003         const struct bt_hci_evt_short_range_mode_change *evt = data;
11004
11005         print_status(evt->status);
11006         print_phy_handle(evt->phy_handle);
11007         print_enable("Short range mode", evt->mode);
11008 }
11009
11010 static void amp_status_change_evt(struct timeval *tv, uint16_t index,
11011                                         const void *data, uint8_t size)
11012 {
11013         const struct bt_hci_evt_amp_status_change *evt = data;
11014
11015         print_status(evt->status);
11016         print_amp_status(evt->amp_status);
11017 }
11018
11019 static void triggered_clock_capture_evt(struct timeval *tv, uint16_t index,
11020                                         const void *data, uint8_t size)
11021 {
11022         const struct bt_hci_evt_triggered_clock_capture *evt = data;
11023
11024         print_handle(evt->handle);
11025         print_clock_type(evt->type);
11026         print_clock(evt->clock);
11027         print_clock_offset(evt->clock_offset);
11028 }
11029
11030 static void sync_train_complete_evt(struct timeval *tv, uint16_t index,
11031                                         const void *data, uint8_t size)
11032 {
11033         const struct bt_hci_evt_sync_train_complete *evt = data;
11034
11035         print_status(evt->status);
11036 }
11037
11038 static void sync_train_received_evt(struct timeval *tv, uint16_t index,
11039                                         const void *data, uint8_t size)
11040 {
11041         const struct bt_hci_evt_sync_train_received *evt = data;
11042
11043         print_status(evt->status);
11044         print_bdaddr(evt->bdaddr);
11045         print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
11046         print_channel_map(evt->map);
11047         print_lt_addr(evt->lt_addr);
11048         print_field("Next broadcast instant: 0x%4.4x",
11049                                         le16_to_cpu(evt->instant));
11050         print_interval(evt->interval);
11051         print_field("Service Data: 0x%2.2x", evt->service_data);
11052 }
11053
11054 static void peripheral_broadcast_receive_evt(struct timeval *tv, uint16_t index,
11055                                         const void *data, uint8_t size)
11056 {
11057         const struct bt_hci_evt_peripheral_broadcast_receive *evt = data;
11058
11059         print_bdaddr(evt->bdaddr);
11060         print_lt_addr(evt->lt_addr);
11061         print_field("Clock: 0x%8.8x", le32_to_cpu(evt->clock));
11062         print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
11063         print_field("Receive status: 0x%2.2x", evt->status);
11064         print_broadcast_fragment(evt->fragment);
11065         print_field("Length: %d", evt->length);
11066
11067         if (size - 18 != evt->length)
11068                 print_text(COLOR_ERROR, "invalid data size (%d != %d)",
11069                                                 size - 18, evt->length);
11070
11071         if (evt->lt_addr == 0x01 && evt->length == 17)
11072                 print_3d_broadcast(data + 18, size - 18);
11073         else
11074                 packet_hexdump(data + 18, size - 18);
11075 }
11076
11077 static void peripheral_broadcast_timeout_evt(struct timeval *tv, uint16_t index,
11078                                         const void *data, uint8_t size)
11079 {
11080         const struct bt_hci_evt_peripheral_broadcast_timeout *evt = data;
11081
11082         print_bdaddr(evt->bdaddr);
11083         print_lt_addr(evt->lt_addr);
11084 }
11085
11086 static void truncated_page_complete_evt(struct timeval *tv, uint16_t index,
11087                                         const void *data, uint8_t size)
11088 {
11089         const struct bt_hci_evt_truncated_page_complete *evt = data;
11090
11091         print_status(evt->status);
11092         print_bdaddr(evt->bdaddr);
11093 }
11094
11095 static void peripheral_page_response_timeout_evt(struct timeval *tv,
11096                                         uint16_t index, const void *data,
11097                                         uint8_t size)
11098 {
11099 }
11100
11101 static void channel_map_change_evt(struct timeval *tv, uint16_t index,
11102                                         const void *data, uint8_t size)
11103 {
11104         const struct bt_hci_evt_channel_map_change *evt = data;
11105
11106         print_channel_map(evt->map);
11107 }
11108
11109 static void inquiry_response_notify_evt(struct timeval *tv, uint16_t index,
11110                                         const void *data, uint8_t size)
11111 {
11112         const struct bt_hci_evt_inquiry_response_notify *evt = data;
11113
11114         print_iac(evt->lap);
11115         print_rssi(evt->rssi);
11116 }
11117
11118 static void auth_payload_timeout_expired_evt(struct timeval *tv, uint16_t index,
11119                                         const void *data, uint8_t size)
11120 {
11121         const struct bt_hci_evt_auth_payload_timeout_expired *evt = data;
11122
11123         print_handle(evt->handle);
11124 }
11125
11126 static void le_conn_complete_evt(struct timeval *tv, uint16_t index,
11127                                         const void *data, uint8_t size)
11128 {
11129         const struct bt_hci_evt_le_conn_complete *evt = data;
11130
11131         print_status(evt->status);
11132         print_handle(evt->handle);
11133         print_role(evt->role);
11134         print_peer_addr_type("Peer address type", evt->peer_addr_type);
11135         print_addr("Peer address", evt->peer_addr, evt->peer_addr_type);
11136         print_slot_125("Connection interval", evt->interval);
11137         print_conn_latency("Connection latency", evt->latency);
11138         print_field("Supervision timeout: %d msec (0x%4.4x)",
11139                                         le16_to_cpu(evt->supv_timeout) * 10,
11140                                         le16_to_cpu(evt->supv_timeout));
11141         print_field("Central clock accuracy: 0x%2.2x", evt->clock_accuracy);
11142
11143         if (evt->status == 0x00)
11144                 assign_handle(index, le16_to_cpu(evt->handle), 0x01,
11145                                 (void *)evt->peer_addr, evt->peer_addr_type);
11146 }
11147
11148 static void le_adv_report_evt(struct timeval *tv, uint16_t index,
11149                                         const void *data, uint8_t size)
11150 {
11151         const struct bt_hci_evt_le_adv_report *evt = data;
11152         uint8_t evt_len;
11153         int8_t *rssi;
11154
11155         print_num_reports(evt->num_reports);
11156
11157 report:
11158         print_adv_event_type("Event type", evt->event_type);
11159         print_peer_addr_type("Address type", evt->addr_type);
11160         print_addr("Address", evt->addr, evt->addr_type);
11161         print_field("Data length: %d", evt->data_len);
11162         print_eir(evt->data, evt->data_len, true);
11163
11164         rssi = (int8_t *) (evt->data + evt->data_len);
11165         print_rssi(*rssi);
11166
11167         evt_len = sizeof(*evt) + evt->data_len + 1;
11168
11169         if (size > evt_len) {
11170                 data += evt_len - 1;
11171                 size -= evt_len - 1;
11172                 evt = data;
11173                 goto report;
11174         }
11175 }
11176
11177 static void le_conn_update_complete_evt(struct timeval *tv, uint16_t index,
11178                                         const void *data, uint8_t size)
11179 {
11180         const struct bt_hci_evt_le_conn_update_complete *evt = data;
11181
11182         print_status(evt->status);
11183         print_handle(evt->handle);
11184         print_slot_125("Connection interval", evt->interval);
11185         print_conn_latency("Connection latency", evt->latency);
11186         print_field("Supervision timeout: %d msec (0x%4.4x)",
11187                                         le16_to_cpu(evt->supv_timeout) * 10,
11188                                         le16_to_cpu(evt->supv_timeout));
11189 }
11190
11191 static void le_remote_features_complete_evt(struct timeval *tv, uint16_t index,
11192                                         const void *data, uint8_t size)
11193 {
11194         const struct bt_hci_evt_le_remote_features_complete *evt = data;
11195
11196         print_status(evt->status);
11197         print_handle(evt->handle);
11198         print_features(0, evt->features, 0x01);
11199 }
11200
11201 static void le_long_term_key_request_evt(struct timeval *tv, uint16_t index,
11202                                         const void *data, uint8_t size)
11203 {
11204         const struct bt_hci_evt_le_long_term_key_request *evt = data;
11205
11206         print_handle(evt->handle);
11207         print_random_number(evt->rand);
11208         print_encrypted_diversifier(evt->ediv);
11209 }
11210
11211 static void le_conn_param_request_evt(struct timeval *tv, uint16_t index,
11212                                       const void *data, uint8_t size)
11213 {
11214         const struct bt_hci_evt_le_conn_param_request *evt = data;
11215
11216         print_handle(evt->handle);
11217         print_slot_125("Min connection interval", evt->min_interval);
11218         print_slot_125("Max connection interval", evt->max_interval);
11219         print_conn_latency("Connection latency", evt->latency);
11220         print_field("Supervision timeout: %d msec (0x%4.4x)",
11221                                         le16_to_cpu(evt->supv_timeout) * 10,
11222                                         le16_to_cpu(evt->supv_timeout));
11223 }
11224
11225 static void le_data_length_change_evt(struct timeval *tv, uint16_t index,
11226                                       const void *data, uint8_t size)
11227 {
11228         const struct bt_hci_evt_le_data_length_change *evt = data;
11229
11230         print_handle(evt->handle);
11231         print_field("Max TX octets: %d", le16_to_cpu(evt->max_tx_len));
11232         print_field("Max TX time: %d", le16_to_cpu(evt->max_tx_time));
11233         print_field("Max RX octets: %d", le16_to_cpu(evt->max_rx_len));
11234         print_field("Max RX time: %d", le16_to_cpu(evt->max_rx_time));
11235 }
11236
11237 static void le_read_local_pk256_complete_evt(struct timeval *tv, uint16_t index,
11238                                         const void *data, uint8_t size)
11239 {
11240         const struct bt_hci_evt_le_read_local_pk256_complete *evt = data;
11241
11242         print_status(evt->status);
11243         print_pk256("Local P-256 public key", evt->local_pk256);
11244 }
11245
11246 static void le_generate_dhkey_complete_evt(struct timeval *tv, uint16_t index,
11247                                         const void *data, uint8_t size)
11248 {
11249         const struct bt_hci_evt_le_generate_dhkey_complete *evt = data;
11250
11251         print_status(evt->status);
11252         print_dhkey(evt->dhkey);
11253 }
11254
11255 static void le_enhanced_conn_complete_evt(struct timeval *tv, uint16_t index,
11256                                         const void *data, uint8_t size)
11257 {
11258         const struct bt_hci_evt_le_enhanced_conn_complete *evt = data;
11259
11260         print_status(evt->status);
11261         print_handle(evt->handle);
11262         print_role(evt->role);
11263         print_peer_addr_type("Peer address type", evt->peer_addr_type);
11264         print_addr("Peer address", evt->peer_addr, evt->peer_addr_type);
11265         print_addr("Local resolvable private address", evt->local_rpa, 0x01);
11266         print_addr("Peer resolvable private address", evt->peer_rpa, 0x01);
11267         print_slot_125("Connection interval", evt->interval);
11268         print_conn_latency("Connection latency", evt->latency);
11269         print_field("Supervision timeout: %d msec (0x%4.4x)",
11270                                         le16_to_cpu(evt->supv_timeout) * 10,
11271                                         le16_to_cpu(evt->supv_timeout));
11272         print_field("Central clock accuracy: 0x%2.2x", evt->clock_accuracy);
11273
11274         if (evt->status == 0x00)
11275                 assign_handle(index, le16_to_cpu(evt->handle), 0x01,
11276                                 (void *)evt->peer_addr, evt->peer_addr_type);
11277 }
11278
11279 static void le_direct_adv_report_evt(struct timeval *tv, uint16_t index,
11280                                         const void *data, uint8_t size)
11281 {
11282         const struct bt_hci_evt_le_direct_adv_report *evt = data;
11283
11284         print_num_reports(evt->num_reports);
11285
11286         print_adv_event_type("Event type", evt->event_type);
11287         print_peer_addr_type("Address type", evt->addr_type);
11288         print_addr("Address", evt->addr, evt->addr_type);
11289         print_addr_type("Direct address type", evt->direct_addr_type);
11290         print_addr("Direct address", evt->direct_addr, evt->direct_addr_type);
11291         print_rssi(evt->rssi);
11292
11293         if (size > sizeof(*evt))
11294                 packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
11295 }
11296
11297 static void le_phy_update_complete_evt(struct timeval *tv, uint16_t index,
11298                                         const void *data, uint8_t size)
11299 {
11300         const struct bt_hci_evt_le_phy_update_complete *evt = data;
11301
11302         print_status(evt->status);
11303         print_handle(evt->handle);
11304         print_le_phy("TX PHY", evt->tx_phy);
11305         print_le_phy("RX PHY", evt->rx_phy);
11306 }
11307
11308 static const struct bitfield_data ext_adv_report_evt_type[] = {
11309         {  0, "Connectable"             },
11310         {  1, "Scannable"               },
11311         {  2, "Directed"        },
11312         {  3, "Scan response"   },
11313         {  4, "Use legacy advertising PDUs"     },
11314         { }
11315 };
11316
11317 static void print_ext_adv_report_evt_type(const char *indent, uint16_t flags)
11318 {
11319         uint16_t mask = flags;
11320         uint16_t props = flags;
11321         uint8_t data_status;
11322         const char *str;
11323         const char *color_on;
11324         int i;
11325
11326         print_field("%sEvent type: 0x%4.4x", indent, flags);
11327
11328         props &= 0x1f;
11329         print_field("%s  Props: 0x%4.4x", indent, props);
11330         for (i = 0; ext_adv_report_evt_type[i].str; i++) {
11331                 if (flags & (1 << ext_adv_report_evt_type[i].bit)) {
11332                         print_field("%s    %s", indent,
11333                                                 ext_adv_report_evt_type[i].str);
11334                         mask &= ~(1 << ext_adv_report_evt_type[i].bit);
11335                 }
11336         }
11337
11338         data_status = (flags >> 5) & 3;
11339         mask &= ~(data_status << 5);
11340
11341         switch (data_status) {
11342         case 0x00:
11343                 str = "Complete";
11344                 color_on = COLOR_GREEN;
11345                 break;
11346         case 0x01:
11347                 str = "Incomplete, more data to come";
11348                 color_on = COLOR_YELLOW;
11349                 break;
11350         case 0x02:
11351                 str = "Incomplete, data truncated, no more to come";
11352                 color_on = COLOR_RED;
11353                 break;
11354         default:
11355                 str = "Reserved";
11356                 color_on = COLOR_RED;
11357                 break;
11358         }
11359
11360         print_field("%s  Data status: %s%s%s", indent, color_on, str, COLOR_OFF);
11361
11362         if (mask)
11363                 print_text(COLOR_UNKNOWN_ADV_FLAG,
11364                                 "%s  Reserved (0x%4.4x)", indent, mask);
11365 }
11366
11367 static void print_legacy_adv_report_pdu(uint16_t flags)
11368 {
11369         const char *str;
11370
11371         if (!(flags & (1 << 4)))
11372                 return;
11373
11374         switch (flags) {
11375         case 0x10:
11376                 str = "ADV_NONCONN_IND";
11377                 break;
11378         case 0x12:
11379                 str = "ADV_SCAN_IND";
11380                 break;
11381         case 0x13:
11382                 str = "ADV_IND";
11383                 break;
11384         case 0x15:
11385                 str = "ADV_DIRECT_IND";
11386                 break;
11387         case 0x1a:
11388                 str = "SCAN_RSP to an ADV_IND";
11389                 break;
11390         case 0x1b:
11391                 str = "SCAN_RSP to an ADV_SCAN_IND";
11392                 break;
11393         default:
11394                 str = "Reserved";
11395                 break;
11396         }
11397
11398         print_field("  Legacy PDU Type: %s (0x%4.4x)", str, flags);
11399 }
11400
11401 static void le_ext_adv_report_evt(struct timeval *tv, uint16_t index,
11402                                         const void *data, uint8_t size)
11403 {
11404         const struct bt_hci_evt_le_ext_adv_report *evt = data;
11405         const struct bt_hci_le_ext_adv_report *report;
11406         const char *str;
11407         int i;
11408
11409         print_num_reports(evt->num_reports);
11410
11411         data += sizeof(evt->num_reports);
11412
11413         for (i = 0; i < evt->num_reports; ++i) {
11414                 report = data;
11415                 print_field("Entry %d", i);
11416                 print_ext_adv_report_evt_type("  ", report->event_type);
11417                 print_legacy_adv_report_pdu(report->event_type);
11418                 print_peer_addr_type("  Address type", report->addr_type);
11419                 print_addr("  Address", report->addr, report->addr_type);
11420
11421                 switch (report->primary_phy) {
11422                 case 0x01:
11423                         str = "LE 1M";
11424                         break;
11425                 case 0x03:
11426                         str = "LE Coded";
11427                         break;
11428                 default:
11429                         str = "Reserved";
11430                         break;
11431                 }
11432
11433                 print_field("  Primary PHY: %s", str);
11434
11435                 switch (report->secondary_phy) {
11436                 case 0x00:
11437                         str = "No packets";
11438                         break;
11439                 case 0x01:
11440                         str = "LE 1M";
11441                         break;
11442                 case 0x02:
11443                         str = "LE 2M";
11444                         break;
11445                 case 0x03:
11446                         str = "LE Coded";
11447                         break;
11448                 default:
11449                         str = "Reserved";
11450                         break;
11451                 }
11452
11453                 print_field("  Secondary PHY: %s", str);
11454
11455                 if (report->sid == 0xff)
11456                         print_field("  SID: no ADI field (0x%2.2x)",
11457                                                                 report->sid);
11458                 else if (report->sid > 0x0f)
11459                         print_field("  SID: Reserved (0x%2.2x)", report->sid);
11460                 else
11461                         print_field("  SID: 0x%2.2x", report->sid);
11462
11463                 print_field("  TX power: %d dBm", report->tx_power);
11464
11465                 if (report->rssi == 127)
11466                         print_field("  RSSI: not available (0x%2.2x)",
11467                                                         (uint8_t) report->rssi);
11468                 else if (report->rssi >= -127 && report->rssi <= 20)
11469                         print_field("  RSSI: %d dBm (0x%2.2x)",
11470                                         report->rssi, (uint8_t) report->rssi);
11471                 else
11472                         print_field("  RSSI: reserved (0x%2.2x)",
11473                                                         (uint8_t) report->rssi);
11474
11475                 print_slot_125("  Periodic advertising interval",
11476                                                         report->interval);
11477                 print_peer_addr_type("  Direct address type",
11478                                                 report->direct_addr_type);
11479                 print_addr("  Direct address", report->direct_addr,
11480                                                 report->direct_addr_type);
11481                 print_field("  Data length: 0x%2.2x", report->data_len);
11482                 data += sizeof(struct bt_hci_le_ext_adv_report);
11483                 packet_hexdump(data, report->data_len);
11484                 print_eir(data, report->data_len, true);
11485                 data += report->data_len;
11486         }
11487 }
11488
11489 static void le_pa_sync_evt(struct timeval *tv, uint16_t index,
11490                                 const void *data, uint8_t size)
11491 {
11492         const struct bt_hci_evt_le_per_sync_established *evt = data;
11493
11494         print_status(evt->status);
11495         print_field("Sync handle: %d", evt->handle);
11496         if (evt->sid > 0x0f)
11497                 print_field("Advertising SID: Reserved (0x%2.2x)", evt->sid);
11498         else
11499                 print_field("Advertising SID: 0x%2.2x", evt->sid);
11500
11501         print_peer_addr_type("Advertiser address type", evt->addr_type);
11502         print_addr("Advertiser address", evt->addr, evt->addr_type);
11503         print_le_phy("Advertiser PHY", evt->phy);
11504         print_slot_125("Periodic advertising interval", evt->interval);
11505         print_field("Advertiser clock accuracy: 0x%2.2x", evt->clock_accuracy);
11506 }
11507
11508 static void le_pa_report_evt(struct timeval *tv, uint16_t index,
11509                                 const void *data, uint8_t size)
11510 {
11511         const struct bt_hci_le_pa_report *evt = data;
11512         const char *color_on;
11513         const char *str;
11514
11515         print_field("Sync handle: %d", evt->handle);
11516         print_power_level(evt->tx_power, NULL);
11517         if (evt->rssi == 127)
11518                 print_field("RSSI: not available (0x%2.2x)",
11519                                                 (uint8_t) evt->rssi);
11520         else if (evt->rssi >= -127 && evt->rssi <= 20)
11521                 print_field("RSSI: %d dBm (0x%2.2x)",
11522                                 evt->rssi, (uint8_t) evt->rssi);
11523         else
11524                 print_field("RSSI: reserved (0x%2.2x)",
11525                                                 (uint8_t) evt->rssi);
11526
11527         switch (evt->cte_type) {
11528         case 0x00:
11529                 str = "AoA Constant Tone Extension";
11530                 break;
11531         case 0x01:
11532                 str = "AoA Constant Tone Extension with 1us slots";
11533                 break;
11534         case 0x02:
11535                 str = "AoD Constant Tone Extension with 2us slots";
11536                 break;
11537         case 0xff:
11538                 str = "No Constant Tone Extension";
11539                 break;
11540         default:
11541                 str = "Reserved";
11542                 break;
11543         }
11544
11545         print_field("CTE Type: %s (0x%2x)", str, evt->cte_type);
11546
11547         switch (evt->data_status) {
11548         case 0x00:
11549                 str = "Complete";
11550                 color_on = COLOR_GREEN;
11551                 break;
11552         case 0x01:
11553                 str = "Incomplete, more data to come";
11554                 color_on = COLOR_YELLOW;
11555                 break;
11556         case 0x02:
11557                 str = "Incomplete, data truncated, no more to come";
11558                 color_on = COLOR_RED;
11559                 break;
11560         default:
11561                 str = "Reserved";
11562                 color_on = COLOR_RED;
11563                 break;
11564         }
11565
11566         print_field("Data status: %s%s%s", color_on, str, COLOR_OFF);
11567         print_field("Data length: 0x%2.2x", evt->data_len);
11568         packet_hexdump(evt->data, evt->data_len);
11569 }
11570
11571 static void le_pa_sync_lost_evt(struct timeval *tv, uint16_t index,
11572                                         const void *data, uint8_t size)
11573 {
11574         const struct bt_hci_evt_le_per_sync_lost *evt = data;
11575
11576         print_field("Sync handle: %d", evt->handle);
11577 }
11578
11579 static void le_adv_set_term_evt(struct timeval *tv, uint16_t index,
11580                                         const void *data, uint8_t size)
11581 {
11582         const struct bt_hci_evt_le_adv_set_term *evt = data;
11583
11584         print_status(evt->status);
11585         print_field("Handle: %d", evt->handle);
11586         print_field("Connection handle: %d", evt->conn_handle);
11587         print_field("Number of completed extended advertising events: %d",
11588                         evt->num_evts);
11589 }
11590
11591 static void le_scan_req_received_evt(struct timeval *tv, uint16_t index,
11592                                         const void *data, uint8_t size)
11593 {
11594         const struct bt_hci_evt_le_scan_req_received *evt = data;
11595
11596         print_field("Handle: %d", evt->handle);
11597         print_peer_addr_type("Scanner address type", evt->scanner_addr_type);
11598         print_addr("Scanner address", evt->scanner_addr,
11599                                                         evt->scanner_addr_type);
11600 }
11601
11602 static void le_chan_select_alg_evt(struct timeval *tv, uint16_t index,
11603                                         const void *data, uint8_t size)
11604 {
11605         const struct bt_hci_evt_le_chan_select_alg *evt = data;
11606         const char *str;
11607
11608         print_handle(evt->handle);
11609
11610         switch (evt->algorithm) {
11611         case 0x00:
11612                 str = "#1";
11613                 break;
11614         case 0x01:
11615                 str = "#2";
11616                 break;
11617         default:
11618                 str = "Reserved";
11619                 break;
11620         }
11621
11622         print_field("Algorithm: %s (0x%2.2x)", str, evt->algorithm);
11623 }
11624
11625 static void le_cte_request_failed_evt(struct timeval *tv, uint16_t index,
11626                                         const void *data, uint8_t size)
11627 {
11628         const struct bt_hci_evt_le_cte_request_failed *evt = data;
11629
11630         print_status(evt->status);
11631         print_field("Connection handle: %d", evt->handle);
11632 }
11633
11634 static void le_pa_sync_trans_rec_evt(struct timeval *tv, uint16_t index,
11635                                         const void *data, uint8_t size)
11636 {
11637         const struct bt_hci_evt_le_pa_sync_trans_rec *evt = data;
11638
11639         print_status(evt->status);
11640         print_field("Handle: %d", evt->handle);
11641         print_field("Connection handle: %d", evt->handle);
11642         print_field("Service data: 0x%4.4x", evt->service_data);
11643         print_field("Sync handle: %d", evt->sync_handle);
11644         print_field("SID: 0x%2.2x", evt->sid);
11645         print_peer_addr_type("Address type:", evt->addr_type);
11646         print_addr("Address:", evt->addr, evt->addr_type);
11647         print_le_phy("PHY:", evt->phy);
11648         print_field("Periodic advertising Interval: %.3f",
11649                                                         1.25 * evt->interval);
11650         print_clock_accuracy(evt->clock_accuracy);
11651 }
11652
11653 static void le_cis_established_evt(struct timeval *tv, uint16_t index,
11654                                         const void *data, uint8_t size)
11655 {
11656         const struct bt_hci_evt_le_cis_established *evt = data;
11657
11658         print_status(evt->status);
11659         print_field("Connection Handle: %d", le16_to_cpu(evt->conn_handle));
11660         print_usec_interval("CIG Synchronization Delay", evt->cig_sync_delay);
11661         print_usec_interval("CIS Synchronization Delay", evt->cis_sync_delay);
11662         print_usec_interval("Central to Peripheral Latency", evt->c_latency);
11663         print_usec_interval("Peripheral to Central Latency", evt->p_latency);
11664         print_le_phy("Central to Peripheral PHY", evt->c_phy);
11665         print_le_phy("Peripheral to Central PHY", evt->p_phy);
11666         print_field("Number of Subevents: %u", evt->nse);
11667         print_field("Central to Peripheral Burst Number: %u", evt->c_bn);
11668         print_field("Peripheral to Central Burst Number: %u", evt->p_bn);
11669         print_field("Central to Peripheral Flush Timeout: %u", evt->c_ft);
11670         print_field("Peripheral to Central Flush Timeout: %u", evt->p_ft);
11671         print_field("Central to Peripheral MTU: %u", le16_to_cpu(evt->c_mtu));
11672         print_field("Peripheral to Central MTU: %u", le16_to_cpu(evt->p_mtu));
11673         print_slot_125("ISO Interval", evt->interval);
11674
11675         if (!evt->status)
11676                 assign_handle(index, le16_to_cpu(evt->conn_handle), 0x05,
11677                                         NULL, BDADDR_LE_PUBLIC);
11678 }
11679
11680 static void le_req_cis_evt(struct timeval *tv, uint16_t index,
11681                                         const void *data, uint8_t size)
11682 {
11683         const struct bt_hci_evt_le_cis_req *evt = data;
11684         struct packet_conn_data *conn;
11685
11686         print_field("ACL Handle: %d", le16_to_cpu(evt->acl_handle));
11687         print_field("CIS Handle: %d", le16_to_cpu(evt->cis_handle));
11688         print_field("CIG ID: 0x%2.2x", evt->cig_id);
11689         print_field("CIS ID: 0x%2.2x", evt->cis_id);
11690
11691         conn = packet_get_conn_data(evt->acl_handle);
11692         if (conn)
11693                 conn->link = evt->cis_handle;
11694 }
11695
11696 static void print_bis_handle(const void *data, int i)
11697 {
11698         uint16_t handle = get_le16(data);
11699
11700         print_field("Connection Handle #%d: %d", i, handle);
11701 }
11702
11703 static void le_big_complete_evt(struct timeval *tv, uint16_t index,
11704                                         const void *data, uint8_t size)
11705 {
11706         const struct bt_hci_evt_le_big_complete *evt = data;
11707
11708         print_status(evt->status);
11709         print_field("Handle: 0x%2.2x", evt->handle);
11710         print_usec_interval("BIG Synchronization Delay", evt->sync_delay);
11711         print_usec_interval("Transport Latency", evt->latency);
11712         print_le_phy("PHY", evt->phy);
11713         print_field("NSE: %u", evt->nse);
11714         print_field("BN: %u", evt->bn);
11715         print_field("PTO: %u", evt->pto);
11716         print_field("IRC: %u", evt->irc);
11717         print_field("Maximum PDU: %u", evt->max_pdu);
11718         print_slot_125("ISO Interval", evt->interval);
11719         print_list(evt->bis_handle, size, evt->num_bis,
11720                         sizeof(*evt->bis_handle), print_bis_handle);
11721
11722         if (!evt->status) {
11723                 int i;
11724
11725                 for (i = 0; i < evt->num_bis; i++)
11726                         assign_handle(index, le16_to_cpu(evt->bis_handle[i]),
11727                                         0x05, NULL, BDADDR_LE_PUBLIC);
11728         }
11729 }
11730
11731 static void le_big_terminate_evt(struct timeval *tv, uint16_t index,
11732                                         const void *data, uint8_t size)
11733 {
11734         const struct bt_hci_evt_le_big_terminate *evt = data;
11735
11736         print_field("BIG Handle: 0x%2.2x", evt->handle);
11737         print_reason(evt->reason);
11738 }
11739
11740 static void le_big_sync_estabilished_evt(struct timeval *tv, uint16_t index,
11741                                         const void *data, uint8_t size)
11742 {
11743         const struct bt_hci_evt_le_big_sync_estabilished *evt = data;
11744
11745         print_status(evt->status);
11746         print_field("BIG Handle: 0x%2.2x", evt->handle);
11747         print_usec_interval("Transport Latency", evt->latency);
11748         print_field("NSE: %u", evt->nse);
11749         print_field("BN: %u", evt->bn);
11750         print_field("PTO: %u", evt->bn);
11751         print_field("IRC: %u", evt->irc);
11752         print_field("Maximum PDU: %u", evt->max_pdu);
11753         print_slot_125("ISO Interval", evt->interval);
11754         print_list(evt->bis, size, evt->num_bis, sizeof(*evt->bis),
11755                                                 print_bis_handle);
11756
11757         if (!evt->status) {
11758                 int i;
11759
11760                 for (i = 0; i < evt->num_bis; i++)
11761                         assign_handle(index, le16_to_cpu(evt->bis[i]),
11762                                         0x05, NULL, BDADDR_LE_PUBLIC);
11763         }
11764 }
11765
11766 static void le_big_sync_lost_evt(struct timeval *tv, uint16_t index,
11767                                         const void *data, uint8_t size)
11768 {
11769         const struct bt_hci_evt_le_big_sync_lost *evt = data;
11770
11771         print_field("BIG Handle: 0x%2.2x", evt->big_handle);
11772         print_reason(evt->reason);
11773 }
11774
11775 static void le_req_sca_complete_evt(struct timeval *tv, uint16_t index,
11776                                         const void *data, uint8_t size)
11777 {
11778         const struct bt_hci_evt_le_req_peer_sca_complete *evt = data;
11779
11780         print_status(evt->status);
11781         print_field("Connection Handle: %d", le16_to_cpu(evt->handle));
11782         print_sca(evt->sca);
11783 }
11784
11785 static void le_big_info_evt(struct timeval *tv, uint16_t index,
11786                                         const void *data, uint8_t size)
11787 {
11788         const struct bt_hci_evt_le_big_info_adv_report *evt = data;
11789
11790         print_field("Sync Handle: 0x%4.4x", evt->sync_handle);
11791         print_field("Number BIS: %u", evt->num_bis);
11792         print_field("NSE: %u", evt->nse);
11793         print_slot_125("ISO Interval", evt->iso_interval);
11794         print_field("BN: %u", evt->bn);
11795         print_field("PTO: %u", evt->bn);
11796         print_field("IRC: %u", evt->irc);
11797         print_field("Maximum PDU: %u", evt->max_pdu);
11798         print_usec_interval("SDU Interval", evt->sdu_interval);
11799         print_field("Maximum SDU: %u", evt->max_sdu);
11800         print_le_phy("PHY", evt->phy);
11801         print_framing(evt->framing);
11802         print_field("Encryption: 0x%02x", evt->encryption);
11803 }
11804
11805 struct subevent_data {
11806         uint8_t subevent;
11807         const char *str;
11808         void (*func) (struct timeval *tv, uint16_t index, const void *data,
11809                                                         uint8_t size);
11810         uint8_t size;
11811         bool fixed;
11812 };
11813
11814 static void print_subevent(struct timeval *tv, uint16_t index,
11815                                 const struct subevent_data *subevent_data,
11816                                 const void *data, uint8_t size)
11817 {
11818         const char *subevent_color;
11819
11820         if (subevent_data->func)
11821                 subevent_color = COLOR_HCI_EVENT;
11822         else
11823                 subevent_color = COLOR_HCI_EVENT_UNKNOWN;
11824
11825         print_indent(6, subevent_color, "", subevent_data->str, COLOR_OFF,
11826                                         " (0x%2.2x)", subevent_data->subevent);
11827
11828         if (!subevent_data->func) {
11829                 packet_hexdump(data, size);
11830                 return;
11831         }
11832
11833         if (subevent_data->fixed) {
11834                 if (size != subevent_data->size) {
11835                         print_text(COLOR_ERROR, "invalid packet size");
11836                         packet_hexdump(data, size);
11837                         return;
11838                 }
11839         } else {
11840                 if (size < subevent_data->size) {
11841                         print_text(COLOR_ERROR, "too short packet");
11842                         packet_hexdump(data, size);
11843                         return;
11844                 }
11845         }
11846
11847         subevent_data->func(tv, index, data, size);
11848 }
11849
11850 static const struct subevent_data le_meta_event_table[] = {
11851         { 0x01, "LE Connection Complete",
11852                                 le_conn_complete_evt, 18, true },
11853         { 0x02, "LE Advertising Report",
11854                                 le_adv_report_evt, 1, false },
11855         { 0x03, "LE Connection Update Complete",
11856                                 le_conn_update_complete_evt, 9, true },
11857         { 0x04, "LE Read Remote Used Features",
11858                                 le_remote_features_complete_evt, 11, true },
11859         { 0x05, "LE Long Term Key Request",
11860                                 le_long_term_key_request_evt, 12, true },
11861         { 0x06, "LE Remote Connection Parameter Request",
11862                                 le_conn_param_request_evt, 10, true },
11863         { 0x07, "LE Data Length Change",
11864                                 le_data_length_change_evt, 10, true },
11865         { 0x08, "LE Read Local P-256 Public Key Complete",
11866                                 le_read_local_pk256_complete_evt, 65, true },
11867         { 0x09, "LE Generate DHKey Complete",
11868                                 le_generate_dhkey_complete_evt, 33, true },
11869         { 0x0a, "LE Enhanced Connection Complete",
11870                                 le_enhanced_conn_complete_evt, 30, true },
11871         { 0x0b, "LE Direct Advertising Report",
11872                                 le_direct_adv_report_evt, 1, false },
11873         { 0x0c, "LE PHY Update Complete",
11874                                 le_phy_update_complete_evt, 5, true},
11875         { 0x0d, "LE Extended Advertising Report",
11876                                 le_ext_adv_report_evt, 1, false},
11877         { 0x0e, "LE Periodic Advertising Sync Established",
11878                                 le_pa_sync_evt, 15, true },
11879         { 0x0f, "LE Periodic Advertising Report",
11880                                 le_pa_report_evt, 7, false},
11881         { 0x10, "LE Periodic Advertising Sync Lost",
11882                                 le_pa_sync_lost_evt, 2, true},
11883         { 0x11, "LE Scan Timeout" },
11884         { 0x12, "LE Advertising Set Terminated",
11885                                 le_adv_set_term_evt, 5, true},
11886         { 0x13, "LE Scan Request Received",
11887                                 le_scan_req_received_evt, 8, true},
11888         { 0x14, "LE Channel Selection Algorithm",
11889                                 le_chan_select_alg_evt, 3, true},
11890         { 0x17, "LE CTE Request Failed",
11891                                 le_cte_request_failed_evt, 3, true},
11892         { 0x18, "LE Periodic Advertising Sync Transfer Received",
11893                                         le_pa_sync_trans_rec_evt, 19,
11894                                         true},
11895         { BT_HCI_EVT_LE_CIS_ESTABLISHED,
11896                                 "LE Connected Isochronous Stream Established",
11897                                 le_cis_established_evt,
11898                                 sizeof(struct bt_hci_evt_le_cis_established),
11899                                 true },
11900         { BT_HCI_EVT_LE_CIS_REQ, "LE Connected Isochronous Stream Request",
11901                                 le_req_cis_evt,
11902                                 sizeof(struct bt_hci_evt_le_cis_req),
11903                                 true },
11904         { BT_HCI_EVT_LE_BIG_COMPLETE,
11905                                 "LE Broadcast Isochronous Group Complete",
11906                                 le_big_complete_evt,
11907                                 sizeof(struct bt_hci_evt_le_big_complete) },
11908         { BT_HCI_EVT_LE_BIG_TERMINATE,
11909                                 "LE Broadcast Isochronous Group Terminate",
11910                                 le_big_terminate_evt,
11911                                 sizeof(struct bt_hci_evt_le_big_terminate) },
11912         { BT_HCI_EVT_LE_BIG_SYNC_ESTABILISHED,
11913                                 "LE Broadcast Isochronous Group Sync "
11914                                 "Estabilished", le_big_sync_estabilished_evt,
11915                                 sizeof(struct bt_hci_evt_le_big_sync_lost) },
11916         { BT_HCI_EVT_LE_BIG_SYNC_LOST,
11917                                 "LE Broadcast Isochronous Group Sync Lost",
11918                                 le_big_sync_lost_evt,
11919                                 sizeof(struct bt_hci_evt_le_big_sync_lost) },
11920         { BT_HCI_EVT_LE_REQ_PEER_SCA_COMPLETE,
11921                                 "LE Request Peer SCA Complete",
11922                                 le_req_sca_complete_evt,
11923                                 sizeof(
11924                                 struct bt_hci_evt_le_req_peer_sca_complete)},
11925         { BT_HCI_EVT_LE_BIG_INFO_ADV_REPORT,
11926                 "LE Broadcast Isochronous Group Info Advertising Report",
11927                 le_big_info_evt,
11928                 sizeof(struct bt_hci_evt_le_big_info_adv_report) },
11929         { }
11930 };
11931
11932 static void le_meta_event_evt(struct timeval *tv, uint16_t index,
11933                                 const void *data, uint8_t size)
11934 {
11935         uint8_t subevent = *((const uint8_t *) data);
11936         struct subevent_data unknown;
11937         const struct subevent_data *subevent_data = &unknown;
11938         int i;
11939
11940         unknown.subevent = subevent;
11941         unknown.str = "Unknown";
11942         unknown.func = NULL;
11943         unknown.size = 0;
11944         unknown.fixed = true;
11945
11946         for (i = 0; le_meta_event_table[i].str; i++) {
11947                 if (le_meta_event_table[i].subevent == subevent) {
11948                         subevent_data = &le_meta_event_table[i];
11949                         break;
11950                 }
11951         }
11952
11953         print_subevent(tv, index, subevent_data, data + 1, size - 1);
11954 }
11955
11956 static void vendor_evt(struct timeval *tv, uint16_t index,
11957                                 const void *data, uint8_t size)
11958 {
11959         struct subevent_data vendor_data;
11960         char vendor_str[150];
11961         int consumed_size;
11962         const struct vendor_evt *vnd = current_vendor_evt(data, &consumed_size);
11963
11964         if (vnd) {
11965                 const char *str = current_vendor_evt_str();
11966
11967                 if (str) {
11968                         snprintf(vendor_str, sizeof(vendor_str),
11969                                                 "%s %s", str, vnd->str);
11970                         vendor_data.str = vendor_str;
11971                 } else
11972                         vendor_data.str = vnd->str;
11973                 vendor_data.subevent = vnd->evt;
11974                 vendor_data.func = vnd->evt_func;
11975                 vendor_data.size = vnd->evt_size;
11976                 vendor_data.fixed = vnd->evt_fixed;
11977
11978                 print_subevent(tv, index, &vendor_data, data + consumed_size,
11979                                                         size - consumed_size);
11980         } else {
11981                 uint16_t manufacturer;
11982
11983                 if (index_current < MAX_INDEX)
11984                         manufacturer = index_list[index_current].manufacturer;
11985                 else
11986                         manufacturer = fallback_manufacturer;
11987
11988                 vendor_event(manufacturer, data, size);
11989         }
11990 }
11991
11992 struct event_data {
11993         uint8_t event;
11994         const char *str;
11995         void (*func) (struct timeval *tv, uint16_t index, const void *data,
11996                                                         uint8_t size);
11997         uint8_t size;
11998         bool fixed;
11999 };
12000
12001 static const struct event_data event_table[] = {
12002         { 0x01, "Inquiry Complete",
12003                                 inquiry_complete_evt, 1, true },
12004         { 0x02, "Inquiry Result",
12005                                 inquiry_result_evt, 1, false },
12006         { 0x03, "Connect Complete",
12007                                 conn_complete_evt, 11, true },
12008         { 0x04, "Connect Request",
12009                                 conn_request_evt, 10, true },
12010         { 0x05, "Disconnect Complete",
12011                                 disconnect_complete_evt, 4, true },
12012         { 0x06, "Auth Complete",
12013                                 auth_complete_evt, 3, true },
12014         { 0x07, "Remote Name Req Complete",
12015                                 remote_name_request_complete_evt, 255, true },
12016         { 0x08, "Encryption Change",
12017                                 encrypt_change_evt, 4, true },
12018         { 0x09, "Change Connection Link Key Complete",
12019                                 change_conn_link_key_complete_evt, 3, true },
12020         { 0x0a, "Link Key Type Changed",
12021                                 link_key_type_changed_evt, 4, true },
12022         { 0x0b, "Read Remote Supported Features",
12023                                 remote_features_complete_evt, 11, true },
12024         { 0x0c, "Read Remote Version Complete",
12025                                 remote_version_complete_evt, 8, true },
12026         { 0x0d, "QoS Setup Complete",
12027                                 qos_setup_complete_evt, 21, true },
12028         { 0x0e, "Command Complete",
12029                                 cmd_complete_evt, 3, false },
12030         { 0x0f, "Command Status",
12031                                 cmd_status_evt, 4, true },
12032         { 0x10, "Hardware Error",
12033                                 hardware_error_evt, 1, true },
12034         { 0x11, "Flush Occurred",
12035                                 flush_occurred_evt, 2, true },
12036         { 0x12, "Role Change",
12037                                 role_change_evt, 8, true },
12038         { 0x13, "Number of Completed Packets",
12039                                 num_completed_packets_evt, 1, false },
12040         { 0x14, "Mode Change",
12041                                 mode_change_evt, 6, true },
12042         { 0x15, "Return Link Keys",
12043                                 return_link_keys_evt, 1, false },
12044         { 0x16, "PIN Code Request",
12045                                 pin_code_request_evt, 6, true },
12046         { 0x17, "Link Key Request",
12047                                 link_key_request_evt, 6, true },
12048         { 0x18, "Link Key Notification",
12049                                 link_key_notify_evt, 23, true },
12050         { 0x19, "Loopback Command",
12051                                 loopback_command_evt, 3, false },
12052         { 0x1a, "Data Buffer Overflow",
12053                                 data_buffer_overflow_evt, 1, true },
12054         { 0x1b, "Max Slots Change",
12055                                 max_slots_change_evt, 3, true },
12056         { 0x1c, "Read Clock Offset Complete",
12057                                 clock_offset_complete_evt, 5, true },
12058         { 0x1d, "Connection Packet Type Changed",
12059                                 conn_pkt_type_changed_evt, 5, true },
12060         { 0x1e, "QoS Violation",
12061                                 qos_violation_evt, 2, true },
12062         { 0x1f, "Page Scan Mode Change",
12063                                 pscan_mode_change_evt, 7, true },
12064         { 0x20, "Page Scan Repetition Mode Change",
12065                                 pscan_rep_mode_change_evt, 7, true },
12066         { 0x21, "Flow Specification Complete",
12067                                 flow_spec_complete_evt, 22, true },
12068         { 0x22, "Inquiry Result with RSSI",
12069                                 inquiry_result_with_rssi_evt, 1, false },
12070         { 0x23, "Read Remote Extended Features",
12071                                 remote_ext_features_complete_evt, 13, true },
12072         { 0x2c, "Synchronous Connect Complete",
12073                                 sync_conn_complete_evt, 17, true },
12074         { 0x2d, "Synchronous Connect Changed",
12075                                 sync_conn_changed_evt, 9, true },
12076         { 0x2e, "Sniff Subrating",
12077                                 sniff_subrating_evt, 11, true },
12078         { 0x2f, "Extended Inquiry Result",
12079                                 ext_inquiry_result_evt, 1, false },
12080         { 0x30, "Encryption Key Refresh Complete",
12081                                 encrypt_key_refresh_complete_evt, 3, true },
12082         { 0x31, "IO Capability Request",
12083                                 io_capability_request_evt, 6, true },
12084         { 0x32, "IO Capability Response",
12085                                 io_capability_response_evt, 9, true },
12086         { 0x33, "User Confirmation Request",
12087                                 user_confirm_request_evt, 10, true },
12088         { 0x34, "User Passkey Request",
12089                                 user_passkey_request_evt, 6, true },
12090         { 0x35, "Remote OOB Data Request",
12091                                 remote_oob_data_request_evt, 6, true },
12092         { 0x36, "Simple Pairing Complete",
12093                                 simple_pairing_complete_evt, 7, true },
12094         { 0x38, "Link Supervision Timeout Changed",
12095                                 link_supv_timeout_changed_evt, 4, true },
12096         { 0x39, "Enhanced Flush Complete",
12097                                 enhanced_flush_complete_evt, 2, true },
12098         { 0x3b, "User Passkey Notification",
12099                                 user_passkey_notify_evt, 10, true },
12100         { 0x3c, "Keypress Notification",
12101                                 keypress_notify_evt, 7, true },
12102         { 0x3d, "Remote Host Supported Features",
12103                                 remote_host_features_notify_evt, 14, true },
12104         { 0x3e, "LE Meta Event",
12105                                 le_meta_event_evt, 1, false },
12106         { 0x40, "Physical Link Complete",
12107                                 phy_link_complete_evt, 2, true },
12108         { 0x41, "Channel Selected",
12109                                 channel_selected_evt, 1, true },
12110         { 0x42, "Disconnect Physical Link Complete",
12111                                 disconn_phy_link_complete_evt, 3, true },
12112         { 0x43, "Physical Link Loss Early Warning",
12113                                 phy_link_loss_early_warning_evt, 2, true },
12114         { 0x44, "Physical Link Recovery",
12115                                 phy_link_recovery_evt, 1, true },
12116         { 0x45, "Logical Link Complete",
12117                                 logic_link_complete_evt, 5, true },
12118         { 0x46, "Disconnect Logical Link Complete",
12119                                 disconn_logic_link_complete_evt, 4, true },
12120         { 0x47, "Flow Specification Modify Complete",
12121                                 flow_spec_modify_complete_evt, 3, true },
12122         { 0x48, "Number of Completed Data Blocks",
12123                                 num_completed_data_blocks_evt, 3, false },
12124         { 0x49, "AMP Start Test" },
12125         { 0x4a, "AMP Test End" },
12126         { 0x4b, "AMP Receiver Report" },
12127         { 0x4c, "Short Range Mode Change Complete",
12128                                 short_range_mode_change_evt, 3, true },
12129         { 0x4d, "AMP Status Change",
12130                                 amp_status_change_evt, 2, true },
12131         { 0x4e, "Triggered Clock Capture",
12132                                 triggered_clock_capture_evt, 9, true },
12133         { 0x4f, "Synchronization Train Complete",
12134                                 sync_train_complete_evt, 1, true },
12135         { 0x50, "Synchronization Train Received",
12136                                 sync_train_received_evt, 29, true },
12137         { 0x51, "Connectionless Peripheral Broadcast Receive",
12138                                 peripheral_broadcast_receive_evt, 18, false },
12139         { 0x52, "Connectionless Peripheral Broadcast Timeout",
12140                                 peripheral_broadcast_timeout_evt, 7, true },
12141         { 0x53, "Truncated Page Complete",
12142                                 truncated_page_complete_evt, 7, true },
12143         { 0x54, "Peripheral Page Response Timeout",
12144                                 peripheral_page_response_timeout_evt, 0, true },
12145         { 0x55, "Connectionless Peripheral Broadcast Channel Map Change",
12146                                 channel_map_change_evt, 10, true },
12147         { 0x56, "Inquiry Response Notification",
12148                                 inquiry_response_notify_evt, 4, true },
12149         { 0x57, "Authenticated Payload Timeout Expired",
12150                                 auth_payload_timeout_expired_evt, 2, true },
12151         { 0x58, "SAM Status Change" },
12152         { 0xfe, "Testing" },
12153         { 0xff, "Vendor", vendor_evt, 0, false },
12154         { }
12155 };
12156
12157 void packet_new_index(struct timeval *tv, uint16_t index, const char *label,
12158                                 uint8_t type, uint8_t bus, const char *name)
12159 {
12160         char details[48];
12161
12162         sprintf(details, "(%s,%s,%s)", hci_typetostr(type),
12163                                         hci_bustostr(bus), name);
12164
12165         print_packet(tv, NULL, '=', index, NULL, COLOR_NEW_INDEX,
12166                                         "New Index", label, details);
12167 }
12168
12169 void packet_del_index(struct timeval *tv, uint16_t index, const char *label)
12170 {
12171         print_packet(tv, NULL, '=', index, NULL, COLOR_DEL_INDEX,
12172                                         "Delete Index", label, NULL);
12173 }
12174
12175 void packet_open_index(struct timeval *tv, uint16_t index, const char *label)
12176 {
12177         print_packet(tv, NULL, '=', index, NULL, COLOR_OPEN_INDEX,
12178                                         "Open Index", label, NULL);
12179 }
12180
12181 void packet_close_index(struct timeval *tv, uint16_t index, const char *label)
12182 {
12183         print_packet(tv, NULL, '=', index, NULL, COLOR_CLOSE_INDEX,
12184                                         "Close Index", label, NULL);
12185 }
12186
12187 void packet_index_info(struct timeval *tv, uint16_t index, const char *label,
12188                                                         uint16_t manufacturer)
12189 {
12190         char details[128];
12191
12192         sprintf(details, "(%s)", bt_compidtostr(manufacturer));
12193
12194         print_packet(tv, NULL, '=', index, NULL, COLOR_INDEX_INFO,
12195                                         "Index Info", label, details);
12196 }
12197
12198 void packet_vendor_diag(struct timeval *tv, uint16_t index,
12199                                         uint16_t manufacturer,
12200                                         const void *data, uint16_t size)
12201 {
12202         char extra_str[16];
12203
12204         sprintf(extra_str, "(len %d)", size);
12205
12206         print_packet(tv, NULL, '=', index, NULL, COLOR_VENDOR_DIAG,
12207                                         "Vendor Diagnostic", NULL, extra_str);
12208
12209         switch (manufacturer) {
12210         case 15:
12211                 broadcom_lm_diag(data, size);
12212                 break;
12213         default:
12214                 packet_hexdump(data, size);
12215                 break;
12216         }
12217 }
12218
12219 void packet_system_note(struct timeval *tv, struct ucred *cred,
12220                                         uint16_t index, const void *message)
12221 {
12222         print_packet(tv, cred, '=', index, NULL, COLOR_SYSTEM_NOTE,
12223                                         "Note", message, NULL);
12224 }
12225
12226 struct monitor_l2cap_hdr {
12227         uint16_t cid;
12228         uint16_t psm;
12229 } __attribute__((packed));
12230
12231 static void packet_decode(struct timeval *tv, struct ucred *cred, char dir,
12232                                 uint16_t index, const char *color,
12233                                 const char *label, const void *data,
12234                                 uint16_t size)
12235 {
12236         const struct monitor_l2cap_hdr *hdr = data;
12237
12238         if (size < sizeof(*hdr)) {
12239                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12240                         "Malformed User Data packet", NULL, NULL);
12241         }
12242
12243         print_packet(tv, cred, dir, index, NULL, COLOR_HCI_ACLDATA, label,
12244                                 dir == '>' ? "User Data RX" : "User Data TX",
12245                                 NULL);
12246
12247         /* Discard last byte since it just a filler */
12248         l2cap_frame(index, dir == '>', 0,
12249                         le16_to_cpu(hdr->cid), le16_to_cpu(hdr->psm),
12250                         data + sizeof(*hdr), size - (sizeof(*hdr) + 1));
12251 }
12252
12253 void packet_user_logging(struct timeval *tv, struct ucred *cred,
12254                                         uint16_t index, uint8_t priority,
12255                                         const char *ident, const void *data,
12256                                         uint16_t size)
12257 {
12258         const char *label;
12259         const char *color;
12260
12261         if (priority > priority_level)
12262                 return;
12263
12264         switch (priority) {
12265         case BTSNOOP_PRIORITY_ERR:
12266                 color = COLOR_ERROR;
12267                 break;
12268         case BTSNOOP_PRIORITY_WARNING:
12269                 color = COLOR_WARN;
12270                 break;
12271         case BTSNOOP_PRIORITY_INFO:
12272                 color = COLOR_INFO;
12273                 break;
12274         case BTSNOOP_PRIORITY_DEBUG:
12275                 color = COLOR_DEBUG;
12276                 break;
12277         default:
12278                 color = COLOR_WHITE_BG;
12279                 break;
12280         }
12281
12282         if (cred) {
12283                 label = NULL;
12284         } else {
12285                 if (ident)
12286                         label = ident;
12287                 else
12288                         label = "Message";
12289         }
12290
12291         if (ident && (ident[0] == '<' || ident[0] == '>')) {
12292                 packet_decode(tv, cred, ident[0], index, color,
12293                               label == ident ? &ident[2] : label,
12294                               data, size);
12295                 return;
12296         }
12297
12298         print_packet(tv, cred, '=', index, NULL, color, label, data, NULL);
12299 }
12300
12301 void packet_hci_command(struct timeval *tv, struct ucred *cred, uint16_t index,
12302                                         const void *data, uint16_t size)
12303 {
12304         const hci_command_hdr *hdr = data;
12305         uint16_t opcode = le16_to_cpu(hdr->opcode);
12306         uint16_t ogf = cmd_opcode_ogf(opcode);
12307         uint16_t ocf = cmd_opcode_ocf(opcode);
12308         struct opcode_data vendor_data;
12309         const struct opcode_data *opcode_data = NULL;
12310         const char *opcode_color, *opcode_str;
12311         char extra_str[25], vendor_str[150];
12312         int i;
12313
12314         if (index >= MAX_INDEX) {
12315                 print_field("Invalid index (%d).", index);
12316                 return;
12317         }
12318
12319         index_list[index].frame++;
12320
12321         if (size < HCI_COMMAND_HDR_SIZE || size > BTSNOOP_MAX_PACKET_SIZE) {
12322                 sprintf(extra_str, "(len %d)", size);
12323                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12324                         "Malformed HCI Command packet", NULL, extra_str);
12325                 return;
12326         }
12327
12328         data += HCI_COMMAND_HDR_SIZE;
12329         size -= HCI_COMMAND_HDR_SIZE;
12330
12331         for (i = 0; opcode_table[i].str; i++) {
12332                 if (opcode_table[i].opcode == opcode) {
12333                         opcode_data = &opcode_table[i];
12334                         break;
12335                 }
12336         }
12337
12338         if (opcode_data) {
12339                 if (opcode_data->cmd_func)
12340                         opcode_color = COLOR_HCI_COMMAND;
12341                 else
12342                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12343                 opcode_str = opcode_data->str;
12344         } else {
12345                 if (ogf == 0x3f) {
12346                         const struct vendor_ocf *vnd = current_vendor_ocf(ocf);
12347
12348                         if (vnd) {
12349                                 const char *str = current_vendor_str(ocf);
12350
12351                                 if (str) {
12352                                         snprintf(vendor_str, sizeof(vendor_str),
12353                                                         "%s %s", str, vnd->str);
12354                                         vendor_data.str = vendor_str;
12355                                 } else
12356                                         vendor_data.str = vnd->str;
12357                                 vendor_data.cmd_func = vnd->cmd_func;
12358                                 vendor_data.cmd_size = vnd->cmd_size;
12359                                 vendor_data.cmd_fixed = vnd->cmd_fixed;
12360
12361                                 opcode_data = &vendor_data;
12362
12363                                 if (opcode_data->cmd_func)
12364                                         opcode_color = COLOR_HCI_COMMAND;
12365                                 else
12366                                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12367                                 opcode_str = opcode_data->str;
12368                         } else {
12369                                 opcode_color = COLOR_HCI_COMMAND;
12370                                 opcode_str = "Vendor";
12371                         }
12372                 } else {
12373                         opcode_color = COLOR_HCI_COMMAND_UNKNOWN;
12374                         opcode_str = "Unknown";
12375                 }
12376         }
12377
12378         sprintf(extra_str, "(0x%2.2x|0x%4.4x) plen %d", ogf, ocf, hdr->plen);
12379
12380         print_packet(tv, cred, '<', index, NULL, opcode_color, "HCI Command",
12381                                                         opcode_str, extra_str);
12382
12383         if (!opcode_data || !opcode_data->cmd_func) {
12384                 packet_hexdump(data, size);
12385                 return;
12386         }
12387
12388         if (size != hdr->plen) {
12389                 print_text(COLOR_ERROR, "invalid packet size (%u != %u)", size,
12390                                                                 hdr->plen);
12391                 packet_hexdump(data, size);
12392                 return;
12393         }
12394
12395         if (opcode_data->cmd_fixed) {
12396                 if (hdr->plen != opcode_data->cmd_size) {
12397                         print_text(COLOR_ERROR, "invalid packet size");
12398                         packet_hexdump(data, size);
12399                         return;
12400                 }
12401         } else {
12402                 if (hdr->plen < opcode_data->cmd_size) {
12403                         print_text(COLOR_ERROR, "too short packet");
12404                         packet_hexdump(data, size);
12405                         return;
12406                 }
12407         }
12408
12409         opcode_data->cmd_func(index, data, hdr->plen);
12410 }
12411
12412 void packet_hci_event(struct timeval *tv, struct ucred *cred, uint16_t index,
12413                                         const void *data, uint16_t size)
12414 {
12415         const hci_event_hdr *hdr = data;
12416         const struct event_data *event_data = NULL;
12417         const char *event_color, *event_str;
12418         char extra_str[25];
12419         int i;
12420
12421         if (index >= MAX_INDEX) {
12422                 print_field("Invalid index (%d).", index);
12423                 return;
12424         }
12425
12426
12427         index_list[index].frame++;
12428
12429         if (size < HCI_EVENT_HDR_SIZE) {
12430                 sprintf(extra_str, "(len %d)", size);
12431                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12432                         "Malformed HCI Event packet", NULL, extra_str);
12433                 packet_hexdump(data, size);
12434                 return;
12435         }
12436
12437         data += HCI_EVENT_HDR_SIZE;
12438         size -= HCI_EVENT_HDR_SIZE;
12439
12440         for (i = 0; event_table[i].str; i++) {
12441                 if (event_table[i].event == hdr->evt) {
12442                         event_data = &event_table[i];
12443                         break;
12444                 }
12445         }
12446
12447         if (event_data) {
12448                 if (event_data->func)
12449                         event_color = COLOR_HCI_EVENT;
12450                 else
12451                         event_color = COLOR_HCI_EVENT_UNKNOWN;
12452                 event_str = event_data->str;
12453         } else {
12454                 event_color = COLOR_HCI_EVENT_UNKNOWN;
12455                 event_str = "Unknown";
12456         }
12457
12458         sprintf(extra_str, "(0x%2.2x) plen %d", hdr->evt, hdr->plen);
12459
12460         print_packet(tv, cred, '>', index, NULL, event_color, "HCI Event",
12461                                                 event_str, extra_str);
12462
12463         if (!event_data || !event_data->func) {
12464                 packet_hexdump(data, size);
12465                 return;
12466         }
12467
12468         if (size != hdr->plen) {
12469                 print_text(COLOR_ERROR, "invalid packet size (%u != %u)", size,
12470                                                                 hdr->plen);
12471                 packet_hexdump(data, size);
12472                 return;
12473         }
12474
12475         if (event_data->fixed) {
12476                 if (hdr->plen != event_data->size) {
12477                         print_text(COLOR_ERROR, "invalid packet size");
12478                         packet_hexdump(data, size);
12479                         return;
12480                 }
12481         } else {
12482                 if (hdr->plen < event_data->size) {
12483                         print_text(COLOR_ERROR, "too short packet");
12484                         packet_hexdump(data, size);
12485                         return;
12486                 }
12487         }
12488
12489         event_data->func(tv, index, data, hdr->plen);
12490 }
12491
12492 static void packet_enqueue_tx(struct timeval *tv, uint16_t handle,
12493                                 size_t num, uint16_t len)
12494 {
12495         struct packet_conn_data *conn;
12496         struct packet_frame *frame;
12497
12498         conn = packet_get_conn_data(handle);
12499         if (!conn)
12500                 return;
12501
12502         if (!conn->tx_q)
12503                 conn->tx_q = queue_new();
12504
12505         frame = new0(struct packet_frame, 1);
12506         if (tv)
12507                 memcpy(&frame->tv, tv, sizeof(*tv));
12508         frame->num = num;
12509         frame->len = len;
12510         queue_push_tail(conn->tx_q, frame);
12511 }
12512
12513 void packet_hci_acldata(struct timeval *tv, struct ucred *cred, uint16_t index,
12514                                 bool in, const void *data, uint16_t size)
12515 {
12516         const struct bt_hci_acl_hdr *hdr = data;
12517         uint16_t handle = le16_to_cpu(hdr->handle);
12518         uint16_t dlen = le16_to_cpu(hdr->dlen);
12519         uint8_t flags = acl_flags(handle);
12520         char handle_str[16], extra_str[32];
12521
12522         if (index >= MAX_INDEX) {
12523                 print_field("Invalid index (%d).", index);
12524                 return;
12525         }
12526
12527         index_list[index].frame++;
12528
12529         if (size < HCI_ACL_HDR_SIZE) {
12530                 if (in)
12531                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12532                                 "Malformed ACL Data RX packet", NULL, NULL);
12533                 else
12534                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12535                                 "Malformed ACL Data TX packet", NULL, NULL);
12536                 packet_hexdump(data, size);
12537                 return;
12538         }
12539
12540         data += HCI_ACL_HDR_SIZE;
12541         size -= HCI_ACL_HDR_SIZE;
12542
12543         sprintf(handle_str, "Handle %d", acl_handle(handle));
12544         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, dlen);
12545
12546         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_ACLDATA,
12547                                 in ? "ACL Data RX" : "ACL Data TX",
12548                                                 handle_str, extra_str);
12549
12550         if (!in)
12551                 packet_enqueue_tx(tv, acl_handle(handle),
12552                                         index_list[index].frame, dlen);
12553
12554         if (size != dlen) {
12555                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12556                                                                 size, dlen);
12557                 packet_hexdump(data, size);
12558                 return;
12559         }
12560
12561         if (filter_mask & PACKET_FILTER_SHOW_ACL_DATA)
12562                 packet_hexdump(data, size);
12563
12564         l2cap_packet(index, in, acl_handle(handle), flags, data, size);
12565 }
12566
12567 void packet_hci_scodata(struct timeval *tv, struct ucred *cred, uint16_t index,
12568                                 bool in, const void *data, uint16_t size)
12569 {
12570         const hci_sco_hdr *hdr = data;
12571         uint16_t handle = le16_to_cpu(hdr->handle);
12572         uint8_t flags = acl_flags(handle);
12573         char handle_str[16], extra_str[32];
12574
12575         index_list[index].frame++;
12576
12577         if (size < HCI_SCO_HDR_SIZE) {
12578                 if (in)
12579                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12580                                 "Malformed SCO Data RX packet", NULL, NULL);
12581                 else
12582                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12583                                 "Malformed SCO Data TX packet", NULL, NULL);
12584                 packet_hexdump(data, size);
12585                 return;
12586         }
12587
12588         data += HCI_SCO_HDR_SIZE;
12589         size -= HCI_SCO_HDR_SIZE;
12590
12591         sprintf(handle_str, "Handle %d", acl_handle(handle));
12592         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, hdr->dlen);
12593
12594         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_SCODATA,
12595                                 in ? "SCO Data RX" : "SCO Data TX",
12596                                                 handle_str, extra_str);
12597
12598         if (!in)
12599                 packet_enqueue_tx(tv, acl_handle(handle),
12600                                         index_list[index].frame, hdr->dlen);
12601
12602         if (size != hdr->dlen) {
12603                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12604                                                         size, hdr->dlen);
12605                 packet_hexdump(data, size);
12606                 return;
12607         }
12608
12609         if (filter_mask & PACKET_FILTER_SHOW_SCO_DATA)
12610                 packet_hexdump(data, size);
12611 }
12612
12613 void packet_hci_isodata(struct timeval *tv, struct ucred *cred, uint16_t index,
12614                                 bool in, const void *data, uint16_t size)
12615 {
12616         const struct bt_hci_iso_hdr *hdr = data;
12617         uint16_t handle = le16_to_cpu(hdr->handle);
12618         uint8_t flags = acl_flags(handle);
12619         char handle_str[16], extra_str[32];
12620
12621         if (index >= MAX_INDEX) {
12622                 print_field("Invalid index (%d).", index);
12623                 return;
12624         }
12625
12626         index_list[index].frame++;
12627
12628         if (size < sizeof(*hdr)) {
12629                 if (in)
12630                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12631                                 "Malformed ISO Data RX packet", NULL, NULL);
12632                 else
12633                         print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12634                                 "Malformed ISO Data TX packet", NULL, NULL);
12635                 packet_hexdump(data, size);
12636                 return;
12637         }
12638
12639         data += sizeof(*hdr);
12640         size -= sizeof(*hdr);
12641
12642         sprintf(handle_str, "Handle %d", acl_handle(handle));
12643         sprintf(extra_str, "flags 0x%2.2x dlen %d", flags, hdr->dlen);
12644
12645         print_packet(tv, cred, in ? '>' : '<', index, NULL, COLOR_HCI_ISODATA,
12646                                 in ? "ISO Data RX" : "ISO Data TX",
12647                                                 handle_str, extra_str);
12648
12649         if (!in)
12650                 packet_enqueue_tx(tv, acl_handle(handle),
12651                                         index_list[index].frame, hdr->dlen);
12652
12653         if (size != hdr->dlen) {
12654                 print_text(COLOR_ERROR, "invalid packet size (%d != %d)",
12655                                                         size, hdr->dlen);
12656                 packet_hexdump(data, size);
12657                 return;
12658         }
12659
12660         if (filter_mask & PACKET_FILTER_SHOW_ISO_DATA)
12661                 packet_hexdump(data, size);
12662 }
12663
12664
12665 void packet_ctrl_open(struct timeval *tv, struct ucred *cred, uint16_t index,
12666                                         const void *data, uint16_t size)
12667 {
12668         uint32_t cookie;
12669         uint16_t format;
12670         char channel[11];
12671
12672         if (size < 6) {
12673                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12674                                 "Malformed Control Open packet", NULL, NULL);
12675                 packet_hexdump(data, size);
12676                 return;
12677         }
12678
12679         cookie = get_le32(data);
12680         format = get_le16(data + 4);
12681
12682         data += 6;
12683         size -= 6;
12684
12685         sprintf(channel, "0x%4.4x", cookie);
12686
12687         if ((format == CTRL_RAW || format == CTRL_USER || format == CTRL_MGMT)
12688                                                                 && size >= 8) {
12689                 uint8_t version;
12690                 uint16_t revision;
12691                 uint32_t flags;
12692                 uint8_t ident_len;
12693                 const char *comm;
12694                 char details[48];
12695                 const char *title;
12696
12697                 version = get_u8(data);
12698                 revision = get_le16(data + 1);
12699                 flags = get_le32(data + 3);
12700                 ident_len = get_u8(data + 7);
12701
12702                 data += 8;
12703                 size -= 8;
12704
12705                 comm = ident_len > 0 ? data : "unknown";
12706
12707                 data += ident_len;
12708                 size -= ident_len;
12709
12710                 assign_ctrl(cookie, format, comm);
12711
12712                 sprintf(details, "%sversion %u.%u",
12713                                 flags & 0x0001 ? "(privileged) " : "",
12714                                 version, revision);
12715
12716                 switch (format) {
12717                 case CTRL_RAW:
12718                         title = "RAW Open";
12719                         break;
12720                 case CTRL_USER:
12721                         title = "USER Open";
12722                         break;
12723                 case CTRL_MGMT:
12724                         title = "MGMT Open";
12725                         break;
12726                 default:
12727                         title = "Control Open";
12728                         break;
12729                 }
12730
12731                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_OPEN,
12732                                                 title, comm, details);
12733         } else {
12734                 char label[7];
12735
12736                 assign_ctrl(cookie, format, NULL);
12737
12738                 sprintf(label, "0x%4.4x", format);
12739
12740                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_OPEN,
12741                                                 "Control Open", label, NULL);
12742         }
12743
12744         packet_hexdump(data, size);
12745 }
12746
12747 void packet_ctrl_close(struct timeval *tv, struct ucred *cred, uint16_t index,
12748                                         const void *data, uint16_t size)
12749 {
12750         uint32_t cookie;
12751         uint16_t format;
12752         char channel[11], label[22];
12753         const char *title;
12754
12755         if (size < 4) {
12756                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
12757                                 "Malformed Control Close packet", NULL, NULL);
12758                 packet_hexdump(data, size);
12759                 return;
12760         }
12761
12762         cookie = get_le32(data);
12763
12764         data += 4;
12765         size -= 4;
12766
12767         sprintf(channel, "0x%4.4x", cookie);
12768
12769         release_ctrl(cookie, &format, label);
12770
12771         switch (format) {
12772         case CTRL_RAW:
12773                 title = "RAW Close";
12774                 break;
12775         case CTRL_USER:
12776                 title = "USER Close";
12777                 break;
12778         case CTRL_MGMT:
12779                 title = "MGMT Close";
12780                 break;
12781         default:
12782                 sprintf(label, "0x%4.4x", format);
12783                 title = "Control Close";
12784                 break;
12785         }
12786
12787         print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
12788                                                         title, label, NULL);
12789
12790         packet_hexdump(data, size);
12791 }
12792
12793 static const struct {
12794         uint8_t status;
12795         const char *str;
12796 } mgmt_status_table[] = {
12797         { 0x00, "Success"               },
12798         { 0x01, "Unknown Command"       },
12799         { 0x02, "Not Connected"         },
12800         { 0x03, "Failed"                },
12801         { 0x04, "Connect Failed"        },
12802         { 0x05, "Authentication Failed" },
12803         { 0x06, "Not Paired"            },
12804         { 0x07, "No Resources"          },
12805         { 0x08, "Timeout"               },
12806         { 0x09, "Already Connected"     },
12807         { 0x0a, "Busy"                  },
12808         { 0x0b, "Rejected"              },
12809         { 0x0c, "Not Supported"         },
12810         { 0x0d, "Invalid Parameters"    },
12811         { 0x0e, "Disconnected"          },
12812         { 0x0f, "Not Powered"           },
12813         { 0x10, "Cancelled"             },
12814         { 0x11, "Invalid Index"         },
12815         { 0x12, "RFKilled"              },
12816         { 0x13, "Already Paired"        },
12817         { 0x14, "Permission Denied"     },
12818         { }
12819 };
12820
12821 static void mgmt_print_status(uint8_t status)
12822 {
12823         const char *str = "Unknown";
12824         const char *color_on, *color_off;
12825         bool unknown = true;
12826         int i;
12827
12828         for (i = 0; mgmt_status_table[i].str; i++) {
12829                 if (mgmt_status_table[i].status == status) {
12830                         str = mgmt_status_table[i].str;
12831                         unknown = false;
12832                         break;
12833                 }
12834         }
12835
12836         if (use_color()) {
12837                 if (status) {
12838                         if (unknown)
12839                                 color_on = COLOR_UNKNOWN_ERROR;
12840                         else
12841                                 color_on = COLOR_RED;
12842                 } else
12843                         color_on = COLOR_GREEN;
12844                 color_off = COLOR_OFF;
12845         } else {
12846                 color_on = "";
12847                 color_off = "";
12848         }
12849
12850         print_field("Status: %s%s%s (0x%2.2x)",
12851                                 color_on, str, color_off, status);
12852 }
12853
12854 static void mgmt_print_address(const uint8_t *address, uint8_t type)
12855 {
12856         switch (type) {
12857         case 0x00:
12858                 print_addr_resolve("BR/EDR Address", address, 0x00, false);
12859                 break;
12860         case 0x01:
12861                 print_addr_resolve("LE Address", address, 0x00, false);
12862                 break;
12863         case 0x02:
12864                 print_addr_resolve("LE Address", address, 0x01, false);
12865                 break;
12866         default:
12867                 print_addr_resolve("Address", address, 0xff, false);
12868                 break;
12869         }
12870 }
12871
12872 static const struct bitfield_data mgmt_address_type_table[] = {
12873         {  0, "BR/EDR"          },
12874         {  1, "LE Public"       },
12875         {  2, "LE Random"       },
12876         { }
12877 };
12878
12879 static void mgmt_print_address_type(uint8_t type)
12880 {
12881         uint8_t mask;
12882
12883         print_field("Address type: 0x%2.2x", type);
12884
12885         mask = print_bitfield(2, type, mgmt_address_type_table);
12886         if (mask)
12887                 print_text(COLOR_UNKNOWN_ADDRESS_TYPE, "  Unknown address type"
12888                                                         " (0x%2.2x)", mask);
12889 }
12890
12891 static void mgmt_print_version(uint8_t version)
12892 {
12893         packet_print_version("Version", version, NULL, 0x0000);
12894 }
12895
12896 static void mgmt_print_manufacturer(uint16_t manufacturer)
12897 {
12898         packet_print_company("Manufacturer", manufacturer);
12899 }
12900
12901 static const struct bitfield_data mgmt_options_table[] = {
12902         {  0, "External configuration"                  },
12903         {  1, "Bluetooth public address configuration"  },
12904         { }
12905 };
12906
12907 static void mgmt_print_options(const char *label, uint32_t options)
12908 {
12909         uint32_t mask;
12910
12911         print_field("%s: 0x%8.8x", label, options);
12912
12913         mask = print_bitfield(2, options, mgmt_options_table);
12914         if (mask)
12915                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Unknown options"
12916                                                         " (0x%8.8x)", mask);
12917 }
12918
12919 static const struct bitfield_data mgmt_settings_table[] = {
12920         {  0, "Powered"                 },
12921         {  1, "Connectable"             },
12922         {  2, "Fast Connectable"        },
12923         {  3, "Discoverable"            },
12924         {  4, "Bondable"                },
12925         {  5, "Link Security"           },
12926         {  6, "Secure Simple Pairing"   },
12927         {  7, "BR/EDR"                  },
12928         {  8, "High Speed"              },
12929         {  9, "Low Energy"              },
12930         { 10, "Advertising"             },
12931         { 11, "Secure Connections"      },
12932         { 12, "Debug Keys"              },
12933         { 13, "Privacy"                 },
12934         { 14, "Controller Configuration"},
12935         { 15, "Static Address"          },
12936         { 16, "PHY Configuration"       },
12937         { 17, "Wideband Speech"         },
12938         { 18, "CIS Central"             },
12939         { 19, "CIS Peripheral"          },
12940         { 20, "ISO Broadcaster"         },
12941         { 21, "Sync Receiver"           },
12942         {}
12943 };
12944
12945 static void mgmt_print_settings(const char *label, uint32_t settings)
12946 {
12947         uint32_t mask;
12948
12949         print_field("%s: 0x%8.8x", label, settings);
12950
12951         mask = print_bitfield(2, settings, mgmt_settings_table);
12952         if (mask)
12953                 print_text(COLOR_UNKNOWN_SETTINGS_BIT, "  Unknown settings"
12954                                                         " (0x%8.8x)", mask);
12955 }
12956
12957 static void mgmt_print_name(const void *data)
12958 {
12959         print_field("Name: %s", (char *) data);
12960         print_field("Short name: %s", (char *) (data + 249));
12961 }
12962
12963 static void mgmt_print_io_capability(uint8_t capability)
12964 {
12965         const char *str;
12966
12967         switch (capability) {
12968         case 0x00:
12969                 str = "DisplayOnly";
12970                 break;
12971         case 0x01:
12972                 str = "DisplayYesNo";
12973                 break;
12974         case 0x02:
12975                 str = "KeyboardOnly";
12976                 break;
12977         case 0x03:
12978                 str = "NoInputNoOutput";
12979                 break;
12980         case 0x04:
12981                 str = "KeyboardDisplay";
12982                 break;
12983         default:
12984                 str = "Reserved";
12985                 break;
12986         }
12987
12988         print_field("Capability: %s (0x%2.2x)", str, capability);
12989 }
12990
12991 static const struct bitfield_data mgmt_device_flags_table[] = {
12992         {  0, "Confirm Name"                    },
12993         {  1, "Legacy Pairing"                  },
12994         {  2, "Not Connectable"                 },
12995         {  3, "Connection Locally Initiated"    },
12996         {  4, "Name Request Failed"             },
12997         {  5, "Scan Response"                   },
12998         { }
12999 };
13000
13001 static void mgmt_print_device_flags(uint32_t flags)
13002 {
13003         uint32_t mask;
13004
13005         print_field("Flags: 0x%8.8x", flags);
13006
13007         mask = print_bitfield(2, flags, mgmt_device_flags_table);
13008         if (mask)
13009                 print_text(COLOR_UNKNOWN_DEVICE_FLAG, "  Unknown device flag"
13010                                                         " (0x%8.8x)", mask);
13011 }
13012
13013 static void mgmt_print_device_action(uint8_t action)
13014 {
13015         const char *str;
13016
13017         switch (action) {
13018         case 0x00:
13019                 str = "Background scan for device";
13020                 break;
13021         case 0x01:
13022                 str = "Allow incoming connection";
13023                 break;
13024         case 0x02:
13025                 str = "Auto-connect remote device";
13026                 break;
13027         default:
13028                 str = "Reserved";
13029                 break;
13030         }
13031
13032         print_field("Action: %s (0x%2.2x)", str, action);
13033 }
13034
13035 static const struct bitfield_data mgmt_adv_flags_table[] = {
13036         {  0, "Switch into Connectable mode"            },
13037         {  1, "Advertise as Discoverable"               },
13038         {  2, "Advertise as Limited Discoverable"       },
13039         {  3, "Add Flags field to Advertising Data"     },
13040         {  4, "Add TX Power field to Advertising Data"  },
13041         {  5, "Add Appearance field to Scan Response"   },
13042         {  6, "Add Local Name in Scan Response"         },
13043         {  7, "Advertise in 1M on Secondary channel"    },
13044         {  8, "Advertise in 2M on Secondary channel"    },
13045         {  9, "Advertise in CODED on Secondary channel" },
13046         {  10, "Support setting Tx Power"               },
13047         {  11, "Support HW offload"                     },
13048         {  12, "Use provided duration parameter"        },
13049         {  13, "Use provided timeout parameter"         },
13050         {  14, "Use provided interval parameters"       },
13051         {  15, "Use provided tx power parameter"        },
13052         {  16, "Contain Scan Response Data"             },
13053         { }
13054 };
13055 #define MGMT_ADV_PARAM_DURATION         (1 << 12)
13056 #define MGMT_ADV_PARAM_TIMEOUT          (1 << 13)
13057 #define MGMT_ADV_PARAM_INTERVALS        (1 << 14)
13058 #define MGMT_ADV_PARAM_TX_POWER         (1 << 15)
13059
13060 static void mgmt_print_adv_flags(uint32_t flags)
13061 {
13062         uint32_t mask;
13063
13064         print_field("Flags: 0x%8.8x", flags);
13065
13066         mask = print_bitfield(2, flags, mgmt_adv_flags_table);
13067         if (mask)
13068                 print_text(COLOR_UNKNOWN_ADV_FLAG, "  Unknown advertising flag"
13069                                                         " (0x%8.8x)", mask);
13070 }
13071
13072 static void mgmt_print_store_hint(uint8_t hint)
13073 {
13074         const char *str;
13075
13076         switch (hint) {
13077         case 0x00:
13078                 str = "No";
13079                 break;
13080         case 0x01:
13081                 str = "Yes";
13082                 break;
13083         default:
13084                 str = "Reserved";
13085                 break;
13086         }
13087
13088         print_field("Store hint: %s (0x%2.2x)", str, hint);
13089 }
13090
13091 static void mgmt_print_connection_parameter(const void *data)
13092 {
13093         uint8_t address_type = get_u8(data + 6);
13094         uint16_t min_conn_interval = get_le16(data + 7);
13095         uint16_t max_conn_interval = get_le16(data + 9);
13096         uint16_t conn_latency = get_le16(data + 11);
13097         uint16_t supv_timeout = get_le16(data + 13);
13098
13099         mgmt_print_address(data, address_type);
13100         print_field("Min connection interval: %u", min_conn_interval);
13101         print_field("Max connection interval: %u", max_conn_interval);
13102         print_conn_latency("Connection latency", conn_latency);
13103         print_field("Supervision timeout: %u", supv_timeout);
13104 }
13105
13106 static void mgmt_print_link_key(const void *data)
13107 {
13108         uint8_t address_type = get_u8(data + 6);
13109         uint8_t key_type = get_u8(data + 7);
13110         uint8_t pin_len = get_u8(data + 24);
13111
13112         mgmt_print_address(data, address_type);
13113         print_key_type(key_type);
13114         print_link_key(data + 8);
13115         print_field("PIN length: %d", pin_len);
13116 }
13117
13118 static void mgmt_print_long_term_key(const void *data)
13119 {
13120         uint8_t address_type = get_u8(data + 6);
13121         uint8_t key_type = get_u8(data + 7);
13122         uint8_t central = get_u8(data + 8);
13123         uint8_t enc_size = get_u8(data + 9);
13124         const char *str;
13125
13126         mgmt_print_address(data, address_type);
13127
13128         switch (key_type) {
13129         case 0x00:
13130                 str = "Unauthenticated legacy key";
13131                 break;
13132         case 0x01:
13133                 str = "Authenticated legacy key";
13134                 break;
13135         case 0x02:
13136                 str = "Unauthenticated key from P-256";
13137                 break;
13138         case 0x03:
13139                 str = "Authenticated key from P-256";
13140                 break;
13141         case 0x04:
13142                 str = "Debug key from P-256";
13143                 break;
13144         default:
13145                 str = "Reserved";
13146                 break;
13147         }
13148
13149         print_field("Key type: %s (0x%2.2x)", str, key_type);
13150         print_field("Central: 0x%2.2x", central);
13151         print_field("Encryption size: %u", enc_size);
13152         print_hex_field("Diversifier", data + 10, 2);
13153         print_hex_field("Randomizer", data + 12, 8);
13154         print_hex_field("Key", data + 20, 16);
13155 }
13156
13157 static void mgmt_print_identity_resolving_key(const void *data)
13158 {
13159         uint8_t address_type = get_u8(data + 6);
13160
13161         mgmt_print_address(data, address_type);
13162         print_hex_field("Key", data + 7, 16);
13163         keys_add_identity(data, address_type, data + 7);
13164 }
13165
13166 static void mgmt_print_signature_resolving_key(const void *data)
13167 {
13168         uint8_t address_type = get_u8(data + 6);
13169         uint8_t key_type = get_u8(data + 7);
13170         const char *str;
13171
13172         mgmt_print_address(data, address_type);
13173
13174         switch (key_type) {
13175         case 0x00:
13176                 str = "Unauthenticated local CSRK";
13177                 break;
13178         case 0x01:
13179                 str = "Unauthenticated remote CSRK";
13180                 break;
13181         case 0x02:
13182                 str = "Authenticated local CSRK";
13183                 break;
13184         case 0x03:
13185                 str = "Authenticated remote CSRK";
13186                 break;
13187         default:
13188                 str = "Reserved";
13189                 break;
13190         }
13191
13192         print_field("Key type: %s (0x%2.2x)", str, key_type);
13193         print_hex_field("Key", data + 8, 16);
13194 }
13195
13196 static void mgmt_print_oob_data(const void *data)
13197 {
13198         print_hash_p192(data);
13199         print_randomizer_p192(data + 16);
13200         print_hash_p256(data + 32);
13201         print_randomizer_p256(data + 48);
13202 }
13203
13204 static const struct bitfield_data mgmt_exp_feature_flags_table[] = {
13205         {  0, "Active"          },
13206         {  1, "Settings change" },
13207         { }
13208 };
13209
13210 static void mgmt_print_exp_feature(const void *data)
13211 {
13212         uint32_t flags = get_le32(data + 16);
13213         uint32_t mask;
13214
13215         print_field("UUID: %s", bt_uuid128_to_str(data));
13216         print_field("Flags: 0x%8.8x", flags);
13217
13218         mask = print_bitfield(2, flags, mgmt_exp_feature_flags_table);
13219         if (mask)
13220                 print_text(COLOR_UNKNOWN_EXP_FEATURE_FLAG,
13221                                 "  Unknown feature flag (0x%8.8x)", mask);
13222 }
13223
13224 static void mgmt_null_cmd(const void *data, uint16_t size)
13225 {
13226 }
13227
13228 static void mgmt_null_rsp(const void *data, uint16_t size)
13229 {
13230 }
13231
13232 static void mgmt_read_version_info_rsp(const void *data, uint16_t size)
13233 {
13234         uint8_t version;
13235         uint16_t revision;
13236
13237         version = get_u8(data);
13238         revision = get_le16(data + 1);
13239
13240         print_field("Version: %u.%u", version, revision);
13241 }
13242
13243 static void mgmt_print_commands(const void *data, uint16_t num);
13244 static void mgmt_print_events(const void *data, uint16_t num);
13245
13246 static void mgmt_read_supported_commands_rsp(const void *data, uint16_t size)
13247 {
13248         uint16_t num_commands = get_le16(data);
13249         uint16_t num_events = get_le16(data + 2);
13250
13251         if (size - 4 != (num_commands * 2) + (num_events *2)) {
13252                 packet_hexdump(data, size);
13253                 return;
13254         }
13255
13256         mgmt_print_commands(data + 4, num_commands);
13257         mgmt_print_events(data + 4 + num_commands * 2, num_events);
13258 }
13259
13260 static void mgmt_read_index_list_rsp(const void *data, uint16_t size)
13261 {
13262         uint16_t num_controllers = get_le16(data);
13263         int i;
13264
13265         print_field("Controllers: %u", num_controllers);
13266
13267         if (size - 2 != num_controllers * 2) {
13268                 packet_hexdump(data + 2, size - 2);
13269                 return;
13270         }
13271
13272         for (i = 0; i < num_controllers; i++) {
13273                 uint16_t index = get_le16(data + 2 + (i * 2));
13274
13275                 print_field("  hci%u", index);
13276         }
13277 }
13278
13279 static void mgmt_read_controller_info_rsp(const void *data, uint16_t size)
13280 {
13281         uint8_t version = get_u8(data + 6);
13282         uint16_t manufacturer = get_le16(data + 7);
13283         uint32_t supported_settings = get_le32(data + 9);
13284         uint32_t current_settings = get_le32(data + 13);
13285
13286         print_addr_resolve("Address", data, 0x00, false);
13287         mgmt_print_version(version);
13288         mgmt_print_manufacturer(manufacturer);
13289         mgmt_print_settings("Supported settings", supported_settings);
13290         mgmt_print_settings("Current settings", current_settings);
13291         print_dev_class(data + 17);
13292         mgmt_print_name(data + 20);
13293 }
13294
13295 static void mgmt_set_powered_cmd(const void *data, uint16_t size)
13296 {
13297         uint8_t enable = get_u8(data);
13298
13299         print_enable("Powered", enable);
13300 }
13301
13302 static void mgmt_set_discoverable_cmd(const void *data, uint16_t size)
13303 {
13304         uint8_t enable = get_u8(data);
13305         uint16_t timeout = get_le16(data + 1);
13306         const char *str;
13307
13308         switch (enable) {
13309         case 0x00:
13310                 str = "Disabled";
13311                 break;
13312         case 0x01:
13313                 str = "General";
13314                 break;
13315         case 0x02:
13316                 str = "Limited";
13317                 break;
13318         default:
13319                 str = "Reserved";
13320                 break;
13321         }
13322
13323         print_field("Discoverable: %s (0x%2.2x)", str, enable);
13324         print_field("Timeout: %u", timeout);
13325 }
13326
13327 static void mgmt_set_connectable_cmd(const void *data, uint16_t size)
13328 {
13329         uint8_t enable = get_u8(data);
13330
13331         print_enable("Connectable", enable);
13332 }
13333
13334 static void mgmt_set_fast_connectable_cmd(const void *data, uint16_t size)
13335 {
13336         uint8_t enable = get_u8(data);
13337
13338         print_enable("Fast Connectable", enable);
13339 }
13340
13341 static void mgmt_set_bondable_cmd(const void *data, uint16_t size)
13342 {
13343         uint8_t enable = get_u8(data);
13344
13345         print_enable("Bondable", enable);
13346 }
13347
13348 static void mgmt_set_link_security_cmd(const void *data, uint16_t size)
13349 {
13350         uint8_t enable = get_u8(data);
13351
13352         print_enable("Link Security", enable);
13353 }
13354
13355 static void mgmt_set_secure_simple_pairing_cmd(const void *data, uint16_t size)
13356 {
13357         uint8_t enable = get_u8(data);
13358
13359         print_enable("Secure Simple Pairing", enable);
13360 }
13361
13362 static void mgmt_set_high_speed_cmd(const void *data, uint16_t size)
13363 {
13364         uint8_t enable = get_u8(data);
13365
13366         print_enable("High Speed", enable);
13367 }
13368
13369 static void mgmt_set_low_energy_cmd(const void *data, uint16_t size)
13370 {
13371         uint8_t enable = get_u8(data);
13372
13373         print_enable("Low Energy", enable);
13374 }
13375
13376 static void mgmt_new_settings_rsp(const void *data, uint16_t size)
13377 {
13378         uint32_t current_settings = get_le32(data);
13379
13380         mgmt_print_settings("Current settings", current_settings);
13381 }
13382
13383 static void mgmt_set_device_class_cmd(const void *data, uint16_t size)
13384 {
13385         uint8_t major = get_u8(data);
13386         uint8_t minor = get_u8(data + 1);
13387
13388         print_field("Major class: 0x%2.2x", major);
13389         print_field("Minor class: 0x%2.2x", minor);
13390 }
13391
13392 static void mgmt_set_device_class_rsp(const void *data, uint16_t size)
13393 {
13394         print_dev_class(data);
13395 }
13396
13397 static void mgmt_set_local_name_cmd(const void *data, uint16_t size)
13398 {
13399         mgmt_print_name(data);
13400 }
13401
13402 static void mgmt_set_local_name_rsp(const void *data, uint16_t size)
13403 {
13404         mgmt_print_name(data);
13405 }
13406
13407 static void mgmt_add_uuid_cmd(const void *data, uint16_t size)
13408 {
13409         uint8_t service_class = get_u8(data + 16);
13410
13411         print_field("UUID: %s", bt_uuid128_to_str(data));
13412         print_field("Service class: 0x%2.2x", service_class);
13413 }
13414
13415 static void mgmt_add_uuid_rsp(const void *data, uint16_t size)
13416 {
13417         print_dev_class(data);
13418 }
13419
13420 static void mgmt_remove_uuid_cmd(const void *data, uint16_t size)
13421 {
13422         print_field("UUID: %s", bt_uuid128_to_str(data));
13423 }
13424
13425 static void mgmt_remove_uuid_rsp(const void *data, uint16_t size)
13426 {
13427         print_dev_class(data);
13428 }
13429
13430 static void mgmt_load_link_keys_cmd(const void *data, uint16_t size)
13431 {
13432         uint8_t debug_keys = get_u8(data);
13433         uint16_t num_keys = get_le16(data + 1);
13434         int i;
13435
13436         print_enable("Debug keys", debug_keys);
13437         print_field("Keys: %u", num_keys);
13438
13439         if (size - 3 != num_keys * 25) {
13440                 packet_hexdump(data + 3, size - 3);
13441                 return;
13442         }
13443
13444         for (i = 0; i < num_keys; i++)
13445                 mgmt_print_link_key(data + 3 + (i * 25));
13446 }
13447
13448 static void mgmt_load_long_term_keys_cmd(const void *data, uint16_t size)
13449 {
13450         uint16_t num_keys = get_le16(data);
13451         int i;
13452
13453         print_field("Keys: %u", num_keys);
13454
13455         if (size - 2 != num_keys * 36) {
13456                 packet_hexdump(data + 2, size - 2);
13457                 return;
13458         }
13459
13460         for (i = 0; i < num_keys; i++)
13461                 mgmt_print_long_term_key(data + 2 + (i * 36));
13462 }
13463
13464 static void mgmt_disconnect_cmd(const void *data, uint16_t size)
13465 {
13466         uint8_t address_type = get_u8(data + 6);
13467
13468         mgmt_print_address(data, address_type);
13469 }
13470
13471 static void mgmt_disconnect_rsp(const void *data, uint16_t size)
13472 {
13473         uint8_t address_type = get_u8(data + 6);
13474
13475         mgmt_print_address(data, address_type);
13476 }
13477
13478 static void mgmt_get_connections_rsp(const void *data, uint16_t size)
13479 {
13480         uint16_t num_connections = get_le16(data);
13481         int i;
13482
13483         print_field("Connections: %u", num_connections);
13484
13485         if (size - 2 != num_connections * 7) {
13486                 packet_hexdump(data + 2, size - 2);
13487                 return;
13488         }
13489
13490         for (i = 0; i < num_connections; i++) {
13491                 uint8_t address_type = get_u8(data + 2 + (i * 7) + 6);
13492
13493                 mgmt_print_address(data + 2 + (i * 7), address_type);
13494         }
13495 }
13496
13497 static void mgmt_pin_code_reply_cmd(const void *data, uint16_t size)
13498 {
13499         uint8_t address_type = get_u8(data + 6);
13500         uint8_t pin_len = get_u8(data + 7);
13501
13502         mgmt_print_address(data, address_type);
13503         print_field("PIN length: %u", pin_len);
13504         print_hex_field("PIN code", data + 8, 16);
13505 }
13506
13507 static void mgmt_pin_code_reply_rsp(const void *data, uint16_t size)
13508 {
13509         uint8_t address_type = get_u8(data + 6);
13510
13511         mgmt_print_address(data, address_type);
13512 }
13513
13514 static void mgmt_pin_code_neg_reply_cmd(const void *data, uint16_t size)
13515 {
13516         uint8_t address_type = get_u8(data + 6);
13517
13518         mgmt_print_address(data, address_type);
13519 }
13520
13521 static void mgmt_pin_code_neg_reply_rsp(const void *data, uint16_t size)
13522 {
13523         uint8_t address_type = get_u8(data + 6);
13524
13525         mgmt_print_address(data, address_type);
13526 }
13527
13528 static void mgmt_set_io_capability_cmd(const void *data, uint16_t size)
13529 {
13530         uint8_t capability = get_u8(data);
13531
13532         mgmt_print_io_capability(capability);
13533 }
13534
13535 static void mgmt_pair_device_cmd(const void *data, uint16_t size)
13536 {
13537         uint8_t address_type = get_u8(data + 6);
13538         uint8_t capability = get_u8(data + 7);
13539
13540         mgmt_print_address(data, address_type);
13541         mgmt_print_io_capability(capability);
13542 }
13543
13544 static void mgmt_pair_device_rsp(const void *data, uint16_t size)
13545 {
13546         uint8_t address_type = get_u8(data + 6);
13547
13548         mgmt_print_address(data, address_type);
13549 }
13550
13551 static void mgmt_cancel_pair_device_cmd(const void *data, uint16_t size)
13552 {
13553         uint8_t address_type = get_u8(data + 6);
13554
13555         mgmt_print_address(data, address_type);
13556 }
13557
13558 static void mgmt_cancel_pair_device_rsp(const void *data, uint16_t size)
13559 {
13560         uint8_t address_type = get_u8(data + 6);
13561
13562         mgmt_print_address(data, address_type);
13563 }
13564
13565 static void mgmt_unpair_device_cmd(const void *data, uint16_t size)
13566 {
13567         uint8_t address_type = get_u8(data + 6);
13568         uint8_t disconnect = get_u8(data + 7);
13569
13570         mgmt_print_address(data, address_type);
13571         print_enable("Disconnect", disconnect);
13572 }
13573
13574 static void mgmt_unpair_device_rsp(const void *data, uint16_t size)
13575 {
13576         uint8_t address_type = get_u8(data + 6);
13577
13578         mgmt_print_address(data, address_type);
13579 }
13580
13581 static void mgmt_user_confirmation_reply_cmd(const void *data, uint16_t size)
13582 {
13583         uint8_t address_type = get_u8(data + 6);
13584
13585         mgmt_print_address(data, address_type);
13586 }
13587
13588 static void mgmt_user_confirmation_reply_rsp(const void *data, uint16_t size)
13589 {
13590         uint8_t address_type = get_u8(data + 6);
13591
13592         mgmt_print_address(data, address_type);
13593 }
13594
13595 static void mgmt_user_confirmation_neg_reply_cmd(const void *data, uint16_t size)
13596 {
13597         uint8_t address_type = get_u8(data + 6);
13598
13599         mgmt_print_address(data, address_type);
13600 }
13601
13602 static void mgmt_user_confirmation_neg_reply_rsp(const void *data, uint16_t size)
13603 {
13604         uint8_t address_type = get_u8(data + 6);
13605
13606         mgmt_print_address(data, address_type);
13607 }
13608
13609 static void mgmt_user_passkey_reply_cmd(const void *data, uint16_t size)
13610 {
13611         uint8_t address_type = get_u8(data + 6);
13612         uint32_t passkey = get_le32(data + 7);
13613
13614         mgmt_print_address(data, address_type);
13615         print_field("Passkey: 0x%4.4x", passkey);
13616 }
13617
13618 static void mgmt_user_passkey_reply_rsp(const void *data, uint16_t size)
13619 {
13620         uint8_t address_type = get_u8(data + 6);
13621
13622         mgmt_print_address(data, address_type);
13623 }
13624
13625 static void mgmt_user_passkey_neg_reply_cmd(const void *data, uint16_t size)
13626 {
13627         uint8_t address_type = get_u8(data + 6);
13628
13629         mgmt_print_address(data, address_type);
13630 }
13631
13632 static void mgmt_user_passkey_neg_reply_rsp(const void *data, uint16_t size)
13633 {
13634         uint8_t address_type = get_u8(data + 6);
13635
13636         mgmt_print_address(data, address_type);
13637 }
13638
13639 static void mgmt_read_local_oob_data_rsp(const void *data, uint16_t size)
13640 {
13641         mgmt_print_oob_data(data);
13642 }
13643
13644 static void mgmt_add_remote_oob_data_cmd(const void *data, uint16_t size)
13645 {
13646         uint8_t address_type = get_u8(data + 6);
13647
13648         mgmt_print_address(data, address_type);
13649         mgmt_print_oob_data(data + 7);
13650 }
13651
13652 static void mgmt_add_remote_oob_data_rsp(const void *data, uint16_t size)
13653 {
13654         uint8_t address_type = get_u8(data + 6);
13655
13656         mgmt_print_address(data, address_type);
13657 }
13658
13659 static void mgmt_remove_remote_oob_data_cmd(const void *data, uint16_t size)
13660 {
13661         uint8_t address_type = get_u8(data + 6);
13662
13663         mgmt_print_address(data, address_type);
13664 }
13665
13666 static void mgmt_remove_remote_oob_data_rsp(const void *data, uint16_t size)
13667 {
13668         uint8_t address_type = get_u8(data + 6);
13669
13670         mgmt_print_address(data, address_type);
13671 }
13672
13673 static void mgmt_start_discovery_cmd(const void *data, uint16_t size)
13674 {
13675         uint8_t type = get_u8(data);
13676
13677         mgmt_print_address_type(type);
13678 }
13679
13680 static void mgmt_start_discovery_rsp(const void *data, uint16_t size)
13681 {
13682         uint8_t type = get_u8(data);
13683
13684         mgmt_print_address_type(type);
13685 }
13686
13687 static void mgmt_stop_discovery_cmd(const void *data, uint16_t size)
13688 {
13689         uint8_t type = get_u8(data);
13690
13691         mgmt_print_address_type(type);
13692 }
13693
13694 static void mgmt_stop_discovery_rsp(const void *data, uint16_t size)
13695 {
13696         uint8_t type = get_u8(data);
13697
13698         mgmt_print_address_type(type);
13699 }
13700
13701 static void mgmt_confirm_name_cmd(const void *data, uint16_t size)
13702 {
13703         uint8_t address_type = get_u8(data + 6);
13704         uint8_t name_known = get_u8(data + 7);
13705         const char *str;
13706
13707         mgmt_print_address(data, address_type);
13708
13709         switch (name_known) {
13710         case 0x00:
13711                 str = "No";
13712                 break;
13713         case 0x01:
13714                 str = "Yes";
13715                 break;
13716         default:
13717                 str = "Reserved";
13718                 break;
13719         }
13720
13721         print_field("Name known: %s (0x%2.2x)", str, name_known);
13722 }
13723
13724 static void mgmt_confirm_name_rsp(const void *data, uint16_t size)
13725 {
13726         uint8_t address_type = get_u8(data + 6);
13727
13728         mgmt_print_address(data, address_type);
13729 }
13730
13731 static void mgmt_block_device_cmd(const void *data, uint16_t size)
13732 {
13733         uint8_t address_type = get_u8(data + 6);
13734
13735         mgmt_print_address(data, address_type);
13736 }
13737
13738 static void mgmt_block_device_rsp(const void *data, uint16_t size)
13739 {
13740         uint8_t address_type = get_u8(data + 6);
13741
13742         mgmt_print_address(data, address_type);
13743 }
13744
13745 static void mgmt_unblock_device_cmd(const void *data, uint16_t size)
13746 {
13747         uint8_t address_type = get_u8(data + 6);
13748
13749         mgmt_print_address(data, address_type);
13750 }
13751
13752 static void mgmt_unblock_device_rsp(const void *data, uint16_t size)
13753 {
13754         uint8_t address_type = get_u8(data + 6);
13755
13756         mgmt_print_address(data, address_type);
13757 }
13758
13759 static void mgmt_set_device_id_cmd(const void *data, uint16_t size)
13760 {
13761         print_device_id(data, size);
13762 }
13763
13764 static void mgmt_set_advertising_cmd(const void *data, uint16_t size)
13765 {
13766         uint8_t enable = get_u8(data);
13767         const char *str;
13768
13769         switch (enable) {
13770         case 0x00:
13771                 str = "Disabled";
13772                 break;
13773         case 0x01:
13774                 str = "Enabled";
13775                 break;
13776         case 0x02:
13777                 str = "Connectable";
13778                 break;
13779         default:
13780                 str = "Reserved";
13781                 break;
13782         }
13783
13784         print_field("Advertising: %s (0x%2.2x)", str, enable);
13785 }
13786
13787 static void mgmt_set_bredr_cmd(const void *data, uint16_t size)
13788 {
13789         uint8_t enable = get_u8(data);
13790
13791         print_enable("BR/EDR", enable);
13792 }
13793
13794 static void mgmt_set_static_address_cmd(const void *data, uint16_t size)
13795 {
13796         print_addr_resolve("Address", data, 0x01, false);
13797 }
13798
13799 static void mgmt_set_scan_parameters_cmd(const void *data, uint16_t size)
13800 {
13801         uint16_t interval = get_le16(data);
13802         uint16_t window = get_le16(data + 2);
13803
13804         print_field("Interval: %u (0x%2.2x)", interval, interval);
13805         print_field("Window: %u (0x%2.2x)", window, window);
13806 }
13807
13808 static void mgmt_set_secure_connections_cmd(const void *data, uint16_t size)
13809 {
13810         uint8_t enable = get_u8(data);
13811         const char *str;
13812
13813         switch (enable) {
13814         case 0x00:
13815                 str = "Disabled";
13816                 break;
13817         case 0x01:
13818                 str = "Enabled";
13819                 break;
13820         case 0x02:
13821                 str = "Only";
13822                 break;
13823         default:
13824                 str = "Reserved";
13825                 break;
13826         }
13827
13828         print_field("Secure Connections: %s (0x%2.2x)", str, enable);
13829 }
13830
13831 static void mgmt_set_debug_keys_cmd(const void *data, uint16_t size)
13832 {
13833         uint8_t enable = get_u8(data);
13834         const char *str;
13835
13836         switch (enable) {
13837         case 0x00:
13838                 str = "Disabled";
13839                 break;
13840         case 0x01:
13841                 str = "Enabled";
13842                 break;
13843         case 0x02:
13844                 str = "Generate";
13845                 break;
13846         default:
13847                 str = "Reserved";
13848                 break;
13849         }
13850
13851         print_field("Debug Keys: %s (0x%2.2x)", str, enable);
13852 }
13853
13854 static void mgmt_set_privacy_cmd(const void *data, uint16_t size)
13855 {
13856         uint8_t enable = get_u8(data);
13857         const char *str;
13858
13859         switch (enable) {
13860         case 0x00:
13861                 str = "Disabled";
13862                 break;
13863         case 0x01:
13864                 str = "Enabled";
13865                 break;
13866         case 0x02:
13867                 str = "Limited";
13868                 break;
13869         default:
13870                 str = "Reserved";
13871                 break;
13872         }
13873
13874         print_field("Privacy: %s (0x%2.2x)", str, enable);
13875         print_hex_field("Key", data + 1, 16);
13876 }
13877
13878 static void mgmt_load_identity_resolving_keys_cmd(const void *data, uint16_t size)
13879 {
13880         uint16_t num_keys = get_le16(data);
13881         int i;
13882
13883         print_field("Keys: %u", num_keys);
13884
13885         if (size - 2 != num_keys * 23) {
13886                 packet_hexdump(data + 2, size - 2);
13887                 return;
13888         }
13889
13890         for (i = 0; i < num_keys; i++)
13891                 mgmt_print_identity_resolving_key(data + 2 + (i * 23));
13892 }
13893
13894 static void mgmt_get_connection_information_cmd(const void *data, uint16_t size)
13895 {
13896         uint8_t address_type = get_u8(data + 6);
13897
13898         mgmt_print_address(data, address_type);
13899 }
13900
13901 static void mgmt_get_connection_information_rsp(const void *data, uint16_t size)
13902 {
13903         uint8_t address_type = get_u8(data + 6);
13904         int8_t rssi = get_s8(data + 7);
13905         int8_t tx_power = get_s8(data + 8);
13906         int8_t max_tx_power = get_s8(data + 9);
13907
13908         mgmt_print_address(data, address_type);
13909         print_rssi(rssi);
13910         print_power_level(tx_power, NULL);
13911         print_power_level(max_tx_power, "max");
13912 }
13913
13914 static void mgmt_get_clock_information_cmd(const void *data, uint16_t size)
13915 {
13916         uint8_t address_type = get_u8(data + 6);
13917
13918         mgmt_print_address(data, address_type);
13919 }
13920
13921 static void mgmt_get_clock_information_rsp(const void *data, uint16_t size)
13922 {
13923         uint8_t address_type = get_u8(data + 6);
13924         uint32_t local_clock = get_le32(data + 7);
13925         uint32_t piconet_clock = get_le32(data + 11);
13926         uint16_t accuracy = get_le16(data + 15);
13927
13928         mgmt_print_address(data, address_type);
13929         print_field("Local clock: 0x%8.8x", local_clock);
13930         print_field("Piconet clock: 0x%8.8x", piconet_clock);
13931         print_field("Accuracy: 0x%4.4x", accuracy);
13932 }
13933
13934 static void mgmt_add_device_cmd(const void *data, uint16_t size)
13935 {
13936         uint8_t address_type = get_u8(data + 6);
13937         uint8_t action = get_u8(data + 7);
13938
13939         mgmt_print_address(data, address_type);
13940         mgmt_print_device_action(action);
13941 }
13942
13943 static void mgmt_add_device_rsp(const void *data, uint16_t size)
13944 {
13945         uint8_t address_type = get_u8(data + 6);
13946
13947         mgmt_print_address(data, address_type);
13948 }
13949
13950 static void mgmt_remove_device_cmd(const void *data, uint16_t size)
13951 {
13952         uint8_t address_type = get_u8(data + 6);
13953
13954         mgmt_print_address(data, address_type);
13955 }
13956
13957 static void mgmt_remove_device_rsp(const void *data, uint16_t size)
13958 {
13959         uint8_t address_type = get_u8(data + 6);
13960
13961         mgmt_print_address(data, address_type);
13962 }
13963
13964 static void mgmt_load_connection_parameters_cmd(const void *data, uint16_t size)
13965 {
13966         uint16_t num_parameters = get_le16(data);
13967         int i;
13968
13969         print_field("Parameters: %u", num_parameters);
13970
13971         if (size - 2 != num_parameters * 15) {
13972                 packet_hexdump(data + 2, size - 2);
13973                 return;
13974         }
13975
13976         for (i = 0; i < num_parameters; i++)
13977                 mgmt_print_connection_parameter(data + 2 + (i * 15));
13978 }
13979
13980 static void mgmt_read_unconf_index_list_rsp(const void *data, uint16_t size)
13981 {
13982         uint16_t num_controllers = get_le16(data);
13983         int i;
13984
13985         print_field("Controllers: %u", num_controllers);
13986
13987         if (size - 2 != num_controllers * 2) {
13988                 packet_hexdump(data + 2, size - 2);
13989                 return;
13990         }
13991
13992         for (i = 0; i < num_controllers; i++) {
13993                 uint16_t index = get_le16(data + 2 + (i * 2));
13994
13995                 print_field("  hci%u", index);
13996         }
13997 }
13998
13999 static void mgmt_read_controller_conf_info_rsp(const void *data, uint16_t size)
14000 {
14001         uint16_t manufacturer = get_le16(data);
14002         uint32_t supported_options = get_le32(data + 2);
14003         uint32_t missing_options = get_le32(data + 6);
14004
14005         mgmt_print_manufacturer(manufacturer);
14006         mgmt_print_options("Supported options", supported_options);
14007         mgmt_print_options("Missing options", missing_options);
14008 }
14009
14010 static void mgmt_set_external_configuration_cmd(const void *data, uint16_t size)
14011 {
14012         uint8_t enable = get_u8(data);
14013
14014         print_enable("Configuration", enable);
14015 }
14016
14017 static void mgmt_set_public_address_cmd(const void *data, uint16_t size)
14018 {
14019         print_addr_resolve("Address", data, 0x00, false);
14020 }
14021
14022 static void mgmt_new_options_rsp(const void *data, uint16_t size)
14023 {
14024         uint32_t missing_options = get_le32(data);
14025
14026         mgmt_print_options("Missing options", missing_options);
14027 }
14028
14029 static void mgmt_start_service_discovery_cmd(const void *data, uint16_t size)
14030 {
14031         uint8_t type = get_u8(data);
14032         int8_t rssi = get_s8(data + 1);
14033         uint16_t num_uuids = get_le16(data + 2);
14034         int i;
14035
14036         mgmt_print_address_type(type);
14037         print_rssi(rssi);
14038         print_field("UUIDs: %u", num_uuids);
14039
14040         if (size - 4 != num_uuids * 16) {
14041                 packet_hexdump(data + 4, size - 4);
14042                 return;
14043         }
14044
14045         for (i = 0; i < num_uuids; i++)
14046                 print_field("UUID: %s", bt_uuid128_to_str(data + 4 + (i * 16)));
14047 }
14048
14049 static void mgmt_start_service_discovery_rsp(const void *data, uint16_t size)
14050 {
14051         uint8_t type = get_u8(data);
14052
14053         mgmt_print_address_type(type);
14054 }
14055
14056 static void mgmt_read_ext_index_list_rsp(const void *data, uint16_t size)
14057 {
14058         uint16_t num_controllers = get_le16(data);
14059         int i;
14060
14061         print_field("Controllers: %u", num_controllers);
14062
14063         if (size - 2 != num_controllers * 4) {
14064                 packet_hexdump(data + 2, size - 2);
14065                 return;
14066         }
14067
14068         for (i = 0; i < num_controllers; i++) {
14069                 uint16_t index = get_le16(data + 2 + (i * 4));
14070                 uint8_t type = get_u8(data + 4 + (i * 4));
14071                 uint8_t bus = get_u8(data + 5 + (i * 4));
14072                 const char *str;
14073
14074                 switch (type) {
14075                 case 0x00:
14076                         str = "Primary";
14077                         break;
14078                 case 0x01:
14079                         str = "Unconfigured";
14080                         break;
14081                 case 0x02:
14082                         str = "AMP";
14083                         break;
14084                 default:
14085                         str = "Reserved";
14086                         break;
14087                 }
14088
14089                 print_field("  hci%u (%s,%s)", index, str, hci_bustostr(bus));
14090         }
14091 }
14092
14093 static void mgmt_read_local_oob_ext_data_cmd(const void *data, uint16_t size)
14094 {
14095         uint8_t type = get_u8(data);
14096
14097         mgmt_print_address_type(type);
14098 }
14099
14100 static void mgmt_read_local_oob_ext_data_rsp(const void *data, uint16_t size)
14101 {
14102         uint8_t type = get_u8(data);
14103         uint16_t data_len = get_le16(data + 1);
14104
14105         mgmt_print_address_type(type);
14106         print_field("Data length: %u", data_len);
14107         print_eir(data + 3, size - 3, true);
14108 }
14109
14110 static void mgmt_read_advertising_features_rsp(const void *data, uint16_t size)
14111 {
14112         uint32_t flags = get_le32(data);
14113         uint8_t adv_data_len = get_u8(data + 4);
14114         uint8_t scan_rsp_len = get_u8(data + 5);
14115         uint8_t max_instances = get_u8(data + 6);
14116         uint8_t num_instances = get_u8(data + 7);
14117         int i;
14118
14119         mgmt_print_adv_flags(flags);
14120         print_field("Advertising data length: %u", adv_data_len);
14121         print_field("Scan response length: %u", scan_rsp_len);
14122         print_field("Max instances: %u", max_instances);
14123         print_field("Instances: %u", num_instances);
14124
14125         if (size - 8 != num_instances) {
14126                 packet_hexdump(data + 8, size - 8);
14127                 return;
14128         }
14129
14130         for (i = 0; i < num_instances; i++) {
14131                 uint8_t instance = get_u8(data + 8 + i);
14132
14133                 print_field("  %u", instance);
14134         }
14135 }
14136
14137 static void mgmt_add_advertising_cmd(const void *data, uint16_t size)
14138 {
14139         uint8_t instance = get_u8(data);
14140         uint32_t flags = get_le32(data + 1);
14141         uint16_t duration = get_le16(data + 5);
14142         uint16_t timeout = get_le16(data + 7);
14143         uint8_t adv_data_len = get_u8(data + 9);
14144         uint8_t scan_rsp_len = get_u8(data + 10);
14145
14146         print_field("Instance: %u", instance);
14147         mgmt_print_adv_flags(flags);
14148         print_field("Duration: %u", duration);
14149         print_field("Timeout: %u", timeout);
14150         print_field("Advertising data length: %u", adv_data_len);
14151         print_eir(data + 11, adv_data_len, false);
14152         print_field("Scan response length: %u", scan_rsp_len);
14153         print_eir(data + 11 + adv_data_len, scan_rsp_len, false);
14154 }
14155
14156 static void mgmt_add_advertising_rsp(const void *data, uint16_t size)
14157 {
14158         uint8_t instance = get_u8(data);
14159
14160         print_field("Instance: %u", instance);
14161 }
14162
14163 static void mgmt_remove_advertising_cmd(const void *data, uint16_t size)
14164 {
14165         uint8_t instance = get_u8(data);
14166
14167         print_field("Instance: %u", instance);
14168 }
14169
14170 static void mgmt_remove_advertising_rsp(const void *data, uint16_t size)
14171 {
14172         uint8_t instance = get_u8(data);
14173
14174         print_field("Instance: %u", instance);
14175 }
14176
14177 static void mgmt_get_advertising_size_info_cmd(const void *data, uint16_t size)
14178 {
14179         uint8_t instance = get_u8(data);
14180         uint32_t flags = get_le32(data + 1);
14181
14182         print_field("Instance: %u", instance);
14183         mgmt_print_adv_flags(flags);
14184 }
14185
14186 static void mgmt_get_advertising_size_info_rsp(const void *data, uint16_t size)
14187 {
14188         uint8_t instance = get_u8(data);
14189         uint32_t flags = get_le32(data + 1);
14190         uint8_t adv_data_len = get_u8(data + 5);
14191         uint8_t scan_rsp_len = get_u8(data + 6);
14192
14193         print_field("Instance: %u", instance);
14194         mgmt_print_adv_flags(flags);
14195         print_field("Advertising data length: %u", adv_data_len);
14196         print_field("Scan response length: %u", scan_rsp_len);
14197 }
14198
14199 static void mgmt_start_limited_discovery_cmd(const void *data, uint16_t size)
14200 {
14201         uint8_t type = get_u8(data);
14202
14203         mgmt_print_address_type(type);
14204 }
14205
14206 static void mgmt_start_limited_discovery_rsp(const void *data, uint16_t size)
14207 {
14208         uint8_t type = get_u8(data);
14209
14210         mgmt_print_address_type(type);
14211 }
14212
14213 static void mgmt_read_ext_controller_info_rsp(const void *data, uint16_t size)
14214 {
14215         uint8_t version = get_u8(data + 6);
14216         uint16_t manufacturer = get_le16(data + 7);
14217         uint32_t supported_settings = get_le32(data + 9);
14218         uint32_t current_settings = get_le32(data + 13);
14219         uint16_t data_len = get_le16(data + 17);
14220
14221         print_addr_resolve("Address", data, 0x00, false);
14222         mgmt_print_version(version);
14223         mgmt_print_manufacturer(manufacturer);
14224         mgmt_print_settings("Supported settings", supported_settings);
14225         mgmt_print_settings("Current settings", current_settings);
14226         print_field("Data length: %u", data_len);
14227         print_eir(data + 19, size - 19, false);
14228 }
14229
14230 static void mgmt_set_apperance_cmd(const void *data, uint16_t size)
14231 {
14232         uint16_t appearance = get_le16(data);
14233
14234         print_appearance(appearance);
14235 }
14236
14237 static const struct bitfield_data mgmt_phy_table[] = {
14238         {  0, "BR 1M 1SLOT"     },
14239         {  1, "BR 1M 3SLOT"     },
14240         {  2, "BR 1M 5SLOT"     },
14241         {  3, "EDR 2M 1SLOT"    },
14242         {  4, "EDR 2M 3SLOT"    },
14243         {  5, "EDR 2M 5SLOT"    },
14244         {  6, "EDR 3M 1SLOT"    },
14245         {  7, "EDR 3M 3SLOT"    },
14246         {  8, "EDR 3M 5SLOT"    },
14247         {  9, "LE 1M TX"        },
14248         {  10, "LE 1M RX"       },
14249         {  11, "LE 2M TX"       },
14250         {  12, "LE 2M RX"       },
14251         {  13, "LE CODED TX"    },
14252         {  14, "LE CODED RX"    },
14253         { }
14254 };
14255
14256 static void mgmt_print_phys(const char *label, uint16_t phys)
14257 {
14258         uint16_t mask;
14259
14260         print_field("%s: 0x%4.4x", label, phys);
14261
14262         mask = print_bitfield(2, phys, mgmt_phy_table);
14263         if (mask)
14264                 print_text(COLOR_UNKNOWN_PHY, "  Unknown PHYs"
14265                                                         " (0x%8.8x)", mask);
14266 }
14267
14268 static void mgmt_get_phy_rsp(const void *data, uint16_t size)
14269 {
14270         uint32_t supported_phys = get_le32(data);
14271         uint32_t configurable_phys = get_le32(data + 4);
14272         uint32_t selected_phys = get_le32(data + 8);
14273
14274         mgmt_print_phys("Supported PHYs", supported_phys);
14275         mgmt_print_phys("Configurable PHYs", configurable_phys);
14276         mgmt_print_phys("Selected PHYs", selected_phys);
14277 }
14278
14279 static void mgmt_set_phy_cmd(const void *data, uint16_t size)
14280 {
14281         uint32_t selected_phys = get_le32(data);
14282
14283         mgmt_print_phys("Selected PHYs", selected_phys);
14284 }
14285
14286 static void mgmt_read_exp_features_info_rsp(const void *data, uint16_t size)
14287 {
14288         uint16_t num_features = get_le16(data);
14289         int i;
14290
14291         print_field("Features: %u", num_features);
14292
14293         if (size - 2 != num_features * 20) {
14294                 packet_hexdump(data + 2, size - 2);
14295                 return;
14296         }
14297
14298         for (i = 0; i < num_features; i++)
14299                 mgmt_print_exp_feature(data + 2 + (i * 20));
14300 }
14301
14302 static void mgmt_set_exp_feature_cmd(const void *data, uint16_t size)
14303 {
14304         uint8_t enable = get_u8(data + 16);
14305
14306         print_field("UUID: %s", bt_uuid128_to_str(data));
14307         print_enable("Action", enable);
14308 }
14309
14310 static void mgmt_set_exp_feature_rsp(const void *data, uint16_t size)
14311 {
14312         mgmt_print_exp_feature(data);
14313 }
14314
14315 static const struct bitfield_data mgmt_added_device_flags_table[] = {
14316         { 0, "Remote Wakeup"            },
14317         { 1, "Device Privacy Mode"      },
14318         { }
14319 };
14320
14321 static void mgmt_print_added_device_flags(char *label, uint32_t flags)
14322 {
14323         uint32_t mask;
14324
14325         print_field("%s: 0x%8.8x", label, flags);
14326         mask = print_bitfield(2, flags, mgmt_added_device_flags_table);
14327         if (mask)
14328                 print_text(COLOR_UNKNOWN_ADDED_DEVICE_FLAG,
14329                            "  Unknown Flags (0x%8.8x)", mask);
14330 }
14331
14332 static void mgmt_get_device_flags_cmd(const void *data, uint16_t size)
14333 {
14334         uint8_t type = get_u8(data + 6);
14335
14336         mgmt_print_address(data, type);
14337 }
14338
14339 static void mgmt_get_device_flags_rsp(const void *data, uint16_t size)
14340 {
14341         uint8_t type = get_u8(data + 6);
14342         uint32_t supported_flags = get_le32(data + 7);
14343         uint32_t current_flags = get_le32(data + 11);
14344
14345         mgmt_print_address(data, type);
14346         mgmt_print_added_device_flags("Supported Flags", supported_flags);
14347         mgmt_print_added_device_flags("Current Flags", current_flags);
14348 }
14349
14350 static void mgmt_set_device_flags_cmd(const void *data, uint16_t size)
14351 {
14352         uint8_t type = get_u8(data + 6);
14353         uint32_t current_flags = get_le32(data + 7);
14354
14355         mgmt_print_address(data, type);
14356         mgmt_print_added_device_flags("Current Flags", current_flags);
14357 }
14358
14359 static void mgmt_set_device_flags_rsp(const void *data, uint16_t size)
14360 {
14361         uint8_t type = get_u8(data + 6);
14362
14363         mgmt_print_address(data, type);
14364 }
14365 static void mgmt_add_ext_adv_params_cmd(const void *data, uint16_t size)
14366 {
14367         uint8_t instance = get_u8(data);
14368         uint32_t flags = get_le32(data + 1);
14369         uint16_t duration = get_le16(data + 5);
14370         uint16_t timeout = get_le16(data + 7);
14371         uint8_t *min_interval = (uint8_t *)(data + 9);
14372         uint8_t *max_interval = (uint8_t *)(data + 13);
14373         int8_t tx_power = get_s8(data + 17);
14374
14375         print_field("Instance: %u", instance);
14376         mgmt_print_adv_flags(flags);
14377         print_field("Duration: %u", duration);
14378         print_field("Timeout: %u", timeout);
14379         print_ext_slot_625("Min advertising interval", min_interval);
14380         print_ext_slot_625("Max advertising interval", max_interval);
14381         print_power_level(tx_power, NULL);
14382 }
14383
14384 static void mgmt_add_ext_adv_params_rsp(const void *data, uint16_t size)
14385 {
14386         uint8_t instance = get_u8(data);
14387         int8_t tx_power = get_s8(data + 1);
14388         uint8_t max_adv_data_len = get_u8(data+2);
14389         uint8_t max_scan_rsp_len = get_u8(data+3);
14390
14391         print_field("Instance: %u", instance);
14392         print_power_level(tx_power, NULL);
14393         print_field("Available adv data len: %u", max_adv_data_len);
14394         print_field("Available scan rsp data len: %u", max_scan_rsp_len);
14395 }
14396
14397 static void mgmt_add_ext_adv_data_cmd(const void *data, uint16_t size)
14398 {
14399         uint8_t instance = get_u8(data);
14400         uint8_t adv_data_len = get_u8(data + 1);
14401         uint8_t scan_rsp_len = get_u8(data + 2);
14402
14403         print_field("Instance: %u", instance);
14404         print_field("Advertising data length: %u", adv_data_len);
14405         print_eir(data + 3, adv_data_len, false);
14406         print_field("Scan response length: %u", scan_rsp_len);
14407         print_eir(data + 3 + adv_data_len, scan_rsp_len, false);
14408 }
14409
14410 static void mgmt_add_ext_adv_data_rsp(const void *data, uint16_t size)
14411 {
14412         uint8_t instance = get_u8(data);
14413
14414         print_field("Instance: %u", instance);
14415 }
14416
14417 static const struct bitfield_data mgmt_adv_monitor_features_table[] = {
14418         { 1, "OR Patterns"      },
14419         { }
14420 };
14421
14422 static void mgmt_print_adv_monitor_features(char *label, uint32_t flags)
14423 {
14424         uint32_t mask;
14425
14426         print_field("%s: 0x%8.8x", label, flags);
14427         mask = print_bitfield(2, flags, mgmt_adv_monitor_features_table);
14428         if (mask)
14429                 print_text(COLOR_UNKNOWN_ADVMON_FEATURES,
14430                            "  Unknown Flags (0x%8.8x)", mask);
14431 }
14432
14433 static void mgmt_print_adv_monitor_handles(const void *data, uint8_t len)
14434 {
14435         uint8_t idx = 0;
14436
14437         while (idx + 2 <= len) {
14438                 print_field("  Handle: %d", get_le16(data + idx));
14439                 idx += 2;
14440         }
14441 }
14442
14443 static void mgmt_read_adv_monitor_features_rsp(const void *data, uint16_t size)
14444 {
14445         uint32_t supported_features = get_le32(data);
14446         uint32_t enabled_features = get_le32(data + 4);
14447         uint16_t max_num_handles = get_le16(data + 8);
14448         uint8_t max_num_patterns = get_u8(data + 10);
14449         uint16_t num_handles = get_le16(data + 11);
14450
14451         mgmt_print_adv_monitor_features("Supported Features",
14452                                                         supported_features);
14453         mgmt_print_adv_monitor_features("Enabled Features",
14454                                                         enabled_features);
14455         print_field("Max number of handles: %d", max_num_handles);
14456         print_field("Max number of patterns: %d", max_num_patterns);
14457         print_field("Number of handles: %d", num_handles);
14458         mgmt_print_adv_monitor_handles(data + 13, size - 13);
14459 }
14460
14461 static void mgmt_print_adv_monitor_patterns(const void *data, uint8_t len)
14462 {
14463         uint8_t data_idx = 0, pattern_idx = 1;
14464
14465         /* Reference: struct mgmt_adv_pattern in lib/mgmt.h. */
14466         while (data_idx + 34 <= len) {
14467                 uint8_t ad_type = get_u8(data);
14468                 uint8_t offset = get_u8(data + 1);
14469                 uint8_t length = get_u8(data + 2);
14470
14471                 print_field("  Pattern %d:", pattern_idx);
14472                 print_field("    AD type: %d", ad_type);
14473                 print_field("    Offset: %d", offset);
14474                 print_field("    Length: %d", length);
14475                 if (length <= 31)
14476                         print_hex_field("    Value ", data + 3, length);
14477                 else
14478                         print_text(COLOR_ERROR, "    invalid length");
14479
14480                 pattern_idx += 1;
14481                 data_idx += 34;
14482                 data += 34;
14483         }
14484 }
14485
14486 static void mgmt_add_adv_monitor_patterns_cmd(const void *data, uint16_t size)
14487 {
14488         uint8_t pattern_count = get_u8(data);
14489
14490         print_field("Number of patterns: %d", pattern_count);
14491         mgmt_print_adv_monitor_patterns(data + 1, size - 1);
14492 }
14493
14494 static void mgmt_add_adv_monitor_patterns_rssi_cmd(const void *data,
14495                                                                 uint16_t size)
14496 {
14497         int8_t high_rssi = get_s8(data);
14498         uint16_t high_rssi_timeout = get_le16(data + 1);
14499         int8_t low_rssi = get_s8(data + 3);
14500         uint16_t low_rssi_timeout = get_le16(data + 4);
14501         uint8_t sampling_period = get_u8(data + 6);
14502         uint8_t pattern_count = get_u8(data + 7);
14503
14504         print_field("RSSI data:");
14505         print_field("  high threshold: %d dBm", high_rssi);
14506         print_field("  high timeout: %d seconds", high_rssi_timeout);
14507         print_field("  low threshold: %d dBm", low_rssi);
14508         print_field("  low timeout: %d seconds", low_rssi_timeout);
14509
14510         if (sampling_period == 0)
14511                 print_field("  sampling: propagate all (0x00)");
14512         else if (sampling_period == 0xff)
14513                 print_field("  sampling: just once (0xFF)");
14514         else
14515                 print_field("  sampling: every %d ms", 100 * sampling_period);
14516
14517         print_field("Number of patterns: %d", pattern_count);
14518         mgmt_print_adv_monitor_patterns(data + 8, size - 8);
14519 }
14520
14521 static void mgmt_add_adv_monitor_patterns_rsp(const void *data, uint16_t size)
14522 {
14523         uint16_t handle = get_le16(data);
14524
14525         print_field("Handle: %d", handle);
14526 }
14527
14528 static void mgmt_remove_adv_monitor_patterns_cmd(const void *data,
14529                                                                 uint16_t size)
14530 {
14531         uint16_t handle = get_le16(data);
14532
14533         print_field("Handle: %d", handle);
14534 }
14535
14536 static void mgmt_remove_adv_monitor_patterns_rsp(const void *data,
14537                                                                 uint16_t size)
14538 {
14539         uint16_t handle = get_le16(data);
14540
14541         print_field("Handle: %d", handle);
14542 }
14543
14544 static void mgmt_set_mesh_receiver_cmd(const void *data, uint16_t size)
14545 {
14546         uint8_t enable = get_u8(data);
14547         uint16_t window = get_le16(data + 1);
14548         uint16_t period = get_le16(data + 3);
14549         uint8_t num_ad_types = get_u8(data + 5);
14550         const uint8_t *ad_types = data + 6;
14551
14552         print_field("Enable: %d", enable);
14553         print_field("Window: %d", window);
14554         print_field("Period: %d", period);
14555         print_field("Num AD Types: %d", num_ad_types);
14556         size -= 6;
14557
14558         while (size--)
14559                 print_field("  AD Type: %d", *ad_types++);
14560 }
14561
14562 static void mgmt_read_mesh_features_rsp(const void *data, uint16_t size)
14563 {
14564         uint16_t index = get_le16(data);
14565         uint8_t max_handles = get_u8(data + 2);
14566         uint8_t used_handles = get_u8(data + 3);
14567         const uint8_t *handles = data + 4;
14568
14569         print_field("Index: %d", index);
14570         print_field("Max Handles: %d", max_handles);
14571         print_field("Used Handles: %d", used_handles);
14572         size -= 4;
14573
14574         while (size--)
14575                 print_field("  Used Handle: %d", *handles++);
14576 }
14577
14578 static void mgmt_mesh_send_cmd(const void *data, uint16_t size)
14579 {
14580         const uint8_t *addr = data;
14581         uint8_t addr_type = get_u8(data + 6);
14582         uint64_t instant = get_le64(data + 7);
14583         uint16_t delay = get_le16(data + 15);
14584         uint8_t cnt = get_u8(data + 17);
14585         uint8_t adv_data_len = get_u8(data + 18);
14586
14587         data += 19;
14588         size -= 19;
14589         print_bdaddr(addr);
14590         print_field("Addr Type: %d", addr_type);
14591         print_field("Instant: 0x%16.16" PRIx64, instant);
14592         print_field("Delay: %d", delay);
14593         print_field("Count: %d", cnt);
14594         print_field("Data Length: %d", adv_data_len);
14595         print_hex_field("Data", data, size);
14596 }
14597
14598 static void mgmt_mesh_send_rsp(const void *data, uint16_t size)
14599 {
14600         uint8_t handle = get_u8(data);
14601
14602         print_field("Handle: %d", handle);
14603 }
14604
14605 static void mgmt_mesh_send_cancel_cmd(const void *data, uint16_t size)
14606 {
14607         uint8_t handle = get_u8(data);
14608
14609         print_field("Handle: %d", handle);
14610 }
14611
14612 struct mgmt_data {
14613         uint16_t opcode;
14614         const char *str;
14615         void (*func) (const void *data, uint16_t size);
14616         uint16_t size;
14617         bool fixed;
14618         void (*rsp_func) (const void *data, uint16_t size);
14619         uint16_t rsp_size;
14620         bool rsp_fixed;
14621 };
14622
14623 static const struct mgmt_data mgmt_command_table[] = {
14624         { 0x0001, "Read Management Version Information",
14625                                 mgmt_null_cmd, 0, true,
14626                                 mgmt_read_version_info_rsp, 3, true },
14627         { 0x0002, "Read Management Supported Commands",
14628                                 mgmt_null_cmd, 0, true,
14629                                 mgmt_read_supported_commands_rsp, 4, false },
14630         { 0x0003, "Read Controller Index List",
14631                                 mgmt_null_cmd, 0, true,
14632                                 mgmt_read_index_list_rsp, 2, false },
14633         { 0x0004, "Read Controller Information",
14634                                 mgmt_null_cmd, 0, true,
14635                                 mgmt_read_controller_info_rsp, 280, true },
14636         { 0x0005, "Set Powered",
14637                                 mgmt_set_powered_cmd, 1, true,
14638                                 mgmt_new_settings_rsp, 4, true },
14639         { 0x0006, "Set Discoverable",
14640                                 mgmt_set_discoverable_cmd, 3, true,
14641                                 mgmt_new_settings_rsp, 4, true },
14642         { 0x0007, "Set Connectable",
14643                                 mgmt_set_connectable_cmd, 1, true,
14644                                 mgmt_new_settings_rsp, 4, true },
14645         { 0x0008, "Set Fast Connectable",
14646                                 mgmt_set_fast_connectable_cmd, 1, true,
14647                                 mgmt_new_settings_rsp, 4, true },
14648         { 0x0009, "Set Bondable",
14649                                 mgmt_set_bondable_cmd, 1, true,
14650                                 mgmt_new_settings_rsp, 4, true },
14651         { 0x000a, "Set Link Security",
14652                                 mgmt_set_link_security_cmd, 1, true,
14653                                 mgmt_new_settings_rsp, 4, true },
14654         { 0x000b, "Set Secure Simple Pairing",
14655                                 mgmt_set_secure_simple_pairing_cmd, 1, true,
14656                                 mgmt_new_settings_rsp, 4, true },
14657         { 0x000c, "Set High Speed",
14658                                 mgmt_set_high_speed_cmd, 1, true,
14659                                 mgmt_new_settings_rsp, 4, true },
14660         { 0x000d, "Set Low Energy",
14661                                 mgmt_set_low_energy_cmd, 1, true,
14662                                 mgmt_new_settings_rsp, 4, true },
14663         { 0x000e, "Set Device Class",
14664                                 mgmt_set_device_class_cmd, 2, true,
14665                                 mgmt_set_device_class_rsp, 3, true },
14666         { 0x000f, "Set Local Name",
14667                                 mgmt_set_local_name_cmd, 260, true,
14668                                 mgmt_set_local_name_rsp, 260, true },
14669         { 0x0010, "Add UUID",
14670                                 mgmt_add_uuid_cmd, 17, true,
14671                                 mgmt_add_uuid_rsp, 3, true },
14672         { 0x0011, "Remove UUID",
14673                                 mgmt_remove_uuid_cmd, 16, true,
14674                                 mgmt_remove_uuid_rsp, 3, true },
14675         { 0x0012, "Load Link Keys",
14676                                 mgmt_load_link_keys_cmd, 3, false,
14677                                 mgmt_null_rsp, 0, true },
14678         { 0x0013, "Load Long Term Keys",
14679                                 mgmt_load_long_term_keys_cmd, 2, false,
14680                                 mgmt_null_rsp, 0, true },
14681         { 0x0014, "Disconnect",
14682                                 mgmt_disconnect_cmd, 7, true,
14683                                 mgmt_disconnect_rsp, 7, true },
14684         { 0x0015, "Get Connections",
14685                                 mgmt_null_cmd, 0, true,
14686                                 mgmt_get_connections_rsp, 2, false },
14687         { 0x0016, "PIN Code Reply",
14688                                 mgmt_pin_code_reply_cmd, 24, true,
14689                                 mgmt_pin_code_reply_rsp, 7, true },
14690         { 0x0017, "PIN Code Negative Reply",
14691                                 mgmt_pin_code_neg_reply_cmd, 7, true,
14692                                 mgmt_pin_code_neg_reply_rsp, 7, true },
14693         { 0x0018, "Set IO Capability",
14694                                 mgmt_set_io_capability_cmd, 1, true,
14695                                 mgmt_null_rsp, 0, true },
14696         { 0x0019, "Pair Device",
14697                                 mgmt_pair_device_cmd, 8, true,
14698                                 mgmt_pair_device_rsp, 7, true },
14699         { 0x001a, "Cancel Pair Device",
14700                                 mgmt_cancel_pair_device_cmd, 7, true,
14701                                 mgmt_cancel_pair_device_rsp, 7, true },
14702         { 0x001b, "Unpair Device",
14703                                 mgmt_unpair_device_cmd, 8, true,
14704                                 mgmt_unpair_device_rsp, 7, true },
14705         { 0x001c, "User Confirmation Reply",
14706                                 mgmt_user_confirmation_reply_cmd, 7, true,
14707                                 mgmt_user_confirmation_reply_rsp, 7, true },
14708         { 0x001d, "User Confirmation Negative Reply",
14709                                 mgmt_user_confirmation_neg_reply_cmd, 7, true,
14710                                 mgmt_user_confirmation_neg_reply_rsp, 7, true },
14711         { 0x001e, "User Passkey Reply",
14712                                 mgmt_user_passkey_reply_cmd, 11, true,
14713                                 mgmt_user_passkey_reply_rsp, 7, true },
14714         { 0x001f, "User Passkey Negative Reply",
14715                                 mgmt_user_passkey_neg_reply_cmd, 7, true,
14716                                 mgmt_user_passkey_neg_reply_rsp, 7, true },
14717         { 0x0020, "Read Local Out Of Band Data",
14718                                 mgmt_null_cmd, 0, true,
14719                                 mgmt_read_local_oob_data_rsp, 64, true },
14720         { 0x0021, "Add Remote Out Of Band Data",
14721                                 mgmt_add_remote_oob_data_cmd, 71, true,
14722                                 mgmt_add_remote_oob_data_rsp, 7, true },
14723         { 0x0022, "Remove Remote Out Of Band Data",
14724                                 mgmt_remove_remote_oob_data_cmd, 7, true,
14725                                 mgmt_remove_remote_oob_data_rsp, 7, true },
14726         { 0x0023, "Start Discovery",
14727                                 mgmt_start_discovery_cmd, 1, true,
14728                                 mgmt_start_discovery_rsp, 1, true },
14729         { 0x0024, "Stop Discovery",
14730                                 mgmt_stop_discovery_cmd, 1, true,
14731                                 mgmt_stop_discovery_rsp, 1, true },
14732         { 0x0025, "Confirm Name",
14733                                 mgmt_confirm_name_cmd, 8, true,
14734                                 mgmt_confirm_name_rsp, 7, true },
14735         { 0x0026, "Block Device",
14736                                 mgmt_block_device_cmd, 7, true,
14737                                 mgmt_block_device_rsp, 7, true },
14738         { 0x0027, "Unblock Device",
14739                                 mgmt_unblock_device_cmd, 7, true,
14740                                 mgmt_unblock_device_rsp, 7, true },
14741         { 0x0028, "Set Device ID",
14742                                 mgmt_set_device_id_cmd, 8, true,
14743                                 mgmt_null_rsp, 0, true },
14744         { 0x0029, "Set Advertising",
14745                                 mgmt_set_advertising_cmd, 1, true,
14746                                 mgmt_new_settings_rsp, 4, true },
14747         { 0x002a, "Set BR/EDR",
14748                                 mgmt_set_bredr_cmd, 1, true,
14749                                 mgmt_new_settings_rsp, 4, true },
14750         { 0x002b, "Set Static Address",
14751                                 mgmt_set_static_address_cmd, 6, true,
14752                                 mgmt_new_settings_rsp, 4, true },
14753         { 0x002c, "Set Scan Parameters",
14754                                 mgmt_set_scan_parameters_cmd, 4, true,
14755                                 mgmt_null_rsp, 0, true },
14756         { 0x002d, "Set Secure Connections",
14757                                 mgmt_set_secure_connections_cmd, 1, true,
14758                                 mgmt_new_settings_rsp, 4, true },
14759         { 0x002e, "Set Debug Keys",
14760                                 mgmt_set_debug_keys_cmd, 1, true,
14761                                 mgmt_new_settings_rsp, 4, true },
14762         { 0x002f, "Set Privacy",
14763                                 mgmt_set_privacy_cmd, 17, true,
14764                                 mgmt_new_settings_rsp, 4, true },
14765         { 0x0030, "Load Identity Resolving Keys",
14766                                 mgmt_load_identity_resolving_keys_cmd, 2, false,
14767                                 mgmt_null_rsp, 0, true },
14768         { 0x0031, "Get Connection Information",
14769                                 mgmt_get_connection_information_cmd, 7, true,
14770                                 mgmt_get_connection_information_rsp, 10, true },
14771         { 0x0032, "Get Clock Information",
14772                                 mgmt_get_clock_information_cmd, 7, true,
14773                                 mgmt_get_clock_information_rsp, 17, true },
14774         { 0x0033, "Add Device",
14775                                 mgmt_add_device_cmd, 8, true,
14776                                 mgmt_add_device_rsp, 7, true },
14777         { 0x0034, "Remove Device",
14778                                 mgmt_remove_device_cmd, 7, true,
14779                                 mgmt_remove_device_rsp, 7, true },
14780         { 0x0035, "Load Connection Parameters",
14781                                 mgmt_load_connection_parameters_cmd, 2, false,
14782                                 mgmt_null_rsp, 0, true },
14783         { 0x0036, "Read Unconfigured Controller Index List",
14784                                 mgmt_null_cmd, 0, true,
14785                                 mgmt_read_unconf_index_list_rsp, 2, false },
14786         { 0x0037, "Read Controller Configuration Information",
14787                                 mgmt_null_cmd, 0, true,
14788                                 mgmt_read_controller_conf_info_rsp, 10, true },
14789         { 0x0038, "Set External Configuration",
14790                                 mgmt_set_external_configuration_cmd, 1, true,
14791                                 mgmt_new_options_rsp, 4, true },
14792         { 0x0039, "Set Public Address",
14793                                 mgmt_set_public_address_cmd, 6, true,
14794                                 mgmt_new_options_rsp, 4, true },
14795         { 0x003a, "Start Service Discovery",
14796                                 mgmt_start_service_discovery_cmd, 3, false,
14797                                 mgmt_start_service_discovery_rsp, 1, true },
14798         { 0x003b, "Read Local Out Of Band Extended Data",
14799                                 mgmt_read_local_oob_ext_data_cmd, 1, true,
14800                                 mgmt_read_local_oob_ext_data_rsp, 3, false },
14801         { 0x003c, "Read Extended Controller Index List",
14802                                 mgmt_null_cmd, 0, true,
14803                                 mgmt_read_ext_index_list_rsp, 2, false },
14804         { 0x003d, "Read Advertising Features",
14805                                 mgmt_null_cmd, 0, true,
14806                                 mgmt_read_advertising_features_rsp, 8, false },
14807         { 0x003e, "Add Advertising",
14808                                 mgmt_add_advertising_cmd, 11, false,
14809                                 mgmt_add_advertising_rsp, 1, true },
14810         { 0x003f, "Remove Advertising",
14811                                 mgmt_remove_advertising_cmd, 1, true,
14812                                 mgmt_remove_advertising_rsp, 1, true },
14813         { 0x0040, "Get Advertising Size Information",
14814                                 mgmt_get_advertising_size_info_cmd, 5, true,
14815                                 mgmt_get_advertising_size_info_rsp, 7, true },
14816         { 0x0041, "Start Limited Discovery",
14817                                 mgmt_start_limited_discovery_cmd, 1, true,
14818                                 mgmt_start_limited_discovery_rsp, 1, true },
14819         { 0x0042, "Read Extended Controller Information",
14820                                 mgmt_null_cmd, 0, true,
14821                                 mgmt_read_ext_controller_info_rsp, 19, false },
14822         { 0x0043, "Set Appearance",
14823                                 mgmt_set_apperance_cmd, 2, true,
14824                                 mgmt_null_rsp, 0, true },
14825         { 0x0044, "Get PHY Configuration",
14826                                 mgmt_null_cmd, 0, true,
14827                                 mgmt_get_phy_rsp, 12, true },
14828         { 0x0045, "Set PHY Configuration",
14829                                 mgmt_set_phy_cmd, 4, true,
14830                                 mgmt_null_rsp, 0, true },
14831         { 0x0046, "Load Blocked Keys" },
14832         { 0x0047, "Set Wideband Speech" },
14833         { 0x0048, "Read Controller Capabilities" },
14834         { 0x0049, "Read Experimental Features Information",
14835                                 mgmt_null_cmd, 0, true,
14836                                 mgmt_read_exp_features_info_rsp, 2, false },
14837         { 0x004a, "Set Experimental Feature",
14838                                 mgmt_set_exp_feature_cmd, 17, true,
14839                                 mgmt_set_exp_feature_rsp, 20, true },
14840         { 0x004b, "Read Default System Configuration" },
14841         { 0x004c, "Set Default System Configuration" },
14842         { 0x004d, "Read Default Runtime Configuration" },
14843         { 0x004e, "Set Default Runtime Configuration" },
14844         { 0x004f, "Get Device Flags",
14845                                 mgmt_get_device_flags_cmd, 7, true,
14846                                 mgmt_get_device_flags_rsp, 15, true},
14847         { 0x0050, "Set Device Flags",
14848                                 mgmt_set_device_flags_cmd, 11, true,
14849                                 mgmt_set_device_flags_rsp, 7, true},
14850         { 0x0051, "Read Advertisement Monitor Features",
14851                                 mgmt_null_cmd, 0, true,
14852                                 mgmt_read_adv_monitor_features_rsp, 13, false},
14853         { 0x0052, "Add Advertisement Patterns Monitor",
14854                                 mgmt_add_adv_monitor_patterns_cmd, 1, false,
14855                                 mgmt_add_adv_monitor_patterns_rsp, 2, true},
14856         { 0x0053, "Remove Advertisement Monitor",
14857                                 mgmt_remove_adv_monitor_patterns_cmd, 2, true,
14858                                 mgmt_remove_adv_monitor_patterns_rsp, 2, true},
14859         { 0x0054, "Add Extended Advertising Parameters",
14860                                 mgmt_add_ext_adv_params_cmd, 18, false,
14861                                 mgmt_add_ext_adv_params_rsp, 4, true },
14862         { 0x0055, "Add Extended Advertising Data",
14863                                 mgmt_add_ext_adv_data_cmd, 3, false,
14864                                 mgmt_add_ext_adv_data_rsp, 1, true },
14865         { 0x0056, "Add Advertisement Patterns Monitor With RSSI Threshold",
14866                                 mgmt_add_adv_monitor_patterns_rssi_cmd, 8,
14867                                                                         false,
14868                                 mgmt_add_adv_monitor_patterns_rsp, 2, true},
14869         { 0x0057, "Set Mesh Receiver",
14870                                 mgmt_set_mesh_receiver_cmd, 6, false,
14871                                 mgmt_null_rsp, 0, true},
14872         { 0x0058, "Read Mesh Features",
14873                                 mgmt_null_cmd, 0, true,
14874                                 mgmt_read_mesh_features_rsp, 4, false},
14875         { 0x0059, "Mesh Send",
14876                                 mgmt_mesh_send_cmd, 19, false,
14877                                 mgmt_mesh_send_rsp, 1, true},
14878         { 0x0056, "Mesh Send Cancel",
14879                                 mgmt_mesh_send_cancel_cmd, 1, true,
14880                                 mgmt_null_rsp, 0, true},
14881         { }
14882 };
14883
14884 static void mgmt_null_evt(const void *data, uint16_t size)
14885 {
14886 }
14887
14888 static void mgmt_command_complete_evt(const void *data, uint16_t size)
14889 {
14890         uint16_t opcode;
14891         uint8_t status;
14892         const struct mgmt_data *mgmt_data = NULL;
14893         const char *mgmt_color, *mgmt_str;
14894         int i;
14895
14896         opcode = get_le16(data);
14897         status = get_u8(data + 2);
14898
14899         data += 3;
14900         size -= 3;
14901
14902         for (i = 0; mgmt_command_table[i].str; i++) {
14903                 if (mgmt_command_table[i].opcode == opcode) {
14904                         mgmt_data = &mgmt_command_table[i];
14905                         break;
14906                 }
14907         }
14908
14909         if (mgmt_data) {
14910                 if (mgmt_data->rsp_func)
14911                         mgmt_color = COLOR_CTRL_COMMAND;
14912                 else
14913                         mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14914                 mgmt_str = mgmt_data->str;
14915         } else {
14916                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14917                 mgmt_str = "Unknown";
14918         }
14919
14920         print_indent(6, mgmt_color, "", mgmt_str, COLOR_OFF,
14921                                         " (0x%4.4x) plen %u", opcode, size);
14922
14923         mgmt_print_status(status);
14924
14925         if (!mgmt_data || !mgmt_data->rsp_func) {
14926                 packet_hexdump(data, size);
14927                 return;
14928         }
14929
14930         if (mgmt_data->rsp_fixed) {
14931                 if (size != mgmt_data->rsp_size) {
14932                         print_text(COLOR_ERROR, "invalid packet size");
14933                         packet_hexdump(data, size);
14934                         return;
14935                 }
14936         } else {
14937                 if (size < mgmt_data->rsp_size) {
14938                         print_text(COLOR_ERROR, "too short packet");
14939                         packet_hexdump(data, size);
14940                         return;
14941                 }
14942         }
14943
14944         mgmt_data->rsp_func(data, size);
14945 }
14946
14947 static void mgmt_command_status_evt(const void *data, uint16_t size)
14948 {
14949         uint16_t opcode;
14950         uint8_t status;
14951         const struct mgmt_data *mgmt_data = NULL;
14952         const char *mgmt_color, *mgmt_str;
14953         int i;
14954
14955         opcode = get_le16(data);
14956         status = get_u8(data + 2);
14957
14958         for (i = 0; mgmt_command_table[i].str; i++) {
14959                 if (mgmt_command_table[i].opcode == opcode) {
14960                         mgmt_data = &mgmt_command_table[i];
14961                         break;
14962                 }
14963         }
14964
14965         if (mgmt_data) {
14966                 mgmt_color = COLOR_CTRL_COMMAND;
14967                 mgmt_str = mgmt_data->str;
14968         } else {
14969                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
14970                 mgmt_str = "Unknown";
14971         }
14972
14973         print_indent(6, mgmt_color, "", mgmt_str, COLOR_OFF,
14974                                                 " (0x%4.4x)", opcode);
14975
14976         mgmt_print_status(status);
14977 }
14978
14979 static void mgmt_controller_error_evt(const void *data, uint16_t size)
14980 {
14981         uint8_t error = get_u8(data);
14982
14983         print_field("Error: 0x%2.2x", error);
14984 }
14985
14986 static void mgmt_new_settings_evt(const void *data, uint16_t size)
14987 {
14988         uint32_t settings = get_le32(data);
14989
14990         mgmt_print_settings("Current settings", settings);
14991 }
14992
14993 static void mgmt_class_of_dev_changed_evt(const void *data, uint16_t size)
14994 {
14995         print_dev_class(data);
14996 }
14997
14998 static void mgmt_local_name_changed_evt(const void *data, uint16_t size)
14999 {
15000         mgmt_print_name(data);
15001 }
15002
15003 static void mgmt_new_link_key_evt(const void *data, uint16_t size)
15004 {
15005         uint8_t store_hint = get_u8(data);
15006
15007         mgmt_print_store_hint(store_hint);
15008         mgmt_print_link_key(data + 1);
15009 }
15010
15011 static void mgmt_new_long_term_key_evt(const void *data, uint16_t size)
15012 {
15013         uint8_t store_hint = get_u8(data);
15014
15015         mgmt_print_store_hint(store_hint);
15016         mgmt_print_long_term_key(data + 1);
15017 }
15018
15019 static void mgmt_device_connected_evt(const void *data, uint16_t size)
15020 {
15021         uint8_t address_type = get_u8(data + 6);
15022         uint32_t flags = get_le32(data + 7);
15023         uint16_t data_len = get_le16(data + 11);
15024
15025         mgmt_print_address(data, address_type);
15026         mgmt_print_device_flags(flags);
15027         print_field("Data length: %u", data_len);
15028         print_eir(data + 13, size - 13, false);
15029 }
15030
15031 static void mgmt_device_disconnected_evt(const void *data, uint16_t size)
15032 {
15033         uint8_t address_type = get_u8(data + 6);
15034         uint8_t reason = get_u8(data + 7);
15035         const char *str;
15036
15037         mgmt_print_address(data, address_type);
15038
15039         switch (reason) {
15040         case 0x00:
15041                 str = "Unspecified";
15042                 break;
15043         case 0x01:
15044                 str = "Connection timeout";
15045                 break;
15046         case 0x02:
15047                 str = "Connection terminated by local host";
15048                 break;
15049         case 0x03:
15050                 str = "Connection terminated by remote host";
15051                 break;
15052         case 0x04:
15053                 str = "Connection terminated due to authentication failure";
15054                 break;
15055         case 0x05:
15056                 str = "Connection terminated by local host for suspend";
15057                 break;
15058         default:
15059                 str = "Reserved";
15060                 break;
15061         }
15062
15063         print_field("Reason: %s (0x%2.2x)", str, reason);
15064 }
15065
15066 static void mgmt_connect_failed_evt(const void *data, uint16_t size)
15067 {
15068         uint8_t address_type = get_u8(data + 6);
15069         uint8_t status = get_u8(data + 7);
15070
15071         mgmt_print_address(data, address_type);
15072         mgmt_print_status(status);
15073 }
15074
15075 static void mgmt_pin_code_request_evt(const void *data, uint16_t size)
15076 {
15077         uint8_t address_type = get_u8(data + 6);
15078         uint8_t secure_pin = get_u8(data + 7);
15079
15080         mgmt_print_address(data, address_type);
15081         print_field("Secure PIN: 0x%2.2x", secure_pin);
15082 }
15083
15084 static void mgmt_user_confirmation_request_evt(const void *data, uint16_t size)
15085 {
15086         uint8_t address_type = get_u8(data + 6);
15087         uint8_t confirm_hint = get_u8(data + 7);
15088         uint32_t value = get_le32(data + 8);
15089
15090         mgmt_print_address(data, address_type);
15091         print_field("Confirm hint: 0x%2.2x", confirm_hint);
15092         print_field("Value: 0x%8.8x", value);
15093 }
15094
15095 static void mgmt_user_passkey_request_evt(const void *data, uint16_t size)
15096 {
15097         uint8_t address_type = get_u8(data + 6);
15098
15099         mgmt_print_address(data, address_type);
15100 }
15101
15102 static void mgmt_authentication_failed_evt(const void *data, uint16_t size)
15103 {
15104         uint8_t address_type = get_u8(data + 6);
15105         uint8_t status = get_u8(data + 7);
15106
15107         mgmt_print_address(data, address_type);
15108         mgmt_print_status(status);
15109 }
15110
15111 static void mgmt_device_found_evt(const void *data, uint16_t size)
15112 {
15113         uint8_t address_type = get_u8(data + 6);
15114         int8_t rssi = get_s8(data + 7);
15115         uint32_t flags = get_le32(data + 8);
15116         uint16_t data_len = get_le16(data + 12);
15117
15118         mgmt_print_address(data, address_type);
15119         print_rssi(rssi);
15120         mgmt_print_device_flags(flags);
15121         print_field("Data length: %u", data_len);
15122         print_eir(data + 14, size - 14, false);
15123 }
15124
15125 static void mgmt_discovering_evt(const void *data, uint16_t size)
15126 {
15127         uint8_t type = get_u8(data);
15128         uint8_t enable = get_u8(data + 1);
15129
15130         mgmt_print_address_type(type);
15131         print_enable("Discovery", enable);
15132 }
15133
15134 static void mgmt_device_blocked_evt(const void *data, uint16_t size)
15135 {
15136         uint8_t address_type = get_u8(data + 6);
15137
15138         mgmt_print_address(data, address_type);
15139 }
15140
15141 static void mgmt_device_unblocked_evt(const void *data, uint16_t size)
15142 {
15143         uint8_t address_type = get_u8(data + 6);
15144
15145         mgmt_print_address(data, address_type);
15146 }
15147
15148 static void mgmt_device_unpaired_evt(const void *data, uint16_t size)
15149 {
15150         uint8_t address_type = get_u8(data + 6);
15151
15152         mgmt_print_address(data, address_type);
15153 }
15154
15155 static void mgmt_passkey_notify_evt(const void *data, uint16_t size)
15156 {
15157         uint8_t address_type = get_u8(data + 6);
15158         uint32_t passkey = get_le32(data + 7);
15159         uint8_t entered = get_u8(data + 11);
15160
15161         mgmt_print_address(data, address_type);
15162         print_field("Passkey: 0x%8.8x", passkey);
15163         print_field("Entered: %u", entered);
15164 }
15165
15166 static void mgmt_new_identity_resolving_key_evt(const void *data, uint16_t size)
15167 {
15168         uint8_t store_hint = get_u8(data);
15169
15170         mgmt_print_store_hint(store_hint);
15171         print_addr_resolve("Random address", data + 1, 0x01, false);
15172         mgmt_print_identity_resolving_key(data + 7);
15173 }
15174
15175 static void mgmt_new_signature_resolving_key_evt(const void *data, uint16_t size)
15176 {
15177         uint8_t store_hint = get_u8(data);
15178
15179         mgmt_print_store_hint(store_hint);
15180         mgmt_print_signature_resolving_key(data + 1);
15181 }
15182
15183 static void mgmt_device_added_evt(const void *data, uint16_t size)
15184 {
15185         uint8_t address_type = get_u8(data + 6);
15186         uint8_t action = get_u8(data + 7);
15187
15188         mgmt_print_address(data, address_type);
15189         mgmt_print_device_action(action);
15190 }
15191
15192 static void mgmt_device_removed_evt(const void *data, uint16_t size)
15193 {
15194         uint8_t address_type = get_u8(data + 6);
15195
15196         mgmt_print_address(data, address_type);
15197 }
15198
15199 static void mgmt_new_connection_parameter_evt(const void *data, uint16_t size)
15200 {
15201         uint8_t store_hint = get_u8(data);
15202
15203         mgmt_print_store_hint(store_hint);
15204         mgmt_print_connection_parameter(data + 1);
15205 }
15206
15207 static void mgmt_new_conf_options_evt(const void *data, uint16_t size)
15208 {
15209         uint32_t missing_options = get_le32(data);
15210
15211         mgmt_print_options("Missing options", missing_options);
15212 }
15213
15214 static void mgmt_ext_index_added_evt(const void *data, uint16_t size)
15215 {
15216         uint8_t type = get_u8(data);
15217         uint8_t bus = get_u8(data + 1);
15218
15219         print_field("type 0x%2.2x - bus 0x%2.2x", type, bus);
15220 }
15221
15222 static void mgmt_ext_index_removed_evt(const void *data, uint16_t size)
15223 {
15224         uint8_t type = get_u8(data);
15225         uint8_t bus = get_u8(data + 1);
15226
15227         print_field("type 0x%2.2x - bus 0x%2.2x", type, bus);
15228 }
15229
15230 static void mgmt_local_oob_ext_data_updated_evt(const void *data, uint16_t size)
15231 {
15232         uint8_t type = get_u8(data);
15233         uint16_t data_len = get_le16(data + 1);
15234
15235         mgmt_print_address_type(type);
15236         print_field("Data length: %u", data_len);
15237         print_eir(data + 3, size - 3, true);
15238 }
15239
15240 static void mgmt_advertising_added_evt(const void *data, uint16_t size)
15241 {
15242         uint8_t instance = get_u8(data);
15243
15244         print_field("Instance: %u", instance);
15245 }
15246
15247 static void mgmt_advertising_removed_evt(const void *data, uint16_t size)
15248 {
15249         uint8_t instance = get_u8(data);
15250
15251         print_field("Instance: %u", instance);
15252 }
15253
15254 static void mgmt_ext_controller_info_changed_evt(const void *data, uint16_t size)
15255 {
15256         uint16_t data_len = get_le16(data);
15257
15258         print_field("Data length: %u", data_len);
15259         print_eir(data + 2, size - 2, false);
15260 }
15261
15262 static void mgmt_phy_changed_evt(const void *data, uint16_t size)
15263 {
15264         uint32_t selected_phys = get_le32(data);
15265
15266         mgmt_print_phys("Selected PHYs", selected_phys);
15267 }
15268
15269 static void mgmt_exp_feature_changed_evt(const void *data, uint16_t size)
15270 {
15271         mgmt_print_exp_feature(data);
15272 }
15273
15274 static void mgmt_device_flags_changed_evt(const void *data, uint16_t size)
15275 {
15276         uint8_t type = get_u8(data + 6);
15277         uint32_t supported_flags = get_le32(data + 7);
15278         uint32_t current_flags = get_le32(data + 11);
15279
15280         mgmt_print_address(data, type);
15281         mgmt_print_added_device_flags("Supported Flags", supported_flags);
15282         mgmt_print_added_device_flags("Current Flags", current_flags);
15283 }
15284
15285 static void mgmt_adv_monitor_added_evt(const void *data, uint16_t size)
15286 {
15287         uint16_t handle = get_le16(data);
15288
15289         print_field("Handle: %d", handle);
15290 }
15291
15292 static void mgmt_adv_monitor_removed_evt(const void *data, uint16_t size)
15293 {
15294         uint16_t handle = get_le16(data);
15295
15296         print_field("Handle: %d", handle);
15297 }
15298
15299 static void mgmt_controller_suspend_evt(const void *data, uint16_t size)
15300 {
15301         uint8_t state = get_u8(data);
15302         char *str;
15303
15304         switch (state) {
15305         case 0x0:
15306                 str = "Controller running (failed to suspend)";
15307                 break;
15308         case 0x1:
15309                 str = "Disconnected and not scanning";
15310                 break;
15311         case 0x2:
15312                 str = "Page scanning and/or passive scanning";
15313                 break;
15314         default:
15315                 str = "Unknown suspend state";
15316                 break;
15317         }
15318
15319         print_field("Suspend state: %s (%d)", str, state);
15320 }
15321
15322 static void mgmt_controller_resume_evt(const void *data, uint16_t size)
15323 {
15324         uint8_t addr_type = get_u8(data + 6);
15325         uint8_t wake_reason = get_u8(data + 7);
15326         char *str;
15327
15328         switch (wake_reason) {
15329         case 0x0:
15330                 str = "Resume from non-Bluetooth wake source";
15331                 break;
15332         case 0x1:
15333                 str = "Wake due to unexpected event";
15334                 break;
15335         case 0x2:
15336                 str = "Remote wake due to peer device connection";
15337                 break;
15338         default:
15339                 str = "Unknown wake reason";
15340                 break;
15341         }
15342
15343         print_field("Wake reason: %s (%d)", str, wake_reason);
15344         mgmt_print_address(data, addr_type);
15345 }
15346
15347 static void mgmt_adv_monitor_device_found_evt(const void *data, uint16_t size)
15348 {
15349         uint16_t handle = get_le16(data);
15350         const uint8_t *addr = data + 2;
15351         uint8_t addr_type = get_u8(data + 8);
15352         int8_t rssi = get_s8(data + 9);
15353         uint32_t flags = get_le32(data + 10);
15354         uint16_t ad_data_len = get_le16(data + 14);
15355         const uint8_t *ad_data = data + 16;
15356
15357         print_field("Handle: %d", handle);
15358         print_bdaddr(addr);
15359         print_field("Addr Type: %d", addr_type);
15360         print_field("RSSI: %d", rssi);
15361         mgmt_print_device_flags(flags);
15362         print_field("AD Data Len: %d", ad_data_len);
15363         size -= 16;
15364         print_hex_field("AD Data", ad_data, size);
15365 }
15366
15367 static void mgmt_adv_monitor_device_lost_evt(const void *data, uint16_t size)
15368 {
15369         uint16_t handle = get_le16(data);
15370         const uint8_t *addr = data + 2;
15371         uint8_t addr_type = get_u8(data + 8);
15372
15373         print_field("Handle: %d", handle);
15374         print_bdaddr(addr);
15375         print_field("Addr Type: %d", addr_type);
15376 }
15377
15378 static void mgmt_mesh_device_found_evt(const void *data, uint16_t size)
15379 {
15380         const uint8_t *addr = data;
15381         uint8_t addr_type = get_u8(data + 6);
15382         int8_t rssi = get_s8(data + 7);
15383         uint64_t instant = get_le64(data + 8);
15384         uint32_t flags = get_le32(data + 16);
15385         uint16_t eir_len = get_le16(data + 20);
15386         const uint8_t *eir_data = data + 22;
15387
15388         print_bdaddr(addr);
15389         print_field("Addr Type: %d", addr_type);
15390         print_field("RSSI: %d", rssi);
15391         print_field("Instant: 0x%16.16" PRIx64, instant);
15392         mgmt_print_device_flags(flags);
15393         print_field("EIR Length: %d", eir_len);
15394         size -= 22;
15395         print_hex_field("EIR Data", eir_data, size);
15396 }
15397
15398 static void mgmt_mesh_packet_cmplt_evt(const void *data, uint16_t size)
15399 {
15400         uint8_t handle = get_u8(data);
15401
15402         print_field("Handle: %d", handle);
15403 }
15404
15405 static const struct mgmt_data mgmt_event_table[] = {
15406         { 0x0001, "Command Complete",
15407                         mgmt_command_complete_evt, 3, false },
15408         { 0x0002, "Command Status",
15409                         mgmt_command_status_evt, 3, true },
15410         { 0x0003, "Controller Error",
15411                         mgmt_controller_error_evt, 1, true },
15412         { 0x0004, "Index Added",
15413                         mgmt_null_evt, 0, true },
15414         { 0x0005, "Index Removed",
15415                         mgmt_null_evt, 0, true },
15416         { 0x0006, "New Settings",
15417                         mgmt_new_settings_evt, 4, true },
15418         { 0x0007, "Class Of Device Changed",
15419                         mgmt_class_of_dev_changed_evt, 3, true },
15420         { 0x0008, "Local Name Changed",
15421                         mgmt_local_name_changed_evt, 260, true },
15422         { 0x0009, "New Link Key",
15423                         mgmt_new_link_key_evt, 26, true },
15424         { 0x000a, "New Long Term Key",
15425                         mgmt_new_long_term_key_evt, 37, true },
15426         { 0x000b, "Device Connected",
15427                         mgmt_device_connected_evt, 13, false },
15428         { 0x000c, "Device Disconnected",
15429                         mgmt_device_disconnected_evt, 8, true },
15430         { 0x000d, "Connect Failed",
15431                         mgmt_connect_failed_evt, 8, true },
15432         { 0x000e, "PIN Code Request",
15433                         mgmt_pin_code_request_evt, 8, true },
15434         { 0x000f, "User Confirmation Request",
15435                         mgmt_user_confirmation_request_evt, 12, true },
15436         { 0x0010, "User Passkey Request",
15437                         mgmt_user_passkey_request_evt, 7, true },
15438         { 0x0011, "Authentication Failed",
15439                         mgmt_authentication_failed_evt, 8, true },
15440         { 0x0012, "Device Found",
15441                         mgmt_device_found_evt, 14, false },
15442         { 0x0013, "Discovering",
15443                         mgmt_discovering_evt, 2, true },
15444         { 0x0014, "Device Blocked",
15445                         mgmt_device_blocked_evt, 7, true },
15446         { 0x0015, "Device Unblocked",
15447                         mgmt_device_unblocked_evt, 7, true },
15448         { 0x0016, "Device Unpaired",
15449                         mgmt_device_unpaired_evt, 7, true },
15450         { 0x0017, "Passkey Notify",
15451                         mgmt_passkey_notify_evt, 12, true },
15452         { 0x0018, "New Identity Resolving Key",
15453                         mgmt_new_identity_resolving_key_evt, 30, true },
15454         { 0x0019, "New Signature Resolving Key",
15455                         mgmt_new_signature_resolving_key_evt, 25, true },
15456         { 0x001a, "Device Added",
15457                         mgmt_device_added_evt, 8, true },
15458         { 0x001b, "Device Removed",
15459                         mgmt_device_removed_evt, 7, true },
15460         { 0x001c, "New Connection Parameter",
15461                         mgmt_new_connection_parameter_evt, 16, true },
15462         { 0x001d, "Unconfigured Index Added",
15463                         mgmt_null_evt, 0, true },
15464         { 0x001e, "Unconfigured Index Removed",
15465                         mgmt_null_evt, 0, true },
15466         { 0x001f, "New Configuration Options",
15467                         mgmt_new_conf_options_evt, 4, true },
15468         { 0x0020, "Extended Index Added",
15469                         mgmt_ext_index_added_evt, 2, true },
15470         { 0x0021, "Extended Index Removed",
15471                         mgmt_ext_index_removed_evt, 2, true },
15472         { 0x0022, "Local Out Of Band Extended Data Updated",
15473                         mgmt_local_oob_ext_data_updated_evt, 3, false },
15474         { 0x0023, "Advertising Added",
15475                         mgmt_advertising_added_evt, 1, true },
15476         { 0x0024, "Advertising Removed",
15477                         mgmt_advertising_removed_evt, 1, true },
15478         { 0x0025, "Extended Controller Information Changed",
15479                         mgmt_ext_controller_info_changed_evt, 2, false },
15480         { 0x0026, "PHY Configuration Changed",
15481                         mgmt_phy_changed_evt, 4, true },
15482         { 0x0027, "Experimental Feature Changed",
15483                         mgmt_exp_feature_changed_evt, 20, true },
15484         { 0x002a, "Device Flags Changed",
15485                         mgmt_device_flags_changed_evt, 15, true },
15486         { 0x002b, "Advertisement Monitor Added",
15487                         mgmt_adv_monitor_added_evt, 2, true },
15488         { 0x002c, "Advertisement Monitor Removed",
15489                         mgmt_adv_monitor_removed_evt, 2, true },
15490         { 0x002d, "Controller Suspended",
15491                         mgmt_controller_suspend_evt, 1, true },
15492         { 0x002e, "Controller Resumed",
15493                         mgmt_controller_resume_evt, 8, true },
15494         { 0x002f, "ADV Monitor Device Found",
15495                         mgmt_adv_monitor_device_found_evt, 16, false },
15496         { 0x0030, "ADV Monitor Device Lost",
15497                         mgmt_adv_monitor_device_lost_evt, 9, true },
15498         { 0x0031, "Mesh Device Found",
15499                         mgmt_mesh_device_found_evt, 22, false },
15500         { 0x0032, "Mesh Packet Complete",
15501                         mgmt_mesh_packet_cmplt_evt, 1, true },
15502         { }
15503 };
15504
15505 static void mgmt_print_commands(const void *data, uint16_t num)
15506 {
15507         int i;
15508
15509         print_field("Commands: %u", num);
15510
15511         for (i = 0; i < num; i++) {
15512                 uint16_t opcode = get_le16(data + (i * 2));
15513                 const char *str = NULL;
15514                 int n;
15515
15516                 for (n = 0; mgmt_command_table[n].str; n++) {
15517                         if (mgmt_command_table[n].opcode == opcode) {
15518                                 str = mgmt_command_table[n].str;
15519                                 break;
15520                         }
15521                 }
15522
15523                 print_field("  %s (0x%4.4x)", str ?: "Reserved", opcode);
15524         }
15525 }
15526
15527 static void mgmt_print_events(const void *data, uint16_t num)
15528 {
15529         int i;
15530
15531         print_field("Events: %u", num);
15532
15533         for (i = 0; i < num; i++) {
15534                 uint16_t opcode = get_le16(data + (i * 2));
15535                 const char *str = NULL;
15536                 int n;
15537
15538                 for (n = 0; mgmt_event_table[n].str; n++) {
15539                         if (mgmt_event_table[n].opcode == opcode) {
15540                                 str = mgmt_event_table[n].str;
15541                                 break;
15542                         }
15543                 }
15544
15545                 print_field("  %s (0x%4.4x)", str ?: "Reserved", opcode);
15546         }
15547 }
15548
15549 void packet_ctrl_command(struct timeval *tv, struct ucred *cred, uint16_t index,
15550                                         const void *data, uint16_t size)
15551 {
15552         uint32_t cookie;
15553         uint16_t format, opcode;
15554         const struct mgmt_data *mgmt_data = NULL;
15555         const char *mgmt_color, *mgmt_str;
15556         char channel[11], extra_str[25];
15557         int i;
15558
15559         if (size < 4) {
15560                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15561                                 "Malformed Control Command packet", NULL, NULL);
15562                 packet_hexdump(data, size);
15563                 return;
15564         }
15565
15566         cookie = get_le32(data);
15567
15568         data += 4;
15569         size -= 4;
15570
15571         sprintf(channel, "0x%4.4x", cookie);
15572
15573         format = get_format(cookie);
15574
15575         if (format != CTRL_MGMT) {
15576                 char label[7];
15577
15578                 sprintf(label, "0x%4.4x", format);
15579
15580                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
15581                                                 "Control Command", label, NULL);
15582                 packet_hexdump(data, size);
15583                 return;
15584         }
15585
15586         if (size < 2) {
15587                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15588                                 "Malformed MGMT Command packet", NULL, NULL);
15589                 packet_hexdump(data, size);
15590                 return;
15591         }
15592
15593         opcode = get_le16(data);
15594
15595         data += 2;
15596         size -= 2;
15597
15598         for (i = 0; mgmt_command_table[i].str; i++) {
15599                 if (mgmt_command_table[i].opcode == opcode) {
15600                         mgmt_data = &mgmt_command_table[i];
15601                         break;
15602                 }
15603         }
15604
15605         if (mgmt_data) {
15606                 if (mgmt_data->func)
15607                         mgmt_color = COLOR_CTRL_COMMAND;
15608                 else
15609                         mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
15610                 mgmt_str = mgmt_data->str;
15611         } else {
15612                 mgmt_color = COLOR_CTRL_COMMAND_UNKNOWN;
15613                 mgmt_str = "Unknown";
15614         }
15615
15616         sprintf(extra_str, "(0x%4.4x) plen %d", opcode, size);
15617
15618         print_packet(tv, cred, '@', index, channel, mgmt_color,
15619                                         "MGMT Command", mgmt_str, extra_str);
15620
15621         if (!mgmt_data || !mgmt_data->func) {
15622                 packet_hexdump(data, size);
15623                 return;
15624         }
15625
15626         if (mgmt_data->fixed) {
15627                 if (size != mgmt_data->size) {
15628                         print_text(COLOR_ERROR, "invalid packet size");
15629                         packet_hexdump(data, size);
15630                         return;
15631                 }
15632         } else {
15633                 if (size < mgmt_data->size) {
15634                         print_text(COLOR_ERROR, "too short packet");
15635                         packet_hexdump(data, size);
15636                         return;
15637                 }
15638         }
15639
15640         mgmt_data->func(data, size);
15641 }
15642
15643 void packet_ctrl_event(struct timeval *tv, struct ucred *cred, uint16_t index,
15644                                         const void *data, uint16_t size)
15645 {
15646         uint32_t cookie;
15647         uint16_t format, opcode;
15648         const struct mgmt_data *mgmt_data = NULL;
15649         const char *mgmt_color, *mgmt_str;
15650         char channel[11], extra_str[25];
15651         int i;
15652
15653         if (size < 4) {
15654                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15655                                 "Malformed Control Event packet", NULL, NULL);
15656                 packet_hexdump(data, size);
15657                 return;
15658         }
15659
15660         cookie = get_le32(data);
15661
15662         data += 4;
15663         size -= 4;
15664
15665         sprintf(channel, "0x%4.4x", cookie);
15666
15667         format = get_format(cookie);
15668
15669         if (format != CTRL_MGMT) {
15670                 char label[7];
15671
15672                 sprintf(label, "0x%4.4x", format);
15673
15674                 print_packet(tv, cred, '@', index, channel, COLOR_CTRL_CLOSE,
15675                                                 "Control Event", label, NULL);
15676                 packet_hexdump(data, size);
15677                 return;
15678         }
15679
15680         if (size < 2) {
15681                 print_packet(tv, cred, '*', index, NULL, COLOR_ERROR,
15682                                 "Malformed MGMT Event packet", NULL, NULL);
15683                 packet_hexdump(data, size);
15684                 return;
15685         }
15686
15687         opcode = get_le16(data);
15688
15689         data += 2;
15690         size -= 2;
15691
15692         for (i = 0; mgmt_event_table[i].str; i++) {
15693                 if (mgmt_event_table[i].opcode == opcode) {
15694                         mgmt_data = &mgmt_event_table[i];
15695                         break;
15696                 }
15697         }
15698
15699         if (mgmt_data) {
15700                 if (mgmt_data->func)
15701                         mgmt_color = COLOR_CTRL_EVENT;
15702                 else
15703                         mgmt_color = COLOR_CTRL_EVENT_UNKNOWN;
15704                 mgmt_str = mgmt_data->str;
15705         } else {
15706                 mgmt_color = COLOR_CTRL_EVENT_UNKNOWN;
15707                 mgmt_str = "Unknown";
15708         }
15709
15710         sprintf(extra_str, "(0x%4.4x) plen %d", opcode, size);
15711
15712         print_packet(tv, cred, '@', index, channel, mgmt_color,
15713                                         "MGMT Event", mgmt_str, extra_str);
15714
15715         if (!mgmt_data || !mgmt_data->func) {
15716                 packet_hexdump(data, size);
15717                 return;
15718         }
15719
15720         if (mgmt_data->fixed) {
15721                 if (size != mgmt_data->size) {
15722                         print_text(COLOR_ERROR, "invalid packet size");
15723                         packet_hexdump(data, size);
15724                         return;
15725                 }
15726         } else {
15727                 if (size < mgmt_data->size) {
15728                         print_text(COLOR_ERROR, "too short packet");
15729                         packet_hexdump(data, size);
15730                         return;
15731                 }
15732         }
15733
15734         mgmt_data->func(data, size);
15735 }
15736
15737 void packet_todo(void)
15738 {
15739         int i;
15740
15741         printf("HCI commands with missing decodings:\n");
15742
15743         for (i = 0; opcode_table[i].str; i++) {
15744                 if (opcode_table[i].bit < 0)
15745                         continue;
15746
15747                 if (opcode_table[i].cmd_func)
15748                         continue;
15749
15750                 printf("\t%s\n", opcode_table[i].str);
15751         }
15752
15753         printf("HCI events with missing decodings:\n");
15754
15755         for (i = 0; event_table[i].str; i++) {
15756                 if (event_table[i].func)
15757                         continue;
15758
15759                 printf("\t%s\n", event_table[i].str);
15760         }
15761
15762         for (i = 0; le_meta_event_table[i].str; i++) {
15763                 if (le_meta_event_table[i].func)
15764                         continue;
15765
15766                 printf("\t%s\n", le_meta_event_table[i].str);
15767         }
15768 }
15769
15770 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15771 void print_le_set_adv_parameters_cmd(const void *data, uint8_t size)
15772 {
15773         uint16_t dummy = 0;
15774         le_set_adv_parameters_cmd(dummy, data, size);
15775 }
15776
15777 void print_le_set_random_address_cmd(const void *data, uint8_t size)
15778 {
15779         uint16_t dummy = 0;
15780         le_set_random_address_cmd(dummy, data, size);
15781 }
15782
15783 void print_le_set_adv_data_cmd(const void *data, uint8_t size)
15784 {
15785         uint16_t dummy = 0;
15786         le_set_adv_data_cmd(dummy, data, size);
15787 }
15788
15789 void print_le_set_scan_rsp_data_cmd(const void *data, uint8_t size)
15790 {
15791         uint16_t dummy = 0;
15792         le_set_scan_rsp_data_cmd(dummy, data, size);
15793 }
15794
15795 void print_le_set_adv_enable_cmd(const void *data, uint8_t size)
15796 {
15797         uint16_t dummy = 0;
15798         le_set_adv_enable_cmd(dummy, data, size);
15799 }
15800 #endif