jeans/LibreELEC.tv
jeans/LibreELEC.tv
1
0
Fork 0
mirror of https://github.com/LibreELEC/LibreELEC.tv.git synced 2025-07-30 14:16:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #10253 from heitbaum/mesa12.2

Browse Source 
[le12.2] update mesa 25.0.7
This commit is contained in:
Matthias Reichl 2025-07-23 12:26:32 +02:00 committed by GitHub
commit 9586018b60
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 230 additions and 785 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
config/graphic
View File

@ -45,7 +45,7 @@ get_graphicdrivers() {
fi
if listcontains "${GRAPHIC_DRIVERS}" "etnaviv"; then
GALLIUM_DRIVERS+=" etnaviv kmsro"
GALLIUM_DRIVERS+=" etnaviv"
V4L2_SUPPORT="yes"
VAAPI_SUPPORT="no"
VDPAU_SUPPORT="no"
@ -74,11 +74,7 @@ get_graphicdrivers() {
fi
if listcontains "${GRAPHIC_DRIVERS}" "lima"; then
GALLIUM_DRIVERS+=" kmsro lima"
V4L2_SUPPORT="yes"
fi
if listcontains "${GRAPHIC_DRIVERS}" "mali"; then
GALLIUM_DRIVERS+=" lima"
V4L2_SUPPORT="yes"
fi
@ -94,7 +90,7 @@ get_graphicdrivers() {
fi
if listcontains "${GRAPHIC_DRIVERS}" "panfrost"; then
GALLIUM_DRIVERS+=" kmsro panfrost"
GALLIUM_DRIVERS+=" panfrost"
VULKAN_DRIVERS_MESA+=" panfrost"
V4L2_SUPPORT="yes"
fi
@ -125,7 +121,7 @@ get_graphicdrivers() {
fi
if listcontains "${GRAPHIC_DRIVERS}" "vc4"; then
GALLIUM_DRIVERS+=" vc4 v3d kmsro"
GALLIUM_DRIVERS+=" vc4 v3d"
VULKAN_DRIVERS_MESA+=" broadcom"
V4L2_SUPPORT="yes"
VAAPI_SUPPORT="no"

70
licenses/LLVM.txt Normal file
View File

@ -0,0 +1,70 @@
==============================================================================
LLVM Release License
==============================================================================
University of Illinois/NCSA
Open Source License
Copyright (c) 2003-2014 University of Illinois at Urbana-Champaign.
All rights reserved.
Developed by:
LLVM Team
University of Illinois at Urbana-Champaign
http://llvm.org
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal with
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimers.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimers in the
documentation and/or other materials provided with the distribution.
* Neither the names of the LLVM Team, University of Illinois at
Urbana-Champaign, nor the names of its contributors may be used to
endorse or promote products derived from this Software without specific
prior written permission.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
SOFTWARE.
==============================================================================
Copyrights and Licenses for Third Party Software Distributed with LLVM:
==============================================================================
The LLVM software contains code written by third parties. Such software will
have its own individual LICENSE.TXT file in the directory in which it appears.
This file will describe the copyrights, license, and restrictions which apply
to that code.
The disclaimer of warranty in the University of Illinois Open Source License
applies to all code in the LLVM Distribution, and nothing in any of the
other licenses gives permission to use the names of the LLVM Team or the
University of Illinois to endorse or promote products derived from this
Software.
The following pieces of software have additional or alternate copyrights,
licenses, and/or restrictions:
Program Directory
------- ---------
Autoconf llvm/autoconf
llvm/projects/ModuleMaker/autoconf
Google Test llvm/utils/unittest/googletest
OpenBSD regex llvm/lib/Support/{reg*, COPYRIGHT.regex}
pyyaml tests llvm/test/YAMLParser/{*.data, LICENSE.TXT}
ARM contributions llvm/lib/Target/ARM/LICENSE.TXT
md5 contributions llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h

29
packages/devel/libclc/package.mk Normal file
View File

@ -0,0 +1,29 @@
# SPDX-License-Identifier: GPL-2.0-only
# Copyright (C) 2024-present Team LibreELEC (https://libreelec.tv)
PKG_NAME="libclc"
PKG_VERSION="$(get_pkg_version llvm)"
PKG_LICENSE="Apache-2.0"
PKG_URL=""
PKG_DEPENDS_HOST="toolchain:host llvm:host"
PKG_LONGDESC="Low-Level Virtual Machine (LLVM) is a compiler infrastructure."
PKG_DEPENDS_UNPACK+=" llvm"
PKG_PATCH_DIRS+=" $(get_pkg_directory llvm)/patches"
PKG_TOOLCHAIN="cmake"
unpack() {
mkdir -p ${PKG_BUILD}
tar --strip-components=1 -xf ${SOURCES}/llvm/llvm-${PKG_VERSION}.tar.xz -C ${PKG_BUILD}
}
pre_configure() {
PKG_CMAKE_SCRIPT="${PKG_BUILD}/libclc/CMakeLists.txt"
}
pre_configure_host() {
LIBCLC_TARGETS_TO_BUILD="spirv64-mesa3d-"
mkdir -p "${PKG_BUILD}/.${HOST_NAME}"
cd ${PKG_BUILD}/.${HOST_NAME}
PKG_CMAKE_OPTS_HOST="-DLIBCLC_TARGETS_TO_BUILD=${LIBCLC_TARGETS_TO_BUILD}"
}

42
packages/graphics/mesa/package.mk
View File

@ -3,12 +3,13 @@
# Copyright (C) 2018-present Team LibreELEC (https://libreelec.tv)
PKG_NAME="mesa"
PKG_VERSION="24.0.9"
PKG_SHA256="51aa686ca4060e38711a9e8f60c8f1efaa516baf411946ed7f2c265cd582ca4c"
PKG_VERSION="25.0.7"
PKG_SHA256="592272df3cf01e85e7db300c449df5061092574d099da275d19e97ef0510f8a6"
PKG_LICENSE="OSS"
PKG_SITE="http://www.mesa3d.org/"
PKG_URL="https://mesa.freedesktop.org/archive/mesa-${PKG_VERSION}.tar.xz"
PKG_DEPENDS_TARGET="toolchain expat libdrm Mako:host"
PKG_DEPENDS_HOST="toolchain:host expat:host libclc:host libdrm:host Mako:host pyyaml:host spirv-tools:host"
PKG_DEPENDS_TARGET="toolchain expat libdrm Mako:host pyyaml:host"
PKG_LONGDESC="Mesa is a 3-D graphics library with an API."
get_graphicdrivers
@ -17,9 +18,16 @@ if [ "${DEVICE}" = "Dragonboard" ]; then
PKG_DEPENDS_TARGET+=" libarchive libxml2 lua54"
fi
PKG_MESON_OPTS_HOST="-Dglvnd=disabled \
-Dgallium-drivers=iris \
-Dgallium-vdpau=disabled \
-Dplatforms= \
-Dglx=disabled \
-Dvulkan-drivers="
PKG_MESON_OPTS_TARGET="-Dgallium-drivers=${GALLIUM_DRIVERS// /,} \
-Dgallium-extra-hud=false \
-Dgallium-omx=disabled \
-Dgallium-rusticl=false \
-Dgallium-nine=false \
-Dgallium-opencl=disabled \
-Dshader-cache=enabled \
@ -32,31 +40,37 @@ PKG_MESON_OPTS_TARGET="-Dgallium-drivers=${GALLIUM_DRIVERS// /,} \
-Dlmsensors=disabled \
-Dbuild-tests=false \
-Ddraw-use-llvm=false \
-Dselinux=false \
-Dmicrosoft-clc=disabled \
-Dosmesa=false"
if [ "${DISPLAYSERVER}" = "x11" ]; then
PKG_DEPENDS_TARGET+=" xorgproto libXext libXdamage libXfixes libXxf86vm libxcb libX11 libxshmfence libXrandr"
export X11_INCLUDES=
PKG_MESON_OPTS_TARGET+=" -Dplatforms=x11 \
-Ddri3=enabled \
-Dglx=dri"
elif [ "${DISPLAYSERVER}" = "wl" ]; then
PKG_DEPENDS_TARGET+=" wayland wayland-protocols"
PKG_MESON_OPTS_TARGET+=" -Dplatforms=wayland \
-Ddri3=disabled \
-Dglx=disabled"
else
PKG_MESON_OPTS_TARGET+=" -Dplatforms="" \
-Ddri3=disabled \
-Dglx=disabled"
fi
if listcontains "${GRAPHIC_DRIVERS}" "etnaviv"; then
PKG_DEPENDS_TARGET+=" pycparser:host"
fi
if listcontains "${GRAPHIC_DRIVERS}" "iris"; then
PKG_DEPENDS_TARGET+=" mesa:host"
PKG_MESON_OPTS_TARGET+=" -Dmesa-clc=system"
fi
if listcontains "${GRAPHIC_DRIVERS}" "(nvidia|nvidia-ng)"; then
PKG_DEPENDS_TARGET+=" libglvnd"
PKG_MESON_OPTS_TARGET+=" -Dglvnd=true"
PKG_MESON_OPTS_TARGET+=" -Dglvnd=enabled"
else
PKG_MESON_OPTS_TARGET+=" -Dglvnd=false"
PKG_MESON_OPTS_TARGET+=" -Dglvnd=disabled"
fi
if [ "${LLVM_SUPPORT}" = "yes" ]; then
@ -76,7 +90,7 @@ fi
if [ "${VAAPI_SUPPORT}" = "yes" ] && listcontains "${GRAPHIC_DRIVERS}" "(r600|radeonsi)"; then
PKG_DEPENDS_TARGET+=" libva"
PKG_MESON_OPTS_TARGET+=" -Dgallium-va=enabled \
-Dvideo-codecs=vc1dec,h264dec,h264enc,h265dec,h265enc"
-Dvideo-codecs=vc1dec,h264dec,h264enc,h265dec,h265enc,av1dec,av1enc,vp9dec"
else
PKG_MESON_OPTS_TARGET+=" -Dgallium-va=disabled"
fi
@ -99,3 +113,9 @@ if [ "${VULKAN_SUPPORT}" = "yes" ]; then
else
PKG_MESON_OPTS_TARGET+=" -Dvulkan-drivers="
fi
makeinstall_host() {
mkdir -p "${TOOLCHAIN}/bin"
cp -a src/compiler/clc/mesa_clc "${TOOLCHAIN}/bin"
cp -a src/compiler/spirv/vtn_bindgen "${TOOLCHAIN}/bin"
}

6
packages/graphics/vulkan/spirv-headers/package.mk → packages/graphics/spirv-headers/package.mk
View File

@ -6,8 +6,10 @@ PKG_NAME="spirv-headers"
# The SPIRV-Headers pkg_version needs to match the compatible (known_good) glslang pkg_version.
# https://raw.githubusercontent.com/KhronosGroup/glslang/${PKG_VERSION}/known_good.json
# When updating glslang pkg_version please update to the known_good spirv-headers pkg_version.
PKG_VERSION="8b246ff75c6615ba4532fe4fde20f1be090c3764"
PKG_SHA256="cfeed5f9a97d12a9761a26e7f5bd10fedb1a8ce92033075151ae3bc7206fc229"
# When updating spirv-llvm-translator pkg_version validate the minimum githash from
# https://github.com/KhronosGroup/SPIRV-LLVM-Translator/blob/main/spirv-headers-tag.conf
PKG_VERSION="2a611a970fdbc41ac2e3e328802aed9985352dca"
PKG_SHA256="c2225a49c3d7efa5c4f4ce4a6b42081e6ea3daca376f3353d9d7c2722d77a28a"
PKG_LICENSE="Apache-2.0"
PKG_SITE="https://github.com/KhronosGroup/SPIRV-headers"
PKG_URL="https://github.com/KhronosGroup/SPIRV-headers/archive/${PKG_VERSION}.tar.gz"

11
packages/graphics/spirv-llvm-translator/package.mk Normal file
View File

@ -0,0 +1,11 @@
# SPDX-License-Identifier: GPL-2.0-only
# Copyright (C) 2024-present Team LibreELEC (https://libreelec.tv)
PKG_NAME="spirv-llvm-translator"
PKG_VERSION="17.0.14"
PKG_SHA256="0aa498daca090793d87ba24a61b01b6dfdcd00ea960611bd2dca1101333b7d88"
PKG_LICENSE="LLVM"
PKG_SITE="https://github.com/KhronosGroup/SPIRV-LLVM-Translator"
PKG_URL="https://github.com/KhronosGroup/SPIRV-LLVM-Translator/archive/v${PKG_VERSION}.tar.gz"
PKG_LONGDESC="SPIRV-LLVM-Translator"
PKG_TOOLCHAIN="manual"

17
packages/graphics/vulkan/spirv-tools/package.mk → packages/graphics/spirv-tools/package.mk
View File

@ -6,11 +6,20 @@ PKG_NAME="spirv-tools"
# The SPIRV-Tools pkg_version needs to match the compatible (known_good) glslang pkg_version.
# https://raw.githubusercontent.com/KhronosGroup/glslang/${PKG_VERSION}/known_good.json
# When updating glslang pkg_version please update to the known_good spirv-tools pkg_version.
PKG_VERSION="04896c462d9f3f504c99a4698605b6524af813c1"
PKG_SHA256="c0d01e758a543b3a358cb97af02c6817ebd3f5ff13a2edf9fb220646a3d67999"
PKG_VERSION="33e02568181e3312f49a3cf33df470bf96ef293a"
PKG_SHA256="44d1005880c583fc00a0fb41c839214c68214b000ea8dcb54d352732fee600ff"
PKG_LICENSE="Apache-2.0"
PKG_SITE="https://github.com/KhronosGroup/SPIRV-Tools"
PKG_URL="https://github.com/KhronosGroup/SPIRV-Tools/archive/${PKG_VERSION}.tar.gz"
PKG_DEPENDS_HOST=""
PKG_DEPENDS_HOST="toolchain:host"
PKG_DEPENDS_UNPACK="spirv-headers"
PKG_LONGDESC="The SPIR-V Tools project provides an API and commands for processing SPIR-V modules."
PKG_TOOLCHAIN="manual"
PKG_CMAKE_OPTS_HOST="-DSPIRV_SKIP_TESTS=ON"
post_unpack() {
mkdir -p ${PKG_BUILD}/external/spirv-headers
tar --strip-components=1 \
-xf "${SOURCES}/spirv-headers/spirv-headers-$(get_pkg_version spirv-headers).tar.gz" \
-C "${PKG_BUILD}/external/spirv-headers"
}

13
packages/graphics/vulkan/glslang/package.mk
View File

@ -6,8 +6,8 @@ PKG_NAME="glslang"
# The SPIRV-Tools & SPIRV-Headers pkg_version/s need to match the compatible (known_good) glslang pkg_version.
# https://raw.githubusercontent.com/KhronosGroup/glslang/${PKG_VERSION}/known_good.json
# When updating glslang pkg_version please update to the known_good spirv-tools & spirv-headers pkg_version/s.
PKG_VERSION="14.1.0"
PKG_SHA256="b5e4c36d60eda7613f36cfee3489c6f507156829c707e1ecd7f48ca45b435322"
PKG_VERSION="15.4.0"
PKG_SHA256="b16c78e7604b9be9f546ee35ad8b6db6f39bbbbfb19e8d038b6fe2ea5bba4ff4"
PKG_LICENSE="Apache-2.0"
PKG_SITE="https://github.com/KhronosGroup/glslang"
PKG_URL="https://github.com/KhronosGroup/glslang/archive/${PKG_VERSION}.tar.gz"
@ -28,9 +28,14 @@ PKG_CMAKE_OPTS_COMMON="-DBUILD_EXTERNAL=ON \
post_unpack() {
# Enables SPIR-V optimizer capability needed for ENABLE_OPT CMake build option
mkdir -p ${PKG_BUILD}/External/spirv-tools
tar --strip-components=1 \
-xf "${SOURCES}/spirv-tools/spirv-tools-$(get_pkg_version spirv-tools).tar.gz" \
-C "${PKG_BUILD}/External/spirv-tools"
mkdir -p ${PKG_BUILD}/External/spirv-tools/external/spirv-headers
cp -R $(get_build_dir spirv-tools)/* ${PKG_BUILD}/External/spirv-tools
cp -R $(get_build_dir spirv-headers)/* ${PKG_BUILD}/External/spirv-tools/external/spirv-headers
tar --strip-components=1 \
-xf "${SOURCES}/spirv-headers/spirv-headers-$(get_pkg_version spirv-headers).tar.gz" \
-C "${PKG_BUILD}/External/spirv-tools/external/spirv-headers"
}
pre_configure_host() {

25
packages/lang/llvm/package.mk
View File

@ -13,6 +13,10 @@ PKG_DEPENDS_TARGET="toolchain llvm:host zlib"
PKG_LONGDESC="Low-Level Virtual Machine (LLVM) is a compiler infrastructure."
PKG_TOOLCHAIN="cmake"
if listcontains "${GRAPHIC_DRIVERS}" "iris"; then
PKG_DEPENDS_UNPACK="spirv-headers spirv-llvm-translator"
fi
PKG_CMAKE_OPTS_COMMON="-DLLVM_INCLUDE_TOOLS=ON \
-DLLVM_BUILD_TOOLS=OFF \
-DLLVM_BUILD_UTILS=OFF \
@ -41,8 +45,21 @@ PKG_CMAKE_OPTS_COMMON="-DLLVM_INCLUDE_TOOLS=ON \
-DLLVM_ENABLE_RTTI=ON \
-DLLVM_ENABLE_UNWIND_TABLES=OFF \
-DLLVM_ENABLE_Z3_SOLVER=OFF \
-DLLVM_SPIRV_INCLUDE_TESTS=OFF \
-DCMAKE_SKIP_RPATH=ON"
post_unpack() {
if listcontains "${GRAPHIC_DRIVERS}" "iris"; then
mkdir -p "${PKG_BUILD}"/llvm/projects/{SPIRV-Headers,SPIRV-LLVM-Translator}
tar --strip-components=1 \
-xf "${SOURCES}/spirv-headers/spirv-headers-$(get_pkg_version spirv-headers).tar.gz" \
-C "${PKG_BUILD}/llvm/projects/SPIRV-Headers"
tar --strip-components=1 \
-xf "${SOURCES}/spirv-llvm-translator/spirv-llvm-translator-$(get_pkg_version spirv-llvm-translator).tar.gz" \
-C "${PKG_BUILD}/llvm/projects/SPIRV-LLVM-Translator"
fi
}
pre_configure() {
PKG_CMAKE_SCRIPT=${PKG_BUILD}/llvm/CMakeLists.txt
}
@ -84,12 +101,20 @@ pre_configure_host() {
post_make_host() {
ninja ${NINJA_OPTS} llvm-config llvm-tblgen
if listcontains "${GRAPHIC_DRIVERS}" "iris"; then
ninja ${NINJA_OPTS} llvm-as llvm-link llvm-spirv opt
fi
}
post_makeinstall_host() {
mkdir -p ${TOOLCHAIN}/bin
cp -a bin/llvm-config ${TOOLCHAIN}/bin
cp -a bin/llvm-tblgen ${TOOLCHAIN}/bin
if listcontains "${GRAPHIC_DRIVERS}" "iris"; then
cp -a bin/{llvm-as,llvm-link,llvm-spirv,opt} "${TOOLCHAIN}/bin"
fi
}
pre_configure_target() {

17
packages/python/devel/pycparser/package.mk Normal file
View File

@ -0,0 +1,17 @@
# SPDX-License-Identifier: GPL-2.0-only
# Copyright (C) 2024-present Team LibreELEC (https://libreelec.tv)
PKG_NAME="pycparser"
PKG_VERSION="2.22"
PKG_SHA256="491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"
PKG_LICENSE="BSD-3-Clause"
PKG_SITE="https://pypi.org/project/pycparser/"
PKG_URL="https://files.pythonhosted.org/packages/source/${PKG_NAME:0:1}/${PKG_NAME}/${PKG_NAME}-${PKG_VERSION}.tar.gz"
PKG_DEPENDS_HOST="Python3:host setuptools:host"
PKG_LONGDESC="Complete C99 parser in pure Python"
PKG_TOOLCHAIN="manual"
makeinstall_host() {
export DONT_BUILD_LEGACY_PYC=1
exec_thread_safe python3 setup.py install --prefix="${TOOLCHAIN}"
}

17
packages/python/devel/pyyaml/package.mk Normal file
View File

@ -0,0 +1,17 @@
# SPDX-License-Identifier: GPL-2.0-only
# Copyright (C) 2024-present Team LibreELEC (https://libreelec.tv)
PKG_NAME="pyyaml"
PKG_VERSION="6.0.2"
PKG_SHA256="d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"
PKG_LICENSE="MIT"
PKG_SITE="https://pypi.org/project/PyYAML/"
PKG_URL="https://files.pythonhosted.org/packages/source/${PKG_NAME:0:1}/${PKG_NAME}/${PKG_NAME}-${PKG_VERSION}.tar.gz"
PKG_DEPENDS_HOST="Python3:host setuptools:host"
PKG_LONGDESC="YAML parser and emitter for Python"
PKG_TOOLCHAIN="manual"
makeinstall_host() {
export DONT_BUILD_LEGACY_PYC=1
exec_thread_safe python3 setup.py install --prefix="${TOOLCHAIN}"
}

43
projects/RPi/patches/mesa/0001-gallium-Add-kmsro-drivers-for-RP1-DSI-DPI-and-VEC-de.patch
View File

@ -1,43 +0,0 @@
From 54cc206be2d48916862d7e264e886f58b27dd653 Mon Sep 17 00:00:00 2001
From: Dave Stevenson <dave.stevenson@raspberrypi.com>
Date: Thu, 5 Oct 2023 19:32:10 +0100
Subject: [PATCH 1/3] gallium: Add kmsro drivers for RP1 DSI, DPI, and VEC
devices
Signed-off-by: Dave Stevenson <dave.stevenson@raspberrypi.com>
---
src/gallium/targets/dri/meson.build | 3 +++
src/gallium/targets/dri/target.c | 3 +++
2 files changed, 6 insertions(+)
diff --git a/src/gallium/targets/dri/meson.build b/src/gallium/targets/dri/meson.build
index 66619bba0db..443923772e8 100644
--- a/src/gallium/targets/dri/meson.build
+++ b/src/gallium/targets/dri/meson.build
@@ -68,6 +68,9 @@ libgallium_dri = shared_library(
foreach d : [[with_gallium_kmsro, [
'armada-drm_dri.so',
+ 'drm-rp1-dpi_dri.so',
+ 'drm-rp1-dsi_dri.so',
+ 'drm-rp1-vec_dri.so',
'exynos_dri.so',
'hdlcd_dri.so',
'hx8357d_dri.so',
diff --git a/src/gallium/targets/dri/target.c b/src/gallium/targets/dri/target.c
index 9d3069eb004..79f60a7224a 100644
--- a/src/gallium/targets/dri/target.c
+++ b/src/gallium/targets/dri/target.c
@@ -98,6 +98,9 @@ DEFINE_LOADER_DRM_ENTRYPOINT(tegra);
#if defined(GALLIUM_KMSRO)
DEFINE_LOADER_DRM_ENTRYPOINT(armada_drm)
+DEFINE_LOADER_DRM_ENTRYPOINT(drm_rp1_dpi)
+DEFINE_LOADER_DRM_ENTRYPOINT(drm_rp1_dsi)
+DEFINE_LOADER_DRM_ENTRYPOINT(drm_rp1_vec)
DEFINE_LOADER_DRM_ENTRYPOINT(exynos)
DEFINE_LOADER_DRM_ENTRYPOINT(hdlcd)
DEFINE_LOADER_DRM_ENTRYPOINT(hx8357d)
--
2.39.2

713
projects/RPi/patches/mesa/0002-backport-2712D0-support.patch
View File

@ -1,713 +0,0 @@
From 47e68232c04cd35fc9361cffcafdc76cb99a76eb Mon Sep 17 00:00:00 2001
From: Iago Toral Quiroga <itoral@igalia.com>
Date: Tue, 14 May 2024 09:40:16 +0200
Subject: [PATCH 1/3] broadcom/cle: fix up shader record for V3D 7.1.10 /
2712D0
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29189>
---
src/broadcom/cle/v3d_packet.xml | 63 +++++++++++++++++++++++++++++++++
1 file changed, 63 insertions(+)
diff --git a/src/broadcom/cle/v3d_packet.xml b/src/broadcom/cle/v3d_packet.xml
index 09dde392fac3..4763b891aab1 100644
--- a/src/broadcom/cle/v3d_packet.xml
+++ b/src/broadcom/cle/v3d_packet.xml
@@ -1211,6 +1211,69 @@
<field name="Coordinate Shader Uniforms Address" size="32" start="28b" type="address"/>
</struct>
+ <!-- This one is exclusive to 2712D0 (V3D 7.1.10) -->
+ <struct name="GL Shader State Record Draw Index" min_ver="71">
+ <field name="Point size in shaded vertex data" size="1" start="0" type="bool"/>
+ <field name="Enable clipping" size="1" start="1" type="bool"/>
+
+ <field name="Vertex ID read by coordinate shader" size="1" start="2" type="bool"/>
+ <field name="Instance ID read by coordinate shader" size="1" start="3" type="bool"/>
+ <field name="Base Instance ID read by coordinate shader" size="1" start="4" type="bool"/>
+ <field name="cs_basevertex" size="1" start="5" type="bool"/>
+ <field name="cs_drawindex" size="1" start="6" type="bool"/>
+
+ <field name="Vertex ID read by vertex shader" size="1" start="7" type="bool"/>
+ <field name="Instance ID read by vertex shader" size="1" start="8" type="bool"/>
+ <field name="Base Instance ID read by vertex shader" size="1" start="9" type="bool"/>
+ <field name="vs_basevertex" size="1" start="10" type="bool"/>
+ <field name="vs_drawindex" size="1" start="11" type="bool"/>
+
+ <field name="Fragment shader does Z writes" size="1" start="12" type="bool"/>
+ <field name="Turn off early-z test" size="1" start="13" type="bool"/>
+
+ <field name="Fragment shader uses real pixel centre W in addition to centroid W2" size="1" start="15" type="bool"/>
+ <field name="Enable Sample Rate Shading" size="1" start="16" type="bool"/>
+ <field name="Any shader reads hardware-written Primitive ID" size="1" start="17" type="bool"/>
+ <field name="Insert Primitive ID as first varying to fragment shader" size="1" start="18" type="bool"/>
+ <field name="Turn off scoreboard" size="1" start="19" type="bool"/>
+ <field name="Do scoreboard wait on first thread switch" size="1" start="20" type="bool"/>
+ <field name="Disable implicit point/line varyings" size="1" start="21" type="bool"/>
+ <field name="No prim pack" size="1" start="22" type="bool"/>
+ <field name="Never defer FEP depth writes" size="1" start="23" type="bool"/>
+
+ <field name="Number of varyings in Fragment Shader" size="8" start="3b" type="uint"/>
+
+ <field name="Coordinate Shader output VPM segment size" size="4" start="4b" type="uint"/>
+ <field name="Min Coord Shader output segments required in play in addition to VCM cache size" size="4" start="36" type="uint"/>
+
+ <field name="Coordinate Shader input VPM segment size" size="4" start="5b" type="uint"/>
+ <field name="Min Coord Shader input segments required in play" size="4" start="44" type="uint" minus_one="true"/>
+
+ <field name="Vertex Shader output VPM segment size" size="4" start="6b" type="uint"/>
+ <field name="Min Vertex Shader output segments required in play in addition to VCM cache size" size="4" start="52" type="uint"/>
+
+ <field name="Vertex Shader input VPM segment size" size="4" start="7b" type="uint"/>
+ <field name="Min Vertex Shader input segments required in play" size="4" start="60" type="uint" minus_one="true"/>
+
+ <field name="Fragment Shader Code Address" size="29" start="67" type="address"/>
+ <field name="Fragment Shader 4-way threadable" size="1" start="64" type="bool"/>
+ <field name="Fragment Shader start in final thread section" size="1" start="65" type="bool"/>
+ <field name="Fragment Shader Propagate NaNs" size="1" start="66" type="bool"/>
+ <field name="Fragment Shader Uniforms Address" size="32" start="12b" type="address"/>
+
+ <field name="Vertex Shader Code Address" size="29" start="131" type="address"/>
+ <field name="Vertex Shader 4-way threadable" size="1" start="128" type="bool"/>
+ <field name="Vertex Shader start in final thread section" size="1" start="129" type="bool"/>
+ <field name="Vertex Shader Propagate NaNs" size="1" start="130" type="bool"/>
+ <field name="Vertex Shader Uniforms Address" size="32" start="20b" type="address"/>
+
+ <field name="Coordinate Shader Code Address" size="29" start="195" type="address"/>
+ <field name="Coordinate Shader 4-way threadable" size="1" start="192" type="bool"/>
+ <field name="Coordinate Shader start in final thread section" size="1" start="193" type="bool"/>
+ <field name="Coordinate Shader Propagate NaNs" size="1" start="194" type="bool"/>
+ <field name="Coordinate Shader Uniforms Address" size="32" start="28b" type="address"/>
+ </struct>
+
<struct name="Geometry Shader State Record">
<field name="Geometry Bin Mode Shader Code Address" size="29" start="3" type="address"/>
<field name="Geometry Bin Mode Shader 4-way threadable" size="1" start="0" type="bool"/>
--
2.39.2
From 21153810ee2c6b3a3a8943ba442f473ee977d5ff Mon Sep 17 00:00:00 2001
From: Iago Toral Quiroga <itoral@igalia.com>
Date: Tue, 14 May 2024 10:24:07 +0200
Subject: [PATCH 2/3] v3d: support 2712D0
2710D0 has V3D 7.1.10 which included draw index and
base vertex in the shader state record packet, shuffling
the locations of most of its fields. Handle this at run
time by emitting the appropriate packet based on the
V3D version since our current versoning framework doesn't
support changes based on revision number alone.
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29189>
---
src/broadcom/common/v3d_device_info.h | 6 +
src/gallium/drivers/v3d/v3dx_draw.c | 316 +++++++++++++++++---------
2 files changed, 214 insertions(+), 108 deletions(-)
diff --git a/src/broadcom/common/v3d_device_info.h b/src/broadcom/common/v3d_device_info.h
index 8dfc7858727e..0df25e8dcce3 100644
--- a/src/broadcom/common/v3d_device_info.h
+++ b/src/broadcom/common/v3d_device_info.h
@@ -52,4 +52,10 @@ typedef int (*v3d_ioctl_fun)(int fd, unsigned long request, void *arg);
bool
v3d_get_device_info(int fd, struct v3d_device_info* devinfo, v3d_ioctl_fun fun);
+static inline bool
+v3d_device_has_draw_index(struct v3d_device_info *devinfo)
+{
+ return devinfo->ver > 71 || (devinfo->ver == 71 && devinfo->rev >= 10);
+}
+
#endif
diff --git a/src/gallium/drivers/v3d/v3dx_draw.c b/src/gallium/drivers/v3d/v3dx_draw.c
index 128104c213b7..85922f36c4e6 100644
--- a/src/gallium/drivers/v3d/v3dx_draw.c
+++ b/src/gallium/drivers/v3d/v3dx_draw.c
@@ -472,114 +472,100 @@ v3d_emit_tes_gs_shader_params(struct v3d_job *job,
}
static void
-v3d_emit_gl_shader_state(struct v3d_context *v3d,
- const struct pipe_draw_info *info)
+emit_shader_state_record(struct v3d_context *v3d,
+ struct v3d_job *job,
+ const struct pipe_draw_info *info,
+ struct v3d_vertex_stateobj *vtx,
+ struct v3d_cl_reloc cs_uniforms,
+ struct v3d_cl_reloc vs_uniforms,
+ struct v3d_cl_reloc fs_uniforms,
+ struct vpm_config *vpm_cfg_bin,
+ struct vpm_config *vpm_cfg)
{
- struct v3d_job *job = v3d->job;
- /* V3D_DIRTY_VTXSTATE */
- struct v3d_vertex_stateobj *vtx = v3d->vtx;
- /* V3D_DIRTY_VTXBUF */
- struct v3d_vertexbuf_stateobj *vertexbuf = &v3d->vertexbuf;
-
- /* Upload the uniforms to the indirect CL first */
- struct v3d_cl_reloc fs_uniforms =
- v3d_write_uniforms(v3d, job, v3d->prog.fs,
- PIPE_SHADER_FRAGMENT);
-
- struct v3d_cl_reloc gs_uniforms = { NULL, 0 };
- struct v3d_cl_reloc gs_bin_uniforms = { NULL, 0 };
- if (v3d->prog.gs) {
- gs_uniforms = v3d_write_uniforms(v3d, job, v3d->prog.gs,
- PIPE_SHADER_GEOMETRY);
- }
- if (v3d->prog.gs_bin) {
- gs_bin_uniforms = v3d_write_uniforms(v3d, job, v3d->prog.gs_bin,
- PIPE_SHADER_GEOMETRY);
- }
-
- struct v3d_cl_reloc vs_uniforms =
- v3d_write_uniforms(v3d, job, v3d->prog.vs,
- PIPE_SHADER_VERTEX);
- struct v3d_cl_reloc cs_uniforms =
- v3d_write_uniforms(v3d, job, v3d->prog.cs,
- PIPE_SHADER_VERTEX);
-
- /* Update the cache dirty flag based on the shader progs data */
- job->tmu_dirty_rcl |= v3d->prog.cs->prog_data.vs->base.tmu_dirty_rcl;
- job->tmu_dirty_rcl |= v3d->prog.vs->prog_data.vs->base.tmu_dirty_rcl;
- if (v3d->prog.gs_bin) {
- job->tmu_dirty_rcl |=
- v3d->prog.gs_bin->prog_data.gs->base.tmu_dirty_rcl;
- }
- if (v3d->prog.gs) {
- job->tmu_dirty_rcl |=
- v3d->prog.gs->prog_data.gs->base.tmu_dirty_rcl;
- }
- job->tmu_dirty_rcl |= v3d->prog.fs->prog_data.fs->base.tmu_dirty_rcl;
-
- uint32_t num_elements_to_emit = 0;
- for (int i = 0; i < vtx->num_elements; i++) {
- struct pipe_vertex_element *elem = &vtx->pipe[i];
- struct pipe_vertex_buffer *vb =
- &vertexbuf->vb[elem->vertex_buffer_index];
- if (vb->buffer.resource)
- num_elements_to_emit++;
- }
-
- uint32_t shader_state_record_length =
- cl_packet_length(GL_SHADER_STATE_RECORD);
- if (v3d->prog.gs) {
- shader_state_record_length +=
- cl_packet_length(GEOMETRY_SHADER_STATE_RECORD) +
- cl_packet_length(TESSELLATION_GEOMETRY_COMMON_PARAMS) +
- 2 * cl_packet_length(TESSELLATION_GEOMETRY_SHADER_PARAMS);
- }
-
- /* See GFXH-930 workaround below */
- uint32_t shader_rec_offset =
- v3d_cl_ensure_space(&job->indirect,
- shader_state_record_length +
- MAX2(num_elements_to_emit, 1) *
- cl_packet_length(GL_SHADER_STATE_ATTRIBUTE_RECORD),
- 32);
-
- /* XXX perf: We should move most of the SHADER_STATE_RECORD setup to
- * compile time, so that we mostly just have to OR the VS and FS
- * records together at draw time.
+#if V3D_VERSION >= 71
+ /* 2712D0 (V3D 7.1.10) has included draw index and base vertex,
+ * shuffling all the fields in the packet. Since the versioning
+ * framework doesn't handle revision numbers, the XML has a
+ * different shader state record packet including the new fields
+ * and we decide at run time which packet we need to emit.
*/
-
- struct vpm_config vpm_cfg_bin, vpm_cfg;
- v3d_compute_vpm_config(&v3d->screen->devinfo,
- v3d->prog.cs->prog_data.vs,
- v3d->prog.vs->prog_data.vs,
- v3d->prog.gs ? v3d->prog.gs_bin->prog_data.gs : NULL,
- v3d->prog.gs ? v3d->prog.gs->prog_data.gs : NULL,
- &vpm_cfg_bin,
- &vpm_cfg);
-
- if (v3d->prog.gs) {
- v3d_emit_gs_state_record(v3d->job,
- v3d->prog.gs_bin, gs_bin_uniforms,
- v3d->prog.gs, gs_uniforms);
-
- struct v3d_gs_prog_data *gs = v3d->prog.gs->prog_data.gs;
- v3d_emit_tes_gs_common_params(v3d->job,
- gs->out_prim_type,
- gs->num_invocations);
-
- /* Bin Tes/Gs params */
- v3d_emit_tes_gs_shader_params(v3d->job,
- vpm_cfg_bin.gs_width,
- vpm_cfg_bin.Gd,
- vpm_cfg_bin.Gv);
-
- /* Render Tes/Gs params */
- v3d_emit_tes_gs_shader_params(v3d->job,
- vpm_cfg.gs_width,
- vpm_cfg.Gd,
- vpm_cfg.Gv);
+ if (v3d_device_has_draw_index(&v3d->screen->devinfo)) {
+ cl_emit(&job->indirect, GL_SHADER_STATE_RECORD_DRAW_INDEX, shader) {
+ shader.enable_clipping = true;
+ shader.point_size_in_shaded_vertex_data =
+ (info->mode == MESA_PRIM_POINTS &&
+ v3d->rasterizer->base.point_size_per_vertex);
+ shader.fragment_shader_does_z_writes =
+ v3d->prog.fs->prog_data.fs->writes_z;
+ shader.turn_off_early_z_test =
+ v3d->prog.fs->prog_data.fs->disable_ez;
+ shader.fragment_shader_uses_real_pixel_centre_w_in_addition_to_centroid_w2 =
+ v3d->prog.fs->prog_data.fs->uses_center_w;
+ shader.any_shader_reads_hardware_written_primitive_id =
+ (v3d->prog.gs && v3d->prog.gs->prog_data.gs->uses_pid) ||
+ v3d->prog.fs->prog_data.fs->uses_pid;
+ shader.insert_primitive_id_as_first_varying_to_fragment_shader =
+ !v3d->prog.gs && v3d->prog.fs->prog_data.fs->uses_pid;
+ shader.do_scoreboard_wait_on_first_thread_switch =
+ v3d->prog.fs->prog_data.fs->lock_scoreboard_on_first_thrsw;
+ shader.disable_implicit_point_line_varyings =
+ !v3d->prog.fs->prog_data.fs->uses_implicit_point_line_varyings;
+ shader.number_of_varyings_in_fragment_shader =
+ v3d->prog.fs->prog_data.fs->num_inputs;
+ shader.coordinate_shader_code_address =
+ cl_address(v3d_resource(v3d->prog.cs->resource)->bo,
+ v3d->prog.cs->offset);
+ shader.vertex_shader_code_address =
+ cl_address(v3d_resource(v3d->prog.vs->resource)->bo,
+ v3d->prog.vs->offset);
+ shader.fragment_shader_code_address =
+ cl_address(v3d_resource(v3d->prog.fs->resource)->bo,
+ v3d->prog.fs->offset);
+ shader.coordinate_shader_input_vpm_segment_size =
+ v3d->prog.cs->prog_data.vs->vpm_input_size;
+ shader.vertex_shader_input_vpm_segment_size =
+ v3d->prog.vs->prog_data.vs->vpm_input_size;
+ shader.coordinate_shader_output_vpm_segment_size =
+ v3d->prog.cs->prog_data.vs->vpm_output_size;
+ shader.vertex_shader_output_vpm_segment_size =
+ v3d->prog.vs->prog_data.vs->vpm_output_size;
+ shader.coordinate_shader_uniforms_address = cs_uniforms;
+ shader.vertex_shader_uniforms_address = vs_uniforms;
+ shader.fragment_shader_uniforms_address = fs_uniforms;
+ shader.min_coord_shader_input_segments_required_in_play =
+ vpm_cfg_bin->As;
+ shader.min_vertex_shader_input_segments_required_in_play =
+ vpm_cfg->As;
+ shader.min_coord_shader_output_segments_required_in_play_in_addition_to_vcm_cache_size =
+ vpm_cfg_bin->Ve;
+ shader.min_vertex_shader_output_segments_required_in_play_in_addition_to_vcm_cache_size =
+ vpm_cfg->Ve;
+ shader.coordinate_shader_4_way_threadable =
+ v3d->prog.cs->prog_data.vs->base.threads == 4;
+ shader.vertex_shader_4_way_threadable =
+ v3d->prog.vs->prog_data.vs->base.threads == 4;
+ shader.fragment_shader_4_way_threadable =
+ v3d->prog.fs->prog_data.fs->base.threads == 4;
+ shader.coordinate_shader_start_in_final_thread_section =
+ v3d->prog.cs->prog_data.vs->base.single_seg;
+ shader.vertex_shader_start_in_final_thread_section =
+ v3d->prog.vs->prog_data.vs->base.single_seg;
+ shader.fragment_shader_start_in_final_thread_section =
+ v3d->prog.fs->prog_data.fs->base.single_seg;
+ shader.vertex_id_read_by_coordinate_shader =
+ v3d->prog.cs->prog_data.vs->uses_vid;
+ shader.instance_id_read_by_coordinate_shader =
+ v3d->prog.cs->prog_data.vs->uses_iid;
+ shader.vertex_id_read_by_vertex_shader =
+ v3d->prog.vs->prog_data.vs->uses_vid;
+ shader.instance_id_read_by_vertex_shader =
+ v3d->prog.vs->prog_data.vs->uses_iid;
+ }
+ return;
}
+#endif
+ assert(!v3d_device_has_draw_index(&v3d->screen->devinfo));
cl_emit(&job->indirect, GL_SHADER_STATE_RECORD, shader) {
shader.enable_clipping = true;
/* V3D_DIRTY_PRIM_MODE | V3D_DIRTY_RASTERIZER */
@@ -669,14 +655,14 @@ v3d_emit_gl_shader_state(struct v3d_context *v3d,
shader.fragment_shader_uniforms_address = fs_uniforms;
shader.min_coord_shader_input_segments_required_in_play =
- vpm_cfg_bin.As;
+ vpm_cfg_bin->As;
shader.min_vertex_shader_input_segments_required_in_play =
- vpm_cfg.As;
+ vpm_cfg->As;
shader.min_coord_shader_output_segments_required_in_play_in_addition_to_vcm_cache_size =
- vpm_cfg_bin.Ve;
+ vpm_cfg_bin->Ve;
shader.min_vertex_shader_output_segments_required_in_play_in_addition_to_vcm_cache_size =
- vpm_cfg.Ve;
+ vpm_cfg->Ve;
shader.coordinate_shader_4_way_threadable =
v3d->prog.cs->prog_data.vs->base.threads == 4;
@@ -707,6 +693,120 @@ v3d_emit_gl_shader_state(struct v3d_context *v3d,
vtx->defaults_offset);
#endif
}
+}
+
+static void
+v3d_emit_gl_shader_state(struct v3d_context *v3d,
+ const struct pipe_draw_info *info)
+{
+ struct v3d_job *job = v3d->job;
+ /* V3D_DIRTY_VTXSTATE */
+ struct v3d_vertex_stateobj *vtx = v3d->vtx;
+ /* V3D_DIRTY_VTXBUF */
+ struct v3d_vertexbuf_stateobj *vertexbuf = &v3d->vertexbuf;
+
+ /* Upload the uniforms to the indirect CL first */
+ struct v3d_cl_reloc fs_uniforms =
+ v3d_write_uniforms(v3d, job, v3d->prog.fs,
+ PIPE_SHADER_FRAGMENT);
+
+ struct v3d_cl_reloc gs_uniforms = { NULL, 0 };
+ struct v3d_cl_reloc gs_bin_uniforms = { NULL, 0 };
+ if (v3d->prog.gs) {
+ gs_uniforms = v3d_write_uniforms(v3d, job, v3d->prog.gs,
+ PIPE_SHADER_GEOMETRY);
+ }
+ if (v3d->prog.gs_bin) {
+ gs_bin_uniforms = v3d_write_uniforms(v3d, job, v3d->prog.gs_bin,
+ PIPE_SHADER_GEOMETRY);
+ }
+
+ struct v3d_cl_reloc vs_uniforms =
+ v3d_write_uniforms(v3d, job, v3d->prog.vs,
+ PIPE_SHADER_VERTEX);
+ struct v3d_cl_reloc cs_uniforms =
+ v3d_write_uniforms(v3d, job, v3d->prog.cs,
+ PIPE_SHADER_VERTEX);
+
+ /* Update the cache dirty flag based on the shader progs data */
+ job->tmu_dirty_rcl |= v3d->prog.cs->prog_data.vs->base.tmu_dirty_rcl;
+ job->tmu_dirty_rcl |= v3d->prog.vs->prog_data.vs->base.tmu_dirty_rcl;
+ if (v3d->prog.gs_bin) {
+ job->tmu_dirty_rcl |=
+ v3d->prog.gs_bin->prog_data.gs->base.tmu_dirty_rcl;
+ }
+ if (v3d->prog.gs) {
+ job->tmu_dirty_rcl |=
+ v3d->prog.gs->prog_data.gs->base.tmu_dirty_rcl;
+ }
+ job->tmu_dirty_rcl |= v3d->prog.fs->prog_data.fs->base.tmu_dirty_rcl;
+
+ uint32_t num_elements_to_emit = 0;
+ for (int i = 0; i < vtx->num_elements; i++) {
+ struct pipe_vertex_element *elem = &vtx->pipe[i];
+ struct pipe_vertex_buffer *vb =
+ &vertexbuf->vb[elem->vertex_buffer_index];
+ if (vb->buffer.resource)
+ num_elements_to_emit++;
+ }
+
+ uint32_t shader_state_record_length =
+ cl_packet_length(GL_SHADER_STATE_RECORD);
+ if (v3d->prog.gs) {
+ shader_state_record_length +=
+ cl_packet_length(GEOMETRY_SHADER_STATE_RECORD) +
+ cl_packet_length(TESSELLATION_GEOMETRY_COMMON_PARAMS) +
+ 2 * cl_packet_length(TESSELLATION_GEOMETRY_SHADER_PARAMS);
+ }
+
+ /* See GFXH-930 workaround below */
+ uint32_t shader_rec_offset =
+ v3d_cl_ensure_space(&job->indirect,
+ shader_state_record_length +
+ MAX2(num_elements_to_emit, 1) *
+ cl_packet_length(GL_SHADER_STATE_ATTRIBUTE_RECORD),
+ 32);
+
+ /* XXX perf: We should move most of the SHADER_STATE_RECORD setup to
+ * compile time, so that we mostly just have to OR the VS and FS
+ * records together at draw time.
+ */
+
+ struct vpm_config vpm_cfg_bin, vpm_cfg;
+ v3d_compute_vpm_config(&v3d->screen->devinfo,
+ v3d->prog.cs->prog_data.vs,
+ v3d->prog.vs->prog_data.vs,
+ v3d->prog.gs ? v3d->prog.gs_bin->prog_data.gs : NULL,
+ v3d->prog.gs ? v3d->prog.gs->prog_data.gs : NULL,
+ &vpm_cfg_bin,
+ &vpm_cfg);
+
+ if (v3d->prog.gs) {
+ v3d_emit_gs_state_record(v3d->job,
+ v3d->prog.gs_bin, gs_bin_uniforms,
+ v3d->prog.gs, gs_uniforms);
+
+ struct v3d_gs_prog_data *gs = v3d->prog.gs->prog_data.gs;
+ v3d_emit_tes_gs_common_params(v3d->job,
+ gs->out_prim_type,
+ gs->num_invocations);
+
+ /* Bin Tes/Gs params */
+ v3d_emit_tes_gs_shader_params(v3d->job,
+ vpm_cfg_bin.gs_width,
+ vpm_cfg_bin.Gd,
+ vpm_cfg_bin.Gv);
+
+ /* Render Tes/Gs params */
+ v3d_emit_tes_gs_shader_params(v3d->job,
+ vpm_cfg.gs_width,
+ vpm_cfg.Gd,
+ vpm_cfg.Gv);
+ }
+
+ emit_shader_state_record(v3d, job, info, vtx,
+ cs_uniforms, vs_uniforms, fs_uniforms,
+ &vpm_cfg_bin, &vpm_cfg);
bool cs_loaded_any = false;
const bool cs_uses_builtins = v3d->prog.cs->prog_data.vs->uses_iid ||
--
2.39.2
From bb2a9b1ffdb91ad94d1e1f29594d262460d5e29b Mon Sep 17 00:00:00 2001
From: Iago Toral Quiroga <itoral@igalia.com>
Date: Thu, 23 Nov 2023 11:33:57 +0100
Subject: [PATCH 3/3] v3dv: support 2712D0
2712D0 has V3D 7.1.10 which included draw index and
base vertex in the shader state record packet, shuffling
the locations of most of its fields. Handle this at run
time by emitting the appropriate packet based on the
V3D version since our current versioning framework doesn't
support changes based on revision number alone.
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29189>
---
src/broadcom/vulkan/v3dvx_cmd_buffer.c | 96 +++++++++++++++++---------
src/broadcom/vulkan/v3dvx_pipeline.c | 75 +++++++++++++++++---
2 files changed, 130 insertions(+), 41 deletions(-)
diff --git a/src/broadcom/vulkan/v3dvx_cmd_buffer.c b/src/broadcom/vulkan/v3dvx_cmd_buffer.c
index 65b18ae639cd..09fae0307bcd 100644
--- a/src/broadcom/vulkan/v3dvx_cmd_buffer.c
+++ b/src/broadcom/vulkan/v3dvx_cmd_buffer.c
@@ -2333,6 +2333,13 @@ v3dX(cmd_buffer_emit_gl_shader_state)(struct v3dv_cmd_buffer *cmd_buffer)
uint32_t shader_state_record_length =
cl_packet_length(GL_SHADER_STATE_RECORD);
+#if V3D_VERSION >= 71
+ if (v3d_device_has_draw_index(&pipeline->device->devinfo)) {
+ shader_state_record_length =
+ cl_packet_length(GL_SHADER_STATE_RECORD_DRAW_INDEX);
+ }
+#endif
+
if (pipeline->has_gs) {
shader_state_record_length +=
cl_packet_length(GEOMETRY_SHADER_STATE_RECORD) +
@@ -2380,39 +2387,64 @@ v3dX(cmd_buffer_emit_gl_shader_state)(struct v3dv_cmd_buffer *cmd_buffer)
pipeline->device->default_attribute_float;
#endif
- cl_emit_with_prepacked(&job->indirect, GL_SHADER_STATE_RECORD,
- pipeline->shader_state_record, shader) {
-
- /* FIXME: we are setting this values here and during the
- * prepacking. This is because both cl_emit_with_prepacked and v3dvx_pack
- * asserts for minimum values of these. It would be good to get
- * v3dvx_pack to assert on the final value if possible
- */
- shader.min_coord_shader_input_segments_required_in_play =
- pipeline->vpm_cfg_bin.As;
- shader.min_vertex_shader_input_segments_required_in_play =
- pipeline->vpm_cfg.As;
-
- shader.coordinate_shader_code_address =
- v3dv_cl_address(assembly_bo, vs_bin_variant->assembly_offset);
- shader.vertex_shader_code_address =
- v3dv_cl_address(assembly_bo, vs_variant->assembly_offset);
- shader.fragment_shader_code_address =
- v3dv_cl_address(assembly_bo, fs_variant->assembly_offset);
-
- shader.coordinate_shader_uniforms_address = cmd_buffer->state.uniforms.vs_bin;
- shader.vertex_shader_uniforms_address = cmd_buffer->state.uniforms.vs;
- shader.fragment_shader_uniforms_address = cmd_buffer->state.uniforms.fs;
-
-#if V3D_VERSION == 42
- shader.address_of_default_attribute_values =
- v3dv_cl_address(default_attribute_values, 0);
+#if V3D_VERSION >= 71
+ if (v3d_device_has_draw_index(&pipeline->device->devinfo)) {
+ cl_emit_with_prepacked(&job->indirect, GL_SHADER_STATE_RECORD_DRAW_INDEX,
+ pipeline->shader_state_record, shader) {
+ shader.min_coord_shader_input_segments_required_in_play =
+ pipeline->vpm_cfg_bin.As;
+ shader.min_vertex_shader_input_segments_required_in_play =
+ pipeline->vpm_cfg.As;
+ shader.coordinate_shader_code_address =
+ v3dv_cl_address(assembly_bo, vs_bin_variant->assembly_offset);
+ shader.vertex_shader_code_address =
+ v3dv_cl_address(assembly_bo, vs_variant->assembly_offset);
+ shader.fragment_shader_code_address =
+ v3dv_cl_address(assembly_bo, fs_variant->assembly_offset);
+ shader.coordinate_shader_uniforms_address = cmd_buffer->state.uniforms.vs_bin;
+ shader.vertex_shader_uniforms_address = cmd_buffer->state.uniforms.vs;
+ shader.fragment_shader_uniforms_address = cmd_buffer->state.uniforms.fs;
+ shader.any_shader_reads_hardware_written_primitive_id =
+ (pipeline->has_gs && prog_data_gs->uses_pid) || prog_data_fs->uses_pid;
+ shader.insert_primitive_id_as_first_varying_to_fragment_shader =
+ !pipeline->has_gs && prog_data_fs->uses_pid;
+ }
+ } else
#endif
-
- shader.any_shader_reads_hardware_written_primitive_id =
- (pipeline->has_gs && prog_data_gs->uses_pid) || prog_data_fs->uses_pid;
- shader.insert_primitive_id_as_first_varying_to_fragment_shader =
- !pipeline->has_gs && prog_data_fs->uses_pid;
+ {
+ cl_emit_with_prepacked(&job->indirect, GL_SHADER_STATE_RECORD,
+ pipeline->shader_state_record, shader) {
+ /* FIXME: we are setting this values here and during the
+ * prepacking. This is because both cl_emit_with_prepacked and v3dvx_pack
+ * asserts for minimum values of these. It would be good to get
+ * v3dvx_pack to assert on the final value if possible
+ */
+ shader.min_coord_shader_input_segments_required_in_play =
+ pipeline->vpm_cfg_bin.As;
+ shader.min_vertex_shader_input_segments_required_in_play =
+ pipeline->vpm_cfg.As;
+
+ shader.coordinate_shader_code_address =
+ v3dv_cl_address(assembly_bo, vs_bin_variant->assembly_offset);
+ shader.vertex_shader_code_address =
+ v3dv_cl_address(assembly_bo, vs_variant->assembly_offset);
+ shader.fragment_shader_code_address =
+ v3dv_cl_address(assembly_bo, fs_variant->assembly_offset);
+
+ shader.coordinate_shader_uniforms_address = cmd_buffer->state.uniforms.vs_bin;
+ shader.vertex_shader_uniforms_address = cmd_buffer->state.uniforms.vs;
+ shader.fragment_shader_uniforms_address = cmd_buffer->state.uniforms.fs;
+
+ #if V3D_VERSION == 42
+ shader.address_of_default_attribute_values =
+ v3dv_cl_address(default_attribute_values, 0);
+ #endif
+
+ shader.any_shader_reads_hardware_written_primitive_id =
+ (pipeline->has_gs && prog_data_gs->uses_pid) || prog_data_fs->uses_pid;
+ shader.insert_primitive_id_as_first_varying_to_fragment_shader =
+ !pipeline->has_gs && prog_data_fs->uses_pid;
+ }
}
/* Upload vertex element attributes (SHADER_STATE_ATTRIBUTE_RECORD) */
diff --git a/src/broadcom/vulkan/v3dvx_pipeline.c b/src/broadcom/vulkan/v3dvx_pipeline.c
index 478fb9a0fa1e..e515286847bd 100644
--- a/src/broadcom/vulkan/v3dvx_pipeline.c
+++ b/src/broadcom/vulkan/v3dvx_pipeline.c
@@ -399,6 +399,10 @@ v3dX(pipeline_pack_state)(struct v3dv_pipeline *pipeline,
static void
pack_shader_state_record(struct v3dv_pipeline *pipeline)
{
+ /* To siplify the code we ignore here GL_SHADER_STATE_RECORD_DRAW_INDEX
+ * used with 2712D0, since we know that has the same size as the regular
+ * version.
+ */
assert(sizeof(pipeline->shader_state_record) >=
cl_packet_length(GL_SHADER_STATE_RECORD));
@@ -411,6 +415,14 @@ pack_shader_state_record(struct v3dv_pipeline *pipeline)
struct v3d_vs_prog_data *prog_data_vs_bin =
pipeline->shared_data->variants[BROADCOM_SHADER_VERTEX_BIN]->prog_data.vs;
+ bool point_size_in_shaded_vertex_data;
+ if (!pipeline->has_gs) {
+ point_size_in_shaded_vertex_data = pipeline->topology == MESA_PRIM_POINTS;
+ } else {
+ struct v3d_gs_prog_data *prog_data_gs =
+ pipeline->shared_data->variants[BROADCOM_SHADER_GEOMETRY]->prog_data.gs;
+ point_size_in_shaded_vertex_data = prog_data_gs->writes_psiz;
+ }
/* Note: we are not packing addresses, as we need the job (see
* cl_pack_emit_reloc). Additionally uniforms can't be filled up at this
@@ -418,17 +430,62 @@ pack_shader_state_record(struct v3dv_pipeline *pipeline)
* pipeline (like viewport), . Would need to be filled later, so we are
* doing a partial prepacking.
*/
+#if V3D_VERSION >= 71
+ /* 2712D0 (V3D 7.1.10) has included draw index and base vertex, shuffling all
+ * the fields in the packet. Since the versioning framework doesn't handle
+ * revision numbers, the XML has a different shader state record packet
+ * including the new fields and we device at run time which packet we need
+ * to emit.
+ */
+ if (v3d_device_has_draw_index(&pipeline->device->devinfo)) {
+ v3dvx_pack(pipeline->shader_state_record, GL_SHADER_STATE_RECORD_DRAW_INDEX, shader) {
+ shader.enable_clipping = true;
+ shader.point_size_in_shaded_vertex_data = point_size_in_shaded_vertex_data;
+ shader.fragment_shader_does_z_writes = prog_data_fs->writes_z;
+ shader.turn_off_early_z_test = prog_data_fs->disable_ez;
+ shader.fragment_shader_uses_real_pixel_centre_w_in_addition_to_centroid_w2 =
+ prog_data_fs->uses_center_w;
+ shader.enable_sample_rate_shading =
+ pipeline->sample_rate_shading ||
+ (pipeline->msaa && prog_data_fs->force_per_sample_msaa);
+ shader.any_shader_reads_hardware_written_primitive_id = false;
+ shader.do_scoreboard_wait_on_first_thread_switch =
+ prog_data_fs->lock_scoreboard_on_first_thrsw;
+ shader.disable_implicit_point_line_varyings =
+ !prog_data_fs->uses_implicit_point_line_varyings;
+ shader.number_of_varyings_in_fragment_shader = prog_data_fs->num_inputs;
+ shader.coordinate_shader_input_vpm_segment_size = prog_data_vs_bin->vpm_input_size;
+ shader.vertex_shader_input_vpm_segment_size = prog_data_vs->vpm_input_size;
+ shader.coordinate_shader_output_vpm_segment_size = prog_data_vs_bin->vpm_output_size;
+ shader.vertex_shader_output_vpm_segment_size = prog_data_vs->vpm_output_size;
+ shader.min_coord_shader_input_segments_required_in_play =
+ pipeline->vpm_cfg_bin.As;
+ shader.min_vertex_shader_input_segments_required_in_play =
+ pipeline->vpm_cfg.As;
+ shader.min_coord_shader_output_segments_required_in_play_in_addition_to_vcm_cache_size =
+ pipeline->vpm_cfg_bin.Ve;
+ shader.min_vertex_shader_output_segments_required_in_play_in_addition_to_vcm_cache_size =
+ pipeline->vpm_cfg.Ve;
+ shader.coordinate_shader_4_way_threadable = prog_data_vs_bin->base.threads == 4;
+ shader.vertex_shader_4_way_threadable = prog_data_vs->base.threads == 4;
+ shader.fragment_shader_4_way_threadable = prog_data_fs->base.threads == 4;
+ shader.coordinate_shader_start_in_final_thread_section = prog_data_vs_bin->base.single_seg;
+ shader.vertex_shader_start_in_final_thread_section = prog_data_vs->base.single_seg;
+ shader.fragment_shader_start_in_final_thread_section = prog_data_fs->base.single_seg;
+ shader.vertex_id_read_by_coordinate_shader = prog_data_vs_bin->uses_vid;
+ shader.base_instance_id_read_by_coordinate_shader = prog_data_vs_bin->uses_biid;
+ shader.instance_id_read_by_coordinate_shader = prog_data_vs_bin->uses_iid;
+ shader.vertex_id_read_by_vertex_shader = prog_data_vs->uses_vid;
+ shader.base_instance_id_read_by_vertex_shader = prog_data_vs->uses_biid;
+ shader.instance_id_read_by_vertex_shader = prog_data_vs->uses_iid;
+ }
+ return;
+ }
+#endif
+
v3dvx_pack(pipeline->shader_state_record, GL_SHADER_STATE_RECORD, shader) {
shader.enable_clipping = true;
-
- if (!pipeline->has_gs) {
- shader.point_size_in_shaded_vertex_data =
- pipeline->topology == MESA_PRIM_POINTS;
- } else {
- struct v3d_gs_prog_data *prog_data_gs =
- pipeline->shared_data->variants[BROADCOM_SHADER_GEOMETRY]->prog_data.gs;
- shader.point_size_in_shaded_vertex_data = prog_data_gs->writes_psiz;
- }
+ shader.point_size_in_shaded_vertex_data = point_size_in_shaded_vertex_data;
/* Must be set if the shader modifies Z, discards, or modifies
* the sample mask. For any of these cases, the fragment
--
2.39.2