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 <drm/drmP.h> 28 #include <drm/drm_crtc_helper.h> 29 #include <drm/ttm/ttm_execbuf_util.h> 30 31 #include "nouveau_fbcon.h" 32 #include "dispnv04/hw.h" 33 #include "nouveau_crtc.h" 34 #include "nouveau_dma.h" 35 #include "nouveau_gem.h" 36 #include "nouveau_connector.h" 37 #include "nv50_display.h" 38 39 #include "nouveau_fence.h" 40 41 #include <subdev/bios/gpio.h> 42 #include <subdev/gpio.h> 43 #include <engine/disp.h> 44 45 #include <core/class.h> 46 47 static void 48 nouveau_user_framebuffer_destroy(struct drm_framebuffer *drm_fb) 49 { 50 struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb); 51 52 if (fb->nvbo) 53 drm_gem_object_unreference_unlocked(fb->nvbo->gem); 54 55 drm_framebuffer_cleanup(drm_fb); 56 kfree(fb); 57 } 58 59 static int 60 nouveau_user_framebuffer_create_handle(struct drm_framebuffer *drm_fb, 61 struct drm_file *file_priv, 62 unsigned int *handle) 63 { 64 struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb); 65 66 return drm_gem_handle_create(file_priv, fb->nvbo->gem, handle); 67 } 68 69 static const struct drm_framebuffer_funcs nouveau_framebuffer_funcs = { 70 .destroy = nouveau_user_framebuffer_destroy, 71 .create_handle = nouveau_user_framebuffer_create_handle, 72 }; 73 74 int 75 nouveau_framebuffer_init(struct drm_device *dev, 76 struct nouveau_framebuffer *nv_fb, 77 struct drm_mode_fb_cmd2 *mode_cmd, 78 struct nouveau_bo *nvbo) 79 { 80 struct nouveau_drm *drm = nouveau_drm(dev); 81 struct drm_framebuffer *fb = &nv_fb->base; 82 int ret; 83 84 drm_helper_mode_fill_fb_struct(fb, mode_cmd); 85 nv_fb->nvbo = nvbo; 86 87 if (nv_device(drm->device)->card_type >= NV_50) { 88 u32 tile_flags = nouveau_bo_tile_layout(nvbo); 89 if (tile_flags == 0x7a00 || 90 tile_flags == 0xfe00) 91 nv_fb->r_dma = NvEvoFB32; 92 else 93 if (tile_flags == 0x7000) 94 nv_fb->r_dma = NvEvoFB16; 95 else 96 nv_fb->r_dma = NvEvoVRAM_LP; 97 98 switch (fb->depth) { 99 case 8: nv_fb->r_format = 0x1e00; break; 100 case 15: nv_fb->r_format = 0xe900; break; 101 case 16: nv_fb->r_format = 0xe800; break; 102 case 24: 103 case 32: nv_fb->r_format = 0xcf00; break; 104 case 30: nv_fb->r_format = 0xd100; break; 105 default: 106 NV_ERROR(drm, "unknown depth %d\n", fb->depth); 107 return -EINVAL; 108 } 109 110 if (nv_device(drm->device)->chipset == 0x50) 111 nv_fb->r_format |= (tile_flags << 8); 112 113 if (!tile_flags) { 114 if (nv_device(drm->device)->card_type < NV_D0) 115 nv_fb->r_pitch = 0x00100000 | fb->pitches[0]; 116 else 117 nv_fb->r_pitch = 0x01000000 | fb->pitches[0]; 118 } else { 119 u32 mode = nvbo->tile_mode; 120 if (nv_device(drm->device)->card_type >= NV_C0) 121 mode >>= 4; 122 nv_fb->r_pitch = ((fb->pitches[0] / 4) << 4) | mode; 123 } 124 } 125 126 ret = drm_framebuffer_init(dev, fb, &nouveau_framebuffer_funcs); 127 if (ret) { 128 return ret; 129 } 130 131 return 0; 132 } 133 134 static struct drm_framebuffer * 135 nouveau_user_framebuffer_create(struct drm_device *dev, 136 struct drm_file *file_priv, 137 struct drm_mode_fb_cmd2 *mode_cmd) 138 { 139 struct nouveau_framebuffer *nouveau_fb; 140 struct drm_gem_object *gem; 141 int ret; 142 143 gem = drm_gem_object_lookup(dev, file_priv, mode_cmd->handles[0]); 144 if (!gem) 145 return ERR_PTR(-ENOENT); 146 147 nouveau_fb = kzalloc(sizeof(struct nouveau_framebuffer), GFP_KERNEL); 148 if (!nouveau_fb) 149 return ERR_PTR(-ENOMEM); 150 151 ret = nouveau_framebuffer_init(dev, nouveau_fb, mode_cmd, nouveau_gem_object(gem)); 152 if (ret) { 153 drm_gem_object_unreference(gem); 154 return ERR_PTR(ret); 155 } 156 157 return &nouveau_fb->base; 158 } 159 160 static const struct drm_mode_config_funcs nouveau_mode_config_funcs = { 161 .fb_create = nouveau_user_framebuffer_create, 162 .output_poll_changed = nouveau_fbcon_output_poll_changed, 163 }; 164 165 166 struct nouveau_drm_prop_enum_list { 167 u8 gen_mask; 168 int type; 169 char *name; 170 }; 171 172 static struct nouveau_drm_prop_enum_list underscan[] = { 173 { 6, UNDERSCAN_AUTO, "auto" }, 174 { 6, UNDERSCAN_OFF, "off" }, 175 { 6, UNDERSCAN_ON, "on" }, 176 {} 177 }; 178 179 static struct nouveau_drm_prop_enum_list dither_mode[] = { 180 { 7, DITHERING_MODE_AUTO, "auto" }, 181 { 7, DITHERING_MODE_OFF, "off" }, 182 { 1, DITHERING_MODE_ON, "on" }, 183 { 6, DITHERING_MODE_STATIC2X2, "static 2x2" }, 184 { 6, DITHERING_MODE_DYNAMIC2X2, "dynamic 2x2" }, 185 { 4, DITHERING_MODE_TEMPORAL, "temporal" }, 186 {} 187 }; 188 189 static struct nouveau_drm_prop_enum_list dither_depth[] = { 190 { 6, DITHERING_DEPTH_AUTO, "auto" }, 191 { 6, DITHERING_DEPTH_6BPC, "6 bpc" }, 192 { 6, DITHERING_DEPTH_8BPC, "8 bpc" }, 193 {} 194 }; 195 196 #define PROP_ENUM(p,gen,n,list) do { \ 197 struct nouveau_drm_prop_enum_list *l = (list); \ 198 int c = 0; \ 199 while (l->gen_mask) { \ 200 if (l->gen_mask & (1 << (gen))) \ 201 c++; \ 202 l++; \ 203 } \ 204 if (c) { \ 205 p = drm_property_create(dev, DRM_MODE_PROP_ENUM, n, c); \ 206 l = (list); \ 207 c = 0; \ 208 while (p && l->gen_mask) { \ 209 if (l->gen_mask & (1 << (gen))) { \ 210 drm_property_add_enum(p, c, l->type, l->name); \ 211 c++; \ 212 } \ 213 l++; \ 214 } \ 215 } \ 216 } while(0) 217 218 int 219 nouveau_display_init(struct drm_device *dev) 220 { 221 struct nouveau_drm *drm = nouveau_drm(dev); 222 struct nouveau_display *disp = nouveau_display(dev); 223 struct nouveau_gpio *gpio = nouveau_gpio(drm->device); 224 struct drm_connector *connector; 225 int ret; 226 227 ret = disp->init(dev); 228 if (ret) 229 return ret; 230 231 /* enable polling for external displays */ 232 drm_kms_helper_poll_enable(dev); 233 234 /* enable hotplug interrupts */ 235 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 236 struct nouveau_connector *conn = nouveau_connector(connector); 237 if (gpio && conn->hpd.func != DCB_GPIO_UNUSED) { 238 nouveau_event_get(gpio->events, conn->hpd.line, 239 &conn->hpd_func); 240 } 241 } 242 243 return ret; 244 } 245 246 void 247 nouveau_display_fini(struct drm_device *dev) 248 { 249 struct nouveau_drm *drm = nouveau_drm(dev); 250 struct nouveau_display *disp = nouveau_display(dev); 251 struct nouveau_gpio *gpio = nouveau_gpio(drm->device); 252 struct drm_connector *connector; 253 254 /* disable hotplug interrupts */ 255 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 256 struct nouveau_connector *conn = nouveau_connector(connector); 257 if (gpio && conn->hpd.func != DCB_GPIO_UNUSED) { 258 nouveau_event_put(gpio->events, conn->hpd.line, 259 &conn->hpd_func); 260 } 261 } 262 263 drm_kms_helper_poll_disable(dev); 264 disp->fini(dev); 265 } 266 267 int 268 nouveau_display_create(struct drm_device *dev) 269 { 270 struct nouveau_drm *drm = nouveau_drm(dev); 271 struct nouveau_display *disp; 272 u32 pclass = dev->pdev->class >> 8; 273 int ret, gen; 274 275 disp = drm->display = kzalloc(sizeof(*disp), GFP_KERNEL); 276 if (!disp) 277 return -ENOMEM; 278 279 drm_mode_config_init(dev); 280 drm_mode_create_scaling_mode_property(dev); 281 drm_mode_create_dvi_i_properties(dev); 282 283 if (nv_device(drm->device)->card_type < NV_50) 284 gen = 0; 285 else 286 if (nv_device(drm->device)->card_type < NV_D0) 287 gen = 1; 288 else 289 gen = 2; 290 291 PROP_ENUM(disp->dithering_mode, gen, "dithering mode", dither_mode); 292 PROP_ENUM(disp->dithering_depth, gen, "dithering depth", dither_depth); 293 PROP_ENUM(disp->underscan_property, gen, "underscan", underscan); 294 295 disp->underscan_hborder_property = 296 drm_property_create_range(dev, 0, "underscan hborder", 0, 128); 297 298 disp->underscan_vborder_property = 299 drm_property_create_range(dev, 0, "underscan vborder", 0, 128); 300 301 if (gen >= 1) { 302 /* -90..+90 */ 303 disp->vibrant_hue_property = 304 drm_property_create_range(dev, 0, "vibrant hue", 0, 180); 305 306 /* -100..+100 */ 307 disp->color_vibrance_property = 308 drm_property_create_range(dev, 0, "color vibrance", 0, 200); 309 } 310 311 dev->mode_config.funcs = &nouveau_mode_config_funcs; 312 dev->mode_config.fb_base = pci_resource_start(dev->pdev, 1); 313 314 dev->mode_config.min_width = 0; 315 dev->mode_config.min_height = 0; 316 if (nv_device(drm->device)->card_type < NV_10) { 317 dev->mode_config.max_width = 2048; 318 dev->mode_config.max_height = 2048; 319 } else 320 if (nv_device(drm->device)->card_type < NV_50) { 321 dev->mode_config.max_width = 4096; 322 dev->mode_config.max_height = 4096; 323 } else { 324 dev->mode_config.max_width = 8192; 325 dev->mode_config.max_height = 8192; 326 } 327 328 dev->mode_config.preferred_depth = 24; 329 dev->mode_config.prefer_shadow = 1; 330 331 drm_kms_helper_poll_init(dev); 332 drm_kms_helper_poll_disable(dev); 333 334 if (nouveau_modeset == 1 || 335 (nouveau_modeset < 0 && pclass == PCI_CLASS_DISPLAY_VGA)) { 336 if (drm->vbios.dcb.entries) { 337 if (nv_device(drm->device)->card_type < NV_50) 338 ret = nv04_display_create(dev); 339 else 340 ret = nv50_display_create(dev); 341 } else { 342 ret = 0; 343 } 344 345 if (ret) 346 goto disp_create_err; 347 348 if (dev->mode_config.num_crtc) { 349 ret = drm_vblank_init(dev, dev->mode_config.num_crtc); 350 if (ret) 351 goto vblank_err; 352 } 353 354 nouveau_backlight_init(dev); 355 } 356 357 return 0; 358 359 vblank_err: 360 disp->dtor(dev); 361 disp_create_err: 362 drm_kms_helper_poll_fini(dev); 363 drm_mode_config_cleanup(dev); 364 return ret; 365 } 366 367 void 368 nouveau_display_destroy(struct drm_device *dev) 369 { 370 struct nouveau_display *disp = nouveau_display(dev); 371 372 nouveau_backlight_exit(dev); 373 drm_vblank_cleanup(dev); 374 375 drm_kms_helper_poll_fini(dev); 376 drm_mode_config_cleanup(dev); 377 378 if (disp->dtor) 379 disp->dtor(dev); 380 381 nouveau_drm(dev)->display = NULL; 382 kfree(disp); 383 } 384 385 int 386 nouveau_display_suspend(struct drm_device *dev) 387 { 388 struct nouveau_drm *drm = nouveau_drm(dev); 389 struct drm_crtc *crtc; 390 391 nouveau_display_fini(dev); 392 393 NV_INFO(drm, "unpinning framebuffer(s)...\n"); 394 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 395 struct nouveau_framebuffer *nouveau_fb; 396 397 nouveau_fb = nouveau_framebuffer(crtc->fb); 398 if (!nouveau_fb || !nouveau_fb->nvbo) 399 continue; 400 401 nouveau_bo_unpin(nouveau_fb->nvbo); 402 } 403 404 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 405 struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc); 406 407 nouveau_bo_unmap(nv_crtc->cursor.nvbo); 408 nouveau_bo_unpin(nv_crtc->cursor.nvbo); 409 } 410 411 return 0; 412 } 413 414 void 415 nouveau_display_resume(struct drm_device *dev) 416 { 417 struct nouveau_drm *drm = nouveau_drm(dev); 418 struct drm_crtc *crtc; 419 int ret; 420 421 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 422 struct nouveau_framebuffer *nouveau_fb; 423 424 nouveau_fb = nouveau_framebuffer(crtc->fb); 425 if (!nouveau_fb || !nouveau_fb->nvbo) 426 continue; 427 428 nouveau_bo_pin(nouveau_fb->nvbo, TTM_PL_FLAG_VRAM); 429 } 430 431 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 432 struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc); 433 434 ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM); 435 if (!ret) 436 ret = nouveau_bo_map(nv_crtc->cursor.nvbo); 437 if (ret) 438 NV_ERROR(drm, "Could not pin/map cursor.\n"); 439 } 440 441 nouveau_fbcon_set_suspend(dev, 0); 442 nouveau_fbcon_zfill_all(dev); 443 444 nouveau_display_init(dev); 445 446 /* Force CLUT to get re-loaded during modeset */ 447 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 448 struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc); 449 450 nv_crtc->lut.depth = 0; 451 } 452 453 drm_helper_resume_force_mode(dev); 454 455 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 456 struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc); 457 u32 offset = nv_crtc->cursor.nvbo->bo.offset; 458 459 nv_crtc->cursor.set_offset(nv_crtc, offset); 460 nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x, 461 nv_crtc->cursor_saved_y); 462 } 463 } 464 465 static int 466 nouveau_page_flip_emit(struct nouveau_channel *chan, 467 struct nouveau_bo *old_bo, 468 struct nouveau_bo *new_bo, 469 struct nouveau_page_flip_state *s, 470 struct nouveau_fence **pfence) 471 { 472 struct nouveau_fence_chan *fctx = chan->fence; 473 struct nouveau_drm *drm = chan->drm; 474 struct drm_device *dev = drm->dev; 475 unsigned long flags; 476 int ret; 477 478 /* Queue it to the pending list */ 479 spin_lock_irqsave(&dev->event_lock, flags); 480 list_add_tail(&s->head, &fctx->flip); 481 spin_unlock_irqrestore(&dev->event_lock, flags); 482 483 /* Synchronize with the old framebuffer */ 484 ret = nouveau_fence_sync(old_bo->bo.sync_obj, chan); 485 if (ret) 486 goto fail; 487 488 /* Emit the pageflip */ 489 ret = RING_SPACE(chan, 3); 490 if (ret) 491 goto fail; 492 493 if (nv_device(drm->device)->card_type < NV_C0) { 494 BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1); 495 OUT_RING (chan, 0x00000000); 496 OUT_RING (chan, 0x00000000); 497 } else { 498 BEGIN_NVC0(chan, 0, NV10_SUBCHAN_REF_CNT, 1); 499 OUT_RING (chan, 0); 500 BEGIN_IMC0(chan, 0, NVSW_SUBCHAN_PAGE_FLIP, 0x0000); 501 } 502 FIRE_RING (chan); 503 504 ret = nouveau_fence_new(chan, false, pfence); 505 if (ret) 506 goto fail; 507 508 return 0; 509 fail: 510 spin_lock_irqsave(&dev->event_lock, flags); 511 list_del(&s->head); 512 spin_unlock_irqrestore(&dev->event_lock, flags); 513 return ret; 514 } 515 516 int 517 nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb, 518 struct drm_pending_vblank_event *event) 519 { 520 struct drm_device *dev = crtc->dev; 521 struct nouveau_drm *drm = nouveau_drm(dev); 522 struct nouveau_bo *old_bo = nouveau_framebuffer(crtc->fb)->nvbo; 523 struct nouveau_bo *new_bo = nouveau_framebuffer(fb)->nvbo; 524 struct nouveau_page_flip_state *s; 525 struct nouveau_channel *chan = NULL; 526 struct nouveau_fence *fence; 527 struct list_head res; 528 struct ttm_validate_buffer res_val[2]; 529 struct ww_acquire_ctx ticket; 530 int ret; 531 532 if (!drm->channel) 533 return -ENODEV; 534 535 s = kzalloc(sizeof(*s), GFP_KERNEL); 536 if (!s) 537 return -ENOMEM; 538 539 /* Choose the channel the flip will be handled in */ 540 spin_lock(&old_bo->bo.bdev->fence_lock); 541 fence = new_bo->bo.sync_obj; 542 if (fence) 543 chan = fence->channel; 544 if (!chan) 545 chan = drm->channel; 546 spin_unlock(&old_bo->bo.bdev->fence_lock); 547 548 mutex_lock(&chan->cli->mutex); 549 550 if (new_bo != old_bo) { 551 ret = nouveau_bo_pin(new_bo, TTM_PL_FLAG_VRAM); 552 if (likely(!ret)) { 553 res_val[0].bo = &old_bo->bo; 554 res_val[1].bo = &new_bo->bo; 555 INIT_LIST_HEAD(&res); 556 list_add_tail(&res_val[0].head, &res); 557 list_add_tail(&res_val[1].head, &res); 558 ret = ttm_eu_reserve_buffers(&ticket, &res); 559 if (ret) 560 nouveau_bo_unpin(new_bo); 561 } 562 } else 563 ret = ttm_bo_reserve(&new_bo->bo, false, false, false, 0); 564 565 if (ret) { 566 mutex_unlock(&chan->cli->mutex); 567 goto fail_free; 568 } 569 570 /* Initialize a page flip struct */ 571 *s = (struct nouveau_page_flip_state) 572 { { }, event, nouveau_crtc(crtc)->index, 573 fb->bits_per_pixel, fb->pitches[0], crtc->x, crtc->y, 574 new_bo->bo.offset }; 575 576 /* Emit a page flip */ 577 if (nv_device(drm->device)->card_type >= NV_50) { 578 ret = nv50_display_flip_next(crtc, fb, chan, 0); 579 if (ret) { 580 mutex_unlock(&chan->cli->mutex); 581 goto fail_unreserve; 582 } 583 } 584 585 ret = nouveau_page_flip_emit(chan, old_bo, new_bo, s, &fence); 586 mutex_unlock(&chan->cli->mutex); 587 if (ret) 588 goto fail_unreserve; 589 590 /* Update the crtc struct and cleanup */ 591 crtc->fb = fb; 592 593 if (old_bo != new_bo) { 594 ttm_eu_fence_buffer_objects(&ticket, &res, fence); 595 nouveau_bo_unpin(old_bo); 596 } else { 597 nouveau_bo_fence(new_bo, fence); 598 ttm_bo_unreserve(&new_bo->bo); 599 } 600 nouveau_fence_unref(&fence); 601 return 0; 602 603 fail_unreserve: 604 if (old_bo != new_bo) { 605 ttm_eu_backoff_reservation(&ticket, &res); 606 nouveau_bo_unpin(new_bo); 607 } else 608 ttm_bo_unreserve(&new_bo->bo); 609 fail_free: 610 kfree(s); 611 return ret; 612 } 613 614 int 615 nouveau_finish_page_flip(struct nouveau_channel *chan, 616 struct nouveau_page_flip_state *ps) 617 { 618 struct nouveau_fence_chan *fctx = chan->fence; 619 struct nouveau_drm *drm = chan->drm; 620 struct drm_device *dev = drm->dev; 621 struct nouveau_page_flip_state *s; 622 unsigned long flags; 623 624 spin_lock_irqsave(&dev->event_lock, flags); 625 626 if (list_empty(&fctx->flip)) { 627 NV_ERROR(drm, "unexpected pageflip\n"); 628 spin_unlock_irqrestore(&dev->event_lock, flags); 629 return -EINVAL; 630 } 631 632 s = list_first_entry(&fctx->flip, struct nouveau_page_flip_state, head); 633 if (s->event) 634 drm_send_vblank_event(dev, -1, s->event); 635 636 list_del(&s->head); 637 if (ps) 638 *ps = *s; 639 kfree(s); 640 641 spin_unlock_irqrestore(&dev->event_lock, flags); 642 return 0; 643 } 644 645 int 646 nouveau_flip_complete(void *data) 647 { 648 struct nouveau_channel *chan = data; 649 struct nouveau_drm *drm = chan->drm; 650 struct nouveau_page_flip_state state; 651 652 if (!nouveau_finish_page_flip(chan, &state)) { 653 if (nv_device(drm->device)->card_type < NV_50) { 654 nv_set_crtc_base(drm->dev, state.crtc, state.offset + 655 state.y * state.pitch + 656 state.x * state.bpp / 8); 657 } 658 } 659 660 return 0; 661 } 662 663 int 664 nouveau_display_dumb_create(struct drm_file *file_priv, struct drm_device *dev, 665 struct drm_mode_create_dumb *args) 666 { 667 struct nouveau_bo *bo; 668 int ret; 669 670 args->pitch = roundup(args->width * (args->bpp / 8), 256); 671 args->size = args->pitch * args->height; 672 args->size = roundup(args->size, PAGE_SIZE); 673 674 ret = nouveau_gem_new(dev, args->size, 0, NOUVEAU_GEM_DOMAIN_VRAM, 0, 0, &bo); 675 if (ret) 676 return ret; 677 678 ret = drm_gem_handle_create(file_priv, bo->gem, &args->handle); 679 drm_gem_object_unreference_unlocked(bo->gem); 680 return ret; 681 } 682 683 int 684 nouveau_display_dumb_destroy(struct drm_file *file_priv, struct drm_device *dev, 685 uint32_t handle) 686 { 687 return drm_gem_handle_delete(file_priv, handle); 688 } 689 690 int 691 nouveau_display_dumb_map_offset(struct drm_file *file_priv, 692 struct drm_device *dev, 693 uint32_t handle, uint64_t *poffset) 694 { 695 struct drm_gem_object *gem; 696 697 gem = drm_gem_object_lookup(dev, file_priv, handle); 698 if (gem) { 699 struct nouveau_bo *bo = gem->driver_private; 700 *poffset = bo->bo.addr_space_offset; 701 drm_gem_object_unreference_unlocked(gem); 702 return 0; 703 } 704 705 return -ENOENT; 706 } 707