[deliverable/linux.git] / drivers / video / omap2 / dss / overlay.c

/*
 * linux/drivers/video/omap2/dss/overlay.c
 *
 * Copyright (C) 2009 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/>.
 */

#define DSS_SUBSYS_NAME "OVERLAY"

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/sysfs.h>
#include <linux/kobject.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/slab.h>

#include <video/omapdss.h>
#include <plat/cpu.h>

#include "dss.h"
#include "dss_features.h"

static int num_overlays;
static struct list_head overlay_list;

static ssize_t overlay_name_show(struct omap_overlay *ovl, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%s\n", ovl->name);
}

static ssize_t overlay_manager_show(struct omap_overlay *ovl, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%s\n",
			ovl->manager ? ovl->manager->name : "<none>");
}

static ssize_t overlay_manager_store(struct omap_overlay *ovl, const char *buf,
		size_t size)
{
	int i, r;
	struct omap_overlay_manager *mgr = NULL;
	struct omap_overlay_manager *old_mgr;
	int len = size;

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

	if (len > 0) {
		for (i = 0; i < omap_dss_get_num_overlay_managers(); ++i) {
			mgr = omap_dss_get_overlay_manager(i);

			if (sysfs_streq(buf, mgr->name))
				break;

			mgr = NULL;
		}
	}

	if (len > 0 && mgr == NULL)
		return -EINVAL;

	if (mgr)
		DSSDBG("manager %s found\n", mgr->name);

	if (mgr == ovl->manager)
		return size;

	old_mgr = ovl->manager;

	r = dispc_runtime_get();
	if (r)
		return r;

	/* detach old manager */
	if (old_mgr) {
		r = ovl->unset_manager(ovl);
		if (r) {
			DSSERR("detach failed\n");
			goto err;
		}

		r = old_mgr->apply(old_mgr);
		if (r)
			goto err;
	}

	if (mgr) {
		r = ovl->set_manager(ovl, mgr);
		if (r) {
			DSSERR("Failed to attach overlay\n");
			goto err;
		}

		r = mgr->apply(mgr);
		if (r)
			goto err;
	}

	dispc_runtime_put();

	return size;

err:
	dispc_runtime_put();
	return r;
}

static ssize_t overlay_input_size_show(struct omap_overlay *ovl, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d,%d\n",
			ovl->info.width, ovl->info.height);
}

static ssize_t overlay_screen_width_show(struct omap_overlay *ovl, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", ovl->info.screen_width);
}

static ssize_t overlay_position_show(struct omap_overlay *ovl, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d,%d\n",
			ovl->info.pos_x, ovl->info.pos_y);
}

static ssize_t overlay_position_store(struct omap_overlay *ovl,
		const char *buf, size_t size)
{
	int r;
	char *last;
	struct omap_overlay_info info;

	ovl->get_overlay_info(ovl, &info);

	info.pos_x = simple_strtoul(buf, &last, 10);
	++last;
	if (last - buf >= size)
		return -EINVAL;

	info.pos_y = simple_strtoul(last, &last, 10);

	r = ovl->set_overlay_info(ovl, &info);
	if (r)
		return r;

	if (ovl->manager) {
		r = ovl->manager->apply(ovl->manager);
		if (r)
			return r;
	}

	return size;
}

static ssize_t overlay_output_size_show(struct omap_overlay *ovl, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d,%d\n",
			ovl->info.out_width, ovl->info.out_height);
}

static ssize_t overlay_output_size_store(struct omap_overlay *ovl,
		const char *buf, size_t size)
{
	int r;
	char *last;
	struct omap_overlay_info info;

	ovl->get_overlay_info(ovl, &info);

	info.out_width = simple_strtoul(buf, &last, 10);
	++last;
	if (last - buf >= size)
		return -EINVAL;

	info.out_height = simple_strtoul(last, &last, 10);

	r = ovl->set_overlay_info(ovl, &info);
	if (r)
		return r;

	if (ovl->manager) {
		r = ovl->manager->apply(ovl->manager);
		if (r)
			return r;
	}

	return size;
}

static ssize_t overlay_enabled_show(struct omap_overlay *ovl, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", ovl->info.enabled);
}

static ssize_t overlay_enabled_store(struct omap_overlay *ovl, const char *buf,
		size_t size)
{
	int r, enable;
	struct omap_overlay_info info;

	ovl->get_overlay_info(ovl, &info);

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

	info.enabled = !!enable;

	r = ovl->set_overlay_info(ovl, &info);
	if (r)
		return r;

	if (ovl->manager) {
		r = ovl->manager->apply(ovl->manager);
		if (r)
			return r;
	}

	return size;
}

static ssize_t overlay_global_alpha_show(struct omap_overlay *ovl, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n",
			ovl->info.global_alpha);
}

static ssize_t overlay_global_alpha_store(struct omap_overlay *ovl,
		const char *buf, size_t size)
{
	int r;
	u8 alpha;
	struct omap_overlay_info info;

	if (!dss_has_feature(FEAT_GLOBAL_ALPHA))
		return -ENODEV;

	r = kstrtou8(buf, 0, &alpha);
	if (r)
		return r;

	ovl->get_overlay_info(ovl, &info);

	/* Video1 plane does not support global alpha
	 * to always make it 255 completely opaque
	 */
	if (!dss_has_feature(FEAT_GLOBAL_ALPHA_VID1) &&
			ovl->id == OMAP_DSS_VIDEO1)
		info.global_alpha = 255;
	else
		info.global_alpha = alpha;

	r = ovl->set_overlay_info(ovl, &info);
	if (r)
		return r;

	if (ovl->manager) {
		r = ovl->manager->apply(ovl->manager);
		if (r)
			return r;
	}

	return size;
}

static ssize_t overlay_pre_mult_alpha_show(struct omap_overlay *ovl,
		char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n",
			ovl->info.pre_mult_alpha);
}

static ssize_t overlay_pre_mult_alpha_store(struct omap_overlay *ovl,
		const char *buf, size_t size)
{
	int r;
	u8 alpha;
	struct omap_overlay_info info;

	r = kstrtou8(buf, 0, &alpha);
	if (r)
		return r;

	ovl->get_overlay_info(ovl, &info);

	/* only GFX and Video2 plane support pre alpha multiplied
	 * set zero for Video1 plane
	 */
	if (!dss_has_feature(FEAT_GLOBAL_ALPHA_VID1) &&
		ovl->id == OMAP_DSS_VIDEO1)
		info.pre_mult_alpha = 0;
	else
		info.pre_mult_alpha = alpha;

	r = ovl->set_overlay_info(ovl, &info);
	if (r)
		return r;

	if (ovl->manager) {
		r = ovl->manager->apply(ovl->manager);
		if (r)
			return r;
	}

	return size;
}

struct overlay_attribute {
	struct attribute attr;
	ssize_t (*show)(struct omap_overlay *, char *);
	ssize_t	(*store)(struct omap_overlay *, const char *, size_t);
};

#define OVERLAY_ATTR(_name, _mode, _show, _store) \
	struct overlay_attribute overlay_attr_##_name = \
	__ATTR(_name, _mode, _show, _store)

static OVERLAY_ATTR(name, S_IRUGO, overlay_name_show, NULL);
static OVERLAY_ATTR(manager, S_IRUGO|S_IWUSR,
		overlay_manager_show, overlay_manager_store);
static OVERLAY_ATTR(input_size, S_IRUGO, overlay_input_size_show, NULL);
static OVERLAY_ATTR(screen_width, S_IRUGO, overlay_screen_width_show, NULL);
static OVERLAY_ATTR(position, S_IRUGO|S_IWUSR,
		overlay_position_show, overlay_position_store);
static OVERLAY_ATTR(output_size, S_IRUGO|S_IWUSR,
		overlay_output_size_show, overlay_output_size_store);
static OVERLAY_ATTR(enabled, S_IRUGO|S_IWUSR,
		overlay_enabled_show, overlay_enabled_store);
static OVERLAY_ATTR(global_alpha, S_IRUGO|S_IWUSR,
		overlay_global_alpha_show, overlay_global_alpha_store);
static OVERLAY_ATTR(pre_mult_alpha, S_IRUGO|S_IWUSR,
		overlay_pre_mult_alpha_show,
		overlay_pre_mult_alpha_store);

static struct attribute *overlay_sysfs_attrs[] = {
	&overlay_attr_name.attr,
	&overlay_attr_manager.attr,
	&overlay_attr_input_size.attr,
	&overlay_attr_screen_width.attr,
	&overlay_attr_position.attr,
	&overlay_attr_output_size.attr,
	&overlay_attr_enabled.attr,
	&overlay_attr_global_alpha.attr,
	&overlay_attr_pre_mult_alpha.attr,
	NULL
};

static ssize_t overlay_attr_show(struct kobject *kobj, struct attribute *attr,
		char *buf)
{
	struct omap_overlay *overlay;
	struct overlay_attribute *overlay_attr;

	overlay = container_of(kobj, struct omap_overlay, kobj);
	overlay_attr = container_of(attr, struct overlay_attribute, attr);

	if (!overlay_attr->show)
		return -ENOENT;

	return overlay_attr->show(overlay, buf);
}

static ssize_t overlay_attr_store(struct kobject *kobj, struct attribute *attr,
		const char *buf, size_t size)
{
	struct omap_overlay *overlay;
	struct overlay_attribute *overlay_attr;

	overlay = container_of(kobj, struct omap_overlay, kobj);
	overlay_attr = container_of(attr, struct overlay_attribute, attr);

	if (!overlay_attr->store)
		return -ENOENT;

	return overlay_attr->store(overlay, buf, size);
}

static const struct sysfs_ops overlay_sysfs_ops = {
	.show = overlay_attr_show,
	.store = overlay_attr_store,
};

static struct kobj_type overlay_ktype = {
	.sysfs_ops = &overlay_sysfs_ops,
	.default_attrs = overlay_sysfs_attrs,
};

/* Check if overlay parameters are compatible with display */
int dss_check_overlay(struct omap_overlay *ovl, struct omap_dss_device *dssdev)
{
	struct omap_overlay_info *info;
	u16 outw, outh;
	u16 dw, dh;

	if (!dssdev)
		return 0;

	if (!ovl->info.enabled)
		return 0;

	info = &ovl->info;

	if (info->paddr == 0) {
		DSSDBG("check_overlay failed: paddr 0\n");
		return -EINVAL;
	}

	dssdev->driver->get_resolution(dssdev, &dw, &dh);

	DSSDBG("check_overlay %d: (%d,%d %dx%d -> %dx%d) disp (%dx%d)\n",
			ovl->id,
			info->pos_x, info->pos_y,
			info->width, info->height,
			info->out_width, info->out_height,
			dw, dh);

	if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
		outw = info->width;
		outh = info->height;
	} else {
		if (info->out_width == 0)
			outw = info->width;
		else
			outw = info->out_width;

		if (info->out_height == 0)
			outh = info->height;
		else
			outh = info->out_height;
	}

	if (dw < info->pos_x + outw) {
		DSSDBG("check_overlay failed 1: %d < %d + %d\n",
				dw, info->pos_x, outw);
		return -EINVAL;
	}

	if (dh < info->pos_y + outh) {
		DSSDBG("check_overlay failed 2: %d < %d + %d\n",
				dh, info->pos_y, outh);
		return -EINVAL;
	}

	if ((ovl->supported_modes & info->color_mode) == 0) {
		DSSERR("overlay doesn't support mode %d\n", info->color_mode);
		return -EINVAL;
	}

	return 0;
}

static int dss_ovl_set_overlay_info(struct omap_overlay *ovl,
		struct omap_overlay_info *info)
{
	int r;
	struct omap_overlay_info old_info;

	old_info = ovl->info;
	ovl->info = *info;

	if (ovl->manager) {
		r = dss_check_overlay(ovl, ovl->manager->device);
		if (r) {
			ovl->info = old_info;
			return r;
		}
	}

	ovl->info_dirty = true;

	return 0;
}

static void dss_ovl_get_overlay_info(struct omap_overlay *ovl,
		struct omap_overlay_info *info)
{
	*info = ovl->info;
}

static int dss_ovl_wait_for_go(struct omap_overlay *ovl)
{
	return dss_mgr_wait_for_go_ovl(ovl);
}

static int omap_dss_set_manager(struct omap_overlay *ovl,
		struct omap_overlay_manager *mgr)
{
	if (!mgr)
		return -EINVAL;

	if (ovl->manager) {
		DSSERR("overlay '%s' already has a manager '%s'\n",
				ovl->name, ovl->manager->name);
		return -EINVAL;
	}

	if (ovl->info.enabled) {
		DSSERR("overlay has to be disabled to change the manager\n");
		return -EINVAL;
	}

	ovl->manager = mgr;

	/* XXX: When there is an overlay on a DSI manual update display, and
	 * the overlay is first disabled, then moved to tv, and enabled, we
	 * seem to get SYNC_LOST_DIGIT error.
	 *
	 * Waiting doesn't seem to help, but updating the manual update display
	 * after disabling the overlay seems to fix this. This hints that the
	 * overlay is perhaps somehow tied to the LCD output until the output
	 * is updated.
	 *
	 * Userspace workaround for this is to update the LCD after disabling
	 * the overlay, but before moving the overlay to TV.
	 */
	dispc_set_channel_out(ovl->id, mgr->id);

	return 0;
}

static int omap_dss_unset_manager(struct omap_overlay *ovl)
{
	int r;

	if (!ovl->manager) {
		DSSERR("failed to detach overlay: manager not set\n");
		return -EINVAL;
	}

	if (ovl->info.enabled) {
		DSSERR("overlay has to be disabled to unset the manager\n");
		return -EINVAL;
	}

	r = ovl->wait_for_go(ovl);
	if (r)
		return r;

	ovl->manager = NULL;

	return 0;
}

int omap_dss_get_num_overlays(void)
{
	return num_overlays;
}
EXPORT_SYMBOL(omap_dss_get_num_overlays);

struct omap_overlay *omap_dss_get_overlay(int num)
{
	int i = 0;
	struct omap_overlay *ovl;

	list_for_each_entry(ovl, &overlay_list, list) {
		if (i++ == num)
			return ovl;
	}

	return NULL;
}
EXPORT_SYMBOL(omap_dss_get_overlay);

static void omap_dss_add_overlay(struct omap_overlay *overlay)
{
	++num_overlays;
	list_add_tail(&overlay->list, &overlay_list);
}

static struct omap_overlay *dispc_overlays[MAX_DSS_OVERLAYS];

void dss_overlay_setup_dispc_manager(struct omap_overlay_manager *mgr)
{
	mgr->num_overlays = dss_feat_get_num_ovls();
	mgr->overlays = dispc_overlays;
}

#ifdef L4_EXAMPLE
static struct omap_overlay *l4_overlays[1];
void dss_overlay_setup_l4_manager(struct omap_overlay_manager *mgr)
{
	mgr->num_overlays = 1;
	mgr->overlays = l4_overlays;
}
#endif

void dss_init_overlays(struct platform_device *pdev)
{
	int i, r;

	INIT_LIST_HEAD(&overlay_list);

	num_overlays = 0;

	for (i = 0; i < dss_feat_get_num_ovls(); ++i) {
		struct omap_overlay *ovl;
		ovl = kzalloc(sizeof(*ovl), GFP_KERNEL);

		BUG_ON(ovl == NULL);

		switch (i) {
		case 0:
			ovl->name = "gfx";
			ovl->id = OMAP_DSS_GFX;
			ovl->caps = OMAP_DSS_OVL_CAP_DISPC;
			ovl->info.global_alpha = 255;
			break;
		case 1:
			ovl->name = "vid1";
			ovl->id = OMAP_DSS_VIDEO1;
			ovl->caps = OMAP_DSS_OVL_CAP_SCALE |
				OMAP_DSS_OVL_CAP_DISPC;
			ovl->info.global_alpha = 255;
			break;
		case 2:
			ovl->name = "vid2";
			ovl->id = OMAP_DSS_VIDEO2;
			ovl->caps = OMAP_DSS_OVL_CAP_SCALE |
				OMAP_DSS_OVL_CAP_DISPC;
			ovl->info.global_alpha = 255;
			break;
		}

		ovl->set_manager = &omap_dss_set_manager;
		ovl->unset_manager = &omap_dss_unset_manager;
		ovl->set_overlay_info = &dss_ovl_set_overlay_info;
		ovl->get_overlay_info = &dss_ovl_get_overlay_info;
		ovl->wait_for_go = &dss_ovl_wait_for_go;

		ovl->supported_modes =
			dss_feat_get_supported_color_modes(ovl->id);

		omap_dss_add_overlay(ovl);

		r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
				&pdev->dev.kobj, "overlay%d", i);

		if (r) {
			DSSERR("failed to create sysfs file\n");
			continue;
		}

		dispc_overlays[i] = ovl;
	}

#ifdef L4_EXAMPLE
	{
		struct omap_overlay *ovl;
		ovl = kzalloc(sizeof(*ovl), GFP_KERNEL);

		BUG_ON(ovl == NULL);

		ovl->name = "l4";
		ovl->supported_modes = OMAP_DSS_COLOR_RGB24U;

		ovl->set_manager = &omap_dss_set_manager;
		ovl->unset_manager = &omap_dss_unset_manager;
		ovl->set_overlay_info = &dss_ovl_set_overlay_info;
		ovl->get_overlay_info = &dss_ovl_get_overlay_info;

		omap_dss_add_overlay(ovl);

		r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
				&pdev->dev.kobj, "overlayl4");

		if (r)
			DSSERR("failed to create sysfs file\n");

		l4_overlays[0] = ovl;
	}
#endif
}

/* connect overlays to the new device, if not already connected. if force
 * selected, connect always. */
void dss_recheck_connections(struct omap_dss_device *dssdev, bool force)
{
	int i;
	struct omap_overlay_manager *lcd_mgr;
	struct omap_overlay_manager *tv_mgr;
	struct omap_overlay_manager *lcd2_mgr = NULL;
	struct omap_overlay_manager *mgr = NULL;

	lcd_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_LCD);
	tv_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_TV);
	if (dss_has_feature(FEAT_MGR_LCD2))
		lcd2_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_LCD2);

	if (dssdev->channel == OMAP_DSS_CHANNEL_LCD2) {
		if (!lcd2_mgr->device || force) {
			if (lcd2_mgr->device)
				lcd2_mgr->unset_device(lcd2_mgr);
			lcd2_mgr->set_device(lcd2_mgr, dssdev);
			mgr = lcd2_mgr;
		}
	} else if (dssdev->type != OMAP_DISPLAY_TYPE_VENC
			&& dssdev->type != OMAP_DISPLAY_TYPE_HDMI) {
		if (!lcd_mgr->device || force) {
			if (lcd_mgr->device)
				lcd_mgr->unset_device(lcd_mgr);
			lcd_mgr->set_device(lcd_mgr, dssdev);
			mgr = lcd_mgr;
		}
	}

	if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
			|| dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
		if (!tv_mgr->device || force) {
			if (tv_mgr->device)
				tv_mgr->unset_device(tv_mgr);
			tv_mgr->set_device(tv_mgr, dssdev);
			mgr = tv_mgr;
		}
	}

	if (mgr) {
		dispc_runtime_get();

		for (i = 0; i < dss_feat_get_num_ovls(); i++) {
			struct omap_overlay *ovl;
			ovl = omap_dss_get_overlay(i);
			if (!ovl->manager || force) {
				if (ovl->manager)
					omap_dss_unset_manager(ovl);
				omap_dss_set_manager(ovl, mgr);
			}
		}

		dispc_runtime_put();
	}
}

void dss_uninit_overlays(struct platform_device *pdev)
{
	struct omap_overlay *ovl;

	while (!list_empty(&overlay_list)) {
		ovl = list_first_entry(&overlay_list,
				struct omap_overlay, list);
		list_del(&ovl->list);
		kobject_del(&ovl->kobj);
		kobject_put(&ovl->kobj);
		kfree(ovl);
	}

	num_overlays = 0;
}
Commit	Line	Data
eed07e0e TV	1	/*
	2	* linux/drivers/video/omap2/dss/overlay.c
	3	*
	4	* Copyright (C) 2009 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	#define DSS_SUBSYS_NAME "OVERLAY"
	24
	25	#include <linux/kernel.h>
	26	#include <linux/module.h>
	27	#include <linux/err.h>
	28	#include <linux/sysfs.h>
	29	#include <linux/kobject.h>
	30	#include <linux/platform_device.h>
	31	#include <linux/delay.h>
5a0e3ad6	32	#include <linux/slab.h>
eed07e0e	33
a0b38cc4	34	#include <video/omapdss.h>
eed07e0e TV	35	#include <plat/cpu.h>
	36
	37	#include "dss.h"
a0acb557	38	#include "dss_features.h"
eed07e0e TV	39
	40	static int num_overlays;
	41	static struct list_head overlay_list;
	42
	43	static ssize_t overlay_name_show(struct omap_overlay ovl, char buf)
	44	{
	45	return snprintf(buf, PAGE_SIZE, "%s\n", ovl->name);
	46	}
	47
	48	static ssize_t overlay_manager_show(struct omap_overlay ovl, char buf)
	49	{
	50	return snprintf(buf, PAGE_SIZE, "%s\n",
	51	ovl->manager ? ovl->manager->name : "<none>");
	52	}
	53
	54	static ssize_t overlay_manager_store(struct omap_overlay ovl, const char buf,
	55	size_t size)
	56	{
	57	int i, r;
	58	struct omap_overlay_manager *mgr = NULL;
	59	struct omap_overlay_manager *old_mgr;
	60	int len = size;
	61
	62	if (buf[size-1] == '\n')
	63	--len;
	64
	65	if (len > 0) {
	66	for (i = 0; i < omap_dss_get_num_overlay_managers(); ++i) {
	67	mgr = omap_dss_get_overlay_manager(i);
	68
f3c77d63	69	if (sysfs_streq(buf, mgr->name))
eed07e0e TV	70	break;
	71
	72	mgr = NULL;
	73	}
	74	}
	75
	76	if (len > 0 && mgr == NULL)
	77	return -EINVAL;
	78
	79	if (mgr)
	80	DSSDBG("manager %s found\n", mgr->name);
	81
	82	if (mgr == ovl->manager)
	83	return size;
	84
	85	old_mgr = ovl->manager;
	86
4fbafaf3 TV	87	r = dispc_runtime_get();
	88	if (r)
	89	return r;
	90
eed07e0e TV	91	/* detach old manager */
	92	if (old_mgr) {
	93	r = ovl->unset_manager(ovl);
	94	if (r) {
	95	DSSERR("detach failed\n");
4fbafaf3	96	goto err;
eed07e0e TV	97	}
	98
	99	r = old_mgr->apply(old_mgr);
	100	if (r)
4fbafaf3	101	goto err;
eed07e0e TV	102	}
	103
	104	if (mgr) {
	105	r = ovl->set_manager(ovl, mgr);
	106	if (r) {
	107	DSSERR("Failed to attach overlay\n");
4fbafaf3	108	goto err;
eed07e0e TV	109	}
	110
	111	r = mgr->apply(mgr);
	112	if (r)
4fbafaf3	113	goto err;
eed07e0e TV	114	}
eed07e0e TV	115
4fbafaf3 TV	116	dispc_runtime_put();
4fbafaf3 TV	117
eed07e0e	118	return size;
4fbafaf3 TV	119
	120	err:
	121	dispc_runtime_put();
	122	return r;
eed07e0e TV	123	}
	124
	125	static ssize_t overlay_input_size_show(struct omap_overlay ovl, char buf)
	126	{
	127	return snprintf(buf, PAGE_SIZE, "%d,%d\n",
	128	ovl->info.width, ovl->info.height);
	129	}
	130
	131	static ssize_t overlay_screen_width_show(struct omap_overlay ovl, char buf)
	132	{
	133	return snprintf(buf, PAGE_SIZE, "%d\n", ovl->info.screen_width);
	134	}
	135
	136	static ssize_t overlay_position_show(struct omap_overlay ovl, char buf)
	137	{
	138	return snprintf(buf, PAGE_SIZE, "%d,%d\n",
	139	ovl->info.pos_x, ovl->info.pos_y);
	140	}
	141
	142	static ssize_t overlay_position_store(struct omap_overlay *ovl,
	143	const char *buf, size_t size)
	144	{
	145	int r;
	146	char *last;
	147	struct omap_overlay_info info;
	148
	149	ovl->get_overlay_info(ovl, &info);
	150
	151	info.pos_x = simple_strtoul(buf, &last, 10);
	152	++last;
	153	if (last - buf >= size)
	154	return -EINVAL;
	155
	156	info.pos_y = simple_strtoul(last, &last, 10);
	157
	158	r = ovl->set_overlay_info(ovl, &info);
	159	if (r)
	160	return r;
	161
	162	if (ovl->manager) {
	163	r = ovl->manager->apply(ovl->manager);
	164	if (r)
	165	return r;
	166	}
	167
	168	return size;
	169	}
	170
	171	static ssize_t overlay_output_size_show(struct omap_overlay ovl, char buf)
	172	{
	173	return snprintf(buf, PAGE_SIZE, "%d,%d\n",
	174	ovl->info.out_width, ovl->info.out_height);
	175	}
	176
	177	static ssize_t overlay_output_size_store(struct omap_overlay *ovl,
	178	const char *buf, size_t size)
	179	{
	180	int r;
	181	char *last;
	182	struct omap_overlay_info info;
	183
	184	ovl->get_overlay_info(ovl, &info);
	185
	186	info.out_width = simple_strtoul(buf, &last, 10);
187	++last;
188	if (last - buf >= size)
189	return -EINVAL;
190
191	info.out_height = simple_strtoul(last, &last, 10);
192
193	r = ovl->set_overlay_info(ovl, &info);
194	if (r)
195	return r;
196
197	if (ovl->manager) {
198	r = ovl->manager->apply(ovl->manager);
199	if (r)
200	return r;
201	}
202
203	return size;
204	}
205
206	static ssize_t overlay_enabled_show(struct omap_overlay ovl, char buf)
207	{
208	return snprintf(buf, PAGE_SIZE, "%d\n", ovl->info.enabled);
209	}
210
211	static ssize_t overlay_enabled_store(struct omap_overlay ovl, const char buf,
212	size_t size)
213	{
e3502ce9	214	int r, enable;
eed07e0e TV	215	struct omap_overlay_info info;
	216
	217	ovl->get_overlay_info(ovl, &info);
	218
e3502ce9 TV	219	r = kstrtoint(buf, 0, &enable);
	220	if (r)
	221	return r;
	222
	223	info.enabled = !!enable;
eed07e0e TV	224
	225	r = ovl->set_overlay_info(ovl, &info);
	226	if (r)
	227	return r;
	228
	229	if (ovl->manager) {
	230	r = ovl->manager->apply(ovl->manager);
	231	if (r)
	232	return r;
	233	}
	234
	235	return size;
	236	}
	237
	238	static ssize_t overlay_global_alpha_show(struct omap_overlay ovl, char buf)
	239	{
	240	return snprintf(buf, PAGE_SIZE, "%d\n",
	241	ovl->info.global_alpha);
	242	}
	243
	244	static ssize_t overlay_global_alpha_store(struct omap_overlay *ovl,
	245	const char *buf, size_t size)
	246	{
	247	int r;
e3502ce9	248	u8 alpha;
eed07e0e TV	249	struct omap_overlay_info info;
eed07e0e TV	250
332e9d70 TV	251	if (!dss_has_feature(FEAT_GLOBAL_ALPHA))
	252	return -ENODEV;
	253
e3502ce9 TV	254	r = kstrtou8(buf, 0, &alpha);
	255	if (r)
	256	return r;
	257
eed07e0e TV	258	ovl->get_overlay_info(ovl, &info);
	259
	260	/* Video1 plane does not support global alpha
	261	* to always make it 255 completely opaque
	262	*/
a0acb557 AT	263	if (!dss_has_feature(FEAT_GLOBAL_ALPHA_VID1) &&
a0acb557 AT	264	ovl->id == OMAP_DSS_VIDEO1)
eed07e0e TV	265	info.global_alpha = 255;
eed07e0e TV	266	else
e3502ce9	267	info.global_alpha = alpha;
eed07e0e TV	268
	269	r = ovl->set_overlay_info(ovl, &info);
	270	if (r)
	271	return r;
	272
	273	if (ovl->manager) {
	274	r = ovl->manager->apply(ovl->manager);
	275	if (r)
	276	return r;
	277	}
	278
	279	return size;
	280	}
	281
fd28a390 R	282	static ssize_t overlay_pre_mult_alpha_show(struct omap_overlay *ovl,
	283	char *buf)
	284	{
	285	return snprintf(buf, PAGE_SIZE, "%d\n",
	286	ovl->info.pre_mult_alpha);
	287	}
	288
	289	static ssize_t overlay_pre_mult_alpha_store(struct omap_overlay *ovl,
	290	const char *buf, size_t size)
	291	{
	292	int r;
e3502ce9	293	u8 alpha;
fd28a390 R	294	struct omap_overlay_info info;
fd28a390 R	295
e3502ce9 TV	296	r = kstrtou8(buf, 0, &alpha);
	297	if (r)
	298	return r;
	299
fd28a390 R	300	ovl->get_overlay_info(ovl, &info);
	301
	302	/* only GFX and Video2 plane support pre alpha multiplied
	303	* set zero for Video1 plane
	304	*/
	305	if (!dss_has_feature(FEAT_GLOBAL_ALPHA_VID1) &&
	306	ovl->id == OMAP_DSS_VIDEO1)
	307	info.pre_mult_alpha = 0;
	308	else
e3502ce9	309	info.pre_mult_alpha = alpha;
fd28a390 R	310
	311	r = ovl->set_overlay_info(ovl, &info);
	312	if (r)
	313	return r;
	314
	315	if (ovl->manager) {
	316	r = ovl->manager->apply(ovl->manager);
	317	if (r)
	318	return r;
	319	}
	320
	321	return size;
	322	}
	323
eed07e0e TV	324	struct overlay_attribute {
	325	struct attribute attr;
	326	ssize_t (show)(struct omap_overlay , char *);
	327	ssize_t (store)(struct omap_overlay , const char *, size_t);
	328	};
	329
	330	#define OVERLAY_ATTR(_name, _mode, _show, _store) \
	331	struct overlay_attribute overlay_attr_##_name = \
	332	__ATTR(_name, _mode, _show, _store)
	333
	334	static OVERLAY_ATTR(name, S_IRUGO, overlay_name_show, NULL);
	335	static OVERLAY_ATTR(manager, S_IRUGO\|S_IWUSR,
	336	overlay_manager_show, overlay_manager_store);
	337	static OVERLAY_ATTR(input_size, S_IRUGO, overlay_input_size_show, NULL);
	338	static OVERLAY_ATTR(screen_width, S_IRUGO, overlay_screen_width_show, NULL);
	339	static OVERLAY_ATTR(position, S_IRUGO\|S_IWUSR,
	340	overlay_position_show, overlay_position_store);
	341	static OVERLAY_ATTR(output_size, S_IRUGO\|S_IWUSR,
	342	overlay_output_size_show, overlay_output_size_store);
	343	static OVERLAY_ATTR(enabled, S_IRUGO\|S_IWUSR,
	344	overlay_enabled_show, overlay_enabled_store);
	345	static OVERLAY_ATTR(global_alpha, S_IRUGO\|S_IWUSR,
	346	overlay_global_alpha_show, overlay_global_alpha_store);
fd28a390 R	347	static OVERLAY_ATTR(pre_mult_alpha, S_IRUGO\|S_IWUSR,
	348	overlay_pre_mult_alpha_show,
	349	overlay_pre_mult_alpha_store);
eed07e0e TV	350
	351	static struct attribute *overlay_sysfs_attrs[] = {
	352	&overlay_attr_name.attr,
	353	&overlay_attr_manager.attr,
	354	&overlay_attr_input_size.attr,
	355	&overlay_attr_screen_width.attr,
	356	&overlay_attr_position.attr,
	357	&overlay_attr_output_size.attr,
	358	&overlay_attr_enabled.attr,
	359	&overlay_attr_global_alpha.attr,
fd28a390	360	&overlay_attr_pre_mult_alpha.attr,
eed07e0e TV	361	NULL
	362	};
	363
	364	static ssize_t overlay_attr_show(struct kobject kobj, struct attribute attr,
	365	char *buf)
	366	{
	367	struct omap_overlay *overlay;
	368	struct overlay_attribute *overlay_attr;
	369
	370	overlay = container_of(kobj, struct omap_overlay, kobj);
	371	overlay_attr = container_of(attr, struct overlay_attribute, attr);
	372
	373	if (!overlay_attr->show)
	374	return -ENOENT;
	375
	376	return overlay_attr->show(overlay, buf);
	377	}
	378
	379	static ssize_t overlay_attr_store(struct kobject kobj, struct attribute attr,
	380	const char *buf, size_t size)
	381	{
	382	struct omap_overlay *overlay;
	383	struct overlay_attribute *overlay_attr;
	384
	385	overlay = container_of(kobj, struct omap_overlay, kobj);
	386	overlay_attr = container_of(attr, struct overlay_attribute, attr);
	387
	388	if (!overlay_attr->store)
	389	return -ENOENT;
	390
	391	return overlay_attr->store(overlay, buf, size);
	392	}
	393
52cf25d0	394	static const struct sysfs_ops overlay_sysfs_ops = {
eed07e0e TV	395	.show = overlay_attr_show,
	396	.store = overlay_attr_store,
	397	};
	398
	399	static struct kobj_type overlay_ktype = {
	400	.sysfs_ops = &overlay_sysfs_ops,
	401	.default_attrs = overlay_sysfs_attrs,
	402	};
	403
	404	/* Check if overlay parameters are compatible with display */
	405	int dss_check_overlay(struct omap_overlay ovl, struct omap_dss_device dssdev)
	406	{
	407	struct omap_overlay_info *info;
	408	u16 outw, outh;
	409	u16 dw, dh;
	410
	411	if (!dssdev)
	412	return 0;
	413
	414	if (!ovl->info.enabled)
	415	return 0;
	416
	417	info = &ovl->info;
	418
	419	if (info->paddr == 0) {
	420	DSSDBG("check_overlay failed: paddr 0\n");
	421	return -EINVAL;
	422	}
	423
96adcece	424	dssdev->driver->get_resolution(dssdev, &dw, &dh);
eed07e0e TV	425
	426	DSSDBG("check_overlay %d: (%d,%d %dx%d -> %dx%d) disp (%dx%d)\n",
	427	ovl->id,
	428	info->pos_x, info->pos_y,
	429	info->width, info->height,
	430	info->out_width, info->out_height,
	431	dw, dh);
	432
	433	if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
	434	outw = info->width;
	435	outh = info->height;
	436	} else {
	437	if (info->out_width == 0)
	438	outw = info->width;
	439	else
	440	outw = info->out_width;
	441
	442	if (info->out_height == 0)
	443	outh = info->height;
	444	else
	445	outh = info->out_height;
	446	}
	447
	448	if (dw < info->pos_x + outw) {
	449	DSSDBG("check_overlay failed 1: %d < %d + %d\n",
	450	dw, info->pos_x, outw);
	451	return -EINVAL;
	452	}
	453
	454	if (dh < info->pos_y + outh) {
	455	DSSDBG("check_overlay failed 2: %d < %d + %d\n",
	456	dh, info->pos_y, outh);
	457	return -EINVAL;
	458	}
	459
	460	if ((ovl->supported_modes & info->color_mode) == 0) {
	461	DSSERR("overlay doesn't support mode %d\n", info->color_mode);
	462	return -EINVAL;
	463	}
	464
	465	return 0;
	466	}
	467
	468	static int dss_ovl_set_overlay_info(struct omap_overlay *ovl,
	469	struct omap_overlay_info *info)
	470	{
	471	int r;
	472	struct omap_overlay_info old_info;
	473
	474	old_info = ovl->info;
	475	ovl->info = *info;
	476
	477	if (ovl->manager) {
	478	r = dss_check_overlay(ovl, ovl->manager->device);
	479	if (r) {
	480	ovl->info = old_info;
	481	return r;
	482	}
	483	}
	484
	485	ovl->info_dirty = true;
	486
	487	return 0;
	488	}
489
490	static void dss_ovl_get_overlay_info(struct omap_overlay *ovl,
491	struct omap_overlay_info *info)
492	{
493	*info = ovl->info;
494	}
495
496	static int dss_ovl_wait_for_go(struct omap_overlay *ovl)
497	{
498	return dss_mgr_wait_for_go_ovl(ovl);
499	}
500
501	static int omap_dss_set_manager(struct omap_overlay *ovl,
502	struct omap_overlay_manager *mgr)
503	{
504	if (!mgr)
505	return -EINVAL;
506
507	if (ovl->manager) {
508	DSSERR("overlay '%s' already has a manager '%s'\n",
509	ovl->name, ovl->manager->name);
510	return -EINVAL;
511	}
512
513	if (ovl->info.enabled) {
514	DSSERR("overlay has to be disabled to change the manager\n");
515	return -EINVAL;
516	}
517
518	ovl->manager = mgr;
519
d792eecd TV	520	/* XXX: When there is an overlay on a DSI manual update display, and
	521	* the overlay is first disabled, then moved to tv, and enabled, we
	522	* seem to get SYNC_LOST_DIGIT error.
	523	*
	524	* Waiting doesn't seem to help, but updating the manual update display
	525	* after disabling the overlay seems to fix this. This hints that the
	526	* overlay is perhaps somehow tied to the LCD output until the output
	527	* is updated.
	528	*
	529	* Userspace workaround for this is to update the LCD after disabling
	530	* the overlay, but before moving the overlay to TV.
	531	*/
eed07e0e	532	dispc_set_channel_out(ovl->id, mgr->id);
eed07e0e TV	533
	534	return 0;
	535	}
	536
	537	static int omap_dss_unset_manager(struct omap_overlay *ovl)
	538	{
	539	int r;
	540
	541	if (!ovl->manager) {
	542	DSSERR("failed to detach overlay: manager not set\n");
	543	return -EINVAL;
	544	}
	545
	546	if (ovl->info.enabled) {
	547	DSSERR("overlay has to be disabled to unset the manager\n");
	548	return -EINVAL;
	549	}
	550
	551	r = ovl->wait_for_go(ovl);
	552	if (r)
	553	return r;
	554
	555	ovl->manager = NULL;
	556
	557	return 0;
	558	}
	559
	560	int omap_dss_get_num_overlays(void)
	561	{
	562	return num_overlays;
	563	}
	564	EXPORT_SYMBOL(omap_dss_get_num_overlays);
	565
	566	struct omap_overlay *omap_dss_get_overlay(int num)
	567	{
	568	int i = 0;
	569	struct omap_overlay *ovl;
	570
	571	list_for_each_entry(ovl, &overlay_list, list) {
	572	if (i++ == num)
	573	return ovl;
	574	}
	575
	576	return NULL;
	577	}
	578	EXPORT_SYMBOL(omap_dss_get_overlay);
	579
	580	static void omap_dss_add_overlay(struct omap_overlay *overlay)
	581	{
	582	++num_overlays;
	583	list_add_tail(&overlay->list, &overlay_list);
	584	}
	585
a0acb557	586	static struct omap_overlay *dispc_overlays[MAX_DSS_OVERLAYS];
eed07e0e TV	587
	588	void dss_overlay_setup_dispc_manager(struct omap_overlay_manager *mgr)
	589	{
a0acb557	590	mgr->num_overlays = dss_feat_get_num_ovls();
eed07e0e TV	591	mgr->overlays = dispc_overlays;
	592	}
	593
	594	#ifdef L4_EXAMPLE
	595	static struct omap_overlay *l4_overlays[1];
	596	void dss_overlay_setup_l4_manager(struct omap_overlay_manager *mgr)
	597	{
	598	mgr->num_overlays = 1;
	599	mgr->overlays = l4_overlays;
	600	}
	601	#endif
	602
	603	void dss_init_overlays(struct platform_device *pdev)
	604	{
	605	int i, r;
	606
	607	INIT_LIST_HEAD(&overlay_list);
	608
	609	num_overlays = 0;
	610
a0acb557	611	for (i = 0; i < dss_feat_get_num_ovls(); ++i) {
eed07e0e TV	612	struct omap_overlay *ovl;
	613	ovl = kzalloc(sizeof(*ovl), GFP_KERNEL);
	614
	615	BUG_ON(ovl == NULL);
	616
	617	switch (i) {
	618	case 0:
	619	ovl->name = "gfx";
	620	ovl->id = OMAP_DSS_GFX;
eed07e0e TV	621	ovl->caps = OMAP_DSS_OVL_CAP_DISPC;
	622	ovl->info.global_alpha = 255;
	623	break;
	624	case 1:
	625	ovl->name = "vid1";
	626	ovl->id = OMAP_DSS_VIDEO1;
eed07e0e TV	627	ovl->caps = OMAP_DSS_OVL_CAP_SCALE \|
	628	OMAP_DSS_OVL_CAP_DISPC;
	629	ovl->info.global_alpha = 255;
	630	break;
	631	case 2:
	632	ovl->name = "vid2";
	633	ovl->id = OMAP_DSS_VIDEO2;
eed07e0e TV	634	ovl->caps = OMAP_DSS_OVL_CAP_SCALE \|
	635	OMAP_DSS_OVL_CAP_DISPC;
	636	ovl->info.global_alpha = 255;
	637	break;
	638	}
	639
	640	ovl->set_manager = &omap_dss_set_manager;
	641	ovl->unset_manager = &omap_dss_unset_manager;
	642	ovl->set_overlay_info = &dss_ovl_set_overlay_info;
	643	ovl->get_overlay_info = &dss_ovl_get_overlay_info;
	644	ovl->wait_for_go = &dss_ovl_wait_for_go;
	645
a0acb557 AT	646	ovl->supported_modes =
	647	dss_feat_get_supported_color_modes(ovl->id);
	648
eed07e0e TV	649	omap_dss_add_overlay(ovl);
	650
	651	r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
	652	&pdev->dev.kobj, "overlay%d", i);
	653
	654	if (r) {
	655	DSSERR("failed to create sysfs file\n");
	656	continue;
	657	}
	658
	659	dispc_overlays[i] = ovl;
	660	}
	661
	662	#ifdef L4_EXAMPLE
	663	{
	664	struct omap_overlay *ovl;
	665	ovl = kzalloc(sizeof(*ovl), GFP_KERNEL);
	666
	667	BUG_ON(ovl == NULL);
	668
	669	ovl->name = "l4";
	670	ovl->supported_modes = OMAP_DSS_COLOR_RGB24U;
	671
	672	ovl->set_manager = &omap_dss_set_manager;
	673	ovl->unset_manager = &omap_dss_unset_manager;
	674	ovl->set_overlay_info = &dss_ovl_set_overlay_info;
	675	ovl->get_overlay_info = &dss_ovl_get_overlay_info;
	676
	677	omap_dss_add_overlay(ovl);
	678
	679	r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
	680	&pdev->dev.kobj, "overlayl4");
	681
	682	if (r)
	683	DSSERR("failed to create sysfs file\n");
	684
	685	l4_overlays[0] = ovl;
	686	}
	687	#endif
	688	}
	689
	690	/* connect overlays to the new device, if not already connected. if force
	691	* selected, connect always. */
	692	void dss_recheck_connections(struct omap_dss_device *dssdev, bool force)
	693	{
	694	int i;
	695	struct omap_overlay_manager *lcd_mgr;
	696	struct omap_overlay_manager *tv_mgr;
18faa1b6	697	struct omap_overlay_manager *lcd2_mgr = NULL;
eed07e0e TV	698	struct omap_overlay_manager *mgr = NULL;
	699
	700	lcd_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_LCD);
	701	tv_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_TV);
18faa1b6 SS	702	if (dss_has_feature(FEAT_MGR_LCD2))
	703	lcd2_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_LCD2);
	704
	705	if (dssdev->channel == OMAP_DSS_CHANNEL_LCD2) {
	706	if (!lcd2_mgr->device \|\| force) {
	707	if (lcd2_mgr->device)
	708	lcd2_mgr->unset_device(lcd2_mgr);
	709	lcd2_mgr->set_device(lcd2_mgr, dssdev);
	710	mgr = lcd2_mgr;
	711	}
b119601d M	712	} else if (dssdev->type != OMAP_DISPLAY_TYPE_VENC
b119601d M	713	&& dssdev->type != OMAP_DISPLAY_TYPE_HDMI) {
eed07e0e TV	714	if (!lcd_mgr->device \|\| force) {
	715	if (lcd_mgr->device)
	716	lcd_mgr->unset_device(lcd_mgr);
	717	lcd_mgr->set_device(lcd_mgr, dssdev);
	718	mgr = lcd_mgr;
	719	}
	720	}
	721
b119601d M	722	if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
b119601d M	723	\|\| dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
eed07e0e TV	724	if (!tv_mgr->device \|\| force) {
	725	if (tv_mgr->device)
	726	tv_mgr->unset_device(tv_mgr);
	727	tv_mgr->set_device(tv_mgr, dssdev);
	728	mgr = tv_mgr;
	729	}
	730	}
	731
	732	if (mgr) {
4fbafaf3 TV	733	dispc_runtime_get();
4fbafaf3 TV	734
a0acb557	735	for (i = 0; i < dss_feat_get_num_ovls(); i++) {
eed07e0e TV	736	struct omap_overlay *ovl;
	737	ovl = omap_dss_get_overlay(i);
	738	if (!ovl->manager \|\| force) {
	739	if (ovl->manager)
	740	omap_dss_unset_manager(ovl);
	741	omap_dss_set_manager(ovl, mgr);
	742	}
	743	}
4fbafaf3 TV	744
4fbafaf3 TV	745	dispc_runtime_put();
eed07e0e TV	746	}
	747	}
	748
	749	void dss_uninit_overlays(struct platform_device *pdev)
	750	{
	751	struct omap_overlay *ovl;
	752
	753	while (!list_empty(&overlay_list)) {
	754	ovl = list_first_entry(&overlay_list,
	755	struct omap_overlay, list);
	756	list_del(&ovl->list);
	757	kobject_del(&ovl->kobj);
	758	kobject_put(&ovl->kobj);
	759	kfree(ovl);
	760	}
	761
	762	num_overlays = 0;
	763	}
	764