/*
   * Copyright (C) 2014 Freie Universität Berlin
   *
   * This file is subject to the terms and conditions of the GNU Lesser General
   * Public License v2.1. See the file LICENSE in the top level directory for more
   * details.
   */
  
  /**
   * @ingroup tests
   * @{
   *
   * @file
   * @brief       Application for testing low-level SPI driver implementations
   *
   * This implementation covers both, master and slave configurations.
   *
   * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
   *
   * @}
   */
  
  #include <stdio.h>
  #include <string.h>
  #include <stdlib.h>
  
  #include "board.h"
  #include "shell.h"
  #include "periph/spi.h"
  #include "periph/gpio.h"
  
  enum {
      READ = 0,
      WRITE,
      INIT
  } rw;
  
  static int spi_dev = -1;
  static gpio_t spi_cs = -1;
  static int spi_mode_int = -1;
  static spi_conf_t spi_mode = -1;
  static int spi_speed_int = -1;
  static spi_speed_t spi_speed = -1;
  
  /* 0 for slave, 1 for master, -1 for not initialized */
  static int spi_master = -1;
  static int port = -1;
  static int pin = -1;
  
  static char buffer[256];       /* temporary buffer */
  static char rx_buffer[256];    /* global receive buffer */
  static int rx_counter = 0;
  
  static volatile int state;
  static char* mem = "Hello Master! abcdefghijklmnopqrstuvwxyz 0123456789 "
                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  
  int parse_spi_dev(int argc, char **argv)
  {
      /* reset default values */
      spi_dev = SPI_0;
      spi_mode = SPI_CONF_FIRST_RISING;
      spi_speed = SPI_SPEED_1MHZ;
  
      if (argc < 4) {
          printf("usage: %s <dev> <cs port> <cs pin> [mode [speed]]\n", argv[0]);
          puts("        DEV is the SPI device to use:");
          for (int i = 0; i < SPI_NUMOF; i++) {
              printf("             %i - SPI_%i\n", i, i);
          }
          puts("        cs port:  port to use as the chip select line");
          puts("        cs pin:   pin to use on th given port as cs line");
          puts("        mode: must be one of the following options (* marks "
                        "default value):");
          puts("            *0 - POL:0, PHASE:0 - ON FIRST RISING EDGE");
          puts("             1 - POL:0, PHASE:1 - ON SECOND RISING EDGE");
          puts("             2 - POL:1, PHASE:0 - ON FIRST FALLING EDGE");
          puts("             3 - POL:1, PHASE:1 - on second falling edge");
          puts("        speed: must be one of the following options (only used "
                        "in master mode):");
          puts("             0 - 100 KHz");
          puts("             1 - 400 KHz");
          puts("            *2 - 1 MHz");
          puts("             3 - 5 MHz");
          puts("             4 - 10 MHz\n");
          return -4;
      }
      spi_dev = atoi(argv[1]);
      if (spi_dev < 0 || spi_dev >= SPI_NUMOF) {
          puts("error: invalid DEV value given");
          return -1;
      }
      port = atoi(argv[2]);
      pin = atoi(argv[3]);
      spi_cs = GPIO_PIN(port,pin);
      if (argc >= 5) {
          spi_mode_int = argv[4][0] - '0';
          if (spi_mode_int < 0 || spi_mode_int > 3) {
              puts("error: invalid MODE value given");
              return -2;
          } else {
              switch (spi_mode_int) {
                  case 0:
                      spi_mode = SPI_CONF_FIRST_RISING;
                      break;
                  case 1:
                      spi_mode = SPI_CONF_SECOND_RISING;
                      break;
                  case 2:
                      spi_mode = SPI_CONF_FIRST_FALLING;
                      break;
                  case 3:
                      spi_mode = SPI_CONF_SECOND_FALLING;
                      break;
              }
          }
      }
      if (argc >= 6) {
          spi_speed_int = argv[5][0] - '0';
          if (spi_speed_int < 0 || spi_speed_int > 4) {
              puts("error: invalid SPEED value given");
              return -3;
          } else {
              switch (spi_speed_int) {
                  case 0:
                      spi_speed = SPI_SPEED_100KHZ;
                      break;
                  case 1:
                      spi_speed = SPI_SPEED_400KHZ;
                      break;
                  case 2:
                      spi_speed = SPI_SPEED_1MHZ;
                      break;
                  case 3:
                      spi_speed = SPI_SPEED_5MHZ;
                      break;
                  case 4:
                      spi_speed = SPI_SPEED_10MHZ;
                      break;
              }
          }
      }
      return 0;
  }
  
  void print_bytes(char* title, char* chars, int length)
  {
      printf("%4s", title);
      for (int i = 0; i < length; i++) {
          printf("  %2i ", i);
      }
      printf("\n    ");
      for (int i = 0; i < length; i++) {
          printf(" 0x%02x", (int)chars[i]);
      }
      printf("\n    ");
      for (int i = 0; i < length; i++) {
          if (chars[i] < ' ' || chars[i] > '~') {
              printf("  ?? ");
          }
          else {
              printf("   %c ", chars[i]);
          }
      }
      printf("\n\n");
  }
  
  void slave_on_cs(void *arg)
  {
      (void)arg;
  
      spi_transmission_begin(spi_dev, 'F');
      state = 0;
      rw = INIT;
  }
  
  char slave_on_data(char data)
  {
      rx_buffer[rx_counter] = data;
      rx_counter++;
      if (rx_counter >= 256) {
          rx_counter = 0;
      }
  
      switch (rw) {
          case READ:
              return mem[state++];
          case WRITE:
              mem[state++] = data;
              return 'o';
          case INIT:
              if (data == ' ') {
                  rw = READ;
                  return mem[state++];
              } else if (data & 0x80) {
                  rw = WRITE;
                  state = (data & 0x7f);
                  return 'W';
              } else {
                  rw = READ;
                  state = data;
                  return mem[state++];
              }
      }
      return 'e';
  }
  
  int cmd_init_master(int argc, char **argv)
  {
      int res;
      spi_master = -1;
      if (parse_spi_dev(argc, argv) < 0) {
          return 1;
      }
      spi_acquire(spi_dev);
      res = spi_init_master(spi_dev, spi_mode, spi_speed);
      spi_release(spi_dev);
      if (res < 0) {
          printf("spi_init_master: error initializing SPI_%i device (code %i)\n",
                  spi_dev, res);
          return 1;
      }
      res = gpio_init(spi_cs, GPIO_OUT);
      if (res < 0){
          printf("gpio_init: error initializing GPIO_PIN(%i, %i) as CS line (code %i)\n",
                  port, pin, res);
          return 1;
      }
      gpio_set(spi_cs);
      spi_master = 1;
      printf("SPI_%i successfully initialized as master, cs: GPIO_PIN(%i, %i), mode: %i, speed: %i\n",
              spi_dev, port, pin, spi_mode_int, spi_speed_int);
      return 0;
  }
  
  int cmd_init_slave(int argc, char **argv)
  {
      int res;
      spi_master = -1;
      if (parse_spi_dev(argc, argv) < 0) {
          return 1;
      }
      spi_acquire(spi_dev);
      res = spi_init_slave(spi_dev, spi_mode, slave_on_data);
      spi_release(spi_dev);
      if (res < 0) {
          printf("spi_init_slave: error initializing SPI_%i device (code: %i)\n",
                  spi_dev, res);
          return 1;
      }
      res = gpio_init_int(spi_cs, GPIO_IN, GPIO_FALLING, slave_on_cs, 0);
      if (res < 0){
          printf("gpio_init_int: error initializing GPIO_PIN(%i, %i) as CS line (code %i)\n",
                  port, pin, res);
          return 1;
      }
      spi_master = 0;
      printf("SPI_%i successfully initialized as slave, cs: GPIO_PIN(%i, %i), mode: %i\n",
              spi_dev, port, pin, spi_mode_int);
      return 0;
  }
  
  int cmd_transfer(int argc, char **argv)
  {
      int res;
      char *hello = "Hello";
  
      if (spi_master != 1) {
          puts("error: node is not initialized as master, please do so first");
          return 1;
      }
  
      if (argc < 2) {
          puts("No data to transfer given, will transfer 'Hello' to device");
      }
      else {
          hello = argv[1];
      }
  
      /* do the actual data transfer */
      spi_acquire(spi_dev);
      gpio_clear(spi_cs);
      res = spi_transfer_bytes(spi_dev, hello, buffer, strlen(hello));
      gpio_set(spi_cs);
      spi_release(spi_dev);
  
      /* look at the results */
      if (res < 0) {
          printf("error: unable to transfer data to slave (code: %i)\n", res);
          return 1;
      }
      else {
          printf("Transfered %i bytes:\n", res);
          print_bytes("MOSI", hello, res);
          print_bytes("MISO", buffer, res);
          return 0;
      }
  }
  
  int cmd_print(int argc, char **argv)
  {
      if (spi_master != 0) {
          puts("error: node is not initialized as slave");
          return 1;
      }
      else {
          printf("Received %i bytes:\n", rx_counter);
          print_bytes("MOSI", rx_buffer, rx_counter);
      }
      rx_counter = 0;
      memset(&rx_buffer, 0, 256);
      return 0;
  }
  
  static const shell_command_t shell_commands[] = {
      { "init_master", "Initialize node as SPI master", cmd_init_master },
      { "init_slave", "Initialize node as SPI slave", cmd_init_slave },
      { "send", "Transfer string to slave (only in master mode)", cmd_transfer },
      { "print_rx", "Print the received string (only in slave mode)", cmd_print },
      { NULL, NULL, NULL }
  };
  
  int main(void)
  {
      puts("\nRIOT low-level SPI driver test");
      puts("This application enables you to test a platforms SPI driver implementation.");
      puts("Enter 'help' to get started\n");
  
      /* run the shell */
      char line_buf[SHELL_DEFAULT_BUFSIZE];
      shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);
  
      return 0;
  }