Pastebin is 300% more awesome when you are logged in. Sign Up, it's FREE!
Guest

Untitled

By: a guest on Mar 19th, 2013  |  syntax: Python  |  size: 3.43 KB  |  hits: 40  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. from migen.fhdl.structure import *
  2. from migen.fhdl.module import *
  3. from migen.bus import csr
  4. from migen.genlib.fsm import *
  5.  
  6. from miscope.bridges.uart2csr.uart import *
  7.  
  8. WRITE_CMD = 0x01
  9. READ_CMD = 0x02
  10. CLOSE_CMD = 0x03
  11.  
  12. class Uart2Csr(Module):
  13.         def __init__(self, clk_freq, baud):
  14.                 # Uart interface
  15.                 self.rx = Signal()
  16.                 self.tx = Signal()
  17.                
  18.                 # Csr interface
  19.                 self.csr = csr.Interface(32, 8)
  20.  
  21.                 self.debug = Signal()
  22.                
  23.         ###
  24.                
  25.                 self.submodules.uart = UART(clk_freq, baud)
  26.                 uart = self.uart
  27.  
  28.                 #
  29.                 # In/Out
  30.                 #
  31.                 self.comb +=[
  32.                         uart.rx.eq(self.rx),
  33.                         self.tx.eq(uart.tx)
  34.                 ]
  35.  
  36.                 cmd = Signal(8)
  37.                 cnt = Signal(3)
  38.                 sr = Signal(32)
  39.                 burst_cnt = Signal(8)
  40.                 addr = Signal(32)
  41.                 data = Signal(8)
  42.  
  43.        
  44.                 # FSM
  45.                 self.submodules.fsm = FSM("IDLE",
  46.                                                                   "GET_BL", "GET_ADDR",
  47.                                                                  "GET_DATA", "WRITE_CSR",
  48.                                                                   "READ_CSR", "SEND_DATA")
  49.  
  50.                 fsm = self.fsm
  51.                 #
  52.                 # Global
  53.                 #
  54.                 self.sync +=[
  55.                         If(fsm.ongoing(fsm.IDLE), cnt.eq(0)
  56.                         ).Elif(uart.rx_ev, cnt.eq(cnt + 1)),
  57.  
  58.                         If(uart.rx_ev, sr.eq(Cat(uart.rx_dat, sr[0:24])))
  59.  
  60.                 ]
  61.  
  62.  
  63.                 # State done
  64.                 get_bl_done = Signal()
  65.                 get_addr_done = Signal()
  66.                 get_data_done = Signal()
  67.                 send_data_done = Signal()
  68.  
  69.                 self.debug = uart.rx_dat[0]
  70.  
  71.                 #
  72.                 # Idle
  73.                 #
  74.                 fsm.act(fsm.IDLE,
  75.                         If(uart.rx_ev & ((uart.rx_dat == WRITE_CMD) | (uart.rx_dat == READ_CMD)),
  76.                                 fsm.next_state(fsm.GET_BL)
  77.                         )
  78.                 )
  79.  
  80.                 self.sync +=[
  81.                         If(fsm.ongoing(fsm.IDLE) & uart.rx_ev,
  82.                                 cmd.eq(uart.rx_dat)
  83.                         )      
  84.  
  85.                 ]
  86.  
  87.                 #
  88.             # Get burst length
  89.             #
  90.                 fsm.act(fsm.GET_BL,
  91.                         If(get_bl_done,
  92.                                 fsm.next_state(fsm.GET_ADDR)
  93.                         )
  94.                 )
  95.  
  96.                 self.comb += get_bl_done.eq(uart.rx_ev & fsm.ongoing(fsm.GET_BL))
  97.  
  98.                 self.sync +=[
  99.                         If(get_bl_done,
  100.                                 burst_cnt.eq(uart.rx_dat)
  101.                         )
  102.                 ]
  103.  
  104.                 #
  105.                 # Get address
  106.                 #
  107.                 fsm.act(fsm.GET_ADDR,
  108.                         If(get_addr_done & (cmd == WRITE_CMD),
  109.                                 fsm.next_state(fsm.GET_DATA)
  110.                         ).Elif(get_addr_done & (cmd == READ_CMD),
  111.                                 fsm.next_state(fsm.READ_CSR)
  112.                         )      
  113.                 )
  114.  
  115.                 self.comb += get_addr_done.eq(uart.rx_ev & (cnt == 4) & fsm.ongoing(fsm.GET_ADDR))
  116.                
  117.                 self.sync +=[
  118.                         If(get_addr_done,
  119.                                 addr.eq(sr)
  120.                         ).Elif(fsm.exiting(fsm.WRITE_CSR) | send_data_done,
  121.                                 addr.eq(addr + 4)
  122.                         )
  123.                 ]
  124.  
  125.                 #
  126.                 # Get data
  127.                 #
  128.                 fsm.act(fsm.GET_DATA,
  129.                         If(get_data_done,
  130.                                 fsm.next_state(fsm.WRITE_CSR)
  131.                         )
  132.                 )
  133.  
  134.                 self.comb += get_data_done.eq(uart.rx_ev & fsm.ongoing(fsm.GET_DATA))  
  135.  
  136.                 self.sync +=[
  137.                         If(get_data_done,
  138.                                 burst_cnt.eq(burst_cnt-1),
  139.                                 data.eq(uart.rx_dat)
  140.                         )
  141.                 ]
  142.  
  143.                 #
  144.                 # Write Csr
  145.                 #
  146.                 fsm.act(fsm.WRITE_CSR,
  147.                         If((burst_cnt==0),
  148.                                 fsm.next_state(fsm.IDLE)
  149.                         ).Else(fsm.next_state(fsm.GET_DATA))
  150.                 )
  151.  
  152.                 #
  153.                 # Read Csr
  154.                 #
  155.                 fsm.act(fsm.READ_CSR,
  156.                         If(~uart.tx_ev,
  157.                                 fsm.next_state(fsm.SEND_DATA)
  158.                         )
  159.                 )
  160.  
  161.                 #
  162.                 # Send Data
  163.                 #
  164.                 fsm.act(fsm.SEND_DATA,
  165.                   If(send_data_done & (burst_cnt==0),
  166.                                 fsm.next_state(fsm.IDLE)
  167.                         )
  168.                         #If(send_data_done & (burst_cnt==0),
  169.                         #       fsm.next_state(fsm.IDLE)
  170.                         #).Elif(send_data_done,
  171.                         #       fsm.next_state(fsm.READ_CSR)
  172.                         #)
  173.                 )
  174.  
  175.                 self.comb += [
  176.                                 uart.tx_dat.eq(self.csr.dat_r),
  177.                                 uart.tx_we.eq(fsm.entering(fsm.SEND_DATA)),
  178.                                 send_data_done.eq(fsm.ongoing(fsm.SEND_DATA) & uart.tx_ev)
  179.                 ]
  180.  
  181.                 #
  182.                 # Csr access
  183.                 #
  184.                 self.sync +=[
  185.                         self.csr.adr.eq(addr),
  186.                         self.csr.dat_w.eq(data),
  187.                         If(fsm.ongoing(fsm.WRITE_CSR),
  188.                                 self.csr.we.eq(1)
  189.                         ).Else(
  190.                                 self.csr.we.eq(0)      
  191.                         )
  192.                 ]