VFIO updates 2018-03-13
- Display support for vGPUs (Gerd Hoffmann) - Enable new kernel support for mmaps overlapping MSI-X vector table, disable MSI-X emulation on POWER (Alexey Kardashevskiy) -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.14 (GNU/Linux) iQIcBAABAgAGBQJaqCshAAoJECObm247sIsivFQP/3Y0e0mW4fbf1Z0uRiduZ3Bh bAKD52n8Id3alAmelo1P7OUS8LP0vdw9lLAJz9m3VB+Nvye0XewFn0/9SVLnL022 aCBIj9cGg57hraTd6PUfsfG8T1HryDeQqE/PRIYEaqf9htBZ51VM2EY3+n2O7Bcy TVDnac0IOaWb8FrXK+lGpLP6dPFQ0Z+mhkAvDR7v7FZGEy000D71+gKOe4aIAMib X/NJa42O1x9cbDE39AEpVMub/QYwtRD/HkcZwNylyY4YKIjsMtxPYYz2Ndt+wm0r e21s/4iy2a1HXen4OBc2KAnpVoZyGnXya6KZ0dzirt8Q1dK606Az/HxifVb/CJQZ L10NSfYTWNPfPlf0gYZmPlZeZDuNeZaHi8bZGqTquL4AAOTdqtQOMEoT+68qd74s 00B9XrA2Jmjvpya2pHQSqvAsuSqZ1E2iRMGMC9r/+UYb54OnXnrl9fOw/TtbrLMm isbB1Ll0hDcJvacikYJ5ck+lGrFLHbYpWtBIrokBHbw9fwl1I9aY5MloBYZwmcTz e65L7M4MvA/y6gSlCi6DS1fmdZ5ecNnBkuW6YseDI884P4c4+YDMOhs/B/rO16v6 In2fSWvb+DSuAPmn+6QDV0msJg34J2oykbKcdDK7F1g7By/yDNVVgHPoWhi4EGBA u09A/2nM0VwhXYNrElJI =LVMf -----END PGP SIGNATURE----- Merge remote-tracking branch 'remotes/awilliam/tags/vfio-update-20180313.0' into staging VFIO updates 2018-03-13 - Display support for vGPUs (Gerd Hoffmann) - Enable new kernel support for mmaps overlapping MSI-X vector table, disable MSI-X emulation on POWER (Alexey Kardashevskiy) # gpg: Signature made Tue 13 Mar 2018 19:48:49 GMT # gpg: using RSA key 239B9B6E3BB08B22 # gpg: Good signature from "Alex Williamson <alex.williamson@redhat.com>" # gpg: aka "Alex Williamson <alex@shazbot.org>" # gpg: aka "Alex Williamson <alwillia@redhat.com>" # gpg: aka "Alex Williamson <alex.l.williamson@gmail.com>" # Primary key fingerprint: 42F6 C04E 540B D1A9 9E7B 8A90 239B 9B6E 3BB0 8B22 * remotes/awilliam/tags/vfio-update-20180313.0: ppc/spapr, vfio: Turn off MSIX emulation for VFIO devices vfio-pci: Allow mmap of MSIX BAR vfio/pci: Relax DMA map errors for MMIO regions vfio/display: adding dmabuf support vfio/display: adding region support vfio/display: core & wireup vfio/common: cleanup in vfio_region_finalize secondary-vga: properly close QemuConsole on unplug console: minimal hotplug suport ui/pixman: add qemu_drm_format_to_pixman() standard-headers: add drm/drm_fourcc.h Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
commit
a57946ff2a
|
@ -292,6 +292,14 @@ static void pci_secondary_vga_realize(PCIDevice *dev, Error **errp)
|
|||
pci_register_bar(&d->dev, 2, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio);
|
||||
}
|
||||
|
||||
static void pci_secondary_vga_exit(PCIDevice *dev)
|
||||
{
|
||||
PCIVGAState *d = PCI_VGA(dev);
|
||||
VGACommonState *s = &d->vga;
|
||||
|
||||
graphic_console_close(s->con);
|
||||
}
|
||||
|
||||
static void pci_secondary_vga_init(Object *obj)
|
||||
{
|
||||
/* Expose framebuffer byteorder via QOM */
|
||||
|
@ -361,6 +369,7 @@ static void secondary_class_init(ObjectClass *klass, void *data)
|
|||
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
|
||||
|
||||
k->realize = pci_secondary_vga_realize;
|
||||
k->exit = pci_secondary_vga_exit;
|
||||
k->class_id = PCI_CLASS_DISPLAY_OTHER;
|
||||
dc->props = secondary_pci_properties;
|
||||
dc->reset = pci_secondary_vga_reset;
|
||||
|
|
|
@ -2855,6 +2855,11 @@ static void spapr_set_modern_hotplug_events(Object *obj, bool value,
|
|||
spapr->use_hotplug_event_source = value;
|
||||
}
|
||||
|
||||
static bool spapr_get_msix_emulation(Object *obj, Error **errp)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
static char *spapr_get_resize_hpt(Object *obj, Error **errp)
|
||||
{
|
||||
sPAPRMachineState *spapr = SPAPR_MACHINE(obj);
|
||||
|
@ -2936,6 +2941,8 @@ static void spapr_instance_init(Object *obj)
|
|||
object_property_set_description(obj, "vsmt",
|
||||
"Virtual SMT: KVM behaves as if this were"
|
||||
" the host's SMT mode", &error_abort);
|
||||
object_property_add_bool(obj, "vfio-no-msix-emulation",
|
||||
spapr_get_msix_emulation, NULL, NULL);
|
||||
}
|
||||
|
||||
static void spapr_machine_finalizefn(Object *obj)
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
ifeq ($(CONFIG_LINUX), y)
|
||||
obj-$(CONFIG_SOFTMMU) += common.o
|
||||
obj-$(CONFIG_PCI) += pci.o pci-quirks.o
|
||||
obj-$(CONFIG_PCI) += pci.o pci-quirks.o display.o
|
||||
obj-$(CONFIG_VFIO_CCW) += ccw.o
|
||||
obj-$(CONFIG_SOFTMMU) += platform.o
|
||||
obj-$(CONFIG_VFIO_XGMAC) += calxeda-xgmac.o
|
||||
|
|
|
@ -544,18 +544,40 @@ static void vfio_listener_region_add(MemoryListener *listener,
|
|||
|
||||
llsize = int128_sub(llend, int128_make64(iova));
|
||||
|
||||
if (memory_region_is_ram_device(section->mr)) {
|
||||
hwaddr pgmask = (1ULL << ctz64(hostwin->iova_pgsizes)) - 1;
|
||||
|
||||
if ((iova & pgmask) || (int128_get64(llsize) & pgmask)) {
|
||||
error_report("Region 0x%"HWADDR_PRIx"..0x%"HWADDR_PRIx
|
||||
" is not aligned to 0x%"HWADDR_PRIx
|
||||
" and cannot be mapped for DMA",
|
||||
section->offset_within_region,
|
||||
int128_getlo(section->size),
|
||||
pgmask + 1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
ret = vfio_dma_map(container, iova, int128_get64(llsize),
|
||||
vaddr, section->readonly);
|
||||
if (ret) {
|
||||
error_report("vfio_dma_map(%p, 0x%"HWADDR_PRIx", "
|
||||
"0x%"HWADDR_PRIx", %p) = %d (%m)",
|
||||
container, iova, int128_get64(llsize), vaddr, ret);
|
||||
if (memory_region_is_ram_device(section->mr)) {
|
||||
/* Allow unexpected mappings not to be fatal for RAM devices */
|
||||
return;
|
||||
}
|
||||
goto fail;
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
fail:
|
||||
if (memory_region_is_ram_device(section->mr)) {
|
||||
error_report("failed to vfio_dma_map. pci p2p may not work");
|
||||
return;
|
||||
}
|
||||
/*
|
||||
* On the initfn path, store the first error in the container so we
|
||||
* can gracefully fail. Runtime, there's not much we can do other
|
||||
|
@ -577,6 +599,7 @@ static void vfio_listener_region_del(MemoryListener *listener,
|
|||
hwaddr iova, end;
|
||||
Int128 llend, llsize;
|
||||
int ret;
|
||||
bool try_unmap = true;
|
||||
|
||||
if (vfio_listener_skipped_section(section)) {
|
||||
trace_vfio_listener_region_del_skip(
|
||||
|
@ -629,14 +652,34 @@ static void vfio_listener_region_del(MemoryListener *listener,
|
|||
|
||||
trace_vfio_listener_region_del(iova, end);
|
||||
|
||||
ret = vfio_dma_unmap(container, iova, int128_get64(llsize));
|
||||
memory_region_unref(section->mr);
|
||||
if (ret) {
|
||||
error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", "
|
||||
"0x%"HWADDR_PRIx") = %d (%m)",
|
||||
container, iova, int128_get64(llsize), ret);
|
||||
if (memory_region_is_ram_device(section->mr)) {
|
||||
hwaddr pgmask;
|
||||
VFIOHostDMAWindow *hostwin;
|
||||
bool hostwin_found = false;
|
||||
|
||||
QLIST_FOREACH(hostwin, &container->hostwin_list, hostwin_next) {
|
||||
if (hostwin->min_iova <= iova && end <= hostwin->max_iova) {
|
||||
hostwin_found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert(hostwin_found); /* or region_add() would have failed */
|
||||
|
||||
pgmask = (1ULL << ctz64(hostwin->iova_pgsizes)) - 1;
|
||||
try_unmap = !((iova & pgmask) || (int128_get64(llsize) & pgmask));
|
||||
}
|
||||
|
||||
if (try_unmap) {
|
||||
ret = vfio_dma_unmap(container, iova, int128_get64(llsize));
|
||||
if (ret) {
|
||||
error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", "
|
||||
"0x%"HWADDR_PRIx") = %d (%m)",
|
||||
container, iova, int128_get64(llsize), ret);
|
||||
}
|
||||
}
|
||||
|
||||
memory_region_unref(section->mr);
|
||||
|
||||
if (container->iommu_type == VFIO_SPAPR_TCE_v2_IOMMU) {
|
||||
vfio_spapr_remove_window(container,
|
||||
section->offset_within_address_space);
|
||||
|
@ -858,6 +901,13 @@ void vfio_region_finalize(VFIORegion *region)
|
|||
g_free(region->mmaps);
|
||||
|
||||
trace_vfio_region_finalize(region->vbasedev->name, region->nr);
|
||||
|
||||
region->mem = NULL;
|
||||
region->mmaps = NULL;
|
||||
region->nr_mmaps = 0;
|
||||
region->size = 0;
|
||||
region->flags = 0;
|
||||
region->nr = 0;
|
||||
}
|
||||
|
||||
void vfio_region_mmaps_set_enabled(VFIORegion *region, bool enabled)
|
||||
|
@ -1421,6 +1471,21 @@ int vfio_get_dev_region_info(VFIODevice *vbasedev, uint32_t type,
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
bool vfio_has_region_cap(VFIODevice *vbasedev, int region, uint16_t cap_type)
|
||||
{
|
||||
struct vfio_region_info *info = NULL;
|
||||
bool ret = false;
|
||||
|
||||
if (!vfio_get_region_info(vbasedev, region, &info)) {
|
||||
if (vfio_get_region_info_cap(info, cap_type)) {
|
||||
ret = true;
|
||||
}
|
||||
g_free(info);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Interfaces for IBM EEH (Enhanced Error Handling)
|
||||
*/
|
||||
|
|
347
hw/vfio/display.c
Normal file
347
hw/vfio/display.c
Normal file
|
@ -0,0 +1,347 @@
|
|||
/*
|
||||
* display support for mdev based vgpu devices
|
||||
*
|
||||
* Copyright Red Hat, Inc. 2017
|
||||
*
|
||||
* Authors:
|
||||
* Gerd Hoffmann
|
||||
*
|
||||
* This work is licensed under the terms of the GNU GPL, version 2. See
|
||||
* the COPYING file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include <linux/vfio.h>
|
||||
#include <sys/ioctl.h>
|
||||
|
||||
#include "sysemu/sysemu.h"
|
||||
#include "ui/console.h"
|
||||
#include "qapi/error.h"
|
||||
#include "pci.h"
|
||||
|
||||
#ifndef DRM_PLANE_TYPE_PRIMARY
|
||||
# define DRM_PLANE_TYPE_PRIMARY 1
|
||||
# define DRM_PLANE_TYPE_CURSOR 2
|
||||
#endif
|
||||
|
||||
static void vfio_display_update_cursor(VFIODMABuf *dmabuf,
|
||||
struct vfio_device_gfx_plane_info *plane)
|
||||
{
|
||||
if (dmabuf->pos_x != plane->x_pos || dmabuf->pos_y != plane->y_pos) {
|
||||
dmabuf->pos_x = plane->x_pos;
|
||||
dmabuf->pos_y = plane->y_pos;
|
||||
dmabuf->pos_updates++;
|
||||
}
|
||||
if (dmabuf->hot_x != plane->x_hot || dmabuf->hot_y != plane->y_hot) {
|
||||
dmabuf->hot_x = plane->x_hot;
|
||||
dmabuf->hot_y = plane->y_hot;
|
||||
dmabuf->hot_updates++;
|
||||
}
|
||||
}
|
||||
|
||||
static VFIODMABuf *vfio_display_get_dmabuf(VFIOPCIDevice *vdev,
|
||||
uint32_t plane_type)
|
||||
{
|
||||
VFIODisplay *dpy = vdev->dpy;
|
||||
struct vfio_device_gfx_plane_info plane;
|
||||
VFIODMABuf *dmabuf;
|
||||
int fd, ret;
|
||||
|
||||
memset(&plane, 0, sizeof(plane));
|
||||
plane.argsz = sizeof(plane);
|
||||
plane.flags = VFIO_GFX_PLANE_TYPE_DMABUF;
|
||||
plane.drm_plane_type = plane_type;
|
||||
ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &plane);
|
||||
if (ret < 0) {
|
||||
return NULL;
|
||||
}
|
||||
if (!plane.drm_format || !plane.size) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
QTAILQ_FOREACH(dmabuf, &dpy->dmabuf.bufs, next) {
|
||||
if (dmabuf->dmabuf_id == plane.dmabuf_id) {
|
||||
/* found in list, move to head, return it */
|
||||
QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next);
|
||||
QTAILQ_INSERT_HEAD(&dpy->dmabuf.bufs, dmabuf, next);
|
||||
if (plane_type == DRM_PLANE_TYPE_CURSOR) {
|
||||
vfio_display_update_cursor(dmabuf, &plane);
|
||||
}
|
||||
return dmabuf;
|
||||
}
|
||||
}
|
||||
|
||||
fd = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_GET_GFX_DMABUF, &plane.dmabuf_id);
|
||||
if (fd < 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
dmabuf = g_new0(VFIODMABuf, 1);
|
||||
dmabuf->dmabuf_id = plane.dmabuf_id;
|
||||
dmabuf->buf.width = plane.width;
|
||||
dmabuf->buf.height = plane.height;
|
||||
dmabuf->buf.stride = plane.stride;
|
||||
dmabuf->buf.fourcc = plane.drm_format;
|
||||
dmabuf->buf.fd = fd;
|
||||
if (plane_type == DRM_PLANE_TYPE_CURSOR) {
|
||||
vfio_display_update_cursor(dmabuf, &plane);
|
||||
}
|
||||
|
||||
QTAILQ_INSERT_HEAD(&dpy->dmabuf.bufs, dmabuf, next);
|
||||
return dmabuf;
|
||||
}
|
||||
|
||||
static void vfio_display_free_one_dmabuf(VFIODisplay *dpy, VFIODMABuf *dmabuf)
|
||||
{
|
||||
QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next);
|
||||
dpy_gl_release_dmabuf(dpy->con, &dmabuf->buf);
|
||||
close(dmabuf->buf.fd);
|
||||
g_free(dmabuf);
|
||||
}
|
||||
|
||||
static void vfio_display_free_dmabufs(VFIOPCIDevice *vdev)
|
||||
{
|
||||
VFIODisplay *dpy = vdev->dpy;
|
||||
VFIODMABuf *dmabuf, *tmp;
|
||||
uint32_t keep = 5;
|
||||
|
||||
QTAILQ_FOREACH_SAFE(dmabuf, &dpy->dmabuf.bufs, next, tmp) {
|
||||
if (keep > 0) {
|
||||
keep--;
|
||||
continue;
|
||||
}
|
||||
assert(dmabuf != dpy->dmabuf.primary);
|
||||
vfio_display_free_one_dmabuf(dpy, dmabuf);
|
||||
}
|
||||
}
|
||||
|
||||
static void vfio_display_dmabuf_update(void *opaque)
|
||||
{
|
||||
VFIOPCIDevice *vdev = opaque;
|
||||
VFIODisplay *dpy = vdev->dpy;
|
||||
VFIODMABuf *primary, *cursor;
|
||||
bool free_bufs = false, new_cursor = false;;
|
||||
|
||||
primary = vfio_display_get_dmabuf(vdev, DRM_PLANE_TYPE_PRIMARY);
|
||||
if (primary == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (dpy->dmabuf.primary != primary) {
|
||||
dpy->dmabuf.primary = primary;
|
||||
qemu_console_resize(dpy->con,
|
||||
primary->buf.width, primary->buf.height);
|
||||
dpy_gl_scanout_dmabuf(dpy->con, &primary->buf);
|
||||
free_bufs = true;
|
||||
}
|
||||
|
||||
cursor = vfio_display_get_dmabuf(vdev, DRM_PLANE_TYPE_CURSOR);
|
||||
if (dpy->dmabuf.cursor != cursor) {
|
||||
dpy->dmabuf.cursor = cursor;
|
||||
new_cursor = true;
|
||||
free_bufs = true;
|
||||
}
|
||||
|
||||
if (cursor && (new_cursor || cursor->hot_updates)) {
|
||||
bool have_hot = (cursor->hot_x != 0xffffffff &&
|
||||
cursor->hot_y != 0xffffffff);
|
||||
dpy_gl_cursor_dmabuf(dpy->con, &cursor->buf, have_hot,
|
||||
cursor->hot_x, cursor->hot_y);
|
||||
cursor->hot_updates = 0;
|
||||
} else if (!cursor && new_cursor) {
|
||||
dpy_gl_cursor_dmabuf(dpy->con, NULL, false, 0, 0);
|
||||
}
|
||||
|
||||
if (cursor && cursor->pos_updates) {
|
||||
dpy_gl_cursor_position(dpy->con,
|
||||
cursor->pos_x,
|
||||
cursor->pos_y);
|
||||
cursor->pos_updates = 0;
|
||||
}
|
||||
|
||||
dpy_gl_update(dpy->con, 0, 0, primary->buf.width, primary->buf.height);
|
||||
|
||||
if (free_bufs) {
|
||||
vfio_display_free_dmabufs(vdev);
|
||||
}
|
||||
}
|
||||
|
||||
static const GraphicHwOps vfio_display_dmabuf_ops = {
|
||||
.gfx_update = vfio_display_dmabuf_update,
|
||||
};
|
||||
|
||||
static int vfio_display_dmabuf_init(VFIOPCIDevice *vdev, Error **errp)
|
||||
{
|
||||
if (!display_opengl) {
|
||||
error_setg(errp, "vfio-display-dmabuf: opengl not available");
|
||||
return -1;
|
||||
}
|
||||
|
||||
vdev->dpy = g_new0(VFIODisplay, 1);
|
||||
vdev->dpy->con = graphic_console_init(DEVICE(vdev), 0,
|
||||
&vfio_display_dmabuf_ops,
|
||||
vdev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void vfio_display_dmabuf_exit(VFIODisplay *dpy)
|
||||
{
|
||||
VFIODMABuf *dmabuf;
|
||||
|
||||
if (QTAILQ_EMPTY(&dpy->dmabuf.bufs)) {
|
||||
return;
|
||||
}
|
||||
|
||||
while ((dmabuf = QTAILQ_FIRST(&dpy->dmabuf.bufs)) != NULL) {
|
||||
vfio_display_free_one_dmabuf(dpy, dmabuf);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
static void vfio_display_region_update(void *opaque)
|
||||
{
|
||||
VFIOPCIDevice *vdev = opaque;
|
||||
VFIODisplay *dpy = vdev->dpy;
|
||||
struct vfio_device_gfx_plane_info plane = {
|
||||
.argsz = sizeof(plane),
|
||||
.flags = VFIO_GFX_PLANE_TYPE_REGION
|
||||
};
|
||||
pixman_format_code_t format;
|
||||
int ret;
|
||||
|
||||
ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &plane);
|
||||
if (ret < 0) {
|
||||
error_report("ioctl VFIO_DEVICE_QUERY_GFX_PLANE: %s",
|
||||
strerror(errno));
|
||||
return;
|
||||
}
|
||||
if (!plane.drm_format || !plane.size) {
|
||||
return;
|
||||
}
|
||||
format = qemu_drm_format_to_pixman(plane.drm_format);
|
||||
if (!format) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (dpy->region.buffer.size &&
|
||||
dpy->region.buffer.nr != plane.region_index) {
|
||||
/* region changed */
|
||||
vfio_region_exit(&dpy->region.buffer);
|
||||
vfio_region_finalize(&dpy->region.buffer);
|
||||
dpy->region.surface = NULL;
|
||||
}
|
||||
|
||||
if (dpy->region.surface &&
|
||||
(surface_width(dpy->region.surface) != plane.width ||
|
||||
surface_height(dpy->region.surface) != plane.height ||
|
||||
surface_format(dpy->region.surface) != format)) {
|
||||
/* size changed */
|
||||
dpy->region.surface = NULL;
|
||||
}
|
||||
|
||||
if (!dpy->region.buffer.size) {
|
||||
/* mmap region */
|
||||
ret = vfio_region_setup(OBJECT(vdev), &vdev->vbasedev,
|
||||
&dpy->region.buffer,
|
||||
plane.region_index,
|
||||
"display");
|
||||
if (ret != 0) {
|
||||
error_report("%s: vfio_region_setup(%d): %s",
|
||||
__func__, plane.region_index, strerror(-ret));
|
||||
goto err;
|
||||
}
|
||||
ret = vfio_region_mmap(&dpy->region.buffer);
|
||||
if (ret != 0) {
|
||||
error_report("%s: vfio_region_mmap(%d): %s", __func__,
|
||||
plane.region_index, strerror(-ret));
|
||||
goto err;
|
||||
}
|
||||
assert(dpy->region.buffer.mmaps[0].mmap != NULL);
|
||||
}
|
||||
|
||||
if (dpy->region.surface == NULL) {
|
||||
/* create surface */
|
||||
dpy->region.surface = qemu_create_displaysurface_from
|
||||
(plane.width, plane.height, format,
|
||||
plane.stride, dpy->region.buffer.mmaps[0].mmap);
|
||||
dpy_gfx_replace_surface(dpy->con, dpy->region.surface);
|
||||
}
|
||||
|
||||
/* full screen update */
|
||||
dpy_gfx_update(dpy->con, 0, 0,
|
||||
surface_width(dpy->region.surface),
|
||||
surface_height(dpy->region.surface));
|
||||
return;
|
||||
|
||||
err:
|
||||
vfio_region_exit(&dpy->region.buffer);
|
||||
vfio_region_finalize(&dpy->region.buffer);
|
||||
}
|
||||
|
||||
static const GraphicHwOps vfio_display_region_ops = {
|
||||
.gfx_update = vfio_display_region_update,
|
||||
};
|
||||
|
||||
static int vfio_display_region_init(VFIOPCIDevice *vdev, Error **errp)
|
||||
{
|
||||
vdev->dpy = g_new0(VFIODisplay, 1);
|
||||
vdev->dpy->con = graphic_console_init(DEVICE(vdev), 0,
|
||||
&vfio_display_region_ops,
|
||||
vdev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void vfio_display_region_exit(VFIODisplay *dpy)
|
||||
{
|
||||
if (!dpy->region.buffer.size) {
|
||||
return;
|
||||
}
|
||||
|
||||
vfio_region_exit(&dpy->region.buffer);
|
||||
vfio_region_finalize(&dpy->region.buffer);
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
int vfio_display_probe(VFIOPCIDevice *vdev, Error **errp)
|
||||
{
|
||||
struct vfio_device_gfx_plane_info probe;
|
||||
int ret;
|
||||
|
||||
memset(&probe, 0, sizeof(probe));
|
||||
probe.argsz = sizeof(probe);
|
||||
probe.flags = VFIO_GFX_PLANE_TYPE_PROBE | VFIO_GFX_PLANE_TYPE_DMABUF;
|
||||
ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &probe);
|
||||
if (ret == 0) {
|
||||
return vfio_display_dmabuf_init(vdev, errp);
|
||||
}
|
||||
|
||||
memset(&probe, 0, sizeof(probe));
|
||||
probe.argsz = sizeof(probe);
|
||||
probe.flags = VFIO_GFX_PLANE_TYPE_PROBE | VFIO_GFX_PLANE_TYPE_REGION;
|
||||
ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &probe);
|
||||
if (ret == 0) {
|
||||
return vfio_display_region_init(vdev, errp);
|
||||
}
|
||||
|
||||
if (vdev->display == ON_OFF_AUTO_AUTO) {
|
||||
/* not an error in automatic mode */
|
||||
return 0;
|
||||
}
|
||||
|
||||
error_setg(errp, "vfio: device doesn't support any (known) display method");
|
||||
return -1;
|
||||
}
|
||||
|
||||
void vfio_display_finalize(VFIOPCIDevice *vdev)
|
||||
{
|
||||
if (!vdev->dpy) {
|
||||
return;
|
||||
}
|
||||
|
||||
graphic_console_close(vdev->dpy->con);
|
||||
vfio_display_dmabuf_exit(vdev->dpy);
|
||||
vfio_display_region_exit(vdev->dpy);
|
||||
g_free(vdev->dpy);
|
||||
}
|
|
@ -1294,6 +1294,15 @@ static void vfio_pci_fixup_msix_region(VFIOPCIDevice *vdev)
|
|||
off_t start, end;
|
||||
VFIORegion *region = &vdev->bars[vdev->msix->table_bar].region;
|
||||
|
||||
/*
|
||||
* If the host driver allows mapping of a MSIX data, we are going to
|
||||
* do map the entire BAR and emulate MSIX table on top of that.
|
||||
*/
|
||||
if (vfio_has_region_cap(&vdev->vbasedev, region->nr,
|
||||
VFIO_REGION_INFO_CAP_MSIX_MAPPABLE)) {
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* We expect to find a single mmap covering the whole BAR, anything else
|
||||
* means it's either unsupported or already setup.
|
||||
|
@ -1572,6 +1581,19 @@ static int vfio_msix_setup(VFIOPCIDevice *vdev, int pos, Error **errp)
|
|||
*/
|
||||
memory_region_set_enabled(&vdev->pdev.msix_pba_mmio, false);
|
||||
|
||||
/*
|
||||
* The emulated machine may provide a paravirt interface for MSIX setup
|
||||
* so it is not strictly necessary to emulate MSIX here. This becomes
|
||||
* helpful when frequently accessed MMIO registers are located in
|
||||
* subpages adjacent to the MSIX table but the MSIX data containing page
|
||||
* cannot be mapped because of a host page size bigger than the MSIX table
|
||||
* alignment.
|
||||
*/
|
||||
if (object_property_get_bool(OBJECT(qdev_get_machine()),
|
||||
"vfio-no-msix-emulation", NULL)) {
|
||||
memory_region_set_enabled(&vdev->pdev.msix_table_mmio, false);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -3015,6 +3037,13 @@ static void vfio_realize(PCIDevice *pdev, Error **errp)
|
|||
}
|
||||
}
|
||||
|
||||
if (vdev->display != ON_OFF_AUTO_OFF) {
|
||||
ret = vfio_display_probe(vdev, errp);
|
||||
if (ret) {
|
||||
goto out_teardown;
|
||||
}
|
||||
}
|
||||
|
||||
vfio_register_err_notifier(vdev);
|
||||
vfio_register_req_notifier(vdev);
|
||||
vfio_setup_resetfn_quirk(vdev);
|
||||
|
@ -3035,6 +3064,7 @@ static void vfio_instance_finalize(Object *obj)
|
|||
VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pci_dev);
|
||||
VFIOGroup *group = vdev->vbasedev.group;
|
||||
|
||||
vfio_display_finalize(vdev);
|
||||
vfio_bars_finalize(vdev);
|
||||
g_free(vdev->emulated_config_bits);
|
||||
g_free(vdev->rom);
|
||||
|
@ -3123,6 +3153,8 @@ static void vfio_instance_init(Object *obj)
|
|||
static Property vfio_pci_dev_properties[] = {
|
||||
DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice, host),
|
||||
DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice, vbasedev.sysfsdev),
|
||||
DEFINE_PROP_ON_OFF_AUTO("display", VFIOPCIDevice,
|
||||
display, ON_OFF_AUTO_AUTO),
|
||||
DEFINE_PROP_UINT32("x-intx-mmap-timeout-ms", VFIOPCIDevice,
|
||||
intx.mmap_timeout, 1100),
|
||||
DEFINE_PROP_BIT("x-vga", VFIOPCIDevice, features,
|
||||
|
|
|
@ -133,6 +133,7 @@ typedef struct VFIOPCIDevice {
|
|||
#define VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT 2
|
||||
#define VFIO_FEATURE_ENABLE_IGD_OPREGION \
|
||||
(1 << VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT)
|
||||
OnOffAuto display;
|
||||
int32_t bootindex;
|
||||
uint32_t igd_gms;
|
||||
OffAutoPCIBAR msix_relo;
|
||||
|
@ -147,6 +148,7 @@ typedef struct VFIOPCIDevice {
|
|||
bool no_kvm_msi;
|
||||
bool no_kvm_msix;
|
||||
bool no_geforce_quirks;
|
||||
VFIODisplay *dpy;
|
||||
} VFIOPCIDevice;
|
||||
|
||||
uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len);
|
||||
|
@ -174,4 +176,7 @@ int vfio_pci_igd_opregion_init(VFIOPCIDevice *vdev,
|
|||
struct vfio_region_info *info,
|
||||
Error **errp);
|
||||
|
||||
int vfio_display_probe(VFIOPCIDevice *vdev, Error **errp);
|
||||
void vfio_display_finalize(VFIOPCIDevice *vdev);
|
||||
|
||||
#endif /* HW_VFIO_VFIO_PCI_H */
|
||||
|
|
|
@ -26,6 +26,7 @@
|
|||
#include "exec/memory.h"
|
||||
#include "qemu/queue.h"
|
||||
#include "qemu/notify.h"
|
||||
#include "ui/console.h"
|
||||
#ifdef CONFIG_LINUX
|
||||
#include <linux/vfio.h>
|
||||
#endif
|
||||
|
@ -142,6 +143,27 @@ typedef struct VFIOGroup {
|
|||
QLIST_ENTRY(VFIOGroup) container_next;
|
||||
} VFIOGroup;
|
||||
|
||||
typedef struct VFIODMABuf {
|
||||
QemuDmaBuf buf;
|
||||
uint32_t pos_x, pos_y, pos_updates;
|
||||
uint32_t hot_x, hot_y, hot_updates;
|
||||
int dmabuf_id;
|
||||
QTAILQ_ENTRY(VFIODMABuf) next;
|
||||
} VFIODMABuf;
|
||||
|
||||
typedef struct VFIODisplay {
|
||||
QemuConsole *con;
|
||||
struct {
|
||||
VFIORegion buffer;
|
||||
DisplaySurface *surface;
|
||||
} region;
|
||||
struct {
|
||||
QTAILQ_HEAD(, VFIODMABuf) bufs;
|
||||
VFIODMABuf *primary;
|
||||
VFIODMABuf *cursor;
|
||||
} dmabuf;
|
||||
} VFIODisplay;
|
||||
|
||||
void vfio_put_base_device(VFIODevice *vbasedev);
|
||||
void vfio_disable_irqindex(VFIODevice *vbasedev, int index);
|
||||
void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index);
|
||||
|
@ -171,6 +193,7 @@ int vfio_get_region_info(VFIODevice *vbasedev, int index,
|
|||
struct vfio_region_info **info);
|
||||
int vfio_get_dev_region_info(VFIODevice *vbasedev, uint32_t type,
|
||||
uint32_t subtype, struct vfio_region_info **info);
|
||||
bool vfio_has_region_cap(VFIODevice *vbasedev, int region, uint16_t cap_type);
|
||||
#endif
|
||||
extern const MemoryListener vfio_prereg_listener;
|
||||
|
||||
|
|
411
include/standard-headers/drm/drm_fourcc.h
Normal file
411
include/standard-headers/drm/drm_fourcc.h
Normal file
|
@ -0,0 +1,411 @@
|
|||
/*
|
||||
* Copyright 2011 Intel 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
|
||||
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS 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.
|
||||
*/
|
||||
|
||||
#ifndef DRM_FOURCC_H
|
||||
#define DRM_FOURCC_H
|
||||
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define fourcc_code(a, b, c, d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | \
|
||||
((uint32_t)(c) << 16) | ((uint32_t)(d) << 24))
|
||||
|
||||
#define DRM_FORMAT_BIG_ENDIAN (1<<31) /* format is big endian instead of little endian */
|
||||
|
||||
/* color index */
|
||||
#define DRM_FORMAT_C8 fourcc_code('C', '8', ' ', ' ') /* [7:0] C */
|
||||
|
||||
/* 8 bpp Red */
|
||||
#define DRM_FORMAT_R8 fourcc_code('R', '8', ' ', ' ') /* [7:0] R */
|
||||
|
||||
/* 16 bpp Red */
|
||||
#define DRM_FORMAT_R16 fourcc_code('R', '1', '6', ' ') /* [15:0] R little endian */
|
||||
|
||||
/* 16 bpp RG */
|
||||
#define DRM_FORMAT_RG88 fourcc_code('R', 'G', '8', '8') /* [15:0] R:G 8:8 little endian */
|
||||
#define DRM_FORMAT_GR88 fourcc_code('G', 'R', '8', '8') /* [15:0] G:R 8:8 little endian */
|
||||
|
||||
/* 32 bpp RG */
|
||||
#define DRM_FORMAT_RG1616 fourcc_code('R', 'G', '3', '2') /* [31:0] R:G 16:16 little endian */
|
||||
#define DRM_FORMAT_GR1616 fourcc_code('G', 'R', '3', '2') /* [31:0] G:R 16:16 little endian */
|
||||
|
||||
/* 8 bpp RGB */
|
||||
#define DRM_FORMAT_RGB332 fourcc_code('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */
|
||||
#define DRM_FORMAT_BGR233 fourcc_code('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */
|
||||
|
||||
/* 16 bpp RGB */
|
||||
#define DRM_FORMAT_XRGB4444 fourcc_code('X', 'R', '1', '2') /* [15:0] x:R:G:B 4:4:4:4 little endian */
|
||||
#define DRM_FORMAT_XBGR4444 fourcc_code('X', 'B', '1', '2') /* [15:0] x:B:G:R 4:4:4:4 little endian */
|
||||
#define DRM_FORMAT_RGBX4444 fourcc_code('R', 'X', '1', '2') /* [15:0] R:G:B:x 4:4:4:4 little endian */
|
||||
#define DRM_FORMAT_BGRX4444 fourcc_code('B', 'X', '1', '2') /* [15:0] B:G:R:x 4:4:4:4 little endian */
|
||||
|
||||
#define DRM_FORMAT_ARGB4444 fourcc_code('A', 'R', '1', '2') /* [15:0] A:R:G:B 4:4:4:4 little endian */
|
||||
#define DRM_FORMAT_ABGR4444 fourcc_code('A', 'B', '1', '2') /* [15:0] A:B:G:R 4:4:4:4 little endian */
|
||||
#define DRM_FORMAT_RGBA4444 fourcc_code('R', 'A', '1', '2') /* [15:0] R:G:B:A 4:4:4:4 little endian */
|
||||
#define DRM_FORMAT_BGRA4444 fourcc_code('B', 'A', '1', '2') /* [15:0] B:G:R:A 4:4:4:4 little endian */
|
||||
|
||||
#define DRM_FORMAT_XRGB1555 fourcc_code('X', 'R', '1', '5') /* [15:0] x:R:G:B 1:5:5:5 little endian */
|
||||
#define DRM_FORMAT_XBGR1555 fourcc_code('X', 'B', '1', '5') /* [15:0] x:B:G:R 1:5:5:5 little endian */
|
||||
#define DRM_FORMAT_RGBX5551 fourcc_code('R', 'X', '1', '5') /* [15:0] R:G:B:x 5:5:5:1 little endian */
|
||||
#define DRM_FORMAT_BGRX5551 fourcc_code('B', 'X', '1', '5') /* [15:0] B:G:R:x 5:5:5:1 little endian */
|
||||
|
||||
#define DRM_FORMAT_ARGB1555 fourcc_code('A', 'R', '1', '5') /* [15:0] A:R:G:B 1:5:5:5 little endian */
|
||||
#define DRM_FORMAT_ABGR1555 fourcc_code('A', 'B', '1', '5') /* [15:0] A:B:G:R 1:5:5:5 little endian */
|
||||
#define DRM_FORMAT_RGBA5551 fourcc_code('R', 'A', '1', '5') /* [15:0] R:G:B:A 5:5:5:1 little endian */
|
||||
#define DRM_FORMAT_BGRA5551 fourcc_code('B', 'A', '1', '5') /* [15:0] B:G:R:A 5:5:5:1 little endian */
|
||||
|
||||
#define DRM_FORMAT_RGB565 fourcc_code('R', 'G', '1', '6') /* [15:0] R:G:B 5:6:5 little endian */
|
||||
#define DRM_FORMAT_BGR565 fourcc_code('B', 'G', '1', '6') /* [15:0] B:G:R 5:6:5 little endian */
|
||||
|
||||
/* 24 bpp RGB */
|
||||
#define DRM_FORMAT_RGB888 fourcc_code('R', 'G', '2', '4') /* [23:0] R:G:B little endian */
|
||||
#define DRM_FORMAT_BGR888 fourcc_code('B', 'G', '2', '4') /* [23:0] B:G:R little endian */
|
||||
|
||||
/* 32 bpp RGB */
|
||||
#define DRM_FORMAT_XRGB8888 fourcc_code('X', 'R', '2', '4') /* [31:0] x:R:G:B 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_XBGR8888 fourcc_code('X', 'B', '2', '4') /* [31:0] x:B:G:R 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_RGBX8888 fourcc_code('R', 'X', '2', '4') /* [31:0] R:G:B:x 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_BGRX8888 fourcc_code('B', 'X', '2', '4') /* [31:0] B:G:R:x 8:8:8:8 little endian */
|
||||
|
||||
#define DRM_FORMAT_ARGB8888 fourcc_code('A', 'R', '2', '4') /* [31:0] A:R:G:B 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_ABGR8888 fourcc_code('A', 'B', '2', '4') /* [31:0] A:B:G:R 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_RGBA8888 fourcc_code('R', 'A', '2', '4') /* [31:0] R:G:B:A 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_BGRA8888 fourcc_code('B', 'A', '2', '4') /* [31:0] B:G:R:A 8:8:8:8 little endian */
|
||||
|
||||
#define DRM_FORMAT_XRGB2101010 fourcc_code('X', 'R', '3', '0') /* [31:0] x:R:G:B 2:10:10:10 little endian */
|
||||
#define DRM_FORMAT_XBGR2101010 fourcc_code('X', 'B', '3', '0') /* [31:0] x:B:G:R 2:10:10:10 little endian */
|
||||
#define DRM_FORMAT_RGBX1010102 fourcc_code('R', 'X', '3', '0') /* [31:0] R:G:B:x 10:10:10:2 little endian */
|
||||
#define DRM_FORMAT_BGRX1010102 fourcc_code('B', 'X', '3', '0') /* [31:0] B:G:R:x 10:10:10:2 little endian */
|
||||
|
||||
#define DRM_FORMAT_ARGB2101010 fourcc_code('A', 'R', '3', '0') /* [31:0] A:R:G:B 2:10:10:10 little endian */
|
||||
#define DRM_FORMAT_ABGR2101010 fourcc_code('A', 'B', '3', '0') /* [31:0] A:B:G:R 2:10:10:10 little endian */
|
||||
#define DRM_FORMAT_RGBA1010102 fourcc_code('R', 'A', '3', '0') /* [31:0] R:G:B:A 10:10:10:2 little endian */
|
||||
#define DRM_FORMAT_BGRA1010102 fourcc_code('B', 'A', '3', '0') /* [31:0] B:G:R:A 10:10:10:2 little endian */
|
||||
|
||||
/* packed YCbCr */
|
||||
#define DRM_FORMAT_YUYV fourcc_code('Y', 'U', 'Y', 'V') /* [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_YVYU fourcc_code('Y', 'V', 'Y', 'U') /* [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_UYVY fourcc_code('U', 'Y', 'V', 'Y') /* [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian */
|
||||
#define DRM_FORMAT_VYUY fourcc_code('V', 'Y', 'U', 'Y') /* [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian */
|
||||
|
||||
#define DRM_FORMAT_AYUV fourcc_code('A', 'Y', 'U', 'V') /* [31:0] A:Y:Cb:Cr 8:8:8:8 little endian */
|
||||
|
||||
/*
|
||||
* 2 plane RGB + A
|
||||
* index 0 = RGB plane, same format as the corresponding non _A8 format has
|
||||
* index 1 = A plane, [7:0] A
|
||||
*/
|
||||
#define DRM_FORMAT_XRGB8888_A8 fourcc_code('X', 'R', 'A', '8')
|
||||
#define DRM_FORMAT_XBGR8888_A8 fourcc_code('X', 'B', 'A', '8')
|
||||
#define DRM_FORMAT_RGBX8888_A8 fourcc_code('R', 'X', 'A', '8')
|
||||
#define DRM_FORMAT_BGRX8888_A8 fourcc_code('B', 'X', 'A', '8')
|
||||
#define DRM_FORMAT_RGB888_A8 fourcc_code('R', '8', 'A', '8')
|
||||
#define DRM_FORMAT_BGR888_A8 fourcc_code('B', '8', 'A', '8')
|
||||
#define DRM_FORMAT_RGB565_A8 fourcc_code('R', '5', 'A', '8')
|
||||
#define DRM_FORMAT_BGR565_A8 fourcc_code('B', '5', 'A', '8')
|
||||
|
||||
/*
|
||||
* 2 plane YCbCr
|
||||
* index 0 = Y plane, [7:0] Y
|
||||
* index 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
|
||||
* or
|
||||
* index 1 = Cb:Cr plane, [15:0] Cb:Cr little endian
|
||||
*/
|
||||
#define DRM_FORMAT_NV12 fourcc_code('N', 'V', '1', '2') /* 2x2 subsampled Cr:Cb plane */
|
||||
#define DRM_FORMAT_NV21 fourcc_code('N', 'V', '2', '1') /* 2x2 subsampled Cb:Cr plane */
|
||||
#define DRM_FORMAT_NV16 fourcc_code('N', 'V', '1', '6') /* 2x1 subsampled Cr:Cb plane */
|
||||
#define DRM_FORMAT_NV61 fourcc_code('N', 'V', '6', '1') /* 2x1 subsampled Cb:Cr plane */
|
||||
#define DRM_FORMAT_NV24 fourcc_code('N', 'V', '2', '4') /* non-subsampled Cr:Cb plane */
|
||||
#define DRM_FORMAT_NV42 fourcc_code('N', 'V', '4', '2') /* non-subsampled Cb:Cr plane */
|
||||
|
||||
/*
|
||||
* 3 plane YCbCr
|
||||
* index 0: Y plane, [7:0] Y
|
||||
* index 1: Cb plane, [7:0] Cb
|
||||
* index 2: Cr plane, [7:0] Cr
|
||||
* or
|
||||
* index 1: Cr plane, [7:0] Cr
|
||||
* index 2: Cb plane, [7:0] Cb
|
||||
*/
|
||||
#define DRM_FORMAT_YUV410 fourcc_code('Y', 'U', 'V', '9') /* 4x4 subsampled Cb (1) and Cr (2) planes */
|
||||
#define DRM_FORMAT_YVU410 fourcc_code('Y', 'V', 'U', '9') /* 4x4 subsampled Cr (1) and Cb (2) planes */
|
||||
#define DRM_FORMAT_YUV411 fourcc_code('Y', 'U', '1', '1') /* 4x1 subsampled Cb (1) and Cr (2) planes */
|
||||
#define DRM_FORMAT_YVU411 fourcc_code('Y', 'V', '1', '1') /* 4x1 subsampled Cr (1) and Cb (2) planes */
|
||||
#define DRM_FORMAT_YUV420 fourcc_code('Y', 'U', '1', '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */
|
||||
#define DRM_FORMAT_YVU420 fourcc_code('Y', 'V', '1', '2') /* 2x2 subsampled Cr (1) and Cb (2) planes */
|
||||
#define DRM_FORMAT_YUV422 fourcc_code('Y', 'U', '1', '6') /* 2x1 subsampled Cb (1) and Cr (2) planes */
|
||||
#define DRM_FORMAT_YVU422 fourcc_code('Y', 'V', '1', '6') /* 2x1 subsampled Cr (1) and Cb (2) planes */
|
||||
#define DRM_FORMAT_YUV444 fourcc_code('Y', 'U', '2', '4') /* non-subsampled Cb (1) and Cr (2) planes */
|
||||
#define DRM_FORMAT_YVU444 fourcc_code('Y', 'V', '2', '4') /* non-subsampled Cr (1) and Cb (2) planes */
|
||||
|
||||
|
||||
/*
|
||||
* Format Modifiers:
|
||||
*
|
||||
* Format modifiers describe, typically, a re-ordering or modification
|
||||
* of the data in a plane of an FB. This can be used to express tiled/
|
||||
* swizzled formats, or compression, or a combination of the two.
|
||||
*
|
||||
* The upper 8 bits of the format modifier are a vendor-id as assigned
|
||||
* below. The lower 56 bits are assigned as vendor sees fit.
|
||||
*/
|
||||
|
||||
/* Vendor Ids: */
|
||||
#define DRM_FORMAT_MOD_NONE 0
|
||||
#define DRM_FORMAT_MOD_VENDOR_NONE 0
|
||||
#define DRM_FORMAT_MOD_VENDOR_INTEL 0x01
|
||||
#define DRM_FORMAT_MOD_VENDOR_AMD 0x02
|
||||
#define DRM_FORMAT_MOD_VENDOR_NVIDIA 0x03
|
||||
#define DRM_FORMAT_MOD_VENDOR_SAMSUNG 0x04
|
||||
#define DRM_FORMAT_MOD_VENDOR_QCOM 0x05
|
||||
#define DRM_FORMAT_MOD_VENDOR_VIVANTE 0x06
|
||||
#define DRM_FORMAT_MOD_VENDOR_BROADCOM 0x07
|
||||
/* add more to the end as needed */
|
||||
|
||||
#define DRM_FORMAT_RESERVED ((1ULL << 56) - 1)
|
||||
|
||||
#define fourcc_mod_code(vendor, val) \
|
||||
((((uint64_t)DRM_FORMAT_MOD_VENDOR_## vendor) << 56) | ((val) & 0x00ffffffffffffffULL))
|
||||
|
||||
/*
|
||||
* Format Modifier tokens:
|
||||
*
|
||||
* When adding a new token please document the layout with a code comment,
|
||||
* similar to the fourcc codes above. drm_fourcc.h is considered the
|
||||
* authoritative source for all of these.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Invalid Modifier
|
||||
*
|
||||
* This modifier can be used as a sentinel to terminate the format modifiers
|
||||
* list, or to initialize a variable with an invalid modifier. It might also be
|
||||
* used to report an error back to userspace for certain APIs.
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_INVALID fourcc_mod_code(NONE, DRM_FORMAT_RESERVED)
|
||||
|
||||
/*
|
||||
* Linear Layout
|
||||
*
|
||||
* Just plain linear layout. Note that this is different from no specifying any
|
||||
* modifier (e.g. not setting DRM_MODE_FB_MODIFIERS in the DRM_ADDFB2 ioctl),
|
||||
* which tells the driver to also take driver-internal information into account
|
||||
* and so might actually result in a tiled framebuffer.
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_LINEAR fourcc_mod_code(NONE, 0)
|
||||
|
||||
/* Intel framebuffer modifiers */
|
||||
|
||||
/*
|
||||
* Intel X-tiling layout
|
||||
*
|
||||
* This is a tiled layout using 4Kb tiles (except on gen2 where the tiles 2Kb)
|
||||
* in row-major layout. Within the tile bytes are laid out row-major, with
|
||||
* a platform-dependent stride. On top of that the memory can apply
|
||||
* platform-depending swizzling of some higher address bits into bit6.
|
||||
*
|
||||
* This format is highly platforms specific and not useful for cross-driver
|
||||
* sharing. It exists since on a given platform it does uniquely identify the
|
||||
* layout in a simple way for i915-specific userspace.
|
||||
*/
|
||||
#define I915_FORMAT_MOD_X_TILED fourcc_mod_code(INTEL, 1)
|
||||
|
||||
/*
|
||||
* Intel Y-tiling layout
|
||||
*
|
||||
* This is a tiled layout using 4Kb tiles (except on gen2 where the tiles 2Kb)
|
||||
* in row-major layout. Within the tile bytes are laid out in OWORD (16 bytes)
|
||||
* chunks column-major, with a platform-dependent height. On top of that the
|
||||
* memory can apply platform-depending swizzling of some higher address bits
|
||||
* into bit6.
|
||||
*
|
||||
* This format is highly platforms specific and not useful for cross-driver
|
||||
* sharing. It exists since on a given platform it does uniquely identify the
|
||||
* layout in a simple way for i915-specific userspace.
|
||||
*/
|
||||
#define I915_FORMAT_MOD_Y_TILED fourcc_mod_code(INTEL, 2)
|
||||
|
||||
/*
|
||||
* Intel Yf-tiling layout
|
||||
*
|
||||
* This is a tiled layout using 4Kb tiles in row-major layout.
|
||||
* Within the tile pixels are laid out in 16 256 byte units / sub-tiles which
|
||||
* are arranged in four groups (two wide, two high) with column-major layout.
|
||||
* Each group therefore consits out of four 256 byte units, which are also laid
|
||||
* out as 2x2 column-major.
|
||||
* 256 byte units are made out of four 64 byte blocks of pixels, producing
|
||||
* either a square block or a 2:1 unit.
|
||||
* 64 byte blocks of pixels contain four pixel rows of 16 bytes, where the width
|
||||
* in pixel depends on the pixel depth.
|
||||
*/
|
||||
#define I915_FORMAT_MOD_Yf_TILED fourcc_mod_code(INTEL, 3)
|
||||
|
||||
/*
|
||||
* Intel color control surface (CCS) for render compression
|
||||
*
|
||||
* The framebuffer format must be one of the 8:8:8:8 RGB formats.
|
||||
* The main surface will be plane index 0 and must be Y/Yf-tiled,
|
||||
* the CCS will be plane index 1.
|
||||
*
|
||||
* Each CCS tile matches a 1024x512 pixel area of the main surface.
|
||||
* To match certain aspects of the 3D hardware the CCS is
|
||||
* considered to be made up of normal 128Bx32 Y tiles, Thus
|
||||
* the CCS pitch must be specified in multiples of 128 bytes.
|
||||
*
|
||||
* In reality the CCS tile appears to be a 64Bx64 Y tile, composed
|
||||
* of QWORD (8 bytes) chunks instead of OWORD (16 bytes) chunks.
|
||||
* But that fact is not relevant unless the memory is accessed
|
||||
* directly.
|
||||
*/
|
||||
#define I915_FORMAT_MOD_Y_TILED_CCS fourcc_mod_code(INTEL, 4)
|
||||
#define I915_FORMAT_MOD_Yf_TILED_CCS fourcc_mod_code(INTEL, 5)
|
||||
|
||||
/*
|
||||
* Tiled, NV12MT, grouped in 64 (pixels) x 32 (lines) -sized macroblocks
|
||||
*
|
||||
* Macroblocks are laid in a Z-shape, and each pixel data is following the
|
||||
* standard NV12 style.
|
||||
* As for NV12, an image is the result of two frame buffers: one for Y,
|
||||
* one for the interleaved Cb/Cr components (1/2 the height of the Y buffer).
|
||||
* Alignment requirements are (for each buffer):
|
||||
* - multiple of 128 pixels for the width
|
||||
* - multiple of 32 pixels for the height
|
||||
*
|
||||
* For more information: see https://linuxtv.org/downloads/v4l-dvb-apis/re32.html
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_SAMSUNG_64_32_TILE fourcc_mod_code(SAMSUNG, 1)
|
||||
|
||||
/* Vivante framebuffer modifiers */
|
||||
|
||||
/*
|
||||
* Vivante 4x4 tiling layout
|
||||
*
|
||||
* This is a simple tiled layout using tiles of 4x4 pixels in a row-major
|
||||
* layout.
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_VIVANTE_TILED fourcc_mod_code(VIVANTE, 1)
|
||||
|
||||
/*
|
||||
* Vivante 64x64 super-tiling layout
|
||||
*
|
||||
* This is a tiled layout using 64x64 pixel super-tiles, where each super-tile
|
||||
* contains 8x4 groups of 2x4 tiles of 4x4 pixels (like above) each, all in row-
|
||||
* major layout.
|
||||
*
|
||||
* For more information: see
|
||||
* https://github.com/etnaviv/etna_viv/blob/master/doc/hardware.md#texture-tiling
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_VIVANTE_SUPER_TILED fourcc_mod_code(VIVANTE, 2)
|
||||
|
||||
/*
|
||||
* Vivante 4x4 tiling layout for dual-pipe
|
||||
*
|
||||
* Same as the 4x4 tiling layout, except every second 4x4 pixel tile starts at a
|
||||
* different base address. Offsets from the base addresses are therefore halved
|
||||
* compared to the non-split tiled layout.
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED fourcc_mod_code(VIVANTE, 3)
|
||||
|
||||
/*
|
||||
* Vivante 64x64 super-tiling layout for dual-pipe
|
||||
*
|
||||
* Same as the 64x64 super-tiling layout, except every second 4x4 pixel tile
|
||||
* starts at a different base address. Offsets from the base addresses are
|
||||
* therefore halved compared to the non-split super-tiled layout.
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED fourcc_mod_code(VIVANTE, 4)
|
||||
|
||||
/* NVIDIA frame buffer modifiers */
|
||||
|
||||
/*
|
||||
* Tegra Tiled Layout, used by Tegra 2, 3 and 4.
|
||||
*
|
||||
* Pixels are arranged in simple tiles of 16 x 16 bytes.
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_NVIDIA_TEGRA_TILED fourcc_mod_code(NVIDIA, 1)
|
||||
|
||||
/*
|
||||
* 16Bx2 Block Linear layout, used by desktop GPUs, and Tegra K1 and later
|
||||
*
|
||||
* Pixels are arranged in 64x8 Groups Of Bytes (GOBs). GOBs are then stacked
|
||||
* vertically by a power of 2 (1 to 32 GOBs) to form a block.
|
||||
*
|
||||
* Within a GOB, data is ordered as 16B x 2 lines sectors laid in Z-shape.
|
||||
*
|
||||
* Parameter 'v' is the log2 encoding of the number of GOBs stacked vertically.
|
||||
* Valid values are:
|
||||
*
|
||||
* 0 == ONE_GOB
|
||||
* 1 == TWO_GOBS
|
||||
* 2 == FOUR_GOBS
|
||||
* 3 == EIGHT_GOBS
|
||||
* 4 == SIXTEEN_GOBS
|
||||
* 5 == THIRTYTWO_GOBS
|
||||
*
|
||||
* Chapter 20 "Pixel Memory Formats" of the Tegra X1 TRM describes this format
|
||||
* in full detail.
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(v) \
|
||||
fourcc_mod_code(NVIDIA, 0x10 | ((v) & 0xf))
|
||||
|
||||
#define DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_ONE_GOB \
|
||||
fourcc_mod_code(NVIDIA, 0x10)
|
||||
#define DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_TWO_GOB \
|
||||
fourcc_mod_code(NVIDIA, 0x11)
|
||||
#define DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_FOUR_GOB \
|
||||
fourcc_mod_code(NVIDIA, 0x12)
|
||||
#define DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_EIGHT_GOB \
|
||||
fourcc_mod_code(NVIDIA, 0x13)
|
||||
#define DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_SIXTEEN_GOB \
|
||||
fourcc_mod_code(NVIDIA, 0x14)
|
||||
#define DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_THIRTYTWO_GOB \
|
||||
fourcc_mod_code(NVIDIA, 0x15)
|
||||
|
||||
/*
|
||||
* Broadcom VC4 "T" format
|
||||
*
|
||||
* This is the primary layout that the V3D GPU can texture from (it
|
||||
* can't do linear). The T format has:
|
||||
*
|
||||
* - 64b utiles of pixels in a raster-order grid according to cpp. It's 4x4
|
||||
* pixels at 32 bit depth.
|
||||
*
|
||||
* - 1k subtiles made of a 4x4 raster-order grid of 64b utiles (so usually
|
||||
* 16x16 pixels).
|
||||
*
|
||||
* - 4k tiles made of a 2x2 grid of 1k subtiles (so usually 32x32 pixels). On
|
||||
* even 4k tile rows, they're arranged as (BL, TL, TR, BR), and on odd rows
|
||||
* they're (TR, BR, BL, TL), where bottom left is start of memory.
|
||||
*
|
||||
* - an image made of 4k tiles in rows either left-to-right (even rows of 4k
|
||||
* tiles) or right-to-left (odd rows of 4k tiles).
|
||||
*/
|
||||
#define DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED fourcc_mod_code(BROADCOM, 1)
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* DRM_FOURCC_H */
|
|
@ -386,6 +386,7 @@ QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
|
|||
void graphic_console_set_hwops(QemuConsole *con,
|
||||
const GraphicHwOps *hw_ops,
|
||||
void *opaque);
|
||||
void graphic_console_close(QemuConsole *con);
|
||||
|
||||
void graphic_hw_update(QemuConsole *con);
|
||||
void graphic_hw_invalidate(QemuConsole *con);
|
||||
|
@ -398,6 +399,7 @@ QemuConsole *qemu_console_lookup_by_index(unsigned int index);
|
|||
QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head);
|
||||
QemuConsole *qemu_console_lookup_by_device_name(const char *device_id,
|
||||
uint32_t head, Error **errp);
|
||||
QemuConsole *qemu_console_lookup_unused(void);
|
||||
bool qemu_console_is_visible(QemuConsole *con);
|
||||
bool qemu_console_is_graphic(QemuConsole *con);
|
||||
bool qemu_console_is_fixedsize(QemuConsole *con);
|
||||
|
|
|
@ -33,6 +33,8 @@
|
|||
# define PIXMAN_BE_r8g8b8a8 PIXMAN_r8g8b8a8
|
||||
# define PIXMAN_BE_x8b8g8r8 PIXMAN_x8b8g8r8
|
||||
# define PIXMAN_BE_a8b8g8r8 PIXMAN_a8b8g8r8
|
||||
# define PIXMAN_LE_r8g8b8 PIXMAN_b8g8r8
|
||||
# define PIXMAN_LE_a8r8g8b8 PIXMAN_b8g8r8a8
|
||||
# define PIXMAN_LE_x8r8g8b8 PIXMAN_b8g8r8x8
|
||||
#else
|
||||
# define PIXMAN_BE_r8g8b8 PIXMAN_b8g8r8
|
||||
|
@ -44,6 +46,8 @@
|
|||
# define PIXMAN_BE_r8g8b8a8 PIXMAN_a8b8g8r8
|
||||
# define PIXMAN_BE_x8b8g8r8 PIXMAN_r8g8b8x8
|
||||
# define PIXMAN_BE_a8b8g8r8 PIXMAN_r8g8b8a8
|
||||
# define PIXMAN_LE_r8g8b8 PIXMAN_r8g8b8
|
||||
# define PIXMAN_LE_a8r8g8b8 PIXMAN_a8r8g8b8
|
||||
# define PIXMAN_LE_x8r8g8b8 PIXMAN_x8r8g8b8
|
||||
#endif
|
||||
|
||||
|
@ -51,6 +55,7 @@
|
|||
|
||||
PixelFormat qemu_pixelformat_from_pixman(pixman_format_code_t format);
|
||||
pixman_format_code_t qemu_default_pixman_format(int bpp, bool native_endian);
|
||||
pixman_format_code_t qemu_drm_format_to_pixman(uint32_t drm_format);
|
||||
int qemu_pixman_get_type(int rshift, int gshift, int bshift);
|
||||
pixman_format_code_t qemu_pixman_get_format(PixelFormat *pf);
|
||||
bool qemu_pixman_check_format(DisplayChangeListener *dcl,
|
||||
|
|
|
@ -39,6 +39,7 @@ cp_portable() {
|
|||
-e 'input-event-codes' \
|
||||
-e 'sys/' \
|
||||
-e 'pvrdma_verbs' \
|
||||
-e 'drm.h' \
|
||||
> /dev/null
|
||||
then
|
||||
echo "Unexpected #include in input file $f".
|
||||
|
@ -57,6 +58,7 @@ cp_portable() {
|
|||
-e 's/__attribute__((packed))/QEMU_PACKED/' \
|
||||
-e 's/__inline__/inline/' \
|
||||
-e 's/__BITS_PER_LONG/HOST_LONG_BITS/' \
|
||||
-e '/\"drm.h\"/d' \
|
||||
-e '/sys\/ioctl.h/d' \
|
||||
-e 's/SW_MAX/SW_MAX_/' \
|
||||
-e 's/atomic_t/int/' \
|
||||
|
@ -152,6 +154,9 @@ for i in "$tmpdir"/include/linux/*virtio*.h "$tmpdir/include/linux/input.h" \
|
|||
"$tmpdir/include/linux/pci_regs.h"; do
|
||||
cp_portable "$i" "$output/include/standard-headers/linux"
|
||||
done
|
||||
mkdir -p "$output/include/standard-headers/drm"
|
||||
cp_portable "$tmpdir/include/drm/drm_fourcc.h" \
|
||||
"$output/include/standard-headers/drm"
|
||||
|
||||
rm -rf "$output/include/standard-headers/drivers/infiniband/hw/vmw_pvrdma"
|
||||
mkdir -p "$output/include/standard-headers/drivers/infiniband/hw/vmw_pvrdma"
|
||||
|
|
79
ui/console.c
79
ui/console.c
|
@ -1282,11 +1282,16 @@ static QemuConsole *new_console(DisplayState *ds, console_type_t console_type,
|
|||
s->console_type = console_type;
|
||||
|
||||
consoles = g_realloc(consoles, sizeof(*consoles) * (nb_consoles+1));
|
||||
if (console_type != GRAPHIC_CONSOLE) {
|
||||
if (console_type != GRAPHIC_CONSOLE || qdev_hotplug) {
|
||||
s->index = nb_consoles;
|
||||
consoles[nb_consoles++] = s;
|
||||
} else {
|
||||
/* HACK: Put graphical consoles before text consoles. */
|
||||
/*
|
||||
* HACK: Put graphical consoles before text consoles.
|
||||
*
|
||||
* Only do that for coldplugged devices. After initial device
|
||||
* initialization we will not renumber the consoles any more.
|
||||
*/
|
||||
for (i = nb_consoles; i > 0; i--) {
|
||||
if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)
|
||||
break;
|
||||
|
@ -1874,21 +1879,61 @@ QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
|
|||
int height = 480;
|
||||
QemuConsole *s;
|
||||
DisplayState *ds;
|
||||
DisplaySurface *surface;
|
||||
|
||||
ds = get_alloc_displaystate();
|
||||
trace_console_gfx_new();
|
||||
s = new_console(ds, GRAPHIC_CONSOLE, head);
|
||||
s->ui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, dpy_set_ui_info_timer, s);
|
||||
s = qemu_console_lookup_unused();
|
||||
if (s) {
|
||||
trace_console_gfx_reuse(s->index);
|
||||
if (s->surface) {
|
||||
width = surface_width(s->surface);
|
||||
height = surface_height(s->surface);
|
||||
}
|
||||
} else {
|
||||
trace_console_gfx_new();
|
||||
s = new_console(ds, GRAPHIC_CONSOLE, head);
|
||||
s->ui_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
|
||||
dpy_set_ui_info_timer, s);
|
||||
}
|
||||
graphic_console_set_hwops(s, hw_ops, opaque);
|
||||
if (dev) {
|
||||
object_property_set_link(OBJECT(s), OBJECT(dev), "device",
|
||||
&error_abort);
|
||||
}
|
||||
|
||||
s->surface = qemu_create_message_surface(width, height, noinit);
|
||||
surface = qemu_create_message_surface(width, height, noinit);
|
||||
dpy_gfx_replace_surface(s, surface);
|
||||
return s;
|
||||
}
|
||||
|
||||
static const GraphicHwOps unused_ops = {
|
||||
/* no callbacks */
|
||||
};
|
||||
|
||||
void graphic_console_close(QemuConsole *con)
|
||||
{
|
||||
static const char unplugged[] =
|
||||
"Guest display has been unplugged";
|
||||
DisplaySurface *surface;
|
||||
int width = 640;
|
||||
int height = 480;
|
||||
|
||||
if (con->surface) {
|
||||
width = surface_width(con->surface);
|
||||
height = surface_height(con->surface);
|
||||
}
|
||||
|
||||
trace_console_gfx_close(con->index);
|
||||
object_property_set_link(OBJECT(con), NULL, "device", &error_abort);
|
||||
graphic_console_set_hwops(con, &unused_ops, NULL);
|
||||
|
||||
if (con->gl) {
|
||||
dpy_gl_scanout_disable(con);
|
||||
}
|
||||
surface = qemu_create_message_surface(width, height, unplugged);
|
||||
dpy_gfx_replace_surface(con, surface);
|
||||
}
|
||||
|
||||
QemuConsole *qemu_console_lookup_by_index(unsigned int index)
|
||||
{
|
||||
if (index >= nb_consoles) {
|
||||
|
@ -1945,6 +1990,28 @@ QemuConsole *qemu_console_lookup_by_device_name(const char *device_id,
|
|||
return con;
|
||||
}
|
||||
|
||||
QemuConsole *qemu_console_lookup_unused(void)
|
||||
{
|
||||
Object *obj;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < nb_consoles; i++) {
|
||||
if (!consoles[i]) {
|
||||
continue;
|
||||
}
|
||||
if (consoles[i]->hw_ops != &unused_ops) {
|
||||
continue;
|
||||
}
|
||||
obj = object_property_get_link(OBJECT(consoles[i]),
|
||||
"device", &error_abort);
|
||||
if (obj != NULL) {
|
||||
continue;
|
||||
}
|
||||
return consoles[i];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool qemu_console_is_visible(QemuConsole *con)
|
||||
{
|
||||
return (con == active_console) || (con->dcls > 0);
|
||||
|
|
|
@ -6,6 +6,7 @@
|
|||
#include "qemu/osdep.h"
|
||||
#include "qemu-common.h"
|
||||
#include "ui/console.h"
|
||||
#include "standard-headers/drm/drm_fourcc.h"
|
||||
|
||||
PixelFormat qemu_pixelformat_from_pixman(pixman_format_code_t format)
|
||||
{
|
||||
|
@ -88,6 +89,27 @@ pixman_format_code_t qemu_default_pixman_format(int bpp, bool native_endian)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* Note: drm is little endian, pixman is native endian */
|
||||
pixman_format_code_t qemu_drm_format_to_pixman(uint32_t drm_format)
|
||||
{
|
||||
static const struct {
|
||||
uint32_t drm_format;
|
||||
pixman_format_code_t pixman;
|
||||
} map[] = {
|
||||
{ DRM_FORMAT_RGB888, PIXMAN_LE_r8g8b8 },
|
||||
{ DRM_FORMAT_ARGB8888, PIXMAN_LE_a8r8g8b8 },
|
||||
{ DRM_FORMAT_XRGB8888, PIXMAN_LE_x8r8g8b8 }
|
||||
};
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(map); i++) {
|
||||
if (drm_format == map[i].drm_format) {
|
||||
return map[i].pixman;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int qemu_pixman_get_type(int rshift, int gshift, int bshift)
|
||||
{
|
||||
int type = PIXMAN_TYPE_OTHER;
|
||||
|
|
|
@ -2,6 +2,8 @@
|
|||
|
||||
# ui/console.c
|
||||
console_gfx_new(void) ""
|
||||
console_gfx_reuse(int index) "%d"
|
||||
console_gfx_close(int index) "%d"
|
||||
console_putchar_csi(int esc_param0, int esc_param1, int ch, int nb_esc_params) "escape sequence CSI%d;%d%c, %d parameters"
|
||||
console_putchar_unhandled(int ch) "unhandled escape character '%c'"
|
||||
console_txt_new(int w, int h) "%dx%d"
|
||||
|
|
Loading…
Reference in a new issue