1 /* 2 * SDL - Simple DirectMedia Layer 3 * CELL BE Support for PS3 Framebuffer 4 * Copyright (C) 2008, 2009 International Business Machines Corporation 5 * 6 * This library is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU Lesser General Public License as published 8 * by the Free Software Foundation; either version 2.1 of the License, or 9 * (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 19 * USA 20 * 21 * Martin Lowinski <lowinski [at] de [dot] ibm [ibm] com> 22 * Dirk Herrendoerfer <d.herrendoerfer [at] de [dot] ibm [dot] com> 23 * SPE code based on research by: 24 * Rene Becker 25 * Thimo Emmerich 26 */ 27 28 #include "SDL_config.h" 29 30 #include "SDL_video.h" 31 #include "../SDL_sysvideo.h" 32 #include "SDL_ps3events_c.h" 33 #include "SDL_ps3video.h" 34 #include "SDL_ps3yuv_c.h" 35 #include "spulibs/spu_common.h" 36 37 #include <fcntl.h> 38 #include <stdlib.h> 39 #include <sys/ioctl.h> 40 #include <linux/kd.h> 41 #include <sys/mman.h> 42 43 #include <linux/fb.h> 44 #include <asm/ps3fb.h> 45 #include <libspe2.h> 46 #include <malloc.h> 47 48 /* SDL_VideoDevice functions */ 49 static int PS3_Available(); 50 static SDL_VideoDevice *PS3_CreateDevice(int devindex); 51 static int PS3_VideoInit(_THIS, SDL_PixelFormat * vformat); 52 static void PS3_VideoQuit(_THIS); 53 static void PS3_DeleteDevice(SDL_VideoDevice * device); 54 static SDL_Surface *PS3_SetVideoMode(_THIS, SDL_Surface * current, int width, int height, int bpp, Uint32 flags); 55 static SDL_Rect **PS3_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags); 56 57 /* Hardware surface functions */ 58 static int PS3_AllocHWSurface(_THIS, SDL_Surface * surface); 59 static void PS3_FreeHWSurface(_THIS, SDL_Surface * surface); 60 static int PS3_LockHWSurface(_THIS, SDL_Surface * surface); 61 static void PS3_UnlockHWSurface(_THIS, SDL_Surface * surface); 62 static int PS3_FlipDoubleBuffer(_THIS, SDL_Surface * surface); 63 static void PS3_DoubleBufferUpdate(_THIS, int numrects, SDL_Rect * rects); 64 65 /* SPU specific functions */ 66 int SPE_Start(_THIS, spu_data_t * spe_data); 67 int SPE_Stop(_THIS, spu_data_t * spe_data); 68 int SPE_Boot(_THIS, spu_data_t * spe_data); 69 int SPE_Shutdown(_THIS, spu_data_t * spe_data); 70 int SPE_SendMsg(_THIS, spu_data_t * spe_data, unsigned int msg); 71 int SPE_WaitForMsg(_THIS, spu_data_t * spe_data, unsigned int msg); 72 void SPE_RunContext(void *thread_argp); 73 74 /* Helpers */ 75 void enable_cursor(int enable); 76 77 /* Stores the SPE executable name of fb_writer_spu */ 78 extern spe_program_handle_t fb_writer_spu; 79 80 /* SDL PS3 bootstrap function for checking availability */ 81 static int PS3_Available() 82 { 83 return 1; 84 } 85 86 /* SDL PS3 bootstrap function for creating the device */ 87 static SDL_VideoDevice *PS3_CreateDevice(int devindex) 88 { 89 SDL_VideoDevice *this; 90 91 /* Initialise SDL_VideoDevice */ 92 this = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice)); 93 if (this) { 94 memset(this, 0, sizeof *this); 95 this->hidden = (struct SDL_PrivateVideoData *) 96 SDL_malloc(sizeof(struct SDL_PrivateVideoData)); 97 } 98 /* Error handling */ 99 if ((this == NULL) || (this->hidden == NULL)) { 100 SDL_OutOfMemory(); 101 if (this) 102 SDL_free(this); 103 return 0; 104 } 105 memset(this->hidden, 0, sizeof(struct SDL_PrivateVideoData)); 106 107 /* Set the function pointers */ 108 this->VideoInit = PS3_VideoInit; 109 this->ListModes = PS3_ListModes; 110 this->SetVideoMode = PS3_SetVideoMode; 111 this->SetColors = 0; 112 this->CreateYUVOverlay = PS3_CreateYUVOverlay; 113 this->UpdateRects = 0; 114 this->VideoQuit = PS3_VideoQuit; 115 this->AllocHWSurface = PS3_AllocHWSurface; 116 this->CheckHWBlit = 0; 117 this->FillHWRect = 0; 118 this->SetHWColorKey = 0; 119 this->SetHWAlpha = 0; 120 this->LockHWSurface = PS3_LockHWSurface; 121 this->UnlockHWSurface = PS3_UnlockHWSurface; 122 this->FlipHWSurface = PS3_FlipDoubleBuffer; 123 this->FreeHWSurface = PS3_FreeHWSurface; 124 this->SetCaption = 0; 125 this->SetIcon = 0; 126 this->IconifyWindow = 0; 127 this->GrabInput = 0; 128 this->GetWMInfo = 0; 129 this->InitOSKeymap = PS3_InitOSKeymap; 130 this->PumpEvents = PS3_PumpEvents; 131 132 this->free = PS3_DeleteDevice; 133 134 return this; 135 } 136 137 138 /* Bootstraping (see SDL_sysvideo.h) */ 139 VideoBootStrap PS3_bootstrap = { 140 "ps3", "PS3 Cell SPU Driver", 141 PS3_Available, PS3_CreateDevice 142 }; 143 144 145 /* Delete the device */ 146 static void PS3_DeleteDevice(SDL_VideoDevice * device) 147 { 148 free(device->hidden); 149 free(device); 150 } 151 152 153 /* Initialise the PS3 video device */ 154 static int PS3_VideoInit(_THIS, SDL_PixelFormat * vformat) 155 { 156 /* Hide the cursor */ 157 enable_cursor(0); 158 159 /* Create SPU fb_parms and thread structure */ 160 fb_parms = (struct fb_writer_parms_t *) 161 memalign(16, sizeof(struct fb_writer_parms_t)); 162 fb_thread_data = (spu_data_t *) malloc(sizeof(spu_data_t)); 163 if (fb_parms == NULL || fb_thread_data == NULL) { 164 SDL_OutOfMemory(); 165 return -1; 166 } 167 fb_thread_data->program = fb_writer_spu; 168 fb_thread_data->program_name = "fb_writer_spu"; 169 fb_thread_data->argp = (void *)fb_parms; 170 fb_thread_data->keepalive = 1; 171 fb_thread_data->booted = 0; 172 173 SPE_Start(this, fb_thread_data); 174 175 /* Open the device */ 176 fb_dev_fd = open(PS3_DEV_FB, O_RDWR); 177 if (fb_dev_fd < 0) { 178 SDL_SetError("[PS3] Unable to open device %s", PS3_DEV_FB); 179 return -1; 180 } 181 182 /* Get vscreeninfo */ 183 if (ioctl(fb_dev_fd, FBIOGET_VSCREENINFO, &fb_vinfo)) { 184 SDL_SetError("[PS3] Can't get VSCREENINFO"); 185 if (fb_dev_fd >= 0) 186 close(fb_dev_fd); 187 fb_dev_fd = -1; 188 return -1; 189 } 190 191 /* Fill in our hardware acceleration capabilities */ 192 this->info.current_w = fb_vinfo.xres; 193 this->info.current_h = fb_vinfo.yres; 194 this->info.wm_available = 0; 195 this->info.hw_available = 1; 196 197 /* Backup the original vinfo to restore later */ 198 fb_orig_vinfo = fb_vinfo; 199 200 /* 16 and 15 bpp is reported as 16 bpp */ 201 fb_bits_per_pixel = fb_vinfo.bits_per_pixel; 202 if (fb_bits_per_pixel == 16) 203 fb_bits_per_pixel = 204 fb_vinfo.red.length + fb_vinfo.green.length + 205 fb_vinfo.blue.length; 206 207 /* Set SDL_PixelFormat */ 208 vformat->BitsPerPixel = fb_vinfo.bits_per_pixel; 209 210 fb_vinfo.xres_virtual = fb_vinfo.xres; 211 fb_vinfo.yres_virtual = fb_vinfo.yres; 212 213 /* Put vscreeninfo */ 214 if (ioctl(fb_dev_fd, FBIOPUT_VSCREENINFO, &fb_vinfo)) { 215 SDL_SetError("[PS3] Can't put VSCREENINFO"); 216 if (fb_dev_fd >= 0) 217 close(fb_dev_fd); 218 fb_dev_fd = -1; 219 return -1; 220 } 221 222 s_fb_pixel_size = fb_vinfo.bits_per_pixel / 8; 223 224 s_writeable_width = fb_vinfo.xres; 225 s_writeable_height = fb_vinfo.yres; 226 227 /* Get ps3 screeninfo */ 228 if (ioctl(fb_dev_fd, PS3FB_IOCTL_SCREENINFO, (unsigned long)&res) < 0) { 229 SDL_SetError("[PS3] PS3FB_IOCTL_SCREENINFO failed"); 230 } 231 deprintf(1, "[PS3] xres:%d yres:%d xoff:%d yoff:%d\n", res.xres, res.yres, res.xoff, res.yoff); 232 233 /* Only use double buffering if enough fb memory is available */ 234 if (res.num_frames < 2) { 235 double_buffering = 0; 236 } else { 237 double_buffering = 1; 238 } 239 240 real_width = res.xres; 241 real_height = res.yres; 242 243 /* 244 * Take control of frame buffer from kernel, for details see 245 * http://felter.org/wesley/files/ps3/linux-20061110-docs/ApplicationProgrammingEnvironment.html 246 * kernel will no longer flip the screen itself 247 */ 248 ioctl(fb_dev_fd, PS3FB_IOCTL_ON, 0); 249 250 /* Unblank screen */ 251 ioctl(fb_dev_fd, FBIOBLANK, 0); 252 253 return 0; 254 } 255 256 257 /* List available PS3 resolutions */ 258 static SDL_Rect **PS3_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags) 259 { 260 /* A list of video resolutions that we query for (sorted largest to 261 * smallest) 262 */ 263 static SDL_Rect PS3_resolutions[] = { 264 {0, 0, 1920, 1080}, // 1080p 16:9 HD 265 {0, 0, 1600, 1200}, // WUXGA 266 {0, 0, 1280, 1024}, // SXGA 267 {0, 0, 1280, 720}, // 720p 16:9 HD 268 {0, 0, 1024, 768}, // WXGA 269 {0, 0, 1024, 576}, // 576p 16:9 270 {0, 0, 853, 480}, // 480p 16:9 271 {0, 0, 720, 576}, // 576p 4:3 (PAL) 272 {0, 0, 720, 480}, // 480p 16:9 (NTSC) 273 }; 274 static SDL_Rect *PS3_modes[] = { 275 &PS3_resolutions[0], 276 &PS3_resolutions[1], 277 &PS3_resolutions[2], 278 &PS3_resolutions[3], 279 &PS3_resolutions[4], 280 &PS3_resolutions[5], 281 &PS3_resolutions[6], 282 &PS3_resolutions[7], 283 &PS3_resolutions[8], 284 NULL 285 }; 286 SDL_Rect **modes = PS3_modes; 287 288 return modes; 289 } 290 291 292 /* Get a list of the available display modes */ 293 static SDL_Surface *PS3_SetVideoMode(_THIS, SDL_Surface * current, int width, int height, int bpp, Uint32 flags) 294 { 295 s_bounded_input_width = width < s_writeable_width ? width : s_writeable_width; 296 s_bounded_input_height = height < s_writeable_height ? height : s_writeable_height; 297 s_bounded_input_width_offset = (s_writeable_width - s_bounded_input_width) >> 1; 298 s_bounded_input_height_offset = (s_writeable_height - s_bounded_input_height) >> 1; 299 s_input_line_length = width * s_fb_pixel_size; 300 301 current->flags |= flags; 302 303 if (ioctl(fb_dev_fd, FBIOGET_FSCREENINFO, &fb_finfo)) { 304 SDL_SetError("[PS3] Can't get fixed screeninfo"); 305 return NULL; 306 } 307 308 if (fb_finfo.type != FB_TYPE_PACKED_PIXELS) { 309 SDL_SetError("[PS3] type %s not supported", 310 fb_finfo.type); 311 return NULL; 312 } 313 314 /* Note: on PS3, fb_finfo.smem_len is enough for double buffering */ 315 if ((frame_buffer = 316 (uint8_t *) mmap(0, fb_finfo.smem_len, 317 PROT_READ | PROT_WRITE, MAP_SHARED, 318 fb_dev_fd, 0)) == (uint8_t *) - 1) { 319 SDL_SetError("[PS3] Can't mmap for %s", PS3_DEV_FB); 320 return NULL; 321 } else { 322 current->flags |= SDL_DOUBLEBUF; 323 } 324 if (!SDL_ReallocFormat(current, fb_bits_per_pixel, 0, 0, 0, 0)) { 325 return (NULL); 326 } 327 328 /* Blank screen */ 329 memset(frame_buffer, 0x00, fb_finfo.smem_len); 330 331 /* Centering */ 332 s_center[0] = 333 frame_buffer + s_bounded_input_width_offset * s_fb_pixel_size + 334 s_bounded_input_height_offset * fb_finfo.line_length; 335 s_center[1] = s_center[0] + real_height * fb_finfo.line_length; 336 s_center_index = 0; 337 338 current->flags |= SDL_FULLSCREEN; 339 current->w = width; 340 current->h = height; 341 current->pitch = SDL_CalculatePitch(current); 342 343 /* Alloc aligned mem for current->pixels */ 344 s_pixels = memalign(16, current->h * current->pitch); 345 current->pixels = (void *)s_pixels; 346 if (!current->pixels) { 347 SDL_OutOfMemory(); 348 return NULL; 349 } 350 351 /* Set the update rectangle function */ 352 this->UpdateRects = PS3_DoubleBufferUpdate; 353 354 return current; 355 } 356 357 358 /* Copy screen to framebuffer and flip */ 359 void PS3_DoubleBufferUpdate(_THIS, int numrects, SDL_Rect * rects) 360 { 361 if (converter_thread_data && converter_thread_data->booted) 362 SPE_WaitForMsg(this, converter_thread_data, SPU_FIN); 363 364 /* Adjust centering */ 365 s_bounded_input_width_offset = (s_writeable_width - s_bounded_input_width) >> 1; 366 s_bounded_input_height_offset = (s_writeable_height - s_bounded_input_height) >> 1; 367 s_center[0] = frame_buffer + s_bounded_input_width_offset * s_fb_pixel_size + 368 s_bounded_input_height_offset * fb_finfo.line_length; 369 s_center[1] = s_center[0] + real_height * fb_finfo.line_length; 370 371 /* Set SPU parms for copying the surface to framebuffer */ 372 fb_parms->data = (unsigned char *)s_pixels; 373 fb_parms->center = s_center[s_center_index]; 374 fb_parms->out_line_stride = fb_finfo.line_length; 375 fb_parms->in_line_stride = s_input_line_length; 376 fb_parms->bounded_input_height = s_bounded_input_height; 377 fb_parms->bounded_input_width = s_bounded_input_width; 378 fb_parms->fb_pixel_size = s_fb_pixel_size; 379 380 deprintf(3, "[PS3->SPU] fb_thread_data->argp = 0x%x\n", fb_thread_data->argp); 381 382 /* Copying.. */ 383 SPE_SendMsg(this, fb_thread_data, SPU_START); 384 SPE_SendMsg(this, fb_thread_data, (unsigned int)fb_thread_data->argp); 385 386 SPE_WaitForMsg(this, fb_thread_data, SPU_FIN); 387 388 /* Flip the pages */ 389 if (double_buffering) 390 s_center_index = s_center_index ^ 0x01; 391 PS3_FlipDoubleBuffer(this, this->screen); 392 } 393 394 395 /* Enable/Disable cursor */ 396 void enable_cursor(int enable) 397 { 398 int fd = open("/dev/console", O_RDWR | O_NONBLOCK); 399 if (fd >= 0) { 400 ioctl(fd, KDSETMODE, enable ? KD_TEXT : KD_GRAPHICS); 401 close(fd); 402 } 403 } 404 405 406 static int PS3_AllocHWSurface(_THIS, SDL_Surface * surface) 407 { 408 return -1; 409 } 410 411 412 static void PS3_FreeHWSurface(_THIS, SDL_Surface * surface) 413 { 414 return; 415 } 416 417 418 static int PS3_LockHWSurface(_THIS, SDL_Surface * surface) 419 { 420 return 0; 421 } 422 423 424 static void PS3_UnlockHWSurface(_THIS, SDL_Surface * surface) 425 { 426 return; 427 } 428 429 430 /* Blit/Flip buffer to the screen. Must be called after each frame! */ 431 int PS3_FlipDoubleBuffer(_THIS, SDL_Surface * surface) 432 { 433 unsigned long crt = 0; 434 /* Wait for vsync */ 435 deprintf(1, "[PS3] Wait for vsync\n"); 436 ioctl(fb_dev_fd, FBIO_WAITFORVSYNC, &crt); 437 /* Page flip */ 438 deprintf(1, "[PS3] Page flip to buffer #%u 0x%x\n", s_center_index, s_center[s_center_index]); 439 ioctl(fb_dev_fd, PS3FB_IOCTL_FSEL, (unsigned long)&s_center_index); 440 return 1; 441 } 442 443 444 /* Start the SPE thread */ 445 int SPE_Start(_THIS, spu_data_t * spe_data) 446 { 447 deprintf(2, "[PS3->SPU] Start SPE: %s\n", spe_data->program_name); 448 if (!(spe_data->booted)) 449 SPE_Boot(this, spe_data); 450 451 /* To allow re-running of context, spe_ctx_entry has to be set before each call */ 452 spe_data->entry = SPE_DEFAULT_ENTRY; 453 spe_data->error_code = 0; 454 455 /* Create SPE thread and run */ 456 deprintf(2, "[PS3->SPU] Create Thread: %s\n", spe_data->program_name); 457 if (pthread_create 458 (&spe_data->thread, NULL, (void *)&SPE_RunContext, (void *)spe_data)) { 459 deprintf(2, "[PS3->SPU] Could not create pthread for spe: %s\n", spe_data->program_name); 460 SDL_SetError("[PS3->SPU] Could not create pthread for spe"); 461 return -1; 462 } 463 464 if (spe_data->keepalive) 465 SPE_WaitForMsg(this, spe_data, SPU_READY); 466 } 467 468 469 /* Stop the SPE thread */ 470 int SPE_Stop(_THIS, spu_data_t * spe_data) 471 { 472 deprintf(2, "[PS3->SPU] Stop SPE: %s\n", spe_data->program_name); 473 /* Wait for SPE thread to complete */ 474 deprintf(2, "[PS3->SPU] Wait for SPE thread to complete: %s\n", spe_data->program_name); 475 if (pthread_join(spe_data->thread, NULL)) { 476 deprintf(2, "[PS3->SPU] Failed joining the thread: %s\n", spe_data->program_name); 477 SDL_SetError("[PS3->SPU] Failed joining the thread"); 478 return -1; 479 } 480 481 return 0; 482 } 483 484 485 /* Create SPE context and load program */ 486 int SPE_Boot(_THIS, spu_data_t * spe_data) 487 { 488 /* Create SPE context */ 489 deprintf(2, "[PS3->SPU] Create SPE Context: %s\n", spe_data->program_name); 490 spe_data->ctx = spe_context_create(0, NULL); 491 if (spe_data->ctx == NULL) { 492 deprintf(2, "[PS3->SPU] Failed creating SPE context: %s\n", spe_data->program_name); 493 SDL_SetError("[PS3->SPU] Failed creating SPE context"); 494 return -1; 495 } 496 497 /* Load SPE object into SPE local store */ 498 deprintf(2, "[PS3->SPU] Load Program into SPE: %s\n", spe_data->program_name); 499 if (spe_program_load(spe_data->ctx, &spe_data->program)) { 500 deprintf(2, "[PS3->SPU] Failed loading program into SPE context: %s\n", spe_data->program_name); 501 SDL_SetError 502 ("[PS3->SPU] Failed loading program into SPE context"); 503 return -1; 504 } 505 spe_data->booted = 1; 506 deprintf(2, "[PS3->SPU] SPE boot successful\n"); 507 508 return 0; 509 } 510 511 /* (Stop and) shutdown the SPE */ 512 int SPE_Shutdown(_THIS, spu_data_t * spe_data) 513 { 514 if (spe_data->keepalive && spe_data->booted) { 515 SPE_SendMsg(this, spe_data, SPU_EXIT); 516 SPE_Stop(this, spe_data); 517 } 518 519 /* Destroy SPE context */ 520 deprintf(2, "[PS3->SPU] Destroy SPE context: %s\n", spe_data->program_name); 521 if (spe_context_destroy(spe_data->ctx)) { 522 deprintf(2, "[PS3->SPU] Failed destroying context: %s\n", spe_data->program_name); 523 SDL_SetError("[PS3->SPU] Failed destroying context"); 524 return -1; 525 } 526 deprintf(2, "[PS3->SPU] SPE shutdown successful: %s\n", spe_data->program_name); 527 return 0; 528 } 529 530 531 /* Send message to the SPE via mailboxe */ 532 int SPE_SendMsg(_THIS, spu_data_t * spe_data, unsigned int msg) 533 { 534 deprintf(2, "[PS3->SPU] Sending message %u to %s\n", msg, spe_data->program_name); 535 /* Send one message, block until message was sent */ 536 unsigned int spe_in_mbox_msgs[1]; 537 spe_in_mbox_msgs[0] = msg; 538 int in_mbox_write = spe_in_mbox_write(spe_data->ctx, spe_in_mbox_msgs, 1, SPE_MBOX_ALL_BLOCKING); 539 540 if (1 > in_mbox_write) { 541 deprintf(2, "[PS3->SPU] No message could be written to %s\n", spe_data->program_name); 542 SDL_SetError("[PS3->SPU] No message could be written"); 543 return -1; 544 } 545 return 0; 546 } 547 548 549 /* Read 1 message from SPE, block until at least 1 message was received */ 550 int SPE_WaitForMsg(_THIS, spu_data_t * spe_data, unsigned int msg) 551 { 552 deprintf(2, "[PS3->SPU] Waiting for message from %s\n", spe_data->program_name); 553 unsigned int out_messages[1]; 554 while (!spe_out_mbox_status(spe_data->ctx)); 555 int mbox_read = spe_out_mbox_read(spe_data->ctx, out_messages, 1); 556 deprintf(2, "[PS3->SPU] Got message from %s, message was %u\n", spe_data->program_name, out_messages[0]); 557 if (out_messages[0] == msg) 558 return 0; 559 else 560 return -1; 561 } 562 563 564 /* Re-runnable invocation of the spe_context_run call */ 565 void SPE_RunContext(void *thread_argp) 566 { 567 /* argp is the pointer to argument to be passed to the SPE program */ 568 spu_data_t *args = (spu_data_t *) thread_argp; 569 deprintf(3, "[PS3->SPU] void* argp=0x%x\n", (unsigned int)args->argp); 570 571 /* Run it.. */ 572 deprintf(2, "[PS3->SPU] Run SPE program: %s\n", args->program_name); 573 if (spe_context_run 574 (args->ctx, &args->entry, 0, (void *)args->argp, NULL, 575 NULL) < 0) { 576 deprintf(2, "[PS3->SPU] Failed running SPE context: %s\n", args->program_name); 577 SDL_SetError("[PS3->SPU] Failed running SPE context: %s", args->program_name); 578 exit(1); 579 } 580 581 pthread_exit(NULL); 582 } 583 584 585 /* Quits the video driver */ 586 static void PS3_VideoQuit(_THIS) 587 { 588 if (fb_dev_fd > 0) { 589 /* Restore the original video mode */ 590 if (ioctl(fb_dev_fd, FBIOPUT_VSCREENINFO, &fb_orig_vinfo)) 591 SDL_SetError("[PS3] Can't restore original fb_var_screeninfo"); 592 593 /* Give control of frame buffer to kernel */ 594 ioctl(fb_dev_fd, PS3FB_IOCTL_OFF, 0); 595 close(fb_dev_fd); 596 fb_dev_fd = -1; 597 } 598 599 if (frame_buffer) { 600 munmap(frame_buffer, fb_finfo.smem_len); 601 frame_buffer = 0; 602 } 603 604 if (fb_parms) 605 free((void *)fb_parms); 606 if (fb_thread_data) { 607 SPE_Shutdown(this, fb_thread_data); 608 free((void *)fb_thread_data); 609 } 610 611 if (this->screen) { 612 if (double_buffering && this->screen->pixels) { 613 free(this->screen->pixels); 614 } 615 this->screen->pixels = NULL; 616 } 617 618 enable_cursor(1); 619 deprintf(1, "[PS3] VideoQuit\n"); 620 } 621 622
