u32 height, u32 dst_line_length,			     u32 src_line_length){	int status;	u64 line_length;	line_length = dst_line_length;	if (src_line_length != dst_line_length)		line_length |= (u64)src_line_length << 32;	src_offset += GPU_FB_START;	mutex_lock(&ps3_gpu_mutex);	status = lv1_gpu_context_attribute(ps3fb.context_handle,					   L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT,					   dst_offset, GPU_IOIF + src_offset,					   L1GPU_FB_BLIT_WAIT_FOR_COMPLETION |					   (width << 16) | height,					   line_length);	mutex_unlock(&ps3_gpu_mutex);	if (status)		dev_err(dev,			"%s: lv1_gpu_context_attribute FB_BLIT failed: %d\n",			__func__, status);#ifdef HEAD_A	status = lv1_gpu_context_attribute(ps3fb.context_handle,					   L1GPU_CONTEXT_ATTRIBUTE_DISPLAY_FLIP,					   0, frame_offset, 0, 0);	if (status)		dev_err(dev, "%s: lv1_gpu_context_attribute FLIP failed: %d\n",			__func__, status);#endif#ifdef HEAD_B	status = lv1_gpu_context_attribute(ps3fb.context_handle,					   L1GPU_CONTEXT_ATTRIBUTE_DISPLAY_FLIP,					   1, frame_offset, 0, 0);	if (status)		dev_err(dev, "%s: lv1_gpu_context_attribute FLIP failed: %d\n",			__func__, status);#endif}static int ps3fb_sync(struct fb_info *info, u32 frame){	struct ps3fb_par *par = info->par;	int error = 0;	u64 ddr_base, xdr_base;	if (frame > par->num_frames - 1) {		dev_dbg(info->device, "%s: invalid frame number (%u)\n",			__func__, frame);		error = -EINVAL;		goto out;	}	xdr_base = frame * par->xdr_frame_size;	ddr_base = frame * par->ddr_frame_size;	ps3fb_sync_image(info->device, ddr_base + par->full_offset,			 ddr_base + par->fb_offset, xdr_base + par->pan_offset,			 par->width, par->height, par->ddr_line_length,			 info->fix.line_length);out:	return error;}static int ps3fb_open(struct fb_info *info, int user){	atomic_inc(&ps3fb.f_count);	return 0;}static int ps3fb_release(struct fb_info *info, int user){	if (atomic_dec_and_test(&ps3fb.f_count)) {		if (atomic_read(&ps3fb.ext_flip)) {			atomic_set(&ps3fb.ext_flip, 0);			if (!try_acquire_console_sem()) {				ps3fb_sync(info, 0);	/* single buffer */				release_console_sem();			}		}	}	return 0;}    /*     *  Setting the video mode has been split into two parts.     *  First part, xxxfb_check_var, must not write anything     *  to hardware, it should only verify and adjust var.     *  This means it doesn't alter par but it does use hardware     *  data from it to check this var.     */static int ps3fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info){	u32 xdr_line_length, ddr_line_length;	int mode;	mode = ps3fb_find_mode(var, &ddr_line_length, &xdr_line_length);	if (!mode)		return -EINVAL;	/* Virtual screen */	if (var->xres_virtual > xdr_line_length / BPP) {		dev_dbg(info->device,			"Horizontal virtual screen size too large\n");		return -EINVAL;	}	if (var->xoffset + var->xres > var->xres_virtual ||	    var->yoffset + var->yres > var->yres_virtual) {		dev_dbg(info->device, "panning out-of-range\n");		return -EINVAL;	}	/* We support ARGB8888 only */	if (var->bits_per_pixel > 32 || var->grayscale ||	    var->red.offset > 16 || var->green.offset > 8 ||	    var->blue.offset > 0 || var->transp.offset > 24 ||	    var->red.length > 8 || var->green.length > 8 ||	    var->blue.length > 8 || var->transp.length > 8 ||	    var->red.msb_right || var->green.msb_right ||	    var->blue.msb_right || var->transp.msb_right || var->nonstd) {		dev_dbg(info->device, "We support ARGB8888 only\n");		return -EINVAL;	}	var->bits_per_pixel = 32;	var->red.offset = 16;	var->green.offset = 8;	var->blue.offset = 0;	var->transp.offset = 24;	var->red.length = 8;	var->green.length = 8;	var->blue.length = 8;	var->transp.length = 8;	var->red.msb_right = 0;	var->green.msb_right = 0;	var->blue.msb_right = 0;	var->transp.msb_right = 0;	/* Rotation is not supported */	if (var->rotate) {		dev_dbg(info->device, "Rotation is not supported\n");		return -EINVAL;	}	/* Memory limit */	if (var->yres_virtual * xdr_line_length > info->fix.smem_len) {		dev_dbg(info->device, "Not enough memory\n");		return -ENOMEM;	}	var->height = -1;	var->width = -1;	return 0;}    /*     * This routine actually sets the video mode.     */static int ps3fb_set_par(struct fb_info *info){	struct ps3fb_par *par = info->par;	unsigned int mode, ddr_line_length, xdr_line_length, lines, maxlines;	unsigned int ddr_xoff, ddr_yoff, offset;	const struct fb_videomode *vmode;	u64 dst;	mode = ps3fb_find_mode(&info->var, &ddr_line_length, &xdr_line_length);	if (!mode)		return -EINVAL;	vmode = ps3fb_native_vmode(mode & PS3AV_MODE_MASK);	info->fix.xpanstep = info->var.xres_virtual > info->var.xres ? 1 : 0;	info->fix.ypanstep = info->var.yres_virtual > info->var.yres ? 1 : 0;	info->fix.line_length = xdr_line_length;	par->ddr_line_length = ddr_line_length;	par->ddr_frame_size = vmode->yres * ddr_line_length;	par->xdr_frame_size = info->var.yres_virtual * xdr_line_length;	par->num_frames = info->fix.smem_len /			  max(par->ddr_frame_size, par->xdr_frame_size);	/* Keep the special bits we cannot set using fb_var_screeninfo */	par->new_mode_id = (par->new_mode_id & ~PS3AV_MODE_MASK) | mode;	par->width = info->var.xres;	par->height = info->var.yres;	/* Start of the virtual frame buffer (relative to fullscreen) */	ddr_xoff = info->var.left_margin - vmode->left_margin;	ddr_yoff = info->var.upper_margin - vmode->upper_margin;	offset = ddr_yoff * ddr_line_length + ddr_xoff * BPP;	par->fb_offset = GPU_ALIGN_UP(offset);	par->full_offset = par->fb_offset - offset;	par->pan_offset = info->var.yoffset * xdr_line_length +			  info->var.xoffset * BPP;	if (par->new_mode_id != par->mode_id) {		if (ps3av_set_video_mode(par->new_mode_id)) {			par->new_mode_id = par->mode_id;			return -EINVAL;		}		par->mode_id = par->new_mode_id;	}	/* Clear XDR frame buffer memory */	memset((void __force *)info->screen_base, 0, info->fix.smem_len);	/* Clear DDR frame buffer memory */	lines = vmode->yres * par->num_frames;	if (par->full_offset)		lines++;	maxlines = info->fix.smem_len / ddr_line_length;	for (dst = 0; lines; dst += maxlines * ddr_line_length) {		unsigned int l = min(lines, maxlines);		ps3fb_sync_image(info->device, 0, dst, 0, vmode->xres, l,				 ddr_line_length, ddr_line_length);		lines -= l;	}	return 0;}    /*     *  Set a single color register. The values supplied are already     *  rounded down to the hardware's capabilities (according to the     *  entries in the var structure). Return != 0 for invalid regno.     */static int ps3fb_setcolreg(unsigned int regno, unsigned int red,			   unsigned int green, unsigned int blue,			   unsigned int transp, struct fb_info *info){	if (regno >= 16)		return 1;	red >>= 8;	green >>= 8;	blue >>= 8;	transp >>= 8;	((u32 *)info->pseudo_palette)[regno] = transp << 24 | red << 16 |					       green << 8 | blue;	return 0;}static int ps3fb_pan_display(struct fb_var_screeninfo *var,			     struct fb_info *info){	struct ps3fb_par *par = info->par;	par->pan_offset = var->yoffset * info->fix.line_length +			  var->xoffset * BPP;	return 0;}    /*     *  As we have a virtual frame buffer, we need our own mmap function     */static int ps3fb_mmap(struct fb_info *info, struct vm_area_struct *vma){	unsigned long size, offset;	size = vma->vm_end - vma->vm_start;	offset = vma->vm_pgoff << PAGE_SHIFT;	if (offset + size > info->fix.smem_len)		return -EINVAL;	offset += info->fix.smem_start;	if (remap_pfn_range(vma, vma->vm_start, offset >> PAGE_SHIFT,			    size, vma->vm_page_prot))		return -EAGAIN;	dev_dbg(info->device, "ps3fb: mmap framebuffer P(%lx)->V(%lx)\n",		offset, vma->vm_start);	return 0;}    /*     * Blank the display     */static int ps3fb_blank(int blank, struct fb_info *info){	int retval;	dev_dbg(info->device, "%s: blank:%d\n", __func__, blank);	switch (blank) {	case FB_BLANK_POWERDOWN:	case FB_BLANK_HSYNC_SUSPEND:	case FB_BLANK_VSYNC_SUSPEND:	case FB_BLANK_NORMAL:		retval = ps3av_video_mute(1);	/* mute on */		if (!retval)			ps3fb.is_blanked = 1;		break;	default:		/* unblank */		retval = ps3av_video_mute(0);	/* mute off */		if (!retval)			ps3fb.is_blanked = 0;		break;	}	return retval;}static int ps3fb_get_vblank(struct fb_vblank *vblank){	memset(vblank, 0, sizeof(*vblank));	vblank->flags = FB_VBLANK_HAVE_VSYNC;	return 0;}static int ps3fb_wait_for_vsync(u32 crtc){	int ret;	u64 count;	count = ps3fb.vblank_count;	ret = wait_event_interruptible_timeout(ps3fb.wait_vsync,					       count != ps3fb.vblank_count,					       HZ / 10);	if (!ret)		return -ETIMEDOUT;	return 0;}    /*     * ioctl     */static int ps3fb_ioctl(struct fb_info *info, unsigned int cmd,		       unsigned long arg){	void __user *argp = (void __user *)arg;	u32 val;	int retval = -EFAULT;	switch (cmd) {	case FBIOGET_VBLANK:		{			struct fb_vblank vblank;			dev_dbg(info->device, "FBIOGET_VBLANK:\n");			retval = ps3fb_get_vblank(&vblank);			if (retval)				break;			if (copy_to_user(argp, &vblank, sizeof(vblank)))				retval = -EFAULT;			break;		}	case FBIO_WAITFORVSYNC:		{			u32 crt;			dev_dbg(info->device, "FBIO_WAITFORVSYNC:\n");			if (get_user(crt, (u32 __user *) arg))				break;			retval = ps3fb_wait_for_vsync(crt);			break;		}	case PS3FB_IOCTL_SETMODE:		{			struct ps3fb_par *par = info->par;			const struct fb_videomode *vmode;			struct fb_var_screeninfo var;			if (copy_from_user(&val, argp, sizeof(val)))				break;			if (!(val & PS3AV_MODE_MASK)) {				u32 id = ps3av_get_auto_mode();				if (id > 0)					val = (val & ~PS3AV_MODE_MASK) | id;			}			dev_dbg(info->device, "PS3FB_IOCTL_SETMODE:%x\n", val);			retval = -EINVAL;			vmode = ps3fb_vmode(val);			if (vmode) {				var = info->var;				fb_videomode_to_var(&var, vmode);				acquire_console_sem();				info->flags |= FBINFO_MISC_USEREVENT;				/* Force, in case only special bits changed */				var.activate |= FB_ACTIVATE_FORCE;				par->new_mode_id = val;				retval = fb_set_var(info, &var);				info->flags &= ~FBINFO_MISC_USEREVENT;				release_console_sem();			}			break;		}	case PS3FB_IOCTL_GETMODE:		val = ps3av_get_mode();		dev_dbg(info->device, "PS3FB_IOCTL_GETMODE:%x\n", val);		if (!copy_to_user(argp, &val, sizeof(val)))			retval = 0;		break;	case PS3FB_IOCTL_SCREENINFO:		{			struct ps3fb_par *par = info->par;			struct ps3fb_ioctl_res res;			dev_dbg(info->device, "PS3FB_IOCTL_SCREENINFO:\n");			res.xres = info->fix.line_length / BPP;			res.yres = info->var.yres_virtual;			res.xoff = (res.xres - info->var.xres) / 2;			res.yoff = (res.yres - info->var.yres) / 2;			res.num_frames = par->num_frames;			if (!copy_to_user(argp, &res, sizeof(res)))				retval = 0;			break;		}	case PS3FB_IOCTL_ON:		dev_dbg(info->device, "PS3FB_IOCTL_ON:\n");		atomic_inc(&ps3fb.ext_flip);		retval = 0;		break;	case PS3FB_IOCTL_OFF:		dev_dbg(info->device, "PS3FB_IOCTL_OFF:\n");		atomic_dec_if_positive(&ps3fb.ext_flip);		retval = 0;		break;	case PS3FB_IOCTL_FSEL:		if (copy_from_user(&val, argp, sizeof(val)))			break;		dev_dbg(info->device, "PS3FB_IOCTL_FSEL:%d\n", val);		acquire_console_sem();		retval = ps3fb_sync(info, val);		release_console_sem();		break;