/*

 * Access peripherals on the I2C bus.

 *

 * Copyright (C) 2018, 2020 Paul Boddie <paul@boddie.org.uk>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of

 * the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA  02110-1301, USA

 */

#include <l4/devices/cpm-jz4730.h>

#include <l4/devices/i2c-jz4730.h>

#include <l4/devices/memory.h>

#include <l4/re/c/util/cap_alloc.h>

#include <l4/sys/factory.h>

#include <l4/sys/icu.h>

#include <l4/sys/irq.h>

#include <l4/sys/rcv_endpoint.h>

#include <stdio.h>

#include <unistd.h>

/* Device and resource discovery. */

static long item_in_range(long start, long end, long index)

{

  if (start < end)

    return start + index;

  else

    return start - index;

}

/* Scan the I2C bus by performing speculative reads from each device address. */

static void i2c_scan(void *i2c_channel)

{

  uint8_t buf[1];

  unsigned int address;

  for (address = 0; address < 0x20; address++)

    printf("%02x ", address);

  printf("\n");

  for (address = 0; address < 0x20; address++)

    printf("-- ");

  for (address = 0; address < 0x80; address++)

  {

    if ((address % 32) == 0)

      printf("\n");

    if (jz4730_i2c_read(i2c_channel, address, buf, 1))

      printf("%02x ", address);

    else

      printf("?? ");

  }

  printf("\n");

  for (address = 0; address < 0x20; address++)

    printf("-- ");

  printf("\n\n");

}

/* Interpret RTC registers. */

static void rtc_datetime(uint8_t *rtcregs)

{

  const char *weekdays[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

  printf("%s %d%d-%d%d-%d%d %d%d:%d%d:%d%d\n",

    weekdays[rtcregs[0x06] & 0x07],

    (rtcregs[0x08] & 0xf0) >> 4,

    rtcregs[0x08] & 0x0f,

    (rtcregs[0x07] & 0x10) >> 4,

    rtcregs[0x07] & 0x0f,

    (rtcregs[0x05] & 0x30) >> 4,

    rtcregs[0x05] & 0x0f,

    (rtcregs[0x04] & 0x30) >> 4,

    rtcregs[0x04] & 0x0f,

    (rtcregs[0x03] & 0x70) >> 4,

    rtcregs[0x03] & 0x0f,

    (rtcregs[0x02] & 0x70) >> 4,

    rtcregs[0x02] & 0x0f);

}

int main(void)

{

  void *cpm;

  void *i2c, *i2c0;

  /* Interrupts. */

  l4_uint32_t i2c_irq_start = 0, i2c_irq_end = 0;

  l4_cap_idx_t icucap, irq0cap;

  /* Obtain resource details describing the interrupt for I2C channel 0. */

  printf("Access IRQ...\n");

  if (get_irq("jz4730-i2c", &i2c_irq_start, &i2c_irq_end) < 0)

    return 1;

  printf("IRQ range at %d...%d.\n", i2c_irq_start, i2c_irq_end);

  /* Obtain capabilities for the interrupt controller and an interrupt. */

  irq0cap = l4re_util_cap_alloc();

  icucap = l4re_env_get_cap("icu");

  if (l4_is_invalid_cap(icucap))

  { 

    printf("No 'icu' capability available in the virtual bus.\n");

    return 1;

  }

  if (l4_is_invalid_cap(irq0cap))

  {

    printf("Capabilities not available for interrupts.\n");

    return 1;

  }

  /* Create interrupt objects. */

  long err;

  err = l4_error(l4_factory_create_irq(l4re_global_env->factory, irq0cap));

  if (err)

  {

    printf("Could not create IRQ object: %lx\n", err);

    return 1;

  }

  /* Bind interrupt objects to IRQ numbers. */

  err = l4_error(l4_icu_bind(icucap,

                             item_in_range(i2c_irq_start, i2c_irq_end, 0),

                             irq0cap));

  if (err)

  {

    printf("Could not bind IRQ to the ICU: %ld\n", err);

    return 1;

  }

  /* Attach ourselves to the interrupt handler. */

  err = l4_error(l4_rcv_ep_bind_thread(irq0cap, l4re_env()->main_thread, 0));

  if (err)

  {

    printf("Could not attach to IRQs: %ld\n", err);

    return 1;

  }

  /* Peripheral memory. */

  l4_addr_t cpm_base = 0, cpm_base_end = 0;

  l4_addr_t i2c_base = 0, i2c_base_end = 0;

  /* Obtain resource details describing I/O memory. */

  printf("Access CPM...\n");

  if (get_memory("jz4730-cpm", &cpm_base, &cpm_base_end) < 0)

    return 1;

  printf("CPM at 0x%lx...0x%lx.\n", cpm_base, cpm_base_end);

  printf("Access I2C...\n");

  if (get_memory("jz4730-i2c", &i2c_base, &i2c_base_end) < 0)

    return 1;

  printf("I2C at 0x%lx...0x%lx.\n", i2c_base, i2c_base_end);

  /* Obtain CPM and I2C references. */

  cpm = jz4730_cpm_init(cpm_base);

  i2c = jz4730_i2c_init(i2c_base, i2c_base_end, cpm, 100000); /* 100 kHz */

  i2c0 = jz4730_i2c_get_channel(i2c, 0, irq0cap);

  /* Enable I2C. */

  jz4730_i2c_enable(i2c0);

  uint8_t buf[32];

  unsigned int nwritten;

  /* Set the clock: 12:34:56 on Saturday 2nd January 2021. */

  buf[0] = 2; buf[1] = 0x56; buf[2] = 0x34; buf[3] = 0x12; buf[4] = 0x02; buf[5] = 0x06; buf[6] = 0x01; buf[7] = 0x21;

  nwritten = jz4730_i2c_write(i2c0, 0x51, buf, 8);

  printf("Written: %d\n", nwritten);

  for (int i = 0; i < 3; i++)

  {

    /* Issue selection of device register 0. */

    buf[0] = 0;

    nwritten = jz4730_i2c_write(i2c0, 0x51, buf, 1);

    printf("Written: %d\n", nwritten);

    /* Read the contents of 16 registers. */

    unsigned int nread = jz4730_i2c_read(i2c0, 0x51, buf, 16);

    printf("Read: %d\n", nread);

    for (unsigned int i = 0; i < nread; i++)

      printf("%02x ", buf[i]);

    printf("\n");

    /* Show the interpreted date and time. */

    rtc_datetime(buf);

    /* Read from the power controller at 0x28. */

    buf[0] = 0xdb;

    nwritten = jz4730_i2c_write(i2c0, 0x28, buf, 1);

    printf("Written: %d\n", nwritten);

    nread = jz4730_i2c_read(i2c0, 0x28, buf, 1);

    printf("Read: %d\n", nread);

    printf("Voltage level: %1.3f\n", buf[0] * 36235 / 1000000.0);

    buf[0] = 0xd9;

    nwritten = jz4730_i2c_write(i2c0, 0x28, buf, 1);

    printf("Written: %d\n", nwritten);

    nread = jz4730_i2c_read(i2c0, 0x28, buf, 1);

    printf("Read: %d\n", nread);

    printf("Charger connected: %s\n", buf[0] & 1 ? "yes" : "no");

    /* Scan the bus. */

    printf("Scan I2C0...\n");

    i2c_scan(i2c0);

    sleep(5);

  }

  printf("start_not_possible = %d\n"

         "read_not_ready = %d\n"

         "read_not_ready_clear = %d\n"

         "read_not_ready_stx = %d\n"

         "read_not_possible = %d\n"

         "read_nack = %d\n"

         "read_complete = %d\n"

         "write_not_possible = %d\n"

         "write_complete = %d\n"

         "total_reads = %d\n",

         jz4730_i2c_start_not_possible(i2c0), jz4730_i2c_read_not_ready(i2c0), jz4730_i2c_read_not_ready_clear(i2c0), jz4730_i2c_read_not_ready_stx(i2c0),

         jz4730_i2c_read_not_possible(i2c0), jz4730_i2c_read_nack(i2c0), jz4730_i2c_read_complete(i2c0),

         jz4730_i2c_write_not_possible(i2c0), jz4730_i2c_write_complete(i2c0), jz4730_i2c_total_reads(i2c0));

  sleep(30);

  /* Issue a shutdown request. */

  buf[0] = 0xd8; buf[1] = 1;

  nwritten = jz4730_i2c_write(i2c0, 0x28, buf, 2);

  printf("Written: %d\n", nwritten);

  /* Detach from the interrupt. */

  err = l4_error(l4_irq_detach(irq0cap));

  if (err)

    printf("Error detaching from IRQ objects: %ld\n", err);

  return 0;

}