sdram_usart_test.c

Go to the documentation of this file.

#define USART 0

#if USART
  #include "../usart/usart.h"
  #include <stdio.h>
#endif
#include "sdram.h"
#include <avr32/io.h>
#include "mt481c2m32b2tg.h"

#define SUCCESS 0
#define FAILURE -1

#if USART
  typedef char avr32_piomap_t[][2];
  void init_rs232( void );
  int print(volatile avr32_usart_t * usart, char *str);
  int pio_enable_module(avr32_piomap_t piomap, int size);
#endif

#ifndef __GNUC__
  #define AVR32_USART1_RXD_0_PIN      17
  #define AVR32_USART1_RXD_0_FUNCTION 0
  #define AVR32_USART1_TXD_0_PIN      18
  #define AVR32_USART1_TXD_0_FUNCTION 0
#endif

#define STK1000_SDRAM_BASE 0xB0000000 /* Using privileged mode P2 to bypass cache*/
#define CPU_HZ 20000000

int main( void )
{
  static sdram_info *info;
  unsigned long sdram_size, tmp, i;
  int noErrors=0;
  volatile unsigned long *sdram = (void *) STK1000_SDRAM_BASE;

  info->physical_address = STK1000_SDRAM_BASE;
  info->cols = mt481c2m32b2tg_cols;
  info->rows = mt481c2m32b2tg_rows;
  info->banks = mt481c2m32b2tg_banks;
  info->cas = mt481c2m32b2tg_cas;
  info->twr = mt481c2m32b2tg_twr;
  info->trc = mt481c2m32b2tg_trc;
  info->trp = mt481c2m32b2tg_trp;
  info->trcd = mt481c2m32b2tg_trcd;
  info->tras = mt481c2m32b2tg_tras;
  info->txsr = mt481c2m32b2tg_txsr;

  /* Calculate sdram size */
  sdram_size = 1 << (info->rows + info->cols + info->banks + 2);

#if USART
  init_rs232();
#endif
  printf("\nEXTERNAL SDRAM TEST\n\n");
  sdramc_init(info);
  mt481c2m32b2tg_init(info);
  printf("Initialization complete\nTest starting...\n");
  printf("Filling memoryspace (0x%lx)\n", sdram_size);

  for (i = 0; i < sdram_size; i++){
    sdram[i] = i;
    tmp = sdram[i];
    if (tmp != i) {
    #if USART
      printf("SDRAM verifcation failed at 0x%lx", STK1000_SDRAM_BASE + i);
      printf(". Read 0x%lx instead of expected 0x%lx\n", tmp, i);
    #endif
      noErrors++;
    }
  }

  if(noErrors==0){
    printf("SDRAM test completed successfully\n");
    return SUCCESS;
  }else{
    printf("SDRAM test completed with %x errors", noErrors);
    return FAILURE;
  }
}

#if USART
void init_rs232( void )
{
    struct usart_options_t opt;
    volatile struct avr32_usart_t *usart1 = &AVR32_USART1;

    avr32_piomap_t usart_piomap = {
      {AVR32_USART1_RXD_0_PIN, AVR32_USART1_RXD_0_FUNCTION},
      {AVR32_USART1_TXD_0_PIN, AVR32_USART1_TXD_0_FUNCTION}
    };

    // Set options for the USART
    opt.baudrate = 115200;
    opt.charlength = 8;
    opt.paritytype = USART_NO_PARITY;
    opt.stopbits = USART_1_STOPBIT;
    opt.channelmode = USART_NORMAL_CHMODE;

    // Initialize it in RS232 mode
    usart_init_rs232(usart1, &opt, CPU_HZ);

    pio_enable_module(usart_piomap, 2);

}

/* This will enable the usart functionality in the pio module */
int pio_enable_module(avr32_piomap_t piomap, int size)
{
  int i;
  volatile avr32_pio_t *pio;

  /* get the base address for the port */
  switch (**piomap/32) {

  case 0:
    pio = &AVR32_PIOA;
    break;
  case 1:
    pio = &AVR32_PIOB;
    break;
  case 2:
    pio = &AVR32_PIOC;
    break;
  case 3:
    pio = &AVR32_PIOD;
    break;
  case 4:
    pio = &AVR32_PIOE;
    break;
  default :
    return -FAILURE;

  }

  for(i=0; i<size; i++){

    pio->pdr |= ( 1<<( (**piomap) % 32) );
    pio->pudr |= ( 1<<( (**piomap) % 32) );

    switch( *(*piomap+1) ){    
    case 0: /* module A */
      pio->asr |= ( 1<<( (**piomap) % 32) );
      break;
    case 1: /* module B */
      pio->bsr |= ( 1<<( (**piomap) % 32) );
      break;
    default:
      return FAILURE;
    }

    piomap++;

  }
  
  return SUCCESS;
}

int print(volatile avr32_usart_t * usart, char *str)
{
        while (*str != '\0')
                usart_putchar(usart, *str++);
        return 0;
}


/* Newlib replacements for usart */

int _write_r ( struct _reent *ptr, int fd, const void *buf, size_t cnt )
{
  volatile struct avr32_usart_t *usart = &AVR32_USART1;
  char *msg = (char *) buf;
  int i;

  for(i=0; i<cnt; i++){
    usart_putchar(usart, *msg++);
  }
 return cnt;
}

int unimplemented_syscall(const char *);
int remove (char const *dummy){ return unimplemented_syscall("remove");}
int __close (){ return unimplemented_syscall("__close");}

#endif

---