/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#define ADK_INTERNAL
#include "fwk.h"
#include "I2C.h"
#include "coop.h"
#include "dbg.h"

// the hardware interface in this chip is as pleasant to use as cuddling a pirahna, hence the bit-bang solution.
// to use the hardware, set I2C_BITBANG to 0.
// to use the peripheral DMA with the I2C hardware, set I2C_PDC to 1.
#define I2C_BITBANG 0
#define I2C_PDC 1
#define I2C_INT_PDC 1

#define I2C_STAT_DONE 0
#define I2C_STAT_LASTREAD 2
#define I2C_STAT_BUSY 1
#define I2C_STAT_NACK 3

typedef struct _i2cInst
{
    Twi *pTwi;
    volatile uint8_t status;
    uint8_t *lastByte;
} i2c_i;

static i2c_i i2cInst[I2C_NUM_INSTANCES] = { { TWI0, 0, 0 }, { TWI1, 0, 0 } };

static char sdaRd(uint8_t instance);
static void sdaLo(uint8_t instance);
static void sdaHi(uint8_t instance);
static void sclLo(uint8_t instance);
static void sclHi(uint8_t instance);
static void i2cBitTx(uint8_t instance, char bit);
static void i2cStop(uint8_t instance);
static void i2cPdcDisable(Twi *pTwi);

	//sda first please
static const uint8_t pins[I2C_NUM_INSTANCES][2] = { { PORTA(17), PORTA(18) }, { PORTB(12), PORTB(13) } };
static uint32_t delayTicks[I2C_NUM_INSTANCES];


static void i2cDelay(uint8_t instance){

    fwkDelay(delayTicks[instance]);
}

void i2cClock(uint8_t instance, uint32_t clock){
#if I2C_BITBANG
    delayTicks[instance] = (TICKS_PER_MS * 1000) / (8 * clock * 2);
#else
    Twi *pTwi;
    uint32_t dwCkDiv = 0;
    uint32_t dwClDiv;
    uint32_t dwOk = 0;
    if (instance == 0)
        pTwi = TWI0;
    else
        pTwi = TWI1;

    while (!dwOk) {
        dwClDiv = ((BOARD_MCK / (2 * clock)) - 4) / (1 << dwCkDiv);
        if (dwClDiv <= 255)
            dwOk = 1;
        else
            dwCkDiv++;
    }
    pTwi->TWI_CWGR = 0;
    pTwi->TWI_CWGR = (dwCkDiv << 16) | (dwClDiv << 8) | dwClDiv;
#endif
}

// i2c interrupt handler used only for PDC mode
// to prevent runaway operations caused by not responding
// fast enough and setting the stop bit.
void i2c_handler( i2c_i *pInst )
{
    uint32_t status;
    Twi *pTwi = pInst->pTwi;

    status = pTwi->TWI_SR & pTwi->TWI_IMR; // Masked status

    if (TWI_SR_TXBUFE & status) { // Transmit has completed.
        i2cPdcDisable(pTwi);
        pTwi->TWI_CR = TWI_CR_STOP;
        pTwi->TWI_IDR = TWI_IDR_TXBUFE;
        pTwi->TWI_IER = TWI_IER_TXCOMP;
    } else if (TWI_SR_RXBUFF & status) { // Receive has completed
        if (pInst->status == I2C_STAT_LASTREAD) {
            i2cPdcDisable(pTwi);
            pTwi->TWI_IDR = TWI_IDR_RXBUFF;
            pTwi->TWI_IER = TWI_IER_TXCOMP;
        } else {
            pInst->status = I2C_STAT_LASTREAD;
            i2cPdcDisable(pTwi);
            pTwi->TWI_CR = TWI_CR_STOP;
            pTwi->TWI_RPR = pInst->lastByte;
            pTwi->TWI_RCR = 1;
            pTwi->TWI_PTCR = TWI_PTCR_RXTEN;
        }
    } else if (TWI_SR_TXCOMP & status) {
        pInst->status = I2C_STAT_DONE;
        pTwi->TWI_IDR = TWI_IDR_TXCOMP;
    } else if (TWI_SR_NACK & status) {
        pInst->status = I2C_STAT_NACK;
        i2cPdcDisable(pTwi);
    }
}

void TWI0_Handler(void)
{
    i2c_handler(&i2cInst[0]);
}

void TWI1_Handler(void)
{
    i2c_handler(&i2cInst[1]);
}

uint8_t i2cInit(uint8_t instance, uint32_t clock){
    uint8_t i;

    if(instance >= I2C_NUM_INSTANCES) return I2C_ERR_INVAL;

    gpioSetFun(pins[instance][0], GPIO_FUNC_GPIO);
    gpioSetFun(pins[instance][1], GPIO_FUNC_GPIO);
    gpioSetPullup(pins[instance][0], 1);
    gpioSetPullup(pins[instance][1], 1);
    gpioSetDir(pins[instance][0], 0);
    gpioSetDir(pins[instance][1], 0);
    gpioSetVal(pins[instance][0], 0);
    gpioSetVal(pins[instance][1], 0);
    sdaHi(instance);
    sclHi(instance);
    delayTicks[instance] = (TICKS_PER_MS * 1000) / (8 * clock * 2);
    i2cDelay(instance);
    i2cDelay(instance);
    for (i = 0; i < 100; i++)       // Try to reset the bus
        i2cBitTx(instance, 1);
    i2cStop(instance);

#if !I2C_BITBANG
    PMC_EnablePeripheral(instance ? ID_TWI1 : ID_TWI0);
    gpioSetFun(pins[instance][0], GPIO_FUNC_A);
    gpioSetFun(pins[instance][1], GPIO_FUNC_A);
    TWI_ConfigureMaster(instance ? TWI1 : TWI0, clock, BOARD_MCK);

#if I2C_INT_PDC
    NVIC_EnableIRQ(instance ? TWI1_IRQn : TWI0_IRQn);
    if (instance)
        TWI1->TWI_IDR = 0x00F77;
    else
        TWI0->TWI_IDR = 0x00F77;
#endif

#endif


    return I2C_ALL_OK;
}

static void i2cStart(uint8_t instance){

    sdaHi(instance);
    sclHi(instance);
    i2cDelay(instance);
    sdaLo(instance);
    i2cDelay(instance);
    sclLo(instance);
    i2cDelay(instance);
}

static void i2cStop(uint8_t instance){

    i2cDelay(instance);
    sdaLo(instance);
    i2cDelay(instance);
    sclHi(instance);
    i2cDelay(instance);
    sdaHi(instance);
}

static char i2cBitRx(uint8_t instance){

    char ret;

    sdaHi(instance);
    i2cDelay(instance);
    sclHi(instance);
    i2cDelay(instance);
    ret = sdaRd(instance);
    sclLo(instance);

    return ret;
}

static void i2cBitTx(uint8_t instance, char bit){

    if(bit) sdaHi(instance);
    else sdaLo(instance);
    i2cDelay(instance);
    sclHi(instance);
    i2cDelay(instance);
    sclLo(instance);
}

static char i2cSend(uint8_t instance, uint8_t val){	//return 1 -> ack, 0->nak

    uint8_t i;

    for(i = 0; i < 8; i++){
        i2cBitTx(instance, !!(val & 0x80));
        val <<= 1;
    }
    return !i2cBitRx(instance);
}

static uint8_t i2cRecv(uint8_t instance, char ack){

    uint8_t i, v = 0;

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

        v <<= 1;
        if(i2cBitRx(instance)) v |= 1;
    }
    i2cBitTx(instance, !ack);
    return v;
}


static void i2cWaitComplete(Twi *pTwi)
{
    while(!(pTwi->TWI_SR & TWI_SR_TXCOMP)) coopYield();
}

static uint32_t i2cWaitRx(Twi *pTwi)
{
    uint32_t stat;
    do {
        coopYield();
        stat = pTwi->TWI_SR;
        if (stat & TWI_SR_NACK) {
            return stat;
        }
    } while (!(stat & TWI_SR_RXRDY));
}

static uint32_t i2cWaitTx(Twi *pTwi)
{
    uint32_t stat;
    do {
        coopYield();
        stat = pTwi->TWI_SR;
        if (stat & TWI_SR_NACK) {
            return stat;
        }
    } while (!(stat & TWI_SR_TXRDY));
    return 0;
}

static void i2cPdcDisable(Twi *pTwi)
{
    pTwi->TWI_PTCR = TWI_PTCR_RXTDIS;
    pTwi->TWI_PTCR = TWI_PTCR_TXTDIS;
    pTwi->TWI_RPR = 0;
    pTwi->TWI_RCR = 0;
    pTwi->TWI_TPR = 0;
    pTwi->TWI_TCR = 0;
}

static uint32_t i2cWaitPdcTx(Twi *pTwi)
{
    uint32_t stat;
    do {
        coopYield();
        stat = pTwi->TWI_SR;
        if (stat & TWI_SR_NACK) {
            return stat;
        }
    } while (!(stat & TWI_SR_TXBUFE));
    return stat;
}

static uint32_t i2cWaitPdcRx(Twi *pTwi)
{
    uint32_t stat;
    do {
        coopYield();
        stat = pTwi->TWI_SR;
        if ((stat & TWI_SR_NACK) || ((stat & TWI_SR_TXCOMP) && !(stat & TWI_SR_RXBUFF)))  {
            return stat;
        }
    } while(!(stat & TWI_SR_RXBUFF));
    return stat;
}

uint8_t i2cOp(uint8_t instance, uint8_t addr, const uint8_t* sendData, uint8_t sendSz, uint8_t* recvData, uint8_t recvSz){

    uint8_t ret = I2C_ERR_NAK;
    uint32_t stat;

#if I2C_PDC
    uint8_t dat[256];
    uint8_t i;
    uint32_t tmp;
    if (sendData != NULL && (uint32_t)sendData < 0x20000000) {  /* Undocumented feature: PDC can't read from flash */
        if (sendSz > 256)
            return I2C_ERR_INVAL;
        for (i = 0; i < sendSz; i++)
            dat[i] = *sendData++;
        sendData = dat;
    }
#endif

#if !I2C_BITBANG
    Twi *pTwi;
#endif

    if(instance >= I2C_NUM_INSTANCES) return I2C_ERR_INVAL;

#if !I2C_BITBANG
    pTwi = (instance == 0) ? TWI0 : TWI1;
#endif

#if I2C_BITBANG
    addr <<= 1;

    if(sendSz || !recvSz){	//if neither send nor recv requested, do a single send -> this is for a scan

        i2cStart(instance);

        if(!i2cSend(instance, addr)) goto out;
        while(sendSz--) if(!i2cSend(instance, *sendData++)) goto out;
    }
    if(recvSz){

        i2cStart(instance); //if we already sent something, restart

        if(!i2cSend(instance, addr | 1)) goto out;
        while(recvSz){
            recvSz--;
            *recvData++ = i2cRecv(instance, !!recvSz);
        }
    }

    ret = I2C_ALL_OK;
#else

    if (sendSz == 0 && recvSz == 0) {   // Quick (for a scan)
        pTwi->TWI_MMR = 0;
        pTwi->TWI_MMR = (addr << 16);
        pTwi->TWI_CR = TWI_CR_QUICK;
        if (TWI_SR_NACK & i2cWaitTx(pTwi)) {
            i2cWaitComplete(pTwi);
            ret = I2C_ERR_NAK;
            goto out;
        }
        i2cWaitComplete(pTwi);
    }

#if I2C_PDC
    if (sendSz != 0) {
        pTwi->TWI_TPR = (uint32_t)sendData;
        pTwi->TWI_TCR = sendSz;
        pTwi->TWI_MMR = 0;
        pTwi->TWI_MMR = (addr << 16);
        pTwi->TWI_IADR = 0;
        pTwi->TWI_IADR = 0;
        pTwi->TWI_PTCR = TWI_PTCR_TXTEN;
#if I2C_INT_PDC
        i2cInst[instance].status = I2C_STAT_BUSY;
        pTwi->TWI_IER = TWI_IER_TXBUFE | TWI_IER_NACK;
        while((i2cInst[instance].status != I2C_STAT_DONE) &&
              (i2cInst[instance].status != I2C_STAT_NACK))
            coopYield();
        if (i2cInst[instance].status == I2C_STAT_NACK) {
            ret = I2C_ERR_NAK;
            goto out;
        }
#else

        if (TWI_SR_NACK & i2cWaitPdcTx(pTwi)) {
            i2cPdcDisable(pTwi);
            i2cWaitComplete(pTwi);
            ret = I2C_ERR_NAK;
            goto out;
        }
        i2cPdcDisable(pTwi);
        pTwi->TWI_CR = TWI_CR_STOP;
        i2cWaitComplete(pTwi);
#endif
    }

    if (recvSz == 1) {              // We are forced to do the one byte reads manually.
        pTwi->TWI_RPR = (uint32_t)recvData;
        pTwi->TWI_RCR = 1;
        pTwi->TWI_MMR = 0;
        pTwi->TWI_MMR = TWI_MMR_MREAD | (addr << 16);
        pTwi->TWI_CR = TWI_CR_START | TWI_CR_STOP;
        pTwi->TWI_PTCR = TWI_PTCR_RXTEN;
#if I2C_INT_PDC
        i2cInst[instance].status = I2C_STAT_LASTREAD;
        pTwi->TWI_IER = TWI_IER_RXBUFF | TWI_IER_NACK;
        while((i2cInst[instance].status != I2C_STAT_DONE) &&
              (i2cInst[instance].status != I2C_STAT_NACK))
            coopYield();
        if (i2cInst[instance].status == I2C_STAT_NACK) {
            ret = I2C_ERR_NAK;
            goto out;
        }
#else

        if (TWI_SR_NACK & i2cWaitPdcRx(pTwi)) {
            i2cPdcDisable(pTwi);
            i2cWaitComplete(pTwi);
            ret = I2C_ERR_NAK;
            goto out;
        }
        i2cPdcDisable(pTwi);
        i2cWaitComplete(pTwi);
#endif
    }

    if (recvSz > 1) {
        pTwi->TWI_RPR = (uint32_t)recvData;
        pTwi->TWI_RCR = recvSz - 1; // Last byte read is handled manually
        pTwi->TWI_MMR = 0;
        pTwi->TWI_MMR = TWI_MMR_MREAD | (addr << 16);
        pTwi->TWI_CR = TWI_CR_START;
        pTwi->TWI_PTCR = TWI_PTCR_RXTEN;

#if I2C_INT_PDC
        i2cInst[instance].lastByte = recvData + recvSz - 1;
        i2cInst[instance].status = I2C_STAT_BUSY;
        pTwi->TWI_IER = TWI_IER_RXBUFF | TWI_IER_NACK;
        while((i2cInst[instance].status != I2C_STAT_DONE) &&
              (i2cInst[instance].status != I2C_STAT_NACK))
            coopYield();
        if (i2cInst[instance].status == I2C_STAT_NACK) {
            ret = I2C_ERR_NAK;
            goto  out;
        }
#else
        if (TWI_SR_NACK & i2cWaitPdcRx(pTwi)) {
            i2cPdcDisable(pTwi);
            i2cWaitComplete(pTwi);
            ret = I2C_ERR_NAK;
            goto out;
        }
        i2cPdcDisable(pTwi);
        pTwi->TWI_CR = TWI_CR_STOP;
        pTwi->TWI_RPR = (uint32_t)(recvData + recvSz - 1);
        pTwi->TWI_RCR = 1;
        pTwi->TWI_PTCR = TWI_PTCR_RXTEN;
        if (TWI_SR_NACK & i2cWaitPdcRx(pTwi)) {
            i2cPdcDisable(pTwi);
            i2cWaitComplete(pTwi);
            ret = I2C_ERR_NAK;
            goto out;
        }
        i2cPdcDisable(pTwi);
        i2cWaitComplete(pTwi);
#endif
    }
    ret = I2C_ALL_OK;
#else
    if (sendSz != 0) {
        pTwi->TWI_MMR = 0;
        pTwi->TWI_MMR = (addr << 16);
        pTwi->TWI_IADR = 0;
        pTwi->TWI_IADR = 0;
        while (sendSz--) {
            pTwi->TWI_THR = *sendData++;
            stat = i2cWaitTx(pTwi);
            if (stat & TWI_SR_NACK) {
                ret = I2C_ERR_NAK;
                goto out;
            }
        }
        pTwi->TWI_CR = TWI_CR_STOP;
        i2cWaitComplete(pTwi);
    }

    if (recvSz == 1) {
        pTwi->TWI_MMR = 0;
        pTwi->TWI_MMR = TWI_MMR_MREAD | (addr << 16);
        pTwi->TWI_IADR = 0;
        pTwi->TWI_IADR = 0;
        pTwi->TWI_CR = TWI_CR_START | TWI_CR_STOP;
        if (TWI_SR_NACK & i2cWaitRx(pTwi)) {
            ret = I2C_ERR_NAK;
            goto out;
        }
        *recvData = pTwi->TWI_RHR;
        i2cWaitComplete(pTwi);
    } else if (recvSz >= 1) {
        pTwi->TWI_MMR = 0;
        pTwi->TWI_MMR = TWI_MMR_MREAD | (addr << 16);
        pTwi->TWI_IADR = 0;
        pTwi->TWI_IADR = 0;
        pTwi->TWI_CR = TWI_CR_START;
        while (recvSz--) {
            if (TWI_SR_NACK & i2cWaitRx(pTwi)) {
                ret = I2C_ERR_NAK;
                goto out;
            }
            dbgPrintf("\0");
            *recvData++ = pTwi->TWI_RHR;
            if (recvSz == 1) pTwi->TWI_CR = TWI_CR_STOP;
        }
        i2cWaitComplete(pTwi);
    }

    ret = I2C_ALL_OK;
#endif
#endif

out:

#if I2C_BITBANG
    i2cStop(instance);
#else
    if (ret != I2C_ALL_OK) {
        pTwi->TWI_CR = TWI_CR_STOP;
        i2cWaitComplete(pTwi);
    }
#endif

    return ret;
}

uint8_t i2cSingleWrite(uint8_t instance, uint8_t addr, uint8_t reg, uint8_t val){

    unsigned char data[2] = {reg, val};

    return i2cOp(instance, addr, data, 2, NULL, 0);
}

uint8_t i2cSingleRead(uint8_t instance, uint8_t addr, uint8_t reg){

    uint8_t ret, val;

    ret = i2cOp(instance, addr, &reg, 1, &val, 1);

    if(ret != I2C_ALL_OK) val = 0xFF;

    return val;
}

uint8_t i2cQuick(uint8_t instance, uint8_t addr, uint8_t byte){

    return i2cOp(instance, addr, &byte, 1, NULL, 0);
}

uint8_t i2cScan(uint8_t instance, uint8_t addr){

     return i2cOp(instance, addr, NULL, 0, NULL, 0);
}

static char sdaRd(uint8_t instance){

    return gpioGetVal(pins[instance][0]);
}

static void sdaLo(uint8_t instance){

    gpioSetDir(pins[instance][0], 0);
}

static void sdaHi(uint8_t instance){

    gpioSetDir(pins[instance][0], 1);
}

static void sclLo(uint8_t instance){

    gpioSetDir(pins[instance][1], 0);
}

static void sclHi(uint8_t instance){

    gpioSetDir(pins[instance][1], 1);
    while(!gpioGetVal(pins[instance][1]));
}