1690 lines
34 KiB
C
1690 lines
34 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright (C) 2011 Texas Instruments
|
|
* Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
|
|
*/
|
|
|
|
#define DSS_SUBSYS_NAME "APPLY"
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <video/omapfb_dss.h>
|
|
|
|
#include "dss.h"
|
|
#include "dss_features.h"
|
|
#include "dispc-compat.h"
|
|
|
|
/*
|
|
* We have 4 levels of cache for the dispc settings. First two are in SW and
|
|
* the latter two in HW.
|
|
*
|
|
* set_info()
|
|
* v
|
|
* +--------------------+
|
|
* | user_info |
|
|
* +--------------------+
|
|
* v
|
|
* apply()
|
|
* v
|
|
* +--------------------+
|
|
* | info |
|
|
* +--------------------+
|
|
* v
|
|
* write_regs()
|
|
* v
|
|
* +--------------------+
|
|
* | shadow registers |
|
|
* +--------------------+
|
|
* v
|
|
* VFP or lcd/digit_enable
|
|
* v
|
|
* +--------------------+
|
|
* | registers |
|
|
* +--------------------+
|
|
*/
|
|
|
|
struct ovl_priv_data {
|
|
|
|
bool user_info_dirty;
|
|
struct omap_overlay_info user_info;
|
|
|
|
bool info_dirty;
|
|
struct omap_overlay_info info;
|
|
|
|
bool shadow_info_dirty;
|
|
|
|
bool extra_info_dirty;
|
|
bool shadow_extra_info_dirty;
|
|
|
|
bool enabled;
|
|
u32 fifo_low, fifo_high;
|
|
|
|
/*
|
|
* 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;
|
|
};
|
|
|
|
struct mgr_priv_data {
|
|
|
|
bool user_info_dirty;
|
|
struct omap_overlay_manager_info user_info;
|
|
|
|
bool info_dirty;
|
|
struct omap_overlay_manager_info info;
|
|
|
|
bool shadow_info_dirty;
|
|
|
|
/* If true, GO bit is up and shadow registers cannot be written.
|
|
* Never true for manual update displays */
|
|
bool busy;
|
|
|
|
/* If true, dispc output is enabled */
|
|
bool updating;
|
|
|
|
/* If true, a display is enabled using this manager */
|
|
bool enabled;
|
|
|
|
bool extra_info_dirty;
|
|
bool shadow_extra_info_dirty;
|
|
|
|
struct omap_video_timings timings;
|
|
struct dss_lcd_mgr_config lcd_config;
|
|
|
|
void (*framedone_handler)(void *);
|
|
void *framedone_handler_data;
|
|
};
|
|
|
|
static struct {
|
|
struct ovl_priv_data ovl_priv_data_array[MAX_DSS_OVERLAYS];
|
|
struct mgr_priv_data mgr_priv_data_array[MAX_DSS_MANAGERS];
|
|
|
|
bool irq_enabled;
|
|
} dss_data;
|
|
|
|
/* protects dss_data */
|
|
static DEFINE_SPINLOCK(data_lock);
|
|
/* lock for blocking functions */
|
|
static DEFINE_MUTEX(apply_lock);
|
|
static DECLARE_COMPLETION(extra_updated_completion);
|
|
|
|
static void dss_register_vsync_isr(void);
|
|
|
|
static struct ovl_priv_data *get_ovl_priv(struct omap_overlay *ovl)
|
|
{
|
|
return &dss_data.ovl_priv_data_array[ovl->id];
|
|
}
|
|
|
|
static struct mgr_priv_data *get_mgr_priv(struct omap_overlay_manager *mgr)
|
|
{
|
|
return &dss_data.mgr_priv_data_array[mgr->id];
|
|
}
|
|
|
|
static void apply_init_priv(void)
|
|
{
|
|
const int num_ovls = dss_feat_get_num_ovls();
|
|
struct mgr_priv_data *mp;
|
|
int i;
|
|
|
|
for (i = 0; i < num_ovls; ++i) {
|
|
struct ovl_priv_data *op;
|
|
|
|
op = &dss_data.ovl_priv_data_array[i];
|
|
|
|
op->info.color_mode = OMAP_DSS_COLOR_RGB16;
|
|
op->info.rotation_type = OMAP_DSS_ROT_DMA;
|
|
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Initialize some of the lcd_config fields for TV manager, this lets
|
|
* us prevent checking if the manager is LCD or TV at some places
|
|
*/
|
|
mp = &dss_data.mgr_priv_data_array[OMAP_DSS_CHANNEL_DIGIT];
|
|
|
|
mp->lcd_config.video_port_width = 24;
|
|
mp->lcd_config.clock_info.lck_div = 1;
|
|
mp->lcd_config.clock_info.pck_div = 1;
|
|
}
|
|
|
|
/*
|
|
* A LCD manager's stallmode decides whether it is in manual or auto update. TV
|
|
* manager is always auto update, stallmode field for TV manager is false by
|
|
* default
|
|
*/
|
|
static bool ovl_manual_update(struct omap_overlay *ovl)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(ovl->manager);
|
|
|
|
return mp->lcd_config.stallmode;
|
|
}
|
|
|
|
static bool mgr_manual_update(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
return mp->lcd_config.stallmode;
|
|
}
|
|
|
|
static int dss_check_settings_low(struct omap_overlay_manager *mgr,
|
|
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 (!mp->enabled)
|
|
return 0;
|
|
|
|
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);
|
|
|
|
if (!op->enabled && !op->enabling)
|
|
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, mi, &mp->timings, &mp->lcd_config, ois);
|
|
}
|
|
|
|
/*
|
|
* check manager and overlay settings using overlay_info from data->info
|
|
*/
|
|
static int dss_check_settings(struct omap_overlay_manager *mgr)
|
|
{
|
|
return dss_check_settings_low(mgr, 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)
|
|
{
|
|
return dss_check_settings_low(mgr, true);
|
|
}
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
/* to write new values to registers */
|
|
if (mp->info_dirty)
|
|
return true;
|
|
|
|
/* to set GO bit */
|
|
if (mp->shadow_info_dirty)
|
|
return true;
|
|
|
|
/*
|
|
* NOTE: we don't check extra_info flags for disabled
|
|
* managers, once the manager is enabled, the extra_info
|
|
* related manager changes will be taken in by HW.
|
|
*/
|
|
|
|
/* to write new values to registers */
|
|
if (mp->extra_info_dirty)
|
|
return true;
|
|
|
|
/* to set GO bit */
|
|
if (mp->shadow_extra_info_dirty)
|
|
return true;
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
struct ovl_priv_data *op;
|
|
|
|
op = get_ovl_priv(ovl);
|
|
|
|
/*
|
|
* 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;
|
|
|
|
if (!op->enabled)
|
|
continue;
|
|
|
|
/* to write new values to registers */
|
|
if (op->info_dirty)
|
|
return true;
|
|
|
|
/* to set GO bit */
|
|
if (op->shadow_info_dirty)
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
|
|
if (mp->shadow_info_dirty || mp->shadow_extra_info_dirty)
|
|
return true;
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
op = get_ovl_priv(ovl);
|
|
if (op->shadow_info_dirty || op->shadow_extra_info_dirty)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/* returns true if an extra_info field is currently being updated */
|
|
static bool extra_info_update_ongoing(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 omap_overlay *ovl;
|
|
struct mgr_priv_data *mp;
|
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
if (!mp->enabled)
|
|
continue;
|
|
|
|
if (!mp->updating)
|
|
continue;
|
|
|
|
if (mp->extra_info_dirty || mp->shadow_extra_info_dirty)
|
|
return true;
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
|
|
if (op->extra_info_dirty || op->shadow_extra_info_dirty)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
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;
|
|
int r;
|
|
|
|
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);
|
|
r = wait_for_completion_timeout(&extra_updated_completion, t);
|
|
if (r == 0)
|
|
DSSWARN("timeout in wait_pending_extra_info_updates\n");
|
|
}
|
|
|
|
static struct omap_dss_device *dss_mgr_get_device(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct omap_dss_device *dssdev;
|
|
|
|
dssdev = mgr->output;
|
|
if (dssdev == NULL)
|
|
return NULL;
|
|
|
|
while (dssdev->dst)
|
|
dssdev = dssdev->dst;
|
|
|
|
if (dssdev->driver)
|
|
return dssdev;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
static struct omap_dss_device *dss_ovl_get_device(struct omap_overlay *ovl)
|
|
{
|
|
return ovl->manager ? dss_mgr_get_device(ovl->manager) : NULL;
|
|
}
|
|
|
|
static int dss_mgr_wait_for_vsync(struct omap_overlay_manager *mgr)
|
|
{
|
|
unsigned long timeout = msecs_to_jiffies(500);
|
|
u32 irq;
|
|
int r;
|
|
|
|
if (mgr->output == NULL)
|
|
return -ENODEV;
|
|
|
|
r = dispc_runtime_get();
|
|
if (r)
|
|
return r;
|
|
|
|
switch (mgr->output->id) {
|
|
case OMAP_DSS_OUTPUT_VENC:
|
|
irq = DISPC_IRQ_EVSYNC_ODD;
|
|
break;
|
|
case OMAP_DSS_OUTPUT_HDMI:
|
|
irq = DISPC_IRQ_EVSYNC_EVEN;
|
|
break;
|
|
default:
|
|
irq = dispc_mgr_get_vsync_irq(mgr->id);
|
|
break;
|
|
}
|
|
|
|
r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
|
|
|
|
dispc_runtime_put();
|
|
|
|
return r;
|
|
}
|
|
|
|
static int dss_mgr_wait_for_go(struct omap_overlay_manager *mgr)
|
|
{
|
|
unsigned long timeout = msecs_to_jiffies(500);
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
u32 irq;
|
|
unsigned long flags;
|
|
int r;
|
|
int i;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
if (mgr_manual_update(mgr)) {
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
return 0;
|
|
}
|
|
|
|
if (!mp->enabled) {
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
return 0;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
r = dispc_runtime_get();
|
|
if (r)
|
|
return r;
|
|
|
|
irq = dispc_mgr_get_vsync_irq(mgr->id);
|
|
|
|
i = 0;
|
|
while (1) {
|
|
bool shadow_dirty, dirty;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
dirty = mp->info_dirty;
|
|
shadow_dirty = mp->shadow_info_dirty;
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
dispc_runtime_put();
|
|
|
|
return r;
|
|
}
|
|
|
|
static int dss_mgr_wait_for_go_ovl(struct omap_overlay *ovl)
|
|
{
|
|
unsigned long timeout = msecs_to_jiffies(500);
|
|
struct ovl_priv_data *op;
|
|
struct mgr_priv_data *mp;
|
|
u32 irq;
|
|
unsigned long flags;
|
|
int r;
|
|
int i;
|
|
|
|
if (!ovl->manager)
|
|
return 0;
|
|
|
|
mp = get_mgr_priv(ovl->manager);
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
if (ovl_manual_update(ovl)) {
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
return 0;
|
|
}
|
|
|
|
if (!mp->enabled) {
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
return 0;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
r = dispc_runtime_get();
|
|
if (r)
|
|
return r;
|
|
|
|
irq = dispc_mgr_get_vsync_irq(ovl->manager->id);
|
|
|
|
op = get_ovl_priv(ovl);
|
|
i = 0;
|
|
while (1) {
|
|
bool shadow_dirty, dirty;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
dirty = op->info_dirty;
|
|
shadow_dirty = op->shadow_info_dirty;
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
dispc_runtime_put();
|
|
|
|
return r;
|
|
}
|
|
|
|
static void dss_ovl_write_regs(struct omap_overlay *ovl)
|
|
{
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
struct omap_overlay_info *oi;
|
|
bool replication;
|
|
struct mgr_priv_data *mp;
|
|
int r;
|
|
|
|
DSSDBG("writing ovl %d regs\n", ovl->id);
|
|
|
|
if (!op->enabled || !op->info_dirty)
|
|
return;
|
|
|
|
oi = &op->info;
|
|
|
|
mp = get_mgr_priv(ovl->manager);
|
|
|
|
replication = dss_ovl_use_replication(mp->lcd_config, oi->color_mode);
|
|
|
|
r = dispc_ovl_setup(ovl->id, oi, replication, &mp->timings, false);
|
|
if (r) {
|
|
/*
|
|
* We can't do much here, as this function can be called from
|
|
* vsync interrupt.
|
|
*/
|
|
DSSERR("dispc_ovl_setup failed for ovl %d\n", ovl->id);
|
|
|
|
/* This will leave fifo configurations in a nonoptimal state */
|
|
op->enabled = false;
|
|
dispc_ovl_enable(ovl->id, false);
|
|
return;
|
|
}
|
|
|
|
op->info_dirty = false;
|
|
if (mp->updating)
|
|
op->shadow_info_dirty = true;
|
|
}
|
|
|
|
static void dss_ovl_write_regs_extra(struct omap_overlay *ovl)
|
|
{
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
struct mgr_priv_data *mp;
|
|
|
|
DSSDBG("writing ovl %d regs extra\n", ovl->id);
|
|
|
|
if (!op->extra_info_dirty)
|
|
return;
|
|
|
|
/* note: write also when op->enabled == false, so that the ovl gets
|
|
* disabled */
|
|
|
|
dispc_ovl_enable(ovl->id, op->enabled);
|
|
dispc_ovl_set_fifo_threshold(ovl->id, op->fifo_low, op->fifo_high);
|
|
|
|
mp = get_mgr_priv(ovl->manager);
|
|
|
|
op->extra_info_dirty = false;
|
|
if (mp->updating)
|
|
op->shadow_extra_info_dirty = true;
|
|
}
|
|
|
|
static void dss_mgr_write_regs(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
struct omap_overlay *ovl;
|
|
|
|
DSSDBG("writing mgr %d regs\n", mgr->id);
|
|
|
|
if (!mp->enabled)
|
|
return;
|
|
|
|
WARN_ON(mp->busy);
|
|
|
|
/* Commit overlay settings */
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
dss_ovl_write_regs(ovl);
|
|
dss_ovl_write_regs_extra(ovl);
|
|
}
|
|
|
|
if (mp->info_dirty) {
|
|
dispc_mgr_setup(mgr->id, &mp->info);
|
|
|
|
mp->info_dirty = false;
|
|
if (mp->updating)
|
|
mp->shadow_info_dirty = true;
|
|
}
|
|
}
|
|
|
|
static void dss_mgr_write_regs_extra(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
DSSDBG("writing mgr %d regs extra\n", mgr->id);
|
|
|
|
if (!mp->extra_info_dirty)
|
|
return;
|
|
|
|
dispc_mgr_set_timings(mgr->id, &mp->timings);
|
|
|
|
/* lcd_config parameters */
|
|
if (dss_mgr_is_lcd(mgr->id))
|
|
dispc_mgr_set_lcd_config(mgr->id, &mp->lcd_config);
|
|
|
|
mp->extra_info_dirty = false;
|
|
if (mp->updating)
|
|
mp->shadow_extra_info_dirty = true;
|
|
}
|
|
|
|
static void dss_write_regs(void)
|
|
{
|
|
const int num_mgrs = omap_dss_get_num_overlay_managers();
|
|
int i;
|
|
|
|
for (i = 0; i < num_mgrs; ++i) {
|
|
struct omap_overlay_manager *mgr;
|
|
struct mgr_priv_data *mp;
|
|
int r;
|
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
if (!mp->enabled || mgr_manual_update(mgr) || mp->busy)
|
|
continue;
|
|
|
|
r = dss_check_settings(mgr);
|
|
if (r) {
|
|
DSSERR("cannot write registers for manager %s: "
|
|
"illegal configuration\n", mgr->name);
|
|
continue;
|
|
}
|
|
|
|
dss_mgr_write_regs(mgr);
|
|
dss_mgr_write_regs_extra(mgr);
|
|
}
|
|
}
|
|
|
|
static void dss_set_go_bits(void)
|
|
{
|
|
const int num_mgrs = omap_dss_get_num_overlay_managers();
|
|
int i;
|
|
|
|
for (i = 0; i < num_mgrs; ++i) {
|
|
struct omap_overlay_manager *mgr;
|
|
struct mgr_priv_data *mp;
|
|
|
|
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);
|
|
}
|
|
|
|
}
|
|
|
|
static void mgr_clear_shadow_dirty(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct omap_overlay *ovl;
|
|
struct mgr_priv_data *mp;
|
|
struct ovl_priv_data *op;
|
|
|
|
mp = get_mgr_priv(mgr);
|
|
mp->shadow_info_dirty = false;
|
|
mp->shadow_extra_info_dirty = false;
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list) {
|
|
op = get_ovl_priv(ovl);
|
|
op->shadow_info_dirty = false;
|
|
op->shadow_extra_info_dirty = false;
|
|
}
|
|
}
|
|
|
|
static int dss_mgr_connect_compat(struct omap_overlay_manager *mgr,
|
|
struct omap_dss_device *dst)
|
|
{
|
|
return mgr->set_output(mgr, dst);
|
|
}
|
|
|
|
static void dss_mgr_disconnect_compat(struct omap_overlay_manager *mgr,
|
|
struct omap_dss_device *dst)
|
|
{
|
|
mgr->unset_output(mgr);
|
|
}
|
|
|
|
static void dss_mgr_start_update_compat(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
unsigned long flags;
|
|
int r;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
WARN_ON(mp->updating);
|
|
|
|
r = dss_check_settings(mgr);
|
|
if (r) {
|
|
DSSERR("cannot start manual update: illegal configuration\n");
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
return;
|
|
}
|
|
|
|
dss_mgr_write_regs(mgr);
|
|
dss_mgr_write_regs_extra(mgr);
|
|
|
|
mp->updating = true;
|
|
|
|
if (!dss_data.irq_enabled && need_isr())
|
|
dss_register_vsync_isr();
|
|
|
|
dispc_mgr_enable_sync(mgr->id);
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
}
|
|
|
|
static void dss_apply_irq_handler(void *data, u32 mask);
|
|
|
|
static void dss_register_vsync_isr(void)
|
|
{
|
|
const int num_mgrs = dss_feat_get_num_mgrs();
|
|
u32 mask;
|
|
int r, i;
|
|
|
|
mask = 0;
|
|
for (i = 0; i < num_mgrs; ++i)
|
|
mask |= dispc_mgr_get_vsync_irq(i);
|
|
|
|
for (i = 0; i < num_mgrs; ++i)
|
|
mask |= dispc_mgr_get_framedone_irq(i);
|
|
|
|
r = omap_dispc_register_isr(dss_apply_irq_handler, NULL, mask);
|
|
WARN_ON(r);
|
|
|
|
dss_data.irq_enabled = true;
|
|
}
|
|
|
|
static void dss_unregister_vsync_isr(void)
|
|
{
|
|
const int num_mgrs = dss_feat_get_num_mgrs();
|
|
u32 mask;
|
|
int r, i;
|
|
|
|
mask = 0;
|
|
for (i = 0; i < num_mgrs; ++i)
|
|
mask |= dispc_mgr_get_vsync_irq(i);
|
|
|
|
for (i = 0; i < num_mgrs; ++i)
|
|
mask |= dispc_mgr_get_framedone_irq(i);
|
|
|
|
r = omap_dispc_unregister_isr(dss_apply_irq_handler, NULL, mask);
|
|
WARN_ON(r);
|
|
|
|
dss_data.irq_enabled = false;
|
|
}
|
|
|
|
static void dss_apply_irq_handler(void *data, u32 mask)
|
|
{
|
|
const int num_mgrs = dss_feat_get_num_mgrs();
|
|
int i;
|
|
bool extra_updating;
|
|
|
|
spin_lock(&data_lock);
|
|
|
|
/* clear busy, updating flags, shadow_dirty flags */
|
|
for (i = 0; i < num_mgrs; i++) {
|
|
struct omap_overlay_manager *mgr;
|
|
struct mgr_priv_data *mp;
|
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
if (!mp->enabled)
|
|
continue;
|
|
|
|
mp->updating = dispc_mgr_is_enabled(i);
|
|
|
|
if (!mgr_manual_update(mgr)) {
|
|
bool was_busy = mp->busy;
|
|
mp->busy = dispc_mgr_go_busy(i);
|
|
|
|
if (was_busy && !mp->busy)
|
|
mgr_clear_shadow_dirty(mgr);
|
|
}
|
|
}
|
|
|
|
dss_write_regs();
|
|
dss_set_go_bits();
|
|
|
|
extra_updating = extra_info_update_ongoing();
|
|
if (!extra_updating)
|
|
complete_all(&extra_updated_completion);
|
|
|
|
/* call framedone handlers for manual update displays */
|
|
for (i = 0; i < num_mgrs; i++) {
|
|
struct omap_overlay_manager *mgr;
|
|
struct mgr_priv_data *mp;
|
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
if (!mgr_manual_update(mgr) || !mp->framedone_handler)
|
|
continue;
|
|
|
|
if (mask & dispc_mgr_get_framedone_irq(i))
|
|
mp->framedone_handler(mp->framedone_handler_data);
|
|
}
|
|
|
|
if (!need_isr())
|
|
dss_unregister_vsync_isr();
|
|
|
|
spin_unlock(&data_lock);
|
|
}
|
|
|
|
static void omap_dss_mgr_apply_ovl(struct omap_overlay *ovl)
|
|
{
|
|
struct ovl_priv_data *op;
|
|
|
|
op = get_ovl_priv(ovl);
|
|
|
|
if (!op->user_info_dirty)
|
|
return;
|
|
|
|
op->user_info_dirty = false;
|
|
op->info_dirty = true;
|
|
op->info = op->user_info;
|
|
}
|
|
|
|
static void omap_dss_mgr_apply_mgr(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct mgr_priv_data *mp;
|
|
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
if (!mp->user_info_dirty)
|
|
return;
|
|
|
|
mp->user_info_dirty = false;
|
|
mp->info_dirty = true;
|
|
mp->info = mp->user_info;
|
|
}
|
|
|
|
static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
|
|
{
|
|
unsigned long flags;
|
|
struct omap_overlay *ovl;
|
|
int r;
|
|
|
|
DSSDBG("omap_dss_mgr_apply(%s)\n", mgr->name);
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
r = dss_check_settings_apply(mgr);
|
|
if (r) {
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
DSSERR("failed to apply settings: illegal configuration.\n");
|
|
return r;
|
|
}
|
|
|
|
/* 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();
|
|
dss_set_go_bits();
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static void dss_apply_ovl_fifo_thresholds(struct omap_overlay *ovl,
|
|
u32 fifo_low, u32 fifo_high)
|
|
{
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
|
|
if (op->fifo_low == fifo_low && op->fifo_high == fifo_high)
|
|
return;
|
|
|
|
op->fifo_low = fifo_low;
|
|
op->fifo_high = fifo_high;
|
|
op->extra_info_dirty = true;
|
|
}
|
|
|
|
static void dss_ovl_setup_fifo(struct omap_overlay *ovl)
|
|
{
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
u32 fifo_low, fifo_high;
|
|
bool use_fifo_merge = false;
|
|
|
|
if (!op->enabled && !op->enabling)
|
|
return;
|
|
|
|
dispc_ovl_compute_fifo_thresholds(ovl->id, &fifo_low, &fifo_high,
|
|
use_fifo_merge, ovl_manual_update(ovl));
|
|
|
|
dss_apply_ovl_fifo_thresholds(ovl, fifo_low, fifo_high);
|
|
}
|
|
|
|
static void dss_mgr_setup_fifos(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct omap_overlay *ovl;
|
|
struct mgr_priv_data *mp;
|
|
|
|
mp = get_mgr_priv(mgr);
|
|
|
|
if (!mp->enabled)
|
|
return;
|
|
|
|
list_for_each_entry(ovl, &mgr->overlays, list)
|
|
dss_ovl_setup_fifo(ovl);
|
|
}
|
|
|
|
static void dss_setup_fifos(void)
|
|
{
|
|
const int num_mgrs = omap_dss_get_num_overlay_managers();
|
|
struct omap_overlay_manager *mgr;
|
|
int i;
|
|
|
|
for (i = 0; i < num_mgrs; ++i) {
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
dss_mgr_setup_fifos(mgr);
|
|
}
|
|
}
|
|
|
|
static int dss_mgr_enable_compat(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
unsigned long flags;
|
|
int r;
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
if (mp->enabled)
|
|
goto out;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
mp->enabled = true;
|
|
|
|
r = dss_check_settings(mgr);
|
|
if (r) {
|
|
DSSERR("failed to enable manager %d: check_settings failed\n",
|
|
mgr->id);
|
|
goto err;
|
|
}
|
|
|
|
dss_setup_fifos();
|
|
|
|
dss_write_regs();
|
|
dss_set_go_bits();
|
|
|
|
if (!mgr_manual_update(mgr))
|
|
mp->updating = true;
|
|
|
|
if (!dss_data.irq_enabled && need_isr())
|
|
dss_register_vsync_isr();
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
if (!mgr_manual_update(mgr))
|
|
dispc_mgr_enable_sync(mgr->id);
|
|
|
|
out:
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return 0;
|
|
|
|
err:
|
|
mp->enabled = false;
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
mutex_unlock(&apply_lock);
|
|
return r;
|
|
}
|
|
|
|
static void dss_mgr_disable_compat(struct omap_overlay_manager *mgr)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
unsigned long flags;
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
if (!mp->enabled)
|
|
goto out;
|
|
|
|
wait_pending_extra_info_updates();
|
|
|
|
if (!mgr_manual_update(mgr))
|
|
dispc_mgr_disable_sync(mgr->id);
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
mp->updating = false;
|
|
mp->enabled = false;
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
out:
|
|
mutex_unlock(&apply_lock);
|
|
}
|
|
|
|
static int dss_mgr_set_info(struct omap_overlay_manager *mgr,
|
|
struct omap_overlay_manager_info *info)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
unsigned long flags;
|
|
int r;
|
|
|
|
r = dss_mgr_simple_check(mgr, info);
|
|
if (r)
|
|
return r;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
mp->user_info = *info;
|
|
mp->user_info_dirty = true;
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void dss_mgr_get_info(struct omap_overlay_manager *mgr,
|
|
struct omap_overlay_manager_info *info)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
*info = mp->user_info;
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
}
|
|
|
|
static int dss_mgr_set_output(struct omap_overlay_manager *mgr,
|
|
struct omap_dss_device *output)
|
|
{
|
|
int r;
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
if (mgr->output) {
|
|
DSSERR("manager %s is already connected to an output\n",
|
|
mgr->name);
|
|
r = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
if ((mgr->supported_outputs & output->id) == 0) {
|
|
DSSERR("output does not support manager %s\n",
|
|
mgr->name);
|
|
r = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
output->manager = mgr;
|
|
mgr->output = output;
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return 0;
|
|
err:
|
|
mutex_unlock(&apply_lock);
|
|
return r;
|
|
}
|
|
|
|
static int dss_mgr_unset_output(struct omap_overlay_manager *mgr)
|
|
{
|
|
int r;
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
unsigned long flags;
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
if (!mgr->output) {
|
|
DSSERR("failed to unset output, output not set\n");
|
|
r = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
if (mp->enabled) {
|
|
DSSERR("output can't be unset when manager is enabled\n");
|
|
r = -EINVAL;
|
|
goto err1;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
mgr->output->manager = NULL;
|
|
mgr->output = NULL;
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return 0;
|
|
err1:
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
err:
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return r;
|
|
}
|
|
|
|
static void dss_apply_mgr_timings(struct omap_overlay_manager *mgr,
|
|
const struct omap_video_timings *timings)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
mp->timings = *timings;
|
|
mp->extra_info_dirty = true;
|
|
}
|
|
|
|
static void dss_mgr_set_timings_compat(struct omap_overlay_manager *mgr,
|
|
const struct omap_video_timings *timings)
|
|
{
|
|
unsigned long flags;
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
if (mp->updating) {
|
|
DSSERR("cannot set timings for %s: manager needs to be disabled\n",
|
|
mgr->name);
|
|
goto out;
|
|
}
|
|
|
|
dss_apply_mgr_timings(mgr, timings);
|
|
out:
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
}
|
|
|
|
static void dss_apply_mgr_lcd_config(struct omap_overlay_manager *mgr,
|
|
const struct dss_lcd_mgr_config *config)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
mp->lcd_config = *config;
|
|
mp->extra_info_dirty = true;
|
|
}
|
|
|
|
static void dss_mgr_set_lcd_config_compat(struct omap_overlay_manager *mgr,
|
|
const struct dss_lcd_mgr_config *config)
|
|
{
|
|
unsigned long flags;
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
if (mp->enabled) {
|
|
DSSERR("cannot apply lcd config for %s: manager needs to be disabled\n",
|
|
mgr->name);
|
|
goto out;
|
|
}
|
|
|
|
dss_apply_mgr_lcd_config(mgr, config);
|
|
out:
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
}
|
|
|
|
static int dss_ovl_set_info(struct omap_overlay *ovl,
|
|
struct omap_overlay_info *info)
|
|
{
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
unsigned long flags;
|
|
int r;
|
|
|
|
r = dss_ovl_simple_check(ovl, info);
|
|
if (r)
|
|
return r;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
op->user_info = *info;
|
|
op->user_info_dirty = true;
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void dss_ovl_get_info(struct omap_overlay *ovl,
|
|
struct omap_overlay_info *info)
|
|
{
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
*info = op->user_info;
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
}
|
|
|
|
static int dss_ovl_set_manager(struct omap_overlay *ovl,
|
|
struct omap_overlay_manager *mgr)
|
|
{
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
unsigned long flags;
|
|
int r;
|
|
|
|
if (!mgr)
|
|
return -EINVAL;
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
if (ovl->manager) {
|
|
DSSERR("overlay '%s' already has a manager '%s'\n",
|
|
ovl->name, ovl->manager->name);
|
|
r = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
r = dispc_runtime_get();
|
|
if (r)
|
|
goto err;
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
if (op->enabled) {
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
DSSERR("overlay has to be disabled to change the manager\n");
|
|
r = -EINVAL;
|
|
goto err1;
|
|
}
|
|
|
|
dispc_ovl_set_channel_out(ovl->id, mgr->id);
|
|
|
|
ovl->manager = mgr;
|
|
list_add_tail(&ovl->list, &mgr->overlays);
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
dispc_runtime_put();
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return 0;
|
|
|
|
err1:
|
|
dispc_runtime_put();
|
|
err:
|
|
mutex_unlock(&apply_lock);
|
|
return r;
|
|
}
|
|
|
|
static int dss_ovl_unset_manager(struct omap_overlay *ovl)
|
|
{
|
|
struct ovl_priv_data *op = get_ovl_priv(ovl);
|
|
unsigned long flags;
|
|
int r;
|
|
|
|
mutex_lock(&apply_lock);
|
|
|
|
if (!ovl->manager) {
|
|
DSSERR("failed to detach overlay: manager not set\n");
|
|
r = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
if (op->enabled) {
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
DSSERR("overlay has to be disabled to unset the manager\n");
|
|
r = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
/* wait for pending extra_info updates to ensure the ovl is disabled */
|
|
wait_pending_extra_info_updates();
|
|
|
|
/*
|
|
* For a manual update display, there is no guarantee that the overlay
|
|
* is really disabled in HW, we may need an extra update from this
|
|
* manager before the configurations can go in. Return an error if the
|
|
* overlay needed an update from the manager.
|
|
*
|
|
* TODO: Instead of returning an error, try to do a dummy manager update
|
|
* here to disable the overlay in hardware. Use the *GATED fields in
|
|
* the DISPC_CONFIG registers to do a dummy update.
|
|
*/
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
if (ovl_manual_update(ovl) && op->extra_info_dirty) {
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
DSSERR("need an update to change the manager\n");
|
|
r = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
ovl->manager = NULL;
|
|
list_del(&ovl->list);
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return 0;
|
|
err:
|
|
mutex_unlock(&apply_lock);
|
|
return r;
|
|
}
|
|
|
|
static 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;
|
|
}
|
|
|
|
static 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);
|
|
|
|
if (op->enabled) {
|
|
r = 0;
|
|
goto err1;
|
|
}
|
|
|
|
if (ovl->manager == NULL || ovl->manager->output == NULL) {
|
|
r = -EINVAL;
|
|
goto err1;
|
|
}
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
op->enabling = true;
|
|
|
|
r = dss_check_settings(ovl->manager);
|
|
if (r) {
|
|
DSSERR("failed to enable overlay %d: check_settings failed\n",
|
|
ovl->id);
|
|
goto err2;
|
|
}
|
|
|
|
dss_setup_fifos();
|
|
|
|
op->enabling = false;
|
|
dss_apply_ovl_enable(ovl, true);
|
|
|
|
dss_write_regs();
|
|
dss_set_go_bits();
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return 0;
|
|
err2:
|
|
op->enabling = false;
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
err1:
|
|
mutex_unlock(&apply_lock);
|
|
return r;
|
|
}
|
|
|
|
static 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);
|
|
|
|
if (!op->enabled) {
|
|
r = 0;
|
|
goto err;
|
|
}
|
|
|
|
if (ovl->manager == NULL || ovl->manager->output == NULL) {
|
|
r = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
spin_lock_irqsave(&data_lock, flags);
|
|
|
|
dss_apply_ovl_enable(ovl, false);
|
|
dss_write_regs();
|
|
dss_set_go_bits();
|
|
|
|
spin_unlock_irqrestore(&data_lock, flags);
|
|
|
|
mutex_unlock(&apply_lock);
|
|
|
|
return 0;
|
|
|
|
err:
|
|
mutex_unlock(&apply_lock);
|
|
return r;
|
|
}
|
|
|
|
static int dss_mgr_register_framedone_handler_compat(struct omap_overlay_manager *mgr,
|
|
void (*handler)(void *), void *data)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
if (mp->framedone_handler)
|
|
return -EBUSY;
|
|
|
|
mp->framedone_handler = handler;
|
|
mp->framedone_handler_data = data;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void dss_mgr_unregister_framedone_handler_compat(struct omap_overlay_manager *mgr,
|
|
void (*handler)(void *), void *data)
|
|
{
|
|
struct mgr_priv_data *mp = get_mgr_priv(mgr);
|
|
|
|
WARN_ON(mp->framedone_handler != handler ||
|
|
mp->framedone_handler_data != data);
|
|
|
|
mp->framedone_handler = NULL;
|
|
mp->framedone_handler_data = NULL;
|
|
}
|
|
|
|
static const struct dss_mgr_ops apply_mgr_ops = {
|
|
.connect = dss_mgr_connect_compat,
|
|
.disconnect = dss_mgr_disconnect_compat,
|
|
.start_update = dss_mgr_start_update_compat,
|
|
.enable = dss_mgr_enable_compat,
|
|
.disable = dss_mgr_disable_compat,
|
|
.set_timings = dss_mgr_set_timings_compat,
|
|
.set_lcd_config = dss_mgr_set_lcd_config_compat,
|
|
.register_framedone_handler = dss_mgr_register_framedone_handler_compat,
|
|
.unregister_framedone_handler = dss_mgr_unregister_framedone_handler_compat,
|
|
};
|
|
|
|
static int compat_refcnt;
|
|
static DEFINE_MUTEX(compat_init_lock);
|
|
|
|
int omapdss_compat_init(void)
|
|
{
|
|
struct platform_device *pdev = dss_get_core_pdev();
|
|
int i, r;
|
|
|
|
mutex_lock(&compat_init_lock);
|
|
|
|
if (compat_refcnt++ > 0)
|
|
goto out;
|
|
|
|
apply_init_priv();
|
|
|
|
dss_init_overlay_managers_sysfs(pdev);
|
|
dss_init_overlays(pdev);
|
|
|
|
for (i = 0; i < omap_dss_get_num_overlay_managers(); i++) {
|
|
struct omap_overlay_manager *mgr;
|
|
|
|
mgr = omap_dss_get_overlay_manager(i);
|
|
|
|
mgr->set_output = &dss_mgr_set_output;
|
|
mgr->unset_output = &dss_mgr_unset_output;
|
|
mgr->apply = &omap_dss_mgr_apply;
|
|
mgr->set_manager_info = &dss_mgr_set_info;
|
|
mgr->get_manager_info = &dss_mgr_get_info;
|
|
mgr->wait_for_go = &dss_mgr_wait_for_go;
|
|
mgr->wait_for_vsync = &dss_mgr_wait_for_vsync;
|
|
mgr->get_device = &dss_mgr_get_device;
|
|
}
|
|
|
|
for (i = 0; i < omap_dss_get_num_overlays(); i++) {
|
|
struct omap_overlay *ovl = omap_dss_get_overlay(i);
|
|
|
|
ovl->is_enabled = &dss_ovl_is_enabled;
|
|
ovl->enable = &dss_ovl_enable;
|
|
ovl->disable = &dss_ovl_disable;
|
|
ovl->set_manager = &dss_ovl_set_manager;
|
|
ovl->unset_manager = &dss_ovl_unset_manager;
|
|
ovl->set_overlay_info = &dss_ovl_set_info;
|
|
ovl->get_overlay_info = &dss_ovl_get_info;
|
|
ovl->wait_for_go = &dss_mgr_wait_for_go_ovl;
|
|
ovl->get_device = &dss_ovl_get_device;
|
|
}
|
|
|
|
r = dss_install_mgr_ops(&apply_mgr_ops);
|
|
if (r)
|
|
goto err_mgr_ops;
|
|
|
|
r = display_init_sysfs(pdev);
|
|
if (r)
|
|
goto err_disp_sysfs;
|
|
|
|
dispc_runtime_get();
|
|
|
|
r = dss_dispc_initialize_irq();
|
|
if (r)
|
|
goto err_init_irq;
|
|
|
|
dispc_runtime_put();
|
|
|
|
out:
|
|
mutex_unlock(&compat_init_lock);
|
|
|
|
return 0;
|
|
|
|
err_init_irq:
|
|
dispc_runtime_put();
|
|
display_uninit_sysfs(pdev);
|
|
|
|
err_disp_sysfs:
|
|
dss_uninstall_mgr_ops();
|
|
|
|
err_mgr_ops:
|
|
dss_uninit_overlay_managers_sysfs(pdev);
|
|
dss_uninit_overlays(pdev);
|
|
|
|
compat_refcnt--;
|
|
|
|
mutex_unlock(&compat_init_lock);
|
|
|
|
return r;
|
|
}
|
|
EXPORT_SYMBOL(omapdss_compat_init);
|
|
|
|
void omapdss_compat_uninit(void)
|
|
{
|
|
struct platform_device *pdev = dss_get_core_pdev();
|
|
|
|
mutex_lock(&compat_init_lock);
|
|
|
|
if (--compat_refcnt > 0)
|
|
goto out;
|
|
|
|
dss_dispc_uninitialize_irq();
|
|
|
|
display_uninit_sysfs(pdev);
|
|
|
|
dss_uninstall_mgr_ops();
|
|
|
|
dss_uninit_overlay_managers_sysfs(pdev);
|
|
dss_uninit_overlays(pdev);
|
|
out:
|
|
mutex_unlock(&compat_init_lock);
|
|
}
|
|
EXPORT_SYMBOL(omapdss_compat_uninit);
|