rngb: add the support for TRNG for imx6ull

The driver starts by creating basic structures for a phonix driver.
Then it sets flags for tests of rngb and seeding, sequentially.
The last things is waiting for system messaga.

JIRA: RTOS-317

Author: SzpejnaDawid

rngb/imx6ull-rngb.c

@@ -0,0 +1,260 @@
+/*
+ * Phoenix-RTOS
+ *
+ * i.MX 6ULL RNGB driver
+ *
+ * Copyright 2023 Phoenix Systems
+ * Author: Dawid Szpejna
+ *
+ * This file is part of Phoenix-RTOS.
+ *
+ * %LICENSE%
+ */
+
+#include <sys/msg.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <posix/utils.h>
+#include <sys/platform.h>
+#include <stdio.h>
+#include <sys/threads.h>
+#include <sys/interrupt.h>
+#include <sys/mman.h>
+#include <sys/debug.h>
+
+
+#define RNG_VER 0
+#define RNG_CMD 1
+#define RNG_CR  2
+#define RNG_SR  3
+#define RNG_ESR 4
+#define RNG_OUT 5
+
+
+#define RNGB_START_ADDRESS 0x02284000
+#define RNGB_IRQ           (6 + 32)
+
+
+#define AFTER_TEST    0
+#define AFTER_SEEDING 1
+#define ERRO_OCCURRED 1
+#define MMAP_SIZE     4096
+
+
+#define FIELD(address, top, length)  (((*(address)) << (31 - top)) >> (32 - length))
+
+
+/* Flags indicates whether tests or seeding is done */
+typedef struct {
+	volatile uint32_t *base;
+	volatile uint32_t flags;
+	uint32_t port;
+
+	handle_t lock;
+	handle_t cond;
+} rngb_t;
+
+
+static rngb_t common_rngb;
+
+
+int rngb_hinterrupt(unsigned int n, void *arg)
+{
+	rngb_t *rngb_arg = (rngb_t *)arg;
+	rngb_arg->flags += 1u;
+
+	return 1;
+}
+
+
+int systeminit(void)
+{
+	const char devpath[] = "random";
+	int err;
+	oid_t dev;
+
+	/* A default value for flags - nothing is done */
+	common_rngb.flags = 0;
+
+	common_rngb.base = mmap(NULL, MMAP_SIZE, PROT_READ | PROT_WRITE, MAP_DEVICE | MAP_UNCACHED, OID_PHYSMEM, RNGB_START_ADDRESS);
+	if (common_rngb.base == MAP_FAILED) {
+		printf("rngb: Could not map addr\n");
+		return -1;
+	}
+
+	if (portCreate(&common_rngb.port) != EOK) {
+		printf("rngb: Could not create port\n");
+
+		munmap((void *)common_rngb.base, MMAP_SIZE);
+		return -1;
+	}
+
+	dev.port = common_rngb.port;
+	dev.id = 0;
+
+	err = create_dev(&dev, devpath);
+	if (err != EOK) {
+		printf("rngb: Could not create port file %s (err %d)\n", devpath, err);
+
+		portDestroy(common_rngb.port);
+		munmap((void *)common_rngb.base, MMAP_SIZE);
+		return -1;
+	}
+
+	err = mutexCreate(&common_rngb.lock);
+	if (err < 0) {
+		printf("rngb: Could not create mutex for rngb\n");
+
+		portDestroy(common_rngb.port);
+		munmap((void *)common_rngb.base, MMAP_SIZE);
+		return -1;
+	}
+
+	err = condCreate(&common_rngb.cond);
+	if (err < 0) {
+		printf("rngb: Could not create cond for rngb\n");
+
+		portDestroy(common_rngb.port);
+		munmap((void *)common_rngb.base, MMAP_SIZE);
+		return -1;
+	}
+
+	interrupt(RNGB_IRQ, rngb_hinterrupt, &common_rngb, common_rngb.cond, NULL);
+
+	return 0;
+}
+
+
+int hardwareinit(void)
+{
+	int err;
+	mutexLock(common_rngb.lock);
+
+	/* Reset and wait until rngb is sleeping */
+	*(common_rngb.base + RNG_CMD) = (uint32_t)(0x40);
+	do {
+		err = *(common_rngb.base + RNG_SR) & (uint32_t)(0x4);
+	} while(err == 0);
+
+	/* Run self test */
+	*(common_rngb.base + RNG_CMD) = (uint32_t)(0x1);
+	/* Waiting until tests are done */
+	while (common_rngb.flags == AFTER_TEST) {
+		condWait(common_rngb.cond, common_rngb.lock, 0);
+	}
+
+	err = *(common_rngb.base + RNG_SR) & (1 << 16);
+	if (err == ERRO_OCCURRED) {
+		printf("rngb: error after slef tests\n");
+
+		portDestroy(common_rngb.port);
+		munmap((void *)common_rngb.base, MMAP_SIZE);
+		mutexUnlock(common_rngb.lock);
+		return -1;
+	}
+
+	/* Clear the interrupt and run seeding */
+	*(common_rngb.base + RNG_CMD) = (uint32_t)(0x20);
+	*(common_rngb.base + RNG_CMD) = (uint32_t)(0x2);
+	/* Waiting until seeding is done */
+	while (common_rngb.flags == AFTER_SEEDING) {
+		condWait(common_rngb.cond, common_rngb.lock, 0);
+	}
+
+	err = *(common_rngb.base + RNG_SR) & (1 << 16);
+	if (err == ERRO_OCCURRED) {
+		printf("rngb: error after generating seed\n");
+
+		portDestroy(common_rngb.port);
+		munmap((void *)common_rngb.base, MMAP_SIZE);
+		mutexUnlock(common_rngb.lock);
+		return -1;
+	}
+
+	/* Enable automatic seeding */
+	*(common_rngb.base + RNG_CR) = (uint32_t)(0x10);
+	mutexUnlock(common_rngb.lock);
+	return 0;
+}
+
+
+int readrandoms(char *buff, size_t size)
+{
+	char val[sizeof(uint32_t)];
+	unsigned int i;
+	int err, level;
+
+	mutexLock(common_rngb.lock);
+	for (i = 0; i < size; i++) {
+		err = *(common_rngb.base + RNG_SR) & (1 << 16);
+		if (err == ERRO_OCCURRED) {
+			mutexUnlock(common_rngb.lock);
+			return -EIO;
+		}
+
+		if (i % sizeof(uint32_t) == 0) {
+			level = FIELD(common_rngb.base + RNG_SR, 11, 4);
+			if (level == 0) {
+				i--;
+				continue;
+			}
+
+			*((uint32_t *)val) = *(common_rngb.base + RNG_OUT);
+		}
+
+		buff[i] = val[i % sizeof(uint32_t)];
+	}
+
+	mutexUnlock(common_rngb.lock);
+	return i;
+}
+
+
+void thread(void *arg)
+{
+	msg_t msg;
+	unsigned long int rid;
+
+	while (1) {
+		if (msgRecv(common_rngb.port, &msg, &rid) < 0) {
+			continue;
+		}
+
+		msg.o.io.err = -EINVAL;
+		switch (msg.type) {
+			case mtClose:
+			case mtOpen:
+				msg.o.io.err = msg.i.openclose.oid.id != 0 ? -ENOENT : EOK;
+				break;
+
+			case mtRead:
+				if (msg.o.data != NULL && msg.i.io.oid.id == 0) {
+					msg.o.io.err = readrandoms(msg.o.data, msg.o.size);
+				}
+
+				break;
+		}
+
+		msgRespond(common_rngb.port, &msg, rid);
+	}
+}
+
+
+int main(int argc, char **argv)
+{
+	oid_t root;
+
+	/* Wait for the filesystem */
+	while (lookup("/", NULL, &root) < 0) {
+		usleep(10000);
+	}
+
+	if (systeminit() || hardwareinit()) {
+		return -EIO;
+	}
+
+	thread(NULL);
+
+	return 0;
+}