sep: Add support for AKF mailboxes

Add support for SEP behind AKF mailboxes. Some SEPs of this type does not
support the GETRAND operation, so handle that case as well.

Signed-off-by: Nick Chan <towinchenmi@gmail.com>

Author: asdfugil

src/kboot.c

@@ -109,6 +109,9 @@ static int dt_set_rng_seed_sep(int node)
     u64 kaslr_seed;
     uint8_t rng_seed[128]; // same size used by Linux for kexec
 
+    if (!(sep_get_capabilities() & SEP_CAPABILITY_GETRAND))
+        return -1;
+
     if (sep_get_random(&kaslr_seed, sizeof(kaslr_seed)) != sizeof(kaslr_seed))
         bail("SEP: couldn't get enough random bytes for KASLR seed\n");
     if (sep_get_random(rng_seed, sizeof(rng_seed)) != sizeof(rng_seed))

src/sep.c

@@ -2,7 +2,10 @@
 
 #include <string.h>
 
+#include "adt.h"
+#include "akf.h"
 #include "asc.h"
+#include "malloc.h"
 #include "sep.h"
 #include "types.h"
 #include "utils.h"
@@ -18,21 +21,104 @@
 
 #define SEP_TIMEOUT 1000
 
-static asc_dev_t *sep_asc = NULL;
+enum sep_mbox_type {
+    SEP_MBOX_TYPE_AKF,
+    SEP_MBOX_TYPE_ASC,
+};
+
+static struct sep_dev {
+    enum sep_mbox_type type;
+    enum sep_capabilities capabilities;
+    union {
+        akf_dev_t *akf;
+        asc_dev_t *asc;
+    };
+} *sep_dev;
 
 int sep_init(void)
 {
-    if (!sep_asc)
-        sep_asc = asc_init("/arm-io/sep");
-    if (!sep_asc)
+    const char *path = "/arm-io/sep";
+    int sep_path[8];
+
+    int node = adt_path_offset_trace(adt, path, sep_path);
+    if (node < 0) {
+        printf("sep: Error getting sep node %s\n", path);
+        return -1;
+    }
+
+    u64 base;
+    if (adt_get_reg(adt, sep_path, "reg", 0, &base, NULL) < 0) {
+        printf("sep: Error getting akf %s base address.\n", path);
         return -1;
+    }
+
+    sep_dev = calloc(0, sizeof(*sep_dev));
+
+    if (adt_is_compatible(adt, node, "iop,s5l8960x") || adt_is_compatible(adt, node, "iop,s8000")) {
+        sep_dev->type = SEP_MBOX_TYPE_AKF;
+    } else {
+        sep_dev->type = SEP_MBOX_TYPE_ASC;
+    }
+
+    switch (sep_dev->type) {
+        case SEP_MBOX_TYPE_AKF:
+            sep_dev->akf = akf_init(path);
+            break;
+        case SEP_MBOX_TYPE_ASC:
+            sep_dev->asc = asc_init(path);
+            break;
+    }
+
+    if (chip_id != 0x8960 && chip_id != 0x7000 && chip_id != 0x7001 && chip_id != 0x8000 &&
+        chip_id != 0x8001 && chip_id != 0x8003)
+        sep_dev->capabilities |= SEP_CAPABILITY_GETRAND;
+
     return 0;
 }
 
+bool sep_send(u64 msg)
+{
+    switch (sep_dev->type) {
+        case SEP_MBOX_TYPE_AKF: {
+            const struct akf_message akf_msg = {.msg0 = FIELD_GET(msg, MASK(32)),
+                                                .msg1 = FIELD_GET(msg, GENMASK(63, 32))};
+            return akf_send(sep_dev->akf, &akf_msg);
+        }
+        case SEP_MBOX_TYPE_ASC: {
+            const struct asc_message asc_msg = {.msg0 = msg};
+            return asc_send(sep_dev->asc, &asc_msg);
+        }
+    }
+}
+
+bool sep_recv(u64 *reply)
+{
+    switch (sep_dev->type) {
+        case SEP_MBOX_TYPE_ASC: {
+            struct asc_message asc_reply;
+            int retval = asc_recv_timeout(sep_dev->asc, &asc_reply, SEP_TIMEOUT);
+            *reply = asc_reply.msg0;
+            return retval;
+        }
+        case SEP_MBOX_TYPE_AKF: {
+            struct akf_message akf_reply;
+            int retval = akf_recv_timeout(sep_dev->akf, &akf_reply, SEP_TIMEOUT);
+            *reply =
+                FIELD_PREP(MASK(32), akf_reply.msg0) | FIELD_PREP(GENMASK(63, 32), akf_reply.msg1);
+            return retval;
+        }
+    }
+}
+
 size_t sep_get_random(void *buffer, size_t len)
 {
-    const struct asc_message msg_getrand = {.msg0 = FIELD_PREP(SEP_MSG_EP, SEP_EP_ROM) |
-                                                    FIELD_PREP(SEP_MSG_CMD, SEP_MSG_GETRAND)};
+    if (!(sep_dev->capabilities & SEP_CAPABILITY_GETRAND)) {
+        printf("sep: SEP does not support GETRAND\n");
+        return 0;
+    }
+
+    const u64 msg_getrand =
+        FIELD_PREP(SEP_MSG_EP, SEP_EP_ROM) | FIELD_PREP(SEP_MSG_CMD, SEP_MSG_GETRAND);
     int ret;
     size_t done = 0;
 
@@ -41,20 +127,20 @@ size_t sep_get_random(void *buffer, size_t len)
         return 0;
 
     while (len) {
-        struct asc_message reply;
+        u64 reply;
         u32 rng;
         size_t copy;
 
-        if (!asc_send(sep_asc, &msg_getrand))
+        if (!sep_send(msg_getrand))
             return done;
-        if (!asc_recv_timeout(sep_asc, &reply, SEP_TIMEOUT))
+        if (!sep_recv(&reply))
             return done;
-        if (FIELD_GET(SEP_MSG_CMD, reply.msg0) != SEP_REPLY_GETRAND) {
-            printf("SEP: unexpected getrand reply: %016lx\n", reply.msg0);
+        if (FIELD_GET(SEP_MSG_CMD, reply) != SEP_REPLY_GETRAND) {
+            printf("SEP: unexpected getrand reply: %016lx\n", reply);
             return done;
         }
 
-        rng = FIELD_GET(SEP_MSG_DATA, reply.msg0);
+        rng = FIELD_GET(SEP_MSG_DATA, reply);
         copy = sizeof(rng);
         if (copy > len)
             copy = len;
@@ -66,3 +152,8 @@ size_t sep_get_random(void *buffer, size_t len)
 
     return done;
 }
+
+enum sep_capabilities sep_get_capabilities(void)
+{
+    return sep_dev->capabilities;
+}

src/sep.h

@@ -6,7 +6,12 @@
 #include "asc.h"
 #include "types.h"
 
+enum sep_capabilities {
+    SEP_CAPABILITY_GETRAND = BIT(0),
+};
+
 int sep_init(void);
 size_t sep_get_random(void *buffer, size_t len);
+enum sep_capabilities sep_get_capabilities(void);
 
 #endif