[PATCH v3 0/7] firmware: Add initial support for Arm FF-A

[PATCH v3 0/7] firmware: Add initial support for Arm FF-A

[Sudeep Holla]

Hi all,

This is just initial implementation to check on the idea of providing
in-kernel support for Arm FF-A specification. Complete driver support
is still work in progress, I am posting to early feedback and merge
basic support ASAP.

Arm Firmware Framework for Armv8-A specification[1] describes a software
architecture that provides mechanism to utilise the virtualization
extension to isolate software images and describes interfaces that
standardize communication between the various software images. This
includes communication between images in the Secure and Normal world.

The main idea here is to create FFA device to establish any communication
with a secure partition.

--
Regards,
Sudeep

[1] https://developer.arm.com/documentation/den0077/latest

v2->v3:
	- Dropped hypervisor partitions and userspace support as it is
	  no longer in the list of requirements
	- Moved away from ioctl style interface for in-kernel users as
	  there is no need to keep in sync with userspace anymore
	- Some kerneldoc fixes as pointed out in earlier reviews

v1->v2:
	- Moved userspace code to a separate unit, will move to separate
	  module. Still working on minimizing initcall dependencies and
	  exported functions to reuse some of the code.
	- Fixed couple of minor issues pointed out
	- Dropped ASYNC send message as I haven't been able to test

Sudeep Holla (7):
  dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding
  arm64: smccc: Add support for SMCCCv1.2 input/output registers
  firmware: arm_ffa: Add initial FFA bus support for device enumeration
  firmware: arm_ffa: Add initial Arm FFA driver support
  firmware: arm_ffa: Add support for SMCCC as transport to FFA driver
  firmware: arm_ffa: Setup in-kernel users of FFA partitions
  firmware: arm_ffa: Add support for MEM_* interfaces

 .../devicetree/bindings/arm/arm,ffa.yaml      |  58 ++
 arch/arm64/kernel/asm-offsets.c               |   4 +
 arch/arm64/kernel/smccc-call.S                |  22 +
 drivers/firmware/Kconfig                      |   1 +
 drivers/firmware/Makefile                     |   1 +
 drivers/firmware/arm_ffa/Kconfig              |  21 +
 drivers/firmware/arm_ffa/Makefile             |   6 +
 drivers/firmware/arm_ffa/bus.c                | 179 +++++
 drivers/firmware/arm_ffa/common.h             |  32 +
 drivers/firmware/arm_ffa/driver.c             | 660 ++++++++++++++++++
 drivers/firmware/arm_ffa/smccc.c              |  54 ++
 include/linux/arm-smccc.h                     |  50 ++
 include/linux/arm_ffa.h                       | 270 +++++++
 13 files changed, 1358 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
 create mode 100644 drivers/firmware/arm_ffa/Kconfig
 create mode 100644 drivers/firmware/arm_ffa/Makefile
 create mode 100644 drivers/firmware/arm_ffa/bus.c
 create mode 100644 drivers/firmware/arm_ffa/common.h
 create mode 100644 drivers/firmware/arm_ffa/driver.c
 create mode 100644 drivers/firmware/arm_ffa/smccc.c
 create mode 100644 include/linux/arm_ffa.h

--
2.25.1

[PATCH v3 0/7] firmware: Add initial support for Arm FF-A

[Sudeep Holla]

Hi all,

This is just initial implementation to check on the idea of providing
in-kernel support for Arm FF-A specification. Complete driver support
is still work in progress, I am posting to early feedback and merge
basic support ASAP.

Arm Firmware Framework for Armv8-A specification[1] describes a software
architecture that provides mechanism to utilise the virtualization
extension to isolate software images and describes interfaces that
standardize communication between the various software images. This
includes communication between images in the Secure and Normal world.

The main idea here is to create FFA device to establish any communication
with a secure partition.

--
Regards,
Sudeep

[1] https://developer.arm.com/documentation/den0077/latest

v2->v3:
	- Dropped hypervisor partitions and userspace support as it is
	  no longer in the list of requirements
	- Moved away from ioctl style interface for in-kernel users as
	  there is no need to keep in sync with userspace anymore
	- Some kerneldoc fixes as pointed out in earlier reviews

v1->v2:
	- Moved userspace code to a separate unit, will move to separate
	  module. Still working on minimizing initcall dependencies and
	  exported functions to reuse some of the code.
	- Fixed couple of minor issues pointed out
	- Dropped ASYNC send message as I haven't been able to test

Sudeep Holla (7):
  dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding
  arm64: smccc: Add support for SMCCCv1.2 input/output registers
  firmware: arm_ffa: Add initial FFA bus support for device enumeration
  firmware: arm_ffa: Add initial Arm FFA driver support
  firmware: arm_ffa: Add support for SMCCC as transport to FFA driver
  firmware: arm_ffa: Setup in-kernel users of FFA partitions
  firmware: arm_ffa: Add support for MEM_* interfaces

 .../devicetree/bindings/arm/arm,ffa.yaml      |  58 ++
 arch/arm64/kernel/asm-offsets.c               |   4 +
 arch/arm64/kernel/smccc-call.S                |  22 +
 drivers/firmware/Kconfig                      |   1 +
 drivers/firmware/Makefile                     |   1 +
 drivers/firmware/arm_ffa/Kconfig              |  21 +
 drivers/firmware/arm_ffa/Makefile             |   6 +
 drivers/firmware/arm_ffa/bus.c                | 179 +++++
 drivers/firmware/arm_ffa/common.h             |  32 +
 drivers/firmware/arm_ffa/driver.c             | 660 ++++++++++++++++++
 drivers/firmware/arm_ffa/smccc.c              |  54 ++
 include/linux/arm-smccc.h                     |  50 ++
 include/linux/arm_ffa.h                       | 270 +++++++
 13 files changed, 1358 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
 create mode 100644 drivers/firmware/arm_ffa/Kconfig
 create mode 100644 drivers/firmware/arm_ffa/Makefile
 create mode 100644 drivers/firmware/arm_ffa/bus.c
 create mode 100644 drivers/firmware/arm_ffa/common.h
 create mode 100644 drivers/firmware/arm_ffa/driver.c
 create mode 100644 drivers/firmware/arm_ffa/smccc.c
 create mode 100644 include/linux/arm_ffa.h

--
2.25.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Sudeep Holla]

Since the FF-A v1.0 specification doesn't list the UUID of all the
partitions in the discovery API, we need to specify the UUID of the
partitions that need to be accessed by drivers within the kernel.

This binding to provide the list of partitions that kernel drivers
may need to access.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml

diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
new file mode 100644
index 000000000000..a014a5801c34
--- /dev/null
+++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Arm Firmware Framework for Arm v8-A (in-kernel users)
+
+maintainers:
+  - Sudeep Holla <sudeep.holla@arm.com>
+
+description: |
+  Firmware frameworks implementing partition according to the FF-A
+  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
+  Framework for Arm v8-A") [0], providing services to be used by other
+  partitions.
+
+  [0] https://developer.arm.com/docs/den0077/latest
+
+properties:
+  $nodename:
+    const: ffa
+
+  compatible:
+    oneOf:
+      - const: arm,ffa-1.0
+
+patternProperties:
+  "^ffa_partition[0-9]+$":
+    type: object
+    description: One or more child nodes, each describing an FFA partition.
+    properties:
+      $nodename:
+        const: ffa_partition
+
+      compatible:
+        oneOf:
+          - const: arm,ffa-1.0-partition
+
+      uuid:
+        $ref: '/schemas/types.yaml#definitions/string'
+        description: |
+          The 128-bit UUID [2] of the service implemented by this partition.
+
+          [2] https://tools.ietf.org/html/rfc4122
+
+additionalProperties: false
+
+examples:
+  - |
+    ffa {
+      compatible = "arm,ffa-1.0";
+
+      ffa_partition0 {
+        compatible = "arm,ffa-1.0-partition";
+        uuid = "12345678-9abc-def0-1234-56789abcdef0";
+      };
+    };
-- 
2.25.1

[PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Sudeep Holla]

Since the FF-A v1.0 specification doesn't list the UUID of all the
partitions in the discovery API, we need to specify the UUID of the
partitions that need to be accessed by drivers within the kernel.

This binding to provide the list of partitions that kernel drivers
may need to access.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml

diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
new file mode 100644
index 000000000000..a014a5801c34
--- /dev/null
+++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Arm Firmware Framework for Arm v8-A (in-kernel users)
+
+maintainers:
+  - Sudeep Holla <sudeep.holla@arm.com>
+
+description: |
+  Firmware frameworks implementing partition according to the FF-A
+  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
+  Framework for Arm v8-A") [0], providing services to be used by other
+  partitions.
+
+  [0] https://developer.arm.com/docs/den0077/latest
+
+properties:
+  $nodename:
+    const: ffa
+
+  compatible:
+    oneOf:
+      - const: arm,ffa-1.0
+
+patternProperties:
+  "^ffa_partition[0-9]+$":
+    type: object
+    description: One or more child nodes, each describing an FFA partition.
+    properties:
+      $nodename:
+        const: ffa_partition
+
+      compatible:
+        oneOf:
+          - const: arm,ffa-1.0-partition
+
+      uuid:
+        $ref: '/schemas/types.yaml#definitions/string'
+        description: |
+          The 128-bit UUID [2] of the service implemented by this partition.
+
+          [2] https://tools.ietf.org/html/rfc4122
+
+additionalProperties: false
+
+examples:
+  - |
+    ffa {
+      compatible = "arm,ffa-1.0";
+
+      ffa_partition0 {
+        compatible = "arm,ffa-1.0-partition";
+        uuid = "12345678-9abc-def0-1234-56789abcdef0";
+      };
+    };
-- 
2.25.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v3 2/7] arm64: smccc: Add support for SMCCCv1.2 input/output registers

[Sudeep Holla]

SMCCC v1.2 allows x8-x17 to be used as parameter registers and x4—x17
to be used as result registers in SMC64/HVC64. Arm Firmware Framework
for Armv8-A specification makes use of x0-x7 as parameter and result
registers.

Current SMCCC interface in the kernel just use x0-x7 as parameter and
x0-x3 as result registers. Let us add new interface to support x0-x7
as parameter and result registers. This can be extended to include
x8-x17 when there are users for the same.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 arch/arm64/kernel/asm-offsets.c |  4 +++
 arch/arm64/kernel/smccc-call.S  | 22 +++++++++++++++
 include/linux/arm-smccc.h       | 50 +++++++++++++++++++++++++++++++++
 3 files changed, 76 insertions(+)

diff --git a/arch/arm64/kernel/asm-offsets.c b/arch/arm64/kernel/asm-offsets.c
index 7d32fc959b1a..32bcc25337ce 100644
--- a/arch/arm64/kernel/asm-offsets.c
+++ b/arch/arm64/kernel/asm-offsets.c
@@ -122,6 +122,10 @@ int main(void)
   DEFINE(ARM_SMCCC_RES_X2_OFFS,		offsetof(struct arm_smccc_res, a2));
   DEFINE(ARM_SMCCC_QUIRK_ID_OFFS,	offsetof(struct arm_smccc_quirk, id));
   DEFINE(ARM_SMCCC_QUIRK_STATE_OFFS,	offsetof(struct arm_smccc_quirk, state));
+  DEFINE(ARM_SMCCC_V1_2_RES_X0_OFFS,	offsetof(struct arm_smccc_v1_2_res, a0));
+  DEFINE(ARM_SMCCC_V1_2_RES_X2_OFFS,	offsetof(struct arm_smccc_v1_2_res, a2));
+  DEFINE(ARM_SMCCC_V1_2_RES_X4_OFFS,	offsetof(struct arm_smccc_v1_2_res, a4));
+  DEFINE(ARM_SMCCC_V1_2_RES_X6_OFFS,	offsetof(struct arm_smccc_v1_2_res, a6));
   BLANK();
   DEFINE(HIBERN_PBE_ORIG,	offsetof(struct pbe, orig_address));
   DEFINE(HIBERN_PBE_ADDR,	offsetof(struct pbe, address));
diff --git a/arch/arm64/kernel/smccc-call.S b/arch/arm64/kernel/smccc-call.S
index d62447964ed9..0ea15c1742f3 100644
--- a/arch/arm64/kernel/smccc-call.S
+++ b/arch/arm64/kernel/smccc-call.S
@@ -43,3 +43,25 @@ SYM_FUNC_START(__arm_smccc_hvc)
 	SMCCC	hvc
 SYM_FUNC_END(__arm_smccc_hvc)
 EXPORT_SYMBOL(__arm_smccc_hvc)
+
+	.macro SMCCC_v1_2 instr
+	.cfi_startproc
+	\instr #0
+	ldr x8, [sp]
+	stp x0, x1, [x8, #ARM_SMCCC_V1_2_RES_X0_OFFS]
+	stp x2, x3, [x8, #ARM_SMCCC_V1_2_RES_X2_OFFS]
+	stp x4, x5, [x8, #ARM_SMCCC_V1_2_RES_X4_OFFS]
+	stp x6, x7, [x8, #ARM_SMCCC_V1_2_RES_X6_OFFS]
+	ret
+	.cfi_endproc
+.endm
+
+SYM_FUNC_START(arm_smccc_v1_2_hvc)
+	SMCCC_v1_2 hvc
+SYM_FUNC_END(arm_smccc_v1_2_hvc)
+EXPORT_SYMBOL(arm_smccc_v1_2_hvc)
+
+SYM_FUNC_START(arm_smccc_v1_2_smc)
+	SMCCC_v1_2 smc
+SYM_FUNC_END(arm_smccc_v1_2_smc)
+EXPORT_SYMBOL(arm_smccc_v1_2_smc)
diff --git a/include/linux/arm-smccc.h b/include/linux/arm-smccc.h
index f860645f6512..66fd3d582c7f 100644
--- a/include/linux/arm-smccc.h
+++ b/include/linux/arm-smccc.h
@@ -155,6 +155,56 @@ struct arm_smccc_res {
 	unsigned long a3;
 };
 
+#ifdef CONFIG_ARM64
+/* TODO Need to implement for ARM too */
+/**
+ * struct arm_smccc_v1_2_res - Result from SMC/HVC call
+ * @a0-a7 result values from registers 0 to 7
+ */
+struct arm_smccc_v1_2_res {
+	unsigned long a0;
+	unsigned long a1;
+	unsigned long a2;
+	unsigned long a3;
+	unsigned long a4;
+	unsigned long a5;
+	unsigned long a6;
+	unsigned long a7;
+};
+
+/**
+ * arm_smccc_v1_2_hvc() - make HVC calls
+ * @a0-a7: arguments passed in registers 0 to 7
+ * @res: result values from registers 0 to 7
+ *
+ * This function is used to make HVC calls following SMC Calling Convention
+ * v1.2 or above. The content of the supplied param are copied to registers
+ * 0 to 7 prior to the HVC instruction. The return values are updated with
+ * the content from register 0 to 7 on return from the HVC instruction.
+ */
+asmlinkage
+void arm_smccc_v1_2_hvc(unsigned long a0, unsigned long a1, unsigned long a2,
+			unsigned long a3, unsigned long a4, unsigned long a5,
+			unsigned long a6, unsigned long a7,
+			struct arm_smccc_v1_2_res  *res);
+
+/**
+ * arm_smccc_v1_2_smc() - make SMC calls
+ * @a0-a7: arguments passed in registers 0 to 7
+ * @res: result values from registers 0 to 7
+ *
+ * This function is used to make SMC calls following SMC Calling Convention
+ * v1.2 or above. The content of the supplied param are copied to registers
+ * 0 to 7 prior to the SMC instruction. The return values are updated with
+ * the content from register 0 to 7 on return from the SMC instruction.
+ */
+asmlinkage
+void arm_smccc_v1_2_smc(unsigned long a0, unsigned long a1, unsigned long a2,
+			unsigned long a3, unsigned long a4, unsigned long a5,
+			unsigned long a6, unsigned long a7,
+			struct arm_smccc_v1_2_res  *res);
+#endif
+
 /**
  * struct arm_smccc_quirk - Contains quirk information
  * @id: quirk identification
-- 
2.25.1

[PATCH v3 2/7] arm64: smccc: Add support for SMCCCv1.2 input/output registers

[Sudeep Holla]

SMCCC v1.2 allows x8-x17 to be used as parameter registers and x4—x17
to be used as result registers in SMC64/HVC64. Arm Firmware Framework
for Armv8-A specification makes use of x0-x7 as parameter and result
registers.

Current SMCCC interface in the kernel just use x0-x7 as parameter and
x0-x3 as result registers. Let us add new interface to support x0-x7
as parameter and result registers. This can be extended to include
x8-x17 when there are users for the same.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 arch/arm64/kernel/asm-offsets.c |  4 +++
 arch/arm64/kernel/smccc-call.S  | 22 +++++++++++++++
 include/linux/arm-smccc.h       | 50 +++++++++++++++++++++++++++++++++
 3 files changed, 76 insertions(+)

diff --git a/arch/arm64/kernel/asm-offsets.c b/arch/arm64/kernel/asm-offsets.c
index 7d32fc959b1a..32bcc25337ce 100644
--- a/arch/arm64/kernel/asm-offsets.c
+++ b/arch/arm64/kernel/asm-offsets.c
@@ -122,6 +122,10 @@ int main(void)
   DEFINE(ARM_SMCCC_RES_X2_OFFS,		offsetof(struct arm_smccc_res, a2));
   DEFINE(ARM_SMCCC_QUIRK_ID_OFFS,	offsetof(struct arm_smccc_quirk, id));
   DEFINE(ARM_SMCCC_QUIRK_STATE_OFFS,	offsetof(struct arm_smccc_quirk, state));
+  DEFINE(ARM_SMCCC_V1_2_RES_X0_OFFS,	offsetof(struct arm_smccc_v1_2_res, a0));
+  DEFINE(ARM_SMCCC_V1_2_RES_X2_OFFS,	offsetof(struct arm_smccc_v1_2_res, a2));
+  DEFINE(ARM_SMCCC_V1_2_RES_X4_OFFS,	offsetof(struct arm_smccc_v1_2_res, a4));
+  DEFINE(ARM_SMCCC_V1_2_RES_X6_OFFS,	offsetof(struct arm_smccc_v1_2_res, a6));
   BLANK();
   DEFINE(HIBERN_PBE_ORIG,	offsetof(struct pbe, orig_address));
   DEFINE(HIBERN_PBE_ADDR,	offsetof(struct pbe, address));
diff --git a/arch/arm64/kernel/smccc-call.S b/arch/arm64/kernel/smccc-call.S
index d62447964ed9..0ea15c1742f3 100644
--- a/arch/arm64/kernel/smccc-call.S
+++ b/arch/arm64/kernel/smccc-call.S
@@ -43,3 +43,25 @@ SYM_FUNC_START(__arm_smccc_hvc)
 	SMCCC	hvc
 SYM_FUNC_END(__arm_smccc_hvc)
 EXPORT_SYMBOL(__arm_smccc_hvc)
+
+	.macro SMCCC_v1_2 instr
+	.cfi_startproc
+	\instr #0
+	ldr x8, [sp]
+	stp x0, x1, [x8, #ARM_SMCCC_V1_2_RES_X0_OFFS]
+	stp x2, x3, [x8, #ARM_SMCCC_V1_2_RES_X2_OFFS]
+	stp x4, x5, [x8, #ARM_SMCCC_V1_2_RES_X4_OFFS]
+	stp x6, x7, [x8, #ARM_SMCCC_V1_2_RES_X6_OFFS]
+	ret
+	.cfi_endproc
+.endm
+
+SYM_FUNC_START(arm_smccc_v1_2_hvc)
+	SMCCC_v1_2 hvc
+SYM_FUNC_END(arm_smccc_v1_2_hvc)
+EXPORT_SYMBOL(arm_smccc_v1_2_hvc)
+
+SYM_FUNC_START(arm_smccc_v1_2_smc)
+	SMCCC_v1_2 smc
+SYM_FUNC_END(arm_smccc_v1_2_smc)
+EXPORT_SYMBOL(arm_smccc_v1_2_smc)
diff --git a/include/linux/arm-smccc.h b/include/linux/arm-smccc.h
index f860645f6512..66fd3d582c7f 100644
--- a/include/linux/arm-smccc.h
+++ b/include/linux/arm-smccc.h
@@ -155,6 +155,56 @@ struct arm_smccc_res {
 	unsigned long a3;
 };
 
+#ifdef CONFIG_ARM64
+/* TODO Need to implement for ARM too */
+/**
+ * struct arm_smccc_v1_2_res - Result from SMC/HVC call
+ * @a0-a7 result values from registers 0 to 7
+ */
+struct arm_smccc_v1_2_res {
+	unsigned long a0;
+	unsigned long a1;
+	unsigned long a2;
+	unsigned long a3;
+	unsigned long a4;
+	unsigned long a5;
+	unsigned long a6;
+	unsigned long a7;
+};
+
+/**
+ * arm_smccc_v1_2_hvc() - make HVC calls
+ * @a0-a7: arguments passed in registers 0 to 7
+ * @res: result values from registers 0 to 7
+ *
+ * This function is used to make HVC calls following SMC Calling Convention
+ * v1.2 or above. The content of the supplied param are copied to registers
+ * 0 to 7 prior to the HVC instruction. The return values are updated with
+ * the content from register 0 to 7 on return from the HVC instruction.
+ */
+asmlinkage
+void arm_smccc_v1_2_hvc(unsigned long a0, unsigned long a1, unsigned long a2,
+			unsigned long a3, unsigned long a4, unsigned long a5,
+			unsigned long a6, unsigned long a7,
+			struct arm_smccc_v1_2_res  *res);
+
+/**
+ * arm_smccc_v1_2_smc() - make SMC calls
+ * @a0-a7: arguments passed in registers 0 to 7
+ * @res: result values from registers 0 to 7
+ *
+ * This function is used to make SMC calls following SMC Calling Convention
+ * v1.2 or above. The content of the supplied param are copied to registers
+ * 0 to 7 prior to the SMC instruction. The return values are updated with
+ * the content from register 0 to 7 on return from the SMC instruction.
+ */
+asmlinkage
+void arm_smccc_v1_2_smc(unsigned long a0, unsigned long a1, unsigned long a2,
+			unsigned long a3, unsigned long a4, unsigned long a5,
+			unsigned long a6, unsigned long a7,
+			struct arm_smccc_v1_2_res  *res);
+#endif
+
 /**
  * struct arm_smccc_quirk - Contains quirk information
  * @id: quirk identification
-- 
2.25.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v3 3/7] firmware: arm_ffa: Add initial FFA bus support for device enumeration

[Sudeep Holla]

The Arm FF for Armv8-A specification has concept of endpoints or
partitions. In the Normal world, a partition could be a VM when
the Virtualization extension is enabled or the kernel itself.

In order to handle multiple partitions, we can create a FFA device for
each such partition on a dedicated FFA bus. Similarly, different drivers
requiring FFA transport can be registered on the same bus. We can match
the device and drivers using UUID. This is mostly for the in-kernel
users with FFA drivers.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/Kconfig          |   1 +
 drivers/firmware/Makefile         |   1 +
 drivers/firmware/arm_ffa/Kconfig  |  16 +++
 drivers/firmware/arm_ffa/Makefile |   4 +
 drivers/firmware/arm_ffa/bus.c    | 187 ++++++++++++++++++++++++++++++
 include/linux/arm_ffa.h           |  87 ++++++++++++++
 6 files changed, 296 insertions(+)
 create mode 100644 drivers/firmware/arm_ffa/Kconfig
 create mode 100644 drivers/firmware/arm_ffa/Makefile
 create mode 100644 drivers/firmware/arm_ffa/bus.c
 create mode 100644 include/linux/arm_ffa.h

diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 3315e3c21586..be9056226a07 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -295,6 +295,7 @@ config TURRIS_MOX_RWTM
 	  other manufacturing data and also utilize the Entropy Bit Generator
 	  for hardware random number generation.
 
+source "drivers/firmware/arm_ffa/Kconfig"
 source "drivers/firmware/broadcom/Kconfig"
 source "drivers/firmware/google/Kconfig"
 source "drivers/firmware/efi/Kconfig"
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 5e013b6a3692..546ac8e7f6d0 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_TI_SCI_PROTOCOL)	+= ti_sci.o
 obj-$(CONFIG_TRUSTED_FOUNDATIONS) += trusted_foundations.o
 obj-$(CONFIG_TURRIS_MOX_RWTM)	+= turris-mox-rwtm.o
 
+obj-y				+= arm_ffa/
 obj-y				+= arm_scmi/
 obj-y				+= broadcom/
 obj-y				+= meson/
diff --git a/drivers/firmware/arm_ffa/Kconfig b/drivers/firmware/arm_ffa/Kconfig
new file mode 100644
index 000000000000..261a3660650a
--- /dev/null
+++ b/drivers/firmware/arm_ffa/Kconfig
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: GPL-2.0-only
+config ARM_FFA_TRANSPORT
+	tristate "Arm Firmware Framework for Armv8-A"
+	depends on OF
+	depends on ARM64
+	default n
+	help
+	  This Firmware Framework(FF) for Arm A-profile processors describes
+	  interfaces that standardize communication between the various
+	  software images which includes communication between images in
+	  the Secure world and Normal world. It also leverages the
+	  virtualization extension to isolate software images provided
+	  by an ecosystem of vendors from each other.
+
+	  This driver provides interface for all the client drivers making
+	  use of the features offered by ARM FF-A.
diff --git a/drivers/firmware/arm_ffa/Makefile b/drivers/firmware/arm_ffa/Makefile
new file mode 100644
index 000000000000..bfe4323a8784
--- /dev/null
+++ b/drivers/firmware/arm_ffa/Makefile
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: GPL-2.0-only
+ffa-bus-y = bus.o
+ffa-module-objs := $(ffa-bus-y)
+obj-$(CONFIG_ARM_FFA_TRANSPORT) = ffa-module.o
diff --git a/drivers/firmware/arm_ffa/bus.c b/drivers/firmware/arm_ffa/bus.c
new file mode 100644
index 000000000000..7cd98f22bfe9
--- /dev/null
+++ b/drivers/firmware/arm_ffa/bus.c
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2020 ARM Ltd.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/arm_ffa.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+static int ffa_device_match(struct device *dev, struct device_driver *drv)
+{
+	const struct ffa_device_id *id_table;
+	struct ffa_device *ffa_dev;
+
+	id_table = to_ffa_driver(drv)->id_table;
+	ffa_dev = to_ffa_dev(dev);
+
+	while (!uuid_is_null(&id_table->uuid)) {
+		if (uuid_equal(&ffa_dev->uuid, &id_table->uuid))
+			return 1;
+		id_table++;
+	}
+
+	return 0;
+}
+
+static int ffa_device_probe(struct device *dev)
+{
+	struct ffa_driver *ffa_drv = to_ffa_driver(dev->driver);
+	struct ffa_device *ffa_dev = to_ffa_dev(dev);
+
+	if (!ffa_device_match(dev, dev->driver))
+		return -ENODEV;
+
+	return ffa_drv->probe(ffa_dev);
+}
+
+static int ffa_device_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+	uuid_t *dev_id = &to_ffa_dev(dev)->uuid;
+
+	return add_uevent_var(env, "MODALIAS=arm_ffa:%pUb", dev_id);
+}
+
+struct bus_type ffa_bus_type = {
+	.name		= "arm_ffa",
+	.match		= ffa_device_match,
+	.probe		= ffa_device_probe,
+	.uevent		= ffa_device_uevent,
+};
+EXPORT_SYMBOL_GPL(ffa_bus_type);
+
+int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
+			const char *mod_name)
+{
+	int ret;
+
+	driver->driver.bus = &ffa_bus_type;
+	driver->driver.name = driver->name;
+	driver->driver.owner = owner;
+	driver->driver.mod_name = mod_name;
+
+	ret = driver_register(&driver->driver);
+	if (!ret)
+		pr_debug("registered new ffa driver %s\n", driver->name);
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(ffa_driver_register);
+
+void ffa_driver_unregister(struct ffa_driver *driver)
+{
+	driver_unregister(&driver->driver);
+}
+EXPORT_SYMBOL_GPL(ffa_driver_unregister);
+
+static void ffa_release_device(struct device *dev)
+{
+	struct ffa_device *ffa_dev = to_ffa_dev(dev);
+
+	kfree(ffa_dev);
+}
+
+static int __ffa_devices_unregister(struct device *dev, void *data)
+{
+	ffa_release_device(dev);
+
+	return 0;
+}
+
+static void ffa_devices_unregister(void)
+{
+	bus_for_each_dev(&ffa_bus_type, NULL, NULL,
+			 __ffa_devices_unregister);
+}
+
+struct ffa_device *ffa_device_register(const char *name, int vm_id)
+{
+	int ret;
+	struct device *dev;
+	struct ffa_device *ffa_dev;
+	uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	ffa_dev = kzalloc(sizeof(*ffa_dev), GFP_KERNEL);
+	if (!ffa_dev)
+		return NULL;
+
+	dev = &ffa_dev->dev;
+	dev->bus = &ffa_bus_type;
+	dev->release = ffa_release_device;
+	dev_set_name(&ffa_dev->dev, name);
+
+	ffa_dev->vm_id = vm_id;
+	if (uuid_parse(name, &uuid)) {
+		dev_err(dev, "invalid uuid (%s)\n", name);
+		kfree(ffa_dev);
+		return NULL;
+	}
+
+	uuid_copy(&ffa_dev->uuid, &uuid);
+
+	ret = device_register(&ffa_dev->dev);
+	if (ret) {
+		dev_err(dev, "unable to register device %s err=%d\n",
+			dev_name(dev), ret);
+		put_device(dev);
+		return NULL;
+	}
+
+	return ffa_dev;
+}
+EXPORT_SYMBOL_GPL(ffa_device_register);
+
+void ffa_device_unregister(struct ffa_device *ffa_dev)
+{
+	if (!ffa_dev)
+		return;
+
+	device_unregister(&ffa_dev->dev);
+}
+EXPORT_SYMBOL_GPL(ffa_device_unregister);
+
+bool ffa_device_is_valid(struct ffa_device *ffa_dev)
+{
+	bool valid = false;
+	struct device *dev;
+	struct ffa_device *tmp_dev;
+
+	do {
+		dev = bus_find_next_device(&ffa_bus_type, NULL);
+		tmp_dev = to_ffa_dev(dev);
+		if (tmp_dev == ffa_dev) {
+			valid = true;
+			break;
+		}
+		put_device(dev);
+	} while (dev);
+
+	put_device(dev);
+
+	return valid;
+}
+
+static int __init arm_ffa_bus_init(void)
+{
+	return bus_register(&ffa_bus_type);
+}
+module_init(arm_ffa_bus_init);
+
+static void __exit arm_ffa_bus_exit(void)
+{
+	ffa_devices_unregister();
+	bus_unregister(&ffa_bus_type);
+}
+
+module_exit(arm_ffa_bus_exit);
+
+MODULE_ALIAS("arm-ffa-bus");
+MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
+MODULE_DESCRIPTION("Arm FF-A bus driver");
+MODULE_LICENSE("GPL v2");
diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
new file mode 100644
index 000000000000..3defddfb40fc
--- /dev/null
+++ b/include/linux/arm_ffa.h
@@ -0,0 +1,87 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2020 ARM Ltd.
+ */
+
+#ifndef _LINUX_ARM_FFA_H
+#define _LINUX_ARM_FFA_H
+
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/uuid.h>
+
+/* FFA Bus/Device/Driver related */
+struct ffa_device {
+	int vm_id;
+	uuid_t uuid;
+	struct device dev;
+};
+
+#define to_ffa_dev(d) container_of(d, struct ffa_device, dev)
+
+struct ffa_device_id {
+	uuid_t uuid;
+};
+
+struct ffa_driver {
+	const char *name;
+	int (*probe)(struct ffa_device *sdev);
+	void (*remove)(struct ffa_device *sdev);
+	const struct ffa_device_id *id_table;
+
+	struct device_driver driver;
+};
+
+#define to_ffa_driver(d) container_of(d, struct ffa_driver, driver)
+
+static inline void ffa_dev_set_drvdata(struct ffa_device *fdev, void *data)
+{
+	fdev->dev.driver_data = data;
+}
+
+#if IS_REACHABLE(CONFIG_ARM_FFA_TRANSPORT)
+struct ffa_device *ffa_device_register(const char *name, int vm_id);
+void ffa_device_unregister(struct ffa_device *ffa_dev);
+int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
+			const char *mod_name);
+void ffa_driver_unregister(struct ffa_driver *driver);
+
+#else
+static inline
+struct ffa_device *ffa_device_register(const char *name, int vm_id)
+{
+	return NULL;
+}
+
+static inline void ffa_device_unregister(struct ffa_device *dev) {}
+
+static inline int
+ffa_driver_register(struct ffa_driver *driver, struct module *owner,
+		    const char *mod_name)
+{
+	return -EINVAL;
+}
+
+static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
+
+#endif /* CONFIG_ARM_FFA_TRANSPORT */
+
+#define ffa_register(driver) \
+	ffa_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
+#define ffa_unregister(driver) \
+	ffa_driver_unregister(driver)
+
+/**
+ * module_ffa_driver() - Helper macro for registering a psa_ffa driver
+ * @__ffa_driver: ffa_driver structure
+ *
+ * Helper macro for psa_ffa drivers to set up proper module init / exit
+ * functions.  Replaces module_init() and module_exit() and keeps people from
+ * printing pointless things to the kernel log when their driver is loaded.
+ */
+#define module_ffa_driver(__ffa_driver)	\
+	module_driver(__ffa_driver, ffa_register, ffa_unregister)
+
+#endif /* _LINUX_ARM_FFA_H */
-- 
2.25.1

[PATCH v3 3/7] firmware: arm_ffa: Add initial FFA bus support for device enumeration

[Sudeep Holla]

The Arm FF for Armv8-A specification has concept of endpoints or
partitions. In the Normal world, a partition could be a VM when
the Virtualization extension is enabled or the kernel itself.

In order to handle multiple partitions, we can create a FFA device for
each such partition on a dedicated FFA bus. Similarly, different drivers
requiring FFA transport can be registered on the same bus. We can match
the device and drivers using UUID. This is mostly for the in-kernel
users with FFA drivers.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/Kconfig          |   1 +
 drivers/firmware/Makefile         |   1 +
 drivers/firmware/arm_ffa/Kconfig  |  16 +++
 drivers/firmware/arm_ffa/Makefile |   4 +
 drivers/firmware/arm_ffa/bus.c    | 187 ++++++++++++++++++++++++++++++
 include/linux/arm_ffa.h           |  87 ++++++++++++++
 6 files changed, 296 insertions(+)
 create mode 100644 drivers/firmware/arm_ffa/Kconfig
 create mode 100644 drivers/firmware/arm_ffa/Makefile
 create mode 100644 drivers/firmware/arm_ffa/bus.c
 create mode 100644 include/linux/arm_ffa.h

diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 3315e3c21586..be9056226a07 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -295,6 +295,7 @@ config TURRIS_MOX_RWTM
 	  other manufacturing data and also utilize the Entropy Bit Generator
 	  for hardware random number generation.
 
+source "drivers/firmware/arm_ffa/Kconfig"
 source "drivers/firmware/broadcom/Kconfig"
 source "drivers/firmware/google/Kconfig"
 source "drivers/firmware/efi/Kconfig"
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 5e013b6a3692..546ac8e7f6d0 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_TI_SCI_PROTOCOL)	+= ti_sci.o
 obj-$(CONFIG_TRUSTED_FOUNDATIONS) += trusted_foundations.o
 obj-$(CONFIG_TURRIS_MOX_RWTM)	+= turris-mox-rwtm.o
 
+obj-y				+= arm_ffa/
 obj-y				+= arm_scmi/
 obj-y				+= broadcom/
 obj-y				+= meson/
diff --git a/drivers/firmware/arm_ffa/Kconfig b/drivers/firmware/arm_ffa/Kconfig
new file mode 100644
index 000000000000..261a3660650a
--- /dev/null
+++ b/drivers/firmware/arm_ffa/Kconfig
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: GPL-2.0-only
+config ARM_FFA_TRANSPORT
+	tristate "Arm Firmware Framework for Armv8-A"
+	depends on OF
+	depends on ARM64
+	default n
+	help
+	  This Firmware Framework(FF) for Arm A-profile processors describes
+	  interfaces that standardize communication between the various
+	  software images which includes communication between images in
+	  the Secure world and Normal world. It also leverages the
+	  virtualization extension to isolate software images provided
+	  by an ecosystem of vendors from each other.
+
+	  This driver provides interface for all the client drivers making
+	  use of the features offered by ARM FF-A.
diff --git a/drivers/firmware/arm_ffa/Makefile b/drivers/firmware/arm_ffa/Makefile
new file mode 100644
index 000000000000..bfe4323a8784
--- /dev/null
+++ b/drivers/firmware/arm_ffa/Makefile
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: GPL-2.0-only
+ffa-bus-y = bus.o
+ffa-module-objs := $(ffa-bus-y)
+obj-$(CONFIG_ARM_FFA_TRANSPORT) = ffa-module.o
diff --git a/drivers/firmware/arm_ffa/bus.c b/drivers/firmware/arm_ffa/bus.c
new file mode 100644
index 000000000000..7cd98f22bfe9
--- /dev/null
+++ b/drivers/firmware/arm_ffa/bus.c
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2020 ARM Ltd.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/arm_ffa.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+static int ffa_device_match(struct device *dev, struct device_driver *drv)
+{
+	const struct ffa_device_id *id_table;
+	struct ffa_device *ffa_dev;
+
+	id_table = to_ffa_driver(drv)->id_table;
+	ffa_dev = to_ffa_dev(dev);
+
+	while (!uuid_is_null(&id_table->uuid)) {
+		if (uuid_equal(&ffa_dev->uuid, &id_table->uuid))
+			return 1;
+		id_table++;
+	}
+
+	return 0;
+}
+
+static int ffa_device_probe(struct device *dev)
+{
+	struct ffa_driver *ffa_drv = to_ffa_driver(dev->driver);
+	struct ffa_device *ffa_dev = to_ffa_dev(dev);
+
+	if (!ffa_device_match(dev, dev->driver))
+		return -ENODEV;
+
+	return ffa_drv->probe(ffa_dev);
+}
+
+static int ffa_device_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+	uuid_t *dev_id = &to_ffa_dev(dev)->uuid;
+
+	return add_uevent_var(env, "MODALIAS=arm_ffa:%pUb", dev_id);
+}
+
+struct bus_type ffa_bus_type = {
+	.name		= "arm_ffa",
+	.match		= ffa_device_match,
+	.probe		= ffa_device_probe,
+	.uevent		= ffa_device_uevent,
+};
+EXPORT_SYMBOL_GPL(ffa_bus_type);
+
+int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
+			const char *mod_name)
+{
+	int ret;
+
+	driver->driver.bus = &ffa_bus_type;
+	driver->driver.name = driver->name;
+	driver->driver.owner = owner;
+	driver->driver.mod_name = mod_name;
+
+	ret = driver_register(&driver->driver);
+	if (!ret)
+		pr_debug("registered new ffa driver %s\n", driver->name);
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(ffa_driver_register);
+
+void ffa_driver_unregister(struct ffa_driver *driver)
+{
+	driver_unregister(&driver->driver);
+}
+EXPORT_SYMBOL_GPL(ffa_driver_unregister);
+
+static void ffa_release_device(struct device *dev)
+{
+	struct ffa_device *ffa_dev = to_ffa_dev(dev);
+
+	kfree(ffa_dev);
+}
+
+static int __ffa_devices_unregister(struct device *dev, void *data)
+{
+	ffa_release_device(dev);
+
+	return 0;
+}
+
+static void ffa_devices_unregister(void)
+{
+	bus_for_each_dev(&ffa_bus_type, NULL, NULL,
+			 __ffa_devices_unregister);
+}
+
+struct ffa_device *ffa_device_register(const char *name, int vm_id)
+{
+	int ret;
+	struct device *dev;
+	struct ffa_device *ffa_dev;
+	uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	ffa_dev = kzalloc(sizeof(*ffa_dev), GFP_KERNEL);
+	if (!ffa_dev)
+		return NULL;
+
+	dev = &ffa_dev->dev;
+	dev->bus = &ffa_bus_type;
+	dev->release = ffa_release_device;
+	dev_set_name(&ffa_dev->dev, name);
+
+	ffa_dev->vm_id = vm_id;
+	if (uuid_parse(name, &uuid)) {
+		dev_err(dev, "invalid uuid (%s)\n", name);
+		kfree(ffa_dev);
+		return NULL;
+	}
+
+	uuid_copy(&ffa_dev->uuid, &uuid);
+
+	ret = device_register(&ffa_dev->dev);
+	if (ret) {
+		dev_err(dev, "unable to register device %s err=%d\n",
+			dev_name(dev), ret);
+		put_device(dev);
+		return NULL;
+	}
+
+	return ffa_dev;
+}
+EXPORT_SYMBOL_GPL(ffa_device_register);
+
+void ffa_device_unregister(struct ffa_device *ffa_dev)
+{
+	if (!ffa_dev)
+		return;
+
+	device_unregister(&ffa_dev->dev);
+}
+EXPORT_SYMBOL_GPL(ffa_device_unregister);
+
+bool ffa_device_is_valid(struct ffa_device *ffa_dev)
+{
+	bool valid = false;
+	struct device *dev;
+	struct ffa_device *tmp_dev;
+
+	do {
+		dev = bus_find_next_device(&ffa_bus_type, NULL);
+		tmp_dev = to_ffa_dev(dev);
+		if (tmp_dev == ffa_dev) {
+			valid = true;
+			break;
+		}
+		put_device(dev);
+	} while (dev);
+
+	put_device(dev);
+
+	return valid;
+}
+
+static int __init arm_ffa_bus_init(void)
+{
+	return bus_register(&ffa_bus_type);
+}
+module_init(arm_ffa_bus_init);
+
+static void __exit arm_ffa_bus_exit(void)
+{
+	ffa_devices_unregister();
+	bus_unregister(&ffa_bus_type);
+}
+
+module_exit(arm_ffa_bus_exit);
+
+MODULE_ALIAS("arm-ffa-bus");
+MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
+MODULE_DESCRIPTION("Arm FF-A bus driver");
+MODULE_LICENSE("GPL v2");
diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
new file mode 100644
index 000000000000..3defddfb40fc
--- /dev/null
+++ b/include/linux/arm_ffa.h
@@ -0,0 +1,87 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2020 ARM Ltd.
+ */
+
+#ifndef _LINUX_ARM_FFA_H
+#define _LINUX_ARM_FFA_H
+
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/uuid.h>
+
+/* FFA Bus/Device/Driver related */
+struct ffa_device {
+	int vm_id;
+	uuid_t uuid;
+	struct device dev;
+};
+
+#define to_ffa_dev(d) container_of(d, struct ffa_device, dev)
+
+struct ffa_device_id {
+	uuid_t uuid;
+};
+
+struct ffa_driver {
+	const char *name;
+	int (*probe)(struct ffa_device *sdev);
+	void (*remove)(struct ffa_device *sdev);
+	const struct ffa_device_id *id_table;
+
+	struct device_driver driver;
+};
+
+#define to_ffa_driver(d) container_of(d, struct ffa_driver, driver)
+
+static inline void ffa_dev_set_drvdata(struct ffa_device *fdev, void *data)
+{
+	fdev->dev.driver_data = data;
+}
+
+#if IS_REACHABLE(CONFIG_ARM_FFA_TRANSPORT)
+struct ffa_device *ffa_device_register(const char *name, int vm_id);
+void ffa_device_unregister(struct ffa_device *ffa_dev);
+int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
+			const char *mod_name);
+void ffa_driver_unregister(struct ffa_driver *driver);
+
+#else
+static inline
+struct ffa_device *ffa_device_register(const char *name, int vm_id)
+{
+	return NULL;
+}
+
+static inline void ffa_device_unregister(struct ffa_device *dev) {}
+
+static inline int
+ffa_driver_register(struct ffa_driver *driver, struct module *owner,
+		    const char *mod_name)
+{
+	return -EINVAL;
+}
+
+static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
+
+#endif /* CONFIG_ARM_FFA_TRANSPORT */
+
+#define ffa_register(driver) \
+	ffa_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
+#define ffa_unregister(driver) \
+	ffa_driver_unregister(driver)
+
+/**
+ * module_ffa_driver() - Helper macro for registering a psa_ffa driver
+ * @__ffa_driver: ffa_driver structure
+ *
+ * Helper macro for psa_ffa drivers to set up proper module init / exit
+ * functions.  Replaces module_init() and module_exit() and keeps people from
+ * printing pointless things to the kernel log when their driver is loaded.
+ */
+#define module_ffa_driver(__ffa_driver)	\
+	module_driver(__ffa_driver, ffa_register, ffa_unregister)
+
+#endif /* _LINUX_ARM_FFA_H */
-- 
2.25.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v3 4/7] firmware: arm_ffa: Add initial Arm FFA driver support

[Sudeep Holla]

This just add a basic driver that sets up the transport(e.g. SMCCC),
checks the FFA version implemented, get the partition ID for self and
sets up the Tx/Rx buffers for communication.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/arm_ffa/Makefile |   3 +-
 drivers/firmware/arm_ffa/bus.c    |  12 +-
 drivers/firmware/arm_ffa/common.h |  26 +++
 drivers/firmware/arm_ffa/driver.c | 294 ++++++++++++++++++++++++++++++
 4 files changed, 324 insertions(+), 11 deletions(-)
 create mode 100644 drivers/firmware/arm_ffa/common.h
 create mode 100644 drivers/firmware/arm_ffa/driver.c

diff --git a/drivers/firmware/arm_ffa/Makefile b/drivers/firmware/arm_ffa/Makefile
index bfe4323a8784..82d0d35c5324 100644
--- a/drivers/firmware/arm_ffa/Makefile
+++ b/drivers/firmware/arm_ffa/Makefile
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0-only
 ffa-bus-y = bus.o
-ffa-module-objs := $(ffa-bus-y)
+ffa-driver-y = driver.o
+ffa-module-objs := $(ffa-bus-y) $(ffa-driver-y)
 obj-$(CONFIG_ARM_FFA_TRANSPORT) = ffa-module.o
diff --git a/drivers/firmware/arm_ffa/bus.c b/drivers/firmware/arm_ffa/bus.c
index 7cd98f22bfe9..acc82ae969b9 100644
--- a/drivers/firmware/arm_ffa/bus.c
+++ b/drivers/firmware/arm_ffa/bus.c
@@ -167,21 +167,13 @@ bool ffa_device_is_valid(struct ffa_device *ffa_dev)
 	return valid;
 }
 
-static int __init arm_ffa_bus_init(void)
+int __init arm_ffa_bus_init(void)
 {
 	return bus_register(&ffa_bus_type);
 }
-module_init(arm_ffa_bus_init);
 
-static void __exit arm_ffa_bus_exit(void)
+void __exit arm_ffa_bus_exit(void)
 {
 	ffa_devices_unregister();
 	bus_unregister(&ffa_bus_type);
 }
-
-module_exit(arm_ffa_bus_exit);
-
-MODULE_ALIAS("arm-ffa-bus");
-MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
-MODULE_DESCRIPTION("Arm FF-A bus driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
new file mode 100644
index 000000000000..fc6948efe9f3
--- /dev/null
+++ b/drivers/firmware/arm_ffa/common.h
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2020 ARM Ltd.
+ */
+
+#ifndef _FFA_COMMON_H
+#define _FFA_COMMON_H
+
+#include <linux/arm-smccc.h>
+#include <linux/err.h>
+
+typedef struct arm_smccc_v1_2_res ffa_res_t;
+
+typedef ffa_res_t
+(ffa_fn)(unsigned long, unsigned long, unsigned long, unsigned long,
+	 unsigned long, unsigned long, unsigned long, unsigned long);
+
+int __init arm_ffa_bus_init(void);
+void __exit arm_ffa_bus_exit(void);
+
+static inline int __init ffa_transport_init(ffa_fn **invoke_ffa_fn)
+{
+	return -EOPNOTSUPP;
+}
+
+#endif /* _FFA_COMMON_H */
diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
new file mode 100644
index 000000000000..257b331d781c
--- /dev/null
+++ b/drivers/firmware/arm_ffa/driver.c
@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Arm Firmware Framework for ARMv8-A(FFA) interface driver
+ *
+ * The Arm FFA specification[1] describes a software architecture to
+ * leverages the virtualization extension to isolate software images
+ * provided by an ecosystem of vendors from each other and describes
+ * interfaces that standardize communication between the various software
+ * images including communication between images in the Secure world and
+ * Normal world. Any Hypervisor could use the FFA interfaces to enable
+ * communication between VMs it manages.
+ *
+ * The Hypervisor a.k.a Partition managers in FFA terminology can assign
+ * system resources(Memory regions, Devices, CPU cycles) to the partitions
+ * and manage isolation amongst them.
+ *
+ * [1] https://developer.arm.com/docs/den0077/latest
+ *
+ * Copyright (C) 2020 Arm Ltd.
+ */
+
+#define DRIVER_NAME "ARM FF-A"
+#define pr_fmt(fmt) DRIVER_NAME ": " fmt
+
+#include <linux/arm_ffa.h>
+#include <linux/bitfield.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include "common.h"
+
+#define FFA_DRIVER_VERSION	FFA_VERSION_1_0
+
+#define FFA_SMC(calling_convention, func_num)				\
+	ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, (calling_convention),	\
+			   ARM_SMCCC_OWNER_STANDARD, (func_num))
+
+#define FFA_SMC_32(func_num)	FFA_SMC(ARM_SMCCC_SMC_32, (func_num))
+#define FFA_SMC_64(func_num)	FFA_SMC(ARM_SMCCC_SMC_64, (func_num))
+
+#define FFA_ERROR			FFA_SMC_32(0x60)
+#define FFA_SUCCESS			FFA_SMC_32(0x61)
+#define FFA_INTERRUPT			FFA_SMC_32(0x62)
+#define FFA_VERSION			FFA_SMC_32(0x63)
+#define FFA_FEATURES			FFA_SMC_32(0x64)
+#define FFA_RX_RELEASE			FFA_SMC_32(0x65)
+#define FFA_RXTX_MAP			FFA_SMC_32(0x66)
+#define FFA_RXTX_UNMAP			FFA_SMC_32(0x67)
+#define FFA_PARTITION_INFO_GET		FFA_SMC_32(0x68)
+#define FFA_ID_GET			FFA_SMC_32(0x69)
+#define FFA_MSG_POLL			FFA_SMC_32(0x6A)
+#define FFA_MSG_WAIT			FFA_SMC_32(0x6B)
+#define FFA_YIELD			FFA_SMC_32(0x6C)
+#define FFA_RUN				FFA_SMC_32(0x6D)
+#define FFA_MSG_SEND			FFA_SMC_32(0x6E)
+#define FFA_MSG_SEND_DIRECT_REQ		FFA_SMC_32(0x6F)
+#define FFA_FN64_MSG_SEND_DIRECT_REQ	FFA_SMC_64(0x6F)
+#define FFA_MSG_SEND_DIRECT_RESP	FFA_SMC_32(0x70)
+#define FFA_FN64_MSG_SEND_DIRECT_RESP	FFA_SMC_64(0x70)
+#define FFA_MEM_DONATE			FFA_SMC_32(0x71)
+#define FFA_FN64_MEM_DONATE		FFA_SMC_32(0x71)
+#define FFA_MEM_LEND			FFA_SMC_32(0x72)
+#define FFA_FN64_MEM_LEND		FFA_SMC_32(0x72)
+#define FFA_MEM_SHARE			FFA_SMC_32(0x73)
+#define FFA_FN64_MEM_SHARE		FFA_SMC_64(0x73)
+#define FFA_MEM_RETRIEVE_REQ		FFA_SMC_32(0x74)
+#define FFA_FN64_MEM_RETRIEVE_REQ	FFA_SMC_64(0x74)
+#define FFA_MEM_RETRIEVE_RESP		FFA_SMC_32(0x75)
+#define FFA_MEM_RELINQUISH		FFA_SMC_32(0x76)
+#define FFA_MEM_RECLAIM			FFA_SMC_32(0x77)
+#define FFA_MEM_OP_PAUSE		FFA_SMC_32(0x78)
+#define FFA_MEM_OP_RESUME		FFA_SMC_32(0x79)
+#define FFA_MEM_FRAG_RX			FFA_SMC_32(0x7A)
+#define FFA_MEM_FRAG_TX			FFA_SMC_32(0x7B)
+#define FFA_NORMAL_WORLD_RESUME		FFA_SMC_32(0x7C)
+
+/*
+ * For some calls it is necessary to use SMC64 to pass or return 64-bit values.
+ * For such calls FFA_FN_NATIVE(name) will choose the appropriate
+ * (native-width) function ID.
+ */
+#ifdef CONFIG_64BIT
+#define FFA_FN_NATIVE(name)	FFA_FN64_##name
+#else
+#define FFA_FN_NATIVE(name)	FFA_##name
+#endif
+
+/* FFA error codes. */
+#define FFA_RET_SUCCESS            (0)
+#define FFA_RET_NOT_SUPPORTED      (-1)
+#define FFA_RET_INVALID_PARAMETERS (-2)
+#define FFA_RET_NO_MEMORY          (-3)
+#define FFA_RET_BUSY               (-4)
+#define FFA_RET_INTERRUPTED        (-5)
+#define FFA_RET_DENIED             (-6)
+#define FFA_RET_RETRY              (-7)
+#define FFA_RET_ABORTED            (-8)
+
+#define MAJOR_VERSION_MASK	GENMASK(30, 16)
+#define MINOR_VERSION_MASK	GENMASK(15, 0)
+#define MAJOR_VERSION(x)	(u16)(FIELD_GET(MAJOR_VERSION_MASK, (x)))
+#define MINOR_VERSION(x)	(u16)(FIELD_GET(MINOR_VERSION_MASK, (x)))
+#define PACK_VERSION_INFO(major, minor)			\
+	(FIELD_PREP(MAJOR_VERSION_MASK, (major)) |	\
+	 FIELD_PREP(MINOR_VERSION_MASK, (minor)))
+#define FFA_VERSION_1_0		PACK_VERSION_INFO(1, 0)
+#define FFA_MIN_VERSION		FFA_VERSION_1_0
+
+#define SENDER_ID_MASK		GENMASK(31, 16)
+#define RECEIVER_ID_MASK	GENMASK(15, 0)
+#define SENDER_ID(x)		(u16)(FIELD_GET(SENDER_ID_MASK, (x)))
+#define RECEIVER_ID(x)		(u16)(FIELD_GET(RECEIVER_ID_MASK, (x)))
+#define PACK_TARGET_INFO(s, r)		\
+	(FIELD_PREP(SENDER_ID_MASK, (s)) | FIELD_PREP(RECEIVER_ID_MASK, (r)))
+
+/**
+ * FF-A specification mentions explicitly about '4K pages'. This should
+ * not be confused with the kernel PAGE_SIZE, which is the translation
+ * granule kernel is configured and may be one among 4K, 16K and 64K.
+ */
+#define FFA_PAGE_SIZE		SZ_4K
+/* Keeping RX TX buffer size as 64K for now */
+#define RXTX_BUFFER_SIZE	SZ_64K
+
+static ffa_fn *invoke_ffa_fn;
+
+static const int ffa_linux_errmap[] = {
+	/* better than switch case as long as return value is continuous */
+	0,		/* FFA_RET_SUCCESS */
+	-EOPNOTSUPP,	/* FFA_RET_NOT_SUPPORTED */
+	-EINVAL,	/* FFA_RET_INVALID_PARAMETERS */
+	-ENOMEM,	/* FFA_RET_NO_MEMORY */
+	-EBUSY,		/* FFA_RET_BUSY */
+	-EINTR,		/* FFA_RET_INTERRUPTED */
+	-EACCES,	/* FFA_RET_DENIED */
+	-EAGAIN,	/* FFA_RET_RETRY */
+	-ECANCELED,	/* FFA_RET_ABORTED */
+};
+
+static inline int ffa_to_linux_errno(int errno)
+{
+	if (errno < FFA_RET_SUCCESS && errno >= -ARRAY_SIZE(ffa_linux_errmap))
+		return ffa_linux_errmap[-errno];
+	return -EINVAL;
+}
+
+struct ffa_drv_info {
+	u32 version;
+	u16 vm_id;
+	struct mutex rx_lock; /* lock to protect Rx buffer */
+	struct mutex tx_lock; /* lock to protect Tx buffer */
+	void *rx_buffer;
+	void *tx_buffer;
+};
+
+static struct ffa_drv_info *drv_info;
+
+static int ffa_version_check(u32 *version)
+{
+	ffa_res_t ver;
+
+	ver = invoke_ffa_fn(FFA_VERSION, FFA_DRIVER_VERSION, 0, 0, 0, 0, 0, 0);
+
+	if (ver.a0 == FFA_RET_NOT_SUPPORTED) {
+		pr_info("FFA_VERSION returned not supported\n");
+		return -EOPNOTSUPP;
+	}
+
+	if (ver.a0 < FFA_MIN_VERSION || ver.a0 > FFA_DRIVER_VERSION) {
+		pr_err("Incompatible version %d.%d found\n",
+		       MAJOR_VERSION(ver.a0), MINOR_VERSION(ver.a0));
+		return -EINVAL;
+	}
+
+	*version = ver.a0;
+	pr_info("Version %d.%d found\n", MAJOR_VERSION(ver.a0),
+		MINOR_VERSION(ver.a0));
+	return 0;
+}
+
+static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_RXTX_MAP, tx_buf, rx_buf, pg_cnt, 0, 0, 0, 0);
+
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	return 0;
+}
+
+static int ffa_rxtx_unmap(u16 vm_id)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_RXTX_UNMAP, vm_id, 0, 0, 0, 0, 0, 0);
+
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	return 0;
+}
+
+#define VM_ID_MASK	GENMASK(15, 0)
+static int ffa_id_get(u16 *vm_id)
+{
+	ffa_res_t id;
+
+	id = invoke_ffa_fn(FFA_ID_GET, 0, 0, 0, 0, 0, 0, 0);
+
+	if (id.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)id.a2);
+
+	*vm_id = FIELD_GET(VM_ID_MASK, (id.a2));
+
+	return 0;
+}
+
+static int __init ffa_init(void)
+{
+	int ret;
+
+	ret = arm_ffa_bus_init();
+	if (ret)
+		return ret;
+
+	ret = ffa_transport_init(&invoke_ffa_fn);
+	if (ret)
+		return ret;
+
+	drv_info = kzalloc(sizeof(*drv_info), GFP_KERNEL);
+	if (!drv_info)
+		return -ENOMEM;
+
+	ret = ffa_version_check(&drv_info->version);
+	if (ret)
+		goto free_drv_info;
+
+	if (ffa_id_get(&drv_info->vm_id)) {
+		pr_err("failed to obtain VM id for self\n");
+		ret = -ENODEV;
+		goto free_drv_info;
+	}
+
+	drv_info->rx_buffer = alloc_pages_exact(RXTX_BUFFER_SIZE, GFP_KERNEL);
+	if (!drv_info->rx_buffer) {
+		ret = -ENOMEM;
+		goto free_pages;
+	}
+
+	drv_info->tx_buffer = alloc_pages_exact(RXTX_BUFFER_SIZE, GFP_KERNEL);
+	if (!drv_info->tx_buffer) {
+		ret = -ENOMEM;
+		goto free_pages;
+	}
+
+	ret = ffa_rxtx_map(virt_to_phys(drv_info->tx_buffer),
+			   virt_to_phys(drv_info->rx_buffer),
+			   RXTX_BUFFER_SIZE / FFA_PAGE_SIZE);
+	if (ret) {
+		pr_err("failed to register FFA RxTx buffers\n");
+		goto free_pages;
+	}
+
+	mutex_init(&drv_info->rx_lock);
+	mutex_init(&drv_info->tx_lock);
+
+	return 0;
+free_pages:
+	if (drv_info->tx_buffer)
+		free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE);
+	free_pages_exact(drv_info->rx_buffer, RXTX_BUFFER_SIZE);
+free_drv_info:
+	kfree(drv_info);
+	return ret;
+}
+module_init(ffa_init);
+
+static void __exit ffa_exit(void)
+{
+	ffa_rxtx_unmap(drv_info->vm_id);
+	free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE);
+	free_pages_exact(drv_info->rx_buffer, RXTX_BUFFER_SIZE);
+	kfree(drv_info);
+	arm_ffa_bus_exit();
+}
+module_exit(ffa_exit);
+
+MODULE_ALIAS("arm-ffa");
+MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
+MODULE_DESCRIPTION("Arm FF-A interface driver");
+MODULE_LICENSE("GPL v2");
-- 
2.25.1

[PATCH v3 4/7] firmware: arm_ffa: Add initial Arm FFA driver support

[Sudeep Holla]

This just add a basic driver that sets up the transport(e.g. SMCCC),
checks the FFA version implemented, get the partition ID for self and
sets up the Tx/Rx buffers for communication.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/arm_ffa/Makefile |   3 +-
 drivers/firmware/arm_ffa/bus.c    |  12 +-
 drivers/firmware/arm_ffa/common.h |  26 +++
 drivers/firmware/arm_ffa/driver.c | 294 ++++++++++++++++++++++++++++++
 4 files changed, 324 insertions(+), 11 deletions(-)
 create mode 100644 drivers/firmware/arm_ffa/common.h
 create mode 100644 drivers/firmware/arm_ffa/driver.c

diff --git a/drivers/firmware/arm_ffa/Makefile b/drivers/firmware/arm_ffa/Makefile
index bfe4323a8784..82d0d35c5324 100644
--- a/drivers/firmware/arm_ffa/Makefile
+++ b/drivers/firmware/arm_ffa/Makefile
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0-only
 ffa-bus-y = bus.o
-ffa-module-objs := $(ffa-bus-y)
+ffa-driver-y = driver.o
+ffa-module-objs := $(ffa-bus-y) $(ffa-driver-y)
 obj-$(CONFIG_ARM_FFA_TRANSPORT) = ffa-module.o
diff --git a/drivers/firmware/arm_ffa/bus.c b/drivers/firmware/arm_ffa/bus.c
index 7cd98f22bfe9..acc82ae969b9 100644
--- a/drivers/firmware/arm_ffa/bus.c
+++ b/drivers/firmware/arm_ffa/bus.c
@@ -167,21 +167,13 @@ bool ffa_device_is_valid(struct ffa_device *ffa_dev)
 	return valid;
 }
 
-static int __init arm_ffa_bus_init(void)
+int __init arm_ffa_bus_init(void)
 {
 	return bus_register(&ffa_bus_type);
 }
-module_init(arm_ffa_bus_init);
 
-static void __exit arm_ffa_bus_exit(void)
+void __exit arm_ffa_bus_exit(void)
 {
 	ffa_devices_unregister();
 	bus_unregister(&ffa_bus_type);
 }
-
-module_exit(arm_ffa_bus_exit);
-
-MODULE_ALIAS("arm-ffa-bus");
-MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
-MODULE_DESCRIPTION("Arm FF-A bus driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
new file mode 100644
index 000000000000..fc6948efe9f3
--- /dev/null
+++ b/drivers/firmware/arm_ffa/common.h
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2020 ARM Ltd.
+ */
+
+#ifndef _FFA_COMMON_H
+#define _FFA_COMMON_H
+
+#include <linux/arm-smccc.h>
+#include <linux/err.h>
+
+typedef struct arm_smccc_v1_2_res ffa_res_t;
+
+typedef ffa_res_t
+(ffa_fn)(unsigned long, unsigned long, unsigned long, unsigned long,
+	 unsigned long, unsigned long, unsigned long, unsigned long);
+
+int __init arm_ffa_bus_init(void);
+void __exit arm_ffa_bus_exit(void);
+
+static inline int __init ffa_transport_init(ffa_fn **invoke_ffa_fn)
+{
+	return -EOPNOTSUPP;
+}
+
+#endif /* _FFA_COMMON_H */
diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
new file mode 100644
index 000000000000..257b331d781c
--- /dev/null
+++ b/drivers/firmware/arm_ffa/driver.c
@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Arm Firmware Framework for ARMv8-A(FFA) interface driver
+ *
+ * The Arm FFA specification[1] describes a software architecture to
+ * leverages the virtualization extension to isolate software images
+ * provided by an ecosystem of vendors from each other and describes
+ * interfaces that standardize communication between the various software
+ * images including communication between images in the Secure world and
+ * Normal world. Any Hypervisor could use the FFA interfaces to enable
+ * communication between VMs it manages.
+ *
+ * The Hypervisor a.k.a Partition managers in FFA terminology can assign
+ * system resources(Memory regions, Devices, CPU cycles) to the partitions
+ * and manage isolation amongst them.
+ *
+ * [1] https://developer.arm.com/docs/den0077/latest
+ *
+ * Copyright (C) 2020 Arm Ltd.
+ */
+
+#define DRIVER_NAME "ARM FF-A"
+#define pr_fmt(fmt) DRIVER_NAME ": " fmt
+
+#include <linux/arm_ffa.h>
+#include <linux/bitfield.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include "common.h"
+
+#define FFA_DRIVER_VERSION	FFA_VERSION_1_0
+
+#define FFA_SMC(calling_convention, func_num)				\
+	ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, (calling_convention),	\
+			   ARM_SMCCC_OWNER_STANDARD, (func_num))
+
+#define FFA_SMC_32(func_num)	FFA_SMC(ARM_SMCCC_SMC_32, (func_num))
+#define FFA_SMC_64(func_num)	FFA_SMC(ARM_SMCCC_SMC_64, (func_num))
+
+#define FFA_ERROR			FFA_SMC_32(0x60)
+#define FFA_SUCCESS			FFA_SMC_32(0x61)
+#define FFA_INTERRUPT			FFA_SMC_32(0x62)
+#define FFA_VERSION			FFA_SMC_32(0x63)
+#define FFA_FEATURES			FFA_SMC_32(0x64)
+#define FFA_RX_RELEASE			FFA_SMC_32(0x65)
+#define FFA_RXTX_MAP			FFA_SMC_32(0x66)
+#define FFA_RXTX_UNMAP			FFA_SMC_32(0x67)
+#define FFA_PARTITION_INFO_GET		FFA_SMC_32(0x68)
+#define FFA_ID_GET			FFA_SMC_32(0x69)
+#define FFA_MSG_POLL			FFA_SMC_32(0x6A)
+#define FFA_MSG_WAIT			FFA_SMC_32(0x6B)
+#define FFA_YIELD			FFA_SMC_32(0x6C)
+#define FFA_RUN				FFA_SMC_32(0x6D)
+#define FFA_MSG_SEND			FFA_SMC_32(0x6E)
+#define FFA_MSG_SEND_DIRECT_REQ		FFA_SMC_32(0x6F)
+#define FFA_FN64_MSG_SEND_DIRECT_REQ	FFA_SMC_64(0x6F)
+#define FFA_MSG_SEND_DIRECT_RESP	FFA_SMC_32(0x70)
+#define FFA_FN64_MSG_SEND_DIRECT_RESP	FFA_SMC_64(0x70)
+#define FFA_MEM_DONATE			FFA_SMC_32(0x71)
+#define FFA_FN64_MEM_DONATE		FFA_SMC_32(0x71)
+#define FFA_MEM_LEND			FFA_SMC_32(0x72)
+#define FFA_FN64_MEM_LEND		FFA_SMC_32(0x72)
+#define FFA_MEM_SHARE			FFA_SMC_32(0x73)
+#define FFA_FN64_MEM_SHARE		FFA_SMC_64(0x73)
+#define FFA_MEM_RETRIEVE_REQ		FFA_SMC_32(0x74)
+#define FFA_FN64_MEM_RETRIEVE_REQ	FFA_SMC_64(0x74)
+#define FFA_MEM_RETRIEVE_RESP		FFA_SMC_32(0x75)
+#define FFA_MEM_RELINQUISH		FFA_SMC_32(0x76)
+#define FFA_MEM_RECLAIM			FFA_SMC_32(0x77)
+#define FFA_MEM_OP_PAUSE		FFA_SMC_32(0x78)
+#define FFA_MEM_OP_RESUME		FFA_SMC_32(0x79)
+#define FFA_MEM_FRAG_RX			FFA_SMC_32(0x7A)
+#define FFA_MEM_FRAG_TX			FFA_SMC_32(0x7B)
+#define FFA_NORMAL_WORLD_RESUME		FFA_SMC_32(0x7C)
+
+/*
+ * For some calls it is necessary to use SMC64 to pass or return 64-bit values.
+ * For such calls FFA_FN_NATIVE(name) will choose the appropriate
+ * (native-width) function ID.
+ */
+#ifdef CONFIG_64BIT
+#define FFA_FN_NATIVE(name)	FFA_FN64_##name
+#else
+#define FFA_FN_NATIVE(name)	FFA_##name
+#endif
+
+/* FFA error codes. */
+#define FFA_RET_SUCCESS            (0)
+#define FFA_RET_NOT_SUPPORTED      (-1)
+#define FFA_RET_INVALID_PARAMETERS (-2)
+#define FFA_RET_NO_MEMORY          (-3)
+#define FFA_RET_BUSY               (-4)
+#define FFA_RET_INTERRUPTED        (-5)
+#define FFA_RET_DENIED             (-6)
+#define FFA_RET_RETRY              (-7)
+#define FFA_RET_ABORTED            (-8)
+
+#define MAJOR_VERSION_MASK	GENMASK(30, 16)
+#define MINOR_VERSION_MASK	GENMASK(15, 0)
+#define MAJOR_VERSION(x)	(u16)(FIELD_GET(MAJOR_VERSION_MASK, (x)))
+#define MINOR_VERSION(x)	(u16)(FIELD_GET(MINOR_VERSION_MASK, (x)))
+#define PACK_VERSION_INFO(major, minor)			\
+	(FIELD_PREP(MAJOR_VERSION_MASK, (major)) |	\
+	 FIELD_PREP(MINOR_VERSION_MASK, (minor)))
+#define FFA_VERSION_1_0		PACK_VERSION_INFO(1, 0)
+#define FFA_MIN_VERSION		FFA_VERSION_1_0
+
+#define SENDER_ID_MASK		GENMASK(31, 16)
+#define RECEIVER_ID_MASK	GENMASK(15, 0)
+#define SENDER_ID(x)		(u16)(FIELD_GET(SENDER_ID_MASK, (x)))
+#define RECEIVER_ID(x)		(u16)(FIELD_GET(RECEIVER_ID_MASK, (x)))
+#define PACK_TARGET_INFO(s, r)		\
+	(FIELD_PREP(SENDER_ID_MASK, (s)) | FIELD_PREP(RECEIVER_ID_MASK, (r)))
+
+/**
+ * FF-A specification mentions explicitly about '4K pages'. This should
+ * not be confused with the kernel PAGE_SIZE, which is the translation
+ * granule kernel is configured and may be one among 4K, 16K and 64K.
+ */
+#define FFA_PAGE_SIZE		SZ_4K
+/* Keeping RX TX buffer size as 64K for now */
+#define RXTX_BUFFER_SIZE	SZ_64K
+
+static ffa_fn *invoke_ffa_fn;
+
+static const int ffa_linux_errmap[] = {
+	/* better than switch case as long as return value is continuous */
+	0,		/* FFA_RET_SUCCESS */
+	-EOPNOTSUPP,	/* FFA_RET_NOT_SUPPORTED */
+	-EINVAL,	/* FFA_RET_INVALID_PARAMETERS */
+	-ENOMEM,	/* FFA_RET_NO_MEMORY */
+	-EBUSY,		/* FFA_RET_BUSY */
+	-EINTR,		/* FFA_RET_INTERRUPTED */
+	-EACCES,	/* FFA_RET_DENIED */
+	-EAGAIN,	/* FFA_RET_RETRY */
+	-ECANCELED,	/* FFA_RET_ABORTED */
+};
+
+static inline int ffa_to_linux_errno(int errno)
+{
+	if (errno < FFA_RET_SUCCESS && errno >= -ARRAY_SIZE(ffa_linux_errmap))
+		return ffa_linux_errmap[-errno];
+	return -EINVAL;
+}
+
+struct ffa_drv_info {
+	u32 version;
+	u16 vm_id;
+	struct mutex rx_lock; /* lock to protect Rx buffer */
+	struct mutex tx_lock; /* lock to protect Tx buffer */
+	void *rx_buffer;
+	void *tx_buffer;
+};
+
+static struct ffa_drv_info *drv_info;
+
+static int ffa_version_check(u32 *version)
+{
+	ffa_res_t ver;
+
+	ver = invoke_ffa_fn(FFA_VERSION, FFA_DRIVER_VERSION, 0, 0, 0, 0, 0, 0);
+
+	if (ver.a0 == FFA_RET_NOT_SUPPORTED) {
+		pr_info("FFA_VERSION returned not supported\n");
+		return -EOPNOTSUPP;
+	}
+
+	if (ver.a0 < FFA_MIN_VERSION || ver.a0 > FFA_DRIVER_VERSION) {
+		pr_err("Incompatible version %d.%d found\n",
+		       MAJOR_VERSION(ver.a0), MINOR_VERSION(ver.a0));
+		return -EINVAL;
+	}
+
+	*version = ver.a0;
+	pr_info("Version %d.%d found\n", MAJOR_VERSION(ver.a0),
+		MINOR_VERSION(ver.a0));
+	return 0;
+}
+
+static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_RXTX_MAP, tx_buf, rx_buf, pg_cnt, 0, 0, 0, 0);
+
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	return 0;
+}
+
+static int ffa_rxtx_unmap(u16 vm_id)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_RXTX_UNMAP, vm_id, 0, 0, 0, 0, 0, 0);
+
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	return 0;
+}
+
+#define VM_ID_MASK	GENMASK(15, 0)
+static int ffa_id_get(u16 *vm_id)
+{
+	ffa_res_t id;
+
+	id = invoke_ffa_fn(FFA_ID_GET, 0, 0, 0, 0, 0, 0, 0);
+
+	if (id.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)id.a2);
+
+	*vm_id = FIELD_GET(VM_ID_MASK, (id.a2));
+
+	return 0;
+}
+
+static int __init ffa_init(void)
+{
+	int ret;
+
+	ret = arm_ffa_bus_init();
+	if (ret)
+		return ret;
+
+	ret = ffa_transport_init(&invoke_ffa_fn);
+	if (ret)
+		return ret;
+
+	drv_info = kzalloc(sizeof(*drv_info), GFP_KERNEL);
+	if (!drv_info)
+		return -ENOMEM;
+
+	ret = ffa_version_check(&drv_info->version);
+	if (ret)
+		goto free_drv_info;
+
+	if (ffa_id_get(&drv_info->vm_id)) {
+		pr_err("failed to obtain VM id for self\n");
+		ret = -ENODEV;
+		goto free_drv_info;
+	}
+
+	drv_info->rx_buffer = alloc_pages_exact(RXTX_BUFFER_SIZE, GFP_KERNEL);
+	if (!drv_info->rx_buffer) {
+		ret = -ENOMEM;
+		goto free_pages;
+	}
+
+	drv_info->tx_buffer = alloc_pages_exact(RXTX_BUFFER_SIZE, GFP_KERNEL);
+	if (!drv_info->tx_buffer) {
+		ret = -ENOMEM;
+		goto free_pages;
+	}
+
+	ret = ffa_rxtx_map(virt_to_phys(drv_info->tx_buffer),
+			   virt_to_phys(drv_info->rx_buffer),
+			   RXTX_BUFFER_SIZE / FFA_PAGE_SIZE);
+	if (ret) {
+		pr_err("failed to register FFA RxTx buffers\n");
+		goto free_pages;
+	}
+
+	mutex_init(&drv_info->rx_lock);
+	mutex_init(&drv_info->tx_lock);
+
+	return 0;
+free_pages:
+	if (drv_info->tx_buffer)
+		free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE);
+	free_pages_exact(drv_info->rx_buffer, RXTX_BUFFER_SIZE);
+free_drv_info:
+	kfree(drv_info);
+	return ret;
+}
+module_init(ffa_init);
+
+static void __exit ffa_exit(void)
+{
+	ffa_rxtx_unmap(drv_info->vm_id);
+	free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE);
+	free_pages_exact(drv_info->rx_buffer, RXTX_BUFFER_SIZE);
+	kfree(drv_info);
+	arm_ffa_bus_exit();
+}
+module_exit(ffa_exit);
+
+MODULE_ALIAS("arm-ffa");
+MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
+MODULE_DESCRIPTION("Arm FF-A interface driver");
+MODULE_LICENSE("GPL v2");
-- 
2.25.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v3 5/7] firmware: arm_ffa: Add support for SMCCC as transport to FFA driver

[Sudeep Holla]

There are requests to keep the transport separate in order to allow
other possible transports like virtio. So let us keep the SMCCC transport
specific routines abstracted.

It is kept simple for now. Once we add another transport, we can develop
better abstraction.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/arm_ffa/Kconfig  |  5 +++
 drivers/firmware/arm_ffa/Makefile |  3 +-
 drivers/firmware/arm_ffa/common.h |  4 +++
 drivers/firmware/arm_ffa/smccc.c  | 54 +++++++++++++++++++++++++++++++
 4 files changed, 65 insertions(+), 1 deletion(-)
 create mode 100644 drivers/firmware/arm_ffa/smccc.c

diff --git a/drivers/firmware/arm_ffa/Kconfig b/drivers/firmware/arm_ffa/Kconfig
index 261a3660650a..5e3ae5cf82e8 100644
--- a/drivers/firmware/arm_ffa/Kconfig
+++ b/drivers/firmware/arm_ffa/Kconfig
@@ -14,3 +14,8 @@ config ARM_FFA_TRANSPORT
 
 	  This driver provides interface for all the client drivers making
 	  use of the features offered by ARM FF-A.
+
+config ARM_FFA_SMCCC
+	bool
+	default ARM_FFA_TRANSPORT
+	depends on ARM64 && HAVE_ARM_SMCCC_DISCOVERY
diff --git a/drivers/firmware/arm_ffa/Makefile b/drivers/firmware/arm_ffa/Makefile
index 82d0d35c5324..9d9f37523200 100644
--- a/drivers/firmware/arm_ffa/Makefile
+++ b/drivers/firmware/arm_ffa/Makefile
@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: GPL-2.0-only
 ffa-bus-y = bus.o
 ffa-driver-y = driver.o
-ffa-module-objs := $(ffa-bus-y) $(ffa-driver-y)
+ffa-transport-$(CONFIG_ARM_FFA_SMCCC) += smccc.o
+ffa-module-objs := $(ffa-bus-y) $(ffa-driver-y) $(ffa-transport-y)
 obj-$(CONFIG_ARM_FFA_TRANSPORT) = ffa-module.o
diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
index fc6948efe9f3..d019348bf67d 100644
--- a/drivers/firmware/arm_ffa/common.h
+++ b/drivers/firmware/arm_ffa/common.h
@@ -18,9 +18,13 @@ typedef ffa_res_t
 int __init arm_ffa_bus_init(void);
 void __exit arm_ffa_bus_exit(void);
 
+#ifdef CONFIG_ARM_FFA_SMCCC
+int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
+#else
 static inline int __init ffa_transport_init(ffa_fn **invoke_ffa_fn)
 {
 	return -EOPNOTSUPP;
 }
+#endif
 
 #endif /* _FFA_COMMON_H */
diff --git a/drivers/firmware/arm_ffa/smccc.c b/drivers/firmware/arm_ffa/smccc.c
new file mode 100644
index 000000000000..b93d281d2399
--- /dev/null
+++ b/drivers/firmware/arm_ffa/smccc.c
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2020 ARM Ltd.
+ */
+
+#include <linux/printk.h>
+
+#include "common.h"
+
+static struct arm_smccc_v1_2_res
+__arm_ffa_fn_smc(unsigned long function_id, unsigned long arg0,
+		 unsigned long arg1, unsigned long arg2, unsigned long arg3,
+		 unsigned long arg4, unsigned long arg5, unsigned long arg6)
+{
+	struct arm_smccc_v1_2_res res;
+
+	arm_smccc_v1_2_smc(function_id, arg0, arg1, arg2, arg3, arg4, arg5,
+			   arg6, &res);
+
+	return res;
+}
+
+static struct arm_smccc_v1_2_res
+__arm_ffa_fn_hvc(unsigned long function_id, unsigned long arg0,
+		 unsigned long arg1, unsigned long arg2, unsigned long arg3,
+		 unsigned long arg4, unsigned long arg5, unsigned long arg6)
+{
+	struct arm_smccc_v1_2_res res;
+
+	arm_smccc_v1_2_hvc(function_id, arg0, arg1, arg2, arg3, arg4, arg5,
+			   arg6, &res);
+	return res;
+}
+
+int __init ffa_transport_init(ffa_fn **invoke_ffa_fn)
+{
+	enum arm_smccc_conduit conduit;
+
+	if (arm_smccc_get_version() < ARM_SMCCC_VERSION_1_2)
+		return -EOPNOTSUPP;
+
+	conduit = arm_smccc_1_1_get_conduit();
+	if (conduit == SMCCC_CONDUIT_NONE) {
+		pr_err("%s: invalid SMCCC conduit\n", __func__);
+		return -EOPNOTSUPP;
+	}
+
+	if (conduit == SMCCC_CONDUIT_SMC)
+		*invoke_ffa_fn = __arm_ffa_fn_smc;
+	else
+		*invoke_ffa_fn = __arm_ffa_fn_hvc;
+
+	return 0;
+}
-- 
2.25.1

[PATCH v3 5/7] firmware: arm_ffa: Add support for SMCCC as transport to FFA driver

[Sudeep Holla]

There are requests to keep the transport separate in order to allow
other possible transports like virtio. So let us keep the SMCCC transport
specific routines abstracted.

It is kept simple for now. Once we add another transport, we can develop
better abstraction.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/arm_ffa/Kconfig  |  5 +++
 drivers/firmware/arm_ffa/Makefile |  3 +-
 drivers/firmware/arm_ffa/common.h |  4 +++
 drivers/firmware/arm_ffa/smccc.c  | 54 +++++++++++++++++++++++++++++++
 4 files changed, 65 insertions(+), 1 deletion(-)
 create mode 100644 drivers/firmware/arm_ffa/smccc.c

diff --git a/drivers/firmware/arm_ffa/Kconfig b/drivers/firmware/arm_ffa/Kconfig
index 261a3660650a..5e3ae5cf82e8 100644
--- a/drivers/firmware/arm_ffa/Kconfig
+++ b/drivers/firmware/arm_ffa/Kconfig
@@ -14,3 +14,8 @@ config ARM_FFA_TRANSPORT
 
 	  This driver provides interface for all the client drivers making
 	  use of the features offered by ARM FF-A.
+
+config ARM_FFA_SMCCC
+	bool
+	default ARM_FFA_TRANSPORT
+	depends on ARM64 && HAVE_ARM_SMCCC_DISCOVERY
diff --git a/drivers/firmware/arm_ffa/Makefile b/drivers/firmware/arm_ffa/Makefile
index 82d0d35c5324..9d9f37523200 100644
--- a/drivers/firmware/arm_ffa/Makefile
+++ b/drivers/firmware/arm_ffa/Makefile
@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: GPL-2.0-only
 ffa-bus-y = bus.o
 ffa-driver-y = driver.o
-ffa-module-objs := $(ffa-bus-y) $(ffa-driver-y)
+ffa-transport-$(CONFIG_ARM_FFA_SMCCC) += smccc.o
+ffa-module-objs := $(ffa-bus-y) $(ffa-driver-y) $(ffa-transport-y)
 obj-$(CONFIG_ARM_FFA_TRANSPORT) = ffa-module.o
diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
index fc6948efe9f3..d019348bf67d 100644
--- a/drivers/firmware/arm_ffa/common.h
+++ b/drivers/firmware/arm_ffa/common.h
@@ -18,9 +18,13 @@ typedef ffa_res_t
 int __init arm_ffa_bus_init(void);
 void __exit arm_ffa_bus_exit(void);
 
+#ifdef CONFIG_ARM_FFA_SMCCC
+int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
+#else
 static inline int __init ffa_transport_init(ffa_fn **invoke_ffa_fn)
 {
 	return -EOPNOTSUPP;
 }
+#endif
 
 #endif /* _FFA_COMMON_H */
diff --git a/drivers/firmware/arm_ffa/smccc.c b/drivers/firmware/arm_ffa/smccc.c
new file mode 100644
index 000000000000..b93d281d2399
--- /dev/null
+++ b/drivers/firmware/arm_ffa/smccc.c
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2020 ARM Ltd.
+ */
+
+#include <linux/printk.h>
+
+#include "common.h"
+
+static struct arm_smccc_v1_2_res
+__arm_ffa_fn_smc(unsigned long function_id, unsigned long arg0,
+		 unsigned long arg1, unsigned long arg2, unsigned long arg3,
+		 unsigned long arg4, unsigned long arg5, unsigned long arg6)
+{
+	struct arm_smccc_v1_2_res res;
+
+	arm_smccc_v1_2_smc(function_id, arg0, arg1, arg2, arg3, arg4, arg5,
+			   arg6, &res);
+
+	return res;
+}
+
+static struct arm_smccc_v1_2_res
+__arm_ffa_fn_hvc(unsigned long function_id, unsigned long arg0,
+		 unsigned long arg1, unsigned long arg2, unsigned long arg3,
+		 unsigned long arg4, unsigned long arg5, unsigned long arg6)
+{
+	struct arm_smccc_v1_2_res res;
+
+	arm_smccc_v1_2_hvc(function_id, arg0, arg1, arg2, arg3, arg4, arg5,
+			   arg6, &res);
+	return res;
+}
+
+int __init ffa_transport_init(ffa_fn **invoke_ffa_fn)
+{
+	enum arm_smccc_conduit conduit;
+
+	if (arm_smccc_get_version() < ARM_SMCCC_VERSION_1_2)
+		return -EOPNOTSUPP;
+
+	conduit = arm_smccc_1_1_get_conduit();
+	if (conduit == SMCCC_CONDUIT_NONE) {
+		pr_err("%s: invalid SMCCC conduit\n", __func__);
+		return -EOPNOTSUPP;
+	}
+
+	if (conduit == SMCCC_CONDUIT_SMC)
+		*invoke_ffa_fn = __arm_ffa_fn_smc;
+	else
+		*invoke_ffa_fn = __arm_ffa_fn_hvc;
+
+	return 0;
+}
-- 
2.25.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

Parse the FFA nodes from the device-tree and register all the partitions
whose services will be used in the kernel.

In order to also enable in-kernel users of FFA interface, let us add
simple set of operations for such devices.

The in-kernel users are registered without the character device interface.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/arm_ffa/common.h |   2 +
 drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
 include/linux/arm_ffa.h           |  36 +++++-
 3 files changed, 223 insertions(+), 1 deletion(-)

diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
index d019348bf67d..eb1371c2b2b8 100644
--- a/drivers/firmware/arm_ffa/common.h
+++ b/drivers/firmware/arm_ffa/common.h
@@ -6,6 +6,7 @@
 #ifndef _FFA_COMMON_H
 #define _FFA_COMMON_H
 
+#include <linux/arm_ffa.h>
 #include <linux/arm-smccc.h>
 #include <linux/err.h>
 
@@ -17,6 +18,7 @@ typedef ffa_res_t
 
 int __init arm_ffa_bus_init(void);
 void __exit arm_ffa_bus_exit(void);
+bool ffa_device_is_valid(struct ffa_device *ffa_dev);
 
 #ifdef CONFIG_ARM_FFA_SMCCC
 int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
index 257b331d781c..3e4ba841dbf8 100644
--- a/drivers/firmware/arm_ffa/driver.c
+++ b/drivers/firmware/arm_ffa/driver.c
@@ -24,9 +24,13 @@
 
 #include <linux/arm_ffa.h>
 #include <linux/bitfield.h>
+#include <linux/device.h>
 #include <linux/io.h>
+#include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/of.h>
 #include <linux/slab.h>
+#include <linux/uuid.h>
 
 #include "common.h"
 
@@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
 	return 0;
 }
 
+static int ffa_rx_release(void)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
+
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	/* check for ret.a0 == FFA_RX_RELEASE ? */
+
+	return 0;
+}
+
 static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
 {
 	ffa_res_t ret;
@@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
 	return 0;
 }
 
+static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
+				    struct ffa_partition_info **buffer)
+{
+	int count;
+	ffa_res_t partition_info;
+
+	mutex_lock(&drv_info->rx_lock);
+	partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
+				       uuid2, uuid3, 0, 0, 0);
+
+	if (partition_info.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)partition_info.a2);
+
+	count = partition_info.a2;
+
+	if (buffer)
+		memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
+
+	ffa_rx_release();
+
+	mutex_unlock(&drv_info->rx_lock);
+
+	return count;
+}
+
+static int ffa_partition_probe(const char *uuid_str,
+			       struct ffa_partition_info *buffer)
+{
+	int count;
+	uuid_t uuid;
+	u32 uuid0_4[4] = { 0 };
+
+	if (uuid_parse(uuid_str, &uuid)) {
+		pr_err("invalid uuid (%s)\n", uuid_str);
+		return -ENODEV;
+	}
+
+	export_uuid((u8 *)uuid0_4, &uuid);
+	count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
+					 uuid0_4[3], &buffer);
+
+	return count;
+}
+
 #define VM_ID_MASK	GENMASK(15, 0)
 static int ffa_id_get(u16 *vm_id)
 {
@@ -218,9 +280,125 @@ static int ffa_id_get(u16 *vm_id)
 	return 0;
 }
 
+static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
+				   struct ffa_send_direct_data *data)
+{
+	u32 src_dst_ids = PACK_TARGET_INFO(src_id, dst_id);
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_FN_NATIVE(MSG_SEND_DIRECT_REQ), src_dst_ids, 0,
+			    data->data0, data->data1, data->data2,
+			    data->data3, data->data4);
+
+	while (ret.a0 == FFA_INTERRUPT)
+		ret = invoke_ffa_fn(FFA_RUN, ret.a1, 0, 0, 0, 0, 0, 0);
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	if (ret.a0 == FFA_FN_NATIVE(MSG_SEND_DIRECT_RESP)) {
+		data->data0 = ret.a3;
+		data->data1 = ret.a4;
+		data->data2 = ret.a5;
+		data->data3 = ret.a6;
+		data->data4 = ret.a7;
+	}
+
+	return 0;
+}
+
+static u32 ffa_api_version_get(void)
+{
+	return drv_info->version;
+}
+
+static u16 ffa_partition_id_get(struct ffa_device *dev)
+{
+	return dev->vm_id;
+}
+
+static int ffa_partition_info_get(const char *uuid_str,
+				  struct ffa_partition_info *buffer)
+{
+	if (ffa_partition_probe(uuid_str, buffer) == 1)
+		return 0;
+
+	return -ENOENT;
+}
+
+static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
+				 struct ffa_send_direct_data *data)
+{
+	return ffa_msg_send_direct_req(dev->vm_id, ep, data);
+}
+
+static const struct ffa_dev_ops ffa_ops = {
+	.api_version_get = ffa_api_version_get,
+	.partition_id_get = ffa_partition_id_get,
+	.partition_info_get = ffa_partition_info_get,
+	.sync_send_receive = ffa_sync_send_receive,
+};
+
+const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
+{
+	if (ffa_device_is_valid(dev))
+		return &ffa_ops;
+
+	return NULL;
+}
+EXPORT_SYMBOL_GPL(ffa_dev_ops_get);
+
+int ffa_setup_partitions(struct device_node *np)
+{
+	int ret;
+	struct device_node *child;
+	struct ffa_device *ffa_dev;
+	struct ffa_partition_info pbuf;
+	const char *p_uuid, *pfx = "Ignoring FFA partition";
+	uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	for_each_child_of_node(np, child) {
+		if (!of_device_is_compatible(child, "arm,ffa-1.0-partition")) {
+			of_node_put(child);
+			continue;
+		}
+
+		if (of_property_read_string(child, "uuid", &p_uuid)) {
+			pr_err("%s: failed to parse \"uuid\" property\n", pfx);
+			of_node_put(child);
+			continue;
+		}
+
+		of_node_put(child);
+
+		if (uuid_parse(p_uuid, &uuid)) {
+			pr_err("%s: invalid \"uuid\" property (%s)\n",
+			       pfx, p_uuid);
+			continue;
+		}
+
+		ret = ffa_partition_probe(p_uuid, &pbuf);
+		if (ret != 1) {
+			pr_err("%s: %s partition info probe failed\n",
+			       pfx, p_uuid);
+			return -EINVAL;
+		}
+
+		ffa_dev = ffa_device_register(p_uuid, pbuf.id);
+		if (!ffa_dev) {
+			pr_err("%s: failed to register %s\n", pfx, p_uuid);
+			continue;
+		}
+
+		ffa_dev_set_drvdata(ffa_dev, drv_info);
+	}
+
+	return 0;
+}
+
 static int __init ffa_init(void)
 {
 	int ret;
+	struct device_node *np;
 
 	ret = arm_ffa_bus_init();
 	if (ret)
@@ -267,6 +445,14 @@ static int __init ffa_init(void)
 	mutex_init(&drv_info->rx_lock);
 	mutex_init(&drv_info->tx_lock);
 
+	/* Set up all the partitions */
+	np = of_find_compatible_node(NULL, NULL, "arm,ffa-1.0");
+	if (!np)
+		return 0;
+
+	ffa_setup_partitions(np);
+	of_node_put(np);
+
 	return 0;
 free_pages:
 	if (drv_info->tx_buffer)
diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
index 3defddfb40fc..8604c48289ce 100644
--- a/include/linux/arm_ffa.h
+++ b/include/linux/arm_ffa.h
@@ -6,7 +6,6 @@
 #ifndef _LINUX_ARM_FFA_H
 #define _LINUX_ARM_FFA_H
 
-#include <linux/cdev.h>
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/types.h>
@@ -47,6 +46,7 @@ void ffa_device_unregister(struct ffa_device *ffa_dev);
 int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
 			const char *mod_name);
 void ffa_driver_unregister(struct ffa_driver *driver);
+const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev);
 
 #else
 static inline
@@ -66,6 +66,10 @@ ffa_driver_register(struct ffa_driver *driver, struct module *owner,
 
 static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
 
+const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
+{
+	return NULL;
+}
 #endif /* CONFIG_ARM_FFA_TRANSPORT */
 
 #define ffa_register(driver) \
@@ -84,4 +88,34 @@ static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
 #define module_ffa_driver(__ffa_driver)	\
 	module_driver(__ffa_driver, ffa_register, ffa_unregister)
 
+/* FFA transport related */
+struct ffa_partition_info {
+	u16 id;
+	u16 exec_ctxt;
+/* partition supports receipt of direct requests */
+#define FFA_PARTITION_DIRECT_RECV	BIT(0)
+/* partition can send direct requests. */
+#define FFA_PARTITION_DIRECT_SEND	BIT(1)
+/* partition can send and receive indirect messages. */
+#define FFA_PARTITION_INDIRECT_MSG	BIT(2)
+	u32 properties;
+};
+
+struct ffa_send_direct_data {
+	unsigned long data0;
+	unsigned long data1;
+	unsigned long data2;
+	unsigned long data3;
+	unsigned long data4;
+};
+
+struct ffa_dev_ops {
+	u32 (*api_version_get)(void);
+	u16 (*partition_id_get)(struct ffa_device *dev);
+	int (*partition_info_get)(const char *uuid_str,
+				  struct ffa_partition_info *buffer);
+	int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
+				 struct ffa_send_direct_data *data);
+};
+
 #endif /* _LINUX_ARM_FFA_H */
-- 
2.25.1

[PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

Parse the FFA nodes from the device-tree and register all the partitions
whose services will be used in the kernel.

In order to also enable in-kernel users of FFA interface, let us add
simple set of operations for such devices.

The in-kernel users are registered without the character device interface.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/arm_ffa/common.h |   2 +
 drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
 include/linux/arm_ffa.h           |  36 +++++-
 3 files changed, 223 insertions(+), 1 deletion(-)

diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
index d019348bf67d..eb1371c2b2b8 100644
--- a/drivers/firmware/arm_ffa/common.h
+++ b/drivers/firmware/arm_ffa/common.h
@@ -6,6 +6,7 @@
 #ifndef _FFA_COMMON_H
 #define _FFA_COMMON_H
 
+#include <linux/arm_ffa.h>
 #include <linux/arm-smccc.h>
 #include <linux/err.h>
 
@@ -17,6 +18,7 @@ typedef ffa_res_t
 
 int __init arm_ffa_bus_init(void);
 void __exit arm_ffa_bus_exit(void);
+bool ffa_device_is_valid(struct ffa_device *ffa_dev);
 
 #ifdef CONFIG_ARM_FFA_SMCCC
 int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
index 257b331d781c..3e4ba841dbf8 100644
--- a/drivers/firmware/arm_ffa/driver.c
+++ b/drivers/firmware/arm_ffa/driver.c
@@ -24,9 +24,13 @@
 
 #include <linux/arm_ffa.h>
 #include <linux/bitfield.h>
+#include <linux/device.h>
 #include <linux/io.h>
+#include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/of.h>
 #include <linux/slab.h>
+#include <linux/uuid.h>
 
 #include "common.h"
 
@@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
 	return 0;
 }
 
+static int ffa_rx_release(void)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
+
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	/* check for ret.a0 == FFA_RX_RELEASE ? */
+
+	return 0;
+}
+
 static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
 {
 	ffa_res_t ret;
@@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
 	return 0;
 }
 
+static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
+				    struct ffa_partition_info **buffer)
+{
+	int count;
+	ffa_res_t partition_info;
+
+	mutex_lock(&drv_info->rx_lock);
+	partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
+				       uuid2, uuid3, 0, 0, 0);
+
+	if (partition_info.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)partition_info.a2);
+
+	count = partition_info.a2;
+
+	if (buffer)
+		memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
+
+	ffa_rx_release();
+
+	mutex_unlock(&drv_info->rx_lock);
+
+	return count;
+}
+
+static int ffa_partition_probe(const char *uuid_str,
+			       struct ffa_partition_info *buffer)
+{
+	int count;
+	uuid_t uuid;
+	u32 uuid0_4[4] = { 0 };
+
+	if (uuid_parse(uuid_str, &uuid)) {
+		pr_err("invalid uuid (%s)\n", uuid_str);
+		return -ENODEV;
+	}
+
+	export_uuid((u8 *)uuid0_4, &uuid);
+	count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
+					 uuid0_4[3], &buffer);
+
+	return count;
+}
+
 #define VM_ID_MASK	GENMASK(15, 0)
 static int ffa_id_get(u16 *vm_id)
 {
@@ -218,9 +280,125 @@ static int ffa_id_get(u16 *vm_id)
 	return 0;
 }
 
+static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
+				   struct ffa_send_direct_data *data)
+{
+	u32 src_dst_ids = PACK_TARGET_INFO(src_id, dst_id);
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_FN_NATIVE(MSG_SEND_DIRECT_REQ), src_dst_ids, 0,
+			    data->data0, data->data1, data->data2,
+			    data->data3, data->data4);
+
+	while (ret.a0 == FFA_INTERRUPT)
+		ret = invoke_ffa_fn(FFA_RUN, ret.a1, 0, 0, 0, 0, 0, 0);
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	if (ret.a0 == FFA_FN_NATIVE(MSG_SEND_DIRECT_RESP)) {
+		data->data0 = ret.a3;
+		data->data1 = ret.a4;
+		data->data2 = ret.a5;
+		data->data3 = ret.a6;
+		data->data4 = ret.a7;
+	}
+
+	return 0;
+}
+
+static u32 ffa_api_version_get(void)
+{
+	return drv_info->version;
+}
+
+static u16 ffa_partition_id_get(struct ffa_device *dev)
+{
+	return dev->vm_id;
+}
+
+static int ffa_partition_info_get(const char *uuid_str,
+				  struct ffa_partition_info *buffer)
+{
+	if (ffa_partition_probe(uuid_str, buffer) == 1)
+		return 0;
+
+	return -ENOENT;
+}
+
+static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
+				 struct ffa_send_direct_data *data)
+{
+	return ffa_msg_send_direct_req(dev->vm_id, ep, data);
+}
+
+static const struct ffa_dev_ops ffa_ops = {
+	.api_version_get = ffa_api_version_get,
+	.partition_id_get = ffa_partition_id_get,
+	.partition_info_get = ffa_partition_info_get,
+	.sync_send_receive = ffa_sync_send_receive,
+};
+
+const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
+{
+	if (ffa_device_is_valid(dev))
+		return &ffa_ops;
+
+	return NULL;
+}
+EXPORT_SYMBOL_GPL(ffa_dev_ops_get);
+
+int ffa_setup_partitions(struct device_node *np)
+{
+	int ret;
+	struct device_node *child;
+	struct ffa_device *ffa_dev;
+	struct ffa_partition_info pbuf;
+	const char *p_uuid, *pfx = "Ignoring FFA partition";
+	uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	for_each_child_of_node(np, child) {
+		if (!of_device_is_compatible(child, "arm,ffa-1.0-partition")) {
+			of_node_put(child);
+			continue;
+		}
+
+		if (of_property_read_string(child, "uuid", &p_uuid)) {
+			pr_err("%s: failed to parse \"uuid\" property\n", pfx);
+			of_node_put(child);
+			continue;
+		}
+
+		of_node_put(child);
+
+		if (uuid_parse(p_uuid, &uuid)) {
+			pr_err("%s: invalid \"uuid\" property (%s)\n",
+			       pfx, p_uuid);
+			continue;
+		}
+
+		ret = ffa_partition_probe(p_uuid, &pbuf);
+		if (ret != 1) {
+			pr_err("%s: %s partition info probe failed\n",
+			       pfx, p_uuid);
+			return -EINVAL;
+		}
+
+		ffa_dev = ffa_device_register(p_uuid, pbuf.id);
+		if (!ffa_dev) {
+			pr_err("%s: failed to register %s\n", pfx, p_uuid);
+			continue;
+		}
+
+		ffa_dev_set_drvdata(ffa_dev, drv_info);
+	}
+
+	return 0;
+}
+
 static int __init ffa_init(void)
 {
 	int ret;
+	struct device_node *np;
 
 	ret = arm_ffa_bus_init();
 	if (ret)
@@ -267,6 +445,14 @@ static int __init ffa_init(void)
 	mutex_init(&drv_info->rx_lock);
 	mutex_init(&drv_info->tx_lock);
 
+	/* Set up all the partitions */
+	np = of_find_compatible_node(NULL, NULL, "arm,ffa-1.0");
+	if (!np)
+		return 0;
+
+	ffa_setup_partitions(np);
+	of_node_put(np);
+
 	return 0;
 free_pages:
 	if (drv_info->tx_buffer)
diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
index 3defddfb40fc..8604c48289ce 100644
--- a/include/linux/arm_ffa.h
+++ b/include/linux/arm_ffa.h
@@ -6,7 +6,6 @@
 #ifndef _LINUX_ARM_FFA_H
 #define _LINUX_ARM_FFA_H
 
-#include <linux/cdev.h>
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/types.h>
@@ -47,6 +46,7 @@ void ffa_device_unregister(struct ffa_device *ffa_dev);
 int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
 			const char *mod_name);
 void ffa_driver_unregister(struct ffa_driver *driver);
+const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev);
 
 #else
 static inline
@@ -66,6 +66,10 @@ ffa_driver_register(struct ffa_driver *driver, struct module *owner,
 
 static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
 
+const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
+{
+	return NULL;
+}
 #endif /* CONFIG_ARM_FFA_TRANSPORT */
 
 #define ffa_register(driver) \
@@ -84,4 +88,34 @@ static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
 #define module_ffa_driver(__ffa_driver)	\
 	module_driver(__ffa_driver, ffa_register, ffa_unregister)
 
+/* FFA transport related */
+struct ffa_partition_info {
+	u16 id;
+	u16 exec_ctxt;
+/* partition supports receipt of direct requests */
+#define FFA_PARTITION_DIRECT_RECV	BIT(0)
+/* partition can send direct requests. */
+#define FFA_PARTITION_DIRECT_SEND	BIT(1)
+/* partition can send and receive indirect messages. */
+#define FFA_PARTITION_INDIRECT_MSG	BIT(2)
+	u32 properties;
+};
+
+struct ffa_send_direct_data {
+	unsigned long data0;
+	unsigned long data1;
+	unsigned long data2;
+	unsigned long data3;
+	unsigned long data4;
+};
+
+struct ffa_dev_ops {
+	u32 (*api_version_get)(void);
+	u16 (*partition_id_get)(struct ffa_device *dev);
+	int (*partition_info_get)(const char *uuid_str,
+				  struct ffa_partition_info *buffer);
+	int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
+				 struct ffa_send_direct_data *data);
+};
+
 #endif /* _LINUX_ARM_FFA_H */
-- 
2.25.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[PATCH v3 7/7] firmware: arm_ffa: Add support for MEM_* interfaces

[Sudeep Holla]

Most of the MEM_* APIs share the same parameters, so they can be
generalised. Currently only MEM_SHARE is implemented and the user space
interface for that is not added yet.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/arm_ffa/driver.c | 180 ++++++++++++++++++++++++++++++
 include/linux/arm_ffa.h           | 149 +++++++++++++++++++++++++
 2 files changed, 329 insertions(+)

diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
index 3e4ba841dbf8..92a0bf542f18 100644
--- a/drivers/firmware/arm_ffa/driver.c
+++ b/drivers/firmware/arm_ffa/driver.c
@@ -28,7 +28,9 @@
 #include <linux/io.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/mm.h>
 #include <linux/of.h>
+#include <linux/scatterlist.h>
 #include <linux/slab.h>
 #include <linux/uuid.h>
 
@@ -306,6 +308,177 @@ static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
 	return 0;
 }
 
+static int ffa_mem_first_frag(u32 func_id, phys_addr_t buf, u32 buf_sz,
+			      u32 frag_len, u32 len, u64 *handle)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(func_id, len, frag_len, buf, buf_sz, 0, 0, 0);
+
+	while (ret.a0 == FFA_MEM_OP_PAUSE)
+		ret = invoke_ffa_fn(FFA_MEM_OP_RESUME, ret.a1, ret.a2,
+				    0, 0, 0, 0, 0);
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	if (ret.a0 != FFA_SUCCESS)
+		return -EOPNOTSUPP;
+
+	if (handle)
+		*handle = PACK_HANDLE(ret.a3, ret.a2);
+
+	return frag_len;
+}
+
+static int ffa_mem_next_frag(u64 handle, u32 frag_len)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_MEM_FRAG_TX, HANDLE_LOW(handle),
+			    HANDLE_HIGH(handle), frag_len, 0, 0, 0, 0);
+
+	while (ret.a0 == FFA_MEM_OP_PAUSE)
+		ret = invoke_ffa_fn(FFA_MEM_OP_RESUME, ret.a1, ret.a2,
+				    0, 0, 0, 0, 0);
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	if (ret.a0 != FFA_MEM_FRAG_RX)
+		return -EOPNOTSUPP;
+
+	return ret.a3;
+}
+
+static int
+ffa_transmit_fragment(u32 func_id, phys_addr_t buf, u32 buf_sz, u32 frag_len,
+		      u32 len, u64 *handle, bool first)
+{
+	if (!first)
+		return ffa_mem_next_frag(*handle, frag_len);
+
+	return ffa_mem_first_frag(func_id, buf, buf_sz, frag_len,
+				      len, handle);
+}
+
+static u32 ffa_get_num_pages_sg(struct scatterlist *sg)
+{
+	u32 num_pages = 0;
+
+	do {
+		num_pages += sg->length / FFA_PAGE_SIZE;
+	} while ((sg = sg_next(sg)));
+
+	return num_pages;
+}
+
+static int
+ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize,
+		       struct ffa_mem_ops_args *args)
+{
+	int rc = 0;
+	bool first = true;
+	phys_addr_t addr = 0;
+	struct ffa_composite_mem_region *composite;
+	struct ffa_mem_region_addr_range *constituents;
+	struct ffa_mem_region_attributes *ep_mem_access;
+	struct ffa_mem_region *mem_region = buffer;
+	u32 idx, frag_len, length, num_entries = sg_nents(args->sg);
+	u32 buf_sz = max_fragsize / FFA_PAGE_SIZE;
+
+	mem_region->tag = args->tag;
+	mem_region->flags = args->flags;
+	mem_region->sender_id = drv_info->vm_id;
+	mem_region->attributes = FFA_MEM_NORMAL | FFA_MEM_WRITE_BACK |
+				 FFA_MEM_INNER_SHAREABLE;
+	ep_mem_access = &mem_region->ep_mem_access[0];
+
+	for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) {
+		ep_mem_access->receiver = args->attrs[idx].receiver;
+		ep_mem_access->attrs = args->attrs[idx].attrs;
+		ep_mem_access->composite_off = COMPOSITE_OFFSET(args->nattrs);
+	}
+	mem_region->ep_count = args->nattrs;
+
+	composite = buffer + COMPOSITE_OFFSET(args->nattrs);
+	composite->total_pg_cnt = ffa_get_num_pages_sg(args->sg);
+	composite->addr_range_cnt = num_entries;
+
+	length = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, num_entries);
+	frag_len = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, 0);
+	if (frag_len > max_fragsize)
+		return -ENXIO;
+
+	if (!args->use_txbuf)
+		addr = virt_to_phys(buffer);
+
+	constituents = buffer + frag_len;
+	idx = 0;
+	do {
+		if (frag_len == max_fragsize) {
+			rc = ffa_transmit_fragment(func_id, addr, buf_sz,
+						   frag_len, length,
+						   args->g_handle, first);
+			if (rc < 0)
+				return -ENXIO;
+
+			first = false;
+			idx = 0;
+			frag_len = 0;
+			constituents = buffer;
+		}
+
+		if ((void *)constituents - buffer > max_fragsize) {
+			pr_err("Memory Region Fragment > Tx Buffer size\n");
+			return -EFAULT;
+		}
+
+		constituents->address = sg_phys(args->sg);
+		constituents->pg_cnt = args->sg->length / FFA_PAGE_SIZE;
+		constituents++;
+		frag_len += sizeof(struct ffa_mem_region_addr_range);
+	} while ((args->sg = sg_next(args->sg)));
+
+	return ffa_transmit_fragment(func_id, addr, buf_sz, frag_len,
+				     length, args->g_handle, first);
+}
+
+static int ffa_memory_ops(u32 func_id, struct ffa_mem_ops_args *args)
+{
+	int ret;
+	void *buffer;
+
+	if (!args->use_txbuf) {
+		buffer = alloc_pages_exact(RXTX_BUFFER_SIZE, GFP_KERNEL);
+		if (!buffer)
+			return -ENOMEM;
+	} else {
+		buffer = drv_info->tx_buffer;
+		mutex_lock(&drv_info->tx_lock);
+	}
+
+	ret = ffa_setup_and_transmit(func_id, buffer, RXTX_BUFFER_SIZE, args);
+
+	if (args->use_txbuf)
+		mutex_unlock(&drv_info->tx_lock);
+	else
+		free_pages_exact(buffer, RXTX_BUFFER_SIZE);
+
+	return ret < 0 ? ret : 0;
+}
+
+static int ffa_memory_reclaim(u64 g_handle, u32 flags)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_MEM_RECLAIM, HANDLE_LOW(g_handle),
+			    HANDLE_HIGH(g_handle), flags, 0, 0, 0, 0);
+
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	return 0;
+}
+
 static u32 ffa_api_version_get(void)
 {
 	return drv_info->version;
@@ -331,11 +504,18 @@ static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
 	return ffa_msg_send_direct_req(dev->vm_id, ep, data);
 }
 
+static int ffa_memory_share(struct ffa_mem_ops_args *args)
+{
+	return ffa_memory_ops(FFA_FN_NATIVE(MEM_SHARE), args);
+}
+
 static const struct ffa_dev_ops ffa_ops = {
 	.api_version_get = ffa_api_version_get,
 	.partition_id_get = ffa_partition_id_get,
 	.partition_info_get = ffa_partition_info_get,
 	.sync_send_receive = ffa_sync_send_receive,
+	.memory_reclaim = ffa_memory_reclaim,
+	.memory_share = ffa_memory_share,
 };
 
 const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
index 8604c48289ce..67e3180e7097 100644
--- a/include/linux/arm_ffa.h
+++ b/include/linux/arm_ffa.h
@@ -109,6 +109,153 @@ struct ffa_send_direct_data {
 	unsigned long data4;
 };
 
+struct ffa_mem_region_addr_range {
+	/* The base IPA of the constituent memory region, aligned to 4 kiB */
+	u64 address;
+	/* The number of 4 kiB pages in the constituent memory region. */
+	u32 pg_cnt;
+	u32 reserved;
+};
+
+struct ffa_composite_mem_region {
+	/*
+	 * The total number of 4 kiB pages included in this memory region. This
+	 * must be equal to the sum of page counts specified in each
+	 * `struct ffa_mem_region_addr_range`.
+	 */
+	u32 total_pg_cnt;
+	/* The number of constituents included in this memory region range */
+	u32 addr_range_cnt;
+	u64 reserved;
+	/** An array of `addr_range_cnt` memory region constituents. */
+	struct ffa_mem_region_addr_range constituents[];
+};
+
+struct ffa_mem_region_attributes {
+	/* The ID of the VM to which the memory is being given or shared. */
+	u16 receiver;
+	/*
+	 * The permissions with which the memory region should be mapped in the
+	 * receiver's page table.
+	 */
+#define FFA_MEM_EXEC	BIT(3)
+#define FFA_MEM_NO_EXEC	BIT(2)
+#define FFA_MEM_RW		BIT(1)
+#define FFA_MEM_RO		BIT(0)
+	u8 attrs;
+	/*
+	 * Flags used during FFA_MEM_RETRIEVE_REQ and FFA_MEM_RETRIEVE_RESP
+	 * for memory regions with multiple borrowers.
+	 */
+#define FFA_MEM_RETRIEVE_SELF_BORROWER	BIT(0)
+	u8 flag;
+	u32 composite_off;
+	/*
+	 * Offset in bytes from the start of the outer `ffa_memory_region` to
+	 * an `struct ffa_mem_region_addr_range`.
+	 */
+	u64 reserved;
+};
+
+struct ffa_mem_region {
+	/* The ID of the VM/owner which originally sent the memory region */
+	u16 sender_id;
+#define FFA_MEM_NORMAL		BIT(5)
+#define FFA_MEM_DEVICE		BIT(4)
+
+#define FFA_MEM_WRITE_BACK	(3 << 2)
+#define FFA_MEM_NON_CACHEABLE	(1 << 2)
+
+#define FFA_DEV_nGnRnE		(0 << 2)
+#define FFA_DEV_nGnRE		(1 << 2)
+#define FFA_DEV_nGRE		(2 << 2)
+#define FFA_DEV_GRE		(3 << 2)
+
+#define FFA_MEM_NON_SHAREABLE	(0)
+#define FFA_MEM_OUTER_SHAREABLE	(2)
+#define FFA_MEM_INNER_SHAREABLE	(3)
+	u8 attributes;
+	u8 reserved_0;
+/*
+ * Clear memory region contents after unmapping it from the sender and
+ * before mapping it for any receiver.
+ */
+#define FFA_MEM_CLEAR			BIT(0)
+/*
+ * Whether the hypervisor may time slice the memory sharing or retrieval
+ * operation.
+ */
+#define FFA_TIME_SLICE_ENABLE		BIT(1)
+
+/*
+ * Whether the hypervisor should clear the memory region before the receiver
+ * relinquishes it or is aborted.
+ */
+#define FFA_MEM_CLEAR_BEFORE_RELINQUISH	BIT(0)
+/*
+ * Whether the hypervisor should clear the memory region after the receiver
+ * relinquishes it or is aborted.
+ */
+#define FFA_MEM_CLEAR_AFTER_RELINQUISH	BIT(2)
+
+#define FFA_MEM_RETRIEVE_TYPE_IN_RESP	(0 << 3)
+#define FFA_MEM_RETRIEVE_TYPE_SHARE	(1 << 3)
+#define FFA_MEM_RETRIEVE_TYPE_LEND	(2 << 3)
+#define FFA_MEM_RETRIEVE_TYPE_DONATE	(3 << 3)
+
+#define FFA_MEM_RETRIEVE_ADDR_ALIGN_HINT	BIT(9)
+#define FFA_MEM_RETRIEVE_ADDR_ALIGN(x)		((x) << 5)
+	/* Flags to control behaviour of the transaction. */
+	u32 flags;
+#define HANDLE_LOW_MASK		GENMASK_ULL(31, 0)
+#define HANDLE_HIGH_MASK	GENMASK_ULL(63, 32)
+#define HANDLE_LOW(x)		(u32)(FIELD_GET(HANDLE_LOW_MASK, (x)))
+#define	HANDLE_HIGH(x)		(u32)(FIELD_GET(HANDLE_HIGH_MASK, (x)))
+
+#define PACK_HANDLE(l, h)		\
+	(FIELD_PREP(HANDLE_LOW_MASK, (l)) | FIELD_PREP(HANDLE_HIGH_MASK, (h)))
+	/*
+	 * A globally-unique ID assigned by the hypervisor for a region
+	 * of memory being sent between VMs.
+	 */
+	u64 handle;
+	/*
+	 * An implementation defined value associated with the receiver and the
+	 * memory region.
+	 */
+	u64 tag;
+	u32 reserved_1;
+	/*
+	 * The number of `ffa_mem_region_attributes` entries included in this
+	 * transaction.
+	 */
+	u32 ep_count;
+	/*
+	 * An array of endpoint memory access descriptors.
+	 * Each one specifies a memory region offset, an endpoint and the
+	 * attributes with which this memory region should be mapped in that
+	 * endpoint's page table.
+	 */
+	struct ffa_mem_region_attributes ep_mem_access[];
+};
+
+#define	COMPOSITE_OFFSET(x)	\
+	(offsetof(struct ffa_mem_region, ep_mem_access[x]))
+#define CONSTITUENTS_OFFSET(x)	\
+	(offsetof(struct ffa_composite_mem_region, constituents[x]))
+#define COMPOSITE_CONSTITUENTS_OFFSET(x, y)	\
+	(COMPOSITE_OFFSET(x) + CONSTITUENTS_OFFSET(y))
+
+struct ffa_mem_ops_args {
+	bool use_txbuf;
+	u64 tag;
+	u32 flags;
+	struct ffa_mem_region_attributes *attrs;
+	u32 nattrs;
+	struct scatterlist *sg;
+	u64 *g_handle;
+};
+
 struct ffa_dev_ops {
 	u32 (*api_version_get)(void);
 	u16 (*partition_id_get)(struct ffa_device *dev);
@@ -116,6 +263,8 @@ struct ffa_dev_ops {
 				  struct ffa_partition_info *buffer);
 	int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
 				 struct ffa_send_direct_data *data);
+	int (*memory_reclaim)(u64 g_handle, u32 flags);
+	int (*memory_share)(struct ffa_mem_ops_args *args);
 };
 
 #endif /* _LINUX_ARM_FFA_H */
-- 
2.25.1

[PATCH v3 7/7] firmware: arm_ffa: Add support for MEM_* interfaces

[Sudeep Holla]

Most of the MEM_* APIs share the same parameters, so they can be
generalised. Currently only MEM_SHARE is implemented and the user space
interface for that is not added yet.

Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
---
 drivers/firmware/arm_ffa/driver.c | 180 ++++++++++++++++++++++++++++++
 include/linux/arm_ffa.h           | 149 +++++++++++++++++++++++++
 2 files changed, 329 insertions(+)

diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
index 3e4ba841dbf8..92a0bf542f18 100644
--- a/drivers/firmware/arm_ffa/driver.c
+++ b/drivers/firmware/arm_ffa/driver.c
@@ -28,7 +28,9 @@
 #include <linux/io.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/mm.h>
 #include <linux/of.h>
+#include <linux/scatterlist.h>
 #include <linux/slab.h>
 #include <linux/uuid.h>
 
@@ -306,6 +308,177 @@ static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
 	return 0;
 }
 
+static int ffa_mem_first_frag(u32 func_id, phys_addr_t buf, u32 buf_sz,
+			      u32 frag_len, u32 len, u64 *handle)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(func_id, len, frag_len, buf, buf_sz, 0, 0, 0);
+
+	while (ret.a0 == FFA_MEM_OP_PAUSE)
+		ret = invoke_ffa_fn(FFA_MEM_OP_RESUME, ret.a1, ret.a2,
+				    0, 0, 0, 0, 0);
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	if (ret.a0 != FFA_SUCCESS)
+		return -EOPNOTSUPP;
+
+	if (handle)
+		*handle = PACK_HANDLE(ret.a3, ret.a2);
+
+	return frag_len;
+}
+
+static int ffa_mem_next_frag(u64 handle, u32 frag_len)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_MEM_FRAG_TX, HANDLE_LOW(handle),
+			    HANDLE_HIGH(handle), frag_len, 0, 0, 0, 0);
+
+	while (ret.a0 == FFA_MEM_OP_PAUSE)
+		ret = invoke_ffa_fn(FFA_MEM_OP_RESUME, ret.a1, ret.a2,
+				    0, 0, 0, 0, 0);
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	if (ret.a0 != FFA_MEM_FRAG_RX)
+		return -EOPNOTSUPP;
+
+	return ret.a3;
+}
+
+static int
+ffa_transmit_fragment(u32 func_id, phys_addr_t buf, u32 buf_sz, u32 frag_len,
+		      u32 len, u64 *handle, bool first)
+{
+	if (!first)
+		return ffa_mem_next_frag(*handle, frag_len);
+
+	return ffa_mem_first_frag(func_id, buf, buf_sz, frag_len,
+				      len, handle);
+}
+
+static u32 ffa_get_num_pages_sg(struct scatterlist *sg)
+{
+	u32 num_pages = 0;
+
+	do {
+		num_pages += sg->length / FFA_PAGE_SIZE;
+	} while ((sg = sg_next(sg)));
+
+	return num_pages;
+}
+
+static int
+ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize,
+		       struct ffa_mem_ops_args *args)
+{
+	int rc = 0;
+	bool first = true;
+	phys_addr_t addr = 0;
+	struct ffa_composite_mem_region *composite;
+	struct ffa_mem_region_addr_range *constituents;
+	struct ffa_mem_region_attributes *ep_mem_access;
+	struct ffa_mem_region *mem_region = buffer;
+	u32 idx, frag_len, length, num_entries = sg_nents(args->sg);
+	u32 buf_sz = max_fragsize / FFA_PAGE_SIZE;
+
+	mem_region->tag = args->tag;
+	mem_region->flags = args->flags;
+	mem_region->sender_id = drv_info->vm_id;
+	mem_region->attributes = FFA_MEM_NORMAL | FFA_MEM_WRITE_BACK |
+				 FFA_MEM_INNER_SHAREABLE;
+	ep_mem_access = &mem_region->ep_mem_access[0];
+
+	for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) {
+		ep_mem_access->receiver = args->attrs[idx].receiver;
+		ep_mem_access->attrs = args->attrs[idx].attrs;
+		ep_mem_access->composite_off = COMPOSITE_OFFSET(args->nattrs);
+	}
+	mem_region->ep_count = args->nattrs;
+
+	composite = buffer + COMPOSITE_OFFSET(args->nattrs);
+	composite->total_pg_cnt = ffa_get_num_pages_sg(args->sg);
+	composite->addr_range_cnt = num_entries;
+
+	length = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, num_entries);
+	frag_len = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, 0);
+	if (frag_len > max_fragsize)
+		return -ENXIO;
+
+	if (!args->use_txbuf)
+		addr = virt_to_phys(buffer);
+
+	constituents = buffer + frag_len;
+	idx = 0;
+	do {
+		if (frag_len == max_fragsize) {
+			rc = ffa_transmit_fragment(func_id, addr, buf_sz,
+						   frag_len, length,
+						   args->g_handle, first);
+			if (rc < 0)
+				return -ENXIO;
+
+			first = false;
+			idx = 0;
+			frag_len = 0;
+			constituents = buffer;
+		}
+
+		if ((void *)constituents - buffer > max_fragsize) {
+			pr_err("Memory Region Fragment > Tx Buffer size\n");
+			return -EFAULT;
+		}
+
+		constituents->address = sg_phys(args->sg);
+		constituents->pg_cnt = args->sg->length / FFA_PAGE_SIZE;
+		constituents++;
+		frag_len += sizeof(struct ffa_mem_region_addr_range);
+	} while ((args->sg = sg_next(args->sg)));
+
+	return ffa_transmit_fragment(func_id, addr, buf_sz, frag_len,
+				     length, args->g_handle, first);
+}
+
+static int ffa_memory_ops(u32 func_id, struct ffa_mem_ops_args *args)
+{
+	int ret;
+	void *buffer;
+
+	if (!args->use_txbuf) {
+		buffer = alloc_pages_exact(RXTX_BUFFER_SIZE, GFP_KERNEL);
+		if (!buffer)
+			return -ENOMEM;
+	} else {
+		buffer = drv_info->tx_buffer;
+		mutex_lock(&drv_info->tx_lock);
+	}
+
+	ret = ffa_setup_and_transmit(func_id, buffer, RXTX_BUFFER_SIZE, args);
+
+	if (args->use_txbuf)
+		mutex_unlock(&drv_info->tx_lock);
+	else
+		free_pages_exact(buffer, RXTX_BUFFER_SIZE);
+
+	return ret < 0 ? ret : 0;
+}
+
+static int ffa_memory_reclaim(u64 g_handle, u32 flags)
+{
+	ffa_res_t ret;
+
+	ret = invoke_ffa_fn(FFA_MEM_RECLAIM, HANDLE_LOW(g_handle),
+			    HANDLE_HIGH(g_handle), flags, 0, 0, 0, 0);
+
+	if (ret.a0 == FFA_ERROR)
+		return ffa_to_linux_errno((int)ret.a2);
+
+	return 0;
+}
+
 static u32 ffa_api_version_get(void)
 {
 	return drv_info->version;
@@ -331,11 +504,18 @@ static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
 	return ffa_msg_send_direct_req(dev->vm_id, ep, data);
 }
 
+static int ffa_memory_share(struct ffa_mem_ops_args *args)
+{
+	return ffa_memory_ops(FFA_FN_NATIVE(MEM_SHARE), args);
+}
+
 static const struct ffa_dev_ops ffa_ops = {
 	.api_version_get = ffa_api_version_get,
 	.partition_id_get = ffa_partition_id_get,
 	.partition_info_get = ffa_partition_info_get,
 	.sync_send_receive = ffa_sync_send_receive,
+	.memory_reclaim = ffa_memory_reclaim,
+	.memory_share = ffa_memory_share,
 };
 
 const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
index 8604c48289ce..67e3180e7097 100644
--- a/include/linux/arm_ffa.h
+++ b/include/linux/arm_ffa.h
@@ -109,6 +109,153 @@ struct ffa_send_direct_data {
 	unsigned long data4;
 };
 
+struct ffa_mem_region_addr_range {
+	/* The base IPA of the constituent memory region, aligned to 4 kiB */
+	u64 address;
+	/* The number of 4 kiB pages in the constituent memory region. */
+	u32 pg_cnt;
+	u32 reserved;
+};
+
+struct ffa_composite_mem_region {
+	/*
+	 * The total number of 4 kiB pages included in this memory region. This
+	 * must be equal to the sum of page counts specified in each
+	 * `struct ffa_mem_region_addr_range`.
+	 */
+	u32 total_pg_cnt;
+	/* The number of constituents included in this memory region range */
+	u32 addr_range_cnt;
+	u64 reserved;
+	/** An array of `addr_range_cnt` memory region constituents. */
+	struct ffa_mem_region_addr_range constituents[];
+};
+
+struct ffa_mem_region_attributes {
+	/* The ID of the VM to which the memory is being given or shared. */
+	u16 receiver;
+	/*
+	 * The permissions with which the memory region should be mapped in the
+	 * receiver's page table.
+	 */
+#define FFA_MEM_EXEC	BIT(3)
+#define FFA_MEM_NO_EXEC	BIT(2)
+#define FFA_MEM_RW		BIT(1)
+#define FFA_MEM_RO		BIT(0)
+	u8 attrs;
+	/*
+	 * Flags used during FFA_MEM_RETRIEVE_REQ and FFA_MEM_RETRIEVE_RESP
+	 * for memory regions with multiple borrowers.
+	 */
+#define FFA_MEM_RETRIEVE_SELF_BORROWER	BIT(0)
+	u8 flag;
+	u32 composite_off;
+	/*
+	 * Offset in bytes from the start of the outer `ffa_memory_region` to
+	 * an `struct ffa_mem_region_addr_range`.
+	 */
+	u64 reserved;
+};
+
+struct ffa_mem_region {
+	/* The ID of the VM/owner which originally sent the memory region */
+	u16 sender_id;
+#define FFA_MEM_NORMAL		BIT(5)
+#define FFA_MEM_DEVICE		BIT(4)
+
+#define FFA_MEM_WRITE_BACK	(3 << 2)
+#define FFA_MEM_NON_CACHEABLE	(1 << 2)
+
+#define FFA_DEV_nGnRnE		(0 << 2)
+#define FFA_DEV_nGnRE		(1 << 2)
+#define FFA_DEV_nGRE		(2 << 2)
+#define FFA_DEV_GRE		(3 << 2)
+
+#define FFA_MEM_NON_SHAREABLE	(0)
+#define FFA_MEM_OUTER_SHAREABLE	(2)
+#define FFA_MEM_INNER_SHAREABLE	(3)
+	u8 attributes;
+	u8 reserved_0;
+/*
+ * Clear memory region contents after unmapping it from the sender and
+ * before mapping it for any receiver.
+ */
+#define FFA_MEM_CLEAR			BIT(0)
+/*
+ * Whether the hypervisor may time slice the memory sharing or retrieval
+ * operation.
+ */
+#define FFA_TIME_SLICE_ENABLE		BIT(1)
+
+/*
+ * Whether the hypervisor should clear the memory region before the receiver
+ * relinquishes it or is aborted.
+ */
+#define FFA_MEM_CLEAR_BEFORE_RELINQUISH	BIT(0)
+/*
+ * Whether the hypervisor should clear the memory region after the receiver
+ * relinquishes it or is aborted.
+ */
+#define FFA_MEM_CLEAR_AFTER_RELINQUISH	BIT(2)
+
+#define FFA_MEM_RETRIEVE_TYPE_IN_RESP	(0 << 3)
+#define FFA_MEM_RETRIEVE_TYPE_SHARE	(1 << 3)
+#define FFA_MEM_RETRIEVE_TYPE_LEND	(2 << 3)
+#define FFA_MEM_RETRIEVE_TYPE_DONATE	(3 << 3)
+
+#define FFA_MEM_RETRIEVE_ADDR_ALIGN_HINT	BIT(9)
+#define FFA_MEM_RETRIEVE_ADDR_ALIGN(x)		((x) << 5)
+	/* Flags to control behaviour of the transaction. */
+	u32 flags;
+#define HANDLE_LOW_MASK		GENMASK_ULL(31, 0)
+#define HANDLE_HIGH_MASK	GENMASK_ULL(63, 32)
+#define HANDLE_LOW(x)		(u32)(FIELD_GET(HANDLE_LOW_MASK, (x)))
+#define	HANDLE_HIGH(x)		(u32)(FIELD_GET(HANDLE_HIGH_MASK, (x)))
+
+#define PACK_HANDLE(l, h)		\
+	(FIELD_PREP(HANDLE_LOW_MASK, (l)) | FIELD_PREP(HANDLE_HIGH_MASK, (h)))
+	/*
+	 * A globally-unique ID assigned by the hypervisor for a region
+	 * of memory being sent between VMs.
+	 */
+	u64 handle;
+	/*
+	 * An implementation defined value associated with the receiver and the
+	 * memory region.
+	 */
+	u64 tag;
+	u32 reserved_1;
+	/*
+	 * The number of `ffa_mem_region_attributes` entries included in this
+	 * transaction.
+	 */
+	u32 ep_count;
+	/*
+	 * An array of endpoint memory access descriptors.
+	 * Each one specifies a memory region offset, an endpoint and the
+	 * attributes with which this memory region should be mapped in that
+	 * endpoint's page table.
+	 */
+	struct ffa_mem_region_attributes ep_mem_access[];
+};
+
+#define	COMPOSITE_OFFSET(x)	\
+	(offsetof(struct ffa_mem_region, ep_mem_access[x]))
+#define CONSTITUENTS_OFFSET(x)	\
+	(offsetof(struct ffa_composite_mem_region, constituents[x]))
+#define COMPOSITE_CONSTITUENTS_OFFSET(x, y)	\
+	(COMPOSITE_OFFSET(x) + CONSTITUENTS_OFFSET(y))
+
+struct ffa_mem_ops_args {
+	bool use_txbuf;
+	u64 tag;
+	u32 flags;
+	struct ffa_mem_region_attributes *attrs;
+	u32 nattrs;
+	struct scatterlist *sg;
+	u64 *g_handle;
+};
+
 struct ffa_dev_ops {
 	u32 (*api_version_get)(void);
 	u16 (*partition_id_get)(struct ffa_device *dev);
@@ -116,6 +263,8 @@ struct ffa_dev_ops {
 				  struct ffa_partition_info *buffer);
 	int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
 				 struct ffa_send_direct_data *data);
+	int (*memory_reclaim)(u64 g_handle, u32 flags);
+	int (*memory_share)(struct ffa_mem_ops_args *args);
 };
 
 #endif /* _LINUX_ARM_FFA_H */
-- 
2.25.1


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

Hi Sudeep,

Some comments below.

On Fri, Dec 04, 2020 at 12:11:36PM +0000, Sudeep Holla wrote:
> Parse the FFA nodes from the device-tree and register all the partitions
> whose services will be used in the kernel.
> 
> In order to also enable in-kernel users of FFA interface, let us add
> simple set of operations for such devices.
> 
> The in-kernel users are registered without the character device interface.
> 
> Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> ---
>  drivers/firmware/arm_ffa/common.h |   2 +
>  drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
>  include/linux/arm_ffa.h           |  36 +++++-
>  3 files changed, 223 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
> index d019348bf67d..eb1371c2b2b8 100644
> --- a/drivers/firmware/arm_ffa/common.h
> +++ b/drivers/firmware/arm_ffa/common.h
> @@ -6,6 +6,7 @@
>  #ifndef _FFA_COMMON_H
>  #define _FFA_COMMON_H
>  
> +#include <linux/arm_ffa.h>
>  #include <linux/arm-smccc.h>
>  #include <linux/err.h>
>  
> @@ -17,6 +18,7 @@ typedef ffa_res_t
>  
>  int __init arm_ffa_bus_init(void);
>  void __exit arm_ffa_bus_exit(void);
> +bool ffa_device_is_valid(struct ffa_device *ffa_dev);
>  
>  #ifdef CONFIG_ARM_FFA_SMCCC
>  int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
> diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> index 257b331d781c..3e4ba841dbf8 100644
> --- a/drivers/firmware/arm_ffa/driver.c
> +++ b/drivers/firmware/arm_ffa/driver.c
> @@ -24,9 +24,13 @@
>  
>  #include <linux/arm_ffa.h>
>  #include <linux/bitfield.h>
> +#include <linux/device.h>
>  #include <linux/io.h>
> +#include <linux/kernel.h>
>  #include <linux/module.h>
> +#include <linux/of.h>
>  #include <linux/slab.h>
> +#include <linux/uuid.h>
>  
>  #include "common.h"
>  
> @@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
>  	return 0;
>  }
>  
> +static int ffa_rx_release(void)
> +{
> +	ffa_res_t ret;
> +
> +	ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
> +
> +	if (ret.a0 == FFA_ERROR)
> +		return ffa_to_linux_errno((int)ret.a2);
> +
> +	/* check for ret.a0 == FFA_RX_RELEASE ? */
> +
> +	return 0;
> +}
> +
>  static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
>  {
>  	ffa_res_t ret;
> @@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
>  	return 0;
>  }
>  
> +static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
> +				    struct ffa_partition_info **buffer)
> +{
> +	int count;
> +	ffa_res_t partition_info;
> +
> +	mutex_lock(&drv_info->rx_lock);
> +	partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
> +				       uuid2, uuid3, 0, 0, 0);
> +
> +	if (partition_info.a0 == FFA_ERROR)
> +		return ffa_to_linux_errno((int)partition_info.a2);
> +
> +	count = partition_info.a2;
> +
> +	if (buffer)
> +		memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
> +
> +	ffa_rx_release();
> +
> +	mutex_unlock(&drv_info->rx_lock);
> +
> +	return count;
> +}
> +
> +static int ffa_partition_probe(const char *uuid_str,
> +			       struct ffa_partition_info *buffer)
> +{
> +	int count;
> +	uuid_t uuid;
> +	u32 uuid0_4[4] = { 0 };
> +
> +	if (uuid_parse(uuid_str, &uuid)) {
> +		pr_err("invalid uuid (%s)\n", uuid_str);
> +		return -ENODEV;
> +	}
> +
> +	export_uuid((u8 *)uuid0_4, &uuid);
> +	count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> +					 uuid0_4[3], &buffer);
> +
> +	return count;
> +}
> +
>  #define VM_ID_MASK	GENMASK(15, 0)
>  static int ffa_id_get(u16 *vm_id)
>  {
> @@ -218,9 +280,125 @@ static int ffa_id_get(u16 *vm_id)
>  	return 0;
>  }
>  
> +static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
> +				   struct ffa_send_direct_data *data)
> +{
> +	u32 src_dst_ids = PACK_TARGET_INFO(src_id, dst_id);
> +	ffa_res_t ret;
> +
> +	ret = invoke_ffa_fn(FFA_FN_NATIVE(MSG_SEND_DIRECT_REQ), src_dst_ids, 0,
> +			    data->data0, data->data1, data->data2,
> +			    data->data3, data->data4);
> +
> +	while (ret.a0 == FFA_INTERRUPT)
> +		ret = invoke_ffa_fn(FFA_RUN, ret.a1, 0, 0, 0, 0, 0, 0);
> +	if (ret.a0 == FFA_ERROR)
> +		return ffa_to_linux_errno((int)ret.a2);
> +
> +	if (ret.a0 == FFA_FN_NATIVE(MSG_SEND_DIRECT_RESP)) {
> +		data->data0 = ret.a3;
> +		data->data1 = ret.a4;
> +		data->data2 = ret.a5;
> +		data->data3 = ret.a6;
> +		data->data4 = ret.a7;
> +	}
> +
> +	return 0;
> +}
> +
> +static u32 ffa_api_version_get(void)
> +{
> +	return drv_info->version;
> +}
> +
> +static u16 ffa_partition_id_get(struct ffa_device *dev)
> +{
> +	return dev->vm_id;
> +}
> +
> +static int ffa_partition_info_get(const char *uuid_str,
> +				  struct ffa_partition_info *buffer)
> +{
> +	if (ffa_partition_probe(uuid_str, buffer) == 1)
> +		return 0;
> +
> +	return -ENOENT;
> +}
> +
> +static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
> +				 struct ffa_send_direct_data *data)
> +{
> +	return ffa_msg_send_direct_req(dev->vm_id, ep, data);
> +}
> +
> +static const struct ffa_dev_ops ffa_ops = {
> +	.api_version_get = ffa_api_version_get,
> +	.partition_id_get = ffa_partition_id_get,
> +	.partition_info_get = ffa_partition_info_get,
> +	.sync_send_receive = ffa_sync_send_receive,
> +};
> +
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> +{
> +	if (ffa_device_is_valid(dev))
> +		return &ffa_ops;
> +
> +	return NULL;
> +}
> +EXPORT_SYMBOL_GPL(ffa_dev_ops_get);
> +
> +int ffa_setup_partitions(struct device_node *np)
> +{
> +	int ret;
> +	struct device_node *child;
> +	struct ffa_device *ffa_dev;
> +	struct ffa_partition_info pbuf;
> +	const char *p_uuid, *pfx = "Ignoring FFA partition";
> +	uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
> +
> +	for_each_child_of_node(np, child) {

The spec says:
– If the Nil UUID is specified at the Non-secure virtual FF-A instance,
  the Hypervisor must provide information for partitions resident in both
  security states.

Doesn't that make this redundant?


> +		if (!of_device_is_compatible(child, "arm,ffa-1.0-partition")) {
> +			of_node_put(child);
> +			continue;
> +		}
> +
> +		if (of_property_read_string(child, "uuid", &p_uuid)) {
> +			pr_err("%s: failed to parse \"uuid\" property\n", pfx);
> +			of_node_put(child);
> +			continue;
> +		}
> +
> +		of_node_put(child);
> +
> +		if (uuid_parse(p_uuid, &uuid)) {
> +			pr_err("%s: invalid \"uuid\" property (%s)\n",
> +			       pfx, p_uuid);
> +			continue;
> +		}
> +
> +		ret = ffa_partition_probe(p_uuid, &pbuf);
> +		if (ret != 1) {

If ret is > 1 we're in deep trouble as we have a buffer overrun on the
stack.

Cheers,
Jens

> +			pr_err("%s: %s partition info probe failed\n",
> +			       pfx, p_uuid);
> +			return -EINVAL;
> +		}
> +
> +		ffa_dev = ffa_device_register(p_uuid, pbuf.id);
> +		if (!ffa_dev) {
> +			pr_err("%s: failed to register %s\n", pfx, p_uuid);
> +			continue;
> +		}
> +
> +		ffa_dev_set_drvdata(ffa_dev, drv_info);
> +	}
> +
> +	return 0;
> +}
> +
>  static int __init ffa_init(void)
>  {
>  	int ret;
> +	struct device_node *np;
>  
>  	ret = arm_ffa_bus_init();
>  	if (ret)
> @@ -267,6 +445,14 @@ static int __init ffa_init(void)
>  	mutex_init(&drv_info->rx_lock);
>  	mutex_init(&drv_info->tx_lock);
>  
> +	/* Set up all the partitions */
> +	np = of_find_compatible_node(NULL, NULL, "arm,ffa-1.0");
> +	if (!np)
> +		return 0;
> +
> +	ffa_setup_partitions(np);
> +	of_node_put(np);
> +
>  	return 0;
>  free_pages:
>  	if (drv_info->tx_buffer)
> diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
> index 3defddfb40fc..8604c48289ce 100644
> --- a/include/linux/arm_ffa.h
> +++ b/include/linux/arm_ffa.h
> @@ -6,7 +6,6 @@
>  #ifndef _LINUX_ARM_FFA_H
>  #define _LINUX_ARM_FFA_H
>  
> -#include <linux/cdev.h>
>  #include <linux/device.h>
>  #include <linux/module.h>
>  #include <linux/types.h>
> @@ -47,6 +46,7 @@ void ffa_device_unregister(struct ffa_device *ffa_dev);
>  int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
>  			const char *mod_name);
>  void ffa_driver_unregister(struct ffa_driver *driver);
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev);
>  
>  #else
>  static inline
> @@ -66,6 +66,10 @@ ffa_driver_register(struct ffa_driver *driver, struct module *owner,
>  
>  static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
>  
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> +{
> +	return NULL;
> +}
>  #endif /* CONFIG_ARM_FFA_TRANSPORT */
>  
>  #define ffa_register(driver) \
> @@ -84,4 +88,34 @@ static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
>  #define module_ffa_driver(__ffa_driver)	\
>  	module_driver(__ffa_driver, ffa_register, ffa_unregister)
>  
> +/* FFA transport related */
> +struct ffa_partition_info {
> +	u16 id;
> +	u16 exec_ctxt;
> +/* partition supports receipt of direct requests */
> +#define FFA_PARTITION_DIRECT_RECV	BIT(0)
> +/* partition can send direct requests. */
> +#define FFA_PARTITION_DIRECT_SEND	BIT(1)
> +/* partition can send and receive indirect messages. */
> +#define FFA_PARTITION_INDIRECT_MSG	BIT(2)
> +	u32 properties;
> +};
> +
> +struct ffa_send_direct_data {
> +	unsigned long data0;
> +	unsigned long data1;
> +	unsigned long data2;
> +	unsigned long data3;
> +	unsigned long data4;
> +};
> +
> +struct ffa_dev_ops {
> +	u32 (*api_version_get)(void);
> +	u16 (*partition_id_get)(struct ffa_device *dev);
> +	int (*partition_info_get)(const char *uuid_str,
> +				  struct ffa_partition_info *buffer);
> +	int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
> +				 struct ffa_send_direct_data *data);
> +};
> +
>  #endif /* _LINUX_ARM_FFA_H */
> -- 
> 2.25.1
> 

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

Hi Sudeep,

Some comments below.

On Fri, Dec 04, 2020 at 12:11:36PM +0000, Sudeep Holla wrote:
> Parse the FFA nodes from the device-tree and register all the partitions
> whose services will be used in the kernel.
> 
> In order to also enable in-kernel users of FFA interface, let us add
> simple set of operations for such devices.
> 
> The in-kernel users are registered without the character device interface.
> 
> Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> ---
>  drivers/firmware/arm_ffa/common.h |   2 +
>  drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
>  include/linux/arm_ffa.h           |  36 +++++-
>  3 files changed, 223 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
> index d019348bf67d..eb1371c2b2b8 100644
> --- a/drivers/firmware/arm_ffa/common.h
> +++ b/drivers/firmware/arm_ffa/common.h
> @@ -6,6 +6,7 @@
>  #ifndef _FFA_COMMON_H
>  #define _FFA_COMMON_H
>  
> +#include <linux/arm_ffa.h>
>  #include <linux/arm-smccc.h>
>  #include <linux/err.h>
>  
> @@ -17,6 +18,7 @@ typedef ffa_res_t
>  
>  int __init arm_ffa_bus_init(void);
>  void __exit arm_ffa_bus_exit(void);
> +bool ffa_device_is_valid(struct ffa_device *ffa_dev);
>  
>  #ifdef CONFIG_ARM_FFA_SMCCC
>  int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
> diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> index 257b331d781c..3e4ba841dbf8 100644
> --- a/drivers/firmware/arm_ffa/driver.c
> +++ b/drivers/firmware/arm_ffa/driver.c
> @@ -24,9 +24,13 @@
>  
>  #include <linux/arm_ffa.h>
>  #include <linux/bitfield.h>
> +#include <linux/device.h>
>  #include <linux/io.h>
> +#include <linux/kernel.h>
>  #include <linux/module.h>
> +#include <linux/of.h>
>  #include <linux/slab.h>
> +#include <linux/uuid.h>
>  
>  #include "common.h"
>  
> @@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
>  	return 0;
>  }
>  
> +static int ffa_rx_release(void)
> +{
> +	ffa_res_t ret;
> +
> +	ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
> +
> +	if (ret.a0 == FFA_ERROR)
> +		return ffa_to_linux_errno((int)ret.a2);
> +
> +	/* check for ret.a0 == FFA_RX_RELEASE ? */
> +
> +	return 0;
> +}
> +
>  static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
>  {
>  	ffa_res_t ret;
> @@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
>  	return 0;
>  }
>  
> +static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
> +				    struct ffa_partition_info **buffer)
> +{
> +	int count;
> +	ffa_res_t partition_info;
> +
> +	mutex_lock(&drv_info->rx_lock);
> +	partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
> +				       uuid2, uuid3, 0, 0, 0);
> +
> +	if (partition_info.a0 == FFA_ERROR)
> +		return ffa_to_linux_errno((int)partition_info.a2);
> +
> +	count = partition_info.a2;
> +
> +	if (buffer)
> +		memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
> +
> +	ffa_rx_release();
> +
> +	mutex_unlock(&drv_info->rx_lock);
> +
> +	return count;
> +}
> +
> +static int ffa_partition_probe(const char *uuid_str,
> +			       struct ffa_partition_info *buffer)
> +{
> +	int count;
> +	uuid_t uuid;
> +	u32 uuid0_4[4] = { 0 };
> +
> +	if (uuid_parse(uuid_str, &uuid)) {
> +		pr_err("invalid uuid (%s)\n", uuid_str);
> +		return -ENODEV;
> +	}
> +
> +	export_uuid((u8 *)uuid0_4, &uuid);
> +	count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> +					 uuid0_4[3], &buffer);
> +
> +	return count;
> +}
> +
>  #define VM_ID_MASK	GENMASK(15, 0)
>  static int ffa_id_get(u16 *vm_id)
>  {
> @@ -218,9 +280,125 @@ static int ffa_id_get(u16 *vm_id)
>  	return 0;
>  }
>  
> +static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
> +				   struct ffa_send_direct_data *data)
> +{
> +	u32 src_dst_ids = PACK_TARGET_INFO(src_id, dst_id);
> +	ffa_res_t ret;
> +
> +	ret = invoke_ffa_fn(FFA_FN_NATIVE(MSG_SEND_DIRECT_REQ), src_dst_ids, 0,
> +			    data->data0, data->data1, data->data2,
> +			    data->data3, data->data4);
> +
> +	while (ret.a0 == FFA_INTERRUPT)
> +		ret = invoke_ffa_fn(FFA_RUN, ret.a1, 0, 0, 0, 0, 0, 0);
> +	if (ret.a0 == FFA_ERROR)
> +		return ffa_to_linux_errno((int)ret.a2);
> +
> +	if (ret.a0 == FFA_FN_NATIVE(MSG_SEND_DIRECT_RESP)) {
> +		data->data0 = ret.a3;
> +		data->data1 = ret.a4;
> +		data->data2 = ret.a5;
> +		data->data3 = ret.a6;
> +		data->data4 = ret.a7;
> +	}
> +
> +	return 0;
> +}
> +
> +static u32 ffa_api_version_get(void)
> +{
> +	return drv_info->version;
> +}
> +
> +static u16 ffa_partition_id_get(struct ffa_device *dev)
> +{
> +	return dev->vm_id;
> +}
> +
> +static int ffa_partition_info_get(const char *uuid_str,
> +				  struct ffa_partition_info *buffer)
> +{
> +	if (ffa_partition_probe(uuid_str, buffer) == 1)
> +		return 0;
> +
> +	return -ENOENT;
> +}
> +
> +static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
> +				 struct ffa_send_direct_data *data)
> +{
> +	return ffa_msg_send_direct_req(dev->vm_id, ep, data);
> +}
> +
> +static const struct ffa_dev_ops ffa_ops = {
> +	.api_version_get = ffa_api_version_get,
> +	.partition_id_get = ffa_partition_id_get,
> +	.partition_info_get = ffa_partition_info_get,
> +	.sync_send_receive = ffa_sync_send_receive,
> +};
> +
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> +{
> +	if (ffa_device_is_valid(dev))
> +		return &ffa_ops;
> +
> +	return NULL;
> +}
> +EXPORT_SYMBOL_GPL(ffa_dev_ops_get);
> +
> +int ffa_setup_partitions(struct device_node *np)
> +{
> +	int ret;
> +	struct device_node *child;
> +	struct ffa_device *ffa_dev;
> +	struct ffa_partition_info pbuf;
> +	const char *p_uuid, *pfx = "Ignoring FFA partition";
> +	uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
> +
> +	for_each_child_of_node(np, child) {

The spec says:
– If the Nil UUID is specified at the Non-secure virtual FF-A instance,
  the Hypervisor must provide information for partitions resident in both
  security states.

Doesn't that make this redundant?


> +		if (!of_device_is_compatible(child, "arm,ffa-1.0-partition")) {
> +			of_node_put(child);
> +			continue;
> +		}
> +
> +		if (of_property_read_string(child, "uuid", &p_uuid)) {
> +			pr_err("%s: failed to parse \"uuid\" property\n", pfx);
> +			of_node_put(child);
> +			continue;
> +		}
> +
> +		of_node_put(child);
> +
> +		if (uuid_parse(p_uuid, &uuid)) {
> +			pr_err("%s: invalid \"uuid\" property (%s)\n",
> +			       pfx, p_uuid);
> +			continue;
> +		}
> +
> +		ret = ffa_partition_probe(p_uuid, &pbuf);
> +		if (ret != 1) {

If ret is > 1 we're in deep trouble as we have a buffer overrun on the
stack.

Cheers,
Jens

> +			pr_err("%s: %s partition info probe failed\n",
> +			       pfx, p_uuid);
> +			return -EINVAL;
> +		}
> +
> +		ffa_dev = ffa_device_register(p_uuid, pbuf.id);
> +		if (!ffa_dev) {
> +			pr_err("%s: failed to register %s\n", pfx, p_uuid);
> +			continue;
> +		}
> +
> +		ffa_dev_set_drvdata(ffa_dev, drv_info);
> +	}
> +
> +	return 0;
> +}
> +
>  static int __init ffa_init(void)
>  {
>  	int ret;
> +	struct device_node *np;
>  
>  	ret = arm_ffa_bus_init();
>  	if (ret)
> @@ -267,6 +445,14 @@ static int __init ffa_init(void)
>  	mutex_init(&drv_info->rx_lock);
>  	mutex_init(&drv_info->tx_lock);
>  
> +	/* Set up all the partitions */
> +	np = of_find_compatible_node(NULL, NULL, "arm,ffa-1.0");
> +	if (!np)
> +		return 0;
> +
> +	ffa_setup_partitions(np);
> +	of_node_put(np);
> +
>  	return 0;
>  free_pages:
>  	if (drv_info->tx_buffer)
> diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
> index 3defddfb40fc..8604c48289ce 100644
> --- a/include/linux/arm_ffa.h
> +++ b/include/linux/arm_ffa.h
> @@ -6,7 +6,6 @@
>  #ifndef _LINUX_ARM_FFA_H
>  #define _LINUX_ARM_FFA_H
>  
> -#include <linux/cdev.h>
>  #include <linux/device.h>
>  #include <linux/module.h>
>  #include <linux/types.h>
> @@ -47,6 +46,7 @@ void ffa_device_unregister(struct ffa_device *ffa_dev);
>  int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
>  			const char *mod_name);
>  void ffa_driver_unregister(struct ffa_driver *driver);
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev);
>  
>  #else
>  static inline
> @@ -66,6 +66,10 @@ ffa_driver_register(struct ffa_driver *driver, struct module *owner,
>  
>  static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
>  
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> +{
> +	return NULL;
> +}
>  #endif /* CONFIG_ARM_FFA_TRANSPORT */
>  
>  #define ffa_register(driver) \
> @@ -84,4 +88,34 @@ static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
>  #define module_ffa_driver(__ffa_driver)	\
>  	module_driver(__ffa_driver, ffa_register, ffa_unregister)
>  
> +/* FFA transport related */
> +struct ffa_partition_info {
> +	u16 id;
> +	u16 exec_ctxt;
> +/* partition supports receipt of direct requests */
> +#define FFA_PARTITION_DIRECT_RECV	BIT(0)
> +/* partition can send direct requests. */
> +#define FFA_PARTITION_DIRECT_SEND	BIT(1)
> +/* partition can send and receive indirect messages. */
> +#define FFA_PARTITION_INDIRECT_MSG	BIT(2)
> +	u32 properties;
> +};
> +
> +struct ffa_send_direct_data {
> +	unsigned long data0;
> +	unsigned long data1;
> +	unsigned long data2;
> +	unsigned long data3;
> +	unsigned long data4;
> +};
> +
> +struct ffa_dev_ops {
> +	u32 (*api_version_get)(void);
> +	u16 (*partition_id_get)(struct ffa_device *dev);
> +	int (*partition_info_get)(const char *uuid_str,
> +				  struct ffa_partition_info *buffer);
> +	int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
> +				 struct ffa_send_direct_data *data);
> +};
> +
>  #endif /* _LINUX_ARM_FFA_H */
> -- 
> 2.25.1
> 

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

Hi Sudeep,

Some more comments below.

On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
>
> Parse the FFA nodes from the device-tree and register all the partitions
> whose services will be used in the kernel.
>
> In order to also enable in-kernel users of FFA interface, let us add
> simple set of operations for such devices.
>
> The in-kernel users are registered without the character device interface.
>
> Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> ---
>  drivers/firmware/arm_ffa/common.h |   2 +
>  drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
>  include/linux/arm_ffa.h           |  36 +++++-
>  3 files changed, 223 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
> index d019348bf67d..eb1371c2b2b8 100644
> --- a/drivers/firmware/arm_ffa/common.h
> +++ b/drivers/firmware/arm_ffa/common.h
> @@ -6,6 +6,7 @@
>  #ifndef _FFA_COMMON_H
>  #define _FFA_COMMON_H
>
> +#include <linux/arm_ffa.h>
>  #include <linux/arm-smccc.h>
>  #include <linux/err.h>
>
> @@ -17,6 +18,7 @@ typedef ffa_res_t
>
>  int __init arm_ffa_bus_init(void);
>  void __exit arm_ffa_bus_exit(void);
> +bool ffa_device_is_valid(struct ffa_device *ffa_dev);
>
>  #ifdef CONFIG_ARM_FFA_SMCCC
>  int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
> diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> index 257b331d781c..3e4ba841dbf8 100644
> --- a/drivers/firmware/arm_ffa/driver.c
> +++ b/drivers/firmware/arm_ffa/driver.c
> @@ -24,9 +24,13 @@
>
>  #include <linux/arm_ffa.h>
>  #include <linux/bitfield.h>
> +#include <linux/device.h>
>  #include <linux/io.h>
> +#include <linux/kernel.h>
>  #include <linux/module.h>
> +#include <linux/of.h>
>  #include <linux/slab.h>
> +#include <linux/uuid.h>
>
>  #include "common.h"
>
> @@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
>         return 0;
>  }
>
> +static int ffa_rx_release(void)
> +{
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
> +
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       /* check for ret.a0 == FFA_RX_RELEASE ? */
> +
> +       return 0;
> +}
> +
>  static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
>  {
>         ffa_res_t ret;
> @@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
>         return 0;
>  }
>
> +static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
> +                                   struct ffa_partition_info **buffer)
> +{
> +       int count;
> +       ffa_res_t partition_info;
> +
> +       mutex_lock(&drv_info->rx_lock);
> +       partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
> +                                      uuid2, uuid3, 0, 0, 0);
> +
> +       if (partition_info.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)partition_info.a2);
> +
> +       count = partition_info.a2;
> +
> +       if (buffer)
> +               memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
> +
> +       ffa_rx_release();
> +
> +       mutex_unlock(&drv_info->rx_lock);
> +
> +       return count;
> +}
> +
> +static int ffa_partition_probe(const char *uuid_str,
> +                              struct ffa_partition_info *buffer)
> +{
> +       int count;
> +       uuid_t uuid;
> +       u32 uuid0_4[4] = { 0 };
> +
> +       if (uuid_parse(uuid_str, &uuid)) {
> +               pr_err("invalid uuid (%s)\n", uuid_str);
> +               return -ENODEV;
> +       }
> +
> +       export_uuid((u8 *)uuid0_4, &uuid);
> +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> +                                        uuid0_4[3], &buffer);
> +
> +       return count;
> +}
> +
>  #define VM_ID_MASK     GENMASK(15, 0)
>  static int ffa_id_get(u16 *vm_id)
>  {
> @@ -218,9 +280,125 @@ static int ffa_id_get(u16 *vm_id)
>         return 0;
>  }
>
> +static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
> +                                  struct ffa_send_direct_data *data)
> +{
> +       u32 src_dst_ids = PACK_TARGET_INFO(src_id, dst_id);
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(FFA_FN_NATIVE(MSG_SEND_DIRECT_REQ), src_dst_ids, 0,
> +                           data->data0, data->data1, data->data2,
> +                           data->data3, data->data4);
> +
> +       while (ret.a0 == FFA_INTERRUPT)
> +               ret = invoke_ffa_fn(FFA_RUN, ret.a1, 0, 0, 0, 0, 0, 0);
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       if (ret.a0 == FFA_FN_NATIVE(MSG_SEND_DIRECT_RESP)) {
> +               data->data0 = ret.a3;
> +               data->data1 = ret.a4;
> +               data->data2 = ret.a5;
> +               data->data3 = ret.a6;
> +               data->data4 = ret.a7;
> +       }
> +
> +       return 0;
> +}
> +
> +static u32 ffa_api_version_get(void)
> +{
> +       return drv_info->version;
> +}
> +
> +static u16 ffa_partition_id_get(struct ffa_device *dev)
> +{
> +       return dev->vm_id;
> +}
> +
> +static int ffa_partition_info_get(const char *uuid_str,
> +                                 struct ffa_partition_info *buffer)
> +{
> +       if (ffa_partition_probe(uuid_str, buffer) == 1)
> +               return 0;
> +
> +       return -ENOENT;
> +}
> +
> +static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
> +                                struct ffa_send_direct_data *data)
> +{
> +       return ffa_msg_send_direct_req(dev->vm_id, ep, data);
> +}
> +
> +static const struct ffa_dev_ops ffa_ops = {
> +       .api_version_get = ffa_api_version_get,
> +       .partition_id_get = ffa_partition_id_get,
> +       .partition_info_get = ffa_partition_info_get,
> +       .sync_send_receive = ffa_sync_send_receive,
> +};
> +
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> +{
> +       if (ffa_device_is_valid(dev))
> +               return &ffa_ops;
> +
> +       return NULL;
> +}
> +EXPORT_SYMBOL_GPL(ffa_dev_ops_get);
> +
> +int ffa_setup_partitions(struct device_node *np)
This function is only used internally and the return value is ignored.
Maybe make it static void instead?

> +{
> +       int ret;
> +       struct device_node *child;
> +       struct ffa_device *ffa_dev;
> +       struct ffa_partition_info pbuf;
> +       const char *p_uuid, *pfx = "Ignoring FFA partition";
> +       uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
> +
> +       for_each_child_of_node(np, child) {
of_node_put() should only be called on child in case we're leaving the
loop early. for_each_child_of_node() takes care of the other case.

> +               if (!of_device_is_compatible(child, "arm,ffa-1.0-partition")) {
> +                       of_node_put(child);
> +                       continue;
> +               }
> +
> +               if (of_property_read_string(child, "uuid", &p_uuid)) {
> +                       pr_err("%s: failed to parse \"uuid\" property\n", pfx);
> +                       of_node_put(child);
> +                       continue;
> +               }
> +
> +               of_node_put(child);
> +
> +               if (uuid_parse(p_uuid, &uuid)) {
> +                       pr_err("%s: invalid \"uuid\" property (%s)\n",
> +                              pfx, p_uuid);
> +                       continue;
> +               }
> +
> +               ret = ffa_partition_probe(p_uuid, &pbuf);
> +               if (ret != 1) {
> +                       pr_err("%s: %s partition info probe failed\n",
> +                              pfx, p_uuid);
> +                       return -EINVAL;
> +               }
> +
> +               ffa_dev = ffa_device_register(p_uuid, pbuf.id);
> +               if (!ffa_dev) {
> +                       pr_err("%s: failed to register %s\n", pfx, p_uuid);
> +                       continue;
> +               }
> +
> +               ffa_dev_set_drvdata(ffa_dev, drv_info);
> +       }
> +
> +       return 0;
> +}
> +
>  static int __init ffa_init(void)
>  {
>         int ret;
> +       struct device_node *np;
>
>         ret = arm_ffa_bus_init();
>         if (ret)
> @@ -267,6 +445,14 @@ static int __init ffa_init(void)
>         mutex_init(&drv_info->rx_lock);
>         mutex_init(&drv_info->tx_lock);
>
> +       /* Set up all the partitions */
> +       np = of_find_compatible_node(NULL, NULL, "arm,ffa-1.0");
> +       if (!np)
> +               return 0;
> +
> +       ffa_setup_partitions(np);
> +       of_node_put(np);
> +
>         return 0;
>  free_pages:
>         if (drv_info->tx_buffer)
> diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
> index 3defddfb40fc..8604c48289ce 100644
> --- a/include/linux/arm_ffa.h
> +++ b/include/linux/arm_ffa.h
> @@ -6,7 +6,6 @@
>  #ifndef _LINUX_ARM_FFA_H
>  #define _LINUX_ARM_FFA_H
>
> -#include <linux/cdev.h>
>  #include <linux/device.h>
>  #include <linux/module.h>
>  #include <linux/types.h>
> @@ -47,6 +46,7 @@ void ffa_device_unregister(struct ffa_device *ffa_dev);
>  int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
>                         const char *mod_name);
>  void ffa_driver_unregister(struct ffa_driver *driver);
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev);
>
>  #else
>  static inline
> @@ -66,6 +66,10 @@ ffa_driver_register(struct ffa_driver *driver, struct module *owner,
>
>  static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
>
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> +{
> +       return NULL;
> +}
>  #endif /* CONFIG_ARM_FFA_TRANSPORT */
>
>  #define ffa_register(driver) \
> @@ -84,4 +88,34 @@ static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
>  #define module_ffa_driver(__ffa_driver)        \
>         module_driver(__ffa_driver, ffa_register, ffa_unregister)
>
> +/* FFA transport related */
> +struct ffa_partition_info {
> +       u16 id;
> +       u16 exec_ctxt;
> +/* partition supports receipt of direct requests */
> +#define FFA_PARTITION_DIRECT_RECV      BIT(0)
> +/* partition can send direct requests. */
> +#define FFA_PARTITION_DIRECT_SEND      BIT(1)
> +/* partition can send and receive indirect messages. */
> +#define FFA_PARTITION_INDIRECT_MSG     BIT(2)
> +       u32 properties;
> +};
> +
> +struct ffa_send_direct_data {
> +       unsigned long data0;
> +       unsigned long data1;
> +       unsigned long data2;
> +       unsigned long data3;
> +       unsigned long data4;
> +};
A comment describing which register index these maps to would be helpful.

> +
> +struct ffa_dev_ops {
> +       u32 (*api_version_get)(void);
> +       u16 (*partition_id_get)(struct ffa_device *dev);
> +       int (*partition_info_get)(const char *uuid_str,
> +                                 struct ffa_partition_info *buffer);
> +       int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
> +                                struct ffa_send_direct_data *data);
ep can be read directly from dev->vm_id
We may need a way to indicate if we're to use the 32bit or 64bit
calling convention. OP-TEE depends on being able to use 32bit calls
here.

Cheers,
Jens

> +};
> +
>  #endif /* _LINUX_ARM_FFA_H */
> --
> 2.25.1
>

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

Hi Sudeep,

Some more comments below.

On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
>
> Parse the FFA nodes from the device-tree and register all the partitions
> whose services will be used in the kernel.
>
> In order to also enable in-kernel users of FFA interface, let us add
> simple set of operations for such devices.
>
> The in-kernel users are registered without the character device interface.
>
> Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> ---
>  drivers/firmware/arm_ffa/common.h |   2 +
>  drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
>  include/linux/arm_ffa.h           |  36 +++++-
>  3 files changed, 223 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
> index d019348bf67d..eb1371c2b2b8 100644
> --- a/drivers/firmware/arm_ffa/common.h
> +++ b/drivers/firmware/arm_ffa/common.h
> @@ -6,6 +6,7 @@
>  #ifndef _FFA_COMMON_H
>  #define _FFA_COMMON_H
>
> +#include <linux/arm_ffa.h>
>  #include <linux/arm-smccc.h>
>  #include <linux/err.h>
>
> @@ -17,6 +18,7 @@ typedef ffa_res_t
>
>  int __init arm_ffa_bus_init(void);
>  void __exit arm_ffa_bus_exit(void);
> +bool ffa_device_is_valid(struct ffa_device *ffa_dev);
>
>  #ifdef CONFIG_ARM_FFA_SMCCC
>  int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
> diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> index 257b331d781c..3e4ba841dbf8 100644
> --- a/drivers/firmware/arm_ffa/driver.c
> +++ b/drivers/firmware/arm_ffa/driver.c
> @@ -24,9 +24,13 @@
>
>  #include <linux/arm_ffa.h>
>  #include <linux/bitfield.h>
> +#include <linux/device.h>
>  #include <linux/io.h>
> +#include <linux/kernel.h>
>  #include <linux/module.h>
> +#include <linux/of.h>
>  #include <linux/slab.h>
> +#include <linux/uuid.h>
>
>  #include "common.h"
>
> @@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
>         return 0;
>  }
>
> +static int ffa_rx_release(void)
> +{
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
> +
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       /* check for ret.a0 == FFA_RX_RELEASE ? */
> +
> +       return 0;
> +}
> +
>  static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
>  {
>         ffa_res_t ret;
> @@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
>         return 0;
>  }
>
> +static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
> +                                   struct ffa_partition_info **buffer)
> +{
> +       int count;
> +       ffa_res_t partition_info;
> +
> +       mutex_lock(&drv_info->rx_lock);
> +       partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
> +                                      uuid2, uuid3, 0, 0, 0);
> +
> +       if (partition_info.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)partition_info.a2);
> +
> +       count = partition_info.a2;
> +
> +       if (buffer)
> +               memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
> +
> +       ffa_rx_release();
> +
> +       mutex_unlock(&drv_info->rx_lock);
> +
> +       return count;
> +}
> +
> +static int ffa_partition_probe(const char *uuid_str,
> +                              struct ffa_partition_info *buffer)
> +{
> +       int count;
> +       uuid_t uuid;
> +       u32 uuid0_4[4] = { 0 };
> +
> +       if (uuid_parse(uuid_str, &uuid)) {
> +               pr_err("invalid uuid (%s)\n", uuid_str);
> +               return -ENODEV;
> +       }
> +
> +       export_uuid((u8 *)uuid0_4, &uuid);
> +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> +                                        uuid0_4[3], &buffer);
> +
> +       return count;
> +}
> +
>  #define VM_ID_MASK     GENMASK(15, 0)
>  static int ffa_id_get(u16 *vm_id)
>  {
> @@ -218,9 +280,125 @@ static int ffa_id_get(u16 *vm_id)
>         return 0;
>  }
>
> +static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
> +                                  struct ffa_send_direct_data *data)
> +{
> +       u32 src_dst_ids = PACK_TARGET_INFO(src_id, dst_id);
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(FFA_FN_NATIVE(MSG_SEND_DIRECT_REQ), src_dst_ids, 0,
> +                           data->data0, data->data1, data->data2,
> +                           data->data3, data->data4);
> +
> +       while (ret.a0 == FFA_INTERRUPT)
> +               ret = invoke_ffa_fn(FFA_RUN, ret.a1, 0, 0, 0, 0, 0, 0);
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       if (ret.a0 == FFA_FN_NATIVE(MSG_SEND_DIRECT_RESP)) {
> +               data->data0 = ret.a3;
> +               data->data1 = ret.a4;
> +               data->data2 = ret.a5;
> +               data->data3 = ret.a6;
> +               data->data4 = ret.a7;
> +       }
> +
> +       return 0;
> +}
> +
> +static u32 ffa_api_version_get(void)
> +{
> +       return drv_info->version;
> +}
> +
> +static u16 ffa_partition_id_get(struct ffa_device *dev)
> +{
> +       return dev->vm_id;
> +}
> +
> +static int ffa_partition_info_get(const char *uuid_str,
> +                                 struct ffa_partition_info *buffer)
> +{
> +       if (ffa_partition_probe(uuid_str, buffer) == 1)
> +               return 0;
> +
> +       return -ENOENT;
> +}
> +
> +static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
> +                                struct ffa_send_direct_data *data)
> +{
> +       return ffa_msg_send_direct_req(dev->vm_id, ep, data);
> +}
> +
> +static const struct ffa_dev_ops ffa_ops = {
> +       .api_version_get = ffa_api_version_get,
> +       .partition_id_get = ffa_partition_id_get,
> +       .partition_info_get = ffa_partition_info_get,
> +       .sync_send_receive = ffa_sync_send_receive,
> +};
> +
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> +{
> +       if (ffa_device_is_valid(dev))
> +               return &ffa_ops;
> +
> +       return NULL;
> +}
> +EXPORT_SYMBOL_GPL(ffa_dev_ops_get);
> +
> +int ffa_setup_partitions(struct device_node *np)
This function is only used internally and the return value is ignored.
Maybe make it static void instead?

> +{
> +       int ret;
> +       struct device_node *child;
> +       struct ffa_device *ffa_dev;
> +       struct ffa_partition_info pbuf;
> +       const char *p_uuid, *pfx = "Ignoring FFA partition";
> +       uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
> +
> +       for_each_child_of_node(np, child) {
of_node_put() should only be called on child in case we're leaving the
loop early. for_each_child_of_node() takes care of the other case.

> +               if (!of_device_is_compatible(child, "arm,ffa-1.0-partition")) {
> +                       of_node_put(child);
> +                       continue;
> +               }
> +
> +               if (of_property_read_string(child, "uuid", &p_uuid)) {
> +                       pr_err("%s: failed to parse \"uuid\" property\n", pfx);
> +                       of_node_put(child);
> +                       continue;
> +               }
> +
> +               of_node_put(child);
> +
> +               if (uuid_parse(p_uuid, &uuid)) {
> +                       pr_err("%s: invalid \"uuid\" property (%s)\n",
> +                              pfx, p_uuid);
> +                       continue;
> +               }
> +
> +               ret = ffa_partition_probe(p_uuid, &pbuf);
> +               if (ret != 1) {
> +                       pr_err("%s: %s partition info probe failed\n",
> +                              pfx, p_uuid);
> +                       return -EINVAL;
> +               }
> +
> +               ffa_dev = ffa_device_register(p_uuid, pbuf.id);
> +               if (!ffa_dev) {
> +                       pr_err("%s: failed to register %s\n", pfx, p_uuid);
> +                       continue;
> +               }
> +
> +               ffa_dev_set_drvdata(ffa_dev, drv_info);
> +       }
> +
> +       return 0;
> +}
> +
>  static int __init ffa_init(void)
>  {
>         int ret;
> +       struct device_node *np;
>
>         ret = arm_ffa_bus_init();
>         if (ret)
> @@ -267,6 +445,14 @@ static int __init ffa_init(void)
>         mutex_init(&drv_info->rx_lock);
>         mutex_init(&drv_info->tx_lock);
>
> +       /* Set up all the partitions */
> +       np = of_find_compatible_node(NULL, NULL, "arm,ffa-1.0");
> +       if (!np)
> +               return 0;
> +
> +       ffa_setup_partitions(np);
> +       of_node_put(np);
> +
>         return 0;
>  free_pages:
>         if (drv_info->tx_buffer)
> diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
> index 3defddfb40fc..8604c48289ce 100644
> --- a/include/linux/arm_ffa.h
> +++ b/include/linux/arm_ffa.h
> @@ -6,7 +6,6 @@
>  #ifndef _LINUX_ARM_FFA_H
>  #define _LINUX_ARM_FFA_H
>
> -#include <linux/cdev.h>
>  #include <linux/device.h>
>  #include <linux/module.h>
>  #include <linux/types.h>
> @@ -47,6 +46,7 @@ void ffa_device_unregister(struct ffa_device *ffa_dev);
>  int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
>                         const char *mod_name);
>  void ffa_driver_unregister(struct ffa_driver *driver);
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev);
>
>  #else
>  static inline
> @@ -66,6 +66,10 @@ ffa_driver_register(struct ffa_driver *driver, struct module *owner,
>
>  static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
>
> +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> +{
> +       return NULL;
> +}
>  #endif /* CONFIG_ARM_FFA_TRANSPORT */
>
>  #define ffa_register(driver) \
> @@ -84,4 +88,34 @@ static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
>  #define module_ffa_driver(__ffa_driver)        \
>         module_driver(__ffa_driver, ffa_register, ffa_unregister)
>
> +/* FFA transport related */
> +struct ffa_partition_info {
> +       u16 id;
> +       u16 exec_ctxt;
> +/* partition supports receipt of direct requests */
> +#define FFA_PARTITION_DIRECT_RECV      BIT(0)
> +/* partition can send direct requests. */
> +#define FFA_PARTITION_DIRECT_SEND      BIT(1)
> +/* partition can send and receive indirect messages. */
> +#define FFA_PARTITION_INDIRECT_MSG     BIT(2)
> +       u32 properties;
> +};
> +
> +struct ffa_send_direct_data {
> +       unsigned long data0;
> +       unsigned long data1;
> +       unsigned long data2;
> +       unsigned long data3;
> +       unsigned long data4;
> +};
A comment describing which register index these maps to would be helpful.

> +
> +struct ffa_dev_ops {
> +       u32 (*api_version_get)(void);
> +       u16 (*partition_id_get)(struct ffa_device *dev);
> +       int (*partition_info_get)(const char *uuid_str,
> +                                 struct ffa_partition_info *buffer);
> +       int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
> +                                struct ffa_send_direct_data *data);
ep can be read directly from dev->vm_id
We may need a way to indicate if we're to use the 32bit or 64bit
calling convention. OP-TEE depends on being able to use 32bit calls
here.

Cheers,
Jens

> +};
> +
>  #endif /* _LINUX_ARM_FFA_H */
> --
> 2.25.1
>

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 7/7] firmware: arm_ffa: Add support for MEM_* interfaces

[Jens Wiklander]

On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
>
> Most of the MEM_* APIs share the same parameters, so they can be
> generalised. Currently only MEM_SHARE is implemented and the user space
> interface for that is not added yet.
>
> Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> ---
>  drivers/firmware/arm_ffa/driver.c | 180 ++++++++++++++++++++++++++++++
>  include/linux/arm_ffa.h           | 149 +++++++++++++++++++++++++
>  2 files changed, 329 insertions(+)
>
> diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> index 3e4ba841dbf8..92a0bf542f18 100644
> --- a/drivers/firmware/arm_ffa/driver.c
> +++ b/drivers/firmware/arm_ffa/driver.c
> @@ -28,7 +28,9 @@
>  #include <linux/io.h>
>  #include <linux/kernel.h>
>  #include <linux/module.h>
> +#include <linux/mm.h>
>  #include <linux/of.h>
> +#include <linux/scatterlist.h>
>  #include <linux/slab.h>
>  #include <linux/uuid.h>
>
> @@ -306,6 +308,177 @@ static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
>         return 0;
>  }
>
> +static int ffa_mem_first_frag(u32 func_id, phys_addr_t buf, u32 buf_sz,
> +                             u32 frag_len, u32 len, u64 *handle)
> +{
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(func_id, len, frag_len, buf, buf_sz, 0, 0, 0);
> +
> +       while (ret.a0 == FFA_MEM_OP_PAUSE)
> +               ret = invoke_ffa_fn(FFA_MEM_OP_RESUME, ret.a1, ret.a2,
> +                                   0, 0, 0, 0, 0);
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       if (ret.a0 != FFA_SUCCESS)
> +               return -EOPNOTSUPP;
> +
> +       if (handle)
> +               *handle = PACK_HANDLE(ret.a3, ret.a2);
ret.a2 are the lower 32bit and ret.a3 the higher 32bits according to
5.10.2 Memory region handle

> +
> +       return frag_len;
> +}
> +
> +static int ffa_mem_next_frag(u64 handle, u32 frag_len)
> +{
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(FFA_MEM_FRAG_TX, HANDLE_LOW(handle),
> +                           HANDLE_HIGH(handle), frag_len, 0, 0, 0, 0);
> +
> +       while (ret.a0 == FFA_MEM_OP_PAUSE)
> +               ret = invoke_ffa_fn(FFA_MEM_OP_RESUME, ret.a1, ret.a2,
> +                                   0, 0, 0, 0, 0);
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       if (ret.a0 != FFA_MEM_FRAG_RX)
> +               return -EOPNOTSUPP;
> +
> +       return ret.a3;
> +}
> +
> +static int
> +ffa_transmit_fragment(u32 func_id, phys_addr_t buf, u32 buf_sz, u32 frag_len,
> +                     u32 len, u64 *handle, bool first)
> +{
> +       if (!first)
> +               return ffa_mem_next_frag(*handle, frag_len);
> +
> +       return ffa_mem_first_frag(func_id, buf, buf_sz, frag_len,
> +                                     len, handle);
> +}
> +
> +static u32 ffa_get_num_pages_sg(struct scatterlist *sg)
> +{
> +       u32 num_pages = 0;
> +
> +       do {
> +               num_pages += sg->length / FFA_PAGE_SIZE;
> +       } while ((sg = sg_next(sg)));
> +
> +       return num_pages;
> +}
> +
> +static int
> +ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize,
> +                      struct ffa_mem_ops_args *args)
> +{
> +       int rc = 0;
> +       bool first = true;
> +       phys_addr_t addr = 0;
> +       struct ffa_composite_mem_region *composite;
> +       struct ffa_mem_region_addr_range *constituents;
> +       struct ffa_mem_region_attributes *ep_mem_access;
> +       struct ffa_mem_region *mem_region = buffer;
> +       u32 idx, frag_len, length, num_entries = sg_nents(args->sg);
> +       u32 buf_sz = max_fragsize / FFA_PAGE_SIZE;
This must be zero following the same logic as for addr, see 11.3 FFA_MEM_SHARE

> +
> +       mem_region->tag = args->tag;
> +       mem_region->flags = args->flags;
> +       mem_region->sender_id = drv_info->vm_id;
> +       mem_region->attributes = FFA_MEM_NORMAL | FFA_MEM_WRITE_BACK |
> +                                FFA_MEM_INNER_SHAREABLE;
> +       ep_mem_access = &mem_region->ep_mem_access[0];
> +
> +       for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) {
> +               ep_mem_access->receiver = args->attrs[idx].receiver;
> +               ep_mem_access->attrs = args->attrs[idx].attrs;
> +               ep_mem_access->composite_off = COMPOSITE_OFFSET(args->nattrs);
> +       }
> +       mem_region->ep_count = args->nattrs;
> +
> +       composite = buffer + COMPOSITE_OFFSET(args->nattrs);
> +       composite->total_pg_cnt = ffa_get_num_pages_sg(args->sg);
> +       composite->addr_range_cnt = num_entries;
> +
> +       length = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, num_entries);
> +       frag_len = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, 0);
> +       if (frag_len > max_fragsize)
> +               return -ENXIO;
> +
> +       if (!args->use_txbuf)
> +               addr = virt_to_phys(buffer);
> +
> +       constituents = buffer + frag_len;
> +       idx = 0;
> +       do {
> +               if (frag_len == max_fragsize) {
> +                       rc = ffa_transmit_fragment(func_id, addr, buf_sz,
> +                                                  frag_len, length,
> +                                                  args->g_handle, first);
> +                       if (rc < 0)
> +                               return -ENXIO;
> +
> +                       first = false;
> +                       idx = 0;
> +                       frag_len = 0;
> +                       constituents = buffer;
> +               }
> +
> +               if ((void *)constituents - buffer > max_fragsize) {
> +                       pr_err("Memory Region Fragment > Tx Buffer size\n");
> +                       return -EFAULT;
> +               }
> +
> +               constituents->address = sg_phys(args->sg);
> +               constituents->pg_cnt = args->sg->length / FFA_PAGE_SIZE;
> +               constituents++;
> +               frag_len += sizeof(struct ffa_mem_region_addr_range);
> +       } while ((args->sg = sg_next(args->sg)));
> +
> +       return ffa_transmit_fragment(func_id, addr, buf_sz, frag_len,
> +                                    length, args->g_handle, first);
> +}
> +
> +static int ffa_memory_ops(u32 func_id, struct ffa_mem_ops_args *args)
> +{
> +       int ret;
> +       void *buffer;
> +
> +       if (!args->use_txbuf) {
> +               buffer = alloc_pages_exact(RXTX_BUFFER_SIZE, GFP_KERNEL);
> +               if (!buffer)
> +                       return -ENOMEM;
> +       } else {
> +               buffer = drv_info->tx_buffer;
> +               mutex_lock(&drv_info->tx_lock);
> +       }
> +
> +       ret = ffa_setup_and_transmit(func_id, buffer, RXTX_BUFFER_SIZE, args);
> +
> +       if (args->use_txbuf)
> +               mutex_unlock(&drv_info->tx_lock);
> +       else
> +               free_pages_exact(buffer, RXTX_BUFFER_SIZE);
> +
> +       return ret < 0 ? ret : 0;
> +}
> +
> +static int ffa_memory_reclaim(u64 g_handle, u32 flags)
> +{
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(FFA_MEM_RECLAIM, HANDLE_LOW(g_handle),
> +                           HANDLE_HIGH(g_handle), flags, 0, 0, 0, 0);
> +
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       return 0;
> +}
> +
>  static u32 ffa_api_version_get(void)
>  {
>         return drv_info->version;
> @@ -331,11 +504,18 @@ static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
>         return ffa_msg_send_direct_req(dev->vm_id, ep, data);
>  }
>
> +static int ffa_memory_share(struct ffa_mem_ops_args *args)
> +{
> +       return ffa_memory_ops(FFA_FN_NATIVE(MEM_SHARE), args);
> +}
> +
>  static const struct ffa_dev_ops ffa_ops = {
>         .api_version_get = ffa_api_version_get,
>         .partition_id_get = ffa_partition_id_get,
>         .partition_info_get = ffa_partition_info_get,
>         .sync_send_receive = ffa_sync_send_receive,
> +       .memory_reclaim = ffa_memory_reclaim,
> +       .memory_share = ffa_memory_share,
>  };
>
>  const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
> index 8604c48289ce..67e3180e7097 100644
> --- a/include/linux/arm_ffa.h
> +++ b/include/linux/arm_ffa.h
> @@ -109,6 +109,153 @@ struct ffa_send_direct_data {
>         unsigned long data4;
>  };
>
> +struct ffa_mem_region_addr_range {
> +       /* The base IPA of the constituent memory region, aligned to 4 kiB */
> +       u64 address;
> +       /* The number of 4 kiB pages in the constituent memory region. */
> +       u32 pg_cnt;
> +       u32 reserved;
> +};
> +
> +struct ffa_composite_mem_region {
> +       /*
> +        * The total number of 4 kiB pages included in this memory region. This
> +        * must be equal to the sum of page counts specified in each
> +        * `struct ffa_mem_region_addr_range`.
> +        */
> +       u32 total_pg_cnt;
> +       /* The number of constituents included in this memory region range */
> +       u32 addr_range_cnt;
> +       u64 reserved;
> +       /** An array of `addr_range_cnt` memory region constituents. */
> +       struct ffa_mem_region_addr_range constituents[];
> +};
> +
> +struct ffa_mem_region_attributes {
> +       /* The ID of the VM to which the memory is being given or shared. */
> +       u16 receiver;
> +       /*
> +        * The permissions with which the memory region should be mapped in the
> +        * receiver's page table.
> +        */
> +#define FFA_MEM_EXEC   BIT(3)
> +#define FFA_MEM_NO_EXEC        BIT(2)
> +#define FFA_MEM_RW             BIT(1)
> +#define FFA_MEM_RO             BIT(0)
> +       u8 attrs;
> +       /*
> +        * Flags used during FFA_MEM_RETRIEVE_REQ and FFA_MEM_RETRIEVE_RESP
> +        * for memory regions with multiple borrowers.
> +        */
> +#define FFA_MEM_RETRIEVE_SELF_BORROWER BIT(0)
> +       u8 flag;
> +       u32 composite_off;
> +       /*
> +        * Offset in bytes from the start of the outer `ffa_memory_region` to
> +        * an `struct ffa_mem_region_addr_range`.
> +        */
> +       u64 reserved;
> +};
> +
> +struct ffa_mem_region {
> +       /* The ID of the VM/owner which originally sent the memory region */
> +       u16 sender_id;
> +#define FFA_MEM_NORMAL         BIT(5)
> +#define FFA_MEM_DEVICE         BIT(4)
> +
> +#define FFA_MEM_WRITE_BACK     (3 << 2)
> +#define FFA_MEM_NON_CACHEABLE  (1 << 2)
> +
> +#define FFA_DEV_nGnRnE         (0 << 2)
> +#define FFA_DEV_nGnRE          (1 << 2)
> +#define FFA_DEV_nGRE           (2 << 2)
> +#define FFA_DEV_GRE            (3 << 2)
> +
> +#define FFA_MEM_NON_SHAREABLE  (0)
> +#define FFA_MEM_OUTER_SHAREABLE        (2)
> +#define FFA_MEM_INNER_SHAREABLE        (3)
> +       u8 attributes;
> +       u8 reserved_0;
> +/*
> + * Clear memory region contents after unmapping it from the sender and
> + * before mapping it for any receiver.
> + */
> +#define FFA_MEM_CLEAR                  BIT(0)
> +/*
> + * Whether the hypervisor may time slice the memory sharing or retrieval
> + * operation.
> + */
> +#define FFA_TIME_SLICE_ENABLE          BIT(1)
> +
> +/*
> + * Whether the hypervisor should clear the memory region before the receiver
> + * relinquishes it or is aborted.
> + */
> +#define FFA_MEM_CLEAR_BEFORE_RELINQUISH        BIT(0)
> +/*
> + * Whether the hypervisor should clear the memory region after the receiver
> + * relinquishes it or is aborted.
> + */
> +#define FFA_MEM_CLEAR_AFTER_RELINQUISH BIT(2)
> +
> +#define FFA_MEM_RETRIEVE_TYPE_IN_RESP  (0 << 3)
> +#define FFA_MEM_RETRIEVE_TYPE_SHARE    (1 << 3)
> +#define FFA_MEM_RETRIEVE_TYPE_LEND     (2 << 3)
> +#define FFA_MEM_RETRIEVE_TYPE_DONATE   (3 << 3)
> +
> +#define FFA_MEM_RETRIEVE_ADDR_ALIGN_HINT       BIT(9)
> +#define FFA_MEM_RETRIEVE_ADDR_ALIGN(x)         ((x) << 5)
> +       /* Flags to control behaviour of the transaction. */
> +       u32 flags;
> +#define HANDLE_LOW_MASK                GENMASK_ULL(31, 0)
> +#define HANDLE_HIGH_MASK       GENMASK_ULL(63, 32)
> +#define HANDLE_LOW(x)          (u32)(FIELD_GET(HANDLE_LOW_MASK, (x)))
> +#define        HANDLE_HIGH(x)          (u32)(FIELD_GET(HANDLE_HIGH_MASK, (x)))
> +
> +#define PACK_HANDLE(l, h)              \
> +       (FIELD_PREP(HANDLE_LOW_MASK, (l)) | FIELD_PREP(HANDLE_HIGH_MASK, (h)))
> +       /*
> +        * A globally-unique ID assigned by the hypervisor for a region
> +        * of memory being sent between VMs.
> +        */
> +       u64 handle;
> +       /*
> +        * An implementation defined value associated with the receiver and the
> +        * memory region.
> +        */
> +       u64 tag;
> +       u32 reserved_1;
> +       /*
> +        * The number of `ffa_mem_region_attributes` entries included in this
> +        * transaction.
> +        */
> +       u32 ep_count;
> +       /*
> +        * An array of endpoint memory access descriptors.
> +        * Each one specifies a memory region offset, an endpoint and the
> +        * attributes with which this memory region should be mapped in that
> +        * endpoint's page table.
> +        */
> +       struct ffa_mem_region_attributes ep_mem_access[];
> +};
> +
> +#define        COMPOSITE_OFFSET(x)     \
> +       (offsetof(struct ffa_mem_region, ep_mem_access[x]))
> +#define CONSTITUENTS_OFFSET(x) \
> +       (offsetof(struct ffa_composite_mem_region, constituents[x]))
> +#define COMPOSITE_CONSTITUENTS_OFFSET(x, y)    \
> +       (COMPOSITE_OFFSET(x) + CONSTITUENTS_OFFSET(y))
> +
> +struct ffa_mem_ops_args {
> +       bool use_txbuf;
> +       u64 tag;
> +       u32 flags;
> +       struct ffa_mem_region_attributes *attrs;
> +       u32 nattrs;
> +       struct scatterlist *sg;
> +       u64 *g_handle;
It seems a bit inconvenient with a pointer instead of a value here.


Cheers,
Jens

> +};
> +
>  struct ffa_dev_ops {
>         u32 (*api_version_get)(void);
>         u16 (*partition_id_get)(struct ffa_device *dev);
> @@ -116,6 +263,8 @@ struct ffa_dev_ops {
>                                   struct ffa_partition_info *buffer);
>         int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
>                                  struct ffa_send_direct_data *data);
> +       int (*memory_reclaim)(u64 g_handle, u32 flags);
> +       int (*memory_share)(struct ffa_mem_ops_args *args);
>  };
>
>  #endif /* _LINUX_ARM_FFA_H */
> --
> 2.25.1
>

Re: [PATCH v3 7/7] firmware: arm_ffa: Add support for MEM_* interfaces

[Jens Wiklander]

On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
>
> Most of the MEM_* APIs share the same parameters, so they can be
> generalised. Currently only MEM_SHARE is implemented and the user space
> interface for that is not added yet.
>
> Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> ---
>  drivers/firmware/arm_ffa/driver.c | 180 ++++++++++++++++++++++++++++++
>  include/linux/arm_ffa.h           | 149 +++++++++++++++++++++++++
>  2 files changed, 329 insertions(+)
>
> diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> index 3e4ba841dbf8..92a0bf542f18 100644
> --- a/drivers/firmware/arm_ffa/driver.c
> +++ b/drivers/firmware/arm_ffa/driver.c
> @@ -28,7 +28,9 @@
>  #include <linux/io.h>
>  #include <linux/kernel.h>
>  #include <linux/module.h>
> +#include <linux/mm.h>
>  #include <linux/of.h>
> +#include <linux/scatterlist.h>
>  #include <linux/slab.h>
>  #include <linux/uuid.h>
>
> @@ -306,6 +308,177 @@ static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
>         return 0;
>  }
>
> +static int ffa_mem_first_frag(u32 func_id, phys_addr_t buf, u32 buf_sz,
> +                             u32 frag_len, u32 len, u64 *handle)
> +{
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(func_id, len, frag_len, buf, buf_sz, 0, 0, 0);
> +
> +       while (ret.a0 == FFA_MEM_OP_PAUSE)
> +               ret = invoke_ffa_fn(FFA_MEM_OP_RESUME, ret.a1, ret.a2,
> +                                   0, 0, 0, 0, 0);
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       if (ret.a0 != FFA_SUCCESS)
> +               return -EOPNOTSUPP;
> +
> +       if (handle)
> +               *handle = PACK_HANDLE(ret.a3, ret.a2);
ret.a2 are the lower 32bit and ret.a3 the higher 32bits according to
5.10.2 Memory region handle

> +
> +       return frag_len;
> +}
> +
> +static int ffa_mem_next_frag(u64 handle, u32 frag_len)
> +{
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(FFA_MEM_FRAG_TX, HANDLE_LOW(handle),
> +                           HANDLE_HIGH(handle), frag_len, 0, 0, 0, 0);
> +
> +       while (ret.a0 == FFA_MEM_OP_PAUSE)
> +               ret = invoke_ffa_fn(FFA_MEM_OP_RESUME, ret.a1, ret.a2,
> +                                   0, 0, 0, 0, 0);
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       if (ret.a0 != FFA_MEM_FRAG_RX)
> +               return -EOPNOTSUPP;
> +
> +       return ret.a3;
> +}
> +
> +static int
> +ffa_transmit_fragment(u32 func_id, phys_addr_t buf, u32 buf_sz, u32 frag_len,
> +                     u32 len, u64 *handle, bool first)
> +{
> +       if (!first)
> +               return ffa_mem_next_frag(*handle, frag_len);
> +
> +       return ffa_mem_first_frag(func_id, buf, buf_sz, frag_len,
> +                                     len, handle);
> +}
> +
> +static u32 ffa_get_num_pages_sg(struct scatterlist *sg)
> +{
> +       u32 num_pages = 0;
> +
> +       do {
> +               num_pages += sg->length / FFA_PAGE_SIZE;
> +       } while ((sg = sg_next(sg)));
> +
> +       return num_pages;
> +}
> +
> +static int
> +ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize,
> +                      struct ffa_mem_ops_args *args)
> +{
> +       int rc = 0;
> +       bool first = true;
> +       phys_addr_t addr = 0;
> +       struct ffa_composite_mem_region *composite;
> +       struct ffa_mem_region_addr_range *constituents;
> +       struct ffa_mem_region_attributes *ep_mem_access;
> +       struct ffa_mem_region *mem_region = buffer;
> +       u32 idx, frag_len, length, num_entries = sg_nents(args->sg);
> +       u32 buf_sz = max_fragsize / FFA_PAGE_SIZE;
This must be zero following the same logic as for addr, see 11.3 FFA_MEM_SHARE

> +
> +       mem_region->tag = args->tag;
> +       mem_region->flags = args->flags;
> +       mem_region->sender_id = drv_info->vm_id;
> +       mem_region->attributes = FFA_MEM_NORMAL | FFA_MEM_WRITE_BACK |
> +                                FFA_MEM_INNER_SHAREABLE;
> +       ep_mem_access = &mem_region->ep_mem_access[0];
> +
> +       for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) {
> +               ep_mem_access->receiver = args->attrs[idx].receiver;
> +               ep_mem_access->attrs = args->attrs[idx].attrs;
> +               ep_mem_access->composite_off = COMPOSITE_OFFSET(args->nattrs);
> +       }
> +       mem_region->ep_count = args->nattrs;
> +
> +       composite = buffer + COMPOSITE_OFFSET(args->nattrs);
> +       composite->total_pg_cnt = ffa_get_num_pages_sg(args->sg);
> +       composite->addr_range_cnt = num_entries;
> +
> +       length = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, num_entries);
> +       frag_len = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, 0);
> +       if (frag_len > max_fragsize)
> +               return -ENXIO;
> +
> +       if (!args->use_txbuf)
> +               addr = virt_to_phys(buffer);
> +
> +       constituents = buffer + frag_len;
> +       idx = 0;
> +       do {
> +               if (frag_len == max_fragsize) {
> +                       rc = ffa_transmit_fragment(func_id, addr, buf_sz,
> +                                                  frag_len, length,
> +                                                  args->g_handle, first);
> +                       if (rc < 0)
> +                               return -ENXIO;
> +
> +                       first = false;
> +                       idx = 0;
> +                       frag_len = 0;
> +                       constituents = buffer;
> +               }
> +
> +               if ((void *)constituents - buffer > max_fragsize) {
> +                       pr_err("Memory Region Fragment > Tx Buffer size\n");
> +                       return -EFAULT;
> +               }
> +
> +               constituents->address = sg_phys(args->sg);
> +               constituents->pg_cnt = args->sg->length / FFA_PAGE_SIZE;
> +               constituents++;
> +               frag_len += sizeof(struct ffa_mem_region_addr_range);
> +       } while ((args->sg = sg_next(args->sg)));
> +
> +       return ffa_transmit_fragment(func_id, addr, buf_sz, frag_len,
> +                                    length, args->g_handle, first);
> +}
> +
> +static int ffa_memory_ops(u32 func_id, struct ffa_mem_ops_args *args)
> +{
> +       int ret;
> +       void *buffer;
> +
> +       if (!args->use_txbuf) {
> +               buffer = alloc_pages_exact(RXTX_BUFFER_SIZE, GFP_KERNEL);
> +               if (!buffer)
> +                       return -ENOMEM;
> +       } else {
> +               buffer = drv_info->tx_buffer;
> +               mutex_lock(&drv_info->tx_lock);
> +       }
> +
> +       ret = ffa_setup_and_transmit(func_id, buffer, RXTX_BUFFER_SIZE, args);
> +
> +       if (args->use_txbuf)
> +               mutex_unlock(&drv_info->tx_lock);
> +       else
> +               free_pages_exact(buffer, RXTX_BUFFER_SIZE);
> +
> +       return ret < 0 ? ret : 0;
> +}
> +
> +static int ffa_memory_reclaim(u64 g_handle, u32 flags)
> +{
> +       ffa_res_t ret;
> +
> +       ret = invoke_ffa_fn(FFA_MEM_RECLAIM, HANDLE_LOW(g_handle),
> +                           HANDLE_HIGH(g_handle), flags, 0, 0, 0, 0);
> +
> +       if (ret.a0 == FFA_ERROR)
> +               return ffa_to_linux_errno((int)ret.a2);
> +
> +       return 0;
> +}
> +
>  static u32 ffa_api_version_get(void)
>  {
>         return drv_info->version;
> @@ -331,11 +504,18 @@ static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
>         return ffa_msg_send_direct_req(dev->vm_id, ep, data);
>  }
>
> +static int ffa_memory_share(struct ffa_mem_ops_args *args)
> +{
> +       return ffa_memory_ops(FFA_FN_NATIVE(MEM_SHARE), args);
> +}
> +
>  static const struct ffa_dev_ops ffa_ops = {
>         .api_version_get = ffa_api_version_get,
>         .partition_id_get = ffa_partition_id_get,
>         .partition_info_get = ffa_partition_info_get,
>         .sync_send_receive = ffa_sync_send_receive,
> +       .memory_reclaim = ffa_memory_reclaim,
> +       .memory_share = ffa_memory_share,
>  };
>
>  const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
> index 8604c48289ce..67e3180e7097 100644
> --- a/include/linux/arm_ffa.h
> +++ b/include/linux/arm_ffa.h
> @@ -109,6 +109,153 @@ struct ffa_send_direct_data {
>         unsigned long data4;
>  };
>
> +struct ffa_mem_region_addr_range {
> +       /* The base IPA of the constituent memory region, aligned to 4 kiB */
> +       u64 address;
> +       /* The number of 4 kiB pages in the constituent memory region. */
> +       u32 pg_cnt;
> +       u32 reserved;
> +};
> +
> +struct ffa_composite_mem_region {
> +       /*
> +        * The total number of 4 kiB pages included in this memory region. This
> +        * must be equal to the sum of page counts specified in each
> +        * `struct ffa_mem_region_addr_range`.
> +        */
> +       u32 total_pg_cnt;
> +       /* The number of constituents included in this memory region range */
> +       u32 addr_range_cnt;
> +       u64 reserved;
> +       /** An array of `addr_range_cnt` memory region constituents. */
> +       struct ffa_mem_region_addr_range constituents[];
> +};
> +
> +struct ffa_mem_region_attributes {
> +       /* The ID of the VM to which the memory is being given or shared. */
> +       u16 receiver;
> +       /*
> +        * The permissions with which the memory region should be mapped in the
> +        * receiver's page table.
> +        */
> +#define FFA_MEM_EXEC   BIT(3)
> +#define FFA_MEM_NO_EXEC        BIT(2)
> +#define FFA_MEM_RW             BIT(1)
> +#define FFA_MEM_RO             BIT(0)
> +       u8 attrs;
> +       /*
> +        * Flags used during FFA_MEM_RETRIEVE_REQ and FFA_MEM_RETRIEVE_RESP
> +        * for memory regions with multiple borrowers.
> +        */
> +#define FFA_MEM_RETRIEVE_SELF_BORROWER BIT(0)
> +       u8 flag;
> +       u32 composite_off;
> +       /*
> +        * Offset in bytes from the start of the outer `ffa_memory_region` to
> +        * an `struct ffa_mem_region_addr_range`.
> +        */
> +       u64 reserved;
> +};
> +
> +struct ffa_mem_region {
> +       /* The ID of the VM/owner which originally sent the memory region */
> +       u16 sender_id;
> +#define FFA_MEM_NORMAL         BIT(5)
> +#define FFA_MEM_DEVICE         BIT(4)
> +
> +#define FFA_MEM_WRITE_BACK     (3 << 2)
> +#define FFA_MEM_NON_CACHEABLE  (1 << 2)
> +
> +#define FFA_DEV_nGnRnE         (0 << 2)
> +#define FFA_DEV_nGnRE          (1 << 2)
> +#define FFA_DEV_nGRE           (2 << 2)
> +#define FFA_DEV_GRE            (3 << 2)
> +
> +#define FFA_MEM_NON_SHAREABLE  (0)
> +#define FFA_MEM_OUTER_SHAREABLE        (2)
> +#define FFA_MEM_INNER_SHAREABLE        (3)
> +       u8 attributes;
> +       u8 reserved_0;
> +/*
> + * Clear memory region contents after unmapping it from the sender and
> + * before mapping it for any receiver.
> + */
> +#define FFA_MEM_CLEAR                  BIT(0)
> +/*
> + * Whether the hypervisor may time slice the memory sharing or retrieval
> + * operation.
> + */
> +#define FFA_TIME_SLICE_ENABLE          BIT(1)
> +
> +/*
> + * Whether the hypervisor should clear the memory region before the receiver
> + * relinquishes it or is aborted.
> + */
> +#define FFA_MEM_CLEAR_BEFORE_RELINQUISH        BIT(0)
> +/*
> + * Whether the hypervisor should clear the memory region after the receiver
> + * relinquishes it or is aborted.
> + */
> +#define FFA_MEM_CLEAR_AFTER_RELINQUISH BIT(2)
> +
> +#define FFA_MEM_RETRIEVE_TYPE_IN_RESP  (0 << 3)
> +#define FFA_MEM_RETRIEVE_TYPE_SHARE    (1 << 3)
> +#define FFA_MEM_RETRIEVE_TYPE_LEND     (2 << 3)
> +#define FFA_MEM_RETRIEVE_TYPE_DONATE   (3 << 3)
> +
> +#define FFA_MEM_RETRIEVE_ADDR_ALIGN_HINT       BIT(9)
> +#define FFA_MEM_RETRIEVE_ADDR_ALIGN(x)         ((x) << 5)
> +       /* Flags to control behaviour of the transaction. */
> +       u32 flags;
> +#define HANDLE_LOW_MASK                GENMASK_ULL(31, 0)
> +#define HANDLE_HIGH_MASK       GENMASK_ULL(63, 32)
> +#define HANDLE_LOW(x)          (u32)(FIELD_GET(HANDLE_LOW_MASK, (x)))
> +#define        HANDLE_HIGH(x)          (u32)(FIELD_GET(HANDLE_HIGH_MASK, (x)))
> +
> +#define PACK_HANDLE(l, h)              \
> +       (FIELD_PREP(HANDLE_LOW_MASK, (l)) | FIELD_PREP(HANDLE_HIGH_MASK, (h)))
> +       /*
> +        * A globally-unique ID assigned by the hypervisor for a region
> +        * of memory being sent between VMs.
> +        */
> +       u64 handle;
> +       /*
> +        * An implementation defined value associated with the receiver and the
> +        * memory region.
> +        */
> +       u64 tag;
> +       u32 reserved_1;
> +       /*
> +        * The number of `ffa_mem_region_attributes` entries included in this
> +        * transaction.
> +        */
> +       u32 ep_count;
> +       /*
> +        * An array of endpoint memory access descriptors.
> +        * Each one specifies a memory region offset, an endpoint and the
> +        * attributes with which this memory region should be mapped in that
> +        * endpoint's page table.
> +        */
> +       struct ffa_mem_region_attributes ep_mem_access[];
> +};
> +
> +#define        COMPOSITE_OFFSET(x)     \
> +       (offsetof(struct ffa_mem_region, ep_mem_access[x]))
> +#define CONSTITUENTS_OFFSET(x) \
> +       (offsetof(struct ffa_composite_mem_region, constituents[x]))
> +#define COMPOSITE_CONSTITUENTS_OFFSET(x, y)    \
> +       (COMPOSITE_OFFSET(x) + CONSTITUENTS_OFFSET(y))
> +
> +struct ffa_mem_ops_args {
> +       bool use_txbuf;
> +       u64 tag;
> +       u32 flags;
> +       struct ffa_mem_region_attributes *attrs;
> +       u32 nattrs;
> +       struct scatterlist *sg;
> +       u64 *g_handle;
It seems a bit inconvenient with a pointer instead of a value here.


Cheers,
Jens

> +};
> +
>  struct ffa_dev_ops {
>         u32 (*api_version_get)(void);
>         u16 (*partition_id_get)(struct ffa_device *dev);
> @@ -116,6 +263,8 @@ struct ffa_dev_ops {
>                                   struct ffa_partition_info *buffer);
>         int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
>                                  struct ffa_send_direct_data *data);
> +       int (*memory_reclaim)(u64 g_handle, u32 flags);
> +       int (*memory_share)(struct ffa_mem_ops_args *args);
>  };
>
>  #endif /* _LINUX_ARM_FFA_H */
> --
> 2.25.1
>

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

One more comment below.

On Fri, Dec 11, 2020 at 11:45 AM Jens Wiklander
<jens.wiklander@linaro.org> wrote:
>
> Hi Sudeep,
>
> Some more comments below.
>
> On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
> >
> > Parse the FFA nodes from the device-tree and register all the partitions
> > whose services will be used in the kernel.
> >
> > In order to also enable in-kernel users of FFA interface, let us add
> > simple set of operations for such devices.
> >
> > The in-kernel users are registered without the character device interface.
> >
> > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > ---
> >  drivers/firmware/arm_ffa/common.h |   2 +
> >  drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
> >  include/linux/arm_ffa.h           |  36 +++++-
> >  3 files changed, 223 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
> > index d019348bf67d..eb1371c2b2b8 100644
> > --- a/drivers/firmware/arm_ffa/common.h
> > +++ b/drivers/firmware/arm_ffa/common.h
> > @@ -6,6 +6,7 @@
> >  #ifndef _FFA_COMMON_H
> >  #define _FFA_COMMON_H
> >
> > +#include <linux/arm_ffa.h>
> >  #include <linux/arm-smccc.h>
> >  #include <linux/err.h>
> >
> > @@ -17,6 +18,7 @@ typedef ffa_res_t
> >
> >  int __init arm_ffa_bus_init(void);
> >  void __exit arm_ffa_bus_exit(void);
> > +bool ffa_device_is_valid(struct ffa_device *ffa_dev);
> >
> >  #ifdef CONFIG_ARM_FFA_SMCCC
> >  int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
> > diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> > index 257b331d781c..3e4ba841dbf8 100644
> > --- a/drivers/firmware/arm_ffa/driver.c
> > +++ b/drivers/firmware/arm_ffa/driver.c
> > @@ -24,9 +24,13 @@
> >
> >  #include <linux/arm_ffa.h>
> >  #include <linux/bitfield.h>
> > +#include <linux/device.h>
> >  #include <linux/io.h>
> > +#include <linux/kernel.h>
> >  #include <linux/module.h>
> > +#include <linux/of.h>
> >  #include <linux/slab.h>
> > +#include <linux/uuid.h>
> >
> >  #include "common.h"
> >
> > @@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
> >         return 0;
> >  }
> >
> > +static int ffa_rx_release(void)
> > +{
> > +       ffa_res_t ret;
> > +
> > +       ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
> > +
> > +       if (ret.a0 == FFA_ERROR)
> > +               return ffa_to_linux_errno((int)ret.a2);
> > +
> > +       /* check for ret.a0 == FFA_RX_RELEASE ? */
> > +
> > +       return 0;
> > +}
> > +
> >  static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
> >  {
> >         ffa_res_t ret;
> > @@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
> >         return 0;
> >  }
> >
> > +static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
> > +                                   struct ffa_partition_info **buffer)
> > +{
> > +       int count;
> > +       ffa_res_t partition_info;
> > +
> > +       mutex_lock(&drv_info->rx_lock);
> > +       partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
> > +                                      uuid2, uuid3, 0, 0, 0);
> > +
> > +       if (partition_info.a0 == FFA_ERROR)
> > +               return ffa_to_linux_errno((int)partition_info.a2);
> > +
> > +       count = partition_info.a2;
> > +
> > +       if (buffer)
> > +               memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
> > +
> > +       ffa_rx_release();
> > +
> > +       mutex_unlock(&drv_info->rx_lock);
> > +
> > +       return count;
> > +}
> > +
> > +static int ffa_partition_probe(const char *uuid_str,
> > +                              struct ffa_partition_info *buffer)
> > +{
> > +       int count;
> > +       uuid_t uuid;
> > +       u32 uuid0_4[4] = { 0 };
> > +
> > +       if (uuid_parse(uuid_str, &uuid)) {
> > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > +               return -ENODEV;
> > +       }
> > +
> > +       export_uuid((u8 *)uuid0_4, &uuid);
> > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > +                                        uuid0_4[3], &buffer);
Wrong byte order?
According to section 5.3 of the SMCCC, UUIDs are returned as a single
128-bit value using the SMC32 calling convention. This value is mapped
to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
for example shall hold bytes 0 to 3, with byte 0 in the low-order
bits.

Cheers,
Jens

> > +
> > +       return count;
> > +}
> > +
> >  #define VM_ID_MASK     GENMASK(15, 0)
> >  static int ffa_id_get(u16 *vm_id)
> >  {
> > @@ -218,9 +280,125 @@ static int ffa_id_get(u16 *vm_id)
> >         return 0;
> >  }
> >
> > +static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
> > +                                  struct ffa_send_direct_data *data)
> > +{
> > +       u32 src_dst_ids = PACK_TARGET_INFO(src_id, dst_id);
> > +       ffa_res_t ret;
> > +
> > +       ret = invoke_ffa_fn(FFA_FN_NATIVE(MSG_SEND_DIRECT_REQ), src_dst_ids, 0,
> > +                           data->data0, data->data1, data->data2,
> > +                           data->data3, data->data4);
> > +
> > +       while (ret.a0 == FFA_INTERRUPT)
> > +               ret = invoke_ffa_fn(FFA_RUN, ret.a1, 0, 0, 0, 0, 0, 0);
> > +       if (ret.a0 == FFA_ERROR)
> > +               return ffa_to_linux_errno((int)ret.a2);
> > +
> > +       if (ret.a0 == FFA_FN_NATIVE(MSG_SEND_DIRECT_RESP)) {
> > +               data->data0 = ret.a3;
> > +               data->data1 = ret.a4;
> > +               data->data2 = ret.a5;
> > +               data->data3 = ret.a6;
> > +               data->data4 = ret.a7;
> > +       }
> > +
> > +       return 0;
> > +}
> > +
> > +static u32 ffa_api_version_get(void)
> > +{
> > +       return drv_info->version;
> > +}
> > +
> > +static u16 ffa_partition_id_get(struct ffa_device *dev)
> > +{
> > +       return dev->vm_id;
> > +}
> > +
> > +static int ffa_partition_info_get(const char *uuid_str,
> > +                                 struct ffa_partition_info *buffer)
> > +{
> > +       if (ffa_partition_probe(uuid_str, buffer) == 1)
> > +               return 0;
> > +
> > +       return -ENOENT;
> > +}
> > +
> > +static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
> > +                                struct ffa_send_direct_data *data)
> > +{
> > +       return ffa_msg_send_direct_req(dev->vm_id, ep, data);
> > +}
> > +
> > +static const struct ffa_dev_ops ffa_ops = {
> > +       .api_version_get = ffa_api_version_get,
> > +       .partition_id_get = ffa_partition_id_get,
> > +       .partition_info_get = ffa_partition_info_get,
> > +       .sync_send_receive = ffa_sync_send_receive,
> > +};
> > +
> > +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> > +{
> > +       if (ffa_device_is_valid(dev))
> > +               return &ffa_ops;
> > +
> > +       return NULL;
> > +}
> > +EXPORT_SYMBOL_GPL(ffa_dev_ops_get);
> > +
> > +int ffa_setup_partitions(struct device_node *np)
> This function is only used internally and the return value is ignored.
> Maybe make it static void instead?
>
> > +{
> > +       int ret;
> > +       struct device_node *child;
> > +       struct ffa_device *ffa_dev;
> > +       struct ffa_partition_info pbuf;
> > +       const char *p_uuid, *pfx = "Ignoring FFA partition";
> > +       uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
> > +
> > +       for_each_child_of_node(np, child) {
> of_node_put() should only be called on child in case we're leaving the
> loop early. for_each_child_of_node() takes care of the other case.
>
> > +               if (!of_device_is_compatible(child, "arm,ffa-1.0-partition")) {
> > +                       of_node_put(child);
> > +                       continue;
> > +               }
> > +
> > +               if (of_property_read_string(child, "uuid", &p_uuid)) {
> > +                       pr_err("%s: failed to parse \"uuid\" property\n", pfx);
> > +                       of_node_put(child);
> > +                       continue;
> > +               }
> > +
> > +               of_node_put(child);
> > +
> > +               if (uuid_parse(p_uuid, &uuid)) {
> > +                       pr_err("%s: invalid \"uuid\" property (%s)\n",
> > +                              pfx, p_uuid);
> > +                       continue;
> > +               }
> > +
> > +               ret = ffa_partition_probe(p_uuid, &pbuf);
> > +               if (ret != 1) {
> > +                       pr_err("%s: %s partition info probe failed\n",
> > +                              pfx, p_uuid);
> > +                       return -EINVAL;
> > +               }
> > +
> > +               ffa_dev = ffa_device_register(p_uuid, pbuf.id);
> > +               if (!ffa_dev) {
> > +                       pr_err("%s: failed to register %s\n", pfx, p_uuid);
> > +                       continue;
> > +               }
> > +
> > +               ffa_dev_set_drvdata(ffa_dev, drv_info);
> > +       }
> > +
> > +       return 0;
> > +}
> > +
> >  static int __init ffa_init(void)
> >  {
> >         int ret;
> > +       struct device_node *np;
> >
> >         ret = arm_ffa_bus_init();
> >         if (ret)
> > @@ -267,6 +445,14 @@ static int __init ffa_init(void)
> >         mutex_init(&drv_info->rx_lock);
> >         mutex_init(&drv_info->tx_lock);
> >
> > +       /* Set up all the partitions */
> > +       np = of_find_compatible_node(NULL, NULL, "arm,ffa-1.0");
> > +       if (!np)
> > +               return 0;
> > +
> > +       ffa_setup_partitions(np);
> > +       of_node_put(np);
> > +
> >         return 0;
> >  free_pages:
> >         if (drv_info->tx_buffer)
> > diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
> > index 3defddfb40fc..8604c48289ce 100644
> > --- a/include/linux/arm_ffa.h
> > +++ b/include/linux/arm_ffa.h
> > @@ -6,7 +6,6 @@
> >  #ifndef _LINUX_ARM_FFA_H
> >  #define _LINUX_ARM_FFA_H
> >
> > -#include <linux/cdev.h>
> >  #include <linux/device.h>
> >  #include <linux/module.h>
> >  #include <linux/types.h>
> > @@ -47,6 +46,7 @@ void ffa_device_unregister(struct ffa_device *ffa_dev);
> >  int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
> >                         const char *mod_name);
> >  void ffa_driver_unregister(struct ffa_driver *driver);
> > +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev);
> >
> >  #else
> >  static inline
> > @@ -66,6 +66,10 @@ ffa_driver_register(struct ffa_driver *driver, struct module *owner,
> >
> >  static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
> >
> > +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> > +{
> > +       return NULL;
> > +}
> >  #endif /* CONFIG_ARM_FFA_TRANSPORT */
> >
> >  #define ffa_register(driver) \
> > @@ -84,4 +88,34 @@ static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
> >  #define module_ffa_driver(__ffa_driver)        \
> >         module_driver(__ffa_driver, ffa_register, ffa_unregister)
> >
> > +/* FFA transport related */
> > +struct ffa_partition_info {
> > +       u16 id;
> > +       u16 exec_ctxt;
> > +/* partition supports receipt of direct requests */
> > +#define FFA_PARTITION_DIRECT_RECV      BIT(0)
> > +/* partition can send direct requests. */
> > +#define FFA_PARTITION_DIRECT_SEND      BIT(1)
> > +/* partition can send and receive indirect messages. */
> > +#define FFA_PARTITION_INDIRECT_MSG     BIT(2)
> > +       u32 properties;
> > +};
> > +
> > +struct ffa_send_direct_data {
> > +       unsigned long data0;
> > +       unsigned long data1;
> > +       unsigned long data2;
> > +       unsigned long data3;
> > +       unsigned long data4;
> > +};
> A comment describing which register index these maps to would be helpful.
>
> > +
> > +struct ffa_dev_ops {
> > +       u32 (*api_version_get)(void);
> > +       u16 (*partition_id_get)(struct ffa_device *dev);
> > +       int (*partition_info_get)(const char *uuid_str,
> > +                                 struct ffa_partition_info *buffer);
> > +       int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
> > +                                struct ffa_send_direct_data *data);
> ep can be read directly from dev->vm_id
> We may need a way to indicate if we're to use the 32bit or 64bit
> calling convention. OP-TEE depends on being able to use 32bit calls
> here.
>
> Cheers,
> Jens
>
> > +};
> > +
> >  #endif /* _LINUX_ARM_FFA_H */
> > --
> > 2.25.1
> >

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

One more comment below.

On Fri, Dec 11, 2020 at 11:45 AM Jens Wiklander
<jens.wiklander@linaro.org> wrote:
>
> Hi Sudeep,
>
> Some more comments below.
>
> On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
> >
> > Parse the FFA nodes from the device-tree and register all the partitions
> > whose services will be used in the kernel.
> >
> > In order to also enable in-kernel users of FFA interface, let us add
> > simple set of operations for such devices.
> >
> > The in-kernel users are registered without the character device interface.
> >
> > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > ---
> >  drivers/firmware/arm_ffa/common.h |   2 +
> >  drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
> >  include/linux/arm_ffa.h           |  36 +++++-
> >  3 files changed, 223 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
> > index d019348bf67d..eb1371c2b2b8 100644
> > --- a/drivers/firmware/arm_ffa/common.h
> > +++ b/drivers/firmware/arm_ffa/common.h
> > @@ -6,6 +6,7 @@
> >  #ifndef _FFA_COMMON_H
> >  #define _FFA_COMMON_H
> >
> > +#include <linux/arm_ffa.h>
> >  #include <linux/arm-smccc.h>
> >  #include <linux/err.h>
> >
> > @@ -17,6 +18,7 @@ typedef ffa_res_t
> >
> >  int __init arm_ffa_bus_init(void);
> >  void __exit arm_ffa_bus_exit(void);
> > +bool ffa_device_is_valid(struct ffa_device *ffa_dev);
> >
> >  #ifdef CONFIG_ARM_FFA_SMCCC
> >  int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
> > diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> > index 257b331d781c..3e4ba841dbf8 100644
> > --- a/drivers/firmware/arm_ffa/driver.c
> > +++ b/drivers/firmware/arm_ffa/driver.c
> > @@ -24,9 +24,13 @@
> >
> >  #include <linux/arm_ffa.h>
> >  #include <linux/bitfield.h>
> > +#include <linux/device.h>
> >  #include <linux/io.h>
> > +#include <linux/kernel.h>
> >  #include <linux/module.h>
> > +#include <linux/of.h>
> >  #include <linux/slab.h>
> > +#include <linux/uuid.h>
> >
> >  #include "common.h"
> >
> > @@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
> >         return 0;
> >  }
> >
> > +static int ffa_rx_release(void)
> > +{
> > +       ffa_res_t ret;
> > +
> > +       ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
> > +
> > +       if (ret.a0 == FFA_ERROR)
> > +               return ffa_to_linux_errno((int)ret.a2);
> > +
> > +       /* check for ret.a0 == FFA_RX_RELEASE ? */
> > +
> > +       return 0;
> > +}
> > +
> >  static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
> >  {
> >         ffa_res_t ret;
> > @@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
> >         return 0;
> >  }
> >
> > +static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
> > +                                   struct ffa_partition_info **buffer)
> > +{
> > +       int count;
> > +       ffa_res_t partition_info;
> > +
> > +       mutex_lock(&drv_info->rx_lock);
> > +       partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
> > +                                      uuid2, uuid3, 0, 0, 0);
> > +
> > +       if (partition_info.a0 == FFA_ERROR)
> > +               return ffa_to_linux_errno((int)partition_info.a2);
> > +
> > +       count = partition_info.a2;
> > +
> > +       if (buffer)
> > +               memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
> > +
> > +       ffa_rx_release();
> > +
> > +       mutex_unlock(&drv_info->rx_lock);
> > +
> > +       return count;
> > +}
> > +
> > +static int ffa_partition_probe(const char *uuid_str,
> > +                              struct ffa_partition_info *buffer)
> > +{
> > +       int count;
> > +       uuid_t uuid;
> > +       u32 uuid0_4[4] = { 0 };
> > +
> > +       if (uuid_parse(uuid_str, &uuid)) {
> > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > +               return -ENODEV;
> > +       }
> > +
> > +       export_uuid((u8 *)uuid0_4, &uuid);
> > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > +                                        uuid0_4[3], &buffer);
Wrong byte order?
According to section 5.3 of the SMCCC, UUIDs are returned as a single
128-bit value using the SMC32 calling convention. This value is mapped
to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
for example shall hold bytes 0 to 3, with byte 0 in the low-order
bits.

Cheers,
Jens

> > +
> > +       return count;
> > +}
> > +
> >  #define VM_ID_MASK     GENMASK(15, 0)
> >  static int ffa_id_get(u16 *vm_id)
> >  {
> > @@ -218,9 +280,125 @@ static int ffa_id_get(u16 *vm_id)
> >         return 0;
> >  }
> >
> > +static int ffa_msg_send_direct_req(u16 src_id, u16 dst_id,
> > +                                  struct ffa_send_direct_data *data)
> > +{
> > +       u32 src_dst_ids = PACK_TARGET_INFO(src_id, dst_id);
> > +       ffa_res_t ret;
> > +
> > +       ret = invoke_ffa_fn(FFA_FN_NATIVE(MSG_SEND_DIRECT_REQ), src_dst_ids, 0,
> > +                           data->data0, data->data1, data->data2,
> > +                           data->data3, data->data4);
> > +
> > +       while (ret.a0 == FFA_INTERRUPT)
> > +               ret = invoke_ffa_fn(FFA_RUN, ret.a1, 0, 0, 0, 0, 0, 0);
> > +       if (ret.a0 == FFA_ERROR)
> > +               return ffa_to_linux_errno((int)ret.a2);
> > +
> > +       if (ret.a0 == FFA_FN_NATIVE(MSG_SEND_DIRECT_RESP)) {
> > +               data->data0 = ret.a3;
> > +               data->data1 = ret.a4;
> > +               data->data2 = ret.a5;
> > +               data->data3 = ret.a6;
> > +               data->data4 = ret.a7;
> > +       }
> > +
> > +       return 0;
> > +}
> > +
> > +static u32 ffa_api_version_get(void)
> > +{
> > +       return drv_info->version;
> > +}
> > +
> > +static u16 ffa_partition_id_get(struct ffa_device *dev)
> > +{
> > +       return dev->vm_id;
> > +}
> > +
> > +static int ffa_partition_info_get(const char *uuid_str,
> > +                                 struct ffa_partition_info *buffer)
> > +{
> > +       if (ffa_partition_probe(uuid_str, buffer) == 1)
> > +               return 0;
> > +
> > +       return -ENOENT;
> > +}
> > +
> > +static int ffa_sync_send_receive(struct ffa_device *dev, u16 ep,
> > +                                struct ffa_send_direct_data *data)
> > +{
> > +       return ffa_msg_send_direct_req(dev->vm_id, ep, data);
> > +}
> > +
> > +static const struct ffa_dev_ops ffa_ops = {
> > +       .api_version_get = ffa_api_version_get,
> > +       .partition_id_get = ffa_partition_id_get,
> > +       .partition_info_get = ffa_partition_info_get,
> > +       .sync_send_receive = ffa_sync_send_receive,
> > +};
> > +
> > +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> > +{
> > +       if (ffa_device_is_valid(dev))
> > +               return &ffa_ops;
> > +
> > +       return NULL;
> > +}
> > +EXPORT_SYMBOL_GPL(ffa_dev_ops_get);
> > +
> > +int ffa_setup_partitions(struct device_node *np)
> This function is only used internally and the return value is ignored.
> Maybe make it static void instead?
>
> > +{
> > +       int ret;
> > +       struct device_node *child;
> > +       struct ffa_device *ffa_dev;
> > +       struct ffa_partition_info pbuf;
> > +       const char *p_uuid, *pfx = "Ignoring FFA partition";
> > +       uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
> > +
> > +       for_each_child_of_node(np, child) {
> of_node_put() should only be called on child in case we're leaving the
> loop early. for_each_child_of_node() takes care of the other case.
>
> > +               if (!of_device_is_compatible(child, "arm,ffa-1.0-partition")) {
> > +                       of_node_put(child);
> > +                       continue;
> > +               }
> > +
> > +               if (of_property_read_string(child, "uuid", &p_uuid)) {
> > +                       pr_err("%s: failed to parse \"uuid\" property\n", pfx);
> > +                       of_node_put(child);
> > +                       continue;
> > +               }
> > +
> > +               of_node_put(child);
> > +
> > +               if (uuid_parse(p_uuid, &uuid)) {
> > +                       pr_err("%s: invalid \"uuid\" property (%s)\n",
> > +                              pfx, p_uuid);
> > +                       continue;
> > +               }
> > +
> > +               ret = ffa_partition_probe(p_uuid, &pbuf);
> > +               if (ret != 1) {
> > +                       pr_err("%s: %s partition info probe failed\n",
> > +                              pfx, p_uuid);
> > +                       return -EINVAL;
> > +               }
> > +
> > +               ffa_dev = ffa_device_register(p_uuid, pbuf.id);
> > +               if (!ffa_dev) {
> > +                       pr_err("%s: failed to register %s\n", pfx, p_uuid);
> > +                       continue;
> > +               }
> > +
> > +               ffa_dev_set_drvdata(ffa_dev, drv_info);
> > +       }
> > +
> > +       return 0;
> > +}
> > +
> >  static int __init ffa_init(void)
> >  {
> >         int ret;
> > +       struct device_node *np;
> >
> >         ret = arm_ffa_bus_init();
> >         if (ret)
> > @@ -267,6 +445,14 @@ static int __init ffa_init(void)
> >         mutex_init(&drv_info->rx_lock);
> >         mutex_init(&drv_info->tx_lock);
> >
> > +       /* Set up all the partitions */
> > +       np = of_find_compatible_node(NULL, NULL, "arm,ffa-1.0");
> > +       if (!np)
> > +               return 0;
> > +
> > +       ffa_setup_partitions(np);
> > +       of_node_put(np);
> > +
> >         return 0;
> >  free_pages:
> >         if (drv_info->tx_buffer)
> > diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h
> > index 3defddfb40fc..8604c48289ce 100644
> > --- a/include/linux/arm_ffa.h
> > +++ b/include/linux/arm_ffa.h
> > @@ -6,7 +6,6 @@
> >  #ifndef _LINUX_ARM_FFA_H
> >  #define _LINUX_ARM_FFA_H
> >
> > -#include <linux/cdev.h>
> >  #include <linux/device.h>
> >  #include <linux/module.h>
> >  #include <linux/types.h>
> > @@ -47,6 +46,7 @@ void ffa_device_unregister(struct ffa_device *ffa_dev);
> >  int ffa_driver_register(struct ffa_driver *driver, struct module *owner,
> >                         const char *mod_name);
> >  void ffa_driver_unregister(struct ffa_driver *driver);
> > +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev);
> >
> >  #else
> >  static inline
> > @@ -66,6 +66,10 @@ ffa_driver_register(struct ffa_driver *driver, struct module *owner,
> >
> >  static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
> >
> > +const struct ffa_dev_ops *ffa_dev_ops_get(struct ffa_device *dev)
> > +{
> > +       return NULL;
> > +}
> >  #endif /* CONFIG_ARM_FFA_TRANSPORT */
> >
> >  #define ffa_register(driver) \
> > @@ -84,4 +88,34 @@ static inline void ffa_driver_unregister(struct ffa_driver *driver) {}
> >  #define module_ffa_driver(__ffa_driver)        \
> >         module_driver(__ffa_driver, ffa_register, ffa_unregister)
> >
> > +/* FFA transport related */
> > +struct ffa_partition_info {
> > +       u16 id;
> > +       u16 exec_ctxt;
> > +/* partition supports receipt of direct requests */
> > +#define FFA_PARTITION_DIRECT_RECV      BIT(0)
> > +/* partition can send direct requests. */
> > +#define FFA_PARTITION_DIRECT_SEND      BIT(1)
> > +/* partition can send and receive indirect messages. */
> > +#define FFA_PARTITION_INDIRECT_MSG     BIT(2)
> > +       u32 properties;
> > +};
> > +
> > +struct ffa_send_direct_data {
> > +       unsigned long data0;
> > +       unsigned long data1;
> > +       unsigned long data2;
> > +       unsigned long data3;
> > +       unsigned long data4;
> > +};
> A comment describing which register index these maps to would be helpful.
>
> > +
> > +struct ffa_dev_ops {
> > +       u32 (*api_version_get)(void);
> > +       u16 (*partition_id_get)(struct ffa_device *dev);
> > +       int (*partition_info_get)(const char *uuid_str,
> > +                                 struct ffa_partition_info *buffer);
> > +       int (*sync_send_receive)(struct ffa_device *dev, u16 ep,
> > +                                struct ffa_send_direct_data *data);
> ep can be read directly from dev->vm_id
> We may need a way to indicate if we're to use the 32bit or 64bit
> calling convention. OP-TEE depends on being able to use 32bit calls
> here.
>
> Cheers,
> Jens
>
> > +};
> > +
> >  #endif /* _LINUX_ARM_FFA_H */
> > --
> > 2.25.1
> >

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Rob Herring]

On Fri, Dec 04, 2020 at 12:11:31PM +0000, Sudeep Holla wrote:
> Since the FF-A v1.0 specification doesn't list the UUID of all the
> partitions in the discovery API, we need to specify the UUID of the
> partitions that need to be accessed by drivers within the kernel.
> 
> This binding to provide the list of partitions that kernel drivers
> may need to access.
> 
> Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> ---
>  .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
>  1 file changed, 58 insertions(+)
>  create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
> 
> diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> new file mode 100644
> index 000000000000..a014a5801c34
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> @@ -0,0 +1,58 @@
> +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> +%YAML 1.2
> +---
> +$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
> +$schema: http://devicetree.org/meta-schemas/core.yaml#
> +
> +title: Arm Firmware Framework for Arm v8-A (in-kernel users)
> +
> +maintainers:
> +  - Sudeep Holla <sudeep.holla@arm.com>
> +
> +description: |
> +  Firmware frameworks implementing partition according to the FF-A
> +  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
> +  Framework for Arm v8-A") [0], providing services to be used by other
> +  partitions.
> +
> +  [0] https://developer.arm.com/docs/den0077/latest
> +
> +properties:
> +  $nodename:
> +    const: ffa
> +
> +  compatible:
> +    oneOf:
> +      - const: arm,ffa-1.0
> +
> +patternProperties:
> +  "^ffa_partition[0-9]+$":
> +    type: object
> +    description: One or more child nodes, each describing an FFA partition.
> +    properties:
> +      $nodename:
> +        const: ffa_partition
> +
> +      compatible:
> +        oneOf:
> +          - const: arm,ffa-1.0-partition
> +
> +      uuid:
> +        $ref: '/schemas/types.yaml#definitions/string'
> +        description: |
> +          The 128-bit UUID [2] of the service implemented by this partition.
> +
> +          [2] https://tools.ietf.org/html/rfc4122

UUIDs are actually a known thing in json-schema with 'format: uuid'. 
The meta-schema will probably reject that, so we'll need to add support 
to dtschema. Maybe it should be a new definition to reference.

> +
> +additionalProperties: false
> +
> +examples:
> +  - |
> +    ffa {
> +      compatible = "arm,ffa-1.0";
> +
> +      ffa_partition0 {
> +        compatible = "arm,ffa-1.0-partition";
> +        uuid = "12345678-9abc-def0-1234-56789abcdef0";
> +      };
> +    };

This could all be simplified down to just a single property:

arm,ffa-partitions = "12345678-9abc-def0-1234-56789abcdef0", 
	"12345678-9abc-def0-1234-56789abcdef1"
	"12345678-9abc-def0-1234-56789abcdef2";

Obviously, that's not extensible, but do we need it to be?

Rob

Re: [PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Rob Herring]

On Fri, Dec 04, 2020 at 12:11:31PM +0000, Sudeep Holla wrote:
> Since the FF-A v1.0 specification doesn't list the UUID of all the
> partitions in the discovery API, we need to specify the UUID of the
> partitions that need to be accessed by drivers within the kernel.
> 
> This binding to provide the list of partitions that kernel drivers
> may need to access.
> 
> Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> ---
>  .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
>  1 file changed, 58 insertions(+)
>  create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
> 
> diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> new file mode 100644
> index 000000000000..a014a5801c34
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> @@ -0,0 +1,58 @@
> +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> +%YAML 1.2
> +---
> +$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
> +$schema: http://devicetree.org/meta-schemas/core.yaml#
> +
> +title: Arm Firmware Framework for Arm v8-A (in-kernel users)
> +
> +maintainers:
> +  - Sudeep Holla <sudeep.holla@arm.com>
> +
> +description: |
> +  Firmware frameworks implementing partition according to the FF-A
> +  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
> +  Framework for Arm v8-A") [0], providing services to be used by other
> +  partitions.
> +
> +  [0] https://developer.arm.com/docs/den0077/latest
> +
> +properties:
> +  $nodename:
> +    const: ffa
> +
> +  compatible:
> +    oneOf:
> +      - const: arm,ffa-1.0
> +
> +patternProperties:
> +  "^ffa_partition[0-9]+$":
> +    type: object
> +    description: One or more child nodes, each describing an FFA partition.
> +    properties:
> +      $nodename:
> +        const: ffa_partition
> +
> +      compatible:
> +        oneOf:
> +          - const: arm,ffa-1.0-partition
> +
> +      uuid:
> +        $ref: '/schemas/types.yaml#definitions/string'
> +        description: |
> +          The 128-bit UUID [2] of the service implemented by this partition.
> +
> +          [2] https://tools.ietf.org/html/rfc4122

UUIDs are actually a known thing in json-schema with 'format: uuid'. 
The meta-schema will probably reject that, so we'll need to add support 
to dtschema. Maybe it should be a new definition to reference.

> +
> +additionalProperties: false
> +
> +examples:
> +  - |
> +    ffa {
> +      compatible = "arm,ffa-1.0";
> +
> +      ffa_partition0 {
> +        compatible = "arm,ffa-1.0-partition";
> +        uuid = "12345678-9abc-def0-1234-56789abcdef0";
> +      };
> +    };

This could all be simplified down to just a single property:

arm,ffa-partitions = "12345678-9abc-def0-1234-56789abcdef0", 
	"12345678-9abc-def0-1234-56789abcdef1"
	"12345678-9abc-def0-1234-56789abcdef2";

Obviously, that's not extensible, but do we need it to be?

Rob

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Sudeep Holla]

On Mon, Dec 14, 2020 at 04:01:07PM -0600, Rob Herring wrote:
> On Fri, Dec 04, 2020 at 12:11:31PM +0000, Sudeep Holla wrote:
> > Since the FF-A v1.0 specification doesn't list the UUID of all the
> > partitions in the discovery API, we need to specify the UUID of the
> > partitions that need to be accessed by drivers within the kernel.
> > 
> > This binding to provide the list of partitions that kernel drivers
> > may need to access.
> > 
> > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > ---
> >  .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
> >  1 file changed, 58 insertions(+)
> >  create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > 
> > diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > new file mode 100644
> > index 000000000000..a014a5801c34
> > --- /dev/null
> > +++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > @@ -0,0 +1,58 @@
> > +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> > +%YAML 1.2
> > +---
> > +$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
> > +$schema: http://devicetree.org/meta-schemas/core.yaml#
> > +
> > +title: Arm Firmware Framework for Arm v8-A (in-kernel users)
> > +
> > +maintainers:
> > +  - Sudeep Holla <sudeep.holla@arm.com>
> > +
> > +description: |
> > +  Firmware frameworks implementing partition according to the FF-A
> > +  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
> > +  Framework for Arm v8-A") [0], providing services to be used by other
> > +  partitions.
> > +
> > +  [0] https://developer.arm.com/docs/den0077/latest
> > +
> > +properties:
> > +  $nodename:
> > +    const: ffa
> > +
> > +  compatible:
> > +    oneOf:
> > +      - const: arm,ffa-1.0
> > +
> > +patternProperties:
> > +  "^ffa_partition[0-9]+$":
> > +    type: object
> > +    description: One or more child nodes, each describing an FFA partition.
> > +    properties:
> > +      $nodename:
> > +        const: ffa_partition
> > +
> > +      compatible:
> > +        oneOf:
> > +          - const: arm,ffa-1.0-partition
> > +
> > +      uuid:
> > +        $ref: '/schemas/types.yaml#definitions/string'
> > +        description: |
> > +          The 128-bit UUID [2] of the service implemented by this partition.
> > +
> > +          [2] https://tools.ietf.org/html/rfc4122
> 
> UUIDs are actually a known thing in json-schema with 'format: uuid'. 
> The meta-schema will probably reject that, so we'll need to add support 
> to dtschema. Maybe it should be a new definition to reference.
>

Ah OK, I will try that and ask for help if I am stuck as I am still trying
to learn these, not there yet 😄 

> > +
> > +additionalProperties: false
> > +
> > +examples:
> > +  - |
> > +    ffa {
> > +      compatible = "arm,ffa-1.0";
> > +
> > +      ffa_partition0 {
> > +        compatible = "arm,ffa-1.0-partition";
> > +        uuid = "12345678-9abc-def0-1234-56789abcdef0";
> > +      };
> > +    };
>
> This could all be simplified down to just a single property:
>

Thanks for the suggestion, I would love this to force spec authors to
stop relying on DT and add whatever needed in future to the spec as part
of discovery APIs.

> arm,ffa-partitions = "12345678-9abc-def0-1234-56789abcdef0", 
> 	"12345678-9abc-def0-1234-56789abcdef1"
> 	"12345678-9abc-def0-1234-56789abcdef2";
>
> Obviously, that's not extensible, but do we need it to be?
>

I prefer if we don't, but I will run this through spec authors so that
they are aware of what we will do in DT which means they *have* to
incorporate any future needs into the spec discovery apis.

Ah I forgot the spec author is cc-ed. @Achin please shout if you see
issues with this approach.

--
Regards,
Sudeep

Re: [PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Sudeep Holla]

On Mon, Dec 14, 2020 at 04:01:07PM -0600, Rob Herring wrote:
> On Fri, Dec 04, 2020 at 12:11:31PM +0000, Sudeep Holla wrote:
> > Since the FF-A v1.0 specification doesn't list the UUID of all the
> > partitions in the discovery API, we need to specify the UUID of the
> > partitions that need to be accessed by drivers within the kernel.
> > 
> > This binding to provide the list of partitions that kernel drivers
> > may need to access.
> > 
> > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > ---
> >  .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
> >  1 file changed, 58 insertions(+)
> >  create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > 
> > diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > new file mode 100644
> > index 000000000000..a014a5801c34
> > --- /dev/null
> > +++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > @@ -0,0 +1,58 @@
> > +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> > +%YAML 1.2
> > +---
> > +$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
> > +$schema: http://devicetree.org/meta-schemas/core.yaml#
> > +
> > +title: Arm Firmware Framework for Arm v8-A (in-kernel users)
> > +
> > +maintainers:
> > +  - Sudeep Holla <sudeep.holla@arm.com>
> > +
> > +description: |
> > +  Firmware frameworks implementing partition according to the FF-A
> > +  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
> > +  Framework for Arm v8-A") [0], providing services to be used by other
> > +  partitions.
> > +
> > +  [0] https://developer.arm.com/docs/den0077/latest
> > +
> > +properties:
> > +  $nodename:
> > +    const: ffa
> > +
> > +  compatible:
> > +    oneOf:
> > +      - const: arm,ffa-1.0
> > +
> > +patternProperties:
> > +  "^ffa_partition[0-9]+$":
> > +    type: object
> > +    description: One or more child nodes, each describing an FFA partition.
> > +    properties:
> > +      $nodename:
> > +        const: ffa_partition
> > +
> > +      compatible:
> > +        oneOf:
> > +          - const: arm,ffa-1.0-partition
> > +
> > +      uuid:
> > +        $ref: '/schemas/types.yaml#definitions/string'
> > +        description: |
> > +          The 128-bit UUID [2] of the service implemented by this partition.
> > +
> > +          [2] https://tools.ietf.org/html/rfc4122
> 
> UUIDs are actually a known thing in json-schema with 'format: uuid'. 
> The meta-schema will probably reject that, so we'll need to add support 
> to dtschema. Maybe it should be a new definition to reference.
>

Ah OK, I will try that and ask for help if I am stuck as I am still trying
to learn these, not there yet 😄 

> > +
> > +additionalProperties: false
> > +
> > +examples:
> > +  - |
> > +    ffa {
> > +      compatible = "arm,ffa-1.0";
> > +
> > +      ffa_partition0 {
> > +        compatible = "arm,ffa-1.0-partition";
> > +        uuid = "12345678-9abc-def0-1234-56789abcdef0";
> > +      };
> > +    };
>
> This could all be simplified down to just a single property:
>

Thanks for the suggestion, I would love this to force spec authors to
stop relying on DT and add whatever needed in future to the spec as part
of discovery APIs.

> arm,ffa-partitions = "12345678-9abc-def0-1234-56789abcdef0", 
> 	"12345678-9abc-def0-1234-56789abcdef1"
> 	"12345678-9abc-def0-1234-56789abcdef2";
>
> Obviously, that's not extensible, but do we need it to be?
>

I prefer if we don't, but I will run this through spec authors so that
they are aware of what we will do in DT which means they *have* to
incorporate any future needs into the spec discovery apis.

Ah I forgot the spec author is cc-ed. @Achin please shout if you see
issues with this approach.

--
Regards,
Sudeep

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Jens Wiklander]

On Wed, Dec 16, 2020 at 12:24:08PM +0000, Sudeep Holla wrote:
> On Mon, Dec 14, 2020 at 04:01:07PM -0600, Rob Herring wrote:
> > On Fri, Dec 04, 2020 at 12:11:31PM +0000, Sudeep Holla wrote:
> > > Since the FF-A v1.0 specification doesn't list the UUID of all the
> > > partitions in the discovery API, we need to specify the UUID of the
> > > partitions that need to be accessed by drivers within the kernel.
> > > 
> > > This binding to provide the list of partitions that kernel drivers
> > > may need to access.
> > > 
> > > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > > ---
> > >  .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
> > >  1 file changed, 58 insertions(+)
> > >  create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > 
> > > diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > new file mode 100644
> > > index 000000000000..a014a5801c34
> > > --- /dev/null
> > > +++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > @@ -0,0 +1,58 @@
> > > +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> > > +%YAML 1.2
> > > +---
> > > +$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
> > > +$schema: http://devicetree.org/meta-schemas/core.yaml#
> > > +
> > > +title: Arm Firmware Framework for Arm v8-A (in-kernel users)
> > > +
> > > +maintainers:
> > > +  - Sudeep Holla <sudeep.holla@arm.com>
> > > +
> > > +description: |
> > > +  Firmware frameworks implementing partition according to the FF-A
> > > +  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
> > > +  Framework for Arm v8-A") [0], providing services to be used by other
> > > +  partitions.
> > > +
> > > +  [0] https://developer.arm.com/docs/den0077/latest
> > > +
> > > +properties:
> > > +  $nodename:
> > > +    const: ffa
> > > +
> > > +  compatible:
> > > +    oneOf:
> > > +      - const: arm,ffa-1.0
> > > +
> > > +patternProperties:
> > > +  "^ffa_partition[0-9]+$":
> > > +    type: object
> > > +    description: One or more child nodes, each describing an FFA partition.
> > > +    properties:
> > > +      $nodename:
> > > +        const: ffa_partition
> > > +
> > > +      compatible:
> > > +        oneOf:
> > > +          - const: arm,ffa-1.0-partition
> > > +
> > > +      uuid:
> > > +        $ref: '/schemas/types.yaml#definitions/string'
> > > +        description: |
> > > +          The 128-bit UUID [2] of the service implemented by this partition.
> > > +
> > > +          [2] https://tools.ietf.org/html/rfc4122
> > 
> > UUIDs are actually a known thing in json-schema with 'format: uuid'. 
> > The meta-schema will probably reject that, so we'll need to add support 
> > to dtschema. Maybe it should be a new definition to reference.
> >
> 
> Ah OK, I will try that and ask for help if I am stuck as I am still trying
> to learn these, not there yet 😄 
> 
> > > +
> > > +additionalProperties: false
> > > +
> > > +examples:
> > > +  - |
> > > +    ffa {
> > > +      compatible = "arm,ffa-1.0";
> > > +
> > > +      ffa_partition0 {
> > > +        compatible = "arm,ffa-1.0-partition";
> > > +        uuid = "12345678-9abc-def0-1234-56789abcdef0";
> > > +      };
> > > +    };
> >
> > This could all be simplified down to just a single property:
> >
> 
> Thanks for the suggestion, I would love this to force spec authors to
> stop relying on DT and add whatever needed in future to the spec as part
> of discovery APIs.
> 
> > arm,ffa-partitions = "12345678-9abc-def0-1234-56789abcdef0", 
> > 	"12345678-9abc-def0-1234-56789abcdef1"
> > 	"12345678-9abc-def0-1234-56789abcdef2";
> >
> > Obviously, that's not extensible, but do we need it to be?
> >
> 
> I prefer if we don't, but I will run this through spec authors so that
> they are aware of what we will do in DT which means they *have* to
> incorporate any future needs into the spec discovery apis.

Speaking of discovery apis, doesn't the FF-A spec already have that?
Or am I missing something?

Cheers,
Jens

> 
> Ah I forgot the spec author is cc-ed. @Achin please shout if you see
> issues with this approach.
> 
> --
> Regards,
> Sudeep

Re: [PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Jens Wiklander]

On Wed, Dec 16, 2020 at 12:24:08PM +0000, Sudeep Holla wrote:
> On Mon, Dec 14, 2020 at 04:01:07PM -0600, Rob Herring wrote:
> > On Fri, Dec 04, 2020 at 12:11:31PM +0000, Sudeep Holla wrote:
> > > Since the FF-A v1.0 specification doesn't list the UUID of all the
> > > partitions in the discovery API, we need to specify the UUID of the
> > > partitions that need to be accessed by drivers within the kernel.
> > > 
> > > This binding to provide the list of partitions that kernel drivers
> > > may need to access.
> > > 
> > > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > > ---
> > >  .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
> > >  1 file changed, 58 insertions(+)
> > >  create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > 
> > > diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > new file mode 100644
> > > index 000000000000..a014a5801c34
> > > --- /dev/null
> > > +++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > @@ -0,0 +1,58 @@
> > > +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> > > +%YAML 1.2
> > > +---
> > > +$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
> > > +$schema: http://devicetree.org/meta-schemas/core.yaml#
> > > +
> > > +title: Arm Firmware Framework for Arm v8-A (in-kernel users)
> > > +
> > > +maintainers:
> > > +  - Sudeep Holla <sudeep.holla@arm.com>
> > > +
> > > +description: |
> > > +  Firmware frameworks implementing partition according to the FF-A
> > > +  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
> > > +  Framework for Arm v8-A") [0], providing services to be used by other
> > > +  partitions.
> > > +
> > > +  [0] https://developer.arm.com/docs/den0077/latest
> > > +
> > > +properties:
> > > +  $nodename:
> > > +    const: ffa
> > > +
> > > +  compatible:
> > > +    oneOf:
> > > +      - const: arm,ffa-1.0
> > > +
> > > +patternProperties:
> > > +  "^ffa_partition[0-9]+$":
> > > +    type: object
> > > +    description: One or more child nodes, each describing an FFA partition.
> > > +    properties:
> > > +      $nodename:
> > > +        const: ffa_partition
> > > +
> > > +      compatible:
> > > +        oneOf:
> > > +          - const: arm,ffa-1.0-partition
> > > +
> > > +      uuid:
> > > +        $ref: '/schemas/types.yaml#definitions/string'
> > > +        description: |
> > > +          The 128-bit UUID [2] of the service implemented by this partition.
> > > +
> > > +          [2] https://tools.ietf.org/html/rfc4122
> > 
> > UUIDs are actually a known thing in json-schema with 'format: uuid'. 
> > The meta-schema will probably reject that, so we'll need to add support 
> > to dtschema. Maybe it should be a new definition to reference.
> >
> 
> Ah OK, I will try that and ask for help if I am stuck as I am still trying
> to learn these, not there yet 😄 
> 
> > > +
> > > +additionalProperties: false
> > > +
> > > +examples:
> > > +  - |
> > > +    ffa {
> > > +      compatible = "arm,ffa-1.0";
> > > +
> > > +      ffa_partition0 {
> > > +        compatible = "arm,ffa-1.0-partition";
> > > +        uuid = "12345678-9abc-def0-1234-56789abcdef0";
> > > +      };
> > > +    };
> >
> > This could all be simplified down to just a single property:
> >
> 
> Thanks for the suggestion, I would love this to force spec authors to
> stop relying on DT and add whatever needed in future to the spec as part
> of discovery APIs.
> 
> > arm,ffa-partitions = "12345678-9abc-def0-1234-56789abcdef0", 
> > 	"12345678-9abc-def0-1234-56789abcdef1"
> > 	"12345678-9abc-def0-1234-56789abcdef2";
> >
> > Obviously, that's not extensible, but do we need it to be?
> >
> 
> I prefer if we don't, but I will run this through spec authors so that
> they are aware of what we will do in DT which means they *have* to
> incorporate any future needs into the spec discovery apis.

Speaking of discovery apis, doesn't the FF-A spec already have that?
Or am I missing something?

Cheers,
Jens

> 
> Ah I forgot the spec author is cc-ed. @Achin please shout if you see
> issues with this approach.
> 
> --
> Regards,
> Sudeep

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

(sorry for late reply)

On Fri, Dec 11, 2020 at 11:45:08AM +0100, Jens Wiklander wrote:
> On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:

[...]

Agreed on all the comments, so have just removed those context.

> We may need a way to indicate if we're to use the 32bit or 64bit
> calling convention. OP-TEE depends on being able to use 32bit calls
> here.

I assume it would be OP-TEE indicating it would like to use 32-bit.
I am thinking of API from the driver would be like:

int (*32bit_mode_only_set)(struct ffa_device *dev);

Let me know if that works for you. FF-A driver has no other way to evaluate
that and I really don't like that in DT 😉 

--
Regards,
Sudeep

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

(sorry for late reply)

On Fri, Dec 11, 2020 at 11:45:08AM +0100, Jens Wiklander wrote:
> On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:

[...]

Agreed on all the comments, so have just removed those context.

> We may need a way to indicate if we're to use the 32bit or 64bit
> calling convention. OP-TEE depends on being able to use 32bit calls
> here.

I assume it would be OP-TEE indicating it would like to use 32-bit.
I am thinking of API from the driver would be like:

int (*32bit_mode_only_set)(struct ffa_device *dev);

Let me know if that works for you. FF-A driver has no other way to evaluate
that and I really don't like that in DT 😉 

--
Regards,
Sudeep

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

On Tue, Jan 12, 2021 at 06:04:14PM +0000, Sudeep Holla wrote:
> (sorry for late reply)
> 
> On Fri, Dec 11, 2020 at 11:45:08AM +0100, Jens Wiklander wrote:
> > On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
> 
> [...]
> 
> Agreed on all the comments, so have just removed those context.
> 
> > We may need a way to indicate if we're to use the 32bit or 64bit
> > calling convention. OP-TEE depends on being able to use 32bit calls
> > here.
> 
> I assume it would be OP-TEE indicating it would like to use 32-bit.
> I am thinking of API from the driver would be like:
> 
> int (*32bit_mode_only_set)(struct ffa_device *dev);
> 
> Let me know if that works for you. FF-A driver has no other way to evaluate
> that and I really don't like that in DT 😉 

That should work for OP-TEE.

Thanks,
Jens

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

On Tue, Jan 12, 2021 at 06:04:14PM +0000, Sudeep Holla wrote:
> (sorry for late reply)
> 
> On Fri, Dec 11, 2020 at 11:45:08AM +0100, Jens Wiklander wrote:
> > On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
> 
> [...]
> 
> Agreed on all the comments, so have just removed those context.
> 
> > We may need a way to indicate if we're to use the 32bit or 64bit
> > calling convention. OP-TEE depends on being able to use 32bit calls
> > here.
> 
> I assume it would be OP-TEE indicating it would like to use 32-bit.
> I am thinking of API from the driver would be like:
> 
> int (*32bit_mode_only_set)(struct ffa_device *dev);
> 
> Let me know if that works for you. FF-A driver has no other way to evaluate
> that and I really don't like that in DT 😉 

That should work for OP-TEE.

Thanks,
Jens

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

On Mon, Dec 07, 2020 at 01:30:18PM +0100, Jens Wiklander wrote:
> Hi Sudeep,
> 
> Some comments below.
> 
> On Fri, Dec 04, 2020 at 12:11:36PM +0000, Sudeep Holla wrote:

[...]

> > +
> > +int ffa_setup_partitions(struct device_node *np)
> > +{
> > +	int ret;
> > +	struct device_node *child;
> > +	struct ffa_device *ffa_dev;
> > +	struct ffa_partition_info pbuf;
> > +	const char *p_uuid, *pfx = "Ignoring FFA partition";
> > +	uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
> > +
> > +	for_each_child_of_node(np, child) {
> 
> The spec says:
> – If the Nil UUID is specified at the Non-secure virtual FF-A instance,
>   the Hypervisor must provide information for partitions resident in both
>   security states.
>

That was my initial understanding of the specification. However I was told
it is designed mostly for Non-Secure Hypervisor for getting the list of
secure partitions and help in allocation of non-secure partition/endpoint IDs.
This has been topic of discussion recently.

> Doesn't that make this redundant?
>

Not exactly. One main reason why the discovery API (get partition info) is
not much useful here in this context is that it lacks UUID and hence not much
of use unless you know UUID. The result we get for Nil UUID needs to be mapped
to UUID and I can't think of anyway to do so outside the scope of the spec.
I have raised it but not sure if there is a strong requirement to add it.

Similarly, I would have like 32 vs 64 bit capable partition info from there
ideally, but we are here now.

-- 
Regards,
Sudeep

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

On Mon, Dec 07, 2020 at 01:30:18PM +0100, Jens Wiklander wrote:
> Hi Sudeep,
> 
> Some comments below.
> 
> On Fri, Dec 04, 2020 at 12:11:36PM +0000, Sudeep Holla wrote:

[...]

> > +
> > +int ffa_setup_partitions(struct device_node *np)
> > +{
> > +	int ret;
> > +	struct device_node *child;
> > +	struct ffa_device *ffa_dev;
> > +	struct ffa_partition_info pbuf;
> > +	const char *p_uuid, *pfx = "Ignoring FFA partition";
> > +	uuid_t uuid = UUID_INIT(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
> > +
> > +	for_each_child_of_node(np, child) {
> 
> The spec says:
> – If the Nil UUID is specified at the Non-secure virtual FF-A instance,
>   the Hypervisor must provide information for partitions resident in both
>   security states.
>

That was my initial understanding of the specification. However I was told
it is designed mostly for Non-Secure Hypervisor for getting the list of
secure partitions and help in allocation of non-secure partition/endpoint IDs.
This has been topic of discussion recently.

> Doesn't that make this redundant?
>

Not exactly. One main reason why the discovery API (get partition info) is
not much useful here in this context is that it lacks UUID and hence not much
of use unless you know UUID. The result we get for Nil UUID needs to be mapped
to UUID and I can't think of anyway to do so outside the scope of the spec.
I have raised it but not sure if there is a strong requirement to add it.

Similarly, I would have like 32 vs 64 bit capable partition info from there
ideally, but we are here now.

-- 
Regards,
Sudeep

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

On Fri, Dec 11, 2020 at 11:59:40AM +0100, Jens Wiklander wrote:
> One more comment below.
> 
> On Fri, Dec 11, 2020 at 11:45 AM Jens Wiklander
> <jens.wiklander@linaro.org> wrote:
> >
> > Hi Sudeep,
> >
> > Some more comments below.
> >
> > On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
> > >
> > > Parse the FFA nodes from the device-tree and register all the partitions
> > > whose services will be used in the kernel.
> > >
> > > In order to also enable in-kernel users of FFA interface, let us add
> > > simple set of operations for such devices.
> > >
> > > The in-kernel users are registered without the character device interface.
> > >
> > > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > > ---
> > >  drivers/firmware/arm_ffa/common.h |   2 +
> > >  drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
> > >  include/linux/arm_ffa.h           |  36 +++++-
> > >  3 files changed, 223 insertions(+), 1 deletion(-)
> > >
> > > diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
> > > index d019348bf67d..eb1371c2b2b8 100644
> > > --- a/drivers/firmware/arm_ffa/common.h
> > > +++ b/drivers/firmware/arm_ffa/common.h
> > > @@ -6,6 +6,7 @@
> > >  #ifndef _FFA_COMMON_H
> > >  #define _FFA_COMMON_H
> > >
> > > +#include <linux/arm_ffa.h>
> > >  #include <linux/arm-smccc.h>
> > >  #include <linux/err.h>
> > >
> > > @@ -17,6 +18,7 @@ typedef ffa_res_t
> > >
> > >  int __init arm_ffa_bus_init(void);
> > >  void __exit arm_ffa_bus_exit(void);
> > > +bool ffa_device_is_valid(struct ffa_device *ffa_dev);
> > >
> > >  #ifdef CONFIG_ARM_FFA_SMCCC
> > >  int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
> > > diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> > > index 257b331d781c..3e4ba841dbf8 100644
> > > --- a/drivers/firmware/arm_ffa/driver.c
> > > +++ b/drivers/firmware/arm_ffa/driver.c
> > > @@ -24,9 +24,13 @@
> > >
> > >  #include <linux/arm_ffa.h>
> > >  #include <linux/bitfield.h>
> > > +#include <linux/device.h>
> > >  #include <linux/io.h>
> > > +#include <linux/kernel.h>
> > >  #include <linux/module.h>
> > > +#include <linux/of.h>
> > >  #include <linux/slab.h>
> > > +#include <linux/uuid.h>
> > >
> > >  #include "common.h"
> > >
> > > @@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
> > >         return 0;
> > >  }
> > >
> > > +static int ffa_rx_release(void)
> > > +{
> > > +       ffa_res_t ret;
> > > +
> > > +       ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
> > > +
> > > +       if (ret.a0 == FFA_ERROR)
> > > +               return ffa_to_linux_errno((int)ret.a2);
> > > +
> > > +       /* check for ret.a0 == FFA_RX_RELEASE ? */
> > > +
> > > +       return 0;
> > > +}
> > > +
> > >  static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
> > >  {
> > >         ffa_res_t ret;
> > > @@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
> > >         return 0;
> > >  }
> > >
> > > +static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
> > > +                                   struct ffa_partition_info **buffer)
> > > +{
> > > +       int count;
> > > +       ffa_res_t partition_info;
> > > +
> > > +       mutex_lock(&drv_info->rx_lock);
> > > +       partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
> > > +                                      uuid2, uuid3, 0, 0, 0);
> > > +
> > > +       if (partition_info.a0 == FFA_ERROR)
> > > +               return ffa_to_linux_errno((int)partition_info.a2);
> > > +
> > > +       count = partition_info.a2;
> > > +
> > > +       if (buffer)
> > > +               memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
> > > +
> > > +       ffa_rx_release();
> > > +
> > > +       mutex_unlock(&drv_info->rx_lock);
> > > +
> > > +       return count;
> > > +}
> > > +
> > > +static int ffa_partition_probe(const char *uuid_str,
> > > +                              struct ffa_partition_info *buffer)
> > > +{
> > > +       int count;
> > > +       uuid_t uuid;
> > > +       u32 uuid0_4[4] = { 0 };
> > > +
> > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > +               return -ENODEV;
> > > +       }
> > > +
> > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > +                                        uuid0_4[3], &buffer);
> Wrong byte order?
> According to section 5.3 of the SMCCC, UUIDs are returned as a single
> 128-bit value using the SMC32 calling convention. This value is mapped
> to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> for example shall hold bytes 0 to 3, with byte 0 in the low-order
> bits.
>

I need to spend some time to understand the concern here. Initially I agreed
with your analysis and then a quick review make be realise it is all OK.
I need to check if my understanding is correct again. I thought I will
take example and check here itself.

UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"

UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
dac902fd c7486c30 d8bb9ca4 ee86ae27

It seems correct as per SMCCC convention to me, or am I missing something
obvious ?

--
Regards,
Sudeep

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

On Fri, Dec 11, 2020 at 11:59:40AM +0100, Jens Wiklander wrote:
> One more comment below.
> 
> On Fri, Dec 11, 2020 at 11:45 AM Jens Wiklander
> <jens.wiklander@linaro.org> wrote:
> >
> > Hi Sudeep,
> >
> > Some more comments below.
> >
> > On Fri, Dec 4, 2020 at 1:11 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
> > >
> > > Parse the FFA nodes from the device-tree and register all the partitions
> > > whose services will be used in the kernel.
> > >
> > > In order to also enable in-kernel users of FFA interface, let us add
> > > simple set of operations for such devices.
> > >
> > > The in-kernel users are registered without the character device interface.
> > >
> > > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > > ---
> > >  drivers/firmware/arm_ffa/common.h |   2 +
> > >  drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++
> > >  include/linux/arm_ffa.h           |  36 +++++-
> > >  3 files changed, 223 insertions(+), 1 deletion(-)
> > >
> > > diff --git a/drivers/firmware/arm_ffa/common.h b/drivers/firmware/arm_ffa/common.h
> > > index d019348bf67d..eb1371c2b2b8 100644
> > > --- a/drivers/firmware/arm_ffa/common.h
> > > +++ b/drivers/firmware/arm_ffa/common.h
> > > @@ -6,6 +6,7 @@
> > >  #ifndef _FFA_COMMON_H
> > >  #define _FFA_COMMON_H
> > >
> > > +#include <linux/arm_ffa.h>
> > >  #include <linux/arm-smccc.h>
> > >  #include <linux/err.h>
> > >
> > > @@ -17,6 +18,7 @@ typedef ffa_res_t
> > >
> > >  int __init arm_ffa_bus_init(void);
> > >  void __exit arm_ffa_bus_exit(void);
> > > +bool ffa_device_is_valid(struct ffa_device *ffa_dev);
> > >
> > >  #ifdef CONFIG_ARM_FFA_SMCCC
> > >  int __init ffa_transport_init(ffa_fn **invoke_ffa_fn);
> > > diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c
> > > index 257b331d781c..3e4ba841dbf8 100644
> > > --- a/drivers/firmware/arm_ffa/driver.c
> > > +++ b/drivers/firmware/arm_ffa/driver.c
> > > @@ -24,9 +24,13 @@
> > >
> > >  #include <linux/arm_ffa.h>
> > >  #include <linux/bitfield.h>
> > > +#include <linux/device.h>
> > >  #include <linux/io.h>
> > > +#include <linux/kernel.h>
> > >  #include <linux/module.h>
> > > +#include <linux/of.h>
> > >  #include <linux/slab.h>
> > > +#include <linux/uuid.h>
> > >
> > >  #include "common.h"
> > >
> > > @@ -179,6 +183,20 @@ static int ffa_version_check(u32 *version)
> > >         return 0;
> > >  }
> > >
> > > +static int ffa_rx_release(void)
> > > +{
> > > +       ffa_res_t ret;
> > > +
> > > +       ret = invoke_ffa_fn(FFA_RX_RELEASE, 0, 0, 0, 0, 0, 0, 0);
> > > +
> > > +       if (ret.a0 == FFA_ERROR)
> > > +               return ffa_to_linux_errno((int)ret.a2);
> > > +
> > > +       /* check for ret.a0 == FFA_RX_RELEASE ? */
> > > +
> > > +       return 0;
> > > +}
> > > +
> > >  static int ffa_rxtx_map(phys_addr_t tx_buf, phys_addr_t rx_buf, u32 pg_cnt)
> > >  {
> > >         ffa_res_t ret;
> > > @@ -203,6 +221,50 @@ static int ffa_rxtx_unmap(u16 vm_id)
> > >         return 0;
> > >  }
> > >
> > > +static int __ffa_partition_info_get(u32 uuid0, u32 uuid1, u32 uuid2, u32 uuid3,
> > > +                                   struct ffa_partition_info **buffer)
> > > +{
> > > +       int count;
> > > +       ffa_res_t partition_info;
> > > +
> > > +       mutex_lock(&drv_info->rx_lock);
> > > +       partition_info = invoke_ffa_fn(FFA_PARTITION_INFO_GET, uuid0, uuid1,
> > > +                                      uuid2, uuid3, 0, 0, 0);
> > > +
> > > +       if (partition_info.a0 == FFA_ERROR)
> > > +               return ffa_to_linux_errno((int)partition_info.a2);
> > > +
> > > +       count = partition_info.a2;
> > > +
> > > +       if (buffer)
> > > +               memcpy(*buffer, drv_info->rx_buffer, sizeof(*buffer) * count);
> > > +
> > > +       ffa_rx_release();
> > > +
> > > +       mutex_unlock(&drv_info->rx_lock);
> > > +
> > > +       return count;
> > > +}
> > > +
> > > +static int ffa_partition_probe(const char *uuid_str,
> > > +                              struct ffa_partition_info *buffer)
> > > +{
> > > +       int count;
> > > +       uuid_t uuid;
> > > +       u32 uuid0_4[4] = { 0 };
> > > +
> > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > +               return -ENODEV;
> > > +       }
> > > +
> > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > +                                        uuid0_4[3], &buffer);
> Wrong byte order?
> According to section 5.3 of the SMCCC, UUIDs are returned as a single
> 128-bit value using the SMC32 calling convention. This value is mapped
> to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> for example shall hold bytes 0 to 3, with byte 0 in the low-order
> bits.
>

I need to spend some time to understand the concern here. Initially I agreed
with your analysis and then a quick review make be realise it is all OK.
I need to check if my understanding is correct again. I thought I will
take example and check here itself.

UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"

UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
dac902fd c7486c30 d8bb9ca4 ee86ae27

It seems correct as per SMCCC convention to me, or am I missing something
obvious ?

--
Regards,
Sudeep

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Sudeep Holla]

On Wed, Dec 16, 2020 at 12:24:08PM +0000, Sudeep Holla wrote:
> On Mon, Dec 14, 2020 at 04:01:07PM -0600, Rob Herring wrote:
> > On Fri, Dec 04, 2020 at 12:11:31PM +0000, Sudeep Holla wrote:
> > > Since the FF-A v1.0 specification doesn't list the UUID of all the
> > > partitions in the discovery API, we need to specify the UUID of the
> > > partitions that need to be accessed by drivers within the kernel.
> > > 
> > > This binding to provide the list of partitions that kernel drivers
> > > may need to access.
> > > 
> > > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > > ---
> > >  .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
> > >  1 file changed, 58 insertions(+)
> > >  create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > 
> > > diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > new file mode 100644
> > > index 000000000000..a014a5801c34
> > > --- /dev/null
> > > +++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > @@ -0,0 +1,58 @@
> > > +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> > > +%YAML 1.2
> > > +---
> > > +$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
> > > +$schema: http://devicetree.org/meta-schemas/core.yaml#
> > > +
> > > +title: Arm Firmware Framework for Arm v8-A (in-kernel users)
> > > +
> > > +maintainers:
> > > +  - Sudeep Holla <sudeep.holla@arm.com>
> > > +
> > > +description: |
> > > +  Firmware frameworks implementing partition according to the FF-A
> > > +  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
> > > +  Framework for Arm v8-A") [0], providing services to be used by other
> > > +  partitions.
> > > +
> > > +  [0] https://developer.arm.com/docs/den0077/latest
> > > +
> > > +properties:
> > > +  $nodename:
> > > +    const: ffa
> > > +
> > > +  compatible:
> > > +    oneOf:
> > > +      - const: arm,ffa-1.0
> > > +
> > > +patternProperties:
> > > +  "^ffa_partition[0-9]+$":
> > > +    type: object
> > > +    description: One or more child nodes, each describing an FFA partition.
> > > +    properties:
> > > +      $nodename:
> > > +        const: ffa_partition
> > > +
> > > +      compatible:
> > > +        oneOf:
> > > +          - const: arm,ffa-1.0-partition
> > > +
> > > +      uuid:
> > > +        $ref: '/schemas/types.yaml#definitions/string'
> > > +        description: |
> > > +          The 128-bit UUID [2] of the service implemented by this partition.
> > > +
> > > +          [2] https://tools.ietf.org/html/rfc4122
> > 
> > UUIDs are actually a known thing in json-schema with 'format: uuid'. 
> > The meta-schema will probably reject that, so we'll need to add support 
> > to dtschema. Maybe it should be a new definition to reference.
> >
> 
> Ah OK, I will try that and ask for help if I am stuck as I am still trying
> to learn these, not there yet 😄 
> 
> > > +
> > > +additionalProperties: false
> > > +
> > > +examples:
> > > +  - |
> > > +    ffa {
> > > +      compatible = "arm,ffa-1.0";
> > > +
> > > +      ffa_partition0 {
> > > +        compatible = "arm,ffa-1.0-partition";
> > > +        uuid = "12345678-9abc-def0-1234-56789abcdef0";
> > > +      };
> > > +    };
> >
> > This could all be simplified down to just a single property:
> >
> 
> Thanks for the suggestion, I would love this to force spec authors to
> stop relying on DT and add whatever needed in future to the spec as part
> of discovery APIs.
> 
> > arm,ffa-partitions = "12345678-9abc-def0-1234-56789abcdef0", 
> > 	"12345678-9abc-def0-1234-56789abcdef1"
> > 	"12345678-9abc-def0-1234-56789abcdef2";
> >
> > Obviously, that's not extensible, but do we need it to be?
> >
> 
> I prefer if we don't, but I will run this through spec authors so that
> they are aware of what we will do in DT which means they *have* to
> incorporate any future needs into the spec discovery apis.
> 

OK we found some usecase which may require separate nodes. I am sure they
could be alternative solution even with above style of array of UUID strings.

If you remember use of SMC/HVC as SCMI transport[1], it just provides one
way(a2p) communication. P2A is not possible with that, i.e platform
notifications to OSPM is not possible. FFA aims to replace native SMC/HVC
transport there to provide bi-directional support. For such usecase,
where one partition running SCMI server might provide multiple channels
for SCMI communication and we may need to provide the link using phandle
or something in DT.

Let me know your thoughts on those.

--
Regards,
Sudeep

[1] https://lore.kernel.org/r/20201222145603.40192-2-jim2101024@gmail.com

Re: [PATCH v3 1/7] dt-bindings: Arm: Add Firmware Framework for Armv8-A (FF-A) binding

[Sudeep Holla]

On Wed, Dec 16, 2020 at 12:24:08PM +0000, Sudeep Holla wrote:
> On Mon, Dec 14, 2020 at 04:01:07PM -0600, Rob Herring wrote:
> > On Fri, Dec 04, 2020 at 12:11:31PM +0000, Sudeep Holla wrote:
> > > Since the FF-A v1.0 specification doesn't list the UUID of all the
> > > partitions in the discovery API, we need to specify the UUID of the
> > > partitions that need to be accessed by drivers within the kernel.
> > > 
> > > This binding to provide the list of partitions that kernel drivers
> > > may need to access.
> > > 
> > > Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
> > > ---
> > >  .../devicetree/bindings/arm/arm,ffa.yaml      | 58 +++++++++++++++++++
> > >  1 file changed, 58 insertions(+)
> > >  create mode 100644 Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > 
> > > diff --git a/Documentation/devicetree/bindings/arm/arm,ffa.yaml b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > new file mode 100644
> > > index 000000000000..a014a5801c34
> > > --- /dev/null
> > > +++ b/Documentation/devicetree/bindings/arm/arm,ffa.yaml
> > > @@ -0,0 +1,58 @@
> > > +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> > > +%YAML 1.2
> > > +---
> > > +$id: http://devicetree.org/schemas/arm/arm,ffa.yaml#
> > > +$schema: http://devicetree.org/meta-schemas/core.yaml#
> > > +
> > > +title: Arm Firmware Framework for Arm v8-A (in-kernel users)
> > > +
> > > +maintainers:
> > > +  - Sudeep Holla <sudeep.holla@arm.com>
> > > +
> > > +description: |
> > > +  Firmware frameworks implementing partition according to the FF-A
> > > +  specification defined by ARM document number ARM DEN 0077A ("Arm Firmware
> > > +  Framework for Arm v8-A") [0], providing services to be used by other
> > > +  partitions.
> > > +
> > > +  [0] https://developer.arm.com/docs/den0077/latest
> > > +
> > > +properties:
> > > +  $nodename:
> > > +    const: ffa
> > > +
> > > +  compatible:
> > > +    oneOf:
> > > +      - const: arm,ffa-1.0
> > > +
> > > +patternProperties:
> > > +  "^ffa_partition[0-9]+$":
> > > +    type: object
> > > +    description: One or more child nodes, each describing an FFA partition.
> > > +    properties:
> > > +      $nodename:
> > > +        const: ffa_partition
> > > +
> > > +      compatible:
> > > +        oneOf:
> > > +          - const: arm,ffa-1.0-partition
> > > +
> > > +      uuid:
> > > +        $ref: '/schemas/types.yaml#definitions/string'
> > > +        description: |
> > > +          The 128-bit UUID [2] of the service implemented by this partition.
> > > +
> > > +          [2] https://tools.ietf.org/html/rfc4122
> > 
> > UUIDs are actually a known thing in json-schema with 'format: uuid'. 
> > The meta-schema will probably reject that, so we'll need to add support 
> > to dtschema. Maybe it should be a new definition to reference.
> >
> 
> Ah OK, I will try that and ask for help if I am stuck as I am still trying
> to learn these, not there yet 😄 
> 
> > > +
> > > +additionalProperties: false
> > > +
> > > +examples:
> > > +  - |
> > > +    ffa {
> > > +      compatible = "arm,ffa-1.0";
> > > +
> > > +      ffa_partition0 {
> > > +        compatible = "arm,ffa-1.0-partition";
> > > +        uuid = "12345678-9abc-def0-1234-56789abcdef0";
> > > +      };
> > > +    };
> >
> > This could all be simplified down to just a single property:
> >
> 
> Thanks for the suggestion, I would love this to force spec authors to
> stop relying on DT and add whatever needed in future to the spec as part
> of discovery APIs.
> 
> > arm,ffa-partitions = "12345678-9abc-def0-1234-56789abcdef0", 
> > 	"12345678-9abc-def0-1234-56789abcdef1"
> > 	"12345678-9abc-def0-1234-56789abcdef2";
> >
> > Obviously, that's not extensible, but do we need it to be?
> >
> 
> I prefer if we don't, but I will run this through spec authors so that
> they are aware of what we will do in DT which means they *have* to
> incorporate any future needs into the spec discovery apis.
> 

OK we found some usecase which may require separate nodes. I am sure they
could be alternative solution even with above style of array of UUID strings.

If you remember use of SMC/HVC as SCMI transport[1], it just provides one
way(a2p) communication. P2A is not possible with that, i.e platform
notifications to OSPM is not possible. FFA aims to replace native SMC/HVC
transport there to provide bi-directional support. For such usecase,
where one partition running SCMI server might provide multiple channels
for SCMI communication and we may need to provide the link using phandle
or something in DT.

Let me know your thoughts on those.

--
Regards,
Sudeep

[1] https://lore.kernel.org/r/20201222145603.40192-2-jim2101024@gmail.com

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

On Wed, Jan 13, 2021 at 10:44 AM Sudeep Holla <sudeep.holla@arm.com> wrote:
[...]
> > > > +static int ffa_partition_probe(const char *uuid_str,
> > > > +                              struct ffa_partition_info *buffer)
> > > > +{
> > > > +       int count;
> > > > +       uuid_t uuid;
> > > > +       u32 uuid0_4[4] = { 0 };
> > > > +
> > > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > > +               return -ENODEV;
> > > > +       }
> > > > +
> > > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > > +                                        uuid0_4[3], &buffer);
> > Wrong byte order?
> > According to section 5.3 of the SMCCC, UUIDs are returned as a single
> > 128-bit value using the SMC32 calling convention. This value is mapped
> > to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> > for example shall hold bytes 0 to 3, with byte 0 in the low-order
> > bits.
> >
>
> I need to spend some time to understand the concern here. Initially I agreed
> with your analysis and then a quick review make be realise it is all OK.
> I need to check if my understanding is correct again. I thought I will
> take example and check here itself.
>
> UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"
>
> UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
> dac902fd c7486c30 d8bb9ca4 ee86ae27
>
> It seems correct as per SMCCC convention to me, or am I missing something
> obvious ?

In this example I'd expect the first register to hold 0xfd02c9da
regardless of the byte order of the machine. If there is a different
byte order in the receiver it will still be received as 0xfd02c9da.
That's how I've understood the specification.

Cheers,
Jens

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

On Wed, Jan 13, 2021 at 10:44 AM Sudeep Holla <sudeep.holla@arm.com> wrote:
[...]
> > > > +static int ffa_partition_probe(const char *uuid_str,
> > > > +                              struct ffa_partition_info *buffer)
> > > > +{
> > > > +       int count;
> > > > +       uuid_t uuid;
> > > > +       u32 uuid0_4[4] = { 0 };
> > > > +
> > > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > > +               return -ENODEV;
> > > > +       }
> > > > +
> > > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > > +                                        uuid0_4[3], &buffer);
> > Wrong byte order?
> > According to section 5.3 of the SMCCC, UUIDs are returned as a single
> > 128-bit value using the SMC32 calling convention. This value is mapped
> > to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> > for example shall hold bytes 0 to 3, with byte 0 in the low-order
> > bits.
> >
>
> I need to spend some time to understand the concern here. Initially I agreed
> with your analysis and then a quick review make be realise it is all OK.
> I need to check if my understanding is correct again. I thought I will
> take example and check here itself.
>
> UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"
>
> UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
> dac902fd c7486c30 d8bb9ca4 ee86ae27
>
> It seems correct as per SMCCC convention to me, or am I missing something
> obvious ?

In this example I'd expect the first register to hold 0xfd02c9da
regardless of the byte order of the machine. If there is a different
byte order in the receiver it will still be received as 0xfd02c9da.
That's how I've understood the specification.

Cheers,
Jens

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Achin Gupta]

On Wed, Jan 13, 2021 at 01:30:56PM +0100, Jens Wiklander wrote:
> On Wed, Jan 13, 2021 at 10:44 AM Sudeep Holla <sudeep.holla@arm.com> wrote:
> [...]
> > > > > +static int ffa_partition_probe(const char *uuid_str,
> > > > > +                              struct ffa_partition_info *buffer)
> > > > > +{
> > > > > +       int count;
> > > > > +       uuid_t uuid;
> > > > > +       u32 uuid0_4[4] = { 0 };
> > > > > +
> > > > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > > > +               return -ENODEV;
> > > > > +       }
> > > > > +
> > > > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > > > +                                        uuid0_4[3], &buffer);
> > > Wrong byte order?
> > > According to section 5.3 of the SMCCC, UUIDs are returned as a single
> > > 128-bit value using the SMC32 calling convention. This value is mapped
> > > to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> > > for example shall hold bytes 0 to 3, with byte 0 in the low-order
> > > bits.
> > >
> >
> > I need to spend some time to understand the concern here. Initially I agreed
> > with your analysis and then a quick review make be realise it is all OK.
> > I need to check if my understanding is correct again. I thought I will
> > take example and check here itself.
> >
> > UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"

IIUC this maps to (as per RFC4122).

fd02c9da = time_low (bytes 0-3)
306c48c7 = time_mid & time_hi_and_version (bytes 4-7)
a49cbbd8 = clock_seq_hi_and_reserved, clock_seq_low and bytes/octets 0-1 of node (bytes 8-11)
27ae86ee = bytes 2-5 of node (bytes 12-15)

SMCCC says:

w0 : bytes 0-3 with byte 0 in the lower order bits.
w1 : bytes 4-7 with byte 4 in the lower order bits.
w2 : bytes 8-11 with byte 8 in the lower order bits.
w3 : bytes 12-15 with byte 12 in the lower order bits.

This should amount to:

w0 = dac902fd
w1 = c7486c30
w2 = d8bb9ca4
w3 = ee86ae27

So, even though RFC4122 uses big-endian i.e network byte order. The UUID is
encoded as little-endian as per the SMCCC.

What do you reckon?

cheers,
Achin

> >
> > UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
> > dac902fd c7486c30 d8bb9ca4 ee86ae27
> >
> > It seems correct as per SMCCC convention to me, or am I missing something
> > obvious ?
>
> In this example I'd expect the first register to hold 0xfd02c9da
> regardless of the byte order of the machine. If there is a different
> byte order in the receiver it will still be received as 0xfd02c9da.
> That's how I've understood the specification.


>
> Cheers,
> Jens

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Achin Gupta]

On Wed, Jan 13, 2021 at 01:30:56PM +0100, Jens Wiklander wrote:
> On Wed, Jan 13, 2021 at 10:44 AM Sudeep Holla <sudeep.holla@arm.com> wrote:
> [...]
> > > > > +static int ffa_partition_probe(const char *uuid_str,
> > > > > +                              struct ffa_partition_info *buffer)
> > > > > +{
> > > > > +       int count;
> > > > > +       uuid_t uuid;
> > > > > +       u32 uuid0_4[4] = { 0 };
> > > > > +
> > > > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > > > +               return -ENODEV;
> > > > > +       }
> > > > > +
> > > > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > > > +                                        uuid0_4[3], &buffer);
> > > Wrong byte order?
> > > According to section 5.3 of the SMCCC, UUIDs are returned as a single
> > > 128-bit value using the SMC32 calling convention. This value is mapped
> > > to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> > > for example shall hold bytes 0 to 3, with byte 0 in the low-order
> > > bits.
> > >
> >
> > I need to spend some time to understand the concern here. Initially I agreed
> > with your analysis and then a quick review make be realise it is all OK.
> > I need to check if my understanding is correct again. I thought I will
> > take example and check here itself.
> >
> > UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"

IIUC this maps to (as per RFC4122).

fd02c9da = time_low (bytes 0-3)
306c48c7 = time_mid & time_hi_and_version (bytes 4-7)
a49cbbd8 = clock_seq_hi_and_reserved, clock_seq_low and bytes/octets 0-1 of node (bytes 8-11)
27ae86ee = bytes 2-5 of node (bytes 12-15)

SMCCC says:

w0 : bytes 0-3 with byte 0 in the lower order bits.
w1 : bytes 4-7 with byte 4 in the lower order bits.
w2 : bytes 8-11 with byte 8 in the lower order bits.
w3 : bytes 12-15 with byte 12 in the lower order bits.

This should amount to:

w0 = dac902fd
w1 = c7486c30
w2 = d8bb9ca4
w3 = ee86ae27

So, even though RFC4122 uses big-endian i.e network byte order. The UUID is
encoded as little-endian as per the SMCCC.

What do you reckon?

cheers,
Achin

> >
> > UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
> > dac902fd c7486c30 d8bb9ca4 ee86ae27
> >
> > It seems correct as per SMCCC convention to me, or am I missing something
> > obvious ?
>
> In this example I'd expect the first register to hold 0xfd02c9da
> regardless of the byte order of the machine. If there is a different
> byte order in the receiver it will still be received as 0xfd02c9da.
> That's how I've understood the specification.


>
> Cheers,
> Jens

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

On Wed, Jan 13, 2021 at 01:58:56PM +0000, Achin Gupta wrote:
> On Wed, Jan 13, 2021 at 01:30:56PM +0100, Jens Wiklander wrote:
> > On Wed, Jan 13, 2021 at 10:44 AM Sudeep Holla <sudeep.holla@arm.com> wrote:
> > [...]
> > > > > > +static int ffa_partition_probe(const char *uuid_str,
> > > > > > +                              struct ffa_partition_info *buffer)
> > > > > > +{
> > > > > > +       int count;
> > > > > > +       uuid_t uuid;
> > > > > > +       u32 uuid0_4[4] = { 0 };
> > > > > > +
> > > > > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > > > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > > > > +               return -ENODEV;
> > > > > > +       }
> > > > > > +
> > > > > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > > > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > > > > +                                        uuid0_4[3], &buffer);
> > > > Wrong byte order?
> > > > According to section 5.3 of the SMCCC, UUIDs are returned as a single
> > > > 128-bit value using the SMC32 calling convention. This value is mapped
> > > > to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> > > > for example shall hold bytes 0 to 3, with byte 0 in the low-order
> > > > bits.
> > > >
> > >
> > > I need to spend some time to understand the concern here. Initially I agreed
> > > with your analysis and then a quick review make be realise it is all OK.
> > > I need to check if my understanding is correct again. I thought I will
> > > take example and check here itself.
> > >
> > > UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"
> 
> IIUC this maps to (as per RFC4122).
> 
> fd02c9da = time_low (bytes 0-3)
> 306c48c7 = time_mid & time_hi_and_version (bytes 4-7)
> a49cbbd8 = clock_seq_hi_and_reserved, clock_seq_low and bytes/octets 0-1 of node (bytes 8-11)
> 27ae86ee = bytes 2-5 of node (bytes 12-15)
> 
> SMCCC says:
> 
> w0 : bytes 0-3 with byte 0 in the lower order bits.
> w1 : bytes 4-7 with byte 4 in the lower order bits.
> w2 : bytes 8-11 with byte 8 in the lower order bits.
> w3 : bytes 12-15 with byte 12 in the lower order bits.
> 
> This should amount to:
> 
> w0 = dac902fd
> w1 = c7486c30
> w2 = d8bb9ca4
> w3 = ee86ae27
> 
> So, even though RFC4122 uses big-endian i.e network byte order. The UUID is
> encoded as little-endian as per the SMCCC.
> 
> What do you reckon?
>

Thank Achin, that matches my understanding too. I spent some time looking
at RFC4122[1] and concluded what we have is fine.

@Jens, one thing to note, I am not claiming to support this driver with
big-endian kernel. I plan to take that up once we settle with basic support.

> cheers,
> Achin
> 
> > >
> > > UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
> > > dac902fd c7486c30 d8bb9ca4 ee86ae27
> > >

Matches w0-w3 above, thanks for detailed explanation

> > > It seems correct as per SMCCC convention to me, or am I missing something
> > > obvious ?
> >
> > In this example I'd expect the first register to hold 0xfd02c9da
> > regardless of the byte order of the machine. If there is a different
> > byte order in the receiver it will still be received as 0xfd02c9da.
> > That's how I've understood the specification.
> 

-- 
Regards,
Sudeep

[1] https://tools.ietf.org/html/rfc4122

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Sudeep Holla]

On Wed, Jan 13, 2021 at 01:58:56PM +0000, Achin Gupta wrote:
> On Wed, Jan 13, 2021 at 01:30:56PM +0100, Jens Wiklander wrote:
> > On Wed, Jan 13, 2021 at 10:44 AM Sudeep Holla <sudeep.holla@arm.com> wrote:
> > [...]
> > > > > > +static int ffa_partition_probe(const char *uuid_str,
> > > > > > +                              struct ffa_partition_info *buffer)
> > > > > > +{
> > > > > > +       int count;
> > > > > > +       uuid_t uuid;
> > > > > > +       u32 uuid0_4[4] = { 0 };
> > > > > > +
> > > > > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > > > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > > > > +               return -ENODEV;
> > > > > > +       }
> > > > > > +
> > > > > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > > > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > > > > +                                        uuid0_4[3], &buffer);
> > > > Wrong byte order?
> > > > According to section 5.3 of the SMCCC, UUIDs are returned as a single
> > > > 128-bit value using the SMC32 calling convention. This value is mapped
> > > > to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> > > > for example shall hold bytes 0 to 3, with byte 0 in the low-order
> > > > bits.
> > > >
> > >
> > > I need to spend some time to understand the concern here. Initially I agreed
> > > with your analysis and then a quick review make be realise it is all OK.
> > > I need to check if my understanding is correct again. I thought I will
> > > take example and check here itself.
> > >
> > > UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"
> 
> IIUC this maps to (as per RFC4122).
> 
> fd02c9da = time_low (bytes 0-3)
> 306c48c7 = time_mid & time_hi_and_version (bytes 4-7)
> a49cbbd8 = clock_seq_hi_and_reserved, clock_seq_low and bytes/octets 0-1 of node (bytes 8-11)
> 27ae86ee = bytes 2-5 of node (bytes 12-15)
> 
> SMCCC says:
> 
> w0 : bytes 0-3 with byte 0 in the lower order bits.
> w1 : bytes 4-7 with byte 4 in the lower order bits.
> w2 : bytes 8-11 with byte 8 in the lower order bits.
> w3 : bytes 12-15 with byte 12 in the lower order bits.
> 
> This should amount to:
> 
> w0 = dac902fd
> w1 = c7486c30
> w2 = d8bb9ca4
> w3 = ee86ae27
> 
> So, even though RFC4122 uses big-endian i.e network byte order. The UUID is
> encoded as little-endian as per the SMCCC.
> 
> What do you reckon?
>

Thank Achin, that matches my understanding too. I spent some time looking
at RFC4122[1] and concluded what we have is fine.

@Jens, one thing to note, I am not claiming to support this driver with
big-endian kernel. I plan to take that up once we settle with basic support.

> cheers,
> Achin
> 
> > >
> > > UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
> > > dac902fd c7486c30 d8bb9ca4 ee86ae27
> > >

Matches w0-w3 above, thanks for detailed explanation

> > > It seems correct as per SMCCC convention to me, or am I missing something
> > > obvious ?
> >
> > In this example I'd expect the first register to hold 0xfd02c9da
> > regardless of the byte order of the machine. If there is a different
> > byte order in the receiver it will still be received as 0xfd02c9da.
> > That's how I've understood the specification.
> 

-- 
Regards,
Sudeep

[1] https://tools.ietf.org/html/rfc4122

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

On Wed, Jan 13, 2021 at 6:20 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
>
> On Wed, Jan 13, 2021 at 01:58:56PM +0000, Achin Gupta wrote:
> > On Wed, Jan 13, 2021 at 01:30:56PM +0100, Jens Wiklander wrote:
> > > On Wed, Jan 13, 2021 at 10:44 AM Sudeep Holla <sudeep.holla@arm.com> wrote:
> > > [...]
> > > > > > > +static int ffa_partition_probe(const char *uuid_str,
> > > > > > > +                              struct ffa_partition_info *buffer)
> > > > > > > +{
> > > > > > > +       int count;
> > > > > > > +       uuid_t uuid;
> > > > > > > +       u32 uuid0_4[4] = { 0 };
> > > > > > > +
> > > > > > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > > > > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > > > > > +               return -ENODEV;
> > > > > > > +       }
> > > > > > > +
> > > > > > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > > > > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > > > > > +                                        uuid0_4[3], &buffer);
> > > > > Wrong byte order?
> > > > > According to section 5.3 of the SMCCC, UUIDs are returned as a single
> > > > > 128-bit value using the SMC32 calling convention. This value is mapped
> > > > > to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> > > > > for example shall hold bytes 0 to 3, with byte 0 in the low-order
> > > > > bits.
> > > > >
> > > >
> > > > I need to spend some time to understand the concern here. Initially I agreed
> > > > with your analysis and then a quick review make be realise it is all OK.
> > > > I need to check if my understanding is correct again. I thought I will
> > > > take example and check here itself.
> > > >
> > > > UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"
> >
> > IIUC this maps to (as per RFC4122).
> >
> > fd02c9da = time_low (bytes 0-3)
> > 306c48c7 = time_mid & time_hi_and_version (bytes 4-7)
> > a49cbbd8 = clock_seq_hi_and_reserved, clock_seq_low and bytes/octets 0-1 of node (bytes 8-11)
> > 27ae86ee = bytes 2-5 of node (bytes 12-15)
> >
> > SMCCC says:
> >
> > w0 : bytes 0-3 with byte 0 in the lower order bits.
> > w1 : bytes 4-7 with byte 4 in the lower order bits.
> > w2 : bytes 8-11 with byte 8 in the lower order bits.
> > w3 : bytes 12-15 with byte 12 in the lower order bits.
> >
> > This should amount to:
> >
> > w0 = dac902fd
> > w1 = c7486c30
> > w2 = d8bb9ca4
> > w3 = ee86ae27
> >
> > So, even though RFC4122 uses big-endian i.e network byte order. The UUID is
> > encoded as little-endian as per the SMCCC.
> >
> > What do you reckon?
> >
>
> Thank Achin, that matches my understanding too. I spent some time looking
> at RFC4122[1] and concluded what we have is fine.

Thanks for the analysis.

>
> @Jens, one thing to note, I am not claiming to support this driver with
> big-endian kernel. I plan to take that up once we settle with basic support.

No worries, the OP-TEE driver doesn't support that either.

Cheers,
Jens

>
> > cheers,
> > Achin
> >
> > > >
> > > > UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
> > > > dac902fd c7486c30 d8bb9ca4 ee86ae27
> > > >
>
> Matches w0-w3 above, thanks for detailed explanation
>
> > > > It seems correct as per SMCCC convention to me, or am I missing something
> > > > obvious ?
> > >
> > > In this example I'd expect the first register to hold 0xfd02c9da
> > > regardless of the byte order of the machine. If there is a different
> > > byte order in the receiver it will still be received as 0xfd02c9da.
> > > That's how I've understood the specification.
> >
>
> --
> Regards,
> Sudeep
>
> [1] https://tools.ietf.org/html/rfc4122

Re: [PATCH v3 6/7] firmware: arm_ffa: Setup in-kernel users of FFA partitions

[Jens Wiklander]

On Wed, Jan 13, 2021 at 6:20 PM Sudeep Holla <sudeep.holla@arm.com> wrote:
>
> On Wed, Jan 13, 2021 at 01:58:56PM +0000, Achin Gupta wrote:
> > On Wed, Jan 13, 2021 at 01:30:56PM +0100, Jens Wiklander wrote:
> > > On Wed, Jan 13, 2021 at 10:44 AM Sudeep Holla <sudeep.holla@arm.com> wrote:
> > > [...]
> > > > > > > +static int ffa_partition_probe(const char *uuid_str,
> > > > > > > +                              struct ffa_partition_info *buffer)
> > > > > > > +{
> > > > > > > +       int count;
> > > > > > > +       uuid_t uuid;
> > > > > > > +       u32 uuid0_4[4] = { 0 };
> > > > > > > +
> > > > > > > +       if (uuid_parse(uuid_str, &uuid)) {
> > > > > > > +               pr_err("invalid uuid (%s)\n", uuid_str);
> > > > > > > +               return -ENODEV;
> > > > > > > +       }
> > > > > > > +
> > > > > > > +       export_uuid((u8 *)uuid0_4, &uuid);
> > > > > > > +       count = __ffa_partition_info_get(uuid0_4[0], uuid0_4[1], uuid0_4[2],
> > > > > > > +                                        uuid0_4[3], &buffer);
> > > > > Wrong byte order?
> > > > > According to section 5.3 of the SMCCC, UUIDs are returned as a single
> > > > > 128-bit value using the SMC32 calling convention. This value is mapped
> > > > > to argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0
> > > > > for example shall hold bytes 0 to 3, with byte 0 in the low-order
> > > > > bits.
> > > > >
> > > >
> > > > I need to spend some time to understand the concern here. Initially I agreed
> > > > with your analysis and then a quick review make be realise it is all OK.
> > > > I need to check if my understanding is correct again. I thought I will
> > > > take example and check here itself.
> > > >
> > > > UUID: "fd02c9da-306c-48c7-a49c-bbd827ae86ee"
> >
> > IIUC this maps to (as per RFC4122).
> >
> > fd02c9da = time_low (bytes 0-3)
> > 306c48c7 = time_mid & time_hi_and_version (bytes 4-7)
> > a49cbbd8 = clock_seq_hi_and_reserved, clock_seq_low and bytes/octets 0-1 of node (bytes 8-11)
> > 27ae86ee = bytes 2-5 of node (bytes 12-15)
> >
> > SMCCC says:
> >
> > w0 : bytes 0-3 with byte 0 in the lower order bits.
> > w1 : bytes 4-7 with byte 4 in the lower order bits.
> > w2 : bytes 8-11 with byte 8 in the lower order bits.
> > w3 : bytes 12-15 with byte 12 in the lower order bits.
> >
> > This should amount to:
> >
> > w0 = dac902fd
> > w1 = c7486c30
> > w2 = d8bb9ca4
> > w3 = ee86ae27
> >
> > So, even though RFC4122 uses big-endian i.e network byte order. The UUID is
> > encoded as little-endian as per the SMCCC.
> >
> > What do you reckon?
> >
>
> Thank Achin, that matches my understanding too. I spent some time looking
> at RFC4122[1] and concluded what we have is fine.

Thanks for the analysis.

>
> @Jens, one thing to note, I am not claiming to support this driver with
> big-endian kernel. I plan to take that up once we settle with basic support.

No worries, the OP-TEE driver doesn't support that either.

Cheers,
Jens

>
> > cheers,
> > Achin
> >
> > > >
> > > > UUID[0]   UUID[1]  UUID[2]  UUID[3] (referring uuid0_4 above)
> > > > dac902fd c7486c30 d8bb9ca4 ee86ae27
> > > >
>
> Matches w0-w3 above, thanks for detailed explanation
>
> > > > It seems correct as per SMCCC convention to me, or am I missing something
> > > > obvious ?
> > >
> > > In this example I'd expect the first register to hold 0xfd02c9da
> > > regardless of the byte order of the machine. If there is a different
> > > byte order in the receiver it will still be received as 0xfd02c9da.
> > > That's how I've understood the specification.
> >
>
> --
> Regards,
> Sudeep
>
> [1] https://tools.ietf.org/html/rfc4122

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel