ti: k3: common: sec_proxy: Introduce sec_proxy_lite definition

There are two communication scheme that have been enabled to communicate
with Secure Proxy in TI.
a) A full fledged prioritized communication scheme, which involves upto
   5 threads from the perspective of the host software
b) A much simpler "lite" version which is just a two thread scheme
   involving just a transmit and receive thread scheme.

The (a) system is specifically useful when the SoC is massive
involving multiple processor systems and where the potential for
priority inversion is clearly a system usecase killer. However, this
comes with the baggage of significant die area for larger number of
instances of secure proxy, ring accelerator and backing memories
for queued messages. Example SoCs using this scheme would be:
AM654[1], J721E[2], J7200[3]  etc.

The (b) scheme(aka the lite scheme) is introduced on smaller SoCs
where memory and area concerns are paramount. The tradeoff of
priority loss is acceptable given the reduced number of processors
communicating with the central system controller. This brings about
a very significant area and memory usage savings while the loss of
communication priority has no demonstrable impact. Example SoC using
this scheme would be: AM642[4]

While we can detect using JTAG ID and conceptually handle things
dynamically, adding such a scheme involves a lot of unused data (cost
of ATF memory footprint), pointer lookups (performance cost) and still
due to follow on patches, does'nt negate the need for a different
build configuration. However, (a) and (b) family of SoCs share the
same scheme and addresses etc, this helps minimize our churn quite a
bit

Instead of introducing a complex data structure lookup scheme, lets
keep things simple by first introducing the pieces necessary for an
alternate communication scheme, then introduce a second platform
representing the "lite" family of K3 processors.

NOTE: This is only possible since ATF uses just two (secure) threads
for actual communication with the central system controller. This is
sufficient for the function that ATF uses.

The (a) scheme and the (b) scheme also varies w.r.t the base addresses
used, even though the memory window assigned for them have remained
consistent. We introduce the delta as part of this change as well.
This is expected to remain consistent as a standard in TI SoCs.

References:
[1] See AM65x Technical Reference Manual (SPRUID7, April 2018)
for further details: https://www.ti.com/lit/pdf/spruid7

[2] See J721E Technical Reference Manual (SPRUIL1, May 2019)
for further details: https://www.ti.com/lit/pdf/spruil1

[3] See J7200 Technical Reference Manual (SPRUIU1, June 2020)
for further details: https://www.ti.com/lit/pdf/spruiu1

[4] See AM64X Technical Reference Manual (SPRUIM2, Nov 2020)
for further details: https://www.ti.com/lit/pdf/spruim2

Signed-off-by: Nishanth Menon <nm@ti.com>
Change-Id: I697711ee0e6601965015ddf950fdfdec8e759bfc

diff --git a/plat/ti/k3/board/generic/board.mk b/plat/ti/k3/board/generic/board.mk
index c5bd1ec3c3058e95c25211977b33ce6d94030bf4..ef74cd64cabaeddb18ff6932410496f3cc5dc22f 100644 (file)
--- a/plat/ti/k3/board/generic/board.mk
+++ b/plat/ti/k3/board/generic/board.mk
@@ -13,6 +13,10 @@ $(eval $(call add_define,PRELOADED_BL33_BASE))
 K3_HW_CONFIG_BASE ?= 0x82000000
 $(eval $(call add_define,K3_HW_CONFIG_BASE))
 
+# Define sec_proxy usage as the full prioritized communication scheme
+K3_SEC_PROXY_LITE      :=      0
+$(eval $(call add_define,K3_SEC_PROXY_LITE))
+
 # System coherency is managed in hardware
 USE_COHERENT_MEM       :=      1
 

diff --git a/plat/ti/k3/common/drivers/sec_proxy/sec_proxy.c b/plat/ti/k3/common/drivers/sec_proxy/sec_proxy.c
index cbe5fdab93e402889128b2683fb52482631eb9ae..a0bfdee36706f7e9854a0d7cba81e1f3e2f6bc52 100644 (file)
--- a/plat/ti/k3/common/drivers/sec_proxy/sec_proxy.c
+++ b/plat/ti/k3/common/drivers/sec_proxy/sec_proxy.c
@@ -97,11 +97,16 @@ static struct k3_sec_proxy_mbox spm = {
                .data_end_offset = 0x3C,
        },
        .threads = {
+#if !K3_SEC_PROXY_LITE
                SP_THREAD(SP_NOTIFY),
                SP_THREAD(SP_RESPONSE),
                SP_THREAD(SP_HIGH_PRIORITY),
                SP_THREAD(SP_LOW_PRIORITY),
                SP_THREAD(SP_NOTIFY_RESP),
+#else
+               SP_THREAD(SP_RESPONSE),
+               SP_THREAD(SP_HIGH_PRIORITY),
+#endif /* K3_SEC_PROXY_LITE */
        },
 };
 

diff --git a/plat/ti/k3/common/drivers/sec_proxy/sec_proxy.h b/plat/ti/k3/common/drivers/sec_proxy/sec_proxy.h
index 6c4f5dfffa7edcdbe380981368d7e5e937d66e12..f4b0b4baced84a83f5872fda52ed6e65295f2194 100644 (file)
--- a/plat/ti/k3/common/drivers/sec_proxy/sec_proxy.h
+++ b/plat/ti/k3/common/drivers/sec_proxy/sec_proxy.h
@@ -16,13 +16,28 @@
  * enum k3_sec_proxy_chan_id - Secure Proxy thread IDs
  *
  * These the available IDs used in k3_sec_proxy_{send,recv}()
+ * There are two schemes we use:
+ * * if K3_SEC_PROXY_LITE = 1, we just have two threads to talk
+ * * if K3_SEC_PROXY_LITE = 0, we have the full fledged
+ *   communication scheme available.
  */
 enum k3_sec_proxy_chan_id {
+#if !K3_SEC_PROXY_LITE
        SP_NOTIFY = 0,
        SP_RESPONSE,
        SP_HIGH_PRIORITY,
        SP_LOW_PRIORITY,
        SP_NOTIFY_RESP,
+#else
+       SP_RESPONSE = 8,
+       /*
+        * Note: TISCI documentation indicates "low priority", but in reality
+        * with a single thread, there is no low or high priority.. This usage
+        * is more appropriate for TF-A since we can reduce the churn as a
+        * result.
+        */
+       SP_HIGH_PRIORITY,
+#endif /* K3_SEC_PROXY_LITE */
 };
 
 /**

diff --git a/plat/ti/k3/include/platform_def.h b/plat/ti/k3/include/platform_def.h
index a56dd3d74d7d7a4f8066cbbb9cd2e2d04bc42ef1..f12fb0b2116dd41efd6bf980d4347c316809de63 100644 (file)
--- a/plat/ti/k3/include/platform_def.h
+++ b/plat/ti/k3/include/platform_def.h
@@ -162,12 +162,21 @@
 #define K3_GIC_BASE    0x01800000
 #define K3_GIC_SIZE    0x200000
 
+#if !K3_SEC_PROXY_LITE
 #define SEC_PROXY_DATA_BASE    0x32C00000
 #define SEC_PROXY_DATA_SIZE    0x80000
 #define SEC_PROXY_SCFG_BASE    0x32800000
 #define SEC_PROXY_SCFG_SIZE    0x80000
 #define SEC_PROXY_RT_BASE      0x32400000
 #define SEC_PROXY_RT_SIZE      0x80000
+#else
+#define SEC_PROXY_DATA_BASE    0x4D000000
+#define SEC_PROXY_DATA_SIZE    0x80000
+#define SEC_PROXY_SCFG_BASE    0x4A400000
+#define SEC_PROXY_SCFG_SIZE    0x80000
+#define SEC_PROXY_RT_BASE      0x4A600000
+#define SEC_PROXY_RT_SIZE      0x80000
+#endif /* K3_SEC_PROXY_LITE */
 
 #define SEC_PROXY_TIMEOUT_US           1000000
 #define SEC_PROXY_MAX_MESSAGE_SIZE     56