From nobody Sat Nov 2 12:31:15 2024 Delivered-To: importer@patchew.org Received-SPF: none (zoho.com: 198.145.21.10 is neither permitted nor denied by domain of lists.01.org) client-ip=198.145.21.10; envelope-from=edk2-devel-bounces@lists.01.org; helo=ml01.01.org; Authentication-Results: mx.zoho.com; dkim=fail spf=none (zoho.com: 198.145.21.10 is neither permitted nor denied by domain of lists.01.org) smtp.mailfrom=edk2-devel-bounces@lists.01.org; Return-Path: Received: from ml01.01.org (ml01.01.org [198.145.21.10]) by mx.zohomail.com with SMTPS id 149154638241445.024485541612876; Thu, 6 Apr 2017 23:26:22 -0700 (PDT) Received: from [127.0.0.1] (localhost [IPv6:::1]) by ml01.01.org (Postfix) with ESMTP id 544E320D77DD0; Thu, 6 Apr 2017 23:26:21 -0700 (PDT) Received: from mail-pg0-x242.google.com (mail-pg0-x242.google.com [IPv6:2607:f8b0:400e:c05::242]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id 960542194233D for ; Thu, 6 Apr 2017 23:26:20 -0700 (PDT) Received: by mail-pg0-x242.google.com with SMTP id 79so13311173pgf.0 for ; Thu, 06 Apr 2017 23:26:20 -0700 (PDT) Received: from Phils-MBP-57025.fritz.box.fritz.box ([165.84.56.107]) by smtp.gmail.com with ESMTPSA id e70sm7124608pfh.84.2017.04.06.23.26.17 (version=TLS1 cipher=AES128-SHA bits=128/128); Thu, 06 Apr 2017 23:26:19 -0700 (PDT) X-Original-To: edk2-devel@lists.01.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=philjordan-eu.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=h//LacR9FtGUlbjwNJwAxCEj6DDc0qzzLd8oIz5fWAo=; b=BmQeuqtn9xb1F02tQUjr7CslQBS98Rc+FMtgNMu6HrfEV672iXI3cgToMC5DUrrzWK lrDHQPJicY4OgvjYH+xbEWcUPS5KIG5xUlNiuEiRHRs9R7KX46hXWzNVt7alFYcLsiqQ Y/NqOcsSNMxRSgnsFnGxeH5azMz9F5967fX2i7FJ3FS4pDPx+w6otTngjwL2kvIonbMd Hje2TpMX+pHw+1kOZy0HibZ1gr7zos3YFRRLbs8OySUk8Lbel/tWNUxMMEwrLVCaADTC 1Ld4si3Xn/zfz+oVw6t+QKc5zjSShHgIFZf3ykxNX/YylKg9J+44YqXs3Lj8kwTfe+9Q t2uw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=h//LacR9FtGUlbjwNJwAxCEj6DDc0qzzLd8oIz5fWAo=; b=U0mW0lzj39hqCObyVzdhFU/42mUbZg118iBCpG/LA454tyfR1h60hPd66Q2SUDoWIo JqT6M28EXEoyrzJYrrug4z3IUIj3vXnLlCl/eiaz4c23RNvmjIucvf19awujbZLrjJ7i /6bkeBINbENXdjlwxx5aDobXTJjk1kRULRHC41abB957ybdS1gMKixnRqFb75EZ/BpKt fiV3V3nLxEJIjLBX7x5QTJxBbW/huFDDzQ0Q2s/2d42W3GXaj5q3HcEklQkTZjR6avmZ 237q/AhQADX/7OImCBic2FBaZtUwjoHR+EPjTcXlJ+toxKT2NgRufQvl0P2XrYUMKe/8 54Qw== X-Gm-Message-State: AFeK/H20NMJ00Sh47Nywd61ge5ywORvGeWnSoGbMkcrxxSpEhFMkTERUOfYil9VyXTvbUg== X-Received: by 10.99.109.67 with SMTP id i64mr39234998pgc.56.1491546380064; Thu, 06 Apr 2017 23:26:20 -0700 (PDT) From: Phil Dennis-Jordan To: edk2-devel@lists.01.org Date: Fri, 7 Apr 2017 18:25:57 +1200 Message-Id: <1491546358-58572-3-git-send-email-lists@philjordan.eu> X-Mailer: git-send-email 2.3.2 (Apple Git-55) In-Reply-To: <1491546358-58572-1-git-send-email-lists@philjordan.eu> References: <1491546358-58572-1-git-send-email-lists@philjordan.eu> Subject: [edk2] [PATCH v5 2/3] OvmfPkg/QemuVideoDxe: Helper functions for unaligned port I/O. X-BeenThere: edk2-devel@lists.01.org X-Mailman-Version: 2.1.22 Precedence: list List-Id: EDK II Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jordan Justen , Phil Dennis-Jordan , Laszlo Ersek MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Errors-To: edk2-devel-bounces@lists.01.org Sender: "edk2-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZohoMail: RDKM_2 RSF_4 Z_629925259 SPT_0 Content-Type: text/plain; charset="utf-8" From: Phil Dennis-Jordan The VMWare SVGA display device implemented by Qemu (-vga vmware) uses an I/O-type BAR which is laid out such that some register offsets are not aligned to the read/write width with which they are expected to be accessed. (The register value port has an offset of 1 and requires 32 bit wide read/write access.) The EFI_PCI_IO_PROTOCOL's Io.Read/Io.Write functions do not support such unaligned I/O. Before a driver for this device can be added to QemuVideoDxe, helper functions for unaligned I/O are therefore required. This adds the functions UnalignedIoWrite32 and UnalignedIoRead32, based on IoLib's IoWrite32 and IoRead32, for the Ia32 and X64 architectures. Port I/O requires inline assembly, so implementations are provided for the GCC, ICC, and Microsoft compiler families. Such I/O is not possible on other architectures, a dummy (ASSERT()ing) implementation is therefore provided to satisfy the linker. Cc: Jordan Justen Cc: Laszlo Ersek Suggested-by: Jordan Justen Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Phil Dennis-Jordan Reviewed-by: Laszlo Ersek Reviewed-by: Jordan Justen --- Notes: v2: - Separate commit for the unaligned I/O helper functions. [Laszlo] - Dummy implementations return values despite ASSERT(). [Laszlo] - Build failure in ArmVirtPkg fixed. [Laszlo] - More consistent API docs and function ordering. =20 v3: - Fixed typos in commit message [Laszlo] - Added Suggested-by: tag [Laszlo] - Rewrapped comment lines to 79 chars [Laszlo] - Corrected whitespace in function calls [Laszlo] - EFIAPI dropped. [Laszlo] - Fixed return value in dummy UnsignedIoWrite32 [Laszlo] - Dropped "N" imm8 constraint in GCC inline asm [Laszlo] =20 v4, v5: (no changes) OvmfPkg/QemuVideoDxe/QemuVideoDxe.inf | 6 ++ OvmfPkg/QemuVideoDxe/UnalignedIoInternal.h | 59 +++++++++++++++ OvmfPkg/QemuVideoDxe/UnalignedIoGcc.c | 70 +++++++++++++++++ OvmfPkg/QemuVideoDxe/UnalignedIoIcc.c | 80 ++++++++++++++++++++ OvmfPkg/QemuVideoDxe/UnalignedIoMsc.c | 78 +++++++++++++++++++ OvmfPkg/QemuVideoDxe/UnalignedIoUnsupported.c | 66 ++++++++++++++++ 6 files changed, 359 insertions(+) diff --git a/OvmfPkg/QemuVideoDxe/QemuVideoDxe.inf b/OvmfPkg/QemuVideoDxe/Q= emuVideoDxe.inf index affb6ffd88e0..346a5aed94fa 100644 --- a/OvmfPkg/QemuVideoDxe/QemuVideoDxe.inf +++ b/OvmfPkg/QemuVideoDxe/QemuVideoDxe.inf @@ -41,6 +41,12 @@ [Sources.common] =20 [Sources.Ia32, Sources.X64] VbeShim.c + UnalignedIoGcc.c | GCC + UnalignedIoMsc.c | MSFT + UnalignedIoIcc.c | INTEL + +[Sources.IPF, Sources.EBC, Sources.ARM, Sources.AARCH64] + UnalignedIoUnsupported.c =20 [Packages] MdePkg/MdePkg.dec diff --git a/OvmfPkg/QemuVideoDxe/UnalignedIoInternal.h b/OvmfPkg/QemuVideo= Dxe/UnalignedIoInternal.h new file mode 100644 index 000000000000..234de6c21bd1 --- /dev/null +++ b/OvmfPkg/QemuVideoDxe/UnalignedIoInternal.h @@ -0,0 +1,59 @@ +/** @file + Unaligned port I/O, with implementations for various x86 compilers and a + dummy for platforms which do not support unaligned port I/O. + + Copyright (c) 2017, Phil Dennis-Jordan.
+ This program and the accompanying materials are licensed and made availa= ble + under the terms and conditions of the BSD License which accompanies this + distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + +#ifndef _UNALIGNED_IO_INTERNAL_H_ +#define _UNALIGNED_IO_INTERNAL_H_ + +/** + Performs a 32-bit write to the specified, possibly unaligned I/O-type ad= dress. + + Writes the 32-bit I/O port specified by Port with the value specified by= Value + and returns Value. This function must guarantee that all I/O read and wr= ite + operations are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port I/O port address + @param[in] Value 32-bit word to write + + @return The value written to the I/O port. + +**/ +UINT32 +UnalignedIoWrite32 ( + IN UINTN Port, + IN UINT32 Value + ); + +/** + Reads a 32-bit word from the specified, possibly unaligned I/O-type addr= ess. + + Reads the 32-bit I/O port specified by Port. The 32-bit read value is + returned. This function must guarantee that all I/O read and write opera= tions + are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port The I/O port to read. + + @return The value read. + +**/ +UINT32 +UnalignedIoRead32 ( + IN UINTN Port + ); + +#endif diff --git a/OvmfPkg/QemuVideoDxe/UnalignedIoGcc.c b/OvmfPkg/QemuVideoDxe/U= nalignedIoGcc.c new file mode 100644 index 000000000000..105d55d3b903 --- /dev/null +++ b/OvmfPkg/QemuVideoDxe/UnalignedIoGcc.c @@ -0,0 +1,70 @@ +/** @file + Unaligned Port I/O. This file has compiler specifics for GCC as there is= no + ANSI C standard for doing IO. + + Based on IoLibGcc.c. + + Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.
+ This program and the accompanying materials are licensed and made availa= ble + under the terms and conditions of the BSD License which accompanies this + distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + + +#include "UnalignedIoInternal.h" + +/** + Performs a 32-bit write to the specified, possibly unaligned I/O-type + address. + + Writes the 32-bit I/O port specified by Port with the value specified by + Value and returns Value. This function must guarantee that all I/O read = and + write operations are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port I/O port address + @param[in] Value 32-bit word to write + + @return The value written to the I/O port. + +**/ +UINT32 +UnalignedIoWrite32 ( + IN UINTN Port, + IN UINT32 Value + ) +{ + __asm__ __volatile__ ( "outl %0, %1" : : "a" (Value), "d" ((UINT16)Port)= ); + return Value; +} + +/** + Reads a 32-bit word from the specified, possibly unaligned I/O-type addr= ess. + + Reads the 32-bit I/O port specified by Port. The 32-bit read value is + returned. This function must guarantee that all I/O read and write opera= tions + are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port The I/O port to read. + + @return The value read. + +**/ +UINT32 +UnalignedIoRead32 ( + IN UINTN Port + ) +{ + UINT32 Data; + __asm__ __volatile__ ( "inl %1, %0" : "=3Da" (Data) : "d" ((UINT16)Port)= ); + return Data; +} + diff --git a/OvmfPkg/QemuVideoDxe/UnalignedIoIcc.c b/OvmfPkg/QemuVideoDxe/U= nalignedIoIcc.c new file mode 100644 index 000000000000..79f3e446ddba --- /dev/null +++ b/OvmfPkg/QemuVideoDxe/UnalignedIoIcc.c @@ -0,0 +1,80 @@ +/** @file + Unaligned port I/O. This file has compiler specifics for ICC as there + is no ANSI C standard for doing IO. + + Based on IoLibIcc.c. + + Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.
+ This program and the accompanying materials are licensed and made availa= ble + under the terms and conditions of the BSD License which accompanies this + distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + + +#include "UnalignedIoInternal.h" + +/** + Performs a 32-bit write to the specified, possibly unaligned I/O-type + address. + + Writes the 32-bit I/O port specified by Port with the value specified by + Value and returns Value. This function must guarantee that all I/O read = and + write operations are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port I/O port address + @param[in] Value 32-bit word to write + + @return The value written to the I/O port. + +**/ +UINT32 +UnalignedIoWrite32 ( + IN UINTN Port, + IN UINT32 Value + ) +{ + __asm { + mov eax, dword ptr [Value] + mov dx, word ptr [Port] + out dx, eax + } + + return Value; +} + +/** + Reads a 32-bit word from the specified, possibly unaligned I/O-type addr= ess. + + Reads the 32-bit I/O port specified by Port. The 32-bit read value is + returned. This function must guarantee that all I/O read and write opera= tions + are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port The I/O port to read. + + @return The value read. + +**/ +UINT32 +UnalignedIoRead32 ( + IN UINTN Port + ) +{ + UINT32 Data; + + __asm { + mov dx, word ptr [Port] + in eax, dx + mov dword ptr [Data], eax + } + + return Data; +} diff --git a/OvmfPkg/QemuVideoDxe/UnalignedIoMsc.c b/OvmfPkg/QemuVideoDxe/U= nalignedIoMsc.c new file mode 100644 index 000000000000..a466baee8486 --- /dev/null +++ b/OvmfPkg/QemuVideoDxe/UnalignedIoMsc.c @@ -0,0 +1,78 @@ +/** @file + Unaligned port I/O. This file has compiler specifics for Microsoft C as = there + is no ANSI C standard for doing IO. + + Based on IoLibMsc.c + + Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.
+ This program and the accompanying materials are licensed and made availa= ble + under the terms and conditions of the BSD License which accompanies this + distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + + +#include "UnalignedIoInternal.h" + +unsigned long _inpd (unsigned short port); +unsigned long _outpd (unsigned short port, unsigned long dataword ); +void _ReadWriteBarrier (void); + +/** + Performs a 32-bit write to the specified, possibly unaligned I/O-type + address. + + Writes the 32-bit I/O port specified by Port with the value specified by + Value and returns Value. This function must guarantee that all I/O read = and + write operations are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port I/O port address + @param[in] Value 32-bit word to write + + @return The value written to the I/O port. + +**/ +UINT32 +UnalignedIoWrite32 ( + IN UINTN Port, + IN UINT32 Value + ) +{ + _ReadWriteBarrier (); + _outpd ((UINT16)Port, Value); + _ReadWriteBarrier (); + return Value; +} + +/** + Reads a 32-bit word from the specified, possibly unaligned I/O-type addr= ess. + + Reads the 32-bit I/O port specified by Port. The 32-bit read value is + returned. This function must guarantee that all I/O read and write opera= tions + are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port The I/O port to read. + + @return The value read. + +**/ +UINT32 +UnalignedIoRead32 ( + IN UINTN Port + ) +{ + UINT32 Value; + + _ReadWriteBarrier (); + Value =3D _inpd ((UINT16)Port); + _ReadWriteBarrier (); + return Value; +} diff --git a/OvmfPkg/QemuVideoDxe/UnalignedIoUnsupported.c b/OvmfPkg/QemuVi= deoDxe/UnalignedIoUnsupported.c new file mode 100644 index 000000000000..57560ab38fcf --- /dev/null +++ b/OvmfPkg/QemuVideoDxe/UnalignedIoUnsupported.c @@ -0,0 +1,66 @@ +/** @file + Unaligned port I/O dummy implementation for platforms which do not suppo= rt it. + + Copyright (c) 2017, Phil Dennis-Jordan.
+ This program and the accompanying materials are licensed and made availa= ble + under the terms and conditions of the BSD License which accompanies this + distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMP= LIED. + +**/ + + +#include +#include "UnalignedIoInternal.h" + +/** + Performs a 32-bit write to the specified, possibly unaligned I/O-type + address. + + Writes the 32-bit I/O port specified by Port with the value specified by + Value and returns Value. This function must guarantee that all I/O read = and + write operations are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port I/O port address + @param[in] Value 32-bit word to write + + @return The value written to the I/O port. + +**/ +UINT32 +UnalignedIoWrite32 ( + IN UINTN Port, + IN UINT32 Value + ) +{ + ASSERT (FALSE); + return Value; +} + +/** + Reads a 32-bit word from the specified, possibly unaligned I/O-type addr= ess. + + Reads the 32-bit I/O port specified by Port. The 32-bit read value is + returned. This function must guarantee that all I/O read and write opera= tions + are serialized. + + If 32-bit unaligned I/O port operations are not supported, then ASSERT(). + + @param[in] Port The I/O port to read. + + @return The value read. + +**/ +UINT32 +UnalignedIoRead32 ( + IN UINTN Port + ) +{ + ASSERT (FALSE); + return 0; +} --=20 2.3.2 (Apple Git-55) _______________________________________________ edk2-devel mailing list edk2-devel@lists.01.org https://lists.01.org/mailman/listinfo/edk2-devel