git.oblomov.eu Git - nouveau/blob - src/nv_accel_common.c

   1 #include "nv_include.h"
   2
   3 static Bool
   4 NVAccelInitNullObject(ScrnInfoPtr pScrn)
   5 {
   6         NVPtr pNv = NVPTR(pScrn);
   7         static int have_object = FALSE;
   8
   9         if (!have_object) {
  10                 if (!NVDmaCreateContextObject(pNv, NvNullObject,
  11                                                    0x30))
  12                         return FALSE;
  13                 have_object = TRUE;
  14         }
  15
  16         return TRUE;
  17 }
  18
  19 uint32_t
  20 NVAccelGetPixmapOffset(PixmapPtr pPix)
  21 {
  22         ScrnInfoPtr pScrn = xf86Screens[pPix->drawable.pScreen->myNum];
  23         NVPtr pNv = NVPTR(pScrn);
  24         unsigned long offset;
  25
  26         offset = exaGetPixmapOffset(pPix);
  27         if (offset >= pNv->FB->size) {
  28                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
  29                            "AII, passed bad pixmap: offset 0x%lx\n",
  30                            offset);
  31                 return pNv->FB->offset;
  32         }
  33         offset += pNv->FB->offset;
  34
  35         return offset;
  36 }
  37
  38 static Bool
  39 NVAccelInitDmaNotifier0(ScrnInfoPtr pScrn)
  40 {
  41         NVPtr pNv = NVPTR(pScrn);
  42         static int have_object = FALSE;
  43
  44         if (!have_object) {
  45                 pNv->Notifier0 = NVNotifierAlloc(pScrn, NvDmaNotifier0);
  46                 if (!pNv->Notifier0)
  47                         return FALSE;
  48                 have_object = TRUE;
  49         }
  50
  51         return TRUE;
  52 }
  53
  54 /* FLAGS_ROP_AND, DmaFB, DmaFB, 0 */
  55 static Bool
  56 NVAccelInitContextSurfaces(ScrnInfoPtr pScrn)
  57 {
  58         NVPtr pNv = NVPTR(pScrn);
  59         static int have_object = FALSE;
  60         uint32_t   class;
  61
  62         class = (pNv->Architecture >= NV_10) ? NV10_CONTEXT_SURFACES_2D :
  63                                                NV04_CONTEXT_SURFACES_2D;
  64
  65         if (!have_object) {
  66                 if (!NVDmaCreateContextObject(pNv, NvContextSurfaces, class))
  67                         return FALSE;
  68                 have_object = TRUE;
  69         }
  70
  71         NVDmaStart(pNv, NvContextSurfaces, NV04_CONTEXT_SURFACES_2D_SET_DMA_NOTIFY, 1);
  72         NVDmaNext (pNv, NvNullObject);
  73         NVDmaStart(pNv, NvContextSurfaces, NV04_CONTEXT_SURFACES_2D_SET_DMA_IMAGE_SRC, 2);
  74         NVDmaNext (pNv, NvDmaFB);
  75         NVDmaNext (pNv, NvDmaFB);
  76
  77         return TRUE;
  78 }
  79
  80 /* FLAGS_ROP_AND, DmaFB, DmaFB, 0 */
  81 static Bool
  82 NVAccelInitContextBeta1(ScrnInfoPtr pScrn)
  83 {
  84         NVPtr pNv = NVPTR(pScrn);
  85         static int have_object = FALSE;
  86         uint32_t   class;
  87
  88         class = 0x12;
  89
  90         if (!have_object) {
  91                 if (!NVDmaCreateContextObject(pNv, NvContextBeta1, class))
  92                         return FALSE;
  93                 have_object = TRUE;
  94         }
  95
  96         NVDmaStart(pNv, NvContextBeta1, 0x300, 1); /*alpha factor*/
  97         NVDmaNext (pNv, 0xff << 23);
  98
  99         return TRUE;
 100 }
 101
 102
 103 static Bool
 104 NVAccelInitContextBeta4(ScrnInfoPtr pScrn)
 105 {
 106         NVPtr pNv = NVPTR(pScrn);
 107         static int have_object = FALSE;
 108         uint32_t   class;
 109
 110         class = 0x72;
 111
 112         if (!have_object) {
 113                 if (!NVDmaCreateContextObject(pNv, NvContextBeta4, class))
 114                         return FALSE;
 115                 have_object = TRUE;
 116         }
 117
 118         NVDmaStart(pNv, NvContextBeta4, 0x300, 1); /*RGBA factor*/
 119         NVDmaNext (pNv, 0xffff0000);
 120         return TRUE;
 121 }
 122
 123 Bool
 124 NVAccelGetCtxSurf2DFormatFromPixmap(PixmapPtr pPix, int *fmt_ret)
 125 {
 126         switch (pPix->drawable.bitsPerPixel) {
 127         case 32:
 128                 *fmt_ret = SURFACE_FORMAT_A8R8G8B8;
 129                 break;
 130         case 24:
 131                 *fmt_ret = SURFACE_FORMAT_X8R8G8B8;
 132                 break;
 133         case 16:
 134                 *fmt_ret = SURFACE_FORMAT_R5G6B5;
 135                 break;
 136         case 8:
 137                 *fmt_ret = SURFACE_FORMAT_Y8;
 138                 break;
 139         default:
 140                 return FALSE;
 141         }
 142
 143         return TRUE;
 144 }
 145
 146 Bool
 147 NVAccelGetCtxSurf2DFormatFromPicture(PicturePtr pPict, int *fmt_ret)
 148 {
 149         switch (pPict->format) {
 150         case PICT_a8r8g8b8:
 151                 *fmt_ret = SURFACE_FORMAT_A8R8G8B8;
 152                 break;
 153         case PICT_x8r8g8b8:
 154                 *fmt_ret = SURFACE_FORMAT_X8R8G8B8;
 155                 break;
 156         case PICT_r5g6b5:
 157                 *fmt_ret = SURFACE_FORMAT_R5G6B5;
 158                 break;
 159         case PICT_a8:
 160                 *fmt_ret = SURFACE_FORMAT_Y8;
 161                 break;
 162         default:
 163                 return FALSE;
 164         }
 165
 166         return TRUE;
 167 }
 168
 169 Bool
 170 NVAccelSetCtxSurf2D(PixmapPtr psPix, PixmapPtr pdPix, int format)
 171 {
 172         ScrnInfoPtr pScrn = xf86Screens[psPix->drawable.pScreen->myNum];
 173         NVPtr pNv = NVPTR(pScrn);
 174
 175         NVDmaStart(pNv, NvContextSurfaces, SURFACE_FORMAT, 4);
 176         NVDmaNext (pNv, format);
 177         NVDmaNext (pNv, ((uint32_t)exaGetPixmapPitch(pdPix) << 16) |
 178                          (uint32_t)exaGetPixmapPitch(psPix));
 179         NVDmaNext (pNv, NVAccelGetPixmapOffset(psPix));
 180         NVDmaNext (pNv, NVAccelGetPixmapOffset(pdPix));
 181
 182         return TRUE;
 183 }
 184
 185 /* FLAGS_ROP_AND|FLAGS_MONO, 0, 0, 0 */
 186 static Bool
 187 NVAccelInitImagePattern(ScrnInfoPtr pScrn)
 188 {
 189         NVPtr pNv = NVPTR(pScrn);
 190         static int have_object = FALSE;
 191         uint32_t   class;
 192
 193         class = NV04_IMAGE_PATTERN;
 194
 195         if (!have_object) {
 196                 if (!NVDmaCreateContextObject(pNv, NvImagePattern, class))
 197                         return FALSE;
 198                 have_object = TRUE;
 199         }
 200
 201         NVDmaStart(pNv, NvImagePattern,
 202                         0x180, /*NV04_IMAGE_PATTERN_SET_DMA_NOTIFY*/ 1);
 203         NVDmaNext (pNv, NvNullObject);
 204         NVDmaStart(pNv, NvImagePattern, NV04_IMAGE_PATTERN_MONO_FORMAT, 3);
 205 #if X_BYTE_ORDER == X_BIG_ENDIAN
 206         NVDmaNext (pNv, 2 /* NV04_IMAGE_PATTERN_BIGENDIAN/LE_M1 */);
 207 #else
 208         NVDmaNext (pNv, 1 /* NV04_IMAGE_PATTERN_LOWENDIAN/CGA6_M1 */);
 209 #endif
 210         NVDmaNext (pNv, 0 /* NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8 */);
 211         NVDmaNext (pNv, 1 /* NV04_IMAGE_PATTERN_SELECT_MONOCHROME */);
 212
 213         return TRUE;
 214 }
 215
 216 /* FLAGS_ROP_AND, 0, 0, 0 */
 217 static Bool
 218 NVAccelInitRasterOp(ScrnInfoPtr pScrn)
 219 {
 220         NVPtr pNv = NVPTR(pScrn);
 221         static int have_object = FALSE;
 222         uint32_t   class;
 223
 224         class = NV03_PRIMITIVE_RASTER_OP;
 225
 226         if (!have_object) {
 227                 if (!NVDmaCreateContextObject(pNv, NvRop, class))
 228                         return FALSE;
 229                 have_object = TRUE;
 230         }
 231
 232         NVDmaStart(pNv, NvRop, NV03_PRIMITIVE_RASTER_OP_DMA_NOTIFY, 1);
 233         NVDmaNext (pNv, NvNullObject);
 234
 235         pNv->currentRop = ~0;
 236         return TRUE;
 237 }
 238
 239 /* FLAGS_ROP_AND | FLAGS_MONO, 0, 0, 0 */
 240 static Bool
 241 NVAccelInitRectangle(ScrnInfoPtr pScrn)
 242 {
 243         NVPtr pNv = NVPTR(pScrn);
 244         static int have_object = FALSE;
 245         uint32_t   class;
 246
 247         class = NV04_GDI_RECTANGLE_TEXT;
 248
 249         if (!have_object) {
 250                 if (!NVDmaCreateContextObject(pNv, NvRectangle, class))
 251                         return FALSE;
 252                 have_object = TRUE;
 253         }
 254
 255         NVDmaStart(pNv, NvRectangle,
 256                         NV04_GDI_RECTANGLE_TEXT_SET_DMA_NOTIFY, 1);
 257         NVDmaNext (pNv, NvDmaNotifier0);
 258         NVDmaStart(pNv, NvRectangle,
 259                         NV04_GDI_RECTANGLE_TEXT_SET_DMA_FONTS, 1);
 260         NVDmaNext (pNv, NvNullObject);
 261         NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1);
 262         NVDmaNext (pNv, NvContextSurfaces);
 263         NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_ROP5, 1);
 264         NVDmaNext (pNv, NvRop);
 265         NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1);
 266         NVDmaNext (pNv, NvImagePattern);
 267         NVDmaStart(pNv, NvRectangle, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
 268         NVDmaNext (pNv, 1 /* ROP_AND */);
 269         NVDmaStart(pNv, NvRectangle,
 270                         NV04_GDI_RECTANGLE_TEXT_MONO_FORMAT, 1);
 271         /* XXX why putting 1 like renouveau dump, swap the text */
 272 #if 1 || X_BYTE_ORDER == X_BIG_ENDIAN
 273         NVDmaNext (pNv, 2 /* NV04_GDI_RECTANGLE_BIGENDIAN/LE_M1 */);
 274 #else
 275         NVDmaNext (pNv, 1 /* NV04_GDI_RECTANGLE_LOWENDIAN/CGA6_M1 */);
 276 #endif
 277
 278         return TRUE;
 279 }
 280
 281 /* FLAGS_ROP_AND, DmaFB, DmaFB, 0 */
 282 static Bool
 283 NVAccelInitImageBlit(ScrnInfoPtr pScrn)
 284 {
 285         NVPtr pNv = NVPTR(pScrn);
 286         static int have_object = FALSE;
 287         uint32_t   class;
 288
 289         class = (pNv->WaitVSyncPossible) ? NV11_IMAGE_BLIT : NV_IMAGE_BLIT;
 290
 291         if (!have_object) {
 292                 if (!NVDmaCreateContextObject(pNv, NvImageBlit, class))
 293                         return FALSE;
 294                 have_object = TRUE;
 295         }
 296
 297         NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_SET_DMA_NOTIFY, 1);
 298         NVDmaNext (pNv, NvDmaNotifier0);
 299         NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_SET_COLOR_KEY, 1);
 300         NVDmaNext (pNv, NvNullObject);
 301         NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_SET_SURFACES_2D, 1);
 302         NVDmaNext (pNv, NvContextSurfaces);
 303         NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_SET_CLIP_RECTANGLE, 3);
 304         NVDmaNext (pNv, NvNullObject);
 305         NVDmaNext (pNv, NvImagePattern);
 306         NVDmaNext (pNv, NvRop);
 307         NVDmaStart(pNv, NvImageBlit, NV_IMAGE_BLIT_OPERATION, 1);
 308         NVDmaNext (pNv, 1 /* NV_IMAGE_BLIT_OPERATION_ROP_AND */);
 309
 310         if (pNv->WaitVSyncPossible) {
 311                 NVDmaStart(pNv, NvImageBlit, 0x0120, 3);
 312                 NVDmaNext (pNv, 0);
 313                 NVDmaNext (pNv, 1);
 314                 NVDmaNext (pNv, 2);
 315         }
 316
 317         return TRUE;
 318 }
 319
 320 /* FLAGS_SRCCOPY, DmaFB, DmaFB, 0 */
 321 static Bool
 322 NVAccelInitScaledImage(ScrnInfoPtr pScrn)
 323 {
 324         NVPtr pNv = NVPTR(pScrn);
 325         static int have_object = FALSE;
 326         uint32_t   class;
 327
 328         switch (pNv->Architecture) {
 329         case NV_ARCH_04:
 330                 class = NV04_SCALED_IMAGE_FROM_MEMORY;
 331                 break;
 332         case NV_ARCH_10:
 333         case NV_ARCH_20:
 334         case NV_ARCH_30:
 335                 class = NV10_SCALED_IMAGE_FROM_MEMORY;
 336                 break;
 337         case NV_ARCH_40:
 338         default:
 339                 class = NV10_SCALED_IMAGE_FROM_MEMORY | 0x3000;
 340                 break;
 341         }
 342
 343         if (!have_object) {
 344                 if (!NVDmaCreateContextObject(pNv, NvScaledImage, class))
 345                         return FALSE;
 346                 have_object = TRUE;
 347         }
 348
 349         NVDmaStart(pNv, NvScaledImage,
 350                         NV04_SCALED_IMAGE_FROM_MEMORY_DMA_NOTIFY, 1);
 351         NVDmaNext (pNv, NvDmaNotifier0);
 352         NVDmaStart(pNv, NvScaledImage,
 353                         NV04_SCALED_IMAGE_FROM_MEMORY_DMA_IMAGE, 1);
 354         NVDmaNext (pNv, NvDmaFB); /* source object */
 355         NVDmaStart(pNv, NvScaledImage,
 356                         NV04_SCALED_IMAGE_FROM_MEMORY_SURFACE, 1);
 357         NVDmaNext (pNv, NvContextSurfaces);
 358         NVDmaStart(pNv, NvScaledImage,
 359                         NV04_SCALED_IMAGE_FROM_MEMORY_PATTERN, 1);
 360         NVDmaNext (pNv, NvNullObject);
 361         NVDmaStart(pNv, NvScaledImage,
 362                         NV04_SCALED_IMAGE_FROM_MEMORY_ROP, 1);
 363         NVDmaNext (pNv, NvNullObject);
 364         NVDmaStart(pNv, NvScaledImage,
 365                         NV04_SCALED_IMAGE_FROM_MEMORY_BETA1, 1); /* BETA1 */
 366         NVDmaNext (pNv, NvContextBeta1);
 367         NVDmaStart(pNv, NvScaledImage,
 368                         NV04_SCALED_IMAGE_FROM_MEMORY_BETA4, 1); /* BETA4 */
 369         NVDmaNext (pNv, NvContextBeta4);
 370         if (pNv->Architecture>=NV_ARCH_10)
 371         {
 372                 NVDmaStart(pNv, NvScaledImage, 0x2fc, 1); /* NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION */
 373                 NVDmaNext (pNv, 0); /* NV_063_SET_COLOR_CONVERSION_TYPE_DITHER */
 374         }
 375         NVDmaStart(pNv, NvScaledImage,
 376                         NV04_SCALED_IMAGE_FROM_MEMORY_OPERATION, 1);
 377         NVDmaNext (pNv, 3 /* SRCCOPY */);
 378
 379         return TRUE;
 380 }
 381
 382 /* FLAGS_NONE, 0, 0, 0 */
 383 static Bool
 384 NVAccelInitClipRectangle(ScrnInfoPtr pScrn)
 385 {
 386         NVPtr pNv = NVPTR(pScrn);
 387         static int have_object = FALSE;
 388         int class = NV01_CONTEXT_CLIP_RECTANGLE;
 389
 390         if (!have_object) {
 391                 if (!NVDmaCreateContextObject(pNv, NvClipRectangle, class))
 392                         return FALSE;
 393                 have_object = TRUE;
 394         }
 395
 396         NVDmaStart(pNv, NvClipRectangle,
 397                         NV01_CONTEXT_CLIP_RECTANGLE_DMA_NOTIFY, 1);
 398         NVDmaNext (pNv, NvNullObject);
 399
 400         return TRUE;
 401 }
 402
 403 /* FLAGS_ROP_AND | FLAGS_CLIP_ENABLE, 0, 0, 0 */
 404 static Bool
 405 NVAccelInitSolidLine(ScrnInfoPtr pScrn)
 406 {
 407         NVPtr pNv = NVPTR(pScrn);
 408         static int have_object = FALSE;
 409         int class = NV04_SOLID_LINE;
 410
 411         if (!have_object) {
 412                 if (!NVDmaCreateContextObject(pNv, NvSolidLine, class))
 413                         return FALSE;
 414                 have_object = TRUE;
 415         }
 416
 417         NVDmaStart(pNv, NvSolidLine, NV04_SOLID_LINE_CLIP_RECTANGLE, 3);
 418         NVDmaNext (pNv, NvClipRectangle);
 419         NVDmaNext (pNv, NvImagePattern);
 420         NVDmaNext (pNv, NvRop);
 421         NVDmaStart(pNv, NvSolidLine, NV04_SOLID_LINE_SURFACE, 1);
 422         NVDmaNext (pNv, NvContextSurfaces);
 423         NVDmaStart(pNv, NvSolidLine, NV04_SOLID_LINE_OPERATION, 1);
 424         NVDmaNext (pNv, 1); /* ROP_AND */
 425
 426         return TRUE;
 427 }
 428
 429 /* FLAGS_NONE, NvDmaFB, NvDmaAGP, NvDmaNotifier0 */
 430 static Bool
 431 NVAccelInitMemFormat(ScrnInfoPtr pScrn)
 432 {
 433         NVPtr pNv = NVPTR(pScrn);
 434         static int have_object = FALSE;
 435         uint32_t   class;
 436
 437         if (pNv->Architecture < NV_ARCH_50)
 438                 class = NV_MEMORY_TO_MEMORY_FORMAT;
 439         else
 440                 class = NV_MEMORY_TO_MEMORY_FORMAT | 0x5000;
 441
 442         if (!have_object) {
 443                 if (!NVDmaCreateContextObject(pNv, NvMemFormat, class))
 444                                 return FALSE;
 445                 have_object = TRUE;
 446         }
 447
 448         NVDmaStart(pNv, NvMemFormat,
 449                         NV_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1);
 450         NVDmaNext (pNv, NvDmaNotifier0);
 451         NVDmaStart(pNv, NvMemFormat,
 452                         NV_MEMORY_TO_MEMORY_FORMAT_OBJECT_IN, 2);
 453         NVDmaNext (pNv, NvDmaFB);
 454         NVDmaNext (pNv, NvDmaFB);
 455
 456         pNv->M2MFDirection = -1;
 457         return TRUE;
 458 }
 459
 460 static Bool
 461 NVAccelInitImageFromCpu(ScrnInfoPtr pScrn)
 462 {
 463         NVPtr pNv = NVPTR(pScrn);
 464         static int have_object = FALSE;
 465         uint32_t   class;
 466
 467         switch (pNv->Architecture) {
 468         case NV_ARCH_04:
 469                 class = NV_IMAGE_FROM_CPU;
 470                 break;
 471         case NV_ARCH_10:
 472         case NV_ARCH_20:
 473         case NV_ARCH_30:
 474         case NV_ARCH_40:
 475         default:
 476                 class = NV10_IMAGE_FROM_CPU;
 477                 break;
 478         }
 479
 480         if (!have_object) {
 481                 if (!NVDmaCreateContextObject(pNv, NvImageFromCpu, class))
 482                         return FALSE;
 483                 have_object = TRUE;
 484         }
 485
 486         NVDmaStart(pNv, NvImageFromCpu, NV05_IMAGE_FROM_CPU_DMA_NOTIFY, 1);
 487         NVDmaNext (pNv, NvDmaNotifier0);
 488         NVDmaStart(pNv, NvImageFromCpu, NV05_IMAGE_FROM_CPU_CLIP_RECTANGLE, 1);
 489         NVDmaNext (pNv, NvNullObject);
 490         NVDmaStart(pNv, NvImageFromCpu, NV05_IMAGE_FROM_CPU_PATTERN, 1);
 491         NVDmaNext (pNv, NvNullObject);
 492         NVDmaStart(pNv, NvImageFromCpu, NV05_IMAGE_FROM_CPU_ROP, 1);
 493         NVDmaNext (pNv, NvNullObject);
 494         if (pNv->Architecture >= NV_ARCH_10)
 495         {
 496                 NVDmaStart(pNv, NvImageFromCpu, NV05_IMAGE_FROM_CPU_BETA1, 1);
 497                 NVDmaNext (pNv, NvNullObject);
 498                 NVDmaStart(pNv, NvImageFromCpu, NV05_IMAGE_FROM_CPU_BETA4, 1);
 499                 NVDmaNext (pNv, NvNullObject);
 500         }
 501         NVDmaStart(pNv, NvImageFromCpu, NV05_IMAGE_FROM_CPU_SURFACE, 1);
 502         NVDmaNext (pNv, NvContextSurfaces);
 503         NVDmaStart(pNv, NvImageFromCpu, NV05_IMAGE_FROM_CPU_OPERATION, 1);
 504         NVDmaNext (pNv, 3 /* SRCCOPY */);
 505         return TRUE;
 506 }
 507
 508 static Bool
 509 NVAccelInit2D_NV50(ScrnInfoPtr pScrn)
 510 {
 511         NVPtr pNv = NVPTR(pScrn);
 512         static int have_object = FALSE;
 513
 514         if (!have_object) {
 515                 if (!NVDmaCreateContextObject(pNv, Nv2D, 0x502d))
 516                                 return FALSE;
 517                 have_object = TRUE;
 518         }
 519
 520         NVDmaStart(pNv, Nv2D, 0x180, 3);
 521         NVDmaNext (pNv, NvDmaNotifier0);
 522         NVDmaNext (pNv, NvDmaFB);
 523         NVDmaNext (pNv, NvDmaFB);
 524
 525         /* Magics from nv, no clue what they do, but at least some
 526          * of them are needed to avoid crashes.
 527          */
 528         NVDmaStart(pNv, Nv2D, 0x260, 1);
 529         NVDmaNext (pNv, 1);
 530         NVDmaStart(pNv, Nv2D, 0x290, 1);
 531         NVDmaNext (pNv, 1);
 532         NVDmaStart(pNv, Nv2D, 0x29c, 1);
 533         NVDmaNext (pNv, 0);
 534         NVDmaStart(pNv, Nv2D, 0x58c, 1);
 535         NVDmaNext (pNv, 0x111);
 536
 537         pNv->currentRop = 0xfffffffa;
 538         return TRUE;
 539 }
 540
 541 #define INIT_CONTEXT_OBJECT(name) do {                                        \
 542         ret = NVAccelInit##name(pScrn);                                       \
 543         if (!ret) {                                                           \
 544                 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,                         \
 545                            "Failed to initialise context object: "#name       \
 546                            " (%d)\n", ret);                                   \
 547                 return FALSE;                                                 \
 548         }                                                                     \
 549 } while(0)
 550
 551 Bool
 552 NVAccelCommonInit(ScrnInfoPtr pScrn)
 553 {
 554         NVPtr pNv = NVPTR(pScrn);
 555         Bool ret;
 556         if(pNv->NoAccel) return TRUE;
 557
 558         /* General engine objects */
 559         INIT_CONTEXT_OBJECT(NullObject);
 560         INIT_CONTEXT_OBJECT(DmaNotifier0);
 561
 562         /* 2D engine */
 563         if (pNv->Architecture < NV_ARCH_50) {
 564                 INIT_CONTEXT_OBJECT(ContextSurfaces);
 565                 INIT_CONTEXT_OBJECT(ContextBeta1);
 566                 INIT_CONTEXT_OBJECT(ContextBeta4);
 567                 INIT_CONTEXT_OBJECT(ImagePattern);
 568                 INIT_CONTEXT_OBJECT(RasterOp);
 569                 INIT_CONTEXT_OBJECT(Rectangle);
 570                 INIT_CONTEXT_OBJECT(ImageBlit);
 571                 INIT_CONTEXT_OBJECT(ScaledImage);
 572                 INIT_CONTEXT_OBJECT(ClipRectangle);
 573                 INIT_CONTEXT_OBJECT(SolidLine);
 574                 INIT_CONTEXT_OBJECT(ImageFromCpu);
 575         } else {
 576                 INIT_CONTEXT_OBJECT(2D_NV50);
 577         }
 578         INIT_CONTEXT_OBJECT(MemFormat);
 579
 580         /* 3D init */
 581         switch (pNv->Architecture) {
 582         case NV_ARCH_40:
 583                 INIT_CONTEXT_OBJECT(NV40TCL);
 584                 break;
 585         case NV_ARCH_30:
 586                 INIT_CONTEXT_OBJECT(NV30TCL);
 587                 break;
 588         case NV_ARCH_20:
 589         case NV_ARCH_10:
 590                 INIT_CONTEXT_OBJECT(NV10TCL);
 591                 break;
 592         default:
 593                 break;
 594         }
 595
 596         return TRUE;
 597 }
 598