From f6061fe574166b7d23b208f047e8789081877c57 Mon Sep 17 00:00:00 2001 From: jaseg Date: Thu, 27 Feb 2020 16:02:41 +0100 Subject: Add missing files --- controller/fw/src/ldpc_wrapper.cpp | 84 ++++++++++++++ controller/fw/src/main.c | 76 ++++++++++++ controller/fw/src/mspdebug_wrapper.c | 213 ++++++++++++++++++++++++++++++++++ controller/fw/src/mspdebug_wrapper.h | 6 + controller/fw/src/signal_processing.c | 0 controller/fw/src/spi_flash.c | 189 ++++++++++++++++++++++++++++++ controller/fw/src/spi_flash.h | 31 +++++ controller/fw/src/sr_global.h | 8 ++ controller/fw/src/tinyaes_adaptor.c | 13 +++ 9 files changed, 620 insertions(+) create mode 100644 controller/fw/src/ldpc_wrapper.cpp create mode 100644 controller/fw/src/main.c create mode 100644 controller/fw/src/mspdebug_wrapper.c create mode 100644 controller/fw/src/mspdebug_wrapper.h create mode 100644 controller/fw/src/signal_processing.c create mode 100644 controller/fw/src/spi_flash.c create mode 100644 controller/fw/src/spi_flash.h create mode 100644 controller/fw/src/sr_global.h create mode 100644 controller/fw/src/tinyaes_adaptor.c diff --git a/controller/fw/src/ldpc_wrapper.cpp b/controller/fw/src/ldpc_wrapper.cpp new file mode 100644 index 0000000..da63343 --- /dev/null +++ b/controller/fw/src/ldpc_wrapper.cpp @@ -0,0 +1,84 @@ + +#include +#include +#include +#include + +#include "ldpc/generic.hh" +#include "ldpc/layered_decoder.hh" + +static const int DEFAULT_TRIALS = 25; + +struct DVB_S2_TABLE_C9 +{ + static const int M = 360; + static const int N = 16200; + static const int K = 13320; + static const int LINKS_MIN_CN = 15; + static const int LINKS_MAX_CN = 19; + static const int LINKS_TOTAL = 49319; + static const int DEG_MAX = 13; + static const int DEG[]; + static const int LEN[]; + static const int POS[]; +}; + +const int DVB_S2_TABLE_C9::DEG[] = { + 13, 3, 0 +}; + +const int DVB_S2_TABLE_C9::LEN[] = { + 1, 36, 0 +}; + +const int DVB_S2_TABLE_C9::POS[] = { + 3, 2409, 499, 1481, 908, 559, 716, 1270, 333, 2508, 2264, 1702, 2805, + 4, 2447, 1926, + 5, 414, 1224, + 6, 2114, 842, + 7, 212, 573, + 0, 2383, 2112, + 1, 2286, 2348, + 2, 545, 819, + 3, 1264, 143, + 4, 1701, 2258, + 5, 964, 166, + 6, 114, 2413, + 7, 2243, 81, + 0, 1245, 1581, + 1, 775, 169, + 2, 1696, 1104, + 3, 1914, 2831, + 4, 532, 1450, + 5, 91, 974, + 6, 497, 2228, + 7, 2326, 1579, + 0, 2482, 256, + 1, 1117, 1261, + 2, 1257, 1658, + 3, 1478, 1225, + 4, 2511, 980, + 5, 2320, 2675, + 6, 435, 1278, + 7, 228, 503, + 0, 1885, 2369, + 1, 57, 483, + 2, 838, 1050, + 3, 1231, 1990, + 4, 1738, 68, + 5, 2392, 951, + 6, 163, 645, + 7, 2644, 1704, +}; + +extern "C" { + + int ldpc_decode(float *symbols, int trials) { + if (trials < 0) + trials = DEFAULT_TRIALS; + + LDPCDecoder>, LDPC> decoder; + return decoder.run(symbols, symbols+decoder.K, trials, 1); + } + +} diff --git a/controller/fw/src/main.c b/controller/fw/src/main.c new file mode 100644 index 0000000..3131df1 --- /dev/null +++ b/controller/fw/src/main.c @@ -0,0 +1,76 @@ + +#include + +#include +#include +#include + +#include "spi_flash.h" + +static struct spi_flash_if spif; + +static void clock_setup(void) +{ + rcc_clock_setup_pll(&rcc_hse_8mhz_3v3[RCC_CLOCK_3V3_168MHZ]); + rcc_periph_clock_enable(RCC_GPIOA); + rcc_periph_clock_enable(RCC_GPIOB); + rcc_periph_clock_enable(RCC_SPI1); +} + +static void led_setup(void) +{ + gpio_mode_setup(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO6 | GPIO7); +} + +static void spi_flash_if_set_cs(bool val) { + if (val) + gpio_set(GPIOB, GPIO0); + else + gpio_clear(GPIOB, GPIO0); +} + +static void spi_flash_setup(void) +{ + gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO3 | GPIO4 | GPIO5); /* SPI flash SCK/MISO/MOSI */ + gpio_mode_setup(GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO0); /* SPI flash CS */ + gpio_set_output_options(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO0 | GPIO3 | GPIO4 | GPIO5); + gpio_set_af(GPIOB, 5, GPIO3 | GPIO4 | GPIO5); + + spif_init(&spif, 256, SPI1, &spi_flash_if_set_cs); +} + +/* +void spi_flash_test(void) { + spif_clear_mem(&spif); + + uint32_t buf[1024]; + for (size_t addr=0; addr<0x10000; addr += sizeof(buf)) { + for (size_t i=0; i +#include + +#include + +#include "output.h" +#include "jtaglib.h" + +#include "sr_global.h" +#include "mspdebug_wrapper.h" + +#define BLOCK_SIZE 512 /* bytes */ + + +static struct jtdev sr_jtdev; + + +int flash_and_reset(size_t img_start, size_t img_len, ssize_t (*read_block)(int addr, size_t len, uint8_t *out)) +{ + union { + uint8_t bytes[BLOCK_SIZE]; + uint16_t words[BLOCK_SIZE/2]; + } block; + + /* Initialize JTAG connection */ + unsigned int jtag_id = jtag_init(&sr_jtdev); + + if (sr_jtdev.failed) + return -EPIPE; + + if (jtag_id != 0x89 && jtag_id != 0x91) + return -EINVAL; + + /* Clear flash */ + jtag_erase_flash(&sr_jtdev, JTAG_ERASE_MAIN, 0); + if (sr_jtdev.failed) + return -EPIPE; + + /* Write flash */ + for (size_t p = img_start; p < img_start + img_len; p += BLOCK_SIZE) { + ssize_t nin = read_block(p, BLOCK_SIZE, block.bytes); + + if (nin < 0) + return nin; + + if (nin & 1) { /* pad unaligned */ + block.bytes[nin] = 0; + nin ++; + } + + /* Convert to little-endian */ + for (ssize_t i=0; i + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "spi_flash.h" +#include + +enum { + WRITE_ENABLE = 0x06, + WRITE_DISABLE = 0x04, + READ_IDENTIFICATION = 0x9F, + READ_STATUS = 0x05, + WRITE_STATUS = 0x01, + READ_DATA = 0x03, + READ_DATA_FAST = 0x0B, + PAGE_PROGRAM = 0x02, + SECTOR_ERASE = 0xD8, + BULK_ERASE = 0xC7, + DEEP_POWER_DOWN = 0xB9, + DEEP_POWER_DOWN_RELEASE = 0xAB, +}; + +enum { + STATUS_SRWD = 0x80, // 0b 1000 0000 + STATUS_BP2 = 0x10, // 0b 0001 0000 + STATUS_BP1 = 0x08, // 0b 0000 1000 + STATUS_BP0 = 0x04, // 0b 0000 0100 + STATUS_WEL = 0x02, // 0b 0000 0010 + STATUS_WIP = 0x01, // 0b 0000 0001 +}; + + +static void spif_write_page(struct spi_flash_if *spif, size_t addr, size_t len, const char* data); +static uint8_t spif_read_status(struct spi_flash_if *spif); +static void spif_enable_write(struct spi_flash_if *spif); +static void spif_wait_for_write(struct spi_flash_if *spif); + +#define low_byte(x) (x&0xff) +#define mid_byte(x) ((x>>8)&0xff) +#define high_byte(x) ((x>>16)&0xff) + + +void spif_init(struct spi_flash_if *spif, size_t page_size, uint32_t spi_base, void (*cs)(bool val)) { + + spif->spi_base = spi_base; + spif->page_size = page_size; + spif->cs = cs; + spif->cs(1); + + spi_reset(spif->spi_base); + spi_init_master(spif->spi_base, + SPI_CR1_BAUDRATE_FPCLK_DIV_2, + SPI_CR1_CPOL_CLK_TO_1_WHEN_IDLE, + SPI_CR1_CPHA_CLK_TRANSITION_2, + SPI_CR1_DFF_8BIT, + SPI_CR1_MSBFIRST); + + spi_enable_software_slave_management(spif->spi_base); + spi_set_nss_high(spif->spi_base); + + spi_enable(spif->spi_base); + + spif->cs(0); + spi_send(spif->spi_base, READ_IDENTIFICATION); + spif->id.mfg_id = spi_xfer(spif->spi_base, 0); + spif->id.type = spi_xfer(spif->spi_base, 0); + spif->id.size = 1<spi_base, 0); + spif->cs(1); +} + +void spif_read(struct spi_flash_if *spif, size_t addr, size_t len, char* data) { + spif_enable_write(spif); + + spif->cs(0); + spi_xfer(spif->spi_base, READ_DATA); + spi_xfer(spif->spi_base, high_byte(addr)); + spi_xfer(spif->spi_base, mid_byte(addr)); + spi_xfer(spif->spi_base, low_byte(addr)); + + for (size_t i = 0; i < len; i++) + data[i] = spi_xfer(spif->spi_base, 0); + + spif->cs(1); +} + +void spif_write(struct spi_flash_if *spif, size_t addr, size_t len, const char* data) { + size_t written = 0, write_size = 0; + + while (written < len) { + write_size = spif->page_size - ((addr + written) % spif->page_size); + if (written + write_size > len) + write_size = len - written; + + spif_write_page(spif, addr + written, write_size, data + written); + written += write_size; + } +} + +static uint8_t spif_read_status(struct spi_flash_if *spif) { + spif->cs(0); + spi_xfer(spif->spi_base, READ_STATUS); + uint8_t status = spi_xfer(spif->spi_base, 0); + spif->cs(1); + + return status; +} + +void spif_clear_sector(struct spi_flash_if *spif, size_t addr) { + spif_enable_write(spif); + + spif->cs(0); + spi_xfer(spif->spi_base, SECTOR_ERASE); + spi_xfer(spif->spi_base, high_byte(addr)); + spi_xfer(spif->spi_base, mid_byte(addr)); + spi_xfer(spif->spi_base, low_byte(addr)); + spif->cs(1); + + spif_wait_for_write(spif); +} + +void spif_clear_mem(struct spi_flash_if *spif) { + spif_enable_write(spif); + + spif->cs(0); + spi_xfer(spif->spi_base, BULK_ERASE); + spif->cs(1); + + spif_wait_for_write(spif); +} + +static void spif_write_page(struct spi_flash_if *spif, size_t addr, size_t len, const char* data) { + spif_enable_write(spif); + + spif->cs(0); + spi_xfer(spif->spi_base, PAGE_PROGRAM); + spi_xfer(spif->spi_base, high_byte(addr)); + spi_xfer(spif->spi_base, mid_byte(addr)); + spi_xfer(spif->spi_base, low_byte(addr)); + + for (size_t i = 0; i < len; i++) { + spi_xfer(spif->spi_base, data[i]); + } + + spif->cs(1); + spif_wait_for_write(spif); +} + +static void spif_enable_write(struct spi_flash_if *spif) { + spif->cs(0); + spi_xfer(spif->spi_base, WRITE_ENABLE); + spif->cs(1); +} + +static void spif_wait_for_write(struct spi_flash_if *spif) { + while (spif_read_status(spif) & STATUS_WIP) + for (int i = 0; i < 800; i++) + ; +} + +void spif_deep_power_down(struct spi_flash_if *spif) { + spif->cs(0); + spi_xfer(spif->spi_base, DEEP_POWER_DOWN); + spif->cs(1); +} + +void spif_wakeup(struct spi_flash_if *spif) { + spif->cs(0); + spi_xfer(spif->spi_base, DEEP_POWER_DOWN_RELEASE); + spif->cs(1); +} diff --git a/controller/fw/src/spi_flash.h b/controller/fw/src/spi_flash.h new file mode 100644 index 0000000..e647c6a --- /dev/null +++ b/controller/fw/src/spi_flash.h @@ -0,0 +1,31 @@ +#ifndef __SPI_FLASH_H__ +#define __SPI_FLASH_H__ + +#include +#include + +struct spi_mem_id { + size_t size; + uint8_t mfg_id; + uint8_t type; +}; + +struct spi_flash_if { + struct spi_mem_id id; + uint32_t spi_base; + size_t page_size; + void (*cs)(bool val); +}; + +void spif_init(struct spi_flash_if *spif, size_t page_size, uint32_t spi_base, void (*cs)(bool val)); + +void spif_write(struct spi_flash_if *spif, size_t addr, size_t len, const char* data); +void spif_read(struct spi_flash_if *spif, size_t addr, size_t len, char* data); + +void spif_clear_mem(struct spi_flash_if *spif); +void spif_clear_sector(struct spi_flash_if *spif, size_t addr); + +void spif_deep_power_down(struct spi_flash_if *spif); +void spif_wakeup(struct spi_flash_if *spif); + +#endif /* __SPI_FLASH_H__ */ diff --git a/controller/fw/src/sr_global.h b/controller/fw/src/sr_global.h new file mode 100644 index 0000000..8aa219d --- /dev/null +++ b/controller/fw/src/sr_global.h @@ -0,0 +1,8 @@ +#ifndef __SR_GLOBAL_H__ +#define __SR_GLOBAL_H__ + +#define UNUSED(x) ((void) x) + +static inline uint16_t htole(uint16_t val) { return val; } + +#endif /* __SR_GLOBAL_H__ */ diff --git a/controller/fw/src/tinyaes_adaptor.c b/controller/fw/src/tinyaes_adaptor.c new file mode 100644 index 0000000..2489e68 --- /dev/null +++ b/controller/fw/src/tinyaes_adaptor.c @@ -0,0 +1,13 @@ + +#include +#include + +void *memcpy(void *restrict dest, const void *restrict src, size_t n) { + unsigned char *d = dest; + const unsigned char *s = src; + + while (n--) + *d++ = *s++; + + return dest; +} -- cgit