PageRenderTime 102ms CodeModel.GetById 29ms app.highlight 61ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/video/omap2/omapfb/omapfb-main.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 2515 lines | 1942 code | 466 blank | 107 comment | 451 complexity | 44015d6d2780fcef96272cf567bc56d3 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * linux/drivers/video/omap2/omapfb-main.c
   3 *
   4 * Copyright (C) 2008 Nokia Corporation
   5 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
   6 *
   7 * Some code and ideas taken from drivers/video/omap/ driver
   8 * by Imre Deak.
   9 *
  10 * This program is free software; you can redistribute it and/or modify it
  11 * under the terms of the GNU General Public License version 2 as published by
  12 * the Free Software Foundation.
  13 *
  14 * This program is distributed in the hope that it will be useful, but WITHOUT
  15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17 * more details.
  18 *
  19 * You should have received a copy of the GNU General Public License along with
  20 * this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23#include <linux/module.h>
  24#include <linux/delay.h>
  25#include <linux/slab.h>
  26#include <linux/fb.h>
  27#include <linux/dma-mapping.h>
  28#include <linux/vmalloc.h>
  29#include <linux/device.h>
  30#include <linux/platform_device.h>
  31#include <linux/omapfb.h>
  32
  33#include <video/omapdss.h>
  34#include <plat/vram.h>
  35#include <plat/vrfb.h>
  36
  37#include "omapfb.h"
  38
  39#define MODULE_NAME     "omapfb"
  40
  41#define OMAPFB_PLANE_XRES_MIN		8
  42#define OMAPFB_PLANE_YRES_MIN		8
  43
  44static char *def_mode;
  45static char *def_vram;
  46static int def_vrfb;
  47static int def_rotate;
  48static int def_mirror;
  49static bool auto_update;
  50static unsigned int auto_update_freq;
  51module_param(auto_update, bool, 0);
  52module_param(auto_update_freq, uint, 0644);
  53
  54#ifdef DEBUG
  55unsigned int omapfb_debug;
  56module_param_named(debug, omapfb_debug, bool, 0644);
  57static unsigned int omapfb_test_pattern;
  58module_param_named(test, omapfb_test_pattern, bool, 0644);
  59#endif
  60
  61static int omapfb_fb_init(struct omapfb2_device *fbdev, struct fb_info *fbi);
  62static int omapfb_get_recommended_bpp(struct omapfb2_device *fbdev,
  63		struct omap_dss_device *dssdev);
  64
  65#ifdef DEBUG
  66static void draw_pixel(struct fb_info *fbi, int x, int y, unsigned color)
  67{
  68	struct fb_var_screeninfo *var = &fbi->var;
  69	struct fb_fix_screeninfo *fix = &fbi->fix;
  70	void __iomem *addr = fbi->screen_base;
  71	const unsigned bytespp = var->bits_per_pixel >> 3;
  72	const unsigned line_len = fix->line_length / bytespp;
  73
  74	int r = (color >> 16) & 0xff;
  75	int g = (color >> 8) & 0xff;
  76	int b = (color >> 0) & 0xff;
  77
  78	if (var->bits_per_pixel == 16) {
  79		u16 __iomem *p = (u16 __iomem *)addr;
  80		p += y * line_len + x;
  81
  82		r = r * 32 / 256;
  83		g = g * 64 / 256;
  84		b = b * 32 / 256;
  85
  86		__raw_writew((r << 11) | (g << 5) | (b << 0), p);
  87	} else if (var->bits_per_pixel == 24) {
  88		u8 __iomem *p = (u8 __iomem *)addr;
  89		p += (y * line_len + x) * 3;
  90
  91		__raw_writeb(b, p + 0);
  92		__raw_writeb(g, p + 1);
  93		__raw_writeb(r, p + 2);
  94	} else if (var->bits_per_pixel == 32) {
  95		u32 __iomem *p = (u32 __iomem *)addr;
  96		p += y * line_len + x;
  97		__raw_writel(color, p);
  98	}
  99}
 100
 101static void fill_fb(struct fb_info *fbi)
 102{
 103	struct fb_var_screeninfo *var = &fbi->var;
 104	const short w = var->xres_virtual;
 105	const short h = var->yres_virtual;
 106	void __iomem *addr = fbi->screen_base;
 107	int y, x;
 108
 109	if (!addr)
 110		return;
 111
 112	DBG("fill_fb %dx%d, line_len %d bytes\n", w, h, fbi->fix.line_length);
 113
 114	for (y = 0; y < h; y++) {
 115		for (x = 0; x < w; x++) {
 116			if (x < 20 && y < 20)
 117				draw_pixel(fbi, x, y, 0xffffff);
 118			else if (x < 20 && (y > 20 && y < h - 20))
 119				draw_pixel(fbi, x, y, 0xff);
 120			else if (y < 20 && (x > 20 && x < w - 20))
 121				draw_pixel(fbi, x, y, 0xff00);
 122			else if (x > w - 20 && (y > 20 && y < h - 20))
 123				draw_pixel(fbi, x, y, 0xff0000);
 124			else if (y > h - 20 && (x > 20 && x < w - 20))
 125				draw_pixel(fbi, x, y, 0xffff00);
 126			else if (x == 20 || x == w - 20 ||
 127					y == 20 || y == h - 20)
 128				draw_pixel(fbi, x, y, 0xffffff);
 129			else if (x == y || w - x == h - y)
 130				draw_pixel(fbi, x, y, 0xff00ff);
 131			else if (w - x == y || x == h - y)
 132				draw_pixel(fbi, x, y, 0x00ffff);
 133			else if (x > 20 && y > 20 && x < w - 20 && y < h - 20) {
 134				int t = x * 3 / w;
 135				unsigned r = 0, g = 0, b = 0;
 136				unsigned c;
 137				if (var->bits_per_pixel == 16) {
 138					if (t == 0)
 139						b = (y % 32) * 256 / 32;
 140					else if (t == 1)
 141						g = (y % 64) * 256 / 64;
 142					else if (t == 2)
 143						r = (y % 32) * 256 / 32;
 144				} else {
 145					if (t == 0)
 146						b = (y % 256);
 147					else if (t == 1)
 148						g = (y % 256);
 149					else if (t == 2)
 150						r = (y % 256);
 151				}
 152				c = (r << 16) | (g << 8) | (b << 0);
 153				draw_pixel(fbi, x, y, c);
 154			} else {
 155				draw_pixel(fbi, x, y, 0);
 156			}
 157		}
 158	}
 159}
 160#endif
 161
 162static unsigned omapfb_get_vrfb_offset(const struct omapfb_info *ofbi, int rot)
 163{
 164	const struct vrfb *vrfb = &ofbi->region->vrfb;
 165	unsigned offset;
 166
 167	switch (rot) {
 168	case FB_ROTATE_UR:
 169		offset = 0;
 170		break;
 171	case FB_ROTATE_CW:
 172		offset = vrfb->yoffset;
 173		break;
 174	case FB_ROTATE_UD:
 175		offset = vrfb->yoffset * OMAP_VRFB_LINE_LEN + vrfb->xoffset;
 176		break;
 177	case FB_ROTATE_CCW:
 178		offset = vrfb->xoffset * OMAP_VRFB_LINE_LEN;
 179		break;
 180	default:
 181		BUG();
 182	}
 183
 184	offset *= vrfb->bytespp;
 185
 186	return offset;
 187}
 188
 189static u32 omapfb_get_region_rot_paddr(const struct omapfb_info *ofbi, int rot)
 190{
 191	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
 192		return ofbi->region->vrfb.paddr[rot]
 193			+ omapfb_get_vrfb_offset(ofbi, rot);
 194	} else {
 195		return ofbi->region->paddr;
 196	}
 197}
 198
 199static u32 omapfb_get_region_paddr(const struct omapfb_info *ofbi)
 200{
 201	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 202		return ofbi->region->vrfb.paddr[0];
 203	else
 204		return ofbi->region->paddr;
 205}
 206
 207static void __iomem *omapfb_get_region_vaddr(const struct omapfb_info *ofbi)
 208{
 209	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 210		return ofbi->region->vrfb.vaddr[0];
 211	else
 212		return ofbi->region->vaddr;
 213}
 214
 215static struct omapfb_colormode omapfb_colormodes[] = {
 216	{
 217		.dssmode = OMAP_DSS_COLOR_UYVY,
 218		.bits_per_pixel = 16,
 219		.nonstd = OMAPFB_COLOR_YUV422,
 220	}, {
 221		.dssmode = OMAP_DSS_COLOR_YUV2,
 222		.bits_per_pixel = 16,
 223		.nonstd = OMAPFB_COLOR_YUY422,
 224	}, {
 225		.dssmode = OMAP_DSS_COLOR_ARGB16,
 226		.bits_per_pixel = 16,
 227		.red	= { .length = 4, .offset = 8, .msb_right = 0 },
 228		.green	= { .length = 4, .offset = 4, .msb_right = 0 },
 229		.blue	= { .length = 4, .offset = 0, .msb_right = 0 },
 230		.transp	= { .length = 4, .offset = 12, .msb_right = 0 },
 231	}, {
 232		.dssmode = OMAP_DSS_COLOR_RGB16,
 233		.bits_per_pixel = 16,
 234		.red	= { .length = 5, .offset = 11, .msb_right = 0 },
 235		.green	= { .length = 6, .offset = 5, .msb_right = 0 },
 236		.blue	= { .length = 5, .offset = 0, .msb_right = 0 },
 237		.transp	= { .length = 0, .offset = 0, .msb_right = 0 },
 238	}, {
 239		.dssmode = OMAP_DSS_COLOR_RGB24P,
 240		.bits_per_pixel = 24,
 241		.red	= { .length = 8, .offset = 16, .msb_right = 0 },
 242		.green	= { .length = 8, .offset = 8, .msb_right = 0 },
 243		.blue	= { .length = 8, .offset = 0, .msb_right = 0 },
 244		.transp	= { .length = 0, .offset = 0, .msb_right = 0 },
 245	}, {
 246		.dssmode = OMAP_DSS_COLOR_RGB24U,
 247		.bits_per_pixel = 32,
 248		.red	= { .length = 8, .offset = 16, .msb_right = 0 },
 249		.green	= { .length = 8, .offset = 8, .msb_right = 0 },
 250		.blue	= { .length = 8, .offset = 0, .msb_right = 0 },
 251		.transp	= { .length = 0, .offset = 0, .msb_right = 0 },
 252	}, {
 253		.dssmode = OMAP_DSS_COLOR_ARGB32,
 254		.bits_per_pixel = 32,
 255		.red	= { .length = 8, .offset = 16, .msb_right = 0 },
 256		.green	= { .length = 8, .offset = 8, .msb_right = 0 },
 257		.blue	= { .length = 8, .offset = 0, .msb_right = 0 },
 258		.transp	= { .length = 8, .offset = 24, .msb_right = 0 },
 259	}, {
 260		.dssmode = OMAP_DSS_COLOR_RGBA32,
 261		.bits_per_pixel = 32,
 262		.red	= { .length = 8, .offset = 24, .msb_right = 0 },
 263		.green	= { .length = 8, .offset = 16, .msb_right = 0 },
 264		.blue	= { .length = 8, .offset = 8, .msb_right = 0 },
 265		.transp	= { .length = 8, .offset = 0, .msb_right = 0 },
 266	}, {
 267		.dssmode = OMAP_DSS_COLOR_RGBX32,
 268		.bits_per_pixel = 32,
 269		.red	= { .length = 8, .offset = 24, .msb_right = 0 },
 270		.green	= { .length = 8, .offset = 16, .msb_right = 0 },
 271		.blue	= { .length = 8, .offset = 8, .msb_right = 0 },
 272		.transp	= { .length = 0, .offset = 0, .msb_right = 0 },
 273	},
 274};
 275
 276static bool cmp_var_to_colormode(struct fb_var_screeninfo *var,
 277		struct omapfb_colormode *color)
 278{
 279	bool cmp_component(struct fb_bitfield *f1, struct fb_bitfield *f2)
 280	{
 281		return f1->length == f2->length &&
 282			f1->offset == f2->offset &&
 283			f1->msb_right == f2->msb_right;
 284	}
 285
 286	if (var->bits_per_pixel == 0 ||
 287			var->red.length == 0 ||
 288			var->blue.length == 0 ||
 289			var->green.length == 0)
 290		return 0;
 291
 292	return var->bits_per_pixel == color->bits_per_pixel &&
 293		cmp_component(&var->red, &color->red) &&
 294		cmp_component(&var->green, &color->green) &&
 295		cmp_component(&var->blue, &color->blue) &&
 296		cmp_component(&var->transp, &color->transp);
 297}
 298
 299static void assign_colormode_to_var(struct fb_var_screeninfo *var,
 300		struct omapfb_colormode *color)
 301{
 302	var->bits_per_pixel = color->bits_per_pixel;
 303	var->nonstd = color->nonstd;
 304	var->red = color->red;
 305	var->green = color->green;
 306	var->blue = color->blue;
 307	var->transp = color->transp;
 308}
 309
 310static int fb_mode_to_dss_mode(struct fb_var_screeninfo *var,
 311		enum omap_color_mode *mode)
 312{
 313	enum omap_color_mode dssmode;
 314	int i;
 315
 316	/* first match with nonstd field */
 317	if (var->nonstd) {
 318		for (i = 0; i < ARRAY_SIZE(omapfb_colormodes); ++i) {
 319			struct omapfb_colormode *m = &omapfb_colormodes[i];
 320			if (var->nonstd == m->nonstd) {
 321				assign_colormode_to_var(var, m);
 322				*mode = m->dssmode;
 323				return 0;
 324			}
 325		}
 326
 327		return -EINVAL;
 328	}
 329
 330	/* then try exact match of bpp and colors */
 331	for (i = 0; i < ARRAY_SIZE(omapfb_colormodes); ++i) {
 332		struct omapfb_colormode *m = &omapfb_colormodes[i];
 333		if (cmp_var_to_colormode(var, m)) {
 334			assign_colormode_to_var(var, m);
 335			*mode = m->dssmode;
 336			return 0;
 337		}
 338	}
 339
 340	/* match with bpp if user has not filled color fields
 341	 * properly */
 342	switch (var->bits_per_pixel) {
 343	case 1:
 344		dssmode = OMAP_DSS_COLOR_CLUT1;
 345		break;
 346	case 2:
 347		dssmode = OMAP_DSS_COLOR_CLUT2;
 348		break;
 349	case 4:
 350		dssmode = OMAP_DSS_COLOR_CLUT4;
 351		break;
 352	case 8:
 353		dssmode = OMAP_DSS_COLOR_CLUT8;
 354		break;
 355	case 12:
 356		dssmode = OMAP_DSS_COLOR_RGB12U;
 357		break;
 358	case 16:
 359		dssmode = OMAP_DSS_COLOR_RGB16;
 360		break;
 361	case 24:
 362		dssmode = OMAP_DSS_COLOR_RGB24P;
 363		break;
 364	case 32:
 365		dssmode = OMAP_DSS_COLOR_RGB24U;
 366		break;
 367	default:
 368		return -EINVAL;
 369	}
 370
 371	for (i = 0; i < ARRAY_SIZE(omapfb_colormodes); ++i) {
 372		struct omapfb_colormode *m = &omapfb_colormodes[i];
 373		if (dssmode == m->dssmode) {
 374			assign_colormode_to_var(var, m);
 375			*mode = m->dssmode;
 376			return 0;
 377		}
 378	}
 379
 380	return -EINVAL;
 381}
 382
 383static int check_fb_res_bounds(struct fb_var_screeninfo *var)
 384{
 385	int xres_min = OMAPFB_PLANE_XRES_MIN;
 386	int xres_max = 2048;
 387	int yres_min = OMAPFB_PLANE_YRES_MIN;
 388	int yres_max = 2048;
 389
 390	/* XXX: some applications seem to set virtual res to 0. */
 391	if (var->xres_virtual == 0)
 392		var->xres_virtual = var->xres;
 393
 394	if (var->yres_virtual == 0)
 395		var->yres_virtual = var->yres;
 396
 397	if (var->xres_virtual < xres_min || var->yres_virtual < yres_min)
 398		return -EINVAL;
 399
 400	if (var->xres < xres_min)
 401		var->xres = xres_min;
 402	if (var->yres < yres_min)
 403		var->yres = yres_min;
 404	if (var->xres > xres_max)
 405		var->xres = xres_max;
 406	if (var->yres > yres_max)
 407		var->yres = yres_max;
 408
 409	if (var->xres > var->xres_virtual)
 410		var->xres = var->xres_virtual;
 411	if (var->yres > var->yres_virtual)
 412		var->yres = var->yres_virtual;
 413
 414	return 0;
 415}
 416
 417static void shrink_height(unsigned long max_frame_size,
 418		struct fb_var_screeninfo *var)
 419{
 420	DBG("can't fit FB into memory, reducing y\n");
 421	var->yres_virtual = max_frame_size /
 422		(var->xres_virtual * var->bits_per_pixel >> 3);
 423
 424	if (var->yres_virtual < OMAPFB_PLANE_YRES_MIN)
 425		var->yres_virtual = OMAPFB_PLANE_YRES_MIN;
 426
 427	if (var->yres > var->yres_virtual)
 428		var->yres = var->yres_virtual;
 429}
 430
 431static void shrink_width(unsigned long max_frame_size,
 432		struct fb_var_screeninfo *var)
 433{
 434	DBG("can't fit FB into memory, reducing x\n");
 435	var->xres_virtual = max_frame_size / var->yres_virtual /
 436		(var->bits_per_pixel >> 3);
 437
 438	if (var->xres_virtual < OMAPFB_PLANE_XRES_MIN)
 439		var->xres_virtual = OMAPFB_PLANE_XRES_MIN;
 440
 441	if (var->xres > var->xres_virtual)
 442		var->xres = var->xres_virtual;
 443}
 444
 445static int check_vrfb_fb_size(unsigned long region_size,
 446		const struct fb_var_screeninfo *var)
 447{
 448	unsigned long min_phys_size = omap_vrfb_min_phys_size(var->xres_virtual,
 449		var->yres_virtual, var->bits_per_pixel >> 3);
 450
 451	return min_phys_size > region_size ? -EINVAL : 0;
 452}
 453
 454static int check_fb_size(const struct omapfb_info *ofbi,
 455		struct fb_var_screeninfo *var)
 456{
 457	unsigned long max_frame_size = ofbi->region->size;
 458	int bytespp = var->bits_per_pixel >> 3;
 459	unsigned long line_size = var->xres_virtual * bytespp;
 460
 461	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
 462		/* One needs to check for both VRFB and OMAPFB limitations. */
 463		if (check_vrfb_fb_size(max_frame_size, var))
 464			shrink_height(omap_vrfb_max_height(
 465				max_frame_size, var->xres_virtual, bytespp) *
 466				line_size, var);
 467
 468		if (check_vrfb_fb_size(max_frame_size, var)) {
 469			DBG("cannot fit FB to memory\n");
 470			return -EINVAL;
 471		}
 472
 473		return 0;
 474	}
 475
 476	DBG("max frame size %lu, line size %lu\n", max_frame_size, line_size);
 477
 478	if (line_size * var->yres_virtual > max_frame_size)
 479		shrink_height(max_frame_size, var);
 480
 481	if (line_size * var->yres_virtual > max_frame_size) {
 482		shrink_width(max_frame_size, var);
 483		line_size = var->xres_virtual * bytespp;
 484	}
 485
 486	if (line_size * var->yres_virtual > max_frame_size) {
 487		DBG("cannot fit FB to memory\n");
 488		return -EINVAL;
 489	}
 490
 491	return 0;
 492}
 493
 494/*
 495 * Consider if VRFB assisted rotation is in use and if the virtual space for
 496 * the zero degree view needs to be mapped. The need for mapping also acts as
 497 * the trigger for setting up the hardware on the context in question. This
 498 * ensures that one does not attempt to access the virtual view before the
 499 * hardware is serving the address translations.
 500 */
 501static int setup_vrfb_rotation(struct fb_info *fbi)
 502{
 503	struct omapfb_info *ofbi = FB2OFB(fbi);
 504	struct omapfb2_mem_region *rg = ofbi->region;
 505	struct vrfb *vrfb = &rg->vrfb;
 506	struct fb_var_screeninfo *var = &fbi->var;
 507	struct fb_fix_screeninfo *fix = &fbi->fix;
 508	unsigned bytespp;
 509	bool yuv_mode;
 510	enum omap_color_mode mode;
 511	int r;
 512	bool reconf;
 513
 514	if (!rg->size || ofbi->rotation_type != OMAP_DSS_ROT_VRFB)
 515		return 0;
 516
 517	DBG("setup_vrfb_rotation\n");
 518
 519	r = fb_mode_to_dss_mode(var, &mode);
 520	if (r)
 521		return r;
 522
 523	bytespp = var->bits_per_pixel >> 3;
 524
 525	yuv_mode = mode == OMAP_DSS_COLOR_YUV2 || mode == OMAP_DSS_COLOR_UYVY;
 526
 527	/* We need to reconfigure VRFB if the resolution changes, if yuv mode
 528	 * is enabled/disabled, or if bytes per pixel changes */
 529
 530	/* XXX we shouldn't allow this when framebuffer is mmapped */
 531
 532	reconf = false;
 533
 534	if (yuv_mode != vrfb->yuv_mode)
 535		reconf = true;
 536	else if (bytespp != vrfb->bytespp)
 537		reconf = true;
 538	else if (vrfb->xres != var->xres_virtual ||
 539			vrfb->yres != var->yres_virtual)
 540		reconf = true;
 541
 542	if (vrfb->vaddr[0] && reconf) {
 543		fbi->screen_base = NULL;
 544		fix->smem_start = 0;
 545		fix->smem_len = 0;
 546		iounmap(vrfb->vaddr[0]);
 547		vrfb->vaddr[0] = NULL;
 548		DBG("setup_vrfb_rotation: reset fb\n");
 549	}
 550
 551	if (vrfb->vaddr[0])
 552		return 0;
 553
 554	omap_vrfb_setup(&rg->vrfb, rg->paddr,
 555			var->xres_virtual,
 556			var->yres_virtual,
 557			bytespp, yuv_mode);
 558
 559	/* Now one can ioremap the 0 angle view */
 560	r = omap_vrfb_map_angle(vrfb, var->yres_virtual, 0);
 561	if (r)
 562		return r;
 563
 564	/* used by open/write in fbmem.c */
 565	fbi->screen_base = ofbi->region->vrfb.vaddr[0];
 566
 567	fix->smem_start = ofbi->region->vrfb.paddr[0];
 568
 569	switch (var->nonstd) {
 570	case OMAPFB_COLOR_YUV422:
 571	case OMAPFB_COLOR_YUY422:
 572		fix->line_length =
 573			(OMAP_VRFB_LINE_LEN * var->bits_per_pixel) >> 2;
 574		break;
 575	default:
 576		fix->line_length =
 577			(OMAP_VRFB_LINE_LEN * var->bits_per_pixel) >> 3;
 578		break;
 579	}
 580
 581	fix->smem_len = var->yres_virtual * fix->line_length;
 582
 583	return 0;
 584}
 585
 586int dss_mode_to_fb_mode(enum omap_color_mode dssmode,
 587			struct fb_var_screeninfo *var)
 588{
 589	int i;
 590
 591	for (i = 0; i < ARRAY_SIZE(omapfb_colormodes); ++i) {
 592		struct omapfb_colormode *mode = &omapfb_colormodes[i];
 593		if (dssmode == mode->dssmode) {
 594			assign_colormode_to_var(var, mode);
 595			return 0;
 596		}
 597	}
 598	return -ENOENT;
 599}
 600
 601void set_fb_fix(struct fb_info *fbi)
 602{
 603	struct fb_fix_screeninfo *fix = &fbi->fix;
 604	struct fb_var_screeninfo *var = &fbi->var;
 605	struct omapfb_info *ofbi = FB2OFB(fbi);
 606	struct omapfb2_mem_region *rg = ofbi->region;
 607
 608	DBG("set_fb_fix\n");
 609
 610	/* used by open/write in fbmem.c */
 611	fbi->screen_base = (char __iomem *)omapfb_get_region_vaddr(ofbi);
 612
 613	/* used by mmap in fbmem.c */
 614	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
 615		switch (var->nonstd) {
 616		case OMAPFB_COLOR_YUV422:
 617		case OMAPFB_COLOR_YUY422:
 618			fix->line_length =
 619				(OMAP_VRFB_LINE_LEN * var->bits_per_pixel) >> 2;
 620			break;
 621		default:
 622			fix->line_length =
 623				(OMAP_VRFB_LINE_LEN * var->bits_per_pixel) >> 3;
 624			break;
 625		}
 626
 627		fix->smem_len = var->yres_virtual * fix->line_length;
 628	} else {
 629		fix->line_length =
 630			(var->xres_virtual * var->bits_per_pixel) >> 3;
 631		fix->smem_len = rg->size;
 632	}
 633
 634	fix->smem_start = omapfb_get_region_paddr(ofbi);
 635
 636	fix->type = FB_TYPE_PACKED_PIXELS;
 637
 638	if (var->nonstd)
 639		fix->visual = FB_VISUAL_PSEUDOCOLOR;
 640	else {
 641		switch (var->bits_per_pixel) {
 642		case 32:
 643		case 24:
 644		case 16:
 645		case 12:
 646			fix->visual = FB_VISUAL_TRUECOLOR;
 647			/* 12bpp is stored in 16 bits */
 648			break;
 649		case 1:
 650		case 2:
 651		case 4:
 652		case 8:
 653			fix->visual = FB_VISUAL_PSEUDOCOLOR;
 654			break;
 655		}
 656	}
 657
 658	fix->accel = FB_ACCEL_NONE;
 659
 660	fix->xpanstep = 1;
 661	fix->ypanstep = 1;
 662}
 663
 664/* check new var and possibly modify it to be ok */
 665int check_fb_var(struct fb_info *fbi, struct fb_var_screeninfo *var)
 666{
 667	struct omapfb_info *ofbi = FB2OFB(fbi);
 668	struct omap_dss_device *display = fb2display(fbi);
 669	enum omap_color_mode mode = 0;
 670	int i;
 671	int r;
 672
 673	DBG("check_fb_var %d\n", ofbi->id);
 674
 675	WARN_ON(!atomic_read(&ofbi->region->lock_count));
 676
 677	r = fb_mode_to_dss_mode(var, &mode);
 678	if (r) {
 679		DBG("cannot convert var to omap dss mode\n");
 680		return r;
 681	}
 682
 683	for (i = 0; i < ofbi->num_overlays; ++i) {
 684		if ((ofbi->overlays[i]->supported_modes & mode) == 0) {
 685			DBG("invalid mode\n");
 686			return -EINVAL;
 687		}
 688	}
 689
 690	if (var->rotate > 3)
 691		return -EINVAL;
 692
 693	if (check_fb_res_bounds(var))
 694		return -EINVAL;
 695
 696	/* When no memory is allocated ignore the size check */
 697	if (ofbi->region->size != 0 && check_fb_size(ofbi, var))
 698		return -EINVAL;
 699
 700	if (var->xres + var->xoffset > var->xres_virtual)
 701		var->xoffset = var->xres_virtual - var->xres;
 702	if (var->yres + var->yoffset > var->yres_virtual)
 703		var->yoffset = var->yres_virtual - var->yres;
 704
 705	DBG("xres = %d, yres = %d, vxres = %d, vyres = %d\n",
 706			var->xres, var->yres,
 707			var->xres_virtual, var->yres_virtual);
 708
 709	if (display && display->driver->get_dimensions) {
 710		u32 w, h;
 711		display->driver->get_dimensions(display, &w, &h);
 712		var->width = DIV_ROUND_CLOSEST(w, 1000);
 713		var->height = DIV_ROUND_CLOSEST(h, 1000);
 714	} else {
 715		var->height = -1;
 716		var->width = -1;
 717	}
 718
 719	var->grayscale          = 0;
 720
 721	if (display && display->driver->get_timings) {
 722		struct omap_video_timings timings;
 723		display->driver->get_timings(display, &timings);
 724
 725		/* pixclock in ps, the rest in pixclock */
 726		var->pixclock = timings.pixel_clock != 0 ?
 727			KHZ2PICOS(timings.pixel_clock) :
 728			0;
 729		var->left_margin = timings.hbp;
 730		var->right_margin = timings.hfp;
 731		var->upper_margin = timings.vbp;
 732		var->lower_margin = timings.vfp;
 733		var->hsync_len = timings.hsw;
 734		var->vsync_len = timings.vsw;
 735	} else {
 736		var->pixclock = 0;
 737		var->left_margin = 0;
 738		var->right_margin = 0;
 739		var->upper_margin = 0;
 740		var->lower_margin = 0;
 741		var->hsync_len = 0;
 742		var->vsync_len = 0;
 743	}
 744
 745	/* TODO: get these from panel->config */
 746	var->vmode              = FB_VMODE_NONINTERLACED;
 747	var->sync               = 0;
 748
 749	return 0;
 750}
 751
 752/*
 753 * ---------------------------------------------------------------------------
 754 * fbdev framework callbacks
 755 * ---------------------------------------------------------------------------
 756 */
 757static int omapfb_open(struct fb_info *fbi, int user)
 758{
 759	return 0;
 760}
 761
 762static int omapfb_release(struct fb_info *fbi, int user)
 763{
 764	return 0;
 765}
 766
 767static unsigned calc_rotation_offset_dma(const struct fb_var_screeninfo *var,
 768		const struct fb_fix_screeninfo *fix, int rotation)
 769{
 770	unsigned offset;
 771
 772	offset = var->yoffset * fix->line_length +
 773		var->xoffset * (var->bits_per_pixel >> 3);
 774
 775	return offset;
 776}
 777
 778static unsigned calc_rotation_offset_vrfb(const struct fb_var_screeninfo *var,
 779		const struct fb_fix_screeninfo *fix, int rotation)
 780{
 781	unsigned offset;
 782
 783	if (rotation == FB_ROTATE_UD)
 784		offset = (var->yres_virtual - var->yres) *
 785			fix->line_length;
 786	else if (rotation == FB_ROTATE_CW)
 787		offset = (var->yres_virtual - var->yres) *
 788			(var->bits_per_pixel >> 3);
 789	else
 790		offset = 0;
 791
 792	if (rotation == FB_ROTATE_UR)
 793		offset += var->yoffset * fix->line_length +
 794			var->xoffset * (var->bits_per_pixel >> 3);
 795	else if (rotation == FB_ROTATE_UD)
 796		offset -= var->yoffset * fix->line_length +
 797			var->xoffset * (var->bits_per_pixel >> 3);
 798	else if (rotation == FB_ROTATE_CW)
 799		offset -= var->xoffset * fix->line_length +
 800			var->yoffset * (var->bits_per_pixel >> 3);
 801	else if (rotation == FB_ROTATE_CCW)
 802		offset += var->xoffset * fix->line_length +
 803			var->yoffset * (var->bits_per_pixel >> 3);
 804
 805	return offset;
 806}
 807
 808static void omapfb_calc_addr(const struct omapfb_info *ofbi,
 809			     const struct fb_var_screeninfo *var,
 810			     const struct fb_fix_screeninfo *fix,
 811			     int rotation, u32 *paddr, void __iomem **vaddr)
 812{
 813	u32 data_start_p;
 814	void __iomem *data_start_v;
 815	int offset;
 816
 817	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
 818		data_start_p = omapfb_get_region_rot_paddr(ofbi, rotation);
 819		data_start_v = NULL;
 820	} else {
 821		data_start_p = omapfb_get_region_paddr(ofbi);
 822		data_start_v = omapfb_get_region_vaddr(ofbi);
 823	}
 824
 825	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 826		offset = calc_rotation_offset_vrfb(var, fix, rotation);
 827	else
 828		offset = calc_rotation_offset_dma(var, fix, rotation);
 829
 830	data_start_p += offset;
 831	data_start_v += offset;
 832
 833	if (offset)
 834		DBG("offset %d, %d = %d\n",
 835		    var->xoffset, var->yoffset, offset);
 836
 837	DBG("paddr %x, vaddr %p\n", data_start_p, data_start_v);
 838
 839	*paddr = data_start_p;
 840	*vaddr = data_start_v;
 841}
 842
 843/* setup overlay according to the fb */
 844int omapfb_setup_overlay(struct fb_info *fbi, struct omap_overlay *ovl,
 845		u16 posx, u16 posy, u16 outw, u16 outh)
 846{
 847	int r = 0;
 848	struct omapfb_info *ofbi = FB2OFB(fbi);
 849	struct fb_var_screeninfo *var = &fbi->var;
 850	struct fb_fix_screeninfo *fix = &fbi->fix;
 851	enum omap_color_mode mode = 0;
 852	u32 data_start_p = 0;
 853	void __iomem *data_start_v = NULL;
 854	struct omap_overlay_info info;
 855	int xres, yres;
 856	int screen_width;
 857	int mirror;
 858	int rotation = var->rotate;
 859	int i;
 860
 861	WARN_ON(!atomic_read(&ofbi->region->lock_count));
 862
 863	for (i = 0; i < ofbi->num_overlays; i++) {
 864		if (ovl != ofbi->overlays[i])
 865			continue;
 866
 867		rotation = (rotation + ofbi->rotation[i]) % 4;
 868		break;
 869	}
 870
 871	DBG("setup_overlay %d, posx %d, posy %d, outw %d, outh %d\n", ofbi->id,
 872			posx, posy, outw, outh);
 873
 874	if (rotation == FB_ROTATE_CW || rotation == FB_ROTATE_CCW) {
 875		xres = var->yres;
 876		yres = var->xres;
 877	} else {
 878		xres = var->xres;
 879		yres = var->yres;
 880	}
 881
 882	if (ofbi->region->size)
 883		omapfb_calc_addr(ofbi, var, fix, rotation,
 884				 &data_start_p, &data_start_v);
 885
 886	r = fb_mode_to_dss_mode(var, &mode);
 887	if (r) {
 888		DBG("fb_mode_to_dss_mode failed");
 889		goto err;
 890	}
 891
 892	switch (var->nonstd) {
 893	case OMAPFB_COLOR_YUV422:
 894	case OMAPFB_COLOR_YUY422:
 895		if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
 896			screen_width = fix->line_length
 897				/ (var->bits_per_pixel >> 2);
 898			break;
 899		}
 900	default:
 901		screen_width = fix->line_length / (var->bits_per_pixel >> 3);
 902		break;
 903	}
 904
 905	ovl->get_overlay_info(ovl, &info);
 906
 907	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 908		mirror = 0;
 909	else
 910		mirror = ofbi->mirror;
 911
 912	info.paddr = data_start_p;
 913	info.vaddr = data_start_v;
 914	info.screen_width = screen_width;
 915	info.width = xres;
 916	info.height = yres;
 917	info.color_mode = mode;
 918	info.rotation_type = ofbi->rotation_type;
 919	info.rotation = rotation;
 920	info.mirror = mirror;
 921
 922	info.pos_x = posx;
 923	info.pos_y = posy;
 924	info.out_width = outw;
 925	info.out_height = outh;
 926
 927	r = ovl->set_overlay_info(ovl, &info);
 928	if (r) {
 929		DBG("ovl->setup_overlay_info failed\n");
 930		goto err;
 931	}
 932
 933	return 0;
 934
 935err:
 936	DBG("setup_overlay failed\n");
 937	return r;
 938}
 939
 940/* apply var to the overlay */
 941int omapfb_apply_changes(struct fb_info *fbi, int init)
 942{
 943	int r = 0;
 944	struct omapfb_info *ofbi = FB2OFB(fbi);
 945	struct fb_var_screeninfo *var = &fbi->var;
 946	struct omap_overlay *ovl;
 947	u16 posx, posy;
 948	u16 outw, outh;
 949	int i;
 950
 951#ifdef DEBUG
 952	if (omapfb_test_pattern)
 953		fill_fb(fbi);
 954#endif
 955
 956	WARN_ON(!atomic_read(&ofbi->region->lock_count));
 957
 958	for (i = 0; i < ofbi->num_overlays; i++) {
 959		ovl = ofbi->overlays[i];
 960
 961		DBG("apply_changes, fb %d, ovl %d\n", ofbi->id, ovl->id);
 962
 963		if (ofbi->region->size == 0) {
 964			/* the fb is not available. disable the overlay */
 965			omapfb_overlay_enable(ovl, 0);
 966			if (!init && ovl->manager)
 967				ovl->manager->apply(ovl->manager);
 968			continue;
 969		}
 970
 971		if (init || (ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
 972			int rotation = (var->rotate + ofbi->rotation[i]) % 4;
 973			if (rotation == FB_ROTATE_CW ||
 974					rotation == FB_ROTATE_CCW) {
 975				outw = var->yres;
 976				outh = var->xres;
 977			} else {
 978				outw = var->xres;
 979				outh = var->yres;
 980			}
 981		} else {
 982			outw = ovl->info.out_width;
 983			outh = ovl->info.out_height;
 984		}
 985
 986		if (init) {
 987			posx = 0;
 988			posy = 0;
 989		} else {
 990			posx = ovl->info.pos_x;
 991			posy = ovl->info.pos_y;
 992		}
 993
 994		r = omapfb_setup_overlay(fbi, ovl, posx, posy, outw, outh);
 995		if (r)
 996			goto err;
 997
 998		if (!init && ovl->manager)
 999			ovl->manager->apply(ovl->manager);
1000	}
1001	return 0;
1002err:
1003	DBG("apply_changes failed\n");
1004	return r;
1005}
1006
1007/* checks var and eventually tweaks it to something supported,
1008 * DO NOT MODIFY PAR */
1009static int omapfb_check_var(struct fb_var_screeninfo *var, struct fb_info *fbi)
1010{
1011	struct omapfb_info *ofbi = FB2OFB(fbi);
1012	int r;
1013
1014	DBG("check_var(%d)\n", FB2OFB(fbi)->id);
1015
1016	omapfb_get_mem_region(ofbi->region);
1017
1018	r = check_fb_var(fbi, var);
1019
1020	omapfb_put_mem_region(ofbi->region);
1021
1022	return r;
1023}
1024
1025/* set the video mode according to info->var */
1026static int omapfb_set_par(struct fb_info *fbi)
1027{
1028	struct omapfb_info *ofbi = FB2OFB(fbi);
1029	int r;
1030
1031	DBG("set_par(%d)\n", FB2OFB(fbi)->id);
1032
1033	omapfb_get_mem_region(ofbi->region);
1034
1035	set_fb_fix(fbi);
1036
1037	r = setup_vrfb_rotation(fbi);
1038	if (r)
1039		goto out;
1040
1041	r = omapfb_apply_changes(fbi, 0);
1042
1043 out:
1044	omapfb_put_mem_region(ofbi->region);
1045
1046	return r;
1047}
1048
1049static int omapfb_pan_display(struct fb_var_screeninfo *var,
1050		struct fb_info *fbi)
1051{
1052	struct omapfb_info *ofbi = FB2OFB(fbi);
1053	struct fb_var_screeninfo new_var;
1054	int r;
1055
1056	DBG("pan_display(%d)\n", FB2OFB(fbi)->id);
1057
1058	if (var->xoffset == fbi->var.xoffset &&
1059	    var->yoffset == fbi->var.yoffset)
1060		return 0;
1061
1062	new_var = fbi->var;
1063	new_var.xoffset = var->xoffset;
1064	new_var.yoffset = var->yoffset;
1065
1066	fbi->var = new_var;
1067
1068	omapfb_get_mem_region(ofbi->region);
1069
1070	r = omapfb_apply_changes(fbi, 0);
1071
1072	omapfb_put_mem_region(ofbi->region);
1073
1074	return r;
1075}
1076
1077static void mmap_user_open(struct vm_area_struct *vma)
1078{
1079	struct omapfb2_mem_region *rg = vma->vm_private_data;
1080
1081	omapfb_get_mem_region(rg);
1082	atomic_inc(&rg->map_count);
1083	omapfb_put_mem_region(rg);
1084}
1085
1086static void mmap_user_close(struct vm_area_struct *vma)
1087{
1088	struct omapfb2_mem_region *rg = vma->vm_private_data;
1089
1090	omapfb_get_mem_region(rg);
1091	atomic_dec(&rg->map_count);
1092	omapfb_put_mem_region(rg);
1093}
1094
1095static struct vm_operations_struct mmap_user_ops = {
1096	.open = mmap_user_open,
1097	.close = mmap_user_close,
1098};
1099
1100static int omapfb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)
1101{
1102	struct omapfb_info *ofbi = FB2OFB(fbi);
1103	struct fb_fix_screeninfo *fix = &fbi->fix;
1104	struct omapfb2_mem_region *rg;
1105	unsigned long off;
1106	unsigned long start;
1107	u32 len;
1108	int r = -EINVAL;
1109
1110	if (vma->vm_end - vma->vm_start == 0)
1111		return 0;
1112	if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
1113		return -EINVAL;
1114	off = vma->vm_pgoff << PAGE_SHIFT;
1115
1116	rg = omapfb_get_mem_region(ofbi->region);
1117
1118	start = omapfb_get_region_paddr(ofbi);
1119	len = fix->smem_len;
1120	if (off >= len)
1121		goto error;
1122	if ((vma->vm_end - vma->vm_start + off) > len)
1123		goto error;
1124
1125	off += start;
1126
1127	DBG("user mmap region start %lx, len %d, off %lx\n", start, len, off);
1128
1129	vma->vm_pgoff = off >> PAGE_SHIFT;
1130	vma->vm_flags |= VM_IO | VM_RESERVED;
1131	vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
1132	vma->vm_ops = &mmap_user_ops;
1133	vma->vm_private_data = rg;
1134	if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
1135			       vma->vm_end - vma->vm_start,
1136			       vma->vm_page_prot)) {
1137		r = -EAGAIN;
1138		goto error;
1139	}
1140
1141	/* vm_ops.open won't be called for mmap itself. */
1142	atomic_inc(&rg->map_count);
1143
1144	omapfb_put_mem_region(rg);
1145
1146	return 0;
1147
1148 error:
1149	omapfb_put_mem_region(ofbi->region);
1150
1151	return r;
1152}
1153
1154/* Store a single color palette entry into a pseudo palette or the hardware
1155 * palette if one is available. For now we support only 16bpp and thus store
1156 * the entry only to the pseudo palette.
1157 */
1158static int _setcolreg(struct fb_info *fbi, u_int regno, u_int red, u_int green,
1159		u_int blue, u_int transp, int update_hw_pal)
1160{
1161	/*struct omapfb_info *ofbi = FB2OFB(fbi);*/
1162	/*struct omapfb2_device *fbdev = ofbi->fbdev;*/
1163	struct fb_var_screeninfo *var = &fbi->var;
1164	int r = 0;
1165
1166	enum omapfb_color_format mode = OMAPFB_COLOR_RGB24U; /* XXX */
1167
1168	/*switch (plane->color_mode) {*/
1169	switch (mode) {
1170	case OMAPFB_COLOR_YUV422:
1171	case OMAPFB_COLOR_YUV420:
1172	case OMAPFB_COLOR_YUY422:
1173		r = -EINVAL;
1174		break;
1175	case OMAPFB_COLOR_CLUT_8BPP:
1176	case OMAPFB_COLOR_CLUT_4BPP:
1177	case OMAPFB_COLOR_CLUT_2BPP:
1178	case OMAPFB_COLOR_CLUT_1BPP:
1179		/*
1180		   if (fbdev->ctrl->setcolreg)
1181		   r = fbdev->ctrl->setcolreg(regno, red, green, blue,
1182		   transp, update_hw_pal);
1183		   */
1184		/* Fallthrough */
1185		r = -EINVAL;
1186		break;
1187	case OMAPFB_COLOR_RGB565:
1188	case OMAPFB_COLOR_RGB444:
1189	case OMAPFB_COLOR_RGB24P:
1190	case OMAPFB_COLOR_RGB24U:
1191		if (r != 0)
1192			break;
1193
1194		if (regno < 16) {
1195			u16 pal;
1196			pal = ((red >> (16 - var->red.length)) <<
1197					var->red.offset) |
1198				((green >> (16 - var->green.length)) <<
1199				 var->green.offset) |
1200				(blue >> (16 - var->blue.length));
1201			((u32 *)(fbi->pseudo_palette))[regno] = pal;
1202		}
1203		break;
1204	default:
1205		BUG();
1206	}
1207	return r;
1208}
1209
1210static int omapfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
1211		u_int transp, struct fb_info *info)
1212{
1213	DBG("setcolreg\n");
1214
1215	return _setcolreg(info, regno, red, green, blue, transp, 1);
1216}
1217
1218static int omapfb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1219{
1220	int count, index, r;
1221	u16 *red, *green, *blue, *transp;
1222	u16 trans = 0xffff;
1223
1224	DBG("setcmap\n");
1225
1226	red     = cmap->red;
1227	green   = cmap->green;
1228	blue    = cmap->blue;
1229	transp  = cmap->transp;
1230	index   = cmap->start;
1231
1232	for (count = 0; count < cmap->len; count++) {
1233		if (transp)
1234			trans = *transp++;
1235		r = _setcolreg(info, index++, *red++, *green++, *blue++, trans,
1236				count == cmap->len - 1);
1237		if (r != 0)
1238			return r;
1239	}
1240
1241	return 0;
1242}
1243
1244static int omapfb_blank(int blank, struct fb_info *fbi)
1245{
1246	struct omapfb_info *ofbi = FB2OFB(fbi);
1247	struct omapfb2_device *fbdev = ofbi->fbdev;
1248	struct omap_dss_device *display = fb2display(fbi);
1249	struct omapfb_display_data *d;
1250	int r = 0;
1251
1252	if (!display)
1253		return -EINVAL;
1254
1255	omapfb_lock(fbdev);
1256
1257	d = get_display_data(fbdev, display);
1258
1259	switch (blank) {
1260	case FB_BLANK_UNBLANK:
1261		if (display->state != OMAP_DSS_DISPLAY_SUSPENDED)
1262			goto exit;
1263
1264		if (display->driver->resume)
1265			r = display->driver->resume(display);
1266
1267		if ((display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) &&
1268				d->update_mode == OMAPFB_AUTO_UPDATE &&
1269				!d->auto_update_work_enabled)
1270			omapfb_start_auto_update(fbdev, display);
1271
1272		break;
1273
1274	case FB_BLANK_NORMAL:
1275		/* FB_BLANK_NORMAL could be implemented.
1276		 * Needs DSS additions. */
1277	case FB_BLANK_VSYNC_SUSPEND:
1278	case FB_BLANK_HSYNC_SUSPEND:
1279	case FB_BLANK_POWERDOWN:
1280		if (display->state != OMAP_DSS_DISPLAY_ACTIVE)
1281			goto exit;
1282
1283		if (d->auto_update_work_enabled)
1284			omapfb_stop_auto_update(fbdev, display);
1285
1286		if (display->driver->suspend)
1287			r = display->driver->suspend(display);
1288
1289		break;
1290
1291	default:
1292		r = -EINVAL;
1293	}
1294
1295exit:
1296	omapfb_unlock(fbdev);
1297
1298	return r;
1299}
1300
1301#if 0
1302/* XXX fb_read and fb_write are needed for VRFB */
1303ssize_t omapfb_write(struct fb_info *info, const char __user *buf,
1304		size_t count, loff_t *ppos)
1305{
1306	DBG("omapfb_write %d, %lu\n", count, (unsigned long)*ppos);
1307	/* XXX needed for VRFB */
1308	return count;
1309}
1310#endif
1311
1312static struct fb_ops omapfb_ops = {
1313	.owner          = THIS_MODULE,
1314	.fb_open        = omapfb_open,
1315	.fb_release     = omapfb_release,
1316	.fb_fillrect    = cfb_fillrect,
1317	.fb_copyarea    = cfb_copyarea,
1318	.fb_imageblit   = cfb_imageblit,
1319	.fb_blank       = omapfb_blank,
1320	.fb_ioctl       = omapfb_ioctl,
1321	.fb_check_var   = omapfb_check_var,
1322	.fb_set_par     = omapfb_set_par,
1323	.fb_pan_display = omapfb_pan_display,
1324	.fb_mmap	= omapfb_mmap,
1325	.fb_setcolreg	= omapfb_setcolreg,
1326	.fb_setcmap	= omapfb_setcmap,
1327	/*.fb_write	= omapfb_write,*/
1328};
1329
1330static void omapfb_free_fbmem(struct fb_info *fbi)
1331{
1332	struct omapfb_info *ofbi = FB2OFB(fbi);
1333	struct omapfb2_device *fbdev = ofbi->fbdev;
1334	struct omapfb2_mem_region *rg;
1335
1336	rg = ofbi->region;
1337
1338	WARN_ON(atomic_read(&rg->map_count));
1339
1340	if (rg->paddr)
1341		if (omap_vram_free(rg->paddr, rg->size))
1342			dev_err(fbdev->dev, "VRAM FREE failed\n");
1343
1344	if (rg->vaddr)
1345		iounmap(rg->vaddr);
1346
1347	if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
1348		/* unmap the 0 angle rotation */
1349		if (rg->vrfb.vaddr[0]) {
1350			iounmap(rg->vrfb.vaddr[0]);
1351			omap_vrfb_release_ctx(&rg->vrfb);
1352			rg->vrfb.vaddr[0] = NULL;
1353		}
1354	}
1355
1356	rg->vaddr = NULL;
1357	rg->paddr = 0;
1358	rg->alloc = 0;
1359	rg->size = 0;
1360}
1361
1362static void clear_fb_info(struct fb_info *fbi)
1363{
1364	memset(&fbi->var, 0, sizeof(fbi->var));
1365	memset(&fbi->fix, 0, sizeof(fbi->fix));
1366	strlcpy(fbi->fix.id, MODULE_NAME, sizeof(fbi->fix.id));
1367}
1368
1369static int omapfb_free_all_fbmem(struct omapfb2_device *fbdev)
1370{
1371	int i;
1372
1373	DBG("free all fbmem\n");
1374
1375	for (i = 0; i < fbdev->num_fbs; i++) {
1376		struct fb_info *fbi = fbdev->fbs[i];
1377		omapfb_free_fbmem(fbi);
1378		clear_fb_info(fbi);
1379	}
1380
1381	return 0;
1382}
1383
1384static int omapfb_alloc_fbmem(struct fb_info *fbi, unsigned long size,
1385		unsigned long paddr)
1386{
1387	struct omapfb_info *ofbi = FB2OFB(fbi);
1388	struct omapfb2_device *fbdev = ofbi->fbdev;
1389	struct omapfb2_mem_region *rg;
1390	void __iomem *vaddr;
1391	int r;
1392
1393	rg = ofbi->region;
1394
1395	rg->paddr = 0;
1396	rg->vaddr = NULL;
1397	memset(&rg->vrfb, 0, sizeof rg->vrfb);
1398	rg->size = 0;
1399	rg->type = 0;
1400	rg->alloc = false;
1401	rg->map = false;
1402
1403	size = PAGE_ALIGN(size);
1404
1405	if (!paddr) {
1406		DBG("allocating %lu bytes for fb %d\n", size, ofbi->id);
1407		r = omap_vram_alloc(OMAP_VRAM_MEMTYPE_SDRAM, size, &paddr);
1408	} else {
1409		DBG("reserving %lu bytes at %lx for fb %d\n", size, paddr,
1410				ofbi->id);
1411		r = omap_vram_reserve(paddr, size);
1412	}
1413
1414	if (r) {
1415		dev_err(fbdev->dev, "failed to allocate framebuffer\n");
1416		return -ENOMEM;
1417	}
1418
1419	if (ofbi->rotation_type != OMAP_DSS_ROT_VRFB) {
1420		vaddr = ioremap_wc(paddr, size);
1421
1422		if (!vaddr) {
1423			dev_err(fbdev->dev, "failed to ioremap framebuffer\n");
1424			omap_vram_free(paddr, size);
1425			return -ENOMEM;
1426		}
1427
1428		DBG("allocated VRAM paddr %lx, vaddr %p\n", paddr, vaddr);
1429	} else {
1430		r = omap_vrfb_request_ctx(&rg->vrfb);
1431		if (r) {
1432			dev_err(fbdev->dev, "vrfb create ctx failed\n");
1433			return r;
1434		}
1435
1436		vaddr = NULL;
1437	}
1438
1439	rg->paddr = paddr;
1440	rg->vaddr = vaddr;
1441	rg->size = size;
1442	rg->alloc = 1;
1443
1444	return 0;
1445}
1446
1447/* allocate fbmem using display resolution as reference */
1448static int omapfb_alloc_fbmem_display(struct fb_info *fbi, unsigned long size,
1449		unsigned long paddr)
1450{
1451	struct omapfb_info *ofbi = FB2OFB(fbi);
1452	struct omapfb2_device *fbdev = ofbi->fbdev;
1453	struct omap_dss_device *display;
1454	int bytespp;
1455
1456	display =  fb2display(fbi);
1457
1458	if (!display)
1459		return 0;
1460
1461	switch (omapfb_get_recommended_bpp(fbdev, display)) {
1462	case 16:
1463		bytespp = 2;
1464		break;
1465	case 24:
1466		bytespp = 4;
1467		break;
1468	default:
1469		bytespp = 4;
1470		break;
1471	}
1472
1473	if (!size) {
1474		u16 w, h;
1475
1476		display->driver->get_resolution(display, &w, &h);
1477
1478		if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
1479			size = max(omap_vrfb_min_phys_size(w, h, bytespp),
1480					omap_vrfb_min_phys_size(h, w, bytespp));
1481
1482			DBG("adjusting fb mem size for VRFB, %u -> %lu\n",
1483					w * h * bytespp, size);
1484		} else {
1485			size = w * h * bytespp;
1486		}
1487	}
1488
1489	if (!size)
1490		return 0;
1491
1492	return omapfb_alloc_fbmem(fbi, size, paddr);
1493}
1494
1495static enum omap_color_mode fb_format_to_dss_mode(enum omapfb_color_format fmt)
1496{
1497	enum omap_color_mode mode;
1498
1499	switch (fmt) {
1500	case OMAPFB_COLOR_RGB565:
1501		mode = OMAP_DSS_COLOR_RGB16;
1502		break;
1503	case OMAPFB_COLOR_YUV422:
1504		mode = OMAP_DSS_COLOR_YUV2;
1505		break;
1506	case OMAPFB_COLOR_CLUT_8BPP:
1507		mode = OMAP_DSS_COLOR_CLUT8;
1508		break;
1509	case OMAPFB_COLOR_CLUT_4BPP:
1510		mode = OMAP_DSS_COLOR_CLUT4;
1511		break;
1512	case OMAPFB_COLOR_CLUT_2BPP:
1513		mode = OMAP_DSS_COLOR_CLUT2;
1514		break;
1515	case OMAPFB_COLOR_CLUT_1BPP:
1516		mode = OMAP_DSS_COLOR_CLUT1;
1517		break;
1518	case OMAPFB_COLOR_RGB444:
1519		mode = OMAP_DSS_COLOR_RGB12U;
1520		break;
1521	case OMAPFB_COLOR_YUY422:
1522		mode = OMAP_DSS_COLOR_UYVY;
1523		break;
1524	case OMAPFB_COLOR_ARGB16:
1525		mode = OMAP_DSS_COLOR_ARGB16;
1526		break;
1527	case OMAPFB_COLOR_RGB24U:
1528		mode = OMAP_DSS_COLOR_RGB24U;
1529		break;
1530	case OMAPFB_COLOR_RGB24P:
1531		mode = OMAP_DSS_COLOR_RGB24P;
1532		break;
1533	case OMAPFB_COLOR_ARGB32:
1534		mode = OMAP_DSS_COLOR_ARGB32;
1535		break;
1536	case OMAPFB_COLOR_RGBA32:
1537		mode = OMAP_DSS_COLOR_RGBA32;
1538		break;
1539	case OMAPFB_COLOR_RGBX32:
1540		mode = OMAP_DSS_COLOR_RGBX32;
1541		break;
1542	default:
1543		mode = -EINVAL;
1544	}
1545
1546	return mode;
1547}
1548
1549static int omapfb_parse_vram_param(const char *param, int max_entries,
1550		unsigned long *sizes, unsigned long *paddrs)
1551{
1552	int fbnum;
1553	unsigned long size;
1554	unsigned long paddr = 0;
1555	char *p, *start;
1556
1557	start = (char *)param;
1558
1559	while (1) {
1560		p = start;
1561
1562		fbnum = simple_strtoul(p, &p, 10);
1563
1564		if (p == param)
1565			return -EINVAL;
1566
1567		if (*p != ':')
1568			return -EINVAL;
1569
1570		if (fbnum >= max_entries)
1571			return -EINVAL;
1572
1573		size = memparse(p + 1, &p);
1574
1575		if (!size)
1576			return -EINVAL;
1577
1578		paddr = 0;
1579
1580		if (*p == '@') {
1581			paddr = simple_strtoul(p + 1, &p, 16);
1582
1583			if (!paddr)
1584				return -EINVAL;
1585
1586		}
1587
1588		paddrs[fbnum] = paddr;
1589		sizes[fbnum] = size;
1590
1591		if (*p == 0)
1592			break;
1593
1594		if (*p != ',')
1595			return -EINVAL;
1596
1597		++p;
1598
1599		start = p;
1600	}
1601
1602	return 0;
1603}
1604
1605static int omapfb_allocate_all_fbs(struct omapfb2_device *fbdev)
1606{
1607	int i, r;
1608	unsigned long vram_sizes[10];
1609	unsigned long vram_paddrs[10];
1610
1611	memset(&vram_sizes, 0, sizeof(vram_sizes));
1612	memset(&vram_paddrs, 0, sizeof(vram_paddrs));
1613
1614	if (def_vram &&	omapfb_parse_vram_param(def_vram, 10,
1615				vram_sizes, vram_paddrs)) {
1616		dev_err(fbdev->dev, "failed to parse vram parameter\n");
1617
1618		memset(&vram_sizes, 0, sizeof(vram_sizes));
1619		memset(&vram_paddrs, 0, sizeof(vram_paddrs));
1620	}
1621
1622	if (fbdev->dev->platform_data) {
1623		struct omapfb_platform_data *opd;
1624		opd = fbdev->dev->platform_data;
1625		for (i = 0; i < opd->mem_desc.region_cnt; ++i) {
1626			if (!vram_sizes[i]) {
1627				unsigned long size;
1628				unsigned long paddr;
1629
1630				size = opd->mem_desc.region[i].size;
1631				paddr = opd->mem_desc.region[i].paddr;
1632
1633				vram_sizes[i] = size;
1634				vram_paddrs[i] = paddr;
1635			}
1636		}
1637	}
1638
1639	for (i = 0; i < fbdev->num_fbs; i++) {
1640		/* allocate memory automatically only for fb0, or if
1641		 * excplicitly defined with vram or plat data option */
1642		if (i == 0 || vram_sizes[i] != 0) {
1643			r = omapfb_alloc_fbmem_display(fbdev->fbs[i],
1644					vram_sizes[i], vram_paddrs[i]);
1645
1646			if (r)
1647				return r;
1648		}
1649	}
1650
1651	for (i = 0; i < fbdev->num_fbs; i++) {
1652		struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[i]);
1653		struct omapfb2_mem_region *rg;
1654		rg = ofbi->region;
1655
1656		DBG("region%d phys %08x virt %p size=%lu\n",
1657				i,
1658				rg->paddr,
1659				rg->vaddr,
1660				rg->size);
1661	}
1662
1663	return 0;
1664}
1665
1666int omapfb_realloc_fbmem(struct fb_info *fbi, unsigned long size, int type)
1667{
1668	struct omapfb_info *ofbi = FB2OFB(fbi);
1669	struct omapfb2_device *fbdev = ofbi->fbdev;
1670	struct omap_dss_device *display = fb2display(fbi);
1671	struct omapfb2_mem_region *rg = ofbi->region;
1672	unsigned long old_size = rg->size;
1673	unsigned long old_paddr = rg->paddr;
1674	int old_type = rg->type;
1675	int r;
1676
1677	if (type > OMAPFB_MEMTYPE_MAX)
1678		return -EINVAL;
1679
1680	size = PAGE_ALIGN(size);
1681
1682	if (old_size == size && old_type == type)
1683		return 0;
1684
1685	if (display && display->driver->sync)
1686			display->driver->sync(display);
1687
1688	omapfb_free_fbmem(fbi);
1689
1690	if (size == 0) {
1691		clear_fb_info(fbi);
1692		return 0;
1693	}
1694
1695	r = omapfb_alloc_fbmem(fbi, size, 0);
1696
1697	if (r) {
1698		if (old_size)
1699			omapfb_alloc_fbmem(fbi, old_size, old_paddr);
1700
1701		if (rg->size == 0)
1702			clear_fb_info(fbi);
1703
1704		return r;
1705	}
1706
1707	if (old_size == size)
1708		return 0;
1709
1710	if (old_size == 0) {
1711		DBG("initializing fb %d\n", ofbi->id);
1712		r = omapfb_fb_init(fbdev, fbi);
1713		if (r) {
1714			DBG("omapfb_fb_init failed\n");
1715			goto err;
1716		}
1717		r = omapfb_apply_changes(fbi, 1);
1718		if (r) {
1719			DBG("omapfb_apply_changes failed\n");
1720			goto err;
1721		}
1722	} else {
1723		struct fb_var_screeninfo new_var;
1724		memcpy(&new_var, &fbi->var, sizeof(new_var));
1725		r = check_fb_var(fbi, &new_var);
1726		if (r)
1727			goto err;
1728		memcpy(&fbi->var, &new_var, sizeof(fbi->var));
1729		set_fb_fix(fbi);
1730		r = setup_vrfb_rotation(fbi);
1731		if (r)
1732			goto err;
1733	}
1734
1735	return 0;
1736err:
1737	omapfb_free_fbmem(fbi);
1738	clear_fb_info(fbi);
1739	return r;
1740}
1741
1742static void omapfb_auto_update_work(struct work_struct *work)
1743{
1744	struct omap_dss_device *dssdev;
1745	struct omap_dss_driver *dssdrv;
1746	struct omapfb_display_data *d;
1747	u16 w, h;
1748	unsigned int freq;
1749	struct omapfb2_device *fbdev;
1750
1751	d = container_of(work, struct omapfb_display_data,
1752			auto_update_work.work);
1753
1754	dssdev = d->dssdev;
1755	dssdrv = dssdev->driver;
1756	fbdev = d->fbdev;
1757
1758	if (!dssdrv || !dssdrv->update)
1759		return;
1760
1761	if (dssdrv->sync)
1762		dssdrv->sync(dssdev);
1763
1764	dssdrv->get_resolution(dssdev, &w, &h);
1765	dssdrv->update(dssdev, 0, 0, w, h);
1766
1767	freq = auto_update_freq;
1768	if (freq == 0)
1769		freq = 20;
1770	queue_delayed_work(fbdev->auto_update_wq,
1771			&d->auto_update_work, HZ / freq);
1772}
1773
1774void omapfb_start_auto_update(struct omapfb2_device *fbdev,
1775		struct omap_dss_device *display)
1776{
1777	struct omapfb_display_data *d;
1778
1779	if (fbdev->auto_update_wq == NULL) {
1780		struct workqueue_struct *wq;
1781
1782		wq = create_singlethread_workqueue("omapfb_auto_update");
1783
1784		if (wq == NULL) {
1785			dev_err(fbdev->dev, "Failed to create workqueue for "
1786					"auto-update\n");
1787			return;
1788		}
1789
1790		fbdev->auto_update_wq = wq;
1791	}
1792
1793	d = get_display_data(fbdev, display);
1794
1795	INIT_DELAYED_WORK(&d->auto_update_work, omapfb_auto_update_work);
1796
1797	d->auto_update_work_enabled = true;
1798
1799	omapfb_auto_update_work(&d->auto_update_work.work);
1800}
1801
1802void omapfb_stop_auto_update(struct omapfb2_device *fbdev,
1803		struct omap_dss_device *display)
1804{
1805	struct omapfb_display_data *d;
1806
1807	d = get_display_data(fbdev, display);
1808
1809	cancel_delayed_work_sync(&d->auto_update_work);
1810
1811	d->auto_update_work_enabled = false;
1812}
1813
1814/* initialize fb_info, var, fix to something sane based on the display */
1815static int omapfb_fb_init(struct omapfb2_device *fbdev, struct fb_info *fbi)
1816{
1817	struct fb_var_screeninfo *var = &fbi->var;
1818	struct omap_dss_device *display = fb2display(fbi);
1819	struct omapfb_info *ofbi = FB2OFB(fbi);
1820	int r = 0;
1821
1822	fbi->fbops = &omapfb_ops;
1823	fbi->flags = FBINFO_FLAG_DEFAULT;
1824	fbi->pseudo_palette = fbdev->pseudo_palette;
1825
1826	if (ofbi->region->size == 0) {
1827		clear_fb_info(fbi);
1828		return 0;
1829	}
1830
1831	var->nonstd = 0;
1832	var->bits_per_pixel = 0;
1833
1834	var->rotate = def_rotate;
1835
1836	/*
1837	 * Check if there is a default color format set in the board file,
1838	 * and use this format instead the default deducted from the
1839	 * display bpp.
1840	 */
1841	if (fbdev->dev->platform_data) {
1842		struct omapfb_platform_data *opd;
1843		int id = ofbi->id;
1844
1845		opd = fbdev->dev->platform_data;
1846		if (opd->mem_desc.region[id].format_used) {
1847			enum omap_color_mode mode;
1848			enum omapfb_color_format format;
1849
1850			format = opd->mem_desc.region[id].format;
1851			mode = fb_format_to_dss_mode(format);
1852			if (mode < 0) {
1853				r = mode;
1854				goto err;
1855			}
1856			r = dss_mode_to_fb_mode(mode, var);
1857			if (r < 0)
1858				goto err;
1859		}
1860	}
1861
1862	if (display) {
1863		u16 w, h;
1864		int rotation = (var->rotate + ofbi->rotation[0]) % 4;
1865
1866		display->driver->get_resolution(display, &w, &h);
1867
1868		if (rotation == FB_ROTATE_CW ||
1869				rotation == FB_ROTATE_CCW) {
1870			var->xres = h;
1871			var->yres = w;
1872		} else {
1873			var->xres = w;
1874			var->yres = h;
1875		}
1876
1877		var->xres_virtual = var->xres;
1878		var->yres_virtual = var->yres;
1879
1880		if (!var->bits_per_pixel) {
1881			switch (omapfb_get_recommended_bpp(fbdev, display)) {
1882			case 16:
1883				var->bits_per_pixel = 16;
1884				break;
1885			case 24:
1886				var->bits_per_pixel = 32;
1887				break;
1888			default:
1889				dev_err(fbdev->dev, "illegal display "
1890						"bpp\n");
1891				return -EINVAL;
1892			}
1893		}
1894	} else {
1895		/* if there's no display, let's just guess some basic values */
1896		var->xres = 320;
1897		var->yres = 240;
1898		var->xres_virtual = var->xres;
1899		var->yres_virtual = var->yres;
1900		if (!var->bits_per_pixel)
1901			var->bits_per_pixel = 16;
1902	}
1903
1904	r = check_fb_var(fbi, var);
1905	if (r)
1906		goto err;
1907
1908	set_fb_fix(fbi);
1909	r = setup_vrfb_rotation(fbi);
1910	if (r)
1911		goto err;
1912
1913	r = fb_alloc_cmap(&fbi->cmap, 256, 0);
1914	if (r)
1915		dev_err(fbdev->dev, "unable to allocate color map memory\n");
1916
1917err:
1918	return r;
1919}
1920
1921static void fbinfo_cleanup(struct omapfb2_device *fbdev, struct fb_info *fbi)
1922{
1923	fb_dealloc_cmap(&fbi->cmap);
1924}
1925
1926
1927static void omapfb_free_resources(struct omapfb2_device *fbdev)
1928{
1929	int i;
1930
1931	DBG("free_resources\n");
1932
1933	if (fbdev == NULL)
1934		return;
1935
1936	for (i = 0; i < fbdev->num_fbs; i++)
1937		unregister_framebuffer(fbdev->fbs[i]);
1938
1939	/* free the reserved fbmem */
1940	omapfb_free_all_fbmem(fbdev);
1941
1942	for (i = 0; i < fbdev->num_fbs; i++) {
1943		fbinfo_cleanup(fbdev, fbdev->fbs[i]);
1944		framebuffer_release(fbdev->fbs[i]);
1945	}
1946
1947	for (i = 0; i < fbdev->num_displays; i++) {
1948		struct omap_dss_device *dssdev = fbdev->displays[i].dssdev;
1949
1950		if (fbdev->displays[i].auto_update_work_enabled)
1951			omapfb_stop_auto_update(fbdev, dssdev);
1952
1953		if (dssdev->state != OMAP_DSS_DISPLAY_DISABLED)
1954			dssdev->driver->disable(dssdev);
1955
1956		omap_dss_put_device(dssdev);
1957	}
1958
1959	if (fbdev->auto_update_wq != NULL) {
1960		flush_workqueue(fbdev->auto_update_wq);
1961		destroy_workqueue(fbdev->auto_update_wq);
1962		fbdev->auto_update_wq = NULL;
1963	}
1964
1965	dev_set_drvdata(fbdev->dev, NULL);
1966	kfree(fbdev);
1967}
1968
1969static int omapfb_create_framebuffers(struct omapfb2_device *fbdev)
1970{
1971	int r, i;
1972
1973	fbdev->num_fbs = 0;
1974
1975	DBG("create %d framebuffers\n",	CONFIG_FB_OMAP2_NUM_FBS);
1976
1977	/* allocate fb_infos */
1978	for (i = 0; i < CONFIG_FB_OMAP2_NUM_FBS; i++) {
1979		struct fb_info *fbi;
1980		struct omapfb_info *ofbi;
1981
1982		fbi = framebuffer_alloc(sizeof(struct omapfb_info),
1983				fbdev->dev);
1984
1985		if (fbi == NULL) {
1986			dev_err(fbdev->dev,
1987				"unable to allocate memory for plane info\n");
1988			return -ENOMEM;
1989		}
1990
1991		clear_fb_info(fbi);
1992
1993		fbdev->fbs[i] = fbi;
1994
1995		ofbi = FB2OFB(fbi);
1996		ofbi->fbdev = fbdev;
1997		ofbi->id = i;
1998
1999		ofbi->region = &fbdev->regions[i];
2000		ofbi->region->id = i;
2001		init_rwsem(&ofbi->region->lock);
2002
2003		/* assign these early, so that fb alloc can use them */
2004		ofbi->rotation_type = def_vrfb ? OMAP_DSS_ROT_VRFB :
2005			OMAP_DSS_ROT_DMA;
2006		ofbi->mirror = def_mirror;
2007
2008		fbdev->num_fbs++;
2009	}
2010
2011	DBG("fb_infos allocated\n");
2012
2013	/* assign overlays for the fbs */
2014	for (i = 0; i < min(fbdev->num_fbs, fbdev->num_overlays); i++) {
2015		struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[i]);
2016
2017		ofbi->overlays[0] = fbdev->overlays[i];
2018		ofbi->num_overlays = 1;
2019	}
2020
2021	/* allocate fb memories */
2022	r = omapfb_allocate_all_fbs(fbdev);
2023	if (r) {
2024		dev_err(fbdev->dev, "failed to allocate fbmem\n");
2025		return r;
2026	}
2027
2028	DBG("fbmems allocated\n");
2029
2030	/* setup fb_infos */
2031	for (i = 0; i < fbdev->num_fbs; i++) {
2032		struct fb_info *fbi = fbdev->fbs[i];
2033		struct omapfb_info *ofbi = FB2OFB(fbi);
2034
2035		omapfb_get_mem_region(ofbi->region);
2036		r = omapfb_fb_init(fbdev, fbi);
2037		omapfb_put_mem_region(ofbi->region);
2038
2039		if (r) {
2040			dev_err(fbdev->dev, "failed to setup fb_info\n");
2041			return r;
2042		}
2043	}
2044
2045	DBG("fb_infos initialized\n");
2046
2047	for (i = 0; i < fbdev->num_fbs; i++) {
2048		r = register_framebuffer(fbdev->fbs[i]);
2049		if (r != 0) {
2050			dev_err(fbdev->dev,
2051				"registering framebuffer %d failed\n", i);
2052			return r;
2053		}
2054	}
2055
2056	DBG("framebuffers registered\n");
2057
2058	for (i = 0; i < fbdev->num_fbs; i++) {
2059		struct fb_info *fbi = fbdev->fbs[i];
2060		struct omapfb_info *ofbi = FB2OFB(fbi);
2061
2062		omapfb_get_mem_region(ofbi->region);
2063		r = omapfb_apply_changes(fbi, 1);
2064		omapfb_put_mem_region(ofbi->region);
2065
2066		if (r) {
2067			dev_err(fbdev->dev, "failed to change mode\n");
2068			return r;
2069		}
2070	}
2071
2072	/* Enable fb0 */
2073	if (fbdev->num_fbs > 0) {
2074		struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[0]);
2075
2076		if (ofbi->num_overlays > 0) {
2077			struct omap_overlay *ovl = ofbi->overlays[0];
2078
2079			r = omapfb_overlay_enable(ovl, 1);
2080
2081			if (r) {
2082				dev_err(fbdev->dev,
2083						"failed to enable overlay\n");
2084				return r;
2085			}
2086		}
2087	}
2088
2089	DBG("create_framebuffers done\n");
2090
2091	return 0;
2092}
2093
2094static int omapfb_mode_to_timings(const char *mode_str,
2095		struct omap_video_timings *timings, u8 *bpp)
2096{
2097	struct fb_info *fbi;
2098	struct fb_var_screeninfo *var;
2099	struct fb_ops *fbops;
2100	int r;
2101
2102#ifdef CONFIG_OMAP2_DSS_VENC
2103	if (strcmp(mode_str, "pal") == 0) {
2104		*timings = omap_dss_pal_timings;
2105		*bpp = 24;
2106		return 0;
2107	} else if (strcmp(mode_str, "ntsc") == 0) {
2108		*timings = omap_dss_ntsc_timings;
2109		*bpp = 24;
2110		return 0;
2111	}
2112#endif
2113
2114	/* this is quite a hack, but I wanted to use the modedb and for
2115	 * that we need fb_info and var, so we create dummy ones */
2116
2117	*bpp = 0;
2118	fbi = NULL;
2119	var = NULL;
2120	fbops = NULL;
2121
2122	fbi = kzalloc(sizeof(*fbi), GFP_KERNEL);
2123	if (fbi == NULL) {
2124		r = -ENOMEM;
2125		goto err;
2126	}
2127
2128	var = kzalloc(sizeof(*var), GFP_KERNEL);
2129	if (var == NULL) {
2130		r = -ENOMEM;
2131		goto err;
2132	}
2133
2134	fbops = kzalloc(sizeof(*fbops), GFP_KERNEL);
2135	if (fbops == NULL) {
2136		r = -ENOMEM;
2137		goto err;
2138	}
2139
2140	fbi->fbops = fbops;
2141
2142	r = fb_find_mode(var, fbi, mode_str, NULL, 0, NULL, 24);
2143	if (r == 0) {
2144		r = -EINVAL;
2145		goto err;
2146	}
2147
2148	timings->pixel_clock = PICOS2KHZ(var->pixclock);
2149	timings->hbp = var->left_margin;
2150	timings->hfp = var->right_margin;
2151	timings->vbp = var->upper_margin;
2152	timings->vfp = var->lower_margin;
2153	timings->hsw = var->hsync_len;
2154	timings->vsw = var->vsync_len;
2155	timings->x_res = var->xres;
2156	timings->y_res = var->yres;
2157
2158	switch (var->bits_per_pixel) {
2159	case 16:
2160		*bpp = 16;
2161		break;
2162	case 24:
2163	case 32:
2164	default:
2165		*bpp = 24;
2166		break;
2167	}
2168
2169	r = 0;
2170
2171err:
2172	kfree(fbi);
2173	kfree(var);
2174	kfree(fbops);
2175
2176	return r;
2177}
2178
2179static int omapfb_set_def_mode(stru

Large files files are truncated, but you can click here to view the full file