drivers/gpu/drm/nouveau/nouveau_display.c

   1 /*
   2  * Copyright (C) 2008 Maarten Maathuis.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial
  15  * portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  */
  26
  27 #include <acpi/video.h>
  28
  29 #include <drm/drm_atomic.h>
  30 #include <drm/drm_atomic_helper.h>
  31 #include <drm/drm_crtc_helper.h>
  32 #include <drm/drm_fb_helper.h>
  33 #include <drm/drm_fourcc.h>
  34 #include <drm/drm_probe_helper.h>
  35 #include <drm/drm_vblank.h>
  36
  37 #include "nouveau_fbcon.h"
  38 #include "nouveau_crtc.h"
  39 #include "nouveau_gem.h"
  40 #include "nouveau_connector.h"
  41 #include "nv50_display.h"
  42
  43 #include <nvif/class.h>
  44 #include <nvif/cl0046.h>
  45 #include <nvif/event.h>
  46
  47 static int
  48 nouveau_display_vblank_handler(struct nvif_notify *notify)
  49 {
  50         struct nouveau_crtc *nv_crtc =
  51                 container_of(notify, typeof(*nv_crtc), vblank);
  52         drm_crtc_handle_vblank(&nv_crtc->base);
  53         return NVIF_NOTIFY_KEEP;
  54 }
  55
  56 int
  57 nouveau_display_vblank_enable(struct drm_crtc *crtc)
  58 {
  59         struct nouveau_crtc *nv_crtc;
  60
  61         nv_crtc = nouveau_crtc(crtc);
  62         nvif_notify_get(&nv_crtc->vblank);
  63
  64         return 0;
  65 }
  66
  67 void
  68 nouveau_display_vblank_disable(struct drm_crtc *crtc)
  69 {
  70         struct nouveau_crtc *nv_crtc;
  71
  72         nv_crtc = nouveau_crtc(crtc);
  73         nvif_notify_put(&nv_crtc->vblank);
  74 }
  75
  76 static inline int
  77 calc(int blanks, int blanke, int total, int line)
  78 {
  79         if (blanke >= blanks) {
  80                 if (line >= blanks)
  81                         line -= total;
  82         } else {
  83                 if (line >= blanks)
  84                         line -= total;
  85                 line -= blanke + 1;
  86         }
  87         return line;
  88 }
  89
  90 static bool
  91 nouveau_display_scanoutpos_head(struct drm_crtc *crtc, int *vpos, int *hpos,
  92                                 ktime_t *stime, ktime_t *etime)
  93 {
  94         struct {
  95                 struct nv04_disp_mthd_v0 base;
  96                 struct nv04_disp_scanoutpos_v0 scan;
  97         } args = {
  98                 .base.method = NV04_DISP_SCANOUTPOS,
  99                 .base.head = nouveau_crtc(crtc)->index,
 100         };
 101         struct nouveau_display *disp = nouveau_display(crtc->dev);
 102         struct drm_vblank_crtc *vblank = &crtc->dev->vblank[drm_crtc_index(crtc)];
 103         int retry = 20;
 104         bool ret = false;
 105
 106         do {
 107                 ret = nvif_mthd(&disp->disp.object, 0, &args, sizeof(args));
 108                 if (ret != 0)
 109                         return false;
 110
 111                 if (args.scan.vline) {
 112                         ret = true;
 113                         break;
 114                 }
 115
 116                 if (retry) ndelay(vblank->linedur_ns);
 117         } while (retry--);
 118
 119         *hpos = args.scan.hline;
 120         *vpos = calc(args.scan.vblanks, args.scan.vblanke,
 121                      args.scan.vtotal, args.scan.vline);
 122         if (stime) *stime = ns_to_ktime(args.scan.time[0]);
 123         if (etime) *etime = ns_to_ktime(args.scan.time[1]);
 124
 125         return ret;
 126 }
 127
 128 bool
 129 nouveau_display_scanoutpos(struct drm_crtc *crtc,
 130                            bool in_vblank_irq, int *vpos, int *hpos,
 131                            ktime_t *stime, ktime_t *etime,
 132                            const struct drm_display_mode *mode)
 133 {
 134         return nouveau_display_scanoutpos_head(crtc, vpos, hpos,
 135                                                stime, etime);
 136 }
 137
 138 static void
 139 nouveau_display_vblank_fini(struct drm_device *dev)
 140 {
 141         struct drm_crtc *crtc;
 142
 143         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 144                 struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
 145                 nvif_notify_fini(&nv_crtc->vblank);
 146         }
 147 }
 148
 149 static int
 150 nouveau_display_vblank_init(struct drm_device *dev)
 151 {
 152         struct nouveau_display *disp = nouveau_display(dev);
 153         struct drm_crtc *crtc;
 154         int ret;
 155
 156         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 157                 struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
 158                 ret = nvif_notify_init(&disp->disp.object,
 159                                        nouveau_display_vblank_handler, false,
 160                                        NV04_DISP_NTFY_VBLANK,
 161                                        &(struct nvif_notify_head_req_v0) {
 162                                         .head = nv_crtc->index,
 163                                        },
 164                                        sizeof(struct nvif_notify_head_req_v0),
 165                                        sizeof(struct nvif_notify_head_rep_v0),
 166                                        &nv_crtc->vblank);
 167                 if (ret) {
 168                         nouveau_display_vblank_fini(dev);
 169                         return ret;
 170                 }
 171         }
 172
 173         ret = drm_vblank_init(dev, dev->mode_config.num_crtc);
 174         if (ret) {
 175                 nouveau_display_vblank_fini(dev);
 176                 return ret;
 177         }
 178
 179         return 0;
 180 }
 181
 182 static void
 183 nouveau_user_framebuffer_destroy(struct drm_framebuffer *drm_fb)
 184 {
 185         struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
 186
 187         if (fb->nvbo)
 188                 drm_gem_object_put(&fb->nvbo->bo.base);
 189
 190         drm_framebuffer_cleanup(drm_fb);
 191         kfree(fb);
 192 }
 193
 194 static int
 195 nouveau_user_framebuffer_create_handle(struct drm_framebuffer *drm_fb,
 196                                        struct drm_file *file_priv,
 197                                        unsigned int *handle)
 198 {
 199         struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
 200
 201         return drm_gem_handle_create(file_priv, &fb->nvbo->bo.base, handle);
 202 }
 203
 204 static const struct drm_framebuffer_funcs nouveau_framebuffer_funcs = {
 205         .destroy = nouveau_user_framebuffer_destroy,
 206         .create_handle = nouveau_user_framebuffer_create_handle,
 207 };
 208
 209 int
 210 nouveau_framebuffer_new(struct drm_device *dev,
 211                         const struct drm_mode_fb_cmd2 *mode_cmd,
 212                         struct nouveau_bo *nvbo,
 213                         struct nouveau_framebuffer **pfb)
 214 {
 215         struct nouveau_drm *drm = nouveau_drm(dev);
 216         struct nouveau_framebuffer *fb;
 217         int ret;
 218
 219         /* YUV overlays have special requirements pre-NV50 */
 220         if (drm->client.device.info.family < NV_DEVICE_INFO_V0_TESLA &&
 221
 222             (mode_cmd->pixel_format == DRM_FORMAT_YUYV ||
 223              mode_cmd->pixel_format == DRM_FORMAT_UYVY ||
 224              mode_cmd->pixel_format == DRM_FORMAT_NV12 ||
 225              mode_cmd->pixel_format == DRM_FORMAT_NV21) &&
 226             (mode_cmd->pitches[0] & 0x3f || /* align 64 */
 227              mode_cmd->pitches[0] >= 0x10000 || /* at most 64k pitch */
 228              (mode_cmd->pitches[1] && /* pitches for planes must match */
 229               mode_cmd->pitches[0] != mode_cmd->pitches[1]))) {
 230                 struct drm_format_name_buf format_name;
 231                 DRM_DEBUG_KMS("Unsuitable framebuffer: format: %s; pitches: 0x%x\n 0x%x\n",
 232                               drm_get_format_name(mode_cmd->pixel_format,
 233                                                   &format_name),
 234                               mode_cmd->pitches[0],
 235                               mode_cmd->pitches[1]);
 236                 return -EINVAL;
 237         }
 238
 239         if (!(fb = *pfb = kzalloc(sizeof(*fb), GFP_KERNEL)))
 240                 return -ENOMEM;
 241
 242         drm_helper_mode_fill_fb_struct(dev, &fb->base, mode_cmd);
 243         fb->nvbo = nvbo;
 244
 245         ret = drm_framebuffer_init(dev, &fb->base, &nouveau_framebuffer_funcs);
 246         if (ret)
 247                 kfree(fb);
 248         return ret;
 249 }
 250
 251 struct drm_framebuffer *
 252 nouveau_user_framebuffer_create(struct drm_device *dev,
 253                                 struct drm_file *file_priv,
 254                                 const struct drm_mode_fb_cmd2 *mode_cmd)
 255 {
 256         struct nouveau_framebuffer *fb;
 257         struct nouveau_bo *nvbo;
 258         struct drm_gem_object *gem;
 259         int ret;
 260
 261         gem = drm_gem_object_lookup(file_priv, mode_cmd->handles[0]);
 262         if (!gem)
 263                 return ERR_PTR(-ENOENT);
 264         nvbo = nouveau_gem_object(gem);
 265
 266         ret = nouveau_framebuffer_new(dev, mode_cmd, nvbo, &fb);
 267         if (ret == 0)
 268                 return &fb->base;
 269
 270         drm_gem_object_put(gem);
 271         return ERR_PTR(ret);
 272 }
 273
 274 static const struct drm_mode_config_funcs nouveau_mode_config_funcs = {
 275         .fb_create = nouveau_user_framebuffer_create,
 276         .output_poll_changed = nouveau_fbcon_output_poll_changed,
 277 };
 278
 279
 280 struct nouveau_drm_prop_enum_list {
 281         u8 gen_mask;
 282         int type;
 283         char *name;
 284 };
 285
 286 static struct nouveau_drm_prop_enum_list underscan[] = {
 287         { 6, UNDERSCAN_AUTO, "auto" },
 288         { 6, UNDERSCAN_OFF, "off" },
 289         { 6, UNDERSCAN_ON, "on" },
 290         {}
 291 };
 292
 293 static struct nouveau_drm_prop_enum_list dither_mode[] = {
 294         { 7, DITHERING_MODE_AUTO, "auto" },
 295         { 7, DITHERING_MODE_OFF, "off" },
 296         { 1, DITHERING_MODE_ON, "on" },
 297         { 6, DITHERING_MODE_STATIC2X2, "static 2x2" },
 298         { 6, DITHERING_MODE_DYNAMIC2X2, "dynamic 2x2" },
 299         { 4, DITHERING_MODE_TEMPORAL, "temporal" },
 300         {}
 301 };
 302
 303 static struct nouveau_drm_prop_enum_list dither_depth[] = {
 304         { 6, DITHERING_DEPTH_AUTO, "auto" },
 305         { 6, DITHERING_DEPTH_6BPC, "6 bpc" },
 306         { 6, DITHERING_DEPTH_8BPC, "8 bpc" },
 307         {}
 308 };
 309
 310 #define PROP_ENUM(p,gen,n,list) do {                                           \
 311         struct nouveau_drm_prop_enum_list *l = (list);                         \
 312         int c = 0;                                                             \
 313         while (l->gen_mask) {                                                  \
 314                 if (l->gen_mask & (1 << (gen)))                                \
 315                         c++;                                                   \
 316                 l++;                                                           \
 317         }                                                                      \
 318         if (c) {                                                               \
 319                 p = drm_property_create(dev, DRM_MODE_PROP_ENUM, n, c);        \
 320                 l = (list);                                                    \
 321                 while (p && l->gen_mask) {                                     \
 322                         if (l->gen_mask & (1 << (gen))) {                      \
 323                                 drm_property_add_enum(p, l->type, l->name);    \
 324                         }                                                      \
 325                         l++;                                                   \
 326                 }                                                              \
 327         }                                                                      \
 328 } while(0)
 329
 330 static void
 331 nouveau_display_hpd_work(struct work_struct *work)
 332 {
 333         struct nouveau_drm *drm = container_of(work, typeof(*drm), hpd_work);
 334
 335         pm_runtime_get_sync(drm->dev->dev);
 336
 337         drm_helper_hpd_irq_event(drm->dev);
 338
 339         pm_runtime_mark_last_busy(drm->dev->dev);
 340         pm_runtime_put_sync(drm->dev->dev);
 341 }
 342
 343 #ifdef CONFIG_ACPI
 344
 345 static int
 346 nouveau_display_acpi_ntfy(struct notifier_block *nb, unsigned long val,
 347                           void *data)
 348 {
 349         struct nouveau_drm *drm = container_of(nb, typeof(*drm), acpi_nb);
 350         struct acpi_bus_event *info = data;
 351         int ret;
 352
 353         if (!strcmp(info->device_class, ACPI_VIDEO_CLASS)) {
 354                 if (info->type == ACPI_VIDEO_NOTIFY_PROBE) {
 355                         ret = pm_runtime_get(drm->dev->dev);
 356                         if (ret == 1 || ret == -EACCES) {
 357                                 /* If the GPU is already awake, or in a state
 358                                  * where we can't wake it up, it can handle
 359                                  * it's own hotplug events.
 360                                  */
 361                                 pm_runtime_put_autosuspend(drm->dev->dev);
 362                         } else if (ret == 0) {
 363                                 /* This may be the only indication we receive
 364                                  * of a connector hotplug on a runtime
 365                                  * suspended GPU, schedule hpd_work to check.
 366                                  */
 367                                 NV_DEBUG(drm, "ACPI requested connector reprobe\n");
 368                                 schedule_work(&drm->hpd_work);
 369                                 pm_runtime_put_noidle(drm->dev->dev);
 370                         } else {
 371                                 NV_WARN(drm, "Dropped ACPI reprobe event due to RPM error: %d\n",
 372                                         ret);
 373                         }
 374
 375                         /* acpi-video should not generate keypresses for this */
 376                         return NOTIFY_BAD;
 377                 }
 378         }
 379
 380         return NOTIFY_DONE;
 381 }
 382 #endif
 383
 384 int
 385 nouveau_display_init(struct drm_device *dev, bool resume, bool runtime)
 386 {
 387         struct nouveau_display *disp = nouveau_display(dev);
 388         struct drm_connector *connector;
 389         struct drm_connector_list_iter conn_iter;
 390         int ret;
 391
 392         /*
 393          * Enable hotplug interrupts (done as early as possible, since we need
 394          * them for MST)
 395          */
 396         drm_connector_list_iter_begin(dev, &conn_iter);
 397         nouveau_for_each_non_mst_connector_iter(connector, &conn_iter) {
 398                 struct nouveau_connector *conn = nouveau_connector(connector);
 399                 nvif_notify_get(&conn->hpd);
 400         }
 401         drm_connector_list_iter_end(&conn_iter);
 402
 403         ret = disp->init(dev, resume, runtime);
 404         if (ret)
 405                 return ret;
 406
 407         /* enable connector detection and polling for connectors without HPD
 408          * support
 409          */
 410         drm_kms_helper_poll_enable(dev);
 411
 412         return ret;
 413 }
 414
 415 void
 416 nouveau_display_fini(struct drm_device *dev, bool suspend, bool runtime)
 417 {
 418         struct nouveau_display *disp = nouveau_display(dev);
 419         struct nouveau_drm *drm = nouveau_drm(dev);
 420         struct drm_connector *connector;
 421         struct drm_connector_list_iter conn_iter;
 422
 423         if (!suspend) {
 424                 if (drm_drv_uses_atomic_modeset(dev))
 425                         drm_atomic_helper_shutdown(dev);
 426                 else
 427                         drm_helper_force_disable_all(dev);
 428         }
 429
 430         /* disable hotplug interrupts */
 431         drm_connector_list_iter_begin(dev, &conn_iter);
 432         nouveau_for_each_non_mst_connector_iter(connector, &conn_iter) {
 433                 struct nouveau_connector *conn = nouveau_connector(connector);
 434                 nvif_notify_put(&conn->hpd);
 435         }
 436         drm_connector_list_iter_end(&conn_iter);
 437
 438         if (!runtime)
 439                 cancel_work_sync(&drm->hpd_work);
 440
 441         drm_kms_helper_poll_disable(dev);
 442         disp->fini(dev, suspend);
 443 }
 444
 445 static void
 446 nouveau_display_create_properties(struct drm_device *dev)
 447 {
 448         struct nouveau_display *disp = nouveau_display(dev);
 449         int gen;
 450
 451         if (disp->disp.object.oclass < NV50_DISP)
 452                 gen = 0;
 453         else
 454         if (disp->disp.object.oclass < GF110_DISP)
 455                 gen = 1;
 456         else
 457                 gen = 2;
 458
 459         PROP_ENUM(disp->dithering_mode, gen, "dithering mode", dither_mode);
 460         PROP_ENUM(disp->dithering_depth, gen, "dithering depth", dither_depth);
 461         PROP_ENUM(disp->underscan_property, gen, "underscan", underscan);
 462
 463         disp->underscan_hborder_property =
 464                 drm_property_create_range(dev, 0, "underscan hborder", 0, 128);
 465
 466         disp->underscan_vborder_property =
 467                 drm_property_create_range(dev, 0, "underscan vborder", 0, 128);
 468
 469         if (gen < 1)
 470                 return;
 471
 472         /* -90..+90 */
 473         disp->vibrant_hue_property =
 474                 drm_property_create_range(dev, 0, "vibrant hue", 0, 180);
 475
 476         /* -100..+100 */
 477         disp->color_vibrance_property =
 478                 drm_property_create_range(dev, 0, "color vibrance", 0, 200);
 479 }
 480
 481 int
 482 nouveau_display_create(struct drm_device *dev)
 483 {
 484         struct nouveau_drm *drm = nouveau_drm(dev);
 485         struct nvkm_device *device = nvxx_device(&drm->client.device);
 486         struct nouveau_display *disp;
 487         int ret;
 488
 489         disp = drm->display = kzalloc(sizeof(*disp), GFP_KERNEL);
 490         if (!disp)
 491                 return -ENOMEM;
 492
 493         drm_mode_config_init(dev);
 494         drm_mode_create_scaling_mode_property(dev);
 495         drm_mode_create_dvi_i_properties(dev);
 496
 497         dev->mode_config.funcs = &nouveau_mode_config_funcs;
 498         dev->mode_config.fb_base = device->func->resource_addr(device, 1);
 499
 500         dev->mode_config.min_width = 0;
 501         dev->mode_config.min_height = 0;
 502         if (drm->client.device.info.family < NV_DEVICE_INFO_V0_CELSIUS) {
 503                 dev->mode_config.max_width = 2048;
 504                 dev->mode_config.max_height = 2048;
 505         } else
 506         if (drm->client.device.info.family < NV_DEVICE_INFO_V0_TESLA) {
 507                 dev->mode_config.max_width = 4096;
 508                 dev->mode_config.max_height = 4096;
 509         } else
 510         if (drm->client.device.info.family < NV_DEVICE_INFO_V0_FERMI) {
 511                 dev->mode_config.max_width = 8192;
 512                 dev->mode_config.max_height = 8192;
 513         } else {
 514                 dev->mode_config.max_width = 16384;
 515                 dev->mode_config.max_height = 16384;
 516         }
 517
 518         dev->mode_config.preferred_depth = 24;
 519         dev->mode_config.prefer_shadow = 1;
 520
 521         if (drm->client.device.info.chipset < 0x11)
 522                 dev->mode_config.async_page_flip = false;
 523         else
 524                 dev->mode_config.async_page_flip = true;
 525
 526         drm_kms_helper_poll_init(dev);
 527         drm_kms_helper_poll_disable(dev);
 528
 529         if (nouveau_modeset != 2 && drm->vbios.dcb.entries) {
 530                 ret = nvif_disp_ctor(&drm->client.device, 0, &disp->disp);
 531                 if (ret == 0) {
 532                         nouveau_display_create_properties(dev);
 533                         if (disp->disp.object.oclass < NV50_DISP)
 534                                 ret = nv04_display_create(dev);
 535                         else
 536                                 ret = nv50_display_create(dev);
 537                 }
 538         } else {
 539                 ret = 0;
 540         }
 541
 542         if (ret)
 543                 goto disp_create_err;
 544
 545         drm_mode_config_reset(dev);
 546
 547         if (dev->mode_config.num_crtc) {
 548                 ret = nouveau_display_vblank_init(dev);
 549                 if (ret)
 550                         goto vblank_err;
 551         }
 552
 553         INIT_WORK(&drm->hpd_work, nouveau_display_hpd_work);
 554 #ifdef CONFIG_ACPI
 555         drm->acpi_nb.notifier_call = nouveau_display_acpi_ntfy;
 556         register_acpi_notifier(&drm->acpi_nb);
 557 #endif
 558
 559         return 0;
 560
 561 vblank_err:
 562         disp->dtor(dev);
 563 disp_create_err:
 564         drm_kms_helper_poll_fini(dev);
 565         drm_mode_config_cleanup(dev);
 566         return ret;
 567 }
 568
 569 void
 570 nouveau_display_destroy(struct drm_device *dev)
 571 {
 572         struct nouveau_display *disp = nouveau_display(dev);
 573
 574 #ifdef CONFIG_ACPI
 575         unregister_acpi_notifier(&nouveau_drm(dev)->acpi_nb);
 576 #endif
 577         nouveau_display_vblank_fini(dev);
 578
 579         drm_kms_helper_poll_fini(dev);
 580         drm_mode_config_cleanup(dev);
 581
 582         if (disp->dtor)
 583                 disp->dtor(dev);
 584
 585         nvif_disp_dtor(&disp->disp);
 586
 587         nouveau_drm(dev)->display = NULL;
 588         kfree(disp);
 589 }
 590
 591 int
 592 nouveau_display_suspend(struct drm_device *dev, bool runtime)
 593 {
 594         struct nouveau_display *disp = nouveau_display(dev);
 595
 596         if (drm_drv_uses_atomic_modeset(dev)) {
 597                 if (!runtime) {
 598                         disp->suspend = drm_atomic_helper_suspend(dev);
 599                         if (IS_ERR(disp->suspend)) {
 600                                 int ret = PTR_ERR(disp->suspend);
 601                                 disp->suspend = NULL;
 602                                 return ret;
 603                         }
 604                 }
 605         }
 606
 607         nouveau_display_fini(dev, true, runtime);
 608         return 0;
 609 }
 610
 611 void
 612 nouveau_display_resume(struct drm_device *dev, bool runtime)
 613 {
 614         struct nouveau_display *disp = nouveau_display(dev);
 615
 616         nouveau_display_init(dev, true, runtime);
 617
 618         if (drm_drv_uses_atomic_modeset(dev)) {
 619                 if (disp->suspend) {
 620                         drm_atomic_helper_resume(dev, disp->suspend);
 621                         disp->suspend = NULL;
 622                 }
 623                 return;
 624         }
 625 }
 626
 627 int
 628 nouveau_display_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
 629                             struct drm_mode_create_dumb *args)
 630 {
 631         struct nouveau_cli *cli = nouveau_cli(file_priv);
 632         struct nouveau_bo *bo;
 633         uint32_t domain;
 634         int ret;
 635
 636         args->pitch = roundup(args->width * (args->bpp / 8), 256);
 637         args->size = args->pitch * args->height;
 638         args->size = roundup(args->size, PAGE_SIZE);
 639
 640         /* Use VRAM if there is any ; otherwise fallback to system memory */
 641         if (nouveau_drm(dev)->client.device.info.ram_size != 0)
 642                 domain = NOUVEAU_GEM_DOMAIN_VRAM;
 643         else
 644                 domain = NOUVEAU_GEM_DOMAIN_GART;
 645
 646         ret = nouveau_gem_new(cli, args->size, 0, domain, 0, 0, &bo);
 647         if (ret)
 648                 return ret;
 649
 650         ret = drm_gem_handle_create(file_priv, &bo->bo.base, &args->handle);
 651         drm_gem_object_put(&bo->bo.base);
 652         return ret;
 653 }
 654
 655 int
 656 nouveau_display_dumb_map_offset(struct drm_file *file_priv,
 657                                 struct drm_device *dev,
 658                                 uint32_t handle, uint64_t *poffset)
 659 {
 660         struct drm_gem_object *gem;
 661
 662         gem = drm_gem_object_lookup(file_priv, handle);
 663         if (gem) {
 664                 struct nouveau_bo *bo = nouveau_gem_object(gem);
 665                 *poffset = drm_vma_node_offset_addr(&bo->bo.base.vma_node);
 666                 drm_gem_object_put(gem);
 667                 return 0;
 668         }
 669
 670         return -ENOENT;
 671 }