[Mesa-dev] [RFC] tegra: Initial support
Rob Clark
robdclark at gmail.com
Thu Nov 27 08:51:08 PST 2014
On Thu, Nov 27, 2014 at 11:39 AM, Thierry Reding
<thierry.reding at gmail.com> wrote:
> Tegra K1 and later use a GPU that can be driven by the Nouveau driver.
> But the GPU is a pure render node and has no display engine, hence the
> scanout needs to happen on the Tegra display hardware. The GPU and the
> display engine each have a separate DRM device node exposed by the
> kernel.
>
> To make the setup appear as a single device, this driver instantiates
> a Nouveau screen with each instance of a Tegra screen and forwards GPU
> requests to the Nouveau screen. For purposes of scanout it will import
> buffers created on the GPU into the display driver. Handles that
> userspace requests are those of the display driver so that they can be
> used to create framebuffers.
>
> This has been tested with some GBM test programs, as well as kmscube and
> weston. All of those run without modifications, but I'm sure there is a
> lot that can be improved.
>
> TODO:
> - use Nouveau headers to get at the prototype for creating a screen
> - implement enough support to seamlessly integrate with X
> - refactor some of the code to be reusable by other drivers
I haven't looked too carefully at the implementation yet, but couldn't
you just put in src/gallium/drivers/shim ? I guess you'd just want a
small if/else ladder where you create the *actual* screen, to create a
nouveau screen for tegra, an etnaviv screen for imx, armada, etc..?
BR,
-R
>
> Signed-off-by: Thierry Reding <treding at nvidia.com>
> ---
> configure.ac | 12 +-
> src/gallium/Makefile.am | 5 +
> .../auxiliary/target-helpers/inline_drm_helper.h | 30 +
> src/gallium/drivers/tegra/Automake.inc | 11 +
> src/gallium/drivers/tegra/Makefile.am | 17 +
> src/gallium/drivers/tegra/Makefile.sources | 4 +
> src/gallium/drivers/tegra/tegra_context.c | 699 +++++++++++++++++++++
> src/gallium/drivers/tegra/tegra_context.h | 80 +++
> src/gallium/drivers/tegra/tegra_resource.c | 219 +++++++
> src/gallium/drivers/tegra/tegra_resource.h | 98 +++
> src/gallium/drivers/tegra/tegra_screen.c | 311 +++++++++
> src/gallium/drivers/tegra/tegra_screen.h | 45 ++
> src/gallium/targets/dri/Makefile.am | 2 +
> src/gallium/winsys/tegra/drm/Makefile.am | 11 +
> src/gallium/winsys/tegra/drm/Makefile.sources | 2 +
> src/gallium/winsys/tegra/drm/tegra_drm_public.h | 31 +
> src/gallium/winsys/tegra/drm/tegra_drm_winsys.c | 33 +
> 17 files changed, 1609 insertions(+), 1 deletion(-)
> create mode 100644 src/gallium/drivers/tegra/Automake.inc
> create mode 100644 src/gallium/drivers/tegra/Makefile.am
> create mode 100644 src/gallium/drivers/tegra/Makefile.sources
> create mode 100644 src/gallium/drivers/tegra/tegra_context.c
> create mode 100644 src/gallium/drivers/tegra/tegra_context.h
> create mode 100644 src/gallium/drivers/tegra/tegra_resource.c
> create mode 100644 src/gallium/drivers/tegra/tegra_resource.h
> create mode 100644 src/gallium/drivers/tegra/tegra_screen.c
> create mode 100644 src/gallium/drivers/tegra/tegra_screen.h
> create mode 100644 src/gallium/winsys/tegra/drm/Makefile.am
> create mode 100644 src/gallium/winsys/tegra/drm/Makefile.sources
> create mode 100644 src/gallium/winsys/tegra/drm/tegra_drm_public.h
> create mode 100644 src/gallium/winsys/tegra/drm/tegra_drm_winsys.c
>
> diff --git a/configure.ac b/configure.ac
> index 1d9d015481ec..ae50bec95339 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -33,6 +33,7 @@ LIBDRM_INTEL_REQUIRED=2.4.52
> LIBDRM_NVVIEUX_REQUIRED=2.4.33
> LIBDRM_NOUVEAU_REQUIRED="2.4.33 libdrm >= 2.4.41"
> LIBDRM_FREEDRENO_REQUIRED=2.4.57
> +LIBDRM_TEGRA_REQUIRED=2.4.58
> DRI2PROTO_REQUIRED=2.6
> DRI3PROTO_REQUIRED=1.0
> PRESENTPROTO_REQUIRED=1.0
> @@ -733,7 +734,7 @@ GALLIUM_DRIVERS_DEFAULT="r300,r600,svga,swrast"
> AC_ARG_WITH([gallium-drivers],
> [AS_HELP_STRING([--with-gallium-drivers@<:@=DIRS...@:>@],
> [comma delimited Gallium drivers list, e.g.
> - "i915,ilo,nouveau,r300,r600,radeonsi,freedreno,svga,swrast,vc4"
> + "i915,ilo,nouveau,r300,r600,radeonsi,freedreno,tegra,svga,swrast,vc4"
> @<:@default=r300,r600,svga,swrast@:>@])],
> [with_gallium_drivers="$withval"],
> [with_gallium_drivers="$GALLIUM_DRIVERS_DEFAULT"])
> @@ -1937,6 +1938,12 @@ if test -n "$with_gallium_drivers"; then
> gallium_require_drm "freedreno"
> gallium_require_drm_loader
> ;;
> + xtegra)
> + HAVE_GALLIUM_TEGRA=yes
> + PKG_CHECK_MODULES([TEGRA], [libdrm_tegra >= $LIBDRM_TEGRA_REQUIRED])
> + gallium_require_drm "tegra"
> + gallium_require_drm_loader
> + ;;
> xswrast)
> HAVE_GALLIUM_SOFTPIPE=yes
> if test "x$MESA_LLVM" = x1; then
> @@ -2018,6 +2025,7 @@ AM_CONDITIONAL(HAVE_GALLIUM_RADEON_COMMON, test "x$HAVE_GALLIUM_R600" = xyes -o
> "x$HAVE_GALLIUM_RADEONSI" = xyes)
> AM_CONDITIONAL(HAVE_GALLIUM_NOUVEAU, test "x$HAVE_GALLIUM_NOUVEAU" = xyes)
> AM_CONDITIONAL(HAVE_GALLIUM_FREEDRENO, test "x$HAVE_GALLIUM_FREEDRENO" = xyes)
> +AM_CONDITIONAL(HAVE_GALLIUM_TEGRA, test "x$HAVE_GALLIUM_TEGRA" = xyes)
> AM_CONDITIONAL(HAVE_GALLIUM_SOFTPIPE, test "x$HAVE_GALLIUM_SOFTPIPE" = xyes)
> AM_CONDITIONAL(HAVE_GALLIUM_LLVMPIPE, test "x$HAVE_GALLIUM_LLVMPIPE" = xyes)
> AM_CONDITIONAL(HAVE_GALLIUM_VC4, test "x$HAVE_GALLIUM_VC4" = xyes)
> @@ -2159,6 +2167,7 @@ AC_CONFIG_FILES([Makefile
> src/gallium/drivers/rbug/Makefile
> src/gallium/drivers/softpipe/Makefile
> src/gallium/drivers/svga/Makefile
> + src/gallium/drivers/tegra/Makefile
> src/gallium/drivers/trace/Makefile
> src/gallium/drivers/vc4/Makefile
> src/gallium/drivers/vc4/kernel/Makefile
> @@ -2204,6 +2213,7 @@ AC_CONFIG_FILES([Makefile
> src/gallium/winsys/sw/wayland/Makefile
> src/gallium/winsys/sw/wrapper/Makefile
> src/gallium/winsys/sw/xlib/Makefile
> + src/gallium/winsys/tegra/drm/Makefile
> src/gallium/winsys/vc4/drm/Makefile
> src/gbm/Makefile
> src/gbm/main/gbm.pc
> diff --git a/src/gallium/Makefile.am b/src/gallium/Makefile.am
> index 81840b2081b6..1e76681a7329 100644
> --- a/src/gallium/Makefile.am
> +++ b/src/gallium/Makefile.am
> @@ -77,6 +77,11 @@ SUBDIRS += drivers/llvmpipe
> endif
> endif
>
> +## tegra
> +if HAVE_GALLIUM_TEGRA
> +SUBDIRS += drivers/tegra winsys/tegra/drm
> +endif
> +
> ## vc4/rpi
> if HAVE_GALLIUM_VC4
> SUBDIRS += drivers/vc4 winsys/vc4/drm
> diff --git a/src/gallium/auxiliary/target-helpers/inline_drm_helper.h b/src/gallium/auxiliary/target-helpers/inline_drm_helper.h
> index 81649d42582c..5808765a503e 100644
> --- a/src/gallium/auxiliary/target-helpers/inline_drm_helper.h
> +++ b/src/gallium/auxiliary/target-helpers/inline_drm_helper.h
> @@ -58,6 +58,10 @@
> #include "vc4/drm/vc4_drm_public.h"
> #endif
>
> +#if GALLIUM_TEGRA
> +#include "tegra/drm/tegra_drm_public.h"
> +#endif
> +
> static char* driver_name = NULL;
>
> /* XXX: We need to teardown the winsys if *screen_create() fails. */
> @@ -332,6 +336,27 @@ pipe_vc4_create_screen(int fd)
> }
> #endif
>
> +#if defined(GALLIUM_TEGRA)
> +#if defined(DRI_TARGET)
> +const __DRIextension **__driDriverGetExtensions_tegra(void);
> +
> +PUBLIC const __DRIextension **__driDriverGetExtensions_tegra(void)
> +{
> + globalDriverAPI = &galliumdrm_driver_api;
> + return galliumdrm_driver_extensions;
> +}
> +#endif
> +
> +static struct pipe_screen *pipe_tegra_create_screen(int fd)
> +{
> + struct pipe_screen *screen;
> +
> + screen = tegra_drm_screen_create(fd);
> +
> + return screen ? debug_screen_wrap(screen) : NULL;
> +}
> +#endif
> +
> inline struct pipe_screen *
> dd_create_screen(int fd)
> {
> @@ -389,6 +414,11 @@ dd_create_screen(int fd)
> else
> #endif
> #endif
> +#if defined(GALLIUM_TEGRA)
> + if (strcmp(driver_name, "tegra") == 0)
> + return pipe_tegra_create_screen(fd);
> + else
> +#endif
> return NULL;
> }
>
> diff --git a/src/gallium/drivers/tegra/Automake.inc b/src/gallium/drivers/tegra/Automake.inc
> new file mode 100644
> index 000000000000..f65281916245
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/Automake.inc
> @@ -0,0 +1,11 @@
> +if HAVE_GALLIUM_TEGRA
> +
> +TARGET_DRIVERS += tegra
> +TARGET_CPPFLAGS += -DGALLIUM_TEGRA
> +TARGET_LIB_DEPS += \
> + $(top_builddir)/src/gallium/winsys/tegra/drm/libtegradrm.la \
> + $(top_builddir)/src/gallium/drivers/tegra/libtegra.la \
> + $(LIBDRM_LIBS) \
> + $(TEGRA_LIBS)
> +
> +endif
> diff --git a/src/gallium/drivers/tegra/Makefile.am b/src/gallium/drivers/tegra/Makefile.am
> new file mode 100644
> index 000000000000..eb03df9bb2ed
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/Makefile.am
> @@ -0,0 +1,17 @@
> +AUTOMAKE_OPTIONS = subdir-objects
> +
> +include Makefile.sources
> +include $(top_srcdir)/src/gallium/Automake.inc
> +
> +AM_CFLAGS = \
> + $(GALLIUM_DRIVER_CFLAGS) \
> + $(LIBUDEV_CFLAGS) \
> + $(TEGRA_CFLAGS)
> +
> +noinst_LTLIBRARIES = libtegra.la
> +
> +libtegra_la_SOURCES = \
> + $(C_SOURCES)
> +
> +libtegra_la_LIBADD = \
> + $(LIBUDEV_LIBS)
> diff --git a/src/gallium/drivers/tegra/Makefile.sources b/src/gallium/drivers/tegra/Makefile.sources
> new file mode 100644
> index 000000000000..978dd14667f5
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/Makefile.sources
> @@ -0,0 +1,4 @@
> +C_SOURCES := \
> + tegra_context.c \
> + tegra_resource.c \
> + tegra_screen.c
> diff --git a/src/gallium/drivers/tegra/tegra_context.c b/src/gallium/drivers/tegra/tegra_context.c
> new file mode 100644
> index 000000000000..a7a7690ec7bb
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/tegra_context.c
> @@ -0,0 +1,699 @@
> +/*
> + * Copyright © 2014 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.
> + */
> +
> +#include <stdlib.h>
> +
> +#include "util/u_debug.h"
> +#include "util/u_inlines.h"
> +
> +#include "tegra/tegra_context.h"
> +#include "tegra/tegra_resource.h"
> +#include "tegra/tegra_screen.h"
> +
> +static void
> +tegra_destroy(struct pipe_context *pcontext)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->destroy(context->gpu);
> + free(context);
> +}
> +
> +static void
> +tegra_draw_vbo(struct pipe_context *pcontext,
> + const struct pipe_draw_info *pinfo)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct pipe_draw_info info;
> +
> + if (pinfo && pinfo->indirect) {
> + memcpy(&info, pinfo, sizeof(info));
> + info.indirect = tegra_resource_unwrap(info.indirect);
> + pinfo = &info;
> + }
> +
> + context->gpu->draw_vbo(context->gpu, pinfo);
> +}
> +
> +static void *
> +tegra_create_blend_state(struct pipe_context *pcontext,
> + const struct pipe_blend_state *cso)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_blend_state(context->gpu, cso);
> +}
> +
> +static void
> +tegra_bind_blend_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->bind_blend_state(context->gpu, so);
> +}
> +
> +static void
> +tegra_delete_blend_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->delete_blend_state(context->gpu, so);
> +}
> +
> +static void *
> +tegra_create_sampler_state(struct pipe_context *pcontext,
> + const struct pipe_sampler_state *cso)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_sampler_state(context->gpu, cso);
> +}
> +
> +static void
> +tegra_bind_sampler_states(struct pipe_context *pcontext,
> + unsigned shader,
> + unsigned start_slot,
> + unsigned num_samplers,
> + void **samplers)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->bind_sampler_states(context->gpu, shader, start_slot,
> + num_samplers, samplers);
> +}
> +
> +static void
> +tegra_delete_sampler_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->delete_sampler_state(context->gpu, so);
> +}
> +
> +static void *
> +tegra_create_rasterizer_state(struct pipe_context *pcontext,
> + const struct pipe_rasterizer_state *cso)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_rasterizer_state(context->gpu, cso);
> +}
> +
> +static void
> +tegra_bind_rasterizer_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->bind_rasterizer_state(context->gpu, so);
> +}
> +
> +static void
> +tegra_delete_rasterizer_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->delete_rasterizer_state(context->gpu, so);
> +}
> +
> +static void *
> +tegra_create_depth_stencil_alpha_state(struct pipe_context *pcontext,
> + const struct pipe_depth_stencil_alpha_state *cso)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_depth_stencil_alpha_state(context->gpu,
> + cso);
> +}
> +
> +static void
> +tegra_bind_depth_stencil_alpha_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->bind_depth_stencil_alpha_state(context->gpu, so);
> +}
> +
> +static void
> +tegra_delete_depth_stencil_alpha_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->delete_depth_stencil_alpha_state(context->gpu, so);
> +}
> +
> +static void *
> +tegra_create_fs_state(struct pipe_context *pcontext,
> + const struct pipe_shader_state *cso)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_fs_state(context->gpu, cso);
> +}
> +
> +static void
> +tegra_bind_fs_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->bind_fs_state(context->gpu, so);
> +}
> +
> +static void
> +tegra_delete_fs_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->delete_fs_state(context->gpu, so);
> +}
> +
> +static void *
> +tegra_create_vs_state(struct pipe_context *pcontext,
> + const struct pipe_shader_state *cso)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_vs_state(context->gpu, cso);
> +}
> +
> +static void
> +tegra_bind_vs_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->bind_vs_state(context->gpu, so);
> +}
> +
> +static void
> +tegra_delete_vs_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->delete_vs_state(context->gpu, so);
> +}
> +
> +static void *
> +tegra_create_gs_state(struct pipe_context *pcontext,
> + const struct pipe_shader_state *cso)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_gs_state(context->gpu, cso);
> +}
> +
> +static void
> +tegra_bind_gs_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->bind_gs_state(context->gpu, so);
> +}
> +
> +static void
> +tegra_delete_gs_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->delete_gs_state(context->gpu, so);
> +}
> +
> +static void *
> +tegra_create_vertex_elements_state(struct pipe_context *pcontext,
> + unsigned num_elements,
> + const struct pipe_vertex_element *elements)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_vertex_elements_state(context->gpu,
> + num_elements,
> + elements);
> +}
> +
> +static void
> +tegra_bind_vertex_elements_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->bind_vertex_elements_state(context->gpu, so);
> +}
> +
> +static void
> +tegra_delete_vertex_elements_state(struct pipe_context *pcontext,
> + void *so)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->delete_vertex_elements_state(context->gpu, so);
> +}
> +
> +static void
> +tegra_set_constant_buffer(struct pipe_context *pcontext,
> + uint shader,
> + uint index,
> + struct pipe_constant_buffer *buf)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct pipe_constant_buffer buffer;
> +
> + if (buf && buf->buffer) {
> + memcpy(&buffer, buf, sizeof(buffer));
> + buffer.buffer = tegra_resource_unwrap(buffer.buffer);
> + buf = &buffer;
> + }
> +
> + context->gpu->set_constant_buffer(context->gpu, shader, index, buf);
> +}
> +
> +static void
> +tegra_set_framebuffer_state(struct pipe_context *pcontext,
> + const struct pipe_framebuffer_state *fb)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct pipe_framebuffer_state state;
> + unsigned i;
> +
> + if (fb) {
> + memcpy(&state, fb, sizeof(state));
> +
> + for (i = 0; i < fb->nr_cbufs; i++)
> + state.cbufs[i] = tegra_surface_unwrap(fb->cbufs[i]);
> +
> + while (i < PIPE_MAX_COLOR_BUFS)
> + state.cbufs[i++] = NULL;
> +
> + state.zsbuf = tegra_surface_unwrap(fb->zsbuf);
> +
> + fb = &state;
> + }
> +
> + context->gpu->set_framebuffer_state(context->gpu, fb);
> +}
> +
> +static void
> +tegra_set_polygon_stipple(struct pipe_context *pcontext,
> + const struct pipe_poly_stipple *stipple)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->set_polygon_stipple(context->gpu, stipple);
> +}
> +
> +static void
> +tegra_set_scissor_states(struct pipe_context *pcontext,
> + unsigned start_slot,
> + unsigned num_scissors,
> + const struct pipe_scissor_state *scissors)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->set_scissor_states(context->gpu, start_slot,
> + num_scissors, scissors);
> +}
> +
> +static void
> +tegra_set_viewport_states(struct pipe_context *pcontext,
> + unsigned start_slot,
> + unsigned num_viewports,
> + const struct pipe_viewport_state *viewports)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->set_viewport_states(context->gpu, start_slot,
> + num_viewports, viewports);
> +}
> +
> +static void
> +tegra_set_sampler_views(struct pipe_context *pcontext,
> + unsigned shader,
> + unsigned start_slot,
> + unsigned num_views,
> + struct pipe_sampler_view **pviews)
> +{
> + struct pipe_sampler_view *views[PIPE_MAX_SHADER_SAMPLER_VIEWS];
> + struct tegra_context *context = to_tegra_context(pcontext);
> + unsigned i;
> +
> + for (i = 0; i < num_views; i++)
> + views[i] = tegra_sampler_view_unwrap(pviews[i]);
> +
> + context->gpu->set_sampler_views(context->gpu, shader, start_slot,
> + num_views, views);
> +}
> +
> +static void
> +tegra_set_shader_resources(struct pipe_context *pcontext,
> + unsigned start,
> + unsigned count,
> + struct pipe_surface **resources)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->set_shader_resources(context->gpu, start, count,
> + resources);
> +}
> +
> +static void
> +tegra_set_vertex_buffers(struct pipe_context *pcontext,
> + unsigned start_slot,
> + unsigned num_buffers,
> + const struct pipe_vertex_buffer *buffers)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct pipe_vertex_buffer buf[PIPE_MAX_SHADER_INPUTS];
> + unsigned i;
> +
> + if (num_buffers && buffers) {
> + memcpy(buf, buffers, num_buffers * sizeof(struct pipe_vertex_buffer));
> +
> + for (i = 0; i < num_buffers; i++)
> + buf[i].buffer = tegra_resource_unwrap(buf[i].buffer);
> +
> + buffers = buf;
> + }
> +
> + context->gpu->set_vertex_buffers(context->gpu, start_slot,
> + num_buffers, buffers);
> +}
> +
> +static void
> +tegra_set_index_buffer(struct pipe_context *pcontext,
> + const struct pipe_index_buffer *buffer)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct pipe_index_buffer buf;
> +
> + if (buffer) {
> + memcpy(&buf, buffer, sizeof(buf));
> + buf.buffer = tegra_resource_unwrap(buf.buffer);
> + buffer = &buf;
> + }
> +
> + context->gpu->set_index_buffer(context->gpu, buffer);
> +}
> +
> +static struct pipe_stream_output_target *
> +tegra_create_stream_output_target(struct pipe_context *pcontext,
> + struct pipe_resource *presource,
> + unsigned buffer_offset,
> + unsigned buffer_size)
> +{
> + struct tegra_resource *resource = to_tegra_resource(presource);
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + return context->gpu->create_stream_output_target(context->gpu,
> + resource->gpu,
> + buffer_offset,
> + buffer_size);
> +}
> +
> +static void
> +tegra_stream_output_target_destroy(struct pipe_context *pcontext,
> + struct pipe_stream_output_target *target)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->stream_output_target_destroy(context->gpu, target);
> +}
> +
> +static void
> +tegra_set_stream_output_targets(struct pipe_context *pcontext,
> + unsigned num_targets,
> + struct pipe_stream_output_target **targets,
> + const unsigned *offsets)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->set_stream_output_targets(context->gpu, num_targets,
> + targets, offsets);
> +}
> +
> +static void
> +tegra_blit(struct pipe_context *pcontext,
> + const struct pipe_blit_info *pinfo)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct pipe_blit_info info;
> +
> + if (pinfo) {
> + memcpy(&info, pinfo, sizeof(info));
> + info.dst.resource = tegra_resource_unwrap(info.dst.resource);
> + info.src.resource = tegra_resource_unwrap(info.src.resource);
> + pinfo = &info;
> + }
> +
> + context->gpu->blit(context->gpu, pinfo);
> +}
> +
> +static void
> +tegra_clear(struct pipe_context *pcontext,
> + unsigned buffers,
> + const union pipe_color_union *color,
> + double depth,
> + unsigned stencil)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->clear(context->gpu, buffers, color, depth, stencil);
> +}
> +
> +static void
> +tegra_flush(struct pipe_context *pcontext,
> + struct pipe_fence_handle **fence,
> + unsigned flags)
> +{
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->flush(context->gpu, fence, flags);
> +}
> +
> +static struct pipe_sampler_view *
> +tegra_create_sampler_view(struct pipe_context *pcontext,
> + struct pipe_resource *ptexture,
> + const struct pipe_sampler_view *template)
> +{
> + struct tegra_resource *texture = to_tegra_resource(ptexture);
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct tegra_sampler_view *view;
> +
> + view = calloc(1, sizeof(*view));
> + if (!view)
> + return NULL;
> +
> + view->gpu = context->gpu->create_sampler_view(context->gpu,
> + texture->gpu,
> + template);
> + memcpy(&view->base, view->gpu, sizeof(*view->gpu));
> + /* overwrite to prevent reference from being released */
> + view->base.texture = NULL;
> +
> + pipe_reference_init(&view->base.reference, 1);
> + pipe_resource_reference(&view->base.texture, ptexture);
> + view->base.context = pcontext;
> +
> + return &view->base;
> +}
> +
> +static void
> +tegra_sampler_view_destroy(struct pipe_context *pcontext,
> + struct pipe_sampler_view *pview)
> +{
> + struct tegra_sampler_view *view = to_tegra_sampler_view(pview);
> +
> + pipe_resource_reference(&view->base.texture, NULL);
> + pipe_sampler_view_reference(&view->gpu, NULL);
> + free(view);
> +}
> +
> +static void
> +tegra_flush_resource(struct pipe_context *pcontext,
> + struct pipe_resource *presource)
> +{
> + struct tegra_resource *resource = to_tegra_resource(presource);
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->flush_resource(context->gpu, resource->gpu);
> +}
> +
> +static void *
> +tegra_transfer_map(struct pipe_context *pcontext,
> + struct pipe_resource *presource,
> + unsigned level,
> + unsigned usage,
> + const struct pipe_box *box,
> + struct pipe_transfer **ptransfer)
> +{
> + struct tegra_resource *resource = to_tegra_resource(presource);
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct tegra_transfer *transfer;
> +
> + transfer = calloc(1, sizeof(*transfer));
> + if (!transfer)
> + return NULL;
> +
> + transfer->map = context->gpu->transfer_map(context->gpu,
> + resource->gpu,
> + level,
> + usage,
> + box,
> + &transfer->gpu);
> + memcpy(&transfer->base, transfer->gpu, sizeof(*transfer->gpu));
> + transfer->base.resource = NULL;
> + pipe_resource_reference(&transfer->base.resource, presource);
> +
> + *ptransfer = &transfer->base;
> +
> + return transfer->map;
> +}
> +
> +static void
> +tegra_transfer_unmap(struct pipe_context *pcontext,
> + struct pipe_transfer *ptransfer)
> +{
> + struct tegra_transfer *transfer = to_tegra_transfer(ptransfer);
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->transfer_unmap(context->gpu, transfer->gpu);
> + pipe_resource_reference(&transfer->base.resource, NULL);
> + free(transfer);
> +}
> +
> +static void
> +tegra_transfer_inline_write(struct pipe_context *pcontext,
> + struct pipe_resource *presource,
> + unsigned level,
> + unsigned usage,
> + const struct pipe_box *box,
> + const void *data,
> + unsigned stride,
> + unsigned layer_stride)
> +{
> + struct tegra_resource *resource = to_tegra_resource(presource);
> + struct tegra_context *context = to_tegra_context(pcontext);
> +
> + context->gpu->transfer_inline_write(context->gpu, resource->gpu,
> + level, usage, box, data, stride,
> + layer_stride);
> +}
> +
> +struct pipe_context *
> +tegra_context_create(struct pipe_screen *pscreen, void *priv)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> + struct tegra_context *context;
> +
> + context = calloc(1, sizeof(*context));
> + if (!context)
> + return NULL;
> +
> + context->gpu = screen->gpu->context_create(screen->gpu, priv);
> + if (!context->gpu) {
> + debug_error("failed to create GPU context\n");
> + free(context);
> + return NULL;
> + }
> +
> + context->base.screen = &screen->base;
> + context->base.priv = priv;
> +
> + context->base.destroy = tegra_destroy;
> +
> + context->base.draw_vbo = tegra_draw_vbo;
> +
> + context->base.create_blend_state = tegra_create_blend_state;
> + context->base.bind_blend_state = tegra_bind_blend_state;
> + context->base.delete_blend_state = tegra_delete_blend_state;
> +
> + context->base.create_sampler_state = tegra_create_sampler_state;
> + context->base.bind_sampler_states = tegra_bind_sampler_states;
> + context->base.delete_sampler_state = tegra_delete_sampler_state;
> +
> + context->base.create_rasterizer_state = tegra_create_rasterizer_state;
> + context->base.bind_rasterizer_state = tegra_bind_rasterizer_state;
> + context->base.delete_rasterizer_state = tegra_delete_rasterizer_state;
> +
> + context->base.create_depth_stencil_alpha_state = tegra_create_depth_stencil_alpha_state;
> + context->base.bind_depth_stencil_alpha_state = tegra_bind_depth_stencil_alpha_state;
> + context->base.delete_depth_stencil_alpha_state = tegra_delete_depth_stencil_alpha_state;
> +
> + context->base.create_fs_state = tegra_create_fs_state;
> + context->base.bind_fs_state = tegra_bind_fs_state;
> + context->base.delete_fs_state = tegra_delete_fs_state;
> +
> + context->base.create_vs_state = tegra_create_vs_state;
> + context->base.bind_vs_state = tegra_bind_vs_state;
> + context->base.delete_vs_state = tegra_delete_vs_state;
> +
> + context->base.create_gs_state = tegra_create_gs_state;
> + context->base.bind_gs_state = tegra_bind_gs_state;
> + context->base.delete_gs_state = tegra_delete_gs_state;
> +
> + context->base.create_vertex_elements_state = tegra_create_vertex_elements_state;
> + context->base.bind_vertex_elements_state = tegra_bind_vertex_elements_state;
> + context->base.delete_vertex_elements_state = tegra_delete_vertex_elements_state;
> +
> + context->base.set_constant_buffer = tegra_set_constant_buffer;
> + context->base.set_framebuffer_state = tegra_set_framebuffer_state;
> + context->base.set_polygon_stipple = tegra_set_polygon_stipple;
> + context->base.set_scissor_states = tegra_set_scissor_states;
> + context->base.set_viewport_states = tegra_set_viewport_states;
> + context->base.set_sampler_views = tegra_set_sampler_views;
> +
> + context->base.set_shader_resources = tegra_set_shader_resources;
> + context->base.set_vertex_buffers = tegra_set_vertex_buffers;
> + context->base.set_index_buffer = tegra_set_index_buffer;
> +
> + context->base.create_stream_output_target = tegra_create_stream_output_target;
> + context->base.stream_output_target_destroy = tegra_stream_output_target_destroy;
> + context->base.set_stream_output_targets = tegra_set_stream_output_targets;
> +
> + context->base.blit = tegra_blit;
> + context->base.clear = tegra_clear;
> + context->base.flush = tegra_flush;
> +
> + context->base.create_sampler_view = tegra_create_sampler_view;
> + context->base.sampler_view_destroy = tegra_sampler_view_destroy;
> +
> + context->base.flush_resource = tegra_flush_resource;
> +
> + context->base.create_surface = tegra_create_surface;
> + context->base.surface_destroy = tegra_surface_destroy;
> +
> + context->base.transfer_map = tegra_transfer_map;
> + context->base.transfer_unmap = tegra_transfer_unmap;
> + context->base.transfer_inline_write = tegra_transfer_inline_write;
> +
> + return &context->base;
> +}
> diff --git a/src/gallium/drivers/tegra/tegra_context.h b/src/gallium/drivers/tegra/tegra_context.h
> new file mode 100644
> index 000000000000..2a26ec6d9c63
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/tegra_context.h
> @@ -0,0 +1,80 @@
> +/*
> + * Copyright © 2014 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.
> + */
> +
> +#ifndef TEGRA_CONTEXT_H
> +#define TEGRA_CONTEXT_H
> +
> +#include "pipe/p_context.h"
> +#include "pipe/p_state.h"
> +
> +struct tegra_screen;
> +
> +struct tegra_context {
> + struct pipe_context base;
> + struct pipe_context *gpu;
> +};
> +
> +static inline struct tegra_context *
> +to_tegra_context(struct pipe_context *context)
> +{
> + return (struct tegra_context *)context;
> +}
> +
> +struct pipe_context *tegra_context_create(struct pipe_screen *pscreen,
> + void *priv);
> +
> +struct tegra_sampler_view {
> + struct pipe_sampler_view base;
> + struct pipe_sampler_view *gpu;
> +};
> +
> +static INLINE struct tegra_sampler_view *
> +to_tegra_sampler_view(struct pipe_sampler_view *view)
> +{
> + return (struct tegra_sampler_view *)view;
> +}
> +
> +static INLINE struct pipe_sampler_view *
> +tegra_sampler_view_unwrap(struct pipe_sampler_view *view)
> +{
> + if (!view)
> + return NULL;
> +
> + return to_tegra_sampler_view(view)->gpu;
> +}
> +
> +struct tegra_transfer {
> + struct pipe_transfer base;
> + struct pipe_transfer *gpu;
> +
> + unsigned int count;
> + void *map;
> +};
> +
> +static INLINE struct tegra_transfer *
> +to_tegra_transfer(struct pipe_transfer *transfer)
> +{
> + return (struct tegra_transfer *)transfer;
> +}
> +
> +#endif /* TEGRA_SCREEN_H */
> diff --git a/src/gallium/drivers/tegra/tegra_resource.c b/src/gallium/drivers/tegra/tegra_resource.c
> new file mode 100644
> index 000000000000..8c5b7d4e41fc
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/tegra_resource.c
> @@ -0,0 +1,219 @@
> +/*
> + * Copyright © 2014 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.
> + */
> +
> +#include <errno.h>
> +#include <stdlib.h>
> +#include <stdint.h>
> +#include <stdio.h>
> +
> +#include <drm/tegra_drm.h>
> +#include <xf86drm.h>
> +
> +#include "pipe/p_state.h"
> +#include "util/u_debug.h"
> +#include "util/u_format.h"
> +#include "util/u_inlines.h"
> +
> +#include "state_tracker/drm_driver.h"
> +
> +#include "tegra/tegra_context.h"
> +#include "tegra/tegra_resource.h"
> +#include "tegra/tegra_screen.h"
> +
> +struct pipe_resource *
> +tegra_resource_create(struct pipe_screen *pscreen,
> + const struct pipe_resource *template)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> + struct tegra_resource *resource;
> +
> + resource = calloc(1, sizeof(*resource));
> + if (!resource)
> + return NULL;
> +
> + /* import scanout buffers for display */
> + if (template->bind & PIPE_BIND_SCANOUT) {
> + struct drm_tegra_gem_set_tiling args;
> + struct winsys_handle handle;
> + boolean status;
> + int fd, err;
> +
> + resource->gpu = screen->gpu->resource_create(screen->gpu,
> + template);
> + if (!resource->gpu)
> + goto free;
> +
> + memset(&handle, 0, sizeof(handle));
> + handle.type = DRM_API_HANDLE_TYPE_FD;
> +
> + status = screen->gpu->resource_get_handle(screen->gpu,
> + resource->gpu,
> + &handle);
> + if (!status)
> + goto destroy;
> +
> + resource->stride = handle.stride;
> + fd = handle.handle;
> +
> + err = drmPrimeFDToHandle(screen->fd, fd, &resource->handle);
> + if (err < 0) {
> + fprintf(stderr, "drmPrimeFDToHandle() failed: %s\n",
> + strerror(errno));
> + close(fd);
> + goto destroy;
> + }
> +
> + close(fd);
> +
> + memset(&args, 0, sizeof(args));
> + args.handle = resource->handle;
> + args.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK;
> + args.value = 4;
> +
> + err = drmIoctl(screen->fd, DRM_IOCTL_TEGRA_GEM_SET_TILING,
> + &args);
> + if (err < 0) {
> + fprintf(stderr, "failed to set tiling parameters: %s\n",
> + strerror(errno));
> + goto destroy;
> + }
> + } else {
> + resource->gpu = screen->gpu->resource_create(screen->gpu,
> + template);
> + if (!resource->gpu)
> + goto free;
> + }
> +
> + memcpy(&resource->base, resource->gpu, sizeof(*resource->gpu));
> + pipe_reference_init(&resource->base.reference, 1);
> + resource->base.screen = &screen->base;
> +
> + return &resource->base;
> +
> +destroy:
> + screen->gpu->resource_destroy(screen->gpu, resource->gpu);
> +free:
> + free(resource);
> + return NULL;
> +}
> +
> +struct pipe_resource *
> +tegra_resource_from_handle(struct pipe_screen *pscreen,
> + const struct pipe_resource *template,
> + struct winsys_handle *handle)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> + struct tegra_resource *resource;
> +
> + resource = calloc(1, sizeof(*resource));
> + if (!resource)
> + return NULL;
> +
> + resource->gpu = screen->gpu->resource_from_handle(screen->gpu,
> + template,
> + handle);
> + if (!resource->gpu) {
> + free(resource);
> + return NULL;
> + }
> +
> + memcpy(&resource->base, resource->gpu, sizeof(*resource->gpu));
> + pipe_reference_init(&resource->base.reference, 1);
> + resource->base.screen = &screen->base;
> +
> + return &resource->base;
> +}
> +
> +boolean
> +tegra_resource_get_handle(struct pipe_screen *pscreen,
> + struct pipe_resource *presource,
> + struct winsys_handle *handle)
> +{
> + struct tegra_resource *resource = to_tegra_resource(presource);
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> + boolean ret = TRUE;
> +
> + if (presource->bind & PIPE_BIND_SCANOUT) {
> + handle->handle = resource->handle;
> + handle->stride = resource->stride;
> + } else {
> + ret = screen->gpu->resource_get_handle(screen->gpu,
> + resource->gpu,
> + handle);
> + }
> +
> + return ret;
> +}
> +
> +void
> +tegra_resource_destroy(struct pipe_screen *pscreen,
> + struct pipe_resource *presource)
> +{
> + struct tegra_resource *resource = to_tegra_resource(presource);
> +
> + pipe_resource_reference(&resource->gpu, NULL);
> + free(resource);
> +}
> +
> +struct pipe_surface *
> +tegra_create_surface(struct pipe_context *pcontext,
> + struct pipe_resource *presource,
> + const struct pipe_surface *template)
> +{
> + struct tegra_resource *resource = to_tegra_resource(presource);
> + struct tegra_context *context = to_tegra_context(pcontext);
> + struct tegra_surface *surface;
> +
> + surface = calloc(1, sizeof(*surface));
> + if (!surface)
> + return NULL;
> +
> + surface->gpu = context->gpu->create_surface(context->gpu,
> + resource->gpu,
> + template);
> + if (!surface->gpu) {
> + free(surface);
> + return NULL;
> + }
> +
> + memcpy(&surface->base, surface->gpu, sizeof(*surface->gpu));
> + /* overwrite to prevent reference from being released */
> + surface->base.texture = NULL;
> +
> + pipe_reference_init(&surface->base.reference, 1);
> + pipe_resource_reference(&surface->base.texture, presource);
> + surface->base.context = &context->base;
> +
> + return &surface->base;
> +}
> +
> +void
> +tegra_surface_destroy(struct pipe_context *pcontext,
> + struct pipe_surface *psurface)
> +{
> + struct tegra_surface *surface = to_tegra_surface(psurface);
> +
> + pipe_resource_reference(&surface->base.texture, NULL);
> + pipe_surface_reference(&surface->gpu, NULL);
> + free(surface);
> +}
> diff --git a/src/gallium/drivers/tegra/tegra_resource.h b/src/gallium/drivers/tegra/tegra_resource.h
> new file mode 100644
> index 000000000000..783fb37ec466
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/tegra_resource.h
> @@ -0,0 +1,98 @@
> +/*
> + * Copyright © 2014 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.
> + */
> +
> +#ifndef TEGRA_RESOURCE_H
> +#define TEGRA_RESOURCE_H
> +
> +#include "pipe/p_state.h"
> +
> +struct winsys_handle;
> +
> +struct tegra_resource {
> + struct pipe_resource base;
> + struct pipe_resource *gpu;
> +
> + uint32_t stride;
> + uint32_t handle;
> + size_t size;
> +};
> +
> +static INLINE struct tegra_resource *
> +to_tegra_resource(struct pipe_resource *resource)
> +{
> + return (struct tegra_resource *)resource;
> +}
> +
> +static INLINE struct pipe_resource *
> +tegra_resource_unwrap(struct pipe_resource *resource)
> +{
> + if (!resource)
> + return NULL;
> +
> + return to_tegra_resource(resource)->gpu;
> +}
> +
> +struct pipe_resource *
> +tegra_resource_create(struct pipe_screen *pscreen,
> + const struct pipe_resource *template);
> +struct pipe_resource *
> +tegra_resource_from_handle(struct pipe_screen *pscreen,
> + const struct pipe_resource *template,
> + struct winsys_handle *handle);
> +boolean
> +tegra_resource_get_handle(struct pipe_screen *pscreen,
> + struct pipe_resource *resource,
> + struct winsys_handle *handle);
> +void
> +tegra_resource_destroy(struct pipe_screen *pscreen,
> + struct pipe_resource *resource);
> +
> +struct tegra_surface {
> + struct pipe_surface base;
> + struct pipe_surface *gpu;
> +};
> +
> +static INLINE struct tegra_surface *
> +to_tegra_surface(struct pipe_surface *surface)
> +{
> + return (struct tegra_surface *)surface;
> +}
> +
> +static INLINE struct pipe_surface *
> +tegra_surface_unwrap(struct pipe_surface *surface)
> +{
> + if (!surface)
> + return NULL;
> +
> + return to_tegra_surface(surface)->gpu;
> +}
> +
> +struct pipe_surface *
> +tegra_create_surface(struct pipe_context *pcontext,
> + struct pipe_resource *presource,
> + const struct pipe_surface *template);
> +void
> +tegra_surface_destroy(struct pipe_context *pcontext,
> + struct pipe_surface *psurface);
> +
> +#endif /* TEGRA_RESOURCE_H */
> diff --git a/src/gallium/drivers/tegra/tegra_screen.c b/src/gallium/drivers/tegra/tegra_screen.c
> new file mode 100644
> index 000000000000..aa7bf65cb7ec
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/tegra_screen.c
> @@ -0,0 +1,311 @@
> +/*
> + * Copyright © 2014 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.
> + */
> +
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <stdio.h>
> +
> +#ifdef HAVE_LIBUDEV
> +#include <libudev.h>
> +#endif
> +
> +#include "util/u_debug.h"
> +
> +#include "tegra/tegra_context.h"
> +#include "tegra/tegra_resource.h"
> +#include "tegra/tegra_screen.h"
> +
> +/* TODO: obtain from include file */
> +struct pipe_screen *nouveau_drm_screen_create(int fd);
> +
> +static const char *
> +tegra_get_name(struct pipe_screen *pscreen)
> +{
> + return "tegra";
> +}
> +
> +static const char *
> +tegra_get_vendor(struct pipe_screen *pscreen)
> +{
> + return "tegra";
> +}
> +
> +static void tegra_screen_destroy(struct pipe_screen *pscreen)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> +
> + screen->gpu->destroy(screen->gpu);
> + free(pscreen);
> +}
> +
> +static int
> +tegra_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> +
> + return screen->gpu->get_param(screen->gpu, param);
> +}
> +
> +static float
> +tegra_screen_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> +
> + return screen->gpu->get_paramf(screen->gpu, param);
> +}
> +
> +static int
> +tegra_screen_get_shader_param(struct pipe_screen *pscreen,
> + unsigned shader,
> + enum pipe_shader_cap param)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> +
> + return screen->gpu->get_shader_param(screen->gpu, shader, param);
> +}
> +
> +static boolean
> +tegra_screen_is_format_supported(struct pipe_screen *pscreen,
> + enum pipe_format format,
> + enum pipe_texture_target target,
> + unsigned sample_count,
> + unsigned usage)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> +
> + return screen->gpu->is_format_supported(screen->gpu, format, target,
> + sample_count, usage);
> +}
> +
> +static void
> +tegra_fence_reference(struct pipe_screen *pscreen,
> + struct pipe_fence_handle **ptr,
> + struct pipe_fence_handle *fence)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> +
> + screen->gpu->fence_reference(screen->gpu, ptr, fence);
> +}
> +
> +static boolean
> +tegra_fence_signalled(struct pipe_screen *pscreen,
> + struct pipe_fence_handle *fence)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> +
> + return screen->gpu->fence_signalled(screen->gpu, fence);
> +}
> +
> +static boolean
> +tegra_fence_finish(struct pipe_screen *pscreen,
> + struct pipe_fence_handle *fence,
> + uint64_t timeout)
> +{
> + struct tegra_screen *screen = to_tegra_screen(pscreen);
> +
> + return screen->gpu->fence_finish(screen->gpu, fence, timeout);
> +}
> +
> +static struct udev_device *udev_device_new_from_fd(struct udev *udev, int fd)
> +{
> + struct udev_device *device;
> + struct stat stat;
> + int err;
> +
> + err = fstat(fd, &stat);
> + if (err < 0) {
> + fprintf(stderr, "fstat() failed: %s\n", strerror(errno));
> + return NULL;
> + }
> +
> + device = udev_device_new_from_devnum(udev, 'c', stat.st_rdev);
> + if (!device) {
> + fprintf(stderr, "udev_device_new_from_devnum() failed\n");
> + return NULL;
> + }
> +
> + return device;
> +}
> +
> +static struct udev_device *udev_device_get_root(struct udev_device *device)
> +{
> + struct udev_device *parent;
> +
> + while (true) {
> + parent = udev_device_get_parent(device);
> + if (!parent)
> + break;
> +
> + device = parent;
> + }
> +
> + return device;
> +}
> +
> +static bool udev_device_match(struct udev_device *x, struct udev_device *y)
> +{
> + const char *p1 = udev_device_get_syspath(x);
> + const char *p2 = udev_device_get_syspath(y);
> +
> + return strcmp(p1, p2) == 0;
> +}
> +
> +static int tegra_open_render_node(int fd)
> +{
> + struct udev_device *display, *parent, *root;
> + struct udev_list_entry *list, *entry;
> + struct udev_enumerate *enumerate;
> + struct udev *udev;
> +
> + udev = udev_new();
> + if (!udev)
> + return -ENOMEM;
> +
> + display = udev_device_new_from_fd(udev, fd);
> + if (!display) {
> + udev_unref(udev);
> + return -ENODEV;
> + }
> +
> + parent = udev_device_get_parent(display);
> + if (!parent) {
> + udev_device_unref(display);
> + udev_unref(udev);
> + return -ENODEV;
> + }
> +
> + display = parent;
> +
> + root = udev_device_get_root(display);
> + if (!root) {
> + udev_device_unref(display);
> + udev_unref(udev);
> + return -ENODEV;
> + }
> +
> + enumerate = udev_enumerate_new(udev);
> + if (!enumerate) {
> + udev_device_unref(display);
> + udev_unref(udev);
> + return -ENOMEM;
> + }
> +
> + udev_enumerate_add_match_subsystem(enumerate, "drm");
> + udev_enumerate_add_match_sysname(enumerate, "render*");
> + udev_enumerate_scan_devices(enumerate);
> +
> + list = udev_enumerate_get_list_entry(enumerate);
> +
> + udev_list_entry_foreach(entry, list) {
> + const char *path = udev_list_entry_get_name(entry);
> + struct udev_device *device, *bus;
> +
> + device = udev_device_new_from_syspath(udev, path);
> + if (!device)
> + continue;
> +
> + path = udev_device_get_devnode(device);
> +
> + parent = udev_device_get_parent(device);
> + if (!parent) {
> + udev_device_unref(device);
> + continue;
> + }
> +
> + /* do not match if the render nodes shares the same parent */
> + if (udev_device_match(parent, display)) {
> + udev_device_unref(parent);
> + udev_device_unref(device);
> + continue;
> + }
> +
> + bus = udev_device_get_root(device);
> + if (!bus) {
> + udev_device_unref(parent);
> + udev_device_unref(device);
> + continue;
> + }
> +
> + /* both devices need to be on the same bus, though */
> + if (udev_device_match(bus, root)) {
> + fd = open(path, O_RDWR);
> + if (fd < 0)
> + fd = -errno;
> +
> + break;
> + }
> + }
> +
> + udev_enumerate_unref(enumerate);
> + udev_unref(udev);
> +
> + return open("/dev/dri/renderD128", O_RDWR);
> +}
> +
> +struct pipe_screen *
> +tegra_screen_create(int fd)
> +{
> + struct tegra_screen *screen;
> +
> + screen = calloc(1, sizeof(*screen));
> + if (!screen)
> + return NULL;
> +
> + screen->fd = fd;
> +
> + screen->gpu_fd = tegra_open_render_node(screen->fd);
> + if (screen->gpu_fd < 0) {
> + fprintf(stderr, "failed to open GPU device: %s\n",
> + strerror(errno));
> + free(screen);
> + return NULL;
> + }
> +
> + screen->gpu = nouveau_drm_screen_create(screen->gpu_fd);
> + if (!screen->gpu) {
> + fprintf(stderr, "failed to create GPU screen\n");
> + close(screen->gpu_fd);
> + free(screen);
> + return NULL;
> + }
> +
> + screen->base.get_name = tegra_get_name;
> + screen->base.get_vendor = tegra_get_vendor;
> + screen->base.destroy = tegra_screen_destroy;
> + screen->base.get_param = tegra_screen_get_param;
> + screen->base.get_paramf = tegra_screen_get_paramf;
> + screen->base.get_shader_param = tegra_screen_get_shader_param;
> + screen->base.context_create = tegra_context_create;
> + screen->base.is_format_supported = tegra_screen_is_format_supported;
> +
> + screen->base.resource_create = tegra_resource_create;
> + screen->base.resource_from_handle = tegra_resource_from_handle;
> + screen->base.resource_get_handle = tegra_resource_get_handle;
> + screen->base.resource_destroy = tegra_resource_destroy;
> +
> + screen->base.fence_reference = tegra_fence_reference;
> + screen->base.fence_signalled = tegra_fence_signalled;
> + screen->base.fence_finish = tegra_fence_finish;
> +
> + return &screen->base;
> +}
> diff --git a/src/gallium/drivers/tegra/tegra_screen.h b/src/gallium/drivers/tegra/tegra_screen.h
> new file mode 100644
> index 000000000000..1fba510c241f
> --- /dev/null
> +++ b/src/gallium/drivers/tegra/tegra_screen.h
> @@ -0,0 +1,45 @@
> +/*
> + * Copyright © 2014 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.
> + */
> +
> +#ifndef TEGRA_SCREEN_H
> +#define TEGRA_SCREEN_H
> +
> +#include "pipe/p_screen.h"
> +
> +struct tegra_screen {
> + struct pipe_screen base;
> + int fd;
> +
> + struct pipe_screen *gpu;
> + int gpu_fd;
> +};
> +
> +static inline struct tegra_screen *
> +to_tegra_screen(struct pipe_screen *pscreen)
> +{
> + return (struct tegra_screen *)pscreen;
> +}
> +
> +struct pipe_screen *tegra_screen_create(int fd);
> +
> +#endif /* TEGRA_SCREEN_H */
> diff --git a/src/gallium/targets/dri/Makefile.am b/src/gallium/targets/dri/Makefile.am
> index 3c7140d75b5c..0406eaf66537 100644
> --- a/src/gallium/targets/dri/Makefile.am
> +++ b/src/gallium/targets/dri/Makefile.am
> @@ -83,6 +83,8 @@ include $(top_srcdir)/src/gallium/drivers/svga/Automake.inc
>
> include $(top_srcdir)/src/gallium/drivers/freedreno/Automake.inc
>
> +include $(top_srcdir)/src/gallium/drivers/tegra/Automake.inc
> +
> include $(top_srcdir)/src/gallium/drivers/vc4/Automake.inc
>
> include $(top_srcdir)/src/gallium/drivers/softpipe/Automake.inc
> diff --git a/src/gallium/winsys/tegra/drm/Makefile.am b/src/gallium/winsys/tegra/drm/Makefile.am
> new file mode 100644
> index 000000000000..8e3685ee20e8
> --- /dev/null
> +++ b/src/gallium/winsys/tegra/drm/Makefile.am
> @@ -0,0 +1,11 @@
> +include Makefile.sources
> +include $(top_srcdir)/src/gallium/Automake.inc
> +
> +AM_CFLAGS = \
> + -I$(top_srcdir)/src/gallium/drivers \
> + $(GALLIUM_WINSYS_CFLAGS) \
> + $(FREEDRENO_CFLAGS)
> +
> +noinst_LTLIBRARIES = libtegradrm.la
> +
> +libtegradrm_la_SOURCES = $(C_SOURCES)
> diff --git a/src/gallium/winsys/tegra/drm/Makefile.sources b/src/gallium/winsys/tegra/drm/Makefile.sources
> new file mode 100644
> index 000000000000..fe0d5c42e72d
> --- /dev/null
> +++ b/src/gallium/winsys/tegra/drm/Makefile.sources
> @@ -0,0 +1,2 @@
> +C_SOURCES := \
> + tegra_drm_winsys.c
> diff --git a/src/gallium/winsys/tegra/drm/tegra_drm_public.h b/src/gallium/winsys/tegra/drm/tegra_drm_public.h
> new file mode 100644
> index 000000000000..45e3e006f9be
> --- /dev/null
> +++ b/src/gallium/winsys/tegra/drm/tegra_drm_public.h
> @@ -0,0 +1,31 @@
> +/*
> + * Copyright © 2014 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.
> + */
> +
> +#ifndef __TEGRA_DRM_PUBLIC_H__
> +#define __TEGRA_DRM_PUBLIC_H__
> +
> +struct pipe_screen;
> +
> +struct pipe_screen *tegra_drm_screen_create(int fd);
> +
> +#endif /* __TEGRA_DRM_PUBLIC_H__ */
> diff --git a/src/gallium/winsys/tegra/drm/tegra_drm_winsys.c b/src/gallium/winsys/tegra/drm/tegra_drm_winsys.c
> new file mode 100644
> index 000000000000..99b0e1649026
> --- /dev/null
> +++ b/src/gallium/winsys/tegra/drm/tegra_drm_winsys.c
> @@ -0,0 +1,33 @@
> +/*
> + * Copyright © 2014 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.
> + */
> +
> +#include "util/u_debug.h"
> +
> +#include "tegra/tegra_screen.h"
> +
> +struct pipe_screen *tegra_drm_screen_create(int fd);
> +
> +struct pipe_screen *tegra_drm_screen_create(int fd)
> +{
> + return tegra_screen_create(fd);
> +}
> --
> 2.1.3
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/mesa-dev
More information about the mesa-dev
mailing list