Mapping to cell libraries

While much of this documentation focuses on the use of Yosys with FPGAs, it is also possible to map to cell libraries which can be used in designing ASICs. This section will cover a brief example project, available in the Yosys source code under docs/source/code_examples/intro/. The project contains a simple ASIC synthesis script (counter.ys), a digital design written in Verilog (counter.v), and a simple CMOS cell library (mycells.lib). Many of the early steps here are already covered in more detail in the Synthesis starter document.

Note

The counter.ys script includes the commands used to generate the images in this document. Code snippets in this document skip these commands; including line numbers to allow the reader to follow along with the source.

To learn more about these commands, check out A look at the show command.

A simple counter

First, let’s quickly look at the design:

Listing 55 counter.v

module counter (clk, rst, en, count);

	input clk, rst, en;
	output reg [1:0] count;

	always @(posedge clk)
		if (rst)
			count <= 2'd0;
		else if (en)
			count <= count + 2'd1;

endmodule

This is a simple counter with reset and enable. If the reset signal, rst, is high then the counter will reset to 0. Otherwise, if the enable signal, en, is high then the count register will increment by 1 each rising edge of the clock, clk.

Loading the design

Listing 56 counter.ys - read design

# read design
read_verilog counter.v
hierarchy -check -top counter

Our circuit now looks like this:

Fig. 27 counter after hierarchy

Coarse-grain representation

Listing 57 counter.ys - the high-level stuff

# the high-level stuff
proc; opt
memory; opt
fsm; opt

Fig. 28 Coarse-grain representation of the counter module

Logic gate mapping

Listing 58 counter.ys - mapping to internal cell library

# mapping to internal cell library
techmap; opt

Fig. 29 counter after techmap

Mapping to hardware

For this example, we are using a Liberty file to describe a cell library which our internal cell library will be mapped to:

Listing 59 mycells.lib

library(demo) {
  cell(BUF) {
    area: 6;
    pin(A) { direction: input; }
    pin(Y) { direction: output;
              function: "A"; }
  }
  cell(NOT) {
    area: 3;
    pin(A) { direction: input; }
    pin(Y) { direction: output;
              function: "A'"; }
  }
  cell(NAND) {
    area: 4;
    pin(A) { direction: input; }
    pin(B) { direction: input; }
    pin(Y) { direction: output;
             function: "(A*B)'"; }
  }
  cell(NOR) {
    area: 4;
    pin(A) { direction: input; }
    pin(B) { direction: input; }
    pin(Y) { direction: output;
             function: "(A+B)'"; }
  }
  cell(DFF) {
    area: 18;
    ff(IQ, IQN) { clocked_on: C;
                  next_state: D; }
    pin(C) { direction: input;
                 clock: true; }
    pin(D) { direction: input; }
    pin(Q) { direction: output;
              function: "IQ"; }
  }
}

Recall that the Yosys built-in logic gate types are $_NOT_, $_AND_, $_OR_, $_XOR_, and $_MUX_ with an assortment of dff memory types. mycells.lib defines our target cells as BUF, NOT, NAND, NOR, and DFF. Mapping between these is performed with the commands dfflibmap and abc as follows:

Listing 60 counter.ys - mapping to hardware

dfflibmap -liberty mycells.lib

# mapping logic to mycells.lib
abc -liberty mycells.lib

# cleanup
clean

The final version of our counter module looks like this:

Fig. 30 counter after hardware cell mapping

Before finally being output as a verilog file with write_verilog, which can then be loaded into another tool:

Listing 61 counter.ys - write synthesized design

# write synthesized design
write_verilog synth.v