monitor/ll.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  *
   9  *
  10  */
  11
  12 #ifdef HAVE_CONFIG_H
  13 #include <config.h>
  14 #endif
  15
  16 #include <stdio.h>
  17 #include <inttypes.h>
  18
  19 #include "src/shared/util.h"
  20 #include "display.h"
  21 #include "packet.h"
  22 #include "crc.h"
  23 #include "bt.h"
  24 #include "ll.h"
  25
  26 #define COLOR_OPCODE            COLOR_MAGENTA
  27 #define COLOR_OPCODE_UNKNOWN    COLOR_WHITE_BG
  28 #define COLOR_UNKNOWN_OPTIONS_BIT COLOR_WHITE_BG
  29
  30 #define MAX_CHANNEL 16
  31
  32 struct channel_data {
  33         uint32_t access_addr;
  34         uint32_t crc_init;
  35 };
  36
  37 static struct channel_data channel_list[MAX_CHANNEL];
  38
  39 static void set_crc_init(uint32_t access_addr, uint32_t crc_init)
  40 {
  41         int i;
  42
  43         for (i = 0; i < MAX_CHANNEL; i++) {
  44                 if (channel_list[i].access_addr == 0x00000000 ||
  45                                 channel_list[i].access_addr == access_addr) {
  46                         channel_list[i].access_addr = access_addr;
  47                         channel_list[i].crc_init = crc_init;
  48                         break;
  49                 }
  50         }
  51 }
  52
  53 static uint32_t get_crc_init(uint32_t access_addr)
  54 {
  55         int i;
  56
  57         for (i = 0; i < MAX_CHANNEL; i++) {
  58                 if (channel_list[i].access_addr == access_addr)
  59                         return channel_list[i].crc_init;
  60         }
  61
  62         return 0x00000000;
  63 }
  64
  65 static void advertising_packet(const void *data, uint8_t size)
  66 {
  67         const uint8_t *ptr = data;
  68         uint8_t pdu_type, length, win_size, hop, sca;
  69         bool tx_add, rx_add;
  70         uint32_t access_addr, crc_init;
  71         uint16_t win_offset, interval, latency, timeout;
  72         const char *str;
  73
  74         if (size < 2) {
  75                 print_text(COLOR_ERROR, "packet too short");
  76                 packet_hexdump(data, size);
  77                 return;
  78         }
  79
  80         pdu_type = ptr[0] & 0x0f;
  81         tx_add = !!(ptr[0] & 0x40);
  82         rx_add = !!(ptr[0] & 0x80);
  83         length = ptr[1] & 0x3f;
  84
  85         switch (pdu_type) {
  86         case 0x00:
  87                 str = "ADV_IND";
  88                 break;
  89         case 0x01:
  90                 str = "ADV_DIRECT_IND";
  91                 break;
  92         case 0x02:
  93                 str = "ADV_NONCONN_IND";
  94                 break;
  95         case 0x03:
  96                 str = "SCAN_REQ";
  97                 break;
  98         case 0x04:
  99                 str = "SCAN_RSP";
 100                 break;
 101         case 0x05:
 102                 str = "CONNECT_REQ";
 103                 break;
 104         case 0x06:
 105                 str = "ADV_SCAN_IND";
 106                 break;
 107         default:
 108                 str = "Reserved";
 109                 break;
 110         }
 111
 112         print_field("Type: %s (0x%2.2x)", str, pdu_type);
 113         print_field("TxAdd: %u", tx_add);
 114         print_field("RxAdd: %u", rx_add);
 115         print_field("Length: %u", length);
 116
 117         if (length != size - 2) {
 118                 print_text(COLOR_ERROR, "packet size mismatch");
 119                 packet_hexdump(data + 2, size - 2);
 120                 return;
 121         }
 122
 123         switch (pdu_type) {
 124         case 0x00:      /* ADV_IND */
 125         case 0x02:      /* AVD_NONCONN_IND */
 126         case 0x06:      /* ADV_SCAN_IND */
 127         case 0x04:      /* SCAN_RSP */
 128                 if (length < 6) {
 129                         print_text(COLOR_ERROR, "payload too short");
 130                         packet_hexdump(data + 2, length);
 131                         return;
 132                 }
 133
 134                 packet_print_addr("Advertiser address", data + 2, tx_add);
 135                 packet_print_ad(data + 8, length - 6);
 136                 break;
 137
 138         case 0x01:      /* ADV_DIRECT_IND */
 139                 if (length < 12) {
 140                         print_text(COLOR_ERROR, "payload too short");
 141                         packet_hexdump(data + 2, length);
 142                         return;
 143                 }
 144
 145                 packet_print_addr("Advertiser address", data + 2, tx_add);
 146                 packet_print_addr("Inititator address", data + 8, rx_add);
 147                 break;
 148
 149         case 0x03:      /* SCAN_REQ */
 150                 if (length < 12) {
 151                         print_text(COLOR_ERROR, "payload too short");
 152                         packet_hexdump(data + 2, length);
 153                         return;
 154                 }
 155
 156                 packet_print_addr("Scanner address", data + 2, tx_add);
 157                 packet_print_addr("Advertiser address", data + 8, rx_add);
 158                 break;
 159
 160         case 0x05:      /* CONNECT_REQ */
 161                 if (length < 34) {
 162                         print_text(COLOR_ERROR, "payload too short");
 163                         packet_hexdump(data + 2, length);
 164                         return;
 165                 }
 166
 167                 packet_print_addr("Inititator address", data + 2, tx_add);
 168                 packet_print_addr("Advertiser address", data + 8, rx_add);
 169
 170                 access_addr = ptr[14] | ptr[15] << 8 |
 171                                         ptr[16] << 16 | ptr[17] << 24;
 172                 crc_init = ptr[18] | ptr[19] << 8 | ptr[20] << 16;
 173
 174                 print_field("Access address: 0x%8.8x", access_addr);
 175                 print_field("CRC init: 0x%6.6x", crc_init);
 176
 177                 set_crc_init(access_addr, crc24_bit_reverse(crc_init));
 178
 179                 win_size = ptr[21];
 180                 win_offset = ptr[22] | ptr[23] << 8;
 181                 interval = ptr[24] | ptr[25] << 8;
 182                 latency = ptr[26] | ptr[27] << 8;
 183                 timeout = ptr[28] | ptr[29] << 8;
 184
 185                 print_field("Transmit window size: %u", win_size);
 186                 print_field("Transmit window offset: %u", win_offset);
 187                 print_field("Connection interval: %u", interval);
 188                 print_field("Connection peripheral latency: %u", latency);
 189                 print_field("Connection supervision timeout: %u", timeout);
 190
 191                 packet_print_channel_map_ll(ptr + 30);
 192
 193                 hop = ptr[35] & 0x1f;
 194                 sca = (ptr[35] & 0xe0) >> 5;
 195
 196                 switch (sca) {
 197                 case 0:
 198                         str = "251 ppm to 500 ppm";
 199                         break;
 200                 case 1:
 201                         str = "151 ppm to 250 ppm";
 202                         break;
 203                 case 2:
 204                         str = "101 ppm to 150ppm";
 205                         break;
 206                 case 3:
 207                         str = "76 ppm to 100 ppm";
 208                         break;
 209                 case 4:
 210                         str = "51 ppm to 75 ppm";
 211                         break;
 212                 case 5:
 213                         str = "31 ppm to 50 ppm";
 214                         break;
 215                 case 6:
 216                         str = "21 ppm to 30 ppm";
 217                         break;
 218                 case 7:
 219                         str = "0 ppm to 20 ppm";
 220                         break;
 221                 default:
 222                         str = "Invalid";
 223                         break;
 224                 }
 225
 226                 print_field("Hop increment: %u", hop);
 227                 print_field("Sleep clock accuracy: %s (%u)", str, sca);
 228                 break;
 229
 230         default:
 231                 packet_hexdump(data + 2, length);
 232                 break;
 233         }
 234 }
 235
 236 static void data_packet(const void *data, uint8_t size, bool padded)
 237 {
 238         const uint8_t *ptr = data;
 239         uint8_t llid, length;
 240         bool nesn, sn, md;
 241         const char *str;
 242
 243         if (size < 2) {
 244                 print_text(COLOR_ERROR, "packet too short");
 245                 packet_hexdump(data, size);
 246                 return;
 247         }
 248
 249         llid = ptr[0] & 0x03;
 250         nesn = !!(ptr[0] & 0x04);
 251         sn = !!(ptr[0] & 0x08);
 252         md = !!(ptr[0] & 0x10);
 253         length = ptr[1] & 0x1f;
 254
 255         switch (llid) {
 256         case 0x01:
 257                 if (length > 0)
 258                         str = "Continuation fragement of L2CAP message";
 259                 else
 260                         str = "Empty message";
 261                 break;
 262         case 0x02:
 263                 str = "Start of L2CAP message";
 264                 break;
 265         case 0x03:
 266                 str = "Control";
 267                 break;
 268         default:
 269                 str = "Reserved";
 270                 break;
 271         }
 272
 273         print_field("LLID: %s (0x%2.2x)", str, llid);
 274         print_field("Next expected sequence number: %u", nesn);
 275         print_field("Sequence number: %u", sn);
 276         print_field("More data: %u", md);
 277         print_field("Length: %u", length);
 278
 279         switch (llid) {
 280         case 0x03:
 281                 llcp_packet(data + 2, size - 2, padded);
 282                 break;
 283
 284         default:
 285                 packet_hexdump(data + 2, size - 2);
 286                 break;
 287         }
 288 }
 289
 290 void ll_packet(uint16_t frequency, const void *data, uint8_t size, bool padded)
 291 {
 292         const struct bt_ll_hdr *hdr = data;
 293         uint8_t channel = (frequency - 2402) / 2;
 294         uint32_t access_addr;
 295         char access_str[12];
 296         const char *channel_label, *channel_color;
 297         const uint8_t *pdu_data;
 298         uint8_t pdu_len;
 299         uint32_t pdu_crc, crc, crc_init;
 300
 301         if (size < sizeof(*hdr)) {
 302                 print_text(COLOR_ERROR, "packet missing header");
 303                 packet_hexdump(data, size);
 304                 return;
 305         }
 306
 307         if (size < sizeof(*hdr) + 3) {
 308                 print_text(COLOR_ERROR, "packet missing checksum");
 309                 packet_hexdump(data, size);
 310                 return;
 311         }
 312
 313         if (hdr->preamble != 0xaa && hdr->preamble != 0x55) {
 314                 print_text(COLOR_ERROR, "invalid preamble");
 315                 packet_hexdump(data, size);
 316                 return;
 317         }
 318
 319         access_addr = le32_to_cpu(hdr->access_addr);
 320
 321         pdu_data = data + sizeof(*hdr);
 322         pdu_len = size - sizeof(*hdr) - 3;
 323
 324         pdu_crc = pdu_data[pdu_len + 0] | (pdu_data[pdu_len + 1] << 8) |
 325                                                 (pdu_data[pdu_len + 2] << 16);
 326
 327         if (access_addr == 0x8e89bed6) {
 328                 channel_label = "Advertising channel: ";
 329                 channel_color = COLOR_MAGENTA;
 330         } else {
 331                 channel_label = "Data channel: ";
 332                 channel_color = COLOR_CYAN;
 333         }
 334
 335         sprintf(access_str, "0x%8.8x", access_addr);
 336
 337         print_indent(6, channel_color, channel_label, access_str, COLOR_OFF,
 338                 " (channel %d) len %d crc 0x%6.6x", channel, pdu_len, pdu_crc);
 339
 340         if (access_addr == 0x8e89bed6)
 341                 crc_init = 0xaaaaaa;
 342         else
 343                 crc_init = get_crc_init(access_addr);
 344
 345         if (crc_init) {
 346                 crc = crc24_calculate(crc_init, pdu_data, pdu_len);
 347
 348                 if (crc != pdu_crc) {
 349                         print_text(COLOR_ERROR, "invalid checksum");
 350                         packet_hexdump(pdu_data, pdu_len);
 351                         return;
 352                 }
 353         } else
 354                 print_text(COLOR_ERROR, "unknown access address");
 355
 356         if (access_addr == 0x8e89bed6)
 357                 advertising_packet(pdu_data, pdu_len);
 358         else
 359                 data_packet(pdu_data, pdu_len, padded);
 360 }
 361
 362 static void null_pdu(const void *data, uint8_t size)
 363 {
 364 }
 365
 366 static void conn_update_req(const void *data, uint8_t size)
 367 {
 368         const struct bt_ll_conn_update_req *pdu = data;
 369
 370         print_field("Transmit window size: %u", pdu->win_size);
 371         print_field("Transmit window offset: %u", le16_to_cpu(pdu->win_offset));
 372         print_field("Connection interval: %u", le16_to_cpu(pdu->interval));
 373         print_field("Connection peripheral latency: %u",
 374                                                 le16_to_cpu(pdu->latency));
 375         print_field("Connection supervision timeout: %u",
 376                                                 le16_to_cpu(pdu->timeout));
 377         print_field("Connection instant: %u", le16_to_cpu(pdu->instant));
 378 }
 379
 380 static void channel_map_req(const void *data, uint8_t size)
 381 {
 382         const struct bt_ll_channel_map_req *pdu = data;
 383
 384         packet_print_channel_map_ll(pdu->map);
 385         print_field("Connection instant: %u", le16_to_cpu(pdu->instant));
 386 }
 387
 388 static void terminate_ind(const void *data, uint8_t size)
 389 {
 390         const struct bt_ll_terminate_ind *pdu = data;
 391
 392         packet_print_error("Error code", pdu->error);
 393 }
 394
 395 static void enc_req(const void *data, uint8_t size)
 396 {
 397         const struct bt_ll_enc_req *pdu = data;
 398
 399         print_field("Rand: 0x%16.16" PRIx64, le64_to_cpu(pdu->rand));
 400         print_field("EDIV: 0x%4.4x", le16_to_cpu(pdu->ediv));
 401         print_field("SKD (central): 0x%16.16" PRIx64, le64_to_cpu(pdu->skd));
 402         print_field("IV (central): 0x%8.8x", le32_to_cpu(pdu->iv));
 403 }
 404
 405 static void enc_rsp(const void *data, uint8_t size)
 406 {
 407         const struct bt_ll_enc_rsp *pdu = data;
 408
 409         print_field("SKD (peripheral): 0x%16.16" PRIx64, le64_to_cpu(pdu->skd));
 410         print_field("IV (peripheral): 0x%8.8x", le32_to_cpu(pdu->iv));
 411 }
 412
 413 static const char *opcode_to_string(uint8_t opcode);
 414
 415 static void unknown_rsp(const void *data, uint8_t size)
 416 {
 417         const struct bt_ll_unknown_rsp *pdu = data;
 418
 419         print_field("Unknown type: %s (0x%2.2x)",
 420                                 opcode_to_string(pdu->type), pdu->type);
 421 }
 422
 423 static void feature_req(const void *data, uint8_t size)
 424 {
 425         const struct bt_ll_feature_req *pdu = data;
 426
 427         packet_print_features_ll(pdu->features);
 428 }
 429
 430 static void feature_rsp(const void *data, uint8_t size)
 431 {
 432         const struct bt_ll_feature_rsp *pdu = data;
 433
 434         packet_print_features_ll(pdu->features);
 435 }
 436
 437 static void version_ind(const void *data, uint8_t size)
 438 {
 439         const struct bt_ll_version_ind *pdu = data;
 440
 441         packet_print_version("Version", pdu->version,
 442                                 "Subversion", le16_to_cpu(pdu->subversion));
 443         packet_print_company("Company", le16_to_cpu(pdu->company));
 444 }
 445
 446 static void reject_ind(const void *data, uint8_t size)
 447 {
 448         const struct bt_ll_reject_ind *pdu = data;
 449
 450         packet_print_error("Error code", pdu->error);
 451 }
 452
 453 static void peripheral_feature_req(const void *data, uint8_t size)
 454 {
 455         const struct bt_ll_peripheral_feature_req *pdu = data;
 456
 457         packet_print_features_ll(pdu->features);
 458 }
 459
 460 static void conn_param_req(const void *data, uint8_t size)
 461 {
 462         const struct bt_ll_conn_param_req *pdu = data;
 463
 464         print_field("Interval min: %.2f msec (0x%4.4x)",
 465                                 pdu->interval_min * 1.25, pdu->interval_min);
 466         print_field("Interval max: %.2f msec (0x%4.4x)",
 467                                 pdu->interval_max * 1.25, pdu->interval_max);
 468         print_field("Latency: %d (0x%4.4x)", pdu->latency, pdu->latency);
 469         print_field("Timeout: %d msec (0x%4.4x)", pdu->timeout * 10,
 470                                                                 pdu->timeout);
 471         print_field("Preffered periodicity: %.2f (0x%2.2x)",
 472                                 pdu->pref_period * 1.25, pdu->pref_period);
 473         print_field("Reference connection event count: %d (0x%2.2x)",
 474                         pdu->pref_conn_evt_count, pdu->pref_conn_evt_count);
 475         print_field("Offset 0: %.2f msec (0x%2.2x)", pdu->offset_0 * 1.25,
 476                                                                 pdu->offset_0);
 477         print_field("Offset 1: %.2f msec (0x%2.2x)", pdu->offset_1 * 1.25,
 478                                                                 pdu->offset_1);
 479         print_field("Offset 2: %.2f msec (0x%2.2x)", pdu->offset_2 * 1.25,
 480                                                                 pdu->offset_2);
 481         print_field("Offset 3: %.2f msec (0x%2.2x)", pdu->offset_3 * 1.25,
 482                                                                 pdu->offset_3);
 483         print_field("Offset 4: %.2f msec (0x%2.2x)", pdu->offset_4 * 1.25,
 484                                                                 pdu->offset_4);
 485         print_field("Offset 5: %.2f msec (0x%2.2x)", pdu->offset_5 * 1.25,
 486                                                                 pdu->offset_5);
 487 }
 488
 489 static void conn_param_rsp(const void *data, uint8_t size)
 490 {
 491         const struct bt_ll_conn_param_rsp *pdu = data;
 492
 493         print_field("Interval min: %.2f msec (0x%4.4x)",
 494                                 pdu->interval_min * 1.25, pdu->interval_min);
 495         print_field("Interval max: %.2f msec (0x%4.4x)",
 496                                 pdu->interval_max * 1.25, pdu->interval_max);
 497         print_field("Latency: %d (0x%4.4x)", pdu->latency, pdu->latency);
 498         print_field("Timeout: %d msec (0x%4.4x)", pdu->timeout * 10,
 499                                                                 pdu->timeout);
 500         print_field("Preffered periodicity: %.2f (0x%2.2x)",
 501                                 pdu->pref_period * 1.25, pdu->pref_period);
 502         print_field("Reference connection event count: %d (0x%2.2x)",
 503                         pdu->pref_conn_evt_count, pdu->pref_conn_evt_count);
 504         print_field("Offset 0: %.2f msec (0x%2.2x)", pdu->offset_0 * 1.25,
 505                                                                 pdu->offset_0);
 506         print_field("Offset 1: %.2f msec (0x%2.2x)", pdu->offset_1 * 1.25,
 507                                                                 pdu->offset_1);
 508         print_field("Offset 2: %.2f msec (0x%2.2x)", pdu->offset_2 * 1.25,
 509                                                                 pdu->offset_2);
 510         print_field("Offset 3: %.2f msec (0x%2.2x)", pdu->offset_3 * 1.25,
 511                                                                 pdu->offset_3);
 512         print_field("Offset 4: %.2f msec (0x%2.2x)", pdu->offset_4 * 1.25,
 513                                                                 pdu->offset_4);
 514         print_field("Offset 5: %.2f msec (0x%2.2x)", pdu->offset_5 * 1.25,
 515                                                                 pdu->offset_5);
 516 }
 517
 518 static void reject_ind_ext(const void *data, uint8_t size)
 519 {
 520         const struct bt_ll_reject_ind_ext *pdu = data;
 521
 522         print_field("Reject opcode: %u (0x%2.2x)", pdu->opcode, pdu->opcode);
 523         packet_print_error("Error code", pdu->error);
 524 }
 525
 526 static void length_req_rsp(const void *data, uint8_t size)
 527 {
 528         const struct bt_ll_length *pdu = data;
 529
 530         print_field("MaxRxOctets: %u", pdu->rx_len);
 531         print_field("MaxRxTime: %u", pdu->rx_time);
 532         print_field("MaxTxOctets: %u", pdu->tx_len);
 533         print_field("MaxtxTime: %u", pdu->tx_time);
 534 }
 535
 536 static const struct bitfield_data le_phys[] = {
 537         {  0, "LE 1M"   },
 538         {  1, "LE 2M"   },
 539         {  2, "LE Coded"},
 540         { }
 541 };
 542
 543 static void phy_req_rsp(const void *data, uint8_t size)
 544 {
 545         const struct bt_ll_phy *pdu = data;
 546         uint8_t mask;
 547
 548         print_field("RX PHYs: 0x%2.2x", pdu->rx_phys);
 549
 550         mask = print_bitfield(2, pdu->rx_phys, le_phys);
 551         if (mask)
 552                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
 553                                                         " (0x%2.2x)", mask);
 554         print_field("TX PHYs: 0x%2.2x", pdu->tx_phys);
 555
 556         mask = print_bitfield(2, pdu->tx_phys, le_phys);
 557         if (mask)
 558                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
 559                                                         " (0x%2.2x)", mask);
 560 }
 561
 562 static void phy_update_ind(const void *data, uint8_t size)
 563 {
 564         const struct bt_ll_phy_update_ind *pdu = data;
 565         uint8_t mask;
 566
 567         print_field("C_TO_P_PHY: 0x%2.2x", pdu->c_phy);
 568
 569         mask = print_bitfield(2, pdu->c_phy, le_phys);
 570         if (mask)
 571                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
 572                                                         " (0x%2.2x)", mask);
 573
 574         print_field("P_TO_C_PHY: 0x%2.2x", pdu->p_phy);
 575
 576         mask = print_bitfield(2, pdu->p_phy, le_phys);
 577         if (mask)
 578                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
 579                                                         " (0x%2.2x)", mask);
 580
 581         print_field("Instant: 0x%4.4x", pdu->instant);
 582 }
 583
 584 static void min_used_channels(const void *data, uint8_t size)
 585 {
 586         const struct bt_ll_min_used_channels *pdu = data;
 587         uint8_t mask;
 588
 589         print_field("PHYS: 0x%2.2x", pdu->phys);
 590
 591         mask = print_bitfield(2, pdu->phys, le_phys);
 592         if (mask)
 593                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
 594                                                         " (0x%2.2x)", mask);
 595
 596         print_field("MinUsedChannels: 0x%2.2x", pdu->min_channels);
 597 }
 598
 599 static void cte_req(const void *data, uint8_t size)
 600 {
 601         const struct bt_ll_cte_req *pdu = data;
 602
 603         print_field("MinCTELenReq: 0x%2.2x", pdu->cte & 0xf8);
 604         print_field("CTETypeReq: 0x%2.2x", pdu->cte & 0x03);
 605
 606         switch (pdu->cte & 0x03) {
 607         case 0x00:
 608                 print_field("  AoA Constant Tone Extension");
 609                 break;
 610         case 0x01:
 611                 print_field("  AoD Constant Tone Extension with 1 μs slots");
 612                 break;
 613         case 0x02:
 614                 print_field("  AoD Constant Tone Extension with 2 μs slots");
 615                 break;
 616         }
 617 }
 618
 619 static void periodic_sync_ind(const void *data, uint8_t size)
 620 {
 621         const struct bt_ll_periodic_sync_ind *pdu = data;
 622         uint8_t mask;
 623
 624         print_field("ID: 0x%4.4x", pdu->id);
 625         print_field("SyncInfo:");
 626         packet_hexdump(pdu->info, sizeof(pdu->info));
 627         print_field("connEventCount: 0x%4.4x", pdu->event_count);
 628         print_field("lastPaEventCounter: 0x%4.4x", pdu->last_counter);
 629         print_field("SID: 0x%2.2x", pdu->adv_info & 0xf0);
 630         print_field("AType: %s", pdu->adv_info & 0x08 ? "random" : "public");
 631         print_field("SCA: 0x%2.2x", pdu->adv_info & 0x07);
 632         print_field("PHY: 0x%2.2x", pdu->phy);
 633
 634         mask = print_bitfield(2, pdu->phy, le_phys);
 635         if (mask)
 636                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
 637                                                         " (0x%2.2x)", mask);
 638
 639         packet_print_addr("AdvA", pdu->adv_addr, pdu->adv_info & 0x08);
 640         print_field("syncConnEventCount: 0x%4.4x", pdu->sync_counter);
 641 }
 642
 643 static void clock_acc_req_rsp(const void *data, uint8_t size)
 644 {
 645         const struct bt_ll_clock_acc *pdu = data;
 646
 647         print_field("SCA: 0x%2.2x", pdu->sca);
 648 }
 649
 650 static void cis_req(const void *data, uint8_t size)
 651 {
 652         const struct bt_ll_cis_req *cmd = data;
 653         uint32_t interval;
 654         uint8_t mask;
 655
 656         print_field("CIG ID: 0x%2.2x", cmd->cig);
 657         print_field("CIS ID: 0x%2.2x", cmd->cis);
 658         print_field("Central to Peripheral PHY: 0x%2.2x", cmd->c_phy);
 659
 660         mask = print_bitfield(2, cmd->c_phy, le_phys);
 661         if (mask)
 662                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
 663                                                         " (0x%2.2x)", mask);
 664
 665         print_field("Peripheral To Central PHY: 0x%2.2x", cmd->p_phy);
 666
 667         mask = print_bitfield(2, cmd->p_phy, le_phys);
 668         if (mask)
 669                 print_text(COLOR_UNKNOWN_OPTIONS_BIT, "  Reserved"
 670                                                         " (0x%2.2x)", mask);
 671
 672         print_field("Central to Peripheral Maximum SDU: %u", cmd->c_sdu);
 673         print_field("Peripheral to Central Maximum SDU: %u", cmd->p_sdu);
 674
 675         memcpy(&interval, cmd->c_interval, sizeof(cmd->c_interval));
 676         print_field("Central to Peripheral Interval: 0x%6.6x",
 677                                                         le32_to_cpu(interval));
 678         memcpy(&interval, cmd->p_interval, sizeof(cmd->p_interval));
 679         print_field("Peripheral to Central Interval: 0x%6.6x",
 680                                                         le32_to_cpu(interval));
 681
 682         print_field("Central to Peripheral Maximum PDU: %u", cmd->c_pdu);
 683         print_field("Peripheral to Central Maximum PDU: %u", cmd->p_pdu);
 684
 685         print_field("Burst Number: %u us", cmd->bn);
 686
 687         memcpy(&interval, cmd->sub_interval, sizeof(cmd->sub_interval));
 688         print_field("Sub-Interval: 0x%6.6x", le32_to_cpu(interval));
 689
 690         print_field("Central to Peripheral Flush Timeout: %u", cmd->c_ft);
 691         print_field("Peripheral to Central Flush Timeout: %u", cmd->p_ft);
 692
 693         print_field("ISO Interval: 0x%4.4x", le16_to_cpu(cmd->iso_interval));
 694
 695         memcpy(&interval, cmd->offset_min, sizeof(cmd->offset_min));
 696         print_field("CIS Offset Minimum: 0x%6.6x", le32_to_cpu(interval));
 697         memcpy(&interval, cmd->offset_max, sizeof(cmd->offset_max));
 698         print_field("CIS Offset Maximum: 0x%6.6x", le32_to_cpu(interval));
 699
 700         print_field("Connection Event Count: %u", cmd->conn_event_count);
 701 }
 702
 703 static void cis_rsp(const void *data, uint8_t size)
 704 {
 705         const struct bt_ll_cis_rsp *rsp = data;
 706         uint32_t interval;
 707
 708         memcpy(&interval, rsp->offset_min, sizeof(rsp->offset_min));
 709         print_field("CIS Offset Minimum: 0x%6.6x", le32_to_cpu(interval));
 710         memcpy(&interval, rsp->offset_max, sizeof(rsp->offset_max));
 711         print_field("CIS Offset Maximum: 0x%6.6x", le32_to_cpu(interval));
 712
 713         print_field("Connection Event Count: %u", rsp->conn_event_count);
 714 }
 715
 716 static void cis_ind(const void *data, uint8_t size)
 717 {
 718         const struct bt_ll_cis_ind *ind = data;
 719         uint32_t interval;
 720
 721         print_field("CIS Access Address: 0x%4.4x", le32_to_cpu(ind->addr));
 722         memcpy(&interval, ind->cis_offset, sizeof(ind->cis_offset));
 723         print_field("CIS Offset: 0x%6.6x", le32_to_cpu(interval));
 724
 725         memcpy(&interval, ind->cig_sync_delay, sizeof(ind->cig_sync_delay));
 726         print_field("CIG Synchronization Delay: 0x%6.6x",
 727                                         le32_to_cpu(interval));
 728         memcpy(&interval, ind->cis_sync_delay, sizeof(ind->cis_sync_delay));
 729         print_field("CIS Synchronization Delay: %u us",
 730                                         le32_to_cpu(interval));
 731         print_field("Connection Event Count: %u", ind->conn_event_count);
 732 }
 733
 734 static void cis_term_ind(const void *data, uint8_t size)
 735 {
 736         const struct bt_ll_cis_term_ind *ind = data;
 737
 738         print_field("CIG ID: 0x%2.2x", ind->cig);
 739         print_field("CIS ID: 0x%2.2x", ind->cis);
 740         packet_print_error("Reason", ind->reason);
 741 }
 742
 743 struct llcp_data {
 744         uint8_t opcode;
 745         const char *str;
 746         void (*func) (const void *data, uint8_t size);
 747         uint8_t size;
 748         bool fixed;
 749 };
 750
 751 static const struct llcp_data llcp_table[] = {
 752         { 0x00, "LL_CONNECTION_UPDATE_REQ", conn_update_req,   11, true },
 753         { 0x01, "LL_CHANNEL_MAP_REQ",       channel_map_req,    7, true },
 754         { 0x02, "LL_TERMINATE_IND",         terminate_ind,      1, true },
 755         { 0x03, "LL_ENC_REQ",               enc_req,           22, true },
 756         { 0x04, "LL_ENC_RSP",               enc_rsp,           12, true },
 757         { 0x05, "LL_START_ENC_REQ",         null_pdu,           0, true },
 758         { 0x06, "LL_START_ENC_RSP",         null_pdu,           0, true },
 759         { 0x07, "LL_UNKNOWN_RSP",           unknown_rsp,        1, true },
 760         { 0x08, "LL_FEATURE_REQ",           feature_req,        8, true },
 761         { 0x09, "LL_FEATURE_RSP",           feature_rsp,        8, true },
 762         { 0x0a, "LL_PAUSE_ENC_REQ",         null_pdu,           0, true },
 763         { 0x0b, "LL_PAUSE_ENC_RSP",         null_pdu,           0, true },
 764         { 0x0c, "LL_VERSION_IND",           version_ind,        5, true },
 765         { 0x0d, "LL_REJECT_IND",            reject_ind,         1, true },
 766         { 0x0e, "LL_PERIPHERAL_FEATURE_REQ", peripheral_feature_req, 8, true },
 767         { 0x0f, "LL_CONNECTION_PARAM_REQ",  conn_param_req,    23, true },
 768         { 0x10, "LL_CONNECTION_PARAM_RSP",  conn_param_rsp,    23, true },
 769         { 0x11, "LL_REJECT_IND_EXT",        reject_ind_ext,     2, true },
 770         { 0x12, "LL_PING_REQ",              null_pdu,           0, true },
 771         { 0x13, "LL_PING_RSP",              null_pdu,           0, true },
 772         { 0x14, "LL_LENGTH_REQ",            length_req_rsp,     8, true },
 773         { 0x15, "LL_LENGTH_RSP",            length_req_rsp,     8, true },
 774         { 0x16, "LL_PHY_REQ",               phy_req_rsp,        2, true },
 775         { 0x17, "LL_PHY_RSP",               phy_req_rsp,        2, true },
 776         { 0x18, "LL_PHY_UPDATE_IND",        phy_update_ind,     4, true },
 777         { 0x19, "LL_MIN_USED_CHANNELS_IND", min_used_channels,  2, true },
 778         { 0x1a, "LL_CTE_REQ",               cte_req,            1, true },
 779         { 0x1b, "LL_CTE_RSP",               null_pdu,           0, true },
 780         { 0x1c, "LL_PERIODIC_SYNC_IND",     periodic_sync_ind, 34, true },
 781         { 0x1d, "LL_CLOCK_ACCURACY_REQ",    clock_acc_req_rsp,  1, true },
 782         { 0x1e, "LL_CLOCK_ACCURACY_RSP",    clock_acc_req_rsp,  1, true },
 783         { BT_LL_CIS_REQ, "LL_CIS_REQ",      cis_req,
 784                                         sizeof(struct bt_ll_cis_req), true },
 785         { BT_LL_CIS_RSP, "LL_CIS_RSP",      cis_rsp,
 786                                         sizeof(struct bt_ll_cis_rsp), true },
 787         { BT_LL_CIS_IND, "LL_CIS_IND",      cis_ind,
 788                                         sizeof(struct bt_ll_cis_ind), true },
 789         { BT_LL_CIS_TERMINATE_IND, "LL_CIS_TERMINATE_IND", cis_term_ind,
 790                                         sizeof(struct bt_ll_cis_term_ind),
 791                                         true },
 792         { }
 793 };
 794
 795 static const char *opcode_to_string(uint8_t opcode)
 796 {
 797         int i;
 798
 799         for (i = 0; llcp_table[i].str; i++) {
 800                 if (llcp_table[i].opcode == opcode)
 801                         return llcp_table[i].str;
 802         }
 803
 804         return "Unknown";
 805 }
 806
 807 void llcp_packet(const void *data, uint8_t size, bool padded)
 808 {
 809         uint8_t opcode = ((const uint8_t *) data)[0];
 810         const struct llcp_data *llcp_data = NULL;
 811         const char *opcode_color, *opcode_str;
 812         int i;
 813
 814         for (i = 0; llcp_table[i].str; i++) {
 815                 if (llcp_table[i].opcode == opcode) {
 816                         llcp_data = &llcp_table[i];
 817                         break;
 818                 }
 819         }
 820
 821         if (llcp_data) {
 822                 if (llcp_data->func)
 823                         opcode_color = COLOR_OPCODE;
 824                 else
 825                         opcode_color = COLOR_OPCODE_UNKNOWN;
 826                 opcode_str = llcp_data->str;
 827         } else {
 828                 opcode_color = COLOR_OPCODE_UNKNOWN;
 829                 opcode_str = "Unknown";
 830         }
 831
 832         print_indent(6, opcode_color, "", opcode_str, COLOR_OFF,
 833                                                 " (0x%2.2x)", opcode);
 834
 835         if (!llcp_data || !llcp_data->func) {
 836                 packet_hexdump(data + 1, size - 1);
 837                 return;
 838         }
 839
 840         if (llcp_data->fixed && !padded) {
 841                 if (size - 1 != llcp_data->size) {
 842                         print_text(COLOR_ERROR, "invalid packet size");
 843                         packet_hexdump(data + 1, size - 1);
 844                         return;
 845                 }
 846         } else {
 847                 if (size - 1 < llcp_data->size) {
 848                         print_text(COLOR_ERROR, "too short packet");
 849                         packet_hexdump(data + 1, size - 1);
 850                         return;
 851                 }
 852         }
 853
 854         llcp_data->func(data + 1, size - 1);
 855 }