From 38f2dda27736b708979c1f0f796ffa4147209390 Mon Sep 17 00:00:00 2001 From: Shiva Kumar Date: Thu, 14 May 2026 18:24:23 +0530 Subject: [PATCH 1/2] Precompiled: Ubuntu26.04 driver container support Signed-off-by: Shiva Kumar (SW-CLOUD) --- .common-ci.yml | 19 + .github/precompiled-matrix-config.json | 19 +- .github/workflows/precompiled.yaml | 9 + .gitlab-ci.yml | 9 + .nvidia-ci.yml | 47 +++ Makefile | 25 +- base/Dockerfile | 36 ++ multi-arch.mk | 1 + ubuntu26.04/precompiled/Dockerfile | 61 +++ ubuntu26.04/precompiled/local-repo.sh | 100 +++++ ubuntu26.04/precompiled/nvidia-driver | 536 +++++++++++++++++++++++++ 11 files changed, 856 insertions(+), 6 deletions(-) create mode 100644 ubuntu26.04/precompiled/Dockerfile create mode 100755 ubuntu26.04/precompiled/local-repo.sh create mode 100755 ubuntu26.04/precompiled/nvidia-driver diff --git a/.common-ci.yml b/.common-ci.yml index 48620c304..1773a6a3a 100644 --- a/.common-ci.yml +++ b/.common-ci.yml @@ -110,6 +110,14 @@ trigger-pipeline: KERNEL_FLAVOR: [aws, azure, azure-fde, generic, nvidia, oracle] LTS_KERNEL: ["6.8"] +# Define the matrix of precompiled jobs that can be run in parallel for ubuntu26.04 +.driver-versions-precompiled-ubuntu26.04: + parallel: + matrix: + - DRIVER_BRANCH: [595] + KERNEL_FLAVOR: [aws, azure, azure-fde, generic, nvidia, oracle] + LTS_KERNEL: ["7.0"] + .dist-ubuntu22.04: variables: DIST: ubuntu22.04 @@ -467,3 +475,14 @@ release:staging-precompiled-ubuntu24.04: - .release:staging-precompiled needs: - image-precompiled-ubuntu24.04 + +# Precompiled Ubuntu26.04 release +release:staging-precompiled-ubuntu26.04: + variables: + DIST: signed_ubuntu26.04 + BASE_TARGET: resolute + extends: + - .driver-versions-precompiled-ubuntu26.04 + - .release:staging-precompiled + needs: + - image-precompiled-ubuntu26.04 diff --git a/.github/precompiled-matrix-config.json b/.github/precompiled-matrix-config.json index 84d0bb8b5..dbfd3a9cd 100644 --- a/.github/precompiled-matrix-config.json +++ b/.github/precompiled-matrix-config.json @@ -1,14 +1,25 @@ { "driver_branch": ["580", "595"], "kernel_flavors": ["aws", "azure", "azure-fde", "generic", "nvidia", "oracle"], - "dist": ["ubuntu22.04", "ubuntu24.04"], - "lts_kernel": ["5.15", "6.8"], - "exclude_build_matrix_pairs": [], + "dist": ["ubuntu22.04", "ubuntu24.04", "ubuntu26.04"], + "lts_kernel": ["5.15", "6.8", "7.0"], + "exclude_build_matrix_pairs": [ + { "dist": "ubuntu26.04", "driver_branch": "580" } + ], "exclude_precompiled_build_matrix": [ + { "dist": "ubuntu26.04", "driver_branch": "580" }, { "lts_kernel": "5.15", "dist": "ubuntu24.04" }, + { "lts_kernel": "7.0", "dist": "ubuntu24.04" }, + { "lts_kernel": "5.15", "dist": "ubuntu26.04" }, + { "lts_kernel": "6.8", "dist": "ubuntu26.04" }, + { "lts_kernel": "7.0", "dist": "ubuntu22.04" }, { "flavor": "azure-fde", "dist": "ubuntu22.04" } ], "exclude_precompiled_e2e_matrix": [ - { "lts_kernel": "5.15", "dist": "ubuntu24.04" } + { "lts_kernel": "5.15", "dist": "ubuntu24.04" }, + { "lts_kernel": "7.0", "dist": "ubuntu24.04" }, + { "lts_kernel": "5.15", "dist": "ubuntu26.04" }, + { "lts_kernel": "6.8", "dist": "ubuntu26.04" }, + { "lts_kernel": "7.0", "dist": "ubuntu22.04" } ] } diff --git a/.github/workflows/precompiled.yaml b/.github/workflows/precompiled.yaml index ad72c3995..eb8e1ed59 100644 --- a/.github/workflows/precompiled.yaml +++ b/.github/workflows/precompiled.yaml @@ -103,6 +103,8 @@ jobs: BASE_TARGET="jammy" elif [[ "${{ matrix.dist }}" == "ubuntu24.04" ]]; then BASE_TARGET="noble" + elif [[ "${{ matrix.dist }}" == "ubuntu26.04" ]]; then + BASE_TARGET="resolute" fi make DRIVER_BRANCH=${{ matrix.driver_branch }} KERNEL_FLAVOR=${{ matrix.flavor }} LTS_KERNEL=${LTS_KERNEL} build-base-${BASE_TARGET} @@ -133,6 +135,8 @@ jobs: BASE_TARGET="jammy" elif [[ "${{ matrix.dist }}" == "ubuntu24.04" ]]; then BASE_TARGET="noble" + elif [[ "${{ matrix.dist }}" == "ubuntu26.04" ]]; then + BASE_TARGET="resolute" fi tar -cvf kernel-version-${{ matrix.driver_branch }}-${KERNEL_VERSION}-${DIST}.tar kernel_version.txt docker save "${PRIVATE_REGISTRY}/nvidia/driver:base-${BASE_TARGET}-${LTS_KERNEL}-${{ matrix.flavor }}-${{ matrix.driver_branch }}" \ @@ -352,6 +356,9 @@ jobs: if [[ "$DIST" == "ubuntu24.04" ]]; then yq eval '.spec.instance.os = "ubuntu-24.04"' -i tests/holodeck_ubuntu.yaml fi + if [[ "$DIST" == "ubuntu26.04" ]]; then + yq eval '.spec.instance.os = "ubuntu-26.04"' -i tests/holodeck_ubuntu.yaml + fi - name: Set up Holodeck uses: NVIDIA/holodeck@v0.3.4 @@ -467,6 +474,8 @@ jobs: BASE_TARGET="jammy" elif [[ "${DIST}" == "ubuntu24.04" ]]; then BASE_TARGET="noble" + elif [[ "${DIST}" == "ubuntu26.04" ]]; then + BASE_TARGET="resolute" fi image_path="./base-images-${{ matrix.driver_branch }}-${{ matrix.kernel_version }}.tar" echo "uploading $image_path" diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 15db285a4..4e74355f2 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -137,3 +137,12 @@ image-precompiled-ubuntu24.04: extends: - .driver-versions-precompiled-ubuntu24.04 - .image-build-precompiled + +image-precompiled-ubuntu26.04: + variables: + DIST: signed_ubuntu26.04 + BASE_TARGET: resolute + CVE_UPDATES: "curl libc6" + extends: + - .driver-versions-precompiled-ubuntu26.04 + - .image-build-precompiled diff --git a/.nvidia-ci.yml b/.nvidia-ci.yml index f58b0ed0b..add6b6b72 100644 --- a/.nvidia-ci.yml +++ b/.nvidia-ci.yml @@ -112,6 +112,20 @@ image-precompiled-ubuntu24.04: - .driver-versions-precompiled-ubuntu24.04 - .image-pull-generic +image-precompiled-ubuntu26.04: + variables: + DIST: signed_ubuntu26.04 + BASE_TARGET: resolute + PRECOMPILED: "true" + CVE_UPDATES: "curl libc6" + rules: + - if: $CI_PIPELINE_SOURCE == "schedule" + when: delayed + start_in: 30 minutes + extends: + - .driver-versions-precompiled-ubuntu26.04 + - .image-pull-generic + .image-pull-ubuntu22.04: # Perform for each DRIVER_VERSION extends: @@ -282,6 +296,18 @@ image-rocky10: - !reference [.scan-rules-common, rules] - !reference [.precompiled-rules, rules] +.scan-precompiled-ubuntu26.04: + variables: + DIST: signed_ubuntu26.04 + BASE_TARGET: resolute + PRECOMPILED: "true" + extends: + - .driver-versions-precompiled-ubuntu26.04 + - .scan-generic + rules: + - !reference [.scan-rules-common, rules] + - !reference [.precompiled-rules, rules] + .scan-precompiled-ubuntu22.04: variables: DIST: signed_ubuntu22.04 @@ -335,6 +361,15 @@ scan-precompiled-ubuntu24.04-amd64: needs: - image-precompiled-ubuntu24.04 +scan-precompiled-ubuntu26.04-amd64: + variables: + PLATFORM: linux/amd64 + extends: + - .scan-precompiled-ubuntu26.04 + - .platform-amd64 + needs: + - image-precompiled-ubuntu26.04 + scan-precompiled-ubuntu22.04-amd64: variables: PLATFORM: linux/amd64 @@ -477,6 +512,18 @@ release:ngc-precompiled-ubuntu24.04: rules: - !reference [.precompiled-rules, rules] +release:ngc-precompiled-ubuntu26.04: + variables: + DIST: signed_ubuntu26.04 + BASE_TARGET: resolute + PRECOMPILED: "true" + extends: + - .driver-versions-precompiled-ubuntu26.04 + - .release-generic + - .release:ngc-variables + rules: + - !reference [.precompiled-rules, rules] + release:ngc-precompiled-ubuntu22.04: variables: DIST: signed_ubuntu22.04 diff --git a/Makefile b/Makefile index b74bd4b5a..7ee7289cb 100644 --- a/Makefile +++ b/Makefile @@ -54,10 +54,10 @@ OUT_IMAGE_TAG = $(OUT_IMAGE_VERSION)-$(OUT_DIST) OUT_IMAGE = $(OUT_IMAGE_NAME):$(OUT_IMAGE_TAG) ##### Public rules ##### -DISTRIBUTIONS := ubuntu22.04 ubuntu24.04 signed_ubuntu22.04 signed_ubuntu24.04 rhel8 rhel9 rhel10 rocky8 rocky9 rocky10 precompiled_rhcos +DISTRIBUTIONS := ubuntu22.04 ubuntu24.04 signed_ubuntu22.04 signed_ubuntu24.04 signed_ubuntu26.04 rhel8 rhel9 rhel10 rocky8 rocky9 rocky10 precompiled_rhcos RHCOS_VERSIONS := rhcos4.14 rhcos4.15 rhcos4.16 rhcos4.17 rhcos4.18 rhel9.6 PUSH_TARGETS := $(patsubst %, push-%, $(DISTRIBUTIONS)) -BASE_FROM := noble jammy +BASE_FROM := resolute noble jammy PUSH_TARGETS := $(patsubst %, push-%, $(DISTRIBUTIONS)) VGPU_GUEST_DRIVER_PUSH_TARGETS := $(patsubst %, push-vgpuguest-%, $(DISTRIBUTIONS) $(RHCOS_VERSIONS)) VGPU_HOST_DRIVER_PUSH_TARGETS := $(patsubst %, push-vgpuhost-%, $(DISTRIBUTIONS) $(RHCOS_VERSIONS)) @@ -98,6 +98,10 @@ pull-signed_ubuntu24.04%: DIST = ubuntu24.04 pull-signed_ubuntu24.04%: DRIVER_TAG = $(DRIVER_BRANCH) pull-signed_ubuntu24.04%: IMAGE_TAG = $(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) +pull-signed_ubuntu26.04%: DIST = ubuntu26.04 +pull-signed_ubuntu26.04%: DRIVER_TAG = $(DRIVER_BRANCH) +pull-signed_ubuntu26.04%: IMAGE_TAG = $(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) + PLATFORM ?= linux/amd64 $(DRIVER_PULL_TARGETS): pull-%: $(DOCKER) pull "--platform=$(PLATFORM)" "$(IMAGE)" @@ -116,6 +120,10 @@ archive-signed_ubuntu24.04%: DIST = ubuntu24.04 archive-signed_ubuntu24.04%: DRIVER_TAG = $(DRIVER_BRANCH) archive-signed_ubuntu24.04%: IMAGE_TAG = $(if $(VERSION),$(VERSION)-)$(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) +archive-signed_ubuntu26.04%: DIST = ubuntu26.04 +archive-signed_ubuntu26.04%: DRIVER_TAG = $(DRIVER_BRANCH) +archive-signed_ubuntu26.04%: IMAGE_TAG = $(if $(VERSION),$(VERSION)-)$(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) + $(DRIVER_ARCHIVE_TARGETS): archive-%: $(DOCKER) save "$(IMAGE)" -o "archive.tar" @@ -139,6 +147,11 @@ push-signed_ubuntu24.04%: DRIVER_TAG = $(DRIVER_BRANCH) push-signed_ubuntu24.04%: IMAGE_TAG = $(if $(VERSION),$(VERSION)-)$(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) push-signed_ubuntu24.04%: OUT_IMAGE_TAG = $(if $(VERSION),$(VERSION)-)$(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) +push-signed_ubuntu26.04%: DIST = ubuntu26.04 +push-signed_ubuntu26.04%: DRIVER_TAG = $(DRIVER_BRANCH) +push-signed_ubuntu26.04%: IMAGE_TAG = $(if $(VERSION),$(VERSION)-)$(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) +push-signed_ubuntu26.04%: OUT_IMAGE_TAG = $(if $(VERSION),$(VERSION)-)$(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) + # $(DRIVER_BUILD_TARGETS) is in the form of build-$(DIST)-$(DRIVER_VERSION) # Parse the target to set the required variables. build-%: DIST = $(word 2,$(subst -, ,$@)) @@ -191,6 +204,14 @@ build-signed_ubuntu24.04%: DRIVER_TAG = $(DRIVER_BRANCH) build-signed_ubuntu24.04%: IMAGE_TAG = $(if $(VERSION),$(VERSION)-)$(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) build-signed_ubuntu24.04%: DOCKER_BUILD_ARGS = --build-arg KERNEL_VERSION="$(KERNEL_VERSION)" +# ubuntu26.04 Precompiled Driver +build-signed_ubuntu26.04%: DIST = ubuntu26.04 +build-signed_ubuntu26.04%: SUBDIR = . +build-signed_ubuntu26.04%: DOCKERFILE = $(CURDIR)/ubuntu26.04/precompiled/Dockerfile +build-signed_ubuntu26.04%: DRIVER_TAG = $(DRIVER_BRANCH) +build-signed_ubuntu26.04%: IMAGE_TAG = $(if $(VERSION),$(VERSION)-)$(DRIVER_BRANCH)-$(KERNEL_VERSION)-$(DIST) +build-signed_ubuntu26.04%: DOCKER_BUILD_ARGS = --build-arg KERNEL_VERSION="$(KERNEL_VERSION)" + # base is an image used to poll Canonical for the latest kernel version # LTS_KERNEL must be defined in the environment when invoking this target. LTS_KERNEL ?= "" diff --git a/base/Dockerfile b/base/Dockerfile index 101c87fcb..413c963b7 100644 --- a/base/Dockerfile +++ b/base/Dockerfile @@ -1,3 +1,39 @@ +# Ubuntu 26.04 +FROM ubuntu:resolute-20260421 AS resolute + +SHELL ["/bin/bash", "-c"] + +ARG DRIVER_BRANCH +ARG KERNEL_FLAVOR +ARG LTS_KERNEL +ENV DRIVER_BRANCH=${DRIVER_BRANCH} +ENV KERNEL_FLAVOR=${KERNEL_FLAVOR} +ENV LTS_KERNEL=${LTS_KERNEL} + +RUN echo "deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ resolute main restricted universe" > /etc/apt/sources.list && \ + echo "deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ resolute-updates main restricted universe" >> /etc/apt/sources.list && \ + echo "deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ resolute-security main restricted universe" >> /etc/apt/sources.list && \ + echo "deb [arch=amd64] http://us.archive.ubuntu.com/ubuntu resolute-updates main restricted" >> /etc/apt/sources.list && \ + echo "deb [arch=amd64] http://us.archive.ubuntu.com/ubuntu resolute-security main restricted" >> /etc/apt/sources.list && \ + rm -f /etc/apt/sources.list.d/ubuntu.sources + +RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections + +ENV NVIDIA_VISIBLE_DEVICES=void + +RUN apt-get update && apt-get install -y --no-install-recommends \ + apt-utils git curl && \ + rm -rf /var/lib/apt/lists/* + +RUN usermod -o -u 0 -g 0 _apt + +COPY generate-ci-config /usr/local/bin/generate-ci-config + +RUN chmod +x /usr/local/bin/generate-ci-config && \ + generate-ci-config + +ENTRYPOINT ["/usr/bin/sleep","1000"] + # Ubuntu 24.04 FROM ubuntu:noble-20260509.1 AS noble diff --git a/multi-arch.mk b/multi-arch.mk index d5201eb70..c0f1e5cea 100644 --- a/multi-arch.mk +++ b/multi-arch.mk @@ -26,3 +26,4 @@ $(DRIVER_PUSH_TARGETS): push-%: # No multi-arch support for the following distributions build-signed_ubuntu22.04%: DOCKER_BUILD_PLATFORM_OPTIONS = --platform=linux/amd64 build-signed_ubuntu24.04%: DOCKER_BUILD_PLATFORM_OPTIONS = --platform=linux/amd64 +build-signed_ubuntu26.04%: DOCKER_BUILD_PLATFORM_OPTIONS = --platform=linux/amd64 diff --git a/ubuntu26.04/precompiled/Dockerfile b/ubuntu26.04/precompiled/Dockerfile new file mode 100644 index 000000000..1e335a864 --- /dev/null +++ b/ubuntu26.04/precompiled/Dockerfile @@ -0,0 +1,61 @@ +ARG BASE_IMAGE=ubuntu:resolute-20260421 +FROM ${BASE_IMAGE} + +ENV DEBIAN_FRONTEND=noninteractive + +ARG BASE_URL=https://us.download.nvidia.com/tesla +ARG TARGETARCH +ENV TARGETARCH=$TARGETARCH +ARG DRIVER_BRANCH=595 +ENV DRIVER_BRANCH=$DRIVER_BRANCH +ARG DRIVER_VERSION=595.71.05 +ENV DRIVER_VERSION=$DRIVER_VERSION + +ARG KERNEL_VERSION=7.0.0-12-generic +ENV KERNEL_VERSION=$KERNEL_VERSION + +ENV NVIDIA_VISIBLE_DEVICES=void + +RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections + +RUN apt-get update && apt-get install -y --no-install-recommends \ + apt-utils \ + build-essential \ + ca-certificates \ + curl \ + kmod \ + file \ + libelf-dev \ + libglvnd-dev \ + pkg-config && \ + rm -rf /var/lib/apt/lists/* + +# Fetch GPG keys for CUDA repo +RUN rm -f /etc/apt/sources.list.d/cuda* && \ + curl -fsSL https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2604/x86_64/cuda-keyring_1.1-1_all.deb -o cuda-keyring_1.1-1_all.deb && \ + dpkg -i cuda-keyring_1.1-1_all.deb && \ + rm -f cuda-keyring_1.1-1_all.deb + +RUN usermod -o -u 0 -g 0 _apt + +# Install / upgrade packages here that are required to resolve CVEs +ARG CVE_UPDATES +RUN if [ -n "${CVE_UPDATES}" ]; then \ + apt-get update && apt-get --only-upgrade -y install ${CVE_UPDATES} && \ + rm -rf /var/lib/apt/lists/*; \ + fi + +COPY ubuntu26.04/precompiled/nvidia-driver /usr/local/bin + +ADD ubuntu26.04/precompiled/local-repo.sh /tmp + +RUN mkdir -p /usr/local/repos && \ + /tmp/local-repo.sh download_driver_package_deps && \ + /tmp/local-repo.sh build_local_apt_repo && \ + /tmp/local-repo.sh fetch_nvidia_installer && \ + # Remove all other ubuntu apt sources to ensure we only pull from the local apt repo + rm /etc/apt/sources.list.d/* + +WORKDIR /drivers + +ENTRYPOINT ["nvidia-driver", "init"] diff --git a/ubuntu26.04/precompiled/local-repo.sh b/ubuntu26.04/precompiled/local-repo.sh new file mode 100755 index 000000000..46713a601 --- /dev/null +++ b/ubuntu26.04/precompiled/local-repo.sh @@ -0,0 +1,100 @@ +#!/usr/bin/env bash + +set -eu + +LOCAL_REPO_DIR=/usr/local/repos +DRIVER_ARCH=${TARGETARCH/amd64/x86_64} && DRIVER_ARCH=${DRIVER_ARCH/arm64/aarch64} +DRIVER_RUN_FILE=NVIDIA-Linux-$DRIVER_ARCH-$DRIVER_VERSION + +download_apt_with_dep () { + local package_name="$1" + local package_version + if [ $# -gt 1 ] && [ -n "$2" ]; then + package_version="$2" + apt-get download "${package_name}=${package_version}" + else + apt-get download "${package_name}" + fi + + dependent_pkgs=$(apt-cache depends --recurse --no-recommends --no-suggests --no-conflicts --no-breaks --no-replaces --no-enhances "$package_name" | grep "^\w" | grep -v "$package_name" | sort -u) + if [ -n "$dependent_pkgs" ]; then + apt-get download $dependent_pkgs + fi +} + +nvlink5_pkgs_download() { + download_apt_with_dep nvlsm + download_apt_with_dep infiniband-diags +} + +nvsdm_download() { + if [ "$TARGETARCH" = "amd64" ]; then + download_apt_with_dep libnvsdm ${DRIVER_VERSION}* + fi +} + +fabricmanager_download() { + download_apt_with_dep nvidia-fabricmanager ${DRIVER_VERSION}* +} + +nscq_download() { + download_apt_with_dep libnvidia-nscq ${DRIVER_VERSION}* +} + +imex_download() { + download_apt_with_dep nvidia-imex ${DRIVER_VERSION}* +} + +download_driver_package_deps () { + apt-get update + pushd ${LOCAL_REPO_DIR} + + download_apt_with_dep linux-objects-nvidia-${DRIVER_BRANCH}-server-${KERNEL_VERSION} + download_apt_with_dep linux-signatures-nvidia-${KERNEL_VERSION} + download_apt_with_dep linux-modules-nvidia-${DRIVER_BRANCH}-server-${KERNEL_VERSION} + download_apt_with_dep linux-modules-nvidia-${DRIVER_BRANCH}-server-open-${KERNEL_VERSION} + download_apt_with_dep nvidia-utils-${DRIVER_BRANCH}-server + download_apt_with_dep nvidia-headless-no-dkms-${DRIVER_BRANCH}-server + download_apt_with_dep libnvidia-decode-${DRIVER_BRANCH}-server + download_apt_with_dep libnvidia-extra-${DRIVER_BRANCH}-server + download_apt_with_dep libnvidia-encode-${DRIVER_BRANCH}-server + download_apt_with_dep libnvidia-fbc1-${DRIVER_BRANCH}-server + download_apt_with_dep libnvidia-gl-${DRIVER_BRANCH}-server + + fabricmanager_download + nscq_download + nvlink5_pkgs_download + imex_download + nvsdm_download + + ls -al . + popd +} + +build_local_apt_repo () { + pushd ${LOCAL_REPO_DIR} + dpkg-scanpackages . /dev/null | gzip -9c | tee Packages.gz > /dev/null + echo "deb [trusted=yes] file:${LOCAL_REPO_DIR} ./" > /etc/apt/sources.list + popd + apt-get update +} + +fetch_nvidia_installer () { + curl -fSsl -O $BASE_URL/$DRIVER_VERSION/$DRIVER_RUN_FILE.run + chmod +x $DRIVER_RUN_FILE.run + sh $DRIVER_RUN_FILE.run -x + mv $DRIVER_RUN_FILE/nvidia-installer /usr/bin/ + rm -rf $DRIVER_RUN_FILE + rm $DRIVER_RUN_FILE.run +} + +if [ "$1" = "download_driver_package_deps" ]; then + download_driver_package_deps +elif [ "$1" = "build_local_apt_repo" ]; then + build_local_apt_repo +elif [ "$1" = "fetch_nvidia_installer" ]; then + fetch_nvidia_installer +else + echo "Unknown function: $1" + exit 1 +fi diff --git a/ubuntu26.04/precompiled/nvidia-driver b/ubuntu26.04/precompiled/nvidia-driver new file mode 100755 index 000000000..54a926aed --- /dev/null +++ b/ubuntu26.04/precompiled/nvidia-driver @@ -0,0 +1,536 @@ +#! /bin/bash +# Copyright (c) 2018-2022, NVIDIA CORPORATION. All rights reserved. + +set -eu + +KERNEL_VERSION=$(uname -r) +RUN_DIR=/run/nvidia +PID_FILE=${RUN_DIR}/${0##*/}.pid +DRIVER_BRANCH=${DRIVER_BRANCH:?"Missing driver version"} +GPU_DIRECT_RDMA_ENABLED="${GPU_DIRECT_RDMA_ENABLED:-false}" +USE_HOST_MOFED="${USE_HOST_MOFED:-false}" +NVIDIA_MODULE_PARAMS=() +NVIDIA_UVM_MODULE_PARAMS=() +NVIDIA_MODESET_MODULE_PARAMS=() +NVIDIA_PEERMEM_MODULE_PARAMS=() +TARGETARCH=${TARGETARCH:?"Missing TARGETARCH env"} +KERNEL_MODULE_TYPE=${KERNEL_MODULE_TYPE:-auto} +MODPROBE_CONFIG_DIR="/etc/modprobe.d" + + +fabricmanager_install() { + apt-get install -y --no-install-recommends nvidia-fabricmanager=${DRIVER_VERSION}* + apt-mark hold nvidia-fabricmanager +} + +nscq_install() { + apt-get install -y --no-install-recommends libnvidia-nscq=${DRIVER_VERSION}* + apt-mark hold libnvidia-nscq +} + +imex_install() { + apt-get install -y --no-install-recommends nvidia-imex=${DRIVER_VERSION}* + apt-mark hold nvidia-imex +} + +nvlink5_pkgs_install() { + apt-get install -y --no-install-recommends nvlsm + apt-get install -y --no-install-recommends infiniband-diags +} + +# libnvsdm packages are not available for arm64 +nvsdm_install() { + if [ "$TARGETARCH" = "amd64" ]; then + apt-get install -y --no-install-recommends libnvsdm=${DRIVER_VERSION}* + apt-mark hold libnvsdm + fi +} + +_update_package_cache() { + if [ "${PACKAGE_TAG:-}" != "builtin" ]; then + echo "Updating the package cache..." + if ! apt-get -qq update; then + echo "ERROR: Failed to update package cache. "\ + "Ensure that the cluster can access the proper networks." + exit 1 + fi + fi +} + +_assert_nvswitch_system() { + [ -d /proc/driver/nvidia-nvswitch/devices ] || return 1 + if [ -z "$(ls -A /proc/driver/nvidia-nvswitch/devices)" ]; then + return 1 + fi + return 0 +} + +_assert_nvlink5_system() ( + for dir in /sys/class/infiniband/*/device; do + # Define the path to the VPD file + vpd_file="$dir/vpd" + + # Check if the VPD file exists + if [ -f "$vpd_file" ]; then + # Search for 'SW_MNG' in the VPD file + if grep -q "SW_MNG" "$vpd_file"; then + echo "Detected NVLink5+ system" + return 0 + fi + fi + done + return 1 +) + +_ensure_nvlink5_prerequisites() ( + until lsmod | grep mlx5_core > /dev/null 2>&1 && lsmod | grep ib_umad > /dev/null 2>&1; + do + echo "waiting for the mlx5_core and ib_umad kernel modules to be loaded" + sleep 10 + done +) + +# Check if mellanox devices are present +_mellanox_devices_present() { + devices_found=0 + for dev in /sys/bus/pci/devices/*; do + read vendor < $dev/vendor + if [ "$vendor" = "0x15b3" ]; then + echo "Mellanox device found at $(basename $dev)" + return 0 + fi + done + echo "No Mellanox devices were found..." + return 1 +} + +_gpu_direct_rdma_enabled() { + if [ "${GPU_DIRECT_RDMA_ENABLED}" = "true" ]; then + # check if mellanox cards are present + if _mellanox_devices_present; then + return 0 + fi + fi + return 1 +} + +# For each kernel module configuration file mounted into the container, +# parse the file contents and extract the custom module parameters that +# are to be passed as input to 'modprobe'. +# +# Assumptions: +# - Configuration files are named .conf (i.e. nvidia.conf, nvidia-uvm.conf). +# - Configuration files are mounted inside the container at /drivers. +# - Each line in the file contains at least one parameter, where parameters on the same line +# are space delimited. It is up to the user to properly format the file to ensure +# the correct set of parameters are passed to 'modprobe'. +_get_module_params() { + local base_path="/drivers" + # nvidia + if [ -f "${base_path}/nvidia.conf" ]; then + while IFS="" read -r param || [ -n "$param" ]; do + NVIDIA_MODULE_PARAMS+=("$param") + done <"${base_path}/nvidia.conf" + echo "Module parameters provided for nvidia: ${NVIDIA_MODULE_PARAMS[@]}" + fi + # nvidia-uvm + if [ -f "${base_path}/nvidia-uvm.conf" ]; then + while IFS="" read -r param || [ -n "$param" ]; do + NVIDIA_UVM_MODULE_PARAMS+=("$param") + done <"${base_path}/nvidia-uvm.conf" + echo "Module parameters provided for nvidia-uvm: ${NVIDIA_UVM_MODULE_PARAMS[@]}" + fi + # nvidia-modeset + if [ -f "${base_path}/nvidia-modeset.conf" ]; then + while IFS="" read -r param || [ -n "$param" ]; do + NVIDIA_MODESET_MODULE_PARAMS+=("$param") + done <"${base_path}/nvidia-modeset.conf" + echo "Module parameters provided for nvidia-modeset: ${NVIDIA_MODESET_MODULE_PARAMS[@]}" + fi + # nvidia-peermem + if [ -f "${base_path}/nvidia-peermem.conf" ]; then + while IFS="" read -r param || [ -n "$param" ]; do + NVIDIA_PEERMEM_MODULE_PARAMS+=("$param") + done <"${base_path}/nvidia-peermem.conf" + echo "Module parameters provided for nvidia-peermem: ${NVIDIA_PEERMEM_MODULE_PARAMS[@]}" + fi +} + +_create_module_params_conf() { + echo "Parsing kernel module parameters..." + _get_module_params + + if [ ${#NVIDIA_MODULE_PARAMS[@]} -gt 0 ]; then + echo "Configuring nvidia module parameters in ${MODPROBE_CONFIG_DIR}/nvidia.conf" + echo "options nvidia ${NVIDIA_MODULE_PARAMS[@]}" > ${MODPROBE_CONFIG_DIR}/nvidia.conf + fi + if [ ${#NVIDIA_UVM_MODULE_PARAMS[@]} -gt 0 ]; then + echo "Configuring nvidia-uvm module parameters in ${MODPROBE_CONFIG_DIR}/nvidia-uvm.conf" + echo "options nvidia-uvm ${NVIDIA_UVM_MODULE_PARAMS[@]}" > ${MODPROBE_CONFIG_DIR}/nvidia-uvm.conf + fi + if [ ${#NVIDIA_MODESET_MODULE_PARAMS[@]} -gt 0 ]; then + echo "Configuring nvidia-modeset module parameters in ${MODPROBE_CONFIG_DIR}/nvidia-modeset.conf" + echo "options nvidia-modeset ${NVIDIA_MODESET_MODULE_PARAMS[@]}" > ${MODPROBE_CONFIG_DIR}/nvidia-modeset.conf + fi + if [ ${#NVIDIA_PEERMEM_MODULE_PARAMS[@]} -gt 0 ]; then + echo "Configuring nvidia-peermem module parameters in ${MODPROBE_CONFIG_DIR}/nvidia-peermem.conf" + echo "options nvidia-peermem ${NVIDIA_PEERMEM_MODULE_PARAMS[@]}" > ${MODPROBE_CONFIG_DIR}/nvidia-peermem.conf + fi +} + +# Load the kernel modules and start persistenced. +_load_driver() { + local nv_fw_search_path="$RUN_DIR/driver/lib/firmware" + local set_fw_path="true" + local fw_path_config_file="/sys/module/firmware_class/parameters/path" + for param in "${NVIDIA_MODULE_PARAMS[@]}"; do + if [[ "$param" == "NVreg_EnableGpuFirmware=0" ]]; then + set_fw_path="false" + fi + done + + if [[ "$set_fw_path" == "true" ]]; then + echo "Configuring the following firmware search path in '$fw_path_config_file': $nv_fw_search_path" + if [[ ! -z $(grep '[^[:space:]]' $fw_path_config_file) ]]; then + echo "WARNING: A search path is already configured in $fw_path_config_file" + echo " Retaining the current configuration" + else + echo -n "$nv_fw_search_path" > $fw_path_config_file || echo "WARNING: Failed to configure firmware search path" + fi + fi + + echo "Loading ipmi and i2c_core kernel modules..." + modprobe -a i2c_core ipmi_msghandler ipmi_devintf + + echo "Loading NVIDIA driver kernel modules..." + set -o xtrace +o nounset + modprobe nvidia + modprobe nvidia-uvm + modprobe nvidia-modeset + set +o xtrace -o nounset + + + if _gpu_direct_rdma_enabled; then + echo "Loading NVIDIA Peer Memory kernel module..." + set -o xtrace +o nounset + modprobe nvidia-peermem + set +o xtrace -o nounset + fi + + echo "Starting NVIDIA persistence daemon..." + nvidia-persistenced --persistence-mode + + DRIVER_VERSION=$(nvidia-smi -q | grep "Driver Version" | awk -F: '{print $2}' | xargs) + if _assert_nvlink5_system; then + _ensure_nvlink5_prerequisites || return 1 + + echo "Installing NVIDIA fabric manager, libnvsdm and nvlsm packages..." + nvlink5_pkgs_install + fabricmanager_install + nvsdm_install + imex_install + + echo "Starting NVIDIA fabric manager daemon for NVLink5+..." + + fm_config_file=/usr/share/nvidia/nvswitch/fabricmanager.cfg + fm_pid_file=/var/run/nvidia-fabricmanager/nv-fabricmanager.pid + nvlsm_config_file=/usr/share/nvidia/nvlsm/nvlsm.conf + nvlsm_pid_file=/var/run/nvidia-fabricmanager/nvlsm.pid + /usr/bin/nvidia-fabricmanager-start.sh --mode start \ + --fm-config-file $fm_config_file \ + --fm-pid-file $fm_pid_file \ + --nvlsm-config-file $nvlsm_config_file \ + --nvlsm-pid-file $nvlsm_pid_file + + # If not a NVLink5+ switch, check for the presence of NVLink4 (or below) switches + elif _assert_nvswitch_system; then + echo "Installing NVIDIA fabric manager and libnvidia NSCQ packages..." + fabricmanager_install + nscq_install + imex_install + + echo "Starting NVIDIA fabric manager daemon..." + nv-fabricmanager -c /usr/share/nvidia/nvswitch/fabricmanager.cfg + fi + + return 0 +} + +# Stop persistenced and unload the kernel modules if they are currently loaded. +_unload_driver() { + local rmmod_args=() + local nvidia_deps=0 + local nvidia_refs=0 + local nvidia_uvm_refs=0 + local nvidia_modeset_refs=0 + local nvidia_peermem_refs=0 + + if [ -f /var/run/nvidia-persistenced/nvidia-persistenced.pid ]; then + echo "Stopping NVIDIA persistence daemon..." + local pid=$(< /var/run/nvidia-persistenced/nvidia-persistenced.pid) + + kill -SIGTERM "${pid}" + for i in $(seq 1 50); do + kill -0 "${pid}" 2> /dev/null || break + sleep 0.1 + done + if [ $i -eq 50 ]; then + echo "Could not stop NVIDIA persistence daemon" >&2 + return 1 + fi + fi + + if [ -f /var/run/nvidia-fabricmanager/nv-fabricmanager.pid ]; then + echo "Stopping NVIDIA fabric manager daemon..." + local pid=$(< /var/run/nvidia-fabricmanager/nv-fabricmanager.pid) + + kill -SIGTERM "${pid}" + for i in $(seq 1 50); do + kill -0 "${pid}" 2> /dev/null || break + sleep 0.1 + done + if [ $i -eq 50 ]; then + echo "Could not stop NVIDIA fabric manager daemon" >&2 + return 1 + fi + fi + + if [ -f /var/run/nvidia-fabricmanager/nvlsm.pid ]; then + echo "Stopping NVLink Subnet Manager daemon..." + local pid=$(< /var/run/nvidia-fabricmanager/nvlsm.pid) + + kill -SIGTERM "${pid}" + for i in $(seq 1 50); do + kill -0 "${pid}" 2> /dev/null || break + sleep 0.1 + done + if [ $i -eq 50 ]; then + echo "Could not stop NVLink Subnet Manager daemon" >&2 + return 1 + fi + fi + + echo "Unloading NVIDIA driver kernel modules..." + if [ -f /sys/module/nvidia_drm/refcnt ]; then + nvidia_drm_refs=$(< /sys/module/nvidia_drm/refcnt) + rmmod_args+=("nvidia-drm") + ((++nvidia_deps)) + fi + if [ -f /sys/module/nvidia_modeset/refcnt ]; then + nvidia_modeset_refs=$(< /sys/module/nvidia_modeset/refcnt) + rmmod_args+=("nvidia-modeset") + ((++nvidia_deps)) + fi + if [ -f /sys/module/nvidia_uvm/refcnt ]; then + nvidia_uvm_refs=$(< /sys/module/nvidia_uvm/refcnt) + rmmod_args+=("nvidia-uvm") + ((++nvidia_deps)) + fi + if [ -f /sys/module/nvidia_peermem/refcnt ]; then + nvidia_peermem_refs=$(< /sys/module/nvidia_peermem/refcnt) + rmmod_args+=("nvidia-peermem") + ((++nvidia_deps)) + fi + if [ -f /sys/module/nvidia/refcnt ]; then + nvidia_refs=$(< /sys/module/nvidia/refcnt) + rmmod_args+=("nvidia") + fi + if [ ${nvidia_refs} -gt ${nvidia_deps} ]; then + # run lsmod to debug module usage + lsmod | grep nvidia + echo "Could not unload NVIDIA driver kernel modules, driver is in use" >&2 + return 1 + fi + + if [ ${#rmmod_args[@]} -gt 0 ]; then + rmmod ${rmmod_args[@]} + fi + return 0 +} + +_resolve_kernel_type_from_driver_branch() { + KERNEL_TYPE=kernel-open +} + +# _resolve_kernel_type determines which kernel module type, open or proprietary, to install. +# This function assumes that the nvidia-installer binary is in the PATH, so this function +# should only be invoked after the userspace driver components have been installed. +# +# KERNEL_MODULE_TYPE is the frontend interface that users can use to configure which module +# to install. Valid values for KERNEL_MODULE_TYPE are 'auto' (default), 'open', and 'proprietary'. +# When 'auto' is configured, we use the nvidia-installer to recommend the module type to install. +_resolve_kernel_type() { + if [ "${KERNEL_MODULE_TYPE}" == "proprietary" ]; then + KERNEL_TYPE=kernel + elif [ "${KERNEL_MODULE_TYPE}" == "open" ]; then + KERNEL_TYPE=kernel-open + elif [ "${KERNEL_MODULE_TYPE}" == "auto" ]; then + kernel_module_type=$(nvidia-installer --print-recommended-kernel-module-type 2> /dev/null) + if [ $? -ne 0 ]; then + echo "failed to retrieve the recommended kernel module type from nvidia-installer, falling back to using the driver branch" + _resolve_kernel_type_from_driver_branch + return 0 + fi + [[ "${kernel_module_type}" == "open" ]] && KERNEL_TYPE=kernel-open || KERNEL_TYPE=kernel + else + echo "invalid value for the KERNEL_MODULE_TYPE variable: ${KERNEL_MODULE_TYPE}" + return 1 + fi +} + +# Link and install the kernel modules from a precompiled packages +_install_driver() { + # Install necessary driver userspace packages + apt-get install -y --no-install-recommends \ + nvidia-utils-${DRIVER_BRANCH}-server \ + nvidia-headless-no-dkms-${DRIVER_BRANCH}-server \ + libnvidia-decode-${DRIVER_BRANCH}-server \ + libnvidia-extra-${DRIVER_BRANCH}-server \ + libnvidia-encode-${DRIVER_BRANCH}-server \ + libnvidia-fbc1-${DRIVER_BRANCH}-server \ + libnvidia-gl-${DRIVER_BRANCH}-server + + # Now install the precompiled kernel module packages signed by Canonical + if [ "$KERNEL_TYPE" = "kernel-open" ]; then + echo "Installing Open NVIDIA driver kernel modules..." + apt-get install --no-install-recommends -y \ + linux-signatures-nvidia-${KERNEL_VERSION} \ + linux-modules-nvidia-${DRIVER_BRANCH}-server-open-${KERNEL_VERSION} + else + echo "Installing Closed NVIDIA driver kernel modules..." + apt-get install --no-install-recommends -y \ + linux-objects-nvidia-${DRIVER_BRANCH}-server-${KERNEL_VERSION} \ + linux-signatures-nvidia-${KERNEL_VERSION} \ + linux-modules-nvidia-${DRIVER_BRANCH}-server-${KERNEL_VERSION} + fi +} + +# Mount the driver rootfs into the run directory with the exception of sysfs. +_mount_rootfs() { + echo "Mounting NVIDIA driver rootfs..." + mount --make-runbindable /sys + mount --make-private /sys + mkdir -p ${RUN_DIR}/driver + mount --rbind / ${RUN_DIR}/driver +} + +# Unmount the driver rootfs from the run directory. +_unmount_rootfs() { + echo "Unmounting NVIDIA driver rootfs..." + if findmnt -r -o TARGET | grep "${RUN_DIR}/driver" > /dev/null; then + umount -l -R ${RUN_DIR}/driver + fi +} + +init() { + # Determine the kernel module type + _resolve_kernel_type || exit 1 + + echo -e "\n========== NVIDIA Software Installer ==========\n" + echo -e "Starting installation of NVIDIA driver branch ${DRIVER_BRANCH} for Linux kernel version ${KERNEL_VERSION}\n" + + exec 3> ${PID_FILE} + if ! flock -n 3; then + echo "An instance of the NVIDIA driver is already running, aborting" + exit 1 + fi + echo $$ >&3 + + trap "echo 'Caught signal'; exit 1" HUP INT QUIT PIPE TERM + trap "_shutdown" EXIT + + _unload_driver || exit 1 + _unmount_rootfs + + _update_package_cache + + _create_module_params_conf + _install_driver + _load_driver || exit 1 + _mount_rootfs + + echo "Done, now waiting for signal" + sleep infinity & + trap "echo 'Caught signal'; _shutdown && { kill $!; exit 0; }" HUP INT QUIT PIPE TERM + trap - EXIT + while true; do wait $! || continue; done + exit 0 +} + +_shutdown() { + if _unload_driver; then + _unmount_rootfs + rm -f ${PID_FILE} + return 0 + fi + return 1 +} + +# Wait for MOFED drivers to be loaded and load nvidia-peermem whenever it gets unloaded during MOFED driver updates +reload_nvidia_peermem() { + if [ "$USE_HOST_MOFED" = "true" ]; then + until lsmod | grep mlx5_core > /dev/null 2>&1 && [ -f /sys/module/nvidia/refcnt ]; + do + echo "waiting for mellanox ofed and nvidia drivers to be installed" + sleep 10 + done + else + # use driver readiness flag created by MOFED container + until [ -f /run/mellanox/drivers/.driver-ready ] && [ -f /sys/module/nvidia/refcnt ]; + do + echo "waiting for mellanox ofed and nvidia drivers to be installed" + sleep 10 + done + fi + # get any parameters provided for nvidia-peermem + _get_module_params && set +o nounset + if chroot /run/nvidia/driver modprobe nvidia-peermem "${NVIDIA_PEERMEM_MODULE_PARAMS[@]}"; then + if [ -f /sys/module/nvidia_peermem/refcnt ]; then + echo "successfully loaded nvidia-peermem module, now waiting for signal" + sleep inf + trap "echo 'Caught signal'; exit 1" HUP INT QUIT PIPE TERM + fi + fi + echo "failed to load nvidia-peermem module" + exit 1 +} + +# probe by gpu-opertor for liveness/startup checks for nvidia-peermem module to be loaded when MOFED drivers are ready +probe_nvidia_peermem() { + if lsmod | grep mlx5_core > /dev/null 2>&1; then + if [ ! -f /sys/module/nvidia_peermem/refcnt ]; then + echo "nvidia-peermem module is not loaded" + return 1 + fi + else + echo "MOFED drivers are not ready, skipping probe to avoid container restarts..." + fi + return 0 +} + +usage() { + cat >&2 < Date: Tue, 9 Jun 2026 13:46:16 +0530 Subject: [PATCH 2/2] Remove .run file and add nvidia-installer wrapper Signed-off-by: Shiva Kumar (SW-CLOUD) Remove .run file and add nvidia-installer wrapper Signed-off-by: Shiva Kumar (SW-CLOUD) --- scripts/nvidia-installer | 1489 +++++++++++++++++++++++++ ubuntu26.04/precompiled/Dockerfile | 4 +- ubuntu26.04/precompiled/local-repo.sh | 13 - 3 files changed, 1491 insertions(+), 15 deletions(-) create mode 100755 scripts/nvidia-installer diff --git a/scripts/nvidia-installer b/scripts/nvidia-installer new file mode 100755 index 000000000..62b761102 --- /dev/null +++ b/scripts/nvidia-installer @@ -0,0 +1,1489 @@ +#!/usr/bin/env bash +# Derived from NVIDIA nvidia-installer source, including logic/data adapted +# from nvGpus.h and detect-self-hosted.h. +# +# Copyright (c) 2005, 2006, 2012, 2014, 2023 NVIDIA Corporation +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in 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: +# +# The above copyright notice and this permission notice (including the next +# paragraph) shall be included in all copies or substantial portions of the +# Software. +# +# 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 +# AUTHORS 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 IN THE +# SOFTWARE. + +set -eu + +readonly GPU_FLAGS_NO_GSP=$((1 << 0)) +readonly GPU_FLAGS_VGPU_GUEST=$((1 << 1)) +readonly GPU_FLAGS_VGPU_NO_GSP=$((1 << 2)) +readonly GPU_FLAGS_PROPRIETARY_POSSIBLE=$((1 << 3)) + +_read_hex_value() { + local path="$1" + local value + + value=$(<"$path") + echo "${value#0x}" | tr "[:upper:]" "[:lower:]" +} + +_as_hex_literal() { + echo "0x$1" +} + +_pci_devid_is_self_hosted() { + local devid="0x$1" + + (( devid >= 0x2340 && devid <= 0x237f )) || # GH100 Self-Hosted + (( devid >= 0x2940 && devid <= 0x297f )) || # GB100 Self-Hosted + (( devid >= 0x31c0 && devid <= 0x31ff )) || # GB110 Self-Hosted + (( devid == 0x31a1 )) # +} + +_pci_devid_gsp_unlikely() { + local devid="0x$1" + (( devid >= 0x1340 && devid < 0x1e00 )) +} + +_flags_expr_to_bits() { + local expr="$1" + local bits=0 + + [ -n "${expr}" ] || { echo 0; return 0; } + eval "bits=\$(( ${expr} ))" + echo "${bits}" +} + +GpuFlagList() { + case "$1" in + # static const GPU_FLAGS GpuFlagList[] from nvGpus.h + 0x1e02) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e04) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e07) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e09) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e30) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e36) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e78) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e81) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e82) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e84) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e87) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e89) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e90) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e91) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e93) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb5) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb6) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ec2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ec7) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ed0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ed1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ed3) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ef5) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f02) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f03) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f06) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f07) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f08) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f0a) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f0b) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f10) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f11) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f12) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f14) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f15) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f36) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f42) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f47) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f50) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f51) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f54) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f55) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f76) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f82) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f83) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f91) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f95) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f96) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f97) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f98) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f99) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f9c) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f9d) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1f9f) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fa0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fb0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fb1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fb2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fb6) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fb7) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fb8) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fb9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fba) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fbb) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fbc) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1fdd) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ff0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ff2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1ff9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b3) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b6) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20bd) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20fd) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2182) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2184) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2187) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2188) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2189) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2191) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2192) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x21c4) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x21d1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2203) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2204) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2206) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2207) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2208) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x220a) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x220d) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2216) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2232) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x230e) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2414) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2420) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2438) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2460) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2482) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2484) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2486) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2487) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2488) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2489) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x248a) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x249c) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x249d) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24a0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24b0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24b1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24b6) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24b7) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24b8) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24b9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24ba) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24bb) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24c7) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24c9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24dc) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24dd) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24e0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x24fa) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2503) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2504) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2507) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2508) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2520) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2521) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2523) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2531) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2544) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2560) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2563) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2571) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2582) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2584) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25a0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25a2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25a5) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25a6) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25a7) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25a9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25aa) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25ab) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25ac) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25ad) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b8) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25ba) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25bb) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25bc) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25bd) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25e0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25e2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25e5) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25ec) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25ed) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25f9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25fa) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25fb) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2684) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2685) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2689) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2702) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2704) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2705) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2709) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2717) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2730) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2757) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2770) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2782) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2783) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2786) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2788) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27a0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b2) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27ba) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27bb) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27e0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27fb) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2803) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2805) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2808) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2820) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2822) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2838) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2860) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2882) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28a0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28a1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28a3) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28b0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28b8) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28b9) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28ba) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28bb) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28e0) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28e1) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28e3) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x28f8) echo "GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + *) echo "" ;; + esac +} + +GpuSubDeviceFlagList() { + case "$1,$2,$3" in + # static const GPU_SUBDEVICE_FLAGS GpuSubDeviceFlagList[] from nvGpus.h + 0x1e37,0x10de,0x1347) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x1348) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x1349) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x136a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x136b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x136c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x13a4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x13a5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x13a6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x13a7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x13a8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x13a9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x180d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1e37,0x10de,0x1820) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1309) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x130a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x130b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x130c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x130d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x130e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x130f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1310) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1311) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1312) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1313) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1314) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1315) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1345) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1367) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1368) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1369) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x1375) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x139a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x1eb8,0x10de,0x139b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x146f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1470) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1471) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1472) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1473) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1474) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1475) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1476) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1477) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1478) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1479) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x160c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b0,0x10de,0x1840) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x1523) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x1524) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x1525) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x1526) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x1527) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x1528) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x1529) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x152a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x152b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x152c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x152d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x152e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x160d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b2,0x10de,0x1841) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1591) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1592) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1593) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1594) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1595) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1596) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1597) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1598) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x1599) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x159a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x159b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x159c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x160f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b5,0x10de,0x183e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x1589) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x158a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x158b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x158c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x158d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x158e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x158f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x1590) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x1610) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20b7,0x10de,0x183c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x1493) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x1494) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x1495) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x1496) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x1497) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x1498) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x1499) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x149a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x149b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x149c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x149d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x160e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f1,0x10de,0x183d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17b2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17b3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17b4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17b5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17b6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17b7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17b8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17b9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17ba) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17bb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17bc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17bd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x17be) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f3,0x10de,0x1842) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17bf) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17c9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17ca) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x17cb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f5,0x10de,0x183f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17cc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17cd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17ce) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17cf) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17d0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17d1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17d2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17d3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17d4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17d5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17d6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x17d7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x20f6,0x10de,0x1843) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x14fa) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x14fb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x14fc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x14fd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x14fe) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x14ff) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1500) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1501) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1502) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1503) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1504) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1505) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1506) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1507) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1508) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1509) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x150a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x150b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x150c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x150d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x150e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x150f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1510) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1511) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1512) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1513) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1514) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1515) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1516) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1517) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1518) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x1519) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x151a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2230,0x10de,0x2203) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1562) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1563) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1564) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1565) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1566) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1567) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1568) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1569) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x156a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x156b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x156c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x156d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x156e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x156f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1570) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1571) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1572) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1573) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1574) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1575) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1576) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1577) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1578) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x1579) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x157a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x157b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x157c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2231,0x10de,0x2205) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x165c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x165d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x165e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x165f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1660) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1661) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1662) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1663) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1664) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1665) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1666) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1667) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1668) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1669) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x166a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x166b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x166c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x166d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x166e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x166f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1670) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1671) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1672) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1673) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1674) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1675) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x1676) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2233,0x10de,0x2204) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14d5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14d6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14d7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14d8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14d9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14da) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14db) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14dc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14dd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14de) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14df) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14e9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14ea) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14eb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14ec) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14ed) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14ee) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14f3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14f4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14f5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14f6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14f7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14f8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x14f9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x1684) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x1685) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x1686) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x1687) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x1688) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x16e7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2235,0x10de,0x2206) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14b6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14b7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14b8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14b9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14ba) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14bb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14bc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14bd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14be) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14bf) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14c9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14ca) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14cb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14d0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14d1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14d2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14d3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x14d4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x167e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x167f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x1680) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x16e8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2236,0x10de,0x2207) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x155a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x155b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x155c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x155d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x155e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x155f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1560) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1561) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x162a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x162b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x162c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x162d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x162e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x162f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1630) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1631) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1632) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1633) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1634) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1635) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1636) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1637) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1638) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1639) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x163a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x163b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1810) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2237,0x10de,0x1811) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16a3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16a4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16a5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16a6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16a7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16a8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16a9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16aa) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16ab) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16ac) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16ad) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16ae) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16af) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16b9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x16e6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2238,0x10de,0x2208) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x1853) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x1854) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x1855) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x1856) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x1857) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x1858) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x1859) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x185a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x185b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x185c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x185d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x185e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x185f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2321,0x10de,0x1860) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17e2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17e3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17e4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17e5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17e6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17e7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17e8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17e9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17ea) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17eb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17ec) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17ed) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17ee) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x17ef) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2322,0x10de,0x1845) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18d5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18d6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18d7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18d8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18d9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18da) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18db) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18dc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18dd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18de) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18df) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18e0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18e1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18e2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2324,0x10de,0x18e3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2028) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2029) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x202a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x202b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x202c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x202d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x202e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x202f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2030) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2031) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2032) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2033) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2034) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2035) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2047) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2329,0x10de,0x2048) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2108) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2109) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x210a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x210b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x210c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x210d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x210e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x210f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2110) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2111) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2112) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2113) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2114) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2115) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2116) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x232c,0x10de,0x2117) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x187a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x187b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x187c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x187d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x187e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x187f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1880) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1881) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1882) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1883) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1884) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1885) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1886) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1887) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2330,0x10de,0x1888) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16d3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16d4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16d5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16d6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16d7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16d8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16d9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16da) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16db) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16dc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16dd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x16de) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x1798) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x17f0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2331,0x10de,0x1844) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x206e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x206f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2070) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2071) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2072) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2073) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2074) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2075) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2076) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2077) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2078) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x2079) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x207a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x207b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x207e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2335,0x10de,0x207f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18f2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18f3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18f4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18f5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18f6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18f7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18f8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18f9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18fa) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18fb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18fc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2337,0x10de,0x18fd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18e4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18e5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18e6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18e7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18e8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18e9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18ea) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18eb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18ec) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18ed) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18ee) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18ef) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18f0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2339,0x10de,0x18f1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1861) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1862) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1863) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1864) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1865) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1866) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1867) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1868) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x1869) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x186a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x186b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x186c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x186d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233a,0x10de,0x186e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2081) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2082) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2083) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2084) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2085) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2086) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2087) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2088) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2089) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x208a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x208b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x208c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x208d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x208e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x208f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x233b,0x10de,0x2090) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2342,0x10de,0x18c2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2342,0x10de,0x18c3) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2342,0x10de,0x18c4) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2342,0x10de,0x18c5) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2342,0x10de,0x18c6) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2342,0x10de,0x18c7) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2342,0x10de,0x18c8) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2342,0x10de,0x18c9) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2348,0x10de,0x20c2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2348,0x10de,0x20c3) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2348,0x10de,0x20c4) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2348,0x10de,0x20c5) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2348,0x10de,0x20c6) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2348,0x10de,0x20c7) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2348,0x10de,0x20c8) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2348,0x10de,0x20c9) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x25b6,0x10de,0x159d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x159e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x159f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1600) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1601) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1602) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1603) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1604) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1605) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1606) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1607) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1608) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1609) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x160a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x160b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1646) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1647) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1648) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1649) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x164a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x164b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x164c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x164d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x164e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x164f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1650) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1651) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1652) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1653) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1654) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1655) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1656) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x1657) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x2209) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x25b6,0x10de,0x220a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_VGPU_NO_GSP | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1708) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1709) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x170a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x170b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x170c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x170d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x170e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x170f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1710) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1711) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1712) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1713) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1714) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1715) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1716) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1717) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1718) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1719) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x171a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x171b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x171c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x171d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x171e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x171f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1720) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1721) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1722) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1723) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1724) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1725) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1726) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1727) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1728) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x1729) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x172a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x172b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x172c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x172d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x172e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b1,0x10de,0x21fa) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1821) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1822) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1823) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1824) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1825) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1826) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1827) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1828) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1829) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x182a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x182b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x182c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x182d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x182e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x182f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1830) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1831) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1832) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1833) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1834) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1835) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1836) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1837) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x1838) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b2,0x10de,0x21fc) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1958) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1959) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x195a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x195b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x195c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x195d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x195e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x195f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1960) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1961) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1962) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1963) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1964) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1965) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1966) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1967) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1968) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1969) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x196a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x196b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x196c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x196d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x196e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x196f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1970) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1971) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1972) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1973) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1974) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1975) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1976) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1977) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1978) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x1979) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x197a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x197b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x197c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x197d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x197e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b3,0x10de,0x21fb) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x176d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x176e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x176f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1770) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1771) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1772) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1773) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1774) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1775) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1776) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1777) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1778) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1779) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x177a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x177b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x177c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x177d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x177e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x177f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1780) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1781) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1782) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1783) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1784) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1785) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1786) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1787) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1788) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1789) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x178a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x178b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x178c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x178d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x178e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x178f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1790) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1791) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1792) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1793) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x1818) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x181a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b5,0x10de,0x21fd) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x174e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x174f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1750) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1751) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1752) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1753) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1754) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1755) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1756) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1757) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1758) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1759) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x175a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x175b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x175c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x175d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x175e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x175f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1760) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1761) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1762) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1763) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1764) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1765) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1766) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1767) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1768) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x1769) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x176a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x176b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x176c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x181c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x181e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b8,0x10de,0x21ff) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1889) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x188a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x188b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x188c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x188d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x188e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x188f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1890) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1891) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1892) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1893) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1894) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1895) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1896) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1897) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1898) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x1899) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x189a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x189b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x189c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x189d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x189e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x189f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a2) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a3) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a4) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a5) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a6) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a7) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a8) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18a9) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18aa) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18ab) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18ac) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18ad) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18ae) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18af) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18b0) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x18b1) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26b9,0x10de,0x21fe) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1909) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x190a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x190b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x190c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x190d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x190e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x190f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1910) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1911) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1912) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1913) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1914) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1915) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1916) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1917) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1918) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1919) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x191a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x191b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x191c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x191d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x191e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x191f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1920) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1921) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1922) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1923) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1924) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1925) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1926) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1927) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1928) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1929) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x192a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x192b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x192c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x192d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x192e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x192f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1930) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x1931) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x26ba,0x10de,0x2200) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1938) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1939) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x193a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x193b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x193c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x193d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x193e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x193f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1940) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1941) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1942) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1943) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1944) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1945) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1946) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1947) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1948) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1949) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x194a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x194b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x194c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x194d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x194e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x194f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1950) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1951) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1952) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1953) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1954) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1955) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x1956) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b6,0x10de,0x2202) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x172f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1730) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1731) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1732) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1733) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1734) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1735) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1736) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1737) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1738) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1739) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x173a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x173b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x173c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x173d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x173e) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x173f) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1740) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1741) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1742) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1743) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1744) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1745) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1746) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1747) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1748) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x1749) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x174a) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x174b) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x174c) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x174d) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x27b8,0x10de,0x2201) echo "GPU_FLAGS_VGPU_GUEST | GPU_FLAGS_PROPRIETARY_POSSIBLE" ;; + 0x2901,0x10de,0x21d7) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2901,0x10de,0x21d8) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2901,0x10de,0x21d9) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2901,0x10de,0x21da) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2901,0x10de,0x21db) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2901,0x10de,0x21dc) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2901,0x10de,0x21dd) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2901,0x10de,0x21ea) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2941,0x10de,0x20cb) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2941,0x10de,0x20cc) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2941,0x10de,0x20cd) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2941,0x10de,0x20ce) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2941,0x10de,0x20cf) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2941,0x10de,0x20d0) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2941,0x10de,0x20d1) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2941,0x10de,0x20d2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2160) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2161) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2162) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2163) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2164) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2165) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2166) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2167) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2168) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2169) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x216a) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x216b) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x216c) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x216d) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x216e) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x216f) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2170) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2171) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2172) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2173) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2174) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2175) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2176) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2177) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2178) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2179) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x217a) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x217b) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x217c) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x217d) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x217e) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x217f) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2180) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2181) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2182) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2183) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2184) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2185) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2186) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2187) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2188) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2189) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x218a) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x218b) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x218c) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x218d) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x218e) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x218f) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2190) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2191) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2192) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2193) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2194) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2195) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2196) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2197) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2198) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x2199) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x219a) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x219b) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x219c) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x219d) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x219e) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x219f) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21a0) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21a1) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21a2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21a3) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21a4) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21a5) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21a6) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21a7) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21ae) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21af) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b0) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b1) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b3) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b4) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b5) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b6) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b7) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b8) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21b9) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21ba) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21bb) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21bc) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21bd) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21be) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21bf) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21c0) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21c1) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21c2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21c3) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21c4) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21c5) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21c6) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21c7) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21f8) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb5,0x10de,0x21f9) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x2233) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x2234) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x2235) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x2236) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x2243) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x2244) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x2245) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x2246) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x226c) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x226d) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x226e) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x226f) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x22ee) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2bb9,0x10de,0x22ef) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x2295) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x2296) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x2297) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x2298) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x2299) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x229a) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x229b) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x229c) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x229d) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x229e) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x229f) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a0) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a1) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a3) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a4) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a5) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a6) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a7) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a8) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22a9) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22aa) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22ab) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22ac) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22ad) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22ae) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22af) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b0) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b1) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b3) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b4) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b5) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b6) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b7) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b8) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22b9) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22ba) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22bb) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22bc) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22bd) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22be) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22bf) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22c0) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22c1) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x2c3a,0x10de,0x22c2) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x3182,0x10de,0x22cb) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x3182,0x10de,0x22cc) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x3182,0x10de,0x22cd) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x3182,0x10de,0x22ce) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x3182,0x10de,0x22cf) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x3182,0x10de,0x22d0) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x3182,0x10de,0x22d1) echo "GPU_FLAGS_VGPU_GUEST" ;; + 0x3182,0x10de,0x22d2) echo "GPU_FLAGS_VGPU_GUEST" ;; + *) GpuFlagList "$1" ;; + esac +} + +_gpu_flags_for_subdevice() { + local expr + expr=$(GpuSubDeviceFlagList "$1" "$2" "$3") + _flags_expr_to_bits "${expr}" +} + +print_recommended_kernel_module_type() { + local open_modules_required=false + local supported_gpu_present=false + local unsupported_gpu_present=false + + for dev in /sys/bus/pci/devices/*; do + local vendor devid subvendor subdevice flags + local device_has_gsp=true + + [ -f "${dev}/vendor" ] || continue + vendor=$(_read_hex_value "${dev}/vendor") + [ "${vendor}" = "10de" ] || continue + + [ -f "${dev}/device" ] || continue + devid=$(_read_hex_value "${dev}/device") + subvendor=$(_read_hex_value "${dev}/subsystem_vendor") + subdevice=$(_read_hex_value "${dev}/subsystem_device") + + if _pci_devid_is_self_hosted "${devid}"; then + open_modules_required=true + supported_gpu_present=true + continue + fi + + flags=$(_gpu_flags_for_subdevice "$(_as_hex_literal "${devid}")" "$(_as_hex_literal "${subvendor}")" "$(_as_hex_literal "${subdevice}")") + + if (( (flags & GPU_FLAGS_NO_GSP) != 0 )) || + (( (flags & GPU_FLAGS_VGPU_GUEST) != 0 && (flags & GPU_FLAGS_VGPU_NO_GSP) != 0 )); then + device_has_gsp=false + fi + + if [ "${flags}" -eq 0 ] && _pci_devid_gsp_unlikely "${devid}"; then + device_has_gsp=false + fi + + if [ "${device_has_gsp}" = true ]; then + supported_gpu_present=true + else + unsupported_gpu_present=true + fi + done + + if [ "${open_modules_required}" = true ]; then + echo "open" + elif [ "${supported_gpu_present}" = false ] || [ "${unsupported_gpu_present}" = true ]; then + echo "proprietary" + else + echo "open" + fi +} + +main() { + case "${1:-}" in + --print-recommended-kernel-module-type) + [ "$#" -eq 1 ] || exit 1 + print_recommended_kernel_module_type + ;; + *) + echo "unsupported option: ${1:-}" >&2 + exit 1 + ;; + esac +} + +main "$@" diff --git a/ubuntu26.04/precompiled/Dockerfile b/ubuntu26.04/precompiled/Dockerfile index 1e335a864..2816a4408 100644 --- a/ubuntu26.04/precompiled/Dockerfile +++ b/ubuntu26.04/precompiled/Dockerfile @@ -3,7 +3,6 @@ FROM ${BASE_IMAGE} ENV DEBIAN_FRONTEND=noninteractive -ARG BASE_URL=https://us.download.nvidia.com/tesla ARG TARGETARCH ENV TARGETARCH=$TARGETARCH ARG DRIVER_BRANCH=595 @@ -46,13 +45,14 @@ RUN if [ -n "${CVE_UPDATES}" ]; then \ fi COPY ubuntu26.04/precompiled/nvidia-driver /usr/local/bin +COPY scripts/nvidia-installer /usr/local/bin ADD ubuntu26.04/precompiled/local-repo.sh /tmp +RUN chmod +x /usr/local/bin/nvidia-installer RUN mkdir -p /usr/local/repos && \ /tmp/local-repo.sh download_driver_package_deps && \ /tmp/local-repo.sh build_local_apt_repo && \ - /tmp/local-repo.sh fetch_nvidia_installer && \ # Remove all other ubuntu apt sources to ensure we only pull from the local apt repo rm /etc/apt/sources.list.d/* diff --git a/ubuntu26.04/precompiled/local-repo.sh b/ubuntu26.04/precompiled/local-repo.sh index 46713a601..0335ed53a 100755 --- a/ubuntu26.04/precompiled/local-repo.sh +++ b/ubuntu26.04/precompiled/local-repo.sh @@ -3,8 +3,6 @@ set -eu LOCAL_REPO_DIR=/usr/local/repos -DRIVER_ARCH=${TARGETARCH/amd64/x86_64} && DRIVER_ARCH=${DRIVER_ARCH/arm64/aarch64} -DRIVER_RUN_FILE=NVIDIA-Linux-$DRIVER_ARCH-$DRIVER_VERSION download_apt_with_dep () { local package_name="$1" @@ -79,21 +77,10 @@ build_local_apt_repo () { apt-get update } -fetch_nvidia_installer () { - curl -fSsl -O $BASE_URL/$DRIVER_VERSION/$DRIVER_RUN_FILE.run - chmod +x $DRIVER_RUN_FILE.run - sh $DRIVER_RUN_FILE.run -x - mv $DRIVER_RUN_FILE/nvidia-installer /usr/bin/ - rm -rf $DRIVER_RUN_FILE - rm $DRIVER_RUN_FILE.run -} - if [ "$1" = "download_driver_package_deps" ]; then download_driver_package_deps elif [ "$1" = "build_local_apt_repo" ]; then build_local_apt_repo -elif [ "$1" = "fetch_nvidia_installer" ]; then - fetch_nvidia_installer else echo "Unknown function: $1" exit 1