/**
 * @file    HIP9011.cpp
 * @brief   HIP9011/TPIC8101 driver
 *
 *  pin1    VDD
 *  pin2    GND
 *
 *  pin8    Chip Select - CS
 *  pin11   Slave Data Out - MISO-
 *  pin12   Slave Data In - MOSI
 *  pin13   SPI clock - SCLK
 *
 *
 *
 * http://www.ti.com/lit/ds/symlink/tpic8101.pdf
 * http://www.intersil.com/content/dam/Intersil/documents/hip9/hip9011.pdf
 * http://www.intersil.com/content/dam/Intersil/documents/an97/an9770.pdf
 * http://e2e.ti.com/cfs-file/__key/telligent-evolution-components-attachments/00-26-01-00-00-42-36-40/TPIC8101-Training.pdf
 *
 * max SPI frequency: 5MHz max
 *
 * @date Nov 27, 2013
 * @author Andrey Belomutskiy, (c) 2012-2015
 * @Spilly
 */

#include "main.h"
#include "engine.h"
#include "settings.h"
#include "pin_repository.h"
#include "hardware.h"
#include "rpm_calculator.h"
#include "trigger_central.h"
#include "hip9011_lookup.h"
#include "HIP9011.h"
#include "adc_inputs.h"
#include "efilib2.h"
#include "engine_controller.h"

#if EFI_HIP_9011 || defined(__DOXYGEN__)

static NamedOutputPin intHold("HIP");
static OutputPin hipCs;

extern pin_output_mode_e DEFAULT_OUTPUT;

extern uint32_t lastExecutionCount;

uint32_t hipLastExecutionCount;

/**
 * band index is only send to HIP chip on startup
 */
static int currentBandIndex;
static int currentGainIndex = -1;
static int currentIntergratorIndex = -1;
static int settingUpdateCount = 0;
static int currentPrescaler = 0;

/*
 * maximum total number of degrees to subtract from ignition advance
 * when knocking
 */
static int maxKnockSubDeg = 10;

/**
 * Int/Hold pin is controlled from scheduler callbacks which are set according to current RPM
 *
 * The following state makes sure that we only have SPI communication while not integrating and that we take
 * a good ADC reading after integrating.
 *
 * Once integtation window is over, we wait for the 2nd ADC callback and then initiate SPI communication if needed
 *
 * hipOutput should be set to used FAST adc device
 */
static hip_state_e state = NOT_READY;

static scheduling_s startTimer[2];
static scheduling_s endTimer[2];

static Logging *logger;

// SPI_CR1_BR_1 // 5MHz
// SPI_CR1_CPHA Clock Phase
// todo: nicer method which would mention SPI speed explicitly?

static SPIConfig spicfg = { NULL,
/* HW dependent part.*/
NULL, 0,
SPI_CR1_MSTR |
//SPI_CR1_BR_1 // 5MHz
        SPI_CR1_CPHA | SPI_CR1_BR_0 | SPI_CR1_BR_1 | SPI_CR1_BR_2 };

static unsigned char tx_buff[1];
static unsigned char rx_buff[1];
static int nonZeroResponse = 0;

static int spiCount = 0;
static int firstBits = 0;
static int lastBits = 0;
static int knockLevel = 0;
static int knockDebug = 0;
#define SPI_SYNCHRONOUS(value) \
    spiSelect(driver); \
    tx_buff[0] = value; \
    spiExchange(driver, 1, tx_buff, rx_buff); \
    spiUnselect(driver); \
    if (rx_buff[0] != 0) nonZeroResponse++;

// todo: make this configurable
static SPIDriver *driver = &SPID2;

EXTERN_ENGINE
;

static char pinNameBuffer[16];

static float getBand(void) {
    return engineConfiguration->knockBandCustom == 0 ?
            BAND(engineConfiguration->cylinderBore) : engineConfiguration->knockBandCustom;
}

static void showHipInfo(void) {
    if (!boardConfiguration->isHip9011Enabled) {
        scheduleMsg(logger, "hip9011 driver not active");
        return;
    }

    printSpiState(logger, boardConfiguration);
    scheduleMsg(logger, "enabled=%s state=%d bore=%fmm freq=%fkHz PaSDO=%d",
            boolToString(boardConfiguration->isHip9011Enabled),
            state,
            engineConfiguration->cylinderBore, getBand(),
            engineConfiguration->hip9011PrescalerAndSDO);

    scheduleMsg(logger, "band_index=%d gain %f/index=%d", currentBandIndex, boardConfiguration->hip9011Gain, currentGainIndex);
    scheduleMsg(logger, "integrator index=%d hip_threshold=%f knockCount=%d maxKnockSubDeg=%d", currentIntergratorIndex,
            engineConfiguration->hipThreshold, engine->knockCount, maxKnockSubDeg);

    scheduleMsg(logger, "spi= IntHold@%s response count=%d", hwPortname(boardConfiguration->hip9011IntHoldPin),
            nonZeroResponse);
    scheduleMsg(logger, "CS@%s updateCount=%d", hwPortname(boardConfiguration->hip9011CsPin), settingUpdateCount);

    scheduleMsg(logger, "hip output=%fv@%s", getVoltageDivided("hip", engineConfiguration->hipOutputChannel),
            getPinNameByAdcChannel(engineConfiguration->hipOutputChannel, pinNameBuffer));
}

void setHip9011FrankensoPinout(void) {
    /**
     * SPI on PB13/14/15
     */
    boardConfiguration->isHip9011Enabled = true;
    boardConfiguration->hip9011CsPin = GPIOD_0;
    boardConfiguration->hip9011IntHoldPin = GPIOB_11;
    boardConfiguration->is_enabled_spi_2 = true;

    boardConfiguration->hip9011Gain = 0.1;
    engineConfiguration->hipThreshold = 2;

    engineConfiguration->hipOutputChannel = EFI_ADC_10;
}

static void startIntegration(void) {
    if (state == READY_TO_INTEGRATE) {
        /**
         * SPI communication is only allowed while not integrating, so we postpone the exchange
         * until we are done integrating
         */
        state = IS_INTEGRATING;
        turnPinHigh(&intHold);
    }
}

static void endIntegration(void) {
    /**
     * isIntegrating could be 'false' if an SPI command was pending thus we did not integrate during this
     * engine cycle
     */
    if (state == IS_INTEGRATING) {
        turnPinLow(&intHold);
        //state = WAITING_FOR_ADC_TO_SKIP;
        state = GET_SPI_DATA_ONE;
    }
}

/**
 * Shaft Position callback used to start or finish HIP integration
 */
static void intHoldCallback(trigger_event_e ckpEventType, uint32_t index DECLARE_ENGINE_PARAMETER_S) {
    // this callback is invoked on interrupt thread
    engine->m.beforeHipCb = GET_TIMESTAMP();
    if (index != 0)
        return;

    int rpm = engine->rpmCalculator.rpmValue;
    if (!isValidRpm(rpm))
        return;

    int structIndex = getRevolutionCounter() % 2;
    // todo: schedule this based on closest trigger event, same as ignition works
    scheduleByAngle(rpm, &startTimer[structIndex], engineConfiguration->knockDetectionWindowStart,
            (schfunc_t) &startIntegration, NULL, &engine->rpmCalculator);
    hipLastExecutionCount = lastExecutionCount;
    scheduleByAngle(rpm, &endTimer[structIndex], engineConfiguration->knockDetectionWindowEnd,
            (schfunc_t) &endIntegration,
            NULL, &engine->rpmCalculator);
    engine->m.hipCbTime = GET_TIMESTAMP() - engine->m.beforeHipCb;
}
static void setMaxKnockSubDeg(int value) {
    maxKnockSubDeg = value;
    showHipInfo();
}
static void setKnockThresh(float value) {
    engineConfiguration->hipThreshold = value;
    showHipInfo();
}
static void setKnockDebug(int value) {
    knockDebug = value;
    if(knockDebug){
        scheduleMsg(logger, "knock debug enabled");
    } else{
        scheduleMsg(logger, "knock debug disabled");
    }
}

static void setPrescalerAndSDO(int value) {
    engineConfiguration->hip9011PrescalerAndSDO = value;
    showHipInfo();
}

static void setBand(float value) {
    engineConfiguration->knockBandCustom = value;
    showHipInfo();
}

static void setGain(float value) {
    boardConfiguration->hip9011Gain = value;
    showHipInfo();
}

static int getBandIndex(void) {
    float freq = getBand();
    return getHip9011BandIndex(freq);
}
static void endOfSpiExchange(SPIDriver *spip) {
    spiUnselectI(driver);

    float knockVolts = 0;
    switch (spiCount){
    case 0:
        state = GET_SPI_DATA_TWO;
        spiCount ++;
        break;
    case 1:
        state = GET_SPI_DATA_THREE;
        //D7-D0 of digital integrator output
        firstBits = rx_buff[0];
        spiCount ++;
        break;
    case 2:
        state = ALL_SPI_DATA_REC;
        spiCount = 0;
        //D9 to D8 of digital integrator output followed by six zeros
        lastBits = rx_buff[0];




        knockLevel = lastBits<<2;
        knockLevel |= firstBits;
        //convert 12-bit digital integrator output to voltage
        knockVolts = knockLevel * KNOCK_VREF / 1024.0f;

        engine->knockNow = knockVolts > engineConfiguration->hipThreshold;

        /**
         * KnockCount is directly proportional to the degrees of ignition
         * advance removed
         * ex: degrees to subtract = knockCount;
         */

        /**
         * TODO use knockLevel as a factor for amount of ignition advance
         * to remove
         * Perhaps allow the user to set a multiplier
         * ex: degrees to subtract = knockCount + (knockLevel * X)
         * X = user configurable multiplier
         */
        if (engine->knockNow){
            /**
             * TODO put maxKnockSubDeg in board_configuration_s
             * Not sure how offsets work
             */
            if(engine->knockCount < maxKnockSubDeg){
                engine->knockCount++;
            }
        } else if (engine->knockCount >= 1){
            engine->knockCount--;
        } else {
            engine->knockCount = 0;
        }

        if(knockDebug){
            //scheduleMsg(logger, "first = %d", firstBits);
            //scheduleMsg(logger, "last = %d", lastBits);
            scheduleMsg(logger, "total = %d voltage = %f knocking = %d", knockLevel, knockVolts, engine->knockNow);
            //scheduleMsg(logger, "total = %d voltage = %f", knockLevel, knockVolts);
        }

        break;
    case 9:
        state = READY_TO_INTEGRATE;
        spiCount = 0;
        break;
    }
}

//void hipAdcCallback(adcsample_t value) {
void hipCallback(void) {
    if(state == GET_SPI_DATA_ONE){
        tx_buff[0] = SET_PRESCALER_CMD + engineConfiguration->hip9011PrescalerAndSDO;
        state = IS_SENDING_SPI_COMMAND;
        spiSelectI(driver);
        spiStartExchangeI(driver, 1, tx_buff, rx_buff);
    } else if(state == GET_SPI_DATA_TWO){
        //tx_buff[0] = SET_PRESCALER_CMD + engineConfiguration->hip9011PrescalerAndSDO;
        tx_buff[0] = SET_CHANNEL_CMD + 0;
        state = IS_SENDING_SPI_COMMAND;
        spiSelectI(driver);
        spiStartExchangeI(driver, 1, tx_buff, rx_buff);
    } else if(state == GET_SPI_DATA_THREE){
        tx_buff[0] = SET_CHANNEL_CMD + 0;
        state = IS_SENDING_SPI_COMMAND;
        spiSelectI(driver);
        spiStartExchangeI(driver, 1, tx_buff, rx_buff);
    } else if (state == ALL_SPI_DATA_REC) {

        int integratorIndex = getIntegrationIndexByRpm(engine->rpmCalculator.rpmValue);
        int gainIndex = getHip9011GainIndex(boardConfiguration->hip9011Gain);
        int bandIndex = getBandIndex();
        int prescalerIndex = engineConfiguration->hip9011PrescalerAndSDO;

        if (currentGainIndex != gainIndex) {
            spiCount = 9;
            currentGainIndex = gainIndex;

            //added CMD bits
            tx_buff[0] = SET_GAIN_CMD + gainIndex;

            state = IS_SENDING_SPI_COMMAND;
            spiSelectI(driver);
            spiStartExchangeI(driver, 1, tx_buff, rx_buff);
        } else if (currentIntergratorIndex != integratorIndex) {
            spiCount = 9;
            currentIntergratorIndex = integratorIndex;

            //added CMD bits
            tx_buff[0] = SET_INTEGRATOR_CMD + integratorIndex;

            state = IS_SENDING_SPI_COMMAND;
            spiSelectI(driver);
            spiStartExchangeI(driver, 1, tx_buff, rx_buff);
        } else if (currentBandIndex != bandIndex) {
            spiCount = 9;
            currentBandIndex = bandIndex;

            //added CMD bits
            tx_buff[0] = SET_BAND_PASS_CMD + bandIndex;

            state = IS_SENDING_SPI_COMMAND;
            spiSelectI(driver);
            spiStartExchangeI(driver, 1, tx_buff, rx_buff);
        } else if (currentPrescaler != prescalerIndex) {
            spiCount = 9;
            currentPrescaler = prescalerIndex;
            tx_buff[0] = SET_PRESCALER_CMD + prescalerIndex;

            state = IS_SENDING_SPI_COMMAND;
            spiSelectI(driver);
            spiStartExchangeI(driver, 1, tx_buff, rx_buff);
        } else {
            state = READY_TO_INTEGRATE;
        }
    }
}
static bool_t needToInit = true;

static void hipStartupCode(void) {
//  D[4:1] = 0000 : 4 MHz
//  D[4:1] = 0001 : 5 MHz
//  D[4:1] = 0010 : 6 MHz
//  D[4:1] = 0011 ; 8 MHz
//  D[4:1] = 0100 ; 10 MHz
//  D[4:1] = 0101 ; 12 MHz
//  D[4:1] = 0110 : 16 MHz
//  D[4:1] = 0111 : 20 MHz
//  D[4:1] = 1000 : 24 MHz


// '0' for 4MHz
    currentPrescaler = engineConfiguration->hip9011PrescalerAndSDO;
    SPI_SYNCHRONOUS(SET_PRESCALER_CMD + currentPrescaler);

    chThdSleepMilliseconds(10);

    // '0' for channel #1
    SPI_SYNCHRONOUS(SET_CHANNEL_CMD + 0);

    chThdSleepMilliseconds(10);

    // band index depends on cylinder bore
    SPI_SYNCHRONOUS(SET_BAND_PASS_CMD + currentBandIndex);

    chThdSleepMilliseconds(10);
    // enable advanced mode for digital integrator output
    SPI_SYNCHRONOUS(SET_ADVANCED_MODE);

    chThdSleepMilliseconds(10);
    /**
     * Let's restart SPI to switch it from synchronous mode into
     * asynchronous mode
     */
    spiStop(driver);
    spicfg.end_cb = endOfSpiExchange;
    spiStart(driver, &spicfg);
    state = READY_TO_INTEGRATE;
}

static THD_WORKING_AREA(hipTreadStack, UTILITY_THREAD_STACK_SIZE);

static msg_t hipThread(void *arg) {
    chRegSetThreadName("hip9011 init");
    while (true) {
        // some time to let the hardware start
        chThdSleepMilliseconds(500);
        if (needToInit) {
            hipStartupCode();
            needToInit = false;
        }
    }
    return -1;
}

void initHip9011(Logging *sharedLogger) {
    logger = sharedLogger;
    addConsoleAction("hipinfo", showHipInfo);
    if (!boardConfiguration->isHip9011Enabled)
        return;

    // todo: apply new properties on the fly
    prepareHip9011RpmLookup(
            engineConfiguration->knockDetectionWindowEnd - engineConfiguration->knockDetectionWindowStart);

    // todo: configurable
//  driver = getSpiDevice(boardConfiguration->hip9011SpiDevice);

    spicfg.ssport = getHwPort(boardConfiguration->hip9011CsPin);
    spicfg.sspad = getHwPin(boardConfiguration->hip9011CsPin);

    outputPinRegisterExt2("hip int/hold", &intHold, boardConfiguration->hip9011IntHoldPin, &DEFAULT_OUTPUT);
    outputPinRegisterExt2("hip CS", &hipCs, boardConfiguration->hip9011CsPin, &DEFAULT_OUTPUT);

    scheduleMsg(logger, "Starting HIP9011/TPIC8101 driver");
    spiStart(driver, &spicfg);

    currentBandIndex = getBandIndex();

    /**
     * this engine cycle callback would be scheduling actual integration start and end callbacks
     */
    addTriggerEventListener(&intHoldCallback, "DD int/hold", engine);

    addConsoleActionF("set_gain", setGain);
    addConsoleActionF("set_band", setBand);
    addConsoleActionI("set_hip_prescalerandsdo", setPrescalerAndSDO);
    addConsoleActionI("knock_debug", setKnockDebug);
    addConsoleActionF("set_knock_threshold", setKnockThresh);
    addConsoleActionI("set_max_knock_sub_deg", setMaxKnockSubDeg);
    chThdCreateStatic(hipTreadStack, sizeof(hipTreadStack), NORMALPRIO, (tfunc_t) hipThread, NULL);
}

#endif