src/gallium/drivers/nouveau/nouveau_screen.c

   1 #include "pipe/p_defines.h"
   2 #include "pipe/p_screen.h"
   3 #include "pipe/p_state.h"
   4
   5 #include "util/u_memory.h"
   6 #include "util/u_inlines.h"
   7 #include "util/u_format.h"
   8 #include "util/u_format_s3tc.h"
   9 #include "util/u_string.h"
  10
  11 #include <stdio.h>
  12 #include <errno.h>
  13 #include <stdlib.h>
  14
  15 #include "nouveau_winsys.h"
  16 #include "nouveau_screen.h"
  17 #include "nouveau_fence.h"
  18 #include "nouveau_mm.h"
  19 #include "nouveau_buffer.h"
  20
  21 /* XXX this should go away */
  22 #include "state_tracker/drm_driver.h"
  23
  24 int nouveau_mesa_debug = 0;
  25
  26 static const char *
  27 nouveau_screen_get_name(struct pipe_screen *pscreen)
  28 {
  29         struct nouveau_device *dev = nouveau_screen(pscreen)->device;
  30         static char buffer[128];
  31
  32         util_snprintf(buffer, sizeof(buffer), "NV%02X", dev->chipset);
  33         return buffer;
  34 }
  35
  36 static const char *
  37 nouveau_screen_get_vendor(struct pipe_screen *pscreen)
  38 {
  39         return "nouveau";
  40 }
  41
  42 static void
  43 nouveau_screen_fence_ref(struct pipe_screen *pscreen,
  44                          struct pipe_fence_handle **ptr,
  45                          struct pipe_fence_handle *pfence)
  46 {
  47         nouveau_fence_ref(nouveau_fence(pfence), (struct nouveau_fence **)ptr);
  48 }
  49
  50 static boolean
  51 nouveau_screen_fence_signalled(struct pipe_screen *screen,
  52                                struct pipe_fence_handle *pfence)
  53 {
  54         return nouveau_fence_signalled(nouveau_fence(pfence));
  55 }
  56
  57 static boolean
  58 nouveau_screen_fence_finish(struct pipe_screen *screen,
  59                             struct pipe_fence_handle *pfence,
  60                             uint64_t timeout)
  61 {
  62         return nouveau_fence_wait(nouveau_fence(pfence));
  63 }
  64
  65
  66 struct nouveau_bo *
  67 nouveau_screen_bo_from_handle(struct pipe_screen *pscreen,
  68                               struct winsys_handle *whandle,
  69                               unsigned *out_stride)
  70 {
  71         struct nouveau_device *dev = nouveau_screen(pscreen)->device;
  72         struct nouveau_bo *bo = 0;
  73         int ret;
  74
  75         ret = nouveau_bo_name_ref(dev, whandle->handle, &bo);
  76         if (ret) {
  77                 debug_printf("%s: ref name 0x%08x failed with %d\n",
  78                              __FUNCTION__, whandle->handle, ret);
  79                 return NULL;
  80         }
  81
  82         *out_stride = whandle->stride;
  83         return bo;
  84 }
  85
  86
  87 boolean
  88 nouveau_screen_bo_get_handle(struct pipe_screen *pscreen,
  89                              struct nouveau_bo *bo,
  90                              unsigned stride,
  91                              struct winsys_handle *whandle)
  92 {
  93         whandle->stride = stride;
  94
  95         if (whandle->type == DRM_API_HANDLE_TYPE_SHARED) {
  96                 return nouveau_bo_name_get(bo, &whandle->handle) == 0;
  97         } else if (whandle->type == DRM_API_HANDLE_TYPE_KMS) {
  98                 whandle->handle = bo->handle;
  99                 return TRUE;
 100         } else {
 101                 return FALSE;
 102         }
 103 }
 104
 105 int
 106 nouveau_screen_init(struct nouveau_screen *screen, struct nouveau_device *dev)
 107 {
 108         struct pipe_screen *pscreen = &screen->base;
 109         struct nv04_fifo nv04_data = { .vram = 0xbeef0201, .gart = 0xbeef0202 };
 110         struct nvc0_fifo nvc0_data = { };
 111         int size, ret;
 112         void *data;
 113         union nouveau_bo_config mm_config;
 114
 115         char *nv_dbg = getenv("NOUVEAU_MESA_DEBUG");
 116         if (nv_dbg)
 117            nouveau_mesa_debug = atoi(nv_dbg);
 118
 119         if (dev->chipset < 0xc0) {
 120                 data = &nv04_data;
 121                 size = sizeof(nv04_data);
 122         } else {
 123                 data = &nvc0_data;
 124                 size = sizeof(nvc0_data);
 125         }
 126
 127         ret = nouveau_object_new(&dev->object, 0, NOUVEAU_FIFO_CHANNEL_CLASS,
 128                                  data, size, &screen->channel);
 129         if (ret)
 130                 return ret;
 131         screen->device = dev;
 132
 133         ret = nouveau_client_new(screen->device, &screen->client);
 134         if (ret)
 135                 return ret;
 136         ret = nouveau_pushbuf_new(screen->client, screen->channel,
 137                                   4, 512 * 1024, 1,
 138                                   &screen->pushbuf);
 139         if (ret)
 140                 return ret;
 141
 142         pscreen->get_name = nouveau_screen_get_name;
 143         pscreen->get_vendor = nouveau_screen_get_vendor;
 144
 145         pscreen->fence_reference = nouveau_screen_fence_ref;
 146         pscreen->fence_signalled = nouveau_screen_fence_signalled;
 147         pscreen->fence_finish = nouveau_screen_fence_finish;
 148
 149         util_format_s3tc_init();
 150
 151         memset(&mm_config, 0, sizeof(mm_config));
 152
 153         screen->mm_GART = nouveau_mm_create(dev,
 154                                             NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 155                                             &mm_config);
 156         screen->mm_VRAM = nouveau_mm_create(dev, NOUVEAU_BO_VRAM, &mm_config);
 157         return 0;
 158 }
 159
 160 void
 161 nouveau_screen_fini(struct nouveau_screen *screen)
 162 {
 163         nouveau_mm_destroy(screen->mm_GART);
 164         nouveau_mm_destroy(screen->mm_VRAM);
 165
 166         nouveau_pushbuf_del(&screen->pushbuf);
 167
 168         nouveau_client_del(&screen->client);
 169         nouveau_object_del(&screen->channel);
 170
 171         nouveau_device_del(&screen->device);
 172 }