2 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
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:
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial portions
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.
26 * Author: Alan Hourihane <alanh@tungstengraphics.com>
27 * Author: Jakob Bornecrantz <wallbraker@gmail.com>
32 #include "xorg-server.h"
34 #include "xf86_OSproc.h"
36 #include "xf86PciInfo.h"
38 #include "mipointer.h"
40 #include <X11/extensions/randr.h>
45 #include "miscstruct.h"
46 #include "dixstruct.h"
48 #ifndef XSERVER_LIBPCIACCESS
49 #error "libpciaccess needed"
52 #include <pciaccess.h>
54 #include "pipe/p_context.h"
55 #include "xorg_tracker.h"
56 #include "xorg_winsys.h"
63 * Functions and symbols exported to Xorg via pointers.
66 static Bool
drv_pre_init(ScrnInfoPtr pScrn
, int flags
);
67 static Bool
drv_screen_init(int scrnIndex
, ScreenPtr pScreen
, int argc
,
69 static Bool
drv_switch_mode(int scrnIndex
, DisplayModePtr mode
, int flags
);
70 static void drv_adjust_frame(int scrnIndex
, int x
, int y
, int flags
);
71 static Bool
drv_enter_vt(int scrnIndex
, int flags
);
72 static void drv_leave_vt(int scrnIndex
, int flags
);
73 static void drv_free_screen(int scrnIndex
, int flags
);
74 static ModeStatus
drv_valid_mode(int scrnIndex
, DisplayModePtr mode
, Bool verbose
,
81 OPTION_DEBUG_FALLBACK
,
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 {OPTION_DEBUG_FALLBACK
, "DebugFallback", OPTV_BOOLEAN
, {0}, FALSE
},
88 {-1, NULL
, OPTV_NONE
, {0}, FALSE
}
93 * Exported Xorg driver functions to winsys
97 xorg_tracker_available_options(int chipid
, int busid
)
103 xorg_tracker_set_functions(ScrnInfoPtr scrn
)
105 scrn
->PreInit
= drv_pre_init
;
106 scrn
->ScreenInit
= drv_screen_init
;
107 scrn
->SwitchMode
= drv_switch_mode
;
108 scrn
->AdjustFrame
= drv_adjust_frame
;
109 scrn
->EnterVT
= drv_enter_vt
;
110 scrn
->LeaveVT
= drv_leave_vt
;
111 scrn
->FreeScreen
= drv_free_screen
;
112 scrn
->ValidMode
= drv_valid_mode
;
116 xorg_tracker_have_modesetting(ScrnInfoPtr pScrn
, struct pci_device
*device
)
118 char *BusID
= xalloc(64);
119 sprintf(BusID
, "pci:%04x:%02x:%02x.%d",
120 device
->domain
, device
->bus
,
121 device
->dev
, device
->func
);
123 if (drmCheckModesettingSupported(BusID
)) {
124 xf86DrvMsgVerb(pScrn
->scrnIndex
, X_INFO
, 0,
125 "Drm modesetting not supported %s\n", BusID
);
130 xf86DrvMsgVerb(pScrn
->scrnIndex
, X_INFO
, 0,
131 "Drm modesetting supported on %s\n", BusID
);
139 * Internal function definitions
142 static Bool
drv_init_front_buffer_functions(ScrnInfoPtr pScrn
);
143 static Bool
drv_close_screen(int scrnIndex
, ScreenPtr pScreen
);
144 static Bool
drv_save_hw_state(ScrnInfoPtr pScrn
);
145 static Bool
drv_restore_hw_state(ScrnInfoPtr pScrn
);
153 drv_get_rec(ScrnInfoPtr pScrn
)
155 if (pScrn
->driverPrivate
)
158 pScrn
->driverPrivate
= xnfcalloc(1, sizeof(modesettingRec
));
164 drv_free_rec(ScrnInfoPtr pScrn
)
169 if (!pScrn
->driverPrivate
)
172 xfree(pScrn
->driverPrivate
);
174 pScrn
->driverPrivate
= NULL
;
178 drv_probe_ddc(ScrnInfoPtr pScrn
, int index
)
180 ConfiguredMonitor
= NULL
;
184 drv_crtc_resize(ScrnInfoPtr pScrn
, int width
, int height
)
186 modesettingPtr ms
= modesettingPTR(pScrn
);
187 ScreenPtr pScreen
= pScrn
->pScreen
;
188 int old_width
, old_height
;
189 PixmapPtr rootPixmap
;
191 if (width
== pScrn
->virtualX
&& height
== pScrn
->virtualY
)
194 old_width
= pScrn
->virtualX
;
195 old_height
= pScrn
->virtualY
;
196 pScrn
->virtualX
= width
;
197 pScrn
->virtualY
= height
;
199 /* ms->create_front_buffer will remove the old front buffer */
201 rootPixmap
= pScreen
->GetScreenPixmap(pScreen
);
202 if (!pScreen
->ModifyPixmapHeader(rootPixmap
, width
, height
, -1, -1, -1, NULL
))
205 pScrn
->displayWidth
= rootPixmap
->devKind
/ (rootPixmap
->drawable
.bitsPerPixel
/ 8);
207 if (ms
->create_front_buffer(pScrn
) && ms
->bind_front_buffer(pScrn
))
211 * This is the error recovery path.
214 if (!pScreen
->ModifyPixmapHeader(rootPixmap
, old_width
, old_height
, -1, -1, -1, NULL
))
215 FatalError("failed to resize rootPixmap error path\n");
217 pScrn
->displayWidth
= rootPixmap
->devKind
/ (rootPixmap
->drawable
.bitsPerPixel
/ 8);
220 pScrn
->virtualX
= old_width
;
221 pScrn
->virtualY
= old_height
;
223 if (ms
->create_front_buffer(pScrn
) && ms
->bind_front_buffer(pScrn
))
226 FatalError("failed to setup old framebuffer\n");
230 static const xf86CrtcConfigFuncsRec crtc_config_funcs
= {
231 .resize
= drv_crtc_resize
235 drv_init_drm(ScrnInfoPtr pScrn
)
237 modesettingPtr ms
= modesettingPTR(pScrn
);
239 /* deal with server regeneration */
244 sprintf(BusID
, "PCI:%d:%d:%d",
245 ((ms
->PciInfo
->domain
<< 8) | ms
->PciInfo
->bus
),
246 ms
->PciInfo
->dev
, ms
->PciInfo
->func
250 ms
->api
= drm_api_create();
251 ms
->fd
= drmOpen(ms
->api
? ms
->api
->driver_name
: NULL
, BusID
);
257 if (ms
->api
&& ms
->api
->destroy
)
258 ms
->api
->destroy(ms
->api
);
269 drv_close_drm(ScrnInfoPtr pScrn
)
271 modesettingPtr ms
= modesettingPTR(pScrn
);
273 if (ms
->api
&& ms
->api
->destroy
)
274 ms
->api
->destroy(ms
->api
);
284 drv_init_resource_management(ScrnInfoPtr pScrn
)
286 modesettingPtr ms
= modesettingPTR(pScrn
);
288 ScreenPtr pScreen = pScrn->pScreen;
289 PixmapPtr rootPixmap = pScreen->GetScreenPixmap(pScreen);
290 Bool fbAccessDisabled;
294 if (ms
->screen
|| ms
->kms
)
298 ms
->screen
= ms
->api
->create_screen(ms
->api
, ms
->fd
, NULL
);
303 if (ms
->api
->destroy
)
304 ms
->api
->destroy(ms
->api
);
310 if (!kms_create(ms
->fd
, &ms
->kms
))
318 drv_close_resource_management(ScrnInfoPtr pScrn
)
320 modesettingPtr ms
= modesettingPTR(pScrn
);
324 assert(ms
->ctx
== NULL
);
326 for (i
= 0; i
< XORG_NR_FENCES
; i
++) {
328 ms
->screen
->fence_finish(ms
->screen
, ms
->fence
[i
], 0);
329 ms
->screen
->fence_reference(ms
->screen
, &ms
->fence
[i
], NULL
);
332 ms
->screen
->destroy(ms
->screen
);
338 kms_destroy(&ms
->kms
);
345 drv_pre_init(ScrnInfoPtr pScrn
, int flags
)
347 xf86CrtcConfigPtr xf86_config
;
349 rgb defaultWeight
= { 0, 0, 0 };
352 int max_width
, max_height
;
355 if (pScrn
->numEntities
!= 1)
358 pEnt
= xf86GetEntityInfo(pScrn
->entityList
[0]);
360 if (flags
& PROBE_DETECT
) {
361 drv_probe_ddc(pScrn
, pEnt
->index
);
365 cust
= (CustomizerPtr
) pScrn
->driverPrivate
;
366 pScrn
->driverPrivate
= NULL
;
368 /* Allocate driverPrivate */
369 if (!drv_get_rec(pScrn
))
372 ms
= modesettingPTR(pScrn
);
373 ms
->SaveGeneration
= -1;
377 pScrn
->displayWidth
= 640; /* default it */
379 if (ms
->pEnt
->location
.type
!= BUS_PCI
)
382 ms
->PciInfo
= xf86GetPciInfoForEntity(ms
->pEnt
->index
);
384 /* Allocate an entity private if necessary */
385 if (xf86IsEntityShared(pScrn
->entityList
[0])) {
386 FatalError("Entity");
388 msEnt
= xf86GetEntityPrivate(pScrn
->entityList
[0],
389 modesettingEntityIndex
)->ptr
;
390 ms
->entityPrivate
= msEnt
;
395 ms
->entityPrivate
= NULL
;
397 if (xf86IsEntityShared(pScrn
->entityList
[0])) {
398 if (xf86IsPrimInitDone(pScrn
->entityList
[0])) {
401 xf86SetPrimInitDone(pScrn
->entityList
[0]);
407 if (!drv_init_drm(pScrn
))
410 pScrn
->monitor
= pScrn
->confScreen
->monitor
;
411 pScrn
->progClock
= TRUE
;
416 PreferConvert24to32
| SupportConvert24to32
| Support32bppFb
))
419 switch (pScrn
->depth
) {
425 xf86DrvMsg(pScrn
->scrnIndex
, X_ERROR
,
426 "Given depth (%d) is not supported by the driver\n",
430 xf86PrintDepthBpp(pScrn
);
432 if (!xf86SetWeight(pScrn
, defaultWeight
, defaultWeight
))
434 if (!xf86SetDefaultVisual(pScrn
, -1))
437 /* Process the options */
438 xf86CollectOptions(pScrn
, NULL
);
439 if (!(ms
->Options
= xalloc(sizeof(drv_options
))))
441 memcpy(ms
->Options
, drv_options
, sizeof(drv_options
));
442 xf86ProcessOptions(pScrn
->scrnIndex
, pScrn
->options
, ms
->Options
);
444 /* Allocate an xf86CrtcConfig */
445 xf86CrtcConfigInit(pScrn
, &crtc_config_funcs
);
446 xf86_config
= XF86_CRTC_CONFIG_PTR(pScrn
);
448 max_width
= 2048; /* A very low default */
449 max_height
= 2048; /* see screen_init */
450 xf86CrtcSetSizeRange(pScrn
, 320, 200, max_width
, max_height
);
452 if (xf86ReturnOptValBool(ms
->Options
, OPTION_SW_CURSOR
, FALSE
)) {
456 drv_save_hw_state(pScrn
);
458 xorg_crtc_init(pScrn
);
459 xorg_output_init(pScrn
);
461 if (!xf86InitialConfiguration(pScrn
, TRUE
)) {
462 xf86DrvMsg(pScrn
->scrnIndex
, X_ERROR
, "No valid modes.\n");
463 drv_restore_hw_state(pScrn
);
467 drv_restore_hw_state(pScrn
);
470 * If the driver can do gamma correction, it should call xf86SetGamma() here.
473 Gamma zeros
= { 0.0, 0.0, 0.0 };
475 if (!xf86SetGamma(pScrn
, zeros
)) {
480 if (pScrn
->modes
== NULL
) {
481 xf86DrvMsg(pScrn
->scrnIndex
, X_ERROR
, "No modes.\n");
485 pScrn
->currentMode
= pScrn
->modes
;
487 /* Set display resolution */
488 xf86SetDpi(pScrn
, 0, 0);
490 /* Load the required sub modules */
491 if (!xf86LoadSubModule(pScrn
, "fb"))
494 /* XXX: these aren't needed when we are using libkms */
495 if (!xf86LoadSubModule(pScrn
, "exa"))
499 if (!xf86LoadSubModule(pScrn
, "dri2"))
507 drv_save_hw_state(ScrnInfoPtr pScrn
)
509 /*xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);*/
515 drv_restore_hw_state(ScrnInfoPtr pScrn
)
517 /*xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);*/
522 static void drv_block_handler(int i
, pointer blockData
, pointer pTimeout
,
525 ScreenPtr pScreen
= screenInfo
.screens
[i
];
526 modesettingPtr ms
= modesettingPTR(xf86Screens
[pScreen
->myNum
]);
528 pScreen
->BlockHandler
= ms
->blockHandler
;
529 pScreen
->BlockHandler(i
, blockData
, pTimeout
, pReadmask
);
530 pScreen
->BlockHandler
= drv_block_handler
;
535 ms
->ctx
->flush(ms
->ctx
, PIPE_FLUSH_RENDER_CACHE
, &ms
->fence
[XORG_NR_FENCES
-1]);
538 ms
->ctx
->screen
->fence_finish(ms
->ctx
->screen
, ms
->fence
[0], 0);
540 /* The amount of rendering generated by a block handler can be
541 * quite small. Let us get a fair way ahead of hardware before
544 for (j
= 0; j
< XORG_NR_FENCES
- 1; j
++)
545 ms
->screen
->fence_reference(ms
->screen
,
549 ms
->screen
->fence_reference(ms
->screen
,
550 &ms
->fence
[XORG_NR_FENCES
-1],
555 #ifdef DRM_MODE_FEATURE_DIRTYFB
557 RegionPtr dirty
= DamageRegion(ms
->damage
);
558 unsigned num_cliprects
= REGION_NUM_RECTS(dirty
);
561 drmModeClip
*clip
= alloca(num_cliprects
* sizeof(drmModeClip
));
562 BoxPtr rect
= REGION_RECTS(dirty
);
565 /* XXX no need for copy? */
566 for (i
= 0; i
< num_cliprects
; i
++, rect
++) {
567 clip
[i
].x1
= rect
->x1
;
568 clip
[i
].y1
= rect
->y1
;
569 clip
[i
].x2
= rect
->x2
;
570 clip
[i
].y2
= rect
->y2
;
573 /* TODO query connector property to see if this is needed */
574 ret
= drmModeDirtyFB(ms
->fd
, ms
->fb_id
, clip
, num_cliprects
);
576 debug_printf("%s: failed to send dirty (%i, %s)\n",
577 __func__
, ret
, strerror(-ret
));
580 DamageEmpty(ms
->damage
);
587 drv_create_screen_resources(ScreenPtr pScreen
)
589 ScrnInfoPtr pScrn
= xf86Screens
[pScreen
->myNum
];
590 modesettingPtr ms
= modesettingPTR(pScrn
);
591 PixmapPtr rootPixmap
;
596 pScreen
->CreateScreenResources
= ms
->createScreenResources
;
597 ret
= pScreen
->CreateScreenResources(pScreen
);
598 pScreen
->CreateScreenResources
= drv_create_screen_resources
;
600 ms
->bind_front_buffer(pScrn
);
604 drv_adjust_frame(pScrn
->scrnIndex
, pScrn
->frameX0
, pScrn
->frameY0
, 0);
606 #ifdef DRM_MODE_FEATURE_DIRTYFB
607 rootPixmap
= pScreen
->GetScreenPixmap(pScreen
);
608 ms
->damage
= DamageCreate(NULL
, NULL
, DamageReportNone
, TRUE
,
609 pScreen
, rootPixmap
);
612 DamageRegister(&rootPixmap
->drawable
, ms
->damage
);
614 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "Damage tracking initialized\n");
616 xf86DrvMsg(pScrn
->scrnIndex
, X_ERROR
,
617 "Failed to create screen damage record\n");
628 drv_screen_init(int scrnIndex
, ScreenPtr pScreen
, int argc
, char **argv
)
630 ScrnInfoPtr pScrn
= xf86Screens
[pScreen
->myNum
];
631 modesettingPtr ms
= modesettingPTR(pScrn
);
632 unsigned max_width
, max_height
;
634 CustomizerPtr cust
= ms
->cust
;
636 if (!drv_init_drm(pScrn
)) {
637 FatalError("Could not init DRM");
641 if (!drv_init_resource_management(pScrn
)) {
642 FatalError("Could not init resource management (!pipe_screen && !libkms)");
646 if (!drv_init_front_buffer_functions(pScrn
)) {
647 FatalError("Could not init front buffer manager");
651 /* get max width and height */
654 res
= drmModeGetResources(ms
->fd
);
655 max_width
= res
->max_width
;
656 max_height
= res
->max_height
;
657 drmModeFreeResources(res
);
663 maxf
= ms
->screen
->get_paramf(ms
->screen
, PIPE_CAP_MAX_TEXTURE_2D_LEVELS
);
664 max
= (1 << (int)(maxf
- 1.0f
));
665 max_width
= max
< max_width
? max
: max_width
;
666 max_height
= max
< max_height
? max
: max_height
;
669 xf86CrtcSetSizeRange(pScrn
, 1, 1, max_width
, max_height
);
671 pScrn
->pScreen
= pScreen
;
673 /* HW dependent - FIXME */
674 pScrn
->displayWidth
= pScrn
->virtualX
;
676 miClearVisualTypes();
678 if (!miSetVisualTypes(pScrn
->depth
,
679 miGetDefaultVisualMask(pScrn
->depth
),
680 pScrn
->rgbBits
, pScrn
->defaultVisual
))
683 if (!miSetPixmapDepths())
686 pScrn
->memPhysBase
= 0;
689 if (!fbScreenInit(pScreen
, NULL
,
690 pScrn
->virtualX
, pScrn
->virtualY
,
691 pScrn
->xDpi
, pScrn
->yDpi
,
692 pScrn
->displayWidth
, pScrn
->bitsPerPixel
))
695 if (pScrn
->bitsPerPixel
> 8) {
696 /* Fixup RGB ordering */
697 visual
= pScreen
->visuals
+ pScreen
->numVisuals
;
698 while (--visual
>= pScreen
->visuals
) {
699 if ((visual
->class | DynamicClass
) == DirectColor
) {
700 visual
->offsetRed
= pScrn
->offset
.red
;
701 visual
->offsetGreen
= pScrn
->offset
.green
;
702 visual
->offsetBlue
= pScrn
->offset
.blue
;
703 visual
->redMask
= pScrn
->mask
.red
;
704 visual
->greenMask
= pScrn
->mask
.green
;
705 visual
->blueMask
= pScrn
->mask
.blue
;
710 fbPictureInit(pScreen
, NULL
, 0);
712 ms
->blockHandler
= pScreen
->BlockHandler
;
713 pScreen
->BlockHandler
= drv_block_handler
;
714 ms
->createScreenResources
= pScreen
->CreateScreenResources
;
715 pScreen
->CreateScreenResources
= drv_create_screen_resources
;
717 xf86SetBlackWhitePixels(pScreen
);
719 ms
->accelerate_2d
= xf86ReturnOptValBool(ms
->Options
, OPTION_2D_ACCEL
, FALSE
);
720 ms
->debug_fallback
= xf86ReturnOptValBool(ms
->Options
, OPTION_DEBUG_FALLBACK
, ms
->accelerate_2d
);
723 ms
->exa
= xorg_exa_init(pScrn
, ms
->accelerate_2d
);
725 xorg_xv_init(pScreen
);
727 xorg_dri2_init(pScreen
);
731 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "##################################\n");
732 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "# Usefull debugging info follows #\n");
733 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "##################################\n");
734 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "Using %s backend\n",
735 ms
->screen
? "Gallium3D" : "libkms");
736 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "2D Acceleration is %s\n",
737 ms
->screen
&& ms
->accelerate_2d
? "enabled" : "disabled");
738 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "Fallback debugging is %s\n",
739 ms
->debug_fallback
? "enabled" : "disabled");
741 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "3D Acceleration is %s\n",
742 ms
->screen
? "enabled" : "disabled");
744 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "3D Acceleration is disabled\n");
746 xf86DrvMsg(pScrn
->scrnIndex
, X_INFO
, "##################################\n");
748 miInitializeBackingStore(pScreen
);
749 xf86SetBackingStore(pScreen
);
750 xf86SetSilkenMouse(pScreen
);
751 miDCInitialize(pScreen
, xf86GetPointerScreenFuncs());
753 /* Need to extend HWcursor support to handle mask interleave */
755 xf86_cursors_init(pScreen
, 64, 64,
756 HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64
|
757 HARDWARE_CURSOR_ARGB
);
759 /* Must force it before EnterVT, so we are in control of VT and
760 * later memory should be bound when allocating, e.g rotate_mem */
761 pScrn
->vtSema
= TRUE
;
763 pScreen
->SaveScreen
= xf86SaveScreen
;
764 ms
->CloseScreen
= pScreen
->CloseScreen
;
765 pScreen
->CloseScreen
= drv_close_screen
;
767 if (!xf86CrtcScreenInit(pScreen
))
770 if (!miCreateDefColormap(pScreen
))
773 xf86DPMSInit(pScreen
, xf86DPMSSet
, 0);
775 if (serverGeneration
== 1)
776 xf86ShowUnusedOptions(pScrn
->scrnIndex
, pScrn
->options
);
778 if (cust
&& cust
->winsys_screen_init
)
779 cust
->winsys_screen_init(cust
, ms
->fd
);
781 return drv_enter_vt(scrnIndex
, 1);
785 drv_adjust_frame(int scrnIndex
, int x
, int y
, int flags
)
787 ScrnInfoPtr pScrn
= xf86Screens
[scrnIndex
];
788 xf86CrtcConfigPtr config
= XF86_CRTC_CONFIG_PTR(pScrn
);
789 xf86OutputPtr output
= config
->output
[config
->compat_output
];
790 xf86CrtcPtr crtc
= output
->crtc
;
792 if (crtc
&& crtc
->enabled
) {
793 crtc
->funcs
->set_mode_major(crtc
, pScrn
->currentMode
,
795 crtc
->x
= output
->initial_x
+ x
;
796 crtc
->y
= output
->initial_y
+ y
;
801 drv_free_screen(int scrnIndex
, int flags
)
803 drv_free_rec(xf86Screens
[scrnIndex
]);
807 drv_leave_vt(int scrnIndex
, int flags
)
809 ScrnInfoPtr pScrn
= xf86Screens
[scrnIndex
];
810 modesettingPtr ms
= modesettingPTR(pScrn
);
811 xf86CrtcConfigPtr config
= XF86_CRTC_CONFIG_PTR(pScrn
);
812 CustomizerPtr cust
= ms
->cust
;
815 if (cust
&& cust
->winsys_leave_vt
)
816 cust
->winsys_leave_vt(cust
);
818 for (o
= 0; o
< config
->num_crtc
; o
++) {
819 xf86CrtcPtr crtc
= config
->crtc
[o
];
821 xorg_crtc_cursor_destroy(crtc
);
823 if (crtc
->rotatedPixmap
|| crtc
->rotatedData
) {
824 crtc
->funcs
->shadow_destroy(crtc
, crtc
->rotatedPixmap
,
826 crtc
->rotatedPixmap
= NULL
;
827 crtc
->rotatedData
= NULL
;
831 drmModeRmFB(ms
->fd
, ms
->fb_id
);
834 drv_restore_hw_state(pScrn
);
836 if (drmDropMaster(ms
->fd
))
837 xf86DrvMsg(pScrn
->scrnIndex
, X_WARNING
,
838 "drmDropMaster failed: %s\n", strerror(errno
));
840 pScrn
->vtSema
= FALSE
;
844 * This gets called when gaining control of the VT, and from ScreenInit().
847 drv_enter_vt(int scrnIndex
, int flags
)
849 ScrnInfoPtr pScrn
= xf86Screens
[scrnIndex
];
850 modesettingPtr ms
= modesettingPTR(pScrn
);
851 CustomizerPtr cust
= ms
->cust
;
853 if (drmSetMaster(ms
->fd
)) {
854 if (errno
== EINVAL
) {
855 xf86DrvMsg(pScrn
->scrnIndex
, X_WARNING
,
856 "drmSetMaster failed: 2.6.29 or newer kernel required for "
857 "multi-server DRI\n");
859 xf86DrvMsg(pScrn
->scrnIndex
, X_WARNING
,
860 "drmSetMaster failed: %s\n", strerror(errno
));
865 * Only save state once per server generation since that's what most
866 * drivers do. Could change this to save state at each VT enter.
868 if (ms
->SaveGeneration
!= serverGeneration
) {
869 ms
->SaveGeneration
= serverGeneration
;
870 drv_save_hw_state(pScrn
);
873 if (!ms
->create_front_buffer(pScrn
))
876 if (!flags
&& !ms
->bind_front_buffer(pScrn
))
879 if (!xf86SetDesiredModes(pScrn
))
882 if (cust
&& cust
->winsys_enter_vt
)
883 cust
->winsys_enter_vt(cust
);
889 drv_switch_mode(int scrnIndex
, DisplayModePtr mode
, int flags
)
891 ScrnInfoPtr pScrn
= xf86Screens
[scrnIndex
];
893 return xf86SetSingleMode(pScrn
, mode
, RR_Rotate_0
);
897 drv_close_screen(int scrnIndex
, ScreenPtr pScreen
)
899 ScrnInfoPtr pScrn
= xf86Screens
[scrnIndex
];
900 modesettingPtr ms
= modesettingPTR(pScrn
);
901 CustomizerPtr cust
= ms
->cust
;
904 drv_leave_vt(scrnIndex
, 0);
907 if (cust
&& cust
->winsys_screen_close
)
908 cust
->winsys_screen_close(cust
);
912 xorg_dri2_close(pScreen
);
915 pScreen
->BlockHandler
= ms
->blockHandler
;
916 pScreen
->CreateScreenResources
= ms
->createScreenResources
;
918 #ifdef DRM_MODE_FEATURE_DIRTYFB
920 DamageUnregister(&pScreen
->GetScreenPixmap(pScreen
)->drawable
, ms
->damage
);
921 DamageDestroy(ms
->damage
);
926 drmModeRmFB(ms
->fd
, ms
->fb_id
);
927 ms
->destroy_front_buffer(pScrn
);
930 xorg_exa_close(pScrn
);
933 drv_close_resource_management(pScrn
);
935 drv_close_drm(pScrn
);
937 pScrn
->vtSema
= FALSE
;
938 pScreen
->CloseScreen
= ms
->CloseScreen
;
939 return (*pScreen
->CloseScreen
) (scrnIndex
, pScreen
);
943 drv_valid_mode(int scrnIndex
, DisplayModePtr mode
, Bool verbose
, int flags
)
950 * Front buffer backing store functions.
954 drv_destroy_front_buffer_ga3d(ScrnInfoPtr pScrn
)
956 modesettingPtr ms
= modesettingPTR(pScrn
);
961 if (ms
->fb_id
!= -1) {
962 drmModeRmFB(ms
->fd
, ms
->fb_id
);
966 pipe_texture_reference(&ms
->root_texture
, NULL
);
971 drv_create_front_buffer_ga3d(ScrnInfoPtr pScrn
)
973 modesettingPtr ms
= modesettingPTR(pScrn
);
974 unsigned handle
, stride
, fb_id
;
975 struct pipe_texture
*tex
;
980 tex
= xorg_exa_create_root_texture(pScrn
, pScrn
->virtualX
, pScrn
->virtualY
,
981 pScrn
->depth
, pScrn
->bitsPerPixel
);
986 if (!ms
->api
->local_handle_from_texture(ms
->api
, ms
->screen
,
992 ret
= drmModeAddFB(ms
->fd
,
1001 debug_printf("%s: failed to create framebuffer (%i, %s)\n",
1002 __func__
, ret
, strerror(-ret
));
1006 if (!drv_destroy_front_buffer_ga3d(pScrn
))
1007 FatalError("%s: failed to take down old framebuffer\n", __func__
);
1011 drv_adjust_frame(pScrn
->scrnIndex
, pScrn
->frameX0
, pScrn
->frameY0
, 0);
1013 pipe_texture_reference(&ms
->root_texture
, tex
);
1014 pipe_texture_reference(&tex
, NULL
);
1020 pipe_texture_reference(&tex
, NULL
);
1025 drv_bind_front_buffer_ga3d(ScrnInfoPtr pScrn
)
1027 modesettingPtr ms
= modesettingPTR(pScrn
);
1028 ScreenPtr pScreen
= pScrn
->pScreen
;
1029 PixmapPtr rootPixmap
= pScreen
->GetScreenPixmap(pScreen
);
1030 struct pipe_texture
*check
;
1032 xorg_exa_set_displayed_usage(rootPixmap
);
1033 xorg_exa_set_shared_usage(rootPixmap
);
1034 xorg_exa_set_texture(rootPixmap
, ms
->root_texture
);
1035 if (!pScreen
->ModifyPixmapHeader(rootPixmap
, -1, -1, -1, -1, -1, NULL
))
1036 FatalError("Couldn't adjust screen pixmap\n");
1038 check
= xorg_exa_get_texture(rootPixmap
);
1039 if (ms
->root_texture
!= check
)
1040 FatalError("Created new root texture\n");
1042 pipe_texture_reference(&check
, NULL
);
1048 drv_destroy_front_buffer_kms(ScrnInfoPtr pScrn
)
1050 modesettingPtr ms
= modesettingPTR(pScrn
);
1051 ScreenPtr pScreen
= pScrn
->pScreen
;
1052 PixmapPtr rootPixmap
= pScreen
->GetScreenPixmap(pScreen
);
1054 /* XXX Do something with the rootPixmap.
1055 * This currently works fine but if we are getting crashes in
1056 * the fb functions after VT switches maybe look more into it.
1063 if (ms
->fb_id
!= -1) {
1064 drmModeRmFB(ms
->fd
, ms
->fb_id
);
1068 kms_bo_unmap(ms
->root_bo
);
1069 kms_bo_destroy(&ms
->root_bo
);
1074 drv_create_front_buffer_kms(ScrnInfoPtr pScrn
)
1076 modesettingPtr ms
= modesettingPTR(pScrn
);
1077 unsigned handle
, stride
;
1083 attr
[0] = KMS_BO_TYPE
;
1084 #ifdef KMS_BO_TYPE_SCANOUT_X8R8G8B8
1085 attr
[1] = KMS_BO_TYPE_SCANOUT_X8R8G8B8
;
1087 attr
[1] = KMS_BO_TYPE_SCANOUT
;
1089 attr
[2] = KMS_WIDTH
;
1090 attr
[3] = pScrn
->virtualX
;
1091 attr
[4] = KMS_HEIGHT
;
1092 attr
[5] = pScrn
->virtualY
;
1095 if (kms_bo_create(ms
->kms
, attr
, &bo
))
1098 if (kms_bo_get_prop(bo
, KMS_PITCH
, &stride
))
1101 if (kms_bo_get_prop(bo
, KMS_HANDLE
, &handle
))
1104 ret
= drmModeAddFB(ms
->fd
,
1108 pScrn
->bitsPerPixel
,
1113 debug_printf("%s: failed to create framebuffer (%i, %s)",
1114 __func__
, ret
, strerror(-ret
));
1118 if (!drv_destroy_front_buffer_kms(pScrn
))
1119 FatalError("%s: could not takedown old bo", __func__
);
1123 drv_adjust_frame(pScrn
->scrnIndex
, pScrn
->frameX0
, pScrn
->frameY0
, 0);
1130 kms_bo_destroy(&bo
);
1135 drv_bind_front_buffer_kms(ScrnInfoPtr pScrn
)
1137 modesettingPtr ms
= modesettingPTR(pScrn
);
1138 ScreenPtr pScreen
= pScrn
->pScreen
;
1139 PixmapPtr rootPixmap
= pScreen
->GetScreenPixmap(pScreen
);
1143 if (kms_bo_get_prop(ms
->root_bo
, KMS_PITCH
, &stride
))
1146 if (kms_bo_map(ms
->root_bo
, &ptr
))
1149 pScreen
->ModifyPixmapHeader(rootPixmap
,
1153 pScrn
->bitsPerPixel
,
1157 /* This a hack to work around EnableDisableFBAccess setting the pointer
1158 * the real fix would be to replace pScrn->EnableDisableFBAccess hook
1159 * and set the rootPixmap->devPrivate.ptr to something valid before that.
1161 * But in its infinit visdome something uses either this some times before
1162 * that, so our hook doesn't get called before the crash happens.
1164 pScrn
->pixmapPrivate
.ptr
= ptr
;
1169 kms_bo_destroy(&ms
->root_bo
);
1172 #endif /* HAVE_LIBKMS */
1174 static Bool
drv_init_front_buffer_functions(ScrnInfoPtr pScrn
)
1176 modesettingPtr ms
= modesettingPTR(pScrn
);
1178 ms
->destroy_front_buffer
= drv_destroy_front_buffer_ga3d
;
1179 ms
->create_front_buffer
= drv_create_front_buffer_ga3d
;
1180 ms
->bind_front_buffer
= drv_bind_front_buffer_ga3d
;
1182 } else if (ms
->kms
) {
1183 ms
->destroy_front_buffer
= drv_destroy_front_buffer_kms
;
1184 ms
->create_front_buffer
= drv_create_front_buffer_kms
;
1185 ms
->bind_front_buffer
= drv_bind_front_buffer_kms
;
1193 CustomizerPtr
xorg_customizer(ScrnInfoPtr pScrn
)
1195 return modesettingPTR(pScrn
)->cust
;
1198 Bool
xorg_has_gallium(ScrnInfoPtr pScrn
)
1200 return modesettingPTR(pScrn
)->screen
!= NULL
;
1203 /* vim: set sw=4 ts=8 sts=4: */