MicroBlaze + DDR3 + my_IP на AXI, подключение к AXI Опции

[zuuuuk]

Добрый день.
У меня система на SPARTAN6 Mbz + MCB_DDR3 на шине AXI.
Я хочу подключить свой IP блок ко второму порту MCB и получить доступ к DDR3.
т.е. мой IP блок должен быть мастером. Для чтения данных из DDR3.

Подскажите,пожалуйста, какой-нибудь пример подключения своего IP к шине AXI.

[Golikov A.]

то данные из data_in на этом же цикле записываются в fifo.
цикле чего? когда на врайте 1, то каждый такт клока данные записываются, и произойдет это по переднему фронту.

Вот что-то такое и было на тестовом проекте.
да я тоже планирую подразогнать, но сильно усугубляет ЛвИП, все же он много чего еще делает кроме передачи данных...

Зачем нужны регистры, если речь идет о прокачке 2 MB/sec ?
для удобства пользования.

я сделал модуль у которого с одной стороны доступ через акси, через регистры, пишеш в регистр, данные в фифо проваливаются, с другой стороны уже контакты к исполняемым устройствам и автомат управления.


мне когда я генерю такую штуку получаю такой файл, это уже помененный мной,
по умолчанию он регистрам дает имена reg_0 reg_1 ....
и адреса
00001
00010
00100
....

Код

// ------------------------------------------------------
  // Example code to read/write user logic slave model s/w accessible registers
  //
  // Note:
  // The example code presented here is to show you one way of reading/writing
  // software accessible registers implemented in the user logic slave model.
  // Each bit of the Bus2IP_WrCE/Bus2IP_RdCE signals is configured to correspond
  // to one software accessible register by the top level template. For example,
  // if you have four 32 bit software accessible registers in the user logic,
  // you are basically operating on the following memory mapped registers:
  //
  //    Bus2IP_WrCE/Bus2IP_RdCE   Memory Mapped Register
  //                     "1000"   C_BASEADDR + 0x0
  //                     "0100"   C_BASEADDR + 0x4
  //                     "0010"   C_BASEADDR + 0x8
  //                     "0001"   C_BASEADDR + 0xC
  //
  // ------------------------------------------------------

  assign
    slv_reg_write_sel = Bus2IP_WrCE[10:0],
    slv_reg_read_sel  = Bus2IP_RdCE[10:0],
    slv_write_ack     = Bus2IP_WrCE[0] || Bus2IP_WrCE[1] || Bus2IP_WrCE[2] || Bus2IP_WrCE[3] || Bus2IP_WrCE[4] || Bus2IP_WrCE[5] || Bus2IP_WrCE[6] || Bus2IP_WrCE[7] || Bus2IP_WrCE[8] || Bus2IP_WrCE[9]  || Bus2IP_WrCE[10],
    slv_read_ack      = Bus2IP_RdCE[0] || Bus2IP_RdCE[1] || Bus2IP_RdCE[2] || Bus2IP_RdCE[3] || Bus2IP_RdCE[4] || Bus2IP_RdCE[5] || Bus2IP_RdCE[6] || Bus2IP_RdCE[7] || Bus2IP_RdCE[8] || Bus2IP_RdCE[9]  || Bus2IP_RdCE[10];

  // implement slave model register(s)
  always @( posedge Bus2IP_Clk )
    begin

      if ( Bus2IP_Resetn == 1'b0 )
        begin
                    fifo_write_signal <= 0;
          command_reg <= 0;
          path_data_reg <= 0;
          start_step_time_reg <= 0;
          max_step_time_reg <= 0;
          min_step_time_reg <= 0;
          step_time_plus_reg <= 0;
          step_time_minus_reg <= 0;
          stop_path_length <= 0;
          step_len <= 0;
                    dir_len <= 0;
                    STATUS_ADDR <= MAIN_STATUS;
        end
      else
                begin
                    //сбрасываем флаг если нет сигнала записи в данные пути
                    if(slv_reg_write_sel !=  11'b0000000010)
                        fifo_write_signal <= 2'b00;    

                    case ( slv_reg_write_sel )
                        STATUS_REG_CE : //запись в регистр статуса - выбор регистра
                            begin
                                if ( Bus2IP_BE[0] == 1 ) //только младший байт
                                    STATUS_ADDR <=  Bus2IP_Data[STATUS_ADR_SIZE - 1 : 0];
                            end
                        COMMAND_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    command_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        PATH_DATA_REG_CE :
                            begin
                                for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                    if ( Bus2IP_BE[byte_index] == 1 )
                                        path_data_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                                
                                //по клоку надо выдать строб на запись в фифо
                                if(fifo_write_signal == 0)
                                    fifo_write_signal <= 2'b01;
                                //по следующему клоку надо снять строб, но не поставить заново если будет еще клок
                                else if (fifo_write_signal == 2'b01)
                                    fifo_write_signal <= 2'b10;
                                //когда убиреться разрешение на запись, флаг сброситься в 0    
                            end            
                        START_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    start_step_time_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        MAX_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    max_step_time_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        MIN_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    min_step_time_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        PLUS_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    step_time_plus_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        MINUS_STEP_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    step_time_minus_reg[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        STOP_PATH_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    stop_path_length[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        STEP_LEN_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    step_len[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        STEP_DIR_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    dir_len[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];
                        default :
                            begin
                            end
                    endcase
                end    
    end // SLAVE_REG_WRITE_PROC

  // implement slave model register read mux
  always @( slv_reg_read_sel or status_reg or command_reg or path_data_reg or start_step_time_reg or max_step_time_reg or min_step_time_reg or step_time_plus_reg or step_time_minus_reg or stop_path_length or step_len or dir_len)
    begin
      case ( slv_reg_read_sel )
        STATUS_REG_CE : slv_ip2bus_data <= status_reg;
        COMMAND_REG_CE : slv_ip2bus_data <= command_reg;
        PATH_DATA_REG_CE : slv_ip2bus_data <= path_data_reg;
        START_STEP_REG_CE : slv_ip2bus_data <= start_step_time_reg;
        MAX_STEP_REG_CE : slv_ip2bus_data <= max_step_time_reg;
        MIN_STEP_REG_CE : slv_ip2bus_data <= min_step_time_reg;
        PLUS_STEP_REG_CE : slv_ip2bus_data <= step_time_plus_reg;
        MINUS_STEP_REG_CE : slv_ip2bus_data <= step_time_minus_reg;
        STOP_PATH_REG_CE : slv_ip2bus_data <= stop_path_length;
        STEP_LEN_REG_CE : slv_ip2bus_data <= step_len;
                STEP_DIR_REG_CE : slv_ip2bus_data <= dir_len;
        default : slv_ip2bus_data <= 0;
      endcase

    end // SLAVE_REG_READ_PROC

[serg_k1]

я сделал модуль у которого с одной стороны доступ через акси, через регистры, пишеш в регистр, данные в фифо проваливаются, с другой стороны уже контакты к исполняемым устройствам и автомат управления.


мне когда я генерю такую штуку получаю такой файл, это уже помененный мной,
по умолчанию он регистрам дает имена reg_0 reg_1 ....
и адреса
00001
00010
00100
....

да такой код есть . буду разбираться. я так понимаю , что он для записи и чтения ФИФО. а вот после него идет другая часть. для инициализации и запуска одиночной записи. я то думал , что нужно ей пользоваться для реализации алгоритма записи с помощью этого компонента. только не одиночной как в примере ,а Burst Write Transaction . как Figure 10: Example Burst Write Transaction Timing DS844.

Код

//  ------------------------------------------
// Example code to demonstrate user logic master model functionality
//
// Note:
// The example code presented here is to show you one way of instatiating
// the AXI4 (Burst) master interface under user control. It is provided for
// demonstration purposes only and allows the user to exercise the AXI4 (Burst)
// master interface during test and evaluation of the template.
// This user logic master model contains a 16-byte flattened register and
// the user is required to initialize the value to desire and then write to
// the model's 'Go' port to initiate the user logic master operation.
//
//    Control Register     (C_BASEADDR + OFFSET + 0x0):
//       bit 0    - Rd     (Read Request Control)
//       bit 1    - Wr     (Write Request Control)
//       bit 2    - BL     (Bus Lock Control)
//       bit 3    - Brst   (Burst Assertion Control)
//       bit 4-7  - Spare  (Spare Control Bits)
//    Status Register      (C_BASEADDR + OFFSET + 0x1):
//       bit 0    - Done   (Transfer Done Status)
//       bit 1    - Busy   (User Logic Master is Busy)
//       bit 2    - Error  (User Logic Master request got error response)
//       bit 3    - Tmout  (User Logic Master request is timeout)
//       bit 2-7  - Spare  (Spare Status Bits)
//    Addrress Register    (C_BASEADDR + OFFSET + 0x4):
//       bit 0-31 - Target Address (This 32-bit value is used to populate the
//                  ip2bus_Mst_Addr(0:31) address bus during a Read or Write
//                  user logic master operation)
//    Byte Enable Register (C_BASEADDR + OFFSET + 0x8):
//       bit 0-15 - Master BE (This 16-bit value is used to populate the
//                  ip2bus_Mst_BE byte enable bus during a Read or Write user
//                  logic master operation for single data beat transfer)
//    Length Register      (C_BASEADDR + OFFSET + 0xC):
//       bit 0-3  - Reserved
//       bit 4-15 - Transfer Length (This 12-bit value is used to populate the
//                  ip2bus_Mst_Length(0:11) transfer length bus which specifies
//                  the number of bytes (1 to 4095) to transfer during user logic
//                  master Read or Write fixed length burst operations)
//    Go Register          (C_BASEADDR + OFFSET + 0xF):
//       bit 0-7  - Go Port (Write to this byte address initiates the user
//                  logic master transfer, data key value of 0x0A must be used)
//
//    Note: OFFSET may be different depending on your address space configuration,
//          by default it's 0x100. Refer to IPIF address range array
//          for actual value.
//
// Here's an example procedure in your software application to initiate a 64-byte
// read operation (single data beat) of this master model:
//    1. write 0x09 to the control register to perform write operation.
//    2. write the target address to the address register.
//    3. write valid byte lane value to the be register
//      - note: this value must be aligned with ip2bus address  
//    4. write 0x040 to the length register
//    5. write 0x0a to the go register, this will start the master write operation
//
// Here's an example procedure in your software application to initiate a 64-byte
// write operation (single data beat) of this master model:
//   1. write 0x0A to the control register to perform write operation.
//   2. write the target address to the address register
//   3. write valid byte lane value to the be register
//      - note: this value must be aligned with ip2bus address
//   4. write 0x0040 to the length register
//   5. write 0x0a to the go register, this will start the master write operation
//
//----------------------------------------
  assign mst_reg_write_req = Bus2IP_WrCE[10] || Bus2IP_WrCE[11] || Bus2IP_WrCE[12] || Bus2IP_WrCE[13];
  assign mst_reg_read_req  = Bus2IP_RdCE[10] || Bus2IP_RdCE[11] || Bus2IP_RdCE[12] || Bus2IP_RdCE[13];
  assign mst_reg_write_sel = Bus2IP_WrCE[13 : 10];
  assign mst_reg_read_sel  = Bus2IP_RdCE[13 : 10];
  assign mst_write_ack     = mst_reg_write_req;
  assign mst_read_ack      = mst_reg_read_req;

  // rip control bits from master model registers
  assign mst_cntl_rd_req   = mst_reg[0][0];
  assign mst_cntl_wr_req   = mst_reg[0][1];
  assign mst_cntl_bus_lock = mst_reg[0][2];
  assign mst_cntl_burst    = mst_reg[0][3];
  assign mst_ip2bus_addr   = {mst_reg[7], mst_reg[6], mst_reg[5], mst_reg[4]};
  assign mst_ip2bus_be     = {mst_reg[9], mst_reg[8]};
  assign mst_xfer_reg_len  = {mst_reg[14][3 : 0], mst_reg[13], mst_reg[12]};// changed to 20 bits
  assign mst_xfer_length   = mst_xfer_reg_len[C_LENGTH_WIDTH-1 : 0];

  // implement byte write enable for each byte slice of the master model registers
  always @ (Bus2IP_BE or mst_reg_write_req or mst_reg_write_sel)
    begin
      for ( byte_index = 0; byte_index <= 15; byte_index = byte_index+1 )
        mst_byte_we[byte_index] <= mst_reg_write_req & mst_reg_write_sel[3 - (byte_index/BE_WIDTH)] & Bus2IP_BE[byte_index - ((byte_index/BE_WIDTH)*BE_WIDTH)];
    end // MASTER_REG_BYTE_WR_EN
  // implement master model registers
  // The master registers are written to initialize master transfer.
  always @ ( posedge Bus2IP_Clk)
    begin
    if (Bus2IP_Resetn == 1'b0 )
      begin
        for ( byte_index = 0; byte_index <= 14; byte_index = byte_index+1 )
          mst_reg[byte_index] <= 0;
      end
    else
      begin
          if ( mst_byte_we[0] == 1'b1 )
            begin
              mst_reg[0][7:0] <= Bus2IP_Data[7 : 0];
            end
          
             mst_reg[1][1] <= mst_cmd_sm_busy;  
      
          if (mst_byte_we[1] == 1'b1 )
          // allows a clear of the 'Done'/'error'/'timeout'
            begin
              mst_reg[1][0] <= Bus2IP_Data[(1-(1/BE_WIDTH)*BE_WIDTH)*8];
              mst_reg[1][2] <= Bus2IP_Data[(1-(1/BE_WIDTH)*BE_WIDTH)*8+2];
              mst_reg[1][3] <= Bus2IP_Data[(1-(1/BE_WIDTH)*BE_WIDTH)*8+3];
            end
        else
          // 'Done'/'error'/'timeout' from master control state machine
          begin
             mst_reg[1][0]  <= mst_cmd_sm_set_done | mst_reg[1][0];
             mst_reg[1][2]  <= mst_cmd_sm_set_error | mst_reg[1][2];
             mst_reg[1][3]  <= mst_cmd_sm_set_timeout | mst_reg[1][3];
           end
             // byte 2 and 3 are reserved
             // address register (byte 4 to 7)
             // be register (byte 8 to 9)
             // length register (byte 12 to 13)
             // byte 10, 11 and 14 are reserved
         for ( byte_index = 4; byte_index <= 14; byte_index = byte_index+1 )
           if ( mst_byte_we[byte_index] == 1'b1 )
             begin
               mst_reg[byte_index] <= Bus2IP_Data[(byte_index-(byte_index/BE_WIDTH)*BE_WIDTH)*8 +: 8];
             end
      end
    end // MASTER_REG_WRITE_PROC

в примере есть код

Код

STEP_LEN_REG_CE :
                            for ( byte_index = 0; byte_index <= (C_SLV_DWIDTH/8)-1; byte_index = byte_index+1 )
                                if ( Bus2IP_BE[byte_index] == 1 )
                                    step_len[(byte_index*8) +: 8] <= Bus2IP_Data[(byte_index*8) +: 8];

что в результате получается. не конкретно в этом. не понятно в целом. т.е. из неизвестного (так ли это?) Bus2IP_Data,ведь он из другого модуля axi_lite_ipif получается нужный сигнал. этот же вопрос возникает и в MASTER_REG_BYTE_WR_EN.