/*

 * Access the HDMI I2C peripheral on the MIPS Creator CI20 board.

 *

 * Copyright (C) 2020, 2021, 2023 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-jz4780.h>

#include <l4/devices/gpio-jz4780.h>

#include <l4/devices/hdmi-jz4780.h>

#include <l4/devices/lcd-jz4780.h>

#include <l4/devices/lcd-jz4740-config.h>

#include <l4/devices/lcd-jz4740-panel.h>

#include <l4/devices/memory.h>

#include <l4/re/c/dataspace.h>

#include <l4/re/c/dma_space.h>

#include <l4/re/c/mem_alloc.h>

#include <l4/re/c/rm.h>

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

#include <l4/re/env.h>

#include <l4/re/protocols.h>

#include <l4/sys/cache.h>

#include <l4/sys/err.h>

#include <l4/sys/factory.h>

#include <l4/sys/icu.h>

#include <l4/sys/ipc.h>

#include <l4/sys/irq.h>

#include <l4/sys/rcv_endpoint.h>

#include <l4/io/io.h>

#include <l4/libedid/edid.h>

#include <l4/vbus/vbus.h>

#include <stdio.h>

#include <unistd.h>

#include <stdint.h>

#include <string.h>

#include <stdlib.h>

enum {

  DDCSCL = 24,  /* via PORTF */

  DDCSDA = 25,  /* via PORTF */

};

/* Test panel. */

static struct Jz4740_lcd_panel panel = {

  .config = (

      Jz4740_lcd_mode_tft_generic

    | Jz4740_lcd_bpp_24

    | Jz4740_lcd_desc_8_word

    | Jz4740_lcd_underrun_recover

    | Jz4740_lcd_ps_disabled

    | Jz4740_lcd_cls_disabled

    | Jz4740_lcd_spl_disabled

    | Jz4740_lcd_rev_disabled

    | Jz4740_lcd_pclock_negative

    | Jz4740_lcd_hsync_positive

    | Jz4740_lcd_vsync_positive

    | Jz4740_lcd_de_positive),

  .width = 1280,

  .height = 1024,

  .bpp = 24,

  .frame_rate = 60,

  .hsync = 112,

  .vsync = 3,

  .line_start = 248,  // back porch (blanking - hsync - offset)

  .line_end = 48,     // front porch (sync offset)

  .frame_start = 36,  // back porch (blanking - vsync - offset)

  .frame_end = 3,     // front porch (sync offset)

};

/* 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;

}

static void show_timings(uint8_t *buf)

{

  unsigned int width, height;

  /* Attempt to decode EDID information. */

  libedid_prefered_resolution(buf, &width, &height);

  printf("Preferred resolution: %d x %d\n", width, height);

  libedid_dump_standard_timings(buf);

}

int main(void)

{

  long err;

  /* Buffer for EDID data. */

  uint8_t edid[128];

  unsigned int length = 0, i;

  /* Version details. */

  uint8_t hdmi_major;

  uint16_t hdmi_minor;

  const struct Phy_capabilities *phy_def;

  /* Peripheral memory. */

  l4_addr_t cpm_base = 0, cpm_base_end = 0;

  l4_addr_t gpio_base = 0, gpio_base_end = 0;

  l4_addr_t hdmi_base = 0, hdmi_base_end = 0;

  l4_addr_t lcd_base = 0, lcd_base_end = 0;

  l4_addr_t port_f, port_f_end;

  /* Peripheral abstractions. */

  void *cpm;

  void *gpio_port_f;

  void *hdmi;

  void *lcd;

  /* Allocated memory. */

  l4_cap_idx_t desc_mem, fb_mem, dma, vbus;

  l4_size_t desc_size, desc_psize, fb_size, fb_psize;

  l4_addr_t desc_addr, fb_addr;

  l4re_dma_space_dma_addr_t desc_paddr, fb_paddr;

  unsigned char *picture;

  unsigned char *fb_picture, *fb_picture_row;

  unsigned int x, y;

  /* Access to IRQs. */

  l4_uint32_t hdmi_irq_start = 0, hdmi_irq_end = 0;

  l4_uint32_t lcd_irq_start = 0, lcd_irq_end = 0;

  l4_cap_idx_t icu, hdmi_irq, lcd_irq;

  /* Capability allocation. */

  desc_mem = l4re_util_cap_alloc();

  fb_mem = l4re_util_cap_alloc();

  dma = l4re_util_cap_alloc();

  hdmi_irq = l4re_util_cap_alloc();

  lcd_irq = l4re_util_cap_alloc();

  icu = l4re_env_get_cap("icu");

  vbus = l4re_env_get_cap("vbus");

  if (l4_is_invalid_cap(icu))

  {

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

    return 1;

  }

  if (l4_is_invalid_cap(desc_mem) || l4_is_invalid_cap(fb_mem) ||

      l4_is_invalid_cap(hdmi_irq) || l4_is_invalid_cap(lcd_irq))

  {

    printf("Capabilities could not be reserved.\n");

    return 1;

  }

  /* Obtain resource details describing the interrupt for HDMI I2C. */

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

  if (get_irq("jz4780-hdmi", &hdmi_irq_start, &hdmi_irq_end) < 0)

    return 1;

  printf("HDMI IRQ range at %d...%d.\n", hdmi_irq_start, hdmi_irq_end);

  if (get_irq("jz4780-lcd", &lcd_irq_start, &lcd_irq_end) < 0)

    return 1;

  printf("LCD IRQ range at %d...%d.\n", lcd_irq_start, lcd_irq_end);

  /* Create interrupt objects. */

  err = l4_error(l4_factory_create_irq(l4re_global_env->factory, hdmi_irq)) ||

        l4_error(l4_factory_create_irq(l4re_global_env->factory, lcd_irq));

  if (err)

  {

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

    return 1;

  }

  /* Bind interrupt objects to IRQ numbers. Here, the first HDMI interrupt is

     bound, this being the general HDMI interrupt. */

  err = l4_error(l4_icu_bind(icu,

                             item_in_range(hdmi_irq_start, hdmi_irq_end, 0),

                             hdmi_irq)) ||

        l4_error(l4_icu_bind(icu,

                             item_in_range(lcd_irq_start, lcd_irq_end, 0),

                             lcd_irq));

  if (err)

  {

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

    return 1;

  }

  /* Attach ourselves to the interrupt handler with some arbitrary labels. */

  err = l4_error(l4_rcv_ep_bind_thread(hdmi_irq, l4re_env()->main_thread, 0x00)) ||

        l4_error(l4_rcv_ep_bind_thread(lcd_irq, l4re_env()->main_thread, 0x10));

  if (err)

  {

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

    return 1;

  }

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

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

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

    return 1;

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

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

  if (get_memory("jz4780-gpio", &gpio_base, &gpio_base_end) < 0)

    return 1;

  printf("GPIO at 0x%lx...0x%lx.\n", gpio_base, gpio_base_end);

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

  if (get_memory("jz4780-hdmi", &hdmi_base, &hdmi_base_end) < 0)

    return 1;

  printf("HDMI at 0x%lx...0x%lx.\n", hdmi_base, hdmi_base_end);

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

  if (get_memory("jz4780-lcd", &lcd_base, &lcd_base_end) < 0)

    return 1;

  printf("LCD at 0x%lx...0x%lx.\n", lcd_base, lcd_base_end);

  /* Obtain CPM object. */

  cpm = jz4780_cpm_init(cpm_base);

  printf("VPLL frequency: %lld\n", jz4780_cpm_get_frequency(cpm, Clock_pll_V));

  printf("HDMI frequency: %lld\n", jz4780_cpm_get_frequency(cpm, Clock_hdmi));

  jz4780_cpm_stop_clock(cpm, Clock_hdmi);

  jz4780_cpm_set_frequency(cpm, Clock_hdmi, 27000000);

  printf("HDMI frequency: %lld\n", jz4780_cpm_get_frequency(cpm, Clock_hdmi));

  jz4780_cpm_start_clock(cpm, Clock_hdmi);

  /* Configure pins. */

  port_f = gpio_base + 0x500;

  port_f_end = port_f + 0x100;

  printf("PORTF at 0x%lx...0x%lx.\n", port_f, port_f_end);

  gpio_port_f = jz4780_gpio_init(port_f, port_f_end, 32, 0x7fa7f00f, 0x00580ff0);

  printf("Set up GPIO pins...\n");

  jz4780_gpio_config_pad(gpio_port_f, DDCSCL, Function_alt, 0);

  jz4780_gpio_config_pad(gpio_port_f, DDCSDA, Function_alt, 0);

  /* Obtain HDMI reference. */

  printf("Set up HDMI...\n");

  hdmi = jz4780_hdmi_init(hdmi_base, hdmi_base_end, hdmi_irq, &panel);

  printf("Read version...\n");

  jz4780_hdmi_get_version(hdmi, &hdmi_major, &hdmi_minor);

  printf("HDMI version is %x.%03x\n", hdmi_major, hdmi_minor);

  jz4780_hdmi_get_phy_capabilities(hdmi, &phy_def);

  printf("PHY type: %s\n", phy_def->name);

  printf("Connected: %s\n", jz4780_hdmi_connected(hdmi) ? "yes" : "no");

  while (!jz4780_hdmi_connected(hdmi))

    jz4780_hdmi_wait_for_connection(hdmi);

  printf("Read EDID...\n");

  jz4780_hdmi_i2c_set_address(hdmi, 0x50);

  length = jz4780_hdmi_i2c_read(hdmi, edid, 128);

  if (length)

  {

    for (i = 0; i < length; i++)

      printf("%02x%c", edid[i], ((i % 16) != 15) ? ' ' : '\n');

  }

  show_timings(edid);

  /* Obtain LCD reference. */

  printf("Set up LCD...\n");

  lcd = jz4780_lcd_init(lcd_base, &panel);

  /* Test initialisation with a frequency appropriate for the test panel. */

  printf("LCD source: %d\n", jz4780_cpm_get_source(cpm, Clock_lcd));

  printf("LCD frequency: %lld\n", jz4780_cpm_get_frequency(cpm, Clock_lcd_pixel0));

  printf("Desired frequency: %d\n", jz4740_lcd_get_pixel_clock(lcd));

  jz4780_cpm_stop_clock(cpm, Clock_lcd);

  jz4780_cpm_set_frequency(cpm, Clock_lcd, jz4740_lcd_get_pixel_clock(lcd) * 3);

  jz4780_cpm_set_frequency(cpm, Clock_lcd_pixel0, jz4740_lcd_get_pixel_clock(lcd));

  printf("LCD source: %d\n", jz4780_cpm_get_source(cpm, Clock_lcd));

  printf("LCD frequency: %lld\n", jz4780_cpm_get_frequency(cpm, Clock_lcd_pixel0));

  /* With the LCD pixel clock set up, bring up the HDMI. */

  printf("Enable HDMI output...\n");

  jz4780_hdmi_enable(hdmi, jz4780_cpm_get_frequency(cpm, Clock_lcd_pixel0));

  /* Create the DMA space. */

  err = l4_error(l4_factory_create(l4re_env()->mem_alloc, L4RE_PROTO_DMA_SPACE, dma));

  if (err)

  {

    printf("Could not create DMA space: %s\n", l4sys_errtostr(err));

    return 1;

  }

  l4vbus_device_handle_t device = L4VBUS_NULL;

  l4vbus_resource_t dma_resource;

  if (!find_resource(&device, &dma_resource, L4VBUS_RESOURCE_DMA_DOMAIN))

  {

    printf("Could not find DMA domain.\n");

    return 1;

  }

  err = l4vbus_assign_dma_domain(vbus, dma_resource.start,

                                 L4VBUS_DMAD_BIND | L4VBUS_DMAD_L4RE_DMA_SPACE,

                                 dma);

  if (err)

  {

    printf("Could not assign DMA space: %s\n", l4sys_errtostr(err));

    return 1;

  }

  /* Allocate descriptors and framebuffer at 2**8 == 256 byte == 64 word alignment. */

  desc_size = jz4740_lcd_get_descriptors_size(lcd);

  fb_size = jz4740_lcd_get_screen_size(lcd);

  err = l4re_ma_alloc_align(desc_size, desc_mem, L4RE_MA_CONTINUOUS | L4RE_MA_PINNED, 8) ||

        l4re_ma_alloc_align(fb_size, fb_mem, L4RE_MA_CONTINUOUS | L4RE_MA_PINNED, 8);

  if (err)

  {

    printf("Could not allocate memory: %s\n", l4sys_errtostr(err));

    return 1;

  }

  err = l4re_rm_attach((void **) &desc_addr, desc_size,

                       L4RE_RM_F_SEARCH_ADDR | L4RE_RM_F_EAGER_MAP | L4RE_RM_F_RW,

                       desc_mem, 0, L4_PAGESHIFT) ||

        l4re_rm_attach((void **) &fb_addr, fb_size,

                       L4RE_RM_F_SEARCH_ADDR | L4RE_RM_F_EAGER_MAP | L4RE_RM_F_RW,

                       fb_mem, 0, L4_PAGESHIFT);

  if (err)

  {

    printf("Could not map memory: %s\n", l4sys_errtostr(err));

    return 1;

  }

  err = l4re_dma_space_map(dma, desc_mem | L4_CAP_FPAGE_RW, 0, &desc_psize, 0,

                           L4RE_DMA_SPACE_TO_DEVICE, &desc_paddr) ||

        l4re_dma_space_map(dma, fb_mem | L4_CAP_FPAGE_RW, 0, &fb_psize, 0,

                           L4RE_DMA_SPACE_TO_DEVICE, &fb_paddr);

  if (err)

  {

    printf("Could not get physical addresses for memory: %s\n", l4sys_errtostr(err));

    return 1;

  }

  printf("Descriptors at %lx/%llx, size %d/%d.\n", desc_addr, desc_paddr, desc_size, desc_psize);

  printf("Framebuffer at %lx/%llx, size %d/%d.\n", fb_addr, fb_paddr, fb_size, fb_psize);

  //memset((void *) fb_addr, 0x7f, fb_size);

  picture = (unsigned char *) malloc(gimp_image.width * gimp_image.height * gimp_image.bytes_per_pixel);

  GIMP_IMAGE_RUN_LENGTH_DECODE(picture,

                               gimp_image.rle_pixel_data,

                               gimp_image.width * gimp_image.height,

                               gimp_image.bytes_per_pixel);

  fb_picture_row = (unsigned char *) fb_addr;

  for (y = 0; y < gimp_image.height; y++)

  {

    fb_picture = fb_picture_row;

    for (x = 0; x < gimp_image.width; x++)

    {

      *(fb_picture + 2) = *picture++;

      *(fb_picture + 1) = *picture++;

      *fb_picture = *picture++;

      *(fb_picture + 3) = 0;

      fb_picture += 4;

    }

    fb_picture_row += jz4740_lcd_get_line_size(lcd);

  }

  l4_cache_clean_data((unsigned long) fb_addr, (unsigned long) fb_addr + fb_size);

  printf("Start LCD clock and initialise LCD...\n");

  jz4780_cpm_start_clock(cpm, Clock_lcd);

  l4_sleep(1); // 1ms == 1000us

  jz4740_lcd_disable(lcd);

  jz4740_lcd_set_irq(lcd, lcd_irq, Lcd_irq_frame_end);

  jz4740_lcd_config(lcd, (struct Jz4740_lcd_descriptor *) desc_addr,

                         (struct Jz4740_lcd_descriptor *) (l4_addr_t) desc_paddr,

                         fb_paddr);

  jz4740_lcd_enable(lcd);

  printf("LCD enabled: %s\n", jz4740_lcd_enabled(lcd) ? "yes" : "no");

  printf("Wait for interrupt conditions...\n");

  for (i = 0; i < 30000; i++)

  {

    if (jz4740_lcd_wait_for_irq(lcd))

      continue;

    if (!(i % 60))

      printf("IRQ #%d\n", i);

  }

  /* Detach from the interrupts. */

  err = l4_error(l4_irq_detach(hdmi_irq)) ||

        l4_error(l4_irq_detach(lcd_irq));

  if (err)

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

  printf("Done.\n");

  return 0;

}