mmio.h

// Copyright 2018-2019 Delft University of Technology
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <fletcher/arrow-utils.h>
#include <cerata/api.h>
#include <string>
#include <memory>
#include <utility>
#include <vector>
#include <unordered_map>
 
#include "fletchgen/axi4_lite.h"
 
namespace fletchgen {
 
using cerata::Component;
using cerata::Instance;
using cerata::Node;
using cerata::Literal;
using cerata::Port;
using cerata::Parameter;
using cerata::PortArray;
using cerata::integer;
using cerata::Type;
using cerata::ClockDomain;
 
constexpr char MMIO_DEFAULT[] = "fletchgen_mmio_default";
constexpr char MMIO_BATCH[] = "fletchgen_mmio_batch";
constexpr char MMIO_BUFFER[] = "fletchgen_mmio_buffer";
constexpr char MMIO_KERNEL[] = "fletchgen_mmio_kernel";
constexpr char MMIO_PROFILE[] = "fletchgen_mmio_profile";
 
enum class MmioFunction {
  DEFAULT,   
  BATCH,     
  BUFFER,    
  KERNEL,    
  PROFILE    
};
 
enum class MmioBehavior {
  CONTROL,   
  STATUS,    
  STROBE,    
};
 
struct MmioReg {
  MmioReg() = default;
  MmioReg(MmioFunction function,
          MmioBehavior behavior,
          std::string name,
          std::string desc,
          uint32_t width,
          uint32_t index = 0,
          std::optional<uint32_t> addr = std::nullopt,
          std::optional<uint64_t> init = std::nullopt)
      : function(function),
        behavior(behavior),
        name(std::move(name)),
        desc(std::move(desc)),
        width(width),
        index(index),
        addr(addr),
        init(init) {}
  MmioFunction function = MmioFunction::DEFAULT;  
  MmioBehavior behavior = MmioBehavior::CONTROL;  
  std::string name;  
  std::string desc;  
  uint32_t width = 1;  
  uint32_t index = 0;  
  std::optional<uint32_t> addr = std::nullopt;  
  std::optional<uint64_t> init = std::nullopt;  
  std::unordered_map<std::string, std::string> meta;  
};
 
bool ExposeToKernel(MmioFunction fun);
 
struct MmioPort : public Port {
  MmioPort(const std::string &name,
           Port::Dir dir,
           const MmioReg &reg,
           const std::shared_ptr<ClockDomain> &domain = cerata::default_domain());
  MmioReg reg;
  std::shared_ptr<Object> Copy() const override;
};
 
std::shared_ptr<MmioPort> mmio_port(Port::Dir dir, const MmioReg &reg,
                                    const std::shared_ptr<ClockDomain> &domain = cerata::default_domain());
 
std::string GenerateVhdmmioYaml(const std::vector<std::vector<MmioReg> *> &regs,
                                Axi4LiteSpec axi_spec,
                                std::optional<size_t *> next_addr = std::nullopt);
 
std::shared_ptr<Component> mmio(const std::vector<fletcher::RecordBatchDescription> &batches,
                                const std::vector<MmioReg> &regs,
                                Axi4LiteSpec axi_spec);
 
}  // namespace fletchgen