From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by mx.groups.io with SMTP id smtpd.web09.11324.1609753460299479119 for ; Mon, 04 Jan 2021 01:44:20 -0800 Authentication-Results: mx.groups.io; dkim=missing; spf=pass (domain: arm.com, ip: 217.140.110.172, mailfrom: ard.biesheuvel@arm.com) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 2B452101E; Mon, 4 Jan 2021 01:44:19 -0800 (PST) Received: from [192.168.1.81] (unknown [172.31.20.19]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 28BB73F719; Mon, 4 Jan 2021 01:44:18 -0800 (PST) Subject: Re: [edk2-platforms][PATCH 1/1] Platform/RaspberryPi: Add system/user defined reset delay To: Pete Batard , devel@edk2.groups.io Cc: leif@nuviainc.com, samer.el-haj-mahmoud@arm.com, awarkentin@vmware.com References: <20201222134528.793-1-pete@akeo.ie> From: "Ard Biesheuvel" Autocrypt: addr=ard.biesheuvel@arm.com; keydata= LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgptUUlOQkZFS2xnWUJFQURa cnFjY1c0SStpaFBqNHhxYmI0eng5OHNFNTVXSGt5ME82dTRBc1c0RDZyQy9HdnFiCjRlQ2JG KzVEdzViSm5rbWp0dWQ0c0Z1NWl0Mkg4RHJ0NGh5V3pPVkh0NmJzckJFc3FCY1ZjZEdSV3FP dk93UVEKNExPbDhiY1U5cHd2dUZ1ZklaLzkvZDNiNS80RmFUek1DQnpWMWtvQm1aaXNBVlRM VWNQOVVJUklTa25hNjREVwo4TVFXUU1OeDR5S3hQYU5QRXVzd1Z2c3RwUi81Ri9Sa2N2SjhL QVZ3ZTVmVUxMNHdFdy8raXhlcWFOV3M3b09LCkQvQjREYUltWXRCSmdsVmh0OUxNTU1qU1NS KzVMQUpJOWl5bWE0TFNjSURqNVVGRUI5ZUp3SmR4emx0LzBISSsKMXlaWnAwbVJTNmNqZjha anFKL1VhVGsvOXM4VWNxZllMTHlqTlBOSGRyZjRENmdYY1pXQzdZNDg0MElmSlpweQp6WHNh bnBoWC9xMUI2VmREeVVnc1VTUGU2cnNxTHAyL0hHc1l1MEJBODl2S3VvRGpPS1htb05uMFlv S2NQOUZaCjZDNVl3SjdkdTlTSUM2cjBnWFE4WGlXd05vMDZ4aHpaaUFvd1BRcFdZSTBJS3VU a1hYK2RLVHAycGhhRW9aWWEKNjF3YXB3RnJYUy9sMmducjlTOXZmSFJnTFdGUFdMem9rcHhO aC9BZk8wSUF0QjV3MHRUbERqT1Nzd05MdFBJRApKNjJvMDA3MEc0ODhkYnBPSVh1MjRSaU56 QkJBd3U3Vmt3LzZlc0F5d2dORlpibjJKOEJQLzJwSy9lNHYvTHRSClhIcVl2QkViT3k1QTBU dDFOWkJxRVJKci9wTVdwVjhrd0k0dnZPdUtwZUxCZS9TQ3ByODNsWlVuK1FBUkFRQUIKdERO QlpISnBZV0Z1SUNoQmNtUXBJRUpwWlhOb1pYVjJaV3dnUEdGeVpDNWlhV1Z6YUdWMWRtVnNR R2R0WVdscwpMbU52YlQ2SkFsZ0VFd0VJQUVJQ0d3TUdDd2tJQndNQ0JoVUlBZ2tLQ3dRV0Fn TUJBaDRCQWhlQUJRa1VVTHlFCkZpRUU5RDBETW9FVm9aakpBQmFJUFNBT25LWXltUWtGQWwr OC9ZWUNHUUVBQ2drUVBTQU9uS1l5bVFrYkp4QUEKdE9neFcydTQ2K0UvYjJwNkxQSVBQWkM3 VVFmdWVEMXJSbWNIWERKUXlzdGF6dWZFSDNVZytHU0pNQTMxdGErVAo4NlVET1lhMUYxd0RS WFpMTXUrdlRoVEZTUnMxNWY0NVRNM0dlK0hTQ094L20xcUZJb2hvOE9FYmY5dXM3Ny93Ck5l MEU4d0NJcnl0TVNLZ0VZaFRnQVlmR2JkTjg1SWJGV2gzcVhlV2JTRXVBQ2dIalZqdWdKUFR6 eXhFN3BjTFYKZ1RzbmRiMHNIQjgvcFptUGxiRFZldmY4bWszaUdYNnpONno4QVZ0NC9tMVpM M3ZxemlkazI2ZHk3VHBHdWZHVQpWdThKT1ZlaXU4RlRTMGc4dGhSY0hVMGRiN1BOZmV1cTZV c0dzNjEvYXBibHZ6ZXkyWk4rSGVXdmxLVzFoM3Q3CkZHT2RwbnBJL3hsZ1FiMWJqbXBmN2dw YjMrcm9OdWRWMUdSSW1MWldLYU1TbTBaTWdWTk1ETnNZSXNETXNhM0sKQVhoUW1WbnBYa2hC T05kbGs1UWthVExndFkweVQ0SlhZdUJlMUdrRzV6U1NvNWxzaHlsZEVxbzBSRXRFUSsvMAow VVArUVg4UGpSUFBMTEk0OHFseVFLalBaenFrdmo3cGpZaGh6Z2F1dE5MVkJLT3hYZ0JxeUIy UzF5M0craTJoCkVRR1BicElyY1B0SWh2d2lKR09MUkpHMnFHaUREeS90TzBaOUg5TFB6SUNS QWJrNmlGNk5OMmxzOTM3TDRhcUsKVzEvV1RieDdXMXRiby85N1F5VGh6UG9XQ2p3aG9oaTJZ UExpTS9aUU56dVdEUTdLMDNMNnVJRXhzRjdBOUx0SQp0RlMyZW8zcnRjRmgxOEpIYzgzNkRR cW9yRHMwNk1qNlBnczByT08wQkZxME5FRmtjbWxoWVc0Z0tFRnlaQ2tnClFtbGxjMmhsZFha bGJDQThZWEprTG1KcFpYTm9aWFYyWld4QWJHbHVZWEp2TG05eVp6NkpBbFVFRXdFSUFEOEMK R3dNR0N3a0lCd01DQmhVSUFna0tDd1FXQWdNQkFoNEJBaGVBQlFrVVVMeUVGaUVFOUQwRE1v RVZvWmpKQUJhSQpQU0FPbktZeW1Ra0ZBbCs4L1lZQUNna1FQU0FPbktZeW1Ra2NVdy85SEpv U3pWV0xWak84TmVaT1h1MzBMc1l4ClliSmwvZi9WOFdhS1VnYkRyQzZLenJkYUhYcUh4MjdM RS9Wck1BSHRaNkJzckdoZUkxcjlsdy8ySkU0ZzFKMXIKSzNobWFhOS9SZ29sZXpUU3dsajc0 NzFZbHNTL2FkOHhseEJnRDArdG13UHdvM2xZVkgwOXc0N0pnajFlWGwzegovYUdkTEk2MGJ4 U1hCamxJdmJqZUdHMkhYZ2V0MGpaOUhYM1ZNaTFkbk9EeTRQUmM5Q0o3aXN4TkZLamtYbEdJ Cks0MEZPUDhXckdkRytSM0RqK2FmdEtyZ1VQaEtuTGVRZTd4VjdURUxpQzc2cWlWWU5ET0cz NkIzVC9yYVpMQzYKU2wySCtwNHhTaktCL2E2bUtjLzNiY1lVZGswUkxjNnZFbmlDMXh6dHZY NGVlcXJtRlp5RGpWVnEvTjhSSGwxQQpTVE8xL3J5MGZqUGp5UVVqWi9CeGU2cm1JWGJka3lM a2tNeVZMOUxsdnp0Tk1XUWQ1T2lwaFRvSmg0QXlnVXd6CmVYdzhCcnNya2NEN1U0MHR0aytJ cmhKN0tZdStJUVN0dG43dUUydFhZZURWZ3ExV2xrV2tqUTF4eW1uMzVRV0YKdGsra3ZKVWdH a1lMZGx5SDkyaHRMOWNOR1dYMWUxNW53OHl4SnUxRURhM2I0QW94ZStnYTRyeGtpelc3YjlJ Mgo1VEw1RVZVamw2YVN0WEdjTy93RkJHbGRWV1EwSmRtNDRWYkZaMjBQcmVxNHc0WWtJNGlu c0c4UFdCQ3hESnhNCjhVazZZc3h6MzZPU3ZwOGRONDUreWV1WkMzcU1ENzdGMWJNYXdlOGtW VWFWZXBrTUpHUTdnbkZEZU1rSFAxeVIKQmh0RXd2SStVS2wxOVlScHJ4cTBLa0ZrY21saFlX NGdLRUZ5WkNrZ1FtbGxjMmhsZFhabGJDQThZWEprWWtCcgpaWEp1Wld3dWIzSm5Qb2tDUGdR VEFRSUFLQVVDWEo1eDJRSWJBd1VKRHdWL1VnWUxDUWdIQXdJR0ZRZ0NDUW9MCkJCWUNBd0VD SGdFQ0Y0QUFDZ2tRUFNBT25LWXltUWtaTXcvK01VSitzd0lsWmQ4eHNYWHFsYnZtR09ONUNp b0UKbVBrSloxR2RKMHIwMFQvSkV5NEJhYVRySnpPVjFrS29TVVpQTW9Ld1BxTHhlcmsvem5s UnVybmg2OHUvV09HSwoyWDZrYXcxTDlqdUF1ZkZqV1FkYnFtQ1JWUGhEK2hTemE3ZllDbDBF bGxNMkN6dzZGN0tuVCsxS29vQlE0NVlaCk00MHlFY2tvVHdmYTUrNGx6b1BBRlZiSU1GTHBI QS80dFh1YWxPWEIzaksxdTZoZHVaRUpRWDA1cjBpL05sY1oKcTZESUJkckdmMEhBeE9nNC9x N01vVXZ3VU5DN3NWWEFJRkIvWmtCRnB4MEJkT1h5WUJsc3VLOW93M0dCWTkvMAprOVN3Yk83 SW8xYThXVjl6cittYllIS3ZYTmVKaEF4OEJrYW0vb3daL1gzQWk1Z1R2bzBPSlJjNzFzc2RP bGFSCkpuTGFMMDVjTGdiTDIySFJNZTlubUFNQ3F4d1NCUmZCS1JuUTQ1K09MZTE1NkJBQnhM bmZWT2ptQmlwZFVZSDIKSkp0OENWakVDREhkOHFGankyQytablZpVHdaTVFPVHRSd2t1U21v MzRabk1XMmlmMXRCdUlPTUszQnArekJtZQpQRitoaW8xV2h6R0RZUDZobHVzeG5NVjd5cTc3 d1NvWExFTm9FaXY5TmdkRThtSFNKSUtiYmRYWGY4cTNoNnhTCkxqTnJZaURiUzhaWFFtWTJB Ni9RN3Qrc0RvTFJYT0Vjd3ROOGxpbThCQ250cGVreThNQk9ha1JCZDZxRzQzeVQKbWhqVEpD UUJhM25yWTdXTU9lWlFlZ3hHbTQ1VlpRMnpGVWhJRHBseFFBN3V6V2FRZzhCdW5YampreUIx WWNpTwp6VHIxdWE3MXRWVkxuMGUwTVVGa2NtbGhZVzRnS0VGeVpDa2dRbWxsYzJobGRYWmxi Q0E4WVhKa0xtSnBaWE5vClpYVjJaV3hBWVhKdExtTnZiVDZKQWo0RUV3RUNBQ2dGQWx5ZWNn NENHd01GQ1E4RmYxSUdDd2tJQndNQ0JoVUkKQWdrS0N3UVdBZ01CQWg0QkFoZUFBQW9KRUQw Z0RweW1NcGtKMXNNUC9pSWhPVDVRT1Ara1JJSXNRK2Vmc0h2YQp0Y0tsdU56ZmwyVXA5a0k5 V09tYnczUTZ2OXlHR1N0YUlLWVFySSs1dXN6dUc1QUtsVk1IUStKei92UGVLR3I0CnRNcWFJ aFlWNDg4Q21FbmJmbXRhbEQ3aHZBdXN3a2ZDZ2JuT096SS80cVBOdm5oem11Q2JJYUI3OS91 TnNPSzgKaHA0SUM0OEZnYkRYbnRJK3crSWVNOUE5bjNlU1FONnpBeGh4WnNOUVhEcEJzSzhC ZG9pOEtvdDhFSnh2QUIzNgpGZUNVdm1YTGxwNk9ZMys2b01zcnJGMnZyQnkrdE93aWIyK1hs UkVrKzZsS0lvbW83a094VDlXZU92dWYvSDh5CmYvUDR6aGxOOGNMSVdFcy80V0dxc2dzcmxG OHNDdzZ2KzVWOFJheVkwMGMwejRCQnlYTVZGMnhCZFd5ZC8xeE4KWE91c3hnTXA2c3F6WXJF Rmh6UDdjNjZELzAraFIvejIrUzk3SVM1RDc4NzZLS2JYQ25CZ1ZFN1hYcG1WRXczTwo0dU44 MXQ3NXc0QW5nZ3Q4NHpGRmJGVnRkU3N6c3ZWYyswd2M1SXNpRFhCOVo2N1FpN3VQbEJWK3Zv Q0VaQjRlClB6TTJySlFEL2MyRThYSHU5MUlpTU51K2tPWU1MbGJONDZod0tWbkdsc0YyTWxp Y25WRTd5OTc2QUJpUWNkU3gKeFBlb05jTlBnbmlaVWhycVRXMnNab3Jkc080RUdpVHJSRXdj d1U3ZGloNDRWTjJDU29nTnJwYUdJOTR3cDQrdwo3WFRZQlZvSUE0QmEzRXZENXQwcy9ZYjlW Wko5WHJxOXByRFpTSGZwejl5cFdSSnRSbWJpbjUwUlkyTWlFOTVvCmsrWUVkTXNtaGNydmhM alc2dUZSdVFHTkJGKzdoemdCREFESTNiUDBuaHFUcTFrek9venBLNC9DY0JNajhrQ2oKeFNl NTZpNCtEZ1hZakxmWkFNcFM1MHF4dDRXb1BaM2s5K1A5Mno5dTZFSFoxSDNjeEM1OGV3M1Rn a1pPTzdSMApVN1N1clpLSUEyemdoZHRHTDI1clRmRWxteFUzS2paOXJGNFFkc1l1Qml0dU5L T1pIZTdqUEcwTGk2enVHWFlFClRkQ0xQbXYrMmFRZFV3dmhCQkxxRXdwR2NLWElsd3NBclVn d0NXL1lLV29LT2ZOU2YranNRSzRTdC9mWjVYeFoKZjZIZkFEcGN0ZUh5NjhKZDVQem9LQ3dn akg5cFNTd1NWUm1UWUJLdGxxdnVEejV1K1RLRE5MTysxYWhhZSsvKwoxbExaalZ6bWhHMS8w L29YM2k5SzVtR3RuTVQyTzJNUi9uT0duYlVLNGFybExOZEZmd0RidzNXMy8zSmpmMWtBCmlU UXY1Qm5STndLczl5cE56dHpTV0hCNjgxc3JSUTVwNFNTRWdGZTRsTzN4ckdLUHluVWFCSWlp cDcxQmxGdlYKa2RlZGVCdWRoYmZ3cmZpdGpGNmUzT2QwTWs0aGEvME1CSDkzZlVyeTlVMEdk SzRCay9KYk5qTmV6QnYrbk5YOQpCRkFFOXJOek9JYndhNDM4MDZIbUZrU2xpb3ZQSEFrcE40 MEFFUUVBQVlrRDhnUVlBUW9BSmhZaEJQUTlBektCCkZhR1l5UUFXaUQwZ0RweW1NcGtKQlFK ZnU0YzRBaHNDQlFrRm81cUFBY0FKRUQwZ0RweW1NcGtKd1BRZ0JCa0IKQ2dBZEZpRUUrOWxp ZkVCcHlVSVZOMWNwdzA4aU9aTFpqeVFGQWwrN2h6Z0FDZ2tRdzA4aU9aTFpqeVRiTnd3QQpy NkhMV1hQYzBscUIrNVhadFo3SWVMeDNoTFBBMHlCR3pCa3NNd2FkUVZiQmQ0UHVtbWRNZUJX ZmJDTFZVQTlPCjZ6WERIdkVmcU9jNGt1RWIrVnI4L05DM05FeGZrQnVpQThBYkRXbE9GUXE2 NGZmZ1NkT0g1LzQvRFRzWWFLbHcKWnJNWXZzNHhQanlYSG4vd2lLZzlHZU5WeGZTTjBqdzYx MUFhWWd5aFQxZng3VzBRVERyOExPbTdiZGtldUF6bgpsNVhDK0tKOW4yaHNCVkZROWI1eDd6 QzlvbG1qcXRTd2JuT05tcFdkZFI3Wm14WmhMYlZwRWppZjlYbGgzVHVnCkZ3OEJBS1lsN0FM UzJ4anJGSEFEeVZWNFJYNXhCUklIcnRvQ25peU9LZlFqUDRpaXY0cmhEWUx5MldJMTk3SGgK dVFsYnFHM01kcjFTYlVqVFFBanhWV1MrZkVqd0tqNlpRb0pWcVIrajlBdGxxb0xMSzRwVUh3 aTFhS1RIS1RCWApVL0pxY3lXWmZEMG5VZ1krdldxRGxaODVnYzdERm9VeFFjNllDZHhzTEhr YS9wMmd4MTVNa082UU1PQzhnSGRoCnI3YUNiR3VpZGl4SGVIdENDQ2dpRHpIRVF5Z1NHcFlh NVQ3Wm56ekhsbGhtZ2p0b05WVHJKNmtaVWRSaGM5bkcKcTlFUC8wcnRWZmVnUVNYcWNLblJD Q1NwTENQaWU2WDZqMjQ4M2QrbkJHZ2VLWjVIcVBFZU9NTDhwb1ZMc005UQpTUXdIOWs5NnVZ OENCUVl6aU1IRFZ2aXlsbVNmNWNGMSs1WDFKS1crOWhJcjNDWUxpQ3d1c3lGc0ZYbEY1czZH CkZvWFBPQiszZ255SHZtU0lHeUQva3JtT1p1bzgrSUt5clptSEFJYVhTOTRaMUdyT2FBcjIz RlhqbWhXaVhlVXAKUFBSWEs4bHMwMUZpekNZdFNrNXV1WkVLc2psQjd5ckdzYnRodGIxRERB UkVTZW9GU2xzQzZUMlg5ZnFKM292Vgp5dnNHMmNZMHB3NS9FblhDSGpEQmVCaVFIUFRlWjJM eWlyTHZXdFhiaytPSjRkSGNTdFhTdFVwOG9zVEIzNmMxCkp2KzcxQUEvbFYwMm5qYnpmSy9E VXpUTEFrM1RGNWZ5S0tYSFRUWnpQcFA1SVZrTHJLaDVOL2xYMXUwUHQrMnEKVWNpSi9LR3Rj TlNoeGZBdWxmc2RBbDNFMUJBL1Uzc1YrVC9JV2hjbmJtQ3dDUHowWVdtZlJsNjZheFp2bTFT eQo5bU5PWnVSb1d1Z1hKRDBWUGtqVW9jcmF6L3p2TzliZXBaeTRLblJHVFNybndYbFR3aTNZ eDdRSG1PeXNNZTFuCm8wY1dHcVIzSHpLa2pPWGhmTGNxWkloOUdESmZ1a2dDb1dYME02V0hB ZVVHZXd3ZHZJZEttY2NGc2ppeGh2b1kKLzZxdTY4aGVDQ3d1STZVSGp6NkdLbnI0dGcyZ2Fp Um95QUkxckxjZm1mSllKYjk2dWxnK0pBaGJsUHJ0OWdYNAplRGlNSmIweUNyMCttdzA5T1FQ dUJCbW1Iamd2a1daVXFZYVE4V0RnU2xSbmx1eHh1UUdOQkYrN2gwd0JEQUMrCkc4WWFvOWRV OFZZTytsNVhFQitFRW1oTlRTWWJMMlVpWGl0WXUrMHpyMDBxelRDakN2S2p4V2QzVmp3bWdZ VjMKN1JreGhRbHM5TGJFUmZEVVBmZ0JBbFd1MzRzR3FxWnRMZTRsM3IzVHRzUTlSdklvTzN4 dHQ2THAzV2VHeWxaNwp3OGpsdVZBMXZKV1p6ZHlmbnVUU1F4RmhWdEtyT2N3VlJncjZUUXlS K0NISVFXRXMxb29WT3NocGxmektsYmd3CmhWbVUrd24xaVJJU0hZWWJwR2Rsb2RoOUJ4cUY5 RisweVN4TkVQLzhLcm1hS3A5dDBrZDZrY2NiVGd6S212TWsKRzhkSVVzMHJ6NjAzc3Y0eXd2 blZtSzZjLy9TZnRDdmVMdFpLRXRPYkFLa20xc3RQWGJ3Uk15ajB2Ulp5RmdXagpXb2hCUkNC UDRoblE2L0hlRDl5dEN0SFNkeGVueTFiVjdDeGVGeDZyV29LNjlibG43c3RnZ3AycWRuODk4 cVE0CkhyRFh3eU03K09CVWtzR3NCV2ZPRTBadlJaNVYvNFpWNnYzTDFDRnVmR243RSsweDJH dUFLVnVjQ1pzTW0vQmYKR002ckJKdTB1bUZaby9lYjJWUGg1MUdHUDNjVU1aVDNka09FVWh4 bFN0Ty9rUjFOMVVsQS9aSFIwcEcwQ1BVQQpFUUVBQVlrQ1BBUVlBUW9BSmhZaEJQUTlBektC RmFHWXlRQVdpRDBnRHB5bU1wa0pCUUpmdTRkTUFoc2dCUWtGCm81cUFBQW9KRUQwZ0RweW1N cGtKK0pjUC8yOGtoN0xON0liWlJZRVhpWDY2d1N6WHo4NHF4eUh5WXNRZ3dkZWcKYzVVNzcx TVVNNXpRVGM4TXRhQ2dBYjZDQ1VKdDQvZjdsWk1POTUzOUZ4Q0lRdlI1bGFNRHNkNEZWcXp5 WUc1RgpEK2ZoYjlpMGg2V2llby9JaGE3UDZSK1FOSkNyM3JCTkRVNFZmZnFvQjVoT2hwUitX dVZaak5HNnNVemFBeHVaCnRNRDJuSmxURFpKdUFwYURpR0FXWTJIOCtJNjdPMjJHSFhUMDEy RmVDVExuU1RwSnJleUtRcm9ndjQwMVE4b3QKRi9zekZtTURFR1E2OG1ZRktRMldkOGpyOUtF NFJ6VTlzRGYxQktFYUlQbDM0alJ1TGhxSDVJZUFCdzZIaVovTworWEttbDZFOWd6V3VnLzZL bUxhaUY4bWduWWk4Z3ZwUW5OSnBVV2lSdnFiZ1I5K3N5SXJudXNOUG5INDF6Y0FjCjRIS2ND MHQxNTRnWDBUTDZUMVpwTmlzV3UxN0hMNWVoTUJEczk2WFVialVKM3VXZzFCaDIvSHJLa3Bv YjMvSGIKdldFSWlNeUVPZUVxVEM0eGRUTnJJd2IrN3RKeXo2VWhjN3YwbTNqYUFET1RWUTdJ RjlXM2VzbFlvNExlZ2FaTApwdWR6TXBoL2Ryb0tzVUZxdWZUTk1UWWhHN0F3T3JUV1hUeGcz MW5HZXdCQTRWWmhEN0hQOWR0QnRlV25helRkCk1jbFRPc0Q5REMzRUdRLzFnbkxzUnpqNTEy MVJrSkE2UFVETngwcG1kdHpqZkZCVWMwK3k2SFIxb3BMaWt3eU4KVVNabDU5WlVMM29FUVNw d1J6MkdDQ2p0WkdLVGVJNmErOXpqRkcvVU5JQisybzY3OGN1MmwxQXhyalMwdnlQcwphU25i dVFFTkJGRUxsdjBCQ0FERUU2SjFGNmZEaEZNMkJNSy9Xc2x3clRGWHdJV3lIdlVJRDlqaFVr ZVE1ZWFhCnh3ak1pYkhzM2ZmVzAxa1hkRGxTT3NRWjVieldFeDNCc1N3UFluTkp3WWUzam40 YThsLzVweDE2Sk1rZVh2Vm8KODJrWWRoQ3JnSTNuQ1hocEZEODlpZVo5WmVhOGlhaWhQRito eVp6MDlPZXk1WFJ3MU5iVVhLLzg0R1ZZdTJtVQpPZE5Db2kvVnE4VmhSejAyUFVNRFVkZThB bVVENnBPc0pGbU55dXZ3RzE0ZXpEK2wzUU81ZXVMblRaUU4zQ2QzClJqWThjTTl1M3I2L0x6 TnhMQnc2R0psTW9SOHV3VlltSlA2TUFveC9oSWpmaW5odmlFSmRCeUhuZXRnZDdsejgKR2lF TU5HMDNxc2ZHZFl2T2hUOTZwL21xSVUweitGMHlUOUJkck42ZkFCRUJBQUdKQWx3RUtBRUtB RVlXSVFUMApQUU15Z1JXaG1Na0FGb2c5SUE2Y3BqS1pDUVVDWDd1Z0FpZ2RBVk4xY0dWeWMy VmtaV1FnWW5rZ2NuTmhOREE1Ck5pOHpSakU0TUVZMk1qWkVNRVJCUVVJekFBb0pFRDBnRHB5 bU1wa0poVXdRQUx3b25QcEpSN0VVTk9XY3pTSEgKZ2xCYVZhTGxuWGVnQi9IblFDQ3FTVVF2 VHQ5SDZPRVg4Y3pxZFl0cS9JOUp1OCtWRHRWcDdHejZIRGx0ZUJjNApIanRoK3MrejN6YTFm aTdzQjFBdEhTQjl4VE5sZ1ZQeWR2dWlGcFRKamJBUllVTmZlQXl3MkY3cmJKY3MyWjdGCnlJ akY4M3RRQU5wMzMzZGxVN2pLcXMyVm1ESlN2d0pNdmRML29uYnFiR2h2TWp1aVVZUDFlUC9P TlNmdUhVcDUKRmdDa0kxUXZ4QlF2d1NSN05CM296QVM0ZVNLVTdLdUdiMzZKMlVZRVFnNXBB bXFvaHZQZkl6QWx2QlhGY29tWApNcFNsdTJIVGpIb3NCN1A1OXpwSldTeTdJVmI4YVVyazRi ZHlQSEVXY3QvTXIwL0QwWUxhZ0NzTnRXbW1XdkFMCnFrTlo3VFpscWsrVnVrdi9WVm5tRUtL SFkyY0JsWXp6aWNleWo0bmxhejR1S2ZEOWVlY1lWcnNLQUswdDVzUHIKcVdZU3I5R3pIcEts V21Kc1NxRWlNY2NVZERsWjR1dFVpMjRjWFNDOEtTdUFydXlFZk1yTklaYnJCeExyTjJWcwo3 b2RDZXpTbUpNdzVSR1BnalB1a0JVbGJFc29NOVI0bDY2M2w1dG84eEdENk5ZN2pCQ3R1MXZV SlFlNTY5NzkxCkdrdEI5S3N4UjA5aEI5YVJUeld2M0JXcTB5K1ZwMEQ1Rm9mMkNLeTdIRHFx bFB2MDhrWVkxNXRKQUt1cHZhSU0KemdMNlh3MDJnQVo5Z1BoY24rL1VhNGpicUJ6d00zTExI ZFhkS0dEWlpZMGRPUWtlbndqQ09XYzVCYWExYUhZTwpRUFNtdjhnRnZMTEhpekxUM1lTK0lj UzlpUUlsQkJnQkNBQVBBaHNNQlFKYWJIc2hCUWtQQkg2a0FBb0pFRDBnCkRweW1NcGtKRWhv UC9SRHQ2eDZ6UGdiKzFHandHWXVVQXp0bmdZcEZFOTRQdERyQm5aY1hlQmp6TXFvZmdKR0MK Q0hSRlBoY1NZVXB5Sm84MXhZYVBoNGhza0pKRU1PQlp3QXVNYXZiZlpMUHBvT0NIakh4aVdB TG5GWTBvQlRuZwo1VzEwMU1hbnVuMlcyejlOMFlaWTdBaElwMmJGcElPeVk2TW9HQlluSUM0 NU4vb29hNExCWmJCTlBZVlpidmZCCkREeGEvOXZUMHE1eG5qRGtCUmRTRFFoRGU1TjJ2VTBu ejlFWWRzbXE4c2tFWEFFVGpNdCtLQW9ueVhTTG53eWUKNElja1ZpV3lGODhHQnFKM3hHTVBS KzVLeVpwRXhvTXlCL3M1dWhWNTBqelFqOTVhUDd3TDQybzBvWVIzV2crNQoxVXY0dy9Xdjdv Ui9CTlNBZ0VQMVlML2hacWxjTmgxakNHdTdmMWw2Y3lsMTd0WDZtUk1ETEZSbUhDOTArcG1p ClYwMWxZeTczWURnRGhHOFNDbHdnQm4wYXhRQjRMVDhvYnY0dUVCd1hXUkFMOUU3VDNLb0tO VEllUWE4dCtudVoKTm1DMFVXb2MwUFMzalFVZUhsdU43Z0FCS1p0V2ZvSXk4OFVJNGgxSkdZ K0JmUTBpa1cxdVJTcjJmYUJsNHNuWQo5VExkVFFOeHNMb3daNjFxK2RHZzhYS3AxbVY1QWxz b0NwRGJ2TXkrdGM4UXNBNUx5T2Jvank5U3hJdHVObE5kCnVSWEdJVFp0QTlEbDQwTlczTTcr SXJJWnJrRWV3TFZoMngzcm9QTlVGZjNkdy9acUpsTDlPQ3phRnZ5Z1doN1UKbmROQlFJWk5O bzhLcjhoVmsyaFV0cTgxUDBWNGRyYkNsYW90cHRTWVFjUUFxQTVVSVFmeEZ0OFN1UUlOQkZF SwpsZ1lCRUFDbzZKK0JOZWtZejdUNko5RzN3K2gyaSs3eXZmbkRyME1RMDJhWjFPdHRBcS9B MmNDYUNjc3VBQmVpCjdkSVh0OHBiTEw2VlcwNnNuVmdIdC9qTEI0YlVqbTd5bWdjTUEydGpI OW8xeWhCM2xabUZ0QUN2K01YRnRKL24KdE9WaVlEMVdGYjg5ZWd0TGJxQUVtanpKdHJTQkdU Z0UyVUhVck0zb0tWdmdaVm53czRvdDdIVGdXQWN4Z2MrMApmdTdDREc0TXAvNm9yQ1ZCemNP R2ZDUGZPNE9LVTc3STQrM0k0dEc1MDJWcGhHTGdhVVpWdlVJdUNyc0ZWU1Z2CnYrQ1dBYW9n SDc2MWUxVTZsc0d4cmo4MDN3b21NR1VHazZpaGE0S2VJUm9PSytrb3hpcTZQSnJqT2xJZ1c1 WUMKenk2SFdTY012TTZVOGY2SjRsR2k4WExwZFM4RkoyZmFkRHIrMHIvb2J6TWhhcTFGVFBZ NDRONHc5WVJiTzhJTQpQemJIdmFaeHpLeGI4bU1GWXdGT2xYcE5RU2c3TEVlMEhsYjdKeVpx bDMvTEVHaGEyS0drRURXaFJuTVJqOG5iClpySXd2SEtxYjlxSGMxSkhCd1pSNytnblpmMzlo a0krWkh0QktLRFlERWlmVlhGaEdmU0YwalI1UGVYdDlHNGgKUUFQdHBvc2wwYTRUeXQ5akdn cFpFTWhQRnZhcUVHNzBDUjMzY2FoNmxaandjRk16WVFlNjduSXlhN3EvaWRkNQpZczdqMnlt YWxRNHJQMjdWcG9sbnR1Sll1aUpCSk0yWFJhV2VQNGR3cE9YVEdJb041N0ptTlQ0VlNRQnZo TGlvCmpNOE1oZG41cWcrSFNISWlURkNjR2czc1VHc1Z4UWZmcXhRYVlLNEx0NWEzZ3JUZm53 QVJBUUFCaVFJOEJCZ0IKQ0FBbUFoc01GaUVFOUQwRE1vRVZvWmpKQUJhSVBTQU9uS1l5bVFr RkFsKzZRQWdGQ1JSVFJJSUFDZ2tRUFNBTwpuS1l5bVFtM3JRLytJbk1UMThjbXNuRy9MS0s4 WHRlRmtIaVhvZEdXei9McldPWE51TjVsQ21rL09vVTh3ZWRvClBnSlk0WlRxK2hQMjQvam5w UzFsUyt6b1ZTZmxDY2p0bnlRamhDRkhpNGFUTlU2S0ZtaTRrTzlmTW9uZGpiUisKSU1WVDhT RmZZck1udUR0RE1mUXQyWFVDeDgwWTQ3YmtGcHlVa01MSjkwMHhLc3c4VTlicEJkeXVjUm9I SEtNOQpOZTdEdVBFbWI1TWNNbTA3SmhHZ2tPa2k3Unl0REVBdjk2UVRpakljUWUzazBPbERo dmowVkVnTURJWTFXOW9MClZoa3A5Vkl5V3p4RGNHOUlmaUpOcC9iS2FDRk9wczhyc1o4V2h3 UEFxRlgwaHBDUXIvcmEzRGJDaERmR3czazcKcVFETlhITUgyUG9wZnhVd2NXcU9lYk54YkJL ZURZWG5sM0NTUTdzYVVWKzlOd2xsK1o3TVZtTlJMaGkyMi83TQpQY0IyZEdDR2VHK2JCTDZM aFJPT2hkSFd1T29sMGNKZ0xMYldBZkhGK3p5Q0VvS2d0ZUhMYTMybWN2TzhBNFNxCjlEYno2 YktNWjZTTmkyQnpwZEl0N1ZzekNadE14d05XWVduTjN2c3JteWw3azIzS2VFQ0l6dlNLdnor VDJkcjQKaXVQQkx2RUR4N3BFOXV6K0FNQ3VlNURHeVZ6eDVwTmk2b1pDZmIrZzkwRG9OZUFL ejRIbFRWYzVPVzV4TWdpcwp5YkhnSE9NSTFmZzc0UitxS08rYXFuUlZLam1nNUpWMDAvQTFJ UFgwdE1RRit5dkRaQkQ3SHdCN21VM0dSY1VyCnd2UHBkb1dpMVVCQVZ0NU9ydi9XRDJ4WWV4 cEt0aG45TFkxUnZjM1ZiRVdsZjBheU5kV09rODY1QVEwRVVRdVcKM2dFSUFNTWhIayszbFQ0 ZDFHd3NjS3kzU2VhRXBRSGVva0FsZWZ4eWVrbWlOa3I1K1JlOG5adm56TmN6bEphLwpLMzBv Q3RkOWJwMlRpd05IZU1KR1ZBbHlXTVV0b05lamkvUFdDdGJTQ002V05FVlFWVldtRVRBeGJK amFaSm9pCmVKbU9zQ29QODhyU0xBUzdMR0tGTUhmRnozb2hTSG1rUXgrR1AwaTlhWVNrUlZU Uy9pcUNPeFFvNG9ycmxJbVgKbEN4RWdBeTM5czQvNjRqRXlyR2NZNzRobFk3cDNyVFdKTUVp OU9yUzdLbnF1YUVma2M4eXBsYkdlTmc3SDJmNQovWFpFMFNESzIzbUJ3Zks0V25SUTllT2J3 NmJ0d2lsYjM0SVh5UnY0cGN6bWZ4UzU0S3M1eURnUThDcHFIWk5ECmx6SUZqenJsa1FFK0pO OTNOTEI3ZnZqczdkOEFFUUVBQVlrRFJBUVlBUWdBRHdJYkFnVUNXbXg2L3dVSkR3UisKb1FF cHdGMGdCQmtCQWdBR0JRSlJDNWJlQUFvSkVNSTNJSDZWZFBwOXUwRUgvUlk3bHRBS3M1NlFO MnNndkR4WgoycGFndC9qQWl0cHliM3ZiakpqOXRlQThKamMwemNhUEJPcnhxdU9EMmdidWxp c0JMaWtrZG1PTVlheE15MWFZCkIva2Y0WnBXQ2tSRlNOeWpmTXFhMEMyd2pITzJaS0pXQlFO dXJBZ1MvRWg3bVBEUDh5cHIxU1ZwQWEvOExrLzIKY21CcVJ3a3JXSGVJY2tHc3NDMnkxMzl4 Z3QzemJoeXNKMzV6ZGJzb1ZGQzlXUTFJejg5QjNONUZpNC9UMU9sagp6SXRaWFg0S1JNTnRF Zm8xd2lZcGJ5b2FSZEt4eHE2NmcyU294a250RjBKR3p5Nm1FTksyYnRESi9TaGdxaGpICnhz NENGZlp5MU9SSDRTRGhQSmcrSGNwYUk2ZlBQZWdEOXFDeVhTTHBMWEFtOS9qR01tc2RyOW1l MXZzK1VoVW4KbitrSkVEMGdEcHltTXBrSm44a1FBTTVMWjBKTXNTaG1JR0hFbyt5cnNUT05W K2dPZWFtVXB5dVpQb0xDQmhCeApJbHdEayt0NkV0RmV4YlFoSWl6ZjE4U1hxWHIzOHBrVzFx Q0tScXJlbXR0YlQzUUd3dmRaVnQ4QmhERWFmem5mCnN6dE5UYlFNbjNtbVhETmYwOVk5Tmtl RFlOZGJwWi8rc1NlUHdYTzlYZkRMVkdIZmp2Ym81azUwZ1VGNkNpK0UKbEpENW82cCtEWGJE MXBQWEwvYmlnSkRYMWJabTNFVjhXNmtJU1dKOUduNDFpT1RkSm0rdk9teFRsYTByaGZNagpj ZVQyRk93SS96alhRbnB5c3R2U1JCVnhxK2hrWnZhOXZEWlNYOUFnNit4aUxPamZ1cndOK3hR ZTAzOERTdkR3CmdoOGJ5TkJzemh4ajFOOW5wcFlsMFN0dGNzK0RWU2Z6T1E3VW94Uy9ZMkJ2 UjRyZ2k5bUZ6bTQwcDlwZllYTWUKRXkyeG9EVTFXc0hyQlZyT2hQckhhTGIxSVpETU1EeWwx Y2ZVMlZlSkpZVGZnK0NJNFhHR0pLS1FWVTB4bFBHRgpWYzZLMklwRU1yVWxuSSt5ZWlkM3dj RUFNcnUxcWpEYm9acUg3a2FOQTRXN3VYUzJqQ09QTm03Z084bjQ2RFpUCnI4QUpGRmxKZi9N bTdVbWNiN2d4bDhFcDMvbUpjZjM3bzhJMU43ZWRFNkhUdGtkWEp3MXh3RGpYemt1TUI3UUoK UWpjWmZScEorL2k2b0ZzWHBkeHhQcmp2Qmw0dklXcmtZV0JaTzliR3ordVliUUlYSVplMVlp aUJnTGVYaGN2aApFdVlTcnNOaDBPVnRJMlBBZnZqZ1lXYUZSMGtrU3pGTitFRkpmS0JoazNR bjlhK0hZNUIxZUxHL1BtL2R1TnVRCnVRRU5CRkVMbHpvQkNBRHIyOHZBNVBjWnJZZWRHMnJG QUppaDI3OExPZksxSXc1SEdEVzVvZlZtYkpmNSt3RVkKZWdsSFlxUGRMRS9WNGJuR1l1bERs Mkh3N1crK2VsWjVDWTFjNG9uV0RNMlU0M3hrM1RaS2t3NkRWdzFob2g3NwpKa2RrTDFocTRQ azRXRGFoRUlwY0R0QWNYbE9ZOFduckdlQktiU2krME1pK1hPNXdkUlRmNVc5S3A1dEh0dGJs ClNXamNrUThtMkVKeE5Xc2F3THdIcTNGM0REL1prZDFiV3pnQjQrbFczVitNbjZnSHNUbnd3 VW1zY3ZVazZ0UDMKNkoxVE4xQXJqc1o2ajRaZGE3NWRpc0tvcWgrWVV3cFd3V0pBSm1jU2ZN bW5kVkJUeEZyeVhGYmM0LzFQaFAwMgpxM2QxNi92dXRMaEZER21XQ0RzS2tVYTgwOUZGUHhS U2kyVGxBQkVCQUFHSkFpVUVHQUVJQUE4Q0d5QUZBbHBzCmV5RUZDUThFZm1jQUNna1FQU0FP bktZeW1RbUlKdy8rTmdKNnJGbjJsNGNBOWdLenk2RmJHMVNlUm55K2RsOVgKOS96VlpiYU1l cVRMNlZyZ2llZXJsVEx4Zm5GSjZ3Ky9iQnhzUHhteXNHOWswdDE0dzN1OWZ2OTRUL1ZzeWk5 NgoyYUUraHhnWitZd2ozclltcTVMMXVBSkJkMXF4dTJ0NlBOWHdOaEdJWXR3TEJweWdSRUpz WVJBNGFrdCtLTmQ5Cjh6djNjUVRUbXhUYTgyNjVnbUJ6RHN4MitwSUdOUFZKa0xoMm1NU3pz VUQ3ZDhZQkdJV3BmVStxczFNK2k1dzQKdHhNbVA0a2lXaVozdW55ay9IRWpRL2VnMHZiSmho OFU5UW4yMTI2dWkwOGs1SHdFbEUvUlgzQk5ORlUwRHhKVQo5ZzBVWUZEeHVxeURQMEpWS1ZV ZVVrSXVLMVVaQStOWWI0RnlnaTZjNnpXSmwrd1d5TnhHMmFGOGhRS3JxUlhzClNvMUpFTG1U VmJaQ1lhTTlaQTNLbC96eDNDczFkZ210QlZFRTErditXVmUzeDhxWG5jcU1qK1VDOW1aemFh YVIKSC8xT2IzTHprL29ndVpIdDBBZmZhV1hvTXY3SjhuZDNHa29GbmxQZ1RYdm9ETStmRXpC Y1ZzSXl6dVVaRDhxQgpiRTI4MUlUdHlJSHh2TjJBN0FoaE9DZmdlV0FRUEJneHJXWGZxajhr K2pHRU9rUjN4ck80Qy9OK1hPRGVKRmlQClNCalpOR1VEL2tEdFBPTDNjUVR4dFhOV0JXT2hv Vjh5SE1abTlhWTNSNE9oR1BDNU5vZ0V1Q3JZeFN3UXZYZ0IKdHptQmxTZlc5UGtiWTZvY3dO UVRDdk5URjU4NUd1YlJvWFNwWDV1ODZZeUEySjRlSjBhUHhjSUJpcnBTWDQ0MQpUSzZtOEgx d0Zxaz0KPXpEZFAKLS0tLS1FTkQgUEdQIFBVQkxJQyBLRVkgQkxPQ0stLS0tLQo= Message-ID: <8236dcd5-fa4f-130c-6e43-d3aed2e79e4a@arm.com> Date: Mon, 4 Jan 2021 10:44:13 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <20201222134528.793-1-pete@akeo.ie> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: quoted-printable On 12/22/20 2:45 PM, Pete Batard wrote: > Due to the method in which NV variables are stored on removable media > for the Raspberry Pi platform, and the manner in which we dump updated > variables right before reset, it is possible, and has been repeatedly > demonstrated with SSD-based USB 3.0 devices, that the updated file does > not actually end up being written to permanent storage, due to the > device write-cache not having enough time to be flushed before reset. >=20 > To compensate for this, since we don't know of a generic method that > would allow turning off USB mass storage devices write cache (and also > because we are seeing an issue that seems related for SD-based media), > we add a new reset delay PCD, which can be set by the user, and which > we also set as required when NV variables are being dumped. >=20 > Our testing show that, with more than 3 seconds of extra delay, the > storage media has enough time to finalize its internal write, thus > solving the issue of configuration changes not being persisted. >=20 > Signed-off-by: Pete Batard > --- > Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockServiceDxe.c = | 24 ++++++++++++++++++++ > Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockServiceDxe.inf= | 1 + > Platform/RaspberryPi/Library/ResetLib/ResetLib.c = | 11 +++++++++ > Platform/RaspberryPi/Library/ResetLib/ResetLib.inf = | 5 ++++ > Platform/RaspberryPi/RPi3/RPi3.dsc = | 6 +++++ > Platform/RaspberryPi/RPi4/RPi4.dsc = | 6 +++++ > Platform/RaspberryPi/RaspberryPi.dec = | 1 + > 7 files changed, 54 insertions(+) >=20 > diff --git a/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockSe= rviceDxe.c b/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockServ= iceDxe.c > index 07f3f1c24295..4071a3fca468 100644 > --- a/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockServiceDx= e.c > +++ b/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockServiceDx= e.c > @@ -10,6 +10,18 @@ > =20 > #include "VarBlockService.h" > =20 > +// > +// Minimum delay to enact before reset, when variables are dirty (in =CE= =BCs). > +// Needed to ensure that SSD-based USB 3.0 devices have time to flush = their > +// write cache after updating the NV vars. A much smaller delay is app= lied > +// on Pi 3 compared to Pi 4, as we haven't had reports of issues there= yet. > +// > +#if (RPI_MODEL =3D=3D 3) > +#define PLATFORM_RESET_DELAY 500000 > +#else > +#define PLATFORM_RESET_DELAY 3500000 > +#endif > + > VOID *mSFSRegistration; > =20 > =20 > @@ -154,6 +166,7 @@ DumpVars ( > ) > { > EFI_STATUS Status; > + RETURN_STATUS PcdStatus; > =20 > if (mFvInstance->Device =3D=3D NULL) { > DEBUG ((DEBUG_INFO, "Variable store not found?\n")); > @@ -173,6 +186,17 @@ DumpVars ( > } > =20 > DEBUG ((DEBUG_INFO, "Variables dumped!\n")); > + > + // > + // Add a reset delay to give time for slow/cached devices > + // to flush the NV variables write to permanent storage. > + // But only do so if this won't reduce an existing user-set delay. > + // > + if (PcdGet32 (PcdPlatformResetDelay) < PLATFORM_RESET_DELAY) { > + PcdStatus =3D PcdSet32S (PcdPlatformResetDelay, PLATFORM_RESET_DEL= AY); > + ASSERT_RETURN_ERROR (PcdStatus); > + } > + > mFvInstance->Dirty =3D FALSE; > } > =20 > diff --git a/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockSe= rviceDxe.inf b/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockSe= rviceDxe.inf > index ecfb8f85c9c1..c2edb25bd41d 100644 > --- a/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockServiceDx= e.inf > +++ b/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockServiceDx= e.inf > @@ -79,6 +79,7 @@ [Pcd] > gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase > gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase > gRaspberryPiTokenSpaceGuid.PcdNvStorageEventLogBase > + gRaspberryPiTokenSpaceGuid.PcdPlatformResetDelay > gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64 > =20 > [FeaturePcd] > diff --git a/Platform/RaspberryPi/Library/ResetLib/ResetLib.c b/Platfor= m/RaspberryPi/Library/ResetLib/ResetLib.c > index c62a92321ecb..4a50166dd63b 100644 > --- a/Platform/RaspberryPi/Library/ResetLib/ResetLib.c > +++ b/Platform/RaspberryPi/Library/ResetLib/ResetLib.c > @@ -16,6 +16,7 @@ > =20 > #include > #include > +#include > #include > #include > #include > @@ -44,6 +45,7 @@ LibResetSystem ( > ) > { > ARM_SMC_ARGS ArmSmcArgs; > + UINT32 Delay; > =20 > if (!EfiAtRuntime ()) { > /* > @@ -52,6 +54,15 @@ LibResetSystem ( > EfiEventGroupSignal (&gRaspberryPiEventResetGuid); > } > =20 > + Delay =3D PcdGet32 (PcdPlatformResetDelay); > + if (Delay !=3D 0) { > + DEBUG ((DEBUG_INFO, "Platform will be reset in %d.%d seconds...\n"= , > + Delay / 1000000, (Delay % 1000000) / 100000)); > + MicroSecondDelay (Delay); > + } Doesn't this cause a crash at runtime on the DEBUG build due to the fact that the UART is no longer 1:1 mapped? > + DEBUG ((DEBUG_INFO, "Platform %a.\n", > + (ResetType =3D=3D EfiResetShutdown) ? "shutdown" : "reset"))= ; > + > switch (ResetType) { > case EfiResetPlatformSpecific: > // Map the platform specific reset as reboot > diff --git a/Platform/RaspberryPi/Library/ResetLib/ResetLib.inf b/Platf= orm/RaspberryPi/Library/ResetLib/ResetLib.inf > index b02a06d9d0bf..9bdb94a52ebf 100644 > --- a/Platform/RaspberryPi/Library/ResetLib/ResetLib.inf > +++ b/Platform/RaspberryPi/Library/ResetLib/ResetLib.inf > @@ -33,8 +33,13 @@ [LibraryClasses] > DebugLib > BaseLib > ArmSmcLib > + PcdLib > + TimerLib > UefiLib > UefiRuntimeLib > =20 > [Guids] > gRaspberryPiEventResetGuid > + > +[Pcd] > + gRaspberryPiTokenSpaceGuid.PcdPlatformResetDelay ## CONSUMES > diff --git a/Platform/RaspberryPi/RPi3/RPi3.dsc b/Platform/RaspberryPi/= RPi3/RPi3.dsc > index 9408138d0a09..530b42796a0d 100644 > --- a/Platform/RaspberryPi/RPi3/RPi3.dsc > +++ b/Platform/RaspberryPi/RPi3/RPi3.dsc > @@ -508,6 +508,12 @@ [PcdsDynamicHii.common.DEFAULT] > gRaspberryPiTokenSpaceGuid.PcdFanOnGpio|L"FanOnGpio"|gConfigDxeFormS= etGuid|0x0|0 > gRaspberryPiTokenSpaceGuid.PcdFanTemp|L"FanTemp"|gConfigDxeFormSetGu= id|0x0|0 > =20 > + # > + # Reset-related. > + # > + > + gRaspberryPiTokenSpaceGuid.PcdPlatformResetDelay|L"ResetDelay"|gRasp= berryPiTokenSpaceGuid|0x0|0 > + > # > # Common UEFI ones. > # > diff --git a/Platform/RaspberryPi/RPi4/RPi4.dsc b/Platform/RaspberryPi/= RPi4/RPi4.dsc > index ddf4dd6a416e..5f8452aa0b76 100644 > --- a/Platform/RaspberryPi/RPi4/RPi4.dsc > +++ b/Platform/RaspberryPi/RPi4/RPi4.dsc > @@ -522,6 +522,12 @@ [PcdsDynamicHii.common.DEFAULT] > gRaspberryPiTokenSpaceGuid.PcdFanOnGpio|L"FanOnGpio"|gConfigDxeFormS= etGuid|0x0|0 > gRaspberryPiTokenSpaceGuid.PcdFanTemp|L"FanTemp"|gConfigDxeFormSetGu= id|0x0|60 > =20 > + # > + # Reset-related. > + # > + > + gRaspberryPiTokenSpaceGuid.PcdPlatformResetDelay|L"ResetDelay"|gRasp= berryPiTokenSpaceGuid|0x0|0 > + > # > # Common UEFI ones. > # > diff --git a/Platform/RaspberryPi/RaspberryPi.dec b/Platform/RaspberryP= i/RaspberryPi.dec > index c64c61930ea8..10723036aa31 100644 > --- a/Platform/RaspberryPi/RaspberryPi.dec > +++ b/Platform/RaspberryPi/RaspberryPi.dec > @@ -68,3 +68,4 @@ [PcdsFixedAtBuild, PcdsPatchableInModule, PcdsDynamic= , PcdsDynamicEx] > gRaspberryPiTokenSpaceGuid.PcdRamLimitTo3GB|0|UINT32|0x0000001A > gRaspberryPiTokenSpaceGuid.PcdFanOnGpio|0|UINT32|0x0000001C > gRaspberryPiTokenSpaceGuid.PcdFanTemp|0|UINT32|0x0000001D > + gRaspberryPiTokenSpaceGuid.PcdPlatformResetDelay|0|UINT32|0x0000001E >=20