/*
 * Copyright (c) 2022, RPTU Kaiserslautern-Landau
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Authors:
 *    Iron Prando da Silva
 */

#include "TimeDependenciesInfoLPDDR4.h"

using namespace std;

TimeDependenciesInfoLPDDR4::TimeDependenciesInfoLPDDR4(const QJsonObject& memspec, const uint tCK) :
    DRAMTimeDependenciesBase(memspec, tCK)
{
    mInitializeValues();
}

void TimeDependenciesInfoLPDDR4::mInitializeValues()
{
    burstLength = mMemspecJson["memarchitecturespec"].toObject()["burstLength"].toInt();
    dataRate = mMemspecJson["memarchitecturespec"].toObject()["dataRate"].toInt();

    tRRD = tCK * mMemspecJson["memtimingspec"].toObject()["RRD"].toInt();
    tRCD = tCK * mMemspecJson["memtimingspec"].toObject()["RCD"].toInt();
    tRAS = tCK * mMemspecJson["memtimingspec"].toObject()["RAS"].toInt();
    tFAW = tCK * mMemspecJson["memtimingspec"].toObject()["FAW"].toInt();
    tRPpb = tCK * mMemspecJson["memtimingspec"].toObject()["RPpb"].toInt();
    tRPab = tCK * mMemspecJson["memtimingspec"].toObject()["RPab"].toInt();
    tRCpb = tCK * mMemspecJson["memtimingspec"].toObject()["RCpb"].toInt();
    tRCab = tCK * mMemspecJson["memtimingspec"].toObject()["RCab"].toInt();
    tCCD = tCK * mMemspecJson["memtimingspec"].toObject()["CCD"].toInt();
    tRTP = tCK * mMemspecJson["memtimingspec"].toObject()["RTP"].toInt();
    tWR = tCK * mMemspecJson["memtimingspec"].toObject()["WR"].toInt();
    tWTR = tCK * mMemspecJson["memtimingspec"].toObject()["WTR"].toInt();
    tPPD = tCK * mMemspecJson["memtimingspec"].toObject()["PPD"].toInt();
    tWPRE = tCK * mMemspecJson["memtimingspec"].toObject()["WPRE"].toInt();
    tRPST = tCK * mMemspecJson["memtimingspec"].toObject()["RPST"].toInt();
    tDQSCK = tCK * mMemspecJson["memtimingspec"].toObject()["DQSCK"].toInt();
    tDQSS = tCK * mMemspecJson["memtimingspec"].toObject()["DQSS"].toInt();
    tDQS2DQ = tCK * mMemspecJson["memtimingspec"].toObject()["DQS2DQ"].toInt();
    tRL = tCK * mMemspecJson["memtimingspec"].toObject()["RL"].toInt();
    tWL = tCK * mMemspecJson["memtimingspec"].toObject()["WL"].toInt();
    tRFCab = tCK * mMemspecJson["memtimingspec"].toObject()["RFCab"].toInt();
    tRFCpb = tCK * mMemspecJson["memtimingspec"].toObject()["RFCpb"].toInt();
    tESCKE = tCK * mMemspecJson["memtimingspec"].toObject()["ESCKE"].toInt();
    tSR = tCK * mMemspecJson["memtimingspec"].toObject()["SR"].toInt();
    tXSR = tCK * mMemspecJson["memtimingspec"].toObject()["XSR"].toInt();
    tXP = tCK * mMemspecJson["memtimingspec"].toObject()["XP"].toInt();
    tCKE = tCK * mMemspecJson["memtimingspec"].toObject()["CKE"].toInt();
    tCMDCKE = tCK * mMemspecJson["memtimingspec"].toObject()["CMDCKE"].toInt();
    tRTRS = tCK * mMemspecJson["memtimingspec"].toObject()["RTRS"].toInt();

    tBURST = (uint)(burstLength / (float)dataRate) * tCK;
    tRDWR = tRL + tDQSCK + tBURST - tWL + tWPRE + tRPST;
    tRDWR_R = tRL + tBURST + tRTRS - tWL;
    tWRRD = tWL + tCK + tBURST + tWTR;
    tWRRD_R = tWL + tBURST + tRTRS - tRL;
    tRDPRE = tRTP + tBURST - 6 * tCK;
    tRDAACT = tRTP + tRPpb + tBURST - 8 * tCK;
    tWRPRE = 2 * tCK + tWL + tCK + tBURST + tWR;
    tWRAACT = tWL + tBURST + tWR + tCK + tRPpb;
    tACTPDEN = 3 * tCK + tCMDCKE;
    tPRPDEN = tCK + tCMDCKE;
    tRDPDEN = 3 * tCK + tRL + tDQSCK + tBURST + tRPST;
    tWRPDEN = 3 * tCK + tWL +
              (ceil((uint)(tDQSS / (float)tCK)) + ceil((uint)(tDQS2DQ / (float)tCK))) * tCK +
              tBURST + tWR;
    tWRAPDEN = 3 * tCK + tWL +
               (ceil((uint)(tDQSS / (float)tCK)) + ceil((uint)(tDQS2DQ / (float)tCK))) * tCK +
               tBURST + tWR + 2 * tCK;
    tREFPDEN = tCK + tCMDCKE;
    tSREFPDEN = tCK + tESCKE;

    mPools.insert({"CMD_BUS",
                   {1,
                    {
                        {"ACT", 4 * tCK},
                        {"RD", 4 * tCK},
                        {"WR", 4 * tCK},
                        {"RDA", 4 * tCK},
                        {"WRA", 4 * tCK},
                        {"PREPB", 2 * tCK},
                        {"PREAB", 2 * tCK},
                        {"REFAB", 2 * tCK},
                        {"SREFEN", 2 * tCK},
                        {"SREFEX", 2 * tCK},
                        {"REFPB", 2 * tCK},
                    }}});

    mPools.insert({"NAW",
                   {4,
                    {
                        {"ACT", tFAW},
                        {"REFPB", tFAW},
                    }}});
}

const std::vector<QString> TimeDependenciesInfoLPDDR4::getPossiblePhases()
{
    return {
        "ACT",
        "RD",
        "WR",
        "PREPB",
        "RDA",
        "WRA",
        "REFPB",
        "REFAB",
        "PREAB",
        "PDEP",
        "PDXP",
        "SREFEN",
        "SREFEX",
        "PDEA",
        "PDXA",
        "SRPDEN",
        "SRPDEX",
    };
}

DependencyMap TimeDependenciesInfoLPDDR4::mSpecializedGetDependencies() const
{
    DependencyMap dmap;

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("ACT"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRCpb, "ACT", DependencyType::IntraBank, "tRCpb"},
                     {tRRD, "ACT", DependencyType::IntraRank, "tRRD"},
                     {tRDAACT, "RDA", DependencyType::IntraBank, "tRDAACT"},
                     {tWRAACT, "WRA", DependencyType::IntraBank, "tWRAACT"},
                     {tRPpb - 2 * tCK, "PREPB", DependencyType::IntraBank, "tRPpb - 2 * tCK"},
                     {tRPab - 2 * tCK, "PREAB", DependencyType::IntraRank, "tRPab - 2 * tCK"},
                     {tXP, "PDXA", DependencyType::IntraRank, "tXP"},
                     {tXP, "PDXP", DependencyType::IntraRank, "tXP"},
                     {tRFCab - 2 * tCK, "REFAB", DependencyType::IntraRank, "tRFCab - 2 * tCK"},
                     {tRFCpb - 2 * tCK, "REFPB", DependencyType::IntraBank, "tRFCpb - 2 * tCK"},
                     {tRRD - 2 * tCK, "REFPB", DependencyType::IntraRank, "tRRD - 2 * tCK"},
                     {tXSR - 2 * tCK, "SREFEX", DependencyType::IntraRank, "tXSR - 2 * tCK"},
                     {4 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                     {tFAW, "NAW", DependencyType::IntraRank, "tFAW"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("RD"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRCD, "ACT", DependencyType::IntraBank, "tRCD"},
                     {tCCD, "RD", DependencyType::IntraBank, "tCCD"}, //
                     {tCCD, "RD", DependencyType::IntraRank, "tCCD"},
                     {tBURST + tRTRS, "RD", DependencyType::InterRank, "tBURST + tRTRS"},
                     {tCCD, "RDA", DependencyType::IntraRank, "tCCD"},
                     {tBURST + tRTRS, "RDA", DependencyType::InterRank, "tBURST + tRTRS"},
                     {tWRRD, "WR", DependencyType::IntraBank, "tWRRD"},
                     {tWRRD, "WR", DependencyType::IntraRank, "tWRRD"},
                     {tWRRD_R, "WR", DependencyType::InterRank, "tWRRD_R"},
                     {tWRRD, "WRA", DependencyType::IntraRank, "tWRRD"},
                     {tWRRD_R, "WRA", DependencyType::InterRank, "tWRRD_R"},
                     {tXP, "PDXA", DependencyType::IntraRank, "tXP"},
                     {4 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("WR"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRCD, "ACT", DependencyType::IntraBank, "tRCD"},
                     {tRDWR, "RD", DependencyType::IntraBank, "tRDWR"}, //
                     {tRDWR, "RD", DependencyType::IntraRank, "tRDWR"},
                     {tRDWR_R, "RD", DependencyType::InterRank, "tRDWR_R"},
                     {tRDWR, "RDA", DependencyType::IntraRank, "tRDWR"},
                     {tRDWR_R, "RDA", DependencyType::InterRank, "tRDWR_R"},
                     {tCCD, "WR", DependencyType::IntraBank, "tCCD"},
                     {tCCD, "WR", DependencyType::IntraRank, "tCCD"},
                     {tBURST + tRTRS, "WR", DependencyType::InterRank, "tBURST + tRTRS"},
                     {tCCD, "WRA", DependencyType::IntraRank, "tCCD"},
                     {tBURST + tRTRS, "WRA", DependencyType::InterRank, "tBURST + tRTRS"},
                     {tXP, "PDXA", DependencyType::IntraRank, "tXP"},
                     {4 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("PREPB"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRAS + 2 * tCK, "ACT", DependencyType::IntraBank, "tRAS + 2 * tCK"},
                     {tRDPRE, "RD", DependencyType::IntraBank, "tRDPRE"},
                     {tWRPRE, "WR", DependencyType::IntraBank, "tWRPRE"},
                     {tPPD, "PREPB", DependencyType::IntraRank, "tPPD"},
                     {tXP, "PDXA", DependencyType::IntraRank, "tXP"},
                     {2 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("RDA"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRCD, "ACT", DependencyType::IntraBank, "tRCD"},
                     {tCCD, "RD", DependencyType::IntraBank, "tCCD"},
                     {tCCD, "RD", DependencyType::IntraRank, "tCCD"},
                     {tBURST + tRTRS, "RD", DependencyType::InterRank, "tBURST + tRTRS"},
                     {tCCD, "RDA", DependencyType::IntraRank, "tCCD"},
                     {tBURST + tRTRS, "RDA", DependencyType::InterRank, "tBURST + tRTRS"},
                     {max({tWRRD, tWRPRE - tRDPRE}),
                      "WR",
                      DependencyType::IntraBank,
                      "max(tWRRD, tWRPRE - tRDPRE)"},
                     {tWRRD, "WR", DependencyType::IntraRank, "tWRRD"},
                     {tWRRD_R, "WR", DependencyType::InterRank, "tWRRD_R"},
                     {tWRRD, "WRA", DependencyType::IntraRank, "tWRRD"},
                     {tWRRD_R, "WRA", DependencyType::InterRank, "tWRRD_R"},
                     {tXP, "PDXA", DependencyType::IntraRank, "tXP"},
                     {4 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("WRA"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRCD, "ACT", DependencyType::IntraBank, "tRCD"},
                     {tRDWR, "RD", DependencyType::IntraBank, "tRDWR"},
                     {tRDWR, "RD", DependencyType::IntraRank, "tRDWR"},
                     {tRDWR_R, "RD", DependencyType::InterRank, "tRDWR_R"},
                     {tRDWR, "RDA", DependencyType::IntraRank, "tRDWR"},
                     {tRDWR_R, "RDA", DependencyType::InterRank, "tRDWR_R"},
                     {tCCD, "WR", DependencyType::IntraBank, "tCCD"},
                     {tCCD, "WR", DependencyType::IntraRank, "tCCD"},
                     {tBURST + tRTRS, "WR", DependencyType::InterRank, "tBURST + tRTRS"},
                     {tCCD, "WRA", DependencyType::IntraRank, "tCCD"},
                     {tBURST + tRTRS, "WRA", DependencyType::InterRank, "tBURST + tRTRS"},
                     {tXP, "PDXA", DependencyType::IntraRank, "tXP"},
                     {4 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("REFPB"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRCpb + 2 * tCK, "ACT", DependencyType::IntraBank, "tRCpb + 2 * tCK"},
                     {tRRD + 2 * tCK, "ACT", DependencyType::IntraRank, "tRRD + 2 * tCK"},
                     {tRDPRE + tRPpb, "RDA", DependencyType::IntraBank, "tRDPRE + tRPpb"},
                     {tWRPRE + tRPpb, "WRA", DependencyType::IntraBank, "tWRPRE + tRPpb"},
                     {tRPpb, "PREPB", DependencyType::IntraBank, "tRPpb"},
                     {tRPab, "PREAB", DependencyType::IntraRank, "tRPab"},
                     {tXP, "PDXP", DependencyType::IntraRank, "tXP"},
                     {tXP, "PDXA", DependencyType::IntraRank, "tXP"},
                     {tRFCab, "REFAB", DependencyType::IntraRank, "tRFCab"},
                     {tRFCpb, "REFPB", DependencyType::IntraBank, "tRFCpb"}, //
                     {tRFCpb, "REFPB", DependencyType::IntraRank, "tRFCpb"},
                     {tXSR, "SREFEX", DependencyType::IntraRank, "tXSR"},
                     {2 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                     {tFAW, "NAW", DependencyType::IntraRank, "tFAW"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("REFAB"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRCpb + 2 * tCK, "ACT", DependencyType::IntraRank, "tRCpb + 2 * tCK"},
                     {tRDPRE + tRPpb, "RDA", DependencyType::IntraRank, "tRDPRE + tRPpb"},
                     {tWRPRE + tRPpb, "WRA", DependencyType::IntraRank, "tWRPRE + tRPpb"},
                     {tRPpb, "PREPB", DependencyType::IntraRank, "tRPpb"},
                     {tRPab, "PREAB", DependencyType::IntraRank, "tRPab"},
                     {tXP, "PDXP", DependencyType::IntraRank, "tXP"},
                     {tRFCab, "REFAB", DependencyType::IntraRank, "tRFCab"},
                     {tRFCpb, "REFPB", DependencyType::IntraRank, "tRFCpb"},
                     {tXSR, "SREFEX", DependencyType::IntraRank, "tXSR"},
                     {2 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("PREAB"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRAS + 2 * tCK, "ACT", DependencyType::IntraRank, "tRAS + 2 * tCK"},
                     {tRDPRE, "RD", DependencyType::IntraRank, "tRDPRE"},
                     {tRDPRE, "RDA", DependencyType::IntraRank, "tRDPRE"},
                     {tWRPRE, "WR", DependencyType::IntraRank, "tWRPRE"},
                     {tWRPRE, "WRA", DependencyType::IntraRank, "tWRPRE"},
                     {tPPD, "PREPB", DependencyType::IntraRank, "tPPD"},
                     {tXP, "PDXA", DependencyType::IntraRank, "tXP"},
                     {tRFCpb, "REFPB", DependencyType::IntraRank, "tRFCpb"},
                     {2 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("PDEP"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRDPDEN, "RD", DependencyType::IntraRank, "tRDPDEN"},
                     {tRDPDEN, "RDA", DependencyType::IntraRank, "tRDPDEN"},
                     {tWRAPDEN, "WRA", DependencyType::IntraRank, "tWRAPDEN"},
                     {tPRPDEN, "PREPB", DependencyType::IntraRank, "tPRPDEN"},
                     {tPRPDEN, "PREAB", DependencyType::IntraRank, "tPRPDEN"},
                     {tCKE, "PDXP", DependencyType::IntraRank, "tCKE"},
                     {tREFPDEN, "REFAB", DependencyType::IntraRank, "tREFPDEN"},
                     {tREFPDEN, "REFPB", DependencyType::IntraRank, "tREFPDEN"},
                     {tXSR, "SREFEX", DependencyType::IntraRank, "tXSR"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("PDXP"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tCKE, "PDEP", DependencyType::IntraRank, "tCKE"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("SREFEN"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tRCpb + 2 * tCK, "ACT", DependencyType::IntraRank, "tRCpb + 2 * tCK"},
                     {max({tRDPDEN, tRDPRE + tRPpb}),
                      "RDA",
                      DependencyType::IntraRank,
                      "max(tRDPDEN, tRDPRE + tRPpb)"},
                     {max({tWRAPDEN, tWRPRE + tRPpb}),
                      "WRA",
                      DependencyType::IntraRank,
                      "max(tWRAPDEN, tWRPRE + tRPpb)"},
                     {tRPpb, "PREPB", DependencyType::IntraRank, "tRPpb"},
                     {tRPab, "PREAB", DependencyType::IntraRank, "tRPab"},
                     {tXP, "PDXP", DependencyType::IntraRank, "tXP"},
                     {tRFCab, "REFAB", DependencyType::IntraRank, "tRFCab"},
                     {tRFCpb, "REFPB", DependencyType::IntraRank, "tRFCpb"},
                     {tXSR, "SREFEX", DependencyType::IntraRank, "tXSR"},
                     {2 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("SREFEX"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tSR, "SREFEN", DependencyType::IntraRank, "tSR"},
                     {tXP, "SRPDEX", DependencyType::IntraRank, "tXP"}, //
                     {2 * tCK, "CMD_BUS", DependencyType::InterRank, "CommandBus"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("PDEA"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tACTPDEN, "ACT", DependencyType::IntraRank, "tACTPDEN"},
                     {tRDPDEN, "RD", DependencyType::IntraRank, "tRDPDEN"},
                     {tRDPDEN, "RDA", DependencyType::IntraRank, "tRDPDEN"},
                     {tWRPDEN, "WR", DependencyType::IntraRank, "tWRPDEN"},
                     {tWRAPDEN, "WRA", DependencyType::IntraRank, "tWRAPDEN"},
                     {tPRPDEN, "PREPB", DependencyType::IntraRank, "tPRPDEN"},
                     {tCKE, "PDXA", DependencyType::IntraRank, "tCKE"},
                     {tREFPDEN, "REFPB", DependencyType::IntraRank, "tREFPDEN"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("PDXA"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tCKE, "PDEA", DependencyType::IntraRank, "tCKE"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("SRPDEN"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tSREFPDEN, "SREFEN", DependencyType::IntraRank, "tSREFPDEN"},
                 }));

    dmap.emplace(piecewise_construct,
                 forward_as_tuple("SRPDEX"),
                 forward_as_tuple(initializer_list<TimeDependency>{
                     {tCKE, "SRPDEN", DependencyType::IntraRank, "tCKE"},
                 }));

    return dmap;
}