/* USB Host Shield Board test routine. Runs after assembly to check board functionality */

/* USB related */
//#include <Spi.h>
#include <Max3421e.h>
#include <Max3421e_constants.h>
#include <Usb.h>

#include "board_test.h" /* Board test messages */

//#define MAX_SS 10

void setup();
void loop();

MAX3421E Max;
USB Usb;

void setup()
{
  Serial.begin( 115200 );
  //Serial.println("Start");
  //Serial.println( SCK_PIN, DEC );
  Max.powerOn();
  printProgStr( startBanner );
  printProgStr( anykey_msg );
  //Serial.print( Max.getvar(), DEC);
}

void loop()
{
  while( Serial.available() == 0 );  //wait for input
  Serial.read();                     //empty input buffer
  /* start tests */
  /* SPI short test */
  if (!revregcheck()) test_halted();
  /* GPIO test */
  if (!gpiocheck()) printProgStr(PSTR("\r\nGPIO check failed. Make sure GPIO loopback adapter is installed"));
  /* SPI long test */
  if (!spitest()) test_halted();      //test SPI for transmission errors
  if (!osctest()) printProgStr(PSTR("OSCOK test failed. Check the oscillator"));
  if (!usbtest()) printProgStr(PSTR("USB connection test failed. Check traces from USB connector to MAX3421E, as well as VBUS"));  //never gets here
    /* All tests passed */
  printProgStr( anykey_msg );
}

/* SPI short test. Checks connectivity to MAX3421E by reading REVISION register. */
/* Die rev.1 returns 0x01, rev.2 0x12, rev.3 0x13. Any other value is considered communication error */
bool revregcheck()
{
  byte tmpbyte;
  printProgStr(PSTR("\r\nReading REVISION register...Die revision "));
  tmpbyte = Max.regRd( rREVISION );
  switch( tmpbyte ) {
    case( 0x01 ):  //rev.01
      printProgStr(PSTR("01"));
      break;  
    case( 0x12 ):  //rev.02
      printProgStr(PSTR("02"));
      break;
    case( 0x13 ):  //rev.03
      printProgStr(PSTR("03"));
      break;
    default:
      printProgStr(PSTR("invalid. Value returned: "));
      print_hex( tmpbyte, 8 );
      printProgStr( testfailed_msg );
      return( false );
      break;
  }//switch( tmpbyte )...
  printProgStr( testpassed_msg );
  return( true );
}
/* SPI long test */
bool spitest()
{
  byte l = 0;
  byte k = 0;
  byte gpinpol_copy = Max.regRd( rGPINPOL );
  printProgStr(PSTR("\r\nSPI test. Each  '.' indicates 64K transferred. Stops after transferring 1MB (16 dots)\r\n"));
  /**/
  for( byte j = 0; j < 16; j++ ) {
    for( word i = 0; i < 65535; i++ ) {
      Max.regWr( rGPINPOL, k );
      l = Max.regRd( rGPINPOL);
      if( l != k ) {
        printProgStr( spitest_fail_msg );
        print_hex( k, 8);
        printProgStr(PSTR("Value read: "));
        print_hex( l, 8 );
        return( false );                  //test failed
      }
      k++;
    }//for( i = 0; i < 65535; i++
    Serial.print(".");
  }//for j = 0; j < 16...
  Max.regWr( rGPINPOL, gpinpol_copy );
  printProgStr(testpassed_msg);
  return( true );
}
/* Oscillator test */
bool osctest()
{
  printProgStr(PSTR("\r\nOscillator start/stop test."));
  printProgStr( osctest_oscstate_msg );
  check_OSCOKIRQ();                          //print OSCOK state
  printProgStr(PSTR("\r\nSetting CHIP RESET."));
  Max.regWr( rUSBCTL, bmCHIPRES );              //Chip reset. This stops the oscillator
  printProgStr( osctest_oscstate_msg );
  check_OSCOKIRQ();  //print OSCOK state
  printProgStr(PSTR("\r\nClearing CHIP RESET. "));
  Max.regWr( rUSBCTL, 0x00 );                //Chip reset release
  for( word i = 0; i < 65535; i++) {
    if( Max.regRd( rUSBIRQ ) & bmOSCOKIRQ ) {
      printProgStr(PSTR("PLL is stable. Time to stabilize - "));
      Serial.print( i, DEC );
      printProgStr(PSTR(" cycles"));
      printProgStr( testpassed_msg );
      return( true );
    }
  }//for i = 
  return(false);
}
/* Stop/start oscillator */
void check_OSCOKIRQ()
{
  if( Max.regRd( rUSBIRQ ) & bmOSCOKIRQ ) {  //checking oscillator state
    printProgStr(PSTR("ON"));
  }
  else {
    printProgStr(PSTR("OFF"));
  }
}
/* Test USB connectivity */
bool usbtest()
{
  byte rcode;
  byte usbstate;
    Max.powerOn();
    delay( 200 );
    printProgStr(PSTR("\r\nUSB Connectivity test. Waiting for device connection... "));
    while( 1 ) {
      delay( 200 );
      Max.Task();
      Usb.Task();
      usbstate = Usb.getUsbTaskState();
      switch( usbstate ) {
        case( USB_ATTACHED_SUBSTATE_RESET_DEVICE ):
          printProgStr(PSTR("\r\nDevice connected. Resetting"));
          break;
        case( USB_ATTACHED_SUBSTATE_WAIT_SOF ): 
          printProgStr(PSTR("\r\nReset complete. Waiting for the first SOF..."));
          //delay( 1000 );
          break;  
        case( USB_ATTACHED_SUBSTATE_GET_DEVICE_DESCRIPTOR_SIZE ):
          printProgStr(PSTR("\r\nSOF generation started. Enumerating device."));
          break;
        case( USB_STATE_ADDRESSING ):
          printProgStr(PSTR("\r\nSetting device address"));
          //delay( 100 );
          break;
        case( USB_STATE_CONFIGURING ):
          //delay( 1000 );
          printProgStr(PSTR("\r\nGetting device descriptor"));
          rcode = getdevdescr( 1 );
            if( rcode ) {
              printProgStr(PSTR("\r\nError reading device descriptor. Error code "));
              print_hex( rcode, 8 );
            }
            else {
              printProgStr(PSTR("\r\n\nAll tests passed. Press RESET to restart test")); 
              while(1);
            }
          break;
        case( USB_STATE_ERROR ):
          printProgStr(PSTR("\r\nUSB state machine reached error state"));
          break;
        default:
          break;
    }//switch
  }//while(1)
}
/* Get device descriptor */
byte getdevdescr( byte addr )
{
  USB_DEVICE_DESCRIPTOR buf;
  byte rcode;
  rcode = Usb.getDevDescr( addr, 0, 0x12, ( char *)&buf );
  if( rcode ) {
    return( rcode );
  }
  printProgStr(PSTR("\r\nDevice descriptor: "));
  printProgStr(PSTR("\r\nDescriptor Length:\t"));
  print_hex( buf.bLength, 8 );
  printProgStr(PSTR("\r\nDescriptor type:\t"));
  print_hex( buf.bDescriptorType, 8 );
  printProgStr(PSTR("\r\nUSB version:\t"));
  print_hex( buf.bcdUSB, 16 );
  printProgStr(PSTR("\r\nDevice class:\t"));
  print_hex( buf.bDeviceClass, 8 );
  printProgStr(PSTR("\r\nDevice Subclass:\t"));
  print_hex( buf.bDeviceSubClass, 8 );
  printProgStr(PSTR("\r\nDevice Protocol:\t"));
  print_hex( buf.bDeviceProtocol, 8 );
  printProgStr(PSTR("\r\nMax.packet size:\t"));
  print_hex( buf.bMaxPacketSize0, 8 );
  printProgStr(PSTR("\r\nVendor ID:\t"));
  print_hex( buf.idVendor, 16 );
  printProgStr(PSTR("\r\nProduct ID:\t"));
  print_hex( buf.idProduct, 16 );
  printProgStr(PSTR("\r\nRevision ID:\t"));
  print_hex( buf.bcdDevice, 16 );
  printProgStr(PSTR("\r\nMfg.string index:\t"));
  print_hex( buf.iManufacturer, 8 );
  printProgStr(PSTR("\r\nProd.string index:\t"));
  print_hex( buf.iProduct, 8 );
  printProgStr(PSTR("\r\nSerial number index:\t"));
  print_hex( buf.iSerialNumber, 8 );
  printProgStr(PSTR("\r\nNumber of conf.:\t"));
  print_hex( buf.bNumConfigurations, 8 );
  return( 0 );
}

/* GPIO lines check. A loopback adapter connecting GPIN to GPOUT is assumed */
bool gpiocheck()
{
 byte tmpbyte = 0;
  printProgStr(PSTR("\r\nChecking GPIO lines. Install GPIO loopback adapter and press any key to continue..."));
  while( Serial.available() == 0 );  //wait for input
  Serial.read();                     //empty input buffer  
    for( byte i = 0; i < 255; i++ ) {
      Max.gpioWr( i );
      tmpbyte = Max.gpioRd();
      if( tmpbyte != i ) {
        printProgStr(PSTR("GPIO read/write mismatch. Write: "));
        Serial.print(i, HEX);
        printProgStr(PSTR(" Read: "));
        Serial.println( tmpbyte, HEX );
        return( false );
      }//if( tmpbyte != i )
    }//for( i= 0...
    printProgStr( testpassed_msg );
    return( true );
}
/* Test halted state. Generates 0x55 to aid in SPI troubleshooting */    
void test_halted()
{
  printProgStr( test_halted_msg );
  printProgStr(PSTR("\r\nPress RESET to restart test"));
  while( 1 )  {            //System Stop. Generating pattern to keep SCLK, MISO, MOSI, SS busy
    digitalWrite(MAX_SS,LOW);
    Max.regWr( 0x55, 0x55 );
//    Spi.transfer( 0x55 ); 
    digitalWrite(MAX_SS,HIGH);
  }
}
/* given a PROGMEM string, use Serial.print() to send it out */
/* Some non-intuitive casting necessary:                           */
/* printProgStr(PSTR("Func.Mode:\t0x"));                           */
/* printProgStr((char*)pgm_read_word(&mtpopNames[(op & 0xFF)]));   */
void printProgStr(const char* str )
{
  if(!str) { 
    return;
  }
  char c;
  while((c = pgm_read_byte(str++))) {
    Serial.print(c,BYTE);
  }
}
/* prints hex numbers with leading zeroes */
// copyright, Peter H Anderson, Baltimore, MD, Nov, '07
// source: http://www.phanderson.com/arduino/arduino_display.html
void print_hex(int v, int num_places)
{
  int mask=0, n, num_nibbles, digit;

  for (n=1; n<=num_places; n++)
  {
    mask = (mask << 1) | 0x0001;
  }
  v = v & mask; // truncate v to specified number of places

  num_nibbles = num_places / 4;
  if ((num_places % 4) != 0)
  {
    ++num_nibbles;
  }

  do
  {
    digit = ((v >> (num_nibbles-1) * 4)) & 0x0f;
    Serial.print(digit, HEX);
  } 
  while(--num_nibbles);
}