* this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <linux/completion.h>
+
#include "omap_drv.h"
#include <drm/drm_mode.h>
struct omap_video_timings timings;
bool enabled;
- struct omap_drm_apply apply;
-
- struct omap_drm_irq apply_irq;
+ struct omap_drm_irq vblank_irq;
struct omap_drm_irq error_irq;
- /* list of in-progress apply's: */
- struct list_head pending_applies;
-
- /* list of queued apply's: */
- struct list_head queued_applies;
-
- /* for handling queued and in-progress applies: */
- struct work_struct apply_work;
+ /* list of framebuffers to unpin */
+ struct list_head pending_unpins;
/* if there is a pending flip, these will be non-null: */
struct drm_pending_vblank_event *event;
struct drm_framebuffer *old_fb;
+ struct completion completion;
+
/* for handling page flips without caring about what
* the callback is called from. Possibly we should just
* make omap_gem always call the cb from the worker so
* we don't have to care about this..
- *
- * XXX maybe fold into apply_work??
*/
struct work_struct page_flip_work;
bool ignore_digit_sync_lost;
};
+struct omap_framebuffer_unpin {
+ struct list_head list;
+ struct drm_framebuffer *fb;
+};
+
/* -----------------------------------------------------------------------------
* Helper Functions
*/
{
}
-/* Called only from CRTC pre_apply and suspend/resume handlers. */
+/* Called only from omap_crtc_setup and suspend/resume handlers. */
static void omap_crtc_set_enabled(struct drm_crtc *crtc, bool enable)
{
struct drm_device *dev = crtc->dev;
};
/* -----------------------------------------------------------------------------
- * Apply Logic
+ * Setup and Flush
*/
static void omap_crtc_error_irq(struct omap_drm_irq *irq, uint32_t irqstatus)
DRM_ERROR_RATELIMITED("%s: errors: %08x\n", omap_crtc->name, irqstatus);
}
-static void omap_crtc_apply_irq(struct omap_drm_irq *irq, uint32_t irqstatus)
+static void omap_crtc_vblank_irq(struct omap_drm_irq *irq, uint32_t irqstatus)
{
struct omap_crtc *omap_crtc =
- container_of(irq, struct omap_crtc, apply_irq);
- struct drm_crtc *crtc = &omap_crtc->base;
+ container_of(irq, struct omap_crtc, vblank_irq);
+ struct drm_device *dev = omap_crtc->base.dev;
+ unsigned long flags;
- if (!dispc_mgr_go_busy(omap_crtc->channel)) {
- struct omap_drm_private *priv =
- crtc->dev->dev_private;
- DBG("%s: apply done", omap_crtc->name);
- __omap_irq_unregister(crtc->dev, &omap_crtc->apply_irq);
- queue_work(priv->wq, &omap_crtc->apply_work);
- }
+ if (dispc_mgr_go_busy(omap_crtc->channel))
+ return;
+
+ DBG("%s: apply done", omap_crtc->name);
+ __omap_irq_unregister(dev, &omap_crtc->vblank_irq);
+
+ spin_lock_irqsave(&dev->event_lock, flags);
+
+ /* wakeup userspace */
+ if (omap_crtc->event)
+ drm_send_vblank_event(dev, omap_crtc->pipe, omap_crtc->event);
+
+ omap_crtc->event = NULL;
+ omap_crtc->old_fb = NULL;
+
+ spin_unlock_irqrestore(&dev->event_lock, flags);
+
+ complete(&omap_crtc->completion);
}
-static void apply_worker(struct work_struct *work)
+int omap_crtc_flush(struct drm_crtc *crtc)
{
- struct omap_crtc *omap_crtc =
- container_of(work, struct omap_crtc, apply_work);
- struct drm_crtc *crtc = &omap_crtc->base;
- struct drm_device *dev = crtc->dev;
- struct omap_drm_apply *apply, *n;
- bool need_apply;
+ struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
+ struct omap_framebuffer_unpin *fb, *next;
- /*
- * Synchronize everything on mode_config.mutex, to keep
- * the callbacks and list modification all serialized
- * with respect to modesetting ioctls from userspace.
- */
- drm_modeset_lock(&crtc->mutex, NULL);
- dispc_runtime_get();
+ DBG("%s: GO", omap_crtc->name);
- /*
- * If we are still pending a previous update, wait.. when the
- * pending update completes, we get kicked again.
- */
- if (omap_crtc->apply_irq.registered)
- goto out;
-
- /* finish up previous apply's: */
- list_for_each_entry_safe(apply, n,
- &omap_crtc->pending_applies, pending_node) {
- apply->post_apply(apply);
- list_del(&apply->pending_node);
- }
+ WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
+ WARN_ON(omap_crtc->vblank_irq.registered);
- need_apply = !list_empty(&omap_crtc->queued_applies);
+ dispc_runtime_get();
- /* then handle the next round of of queued apply's: */
- list_for_each_entry_safe(apply, n,
- &omap_crtc->queued_applies, queued_node) {
- apply->pre_apply(apply);
- list_del(&apply->queued_node);
- apply->queued = false;
- list_add_tail(&apply->pending_node,
- &omap_crtc->pending_applies);
- }
+ if (dispc_mgr_is_enabled(omap_crtc->channel)) {
+ dispc_mgr_go(omap_crtc->channel);
+ omap_irq_register(crtc->dev, &omap_crtc->vblank_irq);
- if (need_apply) {
- enum omap_channel channel = omap_crtc->channel;
+ WARN_ON(!wait_for_completion_timeout(&omap_crtc->completion,
+ msecs_to_jiffies(100)));
+ reinit_completion(&omap_crtc->completion);
+ }
- DBG("%s: GO", omap_crtc->name);
+ dispc_runtime_put();
- if (dispc_mgr_is_enabled(channel)) {
- dispc_mgr_go(channel);
- omap_irq_register(dev, &omap_crtc->apply_irq);
- } else {
- struct omap_drm_private *priv = dev->dev_private;
- queue_work(priv->wq, &omap_crtc->apply_work);
- }
+ /* Unpin and unreference pending framebuffers. */
+ list_for_each_entry_safe(fb, next, &omap_crtc->pending_unpins, list) {
+ omap_framebuffer_unpin(fb->fb);
+ drm_framebuffer_unreference(fb->fb);
+ list_del(&fb->list);
+ kfree(fb);
}
-out:
- dispc_runtime_put();
- drm_modeset_unlock(&crtc->mutex);
+ return 0;
}
-int omap_crtc_apply(struct drm_crtc *crtc,
- struct omap_drm_apply *apply)
+int omap_crtc_queue_unpin(struct drm_crtc *crtc, struct drm_framebuffer *fb)
{
struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
+ struct omap_framebuffer_unpin *unpin;
- WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
-
- /* no need to queue it again if it is already queued: */
- if (apply->queued)
- return 0;
-
- apply->queued = true;
- list_add_tail(&apply->queued_node, &omap_crtc->queued_applies);
+ unpin = kzalloc(sizeof(*unpin), GFP_KERNEL);
+ if (!unpin)
+ return -ENOMEM;
- /*
- * If there are no currently pending updates, then go ahead and
- * kick the worker immediately, otherwise it will run again when
- * the current update finishes.
- */
- if (list_empty(&omap_crtc->pending_applies)) {
- struct omap_drm_private *priv = crtc->dev->dev_private;
- queue_work(priv->wq, &omap_crtc->apply_work);
- }
+ unpin->fb = fb;
+ list_add_tail(&unpin->list, &omap_crtc->pending_unpins);
return 0;
}
-static void omap_crtc_pre_apply(struct omap_drm_apply *apply)
+static void omap_crtc_setup(struct drm_crtc *crtc)
{
- struct omap_crtc *omap_crtc =
- container_of(apply, struct omap_crtc, apply);
- struct drm_crtc *crtc = &omap_crtc->base;
+ struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
struct omap_drm_private *priv = crtc->dev->dev_private;
struct drm_encoder *encoder = NULL;
unsigned int i;
DBG("%s: enabled=%d", omap_crtc->name, omap_crtc->enabled);
+ dispc_runtime_get();
+
for (i = 0; i < priv->num_encoders; i++) {
if (priv->encoders[i]->crtc == crtc) {
encoder = priv->encoders[i];
omap_encoder_set_enabled(encoder, true);
}
}
-}
-
-static void omap_crtc_post_apply(struct omap_drm_apply *apply)
-{
- /* nothing needed for post-apply */
-}
-void omap_crtc_flush(struct drm_crtc *crtc)
-{
- struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
- int loops = 0;
-
- while (!list_empty(&omap_crtc->pending_applies) ||
- !list_empty(&omap_crtc->queued_applies) ||
- omap_crtc->event || omap_crtc->old_fb) {
-
- if (++loops > 10) {
- dev_err(crtc->dev->dev,
- "omap_crtc_flush() timeout\n");
- break;
- }
-
- schedule_timeout_uninterruptible(msecs_to_jiffies(20));
- }
+ dispc_runtime_put();
}
/* -----------------------------------------------------------------------------
DBG("%s", omap_crtc->name);
- WARN_ON(omap_crtc->apply_irq.registered);
+ WARN_ON(omap_crtc->vblank_irq.registered);
omap_irq_unregister(crtc->dev, &omap_crtc->error_irq);
drm_crtc_cleanup(crtc);
DBG("%s: %d", omap_crtc->name, mode);
- if (enabled != omap_crtc->enabled) {
- omap_crtc->enabled = enabled;
- omap_crtc_apply(crtc, &omap_crtc->apply);
+ if (enabled == omap_crtc->enabled)
+ return;
- /* Enable/disable all planes associated with the CRTC. */
- for (i = 0; i < priv->num_planes; i++) {
- struct drm_plane *plane = priv->planes[i];
- if (plane->crtc == crtc)
- WARN_ON(omap_plane_set_enable(plane, enabled));
- }
+ /* Enable/disable all planes associated with the CRTC. */
+ for (i = 0; i < priv->num_planes; i++) {
+ struct drm_plane *plane = priv->planes[i];
+
+ if (plane->crtc == crtc)
+ WARN_ON(omap_plane_set_enable(plane, enabled));
}
+
+ omap_crtc->enabled = enabled;
+
+ omap_crtc_setup(crtc);
+ omap_crtc_flush(crtc);
}
static bool omap_crtc_mode_fixup(struct drm_crtc *crtc,
return omap_plane_mode_set(crtc->primary, crtc, crtc->primary->fb,
0, 0, mode->hdisplay, mode->vdisplay,
- x, y, mode->hdisplay, mode->vdisplay,
- NULL, NULL);
+ x, y, mode->hdisplay, mode->vdisplay);
}
static void omap_crtc_prepare(struct drm_crtc *crtc)
{
struct drm_plane *plane = crtc->primary;
struct drm_display_mode *mode = &crtc->mode;
+ int ret;
- return omap_plane_mode_set(plane, crtc, crtc->primary->fb,
- 0, 0, mode->hdisplay, mode->vdisplay,
- x, y, mode->hdisplay, mode->vdisplay,
- NULL, NULL);
-}
-
-static void vblank_cb(void *arg)
-{
- struct drm_crtc *crtc = arg;
- struct drm_device *dev = crtc->dev;
- struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
- unsigned long flags;
- struct drm_framebuffer *fb;
-
- spin_lock_irqsave(&dev->event_lock, flags);
-
- /* wakeup userspace */
- if (omap_crtc->event)
- drm_send_vblank_event(dev, omap_crtc->pipe, omap_crtc->event);
-
- fb = omap_crtc->old_fb;
-
- omap_crtc->event = NULL;
- omap_crtc->old_fb = NULL;
-
- spin_unlock_irqrestore(&dev->event_lock, flags);
+ ret = omap_plane_mode_set(plane, crtc, crtc->primary->fb,
+ 0, 0, mode->hdisplay, mode->vdisplay,
+ x, y, mode->hdisplay, mode->vdisplay);
+ if (ret < 0)
+ return ret;
- if (fb)
- drm_framebuffer_unreference(fb);
+ return omap_crtc_flush(crtc);
}
static void page_flip_worker(struct work_struct *work)
drm_modeset_lock(&crtc->mutex, NULL);
omap_plane_mode_set(crtc->primary, crtc, crtc->primary->fb,
0, 0, mode->hdisplay, mode->vdisplay,
- crtc->x, crtc->y, mode->hdisplay, mode->vdisplay,
- vblank_cb, crtc);
+ crtc->x, crtc->y, mode->hdisplay, mode->vdisplay);
+ omap_crtc_flush(crtc);
drm_modeset_unlock(&crtc->mutex);
bo = omap_framebuffer_bo(crtc->primary->fb, 0);
drm_gem_object_unreference_unlocked(bo);
+ drm_framebuffer_unreference(crtc->primary->fb);
}
static void page_flip_cb(void *arg)
crtc = &omap_crtc->base;
INIT_WORK(&omap_crtc->page_flip_work, page_flip_worker);
- INIT_WORK(&omap_crtc->apply_work, apply_worker);
- INIT_LIST_HEAD(&omap_crtc->pending_applies);
- INIT_LIST_HEAD(&omap_crtc->queued_applies);
+ INIT_LIST_HEAD(&omap_crtc->pending_unpins);
- omap_crtc->apply.pre_apply = omap_crtc_pre_apply;
- omap_crtc->apply.post_apply = omap_crtc_post_apply;
+ init_completion(&omap_crtc->completion);
omap_crtc->channel = channel;
omap_crtc->name = channel_names[channel];
omap_crtc->pipe = id;
- omap_crtc->apply_irq.irqmask = pipe2vbl(crtc);
- omap_crtc->apply_irq.irq = omap_crtc_apply_irq;
+ omap_crtc->vblank_irq.irqmask = pipe2vbl(crtc);
+ omap_crtc->vblank_irq.irq = omap_crtc_vblank_irq;
omap_crtc->error_irq.irqmask =
dispc_mgr_get_sync_lost_irq(channel);
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "drm_flip_work.h"
-
#include "omap_drv.h"
#include "omap_dmm_tiler.h"
* plane funcs
*/
-struct callback {
- void (*fxn)(void *);
- void *arg;
-};
-
#define to_omap_plane(x) container_of(x, struct omap_plane, base)
struct omap_plane {
int id; /* TODO rename omap_plane -> omap_plane_id in omapdss so I can use the enum */
const char *name;
struct omap_overlay_info info;
- struct omap_drm_apply apply;
/* position/orientation of scanout within the fb: */
struct omap_drm_window win;
uint32_t formats[32];
struct omap_drm_irq error_irq;
-
- /* for deferring bo unpin's until next post_apply(): */
- struct drm_flip_work unpin_work;
-
- // XXX maybe get rid of this and handle vblank in crtc too?
- struct callback apply_done_cb;
};
-static void omap_plane_unpin_worker(struct drm_flip_work *work, void *val)
-{
- struct omap_plane *omap_plane =
- container_of(work, struct omap_plane, unpin_work);
- struct drm_device *dev = omap_plane->base.dev;
-
- /*
- * omap_framebuffer_pin/unpin are always called from priv->wq,
- * so there's no need for locking here.
- */
- omap_framebuffer_unpin(val);
- mutex_lock(&dev->mode_config.mutex);
- drm_framebuffer_unreference(val);
- mutex_unlock(&dev->mode_config.mutex);
-}
-
/* update which fb (if any) is pinned for scanout */
-static int omap_plane_update_pin(struct drm_plane *plane,
- struct drm_framebuffer *fb)
+static int omap_plane_update_pin(struct drm_plane *plane)
{
struct omap_plane *omap_plane = to_omap_plane(plane);
struct drm_framebuffer *pinned_fb = omap_plane->pinned_fb;
+ struct drm_framebuffer *fb = omap_plane->enabled ? plane->fb : NULL;
+ int ret = 0;
- if (pinned_fb != fb) {
- int ret = 0;
-
- DBG("%p -> %p", pinned_fb, fb);
+ if (pinned_fb == fb)
+ return 0;
- if (fb) {
- drm_framebuffer_reference(fb);
- ret = omap_framebuffer_pin(fb);
- }
+ DBG("%p -> %p", pinned_fb, fb);
- if (pinned_fb)
- drm_flip_work_queue(&omap_plane->unpin_work, pinned_fb);
+ if (fb) {
+ drm_framebuffer_reference(fb);
+ ret = omap_framebuffer_pin(fb);
+ }
- if (ret) {
- dev_err(plane->dev->dev, "could not swap %p -> %p\n",
- omap_plane->pinned_fb, fb);
- drm_framebuffer_unreference(fb);
- omap_plane->pinned_fb = NULL;
- return ret;
- }
+ if (pinned_fb)
+ omap_crtc_queue_unpin(plane->crtc, pinned_fb);
- omap_plane->pinned_fb = fb;
+ if (ret) {
+ dev_err(plane->dev->dev, "could not swap %p -> %p\n",
+ omap_plane->pinned_fb, fb);
+ drm_framebuffer_unreference(fb);
+ omap_plane->pinned_fb = NULL;
+ return ret;
}
+ omap_plane->pinned_fb = fb;
+
return 0;
}
-static void omap_plane_pre_apply(struct omap_drm_apply *apply)
+static int omap_plane_setup(struct omap_plane *omap_plane)
{
- struct omap_plane *omap_plane =
- container_of(apply, struct omap_plane, apply);
- struct omap_drm_window *win = &omap_plane->win;
+ struct omap_overlay_info *info = &omap_plane->info;
struct drm_plane *plane = &omap_plane->base;
struct drm_device *dev = plane->dev;
- struct omap_overlay_info *info = &omap_plane->info;
struct drm_crtc *crtc = plane->crtc;
- enum omap_channel channel;
- bool enabled = omap_plane->enabled && crtc;
int ret;
- DBG("%s, enabled=%d", omap_plane->name, enabled);
+ DBG("%s, enabled=%d", omap_plane->name, omap_plane->enabled);
/* if fb has changed, pin new fb: */
- omap_plane_update_pin(plane, enabled ? plane->fb : NULL);
+ ret = omap_plane_update_pin(plane);
+ if (ret)
+ return ret;
+
+ dispc_runtime_get();
- if (!enabled) {
+ if (!omap_plane->enabled) {
dispc_ovl_enable(omap_plane->id, false);
- return;
+ goto done;
}
- channel = omap_crtc_channel(crtc);
-
/* update scanout: */
- omap_framebuffer_update_scanout(plane->fb, win, info);
+ omap_framebuffer_update_scanout(plane->fb, &omap_plane->win, info);
DBG("%dx%d -> %dx%d (%d)", info->width, info->height,
info->out_width, info->out_height,
DBG("%d,%d %pad %pad", info->pos_x, info->pos_y,
&info->paddr, &info->p_uv_addr);
- dispc_ovl_set_channel_out(omap_plane->id, channel);
+ dispc_ovl_set_channel_out(omap_plane->id,
+ omap_crtc_channel(crtc));
/* and finally, update omapdss: */
ret = dispc_ovl_setup(omap_plane->id, info, false,
omap_crtc_timings(crtc), false);
if (ret) {
dev_err(dev->dev, "dispc_ovl_setup failed: %d\n", ret);
- return;
+ goto done;
}
dispc_ovl_enable(omap_plane->id, true);
-}
-
-static void omap_plane_post_apply(struct omap_drm_apply *apply)
-{
- struct omap_plane *omap_plane =
- container_of(apply, struct omap_plane, apply);
- struct drm_plane *plane = &omap_plane->base;
- struct omap_drm_private *priv = plane->dev->dev_private;
- struct callback cb;
-
- cb = omap_plane->apply_done_cb;
- omap_plane->apply_done_cb.fxn = NULL;
-
- drm_flip_work_commit(&omap_plane->unpin_work, priv->wq);
-
- if (cb.fxn)
- cb.fxn(cb.arg);
-}
-static int omap_plane_apply(struct drm_plane *plane)
-{
- if (plane->crtc) {
- struct omap_plane *omap_plane = to_omap_plane(plane);
- return omap_crtc_apply(plane->crtc, &omap_plane->apply);
- }
- return 0;
+done:
+ dispc_runtime_put();
+ return ret;
}
int omap_plane_mode_set(struct drm_plane *plane,
int crtc_x, int crtc_y,
unsigned int crtc_w, unsigned int crtc_h,
unsigned int src_x, unsigned int src_y,
- unsigned int src_w, unsigned int src_h,
- void (*fxn)(void *), void *arg)
+ unsigned int src_w, unsigned int src_h)
{
struct omap_plane *omap_plane = to_omap_plane(plane);
struct omap_drm_window *win = &omap_plane->win;
win->src_w = src_w;
win->src_h = src_h;
- if (fxn) {
- /* omap_crtc should ensure that a new page flip
- * isn't permitted while there is one pending:
- */
- BUG_ON(omap_plane->apply_done_cb.fxn);
+ return omap_plane_setup(omap_plane);
+}
- omap_plane->apply_done_cb.fxn = fxn;
- omap_plane->apply_done_cb.arg = arg;
- }
+int omap_plane_set_enable(struct drm_plane *plane, bool enable)
+{
+ struct omap_plane *omap_plane = to_omap_plane(plane);
- return omap_plane_apply(plane);
+ if (enable == omap_plane->enabled)
+ return 0;
+
+ omap_plane->enabled = enable;
+ return omap_plane_setup(omap_plane);
}
static int omap_plane_update(struct drm_plane *plane,
uint32_t src_w, uint32_t src_h)
{
struct omap_plane *omap_plane = to_omap_plane(plane);
+ int ret;
+
omap_plane->enabled = true;
/* omap_plane_mode_set() takes adjusted src */
plane->crtc = crtc;
/* src values are in Q16 fixed point, convert to integer: */
- return omap_plane_mode_set(plane, crtc, fb,
- crtc_x, crtc_y, crtc_w, crtc_h,
- src_x >> 16, src_y >> 16, src_w >> 16, src_h >> 16,
- NULL, NULL);
+ ret = omap_plane_mode_set(plane, crtc, fb,
+ crtc_x, crtc_y, crtc_w, crtc_h,
+ src_x >> 16, src_y >> 16,
+ src_w >> 16, src_h >> 16);
+ if (ret < 0)
+ return ret;
+
+ return omap_crtc_flush(plane->crtc);
}
static int omap_plane_disable(struct drm_plane *plane)
omap_plane->info.zorder = plane->type == DRM_PLANE_TYPE_PRIMARY
? 0 : omap_plane->id;
- return omap_plane_set_enable(plane, false);
+ if (!omap_plane->enabled)
+ return 0;
+
+ /* Disabling a plane never fails. */
+ omap_plane->enabled = false;
+ omap_plane_setup(omap_plane);
+
+ return omap_crtc_flush(plane->crtc);
}
static void omap_plane_destroy(struct drm_plane *plane)
drm_plane_cleanup(plane);
- drm_flip_work_cleanup(&omap_plane->unpin_work);
-
kfree(omap_plane);
}
-int omap_plane_set_enable(struct drm_plane *plane, bool enable)
-{
- struct omap_plane *omap_plane = to_omap_plane(plane);
-
- if (enable == omap_plane->enabled)
- return 0;
-
- omap_plane->enabled = enable;
- return omap_plane_apply(plane);
-}
-
/* helper to install properties which are common to planes and crtcs */
void omap_plane_install_properties(struct drm_plane *plane,
struct drm_mode_object *obj)
{
struct omap_plane *omap_plane = to_omap_plane(plane);
struct omap_drm_private *priv = plane->dev->dev_private;
- int ret = -EINVAL;
+ int ret;
if (property == plane->dev->mode_config.rotation_property) {
DBG("%s: rotation: %02x", omap_plane->name, (uint32_t)val);
omap_plane->win.rotation = val;
- ret = omap_plane_apply(plane);
} else if (property == priv->zorder_prop) {
DBG("%s: zorder: %02x", omap_plane->name, (uint32_t)val);
omap_plane->info.zorder = val;
- ret = omap_plane_apply(plane);
+ } else {
+ return -EINVAL;
}
- return ret;
+ /*
+ * We're done if the plane is disabled, properties will be applied the
+ * next time it becomes enabled.
+ */
+ if (!omap_plane->enabled)
+ return 0;
+
+ ret = omap_plane_setup(omap_plane);
+ if (ret < 0)
+ return ret;
+
+ return omap_crtc_flush(plane->crtc);
}
static const struct drm_plane_funcs omap_plane_funcs = {
if (!omap_plane)
return ERR_PTR(-ENOMEM);
- drm_flip_work_init(&omap_plane->unpin_work,
- "unpin", omap_plane_unpin_worker);
-
omap_plane->nformats = omap_framebuffer_get_formats(
omap_plane->formats, ARRAY_SIZE(omap_plane->formats),
dss_feat_get_supported_color_modes(id));
plane = &omap_plane->base;
- omap_plane->apply.pre_apply = omap_plane_pre_apply;
- omap_plane->apply.post_apply = omap_plane_post_apply;
-
omap_plane->error_irq.irqmask = error_irqs[id];
omap_plane->error_irq.irq = omap_plane_error_irq;
omap_irq_register(dev, &omap_plane->error_irq);
projects / GitHub / moto-9609 / android_kernel_motorola_exynos9610.git / commitdiff