nextpnr/ice40/chip.h

/*
 *  nextpnr -- Next Generation Place and Route
 *
 *  Copyright (C) 2018  Clifford Wolf <clifford@clifford.at>
 *
 *  Permission to use, copy, modify, and/or distribute this software for any
 *  purpose with or without fee is hereby granted, provided that the above
 *  copyright notice and this permission notice appear in all copies.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

#include "design.h"

#ifndef CHIP_H
#define CHIP_H

struct DelayInfo
{
    float delay = 0;

    float raiseDelay() { return delay; }
    float fallDelay() { return delay; }
};

// -----------------------------------------------------------------------

enum BelType
{
    TYPE_NIL,
    TYPE_ICESTORM_LC,
    TYPE_ICESTORM_RAM,
    TYPE_SB_IO
};

IdString belTypeToId(BelType type);
BelType belTypeFromId(IdString id);

enum PortPin
{
    PIN_NIL,

    PIN_IN_0,
    PIN_IN_1,
    PIN_IN_2,
    PIN_IN_3,
    PIN_O,
    PIN_LO,
    PIN_CIN,
    PIN_COUT,
    PIN_CEN,
    PIN_CLK,
    PIN_SR,

    PIN_MASK_0,
    PIN_MASK_1,
    PIN_MASK_2,
    PIN_MASK_3,
    PIN_MASK_4,
    PIN_MASK_5,
    PIN_MASK_6,
    PIN_MASK_7,
    PIN_MASK_8,
    PIN_MASK_9,
    PIN_MASK_10,
    PIN_MASK_11,
    PIN_MASK_12,
    PIN_MASK_13,
    PIN_MASK_14,
    PIN_MASK_15,

    PIN_RDATA_0,
    PIN_RDATA_1,
    PIN_RDATA_2,
    PIN_RDATA_3,
    PIN_RDATA_4,
    PIN_RDATA_5,
    PIN_RDATA_6,
    PIN_RDATA_7,
    PIN_RDATA_8,
    PIN_RDATA_9,
    PIN_RDATA_10,
    PIN_RDATA_11,
    PIN_RDATA_12,
    PIN_RDATA_13,
    PIN_RDATA_14,
    PIN_RDATA_15,

    PIN_WDATA_0,
    PIN_WDATA_1,
    PIN_WDATA_2,
    PIN_WDATA_3,
    PIN_WDATA_4,
    PIN_WDATA_5,
    PIN_WDATA_6,
    PIN_WDATA_7,
    PIN_WDATA_8,
    PIN_WDATA_9,
    PIN_WDATA_10,
    PIN_WDATA_11,
    PIN_WDATA_12,
    PIN_WDATA_13,
    PIN_WDATA_14,
    PIN_WDATA_15,

    PIN_WADDR_0,
    PIN_WADDR_1,
    PIN_WADDR_2,
    PIN_WADDR_3,
    PIN_WADDR_4,
    PIN_WADDR_5,
    PIN_WADDR_6,
    PIN_WADDR_7,
    PIN_WADDR_8,
    PIN_WADDR_9,
    PIN_WADDR_10,

    PIN_RADDR_0,
    PIN_RADDR_1,
    PIN_RADDR_2,
    PIN_RADDR_3,
    PIN_RADDR_4,
    PIN_RADDR_5,
    PIN_RADDR_6,
    PIN_RADDR_7,
    PIN_RADDR_8,
    PIN_RADDR_9,
    PIN_RADDR_10,

    PIN_WCLK,
    PIN_WCLKE,
    PIN_WE,

    PIN_RCLK,
    PIN_RCLKE,
    PIN_RE,

    PIN_PACKAGE_PIN,
    PIN_LATCH_INPUT_VALUE,
    PIN_CLOCK_ENABLE,
    PIN_INPUT_CLK,
    PIN_OUTPUT_CLK,
    PIN_OUTPUT_ENABLE,
    PIN_D_OUT_0,
    PIN_D_OUT_1,
    PIN_D_IN_0,
    PIN_D_IN_1
};

IdString PortPinToId(PortPin type);
PortPin PortPinFromId(IdString id);

// -----------------------------------------------------------------------

struct BelInfoPOD
{
    const char *name;
    BelType type;
    int8_t x, y, z;
};

struct BelPortPOD
{
    int32_t bel_index;
    PortPin port;
};

struct PipInfoPOD
{
    int32_t src, dst;
    float delay;
    int8_t x, y;
};

struct WireInfoPOD
{
    const char *name;
    int num_uphill, num_downhill;
    int *pips_uphill, *pips_downhill;

    int num_bels_downhill;
    BelPortPOD bel_uphill;
    BelPortPOD *bels_downhill;

    float x, y;
};

struct ChipInfoPOD
{
    int width, height;
    int num_bels, num_wires, num_pips;
    BelInfoPOD *bel_data;
    WireInfoPOD *wire_data;
    PipInfoPOD *pip_data;
};

extern ChipInfoPOD chip_info_384;
extern ChipInfoPOD chip_info_1k;
extern ChipInfoPOD chip_info_5k;
extern ChipInfoPOD chip_info_8k;

// -----------------------------------------------------------------------

struct BelId
{
    int32_t index = -1;

    bool nil() const { return index < 0; }

    bool operator==(const BelId &other) const { return index == other.index; }
    bool operator!=(const BelId &other) const { return index != other.index; }
};

struct WireId
{
    int32_t index = -1;

    bool nil() const { return index < 0; }

    bool operator==(const WireId &other) const { return index == other.index; }
    bool operator!=(const WireId &other) const { return index != other.index; }
};

struct PipId
{
    int32_t index = -1;

    bool nil() const { return index < 0; }

    bool operator==(const PipId &other) const { return index == other.index; }
    bool operator!=(const PipId &other) const { return index != other.index; }
};

struct BelPin
{
    BelId bel;
    PortPin pin;
};

namespace std {
template <> struct hash<BelId>
{
    std::size_t operator()(const BelId &bel) const noexcept
    {
        return bel.index;
    }
};

template <> struct hash<WireId>
{
    std::size_t operator()(const WireId &wire) const noexcept
    {
        return wire.index;
    }
};

template <> struct hash<PipId>
{
    std::size_t operator()(const PipId &wire) const noexcept
    {
        return wire.index;
    }
};
}

// -----------------------------------------------------------------------

struct BelIterator
{
    int cursor;

    BelIterator operator++() { cursor++; return *this; }
    BelIterator operator++(int) {
		BelIterator	prior(*this);
		cursor++;
		return prior;
	}

    bool operator!=(const BelIterator &other) const
    {
        return cursor != other.cursor;
    }

    bool operator==(const BelIterator &other) const
    {
        return cursor == other.cursor;
    }

    BelId operator*() const
    {
        BelId ret;
        ret.index = cursor;
        return ret;
    }
};

struct BelRange
{
    BelIterator b, e;
    BelIterator begin() const { return b; }
    BelIterator end() const { return e; }
};

// -----------------------------------------------------------------------

struct BelPinIterator
{
    BelPortPOD *ptr = nullptr;

    void operator++() { ptr++; }
    bool operator!=(const BelPinIterator &other) const
    {
        return ptr != other.ptr;
    }

    BelPin operator*() const
    {
        BelPin ret;
        ret.bel.index = ptr->bel_index;
        ret.pin = ptr->port;
        return ret;
    }
};

struct BelPinRange
{
    BelPinIterator b, e;
    BelPinIterator begin() const { return b; }
    BelPinIterator end() const { return e; }
};

// -----------------------------------------------------------------------

struct WireIterator
{
    int cursor = -1;

    void operator++() { cursor++; }
    bool operator!=(const WireIterator &other) const
    {
        return cursor != other.cursor;
    }

    WireId operator*() const
    {
        WireId ret;
        ret.index = cursor;
        return ret;
    }
};

struct WireRange
{
    WireIterator b, e;
    WireIterator begin() const { return b; }
    WireIterator end() const { return e; }
};

// -----------------------------------------------------------------------

struct AllPipIterator
{
    int cursor = -1;

    void operator++() { cursor++; }
    bool operator!=(const AllPipIterator &other) const
    {
        return cursor != other.cursor;
    }

    PipId operator*() const
    {
        PipId ret;
        ret.index = cursor;
        return ret;
    }
};

struct AllPipRange
{
    AllPipIterator b, e;
    AllPipIterator begin() const { return b; }
    AllPipIterator end() const { return e; }
};

// -----------------------------------------------------------------------

struct PipIterator
{
    int *cursor = nullptr;

    void operator++() { cursor++; }
    bool operator!=(const PipIterator &other) const
    {
        return cursor != other.cursor;
    }

    PipId operator*() const
    {
        PipId ret;
        ret.index = *cursor;
        return ret;
    }
};

struct PipRange
{
    PipIterator b, e;
    PipIterator begin() const { return b; }
    PipIterator end() const { return e; }
};

// -----------------------------------------------------------------------

struct ChipArgs
{
    enum
    {
        NONE,
        LP384,
        LP1K,
        LP8K,
        HX1K,
        HX8K,
        UP5K
    } type = NONE;
};

struct Chip
{
    ChipInfoPOD chip_info;

    mutable dict<IdString, int> bel_by_name;
    mutable dict<IdString, int> wire_by_name;
    mutable dict<IdString, int> pip_by_name;

    Chip(ChipArgs args);

    // -------------------------------------------------

    BelId getBelByName(IdString name) const;

    IdString getBelName(BelId bel) const
    {
        assert(!bel.nil());
        return chip_info.bel_data[bel.index].name;
    }

    void bindBel(BelId bel, IdString cell) {}

    void unbindBel(BelId bel) {}

    bool checkBelAvail(BelId bel) const {}

    BelRange getBels() const
    {
        BelRange range;
        range.b.cursor = 0;
        range.e.cursor = chip_info.num_bels;
        return range;
    }

    BelRange getBelsByType(BelType type) const
    {
        BelRange range;
// FIXME
#if 0
		if (type == "TYPE_A") {
			range.b.cursor = bels_type_a_begin;
			range.e.cursor = bels_type_a_end;
		}
		...
#endif
        return range;
    }

    BelType getBelType(BelId bel) const
    {
        assert(!bel.nil());
        return chip_info.bel_data[bel.index].type;
    }

    WireId getWireBelPin(BelId bel, PortPin pin) const;

    BelPin getBelPinUphill(WireId wire) const
    {
        BelPin ret;
        assert(!wire.nil());

        if (chip_info.wire_data[wire.index].bel_uphill.bel_index >= 0) {
            ret.bel.index =
                    chip_info.wire_data[wire.index].bel_uphill.bel_index;
            ret.pin = chip_info.wire_data[wire.index].bel_uphill.port;
        }

        return ret;
    }

    BelPinRange getBelPinsDownhill(WireId wire) const
    {
        BelPinRange range;
        assert(!wire.nil());
        range.b.ptr = chip_info.wire_data[wire.index].bels_downhill;
        range.e.ptr =
                range.b.ptr + chip_info.wire_data[wire.index].num_bels_downhill;
        return range;
    }

    // -------------------------------------------------

    WireId getWireByName(IdString name) const;

    IdString getWireName(WireId wire) const
    {
        assert(!wire.nil());
        return chip_info.wire_data[wire.index].name;
    }

    void bindWire(WireId bel, IdString net) {}

    void unbindWire(WireId bel) {}

    bool checkWireAvail(WireId bel) const {}

    WireRange getWires() const
    {
        WireRange range;
        range.b.cursor = 0;
        range.e.cursor = chip_info.num_wires;
        return range;
    }

    // -------------------------------------------------

    PipId getPipByName(IdString name) const;

    IdString getPipName(PipId pip) const
    {
        assert(!pip.nil());
        std::string src_name =
                chip_info.wire_data[chip_info.pip_data[pip.index].src].name;
        std::string dst_name =
                chip_info.wire_data[chip_info.pip_data[pip.index].dst].name;
        return src_name + "->" + dst_name;
    }

    void bindPip(PipId bel, IdString net) {}

    void unbindPip(PipId bel) {}

    bool checkPipAvail(PipId bel) const {}

    AllPipRange getPips() const
    {
        AllPipRange range;
        range.b.cursor = 0;
        range.e.cursor = chip_info.num_pips;
        return range;
    }

    WireId getPipSrcWire(PipId pip) const
    {
        WireId wire;
        assert(!pip.nil());
        wire.index = chip_info.pip_data[pip.index].src;
        return wire;
    }

    WireId getPipDstWire(PipId pip) const
    {
        WireId wire;
        assert(!pip.nil());
        wire.index = chip_info.pip_data[pip.index].dst;
        return wire;
    }

    DelayInfo getPipDelay(PipId pip) const
    {
        DelayInfo delay;
        assert(!pip.nil());
        delay.delay = chip_info.pip_data[pip.index].delay;
        return delay;
    }

    PipRange getPipsDownhill(WireId wire) const
    {
        PipRange range;
        assert(!wire.nil());
        range.b.cursor = chip_info.wire_data[wire.index].pips_downhill;
        range.e.cursor =
                range.b.cursor + chip_info.wire_data[wire.index].num_downhill;
        return range;
    }

    PipRange getPipsUphill(WireId wire) const
    {
        PipRange range;
        assert(!wire.nil());
        range.b.cursor = chip_info.wire_data[wire.index].pips_uphill;
        range.e.cursor =
                range.b.cursor + chip_info.wire_data[wire.index].num_uphill;
        return range;
    }

    PipRange getWireAliases(WireId wire) const
    {
        PipRange range;
        assert(!wire.nil());
        range.b.cursor = nullptr;
        range.e.cursor = nullptr;
        return range;
    }

    // -------------------------------------------------

    void getBelPosition(BelId bel, float &x, float &y) const;
    void getWirePosition(WireId wire, float &x, float &y) const;
    void getPipPosition(PipId pip, float &x, float &y) const;
    vector<GraphicElement> getBelGraphics(BelId bel) const;
    vector<GraphicElement> getWireGraphics(WireId wire) const;
    vector<GraphicElement> getPipGraphics(PipId pip) const;
    vector<GraphicElement> getFrameGraphics() const;
};

#endif