Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
nouveau_display.c
Go to the documentation of this file.
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 
30 #include "nouveau_fbcon.h"
31 #include "nouveau_hw.h"
32 #include "nouveau_crtc.h"
33 #include "nouveau_dma.h"
34 #include "nouveau_gem.h"
35 #include "nouveau_connector.h"
36 #include "nv50_display.h"
37 
38 #include "nouveau_fence.h"
39 
40 #include <subdev/bios/gpio.h>
41 #include <subdev/gpio.h>
42 #include <engine/disp.h>
43 
44 static void
45 nouveau_user_framebuffer_destroy(struct drm_framebuffer *drm_fb)
46 {
47  struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
48 
49  if (fb->nvbo)
50  drm_gem_object_unreference_unlocked(fb->nvbo->gem);
51 
53  kfree(fb);
54 }
55 
56 static int
57 nouveau_user_framebuffer_create_handle(struct drm_framebuffer *drm_fb,
58  struct drm_file *file_priv,
59  unsigned int *handle)
60 {
61  struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
62 
63  return drm_gem_handle_create(file_priv, fb->nvbo->gem, handle);
64 }
65 
66 static const struct drm_framebuffer_funcs nouveau_framebuffer_funcs = {
67  .destroy = nouveau_user_framebuffer_destroy,
68  .create_handle = nouveau_user_framebuffer_create_handle,
69 };
70 
71 int
73  struct nouveau_framebuffer *nv_fb,
74  struct drm_mode_fb_cmd2 *mode_cmd,
75  struct nouveau_bo *nvbo)
76 {
77  struct nouveau_drm *drm = nouveau_drm(dev);
78  struct drm_framebuffer *fb = &nv_fb->base;
79  int ret;
80 
81  ret = drm_framebuffer_init(dev, fb, &nouveau_framebuffer_funcs);
82  if (ret) {
83  return ret;
84  }
85 
86  drm_helper_mode_fill_fb_struct(fb, mode_cmd);
87  nv_fb->nvbo = nvbo;
88 
89  if (nv_device(drm->device)->card_type >= NV_50) {
90  u32 tile_flags = nouveau_bo_tile_layout(nvbo);
91  if (tile_flags == 0x7a00 ||
92  tile_flags == 0xfe00)
93  nv_fb->r_dma = NvEvoFB32;
94  else
95  if (tile_flags == 0x7000)
96  nv_fb->r_dma = NvEvoFB16;
97  else
98  nv_fb->r_dma = NvEvoVRAM_LP;
99 
100  switch (fb->depth) {
101  case 8: nv_fb->r_format = NV50_EVO_CRTC_FB_DEPTH_8; break;
102  case 15: nv_fb->r_format = NV50_EVO_CRTC_FB_DEPTH_15; break;
103  case 16: nv_fb->r_format = NV50_EVO_CRTC_FB_DEPTH_16; break;
104  case 24:
105  case 32: nv_fb->r_format = NV50_EVO_CRTC_FB_DEPTH_24; break;
106  case 30: nv_fb->r_format = NV50_EVO_CRTC_FB_DEPTH_30; break;
107  default:
108  NV_ERROR(drm, "unknown depth %d\n", fb->depth);
109  return -EINVAL;
110  }
111 
112  if (nv_device(drm->device)->chipset == 0x50)
113  nv_fb->r_format |= (tile_flags << 8);
114 
115  if (!tile_flags) {
116  if (nv_device(drm->device)->card_type < NV_D0)
117  nv_fb->r_pitch = 0x00100000 | fb->pitches[0];
118  else
119  nv_fb->r_pitch = 0x01000000 | fb->pitches[0];
120  } else {
121  u32 mode = nvbo->tile_mode;
122  if (nv_device(drm->device)->card_type >= NV_C0)
123  mode >>= 4;
124  nv_fb->r_pitch = ((fb->pitches[0] / 4) << 4) | mode;
125  }
126  }
127 
128  return 0;
129 }
130 
131 static struct drm_framebuffer *
132 nouveau_user_framebuffer_create(struct drm_device *dev,
133  struct drm_file *file_priv,
134  struct drm_mode_fb_cmd2 *mode_cmd)
135 {
137  struct drm_gem_object *gem;
138  int ret;
139 
140  gem = drm_gem_object_lookup(dev, file_priv, mode_cmd->handles[0]);
141  if (!gem)
142  return ERR_PTR(-ENOENT);
143 
144  nouveau_fb = kzalloc(sizeof(struct nouveau_framebuffer), GFP_KERNEL);
145  if (!nouveau_fb)
146  return ERR_PTR(-ENOMEM);
147 
148  ret = nouveau_framebuffer_init(dev, nouveau_fb, mode_cmd, nouveau_gem_object(gem));
149  if (ret) {
150  drm_gem_object_unreference(gem);
151  return ERR_PTR(ret);
152  }
153 
154  return &nouveau_fb->base;
155 }
156 
157 static const struct drm_mode_config_funcs nouveau_mode_config_funcs = {
158  .fb_create = nouveau_user_framebuffer_create,
159  .output_poll_changed = nouveau_fbcon_output_poll_changed,
160 };
161 
162 
165  int type;
166  char *name;
167 };
168 
169 static struct nouveau_drm_prop_enum_list underscan[] = {
170  { 6, UNDERSCAN_AUTO, "auto" },
171  { 6, UNDERSCAN_OFF, "off" },
172  { 6, UNDERSCAN_ON, "on" },
173  {}
174 };
175 
176 static struct nouveau_drm_prop_enum_list dither_mode[] = {
177  { 7, DITHERING_MODE_AUTO, "auto" },
178  { 7, DITHERING_MODE_OFF, "off" },
179  { 1, DITHERING_MODE_ON, "on" },
180  { 6, DITHERING_MODE_STATIC2X2, "static 2x2" },
181  { 6, DITHERING_MODE_DYNAMIC2X2, "dynamic 2x2" },
182  { 4, DITHERING_MODE_TEMPORAL, "temporal" },
183  {}
184 };
185 
186 static struct nouveau_drm_prop_enum_list dither_depth[] = {
187  { 6, DITHERING_DEPTH_AUTO, "auto" },
188  { 6, DITHERING_DEPTH_6BPC, "6 bpc" },
189  { 6, DITHERING_DEPTH_8BPC, "8 bpc" },
190  {}
191 };
192 
193 #define PROP_ENUM(p,gen,n,list) do { \
194  struct nouveau_drm_prop_enum_list *l = (list); \
195  int c = 0; \
196  while (l->gen_mask) { \
197  if (l->gen_mask & (1 << (gen))) \
198  c++; \
199  l++; \
200  } \
201  if (c) { \
202  p = drm_property_create(dev, DRM_MODE_PROP_ENUM, n, c); \
203  l = (list); \
204  c = 0; \
205  while (p && l->gen_mask) { \
206  if (l->gen_mask & (1 << (gen))) { \
207  drm_property_add_enum(p, c, l->type, l->name); \
208  c++; \
209  } \
210  l++; \
211  } \
212  } \
213 } while(0)
214 
215 int
217 {
218  struct nouveau_drm *drm = nouveau_drm(dev);
219  struct nouveau_display *disp = nouveau_display(dev);
220  struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
221  struct drm_connector *connector;
222  int ret;
223 
224  ret = disp->init(dev);
225  if (ret)
226  return ret;
227 
228  /* power on internal panel if it's not already. the init tables of
229  * some vbios default this to off for some reason, causing the
230  * panel to not work after resume
231  */
232  if (gpio && gpio->get(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff) == 0) {
233  gpio->set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 1);
234  msleep(300);
235  }
236 
237  /* enable polling for external displays */
239 
240  /* enable hotplug interrupts */
241  list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
242  struct nouveau_connector *conn = nouveau_connector(connector);
243  if (gpio)
244  gpio->irq(gpio, 0, conn->hpd, 0xff, true);
245  }
246 
247  return ret;
248 }
249 
250 void
252 {
253  struct nouveau_drm *drm = nouveau_drm(dev);
254  struct nouveau_display *disp = nouveau_display(dev);
255  struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
256  struct drm_connector *connector;
257 
258  /* disable hotplug interrupts */
259  list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
260  struct nouveau_connector *conn = nouveau_connector(connector);
261  if (gpio)
262  gpio->irq(gpio, 0, conn->hpd, 0xff, false);
263  }
264 
266  disp->fini(dev);
267 }
268 
269 static void
270 nouveau_display_vblank_notify(void *data, int crtc)
271 {
272  drm_handle_vblank(data, crtc);
273 }
274 
275 static void
276 nouveau_display_vblank_get(void *data, int crtc)
277 {
278  drm_vblank_get(data, crtc);
279 }
280 
281 static void
282 nouveau_display_vblank_put(void *data, int crtc)
283 {
284  drm_vblank_put(data, crtc);
285 }
286 
287 int
289 {
290  struct nouveau_drm *drm = nouveau_drm(dev);
291  struct nouveau_disp *pdisp = nouveau_disp(drm->device);
292  struct nouveau_display *disp;
293  u32 pclass = dev->pdev->class >> 8;
294  int ret, gen;
295 
296  disp = drm->display = kzalloc(sizeof(*disp), GFP_KERNEL);
297  if (!disp)
298  return -ENOMEM;
299 
300  pdisp->vblank.data = dev;
301  pdisp->vblank.notify = nouveau_display_vblank_notify;
302  pdisp->vblank.get = nouveau_display_vblank_get;
303  pdisp->vblank.put = nouveau_display_vblank_put;
304 
308 
309  if (nv_device(drm->device)->card_type < NV_50)
310  gen = 0;
311  else
312  if (nv_device(drm->device)->card_type < NV_D0)
313  gen = 1;
314  else
315  gen = 2;
316 
317  PROP_ENUM(disp->dithering_mode, gen, "dithering mode", dither_mode);
318  PROP_ENUM(disp->dithering_depth, gen, "dithering depth", dither_depth);
319  PROP_ENUM(disp->underscan_property, gen, "underscan", underscan);
320 
322  drm_property_create_range(dev, 0, "underscan hborder", 0, 128);
323 
325  drm_property_create_range(dev, 0, "underscan vborder", 0, 128);
326 
327  if (gen == 1) {
328  disp->vibrant_hue_property =
330  "vibrant hue", 2);
331  disp->vibrant_hue_property->values[0] = 0;
332  disp->vibrant_hue_property->values[1] = 180; /* -90..+90 */
333 
336  "color vibrance", 2);
337  disp->color_vibrance_property->values[0] = 0;
338  disp->color_vibrance_property->values[1] = 200; /* -100..+100 */
339  }
340 
341  dev->mode_config.funcs = &nouveau_mode_config_funcs;
342  dev->mode_config.fb_base = pci_resource_start(dev->pdev, 1);
343 
344  dev->mode_config.min_width = 0;
345  dev->mode_config.min_height = 0;
346  if (nv_device(drm->device)->card_type < NV_10) {
347  dev->mode_config.max_width = 2048;
348  dev->mode_config.max_height = 2048;
349  } else
350  if (nv_device(drm->device)->card_type < NV_50) {
351  dev->mode_config.max_width = 4096;
352  dev->mode_config.max_height = 4096;
353  } else {
354  dev->mode_config.max_width = 8192;
355  dev->mode_config.max_height = 8192;
356  }
357 
358  dev->mode_config.preferred_depth = 24;
359  dev->mode_config.prefer_shadow = 1;
360 
363 
364  if (nouveau_modeset == 1 ||
365  (nouveau_modeset < 0 && pclass == PCI_CLASS_DISPLAY_VGA)) {
366  if (nv_device(drm->device)->card_type < NV_50)
367  ret = nv04_display_create(dev);
368  else
369  if (nv_device(drm->device)->card_type < NV_D0)
370  ret = nv50_display_create(dev);
371  else
372  ret = nvd0_display_create(dev);
373  if (ret)
374  goto disp_create_err;
375 
376  if (dev->mode_config.num_crtc) {
377  ret = drm_vblank_init(dev, dev->mode_config.num_crtc);
378  if (ret)
379  goto vblank_err;
380  }
381 
383  }
384 
385  return 0;
386 
387 vblank_err:
388  disp->dtor(dev);
389 disp_create_err:
392  return ret;
393 }
394 
395 void
397 {
398  struct nouveau_display *disp = nouveau_display(dev);
399 
401  drm_vblank_cleanup(dev);
402 
403  if (disp->dtor)
404  disp->dtor(dev);
405 
408  nouveau_drm(dev)->display = NULL;
409  kfree(disp);
410 }
411 
412 int
414 {
415  struct nouveau_drm *drm = nouveau_drm(dev);
416  struct drm_crtc *crtc;
417 
419 
420  NV_INFO(drm, "unpinning framebuffer(s)...\n");
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_unpin(nouveau_fb->nvbo);
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  nouveau_bo_unmap(nv_crtc->cursor.nvbo);
435  nouveau_bo_unpin(nv_crtc->cursor.nvbo);
436  }
437 
438  return 0;
439 }
440 
441 void
443 {
444  struct nouveau_drm *drm = nouveau_drm(dev);
445  struct drm_crtc *crtc;
446  int ret;
447 
448  list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
449  struct nouveau_framebuffer *nouveau_fb;
450 
451  nouveau_fb = nouveau_framebuffer(crtc->fb);
452  if (!nouveau_fb || !nouveau_fb->nvbo)
453  continue;
454 
455  nouveau_bo_pin(nouveau_fb->nvbo, TTM_PL_FLAG_VRAM);
456  }
457 
458  list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
459  struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
460 
461  ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM);
462  if (!ret)
463  ret = nouveau_bo_map(nv_crtc->cursor.nvbo);
464  if (ret)
465  NV_ERROR(drm, "Could not pin/map cursor.\n");
466  }
467 
470 
472 
473  /* Force CLUT to get re-loaded during modeset */
474  list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
475  struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
476 
477  nv_crtc->lut.depth = 0;
478  }
479 
481 
482  list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
483  struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
484  u32 offset = nv_crtc->cursor.nvbo->bo.offset;
485 
486  nv_crtc->cursor.set_offset(nv_crtc, offset);
487  nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x,
488  nv_crtc->cursor_saved_y);
489  }
490 }
491 
492 int
494 {
495  struct nouveau_device *device = nouveau_dev(dev);
496 
497  if (device->card_type >= NV_D0)
498  nv_mask(device, 0x6100c0 + (crtc * 0x800), 1, 1);
499  else
500  if (device->card_type >= NV_50)
501  nv_mask(device, NV50_PDISPLAY_INTR_EN_1, 0,
503  else
504  NVWriteCRTC(dev, crtc, NV_PCRTC_INTR_EN_0,
506 
507  return 0;
508 }
509 
510 void
512 {
513  struct nouveau_device *device = nouveau_dev(dev);
514 
515  if (device->card_type >= NV_D0)
516  nv_mask(device, 0x6100c0 + (crtc * 0x800), 1, 0);
517  else
518  if (device->card_type >= NV_50)
519  nv_mask(device, NV50_PDISPLAY_INTR_EN_1,
521  else
522  NVWriteCRTC(dev, crtc, NV_PCRTC_INTR_EN_0, 0);
523 }
524 
525 static int
526 nouveau_page_flip_reserve(struct nouveau_bo *old_bo,
527  struct nouveau_bo *new_bo)
528 {
529  int ret;
530 
531  ret = nouveau_bo_pin(new_bo, TTM_PL_FLAG_VRAM);
532  if (ret)
533  return ret;
534 
535  ret = ttm_bo_reserve(&new_bo->bo, false, false, false, 0);
536  if (ret)
537  goto fail;
538 
539  if (likely(old_bo != new_bo)) {
540  ret = ttm_bo_reserve(&old_bo->bo, false, false, false, 0);
541  if (ret)
542  goto fail_unreserve;
543  }
544 
545  return 0;
546 
547 fail_unreserve:
548  ttm_bo_unreserve(&new_bo->bo);
549 fail:
550  nouveau_bo_unpin(new_bo);
551  return ret;
552 }
553 
554 static void
555 nouveau_page_flip_unreserve(struct nouveau_bo *old_bo,
556  struct nouveau_bo *new_bo,
557  struct nouveau_fence *fence)
558 {
559  nouveau_bo_fence(new_bo, fence);
560  ttm_bo_unreserve(&new_bo->bo);
561 
562  if (likely(old_bo != new_bo)) {
563  nouveau_bo_fence(old_bo, fence);
564  ttm_bo_unreserve(&old_bo->bo);
565  }
566 
567  nouveau_bo_unpin(old_bo);
568 }
569 
570 static int
571 nouveau_page_flip_emit(struct nouveau_channel *chan,
572  struct nouveau_bo *old_bo,
573  struct nouveau_bo *new_bo,
574  struct nouveau_page_flip_state *s,
575  struct nouveau_fence **pfence)
576 {
577  struct nouveau_fence_chan *fctx = chan->fence;
578  struct nouveau_drm *drm = chan->drm;
579  struct drm_device *dev = drm->dev;
580  unsigned long flags;
581  int ret;
582 
583  /* Queue it to the pending list */
584  spin_lock_irqsave(&dev->event_lock, flags);
585  list_add_tail(&s->head, &fctx->flip);
586  spin_unlock_irqrestore(&dev->event_lock, flags);
587 
588  /* Synchronize with the old framebuffer */
589  ret = nouveau_fence_sync(old_bo->bo.sync_obj, chan);
590  if (ret)
591  goto fail;
592 
593  /* Emit the pageflip */
594  ret = RING_SPACE(chan, 3);
595  if (ret)
596  goto fail;
597 
598  if (nv_device(drm->device)->card_type < NV_C0) {
599  BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1);
600  OUT_RING (chan, 0x00000000);
601  OUT_RING (chan, 0x00000000);
602  } else {
603  BEGIN_NVC0(chan, 0, NV10_SUBCHAN_REF_CNT, 1);
604  OUT_RING (chan, 0);
605  BEGIN_IMC0(chan, 0, NVSW_SUBCHAN_PAGE_FLIP, 0x0000);
606  }
607  FIRE_RING (chan);
608 
609  ret = nouveau_fence_new(chan, pfence);
610  if (ret)
611  goto fail;
612 
613  return 0;
614 fail:
615  spin_lock_irqsave(&dev->event_lock, flags);
616  list_del(&s->head);
617  spin_unlock_irqrestore(&dev->event_lock, flags);
618  return ret;
619 }
620 
621 int
623  struct drm_pending_vblank_event *event)
624 {
625  struct drm_device *dev = crtc->dev;
626  struct nouveau_drm *drm = nouveau_drm(dev);
627  struct nouveau_bo *old_bo = nouveau_framebuffer(crtc->fb)->nvbo;
628  struct nouveau_bo *new_bo = nouveau_framebuffer(fb)->nvbo;
629  struct nouveau_page_flip_state *s;
630  struct nouveau_channel *chan = NULL;
631  struct nouveau_fence *fence;
632  int ret;
633 
634  if (!drm->channel)
635  return -ENODEV;
636 
637  s = kzalloc(sizeof(*s), GFP_KERNEL);
638  if (!s)
639  return -ENOMEM;
640 
641  /* Don't let the buffers go away while we flip */
642  ret = nouveau_page_flip_reserve(old_bo, new_bo);
643  if (ret)
644  goto fail_free;
645 
646  /* Initialize a page flip struct */
647  *s = (struct nouveau_page_flip_state)
648  { { }, event, nouveau_crtc(crtc)->index,
649  fb->bits_per_pixel, fb->pitches[0], crtc->x, crtc->y,
650  new_bo->bo.offset };
651 
652  /* Choose the channel the flip will be handled in */
653  fence = new_bo->bo.sync_obj;
654  if (fence)
655  chan = fence->channel;
656  if (!chan)
657  chan = drm->channel;
658  mutex_lock(&chan->cli->mutex);
659 
660  /* Emit a page flip */
661  if (nv_device(drm->device)->card_type >= NV_50) {
662  if (nv_device(drm->device)->card_type >= NV_D0)
663  ret = nvd0_display_flip_next(crtc, fb, chan, 0);
664  else
665  ret = nv50_display_flip_next(crtc, fb, chan);
666  if (ret) {
667  mutex_unlock(&chan->cli->mutex);
668  goto fail_unreserve;
669  }
670  }
671 
672  ret = nouveau_page_flip_emit(chan, old_bo, new_bo, s, &fence);
673  mutex_unlock(&chan->cli->mutex);
674  if (ret)
675  goto fail_unreserve;
676 
677  /* Update the crtc struct and cleanup */
678  crtc->fb = fb;
679 
680  nouveau_page_flip_unreserve(old_bo, new_bo, fence);
681  nouveau_fence_unref(&fence);
682  return 0;
683 
684 fail_unreserve:
685  nouveau_page_flip_unreserve(old_bo, new_bo, NULL);
686 fail_free:
687  kfree(s);
688  return ret;
689 }
690 
691 int
693  struct nouveau_page_flip_state *ps)
694 {
695  struct nouveau_fence_chan *fctx = chan->fence;
696  struct nouveau_drm *drm = chan->drm;
697  struct drm_device *dev = drm->dev;
698  struct nouveau_page_flip_state *s;
699  unsigned long flags;
700 
701  spin_lock_irqsave(&dev->event_lock, flags);
702 
703  if (list_empty(&fctx->flip)) {
704  NV_ERROR(drm, "unexpected pageflip\n");
705  spin_unlock_irqrestore(&dev->event_lock, flags);
706  return -EINVAL;
707  }
708 
709  s = list_first_entry(&fctx->flip, struct nouveau_page_flip_state, head);
710  if (s->event) {
711  struct drm_pending_vblank_event *e = s->event;
712  struct timeval now;
713 
714  do_gettimeofday(&now);
715  e->event.sequence = 0;
716  e->event.tv_sec = now.tv_sec;
717  e->event.tv_usec = now.tv_usec;
718  list_add_tail(&e->base.link, &e->base.file_priv->event_list);
719  wake_up_interruptible(&e->base.file_priv->event_wait);
720  }
721 
722  list_del(&s->head);
723  if (ps)
724  *ps = *s;
725  kfree(s);
726 
727  spin_unlock_irqrestore(&dev->event_lock, flags);
728  return 0;
729 }
730 
731 int
733 {
734  struct nouveau_channel *chan = data;
735  struct nouveau_drm *drm = chan->drm;
736  struct nouveau_page_flip_state state;
737 
738  if (!nouveau_finish_page_flip(chan, &state)) {
739  if (nv_device(drm->device)->card_type < NV_50) {
740  nv_set_crtc_base(drm->dev, state.crtc, state.offset +
741  state.y * state.pitch +
742  state.x * state.bpp / 8);
743  }
744  }
745 
746  return 0;
747 }
748 
749 int
750 nouveau_display_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
751  struct drm_mode_create_dumb *args)
752 {
753  struct nouveau_bo *bo;
754  int ret;
755 
756  args->pitch = roundup(args->width * (args->bpp / 8), 256);
757  args->size = args->pitch * args->height;
758  args->size = roundup(args->size, PAGE_SIZE);
759 
760  ret = nouveau_gem_new(dev, args->size, 0, NOUVEAU_GEM_DOMAIN_VRAM, 0, 0, &bo);
761  if (ret)
762  return ret;
763 
764  ret = drm_gem_handle_create(file_priv, bo->gem, &args->handle);
765  drm_gem_object_unreference_unlocked(bo->gem);
766  return ret;
767 }
768 
769 int
770 nouveau_display_dumb_destroy(struct drm_file *file_priv, struct drm_device *dev,
772 {
773  return drm_gem_handle_delete(file_priv, handle);
774 }
775 
776 int
777 nouveau_display_dumb_map_offset(struct drm_file *file_priv,
778  struct drm_device *dev,
779  uint32_t handle, uint64_t *poffset)
780 {
781  struct drm_gem_object *gem;
782 
783  gem = drm_gem_object_lookup(dev, file_priv, handle);
784  if (gem) {
785  struct nouveau_bo *bo = gem->driver_private;
786  *poffset = bo->bo.addr_space_offset;
787  drm_gem_object_unreference_unlocked(gem);
788  return 0;
789  }
790 
791  return -ENOENT;
792 }