Subversion Repositories neo430

// #################################################################################################
// #  < neo430_wishbone.c - Internal Wishbone interface control functions >                        #
// # ********************************************************************************************* #
// # Use the normal Wishbone functions for BLOCKING access (until ACK is asserted).                #
// # Use non-blocking functions (*_start, wishbone_busy, wishbone_get_data*) to prevent dead locks #
// # when accessing invalid addresses and to do things in parallel when using the Wishbone bus.    #
// # ********************************************************************************************* #
// # 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                                    #
// #################################################################################################
 
#include "neo430.h"
#include "neo430_wishbone.h"
 
 
// ************************************************************************************************
// Byte-wise access functions, with address alignment, blocking
// ************************************************************************************************
 
/* ------------------------------------------------------------
 * INFO Read 32-bit from Wishbone device (blocking), standard mode, pipelined
 * PARAM 32-bit device address
 * RETURN read data
 * ------------------------------------------------------------ */
uint32_t neo430_wishbone32_read32(uint32_t a) {
 
  // 32-bit transfer
  WB32_CT = 0xF;
 
  // device address aligned to 32-bit + transfer trigger
  WB32_RA_32bit = a & (~3);
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
 
  return WB32_D_32bit;
}
 
 
/* ------------------------------------------------------------
 * INFO Write 32-bit to Wishbone device (blocking), standard mode, pipelined
 * PARAM a: 32-bit device address
 * PARAM d: 32-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone32_write32(uint32_t a, uint32_t d) {
 
  // 32-bit transfer
  WB32_CT = 0xF;
 
  // write data
  WB32_D_32bit = d;
 
  // device address aligned to 32-bit + transfer trigger
  WB32_WA_32bit = a & (~3);
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
}
 
 
/* ------------------------------------------------------------
 * INFO Read 16-bit from Wishbone device (blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM 32-bit device address
 * RETURN 16-bit read data
 * ------------------------------------------------------------ */
uint16_t neo430_wishbone32_read16(uint32_t a) {
 
  // 16-bit transfer
  if (a & 2)
    WB32_CT = 0b1100; // high 16-bit word
  else
    WB32_CT = 0b0011; // low 16-bit word
 
  // device address aligned to 16-bit + transfer trigger
  WB32_RA_32bit = a & (~1);
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
 
  if (a & 2)
    return WB32_HD; // high 16-bit word
  else
    return WB32_LD; // low 16-bit word
}
 
 
/* ------------------------------------------------------------
 * INFO Write 16-bit to Wishbone device (blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM a: 32-bit device address
 * PARAM d: 16-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone32_write16(uint32_t a, uint16_t d) {
 
  // 16-bit transfer
  if (a & 2) {
    WB32_CT = 0b1100; // high 16-bit word
    WB32_HD = d;
  }
  else {
    WB32_CT = 0b0011; // low 16-bit word
    WB32_LD = d;
  }
 
  // device address aligned to 16-bit + transfer trigger
  WB32_WA_32bit = a & (~1);
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
}
 
 
/* ------------------------------------------------------------
 * INFO Read 8-bit from Wishbone device (blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM 32-bit device address
 * RETURN 0 if fail, 1 if timeout
 * ------------------------------------------------------------ */
uint8_t neo430_wishbone32_read8(uint32_t a) {
 
  // 8-bit transfer
  WB32_CT = 1 << (a & 3); // corresponding byte enable
 
  // device address aligned to 8-bit + transfer trigger
  WB32_RA_32bit = a;
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
 
  // select correct byte to be read
  uint16_t data;
  if (a & 2)
    data = WB32_HD;
  else
    data = WB32_LD;
 
  if (a & 1)
    data = neo430_bswap(data);
 
  return (uint8_t)data;
}
 
 
/* ------------------------------------------------------------
 * INFO Write 8-bit to Wishbone device (blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM a: 32-bit device address
 * PARAM d: 8-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone32_write8(uint32_t a, uint8_t d) {
 
  // 8-bit transfer
  WB32_CT = 1 << (a & 3); // corresponding byte enable
 
  // select correct byte to be written
  uint16_t data = (uint16_t)d;
  data = (data << 8) | data;
  WB32_LD = data;
  WB32_HD = data;
 
  // device address aligned to 8-bit + transfer trigger
  WB32_WA_32bit = a;
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
}
 
// ************************************************************************************************
// NONBLOCKING FUNCTIONS
// ************************************************************************************************
// Use wishbone_busy() to check status
// Use Wishbone_get_data(address) to get data from read accesses
// ************************************************************************************************
 
/* ------------------------------------------------------------
 * INFO Initiate read 32-bit from Wishbone device (non-blocking), standard mode, pipelined
 * PARAM 32-bit device address
 * ------------------------------------------------------------ */
void neo430_wishbone32_read32_start(uint32_t a) {
 
  // 32-bit transfer
  WB32_CT = 0xF;
 
  // device address aligned to 32-bit + transfer trigger
  WB32_RA_32bit = a & (~3);
}
 
 
/* ------------------------------------------------------------
 * INFO Initiate write 32-bit to Wishbone device (non-blocking), standard mode, pipelined
 * PARAM a: 32-bit device address
 * PARAM d: 32-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone32_write32_start(uint32_t a, uint32_t d) {
 
  // 32-bit transfer
  WB32_CT = 0xF;
 
  // write data
  WB32_D_32bit = d;
 
  // device address aligned to 32-bit + transfer trigger
  WB32_WA_32bit = a & (~3);
}
 
 
/* ------------------------------------------------------------
 * INFO Initiate read 16-bit from Wishbone device (non-blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM 32-bit device address
 * ------------------------------------------------------------ */
void neo430_wishbone32_read16_start(uint32_t a) {
 
  // 16-bit transfer
  if (a & 2)
    WB32_CT = 0b1100; // high 16-bit word
  else
    WB32_CT = 0b0011; // low 16-bit word
 
  // device address aligned to 16-bit + transfer trigger
  WB32_RA_32bit = a & (~1);
}
 
 
/* ------------------------------------------------------------
 * INFO Initiate write 16-bit to Wishbone device (non-blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM a: 32-bit device address
 * PARAM d: 16-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone32_write16_start(uint32_t a, uint16_t d) {
 
  // 16-bit transfer
  if (a & 2) {
    WB32_CT = 0b1100; // high 16-bit word
    WB32_HD = d;
  }
  else {
    WB32_CT = 0b0011; // low 16-bit word
    WB32_LD = d;
  }
}
 
 
/* ------------------------------------------------------------
 * INFO Initiate read 8-bit from Wishbone device (non-blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM 32-bit device address
 * ------------------------------------------------------------ */
void neo430_wishbone32_read8_start(uint32_t a) {
 
  // 8-bit transfer
  WB32_CT = 1 << (a & 3); // corresponding byte enable
 
  // device address aligned to 8-bit + transfer trigger
  WB32_RA_32bit = a;
}
 
 
/* ------------------------------------------------------------
 * INFO Initiate write 8-bit to Wishbone device (non-blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM a: 32-bit device address
 * PARAM d: 8-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone32_write8_start(uint32_t a, uint8_t d) {
 
  // select correct byte to be written
  uint16_t data = (uint16_t)d;
  data = (data << 8) | data;
  WB32_LD = data;
  WB32_HD = data;
 
  // 8-bit transfer
  WB32_CT = 1 << (a & 3); // corresponding byte enable
 
  // device address aligned to 8-bit + transfer trigger
  WB32_WA_32bit = a;
}
 
 
/* ------------------------------------------------------------
 * INFO Read 32-bit data after nonblocking transaction has been started
 * RETURN read data
 * ------------------------------------------------------------ */
uint32_t neo430_wishbone32_get_data32(void) {
 
  return WB32_D_32bit;
}
 
 
/* ------------------------------------------------------------
 * INFO Read 16-bit data after nonblocking transaction has been started
 * PARAM 32-bit device address
 * RETURN read data
 * ------------------------------------------------------------ */
uint16_t neo430_wishbone32_get_data16(uint32_t a) {
 
  if (a & 2)
    return WB32_HD; // high 16-bit word
  else
    return WB32_LD; // low 16-bit word
}
 
 
/* ------------------------------------------------------------
 * INFO Read 8-bit data after nonblocking transaction has been started
 * PARAM 32-bit device address
 * RETURN read data
 * ------------------------------------------------------------ */
uint8_t neo430_wishbone32_get_data8(uint32_t a) {
 
  // select correct byte to be read
  uint16_t data;
  if (a & 2)
    data = WB32_HD;
  else
    data = WB32_LD;
 
  if (a & 1)
    data = neo430_bswap(data);
 
  return (uint8_t)data;
}
 
 
// ************************************************************************************************
// Blocking access functions for data bus width = 32-bit, NO ADDRESS ALIGNMENT
// ************************************************************************************************
 
 
/* ------------------------------------------------------------
 * INFO Read 32-bit from Wishbone device (blocking), standard mode, pipelined
 * PARAM 32-bit device address
 * RETURN 32-bit read data
 * ------------------------------------------------------------ */
uint32_t neo430_wishbone32_read(uint32_t a) {
 
  // 32-bit transfer
  WB32_CT = 0xF;
 
  // device address + transfer trigger
  WB32_RA_32bit = a;
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
 
  return WB32_D_32bit;
}
 
 
/* ------------------------------------------------------------
 * INFO Write 32-bit to Wishbone device (blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM a: 32-bit device address
 * PARAM d: 32-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone32_write(uint32_t a, uint32_t d) {
 
  // 32-bit transfer
  WB32_CT = 0xf;
  WB32_D_32bit = d;
 
  // device address + transfer trigger
  WB32_WA_32bit = a;
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
}
 
 
// ************************************************************************************************
// NONBLOCKING FUNCTIONS
// ************************************************************************************************
// Use wishbone_busy() to check status
// Use Wishbone_get_data(address) to get data from read accesses
// ************************************************************************************************
 
/* ------------------------------------------------------------
 * INFO Initiate read 32-bit from Wishbone device (non-blocking), standard mode, pipelined
 * PARAM 32-bit device address
 * ------------------------------------------------------------ */
void neo430_wishbone32_read_start(uint32_t a) {
 
  // 32-bit transfer
  WB32_CT = 0xF;
 
  // device address + transfer trigger
  WB32_RA_32bit = a;
}
 
 
/* ------------------------------------------------------------
 * INFO Initiate write 32-bit to Wishbone device (non-blocking), standard mode, pipelined
 * PARAM a: 32-bit device address
 * PARAM d: 32-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone32_write_start(uint32_t a, uint32_t d) {
 
  // 32-bit transfer
  WB32_CT = 0xF;
 
  // write data
  WB32_D_32bit = d;
 
  // device address + transfer trigger
  WB32_WA_32bit = a;
}
 
 
/* ------------------------------------------------------------
 * INFO Read 32-bit data after nonblocking transaction has been started
 * PARAM 32-bit device address
 * RETURN 32-bit read data
 * ------------------------------------------------------------ */
uint32_t neo430_wishbone32_get_data(void) {
 
  return WB32_D_32bit;
}
 
 
// ************************************************************************************************
// Blocking access functions for data bus width = 16-bit, NO ADDRESS ALIGNMENT
// ************************************************************************************************
 
 
/* ------------------------------------------------------------
 * INFO Read 16-bit from Wishbone device (blocking), standard mode, pipelined
 * PARAM 32-bit device address
 * RETURN 16-bit read data
 * ------------------------------------------------------------ */
uint16_t neo430_wishbone16_read(uint32_t a) {
 
  // 16-bit transfer
  WB32_CT = 0x3; // low 16-bit word
 
  // device address + transfer trigger
  WB32_RA_32bit = a;
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
 
  return WB32_LD; // low 16-bit word
}
 
 
/* ------------------------------------------------------------
 * INFO Write 16-bit to Wishbone device (blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM a: 32-bit device address
 * PARAM d: 16-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone16_write(uint32_t a, uint16_t d) {
 
  // 16-bit transfer
  WB32_CT = 0x3; // low 16-bit word
  WB32_LD = d;
 
  // device address + transfer trigger
  WB32_WA_32bit = a;
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
}
 
 
// ************************************************************************************************
// NONBLOCKING FUNCTIONS
// ************************************************************************************************
// Use wishbone_busy() to check status
// Use Wishbone_get_data(address) to get data from read accesses
// ************************************************************************************************
 
/* ------------------------------------------------------------
 * INFO Initiate read 16-bit from Wishbone device (non-blocking), standard mode, pipelined
 * PARAM 32-bit device address
 * ------------------------------------------------------------ */
void neo430_wishbone16_read_start(uint32_t a) {
 
  // 16-bit transfer
  WB32_CT = 0x3;
 
  // device address + transfer trigger
  WB32_RA_32bit = a;
}
 
 
/* ------------------------------------------------------------
 * INFO Initiate write 16-bit to Wishbone device (non-blocking), standard mode, pipelined
 * PARAM a: 32-bit device address
 * PARAM d: 16-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone16_write_start(uint32_t a, uint16_t d) {
 
  // 16-bit transfer
  WB32_CT = 0x3;
 
  // write data
  WB32_LD = d;
 
  // device address + transfer trigger
  WB32_WA_32bit = a;
}
 
 
/* ------------------------------------------------------------
 * INFO Read 16-bit data after nonblocking transaction has been started
 * RETURN 16-bit read data
 * ------------------------------------------------------------ */
uint16_t neo430_wishbone16_get_data(void) {
 
  return WB32_LD;
}
 
 
// ************************************************************************************************
// Blocking access functions for data bus width = 8-bit, NO ADDRESS ALIGNMENT
// ************************************************************************************************
 
 
/* ------------------------------------------------------------
 * INFO Read 8-bit from Wishbone device (blocking), standard mode, pipelined
 * PARAM 32-bit device address
 * RETURN 8-bit read data
 * ------------------------------------------------------------ */
uint8_t neo430_wishbone8_read(uint32_t a) {
 
  // 8-bit transfer
  WB32_CT = 0x1;
 
  // device address + transfer trigger
  WB32_RA_32bit = a;
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
 
  return (uint8_t)WB32_LD; // low 16-bit word
}
 
 
/* ------------------------------------------------------------
 * INFO Write 8-bit to Wishbone device (blocking), standard mode, pipelined
 * INFO This function performs a data alignment based on the address!
 * PARAM a: 32-bit device address
 * PARAM d: 8-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone8_write(uint32_t a, uint8_t d) {
 
  // 8-bit transfer
  WB32_CT = 0x1; // low 8-bit word
  WB32_LD = (uint16_t)d;
 
  // device address + transfer trigger
  WB32_WA_32bit = a;
 
  // wait for access to be completed - blocking!
  while((WB32_CT & (1<<WB32_CT_PENDING)) != 0);
}
 
 
// ************************************************************************************************
// NONBLOCKING FUNCTIONS
// ************************************************************************************************
// Use wishbone_busy() to check status
// Use Wishbone_get_data(address) to get data from read accesses
// ************************************************************************************************
 
/* ------------------------------------------------------------
 * INFO Initiate read 16-bit from Wishbone device (non-blocking), standard mode, pipelined
 * PARAM 8-bit device address
 * ------------------------------------------------------------ */
void neo430_wishbone8_read_start(uint32_t a) {
 
  // 8-bit transfer
  WB32_CT = 0x1;
 
  // device address + transfer trigger
  WB32_RA_32bit = a;
}
 
 
/* ------------------------------------------------------------
 * INFO Initiate write 8-bit to Wishbone device (non-blocking), standard mode, pipelined
 * PARAM a: 32-bit device address
 * PARAM d: 8-bit write data
 * ------------------------------------------------------------ */
void neo430_wishbone8_write_start(uint32_t a, uint8_t d) {
 
  // 8-bit transfer
  WB32_CT = 0x1;
 
  // write data
  WB32_LD = (uint16_t)d;
 
  // device address + transfer trigger
  WB32_WA_32bit = a;
}
 
 
/* ------------------------------------------------------------
 * INFO Read 8-bit data after nonblocking transaction has been started
 * RETURN 8-bit read data
 * ------------------------------------------------------------ */
uint8_t neo430_wishbone8_get_data(void) {
 
  return (uint8_t)WB32_LD;
}
 
 
// ************************************************************************************************
// NONBLOCKING ARBITRATION FUNCTIONS
// ************************************************************************************************
 
/* ------------------------------------------------------------
 * INFO Check if Wishbone transaction is (still) in progress
 * RETURN 1 if transfer in progress, 0 if idel
 * ------------------------------------------------------------ */
uint16_t neo430_wishbone_busy(void) {
 
  return (WB32_CT & (1<<WB32_CT_PENDING));
}
 
 
/* ------------------------------------------------------------
 * INFO Terminate current Wishbone transfer
 * ------------------------------------------------------------ */
void neo430_wishbone_terminate(void) {
 
  WB32_CT = 0;
}