2011-11-04 14:48:54 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2011 Texas Instruments
|
|
|
|
* Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
|
|
|
|
*
|
|
|
|
* 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 "APPLY"
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
|
|
|
|
#include <video/omapdss.h>
|
|
|
|
|
|
|
|
#include "dss.h"
|
|
|
|
#include "dss_features.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have 4 levels of cache for the dispc settings. First two are in SW and
|
|
|
|
* the latter two in HW.
|
|
|
|
*
|
2011-11-16 19:31:58 +07:00
|
|
|
* set_info()
|
|
|
|
* v
|
2011-11-04 14:48:54 +07:00
|
|
|
* +--------------------+
|
2011-11-16 19:31:58 +07:00
|
|
|
* | user_info |
|
2011-11-04 14:48:54 +07:00
|
|
|
* +--------------------+
|
|
|
|
* v
|
|
|
|
* apply()
|
|
|
|
* v
|
|
|
|
* +--------------------+
|
2011-11-15 17:04:43 +07:00
|
|
|
* | info |
|
2011-11-04 14:48:54 +07:00
|
|
|
* +--------------------+
|
|
|
|
* v
|
2011-11-15 16:47:39 +07:00
|
|
|
* write_regs()
|
2011-11-04 14:48:54 +07:00
|
|
|
* v
|
|
|
|
* +--------------------+
|
|
|
|
* | shadow registers |
|
|
|
|
* +--------------------+
|
|
|
|
* v
|
|
|
|
* VFP or lcd/digit_enable
|
|
|
|
* v
|
|
|
|
* +--------------------+
|
|
|
|
* | registers |
|
|
|
|
* +--------------------+
|
|
|
|
*/
|
|
|
|
|
2011-11-15 16:56:57 +07:00
|
|
|
struct ovl_priv_data {
|
2011-11-16 19:11:56 +07:00
|
|
|
|
|
|
|
bool user_info_dirty;
|
|
|
|
struct omap_overlay_info user_info;
|
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
bool info_dirty;
|
2011-11-04 14:48:54 +07:00
|
|
|
struct omap_overlay_info info;
|
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
bool shadow_info_dirty;
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
bool extra_info_dirty;
|
|
|
|
bool shadow_extra_info_dirty;
|
|
|
|
|
|
|
|
bool enabled;
|
2011-11-16 19:17:54 +07:00
|
|
|
enum omap_channel channel;
|
2011-11-16 19:28:12 +07:00
|
|
|
u32 fifo_low, fifo_high;
|
2011-11-26 19:26:46 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* True if overlay is to be enabled. Used to check and calculate configs
|
|
|
|
* for the overlay before it is enabled in the HW.
|
|
|
|
*/
|
|
|
|
bool enabling;
|
2011-11-04 14:48:54 +07:00
|
|
|
};
|
|
|
|
|
2011-11-15 17:02:03 +07:00
|
|
|
struct mgr_priv_data {
|
2011-11-16 18:58:07 +07:00
|
|
|
|
|
|
|
bool user_info_dirty;
|
|
|
|
struct omap_overlay_manager_info user_info;
|
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
bool info_dirty;
|
2011-11-04 14:48:54 +07:00
|
|
|
struct omap_overlay_manager_info info;
|
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
bool shadow_info_dirty;
|
|
|
|
|
2011-11-15 20:04:25 +07:00
|
|
|
/* If true, GO bit is up and shadow registers cannot be written.
|
|
|
|
* Never true for manual update displays */
|
|
|
|
bool busy;
|
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
/* If true, dispc output is enabled */
|
|
|
|
bool updating;
|
|
|
|
|
2011-11-15 19:43:53 +07:00
|
|
|
/* If true, a display is enabled using this manager */
|
|
|
|
bool enabled;
|
2011-11-04 14:48:54 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct {
|
2011-11-15 16:56:57 +07:00
|
|
|
struct ovl_priv_data ovl_priv_data_array[MAX_DSS_OVERLAYS];
|
2011-11-15 17:02:03 +07:00
|
|
|
struct mgr_priv_data mgr_priv_data_array[MAX_DSS_MANAGERS];
|
2011-11-04 14:48:54 +07:00
|
|
|
|
|
|
|
bool irq_enabled;
|
2011-11-15 17:04:43 +07:00
|
|
|
} dss_data;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 17:04:43 +07:00
|
|
|
/* protects dss_data */
|
2011-11-15 17:04:10 +07:00
|
|
|
static spinlock_t data_lock;
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
/* lock for blocking functions */
|
|
|
|
static DEFINE_MUTEX(apply_lock);
|
2011-11-16 19:37:48 +07:00
|
|
|
static DECLARE_COMPLETION(extra_updated_completion);
|
2011-11-15 17:04:10 +07:00
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
static void dss_register_vsync_isr(void);
|
|
|
|
|
2011-11-15 16:56:57 +07:00
|
|
|
static struct ovl_priv_data *get_ovl_priv(struct omap_overlay *ovl)
|
|
|
|
{
|
2011-11-15 17:04:43 +07:00
|
|
|
return &dss_data.ovl_priv_data_array[ovl->id];
|
2011-11-15 16:56:57 +07:00
|
|
|
}
|
|
|
|
|
2011-11-15 17:02:03 +07:00
|
|
|
static struct mgr_priv_data *get_mgr_priv(struct omap_overlay_manager *mgr)
|
|
|
|
{
|
2011-11-15 17:04:43 +07:00
|
|
|
return &dss_data.mgr_priv_data_array[mgr->id];
|
2011-11-15 17:02:03 +07:00
|
|
|
}
|
|
|
|
|
2011-11-04 14:48:54 +07:00
|
|
|
void dss_apply_init(void)
|
|
|
|
{
|
2011-11-16 19:11:56 +07:00
|
|
|
const int num_ovls = dss_feat_get_num_ovls();
|
|
|
|
int i;
|
|
|
|
|
2011-11-15 17:04:10 +07:00
|
|
|
spin_lock_init(&data_lock);
|
2011-11-16 19:11:56 +07:00
|
|
|
|
|
|
|
for (i = 0; i < num_ovls; ++i) {
|
|
|
|
struct ovl_priv_data *op;
|
|
|
|
|
|
|
|
op = &dss_data.ovl_priv_data_array[i];
|
|
|
|
|
|
|
|
op->info.global_alpha = 255;
|
|
|
|
|
|
|
|
switch (i) {
|
|
|
|
case 0:
|
|
|
|
op->info.zorder = 0;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
op->info.zorder =
|
|
|
|
dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 3 : 0;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
op->info.zorder =
|
|
|
|
dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 2 : 0;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
op->info.zorder =
|
|
|
|
dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 1 : 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
op->user_info = op->info;
|
|
|
|
}
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool ovl_manual_update(struct omap_overlay *ovl)
|
|
|
|
{
|
|
|
|
return ovl->manager->device->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool mgr_manual_update(struct omap_overlay_manager *mgr)
|
|
|
|
{
|
|
|
|
return mgr->device->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
|
|
|
|
}
|
|
|
|
|
2011-11-17 22:35:28 +07:00
|
|
|
/* Check if overlay parameters are compatible with display */
|
|
|
|
static int dss_ovl_check(struct omap_overlay *ovl,
|
|
|
|
struct omap_overlay_info *info, struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
u16 outw, outh;
|
|
|
|
u16 dw, dh;
|
|
|
|
|
|
|
|
if (dssdev == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dssdev->driver->get_resolution(dssdev, &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) {
|
|
|
|
DSSERR("overlay %d horizontally not inside the display area "
|
|
|
|
"(%d + %d >= %d)\n",
|
|
|
|
ovl->id, info->pos_x, outw, dw);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dh < info->pos_y + outh) {
|
|
|
|
DSSERR("overlay %d vertically not inside the display area "
|
|
|
|
"(%d + %d >= %d)\n",
|
|
|
|
ovl->id, info->pos_y, outh, dh);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dss_mgr_check_zorder(struct omap_overlay_manager *mgr,
|
|
|
|
struct omap_overlay_info **overlay_infos)
|
|
|
|
{
|
|
|
|
struct omap_overlay *ovl1, *ovl2;
|
|
|
|
struct ovl_priv_data *op1, *op2;
|
|
|
|
struct omap_overlay_info *info1, *info2;
|
|
|
|
|
|
|
|
list_for_each_entry(ovl1, &mgr->overlays, list) {
|
|
|
|
op1 = get_ovl_priv(ovl1);
|
|
|
|
info1 = overlay_infos[ovl1->id];
|
|
|
|
|
|
|
|
if (info1 == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
list_for_each_entry(ovl2, &mgr->overlays, list) {
|
|
|
|
if (ovl1 == ovl2)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
op2 = get_ovl_priv(ovl2);
|
|
|
|
info2 = overlay_infos[ovl2->id];
|
|
|
|
|
|
|
|
if (info2 == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (info1->zorder == info2->zorder) {
|
|
|
|
DSSERR("overlays %d and %d have the same "
|
|
|
|
"zorder %d\n",
|
|
|
|
ovl1->id, ovl2->id, info1->zorder);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dss_mgr_check(struct omap_overlay_manager *mgr,
|
|
|
|
struct omap_dss_device *dssdev,
|
|
|
|
struct omap_overlay_manager_info *info,
|
|
|
|
struct omap_overlay_info **overlay_infos)
|
|
|
|
{
|
|
|
|
struct omap_overlay *ovl;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (dss_has_feature(FEAT_ALPHA_FREE_ZORDER)) {
|
|
|
|
r = dss_mgr_check_zorder(mgr, overlay_infos);
|
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
|
|
struct omap_overlay_info *oi;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
oi = overlay_infos[ovl->id];
|
|
|
|
|
|
|
|
if (oi == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
r = dss_ovl_check(ovl, oi, dssdev);
|
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static int dss_check_settings_low(struct omap_overlay_manager *mgr,
|
|
|
|
struct omap_dss_device *dssdev, bool applying)
|
|
|
|
{
|
|
|
|
struct omap_overlay_info *oi;
|
|
|
|
struct omap_overlay_manager_info *mi;
|
|
|
|
struct omap_overlay *ovl;
|
|
|
|
struct omap_overlay_info *ois[MAX_DSS_OVERLAYS];
|
|
|
|
struct ovl_priv_data *op;
|
|
|
|
struct mgr_priv_data *mp;
|
|
|
|
|
|
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
|
|
|
|
if (applying && mp->user_info_dirty)
|
|
|
|
mi = &mp->user_info;
|
|
|
|
else
|
|
|
|
mi = &mp->info;
|
|
|
|
|
|
|
|
/* collect the infos to be tested into the array */
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
|
|
op = get_ovl_priv(ovl);
|
|
|
|
|
2011-11-26 19:26:46 +07:00
|
|
|
if (!op->enabled && !op->enabling)
|
2011-11-17 22:35:28 +07:00
|
|
|
oi = NULL;
|
|
|
|
else if (applying && op->user_info_dirty)
|
|
|
|
oi = &op->user_info;
|
|
|
|
else
|
|
|
|
oi = &op->info;
|
|
|
|
|
|
|
|
ois[ovl->id] = oi;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dss_mgr_check(mgr, dssdev, mi, ois);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check manager and overlay settings using overlay_info from data->info
|
|
|
|
*/
|
|
|
|
static int dss_check_settings(struct omap_overlay_manager *mgr,
|
|
|
|
struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
return dss_check_settings_low(mgr, dssdev, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check manager and overlay settings using overlay_info from ovl->info if
|
|
|
|
* dirty and from data->info otherwise
|
|
|
|
*/
|
|
|
|
static int dss_check_settings_apply(struct omap_overlay_manager *mgr,
|
|
|
|
struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
return dss_check_settings_low(mgr, dssdev, true);
|
|
|
|
}
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
static bool need_isr(void)
|
|
|
|
{
|
|
|
|
const int num_mgrs = dss_feat_get_num_mgrs();
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_mgrs; ++i) {
|
|
|
|
struct omap_overlay_manager *mgr;
|
|
|
|
struct mgr_priv_data *mp;
|
|
|
|
struct omap_overlay *ovl;
|
|
|
|
|
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
|
|
|
|
if (!mp->enabled)
|
|
|
|
continue;
|
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
if (mgr_manual_update(mgr)) {
|
|
|
|
/* to catch FRAMEDONE */
|
|
|
|
if (mp->updating)
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
/* to catch GO bit going down */
|
|
|
|
if (mp->busy)
|
|
|
|
return true;
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
/* to write new values to registers */
|
2011-11-16 19:31:58 +07:00
|
|
|
if (mp->info_dirty)
|
2011-11-18 20:43:29 +07:00
|
|
|
return true;
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-25 22:26:13 +07:00
|
|
|
/* to set GO bit */
|
|
|
|
if (mp->shadow_info_dirty)
|
|
|
|
return true;
|
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
|
|
struct ovl_priv_data *op;
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
op = get_ovl_priv(ovl);
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-25 22:26:13 +07:00
|
|
|
/*
|
|
|
|
* NOTE: we check extra_info flags even for
|
|
|
|
* disabled overlays, as extra_infos need to be
|
|
|
|
* always written.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* to write new values to registers */
|
|
|
|
if (op->extra_info_dirty)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* to set GO bit */
|
|
|
|
if (op->shadow_extra_info_dirty)
|
|
|
|
return true;
|
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
if (!op->enabled)
|
|
|
|
continue;
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
/* to write new values to registers */
|
2011-11-25 22:26:13 +07:00
|
|
|
if (op->info_dirty)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* to set GO bit */
|
|
|
|
if (op->shadow_info_dirty)
|
2011-11-18 20:43:29 +07:00
|
|
|
return true;
|
|
|
|
}
|
2011-11-15 23:25:23 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool need_go(struct omap_overlay_manager *mgr)
|
|
|
|
{
|
|
|
|
struct omap_overlay *ovl;
|
|
|
|
struct mgr_priv_data *mp;
|
|
|
|
struct ovl_priv_data *op;
|
|
|
|
|
|
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
if (mp->shadow_info_dirty)
|
2011-11-15 23:25:23 +07:00
|
|
|
return true;
|
|
|
|
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
|
|
op = get_ovl_priv(ovl);
|
2011-11-16 19:31:58 +07:00
|
|
|
if (op->shadow_info_dirty || op->shadow_extra_info_dirty)
|
2011-11-15 23:25:23 +07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-11-16 19:37:48 +07:00
|
|
|
/* returns true if an extra_info field is currently being updated */
|
|
|
|
static bool extra_info_update_ongoing(void)
|
|
|
|
{
|
|
|
|
const int num_ovls = omap_dss_get_num_overlays();
|
|
|
|
struct ovl_priv_data *op;
|
|
|
|
struct omap_overlay *ovl;
|
|
|
|
struct mgr_priv_data *mp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_ovls; ++i) {
|
|
|
|
ovl = omap_dss_get_overlay(i);
|
|
|
|
op = get_ovl_priv(ovl);
|
|
|
|
|
|
|
|
mp = get_mgr_priv(ovl->manager);
|
|
|
|
|
|
|
|
if (!mp->enabled)
|
|
|
|
continue;
|
|
|
|
|
2011-11-25 22:35:35 +07:00
|
|
|
if (!mp->updating)
|
2011-11-16 19:37:48 +07:00
|
|
|
continue;
|
|
|
|
|
2011-11-25 22:35:35 +07:00
|
|
|
if (op->extra_info_dirty || op->shadow_extra_info_dirty)
|
|
|
|
return true;
|
2011-11-16 19:37:48 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* wait until no extra_info updates are pending */
|
|
|
|
static void wait_pending_extra_info_updates(void)
|
|
|
|
{
|
|
|
|
bool updating;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned long t;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
|
|
|
updating = extra_info_update_ongoing();
|
|
|
|
|
|
|
|
if (!updating) {
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
init_completion(&extra_updated_completion);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
|
|
|
t = msecs_to_jiffies(500);
|
|
|
|
wait_for_completion_timeout(&extra_updated_completion, t);
|
|
|
|
|
|
|
|
updating = extra_info_update_ongoing();
|
|
|
|
|
|
|
|
WARN_ON(updating);
|
|
|
|
}
|
|
|
|
|
2011-11-04 14:48:54 +07:00
|
|
|
int dss_mgr_wait_for_go(struct omap_overlay_manager *mgr)
|
|
|
|
{
|
|
|
|
unsigned long timeout = msecs_to_jiffies(500);
|
2011-11-15 17:02:03 +07:00
|
|
|
struct mgr_priv_data *mp;
|
2011-11-04 14:48:54 +07:00
|
|
|
u32 irq;
|
|
|
|
int r;
|
|
|
|
int i;
|
|
|
|
struct omap_dss_device *dssdev = mgr->device;
|
|
|
|
|
|
|
|
if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (mgr_manual_update(mgr))
|
|
|
|
return 0;
|
|
|
|
|
2011-11-15 16:20:13 +07:00
|
|
|
irq = dispc_mgr_get_vsync_irq(mgr->id);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 17:02:03 +07:00
|
|
|
mp = get_mgr_priv(mgr);
|
2011-11-04 14:48:54 +07:00
|
|
|
i = 0;
|
|
|
|
while (1) {
|
|
|
|
unsigned long flags;
|
|
|
|
bool shadow_dirty, dirty;
|
|
|
|
|
2011-11-15 17:04:10 +07:00
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
2011-11-16 19:31:58 +07:00
|
|
|
dirty = mp->info_dirty;
|
|
|
|
shadow_dirty = mp->shadow_info_dirty;
|
2011-11-15 17:04:10 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
|
|
|
if (!dirty && !shadow_dirty) {
|
|
|
|
r = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 4 iterations is the worst case:
|
|
|
|
* 1 - initial iteration, dirty = true (between VFP and VSYNC)
|
|
|
|
* 2 - first VSYNC, dirty = true
|
|
|
|
* 3 - dirty = false, shadow_dirty = true
|
|
|
|
* 4 - shadow_dirty = false */
|
|
|
|
if (i++ == 3) {
|
|
|
|
DSSERR("mgr(%d)->wait_for_go() not finishing\n",
|
|
|
|
mgr->id);
|
|
|
|
r = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
|
|
|
|
if (r == -ERESTARTSYS)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (r) {
|
|
|
|
DSSERR("mgr(%d)->wait_for_go() timeout\n", mgr->id);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dss_mgr_wait_for_go_ovl(struct omap_overlay *ovl)
|
|
|
|
{
|
|
|
|
unsigned long timeout = msecs_to_jiffies(500);
|
2011-11-15 16:56:57 +07:00
|
|
|
struct ovl_priv_data *op;
|
2011-11-04 14:48:54 +07:00
|
|
|
struct omap_dss_device *dssdev;
|
|
|
|
u32 irq;
|
|
|
|
int r;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!ovl->manager)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dssdev = ovl->manager->device;
|
|
|
|
|
|
|
|
if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (ovl_manual_update(ovl))
|
|
|
|
return 0;
|
|
|
|
|
2011-11-15 16:20:13 +07:00
|
|
|
irq = dispc_mgr_get_vsync_irq(ovl->manager->id);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 16:56:57 +07:00
|
|
|
op = get_ovl_priv(ovl);
|
2011-11-04 14:48:54 +07:00
|
|
|
i = 0;
|
|
|
|
while (1) {
|
|
|
|
unsigned long flags;
|
|
|
|
bool shadow_dirty, dirty;
|
|
|
|
|
2011-11-15 17:04:10 +07:00
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
2011-11-16 19:31:58 +07:00
|
|
|
dirty = op->info_dirty;
|
|
|
|
shadow_dirty = op->shadow_info_dirty;
|
2011-11-15 17:04:10 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
|
|
|
if (!dirty && !shadow_dirty) {
|
|
|
|
r = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 4 iterations is the worst case:
|
|
|
|
* 1 - initial iteration, dirty = true (between VFP and VSYNC)
|
|
|
|
* 2 - first VSYNC, dirty = true
|
|
|
|
* 3 - dirty = false, shadow_dirty = true
|
|
|
|
* 4 - shadow_dirty = false */
|
|
|
|
if (i++ == 3) {
|
|
|
|
DSSERR("ovl(%d)->wait_for_go() not finishing\n",
|
|
|
|
ovl->id);
|
|
|
|
r = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
|
|
|
|
if (r == -ERESTARTSYS)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (r) {
|
|
|
|
DSSERR("ovl(%d)->wait_for_go() timeout\n", ovl->id);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
static void dss_ovl_write_regs(struct omap_overlay *ovl)
|
2011-11-04 14:48:54 +07:00
|
|
|
{
|
2011-11-15 23:25:23 +07:00
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
2011-11-04 14:48:54 +07:00
|
|
|
struct omap_overlay_info *oi;
|
|
|
|
bool ilace, replication;
|
2011-11-18 20:43:29 +07:00
|
|
|
struct mgr_priv_data *mp;
|
2011-11-04 14:48:54 +07:00
|
|
|
int r;
|
|
|
|
|
2011-11-15 16:47:39 +07:00
|
|
|
DSSDBGF("%d", ovl->id);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
if (!op->enabled || !op->info_dirty)
|
2011-11-15 23:25:23 +07:00
|
|
|
return;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
oi = &op->info;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
|
|
|
replication = dss_use_replication(ovl->manager->device, oi->color_mode);
|
|
|
|
|
|
|
|
ilace = ovl->manager->device->type == OMAP_DISPLAY_TYPE_VENC;
|
|
|
|
|
2011-11-15 16:47:39 +07:00
|
|
|
r = dispc_ovl_setup(ovl->id, oi, ilace, replication);
|
2011-11-04 14:48:54 +07:00
|
|
|
if (r) {
|
2011-11-15 23:25:23 +07:00
|
|
|
/*
|
|
|
|
* We can't do much here, as this function can be called from
|
|
|
|
* vsync interrupt.
|
|
|
|
*/
|
2011-11-15 16:47:39 +07:00
|
|
|
DSSERR("dispc_ovl_setup failed for ovl %d\n", ovl->id);
|
2011-11-15 23:25:23 +07:00
|
|
|
|
|
|
|
/* This will leave fifo configurations in a nonoptimal state */
|
|
|
|
op->enabled = false;
|
|
|
|
dispc_ovl_enable(ovl->id, false);
|
|
|
|
return;
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
mp = get_mgr_priv(ovl->manager);
|
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
op->info_dirty = false;
|
2011-11-18 20:43:29 +07:00
|
|
|
if (mp->updating)
|
2011-11-16 19:31:58 +07:00
|
|
|
op->shadow_info_dirty = true;
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
static void dss_ovl_write_regs_extra(struct omap_overlay *ovl)
|
|
|
|
{
|
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
2011-11-18 20:43:29 +07:00
|
|
|
struct mgr_priv_data *mp;
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
|
|
|
|
DSSDBGF("%d", ovl->id);
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
if (!op->extra_info_dirty)
|
|
|
|
return;
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
/* note: write also when op->enabled == false, so that the ovl gets
|
|
|
|
* disabled */
|
|
|
|
|
|
|
|
dispc_ovl_enable(ovl->id, op->enabled);
|
2011-11-16 19:17:54 +07:00
|
|
|
dispc_ovl_set_channel_out(ovl->id, op->channel);
|
2011-11-16 19:28:12 +07:00
|
|
|
dispc_ovl_set_fifo_threshold(ovl->id, op->fifo_low, op->fifo_high);
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
mp = get_mgr_priv(ovl->manager);
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
op->extra_info_dirty = false;
|
2011-11-18 20:43:29 +07:00
|
|
|
if (mp->updating)
|
|
|
|
op->shadow_extra_info_dirty = true;
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
}
|
|
|
|
|
2011-11-15 16:47:39 +07:00
|
|
|
static void dss_mgr_write_regs(struct omap_overlay_manager *mgr)
|
2011-11-04 14:48:54 +07:00
|
|
|
{
|
2011-11-15 23:25:23 +07:00
|
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
struct omap_overlay *ovl;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 16:47:39 +07:00
|
|
|
DSSDBGF("%d", mgr->id);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
if (!mp->enabled)
|
|
|
|
return;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
WARN_ON(mp->busy);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
|
|
|
/* Commit overlay settings */
|
2011-11-15 23:25:23 +07:00
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
|
|
dss_ovl_write_regs(ovl);
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
dss_ovl_write_regs_extra(ovl);
|
|
|
|
}
|
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
if (mp->info_dirty) {
|
2011-11-15 23:25:23 +07:00
|
|
|
dispc_mgr_setup(mgr->id, &mp->info);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 19:31:58 +07:00
|
|
|
mp->info_dirty = false;
|
2011-11-18 20:43:29 +07:00
|
|
|
if (mp->updating)
|
2011-11-16 19:31:58 +07:00
|
|
|
mp->shadow_info_dirty = true;
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
2011-11-15 23:25:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void dss_write_regs(void)
|
|
|
|
{
|
|
|
|
const int num_mgrs = omap_dss_get_num_overlay_managers();
|
|
|
|
int i;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
|
|
|
for (i = 0; i < num_mgrs; ++i) {
|
2011-11-15 23:25:23 +07:00
|
|
|
struct omap_overlay_manager *mgr;
|
|
|
|
struct mgr_priv_data *mp;
|
2011-11-17 22:35:28 +07:00
|
|
|
int r;
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-15 17:02:03 +07:00
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
|
|
mp = get_mgr_priv(mgr);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
if (!mp->enabled || mgr_manual_update(mgr) || mp->busy)
|
2011-11-04 14:48:54 +07:00
|
|
|
continue;
|
|
|
|
|
2011-11-17 22:35:28 +07:00
|
|
|
r = dss_check_settings(mgr, mgr->device);
|
|
|
|
if (r) {
|
|
|
|
DSSERR("cannot write registers for manager %s: "
|
|
|
|
"illegal configuration\n", mgr->name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
dss_mgr_write_regs(mgr);
|
2011-11-25 22:32:20 +07:00
|
|
|
}
|
|
|
|
}
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-25 22:32:20 +07:00
|
|
|
static void dss_set_go_bits(void)
|
|
|
|
{
|
|
|
|
const int num_mgrs = omap_dss_get_num_overlay_managers();
|
|
|
|
int i;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-25 22:32:20 +07:00
|
|
|
for (i = 0; i < num_mgrs; ++i) {
|
|
|
|
struct omap_overlay_manager *mgr;
|
|
|
|
struct mgr_priv_data *mp;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-25 22:32:20 +07:00
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
|
|
|
|
if (!mp->enabled || mgr_manual_update(mgr) || mp->busy)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!need_go(mgr))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
mp->busy = true;
|
|
|
|
|
|
|
|
if (!dss_data.irq_enabled && need_isr())
|
|
|
|
dss_register_vsync_isr();
|
|
|
|
|
|
|
|
dispc_mgr_go(mgr->id);
|
2011-11-15 23:25:23 +07:00
|
|
|
}
|
2011-11-25 22:32:20 +07:00
|
|
|
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void dss_mgr_start_update(struct omap_overlay_manager *mgr)
|
|
|
|
{
|
2011-11-15 17:02:03 +07:00
|
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
unsigned long flags;
|
2011-11-17 22:35:28 +07:00
|
|
|
int r;
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
WARN_ON(mp->updating);
|
|
|
|
|
2011-11-17 22:35:28 +07:00
|
|
|
r = dss_check_settings(mgr, mgr->device);
|
|
|
|
if (r) {
|
|
|
|
DSSERR("cannot start manual update: illegal configuration\n");
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
dss_mgr_write_regs(mgr);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
mp->updating = true;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
if (!dss_data.irq_enabled && need_isr())
|
|
|
|
dss_register_vsync_isr();
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-04 15:22:46 +07:00
|
|
|
dispc_mgr_enable(mgr->id, true);
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
2011-11-15 16:18:12 +07:00
|
|
|
static void dss_apply_irq_handler(void *data, u32 mask);
|
|
|
|
|
|
|
|
static void dss_register_vsync_isr(void)
|
|
|
|
{
|
2011-11-15 16:20:13 +07:00
|
|
|
const int num_mgrs = dss_feat_get_num_mgrs();
|
2011-11-15 16:18:12 +07:00
|
|
|
u32 mask;
|
2011-11-15 16:20:13 +07:00
|
|
|
int r, i;
|
2011-11-15 16:18:12 +07:00
|
|
|
|
2011-11-15 16:20:13 +07:00
|
|
|
mask = 0;
|
|
|
|
for (i = 0; i < num_mgrs; ++i)
|
|
|
|
mask |= dispc_mgr_get_vsync_irq(i);
|
2011-11-15 16:18:12 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
for (i = 0; i < num_mgrs; ++i)
|
|
|
|
mask |= dispc_mgr_get_framedone_irq(i);
|
|
|
|
|
2011-11-15 16:18:12 +07:00
|
|
|
r = omap_dispc_register_isr(dss_apply_irq_handler, NULL, mask);
|
|
|
|
WARN_ON(r);
|
|
|
|
|
2011-11-15 17:04:43 +07:00
|
|
|
dss_data.irq_enabled = true;
|
2011-11-15 16:18:12 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void dss_unregister_vsync_isr(void)
|
|
|
|
{
|
2011-11-15 16:20:13 +07:00
|
|
|
const int num_mgrs = dss_feat_get_num_mgrs();
|
2011-11-15 16:18:12 +07:00
|
|
|
u32 mask;
|
2011-11-15 16:20:13 +07:00
|
|
|
int r, i;
|
2011-11-15 16:18:12 +07:00
|
|
|
|
2011-11-15 16:20:13 +07:00
|
|
|
mask = 0;
|
|
|
|
for (i = 0; i < num_mgrs; ++i)
|
|
|
|
mask |= dispc_mgr_get_vsync_irq(i);
|
2011-11-15 16:18:12 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
for (i = 0; i < num_mgrs; ++i)
|
|
|
|
mask |= dispc_mgr_get_framedone_irq(i);
|
|
|
|
|
2011-11-15 16:18:12 +07:00
|
|
|
r = omap_dispc_unregister_isr(dss_apply_irq_handler, NULL, mask);
|
|
|
|
WARN_ON(r);
|
|
|
|
|
2011-11-15 17:04:43 +07:00
|
|
|
dss_data.irq_enabled = false;
|
2011-11-15 16:18:12 +07:00
|
|
|
}
|
|
|
|
|
2011-11-16 17:03:22 +07:00
|
|
|
static void mgr_clear_shadow_dirty(struct omap_overlay_manager *mgr)
|
2011-11-04 14:48:54 +07:00
|
|
|
{
|
2011-11-15 16:56:57 +07:00
|
|
|
struct omap_overlay *ovl;
|
2011-11-15 17:02:03 +07:00
|
|
|
struct mgr_priv_data *mp;
|
2011-11-15 16:56:57 +07:00
|
|
|
struct ovl_priv_data *op;
|
2011-11-16 17:03:22 +07:00
|
|
|
|
|
|
|
mp = get_mgr_priv(mgr);
|
2011-11-16 19:31:58 +07:00
|
|
|
mp->shadow_info_dirty = false;
|
2011-11-16 17:03:22 +07:00
|
|
|
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
|
|
op = get_ovl_priv(ovl);
|
2011-11-16 19:31:58 +07:00
|
|
|
op->shadow_info_dirty = false;
|
2011-11-16 17:03:22 +07:00
|
|
|
op->shadow_extra_info_dirty = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dss_apply_irq_handler(void *data, u32 mask)
|
|
|
|
{
|
2011-11-04 14:48:54 +07:00
|
|
|
const int num_mgrs = dss_feat_get_num_mgrs();
|
2011-11-15 23:25:23 +07:00
|
|
|
int i;
|
2011-11-16 19:37:48 +07:00
|
|
|
bool extra_updating;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 17:04:10 +07:00
|
|
|
spin_lock(&data_lock);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 17:03:22 +07:00
|
|
|
/* clear busy, updating flags, shadow_dirty flags */
|
2011-11-15 20:04:25 +07:00
|
|
|
for (i = 0; i < num_mgrs; i++) {
|
2011-11-16 17:03:22 +07:00
|
|
|
struct omap_overlay_manager *mgr;
|
|
|
|
struct mgr_priv_data *mp;
|
2011-11-25 22:27:45 +07:00
|
|
|
bool was_updating;
|
2011-11-16 17:03:22 +07:00
|
|
|
|
2011-11-15 20:04:25 +07:00
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
|
2011-11-16 17:03:22 +07:00
|
|
|
if (!mp->enabled)
|
2011-11-15 20:04:25 +07:00
|
|
|
continue;
|
|
|
|
|
2011-11-25 22:27:45 +07:00
|
|
|
was_updating = mp->updating;
|
2011-11-16 17:03:22 +07:00
|
|
|
mp->updating = dispc_mgr_is_enabled(i);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 17:03:22 +07:00
|
|
|
if (!mgr_manual_update(mgr)) {
|
2011-11-25 22:27:45 +07:00
|
|
|
bool was_busy = mp->busy;
|
2011-11-16 17:03:22 +07:00
|
|
|
mp->busy = dispc_mgr_go_busy(i);
|
2011-11-15 20:04:25 +07:00
|
|
|
|
2011-11-25 22:27:45 +07:00
|
|
|
if (was_busy && !mp->busy)
|
2011-11-16 17:03:22 +07:00
|
|
|
mgr_clear_shadow_dirty(mgr);
|
|
|
|
} else {
|
2011-11-25 22:27:45 +07:00
|
|
|
if (was_updating && !mp->updating)
|
2011-11-16 17:03:22 +07:00
|
|
|
mgr_clear_shadow_dirty(mgr);
|
|
|
|
}
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
dss_write_regs();
|
2011-11-25 22:32:20 +07:00
|
|
|
dss_set_go_bits();
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 19:37:48 +07:00
|
|
|
extra_updating = extra_info_update_ongoing();
|
|
|
|
if (!extra_updating)
|
|
|
|
complete_all(&extra_updated_completion);
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
if (!need_isr())
|
|
|
|
dss_unregister_vsync_isr();
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 17:04:10 +07:00
|
|
|
spin_unlock(&data_lock);
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
2011-11-15 18:37:33 +07:00
|
|
|
static void omap_dss_mgr_apply_ovl(struct omap_overlay *ovl)
|
2011-11-04 14:48:54 +07:00
|
|
|
{
|
2011-11-15 16:56:57 +07:00
|
|
|
struct ovl_priv_data *op;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 16:56:57 +07:00
|
|
|
op = get_ovl_priv(ovl);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 19:11:56 +07:00
|
|
|
if (!op->user_info_dirty)
|
2011-11-15 18:37:33 +07:00
|
|
|
return;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 19:11:56 +07:00
|
|
|
op->user_info_dirty = false;
|
2011-11-16 19:31:58 +07:00
|
|
|
op->info_dirty = true;
|
2011-11-16 19:11:56 +07:00
|
|
|
op->info = op->user_info;
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_dss_mgr_apply_mgr(struct omap_overlay_manager *mgr)
|
|
|
|
{
|
2011-11-15 17:02:03 +07:00
|
|
|
struct mgr_priv_data *mp;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-15 17:02:03 +07:00
|
|
|
mp = get_mgr_priv(mgr);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 18:58:07 +07:00
|
|
|
if (!mp->user_info_dirty)
|
2011-11-04 14:48:54 +07:00
|
|
|
return;
|
|
|
|
|
2011-11-16 18:58:07 +07:00
|
|
|
mp->user_info_dirty = false;
|
2011-11-16 19:31:58 +07:00
|
|
|
mp->info_dirty = true;
|
2011-11-16 18:58:07 +07:00
|
|
|
mp->info = mp->user_info;
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
2011-11-16 19:28:12 +07:00
|
|
|
int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
|
2011-11-04 14:48:54 +07:00
|
|
|
{
|
2011-11-16 19:28:12 +07:00
|
|
|
unsigned long flags;
|
|
|
|
struct omap_overlay *ovl;
|
2011-11-17 22:35:28 +07:00
|
|
|
int r;
|
2011-11-16 19:28:12 +07:00
|
|
|
|
|
|
|
DSSDBG("omap_dss_mgr_apply(%s)\n", mgr->name);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-17 22:35:28 +07:00
|
|
|
r = dss_check_settings_apply(mgr, mgr->device);
|
|
|
|
if (r) {
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
DSSERR("failed to apply settings: illegal configuration.\n");
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-11-16 19:28:12 +07:00
|
|
|
/* Configure overlays */
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list)
|
|
|
|
omap_dss_mgr_apply_ovl(ovl);
|
|
|
|
|
|
|
|
/* Configure manager */
|
|
|
|
omap_dss_mgr_apply_mgr(mgr);
|
|
|
|
|
|
|
|
dss_write_regs();
|
2011-11-25 22:32:20 +07:00
|
|
|
dss_set_go_bits();
|
2011-11-16 19:28:12 +07:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
2011-11-16 21:53:44 +07:00
|
|
|
return 0;
|
2011-11-16 19:28:12 +07:00
|
|
|
}
|
|
|
|
|
2011-11-16 20:25:53 +07:00
|
|
|
static void dss_apply_ovl_enable(struct omap_overlay *ovl, bool enable)
|
|
|
|
{
|
|
|
|
struct ovl_priv_data *op;
|
|
|
|
|
|
|
|
op = get_ovl_priv(ovl);
|
|
|
|
|
|
|
|
if (op->enabled == enable)
|
|
|
|
return;
|
|
|
|
|
|
|
|
op->enabled = enable;
|
|
|
|
op->extra_info_dirty = true;
|
|
|
|
}
|
|
|
|
|
2011-11-16 19:28:12 +07:00
|
|
|
static void dss_ovl_setup_fifo(struct omap_overlay *ovl)
|
|
|
|
{
|
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
2011-11-04 14:48:54 +07:00
|
|
|
struct omap_dss_device *dssdev;
|
|
|
|
u32 size, burst_size;
|
2011-11-16 19:28:12 +07:00
|
|
|
u32 fifo_low, fifo_high;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-26 19:36:19 +07:00
|
|
|
if (!op->enabled && !op->enabling)
|
|
|
|
return;
|
|
|
|
|
2011-11-04 14:48:54 +07:00
|
|
|
dssdev = ovl->manager->device;
|
|
|
|
|
|
|
|
size = dispc_ovl_get_fifo_size(ovl->id);
|
|
|
|
|
|
|
|
burst_size = dispc_ovl_get_burst_size(ovl->id);
|
|
|
|
|
|
|
|
switch (dssdev->type) {
|
|
|
|
case OMAP_DISPLAY_TYPE_DPI:
|
|
|
|
case OMAP_DISPLAY_TYPE_DBI:
|
|
|
|
case OMAP_DISPLAY_TYPE_SDI:
|
|
|
|
case OMAP_DISPLAY_TYPE_VENC:
|
|
|
|
case OMAP_DISPLAY_TYPE_HDMI:
|
|
|
|
default_get_overlay_fifo_thresholds(ovl->id, size,
|
2011-11-16 19:28:12 +07:00
|
|
|
burst_size, &fifo_low, &fifo_high);
|
2011-11-04 14:48:54 +07:00
|
|
|
break;
|
|
|
|
#ifdef CONFIG_OMAP2_DSS_DSI
|
|
|
|
case OMAP_DISPLAY_TYPE_DSI:
|
|
|
|
dsi_get_overlay_fifo_thresholds(ovl->id, size,
|
2011-11-16 19:28:12 +07:00
|
|
|
burst_size, &fifo_low, &fifo_high);
|
2011-11-04 14:48:54 +07:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
2011-11-16 19:28:12 +07:00
|
|
|
|
|
|
|
op->fifo_low = fifo_low;
|
|
|
|
op->fifo_high = fifo_high;
|
|
|
|
op->extra_info_dirty = true;
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
2011-11-16 19:28:12 +07:00
|
|
|
static void dss_mgr_setup_fifos(struct omap_overlay_manager *mgr)
|
2011-11-04 14:48:54 +07:00
|
|
|
{
|
2011-11-05 15:59:59 +07:00
|
|
|
struct omap_overlay *ovl;
|
2011-11-16 19:28:12 +07:00
|
|
|
struct mgr_priv_data *mp;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 19:28:12 +07:00
|
|
|
mp = get_mgr_priv(mgr);
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-16 19:28:12 +07:00
|
|
|
if (!mp->enabled)
|
|
|
|
return;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-26 19:36:19 +07:00
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list)
|
|
|
|
dss_ovl_setup_fifo(ovl);
|
|
|
|
}
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-26 19:36:19 +07:00
|
|
|
static void dss_setup_fifos(void)
|
|
|
|
{
|
|
|
|
const int num_mgrs = omap_dss_get_num_overlay_managers();
|
|
|
|
struct omap_overlay_manager *mgr;
|
|
|
|
int i;
|
2011-11-04 14:48:54 +07:00
|
|
|
|
2011-11-26 19:36:19 +07:00
|
|
|
for (i = 0; i < num_mgrs; ++i) {
|
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
|
|
dss_mgr_setup_fifos(mgr);
|
2011-11-16 19:28:12 +07:00
|
|
|
}
|
2011-11-04 14:48:54 +07:00
|
|
|
}
|
|
|
|
|
2011-11-21 18:34:48 +07:00
|
|
|
int dss_mgr_enable(struct omap_overlay_manager *mgr)
|
2011-11-04 15:22:46 +07:00
|
|
|
{
|
2011-11-15 19:43:53 +07:00
|
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
unsigned long flags;
|
2011-11-17 22:35:28 +07:00
|
|
|
int r;
|
2011-11-15 19:43:53 +07:00
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
|
2011-11-16 21:01:33 +07:00
|
|
|
if (mp->enabled)
|
|
|
|
goto out;
|
|
|
|
|
2011-11-15 19:43:53 +07:00
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-17 22:35:28 +07:00
|
|
|
mp->enabled = true;
|
2011-11-26 19:29:39 +07:00
|
|
|
|
2011-11-17 22:35:28 +07:00
|
|
|
r = dss_check_settings(mgr, mgr->device);
|
|
|
|
if (r) {
|
|
|
|
DSSERR("failed to enable manager %d: check_settings failed\n",
|
|
|
|
mgr->id);
|
2011-11-21 18:34:48 +07:00
|
|
|
goto err;
|
2011-11-17 22:35:28 +07:00
|
|
|
}
|
|
|
|
|
2011-11-26 19:36:19 +07:00
|
|
|
dss_setup_fifos();
|
2011-11-16 19:28:12 +07:00
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
dss_write_regs();
|
2011-11-25 22:32:20 +07:00
|
|
|
dss_set_go_bits();
|
2011-11-15 23:25:23 +07:00
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
if (!mgr_manual_update(mgr))
|
|
|
|
mp->updating = true;
|
|
|
|
|
2011-11-15 19:43:53 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
if (!mgr_manual_update(mgr))
|
|
|
|
dispc_mgr_enable(mgr->id, true);
|
|
|
|
|
2011-11-16 21:01:33 +07:00
|
|
|
out:
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_unlock(&apply_lock);
|
2011-11-21 18:34:48 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2011-11-26 19:29:39 +07:00
|
|
|
mp->enabled = false;
|
2011-11-21 18:34:48 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return r;
|
2011-11-04 15:22:46 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void dss_mgr_disable(struct omap_overlay_manager *mgr)
|
|
|
|
{
|
2011-11-15 19:43:53 +07:00
|
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
unsigned long flags;
|
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
|
2011-11-16 21:01:33 +07:00
|
|
|
if (!mp->enabled)
|
|
|
|
goto out;
|
|
|
|
|
2011-11-09 20:30:11 +07:00
|
|
|
if (!mgr_manual_update(mgr))
|
|
|
|
dispc_mgr_enable(mgr->id, false);
|
2011-11-15 19:43:53 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-18 20:43:29 +07:00
|
|
|
mp->updating = false;
|
2011-11-15 19:43:53 +07:00
|
|
|
mp->enabled = false;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
|
2011-11-16 21:01:33 +07:00
|
|
|
out:
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_unlock(&apply_lock);
|
2011-11-04 15:22:46 +07:00
|
|
|
}
|
|
|
|
|
2011-11-17 19:31:09 +07:00
|
|
|
static int dss_mgr_simple_check(struct omap_overlay_manager *mgr,
|
|
|
|
const struct omap_overlay_manager_info *info)
|
|
|
|
{
|
|
|
|
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 (info->partial_alpha_enabled && info->trans_enabled
|
|
|
|
&& info->trans_key_type != OMAP_DSS_COLOR_KEY_GFX_DST) {
|
|
|
|
DSSERR("check_manager: illegal transparency key\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-15 17:15:18 +07:00
|
|
|
int dss_mgr_set_info(struct omap_overlay_manager *mgr,
|
|
|
|
struct omap_overlay_manager_info *info)
|
|
|
|
{
|
2011-11-16 18:58:07 +07:00
|
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
unsigned long flags;
|
2011-11-17 19:31:09 +07:00
|
|
|
int r;
|
|
|
|
|
|
|
|
r = dss_mgr_simple_check(mgr, info);
|
|
|
|
if (r)
|
|
|
|
return r;
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-16 18:58:07 +07:00
|
|
|
mp->user_info = *info;
|
|
|
|
mp->user_info_dirty = true;
|
2011-11-15 17:15:18 +07:00
|
|
|
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
2011-11-15 17:15:18 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void dss_mgr_get_info(struct omap_overlay_manager *mgr,
|
|
|
|
struct omap_overlay_manager_info *info)
|
|
|
|
{
|
2011-11-16 18:58:07 +07:00
|
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-16 18:58:07 +07:00
|
|
|
*info = mp->user_info;
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
2011-11-15 17:15:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
int dss_mgr_set_device(struct omap_overlay_manager *mgr,
|
|
|
|
struct omap_dss_device *dssdev)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
|
2011-11-15 17:15:18 +07:00
|
|
|
if (dssdev->manager) {
|
|
|
|
DSSERR("display '%s' already has a manager '%s'\n",
|
|
|
|
dssdev->name, dssdev->manager->name);
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
2011-11-15 17:15:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((mgr->supported_displays & dssdev->type) == 0) {
|
|
|
|
DSSERR("display '%s' does not support manager '%s'\n",
|
|
|
|
dssdev->name, mgr->name);
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
2011-11-15 17:15:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
dssdev->manager = mgr;
|
|
|
|
mgr->device = dssdev;
|
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
|
2011-11-15 17:15:18 +07:00
|
|
|
return 0;
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
err:
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return r;
|
2011-11-15 17:15:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
int dss_mgr_unset_device(struct omap_overlay_manager *mgr)
|
|
|
|
{
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
int r;
|
|
|
|
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
|
2011-11-15 17:15:18 +07:00
|
|
|
if (!mgr->device) {
|
|
|
|
DSSERR("failed to unset display, display not set.\n");
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
2011-11-15 17:15:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't allow currently enabled displays to have the overlay manager
|
|
|
|
* pulled out from underneath them
|
|
|
|
*/
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
if (mgr->device->state != OMAP_DSS_DISPLAY_DISABLED) {
|
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
|
|
|
}
|
2011-11-15 17:15:18 +07:00
|
|
|
|
|
|
|
mgr->device->manager = NULL;
|
|
|
|
mgr->device = NULL;
|
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
|
2011-11-15 17:15:18 +07:00
|
|
|
return 0;
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
err:
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return r;
|
2011-11-15 17:15:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-11-17 19:26:48 +07:00
|
|
|
static int dss_ovl_simple_check(struct omap_overlay *ovl,
|
|
|
|
const struct omap_overlay_info *info)
|
|
|
|
{
|
|
|
|
if (info->paddr == 0) {
|
|
|
|
DSSERR("check_overlay: paddr cannot be 0\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
|
|
|
|
if (info->out_width != 0 && info->width != info->out_width) {
|
|
|
|
DSSERR("check_overlay: overlay %d doesn't support "
|
|
|
|
"scaling\n", ovl->id);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->out_height != 0 && info->height != info->out_height) {
|
|
|
|
DSSERR("check_overlay: overlay %d doesn't support "
|
|
|
|
"scaling\n", ovl->id);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ovl->supported_modes & info->color_mode) == 0) {
|
|
|
|
DSSERR("check_overlay: overlay %d doesn't support mode %d\n",
|
|
|
|
ovl->id, info->color_mode);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->zorder >= omap_dss_get_num_overlays()) {
|
|
|
|
DSSERR("check_overlay: zorder %d too high\n", info->zorder);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-11-15 17:15:18 +07:00
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
int dss_ovl_set_info(struct omap_overlay *ovl,
|
|
|
|
struct omap_overlay_info *info)
|
|
|
|
{
|
2011-11-16 19:11:56 +07:00
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
unsigned long flags;
|
2011-11-17 19:26:48 +07:00
|
|
|
int r;
|
|
|
|
|
|
|
|
r = dss_ovl_simple_check(ovl, info);
|
|
|
|
if (r)
|
|
|
|
return r;
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-16 19:11:56 +07:00
|
|
|
op->user_info = *info;
|
|
|
|
op->user_info_dirty = true;
|
2011-11-15 17:11:11 +07:00
|
|
|
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void dss_ovl_get_info(struct omap_overlay *ovl,
|
|
|
|
struct omap_overlay_info *info)
|
|
|
|
{
|
2011-11-16 19:11:56 +07:00
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-16 19:11:56 +07:00
|
|
|
*info = op->user_info;
|
OMAPDSS: APPLY: add missing uses of spinlock
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The other
group will not sleep and can be called from interrupts, and the other
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
apply.c already contains a spinlock, which has been used to protect
(badly) the dss_data. This patch adds locks/unlocks of the spinlock to
the missing places, and the lock should now properly protect dss_data.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:32:57 +07:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
2011-11-15 17:11:11 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
int dss_ovl_set_manager(struct omap_overlay *ovl,
|
|
|
|
struct omap_overlay_manager *mgr)
|
|
|
|
{
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
|
|
unsigned long flags;
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
int r;
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
if (!mgr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
if (ovl->manager) {
|
|
|
|
DSSERR("overlay '%s' already has a manager '%s'\n",
|
|
|
|
ovl->name, ovl->manager->name);
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
2011-11-15 17:11:11 +07:00
|
|
|
}
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
|
|
|
if (op->enabled) {
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
2011-11-15 17:11:11 +07:00
|
|
|
DSSERR("overlay has to be disabled to change the manager\n");
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
2011-11-15 17:11:11 +07:00
|
|
|
}
|
|
|
|
|
2011-11-16 19:17:54 +07:00
|
|
|
op->channel = mgr->id;
|
|
|
|
op->extra_info_dirty = true;
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
ovl->manager = mgr;
|
|
|
|
list_add_tail(&ovl->list, &mgr->overlays);
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
return 0;
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
err:
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return r;
|
2011-11-15 17:11:11 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
int dss_ovl_unset_manager(struct omap_overlay *ovl)
|
|
|
|
{
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
|
|
unsigned long flags;
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
int r;
|
|
|
|
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
if (!ovl->manager) {
|
|
|
|
DSSERR("failed to detach overlay: manager not set\n");
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
2011-11-15 17:11:11 +07:00
|
|
|
}
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
|
|
|
if (op->enabled) {
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
2011-11-15 17:11:11 +07:00
|
|
|
DSSERR("overlay has to be disabled to unset the manager\n");
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
2011-11-15 17:11:11 +07:00
|
|
|
}
|
|
|
|
|
2011-11-16 19:17:54 +07:00
|
|
|
op->channel = -1;
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
ovl->manager = NULL;
|
|
|
|
list_del(&ovl->list);
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err:
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool dss_ovl_is_enabled(struct omap_overlay *ovl)
|
|
|
|
{
|
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
|
|
unsigned long flags;
|
|
|
|
bool e;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
|
|
|
e = op->enabled;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dss_ovl_enable(struct omap_overlay *ovl)
|
|
|
|
{
|
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
|
|
unsigned long flags;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
|
2011-11-16 21:01:33 +07:00
|
|
|
if (op->enabled) {
|
|
|
|
r = 0;
|
2011-11-17 22:35:28 +07:00
|
|
|
goto err1;
|
2011-11-16 21:01:33 +07:00
|
|
|
}
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
if (ovl->manager == NULL || ovl->manager->device == NULL) {
|
|
|
|
r = -EINVAL;
|
2011-11-17 22:35:28 +07:00
|
|
|
goto err1;
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-26 19:26:46 +07:00
|
|
|
op->enabling = true;
|
|
|
|
|
2011-11-17 22:35:28 +07:00
|
|
|
r = dss_check_settings(ovl->manager, ovl->manager->device);
|
|
|
|
if (r) {
|
|
|
|
DSSERR("failed to enable overlay %d: check_settings failed\n",
|
|
|
|
ovl->id);
|
|
|
|
goto err2;
|
|
|
|
}
|
|
|
|
|
2011-11-26 19:36:19 +07:00
|
|
|
dss_setup_fifos();
|
2011-11-16 19:28:12 +07:00
|
|
|
|
2011-11-26 19:26:46 +07:00
|
|
|
op->enabling = false;
|
|
|
|
dss_apply_ovl_enable(ovl, true);
|
|
|
|
|
2011-11-15 23:25:23 +07:00
|
|
|
dss_write_regs();
|
2011-11-25 22:32:20 +07:00
|
|
|
dss_set_go_bits();
|
2011-11-15 23:25:23 +07:00
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
|
|
|
|
return 0;
|
2011-11-17 22:35:28 +07:00
|
|
|
err2:
|
2011-11-26 19:26:46 +07:00
|
|
|
op->enabling = false;
|
2011-11-17 22:35:28 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
err1:
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dss_ovl_disable(struct omap_overlay *ovl)
|
|
|
|
{
|
|
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
|
|
unsigned long flags;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
|
2011-11-16 21:01:33 +07:00
|
|
|
if (!op->enabled) {
|
|
|
|
r = 0;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
if (ovl->manager == NULL || ovl->manager->device == NULL) {
|
|
|
|
r = -EINVAL;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
|
2011-11-16 20:25:53 +07:00
|
|
|
dss_apply_ovl_enable(ovl, false);
|
2011-11-15 23:25:23 +07:00
|
|
|
dss_write_regs();
|
2011-11-25 22:32:20 +07:00
|
|
|
dss_set_go_bits();
|
2011-11-15 23:25:23 +07:00
|
|
|
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
|
2011-11-15 17:11:11 +07:00
|
|
|
return 0;
|
OMAPDSS: APPLY: rewrite overlay enable/disable
Overlays are currently enabled and disabled with a boolean in the struct
omap_overlay_info. The overlay info is set with ovl->set_overlay_info(),
and made into use with mgr->apply().
This doesn't work properly, as the enable/disable status may affect also
other overlays, for example when using fifo-merge. Thus the enabling and
disabling of the overlay needs to be done outside the normal overlay
configuration.
This patch achieves that by doing the following things:
1) Add function pointers to struct omap_overlay: enable(), disable() and
is_enabled(). These are used to do the obvious. The functions may block.
2) Move the "enabled" field from struct omap_overlay to ovl_priv_data.
3) Add a new route for settings to be applied to the HW, called
"extra_info". The status of the normal info and extra_info are tracked
separately.
The point here is to allow the normal info to be changed and
applied in non-blocking matter, whereas the extra_info can only be
changed when holding the mutex. This makes it possible to, for example,
set the overlay enable flag, apply it, and wait until the HW has taken
the flag into use.
This is not possible if the enable flag would be in the normal info, as
a new value for the flag could be set at any time from the users of
omapdss.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 21:37:53 +07:00
|
|
|
|
OMAPDSS: APPLY: add mutex
The functions in apply.c, called mostly via function pointers in overlay
and overlay_manager structs, will be divided into two groups. The first
group will not sleep and can be called from interrupts, and the second
group may sleep.
The idea is that the non-sleeping functions may only change certain
settings in overlays and managers, and those settings may only affect
the particular overlay/manager. For example, set the base address of the
overlay.
The blocking functions, however, will handle more complex configuration
changes. For example, when an overlay is enabled and fifo-merge feature
is used, we need to do the enable in multiple steps, waiting in between,
and the change affects multiple overlays and managers.
This patch adds the mutex which is used in the blocking functions to
have exclusive access to overlays and overlay managers.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
2011-11-15 19:28:48 +07:00
|
|
|
err:
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return r;
|
2011-11-15 17:11:11 +07:00
|
|
|
}
|
|
|
|
|