// software i2c master (don`t check i2c bus state!)
#include "main.h"


#define I2C_SDA           A,0,H
#define I2C_SCL           A,1,H
#define INTERNAL_PULLUP   1
#define SCL_PULLUP        0
#define I2C_DELAY         1             //4 uS, standard mode, else nop, nop

#define DEVICE            0xd0          //DS1307

typedef uint8_t addr_t;


// return: true/false
void i2cInit();
bool i2cReadRandom(addr_t address, uint8_t *buffer);
bool i2cReadCurrentAddress(uint8_t *buffer);
bool i2cReadSequential(uint8_t *buffer, uint16_t size);
bool i2cReadBlock(addr_t address, uint8_t *buffer, uint16_t size);

bool i2cWriteByte(addr_t address, uint8_t data);
bool i2cWriteBlock(addr_t address, uint8_t *buffer, uint8_t size);

#include "soft_i2c.h"
#include "ds1307.h"                     //BINARY_DATA

enum {LOW, HIGH};
enum {WRITE, READ};                     // operation bit
enum {NAK, ACK};                        // I2cRead(argument)


#if INTERNAL_PULLUP
#define set_sda_1()       (in(I2C_SDA),  pullup(I2C_SDA))
#define set_sda_0()       (off(I2C_SDA), out(I2C_SDA)   )
 #if SCL_PULLUP
#define set_scl_1()       (in(I2C_SCL),  pullup(I2C_SCL))
#define set_scl_0()       (off(I2C_SCL), out(I2C_SCL)   )
 #else
#define set_scl_1()       on(I2C_SCL)
#define set_scl_0()       off(I2C_SCL)
 #endif
#else
#define set_sda_1()       in(I2C_SDA)
#define set_sda_0()       out(I2C_SDA)
#define set_scl_1()       in(I2C_SCL)
#define set_scl_0()       out(I2C_SCL)
#endif


static bool i2cWrite(uint8_t data);


// Initialize SCL/SDA pins and set the bus high - NOT USED!
// out: SDA = 1  SCL = 1 (open draw)
void i2cInit() {
  #if INTERNAL_PULLUP
  pullup(I2C_SDA);
   #if SCL_PULLUP
  pullup(I2C_SCL);
   #else
  off(I2C_SCL); out(I2C_SCL);
   #endif
  #else
  off(I2C_SDA);                         // low level to output mode
  off(I2C_SCL);                         
  #endif
}


#if I2C_DELAY
void i2c_delay()
{
  _delay_us(I2C_DELAY);
}

#else
#define i2c_delay() asm volatile( "nop \n nop \n" )
#endif


// set start condition, device address and mode
// out: SDA = 1 SCL = 0, if return true
static bool i2c_start(uint8_t device) { //+ R/W mode
  uint8_t i = 0;                        //timeout

  i2c_delay();
  set_sda_1();
  set_scl_1();
  do                                    // check i2c bus
    if (!--i)
      return false;
  #if SCL_PULLUP
  while (!pin(I2C_SDA) || !pin(I2C_SCL));
  #else
  while (!pin(I2C_SDA));
  #endif
  i2c_delay();
  set_sda_0();
  i2c_delay();
  set_scl_0();
  set_sda_1();
  return i2cWrite(device);
}


// Stop condition, set the bus high
// out: SDA = 1 SCL = 1
static void i2c_stop() {
  i2c_delay();
  set_sda_0();
  i2c_delay();
  set_scl_1();
  i2c_delay();                          // tSU_STO: 4,0 0,6
  set_sda_1();
  i2c_delay();
}                                       // tBUF:    4,7 1,3


// Read a byte, send Ack if more reads follow, Nak to terminate read
// in/out: SDA = 1 SCL = 0
static uint8_t i2cRead(uint8_t ack) {
  uint8_t data = 0;

  for (uint8_t i = 0; i < 8; i++) {
    data <<= 1;
    i2c_delay();                        // tLOW:    4,7 1,3
    set_scl_1();
    if (pin(I2C_SDA))
      data |= 1<<0;
    i2c_delay();                        // tHIGH:   4,0 0,6
    set_scl_0();
  }
  set_sda_1();
  if (ack)
    set_sda_0();
  i2c_delay();                          // tLOW:    4,7 1,3
  set_scl_1();
  i2c_delay();                          // tHIGH:   4,0 0,6
  set_scl_0();
  set_sda_1();
  return data;
}


// Write a byte. Return: ACK == true
// in/out: SDA = 1 SCL = 0
static bool i2cWrite(uint8_t data) {
  for (uint8_t m = 1<<7; m; m >>= 1) {
    if (m & data)
      set_sda_1();
    else
      set_sda_0();
    i2c_delay();                        // /2
    set_scl_1();
    i2c_delay();                        // tHIGH:   4,0 0,6
    set_scl_0();
  }
  i2c_delay();                          // tLOW:    4,7 1,3
  set_scl_1();                          // get Ack or Nak
  i2c_delay();                          // tHIGH:   4,0 0,6
  bool ack = pin(I2C_SDA);
  set_scl_0();
  set_sda_1();
  return !ack;
}


// Write address
// in/out: SDA = 1 SCL = 0
static bool i2cWriteAddress(addr_t address) {
  return i2cWrite(address);
}


//----------
// in/out: SDA = 1 SCL = 1 (open draw) - the bus high
// return: false/true

// Read byte @Random address
bool i2cReadRandom(addr_t address, uint8_t *buffer) {
  if (!i2c_start(DEVICE | WRITE))
    return false;
  if (!i2cWriteAddress(address))
    return false;
  return i2cReadCurrentAddress(buffer);
}


// Read byte @Current address
bool i2cReadCurrentAddress(uint8_t *buffer) {
  if (!i2c_start(DEVICE | READ))
    return false;
  *buffer = i2cRead(NAK);               //single byte
  i2c_stop();
  return true;
}


// Sequental Read @Current address
bool i2cReadSequential(uint8_t *buffer, uint16_t size) {
  if (!i2c_start(DEVICE | READ))
    return false;
  do
    *buffer++ = i2cRead(--size);
  while (size);
  i2c_stop();
  return true;
}


// Read block
bool i2cReadBlock(addr_t address, uint8_t *buffer, uint16_t size) {
  if (!i2c_start(DEVICE | WRITE))
    return false;
  if (!i2cWriteAddress(address))
    return false;
  return i2cReadSequential(buffer, size);
}


// Write byte
bool i2cWriteByte(addr_t address, uint8_t data) {
  if (!i2c_start(DEVICE | WRITE))
    return false;
  if (!i2cWriteAddress(address))
    return false;
  bool ack = i2cWrite(data);
  i2c_stop();
  return ack;
}


// Write block
bool i2cWriteBlock(addr_t address, uint8_t *buffer, uint8_t size) {
  bool ack;

  if (!i2c_start(DEVICE | WRITE))
    return false;
  if (!i2cWriteAddress(address))
    return false;
  do
    ack = i2cWrite(*buffer++);
  while (--size);
  i2c_stop();
  return ack;
}