st/xorg: New libkms destroy api
[mesa.git] / src / gallium / state_trackers / xorg / xorg_driver.c
1 /*
2 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * 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, sub license, 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 portions
15 * of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
20 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
21 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 *
26 * Author: Alan Hourihane <alanh@tungstengraphics.com>
27 * Author: Jakob Bornecrantz <wallbraker@gmail.com>
28 *
29 */
30
31
32 #include "xorg-server.h"
33 #include "xf86.h"
34 #include "xf86_OSproc.h"
35 #include "compiler.h"
36 #include "xf86PciInfo.h"
37 #include "xf86Pci.h"
38 #include "mipointer.h"
39 #include "micmap.h"
40 #include <X11/extensions/randr.h>
41 #include "fb.h"
42 #include "edid.h"
43 #include "xf86i2c.h"
44 #include "xf86Crtc.h"
45 #include "miscstruct.h"
46 #include "dixstruct.h"
47 #include "xf86xv.h"
48 #include <X11/extensions/Xv.h>
49 #ifndef XSERVER_LIBPCIACCESS
50 #error "libpciaccess needed"
51 #endif
52
53 #include <pciaccess.h>
54
55 #include "pipe/p_context.h"
56 #include "xorg_tracker.h"
57 #include "xorg_winsys.h"
58
59 #ifdef HAVE_LIBKMS
60 #include "libkms.h"
61 #endif
62
63 /*
64 * Functions and symbols exported to Xorg via pointers.
65 */
66
67 static Bool drv_pre_init(ScrnInfoPtr pScrn, int flags);
68 static Bool drv_screen_init(int scrnIndex, ScreenPtr pScreen, int argc,
69 char **argv);
70 static Bool drv_switch_mode(int scrnIndex, DisplayModePtr mode, int flags);
71 static void drv_adjust_frame(int scrnIndex, int x, int y, int flags);
72 static Bool drv_enter_vt(int scrnIndex, int flags);
73 static void drv_leave_vt(int scrnIndex, int flags);
74 static void drv_free_screen(int scrnIndex, int flags);
75 static ModeStatus drv_valid_mode(int scrnIndex, DisplayModePtr mode, Bool verbose,
76 int flags);
77
78 typedef enum
79 {
80 OPTION_SW_CURSOR,
81 OPTION_2D_ACCEL,
82 } drv_option_enums;
83
84 static const OptionInfoRec drv_options[] = {
85 {OPTION_SW_CURSOR, "SWcursor", OPTV_BOOLEAN, {0}, FALSE},
86 {OPTION_2D_ACCEL, "2DAccel", OPTV_BOOLEAN, {0}, FALSE},
87 {-1, NULL, OPTV_NONE, {0}, FALSE}
88 };
89
90
91 /*
92 * Exported Xorg driver functions to winsys
93 */
94
95 const OptionInfoRec *
96 xorg_tracker_available_options(int chipid, int busid)
97 {
98 return drv_options;
99 }
100
101 void
102 xorg_tracker_set_functions(ScrnInfoPtr scrn)
103 {
104 scrn->PreInit = drv_pre_init;
105 scrn->ScreenInit = drv_screen_init;
106 scrn->SwitchMode = drv_switch_mode;
107 scrn->AdjustFrame = drv_adjust_frame;
108 scrn->EnterVT = drv_enter_vt;
109 scrn->LeaveVT = drv_leave_vt;
110 scrn->FreeScreen = drv_free_screen;
111 scrn->ValidMode = drv_valid_mode;
112 }
113
114
115 /*
116 * Internal function definitions
117 */
118
119 static Bool drv_init_front_buffer_functions(ScrnInfoPtr pScrn);
120 static Bool drv_close_screen(int scrnIndex, ScreenPtr pScreen);
121 static Bool drv_save_hw_state(ScrnInfoPtr pScrn);
122 static Bool drv_restore_hw_state(ScrnInfoPtr pScrn);
123
124
125 /*
126 * Internal functions
127 */
128
129 static Bool
130 drv_get_rec(ScrnInfoPtr pScrn)
131 {
132 if (pScrn->driverPrivate)
133 return TRUE;
134
135 pScrn->driverPrivate = xnfcalloc(sizeof(modesettingRec), 1);
136
137 return TRUE;
138 }
139
140 static void
141 drv_free_rec(ScrnInfoPtr pScrn)
142 {
143 if (!pScrn)
144 return;
145
146 if (!pScrn->driverPrivate)
147 return;
148
149 xfree(pScrn->driverPrivate);
150
151 pScrn->driverPrivate = NULL;
152 }
153
154 static void
155 drv_probe_ddc(ScrnInfoPtr pScrn, int index)
156 {
157 ConfiguredMonitor = NULL;
158 }
159
160 static Bool
161 drv_crtc_resize(ScrnInfoPtr pScrn, int width, int height)
162 {
163 modesettingPtr ms = modesettingPTR(pScrn);
164 PixmapPtr rootPixmap;
165 ScreenPtr pScreen = pScrn->pScreen;
166
167 if (width == pScrn->virtualX && height == pScrn->virtualY)
168 return TRUE;
169
170 pScrn->virtualX = width;
171 pScrn->virtualY = height;
172
173 /*
174 * Remove the old framebuffer & texture.
175 */
176 drmModeRmFB(ms->fd, ms->fb_id);
177 if (!ms->destroy_front_buffer(pScrn))
178 FatalError("failed to destroy front buffer\n");
179
180 rootPixmap = pScreen->GetScreenPixmap(pScreen);
181 if (!pScreen->ModifyPixmapHeader(rootPixmap, width, height, -1, -1, -1, NULL))
182 return FALSE;
183
184 /* HW dependent - FIXME */
185 pScrn->displayWidth = pScrn->virtualX;
186
187 /* now create new frontbuffer */
188 return ms->create_front_buffer(pScrn) && ms->bind_front_buffer(pScrn);
189 }
190
191 static const xf86CrtcConfigFuncsRec crtc_config_funcs = {
192 .resize = drv_crtc_resize
193 };
194
195 static Bool
196 drv_init_drm(ScrnInfoPtr pScrn)
197 {
198 modesettingPtr ms = modesettingPTR(pScrn);
199
200 /* deal with server regeneration */
201 if (ms->fd < 0) {
202 char *BusID;
203
204 BusID = xalloc(64);
205 sprintf(BusID, "PCI:%d:%d:%d",
206 ((ms->PciInfo->domain << 8) | ms->PciInfo->bus),
207 ms->PciInfo->dev, ms->PciInfo->func
208 );
209
210 ms->fd = drmOpen(NULL, BusID);
211
212 if (ms->fd < 0)
213 return FALSE;
214 }
215
216 return TRUE;
217 }
218
219 static Bool
220 drv_init_resource_management(ScrnInfoPtr pScrn)
221 {
222 modesettingPtr ms = modesettingPTR(pScrn);
223
224 if (ms->screen || ms->kms)
225 return TRUE;
226
227 ms->api = drm_api_create();
228 if (ms->api) {
229 ms->screen = ms->api->create_screen(ms->api, ms->fd, NULL);
230
231 if (ms->screen)
232 return TRUE;
233
234 if (ms->api->destroy)
235 ms->api->destroy(ms->api);
236
237 ms->api = NULL;
238 }
239
240 #ifdef HAVE_LIBKMS
241 if (!kms_create(ms->fd, &ms->kms))
242 return TRUE;
243 #endif
244
245 return FALSE;
246 }
247
248 static Bool
249 drv_close_resource_management(ScrnInfoPtr pScrn)
250 {
251 modesettingPtr ms = modesettingPTR(pScrn);
252
253 if (ms->screen)
254 ms->screen->destroy(ms->screen);
255 ms->screen = NULL;
256
257 if (ms->api && ms->api->destroy)
258 ms->api->destroy(ms->api);
259 ms->api = NULL;
260
261 #ifdef HAVE_LIBKMS
262 if (ms->kms)
263 kms_destroy(&ms->kms);
264 #endif
265
266 return TRUE;
267 }
268
269 static Bool
270 drv_pre_init(ScrnInfoPtr pScrn, int flags)
271 {
272 xf86CrtcConfigPtr xf86_config;
273 modesettingPtr ms;
274 rgb defaultWeight = { 0, 0, 0 };
275 EntityInfoPtr pEnt;
276 EntPtr msEnt = NULL;
277 int max_width, max_height;
278
279 if (pScrn->numEntities != 1)
280 return FALSE;
281
282 pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
283
284 if (flags & PROBE_DETECT) {
285 drv_probe_ddc(pScrn, pEnt->index);
286 return TRUE;
287 }
288
289 /* Allocate driverPrivate */
290 if (!drv_get_rec(pScrn))
291 return FALSE;
292
293 ms = modesettingPTR(pScrn);
294 ms->SaveGeneration = -1;
295 ms->pEnt = pEnt;
296
297 pScrn->displayWidth = 640; /* default it */
298
299 if (ms->pEnt->location.type != BUS_PCI)
300 return FALSE;
301
302 ms->PciInfo = xf86GetPciInfoForEntity(ms->pEnt->index);
303
304 /* Allocate an entity private if necessary */
305 if (xf86IsEntityShared(pScrn->entityList[0])) {
306 FatalError("Entity");
307 #if 0
308 msEnt = xf86GetEntityPrivate(pScrn->entityList[0],
309 modesettingEntityIndex)->ptr;
310 ms->entityPrivate = msEnt;
311 #else
312 (void)msEnt;
313 #endif
314 } else
315 ms->entityPrivate = NULL;
316
317 if (xf86IsEntityShared(pScrn->entityList[0])) {
318 if (xf86IsPrimInitDone(pScrn->entityList[0])) {
319 /* do something */
320 } else {
321 xf86SetPrimInitDone(pScrn->entityList[0]);
322 }
323 }
324
325 ms->fd = -1;
326 ms->api = NULL;
327 if (!drv_init_drm(pScrn))
328 return FALSE;
329
330 pScrn->monitor = pScrn->confScreen->monitor;
331 pScrn->progClock = TRUE;
332 pScrn->rgbBits = 8;
333
334 if (!xf86SetDepthBpp
335 (pScrn, 0, 0, 0,
336 PreferConvert24to32 | SupportConvert24to32 | Support32bppFb))
337 return FALSE;
338
339 switch (pScrn->depth) {
340 case 15:
341 case 16:
342 case 24:
343 break;
344 default:
345 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
346 "Given depth (%d) is not supported by the driver\n",
347 pScrn->depth);
348 return FALSE;
349 }
350 xf86PrintDepthBpp(pScrn);
351
352 if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight))
353 return FALSE;
354 if (!xf86SetDefaultVisual(pScrn, -1))
355 return FALSE;
356
357 /* Process the options */
358 xf86CollectOptions(pScrn, NULL);
359 if (!(ms->Options = xalloc(sizeof(drv_options))))
360 return FALSE;
361 memcpy(ms->Options, drv_options, sizeof(drv_options));
362 xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, ms->Options);
363
364 /* Allocate an xf86CrtcConfig */
365 xf86CrtcConfigInit(pScrn, &crtc_config_funcs);
366 xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
367
368 max_width = 8192;
369 max_height = 8192;
370 xf86CrtcSetSizeRange(pScrn, 320, 200, max_width, max_height);
371
372 if (xf86ReturnOptValBool(ms->Options, OPTION_SW_CURSOR, FALSE)) {
373 ms->SWCursor = TRUE;
374 }
375
376 drv_save_hw_state(pScrn);
377
378 xorg_crtc_init(pScrn);
379 xorg_output_init(pScrn);
380
381 if (!xf86InitialConfiguration(pScrn, TRUE)) {
382 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes.\n");
383 drv_restore_hw_state(pScrn);
384 return FALSE;
385 }
386
387 drv_restore_hw_state(pScrn);
388
389 /*
390 * If the driver can do gamma correction, it should call xf86SetGamma() here.
391 */
392 {
393 Gamma zeros = { 0.0, 0.0, 0.0 };
394
395 if (!xf86SetGamma(pScrn, zeros)) {
396 return FALSE;
397 }
398 }
399
400 if (pScrn->modes == NULL) {
401 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No modes.\n");
402 return FALSE;
403 }
404
405 pScrn->currentMode = pScrn->modes;
406
407 /* Set display resolution */
408 xf86SetDpi(pScrn, 0, 0);
409
410 /* Load the required sub modules */
411 if (!xf86LoadSubModule(pScrn, "fb"))
412 return FALSE;
413
414 /* XXX: these aren't needed when we are using libkms */
415 if (!xf86LoadSubModule(pScrn, "exa"))
416 return FALSE;
417
418 #ifdef DRI2
419 if (!xf86LoadSubModule(pScrn, "dri2"))
420 return FALSE;
421 #endif
422
423 return TRUE;
424 }
425
426 static Bool
427 drv_save_hw_state(ScrnInfoPtr pScrn)
428 {
429 /*xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);*/
430
431 return TRUE;
432 }
433
434 static Bool
435 drv_restore_hw_state(ScrnInfoPtr pScrn)
436 {
437 /*xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);*/
438
439 return TRUE;
440 }
441
442 static void drv_block_handler(int i, pointer blockData, pointer pTimeout,
443 pointer pReadmask)
444 {
445 ScreenPtr pScreen = screenInfo.screens[i];
446 modesettingPtr ms = modesettingPTR(xf86Screens[pScreen->myNum]);
447
448 pScreen->BlockHandler = ms->blockHandler;
449 pScreen->BlockHandler(i, blockData, pTimeout, pReadmask);
450 pScreen->BlockHandler = drv_block_handler;
451
452 if (ms->ctx) {
453 int j;
454
455 ms->ctx->flush(ms->ctx, PIPE_FLUSH_RENDER_CACHE, &ms->fence[XORG_NR_FENCES-1]);
456
457 if (ms->fence[0])
458 ms->ctx->screen->fence_finish(ms->ctx->screen, ms->fence[0], 0);
459
460 /* The amount of rendering generated by a block handler can be
461 * quite small. Let us get a fair way ahead of hardware before
462 * throttling.
463 */
464 for (j = 0; j < XORG_NR_FENCES; j++)
465 ms->screen->fence_reference(ms->screen,
466 &ms->fence[j],
467 ms->fence[j+1]);
468
469 ms->screen->fence_reference(ms->screen,
470 &ms->fence[XORG_NR_FENCES-1],
471 NULL);
472 }
473
474
475 #ifdef DRM_MODE_FEATURE_DIRTYFB
476 {
477 RegionPtr dirty = DamageRegion(ms->damage);
478 unsigned num_cliprects = REGION_NUM_RECTS(dirty);
479
480 if (num_cliprects) {
481 drmModeClip *clip = alloca(num_cliprects * sizeof(drmModeClip));
482 BoxPtr rect = REGION_RECTS(dirty);
483 int i;
484
485 /* XXX no need for copy? */
486 for (i = 0; i < num_cliprects; i++, rect++) {
487 clip[i].x1 = rect->x1;
488 clip[i].y1 = rect->y1;
489 clip[i].x2 = rect->x2;
490 clip[i].y2 = rect->y2;
491 }
492
493 /* TODO query connector property to see if this is needed */
494 drmModeDirtyFB(ms->fd, ms->fb_id, clip, num_cliprects);
495
496 DamageEmpty(ms->damage);
497 }
498 }
499 #endif
500 }
501
502 static Bool
503 drv_create_screen_resources(ScreenPtr pScreen)
504 {
505 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
506 modesettingPtr ms = modesettingPTR(pScrn);
507 PixmapPtr rootPixmap;
508 Bool ret;
509
510 ms->noEvict = TRUE;
511
512 pScreen->CreateScreenResources = ms->createScreenResources;
513 ret = pScreen->CreateScreenResources(pScreen);
514 pScreen->CreateScreenResources = drv_create_screen_resources;
515
516 ms->bind_front_buffer(pScrn);
517
518 ms->noEvict = FALSE;
519
520 drv_adjust_frame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
521
522 #ifdef DRM_MODE_FEATURE_DIRTYFB
523 rootPixmap = pScreen->GetScreenPixmap(pScreen);
524 ms->damage = DamageCreate(NULL, NULL, DamageReportNone, TRUE,
525 pScreen, rootPixmap);
526
527 if (ms->damage) {
528 DamageRegister(&rootPixmap->drawable, ms->damage);
529
530 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Damage tracking initialized\n");
531 } else {
532 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
533 "Failed to create screen damage record\n");
534 return FALSE;
535 }
536 #else
537 (void)rootPixmap;
538 #endif
539
540 return ret;
541 }
542
543 static Bool
544 drv_screen_init(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
545 {
546 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
547 modesettingPtr ms = modesettingPTR(pScrn);
548 VisualPtr visual;
549
550 if (!drv_init_drm(pScrn)) {
551 FatalError("Could not init DRM");
552 return FALSE;
553 }
554
555 if (!drv_init_resource_management(pScrn)) {
556 FatalError("Could not init resource management (!pipe_screen && !libkms)");
557 return FALSE;
558 }
559
560 if (!drv_init_front_buffer_functions(pScrn)) {
561 FatalError("Could not init front buffer manager");
562 return FALSE;
563 }
564
565 pScrn->pScreen = pScreen;
566
567 /* HW dependent - FIXME */
568 pScrn->displayWidth = pScrn->virtualX;
569
570 miClearVisualTypes();
571
572 if (!miSetVisualTypes(pScrn->depth,
573 miGetDefaultVisualMask(pScrn->depth),
574 pScrn->rgbBits, pScrn->defaultVisual))
575 return FALSE;
576
577 if (!miSetPixmapDepths())
578 return FALSE;
579
580 pScrn->memPhysBase = 0;
581 pScrn->fbOffset = 0;
582
583 if (!fbScreenInit(pScreen, NULL,
584 pScrn->virtualX, pScrn->virtualY,
585 pScrn->xDpi, pScrn->yDpi,
586 pScrn->displayWidth, pScrn->bitsPerPixel))
587 return FALSE;
588
589 if (pScrn->bitsPerPixel > 8) {
590 /* Fixup RGB ordering */
591 visual = pScreen->visuals + pScreen->numVisuals;
592 while (--visual >= pScreen->visuals) {
593 if ((visual->class | DynamicClass) == DirectColor) {
594 visual->offsetRed = pScrn->offset.red;
595 visual->offsetGreen = pScrn->offset.green;
596 visual->offsetBlue = pScrn->offset.blue;
597 visual->redMask = pScrn->mask.red;
598 visual->greenMask = pScrn->mask.green;
599 visual->blueMask = pScrn->mask.blue;
600 }
601 }
602 }
603
604 fbPictureInit(pScreen, NULL, 0);
605
606 ms->blockHandler = pScreen->BlockHandler;
607 pScreen->BlockHandler = drv_block_handler;
608 ms->createScreenResources = pScreen->CreateScreenResources;
609 pScreen->CreateScreenResources = drv_create_screen_resources;
610
611 xf86SetBlackWhitePixels(pScreen);
612
613 if (ms->screen) {
614 ms->exa = xorg_exa_init(pScrn, xf86ReturnOptValBool(ms->Options,
615 OPTION_2D_ACCEL, TRUE));
616 ms->debug_fallback = debug_get_bool_option("XORG_DEBUG_FALLBACK", TRUE);
617
618 xorg_xv_init(pScreen);
619 #ifdef DRI2
620 xorg_dri2_init(pScreen);
621 #endif
622 }
623
624 miInitializeBackingStore(pScreen);
625 xf86SetBackingStore(pScreen);
626 xf86SetSilkenMouse(pScreen);
627 miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
628
629 /* Need to extend HWcursor support to handle mask interleave */
630 if (!ms->SWCursor)
631 xf86_cursors_init(pScreen, 64, 64,
632 HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64 |
633 HARDWARE_CURSOR_ARGB);
634
635 /* Must force it before EnterVT, so we are in control of VT and
636 * later memory should be bound when allocating, e.g rotate_mem */
637 pScrn->vtSema = TRUE;
638
639 pScreen->SaveScreen = xf86SaveScreen;
640 ms->CloseScreen = pScreen->CloseScreen;
641 pScreen->CloseScreen = drv_close_screen;
642
643 if (!xf86CrtcScreenInit(pScreen))
644 return FALSE;
645
646 if (!miCreateDefColormap(pScreen))
647 return FALSE;
648
649 xf86DPMSInit(pScreen, xf86DPMSSet, 0);
650
651 if (serverGeneration == 1)
652 xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
653
654 if (ms->winsys_screen_init)
655 ms->winsys_screen_init(pScrn);
656
657 return drv_enter_vt(scrnIndex, 1);
658 }
659
660 static void
661 drv_adjust_frame(int scrnIndex, int x, int y, int flags)
662 {
663 ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
664 xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
665 xf86OutputPtr output = config->output[config->compat_output];
666 xf86CrtcPtr crtc = output->crtc;
667
668 if (crtc && crtc->enabled) {
669 crtc->funcs->set_mode_major(crtc, pScrn->currentMode,
670 RR_Rotate_0, x, y);
671 crtc->x = output->initial_x + x;
672 crtc->y = output->initial_y + y;
673 }
674 }
675
676 static void
677 drv_free_screen(int scrnIndex, int flags)
678 {
679 drv_free_rec(xf86Screens[scrnIndex]);
680 }
681
682 static void
683 drv_leave_vt(int scrnIndex, int flags)
684 {
685 ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
686 modesettingPtr ms = modesettingPTR(pScrn);
687 xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
688 int o;
689
690 for (o = 0; o < config->num_crtc; o++) {
691 xf86CrtcPtr crtc = config->crtc[o];
692
693 xorg_crtc_cursor_destroy(crtc);
694
695 if (crtc->rotatedPixmap || crtc->rotatedData) {
696 crtc->funcs->shadow_destroy(crtc, crtc->rotatedPixmap,
697 crtc->rotatedData);
698 crtc->rotatedPixmap = NULL;
699 crtc->rotatedData = NULL;
700 }
701 }
702
703 drmModeRmFB(ms->fd, ms->fb_id);
704
705 drv_restore_hw_state(pScrn);
706
707 if (drmDropMaster(ms->fd))
708 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
709 "drmDropMaster failed: %s\n", strerror(errno));
710
711 pScrn->vtSema = FALSE;
712 }
713
714 /*
715 * This gets called when gaining control of the VT, and from ScreenInit().
716 */
717 static Bool
718 drv_enter_vt(int scrnIndex, int flags)
719 {
720 ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
721 modesettingPtr ms = modesettingPTR(pScrn);
722
723 if (drmSetMaster(ms->fd)) {
724 if (errno == EINVAL) {
725 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
726 "drmSetMaster failed: 2.6.29 or newer kernel required for "
727 "multi-server DRI\n");
728 } else {
729 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
730 "drmSetMaster failed: %s\n", strerror(errno));
731 }
732 }
733
734 /*
735 * Only save state once per server generation since that's what most
736 * drivers do. Could change this to save state at each VT enter.
737 */
738 if (ms->SaveGeneration != serverGeneration) {
739 ms->SaveGeneration = serverGeneration;
740 drv_save_hw_state(pScrn);
741 }
742
743 if (!ms->create_front_buffer(pScrn))
744 return FALSE;
745
746 if (!flags && !ms->bind_front_buffer(pScrn))
747 return FALSE;
748
749 if (!xf86SetDesiredModes(pScrn))
750 return FALSE;
751
752 return TRUE;
753 }
754
755 static Bool
756 drv_switch_mode(int scrnIndex, DisplayModePtr mode, int flags)
757 {
758 ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
759
760 return xf86SetSingleMode(pScrn, mode, RR_Rotate_0);
761 }
762
763 static Bool
764 drv_close_screen(int scrnIndex, ScreenPtr pScreen)
765 {
766 ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
767 modesettingPtr ms = modesettingPTR(pScrn);
768
769 if (pScrn->vtSema) {
770 drv_leave_vt(scrnIndex, 0);
771 }
772
773 if (ms->winsys_screen_close)
774 ms->winsys_screen_close(pScrn);
775
776 #ifdef DRI2
777 if (ms->screen)
778 xorg_dri2_close(pScreen);
779 #endif
780
781 pScreen->BlockHandler = ms->blockHandler;
782 pScreen->CreateScreenResources = ms->createScreenResources;
783
784 #ifdef DRM_MODE_FEATURE_DIRTYFB
785 if (ms->damage) {
786 DamageUnregister(&pScreen->GetScreenPixmap(pScreen)->drawable, ms->damage);
787 DamageDestroy(ms->damage);
788 ms->damage = NULL;
789 }
790 #endif
791
792 drmModeRmFB(ms->fd, ms->fb_id);
793 ms->destroy_front_buffer(pScrn);
794
795 if (ms->exa)
796 xorg_exa_close(pScrn);
797 ms->exa = NULL;
798
799 drv_close_resource_management(pScrn);
800
801 drmClose(ms->fd);
802 ms->fd = -1;
803
804 pScrn->vtSema = FALSE;
805 pScreen->CloseScreen = ms->CloseScreen;
806 return (*pScreen->CloseScreen) (scrnIndex, pScreen);
807 }
808
809 static ModeStatus
810 drv_valid_mode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
811 {
812 return MODE_OK;
813 }
814
815
816 /*
817 * Front buffer backing store functions.
818 */
819
820 static Bool
821 drv_destroy_front_buffer_ga3d(ScrnInfoPtr pScrn)
822 {
823 modesettingPtr ms = modesettingPTR(pScrn);
824 pipe_texture_reference(&ms->root_texture, NULL);
825 return TRUE;
826 }
827
828 static Bool
829 drv_create_front_buffer_ga3d(ScrnInfoPtr pScrn)
830 {
831 modesettingPtr ms = modesettingPTR(pScrn);
832 unsigned handle, stride;
833 struct pipe_texture *tex;
834
835 ms->noEvict = TRUE;
836
837 tex = xorg_exa_create_root_texture(pScrn, pScrn->virtualX, pScrn->virtualY,
838 pScrn->depth, pScrn->bitsPerPixel);
839
840 if (!tex)
841 return FALSE;
842
843 if (!ms->api->local_handle_from_texture(ms->api, ms->screen,
844 tex,
845 &stride,
846 &handle))
847 return FALSE;
848
849 drmModeAddFB(ms->fd,
850 pScrn->virtualX,
851 pScrn->virtualY,
852 pScrn->depth,
853 pScrn->bitsPerPixel,
854 stride,
855 handle,
856 &ms->fb_id);
857
858 pScrn->frameX0 = 0;
859 pScrn->frameY0 = 0;
860 drv_adjust_frame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
861
862 pipe_texture_reference(&ms->root_texture, tex);
863 pipe_texture_reference(&tex, NULL);
864
865 return TRUE;
866 }
867
868 static Bool
869 drv_bind_front_buffer_ga3d(ScrnInfoPtr pScrn)
870 {
871 modesettingPtr ms = modesettingPTR(pScrn);
872 ScreenPtr pScreen = pScrn->pScreen;
873 PixmapPtr rootPixmap = pScreen->GetScreenPixmap(pScreen);
874 struct pipe_texture *check;
875
876 xorg_exa_set_displayed_usage(rootPixmap);
877 xorg_exa_set_shared_usage(rootPixmap);
878 xorg_exa_set_texture(rootPixmap, ms->root_texture);
879 if (!pScreen->ModifyPixmapHeader(rootPixmap, -1, -1, -1, -1, -1, NULL))
880 FatalError("Couldn't adjust screen pixmap\n");
881
882 check = xorg_exa_get_texture(rootPixmap);
883 if (ms->root_texture != check)
884 FatalError("Created new root texture\n");
885
886 pipe_texture_reference(&check, NULL);
887 return TRUE;
888 }
889
890 #ifdef HAVE_LIBKMS
891 static Bool
892 drv_destroy_front_buffer_kms(ScrnInfoPtr pScrn)
893 {
894 modesettingPtr ms = modesettingPTR(pScrn);
895
896 if (!ms->root_bo)
897 return TRUE;
898
899 kms_bo_unmap(ms->root_bo);
900 kms_bo_destroy(&ms->root_bo);
901 return TRUE;
902 }
903
904 static Bool
905 drv_create_front_buffer_kms(ScrnInfoPtr pScrn)
906 {
907 modesettingPtr ms = modesettingPTR(pScrn);
908 unsigned handle, stride;
909 struct kms_bo *bo;
910 unsigned attr[8];
911
912 attr[0] = KMS_BO_TYPE;
913 attr[1] = KMS_BO_TYPE_SCANOUT;
914 attr[2] = KMS_WIDTH;
915 attr[3] = pScrn->virtualX;
916 attr[4] = KMS_HEIGHT;
917 attr[5] = pScrn->virtualY;
918 attr[6] = 0;
919
920 if (kms_bo_create(ms->kms, attr, &bo))
921 return FALSE;
922
923 if (kms_bo_get_prop(bo, KMS_PITCH, &stride))
924 goto err_destroy;
925
926 if (kms_bo_get_prop(bo, KMS_HANDLE, &handle))
927 goto err_destroy;
928
929 drmModeAddFB(ms->fd,
930 pScrn->virtualX,
931 pScrn->virtualY,
932 pScrn->depth,
933 pScrn->bitsPerPixel,
934 stride,
935 handle,
936 &ms->fb_id);
937
938 pScrn->frameX0 = 0;
939 pScrn->frameY0 = 0;
940 drv_adjust_frame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
941 ms->root_bo = bo;
942
943 return TRUE;
944
945 err_destroy:
946 kms_bo_destroy(&bo);
947 return FALSE;
948 }
949
950 static Bool
951 drv_bind_front_buffer_kms(ScrnInfoPtr pScrn)
952 {
953 modesettingPtr ms = modesettingPTR(pScrn);
954 ScreenPtr pScreen = pScrn->pScreen;
955 PixmapPtr rootPixmap = pScreen->GetScreenPixmap(pScreen);
956 unsigned stride;
957 void *ptr;
958
959 if (kms_bo_get_prop(ms->root_bo, KMS_PITCH, &stride))
960 return FALSE;
961
962 if (kms_bo_map(ms->root_bo, &ptr))
963 return FALSE;
964
965 pScreen->ModifyPixmapHeader(rootPixmap,
966 pScreen->width,
967 pScreen->height,
968 pScreen->rootDepth,
969 pScrn->bitsPerPixel,
970 stride,
971 ptr);
972 return TRUE;
973 }
974 #endif /* HAVE_LIBKMS */
975
976 static Bool drv_init_front_buffer_functions(ScrnInfoPtr pScrn)
977 {
978 modesettingPtr ms = modesettingPTR(pScrn);
979 if (ms->screen) {
980 ms->destroy_front_buffer = drv_destroy_front_buffer_ga3d;
981 ms->create_front_buffer = drv_create_front_buffer_ga3d;
982 ms->bind_front_buffer = drv_bind_front_buffer_ga3d;
983 #ifdef HAVE_LIBKMS
984 } else if (ms->kms) {
985 ms->destroy_front_buffer = drv_destroy_front_buffer_kms;
986 ms->create_front_buffer = drv_create_front_buffer_kms;
987 ms->bind_front_buffer = drv_bind_front_buffer_kms;
988 #endif
989 } else
990 return FALSE;
991
992 return TRUE;
993 }
994
995 /* vim: set sw=4 ts=8 sts=4: */