monitor/intel.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 "lib/bluetooth.h"
  20 #include "lib/hci.h"
  21
  22 #include "src/shared/util.h"
  23 #include "display.h"
  24 #include "packet.h"
  25 #include "lmp.h"
  26 #include "ll.h"
  27 #include "vendor.h"
  28 #include "intel.h"
  29
  30 #define COLOR_UNKNOWN_EVENT_MASK        COLOR_WHITE_BG
  31 #define COLOR_UNKNOWN_SCAN_STATUS       COLOR_WHITE_BG
  32 #define COLOR_UNKNOWN_EXT_EVENT         COLOR_WHITE_BG
  33
  34 static void print_status(uint8_t status)
  35 {
  36         packet_print_error("Status", status);
  37 }
  38
  39 static void print_module(uint8_t module)
  40 {
  41         const char *str;
  42
  43         switch (module) {
  44         case 0x01:
  45                 str = "BC";
  46                 break;
  47         case 0x02:
  48                 str = "HCI";
  49                 break;
  50         case 0x03:
  51                 str = "LLC";
  52                 break;
  53         case 0x04:
  54                 str = "OS";
  55                 break;
  56         case 0x05:
  57                 str = "LM";
  58                 break;
  59         case 0x06:
  60                 str = "SC";
  61                 break;
  62         case 0x07:
  63                 str = "SP";
  64                 break;
  65         case 0x08:
  66                 str = "OSAL";
  67                 break;
  68         case 0x09:
  69                 str = "LC";
  70                 break;
  71         case 0x0a:
  72                 str = "APP";
  73                 break;
  74         case 0x0b:
  75                 str = "TLD";
  76                 break;
  77         case 0xf0:
  78                 str = "Debug";
  79                 break;
  80         default:
  81                 str = "Reserved";
  82                 break;
  83         }
  84
  85         print_field("Module: %s (0x%2.2x)", str, module);
  86 }
  87
  88 static void null_cmd(const void *data, uint8_t size)
  89 {
  90 }
  91
  92 static void status_rsp(const void *data, uint8_t size)
  93 {
  94         uint8_t status = get_u8(data);
  95
  96         print_status(status);
  97 }
  98
  99 static void reset_cmd(const void *data, uint8_t size)
 100 {
 101         uint8_t reset_type = get_u8(data);
 102         uint8_t patch_enable = get_u8(data + 1);
 103         uint8_t ddc_reload = get_u8(data + 2);
 104         uint8_t boot_option = get_u8(data + 3);
 105         uint32_t boot_addr = get_le32(data + 4);
 106         const char *str;
 107
 108         switch (reset_type) {
 109         case 0x00:
 110                 str = "Soft software reset";
 111                 break;
 112         case 0x01:
 113                 str = "Hard software reset";
 114                 break;
 115         default:
 116                 str = "Reserved";
 117                 break;
 118         }
 119
 120         print_field("Reset type: %s (0x%2.2x)", str, reset_type);
 121
 122         switch (patch_enable) {
 123         case 0x00:
 124                 str = "Do not enable";
 125                 break;
 126         case 0x01:
 127                 str = "Enable";
 128                 break;
 129         default:
 130                 str = "Reserved";
 131                 break;
 132         }
 133
 134         print_field("Patch vectors: %s (0x%2.2x)", str, patch_enable);
 135
 136         switch (ddc_reload) {
 137         case 0x00:
 138                 str = "Do not reload";
 139                 break;
 140         case 0x01:
 141                 str = "Reload from OTP";
 142                 break;
 143         default:
 144                 str = "Reserved";
 145                 break;
 146         }
 147
 148         print_field("DDC parameters: %s (0x%2.2x)", str, ddc_reload);
 149
 150         switch (boot_option) {
 151         case 0x00:
 152                 str = "Current image";
 153                 break;
 154         case 0x01:
 155                 str = "Specified address";
 156                 break;
 157         default:
 158                 str = "Reserved";
 159                 break;
 160         }
 161
 162         print_field("Boot option: %s (0x%2.2x)", str, boot_option);
 163         print_field("Boot address: 0x%8.8x", boot_addr);
 164 }
 165
 166 static void read_version_rsp(const void *data, uint8_t size)
 167 {
 168         uint8_t status = get_u8(data);
 169         uint8_t hw_platform = get_u8(data + 1);
 170         uint8_t hw_variant = get_u8(data + 2);
 171         uint8_t hw_revision = get_u8(data + 3);
 172         uint8_t fw_variant = get_u8(data + 4);
 173         uint8_t fw_revision = get_u8(data + 5);
 174         uint8_t fw_build_nn = get_u8(data + 6);
 175         uint8_t fw_build_cw = get_u8(data + 7);
 176         uint8_t fw_build_yy = get_u8(data + 8);
 177         uint8_t fw_patch = get_u8(data + 9);
 178
 179         print_status(status);
 180         print_field("Hardware platform: 0x%2.2x", hw_platform);
 181         print_field("Hardware variant: 0x%2.2x", hw_variant);
 182         print_field("Hardware revision: %u.%u", hw_revision >> 4,
 183                                                 hw_revision & 0x0f);
 184         print_field("Firmware variant: 0x%2.2x", fw_variant);
 185         print_field("Firmware revision: %u.%u", fw_revision >> 4,
 186                                                 fw_revision & 0x0f);
 187
 188         print_field("Firmware build: %u-%u.%u", fw_build_nn,
 189                                         fw_build_cw, 2000 + fw_build_yy);
 190         print_field("Firmware patch: %u", fw_patch);
 191 }
 192
 193 static void set_uart_baudrate_cmd(const void *data, uint8_t size)
 194 {
 195         uint8_t baudrate = get_u8(data);
 196         const char *str;
 197
 198         switch (baudrate) {
 199         case 0x00:
 200                 str = "9600 Baud";
 201                 break;
 202         case 0x01:
 203                 str = "19200 Baud";
 204                 break;
 205         case 0x02:
 206                 str = "38400 Baud";
 207                 break;
 208         case 0x03:
 209                 str = "57600 Baud";
 210                 break;
 211         case 0x04:
 212                 str = "115200 Baud";
 213                 break;
 214         case 0x05:
 215                 str = "230400 Baud";
 216                 break;
 217         case 0x06:
 218                 str = "460800 Baud";
 219                 break;
 220         case 0x07:
 221                 str = "921600 Baud";
 222                 break;
 223         case 0x08:
 224                 str = "1843200 Baud";
 225                 break;
 226         case 0x09:
 227                 str = "3250000 baud";
 228                 break;
 229         case 0x0a:
 230                 str = "2000000 baud";
 231                 break;
 232         case 0x0b:
 233                 str = "3000000 baud";
 234                 break;
 235         case 0x0c:
 236                 str = "3714286 baud";
 237                 break;
 238         case 0x0d:
 239                 str = "4333333 baud";
 240                 break;
 241         case 0x0e:
 242                 str = "6500000 baud";
 243                 break;
 244         default:
 245                 str = "Reserved";
 246                 break;
 247         }
 248
 249         print_field("Baudrate: %s (0x%2.2x)", str, baudrate);
 250 }
 251
 252 static void secure_send_cmd(const void *data, uint8_t size)
 253 {
 254         uint8_t type = get_u8(data);
 255         const char *str;
 256
 257         switch (type) {
 258         case 0x00:
 259                 str = "Init";
 260                 break;
 261         case 0x01:
 262                 str = "Data";
 263                 break;
 264         case 0x02:
 265                 str = "Sign";
 266                 break;
 267         case 0x03:
 268                 str = "PKey";
 269                 break;
 270         default:
 271                 str = "Reserved";
 272                 break;
 273         }
 274
 275         print_field("Type: %s fragment (0x%2.2x)", str, type);
 276
 277         packet_hexdump(data + 1, size - 1);
 278 }
 279
 280 static void manufacturer_mode_cmd(const void *data, uint8_t size)
 281 {
 282         uint8_t mode = get_u8(data);
 283         uint8_t reset = get_u8(data + 1);
 284         const char *str;
 285
 286         switch (mode) {
 287         case 0x00:
 288                 str = "Disabled";
 289                 break;
 290         case 0x01:
 291                 str = "Enabled";
 292                 break;
 293         default:
 294                 str = "Reserved";
 295                 break;
 296         }
 297
 298         print_field("Mode switch: %s (0x%2.2x)", str, mode);
 299
 300         switch (reset) {
 301         case 0x00:
 302                 str = "No reset";
 303                 break;
 304         case 0x01:
 305                 str = "Reset and deactivate patches";
 306                 break;
 307         case 0x02:
 308                 str = "Reset and activate patches";
 309                 break;
 310         default:
 311                 str = "Reserved";
 312                 break;
 313         }
 314
 315         print_field("Reset behavior: %s (0x%2.2x)", str, reset);
 316 }
 317
 318 static void write_bd_data_cmd(const void *data, uint8_t size)
 319 {
 320         uint8_t features[8];
 321
 322         packet_print_addr("Address", data, false);
 323         packet_hexdump(data + 6, 6);
 324
 325         memcpy(features, data + 12, 8);
 326         packet_print_features_lmp(features, 0);
 327
 328         memcpy(features, data + 20, 1);
 329         memset(features + 1, 0, 7);
 330         packet_print_features_ll(features);
 331
 332         packet_hexdump(data + 21, size - 21);
 333 }
 334
 335 static void read_bd_data_rsp(const void *data, uint8_t size)
 336 {
 337         uint8_t status = get_u8(data);
 338
 339         print_status(status);
 340         packet_print_addr("Address", data + 1, false);
 341         packet_hexdump(data + 7, size - 7);
 342 }
 343
 344 static void write_bd_address_cmd(const void *data, uint8_t size)
 345 {
 346         packet_print_addr("Address", data, false);
 347 }
 348
 349 static void act_deact_traces_cmd(const void *data, uint8_t size)
 350 {
 351         uint8_t tx = get_u8(data);
 352         uint8_t tx_arq = get_u8(data + 1);
 353         uint8_t rx = get_u8(data + 2);
 354
 355         print_field("Transmit traces: 0x%2.2x", tx);
 356         print_field("Transmit ARQ: 0x%2.2x", tx_arq);
 357         print_field("Receive traces: 0x%2.2x", rx);
 358 }
 359
 360 static void stimulate_exception_cmd(const void *data, uint8_t size)
 361 {
 362         uint8_t type = get_u8(data);
 363         const char *str;
 364
 365         switch (type) {
 366         case 0x00:
 367                 str = "Fatal Exception";
 368                 break;
 369         case 0x01:
 370                 str = "Debug Exception";
 371                 break;
 372         default:
 373                 str = "Reserved";
 374                 break;
 375         }
 376
 377         print_field("Type: %s (0x%2.2x)", str, type);
 378 }
 379
 380 static const struct {
 381         uint8_t bit;
 382         const char *str;
 383 } events_table[] = {
 384         {  0, "Bootup"                  },
 385         {  1, "SCO Rejected via LMP"    },
 386         {  2, "PTT Switch Notification" },
 387         {  7, "Scan Status"             },
 388         {  9, "Debug Exception"         },
 389         { 10, "Fatal Exception"         },
 390         { 11, "System Exception"        },
 391         { 13, "LE Link Established"     },
 392         { 14, "FW Trace String"         },
 393         { }
 394 };
 395
 396 static void set_event_mask_cmd(const void *data, uint8_t size)
 397 {
 398         const uint8_t *events_array = data;
 399         uint64_t mask, events = 0;
 400         int i;
 401
 402         for (i = 0; i < 8; i++)
 403                 events |= ((uint64_t) events_array[i]) << (i * 8);
 404
 405         print_field("Mask: 0x%16.16" PRIx64, events);
 406
 407         mask = events;
 408
 409         for (i = 0; events_table[i].str; i++) {
 410                 if (events & (((uint64_t) 1) << events_table[i].bit)) {
 411                         print_field("  %s", events_table[i].str);
 412                         mask &= ~(((uint64_t) 1) << events_table[i].bit);
 413                 }
 414         }
 415
 416         if (mask)
 417                 print_text(COLOR_UNKNOWN_EVENT_MASK, "  Unknown mask "
 418                                                 "(0x%16.16" PRIx64 ")", mask);
 419 }
 420
 421 static void ddc_config_write_cmd(const void *data, uint8_t size)
 422 {
 423         while (size > 0) {
 424                 uint8_t param_len = get_u8(data);
 425                 uint16_t param_id = get_le16(data + 1);
 426
 427                 print_field("Identifier: 0x%4.4x", param_id);
 428                 packet_hexdump(data + 3, param_len - 2);
 429
 430                 data += param_len + 1;
 431                 size -= param_len + 1;
 432         }
 433 }
 434
 435 static void ddc_config_write_rsp(const void *data, uint8_t size)
 436 {
 437         uint8_t status = get_u8(data);
 438         uint16_t param_id = get_le16(data + 1);
 439
 440         print_status(status);
 441         print_field("Identifier: 0x%4.4x", param_id);
 442 }
 443
 444 static void memory_write_cmd(const void *data, uint8_t size)
 445 {
 446         uint32_t addr = get_le32(data);
 447         uint8_t mode = get_u8(data + 4);
 448         uint8_t length = get_u8(data + 5);
 449         const char *str;
 450
 451         print_field("Address: 0x%8.8x", addr);
 452
 453         switch (mode) {
 454         case 0x00:
 455                 str = "Byte access";
 456                 break;
 457         case 0x01:
 458                 str = "Half word access";
 459                 break;
 460         case 0x02:
 461                 str = "Word access";
 462                 break;
 463         default:
 464                 str = "Reserved";
 465                 break;
 466         }
 467
 468         print_field("Mode: %s (0x%2.2x)", str, mode);
 469         print_field("Length: %u", length);
 470
 471         packet_hexdump(data + 6, size - 6);
 472 }
 473
 474 static void read_supported_features_cmd(const void *data, uint8_t size)
 475 {
 476         uint8_t page = get_u8(data);
 477
 478         print_field("Page: 0x%2.2x", page);
 479 }
 480
 481 static void read_supported_features_rsp(const void *data, uint8_t size)
 482 {
 483         uint8_t status = get_u8(data);
 484         uint8_t page = get_u8(data + 1);
 485         uint8_t max_pages = get_u8(data + 2);
 486
 487         print_status(status);
 488         print_field("Page: 0x%2.2x", page);
 489         print_field("Max Pages: 0x%2.2x", max_pages);
 490         print_field("Supported Features:");
 491         packet_hexdump(data + 3, size - 3);
 492 }
 493
 494 static const struct vendor_ocf vendor_ocf_table[] = {
 495         { 0x001, "Reset",
 496                         reset_cmd, 8, true,
 497                         status_rsp, 1, true },
 498         { 0x002, "No Operation" },
 499         { 0x005, "Read Version",
 500                         null_cmd, 0, true,
 501                         read_version_rsp, 10, true },
 502         { 0x006, "Set UART Baudrate",
 503                         set_uart_baudrate_cmd, 1, true,
 504                         status_rsp, 1, true },
 505         { 0x007, "Enable LPM" },
 506         { 0x008, "PCM Write Configuration" },
 507         { 0x009, "Secure Send",
 508                         secure_send_cmd, 1, false,
 509                         status_rsp, 1, true },
 510         { 0x00d, "Read Secure Boot Params",
 511                         null_cmd, 0, true },
 512         { 0x00e, "Write Secure Boot Params" },
 513         { 0x00f, "Unlock" },
 514         { 0x010, "Change UART Baudrate" },
 515         { 0x011, "Manufacturer Mode",
 516                         manufacturer_mode_cmd, 2, true,
 517                         status_rsp, 1, true },
 518         { 0x012, "Read Link RSSI" },
 519         { 0x022, "Get Exception Info" },
 520         { 0x024, "Clear Exception Info" },
 521         { 0x02f, "Write BD Data",
 522                         write_bd_data_cmd, 6, false },
 523         { 0x030, "Read BD Data",
 524                         null_cmd, 0, true,
 525                         read_bd_data_rsp, 7, false },
 526         { 0x031, "Write BD Address",
 527                         write_bd_address_cmd, 6, true,
 528                         status_rsp, 1, true },
 529         { 0x032, "Flow Specification" },
 530         { 0x034, "Read Secure ID" },
 531         { 0x038, "Set Synchronous USB Interface Type" },
 532         { 0x039, "Config Synchronous Interface" },
 533         { 0x03f, "SW RF Kill",
 534                         null_cmd, 0, true,
 535                         status_rsp, 1, true },
 536         { 0x043, "Activate Deactivate Traces",
 537                         act_deact_traces_cmd, 3, true },
 538         { 0x04d, "Stimulate Exception",
 539                         stimulate_exception_cmd, 1, true,
 540                         status_rsp, 1, true },
 541         { 0x050, "Read HW Version" },
 542         { 0x052, "Set Event Mask",
 543                         set_event_mask_cmd, 8, true,
 544                         status_rsp, 1, true },
 545         { 0x053, "Config_Link_Controller" },
 546         { 0x089, "DDC Write" },
 547         { 0x08a, "DDC Read" },
 548         { 0x08b, "DDC Config Write",
 549                         ddc_config_write_cmd, 3, false,
 550                         ddc_config_write_rsp, 3, true },
 551         { 0x08c, "DDC Config Read" },
 552         { 0x08d, "Memory Read" },
 553         { 0x08e, "Memory Write",
 554                         memory_write_cmd, 6, false,
 555                         status_rsp, 1, true },
 556         { 0x0a6, "Read Supported Features",
 557                         read_supported_features_cmd, 1, true,
 558                         read_supported_features_rsp, 19, true },
 559
 560         { }
 561 };
 562
 563 const struct vendor_ocf *intel_vendor_ocf(uint16_t ocf)
 564 {
 565         int i;
 566
 567         for (i = 0; vendor_ocf_table[i].str; i++) {
 568                 if (vendor_ocf_table[i].ocf == ocf)
 569                         return &vendor_ocf_table[i];
 570         }
 571
 572         return NULL;
 573 }
 574
 575 static void startup_evt(const void *data, uint8_t size)
 576 {
 577 }
 578
 579 static void fatal_exception_evt(const void *data, uint8_t size)
 580 {
 581         uint16_t line = get_le16(data);
 582         uint8_t module = get_u8(data + 2);
 583         uint8_t reason = get_u8(data + 3);
 584
 585         print_field("Line: %u", line);
 586         print_module(module);
 587         print_field("Reason: 0x%2.2x", reason);
 588 }
 589
 590 static void bootup_evt(const void *data, uint8_t size)
 591 {
 592         uint8_t zero = get_u8(data);
 593         uint8_t num_packets = get_u8(data + 1);
 594         uint8_t source = get_u8(data + 2);
 595         uint8_t reset_type = get_u8(data + 3);
 596         uint8_t reset_reason = get_u8(data + 4);
 597         uint8_t ddc_status = get_u8(data + 5);
 598         const char *str;
 599
 600         print_field("Zero: 0x%2.2x", zero);
 601         print_field("Number of packets: %d", num_packets);
 602
 603         switch (source) {
 604         case 0x00:
 605                 str = "Bootloader";
 606                 break;
 607         case 0x01:
 608                 str = "Operational firmware";
 609                 break;
 610         case 0x02:
 611                 str = "Self test firmware";
 612                 break;
 613         default:
 614                 str = "Reserved";
 615                 break;
 616         }
 617
 618         print_field("Source: %s (0x%2.2x)", str, source);
 619
 620         switch (reset_type) {
 621         case 0x00:
 622                 str = "Hardware reset";
 623                 break;
 624         case 0x01:
 625                 str = "Soft watchdog reset";
 626                 break;
 627         case 0x02:
 628                 str = "Soft software reset";
 629                 break;
 630         case 0x03:
 631                 str = "Hard watchdog reset";
 632                 break;
 633         case 0x04:
 634                 str = "Hard software reset";
 635                 break;
 636         default:
 637                 str = "Reserved";
 638                 break;
 639         }
 640
 641         print_field("Reset type: %s (0x%2.2x)", str, reset_type);
 642
 643         switch (reset_reason) {
 644         case 0x00:
 645                 str = "Power on";
 646                 break;
 647         case 0x01:
 648                 str = "Reset command";
 649                 break;
 650         case 0x02:
 651                 str = "Intel reset command";
 652                 break;
 653         case 0x03:
 654                 str = "Watchdog";
 655                 break;
 656         case 0x04:
 657                 str = "Fatal exception";
 658                 break;
 659         case 0x05:
 660                 str = "System exception";
 661                 break;
 662         case 0xff:
 663                 str = "Unknown";
 664                 break;
 665         default:
 666                 str = "Reserved";
 667                 break;
 668         }
 669
 670         print_field("Reset reason: %s (0x%2.2x)", str, reset_reason);
 671
 672         switch (ddc_status) {
 673         case 0x00:
 674                 str = "Firmware default";
 675                 break;
 676         case 0x01:
 677                 str = "Firmware default plus OTP";
 678                 break;
 679         case 0x02:
 680                 str = "Persistent RAM";
 681                 break;
 682         case 0x03:
 683                 str = "Not used";
 684                 break;
 685         default:
 686                 str = "Reserved";
 687                 break;
 688         }
 689
 690         print_field("DDC status: %s (0x%2.2x)", str, ddc_status);
 691 }
 692
 693 static void default_bd_data_evt(const void *data, uint8_t size)
 694 {
 695         uint8_t mem_status = get_u8(data);
 696         const char *str;
 697
 698         switch (mem_status) {
 699         case 0x02:
 700                 str = "Invalid manufacturing data";
 701                 break;
 702         default:
 703                 str = "Reserved";
 704                 break;
 705         }
 706
 707         print_field("Memory status: %s (0x%2.2x)", str, mem_status);
 708 }
 709
 710 static void secure_send_commands_result_evt(const void *data, uint8_t size)
 711 {
 712         uint8_t result = get_u8(data);
 713         uint16_t opcode = get_le16(data + 1);
 714         uint16_t ogf = cmd_opcode_ogf(opcode);
 715         uint16_t ocf = cmd_opcode_ocf(opcode);
 716         uint8_t status = get_u8(data + 3);
 717         const char *str;
 718
 719         switch (result) {
 720         case 0x00:
 721                 str = "Success";
 722                 break;
 723         case 0x01:
 724                 str = "General failure";
 725                 break;
 726         case 0x02:
 727                 str = "Hardware failure";
 728                 break;
 729         case 0x03:
 730                 str = "Signature verification failed";
 731                 break;
 732         case 0x04:
 733                 str = "Parsing error of command buffer";
 734                 break;
 735         case 0x05:
 736                 str = "Command execution failure";
 737                 break;
 738         case 0x06:
 739                 str = "Command parameters error";
 740                 break;
 741         case 0x07:
 742                 str = "Command missing";
 743                 break;
 744         default:
 745                 str = "Reserved";
 746                 break;
 747         }
 748
 749         print_field("Result: %s (0x%2.2x)", str, result);
 750         print_field("Opcode: 0x%4.4x (0x%2.2x|0x%4.4x)", opcode, ogf, ocf);
 751         print_status(status);
 752 }
 753
 754 static void debug_exception_evt(const void *data, uint8_t size)
 755 {
 756         uint16_t line = get_le16(data);
 757         uint8_t module = get_u8(data + 2);
 758         uint8_t reason = get_u8(data + 3);
 759
 760         print_field("Line: %u", line);
 761         print_module(module);
 762         print_field("Reason: 0x%2.2x", reason);
 763 }
 764
 765 static void le_link_established_evt(const void *data, uint8_t size)
 766 {
 767         uint16_t handle = get_le16(data);
 768         uint32_t access_addr = get_le32(data + 10);
 769
 770         print_field("Handle: %u", handle);
 771
 772         packet_hexdump(data + 2, 8);
 773
 774         print_field("Access address: 0x%8.8x", access_addr);
 775
 776         packet_hexdump(data + 14, size - 14);
 777 }
 778
 779 static void scan_status_evt(const void *data, uint8_t size)
 780 {
 781         uint8_t enable = get_u8(data);
 782
 783         print_field("Inquiry scan: %s",
 784                                 (enable & 0x01) ? "Enabled" : "Disabled");
 785         print_field("Page scan: %s",
 786                                 (enable & 0x02) ? "Enabled" : "Disabled");
 787
 788         if (enable & 0xfc)
 789                 print_text(COLOR_UNKNOWN_SCAN_STATUS,
 790                                 "  Unknown status (0x%2.2x)", enable & 0xfc);
 791
 792 }
 793
 794 static void act_deact_traces_complete_evt(const void *data, uint8_t size)
 795 {
 796         uint8_t status = get_u8(data);
 797
 798         print_status(status);
 799 }
 800
 801 static void lmp_pdu_trace_evt(const void *data, uint8_t size)
 802 {
 803         uint8_t type, len, id;
 804         uint16_t handle, count;
 805         uint32_t clock;
 806         const char *str;
 807
 808         type = get_u8(data);
 809         handle = get_le16(data + 1);
 810
 811         switch (type) {
 812         case 0x00:
 813                 str = "RX LMP";
 814                 break;
 815         case 0x01:
 816                 str = "TX LMP";
 817                 break;
 818         case 0x02:
 819                 str = "ACK LMP";
 820                 break;
 821         case 0x03:
 822                 str = "RX LL";
 823                 break;
 824         case 0x04:
 825                 str = "TX LL";
 826                 break;
 827         case 0x05:
 828                 str = "ACK LL";
 829                 break;
 830         default:
 831                 str = "Unknown";
 832                 break;
 833         }
 834
 835         print_field("Type: %s (0x%2.2x)", str, type);
 836         print_field("Handle: %u", handle);
 837
 838         switch (type) {
 839         case 0x00:
 840                 len = size - 8;
 841                 clock = get_le32(data + 4 + len);
 842
 843                 packet_hexdump(data + 3, 1);
 844                 lmp_packet(data + 4, len, false);
 845                 print_field("Clock: 0x%8.8x", clock);
 846                 break;
 847         case 0x01:
 848                 len = size - 9;
 849                 clock = get_le32(data + 4 + len);
 850                 id = get_u8(data + 4 + len + 4);
 851
 852                 packet_hexdump(data + 3, 1);
 853                 lmp_packet(data + 4, len, false);
 854                 print_field("Clock: 0x%8.8x", clock);
 855                 print_field("ID: 0x%2.2x", id);
 856                 break;
 857         case 0x02:
 858                 clock = get_le32(data + 3);
 859                 id = get_u8(data + 3 + 4);
 860
 861                 print_field("Clock: 0x%8.8x", clock);
 862                 print_field("ID: 0x%2.2x", id);
 863                 break;
 864         case 0x03:
 865                 len = size - 8;
 866                 count = get_le16(data + 3);
 867
 868                 print_field("Count: 0x%4.4x", count);
 869                 packet_hexdump(data + 3 + 2 + 1, 2);
 870                 llcp_packet(data + 8, len, false);
 871                 break;
 872         case 0x04:
 873                 len = size - 8;
 874                 count = get_le16(data + 3);
 875                 id = get_u8(data + 3 + 2);
 876
 877                 print_field("Count: 0x%4.4x", count);
 878                 print_field("ID: 0x%2.2x", id);
 879                 packet_hexdump(data + 3 + 2 + 1, 2);
 880                 llcp_packet(data + 8, len, false);
 881                 break;
 882         case 0x05:
 883                 count = get_le16(data + 3);
 884                 id = get_u8(data + 3 + 2);
 885
 886                 print_field("Count: 0x%4.4x", count);
 887                 print_field("ID: 0x%2.2x", id);
 888                 break;
 889         default:
 890                 packet_hexdump(data + 3, size - 3);
 891                 break;
 892         }
 893 }
 894
 895 static void write_bd_data_complete_evt(const void *data, uint8_t size)
 896 {
 897         uint8_t status = get_u8(data);
 898
 899         print_status(status);
 900 }
 901
 902 static void sco_rejected_via_lmp_evt(const void *data, uint8_t size)
 903 {
 904         uint8_t reason = get_u8(data + 6);
 905
 906         packet_print_addr("Address", data, false);
 907         packet_print_error("Reason", reason);
 908 }
 909
 910 static void ptt_switch_notification_evt(const void *data, uint8_t size)
 911 {
 912         uint16_t handle = get_le16(data);
 913         uint8_t table = get_u8(data + 2);
 914         const char *str;
 915
 916         print_field("Handle: %u", handle);
 917
 918         switch (table) {
 919         case 0x00:
 920                 str = "Basic rate";
 921                 break;
 922         case 0x01:
 923                 str = "Enhanced data rate";
 924                 break;
 925         default:
 926                 str = "Reserved";
 927                 break;
 928         }
 929
 930         print_field("Packet type table: %s (0x%2.2x)", str, table);
 931 }
 932
 933 static void system_exception_evt(const void *data, uint8_t size)
 934 {
 935         uint8_t type = get_u8(data);
 936         const char *str;
 937
 938         switch (type) {
 939         case 0x00:
 940                 str = "No Exception";
 941                 break;
 942         case 0x01:
 943                 str = "Undefined Instruction";
 944                 break;
 945         case 0x02:
 946                 str = "Prefetch abort";
 947                 break;
 948         case 0x03:
 949                 str = "Data abort";
 950                 break;
 951         default:
 952                 str = "Reserved";
 953                 break;
 954         }
 955
 956         print_field("Type: %s (0x%2.2x)", str, type);
 957
 958         packet_hexdump(data + 1, size - 1);
 959 }
 960
 961 static const struct vendor_evt vendor_evt_table[] = {
 962         { 0x00, "Startup",
 963                         startup_evt, 0, true },
 964         { 0x01, "Fatal Exception",
 965                         fatal_exception_evt, 4, true },
 966         { 0x02, "Bootup",
 967                         bootup_evt, 6, true },
 968         { 0x05, "Default BD Data",
 969                         default_bd_data_evt, 1, true },
 970         { 0x06, "Secure Send Commands Result",
 971                         secure_send_commands_result_evt, 4, true },
 972         { 0x08, "Debug Exception",
 973                         debug_exception_evt, 4, true },
 974         { 0x0f, "LE Link Established",
 975                         le_link_established_evt, 26, true },
 976         { 0x11, "Scan Status",
 977                         scan_status_evt, 1, true },
 978         { 0x16, "Activate Deactivate Traces Complete",
 979                         act_deact_traces_complete_evt, 1, true },
 980         { 0x17, "LMP PDU Trace",
 981                         lmp_pdu_trace_evt, 3, false },
 982         { 0x19, "Write BD Data Complete",
 983                         write_bd_data_complete_evt, 1, true },
 984         { 0x25, "SCO Rejected via LMP",
 985                         sco_rejected_via_lmp_evt, 7, true },
 986         { 0x26, "PTT Switch Notification",
 987                         ptt_switch_notification_evt, 3, true },
 988         { 0x29, "System Exception",
 989                         system_exception_evt, 133, true },
 990         { 0x2c, "FW Trace String" },
 991         { 0x2e, "FW Trace Binary" },
 992         { }
 993 };
 994
 995 /*
 996  * An Intel telemetry subevent is of the TLV format.
 997  * - Type: takes 1 byte. This is the subevent_id.
 998  * - Length: takes 1 byte.
 999  * - Value: takes |Length| bytes.
1000  */
1001 struct intel_tlv {
1002         uint8_t subevent_id;
1003         uint8_t length;
1004         uint8_t value[];
1005 };
1006
1007 #define TLV_SIZE(tlv) (*((const uint8_t *) tlv + 1) + 2 * sizeof(uint8_t))
1008 #define NEXT_TLV(tlv) (const struct intel_tlv *) \
1009                                         ((const uint8_t *) tlv + TLV_SIZE(tlv))
1010
1011 static void ext_evt_type(const struct intel_tlv *tlv)
1012 {
1013         uint8_t evt_type = get_u8(tlv->value);
1014         const char *str;
1015
1016         switch (evt_type) {
1017         case 0x00:
1018                 str = "System Exception";
1019                 break;
1020         case 0x01:
1021                 str = "Fatal Exception";
1022                 break;
1023         case 0x02:
1024                 str = "Debug Exception";
1025                 break;
1026         case 0x03:
1027                 str = "Connection Event for BR/EDR Link Type";
1028                 break;
1029         case 0x04:
1030                 str = "Disconnection Event";
1031                 break;
1032         case 0x05:
1033                 str = "Audio Link Quality Report Type";
1034                 break;
1035         case 0x06:
1036                 str = "Stats for BR/EDR Link Type";
1037                 break;
1038         default:
1039                 print_text(COLOR_UNKNOWN_EXT_EVENT,
1040                         "Unknown extended telemetry event type (0x%2.2x)",
1041                         evt_type);
1042                 packet_hexdump((const void *) tlv,
1043                                         tlv->length + 2 * sizeof(uint8_t));
1044                 return;
1045         }
1046
1047         print_field("Extended event type (0x%2.2x): %s (0x%2.2x)",
1048                         tlv->subevent_id, str, evt_type);
1049 }
1050
1051 static void ext_acl_evt_conn_handle(const struct intel_tlv *tlv)
1052 {
1053         uint16_t conn_handle = get_le16(tlv->value);
1054
1055         print_field("ACL connection handle (0x%2.2x): 0x%4.4x",
1056                         tlv->subevent_id, conn_handle);
1057 }
1058
1059 static void ext_acl_evt_hec_errors(const struct intel_tlv *tlv)
1060 {
1061         uint32_t num = get_le32(tlv->value);
1062
1063         print_field("Rx HEC errors (0x%2.2x): %d", tlv->subevent_id, num);
1064 }
1065
1066 static void ext_acl_evt_crc_errors(const struct intel_tlv *tlv)
1067 {
1068         uint32_t num = get_le32(tlv->value);
1069
1070         print_field("Rx CRC errors (0x%2.2x): %d", tlv->subevent_id, num);
1071 }
1072
1073 static void ext_acl_evt_num_pkt_from_host(const struct intel_tlv *tlv)
1074 {
1075         uint32_t num = get_le32(tlv->value);
1076
1077         print_field("Packets from host (0x%2.2x): %d",
1078                         tlv->subevent_id, num);
1079 }
1080
1081 static void ext_acl_evt_num_tx_pkt_to_air(const struct intel_tlv *tlv)
1082 {
1083         uint32_t num = get_le32(tlv->value);
1084
1085         print_field("Tx packets (0x%2.2x): %d", tlv->subevent_id, num);
1086 }
1087
1088 static void ext_acl_evt_num_tx_pkt_retry(const struct intel_tlv *tlv)
1089 {
1090         char *subevent_str;
1091         uint32_t num = get_le32(tlv->value);
1092
1093         switch (tlv->subevent_id) {
1094         case 0x4f:
1095                 subevent_str = "Tx packets 0 retries";
1096                 break;
1097         case 0x50:
1098                 subevent_str = "Tx packets 1 retries";
1099                 break;
1100         case 0x51:
1101                 subevent_str = "Tx packets 2 retries";
1102                 break;
1103         case 0x52:
1104                 subevent_str = "Tx packets 3 retries";
1105                 break;
1106         case 0x53:
1107                 subevent_str = "Tx packets 4 retries and more";
1108                 break;
1109         default:
1110                 subevent_str = "Unknown";
1111                 break;
1112         }
1113
1114         print_field("%s (0x%2.2x): %d", subevent_str, tlv->subevent_id, num);
1115 }
1116
1117 static void ext_acl_evt_num_tx_pkt_type(const struct intel_tlv *tlv)
1118 {
1119         char *packet_type_str;
1120         uint32_t num = get_le32(tlv->value);
1121
1122         switch (tlv->subevent_id) {
1123         case 0x54:
1124                 packet_type_str = "DH1";
1125                 break;
1126         case 0x55:
1127                 packet_type_str = "DH3";
1128                 break;
1129         case 0x56:
1130                 packet_type_str = "DH5";
1131                 break;
1132         case 0x57:
1133                 packet_type_str = "2DH1";
1134                 break;
1135         case 0x58:
1136                 packet_type_str = "2DH3";
1137                 break;
1138         case 0x59:
1139                 packet_type_str = "2DH5";
1140                 break;
1141         case 0x5a:
1142                 packet_type_str = "3DH1";
1143                 break;
1144         case 0x5b:
1145                 packet_type_str = "3DH3";
1146                 break;
1147         case 0x5c:
1148                 packet_type_str = "3DH5";
1149                 break;
1150         default:
1151                 packet_type_str = "Unknown";
1152                 break;
1153         }
1154
1155         print_field("Tx %s packets (0x%2.2x): %d",
1156                         packet_type_str, tlv->subevent_id, num);
1157 }
1158
1159 static void ext_acl_evt_num_rx_pkt_from_air(const struct intel_tlv *tlv)
1160 {
1161         uint32_t num = get_le32(tlv->value);
1162
1163         print_field("Rx packets (0x%2.2x): %d",
1164                         tlv->subevent_id, num);
1165 }
1166
1167 static void ext_acl_evt_link_throughput(const struct intel_tlv *tlv)
1168 {
1169         uint32_t num = get_le32(tlv->value);
1170
1171         print_field("ACL link throughput (KBps) (0x%2.2x): %d",
1172                         tlv->subevent_id, num);
1173 }
1174
1175 static void ext_acl_evt_max_packet_latency(const struct intel_tlv *tlv)
1176 {
1177         uint32_t num = get_le32(tlv->value);
1178
1179         print_field("ACL max packet latency (ms) (0x%2.2x): %d",
1180                         tlv->subevent_id, num);
1181 }
1182
1183 static void ext_acl_evt_avg_packet_latency(const struct intel_tlv *tlv)
1184 {
1185         uint32_t num = get_le32(tlv->value);
1186
1187         print_field("ACL avg packet latency (ms) (0x%2.2x): %d",
1188                         tlv->subevent_id, num);
1189 }
1190
1191 static void ext_sco_evt_conn_handle(const struct intel_tlv *tlv)
1192 {
1193         uint16_t conn_handle = get_le16(tlv->value);
1194
1195         print_field("SCO/eSCO connection handle (0x%2.2x): 0x%4.4x",
1196                         tlv->subevent_id, conn_handle);
1197 }
1198
1199 static void ext_sco_evt_num_rx_pkt_from_air(const struct intel_tlv *tlv)
1200 {
1201         uint32_t num = get_le32(tlv->value);
1202
1203         print_field("Packets from host (0x%2.2x): %d", tlv->subevent_id, num);
1204 }
1205
1206 static void ext_sco_evt_num_tx_pkt_to_air(const struct intel_tlv *tlv)
1207 {
1208         uint32_t num = get_le32(tlv->value);
1209
1210         print_field("Tx packets (0x%2.2x): %d", tlv->subevent_id, num);
1211 }
1212
1213 static void ext_sco_evt_num_rx_payloads_lost(const struct intel_tlv *tlv)
1214 {
1215         uint32_t num = get_le32(tlv->value);
1216
1217         print_field("Rx payload lost (0x%2.2x): %d", tlv->subevent_id, num);
1218 }
1219
1220 static void ext_sco_evt_num_tx_payloads_lost(const struct intel_tlv *tlv)
1221 {
1222
1223         uint32_t num = get_le32(tlv->value);
1224
1225         print_field("Tx payload lost (0x%2.2x): %d", tlv->subevent_id, num);
1226 }
1227
1228 static void slots_errors(const struct intel_tlv *tlv, const char *type_str)
1229 {
1230         /* The subevent has 5 slots where each slot is of the uint32_t type. */
1231         uint32_t num[5];
1232         const uint8_t *data = tlv->value;
1233         int i;
1234
1235         if (tlv->length != 5 * sizeof(uint32_t)) {
1236                 print_text(COLOR_UNKNOWN_EXT_EVENT,
1237                                 "  Invalid subevent length (%d)", tlv->length);
1238                 return;
1239         }
1240
1241         for (i = 0; i < 5; i++) {
1242                 num[i] = get_le32(data);
1243                 data += sizeof(uint32_t);
1244         }
1245
1246         print_field("%s (0x%2.2x): %d %d %d %d %d", type_str, tlv->subevent_id,
1247                         num[0], num[1], num[2], num[3], num[4]);
1248 }
1249
1250 static void ext_sco_evt_num_no_sync_errors(const struct intel_tlv *tlv)
1251 {
1252         slots_errors(tlv, "Rx No SYNC errors");
1253 }
1254
1255 static void ext_sco_evt_num_hec_errors(const struct intel_tlv *tlv)
1256 {
1257         slots_errors(tlv, "Rx HEC errors");
1258 }
1259
1260 static void ext_sco_evt_num_crc_errors(const struct intel_tlv *tlv)
1261 {
1262         slots_errors(tlv, "Rx CRC errors");
1263 }
1264
1265 static void ext_sco_evt_num_naks(const struct intel_tlv *tlv)
1266 {
1267         slots_errors(tlv, "Rx NAK errors");
1268 }
1269
1270 static void ext_sco_evt_num_failed_tx_by_wifi(const struct intel_tlv *tlv)
1271 {
1272         slots_errors(tlv, "Failed Tx due to Wifi coex");
1273 }
1274
1275 static void ext_sco_evt_num_failed_rx_by_wifi(const struct intel_tlv *tlv)
1276 {
1277         slots_errors(tlv, "Failed Rx due to Wifi coex");
1278 }
1279
1280 static void ext_sco_evt_samples_inserted(const struct intel_tlv *tlv)
1281 {
1282         uint32_t num = get_le32(tlv->value);
1283
1284         print_field("Late samples inserted based on CDC (0x%2.2x): %d",
1285                         tlv->subevent_id, num);
1286 }
1287
1288 static void ext_sco_evt_samples_dropped(const struct intel_tlv *tlv)
1289 {
1290         uint32_t num = get_le32(tlv->value);
1291
1292         print_field("Samples dropped (0x%2.2x): %d", tlv->subevent_id, num);
1293 }
1294
1295 static void ext_sco_evt_mute_samples(const struct intel_tlv *tlv)
1296 {
1297         uint32_t num = get_le32(tlv->value);
1298
1299         print_field("Mute samples sent at initial connection (0x%2.2x): %d",
1300                         tlv->subevent_id, num);
1301 }
1302
1303 static void ext_sco_evt_plc_injection_data(const struct intel_tlv *tlv)
1304 {
1305         uint32_t num = get_le32(tlv->value);
1306
1307         print_field("PLC injection data (0x%2.2x): %d", tlv->subevent_id, num);
1308 }
1309
1310 static const struct intel_ext_subevent {
1311         uint8_t subevent_id;
1312         uint8_t length;
1313         void (*func)(const struct intel_tlv *tlv);
1314 } intel_ext_subevent_table[] = {
1315         { 0x01, 1, ext_evt_type },
1316
1317         /* ACL audio link quality subevents */
1318         { 0x4a, 2, ext_acl_evt_conn_handle },
1319         { 0x4b, 4, ext_acl_evt_hec_errors },
1320         { 0x4c, 4, ext_acl_evt_crc_errors },
1321         { 0x4d, 4, ext_acl_evt_num_pkt_from_host },
1322         { 0x4e, 4, ext_acl_evt_num_tx_pkt_to_air },
1323         { 0x4f, 4, ext_acl_evt_num_tx_pkt_retry },
1324         { 0x50, 4, ext_acl_evt_num_tx_pkt_retry },
1325         { 0x51, 4, ext_acl_evt_num_tx_pkt_retry },
1326         { 0x52, 4, ext_acl_evt_num_tx_pkt_retry },
1327         { 0x53, 4, ext_acl_evt_num_tx_pkt_retry },
1328         { 0x54, 4, ext_acl_evt_num_tx_pkt_type },
1329         { 0x55, 4, ext_acl_evt_num_tx_pkt_type },
1330         { 0x56, 4, ext_acl_evt_num_tx_pkt_type },
1331         { 0x57, 4, ext_acl_evt_num_tx_pkt_type },
1332         { 0x58, 4, ext_acl_evt_num_tx_pkt_type },
1333         { 0x59, 4, ext_acl_evt_num_tx_pkt_type },
1334         { 0x5a, 4, ext_acl_evt_num_tx_pkt_type },
1335         { 0x5b, 4, ext_acl_evt_num_tx_pkt_type },
1336         { 0x5c, 4, ext_acl_evt_num_tx_pkt_type },
1337         { 0x5d, 4, ext_acl_evt_num_rx_pkt_from_air },
1338         { 0x5e, 4, ext_acl_evt_link_throughput },
1339         { 0x5f, 4, ext_acl_evt_max_packet_latency },
1340         { 0x60, 4, ext_acl_evt_avg_packet_latency },
1341
1342         /* SCO/eSCO audio link quality subevents */
1343         { 0x6a, 2, ext_sco_evt_conn_handle },
1344         { 0x6b, 4, ext_sco_evt_num_rx_pkt_from_air },
1345         { 0x6c, 4, ext_sco_evt_num_tx_pkt_to_air },
1346         { 0x6d, 4, ext_sco_evt_num_rx_payloads_lost },
1347         { 0x6e, 4, ext_sco_evt_num_tx_payloads_lost },
1348         { 0x6f, 20, ext_sco_evt_num_no_sync_errors },
1349         { 0x70, 20, ext_sco_evt_num_hec_errors },
1350         { 0x71, 20, ext_sco_evt_num_crc_errors },
1351         { 0x72, 20, ext_sco_evt_num_naks },
1352         { 0x73, 20, ext_sco_evt_num_failed_tx_by_wifi },
1353         { 0x74, 20, ext_sco_evt_num_failed_rx_by_wifi },
1354         { 0x75, 4, ext_sco_evt_samples_inserted },
1355         { 0x76, 4, ext_sco_evt_samples_dropped },
1356         { 0x77, 4, ext_sco_evt_mute_samples },
1357         { 0x78, 4, ext_sco_evt_plc_injection_data },
1358
1359         /* end */
1360         { 0x0, 0}
1361 };
1362
1363 static const struct intel_tlv *process_ext_subevent(const struct intel_tlv *tlv,
1364                                         const struct intel_tlv *last_tlv)
1365 {
1366         const struct intel_tlv *next_tlv = NEXT_TLV(tlv);
1367         const struct intel_ext_subevent *subevent = NULL;
1368         int i;
1369
1370         for (i = 0; intel_ext_subevent_table[i].length > 0; i++) {
1371                 if (intel_ext_subevent_table[i].subevent_id ==
1372                                                         tlv->subevent_id) {
1373                         subevent = &intel_ext_subevent_table[i];
1374                         break;
1375                 }
1376         }
1377
1378         if (!subevent) {
1379                 print_text(COLOR_UNKNOWN_EXT_EVENT,
1380                                 "Unknown extended subevent 0x%2.2x",
1381                                 tlv->subevent_id);
1382                 return NULL;
1383         }
1384
1385         if (tlv->length != subevent->length) {
1386                 print_text(COLOR_ERROR, "Invalid length %d of subevent 0x%2.2x",
1387                                 tlv->length, tlv->subevent_id);
1388                 return NULL;
1389         }
1390
1391         if (next_tlv > last_tlv) {
1392                 print_text(COLOR_ERROR, "Subevent exceeds the buffer size.");
1393                 return NULL;
1394         }
1395
1396         subevent->func(tlv);
1397
1398         return next_tlv;
1399 }
1400
1401 static void intel_vendor_ext_evt(const void *data, uint8_t size)
1402 {
1403         /* The data pointer points to a number of tlv.*/
1404         const struct intel_tlv *tlv = data;
1405         const struct intel_tlv *last_tlv = data + size;
1406
1407         /* Process every tlv subevent until reaching last_tlv.
1408          * The decoding process terminates normally when tlv == last_tlv.
1409          */
1410         while (tlv && tlv < last_tlv)
1411                 tlv = process_ext_subevent(tlv, last_tlv);
1412
1413         /* If an error occurs in decoding the subevents, hexdump the packet. */
1414         if (!tlv)
1415                 packet_hexdump(data, size);
1416 }
1417
1418 /* Vendor extended events with a vendor prefix. */
1419 static const struct vendor_evt vendor_prefix_evt_table[] = {
1420         { 0x03, "Extended Telemetry", intel_vendor_ext_evt },
1421         { }
1422 };
1423
1424 const uint8_t intel_vendor_prefix[] = {0x87, 0x80};
1425 #define INTEL_VENDOR_PREFIX_SIZE sizeof(intel_vendor_prefix)
1426
1427 /*
1428  * The vendor event with Intel vendor prefix.
1429  * Its format looks like
1430  *   0xff <length> <vendor_prefix> <subopcode> <data>
1431  *   where Intel's <vendor_prefix> is 0x8780.
1432  *
1433  *   When <subopcode> == 0x03, it is a telemetry event; and
1434  *   <data> is a number of tlv data.
1435  */
1436 struct vendor_prefix_evt {
1437         uint8_t prefix_data[INTEL_VENDOR_PREFIX_SIZE];
1438         uint8_t subopcode;
1439 };
1440
1441 static const struct vendor_evt *intel_vendor_prefix_evt(const void *data,
1442                                                         int *consumed_size)
1443 {
1444         unsigned int i;
1445         const struct vendor_prefix_evt *vnd = data;
1446         char prefix_string[INTEL_VENDOR_PREFIX_SIZE * 2 + 1] = { 0 };
1447
1448         /* Check if the vendor prefix matches. */
1449         for (i = 0; i < INTEL_VENDOR_PREFIX_SIZE; i++) {
1450                 if (vnd->prefix_data[i] != intel_vendor_prefix[i])
1451                         return NULL;
1452                 sprintf(prefix_string + i * 2, "%02x", vnd->prefix_data[i]);
1453         }
1454         print_field("Vendor Prefix (0x%s)", prefix_string);
1455
1456         /*
1457          * Handle the vendor event with a vendor prefix.
1458          *   0xff <length> <vendor_prefix> <subopcode> <data>
1459          * This loop checks whether the <subopcode> exists in the
1460          * vendor_prefix_evt_table.
1461          */
1462         for (i = 0; vendor_prefix_evt_table[i].str; i++) {
1463                 if (vendor_prefix_evt_table[i].evt == vnd->subopcode) {
1464                         *consumed_size = sizeof(struct vendor_prefix_evt);
1465                         return &vendor_prefix_evt_table[i];
1466                 }
1467         }
1468
1469         return NULL;
1470 }
1471
1472 const struct vendor_evt *intel_vendor_evt(const void *data, int *consumed_size)
1473 {
1474         uint8_t evt = *((const uint8_t *) data);
1475         int i;
1476
1477         /*
1478          * Handle the vendor event without a vendor prefix.
1479          *   0xff <length> <evt> <data>
1480          * This loop checks whether the <evt> exists in the vendor_evt_table.
1481          */
1482         for (i = 0; vendor_evt_table[i].str; i++) {
1483                 if (vendor_evt_table[i].evt == evt)
1484                         return &vendor_evt_table[i];
1485         }
1486
1487         /*
1488          * It is not a regular event. Check whether it is a vendor extended
1489          * event that comes with a vendor prefix followed by a subopcode.
1490          */
1491         return intel_vendor_prefix_evt(data, consumed_size);
1492 }