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     ms->kms = NULL;
 265 #endif
 266
 267     return TRUE;
 268 }
 269
 270 static Bool
 271 drv_pre_init(ScrnInfoPtr pScrn, int flags)
 272 {
 273     xf86CrtcConfigPtr xf86_config;
 274     modesettingPtr ms;
 275     rgb defaultWeight = { 0, 0, 0 };
 276     EntityInfoPtr pEnt;
 277     EntPtr msEnt = NULL;
 278     int max_width, max_height;
 279
 280     if (pScrn->numEntities != 1)
 281         return FALSE;
 282
 283     pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
 284
 285     if (flags & PROBE_DETECT) {
 286         drv_probe_ddc(pScrn, pEnt->index);
 287         return TRUE;
 288     }
 289
 290     /* Allocate driverPrivate */
 291     if (!drv_get_rec(pScrn))
 292         return FALSE;
 293
 294     ms = modesettingPTR(pScrn);
 295     ms->SaveGeneration = -1;
 296     ms->pEnt = pEnt;
 297
 298     pScrn->displayWidth = 640;         /* default it */
 299
 300     if (ms->pEnt->location.type != BUS_PCI)
 301         return FALSE;
 302
 303     ms->PciInfo = xf86GetPciInfoForEntity(ms->pEnt->index);
 304
 305     /* Allocate an entity private if necessary */
 306     if (xf86IsEntityShared(pScrn->entityList[0])) {
 307         FatalError("Entity");
 308 #if 0
 309         msEnt = xf86GetEntityPrivate(pScrn->entityList[0],
 310                                      modesettingEntityIndex)->ptr;
 311         ms->entityPrivate = msEnt;
 312 #else
 313         (void)msEnt;
 314 #endif
 315     } else
 316         ms->entityPrivate = NULL;
 317
 318     if (xf86IsEntityShared(pScrn->entityList[0])) {
 319         if (xf86IsPrimInitDone(pScrn->entityList[0])) {
 320             /* do something */
 321         } else {
 322             xf86SetPrimInitDone(pScrn->entityList[0]);
 323         }
 324     }
 325
 326     ms->fd = -1;
 327     ms->api = NULL;
 328     if (!drv_init_drm(pScrn))
 329         return FALSE;
 330
 331     pScrn->monitor = pScrn->confScreen->monitor;
 332     pScrn->progClock = TRUE;
 333     pScrn->rgbBits = 8;
 334
 335     if (!xf86SetDepthBpp
 336         (pScrn, 0, 0, 0,
 337          PreferConvert24to32 | SupportConvert24to32 | Support32bppFb))
 338         return FALSE;
 339
 340     switch (pScrn->depth) {
 341     case 15:
 342     case 16:
 343     case 24:
 344         break;
 345     default:
 346         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 347                    "Given depth (%d) is not supported by the driver\n",
 348                    pScrn->depth);
 349         return FALSE;
 350     }
 351     xf86PrintDepthBpp(pScrn);
 352
 353     if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight))
 354         return FALSE;
 355     if (!xf86SetDefaultVisual(pScrn, -1))
 356         return FALSE;
 357
 358     /* Process the options */
 359     xf86CollectOptions(pScrn, NULL);
 360     if (!(ms->Options = xalloc(sizeof(drv_options))))
 361         return FALSE;
 362     memcpy(ms->Options, drv_options, sizeof(drv_options));
 363     xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, ms->Options);
 364
 365     /* Allocate an xf86CrtcConfig */
 366     xf86CrtcConfigInit(pScrn, &crtc_config_funcs);
 367     xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
 368
 369     max_width = 8192;
 370     max_height = 8192;
 371     xf86CrtcSetSizeRange(pScrn, 320, 200, max_width, max_height);
 372
 373     if (xf86ReturnOptValBool(ms->Options, OPTION_SW_CURSOR, FALSE)) {
 374         ms->SWCursor = TRUE;
 375     }
 376
 377     drv_save_hw_state(pScrn);
 378
 379     xorg_crtc_init(pScrn);
 380     xorg_output_init(pScrn);
 381
 382     if (!xf86InitialConfiguration(pScrn, TRUE)) {
 383         xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes.\n");
 384         drv_restore_hw_state(pScrn);
 385         return FALSE;
 386     }
 387
 388     drv_restore_hw_state(pScrn);
 389
 390     /*
 391      * If the driver can do gamma correction, it should call xf86SetGamma() here.
 392      */
 393     {
 394         Gamma zeros = { 0.0, 0.0, 0.0 };
 395
 396         if (!xf86SetGamma(pScrn, zeros)) {
 397             return FALSE;
 398         }
 399     }
 400
 401     if (pScrn->modes == NULL) {
 402         xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No modes.\n");
 403         return FALSE;
 404     }
 405
 406     pScrn->currentMode = pScrn->modes;
 407
 408     /* Set display resolution */
 409     xf86SetDpi(pScrn, 0, 0);
 410
 411     /* Load the required sub modules */
 412     if (!xf86LoadSubModule(pScrn, "fb"))
 413         return FALSE;
 414
 415     /* XXX: these aren't needed when we are using libkms */
 416     if (!xf86LoadSubModule(pScrn, "exa"))
 417         return FALSE;
 418
 419 #ifdef DRI2
 420     if (!xf86LoadSubModule(pScrn, "dri2"))
 421         return FALSE;
 422 #endif
 423
 424     return TRUE;
 425 }
 426
 427 static Bool
 428 drv_save_hw_state(ScrnInfoPtr pScrn)
 429 {
 430     /*xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);*/
 431
 432     return TRUE;
 433 }
 434
 435 static Bool
 436 drv_restore_hw_state(ScrnInfoPtr pScrn)
 437 {
 438     /*xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);*/
 439
 440     return TRUE;
 441 }
 442
 443 static void drv_block_handler(int i, pointer blockData, pointer pTimeout,
 444                               pointer pReadmask)
 445 {
 446     ScreenPtr pScreen = screenInfo.screens[i];
 447     modesettingPtr ms = modesettingPTR(xf86Screens[pScreen->myNum]);
 448
 449     pScreen->BlockHandler = ms->blockHandler;
 450     pScreen->BlockHandler(i, blockData, pTimeout, pReadmask);
 451     pScreen->BlockHandler = drv_block_handler;
 452
 453     if (ms->ctx) {
 454        int j;
 455
 456        ms->ctx->flush(ms->ctx, PIPE_FLUSH_RENDER_CACHE, &ms->fence[XORG_NR_FENCES-1]);
 457
 458        if (ms->fence[0])
 459           ms->ctx->screen->fence_finish(ms->ctx->screen, ms->fence[0], 0);
 460
 461        /* The amount of rendering generated by a block handler can be
 462         * quite small.  Let us get a fair way ahead of hardware before
 463         * throttling.
 464         */
 465        for (j = 0; j < XORG_NR_FENCES; j++)
 466           ms->screen->fence_reference(ms->screen,
 467                                       &ms->fence[j],
 468                                       ms->fence[j+1]);
 469
 470        ms->screen->fence_reference(ms->screen,
 471                                    &ms->fence[XORG_NR_FENCES-1],
 472                                    NULL);
 473     }
 474
 475
 476 #ifdef DRM_MODE_FEATURE_DIRTYFB
 477     {
 478         RegionPtr dirty = DamageRegion(ms->damage);
 479         unsigned num_cliprects = REGION_NUM_RECTS(dirty);
 480
 481         if (num_cliprects) {
 482             drmModeClip *clip = alloca(num_cliprects * sizeof(drmModeClip));
 483             BoxPtr rect = REGION_RECTS(dirty);
 484             int i;
 485
 486             /* XXX no need for copy? */
 487             for (i = 0; i < num_cliprects; i++, rect++) {
 488                 clip[i].x1 = rect->x1;
 489                 clip[i].y1 = rect->y1;
 490                 clip[i].x2 = rect->x2;
 491                 clip[i].y2 = rect->y2;
 492             }
 493
 494             /* TODO query connector property to see if this is needed */
 495             drmModeDirtyFB(ms->fd, ms->fb_id, clip, num_cliprects);
 496
 497             DamageEmpty(ms->damage);
 498         }
 499     }
 500 #endif
 501 }
 502
 503 static Bool
 504 drv_create_screen_resources(ScreenPtr pScreen)
 505 {
 506     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 507     modesettingPtr ms = modesettingPTR(pScrn);
 508     PixmapPtr rootPixmap;
 509     Bool ret;
 510
 511     ms->noEvict = TRUE;
 512
 513     pScreen->CreateScreenResources = ms->createScreenResources;
 514     ret = pScreen->CreateScreenResources(pScreen);
 515     pScreen->CreateScreenResources = drv_create_screen_resources;
 516
 517     ms->bind_front_buffer(pScrn);
 518
 519     ms->noEvict = FALSE;
 520
 521     drv_adjust_frame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 522
 523 #ifdef DRM_MODE_FEATURE_DIRTYFB
 524     rootPixmap = pScreen->GetScreenPixmap(pScreen);
 525     ms->damage = DamageCreate(NULL, NULL, DamageReportNone, TRUE,
 526                               pScreen, rootPixmap);
 527
 528     if (ms->damage) {
 529        DamageRegister(&rootPixmap->drawable, ms->damage);
 530
 531        xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Damage tracking initialized\n");
 532     } else {
 533        xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 534                   "Failed to create screen damage record\n");
 535        return FALSE;
 536     }
 537 #else
 538     (void)rootPixmap;
 539 #endif
 540
 541     return ret;
 542 }
 543
 544 static Bool
 545 drv_screen_init(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
 546 {
 547     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 548     modesettingPtr ms = modesettingPTR(pScrn);
 549     VisualPtr visual;
 550
 551     if (!drv_init_drm(pScrn)) {
 552         FatalError("Could not init DRM");
 553         return FALSE;
 554     }
 555
 556     if (!drv_init_resource_management(pScrn)) {
 557         FatalError("Could not init resource management (!pipe_screen && !libkms)");
 558         return FALSE;
 559     }
 560
 561     if (!drv_init_front_buffer_functions(pScrn)) {
 562         FatalError("Could not init front buffer manager");
 563         return FALSE;
 564     }
 565
 566     pScrn->pScreen = pScreen;
 567
 568     /* HW dependent - FIXME */
 569     pScrn->displayWidth = pScrn->virtualX;
 570
 571     miClearVisualTypes();
 572
 573     if (!miSetVisualTypes(pScrn->depth,
 574                           miGetDefaultVisualMask(pScrn->depth),
 575                           pScrn->rgbBits, pScrn->defaultVisual))
 576         return FALSE;
 577
 578     if (!miSetPixmapDepths())
 579         return FALSE;
 580
 581     pScrn->memPhysBase = 0;
 582     pScrn->fbOffset = 0;
 583
 584     if (!fbScreenInit(pScreen, NULL,
 585                       pScrn->virtualX, pScrn->virtualY,
 586                       pScrn->xDpi, pScrn->yDpi,
 587                       pScrn->displayWidth, pScrn->bitsPerPixel))
 588         return FALSE;
 589
 590     if (pScrn->bitsPerPixel > 8) {
 591         /* Fixup RGB ordering */
 592         visual = pScreen->visuals + pScreen->numVisuals;
 593         while (--visual >= pScreen->visuals) {
 594             if ((visual->class | DynamicClass) == DirectColor) {
 595                 visual->offsetRed = pScrn->offset.red;
 596                 visual->offsetGreen = pScrn->offset.green;
 597                 visual->offsetBlue = pScrn->offset.blue;
 598                 visual->redMask = pScrn->mask.red;
 599                 visual->greenMask = pScrn->mask.green;
 600                 visual->blueMask = pScrn->mask.blue;
 601             }
 602         }
 603     }
 604
 605     fbPictureInit(pScreen, NULL, 0);
 606
 607     ms->blockHandler = pScreen->BlockHandler;
 608     pScreen->BlockHandler = drv_block_handler;
 609     ms->createScreenResources = pScreen->CreateScreenResources;
 610     pScreen->CreateScreenResources = drv_create_screen_resources;
 611
 612     xf86SetBlackWhitePixels(pScreen);
 613
 614     if (ms->screen) {
 615         ms->exa = xorg_exa_init(pScrn, xf86ReturnOptValBool(ms->Options,
 616                                                             OPTION_2D_ACCEL, TRUE));
 617         ms->debug_fallback = debug_get_bool_option("XORG_DEBUG_FALLBACK", TRUE);
 618
 619         xorg_xv_init(pScreen);
 620 #ifdef DRI2
 621         xorg_dri2_init(pScreen);
 622 #endif
 623     }
 624
 625     miInitializeBackingStore(pScreen);
 626     xf86SetBackingStore(pScreen);
 627     xf86SetSilkenMouse(pScreen);
 628     miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
 629
 630     /* Need to extend HWcursor support to handle mask interleave */
 631     if (!ms->SWCursor)
 632         xf86_cursors_init(pScreen, 64, 64,
 633                           HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64 |
 634                           HARDWARE_CURSOR_ARGB);
 635
 636     /* Must force it before EnterVT, so we are in control of VT and
 637      * later memory should be bound when allocating, e.g rotate_mem */
 638     pScrn->vtSema = TRUE;
 639
 640     pScreen->SaveScreen = xf86SaveScreen;
 641     ms->CloseScreen = pScreen->CloseScreen;
 642     pScreen->CloseScreen = drv_close_screen;
 643
 644     if (!xf86CrtcScreenInit(pScreen))
 645         return FALSE;
 646
 647     if (!miCreateDefColormap(pScreen))
 648         return FALSE;
 649
 650     xf86DPMSInit(pScreen, xf86DPMSSet, 0);
 651
 652     if (serverGeneration == 1)
 653         xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
 654
 655     if (ms->winsys_screen_init)
 656         ms->winsys_screen_init(pScrn);
 657
 658     return drv_enter_vt(scrnIndex, 1);
 659 }
 660
 661 static void
 662 drv_adjust_frame(int scrnIndex, int x, int y, int flags)
 663 {
 664     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 665     xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 666     xf86OutputPtr output = config->output[config->compat_output];
 667     xf86CrtcPtr crtc = output->crtc;
 668
 669     if (crtc && crtc->enabled) {
 670         crtc->funcs->set_mode_major(crtc, pScrn->currentMode,
 671                                     RR_Rotate_0, x, y);
 672         crtc->x = output->initial_x + x;
 673         crtc->y = output->initial_y + y;
 674     }
 675 }
 676
 677 static void
 678 drv_free_screen(int scrnIndex, int flags)
 679 {
 680     drv_free_rec(xf86Screens[scrnIndex]);
 681 }
 682
 683 static void
 684 drv_leave_vt(int scrnIndex, int flags)
 685 {
 686     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 687     modesettingPtr ms = modesettingPTR(pScrn);
 688     xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 689     int o;
 690
 691     for (o = 0; o < config->num_crtc; o++) {
 692         xf86CrtcPtr crtc = config->crtc[o];
 693
 694         xorg_crtc_cursor_destroy(crtc);
 695
 696         if (crtc->rotatedPixmap || crtc->rotatedData) {
 697             crtc->funcs->shadow_destroy(crtc, crtc->rotatedPixmap,
 698                                         crtc->rotatedData);
 699             crtc->rotatedPixmap = NULL;
 700             crtc->rotatedData = NULL;
 701         }
 702     }
 703
 704     drmModeRmFB(ms->fd, ms->fb_id);
 705
 706     drv_restore_hw_state(pScrn);
 707
 708     if (drmDropMaster(ms->fd))
 709         xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 710                    "drmDropMaster failed: %s\n", strerror(errno));
 711
 712     pScrn->vtSema = FALSE;
 713 }
 714
 715 /*
 716  * This gets called when gaining control of the VT, and from ScreenInit().
 717  */
 718 static Bool
 719 drv_enter_vt(int scrnIndex, int flags)
 720 {
 721     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 722     modesettingPtr ms = modesettingPTR(pScrn);
 723
 724     if (drmSetMaster(ms->fd)) {
 725         if (errno == EINVAL) {
 726             xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 727                        "drmSetMaster failed: 2.6.29 or newer kernel required for "
 728                        "multi-server DRI\n");
 729         } else {
 730             xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 731                        "drmSetMaster failed: %s\n", strerror(errno));
 732         }
 733     }
 734
 735     /*
 736      * Only save state once per server generation since that's what most
 737      * drivers do.  Could change this to save state at each VT enter.
 738      */
 739     if (ms->SaveGeneration != serverGeneration) {
 740         ms->SaveGeneration = serverGeneration;
 741         drv_save_hw_state(pScrn);
 742     }
 743
 744     if (!ms->create_front_buffer(pScrn))
 745         return FALSE;
 746
 747     if (!flags && !ms->bind_front_buffer(pScrn))
 748         return FALSE;
 749
 750     if (!xf86SetDesiredModes(pScrn))
 751         return FALSE;
 752
 753     return TRUE;
 754 }
 755
 756 static Bool
 757 drv_switch_mode(int scrnIndex, DisplayModePtr mode, int flags)
 758 {
 759     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 760
 761     return xf86SetSingleMode(pScrn, mode, RR_Rotate_0);
 762 }
 763
 764 static Bool
 765 drv_close_screen(int scrnIndex, ScreenPtr pScreen)
 766 {
 767     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 768     modesettingPtr ms = modesettingPTR(pScrn);
 769
 770     if (pScrn->vtSema) {
 771         drv_leave_vt(scrnIndex, 0);
 772     }
 773
 774     if (ms->winsys_screen_close)
 775         ms->winsys_screen_close(pScrn);
 776
 777 #ifdef DRI2
 778     if (ms->screen)
 779         xorg_dri2_close(pScreen);
 780 #endif
 781
 782     pScreen->BlockHandler = ms->blockHandler;
 783     pScreen->CreateScreenResources = ms->createScreenResources;
 784
 785 #ifdef DRM_MODE_FEATURE_DIRTYFB
 786     if (ms->damage) {
 787         DamageUnregister(&pScreen->GetScreenPixmap(pScreen)->drawable, ms->damage);
 788         DamageDestroy(ms->damage);
 789         ms->damage = NULL;
 790     }
 791 #endif
 792
 793     drmModeRmFB(ms->fd, ms->fb_id);
 794     ms->destroy_front_buffer(pScrn);
 795
 796     if (ms->exa)
 797         xorg_exa_close(pScrn);
 798     ms->exa = NULL;
 799
 800     drv_close_resource_management(pScrn);
 801
 802     drmClose(ms->fd);
 803     ms->fd = -1;
 804
 805     pScrn->vtSema = FALSE;
 806     pScreen->CloseScreen = ms->CloseScreen;
 807     return (*pScreen->CloseScreen) (scrnIndex, pScreen);
 808 }
 809
 810 static ModeStatus
 811 drv_valid_mode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
 812 {
 813     return MODE_OK;
 814 }
 815
 816
 817 /*
 818  * Front buffer backing store functions.
 819  */
 820
 821 static Bool
 822 drv_destroy_front_buffer_ga3d(ScrnInfoPtr pScrn)
 823 {
 824     modesettingPtr ms = modesettingPTR(pScrn);
 825     pipe_texture_reference(&ms->root_texture, NULL);
 826     return TRUE;
 827 }
 828
 829 static Bool
 830 drv_create_front_buffer_ga3d(ScrnInfoPtr pScrn)
 831 {
 832     modesettingPtr ms = modesettingPTR(pScrn);
 833     unsigned handle, stride;
 834     struct pipe_texture *tex;
 835
 836     ms->noEvict = TRUE;
 837
 838     tex = xorg_exa_create_root_texture(pScrn, pScrn->virtualX, pScrn->virtualY,
 839                                        pScrn->depth, pScrn->bitsPerPixel);
 840
 841     if (!tex)
 842         return FALSE;
 843
 844     if (!ms->api->local_handle_from_texture(ms->api, ms->screen,
 845                                             tex,
 846                                             &stride,
 847                                             &handle))
 848         return FALSE;
 849
 850     drmModeAddFB(ms->fd,
 851                  pScrn->virtualX,
 852                  pScrn->virtualY,
 853                  pScrn->depth,
 854                  pScrn->bitsPerPixel,
 855                  stride,
 856                  handle,
 857                  &ms->fb_id);
 858
 859     pScrn->frameX0 = 0;
 860     pScrn->frameY0 = 0;
 861     drv_adjust_frame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 862
 863     pipe_texture_reference(&ms->root_texture, tex);
 864     pipe_texture_reference(&tex, NULL);
 865
 866     return TRUE;
 867 }
 868
 869 static Bool
 870 drv_bind_front_buffer_ga3d(ScrnInfoPtr pScrn)
 871 {
 872     modesettingPtr ms = modesettingPTR(pScrn);
 873     ScreenPtr pScreen = pScrn->pScreen;
 874     PixmapPtr rootPixmap = pScreen->GetScreenPixmap(pScreen);
 875     struct pipe_texture *check;
 876
 877     xorg_exa_set_displayed_usage(rootPixmap);
 878     xorg_exa_set_shared_usage(rootPixmap);
 879     xorg_exa_set_texture(rootPixmap, ms->root_texture);
 880     if (!pScreen->ModifyPixmapHeader(rootPixmap, -1, -1, -1, -1, -1, NULL))
 881         FatalError("Couldn't adjust screen pixmap\n");
 882
 883     check = xorg_exa_get_texture(rootPixmap);
 884     if (ms->root_texture != check)
 885         FatalError("Created new root texture\n");
 886
 887     pipe_texture_reference(&check, NULL);
 888     return TRUE;
 889 }
 890
 891 #ifdef HAVE_LIBKMS
 892 static Bool
 893 drv_destroy_front_buffer_kms(ScrnInfoPtr pScrn)
 894 {
 895     modesettingPtr ms = modesettingPTR(pScrn);
 896
 897     if (!ms->root_bo)
 898         return TRUE;
 899
 900     kms_bo_unmap(ms->root_bo);
 901     kms_bo_destroy(ms->root_bo);
 902     ms->root_bo = NULL;
 903     return TRUE;
 904 }
 905
 906 static Bool
 907 drv_create_front_buffer_kms(ScrnInfoPtr pScrn)
 908 {
 909     modesettingPtr ms = modesettingPTR(pScrn);
 910     unsigned handle, stride;
 911     struct kms_bo *bo;
 912     unsigned attr[8];
 913
 914     attr[0] = KMS_BO_TYPE;
 915     attr[1] = KMS_BO_TYPE_SCANOUT;
 916     attr[2] = KMS_WIDTH;
 917     attr[3] = pScrn->virtualX;
 918     attr[4] = KMS_HEIGHT;
 919     attr[5] = pScrn->virtualY;
 920     attr[6] = 0;
 921
 922     if (kms_bo_create(ms->kms, attr, &bo))
 923         return FALSE;
 924
 925     if (kms_bo_get_prop(bo, KMS_PITCH, &stride))
 926         goto err_destroy;
 927
 928     if (kms_bo_get_prop(bo, KMS_HANDLE, &handle))
 929         goto err_destroy;
 930
 931     drmModeAddFB(ms->fd,
 932                  pScrn->virtualX,
 933                  pScrn->virtualY,
 934                  pScrn->depth,
 935                  pScrn->bitsPerPixel,
 936                  stride,
 937                  handle,
 938                  &ms->fb_id);
 939
 940     pScrn->frameX0 = 0;
 941     pScrn->frameY0 = 0;
 942     drv_adjust_frame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 943     ms->root_bo = bo;
 944
 945     return TRUE;
 946
 947 err_destroy:
 948     kms_bo_destroy(bo);
 949     return FALSE;
 950 }
 951
 952 static Bool
 953 drv_bind_front_buffer_kms(ScrnInfoPtr pScrn)
 954 {
 955     modesettingPtr ms = modesettingPTR(pScrn);
 956     ScreenPtr pScreen = pScrn->pScreen;
 957     PixmapPtr rootPixmap = pScreen->GetScreenPixmap(pScreen);
 958     unsigned stride;
 959     void *ptr;
 960
 961     if (kms_bo_get_prop(ms->root_bo, KMS_PITCH, &stride))
 962         return FALSE;
 963
 964     if (kms_bo_map(ms->root_bo, &ptr))
 965         return FALSE;
 966
 967     pScreen->ModifyPixmapHeader(rootPixmap,
 968                                 pScreen->width,
 969                                 pScreen->height,
 970                                 pScreen->rootDepth,
 971                                 pScrn->bitsPerPixel,
 972                                 stride,
 973                                 ptr);
 974     return TRUE;
 975 }
 976 #endif /* HAVE_LIBKMS */
 977
 978 static Bool drv_init_front_buffer_functions(ScrnInfoPtr pScrn)
 979 {
 980     modesettingPtr ms = modesettingPTR(pScrn);
 981     if (ms->screen) {
 982         ms->destroy_front_buffer = drv_destroy_front_buffer_ga3d;
 983         ms->create_front_buffer = drv_create_front_buffer_ga3d;
 984         ms->bind_front_buffer = drv_bind_front_buffer_ga3d;
 985 #ifdef HAVE_LIBKMS
 986     } else if (ms->kms) {
 987         ms->destroy_front_buffer = drv_destroy_front_buffer_kms;
 988         ms->create_front_buffer = drv_create_front_buffer_kms;
 989         ms->bind_front_buffer = drv_bind_front_buffer_kms;
 990 #endif
 991     } else
 992         return FALSE;
 993
 994     return TRUE;
 995 }
 996
 997 /* vim: set sw=4 ts=8 sts=4: */