[linux-block.git] / arch / arm / plat-omap / fb.c

/*
 * File: arch/arm/plat-omap/fb.c
 *
 * Framebuffer device registration for TI OMAP platforms
 *
 * Copyright (C) 2006 Nokia Corporation
 * Author: Imre Deak <imre.deak@nokia.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/memblock.h>
#include <linux/io.h>
#include <linux/omapfb.h>

#include <mach/hardware.h>
#include <asm/mach/map.h>

#include <plat/board.h>
#include <plat/sram.h>

#include "fb.h"

#if defined(CONFIG_FB_OMAP) || defined(CONFIG_FB_OMAP_MODULE)

static struct omapfb_platform_data omapfb_config;
static int config_invalid;
static int configured_regions;

static u64 omap_fb_dma_mask = ~(u32)0;

static struct platform_device omap_fb_device = {
	.name		= "omapfb",
	.id		= -1,
	.dev = {
		.dma_mask		= &omap_fb_dma_mask,
		.coherent_dma_mask	= ~(u32)0,
		.platform_data		= &omapfb_config,
	},
	.num_resources = 0,
};

void omapfb_set_platform_data(struct omapfb_platform_data *data)
{
}

static inline int ranges_overlap(unsigned long start1, unsigned long size1,
				 unsigned long start2, unsigned long size2)
{
	return (start1 >= start2 && start1 < start2 + size2) ||
	       (start2 >= start1 && start2 < start1 + size1);
}

static inline int range_included(unsigned long start1, unsigned long size1,
				 unsigned long start2, unsigned long size2)
{
	return start1 >= start2 && start1 + size1 <= start2 + size2;
}


/* Check if there is an overlapping region. */
static int fbmem_region_reserved(unsigned long start, size_t size)
{
	struct omapfb_mem_region *rg;
	int i;

	rg = &omapfb_config.mem_desc.region[0];
	for (i = 0; i < OMAPFB_PLANE_NUM; i++, rg++) {
		if (!rg->paddr)
			/* Empty slot. */
			continue;
		if (ranges_overlap(start, size, rg->paddr, rg->size))
			return 1;
	}
	return 0;
}

/*
 * Get the region_idx`th region from board config/ATAG and convert it to
 * our internal format.
 */
static int __init get_fbmem_region(int region_idx, struct omapfb_mem_region *rg)
{
	const struct omap_fbmem_config	*conf;
	u32				paddr;

	conf = omap_get_nr_config(OMAP_TAG_FBMEM,
				  struct omap_fbmem_config, region_idx);
	if (conf == NULL)
		return -ENOENT;

	paddr = conf->start;
	/*
	 * Low bits encode the page allocation mode, if high bits
	 * are zero. Otherwise we need a page aligned fixed
	 * address.
	 */
	memset(rg, 0, sizeof(*rg));
	rg->type = paddr & ~PAGE_MASK;
	rg->paddr = paddr & PAGE_MASK;
	rg->size = PAGE_ALIGN(conf->size);
	return 0;
}

static int set_fbmem_region_type(struct omapfb_mem_region *rg, int mem_type,
				  unsigned long mem_start,
				  unsigned long mem_size)
{
	/*
	 * Check if the configuration specifies the type explicitly.
	 * type = 0 && paddr = 0, a default don't care case maps to
	 * the SDRAM type.
	 */
	if (rg->type || !rg->paddr)
		return 0;
	if (ranges_overlap(rg->paddr, rg->size, mem_start, mem_size)) {
		rg->type = mem_type;
		return 0;
	}
	/* Can't determine it. */
	return -1;
}

static int check_fbmem_region(int region_idx, struct omapfb_mem_region *rg,
			      unsigned long start_avail, unsigned size_avail)
{
	unsigned long	paddr = rg->paddr;
	size_t		size = rg->size;

	if (rg->type > OMAPFB_MEMTYPE_MAX) {
		printk(KERN_ERR
			"Invalid start address for FB region %d\n", region_idx);
		return -EINVAL;
	}

	if (!rg->size) {
		printk(KERN_ERR "Zero size for FB region %d\n", region_idx);
		return -EINVAL;
	}

	if (!paddr)
		/* Allocate this dynamically, leave paddr 0 for now. */
		return 0;

	/*
	 * Fixed region for the given RAM range. Check if it's already
	 * reserved by the FB code or someone else.
	 */
	if (fbmem_region_reserved(paddr, size) ||
	    !range_included(paddr, size, start_avail, size_avail)) {
		printk(KERN_ERR "Trying to use reserved memory "
			"for FB region %d\n", region_idx);
		return -EINVAL;
	}

	return 0;
}

static int valid_sdram(unsigned long addr, unsigned long size)
{
	return memblock_is_region_memory(addr, size);
}

static int reserve_sdram(unsigned long addr, unsigned long size)
{
	if (memblock_is_region_reserved(addr, size))
		return -EBUSY;
	if (memblock_reserve(addr, size))
		return -ENOMEM;
	return 0;
}

/*
 * Called from map_io. We need to call to this early enough so that we
 * can reserve the fixed SDRAM regions before VM could get hold of them.
 */
void __init omapfb_reserve_sdram_memblock(void)
{
	unsigned long reserved = 0;
	int i;

	if (config_invalid)
		return;

	for (i = 0; ; i++) {
		struct omapfb_mem_region rg;

		if (get_fbmem_region(i, &rg) < 0)
			break;

		if (i == OMAPFB_PLANE_NUM) {
			pr_err("Extraneous FB mem configuration entries\n");
			config_invalid = 1;
			return;
		}

		/* Check if it's our memory type. */
		if (rg.type != OMAPFB_MEMTYPE_SDRAM)
			continue;

		/* Check if the region falls within SDRAM */
		if (rg.paddr && !valid_sdram(rg.paddr, rg.size))
			continue;

		if (rg.size == 0) {
			pr_err("Zero size for FB region %d\n", i);
			config_invalid = 1;
			return;
		}

		if (rg.paddr) {
			if (reserve_sdram(rg.paddr, rg.size)) {
				pr_err("Trying to use reserved memory for FB region %d\n",
					i);
				config_invalid = 1;
				return;
			}
			reserved += rg.size;
		}

		if (omapfb_config.mem_desc.region[i].size) {
			pr_err("FB region %d already set\n", i);
			config_invalid = 1;
			return;
		}

		omapfb_config.mem_desc.region[i] = rg;
		configured_regions++;
	}
	omapfb_config.mem_desc.region_cnt = i;
	if (reserved)
		pr_info("Reserving %lu bytes SDRAM for frame buffer\n",
			 reserved);
}

/*
 * Called at sram init time, before anything is pushed to the SRAM stack.
 * Because of the stack scheme, we will allocate everything from the
 * start of the lowest address region to the end of SRAM. This will also
 * include padding for page alignment and possible holes between regions.
 *
 * As opposed to the SDRAM case, we'll also do any dynamic allocations at
 * this point, since the driver built as a module would have problem with
 * freeing / reallocating the regions.
 */
unsigned long __init omapfb_reserve_sram(unsigned long sram_pstart,
				  unsigned long sram_vstart,
				  unsigned long sram_size,
				  unsigned long pstart_avail,
				  unsigned long size_avail)
{
	struct omapfb_mem_region	rg;
	unsigned long			pend_avail;
	unsigned long			reserved;
	int				i;

	if (config_invalid)
		return 0;

	reserved = 0;
	pend_avail = pstart_avail + size_avail;
	for (i = 0; ; i++) {
		if (get_fbmem_region(i, &rg) < 0)
			break;
		if (i == OMAPFB_PLANE_NUM) {
			printk(KERN_ERR
				"Extraneous FB mem configuration entries\n");
			config_invalid = 1;
			return 0;
		}

		/* Check if it's our memory type. */
		if (set_fbmem_region_type(&rg, OMAPFB_MEMTYPE_SRAM,
				          sram_pstart, sram_size) < 0 ||
		    (rg.type != OMAPFB_MEMTYPE_SRAM))
			continue;
		BUG_ON(omapfb_config.mem_desc.region[i].size);

		if (check_fbmem_region(i, &rg, pstart_avail, size_avail) < 0) {
			config_invalid = 1;
			return 0;
		}

		if (!rg.paddr) {
			/* Dynamic allocation */
			if ((size_avail & PAGE_MASK) < rg.size) {
				printk("Not enough SRAM for FB region %d\n",
					i);
				config_invalid = 1;
				return 0;
			}
			size_avail = (size_avail - rg.size) & PAGE_MASK;
			rg.paddr = pstart_avail + size_avail;
		}
		/* Reserve everything above the start of the region. */
		if (pend_avail - rg.paddr > reserved)
			reserved = pend_avail - rg.paddr;
		size_avail = pend_avail - reserved - pstart_avail;

		/*
		 * We have a kernel mapping for this already, so the
		 * driver won't have to make one.
		 */
		rg.vaddr = (void *)(sram_vstart + rg.paddr - sram_pstart);
		omapfb_config.mem_desc.region[i] = rg;
		configured_regions++;
	}
	omapfb_config.mem_desc.region_cnt = i;
	if (reserved)
		pr_info("Reserving %lu bytes SRAM for frame buffer\n",
			 reserved);
	return reserved;
}

void omapfb_set_ctrl_platform_data(void *data)
{
	omapfb_config.ctrl_platform_data = data;
}

static int __init omap_init_fb(void)
{
	const struct omap_lcd_config *conf;

	if (config_invalid)
		return 0;
	if (configured_regions != omapfb_config.mem_desc.region_cnt) {
		printk(KERN_ERR "Invalid FB mem configuration entries\n");
		return 0;
	}
	conf = omap_get_config(OMAP_TAG_LCD, struct omap_lcd_config);
	if (conf == NULL) {
		if (configured_regions)
			/* FB mem config, but no LCD config? */
			printk(KERN_ERR "Missing LCD configuration\n");
		return 0;
	}
	omapfb_config.lcd = *conf;

	return platform_device_register(&omap_fb_device);
}

arch_initcall(omap_init_fb);

#elif defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE)

static u64 omap_fb_dma_mask = ~(u32)0;
static struct omapfb_platform_data omapfb_config;

static struct platform_device omap_fb_device = {
	.name		= "omapfb",
	.id		= -1,
	.dev = {
		.dma_mask		= &omap_fb_dma_mask,
		.coherent_dma_mask	= ~(u32)0,
		.platform_data		= &omapfb_config,
	},
	.num_resources = 0,
};

void omapfb_set_platform_data(struct omapfb_platform_data *data)
{
	omapfb_config = *data;
}

static int __init omap_init_fb(void)
{
	return platform_device_register(&omap_fb_device);
}

arch_initcall(omap_init_fb);

void omapfb_reserve_sdram_memblock(void)
{
}

unsigned long __init omapfb_reserve_sram(unsigned long sram_pstart,
				  unsigned long sram_vstart,
				  unsigned long sram_size,
				  unsigned long start_avail,
				  unsigned long size_avail)
{
	return 0;
}

#else

void omapfb_set_platform_data(struct omapfb_platform_data *data)
{
}

void omapfb_reserve_sdram_memblock(void)
{
}

unsigned long __init omapfb_reserve_sram(unsigned long sram_pstart,
				  unsigned long sram_vstart,
				  unsigned long sram_size,
				  unsigned long start_avail,
				  unsigned long size_avail)
{
	return 0;
}

#endif
Commit	Line	Data
c40fae95 TL	1	/*
	2	* File: arch/arm/plat-omap/fb.c
	3	*
	4	* Framebuffer device registration for TI OMAP platforms
	5	*
	6	* Copyright (C) 2006 Nokia Corporation
	7	* Author: Imre Deak <imre.deak@nokia.com>
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation; either version 2 of the License, or (at your
	12	* option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	22	*/
	23
0dc5e77c TL	24	#include <linux/module.h>
0dc5e77c TL	25	#include <linux/kernel.h>
27ac792c	26	#include <linux/mm.h>
0dc5e77c TL	27	#include <linux/init.h>
0dc5e77c TL	28	#include <linux/platform_device.h>
98864ff5	29	#include <linux/memblock.h>
fced80c7	30	#include <linux/io.h>
91773a00	31	#include <linux/omapfb.h>
0dc5e77c	32
a09e64fb	33	#include <mach/hardware.h>
0dc5e77c TL	34	#include <asm/mach/map.h>
0dc5e77c TL	35
ce491cf8 TL	36	#include <plat/board.h>
ce491cf8 TL	37	#include <plat/sram.h>
0dc5e77c	38
b0a330dc MK	39	#include "fb.h"
b0a330dc MK	40
0dc5e77c TL	41	#if defined(CONFIG_FB_OMAP) \|\| defined(CONFIG_FB_OMAP_MODULE)
	42
	43	static struct omapfb_platform_data omapfb_config;
b7cc6d46 ID	44	static int config_invalid;
b7cc6d46 ID	45	static int configured_regions;
0dc5e77c TL	46
	47	static u64 omap_fb_dma_mask = ~(u32)0;
	48
	49	static struct platform_device omap_fb_device = {
	50	.name = "omapfb",
	51	.id = -1,
	52	.dev = {
	53	.dma_mask = &omap_fb_dma_mask,
	54	.coherent_dma_mask = ~(u32)0,
	55	.platform_data = &omapfb_config,
	56	},
	57	.num_resources = 0,
	58	};
	59
b39a982d TV	60	void omapfb_set_platform_data(struct omapfb_platform_data *data)
	61	{
	62	}
	63
b7cc6d46 ID	64	static inline int ranges_overlap(unsigned long start1, unsigned long size1,
b7cc6d46 ID	65	unsigned long start2, unsigned long size2)
0dc5e77c	66	{
b7cc6d46 ID	67	return (start1 >= start2 && start1 < start2 + size2) \|\|
	68	(start2 >= start1 && start2 < start1 + size1);
	69	}
	70
	71	static inline int range_included(unsigned long start1, unsigned long size1,
	72	unsigned long start2, unsigned long size2)
	73	{
	74	return start1 >= start2 && start1 + size1 <= start2 + size2;
	75	}
	76
	77
	78	/* Check if there is an overlapping region. */
	79	static int fbmem_region_reserved(unsigned long start, size_t size)
	80	{
	81	struct omapfb_mem_region *rg;
c40fae95 TL	82	int i;
c40fae95 TL	83
b7cc6d46 ID	84	rg = &omapfb_config.mem_desc.region[0];
	85	for (i = 0; i < OMAPFB_PLANE_NUM; i++, rg++) {
	86	if (!rg->paddr)
	87	/* Empty slot. */
	88	continue;
	89	if (ranges_overlap(start, size, rg->paddr, rg->size))
	90	return 1;
c40fae95	91	}
b7cc6d46 ID	92	return 0;
b7cc6d46 ID	93	}
c40fae95	94
b7cc6d46 ID	95	/*
	96	* Get the region_idx`th region from board config/ATAG and convert it to
	97	* our internal format.
	98	*/
9dbb7a5d	99	static int __init get_fbmem_region(int region_idx, struct omapfb_mem_region *rg)
b7cc6d46 ID	100	{
	101	const struct omap_fbmem_config *conf;
	102	u32 paddr;
0dc5e77c	103
b7cc6d46 ID	104	conf = omap_get_nr_config(OMAP_TAG_FBMEM,
	105	struct omap_fbmem_config, region_idx);
	106	if (conf == NULL)
	107	return -ENOENT;
	108
	109	paddr = conf->start;
	110	/*
	111	* Low bits encode the page allocation mode, if high bits
	112	* are zero. Otherwise we need a page aligned fixed
	113	* address.
	114	*/
	115	memset(rg, 0, sizeof(*rg));
	116	rg->type = paddr & ~PAGE_MASK;
	117	rg->paddr = paddr & PAGE_MASK;
	118	rg->size = PAGE_ALIGN(conf->size);
	119	return 0;
	120	}
	121
	122	static int set_fbmem_region_type(struct omapfb_mem_region *rg, int mem_type,
	123	unsigned long mem_start,
	124	unsigned long mem_size)
	125	{
	126	/*
	127	* Check if the configuration specifies the type explicitly.
	128	* type = 0 && paddr = 0, a default don't care case maps to
	129	* the SDRAM type.
	130	*/
e1a75a1a	131	if (rg->type \|\| !rg->paddr)
b7cc6d46 ID	132	return 0;
	133	if (ranges_overlap(rg->paddr, rg->size, mem_start, mem_size)) {
	134	rg->type = mem_type;
	135	return 0;
	136	}
	137	/* Can't determine it. */
	138	return -1;
	139	}
	140
	141	static int check_fbmem_region(int region_idx, struct omapfb_mem_region *rg,
	142	unsigned long start_avail, unsigned size_avail)
	143	{
	144	unsigned long paddr = rg->paddr;
	145	size_t size = rg->size;
	146
	147	if (rg->type > OMAPFB_MEMTYPE_MAX) {
	148	printk(KERN_ERR
	149	"Invalid start address for FB region %d\n", region_idx);
	150	return -EINVAL;
	151	}
	152
	153	if (!rg->size) {
	154	printk(KERN_ERR "Zero size for FB region %d\n", region_idx);
	155	return -EINVAL;
	156	}
	157
	158	if (!paddr)
	159	/* Allocate this dynamically, leave paddr 0 for now. */
	160	return 0;
	161
	162	/*
	163	* Fixed region for the given RAM range. Check if it's already
	164	* reserved by the FB code or someone else.
	165	*/
	166	if (fbmem_region_reserved(paddr, size) \|\|
	167	!range_included(paddr, size, start_avail, size_avail)) {
	168	printk(KERN_ERR "Trying to use reserved memory "
	169	"for FB region %d\n", region_idx);
	170	return -EINVAL;
	171	}
	172
	173	return 0;
	174	}
	175
a1af0fbb RK	176	static int valid_sdram(unsigned long addr, unsigned long size)
a1af0fbb RK	177	{
5fd03dda	178	return memblock_is_region_memory(addr, size);
a1af0fbb RK	179	}
	180
	181	static int reserve_sdram(unsigned long addr, unsigned long size)
	182	{
98864ff5 RK	183	if (memblock_is_region_reserved(addr, size))
	184	return -EBUSY;
	185	if (memblock_reserve(addr, size))
	186	return -ENOMEM;
	187	return 0;
a1af0fbb RK	188	}
a1af0fbb RK	189
b7cc6d46 ID	190	/*
	191	* Called from map_io. We need to call to this early enough so that we
	192	* can reserve the fixed SDRAM regions before VM could get hold of them.
	193	*/
98864ff5	194	void __init omapfb_reserve_sdram_memblock(void)
b7cc6d46	195	{
a1af0fbb RK	196	unsigned long reserved = 0;
a1af0fbb RK	197	int i;
b7cc6d46 ID	198
	199	if (config_invalid)
	200	return;
	201
b7cc6d46	202	for (i = 0; ; i++) {
a1af0fbb	203	struct omapfb_mem_region rg;
b7cc6d46 ID	204
b7cc6d46 ID	205	if (get_fbmem_region(i, &rg) < 0)
c40fae95	206	break;
a1af0fbb	207
b7cc6d46	208	if (i == OMAPFB_PLANE_NUM) {
a1af0fbb	209	pr_err("Extraneous FB mem configuration entries\n");
b7cc6d46 ID	210	config_invalid = 1;
b7cc6d46 ID	211	return;
0dc5e77c	212	}
a1af0fbb	213
b7cc6d46	214	/* Check if it's our memory type. */
a1af0fbb RK	215	if (rg.type != OMAPFB_MEMTYPE_SDRAM)
	216	continue;
	217
	218	/* Check if the region falls within SDRAM */
	219	if (rg.paddr && !valid_sdram(rg.paddr, rg.size))
b7cc6d46	220	continue;
a1af0fbb RK	221
	222	if (rg.size == 0) {
	223	pr_err("Zero size for FB region %d\n", i);
b7cc6d46 ID	224	config_invalid = 1;
b7cc6d46 ID	225	return;
c40fae95	226	}
a1af0fbb	227
72af2b36	228	if (rg.paddr) {
a1af0fbb RK	229	if (reserve_sdram(rg.paddr, rg.size)) {
	230	pr_err("Trying to use reserved memory for FB region %d\n",
	231	i);
	232	config_invalid = 1;
	233	return;
	234	}
72af2b36 TV	235	reserved += rg.size;
72af2b36 TV	236	}
a1af0fbb RK	237
	238	if (omapfb_config.mem_desc.region[i].size) {
	239	pr_err("FB region %d already set\n", i);
	240	config_invalid = 1;
	241	return;
	242	}
	243
b7cc6d46 ID	244	omapfb_config.mem_desc.region[i] = rg;
b7cc6d46 ID	245	configured_regions++;
0dc5e77c	246	}
c40fae95	247	omapfb_config.mem_desc.region_cnt = i;
b7cc6d46	248	if (reserved)
c40fae95	249	pr_info("Reserving %lu bytes SDRAM for frame buffer\n",
b7cc6d46 ID	250	reserved);
	251	}
	252
	253	/*
	254	* Called at sram init time, before anything is pushed to the SRAM stack.
	255	* Because of the stack scheme, we will allocate everything from the
	256	* start of the lowest address region to the end of SRAM. This will also
	257	* include padding for page alignment and possible holes between regions.
	258	*
	259	* As opposed to the SDRAM case, we'll also do any dynamic allocations at
	260	* this point, since the driver built as a module would have problem with
	261	* freeing / reallocating the regions.
	262	*/
e92840b7	263	unsigned long __init omapfb_reserve_sram(unsigned long sram_pstart,
b7cc6d46 ID	264	unsigned long sram_vstart,
	265	unsigned long sram_size,
	266	unsigned long pstart_avail,
	267	unsigned long size_avail)
	268	{
	269	struct omapfb_mem_region rg;
	270	unsigned long pend_avail;
	271	unsigned long reserved;
	272	int i;
	273
	274	if (config_invalid)
	275	return 0;
	276
	277	reserved = 0;
	278	pend_avail = pstart_avail + size_avail;
	279	for (i = 0; ; i++) {
	280	if (get_fbmem_region(i, &rg) < 0)
	281	break;
	282	if (i == OMAPFB_PLANE_NUM) {
	283	printk(KERN_ERR
	284	"Extraneous FB mem configuration entries\n");
	285	config_invalid = 1;
	286	return 0;
	287	}
c40fae95	288
b7cc6d46 ID	289	/* Check if it's our memory type. */
	290	if (set_fbmem_region_type(&rg, OMAPFB_MEMTYPE_SRAM,
	291	sram_pstart, sram_size) < 0 \|\|
	292	(rg.type != OMAPFB_MEMTYPE_SRAM))
	293	continue;
	294	BUG_ON(omapfb_config.mem_desc.region[i].size);
	295
	296	if (check_fbmem_region(i, &rg, pstart_avail, size_avail) < 0) {
	297	config_invalid = 1;
	298	return 0;
	299	}
	300
	301	if (!rg.paddr) {
	302	/* Dynamic allocation */
	303	if ((size_avail & PAGE_MASK) < rg.size) {
	304	printk("Not enough SRAM for FB region %d\n",
	305	i);
	306	config_invalid = 1;
	307	return 0;
	308	}
	309	size_avail = (size_avail - rg.size) & PAGE_MASK;
	310	rg.paddr = pstart_avail + size_avail;
	311	}
	312	/* Reserve everything above the start of the region. */
	313	if (pend_avail - rg.paddr > reserved)
	314	reserved = pend_avail - rg.paddr;
	315	size_avail = pend_avail - reserved - pstart_avail;
	316
	317	/*
	318	* We have a kernel mapping for this already, so the
	319	* driver won't have to make one.
	320	*/
	321	rg.vaddr = (void *)(sram_vstart + rg.paddr - sram_pstart);
	322	omapfb_config.mem_desc.region[i] = rg;
	323	configured_regions++;
	324	}
	325	omapfb_config.mem_desc.region_cnt = i;
	326	if (reserved)
	327	pr_info("Reserving %lu bytes SRAM for frame buffer\n",
	328	reserved);
	329	return reserved;
0dc5e77c TL	330	}
0dc5e77c TL	331
771af222 ID	332	void omapfb_set_ctrl_platform_data(void *data)
	333	{
	334	omapfb_config.ctrl_platform_data = data;
	335	}
	336
375c324b	337	static int __init omap_init_fb(void)
0dc5e77c TL	338	{
	339	const struct omap_lcd_config *conf;
	340
b7cc6d46 ID	341	if (config_invalid)
	342	return 0;
	343	if (configured_regions != omapfb_config.mem_desc.region_cnt) {
	344	printk(KERN_ERR "Invalid FB mem configuration entries\n");
	345	return 0;
	346	}
0dc5e77c	347	conf = omap_get_config(OMAP_TAG_LCD, struct omap_lcd_config);
b7cc6d46 ID	348	if (conf == NULL) {
	349	if (configured_regions)
	350	/* FB mem config, but no LCD config? */
	351	printk(KERN_ERR "Missing LCD configuration\n");
0dc5e77c	352	return 0;
b7cc6d46	353	}
0dc5e77c TL	354	omapfb_config.lcd = *conf;
	355
	356	return platform_device_register(&omap_fb_device);
	357	}
	358
	359	arch_initcall(omap_init_fb);
	360
b39a982d TV	361	#elif defined(CONFIG_FB_OMAP2) \|\| defined(CONFIG_FB_OMAP2_MODULE)
	362
	363	static u64 omap_fb_dma_mask = ~(u32)0;
	364	static struct omapfb_platform_data omapfb_config;
	365
	366	static struct platform_device omap_fb_device = {
	367	.name = "omapfb",
	368	.id = -1,
	369	.dev = {
	370	.dma_mask = &omap_fb_dma_mask,
	371	.coherent_dma_mask = ~(u32)0,
	372	.platform_data = &omapfb_config,
	373	},
	374	.num_resources = 0,
	375	};
	376
	377	void omapfb_set_platform_data(struct omapfb_platform_data *data)
	378	{
	379	omapfb_config = *data;
	380	}
	381
375c324b	382	static int __init omap_init_fb(void)
b39a982d TV	383	{
	384	return platform_device_register(&omap_fb_device);
	385	}
	386
	387	arch_initcall(omap_init_fb);
0dc5e77c	388
98864ff5 RK	389	void omapfb_reserve_sdram_memblock(void)
	390	{
	391	}
	392
e92840b7	393	unsigned long __init omapfb_reserve_sram(unsigned long sram_pstart,
b7cc6d46 ID	394	unsigned long sram_vstart,
	395	unsigned long sram_size,
	396	unsigned long start_avail,
cc150b03 DB	397	unsigned long size_avail)
	398	{
	399	return 0;
	400	}
b7cc6d46	401
b39a982d TV	402	#else
	403
	404	void omapfb_set_platform_data(struct omapfb_platform_data *data)
	405	{
	406	}
	407
98864ff5 RK	408	void omapfb_reserve_sdram_memblock(void)
	409	{
	410	}
	411
e92840b7	412	unsigned long __init omapfb_reserve_sram(unsigned long sram_pstart,
b39a982d TV	413	unsigned long sram_vstart,
	414	unsigned long sram_size,
	415	unsigned long start_avail,
	416	unsigned long size_avail)
	417	{
	418	return 0;
	419	}
0dc5e77c TL	420
0dc5e77c TL	421	#endif