xref: /system/dev/audio/usb-audio/usb-audio-stream-interface.cpp

// Copyright 2018 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 <audio-proto-utils/format-utils.h>
#include <fbl/algorithm.h>
#include <fbl/auto_call.h>

#include <utility>

#include "debug-logging.h"
#include "usb-audio-device.h"
#include "usb-audio-path.h"
#include "usb-audio-stream-interface.h"

namespace audio {
namespace usb {

// We use our parent's log prefix
const char* UsbAudioStreamInterface::log_prefix() const {
    return parent_.log_prefix();
}

fbl::unique_ptr<UsbAudioStreamInterface> UsbAudioStreamInterface::Create(
        UsbAudioDevice* parent,
        DescriptorListMemory::Iterator* iter) {
    ZX_DEBUG_ASSERT(parent != nullptr);
    ZX_DEBUG_ASSERT(iter != nullptr);

    auto ihdr = iter->hdr_as<usb_interface_descriptor_t>();
    ZX_DEBUG_ASSERT(ihdr);  // The caller should have already verified this.
    uint8_t iid = ihdr->bInterfaceNumber;

    fbl::AllocChecker ac;
    fbl::unique_ptr<UsbAudioStreamInterface> ret(
            new (&ac) UsbAudioStreamInterface(parent, iter->desc_list(), iid));
    if (ac.check()) {
        zx_status_t res = ret->AddInterface(iter);
        if (res == ZX_OK) {
            return ret;
        }
        LOG_EX(ERROR, *parent,
              "Failed to add initial interface (id %u) to UsbAudioStreamInterface (res %d)\n",
              iid, res);
    } else {
        iter->Next(); // Success or failure, we are expected to consume this header.
        LOG_EX(ERROR, *parent,
               "Out of memory attempting to allocate UsbAudioStreamInterface (id %u)\n", iid);
    }

    return nullptr;
}

zx_status_t UsbAudioStreamInterface::AddInterface(DescriptorListMemory::Iterator* iter) {
    // All of these checks should have been made by the caller already.
    ZX_DEBUG_ASSERT(iter != nullptr);
    ZX_DEBUG_ASSERT(iter->desc_list() == desc_list_);

    auto ihdr = iter->hdr_as<usb_interface_descriptor_t>();
    ZX_DEBUG_ASSERT(ihdr != nullptr);
    ZX_DEBUG_ASSERT(ihdr->bInterfaceNumber == iid());

    // No matter what, we need to consume the current descriptor header.
    iter->Next();

    // Make sure that this header represents a unique alternate setting.
    auto alt_id = ihdr->bAlternateSetting;
    auto fmt_iter = formats_.find_if([alt_id](const Format& fmt) -> bool {
                                        return alt_id == fmt.alt_id();
                                    });
    if (fmt_iter.IsValid() || ((idle_hdr_ && (idle_hdr_->bAlternateSetting == alt_id)))) {
        LOG(WARN,
            "Skipping duplicate alternate setting ID in streaming interface descriptor.  "
            "(iid %u, alt_id %u)\n",
            ihdr->bInterfaceNumber, alt_id);
        // Don't return an error if we encounter a malformed header.  Just skip
        // it and do the best we can with what we have.
        return ZX_OK;
    }

    // Examine the next descriptor.  If it is an audio streaming class specific
    // interface descriptor, then this top level descriptor is part of a
    // described format.  Otherwise, this is an empty alternate interface which
    // is probably meant to be selected when this streaming interface is idle
    // and should not be using any bus resources.
    auto next_hdr = iter->hdr_as<usb_audio_desc_header>();
    if ((next_hdr != nullptr) &&
        (next_hdr->bDescriptorType == USB_AUDIO_CS_INTERFACE) &&
        (next_hdr->bDescriptorSubtype == USB_AUDIO_AS_GENERAL)) {
        auto aud_hdr = iter->hdr_as<usb_audio_as_header_desc>();
        iter->Next();

        if (aud_hdr == nullptr) {
            LOG(WARN,
                "Skipping badly formed alternate setting ID in streaming interface descriptor "
                "(iid %u, alt_id %u).\n",
                ihdr->bInterfaceNumber, alt_id);
            return ZX_OK;
        }

        fbl::AllocChecker ac;
        auto format = fbl::make_unique_checked<Format>(&ac, this, iter->desc_list(), ihdr, aud_hdr);
        if (!ac.check()) {
            LOG(ERROR, "Out of memory attempt to add Format to StreamInterface\n");
            return ZX_ERR_NO_MEMORY;
        }

        zx_status_t status = format->Init(iter);
        if (status != ZX_OK) {
            LOG(WARN,
                "Skipping bad format streaming interface descriptor.  (iid %u, alt_id %u)\n",
                ihdr->bInterfaceNumber, alt_id);
            return ZX_OK;
        }

        // Make sure that the endpoint address and terminal link ID of this
        // format matches all previously encountered formats.
        //
        // TODO(johngro) : It is unclear whether or not it makes any sense to
        // have formats which link to different audio paths or have different
        // endpoint addresses (implying potentially different directions).  For
        // now we simply skip these formats if we encounter them.
        //
        // If we ever encounter a device which has a mix of these parameters, we
        // need come back and determine if there is a good generic approach for
        // dealing with the situation.
        if (!formats_.is_empty()) {
            if (format->term_link() != term_link_) {
                LOG(WARN,
                    "Skipping format (iid %u, alt_id %u) with non-uniform terminal ID "
                    "(expected %u, got %u)\n",
                    ihdr->bInterfaceNumber, alt_id, term_link_, format->term_link());
                return ZX_OK;
            }

            if ((format->ep_addr() != ep_addr_) || (format->ep_attr() != ep_attr_)) {
                LOG(ERROR,
                    "Skipping format (iid %u, alt_id %u) with non-uniform endpoint "
                    "address/attributes (expected 0x%02x/0x%02x, got 0x%02x/0x%02x)\n",
                    ihdr->bInterfaceNumber, alt_id,
                    ep_addr_, ep_attr_,
                    format->ep_addr(), format->ep_attr());
                return ZX_OK;
            }
        } else {
            term_link_ = format->term_link();
            ep_addr_   = format->ep_addr();
            ep_attr_   = format->ep_attr();
        }

        max_req_size_ = fbl::max(max_req_size_, format->max_req_size());
        formats_.push_back(std::move(format));
    } else {
        if (idle_hdr_ == nullptr) {
            idle_hdr_ = ihdr;
        } else {
            LOG(WARN,
                "Skipping duplicate \"idle\" interface descriptor in streaming interface "
                "descriptor.  (iid %u, alt_id %u)\n",
                ihdr->bInterfaceNumber, ihdr->bAlternateSetting);
        }
    }

    return ZX_OK;
}

zx_status_t UsbAudioStreamInterface::BuildFormatMap() {
    if (format_map_.size()) {
        LOG(WARN, "Attempted to re-build format map for streaming interface (iid %u)\n", iid());
        return ZX_ERR_BAD_STATE;
    }

    // Make a pass over our list of formats and figure out how big our format
    // map vector may need to be.
    //
    // Note: this is a rough worst case bound on how big the vector needs to be.
    // Someday, we could come back here and compute a much tighter bound if we
    // wanted to.
    size_t worst_case_map_entries = 0;
    for (const auto& fmt : formats_) {
        // A frame rate count of 0 indicates a continuous format range which
        // requires only one format range entry.
        worst_case_map_entries += fmt.frame_rate_cnt() ? fmt.frame_rate_cnt() : 1;
    }

    // Now reserve our memory.
    fbl::AllocChecker ac;
    format_map_.reserve(worst_case_map_entries, &ac);
    if (!ac.check()) {
        LOG(ERROR, "Out of memory attempting to reserve %zu format ranges\n",
            worst_case_map_entries);
        return ZX_ERR_NO_MEMORY;
    }

    // Now iterate over our set and build the map.
    for (const auto& fmt : formats_) {
        // Record the min/max number of channels.
        audio_stream_format_range_t range;
        range.min_channels = fmt.ch_count();
        range.max_channels = fmt.ch_count();

        // Encode the sample container type from the type I format descriptor
        // as an audio device driver audio_sample_format_t.  If we encounter
        // anything that we don't know how to encode, log a warning and skip the
        // format.
        //
        auto tag = fmt.format_tag();
        if (tag == USB_AUDIO_AS_FT_PCM8) {
            if ((fmt.bit_resolution() != 8) || (fmt.subframe_bytes() != 1)) {
                LOG(WARN, "Skipping PCM8 format with invalid bit res/subframe size (%u/%u)\n",
                    fmt.bit_resolution(), fmt.subframe_bytes());
                continue;
            }
            range.sample_formats = static_cast<audio_sample_format_t>(
                    AUDIO_SAMPLE_FORMAT_8BIT | AUDIO_SAMPLE_FORMAT_FLAG_UNSIGNED);
        } else
        if (tag == USB_AUDIO_AS_FT_IEEE_FLOAT) {
            if ((fmt.bit_resolution() != 32) || (fmt.subframe_bytes() != 4)) {
                LOG(WARN, "Skipping IEEE_FLOAT format with invalid bit res/subframe size (%u/%u)\n",
                    fmt.bit_resolution(), fmt.subframe_bytes());
                continue;
            }
            range.sample_formats = AUDIO_SAMPLE_FORMAT_32BIT_FLOAT;
        } else
        if (tag == USB_AUDIO_AS_FT_PCM) {
            switch (fmt.bit_resolution()) {
            case 8:
            case 16:
            case 32: {
                if (fmt.subframe_bytes() != (fmt.bit_resolution() >> 3)) {
                    LOG(WARN,
                        "Skipping PCM format.  Subframe size (%u bytes) does not "
                        "match Bit Res (%u bits)\n",
                        fmt.bit_resolution(),
                        fmt.subframe_bytes());
                    continue;
                }
                switch (fmt.bit_resolution()) {
                case 8:  range.sample_formats = AUDIO_SAMPLE_FORMAT_8BIT; break;
                case 16: range.sample_formats = AUDIO_SAMPLE_FORMAT_16BIT; break;
                case 32: range.sample_formats = AUDIO_SAMPLE_FORMAT_32BIT; break;
                }
            } break;

            case 20:
            case 24: {
                if ((fmt.subframe_bytes() != 3) && (fmt.subframe_bytes() != 4)) {
                    LOG(WARN,
                        "Skipping PCM format.  %u-bit audio must be packed into a 3 "
                        "or 4 byte subframe (Subframe size %u)\n",
                        fmt.bit_resolution(),
                        fmt.subframe_bytes());
                    continue;
                }
                switch (fmt.bit_resolution()) {
                case 20:
                    range.sample_formats = ((fmt.subframe_bytes() == 3)
                                            ? AUDIO_SAMPLE_FORMAT_20BIT_PACKED
                                            : AUDIO_SAMPLE_FORMAT_20BIT_IN32);
                    break;
                case 24:
                    range.sample_formats = ((fmt.subframe_bytes() == 3)
                                            ? AUDIO_SAMPLE_FORMAT_24BIT_PACKED
                                            : AUDIO_SAMPLE_FORMAT_24BIT_IN32);
                    break;
                }
            } break;

            default:
                LOG(WARN, "Skipping PCM format with unsupported bit res (%u bits)\n",
                    fmt.bit_resolution());
                continue;
            }
        } else {
            LOG(WARN, "Skipping unsupported format tag (%u)\n", tag);
            continue;
        }

        // Now pack the supported frame rates.  A format with a frame rate count of
        // 0 is a continuous range of frame rates.  Otherwise, we pack each discrete
        // frame rate as an individual entry.
        //
        // TODO(johngro) : Discrete frame rates could be encoded more compactly
        // if wanted to do so by extracting all of the 48k and 44.1k rates into
        // a bitmask, and then putting together ranges which represented
        // continuous runs of frame rates in each of the families.
        if (fmt.frame_rate_cnt()) {
            for (uint8_t i = 0; i < fmt.frame_rate_cnt(); ++i) {
                uint32_t rate = fmt.frame_rate(i);
                range.min_frames_per_second = rate;
                range.max_frames_per_second = rate;

                if (audio::utils::FrameRateIn48kFamily(rate)) {
                    range.flags = ASF_RANGE_FLAG_FPS_48000_FAMILY;
                } else
                if (audio::utils::FrameRateIn441kFamily(rate)) {
                    range.flags = ASF_RANGE_FLAG_FPS_44100_FAMILY;
                } else {
                    range.flags = ASF_RANGE_FLAG_FPS_CONTINUOUS;
                }

                format_map_.push_back({ range, fmt.alt_id(), fmt.ep_addr(), fmt.max_req_size() });
            }
        } else {
            range.min_frames_per_second = fmt.min_cont_frame_rate();
            range.max_frames_per_second = fmt.max_cont_frame_rate();
            range.flags = ASF_RANGE_FLAG_FPS_CONTINUOUS;
            format_map_.push_back({ range, fmt.alt_id(), fmt.ep_addr(), fmt.max_req_size() });
        }
    }

    // If we failed to encode *any* valid format ranges, log a warning and
    // return an error.  This stream interface is not going to be useful to us.
    if (format_map_.is_empty()) {
        LOG(WARN, "Failed to find any usable formats for streaming interface (iid %u)\n", iid());
        return ZX_ERR_NOT_SUPPORTED;
    }

    return ZX_OK;
}

zx_status_t UsbAudioStreamInterface::LookupFormat(uint32_t frames_per_second,
                                                  uint16_t channels,
                                                  audio_sample_format_t sample_format,
                                                  size_t* out_format_ndx) {
    if (out_format_ndx == nullptr) {
        return ZX_ERR_INVALID_ARGS;
    }

    *out_format_ndx = format_map_.size();

    // Search our format map to find the alternate interface setting which
    // supports the requested format.
    for (size_t i = 0; i < format_map_.size(); ++i) {
        if (audio::utils::FormatIsCompatible(frames_per_second,
                                             channels,
                                             sample_format,
                                             format_map_[i].range_)) {
            *out_format_ndx = i;
            return ZX_OK;
        }
    }

    return ZX_ERR_NOT_SUPPORTED;
}

zx_status_t UsbAudioStreamInterface::ActivateFormat(size_t ndx, uint32_t frames_per_second) {
    if (ndx >= format_map_.size()) {
        return ZX_ERR_INVALID_ARGS;
    }

    // Select the interface used for this format, then configure the endpoint
    // for the requested frame rate.  user know what the maximum request size is
    // for this interface.
    zx_status_t status;
    const auto& f = format_map_[ndx];
    status = usb_set_interface(&parent_.usb_proto(), iid(), f.alt_id_);
    if (status != ZX_OK) {
        LOG(ERROR,
            "Failed to select interface (id %u, alt %u, ep %u) "
            "when configuring format ndx %zu (status %d)\n",
            iid(), f.alt_id_, f.ep_addr_, ndx, status);
        return status;
    }

    // Do not attempt to set the sample rate if the endpoint supports
    // only one.  In theory, devices should ignore this request, but in
    // practice, some devices will refuse the command entirely, and we
    // will get ZX_ERR_IO_REFUSED back from the bus driver.
    //
    // Note: This method of determining whether or not an endpoint
    // supports only a single rate only works here because we currently
    // demand that all of our formats share a single endpoint address.
    // If this changes in the future, this heuristic will need to be
    // revisited.
    bool single_rate = (format_map_.size() == 1) &&
                      !(format_map_[0].range_.flags & ASF_RANGE_FLAG_FPS_CONTINUOUS);
    if (!single_rate) {
        // See section 5.2.3.2.3.1 of the USB Audio 1.0 spec.
        uint8_t buffer[3];
        buffer[0] = static_cast<uint8_t>(frames_per_second);
        buffer[1] = static_cast<uint8_t>(frames_per_second >> 8);
        buffer[2] = static_cast<uint8_t>(frames_per_second >> 16);
        status = usb_control_out(&parent_.usb_proto(),
                             USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
                             USB_AUDIO_SET_CUR,
                             USB_AUDIO_SAMPLING_FREQ_CONTROL << 8,
                             f.ep_addr_, ZX_TIME_INFINITE,
                             &buffer, sizeof(buffer));
        if (status != ZX_OK) {
            if (status == ZX_ERR_IO_REFUSED || status == ZX_ERR_IO_INVALID) {
                // clear the stall/error
                usb_reset_endpoint(&parent_.usb_proto(), f.ep_addr_);
            }

            LOG(ERROR, "Failed to set frame rate %u for ep address %u (status %d)\n",
                frames_per_second, f.ep_addr_, status);

            return status;
        }
    }

    return ZX_OK;
}

zx_status_t UsbAudioStreamInterface::ActivateIdleFormat() {
    if (idle_hdr_ == nullptr) {
        return ZX_ERR_NOT_SUPPORTED;
    }

    ZX_DEBUG_ASSERT(idle_hdr_->bInterfaceNumber == iid());
    return usb_set_interface(&parent_.usb_proto(), iid(), idle_hdr_->bAlternateSetting);
}

void UsbAudioStreamInterface::LinkPath(fbl::unique_ptr<AudioPath> path) {
    ZX_DEBUG_ASSERT(path != nullptr);
    ZX_DEBUG_ASSERT(path_ == nullptr);
    ZX_DEBUG_ASSERT(direction() == path->direction());
    ZX_DEBUG_ASSERT(term_link() == path->stream_terminal().id());
    path_ = std::move(path);
}

zx_status_t UsbAudioStreamInterface::Format::Init(DescriptorListMemory::Iterator* iter) {
    ZX_DEBUG_ASSERT(iter != nullptr);
    ZX_DEBUG_ASSERT(iter->desc_list() == desc_list_);

    // Skip formats tags that we currently do not support or know how to deal
    // with.  Right now, we only deal with the linear PCM forms of Type I audio
    // formats.
    switch (class_hdr_->wFormatTag) {
    case USB_AUDIO_AS_FT_PCM:
    case USB_AUDIO_AS_FT_PCM8:
    case USB_AUDIO_AS_FT_IEEE_FLOAT:
        break;

    default:
        LOG(ERROR,
            "Unsupported format tag (0x%04hx) in class specific audio stream interface "
            "(iid %u, alt_id %u)\n",
            class_hdr_->wFormatTag, interface_hdr_->bInterfaceNumber, alt_id());
        return ZX_ERR_NOT_SUPPORTED;
    }

    // Next go looking for the other headers we will need in order to operate.
    // In specific, we need to find an audio format descriptor (specifically a
    // Type I descriptor), a general USB Endpoint descriptor, and a audio class
    // specific endpoint descriptor.
    //
    // If we encounter something which is not one of these things, then we have
    // run out of headers to parse.
    //
    // If we encounter duplicates of these descriptors, or we encounter
    // something clearly incompatible (such as a type II or type III format
    // descriptor), then we are confused and this interface should be ignored.
    // Be sure to skip headers like this if we return from the middle of the
    // do/while loop below.
    auto cleanup = fbl::MakeAutoCall([iter]() { iter->Next(); });
    do {
        auto hdr = iter->hdr();
        if (hdr == nullptr) {
            break;
        }

        if (hdr->bDescriptorType == USB_AUDIO_CS_INTERFACE) {
            // Stop parsing if this is not an audio format type descriptor
            auto ihdr = iter->hdr_as<usb_audio_desc_header>();
            if ((ihdr == nullptr) || (ihdr->bDescriptorSubtype != USB_AUDIO_AS_FORMAT_TYPE)) {
                break;
            }

            auto fmt_hdr = iter->hdr_as<usb_audio_as_format_type_hdr>();
            if (fmt_hdr == nullptr) {
                break;
            }

            if (fmt_hdr->bFormatType != USB_AUDIO_FORMAT_TYPE_I) {
                LOG(ERROR,
                    "Unsupported format type (%u) in class specific audio stream format type "
                    "interface (iid %u, alt_id %u)\n",
                    fmt_hdr->bFormatType, interface_hdr_->bInterfaceNumber, alt_id());
                return ZX_ERR_NOT_SUPPORTED;
            }

            auto fmt_desc = iter->hdr_as<usb_audio_as_format_type_i_desc>();
            if ((fmt_desc_ != nullptr) || (fmt_desc == nullptr)) {
                LOG(ERROR,
                    "Malformed or duplicate type 1 format type descriptor in class specific audio "
                    "interface (iid %u, alt_id %u)\n",
                    interface_hdr_->bInterfaceNumber, alt_id());
                return ZX_ERR_NOT_SUPPORTED;
            }

            // Stash the pointer, we'll sanity check a bit more once we are finished finding
            // headers.
            fmt_desc_ = fmt_desc;
        } else
        if (hdr->bDescriptorType == USB_DT_ENDPOINT) {
            auto ep_desc = iter->hdr_as<usb_endpoint_descriptor_t>();
            if (ep_desc == nullptr) {
                LOG(ERROR,
                    "Malformed standard endpoint descriptor in class specific audio interface "
                    "(iid %u, alt_id %u)\n",
                    interface_hdr_->bInterfaceNumber, alt_id());
                return ZX_ERR_NOT_SUPPORTED;
            }

            // TODO(johngro): Come back and fix this.  There are devices with
            // multiple isochronous endpoints per format interface.  Device
            // which use an isochronous output endpoint with an Asynchronous
            // sync type seem to have an isochronous input endpoint as well
            // which is probably used for clock recovery.  Instead of
            // skipping/ignoring this endpoint, we really should be using it to
            // recover the device clock.
            if (ep_desc_ != nullptr) {
                LOG(WARN,
                    "Skipping duplicate standard endpoint descriptor in class specific audio "
                    "interface (iid %u, alt_id %u, ep_addr %u)\n",
                    interface_hdr_->bInterfaceNumber, alt_id(), ep_desc->bEndpointAddress);
            } else {
                if ((usb_ep_type(ep_desc) != USB_ENDPOINT_ISOCHRONOUS) ||
                    (usb_ep_sync_type(ep_desc) == USB_ENDPOINT_NO_SYNCHRONIZATION)) {
                    LOG(WARN,
                        "Skipping endpoint descriptor with unsupported attributes "
                        "interface (iid %u, alt_id %u, ep_attr 0x%02x)\n",
                        interface_hdr_->bInterfaceNumber, alt_id(), ep_desc->bmAttributes);
                } else {
                    ep_desc_ = ep_desc;
                }
            }
        } else
        if (hdr->bDescriptorType == USB_AUDIO_CS_ENDPOINT) {
            // Stop parsing if this is not a class specific AS isochronous endpoint descriptor
            auto ihdr = iter->hdr_as<usb_audio_desc_header>();
            if ((ihdr == nullptr) || (ihdr->bDescriptorSubtype != USB_AUDIO_EP_GENERAL)) {
                break;
            }

            auto class_ep_desc = iter->hdr_as<usb_audio_as_isoch_ep_desc>();
            if (class_ep_desc == nullptr) {
                LOG(ERROR,
                    "Malformed or class specific endpoint descriptor in class specific audio "
                    "interface (iid %u, alt_id %u)\n",
                    interface_hdr_->bInterfaceNumber, alt_id());
                return ZX_ERR_NOT_SUPPORTED;
            }

            if (class_ep_desc_ != nullptr) {
                LOG(WARN,
                    "Skipping duplicate class specific endpoint descriptor in class specific "
                    "audio interface (iid %u, alt_id %u\n",
                    interface_hdr_->bInterfaceNumber, alt_id());
            } else {
                class_ep_desc_ = class_ep_desc;
            }
        } else {
            // We don't recognize this descriptor, so we have run out of
            // descriptors that we beleive belong to this format.  Move on to
            // sanity checks.
            break;
        }
    } while (iter->Next());
    cleanup.cancel();

    // Sanity check what we have found so far.  Right now, we need to have found...
    //
    // 1) A Type I audio format type descriptor (PCM)
    // 2) A standard Isochronous USB endpoint descriptor.
    // 3) An audio class specific endpoint descriptor.
    //
    // In addition, we need to make sure that the range of frame rates present
    // in the Type I descriptor makes sense.  If the range is continuous, the
    // array must contain *exactly* 2 entries.  If the range is discrete, then
    // the array must contain an integer number of entries, and must contain at
    // least one entry.
    if ((fmt_desc_ == nullptr) || (ep_desc_ == nullptr) || (class_ep_desc_ == nullptr)) {
        LOG(ERROR,
            "Missing one or more required descriptors in audio interface (iid %u, alt_id %u); "
            "Missing%s%s%s\n",
            interface_hdr_->bInterfaceNumber, alt_id(),
            (fmt_desc_ == nullptr) ? " [Type I Format Type Descriptor]" : "",
            (ep_desc_ == nullptr) ? " [Standard Endpoint Descriptor]" : "",
            (class_ep_desc_  == nullptr) ? " [Class Endpoint Descriptor]" : "");
        return ZX_ERR_NOT_SUPPORTED;
    }

    // hdr_as<> should have already verified this for us.
    ZX_DEBUG_ASSERT(fmt_desc_->bLength >= sizeof(*fmt_desc_));

    // Sanity check the size of the frame rate table.
    size_t expected_bytes = (frame_rate_cnt() ? frame_rate_cnt() : 2)
                          * sizeof(usb_audio_as_samp_freq);
    size_t extra_bytes = fmt_desc_->bLength - sizeof(*fmt_desc_);
    if (expected_bytes != extra_bytes) {
        LOG(ERROR,
            "Bad frame rate table size in type 1 audio format type descriptor in audio interface "
            "(iid %u, alt_id %u).  Expected %zu, Got %zu\n",
            interface_hdr_->bInterfaceNumber, alt_id(), expected_bytes, extra_bytes);
        return ZX_ERR_INTERNAL;
    }

    // If this is a continuous range of frame rates, then the min/max order needs to be correct.
    if ((frame_rate_cnt() == 0) && (min_cont_frame_rate() > max_cont_frame_rate())) {
        LOG(ERROR,
            "Invalid continuous frame rate range [%u, %u] type 1 audio format type descriptor in "
            "audio interface (iid %u, alt_id %u).\n",
            min_cont_frame_rate(), max_cont_frame_rate(),
            interface_hdr_->bInterfaceNumber, alt_id());
        return ZX_ERR_INTERNAL;
    }

    return ZX_OK;
}

}  // namespace usb
}  // namespace audio