Subversion Repositories neo430

// #################################################################################################
// #  < Wishbone bus explorer >                                                                    #
// # ********************************************************************************************* #
// # Manual access to the registers of modules, which are connected to the Wishbone bus. This tool #
// # uses NONBLOCKING Wishbone transactions.                                                       #
// # ********************************************************************************************* #
// # BSD 3-Clause License                                                                          #
// #                                                                                               #
// # Copyright (c) 2020, Stephan Nolting. All rights reserved.                                     #
// #                                                                                               #
// # Redistribution and use in source and binary forms, with or without modification, are          #
// # permitted provided that the following conditions are met:                                     #
// #                                                                                               #
// # 1. Redistributions of source code must retain the above copyright notice, this list of        #
// #    conditions and the following disclaimer.                                                   #
// #                                                                                               #
// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of     #
// #    conditions and the following disclaimer in the documentation and/or other materials        #
// #    provided with the distribution.                                                            #
// #                                                                                               #
// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to  #
// #    endorse or promote products derived from this software without specific prior written      #
// #    permission.                                                                                #
// #                                                                                               #
// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS   #
// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF               #
// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE    #
// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #
// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #
// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    #
// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     #
// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED  #
// # OF THE POSSIBILITY OF SUCH DAMAGE.                                                            #
// # ********************************************************************************************* #
// # The NEO430 Processor - https://github.com/stnolting/neo430                                    #
// #################################################################################################
 
 
// Libraries
#include <stdint.h>
#include <string.h>
#include <neo430.h>
 
// Global variables
uint8_t wb_config = 0;
 
// Prototypes
void setup_wb(void);
void read_wb_address(void);
void write_wb_address(void);
void dump_wb(void);
 
// Configuration
#define MAX_CMD_LENGTH 16
#define BAUD_RATE 19200
 
 
/* ------------------------------------------------------------
 * INFO Main function
 * ------------------------------------------------------------ */
int main(void) {
 
  // setup UART
  neo430_uart_setup(BAUD_RATE);
 
  char buffer[MAX_CMD_LENGTH];
  uint16_t length = 0;
  uint16_t selection = 0;
 
  neo430_uart_br_print("\n--------------------------------------\n"
                  "--- Wishbone Bus Explorer Terminal ---\n"
                  "--------------------------------------\n\n");
 
  // check if WB unit was synthesized, exit if no WB is available
  if (!(SYS_FEATURES & (1<<SYS_WB32_EN))) {
    neo430_uart_br_print("Error! No Wishbone adapter synthesized!");
    return 1;
  }
 
  // default config
  wb_config = 4;
  neo430_wishbone_terminate(); // terminate current transfer
 
  neo430_uart_br_print("Configure the actual data transfer size (1, 2 or 4 bytes)\n"
                       "using 'setup'. Addresses are always 32-bit wide.\n"
                       "This tool uses non-blocking Wishbone transactions.\n\n"
                       "Type 'help' to see the help menu.\n\n");
 
  // Main menu
  for (;;) {
    neo430_uart_br_print("WB_EXPLORER:> ");
    length = neo430_uart_scan(buffer, MAX_CMD_LENGTH, 1);
    neo430_uart_br_print("\n");
 
    if (!length) // nothing to be done
     continue;
 
    // decode input
    selection = 0;
    if (!strcmp(buffer, "help"))
      selection = 1;
    if (!strcmp(buffer, "setup"))
      selection = 2;
    if (!strcmp(buffer, "read"))
      selection = 3;
    if (!strcmp(buffer, "write"))
      selection = 4;
    if (!strcmp(buffer, "dump"))
      selection = 5;
    if (!strcmp(buffer, "reset"))
      selection = 6;
    if (!strcmp(buffer, "exit"))
      selection = 7;
 
    // execute command
    switch(selection) {
 
      case 1: // print help menu
        neo430_uart_br_print("Available commands:\n"
                             " help  - show this text\n"
                             " setup - configure WB interface\n"
                             " read  - read from WB address\n"
                             " write - write to WB address\n"
                             " dump  - dump data from WB addresses\n"
                             " reset - perform soft-reset\n"
                             " exit  - exit program and return to bootloader\n");
        break;
 
      case 2: // setup Wishbone adapter
        setup_wb();
        break;
 
      case 3: // read from address
        read_wb_address();
        break;
 
      case 4: // write to address
        write_wb_address();
        break;
 
      case 5: // dump data
        dump_wb();
        break;
 
      case 6: // restart
        while ((UART_CT & (1<<UART_CT_TX_BUSY)) != 0); // wait for current UART transmission
        neo430_soft_reset();
        break;
 
      case 7: // goto bootloader
        if (!(SYS_FEATURES & (1<<SYS_BTLD_EN)))
          neo430_uart_br_print("No bootloader installed!\n");
        else
          asm volatile ("mov #0xF000, r0");
        break;
 
      default: // invalid command
        neo430_uart_br_print("Invalid command. Type 'help' to see all commands.\n");
        break;
    }
  }
 
  return 0;
}
 
 
/* ------------------------------------------------------------
 * INFO Configure Wishbone adapter
 * ------------------------------------------------------------ */
void setup_wb(void) {
 
  char buffer[2];
 
  neo430_uart_br_print("Select transfer size in bytes (1,2,4): ");
  neo430_uart_scan(buffer, 2, 1);
 
  // process input
  if (!strcmp(buffer, "1"))
    wb_config = 1;
  else if (!strcmp(buffer, "2"))
    wb_config = 2;
  else if (!strcmp(buffer, "4"))
    wb_config = 4;
  else {
    neo430_uart_br_print("\nInvalid input. Cancelling setup.\n");
    return;
  }
 
  neo430_uart_br_print("\nSetup done.\n");
}
 
 
/* ------------------------------------------------------------
 * INFO Read data from Wishbone address
 * ------------------------------------------------------------ */
void read_wb_address(void) {
 
  char buffer[9];
 
  neo430_uart_br_print("Enter hexadecimal target address: 0x");
  neo430_uart_scan(buffer, 9, 1); // 8 hex chars for address plus '\0'
  uint32_t address = neo430_hexstr_to_uint(buffer, strlen(buffer));
 
  neo430_uart_br_print("\nReading from [0x");
  neo430_uart_print_hex_dword(address);
  neo430_uart_br_print("]... ");
 
  // print result
  neo430_uart_br_print("Read data: 0x");
 
  if (wb_config == 1)
    neo430_wishbone32_read8_start(address);
  else if (wb_config == 2)
    neo430_wishbone32_read16_start(address);
  else if (wb_config == 4)
    neo430_wishbone32_read32_start(address);
 
  // wait for transfer to finish
  uint16_t timeout = 0;
  while(1){
    if (!neo430_wishbone_busy())
      break;
    if (timeout++ == 100) {
      neo430_uart_br_print("\nError! Device not responding! Press key to proceed.\n");
      neo430_wishbone_terminate(); // terminate current transfer
      while(!neo430_uart_char_received());
      return;
    }
  }
 
  // read data
  if (wb_config == 1)
    neo430_uart_print_hex_byte(neo430_wishbone32_get_data8(address));
  else if (wb_config == 2)
    neo430_uart_print_hex_word(neo430_wishbone32_get_data16(address));
  else if (wb_config == 4)
    neo430_uart_print_hex_dword(neo430_wishbone32_get_data32());
 
  neo430_uart_br_print("\n");
}
 
 
/* ------------------------------------------------------------
 * INFO Write data to Wishbone address
 * ------------------------------------------------------------ */
void write_wb_address(void) {
 
  char buffer[9];
 
  neo430_uart_br_print("Enter hexadecimal target address: 0x");
  neo430_uart_scan(buffer, 9, 1); // 8 hex chars for address plus '\0'
  uint32_t address = neo430_hexstr_to_uint(buffer, strlen(buffer));
 
  neo430_uart_br_print("\nEnter hexadecimal write data: 0x");
  neo430_uart_scan(buffer, wb_config*2+1, 1); // get right number of hex chars for data plus '\0'
  uint32_t data = neo430_hexstr_to_uint(buffer, strlen(buffer));
 
  neo430_uart_br_print("\nWriting '0x");
  neo430_uart_print_hex_dword(data);
  neo430_uart_br_print("' to [0x");
  neo430_uart_print_hex_dword(address);
  neo430_uart_br_print("]... ");
 
  // perform access
  if (wb_config == 1)
    neo430_wishbone32_write8_start(address, (uint8_t)data);
  else if (wb_config == 2)
    neo430_wishbone32_write16_start(address, (uint16_t)data);
  else if (wb_config == 4)
    neo430_wishbone32_write32_start(address, data);
 
  // wait for transfer to finish
  uint16_t timeout = 0;
  while(1){
    if (!neo430_wishbone_busy())
      break;
    if (timeout++ == 100) {
      neo430_uart_br_print("\nError! Device not responding! Press key to proceed.\n");
      neo430_wishbone_terminate(); // terminate current transfer
      while(!neo430_uart_char_received());
      return;
    }
  }
 
  neo430_uart_br_print("Done.\n"); 
}
 
 
/* ------------------------------------------------------------
 * INFO Dump data from Wishbone address
 * ------------------------------------------------------------ */
void dump_wb(void) {
 
  char buffer[9];
  uint16_t i = 0;
 
  neo430_uart_br_print("Enter hexadecimal start address: 0x");
  neo430_uart_scan(buffer, 9, 1); // 8 hex chars for address plus '\0'
  uint32_t address = neo430_hexstr_to_uint(buffer, strlen(buffer));
 
  neo430_uart_br_print("\nPress any key to start.\n"
                       "You can abort dumping by pressing any key.\n");
  while(!neo430_uart_char_received());
 
  while(1) {
    neo430_uart_br_print("0x");
    neo430_uart_print_hex_dword(address);
    neo430_uart_br_print(":  ");
 
    uint16_t border = 16 / wb_config;
    for (i=0; i<border; i++) {
 
      // trigger access
      if (wb_config == 1)
        neo430_wishbone32_read8_start(address);
      else if (wb_config == 2)
        neo430_wishbone32_read16_start(address);
      else if (wb_config == 4)
        neo430_wishbone32_read32_start(address);
 
      // wait for transfer to finish
      uint16_t timeout = 0;
      while(1){
        if (!neo430_wishbone_busy())
          break;
        if (timeout++ == 100) {
          neo430_uart_br_print("\nError! Device not responding! Press key to proceed.\n");
          neo430_wishbone_terminate(); // terminate current transfer
          while(!neo430_uart_char_received());
          return;
        }
      }
 
      // read data
      if (wb_config == 1) {
        neo430_uart_print_hex_byte(neo430_wishbone32_get_data8(address));
        address += 1;
      }
      else if (wb_config == 2) {
        neo430_uart_print_hex_word(neo430_wishbone32_get_data16(address));
        address += 2;
      }
      else if (wb_config == 4) {
        neo430_uart_print_hex_dword(neo430_wishbone32_get_data32());
        address += 4;
      }
 
      neo430_uart_putc(' ');
    }
 
    neo430_uart_br_print("\n");
    if (neo430_uart_char_received()) // abort
      return;
  }
}