nvc0: import nvc0 gallium driver

1 files changed, 327 insertions, 0 deletions

diff --git a/src/gallium/drivers/nvc0/nvc0_miptree.c b/src/gallium/drivers/nvc0/nvc0_miptree.c
new file mode 100644
index 00000000000..aac09d776c7
--- /dev/null
+++ b/src/gallium/drivers/nvc0/nvc0_miptree.c
@@ -0,0 +1,327 @@
+/*
+ * Copyright 2008 Ben Skeggs
+ *
+ * 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 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 "pipe/p_state.h"
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+
+#include "nvc0_context.h"
+#include "nvc0_resource.h"
+#include "nvc0_transfer.h"
+
+static INLINE uint32_t
+get_tile_dims(unsigned nx, unsigned ny, unsigned nz)
+{
+   uint32_t tile_mode = 0x000;
+
+   if (ny > 64) tile_mode = 0x040; /* height 128 tiles */
+   else
+   if (ny > 32) tile_mode = 0x030; /* height 64 tiles */
+   else
+   if (ny > 16) tile_mode = 0x020; /* height 32 tiles */
+   else
+   if (ny >  8) tile_mode = 0x010; /* height 16 tiles */
+
+   if (nz == 1)
+      return tile_mode;
+   else
+   if (tile_mode > 0x020)
+      tile_mode = 0x020;
+
+   if (nz > 16 && tile_mode < 0x020)
+      return tile_mode | 0x500; /* depth 32 tiles */
+   if (nz > 8) return tile_mode | 0x400; /* depth 16 tiles */
+   if (nz > 4) return tile_mode | 0x300; /* depth 8 tiles */
+   if (nz > 2) return tile_mode | 0x200; /* depth 4 tiles */
+
+   return tile_mode | 0x100;
+}
+
+static INLINE unsigned
+get_zslice_offset(uint32_t tile_mode, unsigned z, unsigned pitch, unsigned nbh)
+{
+   unsigned tile_h = NVC0_TILE_H(tile_mode);
+   unsigned tile_d = NVC0_TILE_D(tile_mode);
+
+   /* pitch_2d == to next slice within this volume tile */
+   /* pitch_3d == size (in bytes) of a volume tile */
+   unsigned pitch_2d = tile_h * 64;
+   unsigned pitch_3d = tile_d * align(nbh, tile_h) * pitch;
+
+   return (z % tile_d) * pitch_2d + (z / tile_d) * pitch_3d;
+}
+
+static void
+nvc0_miptree_destroy(struct pipe_screen *pscreen, struct pipe_resource *pt)
+{
+   struct nvc0_miptree *mt = nvc0_miptree(pt);
+   unsigned l;
+
+   for (l = 0; l <= pt->last_level; ++l)
+      FREE(mt->level[l].image_offset);
+
+   nouveau_screen_bo_release(pscreen, mt->base.bo);
+
+   FREE(mt);
+}
+
+static boolean
+nvc0_miptree_get_handle(struct pipe_screen *pscreen,
+                        struct pipe_resource *pt,
+                        struct winsys_handle *whandle)
+{
+   struct nvc0_miptree *mt = nvc0_miptree(pt);
+   unsigned stride;
+
+   if (!mt || !mt->base.bo)
+      return FALSE;
+
+   stride = util_format_get_stride(mt->base.base.format,
+                                   mt->base.base.width0);
+
+   return nouveau_screen_bo_get_handle(pscreen,
+                                       mt->base.bo,
+                                       stride,
+                                       whandle);
+}
+
+const struct u_resource_vtbl nvc0_miptree_vtbl =
+{
+   nvc0_miptree_get_handle,         /* get_handle */
+   nvc0_miptree_destroy,            /* resource_destroy */
+   NULL,                            /* is_resource_referenced */
+   nvc0_miptree_transfer_new,       /* get_transfer */
+   nvc0_miptree_transfer_del,       /* transfer_destroy */
+   nvc0_miptree_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region, /* transfer_flush_region */
+   nvc0_miptree_transfer_unmap,     /* transfer_unmap */
+   u_default_transfer_inline_write  /* transfer_inline_write */
+};
+
+struct pipe_resource *
+nvc0_miptree_create(struct pipe_screen *pscreen,
+                    const struct pipe_resource *templ)
+{
+   struct nouveau_device *dev = nouveau_screen(pscreen)->device;
+   struct nvc0_miptree *mt = CALLOC_STRUCT(nvc0_miptree);
+   struct pipe_resource *pt = &mt->base.base;
+   int ret, i;
+   unsigned w, h, d, l, image_alignment, alloc_size;
+   uint32_t tile_flags;
+
+   if (!mt)
+      return NULL;
+
+   mt->base.vtbl = &nvc0_miptree_vtbl;
+   *pt = *templ;
+   pipe_reference_init(&pt->reference, 1);
+   pt->screen = pscreen;
+
+   w = pt->width0;
+   h = pt->height0;
+   d = pt->depth0;
+
+   switch (pt->format) {
+   case PIPE_FORMAT_Z16_UNORM:
+      tile_flags = 0x070; /* COMPRESSED */
+      tile_flags = 0x020; /* NORMAL ? */
+      tile_flags = 0x010; /* NORMAL ? */
+      break;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+      tile_flags = 0x530; /* MSAA 4, COMPRESSED */
+      tile_flags = 0x460; /* NORMAL */
+      break;
+   case PIPE_FORMAT_Z24X8_UNORM:
+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+      tile_flags = 0x110; /* NORMAL */
+      if (w * h >= 128 * 128 && 0)
+         tile_flags = 0x170; /* COMPRESSED, requires magic */
+      break;
+   case PIPE_FORMAT_R32G32B32A32_FLOAT:
+      tile_flags = 0xf50; /* COMPRESSED */
+      tile_flags = 0xf70; /* MSAA 2 */
+      tile_flags = 0xf90; /* MSAA 4 */
+      tile_flags = 0xfe0; /* NORMAL */
+      break;
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      tile_flags = 0xce0; /* COMPRESSED */
+      tile_flags = 0xcf0; /* MSAA 2, COMPRESSED */
+      tile_flags = 0xd00; /* MSAA 4, COMPRESSED */
+      tile_flags = 0xc30; /* NORMAL */
+      break;
+   case PIPE_FORMAT_R16G16B16A16_UNORM:
+      tile_flags = 0xe90; /* COMPRESSED */
+      break;
+   default:
+      tile_flags = 0xe00; /* MSAA 4, COMPRESSED 32 BIT */
+      tile_flags = 0xfe0; /* NORMAL 32 BIT */
+      if (w * h >= 128 * 128 && 0)
+         tile_flags = 0xdb0; /* COMPRESSED 32 BIT, requires magic */
+      break;
+   }
+
+   /* XXX: texture arrays */
+   mt->image_nr = (pt->target == PIPE_TEXTURE_CUBE) ? 6 : 1;
+
+   for (l = 0; l <= pt->last_level; l++) {
+      struct nvc0_miptree_level *lvl = &mt->level[l];
+      unsigned nby = util_format_get_nblocksy(pt->format, h);
+
+      lvl->image_offset = CALLOC(mt->image_nr, sizeof(int));
+      lvl->pitch = align(util_format_get_stride(pt->format, w), 64);
+      lvl->tile_mode = get_tile_dims(w, nby, d);
+
+      w = u_minify(w, 1);
+      h = u_minify(h, 1);
+      d = u_minify(d, 1);
+   }
+
+   image_alignment  = NVC0_TILE_H(mt->level[0].tile_mode) * 64;
+   image_alignment *= NVC0_TILE_D(mt->level[0].tile_mode);
+
+   /* NOTE the distinction between arrays of mip-mapped 2D textures and
+    * mip-mapped 3D textures. We can't use image_nr == depth for 3D mip.
+    */
+   for (i = 0; i < mt->image_nr; i++) {
+      for (l = 0; l <= pt->last_level; l++) {
+         struct nvc0_miptree_level *lvl = &mt->level[l];
+         int size;
+         unsigned tile_h = NVC0_TILE_H(lvl->tile_mode);
+         unsigned tile_d = NVC0_TILE_D(lvl->tile_mode);
+
+         h = u_minify(pt->height0, l);
+         d = u_minify(pt->depth0, l);
+
+         size  = lvl->pitch;
+         size *= align(util_format_get_nblocksy(pt->format, h), tile_h);
+         size *= align(d, tile_d);
+
+         lvl->image_offset[i] = mt->total_size;
+
+         mt->total_size += size;
+      }
+      mt->total_size = align(mt->total_size, image_alignment);
+   }
+
+   alloc_size = mt->total_size;
+   if (tile_flags == 0x170)
+      alloc_size *= 3; /* HiZ, XXX: correct size */
+
+   ret = nouveau_bo_new_tile(dev, NOUVEAU_BO_VRAM, 256, alloc_size,
+                             mt->level[0].tile_mode, tile_flags,
+                             &mt->base.bo);
+   if (ret) {
+      for (l = 0; l <= pt->last_level; ++l)
+         FREE(mt->level[l].image_offset);
+      FREE(mt);
+      return NULL;
+   }
+
+   return pt;
+}
+
+struct pipe_resource *
+nvc0_miptree_from_handle(struct pipe_screen *pscreen,
+                         const struct pipe_resource *templ,
+                         struct winsys_handle *whandle)
+{
+   struct nvc0_miptree *mt;
+   unsigned stride;
+
+	/* only supports 2D, non-mip mapped textures for the moment */
+   if ((templ->target != PIPE_TEXTURE_2D &&
+        templ->target != PIPE_TEXTURE_RECT) ||
+       templ->last_level != 0 ||
+       templ->depth0 != 1)
+      return NULL;
+
+   mt = CALLOC_STRUCT(nvc0_miptree);
+   if (!mt)
+      return NULL;
+
+   mt->base.bo = nouveau_screen_bo_from_handle(pscreen, whandle, &stride);
+   if (mt->base.bo == NULL) {
+      FREE(mt);
+      return NULL;
+   }
+
+   mt->base.base = *templ;
+   mt->base.vtbl = &nvc0_miptree_vtbl;
+   pipe_reference_init(&mt->base.base.reference, 1);
+   mt->base.base.screen = pscreen;
+   mt->image_nr = 1;
+   mt->level[0].pitch = stride;
+   mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
+   mt->level[0].tile_mode = mt->base.bo->tile_mode;
+
+   /* no need to adjust bo reference count */
+   return &mt->base.base;
+}
+
+
+/* Surface functions.
+ */
+
+struct pipe_surface *
+nvc0_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_resource *pt,
+                         unsigned face, unsigned level, unsigned zslice,
+                         unsigned flags)
+{
+   struct nvc0_miptree *mt = nvc0_miptree(pt);
+   struct nvc0_miptree_level *lvl = &mt->level[level];
+   struct pipe_surface *ps;
+   unsigned img = 0;
+
+   if (pt->target == PIPE_TEXTURE_CUBE)
+      img = face;
+
+   ps = CALLOC_STRUCT(pipe_surface);
+   if (!ps)
+      return NULL;
+   pipe_resource_reference(&ps->texture, pt);
+   ps->format = pt->format;
+   ps->width = u_minify(pt->width0, level);
+   ps->height = u_minify(pt->height0, level);
+   ps->usage = flags;
+   pipe_reference_init(&ps->reference, 1);
+   ps->face = face;
+   ps->level = level;
+   ps->zslice = zslice;
+   ps->offset = lvl->image_offset[img];
+
+   if (pt->target == PIPE_TEXTURE_3D)
+      ps->offset += get_zslice_offset(lvl->tile_mode, zslice, lvl->pitch,
+                                      util_format_get_nblocksy(pt->format,
+                                                               ps->height));
+   return ps;
+}
+
+void
+nvc0_miptree_surface_del(struct pipe_surface *ps)
+{
+   struct nvc0_surface *s = nvc0_surface(ps);
+
+   pipe_resource_reference(&ps->texture, NULL);
+
+   FREE(s);
+}