// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stdio.h>

#include <iterator>

#include <fbl/algorithm.h>

#include "codec_state.h"

namespace audio {
namespace intel_hda {

// Don't allow this code to pollute the rest of the namespace.
namespace {

const char* ToString(const FunctionGroupState::Type& val) {
  switch (val) {
    case FunctionGroupState::Type::AUDIO:
      return "AUDIO";
    case FunctionGroupState::Type::MODEM:
      return "MODEM";
    default:
      if ((val >= FunctionGroupState::Type::VENDOR_START) &&
          (val <= FunctionGroupState::Type::VENDOR_END))
        return "VENDOR";
      else
        return "<unknown>";
  }
}

const char* ToString(const AudioWidgetCaps::Type& val) {
  switch (val) {
    case AudioWidgetCaps::Type::OUTPUT:
      return "OUTPUT";
    case AudioWidgetCaps::Type::INPUT:
      return "INPUT";
    case AudioWidgetCaps::Type::MIXER:
      return "MIXER";
    case AudioWidgetCaps::Type::SELECTOR:
      return "SELECTOR";
    case AudioWidgetCaps::Type::PIN_COMPLEX:
      return "PIN_COMPLEX";
    case AudioWidgetCaps::Type::POWER:
      return "POWER";
    case AudioWidgetCaps::Type::VOLUME_KNOB:
      return "VOLUME_KNOB";
    case AudioWidgetCaps::Type::BEEP_GEN:
      return "BEEP_GEN";
    case AudioWidgetCaps::Type::VENDOR:
      return "VENDOR";
    default:
      return "<unknown>";
  }
}

const char* PowerStateToString(uint8_t val) {
  switch (val) {
    case 0u:
      return "D0";
    case 1u:
      return "D1";
    case 2u:
      return "D2";
    case 3u:
      return "D3HOT";
    case 4u:
      return "D3COLD";
    default:
      return "Unknown";
  };
}

void Dump(const AmpCaps& caps, const AudioWidgetState::AmpState* amp_state = nullptr) {
  float start = 0.0;
  float stop = 0.0;
  float step = 0.0;

  if (!caps.step_size() || !caps.num_steps()) {
    printf("none\n");
    return;
  } else if (caps.num_steps() == 1) {
    printf("fixed 0 dB gain");
  } else {
    step = (static_cast<float>(caps.step_size()) / 4.0f);
    start = -static_cast<float>(caps.offset()) * step;
    stop = start + ((static_cast<float>(caps.num_steps()) - 1) * step);
    printf("[%.2f, %.2f] dB in %.2f dB steps", start, stop, step);
  }

  printf(" (Can%s mute)", caps.can_mute() ? "" : "'t");

  if (amp_state != nullptr) {
    printf(" [");
    for (size_t i = 0; i < std::size(amp_state->gain); ++i) {
      if (i)
        printf(", ");
      printf("%c:", !i ? 'L' : 'R');

      if (caps.can_mute() && amp_state->mute[i]) {
        printf("mute");
      } else {
        printf("%.2f dB", start + (step * amp_state->gain[0]));
      }
    }

    printf("]");
  }

  printf("\n");
}

void Dump(const AudioWidgetState::StreamFormat& format) {
  if (!format.is_pcm()) {
    printf("Non-PCM (raw 0x%04hx)\n", format.raw_data_);
    return;
  }

  printf("%u chan %u Hz %u bps (raw 0x%04hx)\n", format.channels(), format.sample_rate(),
         format.bits_per_chan(), format.raw_data_);
}

#define FMT(fmt) "%s%17s : " fmt, pad
void Dump(const ConfigDefaults& cfg) {
  static const char* pad = "+     \\-- ";
  const char *tmp, *tmp2;

  // Table 109
  switch (cfg.port_connectivity()) {
    case 0:
      tmp = "Jack";
      break;
    case 1:
      tmp = "Unconnected";
      break;
    case 2:
      tmp = "Integrated";
      break;
    case 3:
      tmp = "Jack+Integrated";
      break;
    default:
      tmp = "ERROR";
      break;
  }

  printf(FMT("%s (%u)\n"), "Port Connectivity", tmp, cfg.port_connectivity());

  // Table 110
  uint32_t loc1 = cfg.location() & 0xF;
  uint32_t loc2 = (cfg.location() >> 4) & 0x3;
  switch (loc1) {
    case 0:
      tmp = "N/A";
      break;
    case 1:
      tmp = "Rear";
      break;
    case 2:
      tmp = "Front";
      break;
    case 3:
      tmp = "Left";
      break;
    case 4:
      tmp = "Right";
      break;
    case 5:
      tmp = "Top";
      break;
    case 6:
      tmp = "Bottom";
      break;
    case 7:
    case 8:
    case 9:
      tmp = "Special";
      break;
    default:
      tmp = "Unknown";
      break;
  }

  switch (loc2) {
    case 0:
      tmp2 = " External";
      break;
    case 1:
      tmp2 = " Internal";
      break;
    case 2:
      tmp2 = " Separate Chassis";
      break;
    case 3:
      tmp2 = " Other";
      break;
    default:
      tmp2 = " ERROR";
      break;
  }

  switch (cfg.location()) {
    case 0x07:
      tmp2 = "";
      tmp = "Rear Panel";
      break;
    case 0x08:
      tmp2 = "";
      tmp = "Drive Bay";
      break;
    case 0x17:
      tmp2 = "";
      tmp = "Riser";
      break;
    case 0x18:
      tmp2 = "";
      tmp = "Digital Display";
      break;
    case 0x19:
      tmp2 = "";
      tmp = "ATAPI";
      break;
    case 0x37:
      tmp2 = "";
      tmp = "Mobile Lid - Inside";
      break;
    case 0x38:
      tmp2 = "";
      tmp = "Mobile Lid - Outside";
      break;
    default:
      break;
  }

  printf(FMT("%s%s (0x%02x)\n"), "Location", tmp, tmp2, cfg.location());

  // Table 111
  switch (cfg.default_device()) {
    case 0x0:
      tmp = "Line Out";
      break;
    case 0x1:
      tmp = "Speaker";
      break;
    case 0x2:
      tmp = "Headphone Out";
      break;
    case 0x3:
      tmp = "CD";
      break;
    case 0x4:
      tmp = "S/PDIF Out";
      break;
    case 0x5:
      tmp = "Digital Other Out";
      break;
    case 0x6:
      tmp = "Modem Line Side";
      break;
    case 0x7:
      tmp = "Modem Handset Side";
      break;
    case 0x8:
      tmp = "Line In";
      break;
    case 0x9:
      tmp = "AUX";
      break;
    case 0xa:
      tmp = "Mic In";
      break;
    case 0xb:
      tmp = "Telephony";
      break;
    case 0xc:
      tmp = "S/PDIF In";
      break;
    case 0xd:
      tmp = "Digital Other In";
      break;
    case 0xf:
      tmp = "Other";
      break;
    default:
      tmp = "Unknown";
      break;
  }

  printf(FMT("%s (%u)\n"), "Default Device", tmp, cfg.default_device());

  // Table 112
  switch (cfg.connection_type()) {
    case 0x1:
      tmp = "1/8 inch";
      break;
    case 0x2:
      tmp = "1/4 inch";
      break;
    case 0x3:
      tmp = "ATAPI Internal";
      break;
    case 0x4:
      tmp = "RCA";
      break;
    case 0x5:
      tmp = "Optical";
      break;
    case 0x6:
      tmp = "Other Digital";
      break;
    case 0x7:
      tmp = "Other Analog";
      break;
    case 0x8:
      tmp = "Multichannel Analog (DIN)";
      break;
    case 0x9:
      tmp = "XLR/Pro";
      break;
    case 0xa:
      tmp = "RJ-11 (Modem)";
      break;
    case 0xb:
      tmp = "Combination";
      break;
    case 0xf:
      tmp = "Other";
      break;
    default:
      tmp = "Unknown";
      break;
  }

  printf(FMT("%s (%u)\n"), "Connection Type", tmp, cfg.connection_type());

  // Table 113
  switch (cfg.color()) {
    case 0x1:
      tmp = "Black";
      break;
    case 0x2:
      tmp = "Grey";
      break;
    case 0x3:
      tmp = "Blue";
      break;
    case 0x4:
      tmp = "Green";
      break;
    case 0x5:
      tmp = "Red";
      break;
    case 0x6:
      tmp = "Orange";
      break;
    case 0x7:
      tmp = "Yellow";
      break;
    case 0x8:
      tmp = "Purple";
      break;
    case 0x9:
      tmp = "Pink";
      break;
    case 0xe:
      tmp = "White";
      break;
    case 0xf:
      tmp = "Other";
      break;
    default:
      tmp = "Unknown";
      break;
  }

  printf(FMT("%s (%u)\n"), "Color", tmp, cfg.color());

  // Associations and Flags
  printf(FMT("Assoc Group (%u) Assoc Seq (%u)%s\n"), "Assoc/Flags", cfg.default_assoc(),
         cfg.sequence(), cfg.misc() & 0x1 ? " JackDetectOverride" : "");
}
#undef FMT

typedef struct flag_lut_entry {
  uint32_t flag_bit;
  const char* flag_name;
} flag_lut_entry_t;

static void ihda_dump_delay(uint8_t delay) {
  if (delay)
    printf("%u samples\n", delay);
  else
    printf("unknown\n");
}

static void ihda_dump_flags(uint32_t flags, const flag_lut_entry_t* table, size_t table_size,
                            const char* suffix, const char* no_flags_text) {
  bool got_one = false;
  for (size_t i = 0; i < table_size; ++i) {
    if (flags & table[i].flag_bit) {
      printf("%s%s", got_one ? " " : "", table[i].flag_name);
      got_one = true;
    }
  }

  printf("%s\n", got_one ? suffix : no_flags_text);
}

static const flag_lut_entry_t POWER_STATE_FLAGS[] = {
    // clang-format off
    { IHDA_PWR_STATE_EPSS,     "EPSS" },
    { IHDA_PWR_STATE_CLKSTOP,  "CLKSTOP" },
    { IHDA_PWR_STATE_S3D3COLD, "S3D3COLD" },
    { IHDA_PWR_STATE_D3COLD,   "D3COLD" },
    { IHDA_PWR_STATE_D3,       "D3HOT" },
    { IHDA_PWR_STATE_D2,       "D2" },
    { IHDA_PWR_STATE_D1,       "D1" },
    { IHDA_PWR_STATE_D0,       "D0" },
    // clang-format on
};

static const flag_lut_entry_t PCM_RATE_FLAGS[] = {
    // clang-format off
    { IHDA_PCM_RATE_384000, "384000" },
    { IHDA_PCM_RATE_192000, "192000" },
    { IHDA_PCM_RATE_176400, "176400" },
    { IHDA_PCM_RATE_96000,   "96000" },
    { IHDA_PCM_RATE_88200,   "88200" },
    { IHDA_PCM_RATE_48000,   "48000" },
    { IHDA_PCM_RATE_44100,   "44100" },
    { IHDA_PCM_RATE_32000,   "32000" },
    { IHDA_PCM_RATE_22050,   "22050" },
    { IHDA_PCM_RATE_16000,   "16000" },
    { IHDA_PCM_RATE_11025,   "11025" },
    { IHDA_PCM_RATE_8000,     "8000" },
    // clang-format on
};

static const flag_lut_entry_t PCM_SIZE_FLAGS[] = {
    // clang-format off
    { IHDA_PCM_SIZE_32BITS, "32" },
    { IHDA_PCM_SIZE_24BITS, "24" },
    { IHDA_PCM_SIZE_20BITS, "20" },
    { IHDA_PCM_SIZE_16BITS, "16" },
    { IHDA_PCM_SIZE_8BITS,   "8" },
    // clang-format on
};

static const flag_lut_entry_t PCM_FMT_FLAGS[] = {
    // clang-format off
    { IHDA_PCM_FORMAT_AC3,     "AC3" },
    { IHDA_PCM_FORMAT_FLOAT32, "FLOAT32" },
    { IHDA_PCM_FORMAT_PCM,     "PCM" },
    // clang-format on
};

static const flag_lut_entry_t AW_CAPS_FLAGS[] = {
    // clang-format off
    { AudioWidgetCaps::FLAG_AMP_PARAM_OVERRIDE, "AmpParamOverride" },
    { AudioWidgetCaps::FLAG_FORMAT_OVERRIDE,    "FormatOverride" },
    { AudioWidgetCaps::FLAG_STRIPE_SUPPORTED,   "StripingSupported" },
    { AudioWidgetCaps::FLAG_PROC_WIDGET,        "HasProcessingControls" },
    { AudioWidgetCaps::FLAG_CAN_SEND_UNSOL,     "CanSendUnsolicited" },
    { AudioWidgetCaps::FLAG_DIGITAL,            "Digital" },
    { AudioWidgetCaps::FLAG_CAN_LR_SWAP,        "CanSwapLR" },
    { AudioWidgetCaps::FLAG_HAS_CONTENT_PROT,   "HasContentProtection" },
    // clang-format on
};

static const flag_lut_entry_t PIN_CAPS_FLAGS[] = {
    // clang-format off
    { AW_PIN_CAPS_FLAG_CAN_IMPEDANCE_SENSE,  "ImpedanceSense" },
    { AW_PIN_CAPS_FLAG_TRIGGER_REQUIRED,     "TrigReq" },
    { AW_PIN_CAPS_FLAG_CAN_PRESENCE_DETECT,  "PresDetect" },
    { AW_PIN_CAPS_FLAG_CAN_DRIVE_HEADPHONES, "HeadphoneDrive" },
    { AW_PIN_CAPS_FLAG_CAN_OUTPUT,           "CanOutput" },
    { AW_PIN_CAPS_FLAG_CAN_INPUT,            "CanInput" },
    { AW_PIN_CAPS_FLAG_BALANCED_IO,          "Balanced" },
    { AW_PIN_CAPS_FLAG_HDMI,                 "HDMI" },
    { AW_PIN_CAPS_FLAG_VREF_HIZ,             "VREF_HIZ" },
    { AW_PIN_CAPS_FLAG_VREF_50_PERCENT,      "VREF_50%" },
    { AW_PIN_CAPS_FLAG_VREF_GROUND,          "VREF_GND" },
    { AW_PIN_CAPS_FLAG_VREF_80_PERCENT,      "VREF_80%" },
    { AW_PIN_CAPS_FLAG_VREF_100_PERCENT,     "VREF_100%" },
    { AW_PIN_CAPS_FLAG_CAN_EAPD,             "EAPD" },
    { AW_PIN_CAPS_FLAG_DISPLAY_PORT,         "DisplayPort" },
    { AW_PIN_CAPS_FLAG_HIGH_BIT_RATE,        "HighBitRate" },
    // clang-format on
};

#define DUMP_FLAGS(flags, table, suffix, no_flags_text) \
  ihda_dump_flags(flags, table, std::size(table), suffix, no_flags_text)

static void ihda_dump_conn_list(const AudioWidgetState& widget) {
  if (!widget.conn_list_len_) {
    printf("empty\n");
    return;
  }

  ZX_DEBUG_ASSERT(widget.conn_list_);
  for (uint32_t i = 0; i < widget.conn_list_len_; ++i) {
    if (i > 0)
      printf(" ");

    const auto& first = widget.conn_list_[i];
    ZX_DEBUG_ASSERT(!first.range_);

    // Is this entry the start of a range or not?
    if ((i + 1) < widget.conn_list_len_) {
      const auto& second = widget.conn_list_[i + 1];
      if (second.range_) {
        printf("[%hu, %hu]", first.nid_, second.nid_);
        i++;
        continue;
      }
    }

    printf("%hu", first.nid_);
  }

  // Mixers are always connected to all of the inputs on their connection lists.
  if (widget.caps_.type() != AudioWidgetCaps::Type::MIXER) {
    if (widget.connected_nid_ndx_ < widget.conn_list_len_) {
      printf(" : [*%hu, ndx %u]\n", widget.connected_nid_, widget.connected_nid_ndx_);
    } else {
      printf(" : [*INVALID, ndx %u]\n", widget.connected_nid_ndx_);
    }
  } else {
    printf("\n");
  }
}

#define FMT(fmt) "%s%20s : " fmt, pad
static void ihda_dump_widget(const AudioWidgetState& widget, uint32_t id, uint32_t count) {
  static const char* pad = "+----- ";

  printf("%sWidget %u/%u\n", pad, id, count);
  printf(FMT("%hu\n"), "Node ID", widget.nid_);
  printf(FMT("[%02x] %s\n"), "Type", static_cast<uint32_t>(widget.caps_.type()),
         ToString(widget.caps_.type()));

  printf(FMT("%08x\n"), "Raw Caps", widget.caps_.raw_data_);

  printf(FMT(""), "Flags");
  DUMP_FLAGS(widget.caps_.raw_data_, AW_CAPS_FLAGS, "", "none");

  if (widget.caps_.can_send_unsol()) {
    printf(FMT("%s [tag 0x%02x]\n"), "Unsolicited Ctrl",
           widget.unsol_resp_ctrl_.enabled() ? "enabled" : "disabled",
           widget.unsol_resp_ctrl_.tag());
  }

  printf(FMT(""), "Delay");
  ihda_dump_delay(widget.caps_.delay());

  printf(FMT("%u\n"), "MaxChan", widget.caps_.ch_count());

  if (widget.caps_.input_amp_present()) {
    if (widget.caps_.type() != AudioWidgetCaps::Type::MIXER) {
      printf(FMT(""), "InputAmp");
      Dump(widget.input_amp_caps_, &widget.input_amp_state_);
    } else {
      for (uint8_t i = 0; i < widget.conn_list_len_; ++i) {
        char tag[32];
        snprintf(tag, std::size(tag), "InputAmp[nid %hu]", widget.conn_list_[i].nid_);
        printf(FMT(""), tag);
        Dump(widget.input_amp_caps_, &widget.conn_list_[i].amp_state_);
      }
    }
  }

  if (widget.caps_.output_amp_present()) {
    printf(FMT(""), "OutputAmp");
    Dump(widget.output_amp_caps_, &widget.output_amp_state_);
  }

  if (widget.caps_.format_override()) {
    printf(FMT(""), "PCM Rates");
    DUMP_FLAGS(widget.pcm_size_rate_, PCM_RATE_FLAGS, "", "none");

    printf(FMT(""), "PCM Sizes");
    DUMP_FLAGS(widget.pcm_size_rate_, PCM_SIZE_FLAGS, " bits", "none");

    printf(FMT(""), "PCM Formats");
    DUMP_FLAGS(widget.pcm_formats_, PCM_FMT_FLAGS, "", "none");
  }

  if ((widget.caps_.type() == AudioWidgetCaps::Type::INPUT) ||
      (widget.caps_.type() == AudioWidgetCaps::Type::OUTPUT)) {
    printf(FMT(""), "Cur Format");
    Dump(widget.cur_format_);
    printf(FMT("tag (%u) chan (%u)\n"), "Tag/Chan", widget.stream_tag_, widget.stream_chan_);
  }

  if (widget.caps_.type() == AudioWidgetCaps::Type::PIN_COMPLEX) {
    if (widget.pin_sense_valid_) {
      const char* pstring = widget.pin_sense_.presence_detect() ? "Plugged" : "Unplugged";
      if (widget.caps_.digital()) {
        printf(FMT("%s, ELD %s [raw 0x%08x]\n"), "Pin Sense", pstring,
               widget.pin_sense_.eld_valid() ? "Valid" : "Invalid", widget.pin_sense_.raw_data_);
      } else {
        if (widget.pin_caps_ & AW_PIN_CAPS_FLAG_CAN_IMPEDANCE_SENSE) {
          printf(FMT("%s, Impedance %u [raw 0x%08x]\n"), "Pin Sense", pstring,
                 widget.pin_sense_.impedance(), widget.pin_sense_.raw_data_);
        } else {
          printf(FMT("%s [raw 0x%08x]\n"), "Pin Sense", pstring, widget.pin_sense_.raw_data_);
        }
      }
    }

    printf(FMT(""), "Pin Caps");
    DUMP_FLAGS(widget.pin_caps_, PIN_CAPS_FLAGS, "", "none");
  }

  if (widget.caps_.can_lr_swap())
    printf(FMT("%s\n"), "L/R Swap", widget.eapd_state_.lr_swap() ? "Swapped" : "Normal");

  if (widget.caps_.type() == AudioWidgetCaps::Type::PIN_COMPLEX) {
    if (widget.pin_caps_ & AW_PIN_CAPS_FLAG_CAN_INPUT)
      printf(FMT("%s\n"), "Input", widget.pin_widget_ctrl_.input_enb() ? "Enabled" : "Disabled");

    if (widget.pin_caps_ & AW_PIN_CAPS_FLAG_CAN_OUTPUT)
      printf(FMT("%s\n"), "Output", widget.pin_widget_ctrl_.output_enb() ? "Enabled" : "Disabled");

    if (widget.pin_caps_ & AW_PIN_CAPS_FLAG_CAN_DRIVE_HEADPHONES)
      printf(FMT("%s\n"), "Headphone Amp",
             widget.pin_widget_ctrl_.hp_amp_enb() ? "Enabled" : "Disabled");

    if (!widget.caps_.digital() &&
        (widget.pin_caps_ & (AW_PIN_CAPS_FLAG_VREF_HIZ | AW_PIN_CAPS_FLAG_VREF_50_PERCENT |
                             AW_PIN_CAPS_FLAG_VREF_GROUND | AW_PIN_CAPS_FLAG_VREF_80_PERCENT |
                             AW_PIN_CAPS_FLAG_VREF_100_PERCENT))) {
      const char* tmp;
      switch (widget.pin_widget_ctrl_.vref_enb()) {
        case VRefEn::HiZ:
          tmp = "Hi-Z";
          break;
        case VRefEn::P50:
          tmp = "50%";
          break;
        case VRefEn::Gnd:
          tmp = "Grounded";
          break;
        case VRefEn::P80:
          tmp = "80%";
          break;
        case VRefEn::P100:
          tmp = "100%";
          break;
        default:
          tmp = "Unknown";
          break;
      }
      printf(FMT("%s\n"), "VRef", tmp);
    }

    if (widget.caps_.digital()) {
      const char* tmp;
      switch (widget.pin_widget_ctrl_.ept()) {
        case EPT::Native:
          tmp = "Native";
          break;
        case EPT::HBR:
          tmp = "High Bit Rate";
          break;
        default:
          tmp = "Unknown";
          break;
      }
      printf(FMT("%s\n"), "Encoded Pkt Type", tmp);
    }

    if (widget.pin_caps_ & AW_PIN_CAPS_FLAG_BALANCED_IO)
      printf(FMT("%s\n"), "Balanced Output", widget.eapd_state_.btl() ? "Yes" : "No");

    if (widget.pin_caps_ & AW_PIN_CAPS_FLAG_CAN_EAPD)
      printf(FMT("Powered %s\n"), "External Amp", widget.eapd_state_.eapd() ? "Up" : "Down");

    printf(FMT("0x%08x\n"), "Raw Cfg Defaults", widget.cfg_defaults_.raw_data_);
    Dump(widget.cfg_defaults_);
  }

  if (widget.caps_.has_power_ctl()) {
    printf(FMT(""), "Sup. Pwr States");
    DUMP_FLAGS(widget.power_.supported_states_, POWER_STATE_FLAGS, "", "none");
    printf(FMT("Set %s(%u) Active %s(%u)%s%s%s\n"), "Cur Pwr State",
           PowerStateToString(widget.power_.set_), widget.power_.set_,
           PowerStateToString(widget.power_.active_), widget.power_.active_,
           widget.power_.error_ ? " [ERROR]" : "",
           widget.power_.clock_stop_ok_ ? " [ClkStopOK]" : "",
           widget.power_.settings_reset_ ? " [Settings Reset]" : "");
  }

  if (widget.caps_.has_conn_list()) {
    printf(FMT(""), "ConnList");
    ihda_dump_conn_list(widget);
  }

  if (widget.caps_.proc_widget()) {
    printf(FMT("%s\n"), "Can Bypass Proc", widget.can_bypass_processing_ ? "yes" : "no");
    printf(FMT("%u\n"), "Proc Coefficients", widget.processing_coefficient_count_);
  }

  if (widget.caps_.type() == AudioWidgetCaps::Type::VOLUME_KNOB) {
    printf(FMT("%s\n"), "Vol Knob Type", widget.vol_knob_is_delta_ ? "delta" : "absolute");
    printf(FMT("%u\n"), "Vol Knob Steps", widget.vol_knob_steps_);
  }

  printf("%s\n", pad);
}
#undef FMT

#define FMT(fmt) "%s%26s : " fmt, pad
static void ihda_dump_codec_fn_group(const CodecState& codec, uint32_t id) {
  ZX_DEBUG_ASSERT(codec.fn_groups_ && (id < codec.fn_group_count_) && codec.fn_groups_[id]);
  static const char* pad = "+--- ";
  const auto& fn_group = *codec.fn_groups_[id];

  printf("%sFunction Group %u/%u\n", pad, id + 1, codec.fn_group_count_);
  printf(FMT("%hu\n"), "Node ID", fn_group.nid_);
  printf(FMT("%s\n"), "Type", ToString(fn_group.type_));

  if (fn_group.can_send_unsolicited_) {
    printf(FMT("%s [tag 0x%02x]\n"), "Unsolicited Ctrl",
           fn_group.unsol_resp_ctrl_.enabled() ? "enabled" : "disabled",
           fn_group.unsol_resp_ctrl_.tag());
  }

  if (fn_group.type_ != FunctionGroupState::Type::AUDIO)
    return;

  const auto& afg = *reinterpret_cast<AudioFunctionGroupState*>(codec.fn_groups_[id].get());

  printf(FMT("%08x\n"), "Raw Caps", afg.caps_.raw_data_);
  printf(FMT("%s\n"), "Beep Gen", afg.caps_.has_beep_gen() ? "yes" : "no");

  printf(FMT(""), "Input Path Delay");
  ihda_dump_delay(afg.caps_.path_input_delay());

  printf(FMT(""), "Output Path Delay");
  ihda_dump_delay(afg.caps_.path_output_delay());

  printf(FMT(""), "Default PCM Rates");
  DUMP_FLAGS(afg.default_pcm_size_rate_, PCM_RATE_FLAGS, "", "none");

  printf(FMT(""), "Default PCM Sizes");
  DUMP_FLAGS(afg.default_pcm_size_rate_, PCM_SIZE_FLAGS, " bits", "none");

  printf(FMT(""), "Default PCM Formats");
  DUMP_FLAGS(afg.default_pcm_formats_, PCM_FMT_FLAGS, "", "none");

  printf(FMT(""), "Default Input Amp Caps");
  Dump(afg.default_input_amp_caps_);

  printf(FMT(""), "Default Output Amp Caps");
  Dump(afg.default_output_amp_caps_);

  printf(FMT(""), "Sup. Pwr States");
  DUMP_FLAGS(afg.power_.supported_states_, POWER_STATE_FLAGS, "", "none");
  printf(FMT("Set %s(%u) Active %s(%u)%s%s%s\n"), "Cur Pwr State",
         PowerStateToString(afg.power_.set_), afg.power_.set_,
         PowerStateToString(afg.power_.active_), afg.power_.active_,
         afg.power_.error_ ? " [ERROR]" : "", afg.power_.clock_stop_ok_ ? " [ClkStopOK]" : "",
         afg.power_.settings_reset_ ? " [Settings Reset]" : "");

  printf(FMT("%u\n"), "GPIOs", afg.gpio_count_);
  printf(FMT("%u\n"), "GPIs", afg.gpi_count_);
  printf(FMT("%u\n"), "GPOs", afg.gpo_count_);
  printf(FMT("%s\n"), "GPIOs can wake", afg.gpio_can_wake_ ? "yes" : "no");
  printf(FMT("%s\n"), "GPIOs can send unsolicited", afg.gpio_can_send_unsolicited_ ? "yes" : "no");

  printf(FMT("BMID(%04hx) BSKU(%02x) AssyID(%02x) : Raw 0x%08x\n"), "Impl ID",
         fn_group.impl_id_.BoardMfrID(), fn_group.impl_id_.BoardSKU(),
         fn_group.impl_id_.AssemblyID(), fn_group.impl_id_.raw_data_);

  printf(FMT("%u\n"), "Widgets", afg.widget_count_);

  for (uint32_t i = 0; i < afg.widget_count_; ++i) {
    ZX_DEBUG_ASSERT(afg.widgets_[i]);
    ihda_dump_widget(*afg.widgets_[i], i + 1, afg.widget_count_);
  }
}
#undef FMT
}  // namespace

#define FMT(fmt) "%s%10s : " fmt, pad
void print_codec_state(const CodecState& codec) {
  static const char* pad = "+- ";

  printf(FMT("0x%04hx:0x%04hx\n"), "VID/DID", codec.vendor_id_, codec.device_id_);
  printf(FMT("%u.%u\n"), "Rev", codec.major_rev_, codec.minor_rev_);
  printf(FMT("%u.%u\n"), "Vendor Rev", codec.vendor_rev_id_, codec.vendor_stepping_id_);
  printf("%s%u function group%s\n", pad, codec.fn_group_count_,
         codec.fn_group_count_ == 1 ? "" : "s");

  for (uint32_t i = 0; i < codec.fn_group_count_; ++i)
    ihda_dump_codec_fn_group(codec, i);
}
#undef FMT

}  // namespace intel_hda
}  // namespace audio