Guest User

Untitled

a guest
Mar 19th, 2013
96
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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.         ]
RAW Paste Data