/*
 * Copyright (c) 2004-2007 Marcus Overhagen <marcus@overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction, 
 * including without limitation the rights to use, copy, modify, 
 * merge, publish, distribute, sublicense, and/or sell copies of 
 * the Software, and to permit persons to whom the Software is 
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <stdlib.h>
#include <string.h>
#include <KernelExport.h>
#include "i2c_core.h"

#define TRACE_I2C
#ifdef TRACE_I2C
  #define TRACE dprintf
#else
  #define TRACE(a...)
#endif

static status_t i2c_writebyte(i2c_bus *bus, uint8 byte, int *ack);
static status_t i2c_readbyte(i2c_bus *bus, uint8 *pbyte);
static status_t i2c_read_unlocked(i2c_bus *bus, int address, void *data, int size);
static status_t i2c_write_unlocked(i2c_bus *bus, int address, const void *data, int size);


struct _i2c_bus
{
        void *cookie;
        bigtime_t delay;
        bigtime_t timeout;
        i2c_set_scl set_scl;
        i2c_set_sda set_sda;
        i2c_get_scl get_scl;
        i2c_get_sda get_sda;
        sem_id sem;
};


i2c_bus *
i2c_create_bus(void *cookie,
                           int frequency,
                           bigtime_t timeout,
                           i2c_set_scl set_scl,
                           i2c_set_sda set_sda,
                           i2c_get_scl get_scl,
                           i2c_get_sda get_sda)
{
        i2c_bus *bus = malloc(sizeof(i2c_bus));
        if (!bus)
                return NULL;

        bus->sem = create_sem(1, "i2c bus access");
        if (bus->sem < 0) {
                free(bus);
                return NULL;
        }

        bus->cookie = cookie;
        bus->delay = 1000000 / frequency;
        if (bus->delay == 0)
                bus->delay = 1;
        bus->timeout = timeout;
        bus->set_scl = set_scl;
        bus->set_sda = set_sda;
        bus->get_scl = get_scl;
        bus->get_sda = get_sda;

        set_scl(cookie, 1);
        set_sda(cookie, 1);

        return bus;
}


void
i2c_delete_bus(i2c_bus *bus)
{
        if (!bus)
                return;
        delete_sem(bus->sem);
        free(bus);
}


static inline void
set_sda_low(i2c_bus *bus)
{
        bus->set_sda(bus->cookie, 0);
        snooze(bus->delay);
}


static inline void
set_sda_high(i2c_bus *bus)
{
        bus->set_sda(bus->cookie, 1);
        snooze(bus->delay);
}


static inline void
set_scl_low(i2c_bus *bus)
{
        bus->set_scl(bus->cookie, 0);
        snooze(bus->delay);
}


static inline status_t
set_scl_high(i2c_bus *bus)
{
        bigtime_t end = system_time() + bus->timeout;
        bus->set_scl(bus->cookie, 1);
        while (0 == bus->get_scl(bus->cookie)) {
                if (system_time() > end)
                        return B_TIMED_OUT;
                snooze(5);
        }
        snooze(bus->delay);
        return B_OK;
}


static inline void
i2c_start(i2c_bus *bus)
{
        set_sda_low(bus);
        set_scl_low(bus);
}


static inline void
i2c_stop(i2c_bus *bus)
{
        set_sda_low(bus);
        set_scl_high(bus);
        set_sda_high(bus);
}


static inline status_t
i2c_start_address(i2c_bus *bus, int address, int read /* 1 = read, 0 = write */)
{
        status_t res;
        uint8 addr;
        int ack;
        int i;

//      TRACE("i2c_start_address: enter\n");

        addr = (address << 1) | (read & 1);
        for (i = 0; i < 5; i++) {
                i2c_start(bus);
                res = i2c_writebyte(bus, addr, &ack);
                if (res == B_OK) {
                        if (ack)
                                break;
                        res = B_ERROR;
                }
                if (res == B_TIMED_OUT)
                        break;
                i2c_stop(bus);
                snooze(50);
        }
        
//      TRACE("i2c_start_address: %s, ack %d, i %d\n", strerror(res), ack, i);
        return res;
}

        
/* write one byte and the ack/nack
 * return values:
 * B_OK => byte transmitted
 * B_ERROR => arbitration lost
 * B_TIMED_OUT => time out
 */
status_t
i2c_writebyte(i2c_bus *bus, uint8 byte, int *ack)
{
        int has_arbitration;

        int i;
        has_arbitration = 1;
        for (i = 7; i >= 0; i--) {
                int bit = (byte >> i) & 1;
                if (has_arbitration) {
                        if (bit)
                                set_sda_high(bus);
                        else
                                set_sda_low(bus);
                }
                if (set_scl_high(bus) != B_OK) {
                        set_sda_high(bus); // avoid blocking the bus
                        TRACE("i2c_writebyte timeout at bit %d\n", i);
                        return B_TIMED_OUT;
                }
                if (has_arbitration) {
                        if (bit == 1 && 0 == bus->get_sda(bus->cookie)) {
                                has_arbitration = 0;
//                              TRACE("i2c_writebyte lost arbitration at bit %d\n", i);
                        }
                }
                set_scl_low(bus);
        }
        set_sda_high(bus);
        if (set_scl_high(bus) != B_OK) {
                TRACE("i2c_writebyte timeout at ack\n");
                return B_TIMED_OUT;
        }
        *ack = 0 == bus->get_sda(bus->cookie);
        set_scl_low(bus);

        return has_arbitration ? B_OK : B_ERROR;
}


/* read one byte, don't generate ack
 */
status_t
i2c_readbyte(i2c_bus *bus, uint8 *pbyte)
{
        int i;
        uint8 byte;
        
        set_sda_high(bus);
        byte = 0;
        for (i = 7; i >= 0; i--) {
                if (set_scl_high(bus) != B_OK) {
                        TRACE("i2c_readbyte timeout at bit %d\n", i);
                        return B_TIMED_OUT;
                }
                byte = (byte << 1) | bus->get_sda(bus->cookie);
                set_scl_low(bus);
        }
        *pbyte = byte;
        return B_OK;
}


status_t
i2c_read_unlocked(i2c_bus *bus, int address, void *data, int size)
{
        status_t status;
        uint8 *bytes;
        
        if (size <= 0)
                return B_BAD_VALUE;
        
        status = i2c_start_address(bus, address, 1 /* 1 = read, 0 = write */);
        if (status != B_OK) {
                TRACE("i2c_read: error on i2c_start_address: %s\n", strerror(status));
                return status;
        }

        bytes = data;
        while (size > 0) {
                if (i2c_readbyte(bus, bytes) != B_OK) { // timeout
                        TRACE("i2c_read: timeout error on byte %ld\n", bytes - (uint8 *)data);
                        return B_TIMED_OUT;
                }
                if (size > 0)
                        set_sda_low(bus); // ack
                else
                        set_sda_high(bus); // nack
                        
                if (set_scl_high(bus) != B_OK) {
                        set_sda_high(bus); // avoid blocking the bus
                        TRACE("i2c_read: timeout at ack\n");
                        return B_TIMED_OUT;
                }
                set_scl_low(bus);
                set_sda_high(bus);

                size--;
                bytes++;
        }
        
        i2c_stop(bus);

        return B_OK;
}


status_t
i2c_write_unlocked(i2c_bus *bus, int address, const void *data, int size)
{
        const uint8 *bytes;
        status_t status;
        int ack;

        if (size <= 0)
                return B_BAD_VALUE;

        status = i2c_start_address(bus, address, 0 /* 1 = read, 0 = write */);
        if (status != B_OK) {
                TRACE("i2c_write: error on i2c_start_address: %s\n", strerror(status));
                return status;
        }

        bytes = data;
        while (size > 0) {
                status = i2c_writebyte(bus, *bytes, &ack);
                if (status == B_TIMED_OUT) {
                        TRACE("i2c_write: timeout error on byte %ld\n", bytes - (uint8 *)data);
                        return B_TIMED_OUT;
                }
                if (status != B_OK) {
                        TRACE("i2c_write: arbitration lost on byte %ld\n", bytes - (uint8 *)data);
                        break;
                }
                if (!ack) {
                        TRACE("i2c_write: error, got NACK on byte %ld\n", bytes - (uint8 *)data);
                        break;
                }
                bytes++;
                size--;
        }
        i2c_stop(bus);
        
        if (status != B_OK)
                return status;
        
        return ack ? B_OK : B_ERROR;
}


status_t
i2c_read(i2c_bus *bus, int address, void *data, int size)
{
        status_t res;
        acquire_sem(bus->sem);
        res = i2c_read_unlocked(bus, address, data, size);
        release_sem(bus->sem);
        return res;
}


status_t
i2c_write(i2c_bus *bus, int address, const void *data, int size)
{
        status_t res;
        acquire_sem(bus->sem);
        res = i2c_write_unlocked(bus, address, data, size);
        release_sem(bus->sem);
        return res;
}


status_t
i2c_xfer(i2c_bus *bus, int address,
                 const void *write_data, int write_size,
                 void *read_data, int read_size)
{
        status_t res;

        acquire_sem(bus->sem);
        
        if (write_data != 0 && write_size != 0) {
                res = i2c_write_unlocked(bus, address, write_data, write_size);
                if (res != B_OK) {
                        release_sem(bus->sem);
                        return res;
                }
        }

        if (read_data != 0 && read_size != 0) {
                res = i2c_read_unlocked(bus, address, read_data, read_size);
                if (res != B_OK) {
                        release_sem(bus->sem);
                        return res;
                }
        }

        release_sem(bus->sem);
        
        return B_OK;
}