// 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 <ddk/binding.h>
#include <ddk/debug.h>
#include <ddk/platform-defs.h>
#include <ddk/protocol/composite.h>
#include <ddktl/pdev.h>
#include <soc/aml-t931/t931-gpio.h>

#include "audio-stream-out.h"

namespace audio {
namespace sherlock {

enum {
    COMPONENT_PDEV,
    COMPONENT_FAULT_GPIO,
    COMPONENT_ENABLE_GPIO,
    COMPONENT_I2C_0,
    COMPONENT_I2C_1,
    COMPONENT_I2C_2, // Optional
    COMPONENT_COUNT,
};

// Expects L+R for tweeters + L+R for the 1 Woofer (mixed in HW).
// The user must perform crossover filtering on these channels.
constexpr size_t kNumberOfChannels = 4;
// Calculate ring buffer size for 1 second of 16-bit, 48kHz.
constexpr size_t kRingBufferSize = fbl::round_up<size_t, size_t>(48000 * 2 * kNumberOfChannels,
                                                                 PAGE_SIZE);

SherlockAudioStreamOut::SherlockAudioStreamOut(zx_device_t* parent)
    : SimpleAudioStream(parent, false), pdev_(parent) {
}

zx_status_t SherlockAudioStreamOut::InitPdev() {
    composite_protocol_t composite;

    auto status = device_get_protocol(parent(), ZX_PROTOCOL_COMPOSITE, &composite);
    if (status != ZX_OK) {
        zxlogf(ERROR, "Could not get composite protocol\n");
        return status;
    }

    zx_device_t* components[COMPONENT_COUNT] = {};
    size_t actual;
    composite_get_components(&composite, components, countof(components), &actual);
    if (actual < countof(components) - 1) {
        zxlogf(ERROR, "could not get components\n");
        return ZX_ERR_NOT_SUPPORTED;
    }

    pdev_ = components[COMPONENT_PDEV];
    if (!pdev_.is_valid()) {
        return ZX_ERR_NO_RESOURCES;
    }

    status = device_get_metadata(parent(), DEVICE_METADATA_PRIVATE, &codecs_types_,
                                             sizeof(metadata::Codec), &actual);
    if (status != ZX_OK || sizeof(metadata::Codec) != actual) {
        zxlogf(ERROR, "%s device_get_metadata failed %d\n", __FILE__, status);
        return status;
    }

    if (codecs_types_ == metadata::Codec::Tas5760_Tas5720) {
        zxlogf(INFO, "audio: using Tas5760 and Tas5720 codecs\n");
        fbl::AllocChecker ac;
        codecs_ = fbl::Array(new (&ac) fbl::unique_ptr<Codec>[2], 2);
        if (!ac.check()) {
            return ZX_ERR_NO_MEMORY;
        }
        codecs_[0] = Tas5760::Create(components[COMPONENT_I2C_0]);
        if (!codecs_[0]) {
            zxlogf(ERROR, "%s could not get tas5760\n", __func__);
            return ZX_ERR_NO_RESOURCES;
        }
        codecs_[1] = Tas5720::Create(components[COMPONENT_I2C_1]);
        if (!codecs_[1]) {
            zxlogf(ERROR, "%s could not get tas5720\n", __func__);
            return ZX_ERR_NO_RESOURCES;
        }
    } else if (codecs_types_ == metadata::Codec::Tas5720x3) {
        zxlogf(INFO, "audio: using 3 Tas5720 codecs\n");
        fbl::AllocChecker ac;
        codecs_ = fbl::Array(new (&ac) fbl::unique_ptr<Codec>[3], 3);
        if (!ac.check()) {
            return ZX_ERR_NO_MEMORY;
        }
        for (uint32_t i = 0; i < 3; ++i) {
            codecs_[i] = Tas5720::Create(components[COMPONENT_I2C_0 + i]);
            if (!codecs_[i]) {
                zxlogf(ERROR, "%s could not get tas5720\n", __func__);
                return ZX_ERR_NO_RESOURCES;
            }
        }
    } else {
        zxlogf(ERROR, "%s invalid or unsupported codec\n", __func__);
        return ZX_ERR_NO_RESOURCES;
    }

    audio_fault_ = components[COMPONENT_FAULT_GPIO];
    audio_en_ = components[COMPONENT_ENABLE_GPIO];

    if (!audio_fault_.is_valid() || !audio_en_.is_valid()) {
        zxlogf(ERROR, "%s failed to allocate gpio\n", __func__);
        return ZX_ERR_NO_RESOURCES;
    }

    status = pdev_.GetBti(0, &bti_);
    if (status != ZX_OK) {
        zxlogf(ERROR, "%s could not obtain bti - %d\n", __func__, status);
        return status;
    }

    std::optional<ddk::MmioBuffer> mmio;
    status = pdev_.MapMmio(0, &mmio);
    if (status != ZX_OK) {
        return status;
    }
    aml_audio_ = AmlTdmDevice::Create(*std::move(mmio), HIFI_PLL, TDM_OUT_C, FRDDR_A, MCLK_C);
    if (aml_audio_ == nullptr) {
        zxlogf(ERROR, "%s failed to create tdm device\n", __func__);
        return ZX_ERR_NO_MEMORY;
    }

    // Drive strength settings
    status = pdev_.MapMmio(1, &mmio);
    if (status != ZX_OK) {
        return status;
    }
    // Strength 1 for sclk (bit 14, GPIOZ(7)) and lrclk (bit 12, GPIOZ(6)),
    // GPIO offsets are in 4 bytes units.
    mmio->SetBits<uint32_t>((1 << 14) | (1 << 12), 4 * T931_PAD_DS_REG4A);
    status = pdev_.MapMmio(2, &mmio);
    if (status != ZX_OK) {
        return status;
    }
    // Strength 1 for mclk (bit 18,  GPIOAO(9)), GPIO offsets are in 4 bytes units.
    mmio->SetBit<uint32_t>(18, 4 * T931_AO_PAD_DS_A);

    audio_en_.Write(1); // SOC_AUDIO_EN.

    if (codecs_types_ == metadata::Codec::Tas5760_Tas5720) {
        codecs_[0]->Init(std::nullopt); // No slot setting, always uses L+R.
        codecs_[1]->Init(0);  // Use TDM slot 0.
    } else {
        codecs_[0]->Init(0); // Use TDM slot 0.
        codecs_[1]->Init(1); // Use TDM slot 1.
        codecs_[2]->Init(0); // Use TDM slot 0.
    }

    InitBuffer(kRingBufferSize);

    aml_audio_->SetBuffer(pinned_ring_buffer_.region(0).phys_addr,
                          pinned_ring_buffer_.region(0).size);

    // Setup Stereo Left Justified:
    // -lrclk duty = 64 sclk (SetSclkDiv lrdiv=63 below).
    // -No delay from the time the lrclk signal changes state state to the first bit of data on the
    // data lines  (ConfigTdmOutSlot bitoffset=4 below accomplishes this).
    // -3072MHz/64 = 48KHz.

    // 4 bitoffset, 2 slots, 32 bits/slot, 16 bits/sample, enable mix L+R on lane 1.
    aml_audio_->ConfigTdmOutSlot(4, 1, 31, 15, (1 << 1));

    // Lane 0 L channel set to FRDDR slot 0.
    // Lane 0 R channel set to FRDDR slot 1.
    // Lane 1 L channel set to FRDDR slot 2.  Mixed with R, see ConfigTdmOutSlot above.
    // Lane 1 R channel set to FRDDR slot 3.  Mixed with L, see ConfigTdmOutSlot above.
    aml_audio_->ConfigTdmOutSwaps(0x00003210);

    // Tweeters: Lane 0, unmask TDM slots 0 & 1 (L+R FRDDR slots 0 & 1).
    aml_audio_->ConfigTdmOutLane(0, 0x00000003);

    // Woofer: Lane 1, unmask TDM slot 0 & 1 (Woofer FRDDR slots 2 & 3).
    aml_audio_->ConfigTdmOutLane(1, 0x00000003);

    // mclk = T931_HIFI_PLL_RATE/125 = 1536MHz/125 = 12.288MHz.
    aml_audio_->SetMclkDiv(124);

    // Per schematic, mclk uses pad 0 (MCLK_0 instead of MCLK_1).
    aml_audio_->SetMClkPad(MCLK_PAD_0);

    // sclk = 12.288MHz/4 = 3.072MHz, 32L + 32R sclks = 64 sclks.
    aml_audio_->SetSclkDiv(3, 31, 63);

    aml_audio_->Sync();

    return ZX_OK;
}

zx_status_t SherlockAudioStreamOut::Init() {
    zx_status_t status;

    status = InitPdev();
    if (status != ZX_OK) {
        return status;
    }

    status = AddFormats();
    if (status != ZX_OK) {
        return status;
    }

    float gain = codecs_[0]->GetGain();
    float min_gain = codecs_[0]->GetMinGain();
    float max_gain = codecs_[0]->GetMaxGain();
    float gain_step = codecs_[0]->GetGainStep();
    for (size_t i = 1; i < codecs_.size(); ++i) {
        min_gain = fbl::max(min_gain, codecs_[i]->GetMinGain());
        max_gain = fbl::min(max_gain, codecs_[i]->GetMaxGain());
        gain_step = fbl::max(gain_step, codecs_[i]->GetGainStep());
        status = codecs_[i]->SetGain(gain);
        if (status != ZX_OK) {
            return status;
        }
    }
    cur_gain_state_.cur_gain = gain;
    cur_gain_state_.cur_mute = false;
    cur_gain_state_.cur_agc = false;

    cur_gain_state_.min_gain = min_gain;
    cur_gain_state_.max_gain = max_gain;
    cur_gain_state_.gain_step = gain_step;
    cur_gain_state_.can_mute = false;
    cur_gain_state_.can_agc = false;

    snprintf(device_name_, sizeof(device_name_), "sherlock-audio-out");
    snprintf(mfr_name_, sizeof(mfr_name_), "unknown");
    snprintf(prod_name_, sizeof(prod_name_), "sherlock");

    unique_id_ = AUDIO_STREAM_UNIQUE_ID_BUILTIN_SPEAKERS;

    return ZX_OK;
}

zx_status_t SherlockAudioStreamOut::InitPost() {

    notify_timer_ = dispatcher::Timer::Create();
    if (notify_timer_ == nullptr) {
        return ZX_ERR_NO_MEMORY;
    }

    dispatcher::Timer::ProcessHandler thandler(
        [tdm = this](dispatcher::Timer * timer)->zx_status_t {
            OBTAIN_EXECUTION_DOMAIN_TOKEN(t, tdm->domain_);
            return tdm->ProcessRingNotification();
        });

    return notify_timer_->Activate(domain_, std::move(thandler));
}

// Timer handler for sending out position notifications.
zx_status_t SherlockAudioStreamOut::ProcessRingNotification() {
    ZX_ASSERT(us_per_notification_ != 0);

    // TODO(andresoportus): johngro noticed there is some drifting on notifications here,
    // could be improved with maintaining an absolute time and even better computing using
    // rationals, but higher level code should not rely on this anyways (see MTWN-57).
    notify_timer_->Arm(zx_deadline_after(ZX_USEC(us_per_notification_)));

    audio_proto::RingBufPositionNotify resp = {};
    resp.hdr.cmd = AUDIO_RB_POSITION_NOTIFY;

    resp.ring_buffer_pos = aml_audio_->GetRingPosition();
    return NotifyPosition(resp);
}

zx_status_t SherlockAudioStreamOut::ChangeFormat(const audio_proto::StreamSetFmtReq& req) {
    fifo_depth_ = aml_audio_->fifo_depth();
    external_delay_nsec_ = 0;

    // At this time only one format is supported, and hardware is initialized
    // during driver binding, so nothing to do at this time.
    return ZX_OK;
}

void SherlockAudioStreamOut::ShutdownHook() {
    aml_audio_->Shutdown();
    audio_en_.Write(0);
}

zx_status_t SherlockAudioStreamOut::SetGain(const audio_proto::SetGainReq& req) {
    for (size_t i = 0; i < codecs_.size(); ++i) {
        zx_status_t status = codecs_[i]->SetGain(req.gain);
        if (status != ZX_OK) {
            return status;
        }
    }
    cur_gain_state_.cur_gain = req.gain;
    // TODO(andresoportus): More options on volume setting, e.g.:
    // -Allow for ratio between tweeters and woofer gains.
    // -Make use of analog gain options in TAS5720.
    // -Add codecs mute and fade support.
    return ZX_OK;
}

zx_status_t SherlockAudioStreamOut::GetBuffer(const audio_proto::RingBufGetBufferReq& req,
                                              uint32_t* out_num_rb_frames,
                                              zx::vmo* out_buffer) {

    uint32_t rb_frames =
        static_cast<uint32_t>(pinned_ring_buffer_.region(0).size) / frame_size_;

    if (req.min_ring_buffer_frames > rb_frames) {
        return ZX_ERR_OUT_OF_RANGE;
    }
    zx_status_t status;
    constexpr uint32_t rights = ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_MAP | ZX_RIGHT_TRANSFER;
    status = ring_buffer_vmo_.duplicate(rights, out_buffer);
    if (status != ZX_OK) {
        return status;
    }

    *out_num_rb_frames = rb_frames;

    aml_audio_->SetBuffer(pinned_ring_buffer_.region(0).phys_addr,
                          rb_frames * frame_size_);

    return ZX_OK;
}

zx_status_t SherlockAudioStreamOut::Start(uint64_t* out_start_time) {

    *out_start_time = aml_audio_->Start();

    uint32_t notifs = LoadNotificationsPerRing();
    if (notifs) {
        us_per_notification_ = static_cast<uint32_t>(
            1000 * pinned_ring_buffer_.region(0).size / (frame_size_ * 48 * notifs));
        notify_timer_->Arm(zx_deadline_after(ZX_USEC(us_per_notification_)));
    } else {
        us_per_notification_ = 0;
    }
    return ZX_OK;
}

zx_status_t SherlockAudioStreamOut::Stop() {
    notify_timer_->Cancel();
    us_per_notification_ = 0;
    aml_audio_->Stop();
    return ZX_OK;
}

zx_status_t SherlockAudioStreamOut::AddFormats() {
    fbl::AllocChecker ac;
    supported_formats_.reserve(1, &ac);
    if (!ac.check()) {
        zxlogf(ERROR, "Out of memory, can not create supported formats list\n");
        return ZX_ERR_NO_MEMORY;
    }

    // Add the range for basic audio support.
    audio_stream_format_range_t range;

    range.min_channels = kNumberOfChannels;
    range.max_channels = kNumberOfChannels;
    range.sample_formats = AUDIO_SAMPLE_FORMAT_16BIT;
    range.min_frames_per_second = 48000;
    range.max_frames_per_second = 48000;
    range.flags = ASF_RANGE_FLAG_FPS_48000_FAMILY;

    supported_formats_.push_back(range);

    return ZX_OK;
}

zx_status_t SherlockAudioStreamOut::InitBuffer(size_t size) {
    zx_status_t status;
    // TODO(ZX-3149): Per johngro's suggestion preallocate contiguous memory (say in
    // platform bus) since we are likely to fail after running for a while and we need to
    // init again (say the devhost is restarted).
    status = zx_vmo_create_contiguous(bti_.get(), size, 0,
                                      ring_buffer_vmo_.reset_and_get_address());
    if (status != ZX_OK) {
        zxlogf(ERROR, "%s failed to allocate ring buffer vmo - %d\n", __func__, status);
        return status;
    }

    status = pinned_ring_buffer_.Pin(ring_buffer_vmo_, bti_, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE);
    if (status != ZX_OK) {
        zxlogf(ERROR, "%s failed to pin ring buffer vmo - %d\n", __func__, status);
        return status;
    }
    if (pinned_ring_buffer_.region_count() != 1) {
        zxlogf(ERROR, "%s buffer is not contiguous", __func__);
        return ZX_ERR_NO_MEMORY;
    }

    return ZX_OK;
}

static zx_status_t audio_bind(void* ctx, zx_device_t* device) {
    auto stream =
        audio::SimpleAudioStream::Create<audio::sherlock::SherlockAudioStreamOut>(device);
    if (stream == nullptr) {
        return ZX_ERR_NO_MEMORY;
    }

    return ZX_OK;
}

static zx_driver_ops_t driver_ops = [](){
    zx_driver_ops_t ops = {};
    ops.version = DRIVER_OPS_VERSION;
    ops.bind = audio_bind;
    return ops;
}();

} // sherlock
} // audio

// clang-format off
ZIRCON_DRIVER_BEGIN(aml_sherlock_tdm, audio::sherlock::driver_ops, "zircon", "0.1", 4)
    BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_COMPOSITE),
    BI_ABORT_IF(NE, BIND_PLATFORM_DEV_VID, PDEV_VID_AMLOGIC),
    BI_ABORT_IF(NE, BIND_PLATFORM_DEV_PID, PDEV_PID_AMLOGIC_T931),
    BI_MATCH_IF(EQ, BIND_PLATFORM_DEV_DID, PDEV_DID_AMLOGIC_TDM),
ZIRCON_DRIVER_END(aml_sherlock_tdm)
// clang-format on