misoclib/dvisampler/__init__.py

   1 from migen.fhdl.std import *
   2 from migen.bank.description import AutoCSR
   3
   4 from misoclib.dvisampler.edid import EDID
   5 from misoclib.dvisampler.clocking import Clocking
   6 from misoclib.dvisampler.datacapture import DataCapture
   7 from misoclib.dvisampler.charsync import CharSync
   8 from misoclib.dvisampler.wer import WER
   9 from misoclib.dvisampler.decoding import Decoding
  10 from misoclib.dvisampler.chansync import ChanSync
  11 from misoclib.dvisampler.analysis import SyncPolarity, ResolutionDetection, FrameExtraction
  12 from misoclib.dvisampler.dma import DMA
  13
  14 class DVISampler(Module, AutoCSR):
  15         def __init__(self, pads, lasmim, n_dma_slots=2):
  16                 self.submodules.edid = EDID(pads)
  17                 self.submodules.clocking = Clocking(pads)
  18
  19                 for datan in range(3):
  20                         name = "data" + str(datan)
  21
  22                         cap = DataCapture(getattr(pads, name + "_p"), getattr(pads, name + "_n"), 8)
  23                         setattr(self.submodules, name + "_cap", cap)
  24                         self.comb += cap.serdesstrobe.eq(self.clocking.serdesstrobe)
  25
  26                         charsync = CharSync()
  27                         setattr(self.submodules, name + "_charsync", charsync)
  28                         self.comb += charsync.raw_data.eq(cap.d)
  29
  30                         wer = WER()
  31                         setattr(self.submodules, name + "_wer", wer)
  32                         self.comb += wer.data.eq(charsync.data)
  33
  34                         decoding = Decoding()
  35                         setattr(self.submodules, name + "_decod", decoding)
  36                         self.comb += [
  37                                 decoding.valid_i.eq(charsync.synced),
  38                                 decoding.input.eq(charsync.data)
  39                         ]
  40
  41                 self.submodules.chansync = ChanSync()
  42                 self.comb += [
  43                         self.chansync.valid_i.eq(self.data0_decod.valid_o & \
  44                           self.data1_decod.valid_o & self.data2_decod.valid_o),
  45                         self.chansync.data_in0.eq(self.data0_decod.output),
  46                         self.chansync.data_in1.eq(self.data1_decod.output),
  47                         self.chansync.data_in2.eq(self.data2_decod.output),
  48                 ]
  49
  50                 self.submodules.syncpol = SyncPolarity()
  51                 self.comb += [
  52                         self.syncpol.valid_i.eq(self.chansync.chan_synced),
  53                         self.syncpol.data_in0.eq(self.chansync.data_out0),
  54                         self.syncpol.data_in1.eq(self.chansync.data_out1),
  55                         self.syncpol.data_in2.eq(self.chansync.data_out2)
  56                 ]
  57
  58                 self.submodules.resdetection = ResolutionDetection()
  59                 self.comb += [
  60                         self.resdetection.valid_i.eq(self.syncpol.valid_o),
  61                         self.resdetection.de.eq(self.syncpol.de),
  62                         self.resdetection.vsync.eq(self.syncpol.vsync)
  63                 ]
  64
  65                 self.submodules.frame = FrameExtraction(24*lasmim.dw//32)
  66                 self.comb += [
  67                         self.frame.valid_i.eq(self.syncpol.valid_o),
  68                         self.frame.de.eq(self.syncpol.de),
  69                         self.frame.vsync.eq(self.syncpol.vsync),
  70                         self.frame.r.eq(self.syncpol.r),
  71                         self.frame.g.eq(self.syncpol.g),
  72                         self.frame.b.eq(self.syncpol.b)
  73                 ]
  74
  75                 self.submodules.dma = DMA(lasmim, n_dma_slots)
  76                 self.comb += self.frame.frame.connect(self.dma.frame)
  77                 self.ev = self.dma.ev
  78
  79         autocsr_exclude = {"ev"}