1 from migen
.fhdl
.structure
import *
2 from migen
.fhdl
.specials
import Instance
3 from migen
.flow
.actor
import *
4 from migen
.flow
.network
import *
5 from migen
.flow
.transactions
import *
6 from migen
.flow
import plumbing
7 from migen
.actorlib
import misc
, dma_asmi
, structuring
, sim
, spi
8 from migen
.bank
.description
import *
9 from migen
.bank
import csrgen
32 class _FrameInitiator(spi
.SingleGenerator
):
33 def __init__(self
, asmi_bits
, length_bits
, alignment_bits
):
35 ("hres", _hbits
, 640),
36 ("hsync_start", _hbits
, 656),
37 ("hsync_end", _hbits
, 752),
38 ("hscan", _hbits
, 799),
40 ("vres", _vbits
, 480),
41 ("vsync_start", _vbits
, 492),
42 ("vsync_end", _vbits
, 494),
43 ("vscan", _vbits
, 524),
45 ("base", asmi_bits
, 0, alignment_bits
),
46 ("length", length_bits
, 640*480*4, alignment_bits
)
48 spi
.SingleGenerator
.__init
__(self
, layout
, spi
.MODE_CONTINUOUS
)
55 ("hsync_start", _hbits
),
56 ("hsync_end", _hbits
),
59 ("vsync_start", _vbits
),
60 ("vsync_end", _vbits
),
62 ("pixels", Sink
, _pixel_layout
),
63 ("dac", Source
, _dac_layout
)
66 def get_fragment(self
):
71 generate_en
= Signal()
72 hcounter
= Signal(_hbits
)
73 vcounter
= Signal(_vbits
)
75 skip
= _bpc
- _bpc_dac
77 active
.eq(hactive
& vactive
),
79 self
.token("dac").r
.eq(self
.token("pixels").r
[skip
:]),
80 self
.token("dac").g
.eq(self
.token("pixels").g
[skip
:]),
81 self
.token("dac").b
.eq(self
.token("pixels").b
[skip
:])
84 generate_en
.eq(self
.endpoints
["timing"].stb
& (~active | self
.endpoints
["pixels"].stb
)),
85 self
.endpoints
["pixels"].ack
.eq(self
.endpoints
["dac"].ack
& active
),
86 self
.endpoints
["dac"].stb
.eq(generate_en
)
88 tp
= self
.token("timing")
90 self
.endpoints
["timing"].ack
.eq(0),
91 If(generate_en
& self
.endpoints
["dac"].ack
,
92 hcounter
.eq(hcounter
+ 1),
94 If(hcounter
== 0, hactive
.eq(1)),
95 If(hcounter
== tp
.hres
, hactive
.eq(0)),
96 If(hcounter
== tp
.hsync_start
, self
.token("dac").hsync
.eq(1)),
97 If(hcounter
== tp
.hsync_end
, self
.token("dac").hsync
.eq(0)),
98 If(hcounter
== tp
.hscan
,
100 If(vcounter
== tp
.vscan
,
102 self
.endpoints
["timing"].ack
.eq(1)
104 vcounter
.eq(vcounter
+ 1)
108 If(vcounter
== 0, vactive
.eq(1)),
109 If(vcounter
== tp
.vres
, vactive
.eq(0)),
110 If(vcounter
== tp
.vsync_start
, self
.token("dac").vsync
.eq(1)),
111 If(vcounter
== tp
.vsync_end
, self
.token("dac").vsync
.eq(0))
115 return Fragment(comb
, sync
)
119 Actor
.__init
__(self
, ("dac", Sink
, _dac_layout
))
121 self
.vga_hsync_n
= Signal()
122 self
.vga_vsync_n
= Signal()
123 self
.vga_r
= Signal(_bpc_dac
)
124 self
.vga_g
= Signal(_bpc_dac
)
125 self
.vga_b
= Signal(_bpc_dac
)
127 def get_fragment(self
):
128 data_width
= 2+3*_bpc_dac
130 fifo_write_en
= Signal()
131 fifo_data_out
= Signal(data_width
)
132 fifo_data_in
= Signal(data_width
)
133 asfifo
= Instance("asfifo",
134 Instance
.Parameter("data_width", data_width
),
135 Instance
.Parameter("address_width", 8),
137 Instance
.Output("data_out", fifo_data_out
),
138 Instance
.Output("empty"),
139 Instance
.Input("read_en", 1),
140 Instance
.ClockPort("clk_read", "vga"),
142 Instance
.Input("data_in", fifo_data_in
),
143 Instance
.Output("full", fifo_full
),
144 Instance
.Input("write_en", fifo_write_en
),
145 Instance
.ClockPort("clk_write"),
147 Instance
.Input("rst", 0))
148 t
= self
.token("dac")
151 Cat(self
.vga_hsync_n
, self
.vga_vsync_n
, self
.vga_r
, self
.vga_g
, self
.vga_b
).eq(asfifo
.get_io("data_out")),
153 self
.endpoints
["dac"].ack
.eq(~fifo_full
),
154 fifo_write_en
.eq(self
.endpoints
["dac"].stb
),
155 fifo_data_in
.eq(Cat(~t
.hsync
, ~t
.vsync
, t
.r
, t
.g
, t
.b
)),
165 print("H/V:" + str(t
.value
["hsync"]) + str(t
.value
["vsync"])
166 + " " + str(t
.value
["r"]) + " " + str(t
.value
["g"]) + " " + str(t
.value
["b"]))
170 def __init__(self
, address
, asmiport
, simulation
=False):
171 asmi_bits
= asmiport
.hub
.aw
172 alignment_bits
= bits_for(asmiport
.hub
.dw
//8) - 1
173 length_bits
= _hbits
+ _vbits
+ 2 - alignment_bits
174 pack_factor
= asmiport
.hub
.dw
//_bpp
175 packed_pixels
= structuring
.pack_layout(_pixel_layout
, pack_factor
)
177 fi
= _FrameInitiator(asmi_bits
, length_bits
, alignment_bits
)
178 adrloop
= misc
.IntSequence(length_bits
, asmi_bits
)
179 adrbuffer
= AbstractActor(plumbing
.Buffer
)
180 dma
= dma_asmi
.Reader(asmiport
)
181 datbuffer
= AbstractActor(plumbing
.Buffer
)
182 cast
= structuring
.Cast(asmiport
.hub
.dw
, packed_pixels
)
183 unpack
= structuring
.Unpack(pack_factor
, _pixel_layout
)
186 fifo
= sim
.SimActor(sim_fifo_gen(), ("dac", Sink
, _dac_layout
))
191 g
.add_connection(fi
, adrloop
, source_subr
=["length", "base"])
192 g
.add_connection(adrloop
, adrbuffer
)
193 g
.add_connection(adrbuffer
, dma
)
194 g
.add_connection(dma
, datbuffer
)
195 g
.add_connection(datbuffer
, cast
)
196 g
.add_connection(cast
, unpack
)
197 g
.add_connection(unpack
, vtg
, sink_ep
="pixels")
198 g
.add_connection(fi
, vtg
, sink_ep
="timing", source_subr
=[
199 "hres", "hsync_start", "hsync_end", "hscan",
200 "vres", "vsync_start", "vsync_end", "vscan"])
201 g
.add_connection(vtg
, fifo
)
202 self
._comp
_actor
= CompositeActor(g
, debugger
=False)
204 self
.bank
= csrgen
.Bank(fi
.get_registers() + self
._comp
_actor
.get_registers(),
208 self
.vga_psave_n
= Signal()
210 self
.vga_hsync_n
= fifo
.vga_hsync_n
211 self
.vga_vsync_n
= fifo
.vga_vsync_n
212 self
.vga_sync_n
= Signal()
213 self
.vga_blank_n
= Signal()
215 self
.vga_r
= fifo
.vga_r
216 self
.vga_g
= fifo
.vga_g
217 self
.vga_b
= fifo
.vga_b
219 def get_fragment(self
):
221 self
.vga_sync_n
.eq(0),
222 self
.vga_psave_n
.eq(1),
223 self
.vga_blank_n
.eq(1)
225 return self
.bank
.get_fragment() \
226 + self
._comp
_actor
.get_fragment() \