Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 284b2884 authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge tag 'omapdrm-4.2-atomic' of... 

Merge tag 'omapdrm-4.2-atomic' of git://git.kernel.org/pub/scm/linux/kernel/git/tomba/linux into drm-next

omapdrm atomic modesetting support

Atomic modesetting support for omapdrm.

" we've had issues with omapdrm for years,
which we've not been able to fix properly (like warnings/crashes when unloading
modules, page-flips tearing, race issues with fbs). All those problems seem to
be gone after this rewrite of omapdrm for atomic modesetting, and the resulting
code is much cleaner and more maintainable."

* tag 'omapdrm-4.2-atomic' of git://git.kernel.org/pub/scm/linux/kernel/git/tomba/linux: (43 commits)
  drm: omapdrm: new vblank and event handling
  drm: omapdrm: merge omap_crtc_flush and omap_crtc_atomic_flush
  drm: omapdrm: add lock for fb pinning
  drm: omapdrm: if omap_plane_atomic_update fails, disable plane
  drm: omapdrm: inline omap_plane_setup into update/disable
  drm: omapdrm: omap_plane_setup() cannot fail, use WARN
  drm: omapdrm: Don't setup planes manually from CRTC .enable()/.disable()
  drm: omapdrm: Don't flush CRTC when enabling or disabling it
  drm: omapdrm: Move encoder setup to encoder operations
  drm: omapdrm: Simplify DSS power management
  drm: omapdrm: Remove nested PM get/sync when configuring encoders
  drm: omapdrm: Support unlinking page flip events prematurely
  drm: omapdrm: omap_crtc_flush() isn't called with modeset locked
  drm: omapdrm: Don't get/put dispc in omap_crtc_flush()
  drm: omapdrm: Make the omap_crtc_flush function static
  drm: omapdrm: Remove omap_plane enabled field
  drm: omapdrm: Remove omap_crtc enabled field
  drm: omapdrm: Move crtc info out of the crtc structure
  drm: omapdrm: Move plane info and win out of the plane structure
  drm: omapdrm: Switch crtc and plane set_property to atomic helpers
  ...
parents b9a1077a 5f741b39

drivers/gpu/drm/omapdrm/omap_connector.c

+8 −4
Original line number Diff line number Diff line
@@ -17,10 +17,11 @@ 
 * this program.  If not, see <http://www.gnu.org/licenses/>.

 */



#include "omap_drv.h"

#include <drm/drm_atomic_helper.h>

#include <drm/drm_crtc.h>

#include <drm/drm_crtc_helper.h>



#include "drm_crtc.h"

#include "drm_crtc_helper.h"

#include "omap_drv.h"



/*

 * connector funcs
@@ -259,10 +260,13 @@ struct drm_encoder *omap_connector_attached_encoder( 
}



static const struct drm_connector_funcs omap_connector_funcs = {

	.dpms = drm_helper_connector_dpms,

	.dpms = drm_atomic_helper_connector_dpms,

	.reset = drm_atomic_helper_connector_reset,

	.detect = omap_connector_detect,

	.fill_modes = drm_helper_probe_single_connector_modes,

	.destroy = omap_connector_destroy,

	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,

	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,

};



static const struct drm_connector_helper_funcs omap_connector_helper_funcs = {

drivers/gpu/drm/omapdrm/omap_crtc.c

+162 −379
Original line number Diff line number Diff line
@@ -17,12 +17,14 @@ 
 * this program.  If not, see <http://www.gnu.org/licenses/>.

 */



#include "omap_drv.h"



#include <drm/drm_atomic.h>

#include <drm/drm_atomic_helper.h>

#include <drm/drm_crtc.h>

#include <drm/drm_crtc_helper.h>

#include <drm/drm_mode.h>

#include <drm/drm_plane_helper.h>

#include "drm_crtc.h"

#include "drm_crtc_helper.h"



#include "omap_drv.h"



#define to_omap_crtc(x) container_of(x, struct omap_crtc, base)
@@ -30,10 +32,7 @@ struct omap_crtc { 
	struct drm_crtc base;



	const char *name;

	int pipe;

	enum omap_channel channel;

	struct omap_overlay_manager_info info;

	struct drm_encoder *current_encoder;



	/*

	 * Temporary: eventually this will go away, but it is needed
@@ -44,36 +43,14 @@ struct omap_crtc { 
	struct omap_overlay_manager *mgr;



	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;



	/* if there is a pending flip, these will be non-null: */

	struct drm_pending_vblank_event *event;

	struct drm_framebuffer *old_fb;



	/* 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;



	bool pending;

	wait_queue_head_t pending_wait;

};



/* -----------------------------------------------------------------------------
@@ -87,7 +64,7 @@ uint32_t pipe2vbl(struct drm_crtc *crtc) 
	return dispc_mgr_get_vsync_irq(omap_crtc->channel);

}



const struct omap_video_timings *omap_crtc_timings(struct drm_crtc *crtc)

struct omap_video_timings *omap_crtc_timings(struct drm_crtc *crtc)

{

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);

	return &omap_crtc->timings;
@@ -99,6 +76,15 @@ enum omap_channel omap_crtc_channel(struct drm_crtc *crtc) 
	return omap_crtc->channel;

}



int omap_crtc_wait_pending(struct drm_crtc *crtc)

{

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);



	return wait_event_timeout(omap_crtc->pending_wait,

				  !omap_crtc->pending,

				  msecs_to_jiffies(50));

}



/* -----------------------------------------------------------------------------

 * DSS Manager Functions

 */
@@ -116,7 +102,7 @@ enum omap_channel omap_crtc_channel(struct drm_crtc *crtc) 
static struct omap_crtc *omap_crtcs[8];



/* we can probably ignore these until we support command-mode panels: */

static int omap_crtc_connect(struct omap_overlay_manager *mgr,

static int omap_crtc_dss_connect(struct omap_overlay_manager *mgr,

		struct omap_dss_device *dst)

{

	if (mgr->output)
@@ -131,18 +117,18 @@ static int omap_crtc_connect(struct omap_overlay_manager *mgr, 
	return 0;

}



static void omap_crtc_disconnect(struct omap_overlay_manager *mgr,

static void omap_crtc_dss_disconnect(struct omap_overlay_manager *mgr,

		struct omap_dss_device *dst)

{

	mgr->output->manager = NULL;

	mgr->output = NULL;

}



static void omap_crtc_start_update(struct omap_overlay_manager *mgr)

static void omap_crtc_dss_start_update(struct omap_overlay_manager *mgr)

{

}



/* Called only from CRTC pre_apply and suspend/resume handlers. */

/* Called only from the encoder enable/disable and suspend/resume handlers. */

static void omap_crtc_set_enabled(struct drm_crtc *crtc, bool enable)

{

	struct drm_device *dev = crtc->dev;
@@ -200,11 +186,18 @@ static void omap_crtc_set_enabled(struct drm_crtc *crtc, bool enable) 
}





static int omap_crtc_enable(struct omap_overlay_manager *mgr)

static int omap_crtc_dss_enable(struct omap_overlay_manager *mgr)

{

	struct omap_crtc *omap_crtc = omap_crtcs[mgr->id];

	struct omap_overlay_manager_info info;



	memset(&info, 0, sizeof(info));

	info.default_color = 0x00000000;

	info.trans_key = 0x00000000;

	info.trans_key_type = OMAP_DSS_COLOR_KEY_GFX_DST;

	info.trans_enabled = false;



	dispc_mgr_setup(omap_crtc->channel, &omap_crtc->info);

	dispc_mgr_setup(omap_crtc->channel, &info);

	dispc_mgr_set_timings(omap_crtc->channel,

			&omap_crtc->timings);

	omap_crtc_set_enabled(&omap_crtc->base, true);
@@ -212,14 +205,14 @@ static int omap_crtc_enable(struct omap_overlay_manager *mgr) 
	return 0;

}



static void omap_crtc_disable(struct omap_overlay_manager *mgr)

static void omap_crtc_dss_disable(struct omap_overlay_manager *mgr)

{

	struct omap_crtc *omap_crtc = omap_crtcs[mgr->id];



	omap_crtc_set_enabled(&omap_crtc->base, false);

}



static void omap_crtc_set_timings(struct omap_overlay_manager *mgr,

static void omap_crtc_dss_set_timings(struct omap_overlay_manager *mgr,

		const struct omap_video_timings *timings)

{

	struct omap_crtc *omap_crtc = omap_crtcs[mgr->id];
@@ -227,7 +220,7 @@ static void omap_crtc_set_timings(struct omap_overlay_manager *mgr, 
	omap_crtc->timings = *timings;

}



static void omap_crtc_set_lcd_config(struct omap_overlay_manager *mgr,

static void omap_crtc_dss_set_lcd_config(struct omap_overlay_manager *mgr,

		const struct dss_lcd_mgr_config *config)

{

	struct omap_crtc *omap_crtc = omap_crtcs[mgr->id];
@@ -235,211 +228,99 @@ static void omap_crtc_set_lcd_config(struct omap_overlay_manager *mgr, 
	dispc_mgr_set_lcd_config(omap_crtc->channel, config);

}



static int omap_crtc_register_framedone_handler(

static int omap_crtc_dss_register_framedone(

		struct omap_overlay_manager *mgr,

		void (*handler)(void *), void *data)

{

	return 0;

}



static void omap_crtc_unregister_framedone_handler(

static void omap_crtc_dss_unregister_framedone(

		struct omap_overlay_manager *mgr,

		void (*handler)(void *), void *data)

{

}



static const struct dss_mgr_ops mgr_ops = {

	.connect = omap_crtc_connect,

	.disconnect = omap_crtc_disconnect,

	.start_update = omap_crtc_start_update,

	.enable = omap_crtc_enable,

	.disable = omap_crtc_disable,

	.set_timings = omap_crtc_set_timings,

	.set_lcd_config = omap_crtc_set_lcd_config,

	.register_framedone_handler = omap_crtc_register_framedone_handler,

	.unregister_framedone_handler = omap_crtc_unregister_framedone_handler,

	.connect = omap_crtc_dss_connect,

	.disconnect = omap_crtc_dss_disconnect,

	.start_update = omap_crtc_dss_start_update,

	.enable = omap_crtc_dss_enable,

	.disable = omap_crtc_dss_disable,

	.set_timings = omap_crtc_dss_set_timings,

	.set_lcd_config = omap_crtc_dss_set_lcd_config,

	.register_framedone_handler = omap_crtc_dss_register_framedone,

	.unregister_framedone_handler = omap_crtc_dss_unregister_framedone,

};



/* -----------------------------------------------------------------------------

 * Apply Logic

 * Setup, Flush and Page Flip

 */



static void omap_crtc_error_irq(struct omap_drm_irq *irq, uint32_t irqstatus)

static void omap_crtc_complete_page_flip(struct drm_crtc *crtc)

{

	struct omap_crtc *omap_crtc =

			container_of(irq, struct omap_crtc, error_irq);



	if (omap_crtc->ignore_digit_sync_lost) {

		irqstatus &= ~DISPC_IRQ_SYNC_LOST_DIGIT;

		if (!irqstatus)

			return;

	}



	DRM_ERROR_RATELIMITED("%s: errors: %08x\n", omap_crtc->name, irqstatus);

}

	struct drm_pending_vblank_event *event;

	struct drm_device *dev = crtc->dev;

	unsigned long flags;



static void omap_crtc_apply_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;

	event = crtc->state->event;



	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 (!event)

		return;



static void apply_worker(struct work_struct *work)

{

	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;

	spin_lock_irqsave(&dev->event_lock, flags);



	/*

	 * 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();

	list_del(&event->base.link);



	/*

	 * If we are still pending a previous update, wait.. when the

	 * pending update completes, we get kicked again.

	 * Queue the event for delivery if it's still linked to a file

	 * handle, otherwise just destroy it.

	 */

	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);

	}



	need_apply = !list_empty(&omap_crtc->queued_applies);



	/* 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 (need_apply) {

		enum omap_channel channel = omap_crtc->channel;



		DBG("%s: GO", omap_crtc->name);



		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);

		}

	}

	if (event->base.file_priv)

		drm_crtc_send_vblank_event(crtc, event);

	else

		event->base.destroy(&event->base);



out:

	dispc_runtime_put();

	drm_modeset_unlock(&crtc->mutex);

	spin_unlock_irqrestore(&dev->event_lock, flags);

}



int omap_crtc_apply(struct drm_crtc *crtc,

		struct omap_drm_apply *apply)

static void omap_crtc_error_irq(struct omap_drm_irq *irq, uint32_t irqstatus)

{

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);



	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);

	struct omap_crtc *omap_crtc =

			container_of(irq, struct omap_crtc, error_irq);



	/*

	 * 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);

	if (omap_crtc->ignore_digit_sync_lost) {

		irqstatus &= ~DISPC_IRQ_SYNC_LOST_DIGIT;

		if (!irqstatus)

			return;

	}



	return 0;

	DRM_ERROR_RATELIMITED("%s: errors: %08x\n", omap_crtc->name, irqstatus);

}



static void omap_crtc_pre_apply(struct omap_drm_apply *apply)

static void omap_crtc_vblank_irq(struct omap_drm_irq *irq, uint32_t irqstatus)

{

	struct omap_crtc *omap_crtc =

			container_of(apply, struct omap_crtc, apply);

	struct drm_crtc *crtc = &omap_crtc->base;

	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);

			container_of(irq, struct omap_crtc, vblank_irq);

	struct drm_device *dev = omap_crtc->base.dev;



	for (i = 0; i < priv->num_encoders; i++) {

		if (priv->encoders[i]->crtc == crtc) {

			encoder = priv->encoders[i];

			break;

		}

	}



	if (omap_crtc->current_encoder && encoder != omap_crtc->current_encoder)

		omap_encoder_set_enabled(omap_crtc->current_encoder, false);



	omap_crtc->current_encoder = encoder;



	if (!omap_crtc->enabled) {

		if (encoder)

			omap_encoder_set_enabled(encoder, false);

	} else {

		if (encoder) {

			omap_encoder_set_enabled(encoder, false);

			omap_encoder_update(encoder, omap_crtc->mgr,

					&omap_crtc->timings);

			omap_encoder_set_enabled(encoder, true);

		}

	}

}

	if (dispc_mgr_go_busy(omap_crtc->channel))

		return;



static void omap_crtc_post_apply(struct omap_drm_apply *apply)

{

	/* nothing needed for post-apply */

}

	DBG("%s: apply done", omap_crtc->name);



void omap_crtc_flush(struct drm_crtc *crtc)

{

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);

	int loops = 0;

	__omap_irq_unregister(dev, &omap_crtc->vblank_irq);



	while (!list_empty(&omap_crtc->pending_applies) ||

		!list_empty(&omap_crtc->queued_applies) ||

		omap_crtc->event || omap_crtc->old_fb) {

	rmb();

	WARN_ON(!omap_crtc->pending);

	omap_crtc->pending = false;

	wmb();



		if (++loops > 10) {

			dev_err(crtc->dev->dev,

				"omap_crtc_flush() timeout\n");

			break;

		}

	/* wake up userspace */

	omap_crtc_complete_page_flip(&omap_crtc->base);



		schedule_timeout_uninterruptible(msecs_to_jiffies(20));

	}

	/* wake up omap_atomic_complete */

	wake_up(&omap_crtc->pending_wait);

}



/* -----------------------------------------------------------------------------
@@ -452,7 +333,7 @@ static void omap_crtc_destroy(struct drm_crtc *crtc) 


	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);
@@ -460,28 +341,6 @@ static void omap_crtc_destroy(struct drm_crtc *crtc) 
	kfree(omap_crtc);

}



static void omap_crtc_dpms(struct drm_crtc *crtc, int mode)

{

	struct omap_drm_private *priv = crtc->dev->dev_private;

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);

	bool enabled = (mode == DRM_MODE_DPMS_ON);

	int i;



	DBG("%s: %d", omap_crtc->name, mode);



	if (enabled != omap_crtc->enabled) {

		omap_crtc->enabled = enabled;

		omap_crtc_apply(crtc, &omap_crtc->apply);



		/* 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));

		}

	}

}



static bool omap_crtc_mode_fixup(struct drm_crtc *crtc,

		const struct drm_display_mode *mode,

		struct drm_display_mode *adjusted_mode)
@@ -489,187 +348,127 @@ static bool omap_crtc_mode_fixup(struct drm_crtc *crtc, 
	return true;

}



static int omap_crtc_mode_set(struct drm_crtc *crtc,

		struct drm_display_mode *mode,

		struct drm_display_mode *adjusted_mode,

		int x, int y,

		struct drm_framebuffer *old_fb)

static void omap_crtc_enable(struct drm_crtc *crtc)

{

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);



	mode = adjusted_mode;

	DBG("%s", omap_crtc->name);



	DBG("%s: set mode: %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",

			omap_crtc->name, mode->base.id, mode->name,

			mode->vrefresh, mode->clock,

			mode->hdisplay, mode->hsync_start,

			mode->hsync_end, mode->htotal,

			mode->vdisplay, mode->vsync_start,

			mode->vsync_end, mode->vtotal,

			mode->type, mode->flags);

	rmb();

	WARN_ON(omap_crtc->pending);

	omap_crtc->pending = true;

	wmb();



	copy_timings_drm_to_omap(&omap_crtc->timings, mode);

	omap_irq_register(crtc->dev, &omap_crtc->vblank_irq);



	/*

	 * The primary plane CRTC can be reset if the plane is disabled directly

	 * through the universal plane API. Set it again here.

	 */

	crtc->primary->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);

	drm_crtc_vblank_on(crtc);

}



static void omap_crtc_prepare(struct drm_crtc *crtc)

static void omap_crtc_disable(struct drm_crtc *crtc)

{

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);

	DBG("%s", omap_crtc->name);

	omap_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);

}



static void omap_crtc_commit(struct drm_crtc *crtc)

{

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);

	DBG("%s", omap_crtc->name);

	omap_crtc_dpms(crtc, DRM_MODE_DPMS_ON);

}



static int omap_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,

		struct drm_framebuffer *old_fb)

{

	struct drm_plane *plane = crtc->primary;

	struct drm_display_mode *mode = &crtc->mode;



	return omap_plane_mode_set(plane, crtc, crtc->primary->fb,

				   0, 0, mode->hdisplay, mode->vdisplay,

				   x, y, mode->hdisplay, mode->vdisplay,

				   NULL, NULL);

	drm_crtc_vblank_off(crtc);

}



static void vblank_cb(void *arg)

static void omap_crtc_mode_set_nofb(struct drm_crtc *crtc)

{

	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;

	struct drm_display_mode *mode = &crtc->state->adjusted_mode;



	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);

	DBG("%s: set mode: %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",

	    omap_crtc->name, mode->base.id, mode->name,

	    mode->vrefresh, mode->clock,

	    mode->hdisplay, mode->hsync_start, mode->hsync_end, mode->htotal,

	    mode->vdisplay, mode->vsync_start, mode->vsync_end, mode->vtotal,

	    mode->type, mode->flags);



	if (fb)

		drm_framebuffer_unreference(fb);

	copy_timings_drm_to_omap(&omap_crtc->timings, mode);

}



static void page_flip_worker(struct work_struct *work)

static void omap_crtc_atomic_begin(struct drm_crtc *crtc)

{

	struct omap_crtc *omap_crtc =

			container_of(work, struct omap_crtc, page_flip_work);

	struct drm_crtc *crtc = &omap_crtc->base;

	struct drm_display_mode *mode = &crtc->mode;

	struct drm_gem_object *bo;



	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);

	drm_modeset_unlock(&crtc->mutex);



	bo = omap_framebuffer_bo(crtc->primary->fb, 0);

	drm_gem_object_unreference_unlocked(bo);

}



static void page_flip_cb(void *arg)

static void omap_crtc_atomic_flush(struct drm_crtc *crtc)

{

	struct drm_crtc *crtc = arg;

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);

	struct omap_drm_private *priv = crtc->dev->dev_private;



	/* avoid assumptions about what ctxt we are called from: */

	queue_work(priv->wq, &omap_crtc->page_flip_work);

}

	WARN_ON(omap_crtc->vblank_irq.registered);



static int omap_crtc_page_flip_locked(struct drm_crtc *crtc,

		 struct drm_framebuffer *fb,

		 struct drm_pending_vblank_event *event,

		 uint32_t page_flip_flags)

{

	struct drm_device *dev = crtc->dev;

	struct omap_crtc *omap_crtc = to_omap_crtc(crtc);

	struct drm_plane *primary = crtc->primary;

	struct drm_gem_object *bo;

	unsigned long flags;

	if (dispc_mgr_is_enabled(omap_crtc->channel)) {



	DBG("%d -> %d (event=%p)", primary->fb ? primary->fb->base.id : -1,

			fb->base.id, event);

		DBG("%s: GO", omap_crtc->name);



	spin_lock_irqsave(&dev->event_lock, flags);

		rmb();

		WARN_ON(omap_crtc->pending);

		omap_crtc->pending = true;

		wmb();



	if (omap_crtc->old_fb) {

		spin_unlock_irqrestore(&dev->event_lock, flags);

		dev_err(dev->dev, "already a pending flip\n");

		return -EBUSY;

		dispc_mgr_go(omap_crtc->channel);

		omap_irq_register(crtc->dev, &omap_crtc->vblank_irq);

	}



	omap_crtc->event = event;

	omap_crtc->old_fb = primary->fb = fb;

	drm_framebuffer_reference(omap_crtc->old_fb);

	crtc->invert_dimensions = !!(crtc->primary->state->rotation &

				    (BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_270)));

}



	spin_unlock_irqrestore(&dev->event_lock, flags);

static int omap_crtc_atomic_set_property(struct drm_crtc *crtc,

					 struct drm_crtc_state *state,

					 struct drm_property *property,

					 uint64_t val)

{

	struct drm_plane_state *plane_state;

	struct drm_plane *plane = crtc->primary;



	/*

	 * Hold a reference temporarily until the crtc is updated

	 * and takes the reference to the bo.  This avoids it

	 * getting freed from under us:

	 * Delegate property set to the primary plane. Get the plane state and

	 * set the property directly.

	 */

	bo = omap_framebuffer_bo(fb, 0);

	drm_gem_object_reference(bo);



	omap_gem_op_async(bo, OMAP_GEM_READ, page_flip_cb, crtc);

	plane_state = drm_atomic_get_plane_state(state->state, plane);

	if (!plane_state)

		return -EINVAL;



	return 0;

	return drm_atomic_plane_set_property(plane, plane_state, property, val);

}



static int omap_crtc_set_property(struct drm_crtc *crtc,

		struct drm_property *property, uint64_t val)

static int omap_crtc_atomic_get_property(struct drm_crtc *crtc,

					 const struct drm_crtc_state *state,

					 struct drm_property *property,

					 uint64_t *val)

{

	struct omap_drm_private *priv = crtc->dev->dev_private;



	if (property == priv->rotation_prop) {

		crtc->invert_dimensions =

				!!(val & ((1LL << DRM_ROTATE_90) | (1LL << DRM_ROTATE_270)));

	}



	return omap_plane_set_property(crtc->primary, property, val);

	/*

	 * Delegate property get to the primary plane. The

	 * drm_atomic_plane_get_property() function isn't exported, but can be

	 * called through drm_object_property_get_value() as that will call

	 * drm_atomic_get_property() for atomic drivers.

	 */

	return drm_object_property_get_value(&crtc->primary->base, property,

					     val);

}



static const struct drm_crtc_funcs omap_crtc_funcs = {

	.set_config = drm_crtc_helper_set_config,

	.reset = drm_atomic_helper_crtc_reset,

	.set_config = drm_atomic_helper_set_config,

	.destroy = omap_crtc_destroy,

	.page_flip = omap_crtc_page_flip_locked,

	.set_property = omap_crtc_set_property,

	.page_flip = drm_atomic_helper_page_flip,

	.set_property = drm_atomic_helper_crtc_set_property,

	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,

	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,

	.atomic_set_property = omap_crtc_atomic_set_property,

	.atomic_get_property = omap_crtc_atomic_get_property,

};



static const struct drm_crtc_helper_funcs omap_crtc_helper_funcs = {

	.dpms = omap_crtc_dpms,

	.mode_fixup = omap_crtc_mode_fixup,

	.mode_set = omap_crtc_mode_set,

	.prepare = omap_crtc_prepare,

	.commit = omap_crtc_commit,

	.mode_set_base = omap_crtc_mode_set_base,

	.mode_set_nofb = omap_crtc_mode_set_nofb,

	.disable = omap_crtc_disable,

	.enable = omap_crtc_enable,

	.atomic_begin = omap_crtc_atomic_begin,

	.atomic_flush = omap_crtc_atomic_flush,

};



/* -----------------------------------------------------------------------------
@@ -699,7 +498,6 @@ struct drm_crtc *omap_crtc_init(struct drm_device *dev, 
{

	struct drm_crtc *crtc = NULL;

	struct omap_crtc *omap_crtc;

	struct omap_overlay_manager_info *info;

	int ret;



	DBG("%s", channel_names[channel]);
@@ -710,21 +508,13 @@ struct drm_crtc *omap_crtc_init(struct drm_device *dev, 


	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);



	omap_crtc->apply.pre_apply  = omap_crtc_pre_apply;

	omap_crtc->apply.post_apply = omap_crtc_post_apply;

	init_waitqueue_head(&omap_crtc->pending_wait);



	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);
@@ -734,13 +524,6 @@ struct drm_crtc *omap_crtc_init(struct drm_device *dev, 
	/* temporary: */

	omap_crtc->mgr = omap_dss_get_overlay_manager(channel);



	/* TODO: fix hard-coded setup.. add properties! */

	info = &omap_crtc->info;

	info->default_color = 0x00000000;

	info->trans_key = 0x00000000;

	info->trans_key_type = OMAP_DSS_COLOR_KEY_GFX_DST;

	info->trans_enabled = false;



	ret = drm_crtc_init_with_planes(dev, crtc, plane, NULL,

					&omap_crtc_funcs);

	if (ret < 0) {

drivers/gpu/drm/omapdrm/omap_debugfs.c

+3 −3
Original line number Diff line number Diff line
@@ -17,12 +17,12 @@ 
 * this program.  If not, see <http://www.gnu.org/licenses/>.

 */



#include <drm/drm_crtc.h>

#include <drm/drm_fb_helper.h>



#include "omap_drv.h"

#include "omap_dmm_tiler.h"



#include "drm_fb_helper.h"





#ifdef CONFIG_DEBUG_FS



static int gem_show(struct seq_file *m, void *arg)

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

+10 −9
Original line number Diff line number Diff line
@@ -15,21 +15,22 @@ 
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#include <linux/completion.h>

#include <linux/delay.h>

#include <linux/dma-mapping.h>

#include <linux/errno.h>

#include <linux/init.h>

#include <linux/interrupt.h>

#include <linux/list.h>

#include <linux/mm.h>

#include <linux/module.h>

#include <linux/platform_device.h> /* platform_device() */

#include <linux/errno.h>

#include <linux/sched.h>

#include <linux/wait.h>

#include <linux/interrupt.h>

#include <linux/dma-mapping.h>

#include <linux/slab.h>

#include <linux/vmalloc.h>

#include <linux/delay.h>

#include <linux/mm.h>

#include <linux/time.h>

#include <linux/list.h>

#include <linux/completion.h>

#include <linux/vmalloc.h>

#include <linux/wait.h>



#include "omap_dmm_tiler.h"

#include "omap_dmm_priv.h"