1/* 2 * linux/drivers/video/ps3fb.c -- PS3 GPU frame buffer device 3 * 4 * Copyright (C) 2006 Sony Computer Entertainment Inc. 5 * Copyright 2006, 2007 Sony Corporation 6 * 7 * This file is based on : 8 * 9 * linux/drivers/video/vfb.c -- Virtual frame buffer device 10 * 11 * Copyright (C) 2002 James Simmons 12 * 13 * Copyright (C) 1997 Geert Uytterhoeven 14 * 15 * This file is subject to the terms and conditions of the GNU General Public 16 * License. See the file COPYING in the main directory of this archive for 17 * more details. 18 */ 19 20#include <linux/module.h> 21#include <linux/kernel.h> 22#include <linux/errno.h> 23#include <linux/string.h> 24#include <linux/mm.h> 25#include <linux/tty.h> 26#include <linux/slab.h> 27#include <linux/vmalloc.h> 28#include <linux/delay.h> 29#include <linux/interrupt.h> 30#include <linux/platform_device.h> 31#include <linux/console.h> 32#include <linux/ioctl.h> 33#include <linux/notifier.h> 34#include <linux/reboot.h> 35#include <linux/kthread.h> 36#include <linux/freezer.h> 37 38#include <asm/uaccess.h> 39#include <linux/fb.h> 40#include <linux/init.h> 41#include <asm/time.h> 42 43#include <asm/abs_addr.h> 44#include <asm/lv1call.h> 45#include <asm/ps3av.h> 46#include <asm/ps3fb.h> 47#include <asm/ps3.h> 48 49#ifdef PS3FB_DEBUG 50#define DPRINTK(fmt, args...) printk("%s: " fmt, __func__ , ##args) 51#else 52#define DPRINTK(fmt, args...) 53#endif 54 55#define L1GPU_CONTEXT_ATTRIBUTE_DISPLAY_SYNC 0x101 56#define L1GPU_CONTEXT_ATTRIBUTE_DISPLAY_FLIP 0x102 57#define L1GPU_CONTEXT_ATTRIBUTE_FB_SETUP 0x600 58#define L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT 0x601 59#define L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT_SYNC 0x602 60 61#define L1GPU_FB_BLIT_WAIT_FOR_COMPLETION (1ULL << 32) 62 63#define L1GPU_DISPLAY_SYNC_HSYNC 1 64#define L1GPU_DISPLAY_SYNC_VSYNC 2 65 66#define DDR_SIZE (0) /* used no ddr */ 67#define GPU_OFFSET (64 * 1024) 68#define GPU_IOIF (0x0d000000UL) 69 70#define PS3FB_FULL_MODE_BIT 0x80 71 72#define GPU_INTR_STATUS_VSYNC_0 0 /* vsync on head A */ 73#define GPU_INTR_STATUS_VSYNC_1 1 /* vsync on head B */ 74#define GPU_INTR_STATUS_FLIP_0 3 /* flip head A */ 75#define GPU_INTR_STATUS_FLIP_1 4 /* flip head B */ 76#define GPU_INTR_STATUS_QUEUE_0 5 /* queue head A */ 77#define GPU_INTR_STATUS_QUEUE_1 6 /* queue head B */ 78 79#define GPU_DRIVER_INFO_VERSION 0x211 80 81/* gpu internals */ 82struct display_head { 83 u64 be_time_stamp; 84 u32 status; 85 u32 offset; 86 u32 res1; 87 u32 res2; 88 u32 field; 89 u32 reserved1; 90 91 u64 res3; 92 u32 raster; 93 94 u64 vblank_count; 95 u32 field_vsync; 96 u32 reserved2; 97}; 98 99struct gpu_irq { 100 u32 irq_outlet; 101 u32 status; 102 u32 mask; 103 u32 video_cause; 104 u32 graph_cause; 105 u32 user_cause; 106 107 u32 res1; 108 u64 res2; 109 110 u32 reserved[4]; 111}; 112 113struct gpu_driver_info { 114 u32 version_driver; 115 u32 version_gpu; 116 u32 memory_size; 117 u32 hardware_channel; 118 119 u32 nvcore_frequency; 120 u32 memory_frequency; 121 122 u32 reserved[1063]; 123 struct display_head display_head[8]; 124 struct gpu_irq irq; 125}; 126 127struct ps3fb_priv { 128 unsigned int irq_no; 129 void *dev; 130 131 u64 context_handle, memory_handle; 132 void *xdr_ea; 133 struct gpu_driver_info *dinfo; 134 u32 res_index; 135 136 u64 vblank_count; /* frame count */ 137 wait_queue_head_t wait_vsync; 138 139 u32 num_frames; /* num of frame buffers */ 140 atomic_t ext_flip; /* on/off flip with vsync */ 141 atomic_t f_count; /* fb_open count */ 142 int is_blanked; 143 int is_kicked; 144 struct task_struct *task; 145}; 146static struct ps3fb_priv ps3fb; 147 148struct ps3fb_res_table { 149 u32 xres; 150 u32 yres; 151 u32 xoff; 152 u32 yoff; 153 u32 type; 154}; 155#define PS3FB_RES_FULL 1 156static const struct ps3fb_res_table ps3fb_res[] = { 157 /* res_x,y margin_x,y full */ 158 { 720, 480, 72, 48 , 0}, 159 { 720, 576, 72, 58 , 0}, 160 { 1280, 720, 78, 38 , 0}, 161 { 1920, 1080, 116, 58 , 0}, 162 /* full mode */ 163 { 720, 480, 0, 0 , PS3FB_RES_FULL}, 164 { 720, 576, 0, 0 , PS3FB_RES_FULL}, 165 { 1280, 720, 0, 0 , PS3FB_RES_FULL}, 166 { 1920, 1080, 0, 0 , PS3FB_RES_FULL}, 167 /* vesa: normally full mode */ 168 { 1280, 768, 0, 0 , 0}, 169 { 1280, 1024, 0, 0 , 0}, 170 { 1920, 1200, 0, 0 , 0}, 171 { 0, 0, 0, 0 , 0} }; 172 173/* default resolution */ 174#define GPU_RES_INDEX 0 /* 720 x 480 */ 175 176static const struct fb_videomode ps3fb_modedb[] = { 177 /* 60 Hz broadcast modes (modes "1" to "5") */ 178 { 179 /* 480i */ 180 "480i", 60, 576, 384, 74074, 130, 89, 78, 57, 63, 6, 181 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED 182 }, { 183 /* 480p */ 184 "480p", 60, 576, 384, 37037, 130, 89, 78, 57, 63, 6, 185 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 186 }, { 187 /* 720p */ 188 "720p", 60, 1124, 644, 13481, 298, 148, 57, 44, 80, 5, 189 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 190 }, { 191 /* 1080i */ 192 "1080i", 60, 1688, 964, 13481, 264, 160, 94, 62, 88, 5, 193 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED 194 }, { 195 /* 1080p */ 196 "1080p", 60, 1688, 964, 6741, 264, 160, 94, 62, 88, 5, 197 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 198 }, 199 200 /* 50 Hz broadcast modes (modes "6" to "10") */ 201 { 202 /* 576i */ 203 "576i", 50, 576, 460, 74074, 142, 83, 97, 63, 63, 5, 204 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED 205 }, { 206 /* 576p */ 207 "576p", 50, 576, 460, 37037, 142, 83, 97, 63, 63, 5, 208 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 209 }, { 210 /* 720p */ 211 "720p", 50, 1124, 644, 13468, 298, 478, 57, 44, 80, 5, 212 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 213 }, { 214 /* 1080 */ 215 "1080i", 50, 1688, 964, 13468, 264, 600, 94, 62, 88, 5, 216 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED 217 }, { 218 /* 1080p */ 219 "1080p", 50, 1688, 964, 6734, 264, 600, 94, 62, 88, 5, 220 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 221 }, 222 223 /* VESA modes (modes "11" to "13") */ 224 { 225 /* WXGA */ 226 "wxga", 60, 1280, 768, 12924, 160, 24, 29, 3, 136, 6, 227 0, FB_VMODE_NONINTERLACED, 228 FB_MODE_IS_VESA 229 }, { 230 /* SXGA */ 231 "sxga", 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3, 232 FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED, 233 FB_MODE_IS_VESA 234 }, { 235 /* WUXGA */ 236 "wuxga", 60, 1920, 1200, 6494, 80, 48, 26, 3, 32, 6, 237 FB_SYNC_HOR_HIGH_ACT, FB_VMODE_NONINTERLACED, 238 FB_MODE_IS_VESA 239 }, 240 241 /* 60 Hz broadcast modes (full resolution versions of modes "1" to "5") */ 242 { 243 /* 480if */ 244 "480if", 60, 720, 480, 74074, 58, 17, 30, 9, 63, 6, 245 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED 246 }, { 247 /* 480pf */ 248 "480pf", 60, 720, 480, 37037, 58, 17, 30, 9, 63, 6, 249 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 250 }, { 251 /* 720pf */ 252 "720pf", 60, 1280, 720, 13481, 220, 70, 19, 6, 80, 5, 253 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 254 }, { 255 /* 1080if */ 256 "1080if", 60, 1920, 1080, 13481, 148, 44, 36, 4, 88, 5, 257 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED 258 }, { 259 /* 1080pf */ 260 "1080pf", 60, 1920, 1080, 6741, 148, 44, 36, 4, 88, 5, 261 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 262 }, 263 264 /* 50 Hz broadcast modes (full resolution versions of modes "6" to "10") */ 265 { 266 /* 576if */ 267 "576if", 50, 720, 576, 74074, 70, 11, 39, 5, 63, 5, 268 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED 269 }, { 270 /* 576pf */ 271 "576pf", 50, 720, 576, 37037, 70, 11, 39, 5, 63, 5, 272 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 273 }, { 274 /* 720pf */ 275 "720pf", 50, 1280, 720, 13468, 220, 400, 19, 6, 80, 5, 276 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 277 }, { 278 /* 1080if */ 279 "1080f", 50, 1920, 1080, 13468, 148, 484, 36, 4, 88, 5, 280 FB_SYNC_BROADCAST, FB_VMODE_INTERLACED 281 }, { 282 /* 1080pf */ 283 "1080pf", 50, 1920, 1080, 6734, 148, 484, 36, 4, 88, 5, 284 FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED 285 } 286}; 287 288 289#define HEAD_A 290#define HEAD_B 291 292#define X_OFF(i) (ps3fb_res[i].xoff) /* left/right margin (pixel) */ 293#define Y_OFF(i) (ps3fb_res[i].yoff) /* top/bottom margin (pixel) */ 294#define WIDTH(i) (ps3fb_res[i].xres) /* width of FB */ 295#define HEIGHT(i) (ps3fb_res[i].yres) /* height of FB */ 296#define BPP 4 /* number of bytes per pixel */ 297#define VP_OFF(i) (WIDTH(i) * Y_OFF(i) * BPP + X_OFF(i) * BPP) 298#define FB_OFF(i) (GPU_OFFSET - VP_OFF(i) % GPU_OFFSET) 299 300static int ps3fb_mode; 301module_param(ps3fb_mode, bool, 0); 302 303static char *mode_option __initdata; 304 305 306static int ps3fb_get_res_table(u32 xres, u32 yres) 307{ 308 int full_mode; 309 unsigned int i; 310 u32 x, y, f; 311 312 full_mode = (ps3fb_mode & PS3FB_FULL_MODE_BIT) ? PS3FB_RES_FULL : 0; 313 for (i = 0;; i++) { 314 x = ps3fb_res[i].xres; 315 y = ps3fb_res[i].yres; 316 f = ps3fb_res[i].type; 317 318 if (!x) { 319 DPRINTK("ERROR: ps3fb_get_res_table()\n"); 320 return -1; 321 } 322 323 if (full_mode == PS3FB_RES_FULL && f != PS3FB_RES_FULL) 324 continue; 325 326 if (x == xres && (yres == 0 || y == yres)) 327 break; 328 329 x = x - 2 * ps3fb_res[i].xoff; 330 y = y - 2 * ps3fb_res[i].yoff; 331 if (x == xres && (yres == 0 || y == yres)) 332 break; 333 } 334 return i; 335} 336 337static unsigned int ps3fb_find_mode(const struct fb_var_screeninfo *var, 338 u32 *line_length) 339{ 340 unsigned int i, mode; 341 342 for (i = 0; i < ARRAY_SIZE(ps3fb_modedb); i++) 343 if (var->xres == ps3fb_modedb[i].xres && 344 var->yres == ps3fb_modedb[i].yres && 345 var->pixclock == ps3fb_modedb[i].pixclock && 346 var->hsync_len == ps3fb_modedb[i].hsync_len && 347 var->vsync_len == ps3fb_modedb[i].vsync_len && 348 var->left_margin == ps3fb_modedb[i].left_margin && 349 var->right_margin == ps3fb_modedb[i].right_margin && 350 var->upper_margin == ps3fb_modedb[i].upper_margin && 351 var->lower_margin == ps3fb_modedb[i].lower_margin && 352 var->sync == ps3fb_modedb[i].sync && 353 (var->vmode & FB_VMODE_MASK) == ps3fb_modedb[i].vmode) { 354 /* Cropped broadcast modes use the full line_length */ 355 *line_length = 356 ps3fb_modedb[i < 10 ? i + 13 : i].xres * 4; 357 /* Full broadcast modes have the full mode bit set */ 358 mode = i > 12 ? (i - 12) | PS3FB_FULL_MODE_BIT : i + 1; 359 360 DPRINTK("ps3fb_find_mode: mode %u\n", mode); 361 return mode; 362 } 363 364 DPRINTK("ps3fb_find_mode: mode not found\n"); 365 return 0; 366 367} 368 369static const struct fb_videomode *ps3fb_default_mode(void) 370{ 371 u32 mode = ps3fb_mode & PS3AV_MODE_MASK; 372 u32 flags; 373 374 if (mode < 1 || mode > 13) 375 return NULL; 376 377 flags = ps3fb_mode & ~PS3AV_MODE_MASK; 378 379 if (mode <= 10 && flags & PS3FB_FULL_MODE_BIT) { 380 /* Full broadcast mode */ 381 return &ps3fb_modedb[mode + 12]; 382 } 383 384 return &ps3fb_modedb[mode - 1]; 385} 386 387static int ps3fb_sync(u32 frame) 388{ 389 int i, status; 390 u32 xres, yres; 391 u64 fb_ioif, offset; 392 393 i = ps3fb.res_index; 394 xres = ps3fb_res[i].xres; 395 yres = ps3fb_res[i].yres; 396 397 if (frame > ps3fb.num_frames - 1) { 398 printk(KERN_WARNING "%s: invalid frame number (%u)\n", 399 __func__, frame); 400 return -EINVAL; 401 } 402 offset = xres * yres * BPP * frame; 403 404 fb_ioif = GPU_IOIF + FB_OFF(i) + offset; 405 status = lv1_gpu_context_attribute(ps3fb.context_handle, 406 L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT, 407 offset, fb_ioif, 408 L1GPU_FB_BLIT_WAIT_FOR_COMPLETION | 409 (xres << 16) | yres, 410 xres * BPP); /* line_length */ 411 if (status) 412 printk(KERN_ERR 413 "%s: lv1_gpu_context_attribute FB_BLIT failed: %d\n", 414 __func__, status); 415#ifdef HEAD_A 416 status = lv1_gpu_context_attribute(ps3fb.context_handle, 417 L1GPU_CONTEXT_ATTRIBUTE_DISPLAY_FLIP, 418 0, offset, 0, 0); 419 if (status) 420 printk(KERN_ERR 421 "%s: lv1_gpu_context_attribute FLIP failed: %d\n", 422 __func__, status); 423#endif 424#ifdef HEAD_B 425 status = lv1_gpu_context_attribute(ps3fb.context_handle, 426 L1GPU_CONTEXT_ATTRIBUTE_DISPLAY_FLIP, 427 1, offset, 0, 0); 428 if (status) 429 printk(KERN_ERR 430 "%s: lv1_gpu_context_attribute FLIP failed: %d\n", 431 __func__, status); 432#endif 433 return 0; 434} 435 436 437static int ps3fb_open(struct fb_info *info, int user) 438{ 439 atomic_inc(&ps3fb.f_count); 440 return 0; 441} 442 443static int ps3fb_release(struct fb_info *info, int user) 444{ 445 if (atomic_dec_and_test(&ps3fb.f_count)) { 446 if (atomic_read(&ps3fb.ext_flip)) { 447 atomic_set(&ps3fb.ext_flip, 0); 448 ps3fb_sync(0); /* single buffer */ 449 } 450 } 451 return 0; 452} 453 454 /* 455 * Setting the video mode has been split into two parts. 456 * First part, xxxfb_check_var, must not write anything 457 * to hardware, it should only verify and adjust var. 458 * This means it doesn't alter par but it does use hardware 459 * data from it to check this var. 460 */ 461 462static int ps3fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info) 463{ 464 u32 line_length; 465 int mode; 466 int i; 467 468 DPRINTK("var->xres:%u info->var.xres:%u\n", var->xres, info->var.xres); 469 DPRINTK("var->yres:%u info->var.yres:%u\n", var->yres, info->var.yres); 470 471 mode = ps3fb_find_mode(var, &line_length); 472 if (!mode) 473 return -EINVAL; 474 475 /* 476 * FB_VMODE_CONUPDATE and FB_VMODE_SMOOTH_XPAN are equal! 477 * as FB_VMODE_SMOOTH_XPAN is only used internally 478 */ 479 480 if (var->vmode & FB_VMODE_CONUPDATE) { 481 var->vmode |= FB_VMODE_YWRAP; 482 var->xoffset = info->var.xoffset; 483 var->yoffset = info->var.yoffset; 484 } 485 486 /* Virtual screen and panning are not supported */ 487 if (var->xres_virtual > var->xres || var->yres_virtual > var->yres || 488 var->xoffset || var->yoffset) { 489 DPRINTK("Virtual screen and panning are not supported\n"); 490 return -EINVAL; 491 } 492 493 var->xres_virtual = var->xres; 494 var->yres_virtual = var->yres; 495 496 /* We support ARGB8888 only */ 497 if (var->bits_per_pixel > 32 || var->grayscale || 498 var->red.offset > 16 || var->green.offset > 8 || 499 var->blue.offset > 0 || var->transp.offset > 24 || 500 var->red.length > 8 || var->green.length > 8 || 501 var->blue.length > 8 || var->transp.length > 8 || 502 var->red.msb_right || var->green.msb_right || 503 var->blue.msb_right || var->transp.msb_right || var->nonstd) { 504 DPRINTK("We support ARGB8888 only\n"); 505 return -EINVAL; 506 } 507 508 var->bits_per_pixel = 32; 509 var->red.offset = 16; 510 var->green.offset = 8; 511 var->blue.offset = 0; 512 var->transp.offset = 24; 513 var->red.length = 8; 514 var->green.length = 8; 515 var->blue.length = 8; 516 var->transp.length = 8; 517 var->red.msb_right = 0; 518 var->green.msb_right = 0; 519 var->blue.msb_right = 0; 520 var->transp.msb_right = 0; 521 522 /* Rotation is not supported */ 523 if (var->rotate) { 524 DPRINTK("Rotation is not supported\n"); 525 return -EINVAL; 526 } 527 528 /* Memory limit */ 529 i = ps3fb_get_res_table(var->xres, var->yres); 530 if (ps3fb_res[i].xres*ps3fb_res[i].yres*BPP > ps3fb_videomemory.size) { 531 DPRINTK("Not enough memory\n"); 532 return -ENOMEM; 533 } 534 535 var->height = -1; 536 var->width = -1; 537 538 return 0; 539} 540 541 /* 542 * This routine actually sets the video mode. 543 */ 544 545static int ps3fb_set_par(struct fb_info *info) 546{ 547 unsigned int mode; 548 int i; 549 unsigned long offset; 550 static int first = 1; 551 552 DPRINTK("xres:%d xv:%d yres:%d yv:%d clock:%d\n", 553 info->var.xres, info->var.xres_virtual, 554 info->var.yres, info->var.yres_virtual, info->var.pixclock); 555 i = ps3fb_get_res_table(info->var.xres, info->var.yres); 556 ps3fb.res_index = i; 557 558 mode = ps3fb_find_mode(&info->var, &info->fix.line_length); 559 if (!mode) 560 return -EINVAL; 561 562 offset = FB_OFF(i) + VP_OFF(i); 563 info->fix.smem_len = ps3fb_videomemory.size - offset; 564 info->screen_base = (char __iomem *)ps3fb.xdr_ea + offset; 565 memset(ps3fb.xdr_ea, 0, ps3fb_videomemory.size); 566 567 ps3fb.num_frames = ps3fb_videomemory.size/ 568 (ps3fb_res[i].xres*ps3fb_res[i].yres*BPP); 569 570 /* Keep the special bits we cannot set using fb_var_screeninfo */ 571 ps3fb_mode = (ps3fb_mode & ~PS3AV_MODE_MASK) | mode; 572 573 if (ps3av_set_video_mode(ps3fb_mode, first)) 574 return -EINVAL; 575 576 first = 0; 577 return 0; 578} 579 580 /* 581 * Set a single color register. The values supplied are already 582 * rounded down to the hardware's capabilities (according to the 583 * entries in the var structure). Return != 0 for invalid regno. 584 */ 585 586static int ps3fb_setcolreg(unsigned int regno, unsigned int red, 587 unsigned int green, unsigned int blue, 588 unsigned int transp, struct fb_info *info) 589{ 590 if (regno >= 16) 591 return 1; 592 593 red >>= 8; 594 green >>= 8; 595 blue >>= 8; 596 transp >>= 8; 597 598 ((u32 *)info->pseudo_palette)[regno] = transp << 24 | red << 16 | 599 green << 8 | blue; 600 return 0; 601} 602 603 /* 604 * As we have a virtual frame buffer, we need our own mmap function 605 */ 606 607static int ps3fb_mmap(struct fb_info *info, struct vm_area_struct *vma) 608{ 609 unsigned long size, offset; 610 int i; 611 612 i = ps3fb_get_res_table(info->var.xres, info->var.yres); 613 if (i == -1) 614 return -EINVAL; 615 616 size = vma->vm_end - vma->vm_start; 617 offset = vma->vm_pgoff << PAGE_SHIFT; 618 if (offset + size > info->fix.smem_len) 619 return -EINVAL; 620 621 offset += info->fix.smem_start + FB_OFF(i) + VP_OFF(i); 622 if (remap_pfn_range(vma, vma->vm_start, offset >> PAGE_SHIFT, 623 size, vma->vm_page_prot)) 624 return -EAGAIN; 625 626 printk(KERN_DEBUG "ps3fb: mmap framebuffer P(%lx)->V(%lx)\n", offset, 627 vma->vm_start); 628 return 0; 629} 630 631 /* 632 * Blank the display 633 */ 634 635static int ps3fb_blank(int blank, struct fb_info *info) 636{ 637 int retval; 638 639 DPRINTK("%s: blank:%d\n", __func__, blank); 640 switch (blank) { 641 case FB_BLANK_POWERDOWN: 642 case FB_BLANK_HSYNC_SUSPEND: 643 case FB_BLANK_VSYNC_SUSPEND: 644 case FB_BLANK_NORMAL: 645 retval = ps3av_video_mute(1); /* mute on */ 646 if (!retval) 647 ps3fb.is_blanked = 1; 648 break; 649 650 default: /* unblank */ 651 retval = ps3av_video_mute(0); /* mute off */ 652 if (!retval) 653 ps3fb.is_blanked = 0; 654 break; 655 } 656 return retval; 657} 658 659static int ps3fb_get_vblank(struct fb_vblank *vblank) 660{ 661 memset(vblank, 0, sizeof(&vblank)); 662 vblank->flags = FB_VBLANK_HAVE_VSYNC; 663 return 0; 664} 665 666int ps3fb_wait_for_vsync(u32 crtc) 667{ 668 int ret; 669 u64 count; 670 671 count = ps3fb.vblank_count; 672 ret = wait_event_interruptible_timeout(ps3fb.wait_vsync, 673 count != ps3fb.vblank_count, 674 HZ / 10); 675 if (!ret) 676 return -ETIMEDOUT; 677 678 return 0; 679} 680 681EXPORT_SYMBOL_GPL(ps3fb_wait_for_vsync); 682 683void ps3fb_flip_ctl(int on) 684{ 685 if (on) 686 atomic_dec_if_positive(&ps3fb.ext_flip); 687 else 688 atomic_inc(&ps3fb.ext_flip); 689} 690 691EXPORT_SYMBOL_GPL(ps3fb_flip_ctl); 692 693 /* 694 * ioctl 695 */ 696 697static int ps3fb_ioctl(struct fb_info *info, unsigned int cmd, 698 unsigned long arg) 699{ 700 void __user *argp = (void __user *)arg; 701 u32 val, old_mode; 702 int retval = -EFAULT; 703 704 switch (cmd) { 705 case FBIOGET_VBLANK: 706 { 707 struct fb_vblank vblank; 708 DPRINTK("FBIOGET_VBLANK:\n"); 709 retval = ps3fb_get_vblank(&vblank); 710 if (retval) 711 break; 712 713 if (copy_to_user(argp, &vblank, sizeof(vblank))) 714 retval = -EFAULT; 715 break; 716 } 717 718 case FBIO_WAITFORVSYNC: 719 { 720 u32 crt; 721 DPRINTK("FBIO_WAITFORVSYNC:\n"); 722 if (get_user(crt, (u32 __user *) arg)) 723 break; 724 725 retval = ps3fb_wait_for_vsync(crt); 726 break; 727 } 728 729 case PS3FB_IOCTL_SETMODE: 730 { 731 const struct fb_videomode *mode; 732 struct fb_var_screeninfo var; 733 734 if (copy_from_user(&val, argp, sizeof(val))) 735 break; 736 737 if (!(val & PS3AV_MODE_MASK)) { 738 u32 id = ps3av_get_auto_mode(0); 739 if (id > 0) 740 val = (val & ~PS3AV_MODE_MASK) | id; 741 } 742 DPRINTK("PS3FB_IOCTL_SETMODE:%x\n", val); 743 retval = -EINVAL; 744 old_mode = ps3fb_mode; 745 ps3fb_mode = val; 746 mode = ps3fb_default_mode(); 747 if (mode) { 748 var = info->var; 749 fb_videomode_to_var(&var, mode); 750 acquire_console_sem(); 751 info->flags |= FBINFO_MISC_USEREVENT; 752 /* Force, in case only special bits changed */ 753 var.activate |= FB_ACTIVATE_FORCE; 754 retval = fb_set_var(info, &var); 755 info->flags &= ~FBINFO_MISC_USEREVENT; 756 release_console_sem(); 757 } 758 if (retval) 759 ps3fb_mode = old_mode; 760 break; 761 } 762 763 case PS3FB_IOCTL_GETMODE: 764 val = ps3av_get_mode(); 765 DPRINTK("PS3FB_IOCTL_GETMODE:%x\n", val); 766 if (!copy_to_user(argp, &val, sizeof(val))) 767 retval = 0; 768 break; 769 770 case PS3FB_IOCTL_SCREENINFO: 771 { 772 struct ps3fb_ioctl_res res; 773 int i = ps3fb.res_index; 774 DPRINTK("PS3FB_IOCTL_SCREENINFO:\n"); 775 res.xres = ps3fb_res[i].xres; 776 res.yres = ps3fb_res[i].yres; 777 res.xoff = ps3fb_res[i].xoff; 778 res.yoff = ps3fb_res[i].yoff; 779 res.num_frames = ps3fb.num_frames; 780 if (!copy_to_user(argp, &res, sizeof(res))) 781 retval = 0; 782 break; 783 } 784 785 case PS3FB_IOCTL_ON: 786 DPRINTK("PS3FB_IOCTL_ON:\n"); 787 atomic_inc(&ps3fb.ext_flip); 788 retval = 0; 789 break; 790 791 case PS3FB_IOCTL_OFF: 792 DPRINTK("PS3FB_IOCTL_OFF:\n"); 793 atomic_dec_if_positive(&ps3fb.ext_flip); 794 retval = 0; 795 break; 796 797 case PS3FB_IOCTL_FSEL: 798 if (copy_from_user(&val, argp, sizeof(val))) 799 break; 800 801 DPRINTK("PS3FB_IOCTL_FSEL:%d\n", val); 802 retval = ps3fb_sync(val); 803 break; 804 805 default: 806 retval = -ENOIOCTLCMD; 807 break; 808 } 809 return retval; 810} 811 812static int ps3fbd(void *arg) 813{ 814 while (!kthread_should_stop()) { 815 try_to_freeze(); 816 set_current_state(TASK_INTERRUPTIBLE); 817 if (ps3fb.is_kicked) { 818 ps3fb.is_kicked = 0; 819 ps3fb_sync(0); /* single buffer */ 820 } 821 schedule(); 822 } 823 return 0; 824} 825 826static irqreturn_t ps3fb_vsync_interrupt(int irq, void *ptr) 827{ 828 u64 v1; 829 int status; 830 struct display_head *head = &ps3fb.dinfo->display_head[1]; 831 832 status = lv1_gpu_context_intr(ps3fb.context_handle, &v1); 833 if (status) { 834 printk(KERN_ERR "%s: lv1_gpu_context_intr failed: %d\n", 835 __func__, status); 836 return IRQ_NONE; 837 } 838 839 if (v1 & (1 << GPU_INTR_STATUS_VSYNC_1)) { 840 /* VSYNC */ 841 ps3fb.vblank_count = head->vblank_count; 842 if (ps3fb.task && !ps3fb.is_blanked && 843 !atomic_read(&ps3fb.ext_flip)) { 844 ps3fb.is_kicked = 1; 845 wake_up_process(ps3fb.task); 846 } 847 wake_up_interruptible(&ps3fb.wait_vsync); 848 } 849 850 return IRQ_HANDLED; 851} 852 853#ifndef MODULE 854static int __init ps3fb_setup(char *options) 855{ 856 char *this_opt; 857 int mode = 0; 858 859 if (!options || !*options) 860 return 0; /* no options */ 861 862 while ((this_opt = strsep(&options, ",")) != NULL) { 863 if (!*this_opt) 864 continue; 865 if (!strncmp(this_opt, "mode:", 5)) 866 mode = simple_strtoul(this_opt + 5, NULL, 0); 867 else 868 mode_option = this_opt; 869 } 870 return mode; 871} 872#endif /* MODULE */ 873 874 /* 875 * Initialisation 876 */ 877 878static void ps3fb_platform_release(struct device *device) 879{ 880 /* This is called when the reference count goes to zero. */ 881} 882 883static int ps3fb_vsync_settings(struct gpu_driver_info *dinfo, void *dev) 884{ 885 int error; 886 887 DPRINTK("version_driver:%x\n", dinfo->version_driver); 888 DPRINTK("irq outlet:%x\n", dinfo->irq.irq_outlet); 889 DPRINTK("version_gpu:%x memory_size:%x ch:%x core_freq:%d mem_freq:%d\n", 890 dinfo->version_gpu, dinfo->memory_size, dinfo->hardware_channel, 891 dinfo->nvcore_frequency/1000000, dinfo->memory_frequency/1000000); 892 893 if (dinfo->version_driver != GPU_DRIVER_INFO_VERSION) { 894 printk(KERN_ERR "%s: version_driver err:%x\n", __func__, 895 dinfo->version_driver); 896 return -EINVAL; 897 } 898 899 ps3fb.dev = dev; 900 error = ps3_irq_plug_setup(PS3_BINDING_CPU_ANY, dinfo->irq.irq_outlet, 901 &ps3fb.irq_no); 902 if (error) { 903 printk(KERN_ERR "%s: ps3_alloc_irq failed %d\n", __func__, 904 error); 905 return error; 906 } 907 908 error = request_irq(ps3fb.irq_no, ps3fb_vsync_interrupt, IRQF_DISABLED, 909 "ps3fb vsync", ps3fb.dev); 910 if (error) { 911 printk(KERN_ERR "%s: request_irq failed %d\n", __func__, 912 error); 913 ps3_irq_plug_destroy(ps3fb.irq_no); 914 return error; 915 } 916 917 dinfo->irq.mask = (1 << GPU_INTR_STATUS_VSYNC_1) | 918 (1 << GPU_INTR_STATUS_FLIP_1); 919 return 0; 920} 921 922static int ps3fb_xdr_settings(u64 xdr_lpar) 923{ 924 int status; 925 926 status = lv1_gpu_context_iomap(ps3fb.context_handle, GPU_IOIF, 927 xdr_lpar, ps3fb_videomemory.size, 0); 928 if (status) { 929 printk(KERN_ERR "%s: lv1_gpu_context_iomap failed: %d\n", 930 __func__, status); 931 return -ENXIO; 932 } 933 DPRINTK("video:%p xdr_ea:%p ioif:%lx lpar:%lx phys:%lx size:%lx\n", 934 ps3fb_videomemory.address, ps3fb.xdr_ea, GPU_IOIF, xdr_lpar, 935 virt_to_abs(ps3fb.xdr_ea), ps3fb_videomemory.size); 936 937 status = lv1_gpu_context_attribute(ps3fb.context_handle, 938 L1GPU_CONTEXT_ATTRIBUTE_FB_SETUP, 939 xdr_lpar, ps3fb_videomemory.size, 940 GPU_IOIF, 0); 941 if (status) { 942 printk(KERN_ERR 943 "%s: lv1_gpu_context_attribute FB_SETUP failed: %d\n", 944 __func__, status); 945 return -ENXIO; 946 } 947 return 0; 948} 949 950static struct fb_ops ps3fb_ops = { 951 .fb_open = ps3fb_open, 952 .fb_release = ps3fb_release, 953 .fb_read = fb_sys_read, 954 .fb_write = fb_sys_write, 955 .fb_check_var = ps3fb_check_var, 956 .fb_set_par = ps3fb_set_par, 957 .fb_setcolreg = ps3fb_setcolreg, 958 .fb_fillrect = sys_fillrect, 959 .fb_copyarea = sys_copyarea, 960 .fb_imageblit = sys_imageblit, 961 .fb_mmap = ps3fb_mmap, 962 .fb_blank = ps3fb_blank, 963 .fb_ioctl = ps3fb_ioctl, 964 .fb_compat_ioctl = ps3fb_ioctl 965}; 966 967static struct fb_fix_screeninfo ps3fb_fix __initdata = { 968 .id = "PS3 FB", 969 .type = FB_TYPE_PACKED_PIXELS, 970 .visual = FB_VISUAL_TRUECOLOR, 971 .accel = FB_ACCEL_NONE, 972}; 973 974static int __init ps3fb_probe(struct platform_device *dev) 975{ 976 struct fb_info *info; 977 int retval = -ENOMEM; 978 u64 ddr_lpar = 0; 979 u64 lpar_dma_control = 0; 980 u64 lpar_driver_info = 0; 981 u64 lpar_reports = 0; 982 u64 lpar_reports_size = 0; 983 u64 xdr_lpar; 984 int status; 985 unsigned long offset; 986 struct task_struct *task; 987 988 /* get gpu context handle */ 989 status = lv1_gpu_memory_allocate(DDR_SIZE, 0, 0, 0, 0, 990 &ps3fb.memory_handle, &ddr_lpar); 991 if (status) { 992 printk(KERN_ERR "%s: lv1_gpu_memory_allocate failed: %d\n", 993 __func__, status); 994 goto err; 995 } 996 DPRINTK("ddr:lpar:0x%lx\n", ddr_lpar); 997 998 status = lv1_gpu_context_allocate(ps3fb.memory_handle, 0, 999 &ps3fb.context_handle, 1000 &lpar_dma_control, &lpar_driver_info, 1001 &lpar_reports, &lpar_reports_size); 1002 if (status) { 1003 printk(KERN_ERR "%s: lv1_gpu_context_attribute failed: %d\n", 1004 __func__, status); 1005 goto err_gpu_memory_free; 1006 } 1007 1008 /* vsync interrupt */ 1009 ps3fb.dinfo = ioremap(lpar_driver_info, 128 * 1024); 1010 if (!ps3fb.dinfo) { 1011 printk(KERN_ERR "%s: ioremap failed\n", __func__); 1012 goto err_gpu_context_free; 1013 } 1014 1015 retval = ps3fb_vsync_settings(ps3fb.dinfo, dev); 1016 if (retval) 1017 goto err_iounmap_dinfo; 1018 1019 /* xdr frame buffer */ 1020 ps3fb.xdr_ea = ps3fb_videomemory.address; 1021 xdr_lpar = ps3_mm_phys_to_lpar(__pa(ps3fb.xdr_ea)); 1022 retval = ps3fb_xdr_settings(xdr_lpar); 1023 if (retval) 1024 goto err_free_irq; 1025 1026 /* 1027 * ps3fb must clear memory to prevent kernel info 1028 * leakage into userspace 1029 */ 1030 memset(ps3fb.xdr_ea, 0, ps3fb_videomemory.size); 1031 info = framebuffer_alloc(sizeof(u32) * 16, &dev->dev); 1032 if (!info) 1033 goto err_free_irq; 1034 1035 offset = FB_OFF(ps3fb.res_index) + VP_OFF(ps3fb.res_index); 1036 info->screen_base = (char __iomem *)ps3fb.xdr_ea + offset; 1037 info->fbops = &ps3fb_ops; 1038 1039 info->fix = ps3fb_fix; 1040 info->fix.smem_start = virt_to_abs(ps3fb.xdr_ea); 1041 info->fix.smem_len = ps3fb_videomemory.size - offset; 1042 info->pseudo_palette = info->par; 1043 info->par = NULL; 1044 info->flags = FBINFO_FLAG_DEFAULT; 1045 1046 retval = fb_alloc_cmap(&info->cmap, 256, 0); 1047 if (retval < 0) 1048 goto err_framebuffer_release; 1049 1050 if (!fb_find_mode(&info->var, info, mode_option, ps3fb_modedb, 1051 ARRAY_SIZE(ps3fb_modedb), ps3fb_default_mode(), 32)) { 1052 retval = -EINVAL; 1053 goto err_fb_dealloc; 1054 } 1055 1056 fb_videomode_to_modelist(ps3fb_modedb, ARRAY_SIZE(ps3fb_modedb), 1057 &info->modelist); 1058 1059 retval = register_framebuffer(info); 1060 if (retval < 0) 1061 goto err_fb_dealloc; 1062 1063 platform_set_drvdata(dev, info); 1064 1065 printk(KERN_INFO 1066 "fb%d: PS3 frame buffer device, using %ld KiB of video memory\n", 1067 info->node, ps3fb_videomemory.size >> 10); 1068 1069 task = kthread_run(ps3fbd, info, "ps3fbd"); 1070 if (IS_ERR(task)) { 1071 retval = PTR_ERR(task); 1072 goto err_unregister_framebuffer; 1073 } 1074 1075 ps3fb.task = task; 1076 1077 return 0; 1078 1079err_unregister_framebuffer: 1080 unregister_framebuffer(info); 1081err_fb_dealloc: 1082 fb_dealloc_cmap(&info->cmap); 1083err_framebuffer_release: 1084 framebuffer_release(info); 1085err_free_irq: 1086 free_irq(ps3fb.irq_no, ps3fb.dev); 1087 ps3_irq_plug_destroy(ps3fb.irq_no); 1088err_iounmap_dinfo: 1089 iounmap((u8 __iomem *)ps3fb.dinfo); 1090err_gpu_context_free: 1091 lv1_gpu_context_free(ps3fb.context_handle); 1092err_gpu_memory_free: 1093 lv1_gpu_memory_free(ps3fb.memory_handle); 1094err: 1095 return retval; 1096} 1097 1098static void ps3fb_shutdown(struct platform_device *dev) 1099{ 1100 ps3fb_flip_ctl(0); /* flip off */ 1101 ps3fb.dinfo->irq.mask = 0; 1102 free_irq(ps3fb.irq_no, ps3fb.dev); 1103 ps3_irq_plug_destroy(ps3fb.irq_no); 1104 iounmap((u8 __iomem *)ps3fb.dinfo); 1105} 1106 1107void ps3fb_cleanup(void) 1108{ 1109 int status; 1110 1111 if (ps3fb.task) { 1112 struct task_struct *task = ps3fb.task; 1113 ps3fb.task = NULL; 1114 kthread_stop(task); 1115 } 1116 if (ps3fb.irq_no) { 1117 free_irq(ps3fb.irq_no, ps3fb.dev); 1118 ps3_irq_plug_destroy(ps3fb.irq_no); 1119 } 1120 iounmap((u8 __iomem *)ps3fb.dinfo); 1121 1122 status = lv1_gpu_context_free(ps3fb.context_handle); 1123 if (status) 1124 DPRINTK("lv1_gpu_context_free failed: %d\n", status); 1125 1126 status = lv1_gpu_memory_free(ps3fb.memory_handle); 1127 if (status) 1128 DPRINTK("lv1_gpu_memory_free failed: %d\n", status); 1129 1130 ps3av_dev_close(); 1131} 1132 1133EXPORT_SYMBOL_GPL(ps3fb_cleanup); 1134 1135static int ps3fb_remove(struct platform_device *dev) 1136{ 1137 struct fb_info *info = platform_get_drvdata(dev); 1138 1139 if (info) { 1140 unregister_framebuffer(info); 1141 fb_dealloc_cmap(&info->cmap); 1142 framebuffer_release(info); 1143 } 1144 ps3fb_cleanup(); 1145 return 0; 1146} 1147 1148static struct platform_driver ps3fb_driver = { 1149 .probe = ps3fb_probe, 1150 .remove = ps3fb_remove, 1151 .shutdown = ps3fb_shutdown, 1152 .driver = { .name = "ps3fb" } 1153}; 1154 1155static struct platform_device ps3fb_device = { 1156 .name = "ps3fb", 1157 .id = 0, 1158 .dev = { .release = ps3fb_platform_release } 1159}; 1160 1161int ps3fb_set_sync(void) 1162{ 1163 int status; 1164 1165#ifdef HEAD_A 1166 status = lv1_gpu_context_attribute(0x0, 1167 L1GPU_CONTEXT_ATTRIBUTE_DISPLAY_SYNC, 1168 0, L1GPU_DISPLAY_SYNC_VSYNC, 0, 0); 1169 if (status) { 1170 printk(KERN_ERR 1171 "%s: lv1_gpu_context_attribute DISPLAY_SYNC failed: %d\n", 1172 __func__, status); 1173 return -1; 1174 } 1175#endif 1176#ifdef HEAD_B 1177 status = lv1_gpu_context_attribute(0x0, 1178 L1GPU_CONTEXT_ATTRIBUTE_DISPLAY_SYNC, 1179 1, L1GPU_DISPLAY_SYNC_VSYNC, 0, 0); 1180 1181 if (status) { 1182 printk(KERN_ERR 1183 "%s: lv1_gpu_context_attribute DISPLAY_MODE failed: %d\n", 1184 __func__, status); 1185 return -1; 1186 } 1187#endif 1188 return 0; 1189} 1190 1191EXPORT_SYMBOL_GPL(ps3fb_set_sync); 1192 1193static int __init ps3fb_init(void) 1194{ 1195 int error; 1196#ifndef MODULE 1197 int mode; 1198 char *option = NULL; 1199 1200 if (fb_get_options("ps3fb", &option)) 1201 goto err; 1202#endif 1203 1204 if (!ps3fb_videomemory.address) 1205 goto err; 1206 1207 error = ps3av_dev_open(); 1208 if (error) { 1209 printk(KERN_ERR "%s: ps3av_dev_open failed\n", __func__); 1210 goto err; 1211 } 1212 1213 ps3fb_mode = ps3av_get_mode(); 1214 DPRINTK("ps3av_mode:%d\n", ps3fb_mode); 1215#ifndef MODULE 1216 mode = ps3fb_setup(option); /* check boot option */ 1217 if (mode) 1218 ps3fb_mode = mode; 1219#endif 1220 if (ps3fb_mode > 0) { 1221 u32 xres, yres; 1222 ps3av_video_mode2res(ps3fb_mode, &xres, &yres); 1223 ps3fb.res_index = ps3fb_get_res_table(xres, yres); 1224 DPRINTK("res_index:%d\n", ps3fb.res_index); 1225 } else 1226 ps3fb.res_index = GPU_RES_INDEX; 1227 1228 atomic_set(&ps3fb.f_count, -1); /* fbcon opens ps3fb */ 1229 atomic_set(&ps3fb.ext_flip, 0); /* for flip with vsync */ 1230 init_waitqueue_head(&ps3fb.wait_vsync); 1231 ps3fb.num_frames = 1; 1232 1233 error = platform_driver_register(&ps3fb_driver); 1234 if (!error) { 1235 error = platform_device_register(&ps3fb_device); 1236 if (error) 1237 platform_driver_unregister(&ps3fb_driver); 1238 } 1239 1240 ps3fb_set_sync(); 1241 1242 return error; 1243 1244err: 1245 return -ENXIO; 1246} 1247 1248module_init(ps3fb_init); 1249 1250#ifdef MODULE 1251static void __exit ps3fb_exit(void) 1252{ 1253 platform_device_unregister(&ps3fb_device); 1254 platform_driver_unregister(&ps3fb_driver); 1255} 1256 1257module_exit(ps3fb_exit); 1258 1259MODULE_LICENSE("GPL"); 1260#endif /* MODULE */ 1261