[deliverable/linux.git] / drivers / video / fbdev / omap2 / omapfb / omapfb-sysfs.c

/*
 * linux/drivers/video/omap2/omapfb-sysfs.c
 *
 * Copyright (C) 2008 Nokia Corporation
 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
 *
 * Some code and ideas taken from drivers/video/omap/ driver
 * by Imre Deak.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <linux/fb.h>
#include <linux/sysfs.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/platform_device.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/omapfb.h>

#include <video/omapfb_dss.h>
#include <video/omapvrfb.h>

#include "omapfb.h"

static ssize_t show_rotate_type(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);

	return snprintf(buf, PAGE_SIZE, "%d\n", ofbi->rotation_type);
}

static ssize_t store_rotate_type(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);
	struct omapfb2_mem_region *rg;
	int rot_type;
	int r;

	r = kstrtoint(buf, 0, &rot_type);
	if (r)
		return r;

	if (rot_type != OMAP_DSS_ROT_DMA && rot_type != OMAP_DSS_ROT_VRFB)
		return -EINVAL;

	if (!lock_fb_info(fbi))
		return -ENODEV;

	r = 0;
	if (rot_type == ofbi->rotation_type)
		goto out;

	rg = omapfb_get_mem_region(ofbi->region);

	if (rg->size) {
		r = -EBUSY;
		goto put_region;
	}

	ofbi->rotation_type = rot_type;

	/*
	 * Since the VRAM for this FB is not allocated at the moment we don't
	 * need to do any further parameter checking at this point.
	 */
put_region:
	omapfb_put_mem_region(rg);
out:
	unlock_fb_info(fbi);

	return r ? r : count;
}


static ssize_t show_mirror(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);

	return snprintf(buf, PAGE_SIZE, "%d\n", ofbi->mirror);
}

static ssize_t store_mirror(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);
	bool mirror;
	int r;
	struct fb_var_screeninfo new_var;

	r = strtobool(buf, &mirror);
	if (r)
		return r;

	if (!lock_fb_info(fbi))
		return -ENODEV;

	ofbi->mirror = mirror;

	omapfb_get_mem_region(ofbi->region);

	memcpy(&new_var, &fbi->var, sizeof(new_var));
	r = check_fb_var(fbi, &new_var);
	if (r)
		goto out;
	memcpy(&fbi->var, &new_var, sizeof(fbi->var));

	set_fb_fix(fbi);

	r = omapfb_apply_changes(fbi, 0);
	if (r)
		goto out;

	r = count;
out:
	omapfb_put_mem_region(ofbi->region);

	unlock_fb_info(fbi);

	return r;
}

static ssize_t show_overlays(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);
	struct omapfb2_device *fbdev = ofbi->fbdev;
	ssize_t l = 0;
	int t;

	if (!lock_fb_info(fbi))
		return -ENODEV;
	omapfb_lock(fbdev);

	for (t = 0; t < ofbi->num_overlays; t++) {
		struct omap_overlay *ovl = ofbi->overlays[t];
		int ovlnum;

		for (ovlnum = 0; ovlnum < fbdev->num_overlays; ++ovlnum)
			if (ovl == fbdev->overlays[ovlnum])
				break;

		l += snprintf(buf + l, PAGE_SIZE - l, "%s%d",
				t == 0 ? "" : ",", ovlnum);
	}

	l += snprintf(buf + l, PAGE_SIZE - l, "\n");

	omapfb_unlock(fbdev);
	unlock_fb_info(fbi);

	return l;
}

static struct omapfb_info *get_overlay_fb(struct omapfb2_device *fbdev,
		struct omap_overlay *ovl)
{
	int i, t;

	for (i = 0; i < fbdev->num_fbs; i++) {
		struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[i]);

		for (t = 0; t < ofbi->num_overlays; t++) {
			if (ofbi->overlays[t] == ovl)
				return ofbi;
		}
	}

	return NULL;
}

static ssize_t store_overlays(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);
	struct omapfb2_device *fbdev = ofbi->fbdev;
	struct omap_overlay *ovls[OMAPFB_MAX_OVL_PER_FB];
	struct omap_overlay *ovl;
	int num_ovls, r, i;
	int len;
	bool added = false;

	num_ovls = 0;

	len = strlen(buf);
	if (buf[len - 1] == '\n')
		len = len - 1;

	if (!lock_fb_info(fbi))
		return -ENODEV;
	omapfb_lock(fbdev);

	if (len > 0) {
		char *p = (char *)buf;
		int ovlnum;

		while (p < buf + len) {
			int found;
			if (num_ovls == OMAPFB_MAX_OVL_PER_FB) {
				r = -EINVAL;
				goto out;
			}

			ovlnum = simple_strtoul(p, &p, 0);
			if (ovlnum > fbdev->num_overlays) {
				r = -EINVAL;
				goto out;
			}

			found = 0;
			for (i = 0; i < num_ovls; ++i) {
				if (ovls[i] == fbdev->overlays[ovlnum]) {
					found = 1;
					break;
				}
			}

			if (!found)
				ovls[num_ovls++] = fbdev->overlays[ovlnum];

			p++;
		}
	}

	for (i = 0; i < num_ovls; ++i) {
		struct omapfb_info *ofbi2 = get_overlay_fb(fbdev, ovls[i]);
		if (ofbi2 && ofbi2 != ofbi) {
			dev_err(fbdev->dev, "overlay already in use\n");
			r = -EINVAL;
			goto out;
		}
	}

	/* detach unused overlays */
	for (i = 0; i < ofbi->num_overlays; ++i) {
		int t, found;

		ovl = ofbi->overlays[i];

		found = 0;

		for (t = 0; t < num_ovls; ++t) {
			if (ovl == ovls[t]) {
				found = 1;
				break;
			}
		}

		if (found)
			continue;

		DBG("detaching %d\n", ofbi->overlays[i]->id);

		omapfb_get_mem_region(ofbi->region);

		omapfb_overlay_enable(ovl, 0);

		if (ovl->manager)
			ovl->manager->apply(ovl->manager);

		omapfb_put_mem_region(ofbi->region);

		for (t = i + 1; t < ofbi->num_overlays; t++) {
			ofbi->rotation[t-1] = ofbi->rotation[t];
			ofbi->overlays[t-1] = ofbi->overlays[t];
		}

		ofbi->num_overlays--;
		i--;
	}

	for (i = 0; i < num_ovls; ++i) {
		int t, found;

		ovl = ovls[i];

		found = 0;

		for (t = 0; t < ofbi->num_overlays; ++t) {
			if (ovl == ofbi->overlays[t]) {
				found = 1;
				break;
			}
		}

		if (found)
			continue;
		ofbi->rotation[ofbi->num_overlays] = 0;
		ofbi->overlays[ofbi->num_overlays++] = ovl;

		added = true;
	}

	if (added) {
		omapfb_get_mem_region(ofbi->region);

		r = omapfb_apply_changes(fbi, 0);

		omapfb_put_mem_region(ofbi->region);

		if (r)
			goto out;
	}

	r = count;
out:
	omapfb_unlock(fbdev);
	unlock_fb_info(fbi);

	return r;
}

static ssize_t show_overlays_rotate(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);
	ssize_t l = 0;
	int t;

	if (!lock_fb_info(fbi))
		return -ENODEV;

	for (t = 0; t < ofbi->num_overlays; t++) {
		l += snprintf(buf + l, PAGE_SIZE - l, "%s%d",
				t == 0 ? "" : ",", ofbi->rotation[t]);
	}

	l += snprintf(buf + l, PAGE_SIZE - l, "\n");

	unlock_fb_info(fbi);

	return l;
}

static ssize_t store_overlays_rotate(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);
	int num_ovls = 0, r, i;
	int len;
	bool changed = false;
	u8 rotation[OMAPFB_MAX_OVL_PER_FB];

	len = strlen(buf);
	if (buf[len - 1] == '\n')
		len = len - 1;

	if (!lock_fb_info(fbi))
		return -ENODEV;

	if (len > 0) {
		char *p = (char *)buf;

		while (p < buf + len) {
			int rot;

			if (num_ovls == ofbi->num_overlays) {
				r = -EINVAL;
				goto out;
			}

			rot = simple_strtoul(p, &p, 0);
			if (rot < 0 || rot > 3) {
				r = -EINVAL;
				goto out;
			}

			if (ofbi->rotation[num_ovls] != rot)
				changed = true;

			rotation[num_ovls++] = rot;

			p++;
		}
	}

	if (num_ovls != ofbi->num_overlays) {
		r = -EINVAL;
		goto out;
	}

	if (changed) {
		for (i = 0; i < num_ovls; ++i)
			ofbi->rotation[i] = rotation[i];

		omapfb_get_mem_region(ofbi->region);

		r = omapfb_apply_changes(fbi, 0);

		omapfb_put_mem_region(ofbi->region);

		if (r)
			goto out;

		/* FIXME error handling? */
	}

	r = count;
out:
	unlock_fb_info(fbi);

	return r;
}

static ssize_t show_size(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);

	return snprintf(buf, PAGE_SIZE, "%lu\n", ofbi->region->size);
}

static ssize_t store_size(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);
	struct omapfb2_device *fbdev = ofbi->fbdev;
	struct omap_dss_device *display = fb2display(fbi);
	struct omapfb2_mem_region *rg;
	unsigned long size;
	int r;
	int i;

	r = kstrtoul(buf, 0, &size);
	if (r)
		return r;

	size = PAGE_ALIGN(size);

	if (!lock_fb_info(fbi))
		return -ENODEV;

	if (display && display->driver->sync)
		display->driver->sync(display);

	rg = ofbi->region;

	down_write_nested(&rg->lock, rg->id);
	atomic_inc(&rg->lock_count);

	if (atomic_read(&rg->map_count)) {
		r = -EBUSY;
		goto out;
	}

	for (i = 0; i < fbdev->num_fbs; i++) {
		struct omapfb_info *ofbi2 = FB2OFB(fbdev->fbs[i]);
		int j;

		if (ofbi2->region != rg)
			continue;

		for (j = 0; j < ofbi2->num_overlays; j++) {
			struct omap_overlay *ovl;
			ovl = ofbi2->overlays[j];
			if (ovl->is_enabled(ovl)) {
				r = -EBUSY;
				goto out;
			}
		}
	}

	if (size != ofbi->region->size) {
		r = omapfb_realloc_fbmem(fbi, size, ofbi->region->type);
		if (r) {
			dev_err(dev, "realloc fbmem failed\n");
			goto out;
		}
	}

	r = count;
out:
	atomic_dec(&rg->lock_count);
	up_write(&rg->lock);

	unlock_fb_info(fbi);

	return r;
}

static ssize_t show_phys(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);

	return snprintf(buf, PAGE_SIZE, "%0x\n", ofbi->region->paddr);
}

static ssize_t show_virt(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct omapfb_info *ofbi = FB2OFB(fbi);

	return snprintf(buf, PAGE_SIZE, "%p\n", ofbi->region->vaddr);
}

static ssize_t show_upd_mode(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	enum omapfb_update_mode mode;
	int r;

	r = omapfb_get_update_mode(fbi, &mode);

	if (r)
		return r;

	return snprintf(buf, PAGE_SIZE, "%u\n", (unsigned)mode);
}

static ssize_t store_upd_mode(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	unsigned mode;
	int r;

	r = kstrtouint(buf, 0, &mode);
	if (r)
		return r;

	r = omapfb_set_update_mode(fbi, mode);
	if (r)
		return r;

	return count;
}

static struct device_attribute omapfb_attrs[] = {
	__ATTR(rotate_type, S_IRUGO | S_IWUSR, show_rotate_type,
			store_rotate_type),
	__ATTR(mirror, S_IRUGO | S_IWUSR, show_mirror, store_mirror),
	__ATTR(size, S_IRUGO | S_IWUSR, show_size, store_size),
	__ATTR(overlays, S_IRUGO | S_IWUSR, show_overlays, store_overlays),
	__ATTR(overlays_rotate, S_IRUGO | S_IWUSR, show_overlays_rotate,
			store_overlays_rotate),
	__ATTR(phys_addr, S_IRUGO, show_phys, NULL),
	__ATTR(virt_addr, S_IRUGO, show_virt, NULL),
	__ATTR(update_mode, S_IRUGO | S_IWUSR, show_upd_mode, store_upd_mode),
};

int omapfb_create_sysfs(struct omapfb2_device *fbdev)
{
	int i;
	int r;

	DBG("create sysfs for fbs\n");
	for (i = 0; i < fbdev->num_fbs; i++) {
		int t;
		for (t = 0; t < ARRAY_SIZE(omapfb_attrs); t++) {
			r = device_create_file(fbdev->fbs[i]->dev,
					&omapfb_attrs[t]);

			if (r) {
				dev_err(fbdev->dev, "failed to create sysfs "
						"file\n");
				return r;
			}
		}
	}

	return 0;
}

void omapfb_remove_sysfs(struct omapfb2_device *fbdev)
{
	int i, t;

	DBG("remove sysfs for fbs\n");
	for (i = 0; i < fbdev->num_fbs; i++) {
		for (t = 0; t < ARRAY_SIZE(omapfb_attrs); t++)
			device_remove_file(fbdev->fbs[i]->dev,
					&omapfb_attrs[t]);
	}
}
Commit	Line	Data
b39a982d TV	1	/*
	2	* linux/drivers/video/omap2/omapfb-sysfs.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/fb.h>
	24	#include <linux/sysfs.h>
	25	#include <linux/device.h>
	26	#include <linux/uaccess.h>
	27	#include <linux/platform_device.h>
	28	#include <linux/kernel.h>
	29	#include <linux/mm.h>
	30	#include <linux/omapfb.h>
	31
62d9e44e	32	#include <video/omapfb_dss.h>
6a1c9f6d	33	#include <video/omapvrfb.h>
b39a982d TV	34
	35	#include "omapfb.h"
	36
	37	static ssize_t show_rotate_type(struct device *dev,
	38	struct device_attribute attr, char buf)
	39	{
	40	struct fb_info *fbi = dev_get_drvdata(dev);
	41	struct omapfb_info *ofbi = FB2OFB(fbi);
	42
	43	return snprintf(buf, PAGE_SIZE, "%d\n", ofbi->rotation_type);
	44	}
	45
	46	static ssize_t store_rotate_type(struct device *dev,
	47	struct device_attribute *attr,
	48	const char *buf, size_t count)
	49	{
	50	struct fb_info *fbi = dev_get_drvdata(dev);
	51	struct omapfb_info *ofbi = FB2OFB(fbi);
430571d5	52	struct omapfb2_mem_region *rg;
e3502ce9	53	int rot_type;
b39a982d TV	54	int r;
b39a982d TV	55
e3502ce9 TV	56	r = kstrtoint(buf, 0, &rot_type);
	57	if (r)
	58	return r;
b39a982d TV	59
	60	if (rot_type != OMAP_DSS_ROT_DMA && rot_type != OMAP_DSS_ROT_VRFB)
	61	return -EINVAL;
	62
27b67c92 JN	63	if (!lock_fb_info(fbi))
27b67c92 JN	64	return -ENODEV;
b39a982d TV	65
	66	r = 0;
	67	if (rot_type == ofbi->rotation_type)
	68	goto out;
	69
3ed37d9a	70	rg = omapfb_get_mem_region(ofbi->region);
430571d5 VS	71
430571d5 VS	72	if (rg->size) {
b39a982d	73	r = -EBUSY;
430571d5	74	goto put_region;
b39a982d TV	75	}
	76
	77	ofbi->rotation_type = rot_type;
	78
	79	/*
	80	* Since the VRAM for this FB is not allocated at the moment we don't
	81	* need to do any further parameter checking at this point.
	82	*/
430571d5	83	put_region:
3ed37d9a	84	omapfb_put_mem_region(rg);
b39a982d TV	85	out:
	86	unlock_fb_info(fbi);
	87
	88	return r ? r : count;
	89	}
	90
	91
	92	static ssize_t show_mirror(struct device *dev,
	93	struct device_attribute attr, char buf)
	94	{
	95	struct fb_info *fbi = dev_get_drvdata(dev);
	96	struct omapfb_info *ofbi = FB2OFB(fbi);
	97
	98	return snprintf(buf, PAGE_SIZE, "%d\n", ofbi->mirror);
	99	}
	100
	101	static ssize_t store_mirror(struct device *dev,
	102	struct device_attribute *attr,
	103	const char *buf, size_t count)
	104	{
	105	struct fb_info *fbi = dev_get_drvdata(dev);
	106	struct omapfb_info *ofbi = FB2OFB(fbi);
7fbf1bb0	107	bool mirror;
b39a982d TV	108	int r;
	109	struct fb_var_screeninfo new_var;
	110
7fbf1bb0	111	r = strtobool(buf, &mirror);
e3502ce9 TV	112	if (r)
e3502ce9 TV	113	return r;
b39a982d	114
27b67c92 JN	115	if (!lock_fb_info(fbi))
27b67c92 JN	116	return -ENODEV;
b39a982d TV	117
	118	ofbi->mirror = mirror;
	119
3ed37d9a TV	120	omapfb_get_mem_region(ofbi->region);
3ed37d9a TV	121
b39a982d TV	122	memcpy(&new_var, &fbi->var, sizeof(new_var));
	123	r = check_fb_var(fbi, &new_var);
	124	if (r)
	125	goto out;
	126	memcpy(&fbi->var, &new_var, sizeof(fbi->var));
	127
	128	set_fb_fix(fbi);
	129
	130	r = omapfb_apply_changes(fbi, 0);
	131	if (r)
	132	goto out;
	133
	134	r = count;
	135	out:
3ed37d9a TV	136	omapfb_put_mem_region(ofbi->region);
3ed37d9a TV	137
b39a982d TV	138	unlock_fb_info(fbi);
	139
	140	return r;
	141	}
	142
	143	static ssize_t show_overlays(struct device *dev,
	144	struct device_attribute attr, char buf)
	145	{
	146	struct fb_info *fbi = dev_get_drvdata(dev);
	147	struct omapfb_info *ofbi = FB2OFB(fbi);
	148	struct omapfb2_device *fbdev = ofbi->fbdev;
	149	ssize_t l = 0;
	150	int t;
	151
27b67c92 JN	152	if (!lock_fb_info(fbi))
27b67c92 JN	153	return -ENODEV;
238a4132	154	omapfb_lock(fbdev);
b39a982d TV	155
	156	for (t = 0; t < ofbi->num_overlays; t++) {
	157	struct omap_overlay *ovl = ofbi->overlays[t];
	158	int ovlnum;
	159
	160	for (ovlnum = 0; ovlnum < fbdev->num_overlays; ++ovlnum)
	161	if (ovl == fbdev->overlays[ovlnum])
	162	break;
	163
	164	l += snprintf(buf + l, PAGE_SIZE - l, "%s%d",
	165	t == 0 ? "" : ",", ovlnum);
	166	}
	167
	168	l += snprintf(buf + l, PAGE_SIZE - l, "\n");
	169
b39a982d	170	omapfb_unlock(fbdev);
238a4132	171	unlock_fb_info(fbi);
b39a982d TV	172
	173	return l;
	174	}
	175
	176	static struct omapfb_info get_overlay_fb(struct omapfb2_device fbdev,
	177	struct omap_overlay *ovl)
	178	{
	179	int i, t;
	180
	181	for (i = 0; i < fbdev->num_fbs; i++) {
	182	struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[i]);
	183
	184	for (t = 0; t < ofbi->num_overlays; t++) {
	185	if (ofbi->overlays[t] == ovl)
	186	return ofbi;
	187	}
	188	}
	189
	190	return NULL;
	191	}
	192
	193	static ssize_t store_overlays(struct device dev, struct device_attribute attr,
	194	const char *buf, size_t count)
	195	{
	196	struct fb_info *fbi = dev_get_drvdata(dev);
	197	struct omapfb_info *ofbi = FB2OFB(fbi);
	198	struct omapfb2_device *fbdev = ofbi->fbdev;
	199	struct omap_overlay *ovls[OMAPFB_MAX_OVL_PER_FB];
	200	struct omap_overlay *ovl;
	201	int num_ovls, r, i;
	202	int len;
	203	bool added = false;
	204
	205	num_ovls = 0;
	206
	207	len = strlen(buf);
	208	if (buf[len - 1] == '\n')
	209	len = len - 1;
	210
27b67c92 JN	211	if (!lock_fb_info(fbi))
27b67c92 JN	212	return -ENODEV;
238a4132	213	omapfb_lock(fbdev);
b39a982d TV	214
	215	if (len > 0) {
	216	char p = (char )buf;
	217	int ovlnum;
	218
	219	while (p < buf + len) {
	220	int found;
	221	if (num_ovls == OMAPFB_MAX_OVL_PER_FB) {
	222	r = -EINVAL;
	223	goto out;
	224	}
	225
	226	ovlnum = simple_strtoul(p, &p, 0);
	227	if (ovlnum > fbdev->num_overlays) {
	228	r = -EINVAL;
	229	goto out;
	230	}
	231
	232	found = 0;
	233	for (i = 0; i < num_ovls; ++i) {
	234	if (ovls[i] == fbdev->overlays[ovlnum]) {
	235	found = 1;
	236	break;
	237	}
	238	}
	239
	240	if (!found)
	241	ovls[num_ovls++] = fbdev->overlays[ovlnum];
	242
	243	p++;
	244	}
	245	}
	246
	247	for (i = 0; i < num_ovls; ++i) {
	248	struct omapfb_info *ofbi2 = get_overlay_fb(fbdev, ovls[i]);
	249	if (ofbi2 && ofbi2 != ofbi) {
	250	dev_err(fbdev->dev, "overlay already in use\n");
	251	r = -EINVAL;
	252	goto out;
	253	}
	254	}
	255
	256	/* detach unused overlays */
	257	for (i = 0; i < ofbi->num_overlays; ++i) {
	258	int t, found;
	259
	260	ovl = ofbi->overlays[i];
	261
	262	found = 0;
	263
	264	for (t = 0; t < num_ovls; ++t) {
	265	if (ovl == ovls[t]) {
	266	found = 1;
	267	break;
	268	}
	269	}
	270
	271	if (found)
	272	continue;
	273
	274	DBG("detaching %d\n", ofbi->overlays[i]->id);
	275
3ed37d9a TV	276	omapfb_get_mem_region(ofbi->region);
3ed37d9a TV	277
b39a982d TV	278	omapfb_overlay_enable(ovl, 0);
	279
	280	if (ovl->manager)
	281	ovl->manager->apply(ovl->manager);
	282
3ed37d9a TV	283	omapfb_put_mem_region(ofbi->region);
3ed37d9a TV	284
b39a982d TV	285	for (t = i + 1; t < ofbi->num_overlays; t++) {
	286	ofbi->rotation[t-1] = ofbi->rotation[t];
	287	ofbi->overlays[t-1] = ofbi->overlays[t];
	288	}
	289
	290	ofbi->num_overlays--;
	291	i--;
	292	}
	293
	294	for (i = 0; i < num_ovls; ++i) {
	295	int t, found;
	296
	297	ovl = ovls[i];
	298
	299	found = 0;
	300
	301	for (t = 0; t < ofbi->num_overlays; ++t) {
	302	if (ovl == ofbi->overlays[t]) {
	303	found = 1;
	304	break;
	305	}
	306	}
	307
	308	if (found)
	309	continue;
	310	ofbi->rotation[ofbi->num_overlays] = 0;
	311	ofbi->overlays[ofbi->num_overlays++] = ovl;
	312
	313	added = true;
	314	}
	315
	316	if (added) {
3ed37d9a TV	317	omapfb_get_mem_region(ofbi->region);
3ed37d9a TV	318
b39a982d	319	r = omapfb_apply_changes(fbi, 0);
430571d5	320
3ed37d9a TV	321	omapfb_put_mem_region(ofbi->region);
3ed37d9a TV	322
b39a982d TV	323	if (r)
	324	goto out;
	325	}
	326
	327	r = count;
	328	out:
b39a982d	329	omapfb_unlock(fbdev);
238a4132	330	unlock_fb_info(fbi);
b39a982d TV	331
	332	return r;
	333	}
	334
	335	static ssize_t show_overlays_rotate(struct device *dev,
	336	struct device_attribute attr, char buf)
	337	{
	338	struct fb_info *fbi = dev_get_drvdata(dev);
	339	struct omapfb_info *ofbi = FB2OFB(fbi);
	340	ssize_t l = 0;
	341	int t;
	342
27b67c92 JN	343	if (!lock_fb_info(fbi))
27b67c92 JN	344	return -ENODEV;
b39a982d TV	345
	346	for (t = 0; t < ofbi->num_overlays; t++) {
	347	l += snprintf(buf + l, PAGE_SIZE - l, "%s%d",
	348	t == 0 ? "" : ",", ofbi->rotation[t]);
	349	}
	350
	351	l += snprintf(buf + l, PAGE_SIZE - l, "\n");
	352
	353	unlock_fb_info(fbi);
	354
	355	return l;
	356	}
	357
	358	static ssize_t store_overlays_rotate(struct device *dev,
	359	struct device_attribute attr, const char buf, size_t count)
	360	{
	361	struct fb_info *fbi = dev_get_drvdata(dev);
	362	struct omapfb_info *ofbi = FB2OFB(fbi);
	363	int num_ovls = 0, r, i;
	364	int len;
	365	bool changed = false;
	366	u8 rotation[OMAPFB_MAX_OVL_PER_FB];
	367
	368	len = strlen(buf);
	369	if (buf[len - 1] == '\n')
	370	len = len - 1;
	371
27b67c92 JN	372	if (!lock_fb_info(fbi))
27b67c92 JN	373	return -ENODEV;
b39a982d TV	374
	375	if (len > 0) {
	376	char p = (char )buf;
	377
	378	while (p < buf + len) {
	379	int rot;
	380
	381	if (num_ovls == ofbi->num_overlays) {
	382	r = -EINVAL;
	383	goto out;
	384	}
	385
	386	rot = simple_strtoul(p, &p, 0);
	387	if (rot < 0 \|\| rot > 3) {
	388	r = -EINVAL;
	389	goto out;
	390	}
	391
	392	if (ofbi->rotation[num_ovls] != rot)
	393	changed = true;
	394
	395	rotation[num_ovls++] = rot;
	396
	397	p++;
	398	}
	399	}
	400
	401	if (num_ovls != ofbi->num_overlays) {
	402	r = -EINVAL;
	403	goto out;
	404	}
	405
	406	if (changed) {
	407	for (i = 0; i < num_ovls; ++i)
	408	ofbi->rotation[i] = rotation[i];
	409
3ed37d9a TV	410	omapfb_get_mem_region(ofbi->region);
3ed37d9a TV	411
b39a982d	412	r = omapfb_apply_changes(fbi, 0);
3ed37d9a TV	413
	414	omapfb_put_mem_region(ofbi->region);
	415
b39a982d TV	416	if (r)
	417	goto out;
	418
	419	/* FIXME error handling? */
	420	}
	421
	422	r = count;
	423	out:
	424	unlock_fb_info(fbi);
	425
	426	return r;
	427	}
	428
	429	static ssize_t show_size(struct device *dev,
	430	struct device_attribute attr, char buf)
	431	{
	432	struct fb_info *fbi = dev_get_drvdata(dev);
	433	struct omapfb_info *ofbi = FB2OFB(fbi);
	434
3ed37d9a	435	return snprintf(buf, PAGE_SIZE, "%lu\n", ofbi->region->size);
b39a982d TV	436	}
	437
	438	static ssize_t store_size(struct device dev, struct device_attribute attr,
	439	const char *buf, size_t count)
	440	{
	441	struct fb_info *fbi = dev_get_drvdata(dev);
	442	struct omapfb_info *ofbi = FB2OFB(fbi);
078ff546	443	struct omapfb2_device *fbdev = ofbi->fbdev;
636f4e1b	444	struct omap_dss_device *display = fb2display(fbi);
078ff546	445	struct omapfb2_mem_region *rg;
b39a982d TV	446	unsigned long size;
	447	int r;
	448	int i;
	449
e3502ce9 TV	450	r = kstrtoul(buf, 0, &size);
	451	if (r)
	452	return r;
	453
	454	size = PAGE_ALIGN(size);
b39a982d	455
27b67c92 JN	456	if (!lock_fb_info(fbi))
27b67c92 JN	457	return -ENODEV;
b39a982d	458
636f4e1b TV	459	if (display && display->driver->sync)
	460	display->driver->sync(display);
	461
b41deecb	462	rg = ofbi->region;
430571d5	463
3ed37d9a TV	464	down_write_nested(&rg->lock, rg->id);
	465	atomic_inc(&rg->lock_count);
	466
078ff546 VS	467	if (atomic_read(&rg->map_count)) {
	468	r = -EBUSY;
	469	goto out;
	470	}
	471
	472	for (i = 0; i < fbdev->num_fbs; i++) {
	473	struct omapfb_info *ofbi2 = FB2OFB(fbdev->fbs[i]);
	474	int j;
	475
	476	if (ofbi2->region != rg)
	477	continue;
	478
	479	for (j = 0; j < ofbi2->num_overlays; j++) {
aaa874a9 TV	480	struct omap_overlay *ovl;
	481	ovl = ofbi2->overlays[j];
	482	if (ovl->is_enabled(ovl)) {
078ff546 VS	483	r = -EBUSY;
	484	goto out;
	485	}
b39a982d TV	486	}
	487	}
	488
078ff546 VS	489	if (size != ofbi->region->size) {
078ff546 VS	490	r = omapfb_realloc_fbmem(fbi, size, ofbi->region->type);
b39a982d TV	491	if (r) {
	492	dev_err(dev, "realloc fbmem failed\n");
	493	goto out;
	494	}
	495	}
	496
	497	r = count;
	498	out:
3ed37d9a TV	499	atomic_dec(&rg->lock_count);
	500	up_write(&rg->lock);
	501
b39a982d TV	502	unlock_fb_info(fbi);
	503
	504	return r;
	505	}
	506
	507	static ssize_t show_phys(struct device *dev,
	508	struct device_attribute attr, char buf)
	509	{
	510	struct fb_info *fbi = dev_get_drvdata(dev);
	511	struct omapfb_info *ofbi = FB2OFB(fbi);
	512
3ed37d9a	513	return snprintf(buf, PAGE_SIZE, "%0x\n", ofbi->region->paddr);
b39a982d TV	514	}
	515
	516	static ssize_t show_virt(struct device *dev,
	517	struct device_attribute attr, char buf)
	518	{
	519	struct fb_info *fbi = dev_get_drvdata(dev);
	520	struct omapfb_info *ofbi = FB2OFB(fbi);
	521
078ff546	522	return snprintf(buf, PAGE_SIZE, "%p\n", ofbi->region->vaddr);
b39a982d TV	523	}
b39a982d TV	524
27cc213e TV	525	static ssize_t show_upd_mode(struct device *dev,
	526	struct device_attribute attr, char buf)
	527	{
	528	struct fb_info *fbi = dev_get_drvdata(dev);
	529	enum omapfb_update_mode mode;
	530	int r;
	531
	532	r = omapfb_get_update_mode(fbi, &mode);
	533
	534	if (r)
	535	return r;
	536
	537	return snprintf(buf, PAGE_SIZE, "%u\n", (unsigned)mode);
	538	}
	539
	540	static ssize_t store_upd_mode(struct device dev, struct device_attribute attr,
	541	const char *buf, size_t count)
	542	{
	543	struct fb_info *fbi = dev_get_drvdata(dev);
	544	unsigned mode;
	545	int r;
	546
	547	r = kstrtouint(buf, 0, &mode);
	548	if (r)
	549	return r;
	550
	551	r = omapfb_set_update_mode(fbi, mode);
	552	if (r)
	553	return r;
	554
	555	return count;
	556	}
	557
b39a982d TV	558	static struct device_attribute omapfb_attrs[] = {
	559	__ATTR(rotate_type, S_IRUGO \| S_IWUSR, show_rotate_type,
	560	store_rotate_type),
	561	__ATTR(mirror, S_IRUGO \| S_IWUSR, show_mirror, store_mirror),
	562	__ATTR(size, S_IRUGO \| S_IWUSR, show_size, store_size),
	563	__ATTR(overlays, S_IRUGO \| S_IWUSR, show_overlays, store_overlays),
	564	__ATTR(overlays_rotate, S_IRUGO \| S_IWUSR, show_overlays_rotate,
	565	store_overlays_rotate),
	566	__ATTR(phys_addr, S_IRUGO, show_phys, NULL),
	567	__ATTR(virt_addr, S_IRUGO, show_virt, NULL),
27cc213e	568	__ATTR(update_mode, S_IRUGO \| S_IWUSR, show_upd_mode, store_upd_mode),
b39a982d TV	569	};
	570
	571	int omapfb_create_sysfs(struct omapfb2_device *fbdev)
	572	{
	573	int i;
	574	int r;
	575
	576	DBG("create sysfs for fbs\n");
	577	for (i = 0; i < fbdev->num_fbs; i++) {
	578	int t;
	579	for (t = 0; t < ARRAY_SIZE(omapfb_attrs); t++) {
	580	r = device_create_file(fbdev->fbs[i]->dev,
	581	&omapfb_attrs[t]);
	582
	583	if (r) {
	584	dev_err(fbdev->dev, "failed to create sysfs "
	585	"file\n");
	586	return r;
	587	}
	588	}
	589	}
	590
	591	return 0;
	592	}
	593
	594	void omapfb_remove_sysfs(struct omapfb2_device *fbdev)
	595	{
	596	int i, t;
	597
	598	DBG("remove sysfs for fbs\n");
	599	for (i = 0; i < fbdev->num_fbs; i++) {
	600	for (t = 0; t < ARRAY_SIZE(omapfb_attrs); t++)
	601	device_remove_file(fbdev->fbs[i]->dev,
	602	&omapfb_attrs[t]);
	603	}
	604	}
	605