Subversion Repositories funbase_ip_library

/*
 * @file   hpd_functions.c
 * @author Lasse Lehtonen
 * @date   2012-02-27
 *
 * @brief Implements platform independent functions for HIBI_PE_DMA.
 *
 */
 
#include "hpd_macros.h"
#include "hpd_config.h"
#include "hpd_functions.h"
 
#include <string.h>
 
 
void hpd_initialize()
{
  int i;
  int base;
  int tx_base;
  int tx_size;
  int tx_haddr;
  int tx_cmd;
  int rx_base;
  int rx_words;
  int rx_haddr;
  int n_streams;
  int n_packets;
  int c;
  for(i = 0; i < NUM_OF_HIBI_PE_DMAS; ++i) {
    base       = hpd_ifaces[i].base_address;
    tx_base    = hpd_ifaces[i].tx_base_address;
    tx_size    = hpd_ifaces[i].tx_buffer_bytes;
    tx_haddr   = hpd_ifaces[i].tx_hibi_address;
    tx_cmd     = hpd_ifaces[i].tx_hibi_command;
    n_streams  = hpd_ifaces[i].n_stream_channels;
    n_packets  = hpd_ifaces[i].n_packet_channels;
 
    // Set tx_buffer start address
    HPD_TX_MEM_ADDR(tx_base, base);
 
    // Set amount to send
    HPD_TX_WORDS(((tx_size+3) >> 2), base);
 
    // Set target hibi command
    HPD_TX_CMD(tx_cmd, base);
 
    // Set target hibi address
    HPD_TX_HIBI_ADDR(tx_haddr, base);
 
    for(c = 0; c < n_streams; ++c) {
      rx_base  = hpd_ifaces[i].rx_streams[c].rx_base_address;
      rx_words = (hpd_ifaces[i].rx_streams[c].rx_buffer_bytes+3) >> 2;
      rx_haddr = hpd_ifaces[i].rx_streams[c].rx_hibi_address;
      hpd_ifaces[i].rx_streams[c].rx_read_words = 0;
      // Set receive mem address for incoming data
      HPD_RX_MEM_ADDR(c, rx_base, base);
      // Set amount to receive
      HPD_RX_WORDS(c, rx_words, base);
      // Set hibi address to receive data
      HPD_RX_HIBI_ADDR(c, rx_haddr, base);
    }
 
    for(c = 0; c < n_packets; ++c) {
      rx_base  = hpd_ifaces[i].rx_packets[c].rx_base_address;
      rx_words = (hpd_ifaces[i].rx_packets[c].rx_buffer_bytes+3) >> 2;
      rx_haddr = hpd_ifaces[i].rx_packets[c].rx_hibi_address;
      // Set receive mem address for incoming data
      HPD_RX_MEM_ADDR(c+n_streams, rx_base, base);
      // Set amount to receive
      HPD_RX_WORDS(c+n_streams, rx_words, base);
      // Set hibi address to receive data
      HPD_RX_HIBI_ADDR(c+n_streams, rx_haddr, base);
    }
  }
}
 
 
void hpd_tx_base_conf_gen(int base, int words, int iface)
{
  hpd_ifaces[iface].tx_base_address = base;
  hpd_ifaces[iface].tx_buffer_bytes = words << 2;
  int hpd_base = hpd_ifaces[iface].base_address;
 
  // Set tx_buffer start address
  HPD_TX_MEM_ADDR(base, hpd_base);
 
  // Set amount to send
  HPD_TX_WORDS(words, hpd_base);
}
 
 
void hpd_tx_base_conf(int base, int words)
{
  hpd_tx_base_conf_gen(base, words, 0);
}
 
 
void hpd_tx_send_gen(int daddr, int words, int haddr, int iface)
{
  int tx_done = 0;    
  int base     = hpd_ifaces[iface].base_address;
  int tx_base  = hpd_ifaces[iface].tx_base_address;
  int tx_haddr = hpd_ifaces[iface].tx_hibi_address;
  int tx_cmd   = hpd_ifaces[iface].tx_hibi_command;
 
  // Poll HPD until it's not sending previous tx anymore
  for(; !tx_done;) {
    HPD_TX_GET_DONE(tx_done, base);
  }
 
  // Set tx_buffer start address
  if(tx_base != daddr) {
    HPD_TX_MEM_ADDR(daddr, base);
  }
 
  // Set target hibi command WRITE
  if(tx_cmd != 2) {
    HPD_TX_CMD(2, base);
    hpd_ifaces[iface].tx_hibi_command = 2;
  }
 
  // Set target hibi address
  if(tx_haddr != haddr) {
    HPD_TX_HIBI_ADDR(haddr, base);
    hpd_ifaces[iface].tx_hibi_address = haddr;
  }  
 
  // Set amount to send
  HPD_TX_WORDS(words, base);
 
  // Start the transfer
  HPD_TX_START(base);
}
 
void hpd_tx_send(int daddr, int words, int haddr)
{
  hpd_tx_send_gen(daddr, words, haddr, 0);
}
 
void hpd_tx_send_copy_gen(int daddr, int words, int haddr, int iface)
{
  int tx_done  = 0;  
  int base     = hpd_ifaces[iface].base_address;
  int tx_base  = hpd_ifaces[iface].tx_base_address;
  int tx_size  = hpd_ifaces[iface].tx_buffer_bytes;
  int tx_haddr = hpd_ifaces[iface].tx_hibi_address;
  int tx_cmd   = hpd_ifaces[iface].tx_hibi_command;
 
  // Set tx_buffer start address
  HPD_TX_MEM_ADDR(tx_base, base);
 
  // Set target hibi command WRITE
  if(tx_cmd != 2) {
    HPD_TX_CMD(2, base);
    hpd_ifaces[iface].tx_hibi_command = 2;
  }
 
  // Set target hibi address
  if(tx_haddr != haddr) {
    HPD_TX_HIBI_ADDR(haddr, base);
    hpd_ifaces[iface].tx_hibi_address = haddr;
  }  
 
  while(words > 0)
    {
      // Poll HPD until it's not sending previous tx anymore
      for(; !tx_done;) {
	HPD_TX_GET_DONE(tx_done, base);
      }
      tx_done = 0;
 
      // Copy data in pieces if there's more than tx_buffer's size
      if(words > (tx_size >> 2)) {
	memcpy((void*)tx_base, (void*)daddr, tx_size);
	daddr += tx_size;
	words -= (tx_size >> 2);
	// Set how many words to send
	HPD_TX_WORDS((tx_size >> 2), base);
      } else {
	memcpy((void*)tx_base, (void*)daddr, (words << 2));	
	// Set how many words to send
	HPD_TX_WORDS(words, base);
	words = 0;
      }
 
      // Start the transfer
      HPD_TX_START(base);
    }
}
 
void hpd_tx_send_copy(int daddr, int words, int haddr)
{
  hpd_tx_send_copy_gen(daddr, words, haddr, 0);
}
 
 
void hpd_rx_packet_init_gen(int chan, int daddr, 
			    int words, int haddr, int iface)
{
  int base      = hpd_ifaces[iface].base_address;
  int rx_base   = hpd_ifaces[iface].rx_packets[chan].rx_base_address;
  int rx_size   = hpd_ifaces[iface].rx_packets[chan].rx_buffer_bytes;
  int rx_haddr  = hpd_ifaces[iface].rx_packets[chan].rx_hibi_address;
  int n_streams = hpd_ifaces[iface].n_stream_channels;
 
  // Set receive mem address for incoming data
  if(rx_base != daddr) {
    HPD_RX_MEM_ADDR(chan+n_streams, daddr, base);
    hpd_ifaces[iface].rx_packets[chan].rx_base_address = daddr;
  }
 
  // Set amount to receive
  if((rx_size >> 2) != words) {
    HPD_RX_WORDS(chan+n_streams, words, base);
    hpd_ifaces[iface].rx_packets[chan].rx_buffer_bytes = (words << 2);
  }
 
  // Set hibi address to receive data
  if(rx_haddr != haddr) {
    HPD_RX_HIBI_ADDR(chan+n_streams, haddr, base);
    hpd_ifaces[iface].rx_packets[chan].rx_hibi_address = haddr;
  }
 
  // Initialize receiving
  HPD_RX_INIT(chan+n_streams, base);
}
 
void hpd_rx_packet_init(int chan, int daddr, int words, int haddr)
{
  hpd_rx_packet_init_gen(chan, daddr, words, haddr, 0);
}
 
 
void hpd_rx_stream_init_gen(int chan, int daddr, 
			    int words, int haddr, int iface)
{
  int base      = hpd_ifaces[iface].base_address;
  int rx_base   = hpd_ifaces[iface].rx_streams[chan].rx_base_address;
  int rx_size   = hpd_ifaces[iface].rx_streams[chan].rx_buffer_bytes;
  int rx_haddr  = hpd_ifaces[iface].rx_streams[chan].rx_hibi_address;
  hpd_ifaces[iface].rx_streams[chan].rx_read_words = 0;
 
  // Set receive mem address for incoming data
  if(rx_base != daddr) {
    HPD_RX_MEM_ADDR(chan, daddr, base);
    hpd_ifaces[iface].rx_streams[chan].rx_base_address = daddr;
  }
 
  // Set the length of the rx buffer in words
  if((rx_size >> 2) != words) {
    HPD_RX_WORDS(chan, words, base);
    hpd_ifaces[iface].rx_streams[chan].rx_buffer_bytes = (words << 2);
  }
 
  // Set hibi address to receive data
  if(rx_haddr != haddr) {
    HPD_RX_HIBI_ADDR(chan, haddr, base);
    hpd_ifaces[iface].rx_streams[chan].rx_hibi_address = haddr;
  }
 
  // Initialize receiving
  HPD_RX_INIT(chan, base);
}
 
 
void hpd_rx_stream_init(int chan, int daddr, int words, int haddr)
{
  hpd_rx_stream_init_gen(chan, daddr, words, haddr, 0);
}
 
 
void hpd_rx_packet_reinit_gen(int chan, int iface)
{
  int base      = hpd_ifaces[iface].base_address;
  int n_streams = hpd_ifaces[iface].n_stream_channels;
  // Initialize receiving
  HPD_RX_INIT(chan+n_streams, base);
}
 
 
void hpd_rx_packet_reinit(int chan)
{
  hpd_rx_packet_reinit_gen(chan, 0);
}
 
 
void hpd_rx_stream_reinit_gen(int chan, int iface)
{
  int base      = hpd_ifaces[iface].base_address;
  // Initialize receiving
  HPD_RX_INIT(chan, base);
}
 
 
void hpd_rx_stream_reinit(int chan)
{
  hpd_rx_stream_reinit_gen(chan, 0);
}
 
 
void hpd_rx_packet_read_gen(int chan, void* buffer, int iface)
{
  int rx_base = hpd_ifaces[iface].rx_packets[chan].rx_base_address;
  int rx_size = hpd_ifaces[iface].rx_packets[chan].rx_buffer_bytes;
  memcpy(buffer, (void*)rx_base, rx_size);
}
 
 
void hpd_rx_packet_read(int chan, void* buffer)
{
  hpd_rx_packet_read_gen(chan, buffer, 0);
}
 
 
void hpd_rx_packet_get_conf_gen(int chan, int* rx_base, int* rx_bytes,
				int* rx_haddr, int iface)
{
  if(rx_base) {
    *rx_base = hpd_ifaces[iface].rx_packets[chan].rx_base_address;
  }
 
  if(rx_bytes) {
    *rx_bytes = hpd_ifaces[iface].rx_packets[chan].rx_buffer_bytes;
  }
 
  if(rx_haddr) {
    *rx_haddr = hpd_ifaces[iface].rx_packets[chan].rx_hibi_address;
  }
}
 
 
void hpd_rx_packet_get_conf(int chan, int* rx_base, int* rx_bytes,
			    int* rx_haddr)
{
  hpd_rx_packet_get_conf_gen(chan, rx_base, rx_bytes, rx_haddr, 0);
}
 
 
void hpd_rx_stream_get_conf_gen(int chan, int* rx_base, int* rx_bytes,
				int* rx_haddr, int iface)
{
  if(rx_base) {
    *rx_base = hpd_ifaces[iface].rx_streams[chan].rx_base_address;
  }
 
  if(rx_bytes) {
    *rx_bytes = hpd_ifaces[iface].rx_streams[chan].rx_buffer_bytes;
  }
 
  if(rx_haddr) {
    *rx_haddr = hpd_ifaces[iface].rx_streams[chan].rx_hibi_address;
  }
}
 
 
void hpd_rx_stream_get_conf(int chan, int* rx_base, int* rx_bytes,
			    int* rx_haddr)
{
  hpd_rx_stream_get_conf_gen(chan, rx_base, rx_bytes, rx_haddr, 0);
}
 
 
int hpd_rx_packet_poll_gen(int chan, int iface)
{
  int rx_words  = hpd_ifaces[iface].rx_packets[chan].rx_buffer_bytes >> 2;
  int base      = hpd_ifaces[iface].base_address;
  int n_streams = hpd_ifaces[iface].n_stream_channels;
  int received;
  HPD_RX_GET_WORDS(received, chan+n_streams, base);
  if(rx_words == received)
    return 1;
  return 0;
}
 
 
int hpd_rx_packet_poll(int chan)
{
  return hpd_rx_packet_poll_gen(chan, 0);
}
 
 
int hpd_rx_stream_poll_gen(int chan, int iface)
{
  int base     = hpd_ifaces[iface].base_address;
  int received;
  HPD_RX_GET_WORDS(received, chan, base);
  return received;
}
 
 
int hpd_rx_stream_poll(int chan)
{
  return hpd_rx_stream_poll_gen(chan, 0);
}
 
 
void hpd_rx_stream_read_gen(int chan, int words, int* buffer, int iface)
{
  int base          = hpd_ifaces[iface].base_address;
  int rx_base       = hpd_ifaces[iface].rx_streams[chan].rx_base_address;
  int rx_size       = hpd_ifaces[iface].rx_streams[chan].rx_buffer_bytes;
  int rx_read_words = hpd_ifaces[iface].rx_streams[chan].rx_read_words;
 
  if(words > (rx_size >> 2) - rx_read_words) {
    memcpy((void*)buffer, (void*)rx_base + (rx_read_words << 2), 
	   rx_size - (rx_read_words << 2));
    memcpy((void*)buffer + (rx_size - (rx_read_words << 2)),
	   (void*)rx_base, (words << 2) - (rx_size - (rx_read_words << 2)));
    hpd_ifaces[iface].rx_streams[chan].rx_read_words =
      words - (rx_size << 2) + rx_read_words;
  }
  else {
    memcpy((void*)buffer, (void*)rx_base + (rx_read_words << 2), (words << 2));
    hpd_ifaces[iface].rx_streams[chan].rx_read_words = 
      (rx_read_words + words) %  (rx_size >> 2);
  }
  HPD_RX_WORDS(chan, words, base);
}
 
 
void hpd_rx_stream_read(int chan, int words, int* buffer)
{
  hpd_rx_stream_read_gen(chan, words, buffer, 0);
}
 
 
void hpd_rx_stream_ack_gen(int chan, int words, int iface)
{
  int base = hpd_ifaces[iface].base_address;
  HPD_RX_WORDS(chan, words, base);
}
 
 
void hpd_rx_stream_ack(int chan, int words)
{
  hpd_rx_stream_ack_gen(chan, words, 0);
}
 
 
void hpd_irq_enable_gen(int iface)
{
  int base = hpd_ifaces[iface].base_address;
  HPD_IRQ_ENA(base);
}
 
 
void hpd_irq_enable()
{
  hpd_irq_enable_gen(0);
}
 
 
void hpd_irq_disable_gen(int iface)
{
  int base = hpd_ifaces[iface].base_address;
  HPD_IRQ_DIS(base);
}
 
 
void hpd_irq_disable()
{
  hpd_irq_disable_gen(0);
}
 
 
void hpd_irq_packet_ack_gen(int chan, int iface)
{
  int base      = hpd_ifaces[iface].base_address;
  int n_streams = hpd_ifaces[iface].n_stream_channels;
  HPD_CLEAR_IRQ_REG(chan+n_streams, base);
}
 
 
void hpd_irq_packet_ack(int chan)
{
  hpd_irq_packet_ack_gen(chan, 0);
}
 
 
void hpd_irq_stream_ack_gen(int chan, int iface)
{
  int base = hpd_ifaces[iface].base_address;
  HPD_CLEAR_IRQ_CHAN(chan, base);
}
 
 
void hpd_irq_stream_ack(int chan)
{
  hpd_irq_stream_ack_gen(chan, 0);
}
 
 
int hpd_irq_get_vector_gen(int iface)
{
  int base = hpd_ifaces[iface].base_address;
  int vector;
  HPD_GET_IRQ_REG(vector, base);
  return vector;
}
 
 
int hpd_irq_get_vector()
{
  return hpd_irq_get_vector_gen(0);
}
 
 
void hpd_irq_clear_vector_gen(int mask, int iface)
{
  int base = hpd_ifaces[iface].base_address;
  HPD_CLEAR_IRQ_REG(mask, base);
}
 
 
void hpd_irq_clear_vector(int mask)
{
  hpd_irq_clear_vector_gen(mask, 0);
}