/*

 * Access various peripherals on a board.

 *

 * 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

 */

#pragma once

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

#include <l4/sys/types.h>

#include <l4/devices/clocks.h>

#include <l4/devices/gpio.h>

#include <stdint.h>

/* AIC adapter functions. */

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

void *aic_get_channel(void *aic, int num, void *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);

/* CPM adapter functions. */

void *cpm_init(l4_addr_t cpm_base);

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

int cpm_have_clock(void *cpm, enum Clock_identifiers clock);

void cpm_start_clock(void *cpm, enum Clock_identifiers clock);

void cpm_stop_clock(void *cpm, enum Clock_identifiers clock);

int cpm_get_parameters(void *cpm, enum Clock_identifiers clock,

                       uint32_t parameters[]);

int cpm_set_parameters(void *cpm, enum Clock_identifiers clock,

                       int num_parameters, uint32_t parameters[]);

uint8_t cpm_get_source(void *cpm, enum Clock_identifiers clock);

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

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

void cpm_set_source_clock(void *cpm, enum Clock_identifiers clock,

                          enum Clock_identifiers source);

uint64_t cpm_get_source_frequency(void *cpm, enum Clock_identifiers clock);

uint64_t cpm_get_frequency(void *cpm, enum Clock_identifiers clock);

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

/* DMA adapter functions. */

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

void dma_disable(void *dma_chip);

void dma_enable(void *dma_chip);

void *dma_get_channel(void *dma, uint8_t channel, l4_cap_idx_t 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);

unsigned int dma_wait(void *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);

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

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

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

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

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

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

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

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

unsigned gpio_multi_get(void *gpio, unsigned offset);

int gpio_get(void *gpio, unsigned pin);

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

void *gpio_get_irq(void *gpio, unsigned pin);

bool gpio_irq_set_mode(void *gpio_irq, unsigned mode);

/* I2C adapter functions. */

void *i2c_init(l4_addr_t start, l4_addr_t end, void *cpm, uint32_t frequency);

void *i2c_get_channel(void *i2c, uint8_t channel);

uint32_t i2c_get_frequency(void *i2c_channel);

void i2c_set_target(void *i2c_channel, uint8_t addr);

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

                    int stop);

void i2c_read(void *i2c_channel);

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

                     int stop);

void i2c_write(void *i2c_channel);

int i2c_read_done(void *i2c_channel);

int i2c_write_done(void *i2c_channel);

unsigned int i2c_have_read(void *i2c_channel);

unsigned int i2c_have_written(void *i2c_channel);

int i2c_failed(void *i2c_channel);

void i2c_stop(void *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_get_channel(void *spi, uint8_t num, void *channel, uint64_t frequency,

                      void *control_chip, int control_pin, int control_alt_func);

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);

void spi_acquire_control(void *channel, int level);

void spi_release_control(void *channel);

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

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

                    uint8_t unit_size, uint8_t 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);

/* Memory regions. */

enum memory_regions

{

  AIC, CPM, DMA, GPIO, I2C, SSI

};

/* CPM definitions. */

struct clock_info

{

  const char *id;

  enum Clock_identifiers clock;

  const char *name;

};

/* DMA definitions. */

struct dma_region

{

  unsigned int size;

  unsigned int align;

  l4_addr_t vaddr;

  l4re_dma_space_dma_addr_t paddr;

  l4_cap_idx_t mem;

};

/* GPIO definitions. */

struct gpio_port

{

  const uint32_t pull_ups, pull_downs;

};