SecBSD/xenocara
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sync code with last improvements from OpenBSD

Browse source
This commit is contained in:
purplerain 2023-08-28 05:57:34 +00:00
commit 88965415ff
Signed by: purplerain
GPG key ID: F42C07F07E2E35B7
26235 changed files with 29195616 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

14
lib/libdrm/tests/modetest/Android.mk Normal file
View file

@ -0,0 +1,14 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
include $(LOCAL_PATH)/Makefile.sources
LOCAL_SRC_FILES := $(MODETEST_FILES)
LOCAL_MODULE := modetest
LOCAL_SHARED_LIBRARIES := libdrm
LOCAL_STATIC_LIBRARIES := libdrm_util
include $(LIBDRM_COMMON_MK)
include $(BUILD_EXECUTABLE)

6
lib/libdrm/tests/modetest/Makefile.sources Normal file
View file

@ -0,0 +1,6 @@
MODETEST_FILES := \
buffers.c \
buffers.h \
cursor.c \
cursor.h \
modetest.c

340
lib/libdrm/tests/modetest/buffers.c Normal file
View file

@ -0,0 +1,340 @@
/*
* DRM based mode setting test program
* Copyright 2008 Tungsten Graphics
* Jakob Bornecrantz <jakob@tungstengraphics.com>
* Copyright 2008 Intel Corporation
* Jesse Barnes <jesse.barnes@intel.com>
*
* 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 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.
*/
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <sys/ioctl.h>
#include "drm.h"
#include "drm_fourcc.h"
#include "libdrm_macros.h"
#include "xf86drm.h"
#include "xf86drmMode.h"
#include "buffers.h"
struct bo
{
int fd;
void *ptr;
uint64_t size;
uint32_t pitch;
uint32_t handle;
};
/* -----------------------------------------------------------------------------
* Buffers management
*/
static struct bo *
bo_create_dumb(int fd, unsigned int width, unsigned int height, unsigned int bpp)
{
struct bo *bo;
int ret;
bo = calloc(1, sizeof(*bo));
if (bo == NULL) {
fprintf(stderr, "failed to allocate buffer object\n");
return NULL;
}
ret = drmModeCreateDumbBuffer(fd, width, height, bpp, 0, &bo->handle,
&bo->pitch, &bo->size);
if (ret) {
fprintf(stderr, "failed to create dumb buffer: %s\n",
strerror(errno));
free(bo);
return NULL;
}
bo->fd = fd;
return bo;
}
static int bo_map(struct bo *bo, void **out)
{
void *map;
int ret;
uint64_t offset;
ret = drmModeMapDumbBuffer(bo->fd, bo->handle, &offset);
if (ret)
return ret;
map = drm_mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED,
bo->fd, offset);
if (map == MAP_FAILED)
return -EINVAL;
bo->ptr = map;
*out = map;
return 0;
}
static void bo_unmap(struct bo *bo)
{
if (!bo->ptr)
return;
drm_munmap(bo->ptr, bo->size);
bo->ptr = NULL;
}
struct bo *
bo_create(int fd, unsigned int format,
unsigned int width, unsigned int height,
unsigned int handles[4], unsigned int pitches[4],
unsigned int offsets[4], enum util_fill_pattern pattern)
{
unsigned int virtual_height;
struct bo *bo;
unsigned int bpp;
void *planes[3] = { 0, };
void *virtual;
int ret;
switch (format) {
case DRM_FORMAT_C8:
case DRM_FORMAT_NV12:
case DRM_FORMAT_NV21:
case DRM_FORMAT_NV16:
case DRM_FORMAT_NV61:
case DRM_FORMAT_YUV420:
case DRM_FORMAT_YVU420:
bpp = 8;
break;
case DRM_FORMAT_ARGB4444:
case DRM_FORMAT_XRGB4444:
case DRM_FORMAT_ABGR4444:
case DRM_FORMAT_XBGR4444:
case DRM_FORMAT_RGBA4444:
case DRM_FORMAT_RGBX4444:
case DRM_FORMAT_BGRA4444:
case DRM_FORMAT_BGRX4444:
case DRM_FORMAT_ARGB1555:
case DRM_FORMAT_XRGB1555:
case DRM_FORMAT_ABGR1555:
case DRM_FORMAT_XBGR1555:
case DRM_FORMAT_RGBA5551:
case DRM_FORMAT_RGBX5551:
case DRM_FORMAT_BGRA5551:
case DRM_FORMAT_BGRX5551:
case DRM_FORMAT_RGB565:
case DRM_FORMAT_BGR565:
case DRM_FORMAT_UYVY:
case DRM_FORMAT_VYUY:
case DRM_FORMAT_YUYV:
case DRM_FORMAT_YVYU:
bpp = 16;
break;
case DRM_FORMAT_BGR888:
case DRM_FORMAT_RGB888:
bpp = 24;
break;
case DRM_FORMAT_ARGB8888:
case DRM_FORMAT_XRGB8888:
case DRM_FORMAT_ABGR8888:
case DRM_FORMAT_XBGR8888:
case DRM_FORMAT_RGBA8888:
case DRM_FORMAT_RGBX8888:
case DRM_FORMAT_BGRA8888:
case DRM_FORMAT_BGRX8888:
case DRM_FORMAT_ARGB2101010:
case DRM_FORMAT_XRGB2101010:
case DRM_FORMAT_ABGR2101010:
case DRM_FORMAT_XBGR2101010:
case DRM_FORMAT_RGBA1010102:
case DRM_FORMAT_RGBX1010102:
case DRM_FORMAT_BGRA1010102:
case DRM_FORMAT_BGRX1010102:
bpp = 32;
break;
case DRM_FORMAT_XRGB16161616F:
case DRM_FORMAT_XBGR16161616F:
case DRM_FORMAT_ARGB16161616F:
case DRM_FORMAT_ABGR16161616F:
bpp = 64;
break;
default:
fprintf(stderr, "unsupported format 0x%08x\n", format);
return NULL;
}
switch (format) {
case DRM_FORMAT_NV12:
case DRM_FORMAT_NV21:
case DRM_FORMAT_YUV420:
case DRM_FORMAT_YVU420:
virtual_height = height * 3 / 2;
break;
case DRM_FORMAT_NV16:
case DRM_FORMAT_NV61:
virtual_height = height * 2;
break;
default:
virtual_height = height;
break;
}
bo = bo_create_dumb(fd, width, virtual_height, bpp);
if (!bo)
return NULL;
ret = bo_map(bo, &virtual);
if (ret) {
fprintf(stderr, "failed to map buffer: %s\n",
strerror(-errno));
bo_destroy(bo);
return NULL;
}
/* just testing a limited # of formats to test single
* and multi-planar path.. would be nice to add more..
*/
switch (format) {
case DRM_FORMAT_UYVY:
case DRM_FORMAT_VYUY:
case DRM_FORMAT_YUYV:
case DRM_FORMAT_YVYU:
offsets[0] = 0;
handles[0] = bo->handle;
pitches[0] = bo->pitch;
planes[0] = virtual;
break;
case DRM_FORMAT_NV12:
case DRM_FORMAT_NV21:
case DRM_FORMAT_NV16:
case DRM_FORMAT_NV61:
offsets[0] = 0;
handles[0] = bo->handle;
pitches[0] = bo->pitch;
pitches[1] = pitches[0];
offsets[1] = pitches[0] * height;
handles[1] = bo->handle;
planes[0] = virtual;
planes[1] = virtual + offsets[1];
break;
case DRM_FORMAT_YUV420:
case DRM_FORMAT_YVU420:
offsets[0] = 0;
handles[0] = bo->handle;
pitches[0] = bo->pitch;
pitches[1] = pitches[0] / 2;
offsets[1] = pitches[0] * height;
handles[1] = bo->handle;
pitches[2] = pitches[1];
offsets[2] = offsets[1] + pitches[1] * height / 2;
handles[2] = bo->handle;
planes[0] = virtual;
planes[1] = virtual + offsets[1];
planes[2] = virtual + offsets[2];
break;
case DRM_FORMAT_C8:
case DRM_FORMAT_ARGB4444:
case DRM_FORMAT_XRGB4444:
case DRM_FORMAT_ABGR4444:
case DRM_FORMAT_XBGR4444:
case DRM_FORMAT_RGBA4444:
case DRM_FORMAT_RGBX4444:
case DRM_FORMAT_BGRA4444:
case DRM_FORMAT_BGRX4444:
case DRM_FORMAT_ARGB1555:
case DRM_FORMAT_XRGB1555:
case DRM_FORMAT_ABGR1555:
case DRM_FORMAT_XBGR1555:
case DRM_FORMAT_RGBA5551:
case DRM_FORMAT_RGBX5551:
case DRM_FORMAT_BGRA5551:
case DRM_FORMAT_BGRX5551:
case DRM_FORMAT_RGB565:
case DRM_FORMAT_BGR565:
case DRM_FORMAT_BGR888:
case DRM_FORMAT_RGB888:
case DRM_FORMAT_ARGB8888:
case DRM_FORMAT_XRGB8888:
case DRM_FORMAT_ABGR8888:
case DRM_FORMAT_XBGR8888:
case DRM_FORMAT_RGBA8888:
case DRM_FORMAT_RGBX8888:
case DRM_FORMAT_BGRA8888:
case DRM_FORMAT_BGRX8888:
case DRM_FORMAT_ARGB2101010:
case DRM_FORMAT_XRGB2101010:
case DRM_FORMAT_ABGR2101010:
case DRM_FORMAT_XBGR2101010:
case DRM_FORMAT_RGBA1010102:
case DRM_FORMAT_RGBX1010102:
case DRM_FORMAT_BGRA1010102:
case DRM_FORMAT_BGRX1010102:
case DRM_FORMAT_XRGB16161616F:
case DRM_FORMAT_XBGR16161616F:
case DRM_FORMAT_ARGB16161616F:
case DRM_FORMAT_ABGR16161616F:
offsets[0] = 0;
handles[0] = bo->handle;
pitches[0] = bo->pitch;
planes[0] = virtual;
break;
}
util_fill_pattern(format, pattern, planes, width, height, pitches[0]);
bo_unmap(bo);
return bo;
}
void bo_destroy(struct bo *bo)
{
int ret;
ret = drmModeDestroyDumbBuffer(bo->fd, bo->handle);
if (ret)
fprintf(stderr, "failed to destroy dumb buffer: %s\n",
strerror(errno));
free(bo);
}

40
lib/libdrm/tests/modetest/buffers.h Normal file
View file

@ -0,0 +1,40 @@
/*
* DRM based mode setting test program
* Copyright 2008 Tungsten Graphics
* Jakob Bornecrantz <jakob@tungstengraphics.com>
* Copyright 2008 Intel Corporation
* Jesse Barnes <jesse.barnes@intel.com>
*
* 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 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.
*/
#ifndef __BUFFERS_H__
#define __BUFFERS_H__
#include "util/pattern.h"
struct bo;
struct bo *bo_create(int fd, unsigned int format,
unsigned int width, unsigned int height,
unsigned int handles[4], unsigned int pitches[4],
unsigned int offsets[4], enum util_fill_pattern pattern);
void bo_destroy(struct bo *bo);
#endif

206
lib/libdrm/tests/modetest/cursor.c Normal file
View file

@ -0,0 +1,206 @@
/*
* DRM based mode setting test program
* Copyright (C) 2013 Red Hat
* Author: Rob Clark <robdclark@gmail.com>
*
* 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 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.
*/
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <signal.h>
#include <sys/time.h>
#include <pthread.h>
#include <unistd.h>
#include "xf86drm.h"
#include "xf86drmMode.h"
#include "util/common.h"
#include "buffers.h"
#include "cursor.h"
struct cursor {
int fd;
uint32_t bo_handle;
uint32_t crtc_id;
uint32_t crtc_w, crtc_h;
uint32_t w, h;
/* current state */
uint32_t enabled, x, y;
int32_t dx, dy;
};
#define MAX_CURSORS 8
static struct cursor cursors[MAX_CURSORS];
static int ncursors;
static pthread_t cursor_thread;
static int cursor_running;
/*
* Timer driven program loops through these steps to move/enable/disable
* the cursor
*/
struct cursor_step {
void (*run)(struct cursor *cursor, const struct cursor_step *step);
uint32_t msec;
uint32_t repeat;
int arg;
};
static uint32_t indx, count;
static void set_cursor(struct cursor *cursor, const struct cursor_step *step)
{
int enabled = (step->arg ^ count) & 0x1;
uint32_t handle = 0;
if (enabled)
handle = cursor->bo_handle;
cursor->enabled = enabled;
drmModeSetCursor(cursor->fd, cursor->crtc_id, handle, cursor->w, cursor->h);
}
static void move_cursor(struct cursor *cursor, const struct cursor_step *step)
{
int x = cursor->x;
int y = cursor->y;
if (!cursor->enabled)
drmModeSetCursor(cursor->fd, cursor->crtc_id,
cursor->bo_handle, cursor->w, cursor->h);
/* calculate new cursor position: */
x += cursor->dx * step->arg;
y += cursor->dy * step->arg;
if (x < 0) {
x = 0;
cursor->dx = 1;
} else if (x > (int)cursor->crtc_w) {
x = cursor->crtc_w - 1;
cursor->dx = -1;
}
if (y < 0) {
y = 0;
cursor->dy = 1;
} else if (y > (int)cursor->crtc_h) {
y = cursor->crtc_h - 1;
cursor->dy = -1;
}
cursor->x = x;
cursor->y = y;
drmModeMoveCursor(cursor->fd, cursor->crtc_id, x, y);
}
static const struct cursor_step steps[] = {
{ set_cursor, 10, 0, 1 }, /* enable */
{ move_cursor, 1, 100, 1 },
{ move_cursor, 1, 10, 10 },
{ set_cursor, 1, 100, 0 }, /* disable/enable loop */
{ move_cursor, 1, 10, 10 },
{ move_cursor, 9, 100, 1 },
{ move_cursor, 11, 100, 5 },
{ set_cursor, 17, 10, 0 }, /* disable/enable loop */
{ move_cursor, 9, 100, 1 },
{ set_cursor, 13, 10, 0 }, /* disable/enable loop */
{ move_cursor, 9, 100, 1 },
{ set_cursor, 13, 10, 0 }, /* disable/enable loop */
{ set_cursor, 10, 0, 0 }, /* disable */
};
static void *cursor_thread_func(void *data)
{
while (cursor_running) {
const struct cursor_step *step = &steps[indx % ARRAY_SIZE(steps)];
int i;
for (i = 0; i < ncursors; i++) {
struct cursor *cursor = &cursors[i];
step->run(cursor, step);
}
/* iterate to next count/step: */
if (count < step->repeat) {
count++;
} else {
count = 0;
indx++;
}
usleep(1000 * step->msec);
}
return NULL;
}
int cursor_init(int fd, uint32_t bo_handle, uint32_t crtc_id,
uint32_t crtc_w, uint32_t crtc_h, uint32_t w, uint32_t h)
{
struct cursor *cursor = &cursors[ncursors];
assert(ncursors < MAX_CURSORS);
cursor->fd = fd;
cursor->bo_handle = bo_handle;
cursor->crtc_id = crtc_id;
cursor->crtc_w = crtc_w;
cursor->crtc_h = crtc_h;
cursor->w = w;
cursor->h = h;
cursor->enabled = 0;
cursor->x = w/2;
cursor->y = h/2;
cursor->dx = 1;
cursor->dy = 1;
ncursors++;
return 0;
}
int cursor_start(void)
{
cursor_running = 1;
pthread_create(&cursor_thread, NULL, cursor_thread_func, NULL);
printf("starting cursor\n");
return 0;
}
int cursor_stop(void)
{
cursor_running = 0;
pthread_join(cursor_thread, NULL);
printf("cursor stopped\n");
return 0;
}

33
lib/libdrm/tests/modetest/cursor.h Normal file
View file

@ -0,0 +1,33 @@
/*
* DRM based mode setting test program
* Copyright (C) 2014 Red Hat
* Author: Rob Clark <robdclark@gmail.com>
*
* 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 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.
*/
#ifndef __CURSOR_H__
#define __CURSOR_H__
int cursor_init(int fd, uint32_t bo_handle, uint32_t crtc_id,
uint32_t crtc_w, uint32_t crtc_h, uint32_t w, uint32_t h);
int cursor_start(void);
int cursor_stop(void);
#endif

29
lib/libdrm/tests/modetest/meson.build Normal file
View file

@ -0,0 +1,29 @@
# Copyright © 2018 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 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.
modetest = executable(
'modetest',
files('buffers.c', 'cursor.c', 'modetest.c'),
c_args : [libdrm_c_args, '-Wno-pointer-arith'],
include_directories : [inc_root, inc_tests, inc_drm],
dependencies : [dep_threads, dep_cairo],
link_with : [libdrm, libutil],
install : with_install_tests,
)

2285
lib/libdrm/tests/modetest/modetest.c Normal file
View file

File diff suppressed because it is too large Load diff