1 /* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2012 Sam Lantinga 4 5 This library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Lesser General Public 7 License as published by the Free Software Foundation; either 8 version 2.1 of the License, or (at your option) any later version. 9 10 This library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 19 Sam Lantinga 20 slouken (at) libsdl.org 21 */ 22 #include "SDL_config.h" 23 24 /* Framebuffer console based SDL video driver implementation. 25 */ 26 27 #include <fcntl.h> 28 #include <unistd.h> 29 #include <sys/ioctl.h> 30 #include <sys/mman.h> 31 32 #include "SDL_video.h" 33 #include "SDL_mouse.h" 34 #include "../SDL_sysvideo.h" 35 #include "../SDL_pixels_c.h" 36 #include "../../events/SDL_events_c.h" 37 #include "../SDL_cursor_c.h" 38 #include "SDL_gsvideo.h" 39 #include "SDL_gsmouse_c.h" 40 #include "SDL_gsevents_c.h" 41 #include "SDL_gsyuv_c.h" 42 43 44 /* Initialization/Query functions */ 45 static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat); 46 static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); 47 static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); 48 static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); 49 static void GS_VideoQuit(_THIS); 50 51 /* Hardware surface functions */ 52 static int GS_AllocHWSurface(_THIS, SDL_Surface *surface); 53 static int GS_LockHWSurface(_THIS, SDL_Surface *surface); 54 static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface); 55 static void GS_FreeHWSurface(_THIS, SDL_Surface *surface); 56 57 /* GS driver bootstrap functions */ 58 59 static int GS_Available(void) 60 { 61 int console, memory; 62 63 console = open(PS2_DEV_GS, O_RDWR, 0); 64 if ( console >= 0 ) { 65 close(console); 66 } 67 memory = open(PS2_DEV_MEM, O_RDWR, 0); 68 if ( memory >= 0 ) { 69 close(memory); 70 } 71 return((console >= 0) && (memory >= 0)); 72 } 73 74 static void GS_DeleteDevice(SDL_VideoDevice *device) 75 { 76 SDL_free(device->hidden); 77 SDL_free(device); 78 } 79 80 static SDL_VideoDevice *GS_CreateDevice(int devindex) 81 { 82 SDL_VideoDevice *this; 83 84 /* Initialize all variables that we clean on shutdown */ 85 this = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); 86 if ( this ) { 87 SDL_memset(this, 0, (sizeof *this)); 88 this->hidden = (struct SDL_PrivateVideoData *) 89 SDL_malloc((sizeof *this->hidden)); 90 } 91 if ( (this == NULL) || (this->hidden == NULL) ) { 92 SDL_OutOfMemory(); 93 if ( this ) { 94 SDL_free(this); 95 } 96 return(0); 97 } 98 SDL_memset(this->hidden, 0, (sizeof *this->hidden)); 99 mouse_fd = -1; 100 keyboard_fd = -1; 101 102 /* Set the function pointers */ 103 this->VideoInit = GS_VideoInit; 104 this->ListModes = GS_ListModes; 105 this->SetVideoMode = GS_SetVideoMode; 106 this->CreateYUVOverlay = GS_CreateYUVOverlay; 107 this->SetColors = GS_SetColors; 108 this->UpdateRects = NULL; 109 this->VideoQuit = GS_VideoQuit; 110 this->AllocHWSurface = GS_AllocHWSurface; 111 this->CheckHWBlit = NULL; 112 this->FillHWRect = NULL; 113 this->SetHWColorKey = NULL; 114 this->SetHWAlpha = NULL; 115 this->LockHWSurface = GS_LockHWSurface; 116 this->UnlockHWSurface = GS_UnlockHWSurface; 117 this->FlipHWSurface = NULL; 118 this->FreeHWSurface = GS_FreeHWSurface; 119 this->SetIcon = NULL; 120 this->SetCaption = NULL; 121 this->GetWMInfo = NULL; 122 this->FreeWMCursor = GS_FreeWMCursor; 123 this->CreateWMCursor = GS_CreateWMCursor; 124 this->ShowWMCursor = GS_ShowWMCursor; 125 this->MoveWMCursor = GS_MoveWMCursor; 126 this->InitOSKeymap = GS_InitOSKeymap; 127 this->PumpEvents = GS_PumpEvents; 128 129 this->free = GS_DeleteDevice; 130 131 return this; 132 } 133 134 VideoBootStrap PS2GS_bootstrap = { 135 "ps2gs", "PlayStation 2 Graphics Synthesizer", 136 GS_Available, GS_CreateDevice 137 }; 138 139 /* These are the pixel formats for the 32, 24, and 16 bit video modes */ 140 static struct { 141 int bpp; 142 Uint32 r; 143 Uint32 g; 144 Uint32 b; 145 } GS_pixelmasks[] = { 146 { 32, 0x000000FF, /* RGB little-endian */ 147 0x0000FF00, 148 0x00FF0000 }, 149 { 24, 0x000000FF, /* RGB little-endian */ 150 0x0000FF00, 151 0x00FF0000 }, 152 { 16, 0x0000001f, /* RGB little-endian */ 153 0x000003e0, 154 0x00007c00 }, 155 }; 156 /* This is a mapping from SDL bytes-per-pixel to GS pixel format */ 157 static int GS_formatmap[] = { 158 -1, /* 0 bpp, not a legal value */ 159 -1, /* 8 bpp, not supported (yet?) */ 160 PS2_GS_PSMCT16, /* 16 bpp */ 161 PS2_GS_PSMCT24, /* 24 bpp */ 162 PS2_GS_PSMCT32 /* 32 bpp */ 163 }; 164 165 static unsigned long long head_tags[] __attribute__((aligned(16))) = { 166 4 | (1LL << 60), /* GIFtag */ 167 0x0e, /* A+D */ 168 0, /* 2 */ 169 PS2_GS_BITBLTBUF, 170 0, /* 4 */ 171 PS2_GS_TRXPOS, 172 0, /* 6 */ 173 PS2_GS_TRXREG, 174 0, /* 8 */ 175 PS2_GS_TRXDIR 176 }; 177 178 #define MAXIMG (32767 * 16) 179 #define MAXTAGS 8 180 181 static inline int loadimage_nonblock(int fd, struct ps2_image *image, int size, 182 unsigned long long *hm, 183 unsigned long long *im) 184 { 185 struct ps2_plist plist; 186 struct ps2_packet packet[1 + MAXTAGS * 2]; 187 int isize; 188 int pnum, it, eop; 189 char *data; 190 191 /* initialize the variables */ 192 data = (char *)image->ptr; 193 pnum = it = eop = 0; 194 plist.packet = packet; 195 196 /* make BITBLT packet */ 197 packet[pnum].ptr = hm; 198 packet[pnum].len = sizeof(head_tags); 199 pnum++; 200 hm[2] = ((unsigned long long)image->fbp << 32) | 201 ((unsigned long long)image->fbw << 48) | 202 ((unsigned long long)image->psm << 56); 203 hm[4] = ((unsigned long long)image->x << 32) | 204 ((unsigned long long)image->y << 48); 205 hm[6] = (unsigned long long)image->w | 206 ((unsigned long long)image->h << 32); 207 208 /* make image mode tags */ 209 while (!eop) { 210 isize = size > MAXIMG ? MAXIMG : size; 211 size -= isize; 212 eop = (size == 0); 213 214 packet[pnum].ptr = &im[it]; 215 packet[pnum].len = sizeof(unsigned long long) * 2; 216 pnum++; 217 im[it++] = (isize >> 4) | (eop ? (1 << 15) : 0) | (2LL << 58); 218 im[it++] = 0; 219 220 packet[pnum].ptr = (void *)data; 221 packet[pnum].len = isize; 222 pnum++; 223 data += isize; 224 } 225 plist.num = pnum; 226 227 return ioctl(fd, PS2IOC_SENDL, &plist); 228 } 229 230 static unsigned long long tex_tags[] __attribute__((aligned(16))) = { 231 3 | (1LL << 60), /* GIFtag */ 232 0x0e, /* A+D */ 233 0, /* 2 */ 234 PS2_GS_TEX0_1, 235 (1 << 5) + (1 << 6), 236 PS2_GS_TEX1_1, 237 0, 238 PS2_GS_TEXFLUSH 239 }; 240 static unsigned long long scale_tags[] __attribute__((aligned(16))) = { 241 5 | (1LL << 60), /* GIFtag */ 242 0x0e, /* A+D */ 243 6 + (1 << 4) + (1 << 8), 244 PS2_GS_PRIM, 245 ((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16), 246 PS2_GS_UV, 247 ((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16), 248 PS2_GS_XYZ2, 249 0, /* 8 */ 250 PS2_GS_UV, 251 0, /* 10 */ 252 PS2_GS_XYZ2 253 }; 254 255 256 int scaleimage_nonblock(int fd, unsigned long long *tm, unsigned long long *sm) 257 { 258 struct ps2_plist plist; 259 struct ps2_packet packet[2]; 260 261 /* initialize the variables */ 262 plist.num = 2; 263 plist.packet = packet; 264 265 packet[0].ptr = tm; 266 packet[0].len = sizeof(tex_tags); 267 packet[1].ptr = sm; 268 packet[1].len = sizeof(scale_tags); 269 270 return ioctl(fd, PS2IOC_SENDL, &plist); 271 } 272 273 static int power_of_2(int value) 274 { 275 int shift; 276 277 for ( shift = 0; (1<<shift) < value; ++shift ) { 278 /* Keep looking */ ; 279 } 280 return(shift); 281 } 282 283 static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat) 284 { 285 struct ps2_screeninfo vinfo; 286 287 /* Initialize the library */ 288 console_fd = open(PS2_DEV_GS, O_RDWR, 0); 289 if ( console_fd < 0 ) { 290 SDL_SetError("Unable to open %s", PS2_DEV_GS); 291 return(-1); 292 } 293 memory_fd = open(PS2_DEV_MEM, O_RDWR, 0); 294 if ( memory_fd < 0 ) { 295 close(console_fd); 296 console_fd = -1; 297 SDL_SetError("Unable to open %s", PS2_DEV_MEM); 298 return(-1); 299 } 300 301 if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) { 302 close(memory_fd); 303 close(console_fd); 304 console_fd = -1; 305 SDL_SetError("Couldn't get console pixel format"); 306 return(-1); 307 } 308 309 /* Determine the current screen size */ 310 this->info.current_w = vinfo.w; 311 this->info.current_h = vinfo.h; 312 313 /* Determine the current screen depth */ 314 switch (vinfo.psm) { 315 /* Supported pixel formats */ 316 case PS2_GS_PSMCT32: 317 case PS2_GS_PSMCT24: 318 case PS2_GS_PSMCT16: 319 break; 320 default: 321 GS_VideoQuit(this); 322 SDL_SetError("Unknown console pixel format: %d", vinfo.psm); 323 return(-1); 324 } 325 vformat->BitsPerPixel = GS_pixelmasks[vinfo.psm].bpp; 326 vformat->Rmask = GS_pixelmasks[vinfo.psm].r; 327 vformat->Gmask = GS_pixelmasks[vinfo.psm].g; 328 vformat->Bmask = GS_pixelmasks[vinfo.psm].b; 329 saved_vinfo = vinfo; 330 331 /* Enable mouse and keyboard support */ 332 if ( GS_OpenKeyboard(this) < 0 ) { 333 GS_VideoQuit(this); 334 SDL_SetError("Unable to open keyboard"); 335 return(-1); 336 } 337 if ( GS_OpenMouse(this) < 0 ) { 338 const char *sdl_nomouse; 339 340 sdl_nomouse = SDL_getenv("SDL_NOMOUSE"); 341 if ( ! sdl_nomouse ) { 342 GS_VideoQuit(this); 343 SDL_SetError("Unable to open mouse"); 344 return(-1); 345 } 346 } 347 348 /* We're done! */ 349 return(0); 350 } 351 352 static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) 353 { 354 static SDL_Rect GS_vesa_mode_list[] = { 355 { 0, 0, 1280, 1024 }, 356 { 0, 0, 1024, 768 }, 357 { 0, 0, 800, 600 }, 358 { 0, 0, 640, 480 } 359 }; 360 static SDL_Rect *GS_vesa_modes[] = { 361 &GS_vesa_mode_list[0], 362 &GS_vesa_mode_list[1], 363 &GS_vesa_mode_list[2], 364 &GS_vesa_mode_list[3], 365 NULL 366 }; 367 static SDL_Rect GS_tvout_stretch; 368 static SDL_Rect GS_tvout_mode; 369 static SDL_Rect *GS_tvout_modes[3]; 370 SDL_Rect **modes = NULL; 371 372 switch (format->BitsPerPixel) { 373 case 16: 374 case 24: 375 case 32: 376 if ( saved_vinfo.mode == PS2_GS_VESA ) { 377 modes = GS_vesa_modes; 378 } else { 379 int i, j = 0; 380 381 // FIXME - what's wrong with the stretch code at 16 bpp? 382 if ( format->BitsPerPixel != 32 ) break; 383 /* Add a mode that we could possibly stretch to */ 384 for ( i=0; GS_vesa_modes[i]; ++i ) { 385 if ( (GS_vesa_modes[i]->w == saved_vinfo.w) && 386 (GS_vesa_modes[i]->h != saved_vinfo.h) ) { 387 GS_tvout_stretch.w=GS_vesa_modes[i]->w; 388 GS_tvout_stretch.h=GS_vesa_modes[i]->h; 389 GS_tvout_modes[j++] = &GS_tvout_stretch; 390 break; 391 } 392 } 393 /* Add the current TV video mode */ 394 GS_tvout_mode.w = saved_vinfo.w; 395 GS_tvout_mode.h = saved_vinfo.h; 396 GS_tvout_modes[j++] = &GS_tvout_mode; 397 GS_tvout_modes[j++] = NULL; 398 399 /* Return the created list of modes */ 400 modes = GS_tvout_modes; 401 } 402 break; 403 default: 404 break; 405 } 406 return(modes); 407 } 408 409 /* Various screen update functions available */ 410 static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects); 411 412 static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current, 413 int width, int height, int bpp, Uint32 flags) 414 { 415 struct ps2_screeninfo vinfo; 416 417 /* Set the terminal into graphics mode */ 418 if ( GS_EnterGraphicsMode(this) < 0 ) { 419 return(NULL); 420 } 421 422 /* Set the video mode and get the final screen format */ 423 if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) { 424 SDL_SetError("Couldn't get console screen info"); 425 return(NULL); 426 } 427 if ( (vinfo.w != width) || (vinfo.h != height) || 428 (GS_pixelmasks[vinfo.psm].bpp != bpp) ) { 429 /* If we're not in VESA mode, we have to scale resolution */ 430 if ( saved_vinfo.mode == PS2_GS_VESA ) { 431 switch (width) { 432 case 640: 433 vinfo.res = PS2_GS_640x480; 434 break; 435 case 800: 436 vinfo.res = PS2_GS_800x600; 437 break; 438 case 1024: 439 vinfo.res = PS2_GS_1024x768; 440 break; 441 case 1280: 442 vinfo.res = PS2_GS_1280x1024; 443 break; 444 default: 445 SDL_SetError("Unsupported resolution: %dx%d\n", 446 width, height); 447 return(NULL); 448 } 449 vinfo.res |= (PS2_GS_75Hz << 8); 450 vinfo.w = width; 451 vinfo.h = height; 452 } 453 vinfo.fbp = 0; 454 vinfo.psm = GS_formatmap[bpp/8]; 455 if ( vinfo.psm < 0 ) { 456 SDL_SetError("Unsupported depth: %d bpp\n", bpp); 457 return(NULL); 458 } 459 if ( ioctl(console_fd, PS2IOC_SSCREENINFO, &vinfo) < 0 ) { 460 SDL_SetError("Couldn't set console screen info"); 461 return(NULL); 462 } 463 464 /* Unmap the previous DMA buffer */ 465 if ( mapped_mem ) { 466 munmap(mapped_mem, mapped_len); 467 mapped_mem = NULL; 468 } 469 } 470 if ( ! SDL_ReallocFormat(current, GS_pixelmasks[vinfo.psm].bpp, 471 GS_pixelmasks[vinfo.psm].r, 472 GS_pixelmasks[vinfo.psm].g, 473 GS_pixelmasks[vinfo.psm].b, 0) ) { 474 return(NULL); 475 } 476 477 /* Set up the new mode framebuffer */ 478 current->flags = SDL_FULLSCREEN; 479 current->w = width; 480 current->h = height; 481 current->pitch = SDL_CalculatePitch(current); 482 483 /* Memory map the DMA area for block memory transfer */ 484 if ( ! mapped_mem ) { 485 pixels_len = height * current->pitch; 486 mapped_len = pixels_len + 487 /* Screen update DMA command area */ 488 sizeof(head_tags) + ((2 * MAXTAGS) * 16); 489 if ( saved_vinfo.mode != PS2_GS_VESA ) { 490 mapped_len += sizeof(tex_tags) + sizeof(scale_tags); 491 } 492 mapped_mem = mmap(0, mapped_len, PROT_READ|PROT_WRITE, 493 MAP_SHARED, memory_fd, 0); 494 if ( mapped_mem == MAP_FAILED ) { 495 SDL_SetError("Unable to map %d bytes for DMA", 496 mapped_len); 497 mapped_mem = NULL; 498 return(NULL); 499 } 500 501 /* Set up the entire screen for DMA transfer */ 502 screen_image.ptr = mapped_mem; 503 screen_image.fbp = 0; 504 screen_image.fbw = (vinfo.w + 63) / 64; 505 screen_image.psm = vinfo.psm; 506 screen_image.x = 0; 507 if ( vinfo.h == height ) { 508 screen_image.y = 0; 509 } else { 510 /* Put image offscreen and scale to screen height */ 511 screen_image.y = vinfo.h; 512 } 513 screen_image.w = current->w; 514 screen_image.h = current->h; 515 516 /* get screen image data size (qword aligned) */ 517 screen_image_size = (screen_image.w * screen_image.h); 518 switch (screen_image.psm) { 519 case PS2_GS_PSMCT32: 520 screen_image_size *= 4; 521 break; 522 case PS2_GS_PSMCT24: 523 screen_image_size *= 3; 524 break; 525 case PS2_GS_PSMCT16: 526 screen_image_size *= 2; 527 break; 528 } 529 screen_image_size = (screen_image_size + 15) & ~15; 530 531 /* Set up the memory for screen update DMA commands */ 532 head_tags_mem = (unsigned long long *) 533 (mapped_mem + pixels_len); 534 image_tags_mem = (unsigned long long *) 535 ((caddr_t)head_tags_mem + sizeof(head_tags)); 536 SDL_memcpy(head_tags_mem, head_tags, sizeof(head_tags)); 537 if ( saved_vinfo.mode != PS2_GS_VESA ) { 538 tex_tags_mem = (unsigned long long *) 539 ((caddr_t)image_tags_mem + ((2*MAXTAGS)*16)); 540 scale_tags_mem = (unsigned long long *) 541 ((caddr_t)tex_tags_mem + sizeof(tex_tags)); 542 SDL_memcpy(tex_tags_mem, tex_tags, sizeof(tex_tags)); 543 tex_tags_mem[2] = 544 (vinfo.h * vinfo.w) / 64 + 545 ((unsigned long long)screen_image.fbw << 14) + 546 ((unsigned long long)screen_image.psm << 20) + 547 ((unsigned long long)power_of_2(screen_image.w) << 26) + 548 ((unsigned long long)power_of_2(screen_image.h) << 30) + 549 ((unsigned long long)1 << 34) + 550 ((unsigned long long)1 << 35); 551 SDL_memcpy(scale_tags_mem, scale_tags, sizeof(scale_tags)); 552 scale_tags_mem[8] = 553 ((unsigned long long)screen_image.w * 16) + 554 (((unsigned long long)screen_image.h * 16) << 16); 555 scale_tags_mem[10] = 556 ((unsigned long long)vinfo.w * 16) + 557 (((unsigned long long)vinfo.h * 16) << 16); 558 } 559 } 560 current->pixels = NULL; 561 if ( SDL_getenv("SDL_FULLSCREEN_UPDATE") ) { 562 /* Correct semantics */ 563 current->flags |= SDL_ASYNCBLIT; 564 } else { 565 /* We lie here - the screen memory isn't really the visible 566 display memory and still requires an update, but this 567 has the desired effect for most applications. 568 */ 569 current->flags |= SDL_HWSURFACE; 570 } 571 572 /* Set the update rectangle function */ 573 this->UpdateRects = GS_DMAFullUpdate; 574 575 /* We're done */ 576 return(current); 577 } 578 579 /* We don't support hardware surfaces yet */ 580 static int GS_AllocHWSurface(_THIS, SDL_Surface *surface) 581 { 582 return(-1); 583 } 584 static void GS_FreeHWSurface(_THIS, SDL_Surface *surface) 585 { 586 return; 587 } 588 static int GS_LockHWSurface(_THIS, SDL_Surface *surface) 589 { 590 if ( surface == this->screen ) { 591 /* Since mouse motion affects 'pixels', lock it */ 592 SDL_LockCursor(); 593 594 /* Make sure any pending DMA has completed */ 595 if ( dma_pending ) { 596 ioctl(console_fd, PS2IOC_SENDQCT, 1); 597 dma_pending = 0; 598 } 599 600 /* If the cursor is drawn on the DMA area, remove it */ 601 if ( cursor_drawn ) { 602 surface->pixels = mapped_mem + surface->offset; 603 SDL_EraseCursorNoLock(this->screen); 604 cursor_drawn = 0; 605 } 606 607 /* Set the surface pixels to the base of the DMA area */ 608 surface->pixels = mapped_mem; 609 610 /* We're finished! */ 611 SDL_UnlockCursor(); 612 } 613 return(0); 614 } 615 static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface) 616 { 617 if ( surface == this->screen ) { 618 /* Since mouse motion affects 'pixels', lock it */ 619 SDL_LockCursor(); 620 surface->pixels = NULL; 621 SDL_UnlockCursor(); 622 } 623 } 624 625 static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects) 626 { 627 /* Lock so we aren't interrupted by a mouse update */ 628 SDL_LockCursor(); 629 630 /* Make sure any pending DMA has completed */ 631 if ( dma_pending ) { 632 ioctl(console_fd, PS2IOC_SENDQCT, 1); 633 dma_pending = 0; 634 } 635 636 /* If the mouse is visible, draw it on the DMA area */ 637 if ( (SDL_cursorstate & CURSOR_VISIBLE) && !cursor_drawn ) { 638 this->screen->pixels = mapped_mem + this->screen->offset; 639 SDL_DrawCursorNoLock(this->screen); 640 this->screen->pixels = NULL; 641 cursor_drawn = 1; 642 } 643 644 /* Put the image onto the screen */ 645 loadimage_nonblock(console_fd, 646 &screen_image, screen_image_size, 647 head_tags_mem, image_tags_mem); 648 if ( screen_image.y > 0 ) { 649 /* Need to scale offscreen image to TV output */ 650 ioctl(console_fd, PS2IOC_SENDQCT, 1); 651 dma_pending = 0; 652 scaleimage_nonblock(console_fd, tex_tags_mem, scale_tags_mem); 653 } else { 654 dma_pending = 1; 655 } 656 657 /* We're finished! */ 658 SDL_UnlockCursor(); 659 } 660 661 static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) 662 { 663 return(0); 664 } 665 666 static void GS_VideoQuit(_THIS) 667 { 668 /* Close console and input file descriptors */ 669 if ( console_fd > 0 ) { 670 /* Unmap the video framebuffer */ 671 if ( mapped_mem ) { 672 /* Unmap the video framebuffer */ 673 munmap(mapped_mem, mapped_len); 674 mapped_mem = NULL; 675 } 676 close(memory_fd); 677 678 /* Restore the original video mode */ 679 if ( GS_InGraphicsMode(this) ) { 680 ioctl(console_fd, PS2IOC_SSCREENINFO, &saved_vinfo); 681 } 682 683 /* We're all done with the graphics device */ 684 close(console_fd); 685 console_fd = -1; 686 } 687 GS_CloseMouse(this); 688 GS_CloseKeyboard(this); 689 } 690
