| // 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 <fbl/algorithm.h> |
| #include <limits> |
| #include <math.h> |
| #include <utility> |
| |
| #include "debug-logging.h" |
| #include "usb-audio-units.h" |
| |
| namespace audio { |
| namespace usb { |
| |
| // a small internal helper methods which handles a bunch of ugly casting for us. |
| template <typename T, typename U> |
| static inline const T* offset_ptr(const U* p, size_t offset) { |
| return ((offset + sizeof(T)) <= p->bLength) |
| ? reinterpret_cast<const T*>(reinterpret_cast<uintptr_t>(p) + offset) |
| : nullptr; |
| } |
| |
| const char* AudioUnit::type_name() const { |
| switch (type()) { |
| case Type::InputTerminal: return "InputTerminal"; |
| case Type::OutputTerminal: return "OutputTerminal"; |
| case Type::MixerUnit: return "MixerUnit"; |
| case Type::SelectorUnit: return "SelectorUnit"; |
| case Type::FeatureUnit: return "FeatureUnit"; |
| case Type::ProcessingUnit: return "ProcessingUnit"; |
| case Type::ExtensionUnit: return "ExtensionUnit"; |
| default: return "<Unknown>"; |
| } |
| } |
| |
| fbl::RefPtr<AudioUnit> AudioUnit::Create(const DescriptorListMemory::Iterator& iter, uint8_t iid) { |
| auto hdr = iter.hdr_as<usb_audio_desc_header>(); |
| |
| // This should already have been verified by the code calling us. |
| ZX_DEBUG_ASSERT(hdr != nullptr); |
| |
| switch (hdr->bDescriptorSubtype) { |
| case USB_AUDIO_AC_INPUT_TERMINAL: return InputTerminal::Create(iter, iid); |
| case USB_AUDIO_AC_OUTPUT_TERMINAL: return OutputTerminal::Create(iter, iid); |
| case USB_AUDIO_AC_MIXER_UNIT: return MixerUnit::Create(iter, iid); |
| case USB_AUDIO_AC_SELECTOR_UNIT: return SelectorUnit::Create(iter, iid); |
| case USB_AUDIO_AC_FEATURE_UNIT: return FeatureUnit::Create(iter, iid); |
| case USB_AUDIO_AC_PROCESSING_UNIT: return ProcessingUnit::Create(iter, iid); |
| case USB_AUDIO_AC_EXTENSION_UNIT: return ExtensionUnit::Create(iter, iid); |
| default: |
| GLOBAL_LOG(WARN, "Unrecognized audio control descriptor (type %u) @ offset %zu\n", |
| hdr->bDescriptorSubtype, iter.offset()); |
| return nullptr; |
| } |
| } |
| |
| zx_status_t AudioUnit::CtrlReq(const usb_protocol_t& proto, |
| uint8_t code, uint16_t val, uint16_t len, void* data) { |
| if (!len || (data == nullptr)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| // For audio class specific control codes, get control codes all have their MSB set. |
| uint8_t req_type = (code & 0x80) |
| ? USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE |
| : USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE; |
| |
| // TODO(johngro) : See about fixing the use of const in the C API for the |
| // USB bus protocol. There is no good reason why a usb_protocol structure |
| // should need to be mutable when performing operations such as usb_control. |
| auto proto_ptr = const_cast<usb_protocol_t*>(&proto); |
| |
| // TODO(johngro) : Do better than this if we can. |
| // |
| // None of these control transactions should every take any |
| // significant amount of time, and if the turn out to do so, then we really |
| // need to find a way to use the USB bus driver in an asynchronous fashion. |
| // Even 500 mSec is just *way* too long to ever block a driver thread, for |
| // pretty much any reason. Right now, this timeout is here only for safety |
| // reasons; it would be better to timeout after a half of a second then to |
| // block the entire USB device forever. |
| // |
| // It is tempting to simply kill the driver/process if we ever timeout on |
| // one of these operations, but at time this code was written, that would |
| // kill the entire USB bus driver. So, for now, we eat the timeout and rely |
| // on the code above us taking some action to shut this device down. |
| constexpr uint64_t kRelativeTimeout = ZX_MSEC(500); |
| size_t done = 0; |
| zx_status_t status; |
| if ((req_type & USB_DIR_MASK) == USB_DIR_OUT) { |
| status = usb_control_out(proto_ptr, req_type, code, val, index(), |
| zx_deadline_after(kRelativeTimeout), data, len); |
| done = len; |
| } else { |
| status = usb_control_in(proto_ptr, req_type, code, val, index(), |
| zx_deadline_after(kRelativeTimeout), data, len, &done); |
| } |
| if ((status == ZX_OK) && (done != len)) { |
| status = ZX_ERR_BUFFER_TOO_SMALL; |
| } |
| |
| if (status != ZX_OK) { |
| GLOBAL_LOG(WARN, |
| "WARNING: Audio control request failed! Unit (%s:id %u), " |
| "code 0x%02x val 0x%04hx, ndx 0x%04x [bytes expected %u, got %zu] (status %d)\n", |
| type_name(), id(), code, val, index(), len, done, status); |
| } |
| |
| return status; |
| } |
| |
| fbl::RefPtr<InputTerminal> InputTerminal::Create(const DescriptorListMemory::Iterator& iter, |
| uint8_t iid) { |
| auto hdr = iter.hdr_as<usb_audio_ac_input_terminal_desc>(); |
| |
| if (hdr == nullptr) { |
| GLOBAL_LOG(WARN, "InputTerminal header appears invalid @ offset %zu\n", iter.offset()); |
| return nullptr; |
| } |
| |
| // TODO(johngro): additional sanity checking and pre-processing goes here. |
| |
| fbl::AllocChecker ac; |
| auto ret = fbl::AdoptRef(new (&ac) InputTerminal(iter.desc_list(), hdr, iid)); |
| return ac.check() ? ret : nullptr; |
| } |
| |
| fbl::RefPtr<OutputTerminal> OutputTerminal::Create(const DescriptorListMemory::Iterator& iter, |
| uint8_t iid) { |
| auto hdr = iter.hdr_as<usb_audio_ac_output_terminal_desc>(); |
| |
| if (hdr == nullptr) { |
| GLOBAL_LOG(WARN, "OutputTerminal header appears invalid @ offset %zu\n", iter.offset()); |
| return nullptr; |
| } |
| |
| // TODO(johngro): additional sanity checking and pre-processing goes here. |
| |
| fbl::AllocChecker ac; |
| auto ret = fbl::AdoptRef(new (&ac) OutputTerminal(iter.desc_list(), hdr, iid)); |
| return ac.check() ? ret : nullptr; |
| } |
| |
| fbl::RefPtr<MixerUnit> MixerUnit::Create(const DescriptorListMemory::Iterator& iter, uint8_t iid) { |
| // Find the size of each of the inlined variable length arrays in this |
| // structure, finding the locations of the constant headers in the process. |
| // If anything does not look right, complain and move on. |
| auto hdr0 = iter.hdr_as<usb_audio_ac_mixer_unit_desc_0>(); |
| if (hdr0 != nullptr) { |
| size_t off = sizeof(*hdr0) + hdr0->bNrInPins; |
| auto hdr1 = offset_ptr<usb_audio_ac_mixer_unit_desc_1>(hdr0, off); |
| if (hdr1 != nullptr) { |
| // Determining the size of bmControls is a bit of a pain. To do so, |
| // we need to know 'n', which is the sum the number of channels |
| // across all of the input pins, and 'm' (which should be |
| // hdr1->bNrChannels). At this stage of parsing our unit/terminal |
| // graph, we may not have access to all of the sources which might |
| // feed into the calculation of 'n'. Because of this, for now, just |
| // assume that the size of bmControls (in bytes) is equal to the |
| // space remaining in the descriptor, demanding that this be at |
| // least equal to a single byte (if it was zero, it means that we |
| // either have no input or no output channels, neither of which |
| // makes sense). |
| if (sizeof(usb_audio_ac_mixer_unit_desc_2) < hdr0->bLength) { |
| size_t off2 = hdr0->bLength - sizeof(usb_audio_ac_mixer_unit_desc_2); |
| if (off2 > off) { |
| auto hdr2 = offset_ptr<usb_audio_ac_mixer_unit_desc_2>(hdr0, off2); |
| ZX_DEBUG_ASSERT(hdr2 != nullptr); |
| |
| // TODO(johngro): additional sanity checking and pre-processing goes here. |
| fbl::AllocChecker ac; |
| auto ret = fbl::AdoptRef( |
| new (&ac) MixerUnit(iter.desc_list(), hdr0, hdr1, hdr2, iid)); |
| return ac.check() ? ret : nullptr; |
| } |
| } |
| } |
| } |
| |
| GLOBAL_LOG(WARN, "MixerUnit header appears invalid @ offset %zu\n", iter.offset()); |
| return nullptr; |
| } |
| |
| fbl::RefPtr<SelectorUnit> SelectorUnit::Create(const DescriptorListMemory::Iterator& iter, |
| uint8_t iid) { |
| // Find the size of each of the inlined variable length arrays in this |
| // structure, finding the locations of the constant headers in the process. |
| // If anything does not look right, complain and move on. |
| auto hdr0 = iter.hdr_as<usb_audio_ac_selector_unit_desc_0>(); |
| if (hdr0 != nullptr) { |
| size_t off = sizeof(*hdr0) + hdr0->bNrInPins; |
| auto hdr1 = offset_ptr<usb_audio_ac_selector_unit_desc_1>(hdr0, off); |
| if (hdr1 != nullptr) { |
| // TODO(johngro): additional sanity checking and pre-processing goes here. |
| fbl::AllocChecker ac; |
| auto ret = fbl::AdoptRef(new (&ac) SelectorUnit(iter.desc_list(), hdr0, hdr1, iid)); |
| return ac.check() ? ret : nullptr; |
| } |
| } |
| |
| GLOBAL_LOG(WARN, "SelectorUnit header appears invalid @ offset %zu\n", iter.offset()); |
| return nullptr; |
| } |
| |
| zx_status_t SelectorUnit::Select(const usb_protocol_t& proto, uint8_t upstream_id) { |
| // Section 5.2.2.3.3. defines the selector index as being 1s indexed, so |
| // zero is an easy to use "invalid" value. |
| uint8_t ndx = 0; |
| |
| // Find the appropriate index or return an error trying. |
| uint32_t cnt = source_count(); |
| for (uint32_t i = 0; i < cnt; ++i) { |
| if (upstream_id == source_id(i)) { |
| ndx = static_cast<uint8_t>(i + 1); |
| break; |
| } |
| } |
| |
| if (!ndx) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| // Now go ahead and set the value; |
| return CtrlReq(proto, USB_AUDIO_SET_CUR, 0, &ndx); |
| } |
| |
| fbl::RefPtr<FeatureUnit> FeatureUnit::Create(const DescriptorListMemory::Iterator& iter, |
| uint8_t iid) { |
| // Find the size of each of the inlined variable length arrays in this |
| // structure, finding the locations of the constant headers in the process. |
| // If anything does not look right, complain and move on. |
| auto hdr0 = iter.hdr_as<usb_audio_ac_feature_unit_desc_0>(); |
| if (hdr0 != nullptr) { |
| // The exact expected size of the Controls bitmap depends on the number |
| // of channels feeding this feature unit. This information is not |
| // contained in the feature unit itself, but instead exists upstream of |
| // the unit in first unit/terminal which contains a channel cluster |
| // element. At this point in parsing, we have not discovered all of the |
| // units present in the audio control interface yet, so we cannot trace |
| // upstream to sanity check the size of this field. |
| // |
| // For now, we perform the most basic check we can by assuming that the |
| // size of the Controls bitmap must be... |
| // |
| // 1) Non-zero, and... |
| // 2) Divisible by bControlSize, which must also be non-zero. |
| // |
| // In the future, more stringent checks can be applied during Probe. |
| constexpr size_t kHdrOverhead = sizeof(*hdr0) + sizeof(usb_audio_ac_feature_unit_desc_1); |
| size_t ctrl_array_bytes = hdr0->bLength - kHdrOverhead; |
| if ((kHdrOverhead < hdr0->bLength) && |
| (hdr0->bControlSize > 0) && |
| (!(ctrl_array_bytes % hdr0->bControlSize))) { |
| // Allocate memory for our Features capability array. |
| fbl::AllocChecker ac; |
| size_t feat_len = ctrl_array_bytes / hdr0->bControlSize; |
| auto feat_mem = fbl::unique_ptr<Features[]>(new (&ac) Features[feat_len]); |
| |
| if (ac.check()) { |
| // We just made sure that this fits, there should be no way for us |
| // to have run out of data. |
| size_t off = hdr0->bLength - sizeof(usb_audio_ac_feature_unit_desc_1); |
| auto hdr1 = offset_ptr<usb_audio_ac_feature_unit_desc_1>(hdr0, off); |
| ZX_DEBUG_ASSERT(hdr1 != nullptr); |
| |
| auto ret = fbl::AdoptRef(new (&ac) FeatureUnit(iter.desc_list(), |
| hdr0, hdr1, |
| std::move(feat_mem), feat_len, |
| iid)); |
| if (ac.check()) { |
| return ret; |
| } |
| } |
| |
| GLOBAL_LOG(WARN, "Out of memory attempting to allocate FeatureUnit @ offset %zu\n", |
| iter.offset()); |
| return nullptr; |
| } |
| } |
| |
| GLOBAL_LOG(WARN, "FeatureUnit header appears invalid @ offset %zu\n", iter.offset()); |
| return nullptr; |
| } |
| |
| zx_status_t FeatureUnit::Probe(const usb_protocol_t& proto) { |
| zx_status_t res; |
| |
| // Start by going over our channel feature bitmap and extracting the actual |
| // feature bits for each channel. Right now, we demand that the size of |
| // each entry be (at most) a 32 bit integer. The USB Audio 1.0 Spec only |
| // defines bits up to bit 9, so we really only understand how to handle up |
| // to there. If we cannot fit each of the bitmap entries in a 32-bit |
| // integer, then the USB audio spec has come a long way and someone should |
| // come back here and update this driver. |
| ZX_DEBUG_ASSERT(feature_desc()->bControlSize != 0); // Create should have checked this already |
| if (feature_desc()->bControlSize > sizeof(uint32_t)) { |
| GLOBAL_LOG(WARN, "FeatureUnit id %u has unsupported bControlSize > %zu (%u)\n", |
| id(), sizeof(uint32_t), feature_desc()->bControlSize); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| for (size_t i = 0; i < features_.size(); ++i) { |
| auto& f = features_[i]; |
| f.supported_ = 0; |
| for (uint8_t j = 0; j <feature_desc()->bControlSize; ++j) { |
| uint32_t bits = feature_desc()->bmaControls[(i * feature_desc()->bControlSize) + j]; |
| f.supported_ |= bits << (8 * j); |
| } |
| } |
| |
| // Now, go over our array of features and compute both the union and the |
| // intersection of the features for all of the individual channels. |
| uint32_t ch_feat_union = 0; |
| uint32_t ch_feat_intersection = 0; |
| if (features_.size() > 1) { |
| ch_feat_union = features_[1].supported_; |
| ch_feat_intersection = features_[1].supported_; |
| for (size_t i = 2; i < features_.size(); ++i) { |
| ch_feat_union |= features_[i].supported_; |
| ch_feat_intersection &= features_[i].supported_; |
| |
| } |
| } |
| |
| // Next check for a set of uniformity requirements. In particular, there |
| // are three types of controls (mute, AGC, and volume/gain) that we want to |
| // enforce these guarantees for. Specifically, |
| // |
| // 1) We can handle these controls at the master level, or the individual |
| // channel level, but we don't really know what to do if the controls |
| // exist at both levels. |
| // 2) If we are controlling these things at the individual control level, we |
| // are doing so in a way which mimics a master control knob only. So, if |
| // we have these controls at the per-channel level, it is important that |
| // they be they be identical for each of the individual channels. |
| constexpr uint32_t kUniformControls = USB_AUDIO_FU_BMA_MUTE |
| | USB_AUDIO_FU_BMA_VOLUME |
| | USB_AUDIO_FU_BMA_AUTOMATIC_GAIN; |
| ZX_DEBUG_ASSERT(features_.size() > 0); // Create should have checked this already |
| if (((features_[0].supported_ & ch_feat_union & kUniformControls) != 0) || // Check #1 |
| ((ch_feat_union ^ ch_feat_intersection) & kUniformControls)) { // Check #2 |
| GLOBAL_LOG(WARN, |
| "FeatureUnit id %u has unsupported non-uniform gain controls. " |
| "Master 0x%08x, Channel Union 0x%08x, Channel Intersection 0x%08x.\n", |
| id(), features_[0].supported_, ch_feat_union, ch_feat_intersection); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| // Stash bitmaps of controls we care about for later. |
| master_feat_ = features_[0].supported_ & kUniformControls; |
| ch_feat_ = ch_feat_intersection & kUniformControls; |
| |
| // If this feature unit has volume control, fetch and sanity check the |
| // min/max/res of all of the channels. |
| if (has_vol()) { |
| // Go over each of the volume controls and cache the min/max/res values. |
| for (size_t i = 0; i < features_.size(); ++i) { |
| auto& f = features_[i]; |
| |
| if (!f.has_vol()) { |
| continue; |
| } |
| |
| uint8_t ch = static_cast<uint8_t>(i); |
| |
| res = FeatCtrlReq(proto, USB_AUDIO_GET_MIN, USB_AUDIO_VOLUME_CONTROL, ch, &f.vol_min_); |
| if (res != ZX_OK) { |
| return res; |
| } |
| |
| res = FeatCtrlReq(proto, USB_AUDIO_GET_MAX, USB_AUDIO_VOLUME_CONTROL, ch, &f.vol_max_); |
| if (res != ZX_OK) { |
| return res; |
| } |
| |
| res = FeatCtrlReq(proto, USB_AUDIO_GET_RES, USB_AUDIO_VOLUME_CONTROL, ch, &f.vol_res_); |
| if (res != ZX_OK) { |
| return res; |
| } |
| } |
| |
| // If volume control is done at the per-channel level, make sure that all of |
| // the channels support the same range. Otherwise, our volume control range |
| // is equal to the master channel's range. |
| if (features_[0].has_vol()) { |
| vol_min_ = features_[0].vol_min_; |
| vol_max_ = features_[0].vol_max_; |
| vol_res_ = features_[0].vol_res_; |
| } else { |
| vol_min_ = features_[1].vol_min_; |
| vol_max_ = features_[1].vol_max_; |
| vol_res_ = features_[1].vol_res_; |
| for (size_t i = 2; i < features_.size(); ++i) { |
| if ((vol_min_ != features_[i].vol_min_) || |
| (vol_max_ != features_[i].vol_max_) || |
| (vol_res_ != features_[i].vol_res_)) { |
| GLOBAL_LOG(WARN, |
| "FeatureUnit id %u has unsupported non-uniform gain controls. " |
| "Channel %zu's gain range [%hd, %hd, %hd] does not match Channel 1's " |
| "range [%hd, %hd, %hd]\n", |
| id(), i, |
| vol_min_, vol_max_, vol_res_, |
| features_[i].vol_min_, features_[i].vol_max_, features_[i].vol_res_); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| } |
| } |
| |
| if (vol_min_ > vol_max_) { |
| GLOBAL_LOG(WARN, "FeatureUnit id %u has invalid volume range [%hd, %hd]\n", |
| id(), vol_min_, vol_max_); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| if (!vol_res_) { |
| GLOBAL_LOG(WARN, "FeatureUnit id %u has invalid volume res %hd\n", id(), vol_res_); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| // Fetch the current volume setting from the appropriate source, then |
| // make certain that all channels are set to the same if there is no |
| // master control knob. |
| bool master_control = (master_feat_ & USB_AUDIO_FU_BMA_VOLUME); |
| uint8_t ch = master_control ? 0 : 1; |
| res = FeatCtrlReq(proto, USB_AUDIO_GET_CUR, USB_AUDIO_VOLUME_CONTROL, ch, &vol_cur_); |
| if (res != ZX_OK) { |
| return res; |
| } |
| |
| if (!master_control) { |
| SetFeature(proto, USB_AUDIO_VOLUME_CONTROL, vol_cur_); |
| } |
| } |
| |
| // If we have mute controls, figure out the current setting. |
| if (has_mute()) { |
| res = FeatCtrlReq(proto, USB_AUDIO_GET_CUR, USB_AUDIO_MUTE_CONTROL, 0, &mute_cur_); |
| if (res != ZX_OK) { |
| return res; |
| } |
| } |
| |
| // If we have agc controls, figure out the current setting. |
| if (has_agc()) { |
| res = FeatCtrlReq(proto, USB_AUDIO_GET_CUR, USB_AUDIO_AUTOMATIC_GAIN_CONTROL, 0, &agc_cur_); |
| if (res != ZX_OK) { |
| return res; |
| } |
| } |
| |
| // Dump some diags info if TRACE level logging is enabled. |
| if (has_vol()) { |
| GLOBAL_LOG(TRACE, |
| "FeatureUnit id %u: can%s mute, can%s AGC, gain [%.3f, %.3f: step %.3f] dB\n", |
| id(), |
| has_mute() ? "" : "not", |
| has_agc() ? "" : "not", |
| vol_min_db(), vol_max_db(), vol_res_db()); |
| } else { |
| GLOBAL_LOG(TRACE, "FeatureUnit id %u: can%s mute, can%s AGC, and has fixed gain\n", |
| id(), has_mute() ? "" : "not", has_agc() ? "" : "not"); |
| } |
| |
| // All done! Declare success and get out. |
| return ZX_OK; |
| }; |
| |
| float FeatureUnit::SetVol(const usb_protocol_t& proto, float db) { |
| // If we have no volume control, then our gain is fixed at 0.0 dB no matter |
| // what the user asks for. |
| if (!has_vol()) { |
| return 0.0; |
| } |
| |
| // Convert to our target value. Start by converting to ticks. |
| float ticks_float = db / kDbPerTick; |
| |
| // Now snap to the closest allowed tick based on our resolution. |
| ticks_float = roundf(ticks_float / vol_res_) * vol_res_; |
| |
| // Now clamp to the acceptable min/max range and convert to integer ticks. |
| vol_cur_ = static_cast<int16_t>(fbl::clamp<float>(ticks_float, vol_min_, vol_max_)); |
| |
| // Finally apply the setting. If we have no explicit mute control, and we |
| // are currently supposed to be muted, skip this step. We are using the |
| // volume control to simulate mute to the best of our abilities; we will |
| // restore vol_cur_ when the unit finally becomes un-muted. |
| if (!(mute_cur_ && !has_mute())) { |
| SetFeature(proto, USB_AUDIO_VOLUME_CONTROL, vol_cur_); |
| } |
| |
| return vol_cur_ * kDbPerTick; |
| } |
| |
| bool FeatureUnit::SetMute(const usb_protocol_t& proto, bool mute) { |
| mute_cur_ = mute; |
| |
| // If we have an explicit mute control, use that. Otherwise, do the best we |
| // can using the volume control (if present). |
| if (has_mute()) { |
| SetFeature(proto, USB_AUDIO_MUTE_CONTROL, mute_cur_); |
| } else { |
| // Section 5.2.2.4.3.2 of the USB Audio 1.0 spec defines int16::min as |
| // -inf dB for the purpose of setting gain. |
| int16_t tgt = mute ? std::numeric_limits<int16_t>::min() : vol_cur_; |
| SetFeature(proto, USB_AUDIO_VOLUME_CONTROL, tgt); |
| } |
| |
| return !!mute_cur_; |
| } |
| |
| bool FeatureUnit::SetAgc(const usb_protocol_t& proto, bool agc) { |
| if (has_agc()) { |
| agc_cur_ = agc; |
| SetFeature(proto, USB_AUDIO_AUTOMATIC_GAIN_CONTROL, static_cast<uint8_t>(agc)); |
| } |
| return !!agc_cur_; |
| } |
| |
| fbl::RefPtr<ProcessingUnit> ProcessingUnit::Create(const DescriptorListMemory::Iterator& iter, |
| uint8_t iid) { |
| // Find the size of each of the inlined variable length arrays in this |
| // structure, finding the locations of the constant headers in the process. |
| // If anything does not look right, complain and move on. |
| auto hdr0 = iter.hdr_as<usb_audio_ac_processing_unit_desc_0>(); |
| if (hdr0 != nullptr) { |
| size_t off = sizeof(*hdr0) + hdr0->bNrInPins; |
| auto hdr1 = offset_ptr<usb_audio_ac_processing_unit_desc_1>(hdr0, off); |
| if (hdr1 != nullptr) { |
| off += sizeof(*hdr1) + hdr1->bControlSize; |
| auto hdr2 = offset_ptr<usb_audio_ac_processing_unit_desc_2>(hdr0, off); |
| |
| // TODO(johngro): additional sanity checking and pre-processing goes here. |
| // |
| // Note: Processing units actually come in their own pre-defined |
| // sub-flavors (determined by hdr0->wProcessType). Instead of |
| // lumping them all together into one ProcessingUnit class, we |
| // should probably take the time to break them down into the various |
| // sub-flavors, at which point in time, the big validation switch |
| // statement would go somewhere in here. |
| // |
| // For now, however, we do not expect to have any need to control |
| // processing units. If we ever encounter one, we really only want |
| // to understand the size of the baSourceID array so that we can |
| // successfully walk the graph when attempting to build input/output |
| // stream paths. |
| fbl::AllocChecker ac; |
| auto ret = fbl::AdoptRef( |
| new (&ac) ProcessingUnit(iter.desc_list(), hdr0, hdr1, hdr2, iid)); |
| return ac.check() ? ret : nullptr; |
| } |
| } |
| |
| GLOBAL_LOG(WARN, "ProcessingUnit header appears invalid @ offset %zu\n", iter.offset()); |
| return nullptr; |
| } |
| |
| fbl::RefPtr<ExtensionUnit> ExtensionUnit::Create(const DescriptorListMemory::Iterator& iter, |
| uint8_t iid) { |
| // Find the size of each of the inlined variable length arrays in this |
| // structure, finding the locations of the constant headers in the process. |
| // If anything does not look right, complain and move on. |
| auto hdr0 = iter.hdr_as<usb_audio_ac_extension_unit_desc_0>(); |
| if (hdr0 != nullptr) { |
| size_t off = sizeof(*hdr0) + hdr0->bNrInPins; |
| auto hdr1 = offset_ptr<usb_audio_ac_extension_unit_desc_1>(hdr0, off); |
| if (hdr1 != nullptr) { |
| off += sizeof(*hdr1) + hdr1->bControlSize; |
| auto hdr2 = offset_ptr<usb_audio_ac_extension_unit_desc_2>(hdr0, off); |
| |
| // TODO(johngro): additional sanity checking and pre-processing goes here. |
| fbl::AllocChecker ac; |
| auto ret = fbl::AdoptRef( |
| new (&ac) ExtensionUnit(iter.desc_list(), hdr0, hdr1, hdr2, iid)); |
| return ac.check() ? ret : nullptr; |
| } |
| } |
| |
| GLOBAL_LOG(WARN, "ExtensionUnit header appears invalid @ offset %zu\n", iter.offset()); |
| return nullptr; |
| } |
| |
| } // namespace usb |
| } // namespace audio |
