src/ps3gpu_driver.c

   1 /*-
   2  * Copyright (C) 2011 glevand <geoffrey.levand@mail.ru>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification, immediately at the beginning of the file.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include "xf86.h"
  34 #include "xf86_OSproc.h"
  35
  36 #include "xf86Cursor.h"
  37
  38 #include "exa.h"
  39
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <sys/uio.h>
  43 #include <sys/ioctl.h>
  44 #include <sys/mman.h>
  45 #include <fcntl.h>
  46 #include <unistd.h>
  47
  48 #include "ps3gpu_ctl.h"
  49
  50 #include "ps3gpu.h"
  51 #include "ps3gpu_cursor.h"
  52 #include "ps3gpu_accel.h"
  53
  54 #define PS3GPU_VERSION          4000
  55 #define PS3GPU_NAME             "ps3gpu"
  56 #define PS3GPU_DRIVER_NAME      "ps3gpu"
  57 #define PS3GPU_MAJOR_VERSION    0
  58 #define PS3GPU_MINOR_VERSION    1
  59 #define PS3GPU_PATCHLEVEL       0
  60
  61 #define PS3GPU_DEVICE_PATH      "/dev/ps3gpu"
  62
  63 #ifdef XFree86LOADER
  64
  65 static pointer Ps3GpuSetup(pointer module, pointer opts,
  66     int *errmaj, int *errmin);
  67 static const OptionInfoRec *Ps3GpuAvailableOptions(int chipid, int busid);
  68 static void Ps3GpuIdentify(int flags);
  69 static Bool Ps3GpuProbe(DriverPtr drv, int flags);
  70 static Bool Ps3GpuPreInit(ScrnInfoPtr pScrn, int flags);
  71 static Bool Ps3GpuScreenInit(int scrnIndex, ScreenPtr pScreen,
  72     int argc, char **argv);
  73 static Bool Ps3GpuCloseScreen(int scrnIndex, ScreenPtr pScreen);
  74 static void Ps3GpuFreeScreen(int scrnIndex, int flags);
  75 static Bool Ps3GpuSaveScreen(ScreenPtr pScreen, int mode);
  76 static ModeStatus Ps3GpuValidMode(int scrnIndex, DisplayModePtr mode,
  77     Bool verbose, int flags);
  78 static Bool Ps3GpuSwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
  79 static Bool Ps3GpuSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode);
  80 static void Ps3GpuAdjustFrame(int scrnIndex, int x, int y, int flags);
  81 static Bool Ps3GpuEnterVT(int scrnIndex, int flags);
  82 static void Ps3GpuLeaveVT(int scrnIndex, int flags);
  83 static void Ps3GpuSave(ScrnInfoPtr pScrn);
  84 static void Ps3GpuRestore(ScrnInfoPtr pScrn);
  85 static Bool Ps3GpuMapMem(ScrnInfoPtr pScrn);
  86 static Bool Ps3GpuUnmapMem(ScrnInfoPtr pScrn);
  87 static Bool Ps3GpuDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op,
  88     pointer ptr);
  89
  90 #endif /* XFree86LOADER */
  91
  92 _X_EXPORT DriverRec PS3GPU = {
  93         PS3GPU_VERSION,
  94         PS3GPU_DRIVER_NAME,
  95         Ps3GpuIdentify,
  96         Ps3GpuProbe,
  97         Ps3GpuAvailableOptions,
  98         NULL,
  99         0,
 100         Ps3GpuDriverFunc
 101 };
 102
 103 static SymTabRec Ps3GpuChipsets[] = {
 104         { 0, "ps3gpu" },
 105         { -1, NULL }
 106 };
 107
 108 enum {
 109         OPTION_SHADOW_FB,
 110         OPTION_SW_CURSOR,
 111         OPTION_NOACCEL
 112 };
 113
 114 static const OptionInfoRec Ps3GpuOptions[] = {
 115         { OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, { 0 }, FALSE },
 116         { OPTION_SW_CURSOR, "SWcursor", OPTV_BOOLEAN, { 0 }, FALSE },
 117         { OPTION_NOACCEL, "NoAccel", OPTV_BOOLEAN, { 0 }, FALSE },
 118         { -1, NULL, OPTV_NONE, { 0 }, FALSE }
 119 };
 120
 121 #ifdef XFree86LOADER
 122
 123 static XF86ModuleVersionInfo Ps3GpuVersRec = {
 124         "ps3gpu",
 125         MODULEVENDORSTRING,
 126         MODINFOSTRING1,
 127         MODINFOSTRING2,
 128         XORG_VERSION_CURRENT,
 129         PS3GPU_MAJOR_VERSION,
 130         PS3GPU_MINOR_VERSION,
 131         PS3GPU_PATCHLEVEL,
 132         ABI_CLASS_VIDEODRV,
 133         ABI_VIDEODRV_VERSION,
 134         NULL,
 135         { 0, 0, 0, 0 }
 136 };
 137
 138 _X_EXPORT XF86ModuleData ps3gpuModuleData = { &Ps3GpuVersRec, Ps3GpuSetup, NULL };
 139
 140 static pointer
 141 Ps3GpuSetup(pointer module, pointer opts,
 142     int *errmaj, int *errmin)
 143 {
 144         static Bool setupDone = FALSE;
 145
 146         if (!setupDone) {
 147                 setupDone = TRUE;
 148                 xf86AddDriver(&PS3GPU, module, HaveDriverFuncs);
 149                 return ((pointer) 1);
 150         } else {
 151                 if (errmaj != NULL)
 152                         *errmaj = LDR_ONCEONLY;
 153                 return (NULL);
 154         }
 155 }
 156
 157 #endif /* XFree86LOADER */
 158
 159 static Bool
 160 Ps3GpuGetRec(ScrnInfoPtr pScrn)
 161 {
 162         if (pScrn->driverPrivate)
 163                 return (TRUE);
 164
 165         pScrn->driverPrivate = xnfcalloc(sizeof(Ps3GpuRec), 1);
 166
 167         return (TRUE);
 168 }
 169
 170 static void
 171 Ps3GpuFreeRec(ScrnInfoPtr pScrn)
 172 {
 173         if (!pScrn->driverPrivate)
 174                 return;
 175
 176         xfree(pScrn->driverPrivate);
 177
 178         pScrn->driverPrivate = NULL;
 179 }
 180
 181 static const OptionInfoRec *
 182 Ps3GpuAvailableOptions(int chipid, int busid)
 183 {
 184         return (Ps3GpuOptions);
 185 }
 186
 187 static void
 188 Ps3GpuIdentify(int flags)
 189 {
 190         xf86PrintChipsets(PS3GPU_NAME, "driver for PS3 GPU", Ps3GpuChipsets);
 191 }
 192
 193 static Bool
 194 Ps3GpuProbe(DriverPtr drv, int flags)
 195 {
 196         ScrnInfoPtr pScrn = NULL;
 197         GDevPtr *devSections;
 198         int numDevSections;
 199         Bool foundScreen = FALSE;
 200         int i;
 201
 202         if (flags & PROBE_DETECT)
 203                 return (FALSE);
 204
 205         numDevSections = xf86MatchDevice(PS3GPU_DRIVER_NAME, &devSections);
 206         if (numDevSections <= 0)
 207                 return (FALSE);
 208
 209         if (numDevSections > 1) {
 210                 xf86Msg(X_ERROR, "Ignoring additional device sections\n");
 211                 numDevSections = 1;
 212         }
 213
 214         for (i = 0; i < numDevSections; i++) {
 215                 int entityIndex = xf86ClaimFbSlot(drv, 0, devSections[i],
 216                     TRUE);
 217
 218                 pScrn = xf86ConfigFbEntity(NULL, 0, entityIndex,
 219                     NULL, NULL, NULL, NULL);
 220                 if (pScrn) {
 221                         pScrn->driverVersion = PS3GPU_VERSION;
 222                         pScrn->driverName = PS3GPU_DRIVER_NAME;
 223                         pScrn->name = PS3GPU_NAME;
 224                         pScrn->Probe = Ps3GpuProbe;
 225                         pScrn->PreInit = Ps3GpuPreInit;
 226                         pScrn->ScreenInit = Ps3GpuScreenInit;
 227                         pScrn->FreeScreen = Ps3GpuFreeScreen;
 228                         pScrn->SwitchMode = Ps3GpuSwitchMode;
 229                         pScrn->AdjustFrame = Ps3GpuAdjustFrame;
 230                         pScrn->EnterVT = Ps3GpuEnterVT;
 231                         pScrn->LeaveVT = Ps3GpuLeaveVT;
 232                         pScrn->ValidMode = Ps3GpuValidMode;
 233
 234                         foundScreen = TRUE;
 235                 }
 236         }
 237
 238         xfree(devSections);
 239
 240         return (foundScreen);
 241 }
 242
 243 static Bool
 244 Ps3GpuPreInit(ScrnInfoPtr pScrn, int flags)
 245 {
 246         Ps3GpuPtr gPtr;
 247         GDevPtr device = xf86GetEntityInfo(pScrn->entityList[0])->device;
 248         rgb rgbZeros = { 0, 0, 0 };
 249         rgb rgbMasks = { 0x00ff0000, 0x0000ff00, 0x000000ff };
 250         Gamma gammaZeroes = { 0.0, 0.0, 0.0 };
 251         DisplayModePtr mode;
 252         int i;
 253
 254         if (flags & PROBE_DETECT)
 255                 return (FALSE);
 256
 257         pScrn->monitor = pScrn->confScreen->monitor;
 258
 259         if (!Ps3GpuGetRec(pScrn))
 260                 return (FALSE);
 261
 262         gPtr = PS3GPUPTR(pScrn);
 263
 264         pScrn->monitor = pScrn->confScreen->monitor;
 265
 266         if (pScrn->numEntities > 1)
 267                 return (FALSE);
 268
 269         gPtr->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
 270
 271         pScrn->chipset = (char *) xf86TokenToString(Ps3GpuChipsets,
 272             gPtr->pEnt->chipset);
 273
 274         xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Chipset is a %s\n",
 275             pScrn->chipset);
 276
 277         if (!xf86SetDepthBpp(pScrn, 0, 0, 0,  Support32bppFb)) {
 278                 return (FALSE);
 279         } else {
 280                 switch (pScrn->depth) {
 281                 case 24:
 282                 break;
 283                 default:
 284                         xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 285                             "Given depth (%d) is not supported by this driver\n",
 286                             pScrn->depth);
 287                         return (FALSE);
 288                 }
 289         }
 290
 291         xf86PrintDepthBpp(pScrn);
 292
 293         if (pScrn->depth == 8)
 294                 pScrn->rgbBits = 8;
 295
 296         if (!xf86SetWeight(pScrn, rgbZeros, rgbMasks))
 297                 return (FALSE);
 298
 299         if (!xf86SetDefaultVisual(pScrn, -1))
 300                 return (FALSE);
 301
 302         if (!xf86SetGamma(pScrn, gammaZeroes))
 303                 return (FALSE);
 304
 305         xf86CollectOptions(pScrn, device->options);
 306
 307         if (!(gPtr->options = xalloc(sizeof(Ps3GpuOptions))))
 308                 return (FALSE);
 309
 310         memcpy(gPtr->options, Ps3GpuOptions, sizeof(Ps3GpuOptions));
 311
 312         xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, gPtr->options);
 313
 314         if (device->videoRam != 0) {
 315                 pScrn->videoRam = device->videoRam;
 316                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "VideoRAM: %d kByte\n",
 317                     pScrn->videoRam);
 318         } else {
 319                 pScrn->videoRam = 64 * 1024;
 320                 xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "VideoRAM: %d kByte\n",
 321                     pScrn->videoRam);
 322         }
 323
 324         xf86GetOptValBool(gPtr->options, OPTION_SHADOW_FB, &gPtr->shadowFB);
 325         xf86GetOptValBool(gPtr->options, OPTION_SW_CURSOR, &gPtr->swCursor);
 326         xf86GetOptValBool(gPtr->options, OPTION_NOACCEL, &gPtr->noAccel);
 327
 328         if (gPtr->shadowFB) {
 329                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 330                     "Using Shadow Framebuffer\n");
 331         }
 332
 333         if (gPtr->swCursor) {
 334                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 335                     "Using Software Cursor\n");
 336         }
 337
 338         if (!gPtr->noAccel) {
 339                 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 340                     "Acceleration disabled\n");
 341         }
 342
 343         pScrn->progClock = TRUE;
 344
 345         mode = (DisplayModePtr) xalloc(sizeof(DisplayModeRec));
 346         mode->prev = mode;
 347         mode->next = mode;
 348         mode->name = "ps3gpu current mode";
 349         mode->status = MODE_OK;
 350         mode->type = M_T_BUILTIN;
 351         mode->Clock = 0;
 352         mode->HDisplay = 1920;
 353         mode->HSyncStart = 0;
 354         mode->HSyncEnd = 0;
 355         mode->HTotal = 0;
 356         mode->HSkew = 0;
 357         mode->VDisplay = 1080;
 358         mode->VSyncStart = 0;
 359         mode->VSyncEnd = 0;
 360         mode->VTotal = 0;
 361         mode->VScan = 0;
 362         mode->Flags = 0;
 363
 364         if (pScrn->modes != NULL) {
 365                 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 366                    "Ignoring mode specification from screen section\n");
 367         }
 368
 369         pScrn->currentMode = pScrn->modes = mode;
 370
 371         pScrn->virtualX = mode->HDisplay;
 372         pScrn->virtualY = mode->VDisplay;
 373         pScrn->displayWidth = pScrn->virtualX;
 374
 375         xf86PrintModes(pScrn);
 376
 377         xf86SetDpi(pScrn, 0, 0);
 378
 379         if (gPtr->shadowFB) {
 380                 if (!xf86LoadSubModule(pScrn, "shadow")) {
 381                         Ps3GpuFreeRec(pScrn);
 382                         return (FALSE);
 383                 }
 384         }
 385
 386         if (!xf86LoadSubModule(pScrn, "fb")) {
 387                 Ps3GpuFreeRec(pScrn);
 388                 return (FALSE);
 389         }
 390
 391         if (!gPtr->noAccel) {
 392                 if (!xf86LoadSubModule(pScrn, "exa")) {
 393                         Ps3GpuFreeRec(pScrn);
 394                         return (FALSE);
 395                 }
 396         }
 397
 398         return (TRUE);
 399 }
 400
 401 static Bool
 402 Ps3GpuScreenInit(int scrnIndex, ScreenPtr pScreen,
 403     int argc, char **argv)
 404 {
 405         ScrnInfoPtr pScrn;
 406         Ps3GpuPtr gPtr;
 407         int err;
 408
 409         pScrn = xf86Screens[pScreen->myNum];
 410         gPtr = PS3GPUPTR(pScrn);
 411
 412         if (!Ps3GpuMapMem(pScrn))
 413                 return (FALSE);
 414
 415         if (!Ps3GpuSetMode(pScrn, pScrn->currentMode))
 416                 return (FALSE);
 417
 418         Ps3GpuAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 419
 420         miClearVisualTypes();
 421
 422         err = miSetVisualTypes(pScrn->depth,
 423             miGetDefaultVisualMask(pScrn->depth),
 424             pScrn->rgbBits, pScrn->defaultVisual);
 425         if (!err)
 426                 return (FALSE);
 427
 428         if (!miSetPixmapDepths())
 429                 return (FALSE);
 430
 431         err = fbScreenInit(pScreen, gPtr->fbBase, pScrn->virtualX,
 432             pScrn->virtualY, pScrn->xDpi, pScrn->yDpi, pScrn->displayWidth,
 433             pScrn->bitsPerPixel);
 434         if (!err)
 435                 return (FALSE);
 436
 437         if (pScrn->depth > 8) {
 438                 VisualPtr visual = pScreen->visuals + pScreen->numVisuals;
 439
 440                 while (--visual >= pScreen->visuals) {
 441                         if ((visual->class | DynamicClass) == DirectColor) {
 442                                 visual->offsetRed = pScrn->offset.red;
 443                                 visual->offsetGreen = pScrn->offset.green;
 444                                 visual->offsetBlue = pScrn->offset.blue;
 445                                 visual->redMask = pScrn->mask.red;
 446                                 visual->greenMask = pScrn->mask.green;
 447                                 visual->blueMask = pScrn->mask.blue;
 448                         }
 449                 }
 450         }
 451
 452         fbPictureInit(pScreen, 0, 0);
 453
 454         xf86SetBlackWhitePixels(pScreen);
 455
 456         miInitializeBackingStore(pScreen);
 457         xf86SetBackingStore(pScreen);
 458         xf86SetSilkenMouse(pScreen);
 459
 460         miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
 461
 462         if (!gPtr->swCursor)
 463                 Ps3GpuCursorInit(pScreen);
 464
 465         if (!gPtr->noAccel)
 466                 Ps3GpuAccelInit(pScreen);
 467
 468         if(!miCreateDefColormap(pScreen))
 469                 return (FALSE);
 470
 471         pScreen->SaveScreen = Ps3GpuSaveScreen;
 472
 473         gPtr->closeScreen = pScreen->CloseScreen;
 474         pScreen->CloseScreen = Ps3GpuCloseScreen;
 475
 476         if (serverGeneration == 1)
 477                 xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
 478
 479         return (TRUE);
 480 }
 481
 482 static Bool
 483 Ps3GpuCloseScreen(int scrnIndex, ScreenPtr pScreen)
 484 {
 485         ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 486         Ps3GpuPtr gPtr = PS3GPUPTR(pScrn);
 487
 488         if (pScrn->vtSema) {
 489                 Ps3GpuRestore(pScrn);
 490                 Ps3GpuUnmapMem(pScrn);
 491         }
 492
 493         if (gPtr->cursorInfo)
 494                 xf86DestroyCursorInfoRec(gPtr->cursorInfo);
 495
 496         pScrn->vtSema = FALSE;
 497
 498         pScreen->CloseScreen = gPtr->closeScreen;
 499
 500         return (*pScreen->CloseScreen)(scrnIndex, pScreen);
 501 }
 502
 503 static void
 504 Ps3GpuFreeScreen(int scrnIndex, int flags)
 505 {
 506         Ps3GpuFreeRec(xf86Screens[scrnIndex]);
 507 }
 508
 509 static Bool
 510 Ps3GpuSaveScreen(ScreenPtr pScreen, int mode)
 511 {
 512         return (TRUE);
 513 }
 514
 515 static ModeStatus
 516 Ps3GpuValidMode(int scrnIndex, DisplayModePtr mode,
 517     Bool verbose, int flags)
 518 {
 519         return (MODE_OK);
 520 }
 521
 522 static Bool
 523 Ps3GpuSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
 524 {
 525         return (TRUE);
 526 }
 527
 528 static Bool
 529 Ps3GpuSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
 530 {
 531         Ps3GpuPtr gPtr = PS3GPUPTR(pScrn);
 532         struct ps3gpu_ctl_flip flip;
 533         int err;
 534
 535         pScrn->vtSema = TRUE;
 536
 537         flip.context_id = gPtr->gpuContextId;
 538         flip.head = PS3GPU_CTL_HEAD_A;
 539         flip.offset = gPtr->fbHandle;
 540
 541         err = ioctl(gPtr->fd, PS3GPU_CTL_FLIP, &flip);
 542         if (err) {
 543                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 544                     "Failed to flip head A\n");
 545                 return (FALSE);
 546         }
 547
 548         flip.context_id = gPtr->gpuContextId;
 549         flip.head = PS3GPU_CTL_HEAD_B;
 550         flip.offset = gPtr->fbHandle;
 551
 552         err = ioctl(gPtr->fd, PS3GPU_CTL_FLIP, &flip);
 553         if (err) {
 554                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 555                     "Failed to flip head B\n");
 556                 return (FALSE);
 557         }
 558
 559         return (TRUE);
 560 }
 561
 562 static void
 563 Ps3GpuAdjustFrame(int scrnIndex, int x, int y, int flags)
 564 {
 565 }
 566
 567 static Bool
 568 Ps3GpuEnterVT(int scrnIndex, int flags)
 569 {
 570         ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 571
 572         if (!Ps3GpuSetMode(pScrn, pScrn->currentMode))
 573                 return (FALSE);
 574
 575         return (TRUE);
 576 }
 577
 578 static void
 579 Ps3GpuLeaveVT(int scrnIndex, int flags)
 580 {
 581 }
 582
 583 static void
 584 Ps3GpuSave(ScrnInfoPtr pScrn)
 585 {
 586 }
 587
 588 static void
 589 Ps3GpuRestore(ScrnInfoPtr pScrn)
 590 {
 591 }
 592
 593 static Bool
 594 Ps3GpuMapMem(ScrnInfoPtr pScrn)
 595 {
 596         Ps3GpuPtr gPtr = PS3GPUPTR(pScrn);
 597         struct ps3gpu_ctl_context_allocate contextAllocate;
 598         struct ps3gpu_ctl_memory_allocate memoryAllocate;
 599         int err;
 600
 601         gPtr->fd = open(PS3GPU_DEVICE_PATH, O_RDWR | O_NONBLOCK);
 602         if (gPtr->fd < 0) {
 603                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 604                     "Failed to open GPU device\n");
 605                 return (FALSE);
 606         }
 607
 608         gPtr->fbSize = (pScrn->videoRam - 1024) * 1024;
 609
 610         contextAllocate.vram_size = pScrn->videoRam / 1024;
 611
 612         err = ioctl(gPtr->fd, PS3GPU_CTL_CONTEXT_ALLOCATE,
 613             &contextAllocate);
 614         if (err) {
 615                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 616                     "Failed to allocate GPU context\n");
 617                 return (FALSE);
 618         }
 619
 620         gPtr->gpuContextId = contextAllocate.context_id;
 621         gPtr->gpuControlHandle = contextAllocate.control_handle;
 622         gPtr->gpuControlSize = contextAllocate.control_size;
 623
 624         memoryAllocate.context_id = contextAllocate.context_id;
 625         memoryAllocate.type = PS3GPU_CTL_MEMORY_TYPE_VIDEO;
 626         memoryAllocate.size = gPtr->fbSize;
 627         memoryAllocate.align = 12;
 628
 629         err = ioctl(gPtr->fd, PS3GPU_CTL_MEMORY_ALLOCATE,
 630             &memoryAllocate);
 631         if (err) {
 632                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 633                     "Failed to allocate framebuffer memory\n");
 634                 return (FALSE);
 635         }
 636
 637         gPtr->fbHandle = memoryAllocate.handle;
 638         gPtr->fbGpuAddress = memoryAllocate.gpu_addr;
 639
 640         gPtr->fbBase = (pointer) mmap(NULL, gPtr->fbSize,
 641             PROT_READ | PROT_WRITE, MAP_SHARED, gPtr->fd,
 642             gPtr->fbHandle);
 643         if (gPtr->fbBase == (pointer *) MAP_FAILED) {
 644                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 645                     "Failed to map framebuffer memory\n");
 646                 return (FALSE);
 647         }
 648
 649         return (TRUE);
 650 }
 651
 652 static Bool
 653 Ps3GpuUnmapMem(ScrnInfoPtr pScrn)
 654 {
 655         Ps3GpuPtr gPtr = PS3GPUPTR(pScrn);
 656
 657         close(gPtr->fd);
 658
 659         gPtr->fbBase = NULL;
 660
 661         return (TRUE);
 662 }
 663
 664 static Bool
 665 Ps3GpuDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op,
 666     pointer ptr)
 667 {
 668         CARD32 *flag;
 669
 670         switch (op) {
 671         case GET_REQUIRED_HW_INTERFACES:
 672                 flag = (CARD32 *) ptr;
 673                 *flag = 0;
 674                 return (TRUE);
 675         default:
 676                 return (FALSE);
 677         }
 678 }