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

/*
 * linux/drivers/video/omap2/dss/manager.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 "MANAGER"

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/jiffies.h>

#include <video/omapdss.h>

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

static int num_managers;
static struct list_head manager_list;

static ssize_t manager_name_show(struct omap_overlay_manager *mgr, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%s\n", mgr->name);
}

static ssize_t manager_display_show(struct omap_overlay_manager *mgr, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%s\n",
			mgr->device ? mgr->device->name : "<none>");
}

static ssize_t manager_display_store(struct omap_overlay_manager *mgr,
		const char *buf, size_t size)
{
	int r = 0;
	size_t len = size;
	struct omap_dss_device *dssdev = NULL;

	int match(struct omap_dss_device *dssdev, void *data)
	{
		const char *str = data;
		return sysfs_streq(dssdev->name, str);
	}

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

	if (len > 0)
		dssdev = omap_dss_find_device((void *)buf, match);

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

	if (dssdev)
		DSSDBG("display %s found\n", dssdev->name);

	if (mgr->device) {
		r = mgr->unset_device(mgr);
		if (r) {
			DSSERR("failed to unset display\n");
			goto put_device;
		}
	}

	if (dssdev) {
		r = mgr->set_device(mgr, dssdev);
		if (r) {
			DSSERR("failed to set manager\n");
			goto put_device;
		}

		r = mgr->apply(mgr);
		if (r) {
			DSSERR("failed to apply dispc config\n");
			goto put_device;
		}
	}

put_device:
	if (dssdev)
		omap_dss_put_device(dssdev);

	return r ? r : size;
}

static ssize_t manager_default_color_show(struct omap_overlay_manager *mgr,
					  char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%#x\n", mgr->info.default_color);
}

static ssize_t manager_default_color_store(struct omap_overlay_manager *mgr,
					   const char *buf, size_t size)
{
	struct omap_overlay_manager_info info;
	u32 color;
	int r;

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

	mgr->get_manager_info(mgr, &info);

	info.default_color = color;

	r = mgr->set_manager_info(mgr, &info);
	if (r)
		return r;

	r = mgr->apply(mgr);
	if (r)
		return r;

	return size;
}

static const char *trans_key_type_str[] = {
	"gfx-destination",
	"video-source",
};

static ssize_t manager_trans_key_type_show(struct omap_overlay_manager *mgr,
					   char *buf)
{
	enum omap_dss_trans_key_type key_type;

	key_type = mgr->info.trans_key_type;
	BUG_ON(key_type >= ARRAY_SIZE(trans_key_type_str));

	return snprintf(buf, PAGE_SIZE, "%s\n", trans_key_type_str[key_type]);
}

static ssize_t manager_trans_key_type_store(struct omap_overlay_manager *mgr,
					    const char *buf, size_t size)
{
	enum omap_dss_trans_key_type key_type;
	struct omap_overlay_manager_info info;
	int r;

	for (key_type = OMAP_DSS_COLOR_KEY_GFX_DST;
			key_type < ARRAY_SIZE(trans_key_type_str); key_type++) {
		if (sysfs_streq(buf, trans_key_type_str[key_type]))
			break;
	}

	if (key_type == ARRAY_SIZE(trans_key_type_str))
		return -EINVAL;

	mgr->get_manager_info(mgr, &info);

	info.trans_key_type = key_type;

	r = mgr->set_manager_info(mgr, &info);
	if (r)
		return r;

	r = mgr->apply(mgr);
	if (r)
		return r;

	return size;
}

static ssize_t manager_trans_key_value_show(struct omap_overlay_manager *mgr,
					    char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%#x\n", mgr->info.trans_key);
}

static ssize_t manager_trans_key_value_store(struct omap_overlay_manager *mgr,
					     const char *buf, size_t size)
{
	struct omap_overlay_manager_info info;
	u32 key_value;
	int r;

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

	mgr->get_manager_info(mgr, &info);

	info.trans_key = key_value;

	r = mgr->set_manager_info(mgr, &info);
	if (r)
		return r;

	r = mgr->apply(mgr);
	if (r)
		return r;

	return size;
}

static ssize_t manager_trans_key_enabled_show(struct omap_overlay_manager *mgr,
					      char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.trans_enabled);
}

static ssize_t manager_trans_key_enabled_store(struct omap_overlay_manager *mgr,
					       const char *buf, size_t size)
{
	struct omap_overlay_manager_info info;
	bool enable;
	int r;

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

	mgr->get_manager_info(mgr, &info);

	info.trans_enabled = enable;

	r = mgr->set_manager_info(mgr, &info);
	if (r)
		return r;

	r = mgr->apply(mgr);
	if (r)
		return r;

	return size;
}

static ssize_t manager_alpha_blending_enabled_show(
		struct omap_overlay_manager *mgr, char *buf)
{
	WARN_ON(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER));

	return snprintf(buf, PAGE_SIZE, "%d\n",
		mgr->info.partial_alpha_enabled);
}

static ssize_t manager_alpha_blending_enabled_store(
		struct omap_overlay_manager *mgr,
		const char *buf, size_t size)
{
	struct omap_overlay_manager_info info;
	bool enable;
	int r;

	WARN_ON(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER));

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

	mgr->get_manager_info(mgr, &info);

	info.partial_alpha_enabled = enable;

	r = mgr->set_manager_info(mgr, &info);
	if (r)
		return r;

	r = mgr->apply(mgr);
	if (r)
		return r;

	return size;
}

static ssize_t manager_cpr_enable_show(struct omap_overlay_manager *mgr,
		char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.cpr_enable);
}

static ssize_t manager_cpr_enable_store(struct omap_overlay_manager *mgr,
		const char *buf, size_t size)
{
	struct omap_overlay_manager_info info;
	int r;
	bool enable;

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

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

	mgr->get_manager_info(mgr, &info);

	if (info.cpr_enable == enable)
		return size;

	info.cpr_enable = enable;

	r = mgr->set_manager_info(mgr, &info);
	if (r)
		return r;

	r = mgr->apply(mgr);
	if (r)
		return r;

	return size;
}

static ssize_t manager_cpr_coef_show(struct omap_overlay_manager *mgr,
		char *buf)
{
	struct omap_overlay_manager_info info;

	mgr->get_manager_info(mgr, &info);

	return snprintf(buf, PAGE_SIZE,
			"%d %d %d %d %d %d %d %d %d\n",
			info.cpr_coefs.rr,
			info.cpr_coefs.rg,
			info.cpr_coefs.rb,
			info.cpr_coefs.gr,
			info.cpr_coefs.gg,
			info.cpr_coefs.gb,
			info.cpr_coefs.br,
			info.cpr_coefs.bg,
			info.cpr_coefs.bb);
}

static ssize_t manager_cpr_coef_store(struct omap_overlay_manager *mgr,
		const char *buf, size_t size)
{
	struct omap_overlay_manager_info info;
	struct omap_dss_cpr_coefs coefs;
	int r, i;
	s16 *arr;

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

	if (sscanf(buf, "%hd %hd %hd %hd %hd %hd %hd %hd %hd",
				&coefs.rr, &coefs.rg, &coefs.rb,
				&coefs.gr, &coefs.gg, &coefs.gb,
				&coefs.br, &coefs.bg, &coefs.bb) != 9)
		return -EINVAL;

	arr = (s16[]){ coefs.rr, coefs.rg, coefs.rb,
		coefs.gr, coefs.gg, coefs.gb,
		coefs.br, coefs.bg, coefs.bb };

	for (i = 0; i < 9; ++i) {
		if (arr[i] < -512 || arr[i] > 511)
			return -EINVAL;
	}

	mgr->get_manager_info(mgr, &info);

	info.cpr_coefs = coefs;

	r = mgr->set_manager_info(mgr, &info);
	if (r)
		return r;

	r = mgr->apply(mgr);
	if (r)
		return r;

	return size;
}

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

#define MANAGER_ATTR(_name, _mode, _show, _store) \
	struct manager_attribute manager_attr_##_name = \
	__ATTR(_name, _mode, _show, _store)

static MANAGER_ATTR(name, S_IRUGO, manager_name_show, NULL);
static MANAGER_ATTR(display, S_IRUGO|S_IWUSR,
		manager_display_show, manager_display_store);
static MANAGER_ATTR(default_color, S_IRUGO|S_IWUSR,
		manager_default_color_show, manager_default_color_store);
static MANAGER_ATTR(trans_key_type, S_IRUGO|S_IWUSR,
		manager_trans_key_type_show, manager_trans_key_type_store);
static MANAGER_ATTR(trans_key_value, S_IRUGO|S_IWUSR,
		manager_trans_key_value_show, manager_trans_key_value_store);
static MANAGER_ATTR(trans_key_enabled, S_IRUGO|S_IWUSR,
		manager_trans_key_enabled_show,
		manager_trans_key_enabled_store);
static MANAGER_ATTR(alpha_blending_enabled, S_IRUGO|S_IWUSR,
		manager_alpha_blending_enabled_show,
		manager_alpha_blending_enabled_store);
static MANAGER_ATTR(cpr_enable, S_IRUGO|S_IWUSR,
		manager_cpr_enable_show,
		manager_cpr_enable_store);
static MANAGER_ATTR(cpr_coef, S_IRUGO|S_IWUSR,
		manager_cpr_coef_show,
		manager_cpr_coef_store);


static struct attribute *manager_sysfs_attrs[] = {
	&manager_attr_name.attr,
	&manager_attr_display.attr,
	&manager_attr_default_color.attr,
	&manager_attr_trans_key_type.attr,
	&manager_attr_trans_key_value.attr,
	&manager_attr_trans_key_enabled.attr,
	&manager_attr_alpha_blending_enabled.attr,
	&manager_attr_cpr_enable.attr,
	&manager_attr_cpr_coef.attr,
	NULL
};

static ssize_t manager_attr_show(struct kobject *kobj, struct attribute *attr,
		char *buf)
{
	struct omap_overlay_manager *manager;
	struct manager_attribute *manager_attr;

	manager = container_of(kobj, struct omap_overlay_manager, kobj);
	manager_attr = container_of(attr, struct manager_attribute, attr);

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

	return manager_attr->show(manager, buf);
}

static ssize_t manager_attr_store(struct kobject *kobj, struct attribute *attr,
		const char *buf, size_t size)
{
	struct omap_overlay_manager *manager;
	struct manager_attribute *manager_attr;

	manager = container_of(kobj, struct omap_overlay_manager, kobj);
	manager_attr = container_of(attr, struct manager_attribute, attr);

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

	return manager_attr->store(manager, buf, size);
}

static const struct sysfs_ops manager_sysfs_ops = {
	.show = manager_attr_show,
	.store = manager_attr_store,
};

static struct kobj_type manager_ktype = {
	.sysfs_ops = &manager_sysfs_ops,
	.default_attrs = manager_sysfs_attrs,
};

static int omap_dss_set_device(struct omap_overlay_manager *mgr,
		struct omap_dss_device *dssdev)
{
	int i;
	int r;

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

	if ((mgr->supported_displays & dssdev->type) == 0) {
		DSSERR("display '%s' does not support manager '%s'\n",
			       dssdev->name, mgr->name);
		return -EINVAL;
	}

	for (i = 0; i < mgr->num_overlays; i++) {
		struct omap_overlay *ovl = mgr->overlays[i];

		if (ovl->manager != mgr || !ovl->info.enabled)
			continue;

		r = dss_check_overlay(ovl, dssdev);
		if (r)
			return r;
	}

	dssdev->manager = mgr;
	mgr->device = dssdev;
	mgr->device_changed = true;

	return 0;
}

static int omap_dss_unset_device(struct omap_overlay_manager *mgr)
{
	if (!mgr->device) {
		DSSERR("failed to unset display, display not set.\n");
		return -EINVAL;
	}

	/*
	 * Don't allow currently enabled displays to have the overlay manager
	 * pulled out from underneath them
	 */
	if (mgr->device->state != OMAP_DSS_DISPLAY_DISABLED)
		return -EINVAL;

	mgr->device->manager = NULL;
	mgr->device = NULL;
	mgr->device_changed = true;

	return 0;
}

static int dss_mgr_wait_for_vsync(struct omap_overlay_manager *mgr)
{
	unsigned long timeout = msecs_to_jiffies(500);
	u32 irq;

	if (mgr->device->type == OMAP_DISPLAY_TYPE_VENC) {
		irq = DISPC_IRQ_EVSYNC_ODD;
	} else if (mgr->device->type == OMAP_DISPLAY_TYPE_HDMI) {
		irq = DISPC_IRQ_EVSYNC_EVEN;
	} else {
		if (mgr->id == OMAP_DSS_CHANNEL_LCD)
			irq = DISPC_IRQ_VSYNC;
		else
			irq = DISPC_IRQ_VSYNC2;
	}
	return omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
}

static int dss_check_manager(struct omap_overlay_manager *mgr)
{
	if (dss_has_feature(FEAT_ALPHA_FIXED_ZORDER)) {
		/*
		 * OMAP3 supports only graphics source transparency color key
		 * and alpha blending simultaneously. See TRM 15.4.2.4.2.2
		 * Alpha Mode
		 */
		if (mgr->info.partial_alpha_enabled && mgr->info.trans_enabled
			&& mgr->info.trans_key_type !=
				OMAP_DSS_COLOR_KEY_GFX_DST)
			return -EINVAL;
	}

	return 0;
}

static int omap_dss_mgr_set_info(struct omap_overlay_manager *mgr,
		struct omap_overlay_manager_info *info)
{
	int r;
	struct omap_overlay_manager_info old_info;

	old_info = mgr->info;
	mgr->info = *info;

	r = dss_check_manager(mgr);
	if (r) {
		mgr->info = old_info;
		return r;
	}

	mgr->info_dirty = true;

	return 0;
}

static void omap_dss_mgr_get_info(struct omap_overlay_manager *mgr,
		struct omap_overlay_manager_info *info)
{
	*info = mgr->info;
}

static void omap_dss_add_overlay_manager(struct omap_overlay_manager *manager)
{
	++num_managers;
	list_add_tail(&manager->list, &manager_list);
}

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

	INIT_LIST_HEAD(&manager_list);

	num_managers = 0;

	for (i = 0; i < dss_feat_get_num_mgrs(); ++i) {
		struct omap_overlay_manager *mgr;
		mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);

		BUG_ON(mgr == NULL);

		switch (i) {
		case 0:
			mgr->name = "lcd";
			mgr->id = OMAP_DSS_CHANNEL_LCD;
			break;
		case 1:
			mgr->name = "tv";
			mgr->id = OMAP_DSS_CHANNEL_DIGIT;
			break;
		case 2:
			mgr->name = "lcd2";
			mgr->id = OMAP_DSS_CHANNEL_LCD2;
			break;
		}

		mgr->set_device = &omap_dss_set_device;
		mgr->unset_device = &omap_dss_unset_device;
		mgr->apply = &omap_dss_mgr_apply;
		mgr->set_manager_info = &omap_dss_mgr_set_info;
		mgr->get_manager_info = &omap_dss_mgr_get_info;
		mgr->wait_for_go = &dss_mgr_wait_for_go;
		mgr->wait_for_vsync = &dss_mgr_wait_for_vsync;

		mgr->caps = 0;
		mgr->supported_displays =
			dss_feat_get_supported_displays(mgr->id);

		dss_overlay_setup_dispc_manager(mgr);

		omap_dss_add_overlay_manager(mgr);

		r = kobject_init_and_add(&mgr->kobj, &manager_ktype,
				&pdev->dev.kobj, "manager%d", i);

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

	return 0;
}

void dss_uninit_overlay_managers(struct platform_device *pdev)
{
	struct omap_overlay_manager *mgr;

	while (!list_empty(&manager_list)) {
		mgr = list_first_entry(&manager_list,
				struct omap_overlay_manager, list);
		list_del(&mgr->list);
		kobject_del(&mgr->kobj);
		kobject_put(&mgr->kobj);
		kfree(mgr);
	}

	num_managers = 0;
}

int omap_dss_get_num_overlay_managers(void)
{
	return num_managers;
}
EXPORT_SYMBOL(omap_dss_get_num_overlay_managers);

struct omap_overlay_manager *omap_dss_get_overlay_manager(int num)
{
	int i = 0;
	struct omap_overlay_manager *mgr;

	list_for_each_entry(mgr, &manager_list, list) {
		if (i++ == num)
			return mgr;
	}

	return NULL;
}
EXPORT_SYMBOL(omap_dss_get_overlay_manager);
Commit	Line	Data
eed07e0e TV	1	/*
	2	* linux/drivers/video/omap2/dss/manager.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 "MANAGER"
	24
	25	#include <linux/kernel.h>
5a0e3ad6	26	#include <linux/slab.h>
eed07e0e TV	27	#include <linux/module.h>
eed07e0e TV	28	#include <linux/platform_device.h>
eed07e0e TV	29	#include <linux/jiffies.h>
eed07e0e TV	30
a0b38cc4	31	#include <video/omapdss.h>
eed07e0e TV	32
eed07e0e TV	33	#include "dss.h"
a0acb557	34	#include "dss_features.h"
eed07e0e TV	35
	36	static int num_managers;
	37	static struct list_head manager_list;
	38
	39	static ssize_t manager_name_show(struct omap_overlay_manager mgr, char buf)
	40	{
	41	return snprintf(buf, PAGE_SIZE, "%s\n", mgr->name);
	42	}
	43
	44	static ssize_t manager_display_show(struct omap_overlay_manager mgr, char buf)
	45	{
	46	return snprintf(buf, PAGE_SIZE, "%s\n",
	47	mgr->device ? mgr->device->name : "<none>");
	48	}
	49
	50	static ssize_t manager_display_store(struct omap_overlay_manager *mgr,
	51	const char *buf, size_t size)
	52	{
	53	int r = 0;
	54	size_t len = size;
	55	struct omap_dss_device *dssdev = NULL;
	56
	57	int match(struct omap_dss_device dssdev, void data)
	58	{
	59	const char *str = data;
	60	return sysfs_streq(dssdev->name, str);
	61	}
	62
	63	if (buf[size-1] == '\n')
	64	--len;
	65
	66	if (len > 0)
	67	dssdev = omap_dss_find_device((void *)buf, match);
	68
	69	if (len > 0 && dssdev == NULL)
	70	return -EINVAL;
	71
	72	if (dssdev)
	73	DSSDBG("display %s found\n", dssdev->name);
	74
	75	if (mgr->device) {
	76	r = mgr->unset_device(mgr);
	77	if (r) {
	78	DSSERR("failed to unset display\n");
	79	goto put_device;
	80	}
	81	}
	82
	83	if (dssdev) {
	84	r = mgr->set_device(mgr, dssdev);
	85	if (r) {
	86	DSSERR("failed to set manager\n");
	87	goto put_device;
	88	}
	89
	90	r = mgr->apply(mgr);
	91	if (r) {
	92	DSSERR("failed to apply dispc config\n");
	93	goto put_device;
	94	}
	95	}
	96
	97	put_device:
	98	if (dssdev)
99	omap_dss_put_device(dssdev);
100
101	return r ? r : size;
102	}
103
104	static ssize_t manager_default_color_show(struct omap_overlay_manager *mgr,
105	char *buf)
106	{
e3a26aec	107	return snprintf(buf, PAGE_SIZE, "%#x\n", mgr->info.default_color);
eed07e0e TV	108	}
	109
	110	static ssize_t manager_default_color_store(struct omap_overlay_manager *mgr,
	111	const char *buf, size_t size)
	112	{
	113	struct omap_overlay_manager_info info;
	114	u32 color;
	115	int r;
	116
e3a26aec TV	117	r = kstrtouint(buf, 0, &color);
	118	if (r)
	119	return r;
eed07e0e TV	120
	121	mgr->get_manager_info(mgr, &info);
	122
	123	info.default_color = color;
	124
	125	r = mgr->set_manager_info(mgr, &info);
	126	if (r)
	127	return r;
	128
	129	r = mgr->apply(mgr);
	130	if (r)
	131	return r;
	132
	133	return size;
	134	}
	135
	136	static const char *trans_key_type_str[] = {
	137	"gfx-destination",
	138	"video-source",
	139	};
	140
	141	static ssize_t manager_trans_key_type_show(struct omap_overlay_manager *mgr,
	142	char *buf)
	143	{
	144	enum omap_dss_trans_key_type key_type;
	145
	146	key_type = mgr->info.trans_key_type;
	147	BUG_ON(key_type >= ARRAY_SIZE(trans_key_type_str));
	148
	149	return snprintf(buf, PAGE_SIZE, "%s\n", trans_key_type_str[key_type]);
	150	}
	151
	152	static ssize_t manager_trans_key_type_store(struct omap_overlay_manager *mgr,
	153	const char *buf, size_t size)
	154	{
	155	enum omap_dss_trans_key_type key_type;
	156	struct omap_overlay_manager_info info;
	157	int r;
	158
	159	for (key_type = OMAP_DSS_COLOR_KEY_GFX_DST;
	160	key_type < ARRAY_SIZE(trans_key_type_str); key_type++) {
	161	if (sysfs_streq(buf, trans_key_type_str[key_type]))
	162	break;
	163	}
	164
	165	if (key_type == ARRAY_SIZE(trans_key_type_str))
	166	return -EINVAL;
	167
	168	mgr->get_manager_info(mgr, &info);
	169
	170	info.trans_key_type = key_type;
	171
	172	r = mgr->set_manager_info(mgr, &info);
	173	if (r)
	174	return r;
	175
	176	r = mgr->apply(mgr);
	177	if (r)
	178	return r;
	179
	180	return size;
	181	}
	182
	183	static ssize_t manager_trans_key_value_show(struct omap_overlay_manager *mgr,
184	char *buf)
185	{
e3a26aec	186	return snprintf(buf, PAGE_SIZE, "%#x\n", mgr->info.trans_key);
eed07e0e TV	187	}
	188
	189	static ssize_t manager_trans_key_value_store(struct omap_overlay_manager *mgr,
	190	const char *buf, size_t size)
	191	{
	192	struct omap_overlay_manager_info info;
	193	u32 key_value;
	194	int r;
	195
e3a26aec TV	196	r = kstrtouint(buf, 0, &key_value);
	197	if (r)
	198	return r;
eed07e0e TV	199
	200	mgr->get_manager_info(mgr, &info);
	201
	202	info.trans_key = key_value;
	203
	204	r = mgr->set_manager_info(mgr, &info);
	205	if (r)
	206	return r;
	207
	208	r = mgr->apply(mgr);
	209	if (r)
	210	return r;
	211
	212	return size;
	213	}
	214
	215	static ssize_t manager_trans_key_enabled_show(struct omap_overlay_manager *mgr,
	216	char *buf)
	217	{
	218	return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.trans_enabled);
	219	}
	220
	221	static ssize_t manager_trans_key_enabled_store(struct omap_overlay_manager *mgr,
	222	const char *buf, size_t size)
	223	{
	224	struct omap_overlay_manager_info info;
e3a26aec	225	bool enable;
eed07e0e TV	226	int r;
eed07e0e TV	227
e3a26aec TV	228	r = strtobool(buf, &enable);
	229	if (r)
	230	return r;
eed07e0e TV	231
	232	mgr->get_manager_info(mgr, &info);
	233
e3a26aec	234	info.trans_enabled = enable;
eed07e0e TV	235
	236	r = mgr->set_manager_info(mgr, &info);
	237	if (r)
	238	return r;
	239
	240	r = mgr->apply(mgr);
	241	if (r)
	242	return r;
	243
	244	return size;
	245	}
	246
	247	static ssize_t manager_alpha_blending_enabled_show(
	248	struct omap_overlay_manager mgr, char buf)
	249	{
11354dd5 AT	250	WARN_ON(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER));
	251
	252	return snprintf(buf, PAGE_SIZE, "%d\n",
	253	mgr->info.partial_alpha_enabled);
eed07e0e TV	254	}
	255
	256	static ssize_t manager_alpha_blending_enabled_store(
	257	struct omap_overlay_manager *mgr,
	258	const char *buf, size_t size)
	259	{
	260	struct omap_overlay_manager_info info;
e3a26aec	261	bool enable;
eed07e0e TV	262	int r;
eed07e0e TV	263
11354dd5 AT	264	WARN_ON(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER));
11354dd5 AT	265
e3a26aec TV	266	r = strtobool(buf, &enable);
	267	if (r)
	268	return r;
eed07e0e TV	269
	270	mgr->get_manager_info(mgr, &info);
	271
11354dd5	272	info.partial_alpha_enabled = enable;
eed07e0e TV	273
	274	r = mgr->set_manager_info(mgr, &info);
	275	if (r)
	276	return r;
	277
	278	r = mgr->apply(mgr);
	279	if (r)
	280	return r;
	281
	282	return size;
	283	}
	284
3c07cae2 TV	285	static ssize_t manager_cpr_enable_show(struct omap_overlay_manager *mgr,
	286	char *buf)
	287	{
	288	return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.cpr_enable);
	289	}
	290
	291	static ssize_t manager_cpr_enable_store(struct omap_overlay_manager *mgr,
	292	const char *buf, size_t size)
	293	{
	294	struct omap_overlay_manager_info info;
3c07cae2 TV	295	int r;
	296	bool enable;
	297
	298	if (!dss_has_feature(FEAT_CPR))
	299	return -ENODEV;
	300
e3a26aec	301	r = strtobool(buf, &enable);
3c07cae2 TV	302	if (r)
	303	return r;
	304
3c07cae2 TV	305	mgr->get_manager_info(mgr, &info);
	306
	307	if (info.cpr_enable == enable)
	308	return size;
	309
	310	info.cpr_enable = enable;
	311
	312	r = mgr->set_manager_info(mgr, &info);
	313	if (r)
	314	return r;
	315
	316	r = mgr->apply(mgr);
	317	if (r)
	318	return r;
	319
	320	return size;
	321	}
	322
	323	static ssize_t manager_cpr_coef_show(struct omap_overlay_manager *mgr,
	324	char *buf)
	325	{
	326	struct omap_overlay_manager_info info;
	327
	328	mgr->get_manager_info(mgr, &info);
	329
	330	return snprintf(buf, PAGE_SIZE,
	331	"%d %d %d %d %d %d %d %d %d\n",
	332	info.cpr_coefs.rr,
	333	info.cpr_coefs.rg,
	334	info.cpr_coefs.rb,
	335	info.cpr_coefs.gr,
	336	info.cpr_coefs.gg,
	337	info.cpr_coefs.gb,
	338	info.cpr_coefs.br,
	339	info.cpr_coefs.bg,
	340	info.cpr_coefs.bb);
	341	}
	342
	343	static ssize_t manager_cpr_coef_store(struct omap_overlay_manager *mgr,
	344	const char *buf, size_t size)
	345	{
	346	struct omap_overlay_manager_info info;
	347	struct omap_dss_cpr_coefs coefs;
	348	int r, i;
	349	s16 *arr;
	350
	351	if (!dss_has_feature(FEAT_CPR))
	352	return -ENODEV;
	353
	354	if (sscanf(buf, "%hd %hd %hd %hd %hd %hd %hd %hd %hd",
	355	&coefs.rr, &coefs.rg, &coefs.rb,
	356	&coefs.gr, &coefs.gg, &coefs.gb,
	357	&coefs.br, &coefs.bg, &coefs.bb) != 9)
	358	return -EINVAL;
	359
	360	arr = (s16[]){ coefs.rr, coefs.rg, coefs.rb,
	361	coefs.gr, coefs.gg, coefs.gb,
	362	coefs.br, coefs.bg, coefs.bb };
	363
	364	for (i = 0; i < 9; ++i) {
	365	if (arr[i] < -512 \|\| arr[i] > 511)
	366	return -EINVAL;
	367	}
	368
369	mgr->get_manager_info(mgr, &info);
370
371	info.cpr_coefs = coefs;
372
373	r = mgr->set_manager_info(mgr, &info);
374	if (r)
375	return r;
376
377	r = mgr->apply(mgr);
378	if (r)
379	return r;
380
381	return size;
382	}
383
eed07e0e TV	384	struct manager_attribute {
	385	struct attribute attr;
	386	ssize_t (show)(struct omap_overlay_manager , char *);
	387	ssize_t (store)(struct omap_overlay_manager , const char *, size_t);
	388	};
	389
	390	#define MANAGER_ATTR(_name, _mode, _show, _store) \
	391	struct manager_attribute manager_attr_##_name = \
	392	__ATTR(_name, _mode, _show, _store)
	393
	394	static MANAGER_ATTR(name, S_IRUGO, manager_name_show, NULL);
	395	static MANAGER_ATTR(display, S_IRUGO\|S_IWUSR,
	396	manager_display_show, manager_display_store);
	397	static MANAGER_ATTR(default_color, S_IRUGO\|S_IWUSR,
	398	manager_default_color_show, manager_default_color_store);
	399	static MANAGER_ATTR(trans_key_type, S_IRUGO\|S_IWUSR,
	400	manager_trans_key_type_show, manager_trans_key_type_store);
	401	static MANAGER_ATTR(trans_key_value, S_IRUGO\|S_IWUSR,
	402	manager_trans_key_value_show, manager_trans_key_value_store);
	403	static MANAGER_ATTR(trans_key_enabled, S_IRUGO\|S_IWUSR,
	404	manager_trans_key_enabled_show,
	405	manager_trans_key_enabled_store);
	406	static MANAGER_ATTR(alpha_blending_enabled, S_IRUGO\|S_IWUSR,
	407	manager_alpha_blending_enabled_show,
	408	manager_alpha_blending_enabled_store);
3c07cae2 TV	409	static MANAGER_ATTR(cpr_enable, S_IRUGO\|S_IWUSR,
	410	manager_cpr_enable_show,
	411	manager_cpr_enable_store);
	412	static MANAGER_ATTR(cpr_coef, S_IRUGO\|S_IWUSR,
	413	manager_cpr_coef_show,
	414	manager_cpr_coef_store);
eed07e0e TV	415
	416
	417	static struct attribute *manager_sysfs_attrs[] = {
	418	&manager_attr_name.attr,
	419	&manager_attr_display.attr,
	420	&manager_attr_default_color.attr,
	421	&manager_attr_trans_key_type.attr,
	422	&manager_attr_trans_key_value.attr,
	423	&manager_attr_trans_key_enabled.attr,
	424	&manager_attr_alpha_blending_enabled.attr,
3c07cae2 TV	425	&manager_attr_cpr_enable.attr,
3c07cae2 TV	426	&manager_attr_cpr_coef.attr,
eed07e0e TV	427	NULL
	428	};
	429
	430	static ssize_t manager_attr_show(struct kobject kobj, struct attribute attr,
	431	char *buf)
	432	{
	433	struct omap_overlay_manager *manager;
	434	struct manager_attribute *manager_attr;
	435
	436	manager = container_of(kobj, struct omap_overlay_manager, kobj);
	437	manager_attr = container_of(attr, struct manager_attribute, attr);
	438
	439	if (!manager_attr->show)
	440	return -ENOENT;
	441
	442	return manager_attr->show(manager, buf);
	443	}
	444
	445	static ssize_t manager_attr_store(struct kobject kobj, struct attribute attr,
	446	const char *buf, size_t size)
	447	{
	448	struct omap_overlay_manager *manager;
	449	struct manager_attribute *manager_attr;
	450
	451	manager = container_of(kobj, struct omap_overlay_manager, kobj);
	452	manager_attr = container_of(attr, struct manager_attribute, attr);
	453
	454	if (!manager_attr->store)
	455	return -ENOENT;
	456
	457	return manager_attr->store(manager, buf, size);
	458	}
	459
52cf25d0	460	static const struct sysfs_ops manager_sysfs_ops = {
eed07e0e TV	461	.show = manager_attr_show,
	462	.store = manager_attr_store,
	463	};
	464
	465	static struct kobj_type manager_ktype = {
	466	.sysfs_ops = &manager_sysfs_ops,
	467	.default_attrs = manager_sysfs_attrs,
	468	};
	469
eed07e0e TV	470	static int omap_dss_set_device(struct omap_overlay_manager *mgr,
	471	struct omap_dss_device *dssdev)
	472	{
	473	int i;
	474	int r;
	475
	476	if (dssdev->manager) {
	477	DSSERR("display '%s' already has a manager '%s'\n",
	478	dssdev->name, dssdev->manager->name);
	479	return -EINVAL;
	480	}
	481
	482	if ((mgr->supported_displays & dssdev->type) == 0) {
	483	DSSERR("display '%s' does not support manager '%s'\n",
	484	dssdev->name, mgr->name);
	485	return -EINVAL;
	486	}
	487
	488	for (i = 0; i < mgr->num_overlays; i++) {
	489	struct omap_overlay *ovl = mgr->overlays[i];
	490
	491	if (ovl->manager != mgr \|\| !ovl->info.enabled)
	492	continue;
	493
	494	r = dss_check_overlay(ovl, dssdev);
	495	if (r)
	496	return r;
	497	}
	498
	499	dssdev->manager = mgr;
	500	mgr->device = dssdev;
	501	mgr->device_changed = true;
	502
	503	return 0;
	504	}
	505
	506	static int omap_dss_unset_device(struct omap_overlay_manager *mgr)
	507	{
	508	if (!mgr->device) {
	509	DSSERR("failed to unset display, display not set.\n");
	510	return -EINVAL;
	511	}
	512
0f770b47 DM	513	/*
	514	* Don't allow currently enabled displays to have the overlay manager
	515	* pulled out from underneath them
	516	*/
	517	if (mgr->device->state != OMAP_DSS_DISPLAY_DISABLED)
	518	return -EINVAL;
	519
eed07e0e TV	520	mgr->device->manager = NULL;
	521	mgr->device = NULL;
	522	mgr->device_changed = true;
	523
	524	return 0;
	525	}
	526
3f71cbe7 TV	527	static int dss_mgr_wait_for_vsync(struct omap_overlay_manager *mgr)
	528	{
	529	unsigned long timeout = msecs_to_jiffies(500);
	530	u32 irq;
	531
18faa1b6	532	if (mgr->device->type == OMAP_DISPLAY_TYPE_VENC) {
3f71cbe7	533	irq = DISPC_IRQ_EVSYNC_ODD;
b119601d M	534	} else if (mgr->device->type == OMAP_DISPLAY_TYPE_HDMI) {
b119601d M	535	irq = DISPC_IRQ_EVSYNC_EVEN;
18faa1b6 SS	536	} else {
	537	if (mgr->id == OMAP_DSS_CHANNEL_LCD)
	538	irq = DISPC_IRQ_VSYNC;
	539	else
	540	irq = DISPC_IRQ_VSYNC2;
	541	}
3f71cbe7 TV	542	return omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
	543	}
	544
eed07e0e TV	545	static int dss_check_manager(struct omap_overlay_manager *mgr)
eed07e0e TV	546	{
11354dd5 AT	547	if (dss_has_feature(FEAT_ALPHA_FIXED_ZORDER)) {
	548	/*
	549	* OMAP3 supports only graphics source transparency color key
	550	* and alpha blending simultaneously. See TRM 15.4.2.4.2.2
	551	* Alpha Mode
	552	*/
	553	if (mgr->info.partial_alpha_enabled && mgr->info.trans_enabled
	554	&& mgr->info.trans_key_type !=
	555	OMAP_DSS_COLOR_KEY_GFX_DST)
	556	return -EINVAL;
	557	}
eed07e0e TV	558
	559	return 0;
	560	}
	561
	562	static int omap_dss_mgr_set_info(struct omap_overlay_manager *mgr,
	563	struct omap_overlay_manager_info *info)
	564	{
	565	int r;
	566	struct omap_overlay_manager_info old_info;
	567
	568	old_info = mgr->info;
	569	mgr->info = *info;
	570
	571	r = dss_check_manager(mgr);
	572	if (r) {
	573	mgr->info = old_info;
	574	return r;
	575	}
	576
	577	mgr->info_dirty = true;
	578
	579	return 0;
	580	}
	581
	582	static void omap_dss_mgr_get_info(struct omap_overlay_manager *mgr,
	583	struct omap_overlay_manager_info *info)
	584	{
	585	*info = mgr->info;
	586	}
	587
	588	static void omap_dss_add_overlay_manager(struct omap_overlay_manager *manager)
	589	{
	590	++num_managers;
	591	list_add_tail(&manager->list, &manager_list);
	592	}
	593
	594	int dss_init_overlay_managers(struct platform_device *pdev)
	595	{
	596	int i, r;
	597
eed07e0e TV	598	INIT_LIST_HEAD(&manager_list);
	599
	600	num_managers = 0;
	601
a0acb557	602	for (i = 0; i < dss_feat_get_num_mgrs(); ++i) {
eed07e0e TV	603	struct omap_overlay_manager *mgr;
	604	mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
	605
	606	BUG_ON(mgr == NULL);
	607
	608	switch (i) {
	609	case 0:
	610	mgr->name = "lcd";
	611	mgr->id = OMAP_DSS_CHANNEL_LCD;
eed07e0e TV	612	break;
	613	case 1:
	614	mgr->name = "tv";
	615	mgr->id = OMAP_DSS_CHANNEL_DIGIT;
eed07e0e	616	break;
18faa1b6 SS	617	case 2:
	618	mgr->name = "lcd2";
	619	mgr->id = OMAP_DSS_CHANNEL_LCD2;
	620	break;
eed07e0e TV	621	}
	622
	623	mgr->set_device = &omap_dss_set_device;
	624	mgr->unset_device = &omap_dss_unset_device;
	625	mgr->apply = &omap_dss_mgr_apply;
	626	mgr->set_manager_info = &omap_dss_mgr_set_info;
	627	mgr->get_manager_info = &omap_dss_mgr_get_info;
	628	mgr->wait_for_go = &dss_mgr_wait_for_go;
3f71cbe7	629	mgr->wait_for_vsync = &dss_mgr_wait_for_vsync;
eed07e0e	630
4a9e78ab	631	mgr->caps = 0;
a0acb557 AT	632	mgr->supported_displays =
a0acb557 AT	633	dss_feat_get_supported_displays(mgr->id);
eed07e0e TV	634
	635	dss_overlay_setup_dispc_manager(mgr);
	636
	637	omap_dss_add_overlay_manager(mgr);
	638
	639	r = kobject_init_and_add(&mgr->kobj, &manager_ktype,
	640	&pdev->dev.kobj, "manager%d", i);
	641
	642	if (r) {
	643	DSSERR("failed to create sysfs file\n");
	644	continue;
	645	}
	646	}
	647
eed07e0e TV	648	return 0;
	649	}
	650
	651	void dss_uninit_overlay_managers(struct platform_device *pdev)
	652	{
	653	struct omap_overlay_manager *mgr;
	654
	655	while (!list_empty(&manager_list)) {
	656	mgr = list_first_entry(&manager_list,
	657	struct omap_overlay_manager, list);
	658	list_del(&mgr->list);
	659	kobject_del(&mgr->kobj);
	660	kobject_put(&mgr->kobj);
	661	kfree(mgr);
	662	}
	663
	664	num_managers = 0;
	665	}
	666
	667	int omap_dss_get_num_overlay_managers(void)
	668	{
	669	return num_managers;
	670	}
	671	EXPORT_SYMBOL(omap_dss_get_num_overlay_managers);
	672
	673	struct omap_overlay_manager *omap_dss_get_overlay_manager(int num)
	674	{
	675	int i = 0;
	676	struct omap_overlay_manager *mgr;
	677
	678	list_for_each_entry(mgr, &manager_list, list) {
	679	if (i++ == num)
	680	return mgr;
	681	}
	682
	683	return NULL;
	684	}
	685	EXPORT_SYMBOL(omap_dss_get_overlay_manager);
	686