#include <Wire.h>
#include <SD.h>

#define VCC_PIN 3
#define RST_PIN 2
#define DEV_ADDR 0x38
#define FTS_PACKET_LENGTH 2

File myFile;

void initSD(){

  Serial.print("Initializing SD card...");
  // On the Ethernet Shield, CS is pin 4. It's set as an output by default.
  // Note that even if it's not used as the CS pin, the hardware SS pin 
  // (10 on most Arduino boards, 53 on the Mega) must be left as an output 
  // or the SD library functions will not work. 
   pinMode(10, OUTPUT);
   
  if (!SD.begin(4)) {Serial.println("initialization failed!");return;}
  Serial.println("initialization done.");

  myFile = SD.open("fw.bin");
  if (myFile) {
  	fts_ctpm_fw_upgrade();
    // read from the file until there's nothing else in it:
    myFile.close();
  } else {
  	// if the file didn't open, print an error:
    Serial.println("error opening");
  }


}

void setup(){
	Wire.begin();
  	Serial.begin(9600);
  	init_device();
  	initSD();
  	
}

void loop(){}

void init_device() {
  pinMode(VCC_PIN, OUTPUT);
  pinMode(RST_PIN, OUTPUT);
  digitalWrite(RST_PIN, HIGH);
  digitalWrite(VCC_PIN, HIGH);
}

int cmd_write(byte *a, int n){
        Wire.beginTransmission(DEV_ADDR);
        Wire.write(a,n);
        assert(Wire.endTransmission(DEV_ADDR));
}
 
int byte_read(byte* pbt_buf, int bt_len){
        int r=0;
        byte d=0xFF;
        Wire.requestFrom(DEV_ADDR, bt_len);
        while(Wire.available()){
                d=Wire.read();
                pbt_buf[r]=d;
                Serial.print(d,HEX);
                r++;
        }
}

byte i2c_smbus_read_i2c_block_data(byte command, int length, byte *values)
{
	byte r=0, d=0xFF;
  Wire.beginTransmission(DEV_ADDR);
  Wire.write(command);
  assert(Wire.endTransmission(DEV_ADDR));
  Wire.requestFrom(DEV_ADDR, length);
  while (Wire.available()) {
  	d=Wire.read();
  	values[r]=d;
    Serial.print(d, HEX);
    r++;
  }
}
 
void assert(int e){ if(e){ Serial.print("[E");Serial.print(e);Serial.print("]"); } }

/*
while (myFile.available() && i++<10) {
    	Serial.print(myFile.read(),HEX);Serial.println(" ");
    }
    // close the file:
    
*/

boolean  fts_ctpm_fw_upgrade(/*byte* pbt_buf, unsigned int dw_lenth*/){
	unsigned int dw_lenth = myFile.size();
    byte reg_val[2] = {0};
    byte tmpData[4] = {0,0,0,0};
    unsigned int i = 0;
 
    unsigned int  packet_number;
    unsigned int  j;
    unsigned int  temp;
    unsigned int  lenght;
    byte  packet_buf[FTS_PACKET_LENGTH + 6];
    byte  auc_i2c_write_buf[10];
    byte bt_ecc;
    int i_ret;
        int ret;
        unsigned char ver;
 
    /*********Step 1:Reset  CTPM *****/
        pinMode(RST_PIN, OUTPUT);
    digitalWrite(RST_PIN, LOW);  
    delay(10);  
    pinMode(RST_PIN, OUTPUT);
    digitalWrite(RST_PIN, HIGH);
    Serial.println("[TSP] Step 1: Reset CTPM test");
   
    delay(50);  
    /*********Step 2:Enter upgrade mode *****/
    auc_i2c_write_buf[0] = 0x55;
    auc_i2c_write_buf[1] = 0xaa;
    do{
        i ++;
        i_ret = cmd_write(auc_i2c_write_buf, 2);
        delay(5);
    }while(i_ret <= 0 && i < 5 );
    Serial.println("[TSP] Step 2: Enter upgrade mode");
 
    /*********Step 3:check READ-ID***********************/
    tmpData[0]=0x90;
    cmd_write(tmpData,4);
        i=0;
        i_ret=0;
    do{
        i ++;
        i_ret = byte_read(reg_val,2);
        delay(10);
    }while(i_ret <= 0 && i < 5 );
    Serial.print("[TSP] Step 3: check ID: ");
    Serial.print(reg_val[0],HEX);
    Serial.print(", ");
    Serial.print(reg_val[1],HEX);
        Serial.println(" ");
 
    /*********Step 4:erase app*******************************/
    tmpData[0]=0x61;
    ret = cmd_write(tmpData,1);
   
    delay(1500);
    Serial.print("[TSP] Step 4: erase.ret=");
        Serial.print(ret);
        Serial.println(" ");
 
    /*********Step 5:write firmware(FW) to ctpm flash*********/
    bt_ecc = 0;
        Serial.println("[TSP] Step 5: start upgrade.");
    dw_lenth = dw_lenth - 8;
    packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
    packet_buf[0] = 0xbf;
    packet_buf[1] = 0x00;
    for (j=0;j<packet_number;j++){
        temp = j * FTS_PACKET_LENGTH;
        packet_buf[2] = (byte)(temp>>8);
        packet_buf[3] = (byte)temp;
        lenght = FTS_PACKET_LENGTH;
        packet_buf[4] = (byte)(lenght>>8);
        packet_buf[5] = (byte)lenght;
 
        for (i=0;i<FTS_PACKET_LENGTH;i++){
        	myFile.seek(j*FTS_PACKET_LENGTH + i);
            packet_buf[6+i] = myFile.read();
            bt_ecc ^= packet_buf[6+i];
        }
       
        ret=cmd_write( &packet_buf[0],FTS_PACKET_LENGTH + 6);
        if ((j * FTS_PACKET_LENGTH % 1024) == 0){
              Serial.print("[TSP] upgrade the 0x");
              Serial.print(((unsigned int)j) * FTS_PACKET_LENGTH);
              Serial.println(" th byte.");
        }
    }
 
    if ((dw_lenth) % FTS_PACKET_LENGTH > 0){
        temp = packet_number * FTS_PACKET_LENGTH;
        packet_buf[2] = (byte)(temp>>8);
        packet_buf[3] = (byte)temp;
 
        temp = (dw_lenth) % FTS_PACKET_LENGTH;
        packet_buf[4] = (byte)(temp>>8);
        packet_buf[5] = (byte)temp;
 
        for (i=0;i<temp;i++){
        	myFile.seek(packet_number*FTS_PACKET_LENGTH + i);
            packet_buf[6+i] = myFile.read();
            bt_ecc ^= packet_buf[6+i];
        }
             // printk("[TSP]temp 0x%x \n", temp);
        ret = cmd_write( &packet_buf[0],temp+6);    
              //printk("[TSP] 222 ret 0x%x \n", ret);
        delay(20);
    }
 
    //send the last six byte
    for (i = 0; i<6; i++){
        temp = 0x6ffa + i;
        packet_buf[2] = (byte)(temp>>8);
        packet_buf[3] = (byte)temp;
        temp =1;
        packet_buf[4] = (byte)(temp>>8);
        packet_buf[5] = (byte)temp;
        myFile.seek(dw_lenth + i);
        packet_buf[6] = myFile.read();

        bt_ecc ^= packet_buf[6];
 
        cmd_write(&packet_buf[0],7);  
        delay(20);
    }
 
    /*********Step 6: read out checksum***********************/
 
    i2c_smbus_read_i2c_block_data(0xcc, 1, &(reg_val[0]));
    Serial.print("[TSP] Step 6:  ecc read 0x");
    Serial.print(reg_val[0]);
    Serial.print(", new firmware 0x");
    Serial.print(bt_ecc);
    Serial.println(".");
    if(reg_val[0] != bt_ecc){
        //return ERR_ECC;
    }
 
    /*********Step 7: reset the new FW***********************/
    pinMode(RST_PIN, OUTPUT);
    digitalWrite(RST_PIN, LOW);  
    delay(1);  
    pinMode(RST_PIN, OUTPUT);
    digitalWrite(RST_PIN, HIGH);
 
    return true;
}

#include "adc.h"

#define ADC_DATA_SIZE 320

#define ADC_PERIOD (SystemCoreClock / 1000) / 2

#define ADCx ADC1
#define ADC_Channel_n ADC_Channel_7
#define RCC_APBnPeriph_ADCx RCC_APB2Periph_ADC1
#define ADC_RCC_APBnPeriphClockCmd RCC_APB2PeriphClockCmd
#define ADC_ExternalTrigConv_Tn_trigger ADC_ExternalTrigConv_T3_TRGO

#define GPIOx GPIOA
#define GPIO_Pin_n GPIO_Pin_7
#define RCC_APBnPeriph_GPIOx RCC_APB2Periph_GPIOA
#define GPIO_RCC_APBnPeriphClockCmd RCC_APB2PeriphClockCmd

#define TIMx TIM3
#define TIM_RCC_APBnPeriphClockCmd RCC_APB1PeriphClockCmd
#define RCC_APBnPeriph_TIMx RCC_APB1Periph_TIM3

#define DMAn_Channeln_IRQn DMA1_Channel1_IRQn
#define DMAn_IT_TCn DMA1_IT_TC1
#define DMAn_Channeln DMA1_Channel1
#define RCC_AHBPeriph_DMAn RCC_AHBPeriph_DMA1

static u16 adcDmaData[ADC_DATA_SIZE];

u16 *ADC_getData() { return adcDmaData; }

void timer_config(void) {
  TIM_TimeBaseInitTypeDef tim;
  TIM_RCC_APBnPeriphClockCmd(RCC_APBnPeriph_TIMx, ENABLE);

  /* Time base configuration */
  TIM_TimeBaseStructInit(&tim);
  tim.TIM_Period = (u16)(ADC_PERIOD / 125 - 1);  // 875 - 1;
  tim.TIM_Prescaler = 0;
  tim.TIM_ClockDivision = 0;
  tim.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIMx, &tim);

  TIM_SelectOutputTrigger(TIMx, TIM_TRGOSource_Update);
}

void timer_start(void) { TIM_Cmd(TIMx, ENABLE); }

void timer_stop(void) { TIM_Cmd(TIMx, DISABLE); }

void dma_init() {
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMAn, ENABLE);
  // DMA
  DMA_InitTypeDef dma;
  DMA_StructInit(&dma);

  dma.DMA_BufferSize = ADC_DATA_SIZE;
  dma.DMA_MemoryBaseAddr = (u32)adcDmaData;
  dma.DMA_PeripheralBaseAddr = (u32) & (ADCx->DR);
  dma.DMA_Mode = DMA_Mode_Circular;
  dma.DMA_Priority = DMA_Priority_High;
  dma.DMA_MemoryInc = DMA_MemoryInc_Enable;
  dma.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  dma.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_Init(DMAn_Channeln, &dma);

  NVIC_EnableIRQ(DMAn_Channeln_IRQn);
  DMA_ITConfig(DMAn_Channeln, DMA_IT_TC, ENABLE);
  DMA_Cmd(DMAn_Channeln, ENABLE);
}

void gpio_init() {
  GPIO_RCC_APBnPeriphClockCmd(RCC_APBnPeriph_GPIOx, ENABLE);

  GPIO_InitTypeDef gpio;
  gpio.GPIO_Speed = GPIO_Speed_50MHz;
  gpio.GPIO_Pin = GPIO_Pin_n;
  gpio.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOx, &gpio);
}

void adc_init() {
  // clock for ADC (max 14MHz --> 72/6=12MHz)
  // TODO: check for maximum clock
  // RCC_ADCCLKConfig(RCC_PCLK2_Div2);
  ADC_RCC_APBnPeriphClockCmd(RCC_APBnPeriph_ADCx, ENABLE);

  // ADC
  ADC_InitTypeDef adc;
  adc.ADC_ScanConvMode = DISABLE;
  adc.ADC_ContinuousConvMode = DISABLE;
  adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_Tn_trigger;
  adc.ADC_DataAlign = ADC_DataAlign_Right;
  adc.ADC_Mode = ADC_Mode_Independent;
  adc.ADC_NbrOfChannel = 1;
  ADC_Init(ADCx, &adc);

  ADC_RegularChannelConfig(ADCx, ADC_Channel_n, 1, ADC_SampleTime_1Cycles5);

  ADC_Cmd(ADCx, ENABLE);  // enable ADCx

  // Calibration
  ADC_ResetCalibration(ADCx);  // Reset previous calibration
  while (ADC_GetResetCalibrationStatus(ADCx))
    ;
  ADC_StartCalibration(
      ADCx);  // Start new calibration (ADC must be off at that time)
  while (ADC_GetCalibrationStatus(ADCx))
    ;

  ADC_ExternalTrigConvCmd(ADCx, ENABLE);
  ADC_DMACmd(ADCx, ENABLE);
  ADC_Cmd(ADCx, ENABLE);
}

void ADC_init() {
  gpio_init();
  dma_init();
  adc_init();
  timer_config();
  timer_start();
}

static u8 dataAvailable = 0;

inline u8 isDataAvailable() { return dataAvailable; }

inline void markDataUsed() {
  dataAvailable = 0;
  timer_start();
}

void DMA1_Channel1_IRQHandler(void) {
  if (DMA_GetITStatus(DMAn_IT_TCn) == SET) {
    //        DMA_Cmd(DMA1_Channel1, DISABLE);
    DMA_ClearITPendingBit(DMAn_IT_TCn);
    timer_stop();
    dataAvailable = 1;
  }
}

u8 dmaWorking = 0;
DMA_InitTypeDef dma8, dma16;

void dmaInit() {
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

  // DMA 8bit
  DMA_StructInit(&dma8);
  dma8.DMA_PeripheralBaseAddr = (u32) & (SPI1->DR);
  dma8.DMA_DIR = DMA_DIR_PeripheralDST;
  dma8.DMA_MemoryInc = DMA_MemoryInc_Enable;
  dma8.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  dma8.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  dma8.DMA_Priority = DMA_Priority_High;

  // DMA 16bit
  DMA_StructInit(&dma16);
  dma16.DMA_PeripheralBaseAddr = (u32) & (SPI1->DR);
  dma16.DMA_DIR = DMA_DIR_PeripheralDST;
  dma16.DMA_MemoryInc = DMA_MemoryInc_Enable;
  dma16.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  dma16.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  dma16.DMA_Priority = DMA_Priority_High;

  // IRQs
  NVIC_EnableIRQ(DMA1_Channel3_IRQn);
  DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, ENABLE);
  SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
}

void dmaSend(u8 *data, u32 n) {
  dma8.DMA_MemoryBaseAddr = (u32)data;
  dma8.DMA_BufferSize = n;
  DMA_Init(DMA1_Channel3, &dma8);
  dmaWorking = 1;
  TFT_CS_RESET;
  DMA_Cmd(DMA1_Channel3, ENABLE);
}

void dmaSend16(u16 *data, u16 n) {
  dma16.DMA_MemoryBaseAddr = (u32)data;
  dma16.DMA_BufferSize = n;
  DMA_Init(DMA1_Channel3, &dma16);
  dmaWorking = 1;
  TFT_CS_RESET;
  DMA_Cmd(DMA1_Channel3, ENABLE);
}

#define dmaWait()    \
  while (dmaWorking) \
    ;

void dmaSendData8(u8 *data, u16 n) {
  TFT_DC_SET;
  dmaSend(data, n);
  dmaWait();
}

void dmaSendData16(u16 *data, u16 n) {
  TFT_DC_SET;
  dmaSend16(data, n);
  dmaWait();
}

// TX
void DMA1_Channel3_IRQHandler(void) {
  if (DMA_GetITStatus(DMA1_IT_TC3)) {
    DMA_ClearITPendingBit(DMA1_IT_TC3);
    DMA_Cmd(DMA1_Channel3, DISABLE);
    TFT_CS_SET;
    dmaWorking = 0;
  }
}

void dmaSendCmd(u8 cmd) {
  TFT_DC_RESET;
  dmaSend(&cmd, 1);
  dmaWait();
}