/*

 * Access various peripherals on a board using the X1600.

 *

 * Copyright (C) 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/aic-x1600.h>

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

#include <l4/devices/dma-x1600.h>

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

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

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

// #include <l4/devices/spi-hybrid.h>

#include "common.h"

/* AIC adapter functions. */

void *aic_init(l4_addr_t aic_start, l4_addr_t start, l4_addr_t end, void *cpm)

{

  return x1600_aic_init(aic_start, start, end, cpm);

}

void *aic_get_channel(void *aic, int num, void *channel)

{

  return x1600_aic_get_channel(aic, num, channel);

}

unsigned int aic_transfer(void *channel, l4re_dma_space_dma_addr_t paddr,

                          uint32_t count, uint32_t sample_rate,

                          uint8_t sample_size)

{

  return x1600_aic_transfer(channel, paddr, count, sample_rate, sample_size);

}

/* CPM adapter functions. */

void *cpm_init(l4_addr_t cpm_base)

{

  return x1600_cpm_init(cpm_base);

}

const char *cpm_clock_type(void *cpm, enum Clock_identifiers clock)

{

  return x1600_cpm_clock_type(cpm, clock);

}

int cpm_have_clock(void *cpm, enum Clock_identifiers clock)

{

  return x1600_cpm_have_clock(cpm, clock);

}

void cpm_start_clock(void *cpm, enum Clock_identifiers clock)

{

  x1600_cpm_start_clock(cpm, clock);

}

void cpm_stop_clock(void *cpm, enum Clock_identifiers clock)

{

  x1600_cpm_stop_clock(cpm, clock);

}

int cpm_get_parameters(void *cpm, enum Clock_identifiers clock,

                       uint32_t parameters[])

{

  return x1600_cpm_get_parameters(cpm, clock, parameters);

}

int cpm_set_parameters(void *cpm, enum Clock_identifiers clock,

                       int num_parameters, uint32_t parameters[])

{

  return x1600_cpm_set_parameters(cpm, clock, num_parameters, parameters);

}

uint8_t cpm_get_source(void *cpm, enum Clock_identifiers clock)

{

  return x1600_cpm_get_source(cpm, clock);

}

void cpm_set_source(void *cpm, enum Clock_identifiers clock, uint8_t source)

{

  x1600_cpm_set_source(cpm, clock, source);

}

enum Clock_identifiers cpm_get_source_clock(void *cpm, enum Clock_identifiers clock)

{

  return x1600_cpm_get_source_clock(cpm, clock);

}

void cpm_set_source_clock(void *cpm, enum Clock_identifiers clock, enum Clock_identifiers source)

{

  x1600_cpm_set_source_clock(cpm, clock, source);

}

uint64_t cpm_get_source_frequency(void *cpm, enum Clock_identifiers clock)

{

  return x1600_cpm_get_source_frequency(cpm, clock);

}

uint64_t cpm_get_frequency(void *cpm, enum Clock_identifiers clock)

{

  return x1600_cpm_get_frequency(cpm, clock);

}

int cpm_set_frequency(void *cpm, enum Clock_identifiers clock, uint64_t frequency)

{

  return x1600_cpm_set_frequency(cpm, clock, frequency);

}

/* DMA adapter functions. */

void *dma_init(l4_addr_t start, l4_addr_t end, void *cpm)

{

  return x1600_dma_init(start, end, cpm);

}

void dma_disable(void *dma_chip)

{

  x1600_dma_disable(dma_chip);

}

void dma_enable(void *dma_chip)

{

  x1600_dma_enable(dma_chip);

}

void *dma_get_channel(void *dma, uint8_t channel, l4_cap_idx_t irq)

{

  return x1600_dma_get_channel(dma, channel, irq);

}

unsigned int dma_transfer(void *dma_channel,

                          uint32_t source, uint32_t destination,

                          unsigned int count,

                          int source_increment, int destination_increment,

                          uint8_t source_width, uint8_t destination_width,

                          uint8_t transfer_unit_size,

                          int type)

{

  return x1600_dma_transfer(dma_channel, source, destination, count,

                            source_increment, destination_increment,

                            source_width, destination_width,

                            transfer_unit_size, type);

}

unsigned int dma_wait(void *dma_channel)

{

  return x1600_dma_wait(dma_channel);

}

/* GPIO adapter functions. */

void *gpio_init(l4_addr_t start, l4_addr_t end, unsigned pins,

                l4_uint32_t pull_ups, l4_uint32_t pull_downs)

{

  return x1600_gpio_init(start, end, pins, pull_ups, pull_downs);

}

void gpio_setup(void *gpio, unsigned pin, unsigned mode, int value)

{

  x1600_gpio_setup(gpio, pin, mode, value);

}

void gpio_config_pull(void *gpio, unsigned pin, unsigned mode)

{

  x1600_gpio_config_pull(gpio, pin, mode);

}

void gpio_config_pad(void *gpio, unsigned pin, unsigned func, unsigned value)

{

  x1600_gpio_config_pad(gpio, pin, func, value);

}

void gpio_config_get(void *gpio, unsigned pin, unsigned reg, unsigned *value)

{

  x1600_gpio_config_get(gpio, pin, reg, value);

}

void gpio_config_pad_get(void *gpio, unsigned pin, unsigned *func, unsigned *value)

{

  x1600_gpio_config_pad_get(gpio, pin, func, value);

}

void gpio_multi_setup(void *gpio, Pin_slice const *mask, unsigned mode, unsigned outvalues)

{

  x1600_gpio_multi_setup(gpio, mask, mode, outvalues);

}

void gpio_multi_config_pad(void *gpio, Pin_slice const *mask, unsigned func, unsigned value)

{

  x1600_gpio_multi_config_pad(gpio, mask, func, value);

}

void gpio_multi_set(void *gpio, Pin_slice const *mask, unsigned data)

{

  x1600_gpio_multi_set(gpio, mask, data);

}

unsigned gpio_multi_get(void *gpio, unsigned offset)

{

  return x1600_gpio_multi_get(gpio, offset);

}

int gpio_get(void *gpio, unsigned pin)

{

  return x1600_gpio_get(gpio, pin);

}

void gpio_set(void *gpio, unsigned pin, int value)

{

  x1600_gpio_set(gpio, pin, value);

}

void *gpio_get_irq(void *gpio, unsigned pin)

{

  return x1600_gpio_get_irq(gpio, pin);

}

bool gpio_irq_set_mode(void *gpio_irq, unsigned mode)

{

  return x1600_gpio_irq_set_mode(gpio_irq, mode);

}

/* I2C adapter functions. */

void *i2c_init(l4_addr_t start, l4_addr_t end, void *cpm,

                uint32_t frequency)

{

  return x1600_i2c_init(start, end, cpm, frequency);

}

void *i2c_get_channel(void *i2c, uint8_t channel)

{

  return x1600_i2c_get_channel(i2c, channel);

}

uint32_t i2c_get_frequency(void *i2c_channel)

{

  return x1600_i2c_get_frequency(i2c_channel);

}

void i2c_set_target(void *i2c_channel, uint8_t addr)

{

  return x1600_i2c_set_target(i2c_channel, addr);

}

void i2c_start_read(void *i2c_channel, uint8_t buf[], unsigned int total,

                    int stop)

{

  x1600_i2c_start_read(i2c_channel, buf, total, stop);

}

void i2c_read(void *i2c_channel)

{

  x1600_i2c_read(i2c_channel);

}

void i2c_start_write(void *i2c_channel, uint8_t buf[], unsigned int total,

                     int stop)

{

  x1600_i2c_start_write(i2c_channel, buf, total, stop);

}

void i2c_write(void *i2c_channel)

{

  x1600_i2c_write(i2c_channel);

}

int i2c_read_done(void *i2c_channel)

{

  return x1600_i2c_read_done(i2c_channel);

}

int i2c_write_done(void *i2c_channel)

{

  return x1600_i2c_write_done(i2c_channel);

}

unsigned int i2c_have_read(void *i2c_channel)

{

  return x1600_i2c_have_read(i2c_channel);

}

unsigned int i2c_have_written(void *i2c_channel)

{

  return x1600_i2c_have_written(i2c_channel);

}

int i2c_failed(void *i2c_channel)

{

  return x1600_i2c_failed(i2c_channel);

}

void i2c_stop(void *i2c_channel)

{

  x1600_i2c_stop(i2c_channel);

}

/* SPI adapter functions. */

void *spi_init(l4_addr_t spi_start, l4_addr_t start, l4_addr_t end, void *cpm)

{

  (void) spi_start; (void) start; (void) end; (void) cpm;

  return NULL;

}

void *spi_get_channel(void *spi, uint8_t num, void *channel, uint64_t frequency,

                      void *control_chip, int control_pin, int control_alt_func)

{

  /* NOTE: Initialisation of a hybrid channel to be supported. */

  (void) spi; (void) num; (void) channel; (void) frequency;

  (void) control_chip; (void) control_pin; (void) control_alt_func;

  return NULL;

}

void *spi_get_channel_gpio(uint64_t frequency,

                           void *clock_chip, int clock_pin,

                           void *data_chip, int data_pin,

                           void *enable_chip, int enable_pin,

                           void *control_chip, int control_pin)

{

  return spi_gpio_get_channel(frequency, clock_chip, clock_pin, data_chip,

                              data_pin, enable_chip, enable_pin, control_chip,

                              control_pin);

}

void spi_acquire_control(void *channel, int level)

{

  /* NOTE: Not yet supported. */

  (void) channel; (void) level;

  // spi_hybrid_acquire_control(channel, level);

}

void spi_release_control(void *channel)

{

  /* NOTE: Not yet supported. */

  (void) channel;

  // spi_hybrid_release_control(channel);

}

void spi_send_gpio(void *channel, uint32_t bytes, const uint8_t data[])

{

  spi_gpio_send(channel, bytes, data);

}

void spi_send_units(void *channel, uint32_t bytes, const uint8_t data[], uint8_t unit_size,

                    uint8_t char_size)

{

  /* NOTE: Not yet supported. */

  (void) channel; (void) bytes; (void) data; (void) unit_size; (void) char_size;

  // x1600_spi_send_units(channel, bytes, data, unit_size, char_size);

}

uint32_t spi_transfer(void *channel, l4re_dma_space_dma_addr_t paddr,

                      uint32_t count, uint8_t unit_size, uint8_t char_size,

                      l4_addr_t desc_vaddr, l4re_dma_space_dma_addr_t desc_paddr)

{

  /* NOTE: Not yet supported. */

  (void) channel; (void) paddr; (void) count; (void) unit_size; (void) char_size;

  (void) desc_vaddr; (void) desc_paddr;

  // return x1600_spi_transfer(channel, paddr, count, unit_size, char_size,

  //                           desc_vaddr, desc_paddr);

  return 0;

}

/* Memory regions. */

const char *memory_regions[] = {

  [AIC] = "x1600-aic",

  [CPM] = "x1600-cpm",

  [DMA] = "x1600-dma",

  [GPIO] = "x1600-gpio",

  [I2C] = "x1600-i2c",

  [SSI] = "x1600-ssi",

};

/* AIC definitions. */

void *aic_channels[] = {NULL};

const unsigned int num_aic_channels = 1;

l4_cap_idx_t aic_irqs[] = {L4_INVALID_CAP};

/* CPM definitions. */

struct clock_info clocks[] = {

  {"ext",   Clock_external, "External"},

  {"plla",  Clock_pll_A, "PLL A"},

  {"plle",  Clock_pll_E, "PLL E"},

  {"pllm",  Clock_pll_M, "PLL M"},

  {"main",  Clock_main, "Main"},

  {"cpu",   Clock_cpu, "CPU"},

  {"ahb0",  Clock_hclock0, "AHB0"},

  {"ahb2",  Clock_hclock2, "AHB2"},

  {"apb",   Clock_pclock, "APB"},

  {"aic",   Clock_aic, "AIC"},

  {"dma",   Clock_dma, "DMA"},

  {"lcd0",  Clock_lcd_pixel0, "LCD pixel"},

  {"msc0",  Clock_msc0, "MSC0"},

  {"msc1",  Clock_msc1, "MSC1"},

  {"otg",   Clock_otg0, "USB OTG"},

  {"i2c0",  Clock_i2c0, "I2C0"},

  {"i2c1",  Clock_i2c1, "I2C1"},

  {"i2s0",  Clock_i2s0, "I2S0"},

  {"i2s1",  Clock_i2s1, "I2S1"},

  {"i2s0r", Clock_i2s0_rx, "I2S0 RX"},

  {"i2s0t", Clock_i2s0_tx, "I2S0 TX"},

  {"ssi0",  Clock_ssi0, "SSI"},

  {"uart0", Clock_uart0, "UART0"},

  {"uart1", Clock_uart1, "UART1"},

  {"uart2", Clock_uart2, "UART2"},

  {"uart3", Clock_uart3, "UART3"},

  {NULL,    Clock_undefined, NULL},

};

/* DMA definitions. */

void *dma_channels[32] = {NULL};

const unsigned int num_dma_channels = 32;

struct dma_region dma_regions[8];

const unsigned int num_dma_regions = 8;

l4_cap_idx_t dma_irq = L4_INVALID_CAP;

/* GPIO definitions. */

struct gpio_port gpio_ports[] = {

  {0xffffffff, 0x00000000},

  {0xdffbf7bf, 0x00000000},

  {0x987e0000, 0x07000007},

  {0x0000003f, 0x00000000}

};

const unsigned int num_gpio_ports = 4;

const char gpio_port_labels[] = "ABCD";

/* I2C definitions. */

void *i2c_channels[] = {NULL, NULL};

const unsigned int num_i2c_channels = 2;

l4_cap_idx_t i2c_irqs[] = {L4_INVALID_CAP, L4_INVALID_CAP};

/* SPI definitions. */

void *spi_channels[] = {NULL};

const unsigned int num_spi_channels = 1;