/*
 * Copyright (c) 2020, Arm Limited. All rights reserved.
 * Copyright (c) 2022, Linaro Limited
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * This file is a Partition Manifest (PM) for a minimal Secure Partition (SP)
 * that has additional optional properties defined.
 *
 */

/dts-v1/;

/ {
	compatible = "arm,ffa-manifest-1.0";

	/* Properties */
	description = "op-tee";
	ffa-version = <0x00010000>; /* 31:16 - Major, 15:0 - Minor */
	uuid = <0xe0786148 0xe311f8e7 0x02005ebc 0x1bc5d5a5>;
	id = <1>;
	execution-ctx-count = <8>;
	exception-level = <2>; /* S-EL1 */
	execution-state = <0>; /* AARCH64 */
	load-address = <0xe300000>;
	mem-size = <0xd00000>;	/* OP-TEE specific extension */
	entrypoint-offset = <0x4000>;
	xlat-granule = <0>; /* 4KiB */
	boot-order = <0>;
	messaging-method = <0x3>; /* Direct messaging only */
	ns-interrupts-action = <1>; /* NS_ACTION_ME */

	/* Boot protocol */
	gp-register-num = <0x0>;

	/* Boot Info */
	boot-info {
		compatible = "arm,ffa-manifest-boot-info";
		ffa_manifest;
	};

	device-regions {
		compatible = "arm,ffa-manifest-device-regions";

		uart1 {
			base-address = <0x00000000 0x09040000>;
			pages-count = <1>;
			attributes = <0x3>; /* read-write */
			/* SPI, level-triggered, secure, priority=1 */
			interrupts = <0x28 0xb01>;
		};
	};
};
