fw: Import tkey-libs fw-2

This is an import of the fw-2 tag of tkey-libs.

We import the entire tkey-libs repo minus dot files into the
tillitis-key1 repo to make it very simple not to make mistakes
regarding which firmware tag depends on which tkey-libs tag,
especially considering locking down with NVCM.

Please see README for information about developing with another
tkey-libs or how to import future tkey-libs.

Since tkey-libs is now a part of the repo we also add tkey-libs to the
clean_fw target.

hw/application_fpga/tkey-libs/include/tkey/assert.h

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2022 Tillitis AB <tillitis.se>
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef TKEY_ASSERT_H
+#define TKEY_ASSERT_H
+
+#include <tkey/io.h>
+
+#if defined(QEMU_DEBUG)
+#define assert(expr)                                                           \
+	((expr) ? (void)(0)                                                    \
+		: assert_fail(IO_QEMU, #expr, __FILE__, __LINE__, __func__))
+
+#elif defined(TKEY_DEBUG)
+
+#define assert(expr)                                                           \
+	((expr)                                                                \
+	     ? (void)(0)                                                       \
+	     : assert_fail(IO_TKEYCTRL, #expr, __FILE__, __LINE__, __func__))
+
+#else
+
+#define assert(expr) ((expr) ? (void)(0) : assert_halt())
+#endif
+
+void assert_fail(enum ioend dest, const char *assertion, const char *file,
+		 unsigned int line, const char *function);
+void assert_halt(void);
+#endif

hw/application_fpga/tkey-libs/include/tkey/blake2s.h

@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: 2023 Tillitis AB <tillitis.se>
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef TKEY_BLAKE2S_H
+#define TKEY_BLAKE2S_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+// blake2s state context
+typedef struct {
+	uint8_t b[64]; // input buffer
+	uint32_t h[8]; // chained state
+	uint32_t t[2]; // total number of bytes
+	size_t c;      // pointer for b[]
+	size_t outlen; // digest size
+} blake2s_ctx;
+
+int blake2s(void *out, unsigned long outlen, const void *key,
+	    unsigned long keylen, const void *in, unsigned long inlen,
+	    blake2s_ctx *ctx);
+#endif

hw/application_fpga/tkey-libs/include/tkey/debug.h

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: 2023 Tillitis AB <tillitis.se>
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef TKEY_DEBUG_H
+#define TKEY_DEBUG_H
+
+#include <stdint.h>
+
+#include "io.h"
+
+#if defined(QEMU_DEBUG)
+#define debug_putchar(ch) putchar(IO_QEMU, ch)
+#define debug_lf() putchar(IO_QEMU, '\n')
+#define debug_putinthex(ch) putinthex(IO_QEMU, ch)
+#define debug_puts(s) puts(IO_QEMU, s)
+#define debug_puthex(ch) puthex(IO_QEMU, ch)
+#define debug_hexdump(buf, len) hexdump(IO_QEMU, buf, len)
+
+#elif defined(TKEY_DEBUG)
+
+#define debug_putchar(ch) putchar(IO_TKEYCTRL, ch)
+#define debug_lf() putchar(IO_TKEYCTRL, '\n')
+#define debug_putinthex(ch) putinthex(IO_TKEYCTRL, ch)
+#define debug_puts(s) puts(IO_TKEYCTRL, s)
+#define debug_puthex(ch) puthex(IO_TKEYCTRL, ch)
+#define debug_hexdump(buf, len) hexdump(IO_TKEYCTRL, buf, len)
+
+#else
+
+#define debug_putchar(ch)
+#define debug_lf()
+#define debug_putinthex(n)
+#define debug_puts(s)
+#define debug_puthex(ch)
+#define debug_hexdump(buf, len)
+
+#endif
+
+#endif

hw/application_fpga/tkey-libs/include/tkey/io.h

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: 2025 Tillitis AB <tillitis.se>
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef TKEY_IO_H
+#define TKEY_IO_H
+
+// I/O endpoints. Keep it as bits possible to use in a bitmask in
+// readselect().
+//
+// Note that the the TKEYCTRL, CDC, and HID should be kept the same on
+// the CH552 side.
+enum ioend {
+	IO_NONE = 0x00,	    // No endpoint
+	IO_UART = 0x01,	    // Only destination, raw UART access
+	IO_QEMU = 0x10,	    // Only destination, QEMU debug port
+	IO_TKEYCTRL = 0x20, // HID debug port
+	IO_CDC = 0x40,	    // CDC "serial port"
+	IO_HID = 0x80,	    // HID security token
+};
+
+void write(enum ioend dest, const uint8_t *buf, size_t nbytes);
+int read(enum ioend src, uint8_t *buf, size_t bufsize, size_t nbytes);
+int uart_read(uint8_t *buf, size_t bufsize, size_t nbytes);
+int readselect(int bitmask, enum ioend *endpoint, uint8_t *len);
+void putchar(enum ioend dest, const uint8_t ch);
+void puthex(enum ioend dest, const uint8_t ch);
+void putinthex(enum ioend dest, const uint32_t n);
+void puts(enum ioend dest, const char *s);
+void hexdump(enum ioend dest, void *buf, int len);
+#endif

hw/application_fpga/tkey-libs/include/tkey/led.h

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: 2022 Tillitis AB <tillitis.se>
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef TKEY_LED_H
+#define TKEY_LED_H
+
+#include <stdint.h>
+#include <tkey/tk1_mem.h>
+
+// clang-format off
+#define LED_BLACK 0
+#define LED_RED   (1 << TK1_MMIO_TK1_LED_R_BIT)
+#define LED_GREEN (1 << TK1_MMIO_TK1_LED_G_BIT)
+#define LED_BLUE  (1 << TK1_MMIO_TK1_LED_B_BIT)
+#define LED_WHITE (LED_RED | LED_GREEN | LED_BLUE)
+// clang-format on
+
+uint32_t led_get(void);
+void led_set(uint32_t ledvalue);
+void led_flash_forever(uint32_t ledvalue);
+#endif

hw/application_fpga/tkey-libs/include/tkey/lib.h

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: 2022 Tillitis AB <tillitis.se>
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef TKEY_LIB_H
+#define TKEY_LIB_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+void *memset(void *dest, int c, unsigned n);
+void *memcpy(void *dest, const void *src, unsigned n);
+void memcpy_s(void *dest, size_t destsize, const void *src, size_t n);
+void *wordcpy(void *dest, const void *src, unsigned n);
+void wordcpy_s(void *dest, size_t destsize, const void *src, size_t n);
+int memeq(void *dest, const void *src, size_t n);
+void secure_wipe(void *v, size_t n);
+size_t strlen(const char *str);
+#endif

hw/application_fpga/tkey-libs/include/tkey/proto.h

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: 2022 Tillitis AB <tillitis.se>
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef TKEY_PROTO_H
+#define TKEY_PROTO_H
+
+enum endpoints {
+	DST_HW_IFPGA = 0x00,
+	DST_HW_AFPGA = 0x01,
+	DST_FW = 0x02,
+	DST_SW = 0x03
+};
+
+enum cmdlen {
+	LEN_1,
+	LEN_4,
+	LEN_32,
+	LEN_128
+};
+
+#define CMDLEN_MAXBYTES 128
+
+enum status {
+	STATUS_OK,
+	STATUS_BAD
+};
+
+struct frame_header {
+	uint8_t id;
+	enum endpoints endpoint;
+	size_t len;
+};
+
+uint8_t genhdr(uint8_t id, uint8_t endpoint, uint8_t status, enum cmdlen len);
+int parseframe(uint8_t b, struct frame_header *hdr);
+#endif

hw/application_fpga/tkey-libs/include/tkey/tk1_mem.h

@@ -0,0 +1,148 @@
+/*
+ * Tillitis TKey Memory Map
+ *
+ * SPDX-FileCopyrightText: 2022 Tillitis AB <tillitis.se>
+ * SPDX-License-Identifier: BSD-2-Clause
+ *
+ * Note that this file is also in tillitis-key1 and qemu
+ * (GPL-2.0-or-later). Needs to stay in sync and have a compatible
+ * license.
+ */
+
+// clang-format off
+
+#ifndef TKEY_TK1_MEM_H
+#define TKEY_TK1_MEM_H
+
+/*
+  The canonical location of this file is in:
+
+    https://github.com/tillitis/tkey-libs
+
+  Under:
+
+    include/tkey/tk1_mem.h
+
+  The contents are mostly derived from the Verilog code in
+
+    https://github.com/tillitis/tillitis-key1
+
+  Memory map
+
+  Top level prefix, the first 2 bits in a 32-bit address:
+
+  name	prefix	address length
+  --------------------------------------------------------
+  ROM		0b00	30 bit address
+  RAM		0b01	30 bit address
+  Reserved	0b10
+  Cores		0b11	6 bits for core select, 24 bits rest
+
+  Address Prefix, the first 8 bits in a 32-bit address:
+
+  name		prefix
+  --------------------
+  ROM		0x00
+  RAM		0x40
+  TRNG		0xc0
+  TIMER		0xc1
+  UDS		0xc2
+  UART		0xc3
+  TOUCH		0xc4
+  FW_RAM	0xd0
+  QEMU		0xfe   Not used in real hardware
+  TK1		0xff
+ */
+
+#define TK1_ROM_BASE 0x00000000
+#define TK1_ROM_SIZE 0x2000
+
+#define TK1_RAM_BASE 0x40000000
+#define TK1_RAM_SIZE 0x20000
+
+#define TK1_MMIO_BASE 0xc0000000
+#define TK1_MMIO_SIZE 0x3fffffff
+
+#define TK1_APP_MAX_SIZE 0x20000
+
+#define TK1_MMIO_FW_RAM_BASE 0xd0000000
+// FW_RAM is 4096 bytes
+#define TK1_MMIO_FW_RAM_SIZE 0x1000
+
+#define TK1_MMIO_TRNG_BASE 0xc0000000
+#define TK1_MMIO_TRNG_STATUS 0xc0000024
+#define TK1_MMIO_TRNG_STATUS_READY_BIT 0
+#define TK1_MMIO_TRNG_ENTROPY 0xc0000080
+
+#define TK1_MMIO_TIMER_BASE 0xc1000000
+#define TK1_MMIO_TIMER_CTRL 0xc1000020
+#define TK1_MMIO_TIMER_CTRL_START_BIT 0
+#define TK1_MMIO_TIMER_CTRL_STOP_BIT 1
+
+#define TK1_MMIO_TIMER_STATUS 0xc1000024
+#define TK1_MMIO_TIMER_STATUS_RUNNING_BIT 0
+#define TK1_MMIO_TIMER_PRESCALER 0xc1000028
+#define TK1_MMIO_TIMER_TIMER 0xc100002c
+
+#define TK1_MMIO_UDS_BASE 0xc2000000
+#define TK1_MMIO_UDS_FIRST 0xc2000000
+#define TK1_MMIO_UDS_LAST 0xc200001c
+
+#define TK1_MMIO_UART_BASE 0xc3000000
+#define TK1_MMIO_UART_RX_STATUS 0xc3000080
+#define TK1_MMIO_UART_RX_DATA 0xc3000084
+#define TK1_MMIO_UART_RX_BYTES 0xc3000088
+#define TK1_MMIO_UART_TX_STATUS 0xc3000100
+#define TK1_MMIO_UART_TX_DATA 0xc3000104
+
+#define TK1_MMIO_TOUCH_BASE 0xc4000000
+#define TK1_MMIO_TOUCH_STATUS 0xc4000024
+#define TK1_MMIO_TOUCH_STATUS_EVENT_BIT 0
+
+// This only exists in QEMU, not real hardware
+#define TK1_MMIO_QEMU_BASE 0xfe000000
+#define TK1_MMIO_QEMU_DEBUG 0xfe001000
+
+#define TK1_MMIO_TK1_BASE 0xff000000
+
+#define TK1_MMIO_TK1_NAME0 0xff000000
+#define TK1_MMIO_TK1_NAME1 0xff000004
+#define TK1_MMIO_TK1_VERSION 0xff000008
+
+#define TK1_MMIO_TK1_LED 0xff000024
+#define TK1_MMIO_TK1_LED_R_BIT 2
+#define TK1_MMIO_TK1_LED_G_BIT 1
+#define TK1_MMIO_TK1_LED_B_BIT 0
+
+#define TK1_MMIO_TK1_GPIO 0xff000028
+#define TK1_MMIO_TK1_GPIO1_BIT 0
+#define TK1_MMIO_TK1_GPIO2_BIT 1
+#define TK1_MMIO_TK1_GPIO3_BIT 2
+#define TK1_MMIO_TK1_GPIO4_BIT 3
+
+#define TK1_MMIO_TK1_APP_ADDR 0xff000030
+#define TK1_MMIO_TK1_APP_SIZE 0xff000034
+
+#define TK1_MMIO_TK1_CDI_FIRST 0xff000080
+#define TK1_MMIO_TK1_CDI_LAST 0xff00009c
+
+#define TK1_MMIO_TK1_UDI_FIRST 0xff0000c0
+#define TK1_MMIO_TK1_UDI_LAST 0xff0000c4
+
+// Deprecated - use _ADDR_RAND instead
+#define TK1_MMIO_TK1_RAM_ASLR 0xff000100
+#define TK1_MMIO_TK1_RAM_ADDR_RAND 0xff000100
+// Deprecated - use _DATA_RAND instead
+#define TK1_MMIO_TK1_RAM_SCRAMBLE 0xff000104
+#define TK1_MMIO_TK1_RAM_DATA_RAND 0xff000104
+
+#define TK1_MMIO_TK1_CPU_MON_CTRL 0xff000180
+#define TK1_MMIO_TK1_CPU_MON_FIRST 0xff000184
+#define TK1_MMIO_TK1_CPU_MON_LAST 0xff000188
+
+#define TK1_MMIO_TK1_SYSTEM_RESET 0xff0001C0
+
+#define TK1_MMIO_TK1_SPI_EN 0xff000200
+#define TK1_MMIO_TK1_SPI_XFER 0xff000204
+#define TK1_MMIO_TK1_SPI_DATA 0xff000208
+#endif

hw/application_fpga/tkey-libs/include/tkey/touch.h

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2023 Tillitis AB <tillitis.se>
+// SPDX-License-Identifier: BSD-2-Clause
+
+#ifndef TKEY_TOUCH_H
+#define TKEY_TOUCH_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <tkey/tk1_mem.h>
+
+// touchwait() waits for a touch event while blinking color on the
+// status LED. timeout_s is the timeout in seconds.
+//
+// If a touch event occurs it returns true. If the timeout expires it
+// returns false.
+bool touch_wait(int color, int timeout_s);
+#endif