From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from EUR05-VI1-obe.outbound.protection.outlook.com (EUR05-VI1-obe.outbound.protection.outlook.com [40.107.21.74]) by mx.groups.io with SMTP id smtpd.web09.7482.1666183996483733883 for ; Wed, 19 Oct 2022 05:53:17 -0700 Authentication-Results: mx.groups.io; dkim=pass header.i=@armh.onmicrosoft.com header.s=selector2-armh-onmicrosoft-com header.b=Vdi0El2l; spf=pass (domain: arm.com, ip: 40.107.21.74, mailfrom: sami.mujawar@arm.com) ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=GuDaeEn5KjXnMHGb042FDkUoq+p0KNFsonYAQAd494PvY3/vCug7p6g32GfIXiLvW0ypkPcigaOGNi0PvnF4DwVCrPWnur1qPCGOEgsVTXfS60ncANctD+yLth+0IwsCDTAjhaXGzcOfXVX05c9pX8aujXLPdt3XXf3FBquKcTqH6Ll+iFaZkivtu5gNFcg06p7VppNSPj6c6hyWO+NZ70k11Q0YLtgE3SLuRfWmMF3Rkuh6ithnoKUsZYwbID2JxTFGd80p1rc5lTRzGM3NuDERms8KzhuZanuMWaoAsKi+X12DTX/aKK4f2hzoSvw/RBHPWZRsRWOzPREQOXD8vQ== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=Gi7EQIK+8KPUZSYcbpXL1TyHlTSzvZPRgLzRcOCu0Ww=; b=cs9F+9zrQX4249mIGdfV3rz3EH90iASLG+sJy1Lezu2K4Bc89b8xmG/FK/giGgVu/RP/PRvJAWT6KOq9tiCzK17MvrFs1urSJV2dWoO3yYrs57IbCH7oM+K7NpFRXrg3hYzeL0KA7Arn4opS9nJWwGerjxVSH13C0JY/BMtKHTtnyZd47YM5YNOQ1bQ7MfO+KIWCrhqisIgPRm3FcGaviUminIQfaVXYKsxPxJ/q5IFGT2x7V2+gCye06PEZaceKgoNKIzhJcfbmoICqGgmLN+g/L3KntpZ1109jOIWNQEhbPkRpk9Y5kr6DK8MdvUqLY9gCoINmho8YLVq3/xeTZQ== ARC-Authentication-Results: i=2; mx.microsoft.com 1; spf=pass (sender ip is 63.35.35.123) smtp.rcpttodomain=edk2.groups.io smtp.mailfrom=arm.com; dmarc=pass (p=none sp=none pct=100) action=none header.from=arm.com; dkim=pass (signature was verified) header.d=armh.onmicrosoft.com; arc=pass (0 oda=1 ltdi=1 spf=[1,1,smtp.mailfrom=arm.com] dkim=[1,1,header.d=arm.com] dmarc=[1,1,header.from=arm.com]) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Gi7EQIK+8KPUZSYcbpXL1TyHlTSzvZPRgLzRcOCu0Ww=; b=Vdi0El2lv/66FCF6xMe5Aodp633zgnekeUcrJrrbB5bLK+i0CN7rryHaAxKRz+xEtfszDyJY94FqfgbZw8LQMw0QtNaIch3BZnojRz9DR/6WfSJv3EHbbz6k9Crjy7agis8tynwbMqgqrTdoFg8XhAxVLCSlfdUl/yZgPnfRvW8= Received: from ZR0P278CA0077.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:22::10) by GV1PR08MB8620.eurprd08.prod.outlook.com (2603:10a6:150:84::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5723.34; Wed, 19 Oct 2022 12:53:10 +0000 Received: from VI1EUR03FT046.eop-EUR03.prod.protection.outlook.com (2603:10a6:910:22:cafe::32) by ZR0P278CA0077.outlook.office365.com (2603:10a6:910:22::10) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5723.34 via Frontend Transport; Wed, 19 Oct 2022 12:53:10 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 63.35.35.123) smtp.mailfrom=arm.com; dkim=pass (signature was verified) header.d=armh.onmicrosoft.com;dmarc=pass action=none header.from=arm.com; Received-SPF: Pass (protection.outlook.com: domain of arm.com designates 63.35.35.123 as permitted sender) receiver=protection.outlook.com; client-ip=63.35.35.123; helo=64aa7808-outbound-1.mta.getcheckrecipient.com; pr=C Received: from 64aa7808-outbound-1.mta.getcheckrecipient.com (63.35.35.123) by VI1EUR03FT046.mail.protection.outlook.com (100.127.144.113) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5723.32 via Frontend Transport; Wed, 19 Oct 2022 12:53:09 +0000 Received: ("Tessian outbound f394866f3f2b:v130"); Wed, 19 Oct 2022 12:53:09 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 9854e4ed69af8401 X-CR-MTA-TID: 64aa7808 Received: from b63b71de9564.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id FA45707C-CBD5-4861-BD45-11CAD64B94DC.1; Wed, 19 Oct 2022 12:53:00 +0000 Received: from EUR02-DB5-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id b63b71de9564.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Wed, 19 Oct 2022 12:53:00 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=SGkmsJsJrB/rxdaiRSmuQcejdesJCBqcD0WPWSyNVWelxruU8o15G1N/R5VsocxfiR9WTtbFYZj/j4zWkH8zeMCxbFeN9erl7Lplf17T7JHKhNGvLd2wCuD2on9iuevjwkbXxEt5fCjpaAUS2GaMPrUfQMOMCj3TuJEfgib7VuSZf211yIHA12AYnYyovxNFGen8NCkTHS+c+gD8KIiR8secB61W/d8qEJdOi4wEIvfMewpydRZjZZUGx2aRVc3gsEmF1GmGn7cEFDw5npoU/mOi37rNVbYA3up2L4BVOHptYiyIy2splkRGJaN19DtQVGFQkBJe4AlKJk67n5FEXQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=Gi7EQIK+8KPUZSYcbpXL1TyHlTSzvZPRgLzRcOCu0Ww=; b=ceLhLBsbTkXxG90h51e715K/E6pE+3Rq7oXIP48Zje2aMft4czKvyks8/A7RNMdatDDaituBEIWaTOZEII8RBzsXw/roWbhy4kQOUa2ej0Ey1gPsTBprPoyKb0wV+X97UkfZWbQRLBhrg6oGNGTeeqZOE9tZ60malK/hlc0HYTzJQBixtsbGN2kAgjliypzvXRscfwf6ryhjnODIv32WVyMIUZlNOgEfBlwAw2ZObmOXqpbtMApRUax+YdNttbXCelSN4cO1r4bP15Mv9CCwCWg0IJG1fK3NfUEd56FEBEhEjmjHidQEohAzwBg2JiriAVQ6pyqgpChtfcsH5b3iug== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=arm.com; dmarc=pass action=none header.from=arm.com; dkim=pass header.d=arm.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Gi7EQIK+8KPUZSYcbpXL1TyHlTSzvZPRgLzRcOCu0Ww=; b=Vdi0El2lv/66FCF6xMe5Aodp633zgnekeUcrJrrbB5bLK+i0CN7rryHaAxKRz+xEtfszDyJY94FqfgbZw8LQMw0QtNaIch3BZnojRz9DR/6WfSJv3EHbbz6k9Crjy7agis8tynwbMqgqrTdoFg8XhAxVLCSlfdUl/yZgPnfRvW8= Authentication-Results-Original: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; Received: from AS8PR08MB6806.eurprd08.prod.outlook.com (2603:10a6:20b:39b::12) by DB9PR08MB6650.eurprd08.prod.outlook.com (2603:10a6:10:26d::23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5723.30; Wed, 19 Oct 2022 12:52:56 +0000 Received: from AS8PR08MB6806.eurprd08.prod.outlook.com ([fe80::283c:fe2e:699d:2bf]) by AS8PR08MB6806.eurprd08.prod.outlook.com ([fe80::283c:fe2e:699d:2bf%5]) with mapi id 15.20.5723.033; Wed, 19 Oct 2022 12:52:56 +0000 Message-ID: <27c6db3f-4739-6f1b-d669-f051457122cf@arm.com> Date: Wed, 19 Oct 2022 13:52:54 +0100 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Thunderbird/102.3.3 Subject: Re: [PATCH edk2-platforms 3/4] Platform/ARM: clone NorFlashDxe from ArmPlatformPkg To: Ard Biesheuvel , devel@edk2.groups.io Cc: Leif Lindholm , Thomas Abraham , "nd@arm.com" References: <20221019103555.493477-1-ardb@kernel.org> <20221019103555.493477-4-ardb@kernel.org> From: "Sami Mujawar" In-Reply-To: <20221019103555.493477-4-ardb@kernel.org> X-ClientProxiedBy: LO2P265CA0385.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:f::13) To AS8PR08MB6806.eurprd08.prod.outlook.com (2603:10a6:20b:39b::12) MIME-Version: 1.0 X-MS-TrafficTypeDiagnostic: AS8PR08MB6806:EE_|DB9PR08MB6650:EE_|VI1EUR03FT046:EE_|GV1PR08MB8620:EE_ X-MS-Office365-Filtering-Correlation-Id: 6e581635-a96a-47d8-2f7a-08dab1d0e041 x-checkrecipientrouted: true NoDisclaimer: true X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam-Untrusted: BCL:0; X-Microsoft-Antispam-Message-Info-Original: VYH8klI3yfvJbA1BdTr/10DCbyzDjg+/bG6fZscA2KMGooOz3/kd+Ea6rlG/mttFRmbJ5GkN4+rIIdXRj7DFvBe7Jj1QCMDho4+AUsKFhqhuFvhyfRW020Pji6dIonkSeYWY0+mX0F5iNtGXRxleT1hBeOP5SQrqwcwMEfcWZ1Tz22H1XtO5HPO9DLwiIUT0YIz9CkjETk4Klsz/V9QQEOsuy34JFqKaXxwP44m7p+2sPnIxxBMeO+L0qhQPEb+ciLXJOOAR+5cq2OIvaOOIu/k+zKq5u5XYEwrVxUito3IfhNzyrgyJcMH/haSCyN04zMgPeyNNmOCuaebCeITSvvKkc7hSTFGoZjgPj2CcOiS93l2D52jdHLnerc9OKrq+osjcmWadNsHpEVyjO7r2VBqZBSgQ7kM22D3gxpg7+8s7rxn5YH2Nr/FzcgCKt4AEt8YapttmvzEysHad52nFZxAOjbiHcWp4a7EGD1H4jKFf31r0qEze/8KH/AN3utEqjNRmps/X+xIcnRl6EHh+kjEJGVakhBI61alE9rHXbID7sMtsaUUm0PJX0RhsFfqLbZ4i+v6AcgU9SwrvMgQObpbWra2KHCUzX5vU3JacfsTGKlmGmym2e2W9jbxl0g2o+BNeefTGvMitmbWF70G1nGBZ83K74gNhTxmzblBlWwDFKY77QPL5ZOII5IQi9ypuqKxMVxJlnXQZHRzMKTJhfCi98cfPcRckYDIrQriarLMQiBjCO2XB7A+OD2AtNTq+3deOG4SiG1cJS/uIJ8ALKJ6QsqS8nGNRzDoxmjX7HZX5rXvlcKQFkHHkRdzLg0R7 X-Forefront-Antispam-Report-Untrusted: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:AS8PR08MB6806.eurprd08.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230022)(4636009)(39860400002)(396003)(346002)(376002)(136003)(366004)(451199015)(4326008)(66946007)(66476007)(8676002)(54906003)(316002)(2616005)(6506007)(66556008)(186003)(19627235002)(30864003)(5660300002)(44832011)(86362001)(83380400001)(2906002)(31696002)(26005)(41300700001)(53546011)(36756003)(6512007)(8936002)(66899015)(31686004)(478600001)(6486002)(38100700002)(45980500001)(43740500002)(559001)(579004)(44824005);DIR:OUT;SFP:1101; X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB9PR08MB6650 Original-Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; Return-Path: Sami.Mujawar@arm.com X-EOPAttributedMessage: 0 X-MS-Exchange-Transport-CrossTenantHeadersStripped: VI1EUR03FT046.eop-EUR03.prod.protection.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: d0e31832-0297-4cdd-3910-08dab1d0d7d6 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: OndpaPn3rr8Vhqy6BIf1nJCNY6MHCMG6vZ1l9j8oeE1qc3Cc9fB8YGqU7DG9BasCgLp/zhmA5AawyIr/FiaOJzE4gdMpDqjkAqNALvMae60eQE+wKQGGTzq8pBbmrg8Kk1XlA3ulEPvNfL5Ga370k0QOl4Ngm6wSfStT0ELmttO2JEpxoUM/TLgy3UX4Zkqv+yQ8215USaqM4SqR/MiQ8Nv/QPOfhPTuQw7oV7PgZ0CY3MqXq7Pku2MV7kp8R9wHSl3gx0p68hbTGS1JjRnAX82kc5y3MWaHXbksti2xjoOxv9740TT0Y0226kpZ8pNX8G6CM6Lb1J//SbI8DV0zawwLssRFPSFED2hvuJH/MIN6fCfygy3xSjJarbAgn4vT9py4fyNS8reawh/Y/NamLlGokiPe5N/AujIEo7fxEeqVOZgGEVXKJpqyfMF019/BDDOU5P4rB1fDar508skXixNdKvFLjSj+VbRIY+ftRQ/s0zIToHcJ+bTasQf48alX9SXmbx1VqTq0NEniWdWkccVljavSHsOn77RUEMKc9RP57RXn842otwdDfFNPB5YWbpxMpyZWFQuRPaUHPw/wp24KxTlwleRIfjVKzo9i47sjCA2yhFTaD3tuc8/OnWn3NZLIHoIhJOlqL7DunrUeYJLfJIGcysHZ2es2OGcNqGo/oy/JX1HJZBHbyBoCiguT1HFmyrGkGItnQ9uCd98tWwA3Pgg+joepl/XRzb/HijxYvCfW0Wbq4/Z1e1dH4+jXfQlMI5F5cqGZ/Xjm/PVaMkuG4nP2k2U3dCnk/Y0vXzLaBFI9oBZUi/z5hcie5IKGbs+6FALQxBSfqx6olz07oQ== X-Forefront-Antispam-Report: CIP:63.35.35.123;CTRY:IE;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:64aa7808-outbound-1.mta.getcheckrecipient.com;PTR:ec2-63-35-35-123.eu-west-1.compute.amazonaws.com;CAT:NONE;SFS:(13230022)(4636009)(39860400002)(136003)(396003)(376002)(346002)(451199015)(36840700001)(46966006)(40470700004)(66899015)(5660300002)(4326008)(8676002)(8936002)(70586007)(70206006)(2906002)(44832011)(30864003)(54906003)(40480700001)(41300700001)(316002)(81166007)(356005)(19627235002)(83380400001)(82740400003)(36860700001)(53546011)(6506007)(478600001)(86362001)(6486002)(31696002)(26005)(47076005)(336012)(186003)(6512007)(2616005)(82310400005)(40460700003)(31686004)(36756003)(43740500002)(559001)(579004)(44824005);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Oct 2022 12:53:09.8778 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 6e581635-a96a-47d8-2f7a-08dab1d0e041 X-MS-Exchange-CrossTenant-Id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=f34e5979-57d9-4aaa-ad4d-b122a662184d;Ip=[63.35.35.123];Helo=[64aa7808-outbound-1.mta.getcheckrecipient.com] X-MS-Exchange-CrossTenant-AuthSource: VI1EUR03FT046.eop-EUR03.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: GV1PR08MB8620 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Hi Ard, Thank you for this patch. Reviewed-by: Sami Mujawar Regards, Sami Mujawar On 19/10/2022 11:35 am, Ard Biesheuvel wrote: > The ArmPlatformPkg version of NorFlashDxe and NorFlashStandaloneMm will > be going away, so clone them into Platform/ARM where the ARM platforms > that rely on this driver can keep using it. > > Other than updating the INF version, refreshing the file GUIDs and > reorganizing the various INF sections, no changes have been made to the > driver. > > Signed-off-by: Ard Biesheuvel > --- > Platform/ARM/ARM.dec | 4 + > Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.inf | 71 ++ > Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf | 66 ++ > Platform/ARM/Drivers/NorFlashDxe/NorFlash.h | 422 +++++++++ > Platform/ARM/Drivers/NorFlashDxe/NorFlash.c | 991 ++++++++++++++++++++ > Platform/ARM/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c | 123 +++ > Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.c | 506 ++++++++++ > Platform/ARM/Drivers/NorFlashDxe/NorFlashFvb.c | 777 +++++++++++++++ > Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.c | 383 ++++++++ > 9 files changed, 3343 insertions(+) > > diff --git a/Platform/ARM/ARM.dec b/Platform/ARM/ARM.dec > index cf1c8ef04742..be7e6dc83fde 100644 > --- a/Platform/ARM/ARM.dec > +++ b/Platform/ARM/ARM.dec > @@ -20,4 +20,8 @@ [LibraryClasses] > NorFlashPlatformLib|Include/Library/NorFlashPlatformLib.h > > > > [Guids] > > + gPlatformArmTokenSpaceGuid = { 0x7a5e0def, 0xd3c3, 0x44f3, { 0x8d, 0x69, 0x70, 0xfc, 0x8f, 0xd6, 0x4f, 0xdf } } > > gArmBootMonFsFileInfoGuid = { 0x41e26b9c, 0xada6, 0x45b3, { 0x80, 0x8e, 0x23, 0x57, 0xa3, 0x5b, 0x60, 0xd6 } } > > + > > +[PcdsFeatureFlag.common] > > + gPlatformArmTokenSpaceGuid.PcdNorFlashCheckBlockLocked|FALSE|BOOLEAN|0x0000001 > > diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.inf b/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.inf > new file mode 100644 > index 000000000000..cdf1f5c27f35 > --- /dev/null > +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.inf > @@ -0,0 +1,71 @@ > +#/** @file > > +# > > +# Component description file for NorFlashDxe module > > +# > > +# Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.
> > +# > > +# SPDX-License-Identifier: BSD-2-Clause-Patent > > +# > > +#**/ > > + > > +[Defines] > > + INF_VERSION = 1.29 > > + BASE_NAME = NorFlashDxe > > + FILE_GUID = de6ae758-d662-4e17-a97c-4c5964da4c41 > > + MODULE_TYPE = DXE_RUNTIME_DRIVER > > + VERSION_STRING = 1.0 > > + ENTRY_POINT = NorFlashInitialise > > + > > +[Sources.common] > > + NorFlash.c > > + NorFlash.h > > + NorFlashBlockIoDxe.c > > + NorFlashDxe.c > > + NorFlashFvb.c > > + > > +[Packages] > > + EmbeddedPkg/EmbeddedPkg.dec > > + MdePkg/MdePkg.dec > > + MdeModulePkg/MdeModulePkg.dec > > + Platform/ARM/ARM.dec > > + > > +[LibraryClasses] > > + BaseLib > > + DebugLib > > + DxeServicesTableLib > > + HobLib > > + IoLib > > + NorFlashPlatformLib > > + UefiBootServicesTableLib > > + UefiDriverEntryPoint > > + UefiLib > > + UefiRuntimeLib > > + > > +[Guids] > > + gEdkiiNvVarStoreFormattedGuid ## PRODUCES ## PROTOCOL > > + gEfiAuthenticatedVariableGuid > > + gEfiEventVirtualAddressChangeGuid > > + gEfiSystemNvDataFvGuid > > + gEfiVariableGuid > > + > > +[Protocols] > > + gEfiBlockIoProtocolGuid > > + gEfiDevicePathProtocolGuid > > + gEfiDiskIoProtocolGuid > > + gEfiFirmwareVolumeBlockProtocolGuid > > + > > +[Pcd.common] > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64 > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase64 > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase64 > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize > > + > > + gPlatformArmTokenSpaceGuid.PcdNorFlashCheckBlockLocked > > + > > +[Depex] > > + gEfiCpuArchProtocolGuid > > diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf b/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf > new file mode 100644 > index 000000000000..001f281220f2 > --- /dev/null > +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf > @@ -0,0 +1,66 @@ > +#/** @file > > +# > > +# Component description file for NorFlashStandaloneMm module > > +# > > +# Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.
> > +# Copyright (c) 2020, Linaro, Ltd. All rights reserved.
> > +# > > +# SPDX-License-Identifier: BSD-2-Clause-Patent > > +# > > +#**/ > > + > > +[Defines] > > + INF_VERSION = 1.29 > > + BASE_NAME = NorFlashStandaloneMm > > + FILE_GUID = a87c67d2-f183-415c-993d-11431fc478ee > > + MODULE_TYPE = MM_STANDALONE > > + VERSION_STRING = 1.0 > > + PI_SPECIFICATION_VERSION = 0x00010032 > > + ENTRY_POINT = NorFlashInitialise > > + > > +[Sources.common] > > + NorFlash.c > > + NorFlash.h > > + NorFlashFvb.c > > + NorFlashStandaloneMm.c > > + > > +[Packages] > > + EmbeddedPkg/EmbeddedPkg.dec > > + MdeModulePkg/MdeModulePkg.dec > > + MdePkg/MdePkg.dec > > + Platform/ARM/ARM.dec > > + > > +[LibraryClasses] > > + BaseLib > > + BaseMemoryLib > > + DebugLib > > + IoLib > > + MemoryAllocationLib > > + MmServicesTableLib > > + NorFlashPlatformLib > > + StandaloneMmDriverEntryPoint > > + > > +[Guids] > > + gEfiSystemNvDataFvGuid > > + gEfiVariableGuid > > + gEfiAuthenticatedVariableGuid > > + > > +[Protocols] > > + gEfiSmmFirmwareVolumeBlockProtocolGuid > > + > > +[FixedPcd] > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64 > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase64 > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase64 > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize > > + > > +[FeaturePcd] > > + gPlatformArmTokenSpaceGuid.PcdNorFlashCheckBlockLocked > > + > > +[Depex] > > + TRUE > > diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlash.h b/Platform/ARM/Drivers/NorFlashDxe/NorFlash.h > new file mode 100644 > index 000000000000..c83032e87d9c > --- /dev/null > +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlash.h > @@ -0,0 +1,422 @@ > +/** @file NorFlash.h > > + > > + Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.
> > + > > + SPDX-License-Identifier: BSD-2-Clause-Patent > > + > > +**/ > > + > > +#ifndef __NOR_FLASH_H__ > > +#define __NOR_FLASH_H__ > > + > > +#include > > +#include > > + > > +#include > > + > > +#include > > +#include > > +#include > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#define NOR_FLASH_ERASE_RETRY 10 > > + > > +// Device access macros > > +// These are necessary because we use 2 x 16bit parts to make up 32bit data > > + > > +#define HIGH_16_BITS 0xFFFF0000 > > +#define LOW_16_BITS 0x0000FFFF > > +#define LOW_8_BITS 0x000000FF > > + > > +#define FOLD_32BIT_INTO_16BIT(value) ( ( value >> 16 ) | ( value & LOW_16_BITS ) ) > > + > > +#define GET_LOW_BYTE(value) ( value & LOW_8_BITS ) > > +#define GET_HIGH_BYTE(value) ( GET_LOW_BYTE( value >> 16 ) ) > > + > > +// Each command must be sent simultaneously to both chips, > > +// i.e. at the lower 16 bits AND at the higher 16 bits > > +#define CREATE_NOR_ADDRESS(BaseAddr, OffsetAddr) ((BaseAddr) + ((OffsetAddr) << 2)) > > +#define CREATE_DUAL_CMD(Cmd) ( ( Cmd << 16) | ( Cmd & LOW_16_BITS) ) > > +#define SEND_NOR_COMMAND(BaseAddr, Offset, Cmd) MmioWrite32 (CREATE_NOR_ADDRESS(BaseAddr,Offset), CREATE_DUAL_CMD(Cmd)) > > +#define GET_NOR_BLOCK_ADDRESS(BaseAddr, Lba, LbaSize) ( BaseAddr + (UINTN)((Lba) * LbaSize) ) > > + > > +// Status Register Bits > > +#define P30_SR_BIT_WRITE (BIT7 << 16 | BIT7) > > +#define P30_SR_BIT_ERASE_SUSPEND (BIT6 << 16 | BIT6) > > +#define P30_SR_BIT_ERASE (BIT5 << 16 | BIT5) > > +#define P30_SR_BIT_PROGRAM (BIT4 << 16 | BIT4) > > +#define P30_SR_BIT_VPP (BIT3 << 16 | BIT3) > > +#define P30_SR_BIT_PROGRAM_SUSPEND (BIT2 << 16 | BIT2) > > +#define P30_SR_BIT_BLOCK_LOCKED (BIT1 << 16 | BIT1) > > +#define P30_SR_BIT_BEFP (BIT0 << 16 | BIT0) > > + > > +// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family > > + > > +// On chip buffer size for buffered programming operations > > +// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each word is 2 bytes. > > +// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes > > +#define P30_MAX_BUFFER_SIZE_IN_BYTES ((UINTN)128) > > +#define P30_MAX_BUFFER_SIZE_IN_WORDS (P30_MAX_BUFFER_SIZE_IN_BYTES/((UINTN)4)) > > +#define MAX_BUFFERED_PROG_ITERATIONS 10000000 > > +#define BOUNDARY_OF_32_WORDS 0x7F > > + > > +// CFI Addresses > > +#define P30_CFI_ADDR_QUERY_UNIQUE_QRY 0x10 > > +#define P30_CFI_ADDR_VENDOR_ID 0x13 > > + > > +// CFI Data > > +#define CFI_QRY 0x00595251 > > + > > +// READ Commands > > +#define P30_CMD_READ_DEVICE_ID 0x0090 > > +#define P30_CMD_READ_STATUS_REGISTER 0x0070 > > +#define P30_CMD_CLEAR_STATUS_REGISTER 0x0050 > > +#define P30_CMD_READ_ARRAY 0x00FF > > +#define P30_CMD_READ_CFI_QUERY 0x0098 > > + > > +// WRITE Commands > > +#define P30_CMD_WORD_PROGRAM_SETUP 0x0040 > > +#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP 0x0010 > > +#define P30_CMD_BUFFERED_PROGRAM_SETUP 0x00E8 > > +#define P30_CMD_BUFFERED_PROGRAM_CONFIRM 0x00D0 > > +#define P30_CMD_BEFP_SETUP 0x0080 > > +#define P30_CMD_BEFP_CONFIRM 0x00D0 > > + > > +// ERASE Commands > > +#define P30_CMD_BLOCK_ERASE_SETUP 0x0020 > > +#define P30_CMD_BLOCK_ERASE_CONFIRM 0x00D0 > > + > > +// SUSPEND Commands > > +#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND 0x00B0 > > +#define P30_CMD_SUSPEND_RESUME 0x00D0 > > + > > +// BLOCK LOCKING / UNLOCKING Commands > > +#define P30_CMD_LOCK_BLOCK_SETUP 0x0060 > > +#define P30_CMD_LOCK_BLOCK 0x0001 > > +#define P30_CMD_UNLOCK_BLOCK 0x00D0 > > +#define P30_CMD_LOCK_DOWN_BLOCK 0x002F > > + > > +// PROTECTION Commands > > +#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0 > > + > > +// CONFIGURATION Commands > > +#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060 > > +#define P30_CMD_READ_CONFIGURATION_REGISTER 0x0003 > > + > > +#define NOR_FLASH_SIGNATURE SIGNATURE_32('n', 'o', 'r', '0') > > +#define INSTANCE_FROM_FVB_THIS(a) CR(a, NOR_FLASH_INSTANCE, FvbProtocol, NOR_FLASH_SIGNATURE) > > +#define INSTANCE_FROM_BLKIO_THIS(a) CR(a, NOR_FLASH_INSTANCE, BlockIoProtocol, NOR_FLASH_SIGNATURE) > > +#define INSTANCE_FROM_DISKIO_THIS(a) CR(a, NOR_FLASH_INSTANCE, DiskIoProtocol, NOR_FLASH_SIGNATURE) > > + > > +typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTANCE; > > + > > +#pragma pack (1) > > +typedef struct { > > + VENDOR_DEVICE_PATH Vendor; > > + UINT8 Index; > > + EFI_DEVICE_PATH_PROTOCOL End; > > +} NOR_FLASH_DEVICE_PATH; > > +#pragma pack () > > + > > +struct _NOR_FLASH_INSTANCE { > > + UINT32 Signature; > > + EFI_HANDLE Handle; > > + > > + UINTN DeviceBaseAddress; > > + UINTN RegionBaseAddress; > > + UINTN Size; > > + EFI_LBA StartLba; > > + > > + EFI_BLOCK_IO_PROTOCOL BlockIoProtocol; > > + EFI_BLOCK_IO_MEDIA Media; > > + EFI_DISK_IO_PROTOCOL DiskIoProtocol; > > + > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol; > > + VOID *ShadowBuffer; > > + > > + NOR_FLASH_DEVICE_PATH DevicePath; > > +}; > > + > > +EFI_STATUS > > +NorFlashReadCfiData ( > > + IN UINTN DeviceBaseAddress, > > + IN UINTN CFI_Offset, > > + IN UINT32 NumberOfBytes, > > + OUT UINT32 *Data > > + ); > > + > > +EFI_STATUS > > +NorFlashWriteBuffer ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN TargetAddress, > > + IN UINTN BufferSizeInBytes, > > + IN UINT32 *Buffer > > + ); > > + > > +// > > +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashBlockIoReset ( > > + IN EFI_BLOCK_IO_PROTOCOL *This, > > + IN BOOLEAN ExtendedVerification > > + ); > > + > > +// > > +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashBlockIoReadBlocks ( > > + IN EFI_BLOCK_IO_PROTOCOL *This, > > + IN UINT32 MediaId, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ); > > + > > +// > > +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashBlockIoWriteBlocks ( > > + IN EFI_BLOCK_IO_PROTOCOL *This, > > + IN UINT32 MediaId, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + IN VOID *Buffer > > + ); > > + > > +// > > +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashBlockIoFlushBlocks ( > > + IN EFI_BLOCK_IO_PROTOCOL *This > > + ); > > + > > +// > > +// DiskIO Protocol function EFI_DISK_IO_PROTOCOL.ReadDisk > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashDiskIoReadDisk ( > > + IN EFI_DISK_IO_PROTOCOL *This, > > + IN UINT32 MediaId, > > + IN UINT64 Offset, > > + IN UINTN BufferSize, > > + OUT VOID *Buffer > > + ); > > + > > +// > > +// DiskIO Protocol function EFI_DISK_IO_PROTOCOL.WriteDisk > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashDiskIoWriteDisk ( > > + IN EFI_DISK_IO_PROTOCOL *This, > > + IN UINT32 MediaId, > > + IN UINT64 Offset, > > + IN UINTN BufferSize, > > + IN VOID *Buffer > > + ); > > + > > +// > > +// NorFlashFvbDxe.c > > +// > > + > > +EFI_STATUS > > +EFIAPI > > +FvbGetAttributes ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbSetAttributes ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbGetPhysicalAddress ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + OUT EFI_PHYSICAL_ADDRESS *Address > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbGetBlockSize ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + OUT UINTN *BlockSize, > > + OUT UINTN *NumberOfBlocks > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbRead ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN OUT UINT8 *Buffer > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbWrite ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbEraseBlocks ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + ... > > + ); > > + > > +EFI_STATUS > > +ValidateFvHeader ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ); > > + > > +EFI_STATUS > > +InitializeFvAndVariableStoreHeaders ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ); > > + > > +VOID > > +EFIAPI > > +FvbVirtualNotifyEvent ( > > + IN EFI_EVENT Event, > > + IN VOID *Context > > + ); > > + > > +// > > +// NorFlashDxe.c > > +// > > + > > +EFI_STATUS > > +NorFlashWriteFullBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINT32 *DataBuffer, > > + IN UINT32 BlockSizeInWords > > + ); > > + > > +EFI_STATUS > > +NorFlashUnlockAndEraseSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ); > > + > > +EFI_STATUS > > +NorFlashCreateInstance ( > > + IN UINTN NorFlashDeviceBase, > > + IN UINTN NorFlashRegionBase, > > + IN UINTN NorFlashSize, > > + IN UINT32 Index, > > + IN UINT32 BlockSize, > > + IN BOOLEAN SupportFvb, > > + OUT NOR_FLASH_INSTANCE **NorFlashInstance > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashFvbInitialize ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ); > > + > > +// > > +// NorFlash.c > > +// > > +EFI_STATUS > > +NorFlashWriteSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashWriteBlocks ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + IN VOID *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashReadBlocks ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashRead ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashWrite ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashReset ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ); > > + > > +EFI_STATUS > > +NorFlashEraseSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ); > > + > > +EFI_STATUS > > +NorFlashUnlockSingleBlockIfNecessary ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ); > > + > > +EFI_STATUS > > +NorFlashWriteSingleWord ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN WordAddress, > > + IN UINT32 WriteData > > + ); > > + > > +VOID > > +EFIAPI > > +NorFlashVirtualNotifyEvent ( > > + IN EFI_EVENT Event, > > + IN VOID *Context > > + ); > > + > > +#endif /* __NOR_FLASH_H__ */ > > diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlash.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlash.c > new file mode 100644 > index 000000000000..1b431073ee93 > --- /dev/null > +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlash.c > @@ -0,0 +1,991 @@ > +/** @file NorFlash.c > > + > > + Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.
> > + Copyright (c) 2020, Linaro, Ltd. All rights reserved.
> > + > > + SPDX-License-Identifier: BSD-2-Clause-Patent > > + > > +**/ > > + > > +#include > > + > > +#include "NorFlash.h" > > + > > +// > > +// Global variable declarations > > +// > > +extern NOR_FLASH_INSTANCE **mNorFlashInstances; > > +extern UINT32 mNorFlashDeviceCount; > > + > > +UINT32 > > +NorFlashReadStatusRegister ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN SR_Address > > + ) > > +{ > > + // Prepare to read the status register > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER); > > + return MmioRead32 (Instance->DeviceBaseAddress); > > +} > > + > > +STATIC > > +BOOLEAN > > +NorFlashBlockIsLocked ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + UINT32 LockStatus; > > + > > + // Send command for reading device id > > + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID); > > + > > + // Read block lock status > > + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)); > > + > > + // Decode block lock status > > + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus); > > + > > + if ((LockStatus & 0x2) != 0) { > > + DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n")); > > + } > > + > > + return ((LockStatus & 0x1) != 0); > > +} > > + > > +STATIC > > +EFI_STATUS > > +NorFlashUnlockSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + UINT32 LockStatus; > > + > > + // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations > > + // and to protect shared data structures. > > + > > + if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) { > > + do { > > + // Request a lock setup > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP); > > + > > + // Request an unlock > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK); > > + > > + // Send command for reading device id > > + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID); > > + > > + // Read block lock status > > + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)); > > + > > + // Decode block lock status > > + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus); > > + } while ((LockStatus & 0x1) == 1); > > + } else { > > + // Request a lock setup > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP); > > + > > + // Request an unlock > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK); > > + > > + // Wait until the status register gives us the all clear > > + do { > > + LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress); > > + } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > + } > > + > > + // Put device back into Read Array mode > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY); > > + > > + DEBUG ((DEBUG_BLKIO, "UnlockSingleBlock: BlockAddress=0x%08x\n", BlockAddress)); > > + > > + return EFI_SUCCESS; > > +} > > + > > +EFI_STATUS > > +NorFlashUnlockSingleBlockIfNecessary ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + EFI_STATUS Status; > > + > > + Status = EFI_SUCCESS; > > + > > + if (NorFlashBlockIsLocked (Instance, BlockAddress)) { > > + Status = NorFlashUnlockSingleBlock (Instance, BlockAddress); > > + } > > + > > + return Status; > > +} > > + > > +/** > > + * The following function presumes that the block has already been unlocked. > > + **/ > > +EFI_STATUS > > +NorFlashEraseSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 StatusRegister; > > + > > + Status = EFI_SUCCESS; > > + > > + // Request a block erase and then confirm it > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP); > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM); > > + > > + // Wait until the status register gives us the all clear > > + do { > > + StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress); > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > + > > + if (StatusRegister & P30_SR_BIT_VPP) { > > + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) { > > + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", BlockAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_ERASE) { > > + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", BlockAddress, StatusRegister)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > + // The debug level message has been reduced because a device lock might happen. In this case we just retry it ... > > + DEBUG ((DEBUG_INFO, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", BlockAddress)); > > + Status = EFI_WRITE_PROTECTED; > > + } > > + > > + if (EFI_ERROR (Status)) { > > + // Clear the Status Register > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > + } > > + > > + // Put device back into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +NorFlashWriteSingleWord ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN WordAddress, > > + IN UINT32 WriteData > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 StatusRegister; > > + > > + Status = EFI_SUCCESS; > > + > > + // Request a write single word command > > + SEND_NOR_COMMAND (WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP); > > + > > + // Store the word into NOR Flash; > > + MmioWrite32 (WordAddress, WriteData); > > + > > + // Wait for the write to complete and then check for any errors; i.e. check the Status Register > > + do { > > + // Prepare to read the status register > > + StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress); > > + // The chip is busy while the WRITE bit is not asserted > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > + > > + // Perform a full status check: > > + // Mask the relevant bits of Status Register. > > + // Everything should be zero, if not, we have a problem > > + > > + if (StatusRegister & P30_SR_BIT_VPP) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n", WordAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n", WordAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n", WordAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (!EFI_ERROR (Status)) { > > + // Clear the Status Register > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > + } > > + > > + // Put device back into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + return Status; > > +} > > + > > +/* > > + * Writes data to the NOR Flash using the Buffered Programming method. > > + * > > + * The maximum size of the on-chip buffer is 32-words, because of hardware restrictions. > > + * Therefore this function will only handle buffers up to 32 words or 128 bytes. > > + * To deal with larger buffers, call this function again. > > + * > > + * This function presumes that both the TargetAddress and the TargetAddress+BufferSize > > + * exist entirely within the NOR Flash. Therefore these conditions will not be checked here. > > + * > > + * In buffered programming, if the target address not at the beginning of a 32-bit word boundary, > > + * then programming time is doubled and power consumption is increased. > > + * Therefore, it is a requirement to align buffer writes to 32-bit word boundaries. > > + * i.e. the last 4 bits of the target start address must be zero: 0x......00 > > + */ > > +EFI_STATUS > > +NorFlashWriteBuffer ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN TargetAddress, > > + IN UINTN BufferSizeInBytes, > > + IN UINT32 *Buffer > > + ) > > +{ > > + EFI_STATUS Status; > > + UINTN BufferSizeInWords; > > + UINTN Count; > > + volatile UINT32 *Data; > > + UINTN WaitForBuffer; > > + BOOLEAN BufferAvailable; > > + UINT32 StatusRegister; > > + > > + WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS; > > + BufferAvailable = FALSE; > > + > > + // Check that the target address does not cross a 32-word boundary. > > + if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Check there are some data to program > > + if (BufferSizeInBytes == 0) { > > + return EFI_BUFFER_TOO_SMALL; > > + } > > + > > + // Check that the buffer size does not exceed the maximum hardware buffer size on chip. > > + if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // Check that the buffer size is a multiple of 32-bit words > > + if ((BufferSizeInBytes % 4) != 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // Pre-programming conditions checked, now start the algorithm. > > + > > + // Prepare the data destination address > > + Data = (UINT32 *)TargetAddress; > > + > > + // Check the availability of the buffer > > + do { > > + // Issue the Buffered Program Setup command > > + SEND_NOR_COMMAND (TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP); > > + > > + // Read back the status register bit#7 from the same address > > + if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) { > > + BufferAvailable = TRUE; > > + } > > + > > + // Update the loop counter > > + WaitForBuffer--; > > + } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE)); > > + > > + // The buffer was not available for writing > > + if (WaitForBuffer == 0) { > > + Status = EFI_DEVICE_ERROR; > > + goto EXIT; > > + } > > + > > + // From now on we work in 32-bit words > > + BufferSizeInWords = BufferSizeInBytes / (UINTN)4; > > + > > + // Write the word count, which is (buffer_size_in_words - 1), > > + // because word count 0 means one word. > > + SEND_NOR_COMMAND (TargetAddress, 0, (BufferSizeInWords - 1)); > > + > > + // Write the data to the NOR Flash, advancing each address by 4 bytes > > + for (Count = 0; Count < BufferSizeInWords; Count++, Data++, Buffer++) { > > + MmioWrite32 ((UINTN)Data, *Buffer); > > + } > > + > > + // Issue the Buffered Program Confirm command, to start the programming operation > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM); > > + > > + // Wait for the write to complete and then check for any errors; i.e. check the Status Register > > + do { > > + StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress); > > + // The chip is busy while the WRITE bit is not asserted > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > + > > + // Perform a full status check: > > + // Mask the relevant bits of Status Register. > > + // Everything should be zero, if not, we have a problem > > + > > + Status = EFI_SUCCESS; > > + > > + if (StatusRegister & P30_SR_BIT_VPP) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): VPP Range Error\n", TargetAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): Program Error\n", TargetAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): Device Protect Error\n", TargetAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (!EFI_ERROR (Status)) { > > + // Clear the Status Register > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > + } > > + > > +EXIT: > > + // Put device back into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +NorFlashWriteBlocks ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + IN VOID *Buffer > > + ) > > +{ > > + UINT32 *pWriteBuffer; > > + EFI_STATUS Status; > > + EFI_LBA CurrentBlock; > > + UINT32 BlockSizeInWords; > > + UINT32 NumBlocks; > > + UINT32 BlockCount; > > + > > + Status = EFI_SUCCESS; > > + > > + // The buffer must be valid > > + if (Buffer == NULL) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + if (Instance->Media.ReadOnly == TRUE) { > > + return EFI_WRITE_PROTECTED; > > + } > > + > > + // We must have some bytes to read > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes)); > > + if (BufferSizeInBytes == 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // The size of the buffer must be a multiple of the block size > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->Media.BlockSize)); > > + if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // All blocks must be within the device > > + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize; > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->Media.LastBlock, Lba)); > > + > > + if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n")); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + BlockSizeInWords = Instance->Media.BlockSize / 4; > > + > > + // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer > > + // to a proper data type, so use *ReadBuffer > > + pWriteBuffer = (UINT32 *)Buffer; > > + > > + CurrentBlock = Lba; > > + for (BlockCount = 0; BlockCount < NumBlocks; BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) { > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock)); > > + > > + Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords); > > + > > + if (EFI_ERROR (Status)) { > > + break; > > + } > > + } > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status)); > > + return Status; > > +} > > + > > +#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0) > > + > > +/** > > + Copy Length bytes from Source to Destination, using aligned accesses only. > > + Note that this implementation uses memcpy() semantics rather then memmove() > > + semantics, i.e., SourceBuffer and DestinationBuffer should not overlap. > > + > > + @param DestinationBuffer The target of the copy request. > > + @param SourceBuffer The place to copy from. > > + @param Length The number of bytes to copy. > > + > > + @return Destination > > + > > +**/ > > +STATIC > > +VOID * > > +AlignedCopyMem ( > > + OUT VOID *DestinationBuffer, > > + IN CONST VOID *SourceBuffer, > > + IN UINTN Length > > + ) > > +{ > > + UINT8 *Destination8; > > + CONST UINT8 *Source8; > > + UINT32 *Destination32; > > + CONST UINT32 *Source32; > > + UINT64 *Destination64; > > + CONST UINT64 *Source64; > > + > > + if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 8) && (Length >= 8)) { > > + Destination64 = DestinationBuffer; > > + Source64 = SourceBuffer; > > + while (Length >= 8) { > > + *Destination64++ = *Source64++; > > + Length -= 8; > > + } > > + > > + Destination8 = (UINT8 *)Destination64; > > + Source8 = (CONST UINT8 *)Source64; > > + } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) && (Length >= 4)) { > > + Destination32 = DestinationBuffer; > > + Source32 = SourceBuffer; > > + while (Length >= 4) { > > + *Destination32++ = *Source32++; > > + Length -= 4; > > + } > > + > > + Destination8 = (UINT8 *)Destination32; > > + Source8 = (CONST UINT8 *)Source32; > > + } else { > > + Destination8 = DestinationBuffer; > > + Source8 = SourceBuffer; > > + } > > + > > + while (Length-- != 0) { > > + *Destination8++ = *Source8++; > > + } > > + > > + return DestinationBuffer; > > +} > > + > > +EFI_STATUS > > +NorFlashReadBlocks ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ) > > +{ > > + UINT32 NumBlocks; > > + UINTN StartAddress; > > + > > + DEBUG (( > > + DEBUG_BLKIO, > > + "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n", > > + BufferSizeInBytes, > > + Instance->Media.BlockSize, > > + Instance->Media.LastBlock, > > + Lba > > + )); > > + > > + // The buffer must be valid > > + if (Buffer == NULL) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Return if we have not any byte to read > > + if (BufferSizeInBytes == 0) { > > + return EFI_SUCCESS; > > + } > > + > > + // The size of the buffer must be a multiple of the block size > > + if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // All blocks must be within the device > > + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize; > > + > > + if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) { > > + DEBUG ((DEBUG_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n")); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Get the address to start reading from > > + StartAddress = GET_NOR_BLOCK_ADDRESS ( > > + Instance->RegionBaseAddress, > > + Lba, > > + Instance->Media.BlockSize > > + ); > > + > > + // Put the device into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + // Readout the data > > + AlignedCopyMem (Buffer, (VOID *)StartAddress, BufferSizeInBytes); > > + > > + return EFI_SUCCESS; > > +} > > + > > +EFI_STATUS > > +NorFlashRead ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ) > > +{ > > + UINTN StartAddress; > > + > > + // The buffer must be valid > > + if (Buffer == NULL) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Return if we have not any byte to read > > + if (BufferSizeInBytes == 0) { > > + return EFI_SUCCESS; > > + } > > + > > + if (((Lba * Instance->Media.BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) { > > + DEBUG ((DEBUG_ERROR, "NorFlashRead: ERROR - Read will exceed device size.\n")); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Get the address to start reading from > > + StartAddress = GET_NOR_BLOCK_ADDRESS ( > > + Instance->RegionBaseAddress, > > + Lba, > > + Instance->Media.BlockSize > > + ); > > + > > + // Put the device into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + // Readout the data > > + AlignedCopyMem (Buffer, (VOID *)(StartAddress + Offset), BufferSizeInBytes); > > + > > + return EFI_SUCCESS; > > +} > > + > > +/* > > + Write a full or portion of a block. It must not span block boundaries; that is, > > + Offset + *NumBytes <= Instance->Media.BlockSize. > > +*/ > > +EFI_STATUS > > +NorFlashWriteSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ) > > +{ > > + EFI_STATUS TempStatus; > > + UINT32 Tmp; > > + UINT32 TmpBuf; > > + UINT32 WordToWrite; > > + UINT32 Mask; > > + BOOLEAN DoErase; > > + UINTN BytesToWrite; > > + UINTN CurOffset; > > + UINTN WordAddr; > > + UINTN BlockSize; > > + UINTN BlockAddress; > > + UINTN PrevBlockAddress; > > + > > + PrevBlockAddress = 0; > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Lba, Offset, *NumBytes, Buffer)); > > + > > + // Detect WriteDisabled state > > + if (Instance->Media.ReadOnly == TRUE) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - Can not write: Device is in WriteDisabled state.\n")); > > + // It is in WriteDisabled state, return an error right away > > + return EFI_ACCESS_DENIED; > > + } > > + > > + // Cache the block size to avoid de-referencing pointers all the time > > + BlockSize = Instance->Media.BlockSize; > > + > > + // The write must not span block boundaries. > > + // We need to check each variable individually because adding two large values together overflows. > > + if ((Offset >= BlockSize) || > > + (*NumBytes > BlockSize) || > > + ((Offset + *NumBytes) > BlockSize)) > > + { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize)); > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // We must have some bytes to write > > + if (*NumBytes == 0) { > > + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize)); > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // Pick 128bytes as a good start for word operations as opposed to erasing the > > + // block and writing the data regardless if an erase is really needed. > > + // It looks like most individual NV variable writes are smaller than 128bytes. > > + if (*NumBytes <= 128) { > > + // Check to see if we need to erase before programming the data into NOR. > > + // If the destination bits are only changing from 1s to 0s we can just write. > > + // After a block is erased all bits in the block is set to 1. > > + // If any byte requires us to erase we just give up and rewrite all of it. > > + DoErase = FALSE; > > + BytesToWrite = *NumBytes; > > + CurOffset = Offset; > > + > > + while (BytesToWrite > 0) { > > + // Read full word from NOR, splice as required. A word is the smallest > > + // unit we can write. > > + TempStatus = NorFlashRead (Instance, Lba, CurOffset & ~(0x3), sizeof (Tmp), &Tmp); > > + if (EFI_ERROR (TempStatus)) { > > + return EFI_DEVICE_ERROR; > > + } > > + > > + // Physical address of word in NOR to write. > > + WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS ( > > + Instance->RegionBaseAddress, > > + Lba, > > + BlockSize > > + ); > > + // The word of data that is to be written. > > + TmpBuf = *((UINT32 *)(Buffer + (*NumBytes - BytesToWrite))); > > + > > + // First do word aligned chunks. > > + if ((CurOffset & 0x3) == 0) { > > + if (BytesToWrite >= 4) { > > + // Is the destination still in 'erased' state? > > + if (~Tmp != 0) { > > + // Check to see if we are only changing bits to zero. > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > + DoErase = TRUE; > > + break; > > + } > > + } > > + > > + // Write this word to NOR > > + WordToWrite = TmpBuf; > > + CurOffset += sizeof (TmpBuf); > > + BytesToWrite -= sizeof (TmpBuf); > > + } else { > > + // BytesToWrite < 4. Do small writes and left-overs > > + Mask = ~((~0) << (BytesToWrite * 8)); > > + // Mask out the bytes we want. > > + TmpBuf &= Mask; > > + // Is the destination still in 'erased' state? > > + if ((Tmp & Mask) != Mask) { > > + // Check to see if we are only changing bits to zero. > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > + DoErase = TRUE; > > + break; > > + } > > + } > > + > > + // Merge old and new data. Write merged word to NOR > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > + CurOffset += BytesToWrite; > > + BytesToWrite = 0; > > + } > > + } else { > > + // Do multiple words, but starting unaligned. > > + if (BytesToWrite > (4 - (CurOffset & 0x3))) { > > + Mask = ((~0) << ((CurOffset & 0x3) * 8)); > > + // Mask out the bytes we want. > > + TmpBuf &= Mask; > > + // Is the destination still in 'erased' state? > > + if ((Tmp & Mask) != Mask) { > > + // Check to see if we are only changing bits to zero. > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > + DoErase = TRUE; > > + break; > > + } > > + } > > + > > + // Merge old and new data. Write merged word to NOR > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > + BytesToWrite -= (4 - (CurOffset & 0x3)); > > + CurOffset += (4 - (CurOffset & 0x3)); > > + } else { > > + // Unaligned and fits in one word. > > + Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8); > > + // Mask out the bytes we want. > > + TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask; > > + // Is the destination still in 'erased' state? > > + if ((Tmp & Mask) != Mask) { > > + // Check to see if we are only changing bits to zero. > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > + DoErase = TRUE; > > + break; > > + } > > + } > > + > > + // Merge old and new data. Write merged word to NOR > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > + CurOffset += BytesToWrite; > > + BytesToWrite = 0; > > + } > > + } > > + > > + // > > + // Write the word to NOR. > > + // > > + > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize); > > + if (BlockAddress != PrevBlockAddress) { > > + TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > + if (EFI_ERROR (TempStatus)) { > > + return EFI_DEVICE_ERROR; > > + } > > + > > + PrevBlockAddress = BlockAddress; > > + } > > + > > + TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite); > > + if (EFI_ERROR (TempStatus)) { > > + return EFI_DEVICE_ERROR; > > + } > > + } > > + > > + // Exit if we got here and could write all the data. Otherwise do the > > + // Erase-Write cycle. > > + if (!DoErase) { > > + return EFI_SUCCESS; > > + } > > + } > > + > > + // Check we did get some memory. Buffer is BlockSize. > > + if (Instance->ShadowBuffer == NULL) { > > + DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n")); > > + return EFI_DEVICE_ERROR; > > + } > > + > > + // Read NOR Flash data into shadow buffer > > + TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer); > > + if (EFI_ERROR (TempStatus)) { > > + // Return one of the pre-approved error statuses > > + return EFI_DEVICE_ERROR; > > + } > > + > > + // Put the data at the appropriate location inside the buffer area > > + CopyMem ((VOID *)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes); > > + > > + // Write the modified buffer back to the NorFlash > > + TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer); > > + if (EFI_ERROR (TempStatus)) { > > + // Return one of the pre-approved error statuses > > + return EFI_DEVICE_ERROR; > > + } > > + > > + return EFI_SUCCESS; > > +} > > + > > +/* > > + Although DiskIoDxe will automatically install the DiskIO protocol whenever > > + we install the BlockIO protocol, its implementation is sub-optimal as it reads > > + and writes entire blocks using the BlockIO protocol. In fact we can access > > + NOR flash with a finer granularity than that, so we can improve performance > > + by directly producing the DiskIO protocol. > > +*/ > > + > > +/** > > + Read BufferSize bytes from Offset into Buffer. > > + > > + @param This Protocol instance pointer. > > + @param MediaId Id of the media, changes every time the media is replaced. > > + @param Offset The starting byte offset to read from > > + @param BufferSize Size of Buffer > > + @param Buffer Buffer containing read data > > + > > + @retval EFI_SUCCESS The data was read correctly from the device. > > + @retval EFI_DEVICE_ERROR The device reported an error while performing the read. > > + @retval EFI_NO_MEDIA There is no media in the device. > > + @retval EFI_MEDIA_CHANGED The MediaId does not match the current device. > > + @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not > > + valid for the device. > > + > > +**/ > > +EFI_STATUS > > +EFIAPI > > +NorFlashDiskIoReadDisk ( > > + IN EFI_DISK_IO_PROTOCOL *This, > > + IN UINT32 MediaId, > > + IN UINT64 DiskOffset, > > + IN UINTN BufferSize, > > + OUT VOID *Buffer > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + UINT32 BlockSize; > > + UINT32 BlockOffset; > > + EFI_LBA Lba; > > + > > + Instance = INSTANCE_FROM_DISKIO_THIS (This); > > + > > + if (MediaId != Instance->Media.MediaId) { > > + return EFI_MEDIA_CHANGED; > > + } > > + > > + BlockSize = Instance->Media.BlockSize; > > + Lba = (EFI_LBA)DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset); > > + > > + return NorFlashRead (Instance, Lba, BlockOffset, BufferSize, Buffer); > > +} > > + > > +/** > > + Writes a specified number of bytes to a device. > > + > > + @param This Indicates a pointer to the calling context. > > + @param MediaId ID of the medium to be written. > > + @param Offset The starting byte offset on the logical block I/O device to write. > > + @param BufferSize The size in bytes of Buffer. The number of bytes to write to the device. > > + @param Buffer A pointer to the buffer containing the data to be written. > > + > > + @retval EFI_SUCCESS The data was written correctly to the device. > > + @retval EFI_WRITE_PROTECTED The device can not be written to. > > + @retval EFI_DEVICE_ERROR The device reported an error while performing the write. > > + @retval EFI_NO_MEDIA There is no media in the device. > > + @retval EFI_MEDIA_CHANGED The MediaId does not match the current device. > > + @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not > > + valid for the device. > > + > > +**/ > > +EFI_STATUS > > +EFIAPI > > +NorFlashDiskIoWriteDisk ( > > + IN EFI_DISK_IO_PROTOCOL *This, > > + IN UINT32 MediaId, > > + IN UINT64 DiskOffset, > > + IN UINTN BufferSize, > > + IN VOID *Buffer > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + UINT32 BlockSize; > > + UINT32 BlockOffset; > > + EFI_LBA Lba; > > + UINTN RemainingBytes; > > + UINTN WriteSize; > > + EFI_STATUS Status; > > + > > + Instance = INSTANCE_FROM_DISKIO_THIS (This); > > + > > + if (MediaId != Instance->Media.MediaId) { > > + return EFI_MEDIA_CHANGED; > > + } > > + > > + BlockSize = Instance->Media.BlockSize; > > + Lba = (EFI_LBA)DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset); > > + > > + RemainingBytes = BufferSize; > > + > > + // Write either all the remaining bytes, or the number of bytes that bring > > + // us up to a block boundary, whichever is less. > > + // (DiskOffset | (BlockSize - 1)) + 1) rounds DiskOffset up to the next > > + // block boundary (even if it is already on one). > > + WriteSize = MIN (RemainingBytes, ((DiskOffset | (BlockSize - 1)) + 1) - DiskOffset); > > + > > + do { > > + if (WriteSize == BlockSize) { > > + // Write a full block > > + Status = NorFlashWriteFullBlock (Instance, Lba, Buffer, BlockSize / sizeof (UINT32)); > > + } else { > > + // Write a partial block > > + Status = NorFlashWriteSingleBlock (Instance, Lba, BlockOffset, &WriteSize, Buffer); > > + } > > + > > + if (EFI_ERROR (Status)) { > > + return Status; > > + } > > + > > + // Now continue writing either all the remaining bytes or single blocks. > > + RemainingBytes -= WriteSize; > > + Buffer = (UINT8 *)Buffer + WriteSize; > > + Lba++; > > + BlockOffset = 0; > > + WriteSize = MIN (RemainingBytes, BlockSize); > > + } while (RemainingBytes); > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +NorFlashReset ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ) > > +{ > > + // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + Fixup internal data so that EFI can be call in virtual mode. > > + Call the passed in Child Notify event and convert any pointers in > > + lib to virtual mode. > > + > > + @param[in] Event The Event that is being processed > > + @param[in] Context Event Context > > +**/ > > +VOID > > +EFIAPI > > +NorFlashVirtualNotifyEvent ( > > + IN EFI_EVENT Event, > > + IN VOID *Context > > + ) > > +{ > > + UINTN Index; > > + > > + for (Index = 0; Index < mNorFlashDeviceCount; Index++) { > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->DeviceBaseAddress); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->RegionBaseAddress); > > + > > + // Convert BlockIo protocol > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.FlushBlocks); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.ReadBlocks); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.Reset); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.WriteBlocks); > > + > > + // Convert Fvb > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.EraseBlocks); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetAttributes); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetBlockSize); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetPhysicalAddress); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.Read); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.SetAttributes); > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.Write); > > + > > + if (mNorFlashInstances[Index]->ShadowBuffer != NULL) { > > + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->ShadowBuffer); > > + } > > + } > > + > > + return; > > +} > > diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c > new file mode 100644 > index 000000000000..9d4732c6905a > --- /dev/null > +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c > @@ -0,0 +1,123 @@ > +/** @file NorFlashBlockIoDxe.c > > + > > + Copyright (c) 2011-2013, ARM Ltd. All rights reserved.
> > + > > + SPDX-License-Identifier: BSD-2-Clause-Patent > > + > > +**/ > > + > > +#include > > +#include > > + > > +#include "NorFlash.h" > > + > > +// > > +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashBlockIoReset ( > > + IN EFI_BLOCK_IO_PROTOCOL *This, > > + IN BOOLEAN ExtendedVerification > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_BLKIO_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReset(MediaId=0x%x)\n", This->Media->MediaId)); > > + > > + return NorFlashReset (Instance); > > +} > > + > > +// > > +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashBlockIoReadBlocks ( > > + IN EFI_BLOCK_IO_PROTOCOL *This, > > + IN UINT32 MediaId, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + EFI_STATUS Status; > > + EFI_BLOCK_IO_MEDIA *Media; > > + > > + if (This == NULL) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + Instance = INSTANCE_FROM_BLKIO_THIS (This); > > + Media = This->Media; > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReadBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes (%d kB), BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, BufferSizeInBytes, Buffer)); > > + > > + if (!Media) { > > + Status = EFI_INVALID_PARAMETER; > > + } else if (!Media->MediaPresent) { > > + Status = EFI_NO_MEDIA; > > + } else if (Media->MediaId != MediaId) { > > + Status = EFI_MEDIA_CHANGED; > > + } else if ((Media->IoAlign > 2) && (((UINTN)Buffer & (Media->IoAlign - 1)) != 0)) { > > + Status = EFI_INVALID_PARAMETER; > > + } else { > > + Status = NorFlashReadBlocks (Instance, Lba, BufferSizeInBytes, Buffer); > > + } > > + > > + return Status; > > +} > > + > > +// > > +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashBlockIoWriteBlocks ( > > + IN EFI_BLOCK_IO_PROTOCOL *This, > > + IN UINT32 MediaId, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + IN VOID *Buffer > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + EFI_STATUS Status; > > + > > + Instance = INSTANCE_FROM_BLKIO_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoWriteBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes, BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, Buffer)); > > + > > + if ( !This->Media->MediaPresent ) { > > + Status = EFI_NO_MEDIA; > > + } else if ( This->Media->MediaId != MediaId ) { > > + Status = EFI_MEDIA_CHANGED; > > + } else if ( This->Media->ReadOnly ) { > > + Status = EFI_WRITE_PROTECTED; > > + } else { > > + Status = NorFlashWriteBlocks (Instance, Lba, BufferSizeInBytes, Buffer); > > + } > > + > > + return Status; > > +} > > + > > +// > > +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks > > +// > > +EFI_STATUS > > +EFIAPI > > +NorFlashBlockIoFlushBlocks ( > > + IN EFI_BLOCK_IO_PROTOCOL *This > > + ) > > +{ > > + // No Flush required for the NOR Flash driver > > + // because cache operations are not permitted. > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoFlushBlocks: Function NOT IMPLEMENTED (not required).\n")); > > + > > + // Nothing to do so just return without error > > + return EFI_SUCCESS; > > +} > > diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.c > new file mode 100644 > index 000000000000..f7b92de21a57 > --- /dev/null > +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.c > @@ -0,0 +1,506 @@ > +/** @file NorFlashDxe.c > > + > > + Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.
> > + > > + SPDX-License-Identifier: BSD-2-Clause-Patent > > + > > +**/ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#include "NorFlash.h" > > + > > +STATIC EFI_EVENT mNorFlashVirtualAddrChangeEvent; > > + > > +// > > +// Global variable declarations > > +// > > +NOR_FLASH_INSTANCE **mNorFlashInstances; > > +UINT32 mNorFlashDeviceCount; > > +UINTN mFlashNvStorageVariableBase; > > +EFI_EVENT mFvbVirtualAddrChangeEvent; > > + > > +NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = { > > + NOR_FLASH_SIGNATURE, // Signature > > + NULL, // Handle ... NEED TO BE FILLED > > + > > + 0, // DeviceBaseAddress ... NEED TO BE FILLED > > + 0, // RegionBaseAddress ... NEED TO BE FILLED > > + 0, // Size ... NEED TO BE FILLED > > + 0, // StartLba > > + > > + { > > + EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision > > + NULL, // Media ... NEED TO BE FILLED > > + NorFlashBlockIoReset, // Reset; > > + NorFlashBlockIoReadBlocks, // ReadBlocks > > + NorFlashBlockIoWriteBlocks, // WriteBlocks > > + NorFlashBlockIoFlushBlocks // FlushBlocks > > + }, // BlockIoProtocol > > + > > + { > > + 0, // MediaId ... NEED TO BE FILLED > > + FALSE, // RemovableMedia > > + TRUE, // MediaPresent > > + FALSE, // LogicalPartition > > + FALSE, // ReadOnly > > + FALSE, // WriteCaching; > > + 0, // BlockSize ... NEED TO BE FILLED > > + 4, // IoAlign > > + 0, // LastBlock ... NEED TO BE FILLED > > + 0, // LowestAlignedLba > > + 1, // LogicalBlocksPerPhysicalBlock > > + }, // Media; > > + > > + { > > + EFI_DISK_IO_PROTOCOL_REVISION, // Revision > > + NorFlashDiskIoReadDisk, // ReadDisk > > + NorFlashDiskIoWriteDisk // WriteDisk > > + }, > > + > > + { > > + FvbGetAttributes, // GetAttributes > > + FvbSetAttributes, // SetAttributes > > + FvbGetPhysicalAddress, // GetPhysicalAddress > > + FvbGetBlockSize, // GetBlockSize > > + FvbRead, // Read > > + FvbWrite, // Write > > + FvbEraseBlocks, // EraseBlocks > > + NULL, // ParentHandle > > + }, // FvbProtoccol; > > + NULL, // ShadowBuffer > > + { > > + { > > + { > > + HARDWARE_DEVICE_PATH, > > + HW_VENDOR_DP, > > + { > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)), > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8) > > + } > > + }, > > + { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } > > + }, // GUID ... NEED TO BE FILLED > > + }, > > + 0, // Index > > + { > > + END_DEVICE_PATH_TYPE, > > + END_ENTIRE_DEVICE_PATH_SUBTYPE, > > + { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 } > > + } > > + } // DevicePath > > +}; > > + > > +EFI_STATUS > > +NorFlashCreateInstance ( > > + IN UINTN NorFlashDeviceBase, > > + IN UINTN NorFlashRegionBase, > > + IN UINTN NorFlashSize, > > + IN UINT32 Index, > > + IN UINT32 BlockSize, > > + IN BOOLEAN SupportFvb, > > + OUT NOR_FLASH_INSTANCE **NorFlashInstance > > + ) > > +{ > > + EFI_STATUS Status; > > + NOR_FLASH_INSTANCE *Instance; > > + > > + ASSERT (NorFlashInstance != NULL); > > + > > + Instance = AllocateRuntimeCopyPool (sizeof (NOR_FLASH_INSTANCE), &mNorFlashInstanceTemplate); > > + if (Instance == NULL) { > > + return EFI_OUT_OF_RESOURCES; > > + } > > + > > + Instance->DeviceBaseAddress = NorFlashDeviceBase; > > + Instance->RegionBaseAddress = NorFlashRegionBase; > > + Instance->Size = NorFlashSize; > > + > > + Instance->BlockIoProtocol.Media = &Instance->Media; > > + Instance->Media.MediaId = Index; > > + Instance->Media.BlockSize = BlockSize; > > + Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1; > > + > > + CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid); > > + Instance->DevicePath.Index = (UINT8)Index; > > + > > + Instance->ShadowBuffer = AllocateRuntimePool (BlockSize); > > + if (Instance->ShadowBuffer == NULL) { > > + return EFI_OUT_OF_RESOURCES; > > + } > > + > > + if (SupportFvb) { > > + NorFlashFvbInitialize (Instance); > > + > > + Status = gBS->InstallMultipleProtocolInterfaces ( > > + &Instance->Handle, > > + &gEfiDevicePathProtocolGuid, > > + &Instance->DevicePath, > > + &gEfiBlockIoProtocolGuid, > > + &Instance->BlockIoProtocol, > > + &gEfiFirmwareVolumeBlockProtocolGuid, > > + &Instance->FvbProtocol, > > + NULL > > + ); > > + if (EFI_ERROR (Status)) { > > + FreePool (Instance); > > + return Status; > > + } > > + } else { > > + Status = gBS->InstallMultipleProtocolInterfaces ( > > + &Instance->Handle, > > + &gEfiDevicePathProtocolGuid, > > + &Instance->DevicePath, > > + &gEfiBlockIoProtocolGuid, > > + &Instance->BlockIoProtocol, > > + &gEfiDiskIoProtocolGuid, > > + &Instance->DiskIoProtocol, > > + NULL > > + ); > > + if (EFI_ERROR (Status)) { > > + FreePool (Instance); > > + return Status; > > + } > > + } > > + > > + *NorFlashInstance = Instance; > > + return Status; > > +} > > + > > +/** > > + * This function unlock and erase an entire NOR Flash block. > > + **/ > > +EFI_STATUS > > +NorFlashUnlockAndEraseSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + EFI_STATUS Status; > > + UINTN Index; > > + EFI_TPL OriginalTPL; > > + > > + if (!EfiAtRuntime ()) { > > + // Raise TPL to TPL_HIGH to stop anyone from interrupting us. > > + OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL); > > + } else { > > + // This initialization is only to prevent the compiler to complain about the > > + // use of uninitialized variables > > + OriginalTPL = TPL_HIGH_LEVEL; > > + } > > + > > + Index = 0; > > + // The block erase might fail a first time (SW bug ?). Retry it ... > > + do { > > + // Unlock the block if we have to > > + Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > + if (EFI_ERROR (Status)) { > > + break; > > + } > > + > > + Status = NorFlashEraseSingleBlock (Instance, BlockAddress); > > + Index++; > > + } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED)); > > + > > + if (Index == NOR_FLASH_ERASE_RETRY) { > > + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress, Index)); > > + } > > + > > + if (!EfiAtRuntime ()) { > > + // Interruptions can resume. > > + gBS->RestoreTPL (OriginalTPL); > > + } > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +NorFlashWriteFullBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINT32 *DataBuffer, > > + IN UINT32 BlockSizeInWords > > + ) > > +{ > > + EFI_STATUS Status; > > + UINTN WordAddress; > > + UINT32 WordIndex; > > + UINTN BufferIndex; > > + UINTN BlockAddress; > > + UINTN BuffersInBlock; > > + UINTN RemainingWords; > > + EFI_TPL OriginalTPL; > > + UINTN Cnt; > > + > > + Status = EFI_SUCCESS; > > + > > + // Get the physical address of the block > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4); > > + > > + // Start writing from the first address at the start of the block > > + WordAddress = BlockAddress; > > + > > + if (!EfiAtRuntime ()) { > > + // Raise TPL to TPL_HIGH to stop anyone from interrupting us. > > + OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL); > > + } else { > > + // This initialization is only to prevent the compiler to complain about the > > + // use of uninitialized variables > > + OriginalTPL = TPL_HIGH_LEVEL; > > + } > > + > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress)); > > + goto EXIT; > > + } > > + > > + // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method. > > + > > + // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero > > + if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) { > > + // First, break the entire block into buffer-sized chunks. > > + BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES; > > + > > + // Then feed each buffer chunk to the NOR Flash > > + // If a buffer does not contain any data, don't write it. > > + for (BufferIndex = 0; > > + BufferIndex < BuffersInBlock; > > + BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS > > + ) > > + { > > + // Check the buffer to see if it contains any data (not set all 1s). > > + for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) { > > + if (~DataBuffer[Cnt] != 0 ) { > > + // Some data found, write the buffer. > > + Status = NorFlashWriteBuffer ( > > + Instance, > > + WordAddress, > > + P30_MAX_BUFFER_SIZE_IN_BYTES, > > + DataBuffer > > + ); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + > > + break; > > + } > > + } > > + } > > + > > + // Finally, finish off any remaining words that are less than the maximum size of the buffer > > + RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS; > > + > > + if (RemainingWords != 0) { > > + Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + } > > + } else { > > + // For now, use the single word programming algorithm > > + // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range, > > + // i.e. which ends in the range 0x......01 - 0x......7F. > > + for (WordIndex = 0; WordIndex < BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) { > > + Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + } > > + } > > + > > +EXIT: > > + if (!EfiAtRuntime ()) { > > + // Interruptions can resume. > > + gBS->RestoreTPL (OriginalTPL); > > + } > > + > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status)); > > + } > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashInitialise ( > > + IN EFI_HANDLE ImageHandle, > > + IN EFI_SYSTEM_TABLE *SystemTable > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 Index; > > + NOR_FLASH_DESCRIPTION *NorFlashDevices; > > + BOOLEAN ContainVariableStorage; > > + > > + Status = NorFlashPlatformInitialization (); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to initialize Nor Flash devices\n")); > > + return Status; > > + } > > + > > + Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to get Nor Flash devices\n")); > > + return Status; > > + } > > + > > + mNorFlashInstances = AllocateRuntimePool (sizeof (NOR_FLASH_INSTANCE *) * mNorFlashDeviceCount); > > + > > + for (Index = 0; Index < mNorFlashDeviceCount; Index++) { > > + // Check if this NOR Flash device contain the variable storage region > > + > > + if (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) { > > + ContainVariableStorage = > > + (NorFlashDevices[Index].RegionBaseAddress <= PcdGet64 (PcdFlashNvStorageVariableBase64)) && > > + (PcdGet64 (PcdFlashNvStorageVariableBase64) + PcdGet32 (PcdFlashNvStorageVariableSize) <= > > + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size); > > + } else { > > + ContainVariableStorage = > > + (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) && > > + (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <= > > + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size); > > + } > > + > > + Status = NorFlashCreateInstance ( > > + NorFlashDevices[Index].DeviceBaseAddress, > > + NorFlashDevices[Index].RegionBaseAddress, > > + NorFlashDevices[Index].Size, > > + Index, > > + NorFlashDevices[Index].BlockSize, > > + ContainVariableStorage, > > + &mNorFlashInstances[Index] > > + ); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n", Index)); > > + } > > + } > > + > > + // > > + // Register for the virtual address change event > > + // > > + Status = gBS->CreateEventEx ( > > + EVT_NOTIFY_SIGNAL, > > + TPL_NOTIFY, > > + NorFlashVirtualNotifyEvent, > > + NULL, > > + &gEfiEventVirtualAddressChangeGuid, > > + &mNorFlashVirtualAddrChangeEvent > > + ); > > + ASSERT_EFI_ERROR (Status); > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashFvbInitialize ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 FvbNumLba; > > + EFI_BOOT_MODE BootMode; > > + UINTN RuntimeMmioRegionSize; > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashFvbInitialize\n")); > > + ASSERT ((Instance != NULL)); > > + > > + // > > + // Declare the Non-Volatile storage as EFI_MEMORY_RUNTIME > > + // > > + > > + // Note: all the NOR Flash region needs to be reserved into the UEFI Runtime memory; > > + // even if we only use the small block region at the top of the NOR Flash. > > + // The reason is when the NOR Flash memory is set into program mode, the command > > + // is written as the base of the flash region (ie: Instance->DeviceBaseAddress) > > + RuntimeMmioRegionSize = (Instance->RegionBaseAddress - Instance->DeviceBaseAddress) + Instance->Size; > > + > > + Status = gDS->AddMemorySpace ( > > + EfiGcdMemoryTypeMemoryMappedIo, > > + Instance->DeviceBaseAddress, > > + RuntimeMmioRegionSize, > > + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME > > + ); > > + ASSERT_EFI_ERROR (Status); > > + > > + Status = gDS->SetMemorySpaceAttributes ( > > + Instance->DeviceBaseAddress, > > + RuntimeMmioRegionSize, > > + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME > > + ); > > + ASSERT_EFI_ERROR (Status); > > + > > + mFlashNvStorageVariableBase = (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ? > > + PcdGet64 (PcdFlashNvStorageVariableBase64) : PcdGet32 (PcdFlashNvStorageVariableBase); > > + > > + // Set the index of the first LBA for the FVB > > + Instance->StartLba = (mFlashNvStorageVariableBase - Instance->RegionBaseAddress) / Instance->Media.BlockSize; > > + > > + BootMode = GetBootModeHob (); > > + if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) { > > + Status = EFI_INVALID_PARAMETER; > > + } else { > > + // Determine if there is a valid header at the beginning of the NorFlash > > + Status = ValidateFvHeader (Instance); > > + } > > + > > + // Install the Default FVB header if required > > + if (EFI_ERROR (Status)) { > > + // There is no valid header, so time to install one. > > + DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__)); > > + DEBUG (( > > + DEBUG_INFO, > > + "%a: Installing a correct one for this volume.\n", > > + __FUNCTION__ > > + )); > > + > > + // Erase all the NorFlash that is reserved for variable storage > > + FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize; > > + > > + Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR); > > + if (EFI_ERROR (Status)) { > > + return Status; > > + } > > + > > + // Install all appropriate headers > > + Status = InitializeFvAndVariableStoreHeaders (Instance); > > + if (EFI_ERROR (Status)) { > > + return Status; > > + } > > + } > > + > > + // > > + // The driver implementing the variable read service can now be dispatched; > > + // the varstore headers are in place. > > + // > > + Status = gBS->InstallProtocolInterface ( > > + &gImageHandle, > > + &gEdkiiNvVarStoreFormattedGuid, > > + EFI_NATIVE_INTERFACE, > > + NULL > > + ); > > + ASSERT_EFI_ERROR (Status); > > + > > + // > > + // Register for the virtual address change event > > + // > > + Status = gBS->CreateEventEx ( > > + EVT_NOTIFY_SIGNAL, > > + TPL_NOTIFY, > > + FvbVirtualNotifyEvent, > > + NULL, > > + &gEfiEventVirtualAddressChangeGuid, > > + &mFvbVirtualAddrChangeEvent > > + ); > > + ASSERT_EFI_ERROR (Status); > > + > > + return Status; > > +} > > diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashFvb.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlashFvb.c > new file mode 100644 > index 000000000000..0767581308d2 > --- /dev/null > +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashFvb.c > @@ -0,0 +1,777 @@ > +/*++ @file NorFlashFvbDxe.c > > + > > + Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.
> > + > > + SPDX-License-Identifier: BSD-2-Clause-Patent > > + > > + --*/ > > + > > +#include > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#include > > +#include > > +#include > > + > > +#include "NorFlash.h" > > + > > +extern UINTN mFlashNvStorageVariableBase; > > +/// > > +/// The Firmware Volume Block Protocol is the low-level interface > > +/// to a firmware volume. File-level access to a firmware volume > > +/// should not be done using the Firmware Volume Block Protocol. > > +/// Normal access to a firmware volume must use the Firmware > > +/// Volume Protocol. Typically, only the file system driver that > > +/// produces the Firmware Volume Protocol will bind to the > > +/// Firmware Volume Block Protocol. > > +/// > > + > > +/** > > + Initialises the FV Header and Variable Store Header > > + to support variable operations. > > + > > + @param[in] Ptr - Location to initialise the headers > > + > > +**/ > > +EFI_STATUS > > +InitializeFvAndVariableStoreHeaders ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ) > > +{ > > + EFI_STATUS Status; > > + VOID *Headers; > > + UINTN HeadersLength; > > + EFI_FIRMWARE_VOLUME_HEADER *FirmwareVolumeHeader; > > + VARIABLE_STORE_HEADER *VariableStoreHeader; > > + UINT32 NvStorageFtwSpareSize; > > + UINT32 NvStorageFtwWorkingSize; > > + UINT32 NvStorageVariableSize; > > + UINT64 NvStorageFtwSpareBase; > > + UINT64 NvStorageFtwWorkingBase; > > + UINT64 NvStorageVariableBase; > > + > > + HeadersLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY) + sizeof (VARIABLE_STORE_HEADER); > > + Headers = AllocateZeroPool (HeadersLength); > > + > > + NvStorageFtwWorkingSize = PcdGet32 (PcdFlashNvStorageFtwWorkingSize); > > + NvStorageFtwSpareSize = PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > + NvStorageVariableSize = PcdGet32 (PcdFlashNvStorageVariableSize); > > + > > + NvStorageFtwSpareBase = (PcdGet64 (PcdFlashNvStorageFtwSpareBase64) != 0) ? > > + PcdGet64 (PcdFlashNvStorageFtwSpareBase64) : PcdGet32 (PcdFlashNvStorageFtwSpareBase); > > + NvStorageFtwWorkingBase = (PcdGet64 (PcdFlashNvStorageFtwWorkingBase64) != 0) ? > > + PcdGet64 (PcdFlashNvStorageFtwWorkingBase64) : PcdGet32 (PcdFlashNvStorageFtwWorkingBase); > > + NvStorageVariableBase = (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ? > > + PcdGet64 (PcdFlashNvStorageVariableBase64) : PcdGet32 (PcdFlashNvStorageVariableBase); > > + > > + // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND the FTW working area AND the FTW Spare contiguous. > > + if ((NvStorageVariableBase + NvStorageVariableSize) != NvStorageFtwWorkingBase) { > > + DEBUG (( > > + DEBUG_ERROR, > > + "%a: NvStorageFtwWorkingBase is not contiguous with NvStorageVariableBase region\n", > > + __FUNCTION__ > > + )); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + if ((NvStorageFtwWorkingBase + NvStorageFtwWorkingSize) != NvStorageFtwSpareBase) { > > + DEBUG (( > > + DEBUG_ERROR, > > + "%a: NvStorageFtwSpareBase is not contiguous with NvStorageFtwWorkingBase region\n", > > + __FUNCTION__ > > + )); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Check if the size of the area is at least one block size > > + if ((NvStorageVariableSize <= 0) || (NvStorageVariableSize / Instance->Media.BlockSize <= 0)) { > > + DEBUG (( > > + DEBUG_ERROR, > > + "%a: NvStorageVariableSize is 0x%x, should be atleast one block size\n", > > + __FUNCTION__, > > + NvStorageVariableSize > > + )); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + if ((NvStorageFtwWorkingSize <= 0) || (NvStorageFtwWorkingSize / Instance->Media.BlockSize <= 0)) { > > + DEBUG (( > > + DEBUG_ERROR, > > + "%a: NvStorageFtwWorkingSize is 0x%x, should be atleast one block size\n", > > + __FUNCTION__, > > + NvStorageFtwWorkingSize > > + )); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + if ((NvStorageFtwSpareSize <= 0) || (NvStorageFtwSpareSize / Instance->Media.BlockSize <= 0)) { > > + DEBUG (( > > + DEBUG_ERROR, > > + "%a: NvStorageFtwSpareSize is 0x%x, should be atleast one block size\n", > > + __FUNCTION__, > > + NvStorageFtwSpareSize > > + )); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Ensure the Variable area Base Addresses are aligned on a block size boundaries > > + if ((NvStorageVariableBase % Instance->Media.BlockSize != 0) || > > + (NvStorageFtwWorkingBase % Instance->Media.BlockSize != 0) || > > + (NvStorageFtwSpareBase % Instance->Media.BlockSize != 0)) > > + { > > + DEBUG ((DEBUG_ERROR, "%a: NvStorage Base addresses must be aligned to block size boundaries", __FUNCTION__)); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // > > + // EFI_FIRMWARE_VOLUME_HEADER > > + // > > + FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Headers; > > + CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid); > > + FirmwareVolumeHeader->FvLength = > > + PcdGet32 (PcdFlashNvStorageVariableSize) + > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > + FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE; > > + FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2)( > > + EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled > > + EFI_FVB2_READ_STATUS | // Reads are currently enabled > > + EFI_FVB2_STICKY_WRITE | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY > > + EFI_FVB2_MEMORY_MAPPED | // It is memory mapped > > + EFI_FVB2_ERASE_POLARITY | // After erasure all bits take this value (i.e. '1') > > + EFI_FVB2_WRITE_STATUS | // Writes are currently enabled > > + EFI_FVB2_WRITE_ENABLED_CAP // Writes may be enabled > > + ); > > + FirmwareVolumeHeader->HeaderLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY); > > + FirmwareVolumeHeader->Revision = EFI_FVH_REVISION; > > + FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->Media.LastBlock + 1; > > + FirmwareVolumeHeader->BlockMap[0].Length = Instance->Media.BlockSize; > > + FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0; > > + FirmwareVolumeHeader->BlockMap[1].Length = 0; > > + FirmwareVolumeHeader->Checksum = CalculateCheckSum16 ((UINT16 *)FirmwareVolumeHeader, FirmwareVolumeHeader->HeaderLength); > > + > > + // > > + // VARIABLE_STORE_HEADER > > + // > > + VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)Headers + FirmwareVolumeHeader->HeaderLength); > > + CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid); > > + VariableStoreHeader->Size = PcdGet32 (PcdFlashNvStorageVariableSize) - FirmwareVolumeHeader->HeaderLength; > > + VariableStoreHeader->Format = VARIABLE_STORE_FORMATTED; > > + VariableStoreHeader->State = VARIABLE_STORE_HEALTHY; > > + > > + // Install the combined super-header in the NorFlash > > + Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers); > > + > > + FreePool (Headers); > > + return Status; > > +} > > + > > +/** > > + Check the integrity of firmware volume header. > > + > > + @param[in] FwVolHeader - A pointer to a firmware volume header > > + > > + @retval EFI_SUCCESS - The firmware volume is consistent > > + @retval EFI_NOT_FOUND - The firmware volume has been corrupted. > > + > > +**/ > > +EFI_STATUS > > +ValidateFvHeader ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ) > > +{ > > + UINT16 Checksum; > > + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; > > + VARIABLE_STORE_HEADER *VariableStoreHeader; > > + UINTN VariableStoreLength; > > + UINTN FvLength; > > + > > + FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Instance->RegionBaseAddress; > > + > > + FvLength = PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > + > > + // > > + // Verify the header revision, header signature, length > > + // Length of FvBlock cannot be 2**64-1 > > + // HeaderLength cannot be an odd number > > + // > > + if ( (FwVolHeader->Revision != EFI_FVH_REVISION) > > + || (FwVolHeader->Signature != EFI_FVH_SIGNATURE) > > + || (FwVolHeader->FvLength != FvLength) > > + ) > > + { > > + DEBUG (( > > + DEBUG_INFO, > > + "%a: No Firmware Volume header present\n", > > + __FUNCTION__ > > + )); > > + return EFI_NOT_FOUND; > > + } > > + > > + // Check the Firmware Volume Guid > > + if ( CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid) == FALSE ) { > > + DEBUG (( > > + DEBUG_INFO, > > + "%a: Firmware Volume Guid non-compatible\n", > > + __FUNCTION__ > > + )); > > + return EFI_NOT_FOUND; > > + } > > + > > + // Verify the header checksum > > + Checksum = CalculateSum16 ((UINT16 *)FwVolHeader, FwVolHeader->HeaderLength); > > + if (Checksum != 0) { > > + DEBUG (( > > + DEBUG_INFO, > > + "%a: FV checksum is invalid (Checksum:0x%X)\n", > > + __FUNCTION__, > > + Checksum > > + )); > > + return EFI_NOT_FOUND; > > + } > > + > > + VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)FwVolHeader + FwVolHeader->HeaderLength); > > + > > + // Check the Variable Store Guid > > + if (!CompareGuid (&VariableStoreHeader->Signature, &gEfiVariableGuid) && > > + !CompareGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid)) > > + { > > + DEBUG (( > > + DEBUG_INFO, > > + "%a: Variable Store Guid non-compatible\n", > > + __FUNCTION__ > > + )); > > + return EFI_NOT_FOUND; > > + } > > + > > + VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - FwVolHeader->HeaderLength; > > + if (VariableStoreHeader->Size != VariableStoreLength) { > > + DEBUG (( > > + DEBUG_INFO, > > + "%a: Variable Store Length does not match\n", > > + __FUNCTION__ > > + )); > > + return EFI_NOT_FOUND; > > + } > > + > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + The GetAttributes() function retrieves the attributes and > > + current settings of the block. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and > > + current settings are returned. > > + Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER. > > + > > + @retval EFI_SUCCESS The firmware volume attributes were returned. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbGetAttributes ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > + ) > > +{ > > + EFI_FVB_ATTRIBUTES_2 FlashFvbAttributes; > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2)( > > + > > + EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled > > + EFI_FVB2_READ_STATUS | // Reads are currently enabled > > + EFI_FVB2_STICKY_WRITE | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY > > + EFI_FVB2_MEMORY_MAPPED | // It is memory mapped > > + EFI_FVB2_ERASE_POLARITY // After erasure all bits take this value (i.e. '1') > > + > > + ); > > + > > + // Check if it is write protected > > + if (Instance->Media.ReadOnly != TRUE) { > > + FlashFvbAttributes = FlashFvbAttributes | > > + EFI_FVB2_WRITE_STATUS | // Writes are currently enabled > > + EFI_FVB2_WRITE_ENABLED_CAP; // Writes may be enabled > > + } > > + > > + *Attributes = FlashFvbAttributes; > > + > > + DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes)); > > + > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + The SetAttributes() function sets configurable firmware volume attributes > > + and returns the new settings of the firmware volume. > > + > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Attributes On input, Attributes is a pointer to EFI_FVB_ATTRIBUTES_2 > > + that contains the desired firmware volume settings. > > + On successful return, it contains the new settings of > > + the firmware volume. > > + Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER. > > + > > + @retval EFI_SUCCESS The firmware volume attributes were returned. > > + > > + @retval EFI_INVALID_PARAMETER The attributes requested are in conflict with the capabilities > > + as declared in the firmware volume header. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbSetAttributes ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > + ) > > +{ > > + DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n", *Attributes)); > > + return EFI_UNSUPPORTED; > > +} > > + > > +/** > > + The GetPhysicalAddress() function retrieves the base address of > > + a memory-mapped firmware volume. This function should be called > > + only for memory-mapped firmware volumes. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Address Pointer to a caller-allocated > > + EFI_PHYSICAL_ADDRESS that, on successful > > + return from GetPhysicalAddress(), contains the > > + base address of the firmware volume. > > + > > + @retval EFI_SUCCESS The firmware volume base address was returned. > > + > > + @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbGetPhysicalAddress ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + OUT EFI_PHYSICAL_ADDRESS *Address > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", Instance->RegionBaseAddress)); > > + > > + ASSERT (Address != NULL); > > + > > + *Address = mFlashNvStorageVariableBase; > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + The GetBlockSize() function retrieves the size of the requested > > + block. It also returns the number of additional blocks with > > + the identical size. The GetBlockSize() function is used to > > + retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER). > > + > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Lba Indicates the block for which to return the size. > > + > > + @param BlockSize Pointer to a caller-allocated UINTN in which > > + the size of the block is returned. > > + > > + @param NumberOfBlocks Pointer to a caller-allocated UINTN in > > + which the number of consecutive blocks, > > + starting with Lba, is returned. All > > + blocks in this range have a size of > > + BlockSize. > > + > > + > > + @retval EFI_SUCCESS The firmware volume base address was returned. > > + > > + @retval EFI_INVALID_PARAMETER The requested LBA is out of range. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbGetBlockSize ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + OUT UINTN *BlockSize, > > + OUT UINTN *NumberOfBlocks > > + ) > > +{ > > + EFI_STATUS Status; > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", Lba, Instance->Media.BlockSize, Instance->Media.LastBlock)); > > + > > + if (Lba > Instance->Media.LastBlock) { > > + DEBUG ((DEBUG_ERROR, "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", Lba, Instance->Media.LastBlock)); > > + Status = EFI_INVALID_PARAMETER; > > + } else { > > + // This is easy because in this platform each NorFlash device has equal sized blocks. > > + *BlockSize = (UINTN)Instance->Media.BlockSize; > > + *NumberOfBlocks = (UINTN)(Instance->Media.LastBlock - Lba + 1); > > + > > + DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize: *BlockSize=0x%x, *NumberOfBlocks=0x%x.\n", *BlockSize, *NumberOfBlocks)); > > + > > + Status = EFI_SUCCESS; > > + } > > + > > + return Status; > > +} > > + > > +/** > > + Reads the specified number of bytes into a buffer from the specified block. > > + > > + The Read() function reads the requested number of bytes from the > > + requested block and stores them in the provided buffer. > > + Implementations should be mindful that the firmware volume > > + might be in the ReadDisabled state. If it is in this state, > > + the Read() function must return the status code > > + EFI_ACCESS_DENIED without modifying the contents of the > > + buffer. The Read() function must also prevent spanning block > > + boundaries. If a read is requested that would span a block > > + boundary, the read must read up to the boundary but not > > + beyond. The output parameter NumBytes must be set to correctly > > + indicate the number of bytes actually read. The caller must be > > + aware that a read may be partially completed. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Lba The starting logical block index from which to read. > > + > > + @param Offset Offset into the block at which to begin reading. > > + > > + @param NumBytes Pointer to a UINTN. > > + At entry, *NumBytes contains the total size of the buffer. > > + At exit, *NumBytes contains the total number of bytes read. > > + > > + @param Buffer Pointer to a caller-allocated buffer that will be used > > + to hold the data that is read. > > + > > + @retval EFI_SUCCESS The firmware volume was read successfully, and contents are > > + in Buffer. > > + > > + @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary. > > + On output, NumBytes contains the total number of bytes > > + returned in Buffer. > > + > > + @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state. > > + > > + @retval EFI_DEVICE_ERROR The block device is not functioning correctly and could not be read. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbRead ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN OUT UINT8 *Buffer > > + ) > > +{ > > + EFI_STATUS TempStatus; > > + UINTN BlockSize; > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer)); > > + > > + TempStatus = EFI_SUCCESS; > > + > > + // Cache the block size to avoid de-referencing pointers all the time > > + BlockSize = Instance->Media.BlockSize; > > + > > + DEBUG ((DEBUG_BLKIO, "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", Offset, *NumBytes, BlockSize)); > > + > > + // The read must not span block boundaries. > > + // We need to check each variable individually because adding two large values together overflows. > > + if ((Offset >= BlockSize) || > > + (*NumBytes > BlockSize) || > > + ((Offset + *NumBytes) > BlockSize)) > > + { > > + DEBUG ((DEBUG_ERROR, "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize)); > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // We must have some bytes to read > > + if (*NumBytes == 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // Decide if we are doing full block reads or not. > > + if (*NumBytes % BlockSize != 0) { > > + TempStatus = NorFlashRead (Instance, Instance->StartLba + Lba, Offset, *NumBytes, Buffer); > > + if (EFI_ERROR (TempStatus)) { > > + return EFI_DEVICE_ERROR; > > + } > > + } else { > > + // Read NOR Flash data into shadow buffer > > + TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, Buffer); > > + if (EFI_ERROR (TempStatus)) { > > + // Return one of the pre-approved error statuses > > + return EFI_DEVICE_ERROR; > > + } > > + } > > + > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + Writes the specified number of bytes from the input buffer to the block. > > + > > + The Write() function writes the specified number of bytes from > > + the provided buffer to the specified block and offset. If the > > + firmware volume is sticky write, the caller must ensure that > > + all the bits of the specified range to write are in the > > + EFI_FVB_ERASE_POLARITY state before calling the Write() > > + function, or else the result will be unpredictable. This > > + unpredictability arises because, for a sticky-write firmware > > + volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY > > + state but cannot flip it back again. Before calling the > > + Write() function, it is recommended for the caller to first call > > + the EraseBlocks() function to erase the specified block to > > + write. A block erase cycle will transition bits from the > > + (NOT)EFI_FVB_ERASE_POLARITY state back to the > > + EFI_FVB_ERASE_POLARITY state. Implementations should be > > + mindful that the firmware volume might be in the WriteDisabled > > + state. If it is in this state, the Write() function must > > + return the status code EFI_ACCESS_DENIED without modifying the > > + contents of the firmware volume. The Write() function must > > + also prevent spanning block boundaries. If a write is > > + requested that spans a block boundary, the write must store up > > + to the boundary but not beyond. The output parameter NumBytes > > + must be set to correctly indicate the number of bytes actually > > + written. The caller must be aware that a write may be > > + partially completed. All writes, partial or otherwise, must be > > + fully flushed to the hardware before the Write() service > > + returns. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Lba The starting logical block index to write to. > > + > > + @param Offset Offset into the block at which to begin writing. > > + > > + @param NumBytes The pointer to a UINTN. > > + At entry, *NumBytes contains the total size of the buffer. > > + At exit, *NumBytes contains the total number of bytes actually written. > > + > > + @param Buffer The pointer to a caller-allocated buffer that contains the source for the write. > > + > > + @retval EFI_SUCCESS The firmware volume was written successfully. > > + > > + @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary. > > + On output, NumBytes contains the total number of bytes > > + actually written. > > + > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state. > > + > > + @retval EFI_DEVICE_ERROR The block device is malfunctioning and could not be written. > > + > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbWrite ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + return NorFlashWriteSingleBlock (Instance, Instance->StartLba + Lba, Offset, NumBytes, Buffer); > > +} > > + > > +/** > > + Erases and initialises a firmware volume block. > > + > > + The EraseBlocks() function erases one or more blocks as denoted > > + by the variable argument list. The entire parameter list of > > + blocks must be verified before erasing any blocks. If a block is > > + requested that does not exist within the associated firmware > > + volume (it has a larger index than the last block of the > > + firmware volume), the EraseBlocks() function must return the > > + status code EFI_INVALID_PARAMETER without modifying the contents > > + of the firmware volume. Implementations should be mindful that > > + the firmware volume might be in the WriteDisabled state. If it > > + is in this state, the EraseBlocks() function must return the > > + status code EFI_ACCESS_DENIED without modifying the contents of > > + the firmware volume. All calls to EraseBlocks() must be fully > > + flushed to the hardware before the EraseBlocks() service > > + returns. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > + instance. > > + > > + @param ... The variable argument list is a list of tuples. > > + Each tuple describes a range of LBAs to erase > > + and consists of the following: > > + - An EFI_LBA that indicates the starting LBA > > + - A UINTN that indicates the number of blocks to erase. > > + > > + The list is terminated with an EFI_LBA_LIST_TERMINATOR. > > + For example, the following indicates that two ranges of blocks > > + (5-7 and 10-11) are to be erased: > > + EraseBlocks (This, 5, 3, 10, 2, EFI_LBA_LIST_TERMINATOR); > > + > > + @retval EFI_SUCCESS The erase request successfully completed. > > + > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state. > > + > > + @retval EFI_DEVICE_ERROR The block device is not functioning correctly and could not be written. > > + The firmware device may have been partially erased. > > + > > + @retval EFI_INVALID_PARAMETER One or more of the LBAs listed in the variable argument list do > > + not exist in the firmware volume. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbEraseBlocks ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + ... > > + ) > > +{ > > + EFI_STATUS Status; > > + VA_LIST Args; > > + UINTN BlockAddress; // Physical address of Lba to erase > > + EFI_LBA StartingLba; // Lba from which we start erasing > > + UINTN NumOfLba; // Number of Lba blocks to erase > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n")); > > + > > + Status = EFI_SUCCESS; > > + > > + // Detect WriteDisabled state > > + if (Instance->Media.ReadOnly == TRUE) { > > + // Firmware volume is in WriteDisabled state > > + DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Device is in WriteDisabled state.\n")); > > + return EFI_ACCESS_DENIED; > > + } > > + > > + // Before erasing, check the entire list of parameters to ensure all specified blocks are valid > > + > > + VA_START (Args, This); > > + do { > > + // Get the Lba from which we start erasing > > + StartingLba = VA_ARG (Args, EFI_LBA); > > + > > + // Have we reached the end of the list? > > + if (StartingLba == EFI_LBA_LIST_TERMINATOR) { > > + // Exit the while loop > > + break; > > + } > > + > > + // How many Lba blocks are we requested to erase? > > + NumOfLba = VA_ARG (Args, UINTN); > > + > > + // All blocks must be within range > > + DEBUG (( > > + DEBUG_BLKIO, > > + "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%Lu - 1 ) > LastBlock=%ld.\n", > > + Instance->StartLba + StartingLba, > > + (UINT64)NumOfLba, > > + Instance->Media.LastBlock > > + )); > > + if ((NumOfLba == 0) || ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->Media.LastBlock)) { > > + VA_END (Args); > > + DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n")); > > + Status = EFI_INVALID_PARAMETER; > > + goto EXIT; > > + } > > + } while (TRUE); > > + > > + VA_END (Args); > > + > > + // > > + // To get here, all must be ok, so start erasing > > + // > > + VA_START (Args, This); > > + do { > > + // Get the Lba from which we start erasing > > + StartingLba = VA_ARG (Args, EFI_LBA); > > + > > + // Have we reached the end of the list? > > + if (StartingLba == EFI_LBA_LIST_TERMINATOR) { > > + // Exit the while loop > > + break; > > + } > > + > > + // How many Lba blocks are we requested to erase? > > + NumOfLba = VA_ARG (Args, UINTN); > > + > > + // Go through each one and erase it > > + while (NumOfLba > 0) { > > + // Get the physical address of Lba to erase > > + BlockAddress = GET_NOR_BLOCK_ADDRESS ( > > + Instance->RegionBaseAddress, > > + Instance->StartLba + StartingLba, > > + Instance->Media.BlockSize > > + ); > > + > > + // Erase it > > + DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", Instance->StartLba + StartingLba, BlockAddress)); > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > + if (EFI_ERROR (Status)) { > > + VA_END (Args); > > + Status = EFI_DEVICE_ERROR; > > + goto EXIT; > > + } > > + > > + // Move to the next Lba > > + StartingLba++; > > + NumOfLba--; > > + } > > + } while (TRUE); > > + > > + VA_END (Args); > > + > > +EXIT: > > + return Status; > > +} > > + > > +/** > > + Fixup internal data so that EFI can be call in virtual mode. > > + Call the passed in Child Notify event and convert any pointers in > > + lib to virtual mode. > > + > > + @param[in] Event The Event that is being processed > > + @param[in] Context Event Context > > +**/ > > +VOID > > +EFIAPI > > +FvbVirtualNotifyEvent ( > > + IN EFI_EVENT Event, > > + IN VOID *Context > > + ) > > +{ > > + EfiConvertPointer (0x0, (VOID **)&mFlashNvStorageVariableBase); > > + return; > > +} > > diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.c > new file mode 100644 > index 000000000000..b72ad97b0b55 > --- /dev/null > +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.c > @@ -0,0 +1,383 @@ > +/** @file NorFlashStandaloneMm.c > > + > > + Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.
> > + Copyright (c) 2020, Linaro, Ltd. All rights reserved.
> > + > > + SPDX-License-Identifier: BSD-2-Clause-Patent > > + > > +**/ > > + > > +#include > > +#include > > +#include > > + > > +#include "NorFlash.h" > > + > > +// > > +// Global variable declarations > > +// > > +NOR_FLASH_INSTANCE **mNorFlashInstances; > > +UINT32 mNorFlashDeviceCount; > > +UINTN mFlashNvStorageVariableBase; > > + > > +NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = { > > + NOR_FLASH_SIGNATURE, // Signature > > + NULL, // Handle ... NEED TO BE FILLED > > + > > + 0, // DeviceBaseAddress ... NEED TO BE FILLED > > + 0, // RegionBaseAddress ... NEED TO BE FILLED > > + 0, // Size ... NEED TO BE FILLED > > + 0, // StartLba > > + > > + { > > + EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision > > + NULL, // Media ... NEED TO BE FILLED > > + NULL, // Reset; > > + NULL, // ReadBlocks > > + NULL, // WriteBlocks > > + NULL // FlushBlocks > > + }, // BlockIoProtocol > > + > > + { > > + 0, // MediaId ... NEED TO BE FILLED > > + FALSE, // RemovableMedia > > + TRUE, // MediaPresent > > + FALSE, // LogicalPartition > > + FALSE, // ReadOnly > > + FALSE, // WriteCaching; > > + 0, // BlockSize ... NEED TO BE FILLED > > + 4, // IoAlign > > + 0, // LastBlock ... NEED TO BE FILLED > > + 0, // LowestAlignedLba > > + 1, // LogicalBlocksPerPhysicalBlock > > + }, // Media; > > + > > + { > > + EFI_DISK_IO_PROTOCOL_REVISION, // Revision > > + NULL, // ReadDisk > > + NULL // WriteDisk > > + }, > > + > > + { > > + FvbGetAttributes, // GetAttributes > > + FvbSetAttributes, // SetAttributes > > + FvbGetPhysicalAddress, // GetPhysicalAddress > > + FvbGetBlockSize, // GetBlockSize > > + FvbRead, // Read > > + FvbWrite, // Write > > + FvbEraseBlocks, // EraseBlocks > > + NULL, // ParentHandle > > + }, // FvbProtoccol; > > + NULL, // ShadowBuffer > > + { > > + { > > + { > > + HARDWARE_DEVICE_PATH, > > + HW_VENDOR_DP, > > + { > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)), > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8) > > + } > > + }, > > + { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } > > + }, // GUID ... NEED TO BE FILLED > > + }, > > + 0, // Index > > + { > > + END_DEVICE_PATH_TYPE, > > + END_ENTIRE_DEVICE_PATH_SUBTYPE, > > + { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 } > > + } > > + } // DevicePath > > +}; > > + > > +EFI_STATUS > > +NorFlashCreateInstance ( > > + IN UINTN NorFlashDeviceBase, > > + IN UINTN NorFlashRegionBase, > > + IN UINTN NorFlashSize, > > + IN UINT32 Index, > > + IN UINT32 BlockSize, > > + IN BOOLEAN SupportFvb, > > + OUT NOR_FLASH_INSTANCE **NorFlashInstance > > + ) > > +{ > > + EFI_STATUS Status; > > + NOR_FLASH_INSTANCE *Instance; > > + > > + ASSERT (NorFlashInstance != NULL); > > + > > + Instance = AllocateRuntimeCopyPool (sizeof (NOR_FLASH_INSTANCE), &mNorFlashInstanceTemplate); > > + if (Instance == NULL) { > > + return EFI_OUT_OF_RESOURCES; > > + } > > + > > + Instance->DeviceBaseAddress = NorFlashDeviceBase; > > + Instance->RegionBaseAddress = NorFlashRegionBase; > > + Instance->Size = NorFlashSize; > > + > > + Instance->BlockIoProtocol.Media = &Instance->Media; > > + Instance->Media.MediaId = Index; > > + Instance->Media.BlockSize = BlockSize; > > + Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1; > > + > > + CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid); > > + Instance->DevicePath.Index = (UINT8)Index; > > + > > + Instance->ShadowBuffer = AllocateRuntimePool (BlockSize); > > + if (Instance->ShadowBuffer == NULL) { > > + return EFI_OUT_OF_RESOURCES; > > + } > > + > > + if (SupportFvb) { > > + NorFlashFvbInitialize (Instance); > > + > > + Status = gMmst->MmInstallProtocolInterface ( > > + &Instance->Handle, > > + &gEfiSmmFirmwareVolumeBlockProtocolGuid, > > + EFI_NATIVE_INTERFACE, > > + &Instance->FvbProtocol > > + ); > > + if (EFI_ERROR (Status)) { > > + FreePool (Instance); > > + return Status; > > + } > > + } else { > > + DEBUG ((DEBUG_ERROR, "standalone MM NOR Flash driver only support FVB.\n")); > > + FreePool (Instance); > > + return EFI_UNSUPPORTED; > > + } > > + > > + *NorFlashInstance = Instance; > > + return Status; > > +} > > + > > +/** > > + * This function unlock and erase an entire NOR Flash block. > > + **/ > > +EFI_STATUS > > +NorFlashUnlockAndEraseSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + EFI_STATUS Status; > > + UINTN Index; > > + > > + Index = 0; > > + // The block erase might fail a first time (SW bug ?). Retry it ... > > + do { > > + // Unlock the block if we have to > > + Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > + if (EFI_ERROR (Status)) { > > + break; > > + } > > + > > + Status = NorFlashEraseSingleBlock (Instance, BlockAddress); > > + Index++; > > + } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED)); > > + > > + if (Index == NOR_FLASH_ERASE_RETRY) { > > + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress, Index)); > > + } > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +NorFlashWriteFullBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINT32 *DataBuffer, > > + IN UINT32 BlockSizeInWords > > + ) > > +{ > > + EFI_STATUS Status; > > + UINTN WordAddress; > > + UINT32 WordIndex; > > + UINTN BufferIndex; > > + UINTN BlockAddress; > > + UINTN BuffersInBlock; > > + UINTN RemainingWords; > > + UINTN Cnt; > > + > > + Status = EFI_SUCCESS; > > + > > + // Get the physical address of the block > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4); > > + > > + // Start writing from the first address at the start of the block > > + WordAddress = BlockAddress; > > + > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress)); > > + goto EXIT; > > + } > > + > > + // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method. > > + > > + // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero > > + if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) { > > + // First, break the entire block into buffer-sized chunks. > > + BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES; > > + > > + // Then feed each buffer chunk to the NOR Flash > > + // If a buffer does not contain any data, don't write it. > > + for (BufferIndex = 0; > > + BufferIndex < BuffersInBlock; > > + BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS > > + ) > > + { > > + // Check the buffer to see if it contains any data (not set all 1s). > > + for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) { > > + if (~DataBuffer[Cnt] != 0 ) { > > + // Some data found, write the buffer. > > + Status = NorFlashWriteBuffer ( > > + Instance, > > + WordAddress, > > + P30_MAX_BUFFER_SIZE_IN_BYTES, > > + DataBuffer > > + ); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + > > + break; > > + } > > + } > > + } > > + > > + // Finally, finish off any remaining words that are less than the maximum size of the buffer > > + RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS; > > + > > + if (RemainingWords != 0) { > > + Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + } > > + } else { > > + // For now, use the single word programming algorithm > > + // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range, > > + // i.e. which ends in the range 0x......01 - 0x......7F. > > + for (WordIndex = 0; WordIndex < BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) { > > + Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + } > > + } > > + > > +EXIT: > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status)); > > + } > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashInitialise ( > > + IN EFI_HANDLE ImageHandle, > > + IN EFI_MM_SYSTEM_TABLE *MmSystemTable > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 Index; > > + NOR_FLASH_DESCRIPTION *NorFlashDevices; > > + BOOLEAN ContainVariableStorage; > > + > > + Status = NorFlashPlatformInitialization (); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to initialize Nor Flash devices\n")); > > + return Status; > > + } > > + > > + Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to get Nor Flash devices\n")); > > + return Status; > > + } > > + > > + mNorFlashInstances = AllocatePool (sizeof (NOR_FLASH_INSTANCE *) * mNorFlashDeviceCount); > > + > > + for (Index = 0; Index < mNorFlashDeviceCount; Index++) { > > + // Check if this NOR Flash device contain the variable storage region > > + > > + if (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) != 0) { > > + ContainVariableStorage = > > + (NorFlashDevices[Index].RegionBaseAddress <= FixedPcdGet64 (PcdFlashNvStorageVariableBase64)) && > > + (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) + FixedPcdGet32 (PcdFlashNvStorageVariableSize) <= > > + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size); > > + } else { > > + ContainVariableStorage = > > + (NorFlashDevices[Index].RegionBaseAddress <= FixedPcdGet32 (PcdFlashNvStorageVariableBase)) && > > + (FixedPcdGet32 (PcdFlashNvStorageVariableBase) + FixedPcdGet32 (PcdFlashNvStorageVariableSize) <= > > + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size); > > + } > > + > > + Status = NorFlashCreateInstance ( > > + NorFlashDevices[Index].DeviceBaseAddress, > > + NorFlashDevices[Index].RegionBaseAddress, > > + NorFlashDevices[Index].Size, > > + Index, > > + NorFlashDevices[Index].BlockSize, > > + ContainVariableStorage, > > + &mNorFlashInstances[Index] > > + ); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n", Index)); > > + } > > + } > > + > > + return Status; > > +} > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashFvbInitialize ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 FvbNumLba; > > + > > + ASSERT ((Instance != NULL)); > > + > > + mFlashNvStorageVariableBase = (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ? > > + FixedPcdGet64 (PcdFlashNvStorageVariableBase64) : FixedPcdGet32 (PcdFlashNvStorageVariableBase); > > + // Set the index of the first LBA for the FVB > > + Instance->StartLba = (mFlashNvStorageVariableBase - Instance->RegionBaseAddress) / Instance->Media.BlockSize; > > + > > + // Determine if there is a valid header at the beginning of the NorFlash > > + Status = ValidateFvHeader (Instance); > > + > > + // Install the Default FVB header if required > > + if (EFI_ERROR (Status)) { > > + // There is no valid header, so time to install one. > > + DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__)); > > + DEBUG (( > > + DEBUG_INFO, > > + "%a: Installing a correct one for this volume.\n", > > + __FUNCTION__ > > + )); > > + > > + // Erase all the NorFlash that is reserved for variable storage > > + FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize; > > + > > + Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR); > > + if (EFI_ERROR (Status)) { > > + return Status; > > + } > > + > > + // Install all appropriate headers > > + Status = InitializeFvAndVariableStoreHeaders (Instance); > > + if (EFI_ERROR (Status)) { > > + return Status; > > + } > > + } > > + > > + return Status; > > +} >