bus.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 <cerata/api.h>
 
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "fletchgen/basic_types.h"
 
namespace fletchgen {
 
using cerata::Instance;
using cerata::Component;
using cerata::Port;
using cerata::intl;
using cerata::Object;
 
// Bus channel constructs.
PARAM_DECL_FACTORY(bus_addr_width, 64)
PARAM_DECL_FACTORY(bus_data_width, 512)
PARAM_DECL_FACTORY(bus_len_width, 8)
PARAM_DECL_FACTORY(bus_burst_step_len, 4)
PARAM_DECL_FACTORY(bus_burst_max_len, 16)
 
enum class BusFunction {
  READ,  
  WRITE  
};
 
struct BusDim {
  uint32_t aw = 64;   
  uint32_t dw = 512;  
  uint32_t lw = 8;    
  uint32_t bs = 1;    
  uint32_t bm = 16;   
 
  static BusDim FromString(const std::string &str, BusDim default_to);
 
  [[nodiscard]] std::string ToString() const;
  [[nodiscard]] std::string ToName() const;
};
 
bool operator==(const BusDim &lhs, const BusDim &rhs);
 
struct BusDimParams {
  explicit BusDimParams(cerata::Graph *parent, BusDim dim = BusDim{}, const std::string &prefix = "");
  explicit BusDimParams(const std::shared_ptr<cerata::Graph> &parent,
                        BusDim spec = BusDim{},
                        const std::string &prefix = "")
      : BusDimParams(parent.get(), spec, prefix) {}
  BusDim plain;
  std::shared_ptr<Node> aw;  
  std::shared_ptr<Node> dw;  
  std::shared_ptr<Node> lw;  
  std::shared_ptr<Node> bs;  
  std::shared_ptr<Node> bm;  
 
  [[nodiscard]] std::vector<std::shared_ptr<Object>> all() const;
};
 
struct BusSpecParams {
  BusDimParams dim;
  BusFunction func;
  [[nodiscard]] std::string ToName() const;
};
 
struct BusSpec {
  BusSpec() = default;
  explicit BusSpec(const BusSpecParams &params) : dim(params.dim.plain), func(params.func) {}
  BusDim dim;
  BusFunction func = BusFunction::READ;
  [[nodiscard]] std::string ToName() const;
};
 
bool operator==(const BusSpec &lhs, const BusSpec &rhs);
 
std::shared_ptr<Type> bus_read(const std::shared_ptr<Node> &addr_width,
                               const std::shared_ptr<Node> &data_width,
                               const std::shared_ptr<Node> &len_width);
 
std::shared_ptr<Type> bus_write(const std::shared_ptr<Node> &addr_width,
                                const std::shared_ptr<Node> &data_width,
                                const std::shared_ptr<Node> &len_width);
 
std::shared_ptr<Type> bus(const BusSpecParams &param);
 
struct BusPort : public Port {
  BusPort(const std::string &name,
          Port::Dir dir,
          const BusSpecParams &params,
          std::shared_ptr<ClockDomain> domain = bus_cd())
      : Port(name, bus(params), dir, std::move(domain)), spec_(params) {}
 
  BusSpecParams spec_;
 
  std::shared_ptr<Object> Copy() const override;
};
std::shared_ptr<BusPort> bus_port(const std::string &name, Port::Dir dir, const BusSpecParams &params);
std::shared_ptr<BusPort> bus_port(Port::Dir dir, const BusSpecParams &params);
 
// TODO(johanpel): Perhaps generalize and build some sort of parameter struct/bundle in cerata for fast connection.
void ConnectBusParam(cerata::Graph *dst,
                     const std::string &prefix,
                     const BusDimParams &src,
                     cerata::NodeMap *rebinding);
 
Component *bus_arbiter(BusFunction function);
 
std::shared_ptr<Component> BusReadSerializer();
 
std::shared_ptr<Component> BusWriteSerializer();
 
}  // namespace fletchgen
 
 
template<>
struct std::hash<fletchgen::BusSpec> {
  size_t operator()(fletchgen::BusSpec const &spec) const noexcept {
    auto str = spec.ToName();
    return std::hash<std::string>()(str);
  }
};