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

Commit 19af1365 authored by Clarence Ip's avatar Clarence Ip Committed by Narendra Muppalla
Browse files

drm/msm/sde: update encoder dmesg logging to use sde macros 



This change modifies the video and command mode encoders to use
local sde defined macros for debug and error logging rather than
standard drm ones. The local sde macros allow the logs to be
enabled both from the normal drm_debug and Linux dynamic debug
interfaces.

Change-Id: I25775dbe30f140f3833b3aa7c735f31bbc987f26
Signed-off-by: default avatarClarence Ip <cip@codeaurora.org>
parent 9ffcd59d

drivers/gpu/drm/msm/sde/sde_encoder.c

+104 −68
Original line number Diff line number Diff line
@@ -10,6 +10,7 @@ 
 * GNU General Public License for more details.

 */



#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__

#include "msm_drv.h"

#include "sde_kms.h"

#include "drm_crtc.h"
@@ -23,6 +24,12 @@ 
#include "sde_encoder_phys.h"

#include "display_manager.h"



#define SDE_DEBUG_ENC(e, fmt, ...) SDE_DEBUG("enc%d " fmt,\

		(e) ? (e)->base.base.id : -1, ##__VA_ARGS__)



#define SDE_ERROR_ENC(e, fmt, ...) SDE_ERROR("enc%d " fmt,\

		(e) ? (e)->base.base.id : -1, ##__VA_ARGS__)



/*

 * Two to anticipate panels that can do cmd/vid dynamic switching

 * plan is to create all possible physical encoder types, and switch between
@@ -120,13 +127,24 @@ static struct msm_bus_scale_pdata mdp_bus_scale_table = { 


static void bs_init(struct sde_encoder_virt *sde_enc)

{

	if (!sde_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}



	sde_enc->bus_scaling_client =

	    msm_bus_scale_register_client(&mdp_bus_scale_table);

	DBG("bus scale client: %08x", sde_enc->bus_scaling_client);

	SDE_DEBUG_ENC(sde_enc, "bus scale client %08x\n",

			sde_enc->bus_scaling_client);

}



static void bs_fini(struct sde_encoder_virt *sde_enc)

{

	if (!sde_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}



	if (sde_enc->bus_scaling_client) {

		msm_bus_scale_unregister_client(sde_enc->bus_scaling_client);

		sde_enc->bus_scaling_client = 0;
@@ -135,8 +153,13 @@ static void bs_fini(struct sde_encoder_virt *sde_enc) 


static void bs_set(struct sde_encoder_virt *sde_enc, int idx)

{

	if (!sde_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}



	if (sde_enc->bus_scaling_client) {

		DBG("set bus scaling: %d", idx);

		SDE_DEBUG_ENC(sde_enc, "set bus scaling to %d\n", idx);

		idx = 1;

		msm_bus_scale_client_update_request(sde_enc->bus_scaling_client,

						    idx);
@@ -163,14 +186,14 @@ void sde_encoder_get_hw_resources(struct drm_encoder *drm_enc, 
	struct sde_encoder_virt *sde_enc = NULL;

	int i = 0;



	DBG("");



	if (!hw_res || !drm_enc || !conn_state) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid argument(s), drm_enc %d, res %d, state %d\n",

				drm_enc != 0, hw_res != 0, conn_state != 0);

		return;

	}



	sde_enc = to_sde_encoder_virt(drm_enc);

	SDE_DEBUG_ENC(sde_enc, "\n");



	/* Query resources used by phys encs, expected to be without overlap */

	memset(hw_res, 0, sizeof(*hw_res));
@@ -190,7 +213,7 @@ bool sde_encoder_needs_ctl_start(struct drm_encoder *drm_enc) 
	struct sde_encoder_phys *phys;



	if (!drm_enc) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid pointer\n");

		return false;

	}

	sde_enc = to_sde_encoder_virt(drm_enc);
@@ -207,14 +230,13 @@ static void sde_encoder_destroy(struct drm_encoder *drm_enc) 
	struct sde_encoder_virt *sde_enc = NULL;

	int i = 0;



	DBG("");



	if (!drm_enc) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid encoder\n");

		return;

	}



	sde_enc = to_sde_encoder_virt(drm_enc);

	SDE_DEBUG_ENC(sde_enc, "\n");



	for (i = 0; i < ARRAY_SIZE(sde_enc->phys_encs); i++) {

		struct sde_encoder_phys *phys = sde_enc->phys_encs[i];
@@ -227,7 +249,7 @@ static void sde_encoder_destroy(struct drm_encoder *drm_enc) 
	}



	if (sde_enc->num_phys_encs) {

		DRM_ERROR("Expected num_phys_encs to be 0 not %d\n",

		SDE_ERROR_ENC(sde_enc, "expected 0 num_phys_encs not %d\n",

				sde_enc->num_phys_encs);

	}
@@ -249,14 +271,15 @@ static int sde_encoder_virt_atomic_check( 
	int i = 0;

	int ret = 0;



	DBG("");



	if (!drm_enc || !crtc_state || !conn_state) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid arg(s), drm_enc %d, crtc/conn state %d/%d\n",

				drm_enc != 0, crtc_state != 0, conn_state != 0);

		return -EINVAL;

	}



	sde_enc = to_sde_encoder_virt(drm_enc);

	SDE_DEBUG_ENC(sde_enc, "\n");



	priv = drm_enc->dev->dev_private;

	sde_kms = to_sde_kms(priv->kms);

	mode = &crtc_state->mode;
@@ -275,8 +298,8 @@ static int sde_encoder_virt_atomic_check( 
				ret = -EINVAL;



		if (ret) {

			SDE_ERROR("enc %d mode unsupported, phys %d\n",

					drm_enc->base.id, i);

			SDE_ERROR_ENC(sde_enc,

					"mode unsupported, phys idx %d\n", i);

			break;

		}

	}
@@ -305,14 +328,14 @@ static void sde_encoder_virt_mode_set(struct drm_encoder *drm_enc, 
	struct drm_connector *conn = NULL, *conn_iter;

	int i = 0, ret;



	DBG("");



	if (!drm_enc) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid encoder\n");

		return;

	}



	sde_enc = to_sde_encoder_virt(drm_enc);

	SDE_DEBUG_ENC(sde_enc, "\n");



	priv = drm_enc->dev->dev_private;

	sde_kms = to_sde_kms(priv->kms);

	connector_list = &sde_kms->dev->mode_config.connector_list;
@@ -324,8 +347,7 @@ static void sde_encoder_virt_mode_set(struct drm_encoder *drm_enc, 
			conn = conn_iter;



	if (!conn) {

		SDE_ERROR("enc %d failed to find attached connector\n",

				drm_enc->base.id);

		SDE_ERROR_ENC(sde_enc, "failed to find attached connector\n");

		return;

	}
@@ -333,8 +355,8 @@ static void sde_encoder_virt_mode_set(struct drm_encoder *drm_enc, 
	ret = sde_rm_reserve(&sde_kms->rm, drm_enc, drm_enc->crtc->state,

			conn->state, false);

	if (ret) {

		SDE_ERROR("enc %d failed to reserve hw resources, ret %d\n",

				drm_enc->base.id, ret);

		SDE_ERROR_ENC(sde_enc,

				"failed to reserve hw resources, %d\n", ret);

		return;

	}
@@ -351,14 +373,14 @@ static void sde_encoder_virt_enable(struct drm_encoder *drm_enc) 
	struct sde_encoder_virt *sde_enc = NULL;

	int i = 0;



	DBG("");



	if (!drm_enc) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid encoder\n");

		return;

	}



	sde_enc = to_sde_encoder_virt(drm_enc);

	SDE_DEBUG_ENC(sde_enc, "\n");



	MSM_EVT(drm_enc->dev, 0, 0);



	bs_set(sde_enc, 1);
@@ -376,7 +398,8 @@ static void sde_encoder_virt_enable(struct drm_encoder *drm_enc) 
			 * the encoder role found at panel probe time

			 */

			if (phys->ops.is_master && phys->ops.is_master(phys)) {

				DBG("phys enc master is now idx %d", i);

				SDE_DEBUG_ENC(sde_enc,

						"master is now idx %d\n", i);

				sde_enc->cur_master = phys;

			}

		}
@@ -390,14 +413,14 @@ static void sde_encoder_virt_disable(struct drm_encoder *drm_enc) 
	struct sde_kms *sde_kms;

	int i = 0;



	DBG("");



	if (!drm_enc) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid encoder\n");

		return;

	}



	sde_enc = to_sde_encoder_virt(drm_enc);

	SDE_DEBUG_ENC(sde_enc, "\n");



	priv = drm_enc->dev->dev_private;

	sde_kms = to_sde_kms(priv->kms);
@@ -411,7 +434,7 @@ static void sde_encoder_virt_disable(struct drm_encoder *drm_enc) 
	}



	sde_enc->cur_master = NULL;

	DBG("clear phys enc master");

	SDE_DEBUG_ENC(sde_enc, "cleared master\n");



	bs_set(sde_enc, 0);
@@ -434,8 +457,6 @@ static enum sde_intf sde_encoder_get_intf(struct sde_mdss_cfg *catalog, 
{

	int i = 0;



	DBG("");



	for (i = 0; i < catalog->intf_count; i++) {

		if (catalog->intf[i].type == type

		    && catalog->intf[i].controller_id == controller_id) {
@@ -460,10 +481,8 @@ static void sde_encoder_vblank_callback(struct drm_encoder *drm_enc) 
	struct sde_encoder_virt *sde_enc = NULL;

	unsigned long lock_flags;



	if (!drm_enc) {

		DRM_ERROR("Invalid pointer");

	if (!drm_enc)

		return;

	}



	sde_enc = to_sde_encoder_virt(drm_enc);
@@ -483,6 +502,11 @@ void sde_encoder_register_vblank_callback(struct drm_encoder *drm_enc, 


	enable = vbl_cb ? true : false;



	if (!drm_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}

	SDE_DEBUG_ENC(sde_enc, "\n");

	MSM_EVT(drm_enc->dev, enable, 0);



	spin_lock_irqsave(&sde_enc->spin_lock, lock_flags);
@@ -532,11 +556,12 @@ void sde_encoder_schedule_kickoff(struct drm_encoder *drm_enc, 
	int ret;



	if (!drm_enc) {

		DRM_ERROR("invalid arguments");

		SDE_ERROR("invalid encoder\n");

		return;

	}

	sde_enc = to_sde_encoder_virt(drm_enc);



	SDE_DEBUG_ENC(sde_enc, "\n");

	MSM_EVT(drm_enc->dev, 0, 0);



	spin_lock_irqsave(&sde_enc->spin_lock, lock_flags);
@@ -572,7 +597,8 @@ void sde_encoder_schedule_kickoff(struct drm_encoder *drm_enc, 
				msecs_to_jiffies(WAIT_TIMEOUT_MSEC));

		spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags);

		if (!ret)

			DBG("wait %u msec timed out", WAIT_TIMEOUT_MSEC);

			SDE_DEBUG_ENC(sde_enc, "wait %ums timed out\n",

					WAIT_TIMEOUT_MSEC);

	}



	/* All phys encs are ready to go, trigger the kickoff */
@@ -595,7 +621,7 @@ static int sde_encoder_virt_add_phys_encs( 
{

	struct sde_encoder_phys *enc = NULL;



	DBG("");

	SDE_DEBUG_ENC(sde_enc, "\n");



	/*

	 * We may create up to NUM_PHYS_ENCODER_TYPES physical encoder types
@@ -603,7 +629,7 @@ static int sde_encoder_virt_add_phys_encs( 
	 */

	if (sde_enc->num_phys_encs + NUM_PHYS_ENCODER_TYPES >=

			ARRAY_SIZE(sde_enc->phys_encs)) {

		DRM_ERROR("Too many physical encoders %d, unable to add\n",

		SDE_ERROR_ENC(sde_enc, "too many physical encoders %d\n",

			  sde_enc->num_phys_encs);

		return -EINVAL;

	}
@@ -612,7 +638,7 @@ static int sde_encoder_virt_add_phys_encs( 
		enc = sde_encoder_phys_vid_init(params);



		if (IS_ERR_OR_NULL(enc)) {

			DRM_ERROR("Failed to initialize phys vid enc: %ld\n",

			SDE_ERROR_ENC(sde_enc, "failed to init vid enc: %ld\n",

				PTR_ERR(enc));

			return enc == 0 ? -EINVAL : PTR_ERR(enc);

		}
@@ -625,7 +651,7 @@ static int sde_encoder_virt_add_phys_encs( 
		enc = sde_encoder_phys_cmd_init(params);



		if (IS_ERR_OR_NULL(enc)) {

			DRM_ERROR("Failed to initialize phys cmd enc: %ld\n",

			SDE_ERROR_ENC(sde_enc, "failed to init cmd enc: %ld\n",

				PTR_ERR(enc));

			return enc == 0 ? -EINVAL : PTR_ERR(enc);

		}
@@ -642,10 +668,15 @@ static int sde_encoder_virt_add_phys_enc_wb(struct sde_encoder_virt *sde_enc, 
{

	struct sde_encoder_phys *enc = NULL;



	DBG("");

	if (!sde_enc) {

		SDE_ERROR("invalid encoder\n");

		return -EINVAL;

	}



	SDE_DEBUG_ENC(sde_enc, "\n");



	if (sde_enc->num_phys_encs + 1 >= ARRAY_SIZE(sde_enc->phys_encs)) {

		DRM_ERROR("Too many physical encoders %d, unable to add\n",

		SDE_ERROR_ENC(sde_enc, "too many physical encoders %d\n",

			  sde_enc->num_phys_encs);

		return -EINVAL;

	}
@@ -653,7 +684,7 @@ static int sde_encoder_virt_add_phys_enc_wb(struct sde_encoder_virt *sde_enc, 
	enc = sde_encoder_phys_wb_init(params);



	if (IS_ERR_OR_NULL(enc)) {

		DRM_ERROR("Failed to initialize phys wb enc: %ld\n",

		SDE_ERROR_ENC(sde_enc, "failed to init wb enc: %ld\n",

			PTR_ERR(enc));

		return enc == 0 ? -EINVAL : PTR_ERR(enc);

	}
@@ -678,12 +709,18 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc, 
	};

	struct sde_enc_phys_init_params phys_params;



	if (!sde_enc || !sde_kms) {

		SDE_ERROR("invalid arg(s), enc %d kms %d\n",

				sde_enc != 0, sde_kms != 0);

		return -EINVAL;

	}



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

	phys_params.sde_kms = sde_kms;

	phys_params.parent = &sde_enc->base;

	phys_params.parent_ops = parent_ops;



	DBG("");

	SDE_DEBUG("\n");



	if (disp_info->intf_type == DRM_MODE_CONNECTOR_DSI) {

		*drm_enc_mode = DRM_MODE_ENCODER_DSI;
@@ -695,7 +732,7 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc, 
		*drm_enc_mode = DRM_MODE_ENCODER_VIRTUAL;

		intf_type = INTF_WB;

	} else {

		DRM_ERROR("Unsupported display interface type");

		SDE_ERROR_ENC(sde_enc, "unsupported display interface type\n");

		return -EINVAL;

	}
@@ -703,7 +740,7 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc, 


	sde_enc->display_num_of_h_tiles = disp_info->num_of_h_tiles;



	DBG("dsi_info->num_of_h_tiles %d", disp_info->num_of_h_tiles);

	SDE_DEBUG("dsi_info->num_of_h_tiles %d\n", disp_info->num_of_h_tiles);



	for (i = 0; i < disp_info->num_of_h_tiles && !ret; i++) {

		/*
@@ -722,7 +759,7 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc, 
			phys_params.split_role = ENC_ROLE_SOLO;

		}



		DBG("h_tile_instance %d = %d, split_role %d",

		SDE_DEBUG("h_tile_instance %d = %d, split_role %d\n",

				i, controller_id, phys_params.split_role);



		if (intf_type == INTF_WB) {
@@ -731,8 +768,8 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc, 
					sde_kms->catalog,

					intf_type, controller_id);

			if (phys_params.wb_idx == WB_MAX) {

				DRM_ERROR(

					"Error: could not get writeback: type %d, id %d\n",

				SDE_ERROR_ENC(sde_enc,

					"could not get wb: type %d, id %d\n",

					intf_type, controller_id);

				ret = -EINVAL;

			}
@@ -742,8 +779,8 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc, 
					sde_kms->catalog, intf_type,

					controller_id);

			if (phys_params.intf_idx == INTF_MAX) {

				DRM_ERROR(

					"Error: could not get writeback: type %d, id %d\n",

				SDE_ERROR_ENC(sde_enc,

					"could not get wb: type %d, id %d\n",

					intf_type, controller_id);

				ret = -EINVAL;

			}
@@ -759,7 +796,8 @@ static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc, 
						sde_enc,

						&phys_params);

			if (ret)

				DRM_ERROR("Failed to add phys encs\n");

				SDE_ERROR_ENC(sde_enc,

						"failed to add phys encs\n");

		}

	}
@@ -777,8 +815,6 @@ static struct drm_encoder *sde_encoder_virt_init( 
	int drm_enc_mode = DRM_MODE_ENCODER_NONE;

	int ret = 0;



	DBG("");



	sde_enc = kzalloc(sizeof(*sde_enc), GFP_KERNEL);

	if (!sde_enc) {

		ret = -ENOMEM;
@@ -799,12 +835,12 @@ static struct drm_encoder *sde_encoder_virt_init( 
	sde_enc->pending_kickoff_mask = 0;

	init_waitqueue_head(&sde_enc->pending_kickoff_wq);



	DBG("Created encoder");

	SDE_DEBUG_ENC(sde_enc, "created\n");



	return drm_enc;



fail:

	DRM_ERROR("Failed to create encoder\n");

	SDE_ERROR("failed to create encoder\n");

	if (drm_enc)

		sde_encoder_destroy(drm_enc);
@@ -816,13 +852,12 @@ int sde_encoder_wait_for_commit_done(struct drm_encoder *drm_enc) 
	struct sde_encoder_virt *sde_enc = NULL;

	int i, ret = 0;



	DBG("");



	if (!drm_enc) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid encoder\n");

		return -EINVAL;

	}

	sde_enc = to_sde_encoder_virt(drm_enc);

	SDE_DEBUG_ENC(sde_enc, "\n");



	for (i = 0; i < sde_enc->num_phys_encs; i++) {

		struct sde_encoder_phys *phys = sde_enc->phys_encs[i];
@@ -847,27 +882,28 @@ void sde_encoders_init(struct drm_device *dev) 
	u32 i = 0;

	u32 num_displays = 0;



	DBG("");

	SDE_DEBUG("\n");



	if (!dev || !dev->dev_private) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid device %d\n", dev != 0);

		return;

	}



	priv = dev->dev_private;

	priv->num_encoders = 0;

	if (!priv->kms || !priv->dm) {

		DRM_ERROR("Invalid pointer");

		SDE_ERROR("invalid priv pointer, kms %d dm %d\n",

				priv->kms != 0, priv->dm != 0);

		return;

	}

	disp_man = priv->dm;



	num_displays = display_manager_get_count(disp_man);

	DBG("num_displays %d", num_displays);

	SDE_DEBUG("num_displays %d\n", num_displays);



	if (num_displays > ARRAY_SIZE(priv->encoders)) {

		num_displays = ARRAY_SIZE(priv->encoders);

		DRM_ERROR("Too many displays found, capping to %d",

		SDE_ERROR("too many displays found, capping to %d\n",

				num_displays);

	}
@@ -878,19 +914,19 @@ void sde_encoders_init(struct drm_device *dev) 


		ret = display_manager_get_info_by_index(disp_man, i, &info);

		if (ret) {

			DRM_ERROR("Failed to get display info, %d", ret);

			SDE_ERROR("failed to get display info, %d\n", ret);

			return;

		}



		enc = sde_encoder_virt_init(dev, &info);

		if (IS_ERR_OR_NULL(enc)) {

			DRM_ERROR("Encoder initialization failed");

			SDE_ERROR("encoder initialization failed\n");

			return;

		}



		ret = display_manager_drm_init_by_index(disp_man, i, enc);

		if (ret) {

			DRM_ERROR("Display drm_init failed, %d", ret);

			SDE_ERROR("display drm_init failed, %d\n", ret);

			return;

		}

drivers/gpu/drm/msm/sde/sde_encoder_phys_cmd.c

+128 −46
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ 
 *

 */



#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__

#include <linux/jiffies.h>



#include "sde_encoder_phys.h"
@@ -19,6 +20,16 @@ 
#include "sde_core_irq.h"

#include "sde_formats.h"



#define SDE_DEBUG_CMDENC(e, fmt, ...) SDE_DEBUG("enc%d intf%d " fmt, \

		(e) && (e)->base.parent ? \

		(e)->base.parent->base.id : -1, \

		(e) ? (e)->intf_idx - INTF_0 : -1, ##__VA_ARGS__)



#define SDE_ERROR_CMDENC(e, fmt, ...) SDE_ERROR("enc%d intf%d " fmt, \

		(e) && (e)->base.parent ? \

		(e)->base.parent->base.id : -1, \

		(e) ? (e)->intf_idx - INTF_0 : -1, ##__VA_ARGS__)



#define to_sde_encoder_phys_cmd(x) \

	container_of(x, struct sde_encoder_phys_cmd, base)
@@ -45,6 +56,8 @@ static bool sde_encoder_phys_cmd_mode_fixup( 
		const struct drm_display_mode *mode,

		struct drm_display_mode *adj_mode)

{

	if (phys_enc)

		SDE_DEBUG_CMDENC(to_sde_encoder_phys_cmd(phys_enc), "\n");

	return true;

}
@@ -59,8 +72,13 @@ static void sde_encoder_phys_cmd_mode_set( 
	struct sde_rm_hw_iter iter;

	int i, instance;



	if (!phys_enc || !mode || !adj_mode) {

		SDE_ERROR("invalid arg(s), enc %d mode %d adj_mode %d\n",

				phys_enc != 0, mode != 0, adj_mode != 0);

		return;

	}

	phys_enc->cached_mode = *adj_mode;

	SDE_DEBUG("intf %d, caching mode:\n", cmd_enc->intf_idx);

	SDE_DEBUG_CMDENC(cmd_enc, "caching mode:\n");

	drm_mode_debug_printmodeline(adj_mode);



	instance = phys_enc->split_role == ENC_ROLE_SLAVE ? 1 : 0;
@@ -74,7 +92,8 @@ static void sde_encoder_phys_cmd_mode_set( 
	}



	if (IS_ERR_OR_NULL(phys_enc->hw_ctl)) {

		SDE_ERROR("failed init ctl: %ld\n", PTR_ERR(phys_enc->hw_ctl));

		SDE_ERROR_CMDENC(cmd_enc, "failed to init ctl: %ld\n",

				PTR_ERR(phys_enc->hw_ctl));

		phys_enc->hw_ctl = NULL;

		return;

	}
@@ -88,7 +107,7 @@ static void sde_encoder_phys_cmd_mode_set( 
	}



	if (IS_ERR_OR_NULL(cmd_enc->hw_pp)) {

		SDE_ERROR("failed init pingpong: %ld\n",

		SDE_ERROR_CMDENC(cmd_enc, "failed to init pingpong: %ld\n",

				PTR_ERR(cmd_enc->hw_pp));

		cmd_enc->hw_pp = NULL;

		phys_enc->hw_ctl = NULL;
@@ -100,9 +119,13 @@ static void sde_encoder_phys_cmd_mode_set( 
static void sde_encoder_phys_cmd_pp_tx_done_irq(void *arg, int irq_idx)

{

	struct sde_encoder_phys_cmd *cmd_enc = arg;

	struct sde_encoder_phys *phys_enc = &cmd_enc->base;

	struct sde_encoder_phys *phys_enc;

	int new_pending_cnt;



	if (!cmd_enc)

		return;



	phys_enc = &cmd_enc->base;

	new_pending_cnt = atomic_dec_return(&cmd_enc->pending_cnt);

	MSM_EVT(DEV(phys_enc), cmd_enc->hw_pp->idx, new_pending_cnt);
@@ -119,6 +142,9 @@ static void sde_encoder_phys_cmd_pp_rd_ptr_irq(void *arg, int irq_idx) 
	struct sde_encoder_phys_cmd *cmd_enc = arg;

	struct sde_encoder_phys *phys_enc = &cmd_enc->base;



	if (!cmd_enc)

		return;



	phys_enc->parent_ops.handle_vblank_virt(phys_enc->parent);

}
@@ -134,13 +160,17 @@ static int sde_encoder_phys_cmd_register_pp_irq( 
	struct sde_irq_callback irq_cb;

	int ret = 0;



	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return -EINVAL;

	}

	*irq_idx = sde_core_irq_idx_lookup(phys_enc->sde_kms, intr_type,

			cmd_enc->hw_pp->idx);

	if (*irq_idx < 0) {

		DRM_ERROR(

			"Failed to lookup IRQ index for %s with pp=%d",

		SDE_ERROR_CMDENC(cmd_enc,

			"failed to lookup IRQ index for %s with pp=%d\n",

			irq_name,

			cmd_enc->hw_pp->idx);

			cmd_enc->hw_pp->idx - PINGPONG_0);

		return -EINVAL;

	}
@@ -149,16 +179,18 @@ static int sde_encoder_phys_cmd_register_pp_irq( 
	ret = sde_core_irq_register_callback(phys_enc->sde_kms, *irq_idx,

			&irq_cb);

	if (ret) {

		DRM_ERROR("Failed to register IRQ callback %s", irq_name);

		SDE_ERROR_CMDENC(cmd_enc,

				"failed to register IRQ callback %s\n",

				irq_name);

		return ret;

	}



	ret = sde_core_irq_enable(phys_enc->sde_kms, irq_idx, 1);

	if (ret) {

		DRM_ERROR(

			"Failed to enable IRQ for %s, pp %d, irq_idx=%d",

		SDE_ERROR_CMDENC(cmd_enc,

			"failed to enable IRQ for %s, pp %d, irq_idx %d\n",

			irq_name,

			cmd_enc->hw_pp->idx,

			cmd_enc->hw_pp->idx - PINGPONG_0,

			*irq_idx);

		*irq_idx = -EINVAL;
@@ -168,9 +200,9 @@ static int sde_encoder_phys_cmd_register_pp_irq( 
		return ret;

	}



	DBG("registered IRQ %s for pp %d, irq_idx=%d",

	SDE_DEBUG_CMDENC(cmd_enc, "registered IRQ %s for pp %d, irq_idx %d\n",

			irq_name,

			cmd_enc->hw_pp->idx,

			cmd_enc->hw_pp->idx - PINGPONG_0,

			*irq_idx);



	return ret;
@@ -183,12 +215,17 @@ static int sde_encoder_phys_cmd_unregister_pp_irq( 
	struct sde_encoder_phys_cmd *cmd_enc =

			to_sde_encoder_phys_cmd(phys_enc);



	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return -EINVAL;

	}



	sde_core_irq_disable(phys_enc->sde_kms, &irq_idx, 1);

	sde_core_irq_register_callback(phys_enc->sde_kms, irq_idx,

			NULL);



	DBG("unregister IRQ for pp %d, irq_idx=%d\n",

			cmd_enc->hw_pp->idx,

	SDE_DEBUG_CMDENC(cmd_enc, "unregistered IRQ for pp %d, irq_idx %d\n",

			cmd_enc->hw_pp->idx - PINGPONG_0,

			irq_idx);



	return 0;
@@ -206,11 +243,16 @@ static void sde_encoder_phys_cmd_tearcheck_config( 
	struct msm_drm_private *priv;

	struct sde_kms *sde_kms;



	DBG("intf %d, pp %d", cmd_enc->intf_idx, cmd_enc->hw_pp->idx);

	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}



	SDE_DEBUG_CMDENC(cmd_enc, "pp %d\n", cmd_enc->hw_pp->idx - PINGPONG_0);



	if (!cmd_enc->hw_pp->ops.setup_tearcheck ||

		!cmd_enc->hw_pp->ops.enable_tearcheck) {

		DBG("tearcheck unsupported");

		SDE_DEBUG_CMDENC(cmd_enc, "tearcheck not supported\n");

		return;

	}
@@ -227,7 +269,7 @@ static void sde_encoder_phys_cmd_tearcheck_config( 
	 */

	vsync_hz = sde_power_clk_get_rate(&priv->phandle, "vsync_clk");

	if (!vsync_hz) {

		DBG("invalid vsync clock rate");

		SDE_DEBUG_CMDENC(cmd_enc, "invalid vsync clock rate\n");

		return;

	}
@@ -246,16 +288,21 @@ static void sde_encoder_phys_cmd_tearcheck_config( 
	tc_cfg.start_pos = mode->vdisplay;

	tc_cfg.rd_ptr_irq = mode->vdisplay + 1;



	DBG("tc %d vsync_clk_speed_hz %u mode->vtotal %u mode->vrefresh %u",

		cmd_enc->hw_pp->idx, vsync_hz, mode->vtotal, mode->vrefresh);

	DBG("tc %d enable %u start_pos %u rd_ptr_irq %u",

		tc_enable, cmd_enc->hw_pp->idx, tc_cfg.start_pos,

	SDE_DEBUG_CMDENC(cmd_enc,

		"tc %d vsync_clk_speed_hz %u vtotal %u vrefresh %u\n",

		cmd_enc->hw_pp->idx - PINGPONG_0, vsync_hz,

		mode->vtotal, mode->vrefresh);

	SDE_DEBUG_CMDENC(cmd_enc,

		"tc %d enable %u start_pos %u rd_ptr_irq %u\n",

		cmd_enc->hw_pp->idx - PINGPONG_0, tc_enable, tc_cfg.start_pos,

		tc_cfg.rd_ptr_irq);

	DBG("tc %d hw_vsync_mode %u vsync_count %u vsync_init_val %u",

		cmd_enc->hw_pp->idx, tc_cfg.hw_vsync_mode, tc_cfg.vsync_count,

		tc_cfg.vsync_init_val);

	DBG("tc %d sync_cfgheight %u sync_thresh_start %u sync_thresh_cont %u",

		cmd_enc->hw_pp->idx, tc_cfg.sync_cfg_height,

	SDE_DEBUG_CMDENC(cmd_enc,

		"tc %d hw_vsync_mode %u vsync_count %u vsync_init_val %u\n",

		cmd_enc->hw_pp->idx - PINGPONG_0, tc_cfg.hw_vsync_mode,

		tc_cfg.vsync_count, tc_cfg.vsync_init_val);

	SDE_DEBUG_CMDENC(cmd_enc,

		"tc %d cfgheight %u thresh_start %u thresh_cont %u\n",

		cmd_enc->hw_pp->idx - PINGPONG_0, tc_cfg.sync_cfg_height,

		tc_cfg.sync_threshold_start, tc_cfg.sync_threshold_continue);



	cmd_enc->hw_pp->ops.setup_tearcheck(cmd_enc->hw_pp, &tc_cfg);
@@ -269,11 +316,14 @@ static void sde_encoder_phys_cmd_pingpong_config( 
		to_sde_encoder_phys_cmd(phys_enc);

	struct sde_hw_intf_cfg intf_cfg = { 0 };



	if (!phys_enc->hw_ctl->ops.setup_intf_cfg)

	if (!phys_enc || !phys_enc->hw_ctl ||

			!phys_enc->hw_ctl->ops.setup_intf_cfg) {

		SDE_ERROR("invalid arg(s), enc %d\n", phys_enc != 0);

		return;

	}



	DBG("intf %d pp %d, enabling mode:", cmd_enc->intf_idx,

			cmd_enc->hw_pp->idx);

	SDE_DEBUG_CMDENC(cmd_enc, "pp %d, enabling mode:\n",

			cmd_enc->hw_pp->idx - PINGPONG_0);

	drm_mode_debug_printmodeline(&phys_enc->cached_mode);



	intf_cfg.intf = cmd_enc->intf_idx;
@@ -293,7 +343,11 @@ static void sde_encoder_phys_cmd_split_config( 
	struct sde_hw_mdp *hw_mdptop = phys_enc->hw_mdptop;

	struct split_pipe_cfg cfg = { 0 };



	DBG("enable %d", enable);

	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}

	SDE_DEBUG_CMDENC(cmd_enc, "enable %d\n", enable);



	cfg.en = enable;

	cfg.mode = INTF_MODE_CMD;
@@ -312,7 +366,11 @@ static int sde_encoder_phys_cmd_control_vblank_irq( 
		to_sde_encoder_phys_cmd(phys_enc);

	int ret = 0;



	DBG("enable %d", enable);

	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return -EINVAL;

	}

	SDE_DEBUG_CMDENC(cmd_enc, "enable %d\n", enable);



	/* Slave encoders don't report vblank */

	if (sde_encoder_phys_cmd_is_master(phys_enc)) {
@@ -328,8 +386,9 @@ static int sde_encoder_phys_cmd_control_vblank_irq( 
	}



	if (ret)

		DRM_ERROR("control vblank irq error %d, enable %d\n", ret,

				enable);

		SDE_ERROR_CMDENC(cmd_enc,

				"control vblank irq error %d, enable %d\n",

				ret, enable);



	return ret;

}
@@ -338,14 +397,18 @@ static void sde_encoder_phys_cmd_enable(struct sde_encoder_phys *phys_enc) 
{

	struct sde_encoder_phys_cmd *cmd_enc =

		to_sde_encoder_phys_cmd(phys_enc);

	struct sde_hw_ctl *ctl = phys_enc->hw_ctl;

	struct sde_hw_ctl *ctl;

	u32 flush_mask;

	int ret = 0;



	if (WARN_ON(phys_enc->enable_state == SDE_ENC_ENABLED))

	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}

	SDE_DEBUG_CMDENC(cmd_enc, "pp %d\n", cmd_enc->hw_pp->idx - PINGPONG_0);



	DBG("intf %d, pp %d", cmd_enc->intf_idx, cmd_enc->hw_pp->idx);

	if (WARN_ON(phys_enc->enable_state == SDE_ENC_ENABLED))

		return;



	/*

	 * Only master configures master/slave configuration, so no slave check
@@ -375,12 +438,13 @@ static void sde_encoder_phys_cmd_enable(struct sde_encoder_phys *phys_enc) 
		return;

	}



	ctl = phys_enc->hw_ctl;

	ctl->ops.get_bitmask_intf(ctl, &flush_mask, cmd_enc->intf_idx);

	ctl->ops.update_pending_flush(ctl, flush_mask);

	phys_enc->enable_state = SDE_ENC_ENABLED;



	DBG("Update pending flush CTL_ID %d flush_mask %x, INTF %d",

			ctl->idx, flush_mask, cmd_enc->intf_idx);

	SDE_DEBUG_CMDENC(cmd_enc, "update pending flush ctl %d flush_mask %x\n",

			ctl->idx - CTL_0, flush_mask);

}



static void sde_encoder_phys_cmd_disable(struct sde_encoder_phys *phys_enc)
@@ -388,7 +452,11 @@ static void sde_encoder_phys_cmd_disable(struct sde_encoder_phys *phys_enc) 
	struct sde_encoder_phys_cmd *cmd_enc =

		to_sde_encoder_phys_cmd(phys_enc);



	DBG("intf %d, pp %d", cmd_enc->intf_idx, cmd_enc->hw_pp->idx);

	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}

	SDE_DEBUG_CMDENC(cmd_enc, "pp %d\n", cmd_enc->hw_pp->idx - PINGPONG_0);



	if (WARN_ON(phys_enc->enable_state == SDE_ENC_DISABLED))

		return;
@@ -407,6 +475,10 @@ static void sde_encoder_phys_cmd_destroy(struct sde_encoder_phys *phys_enc) 
	struct sde_encoder_phys_cmd *cmd_enc =

		to_sde_encoder_phys_cmd(phys_enc);



	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}

	kfree(cmd_enc);

}
@@ -418,7 +490,11 @@ static void sde_encoder_phys_cmd_get_hw_resources( 
	struct sde_encoder_phys_cmd *cmd_enc =

		to_sde_encoder_phys_cmd(phys_enc);



	DBG("intf %d", cmd_enc->intf_idx);

	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}

	SDE_DEBUG_CMDENC(cmd_enc, "\n");

	hw_res->intfs[cmd_enc->intf_idx - INTF_0] = INTF_MODE_CMD;

}
@@ -442,7 +518,11 @@ static void sde_encoder_phys_cmd_prepare_for_kickoff( 
			to_sde_encoder_phys_cmd(phys_enc);

	int new_pending_cnt;



	DBG("intf %d, pp %d", cmd_enc->intf_idx, cmd_enc->hw_pp->idx);

	if (!phys_enc) {

		SDE_ERROR("invalid encoder\n");

		return;

	}

	SDE_DEBUG_CMDENC(cmd_enc, "pp %d\n", cmd_enc->hw_pp->idx - PINGPONG_0);



	/*

	 * Mark kickoff request as outstanding. If there are more than one,
@@ -452,8 +532,9 @@ static void sde_encoder_phys_cmd_prepare_for_kickoff( 
	*need_to_wait = new_pending_cnt != 1;



	if (*need_to_wait)

		SDE_DEBUG("intf %d pp %d needs to wait, new_pending_cnt %d",

				cmd_enc->intf_idx, cmd_enc->hw_pp->idx,

		SDE_DEBUG_CMDENC(cmd_enc,

				"pp %d needs to wait, new_pending_cnt %d",

				cmd_enc->hw_pp->idx - PINGPONG_0,

				new_pending_cnt);

	MSM_EVT(DEV(phys_enc), cmd_enc->hw_pp->idx, new_pending_cnt);

}
@@ -488,11 +569,12 @@ struct sde_encoder_phys *sde_encoder_phys_cmd_init( 
	struct sde_hw_mdp *hw_mdp;

	int ret = 0;



	DBG("intf %d", p->intf_idx);

	SDE_DEBUG("intf %d\n", p->intf_idx - INTF_0);



	cmd_enc = kzalloc(sizeof(*cmd_enc), GFP_KERNEL);

	if (!cmd_enc) {

		ret = -ENOMEM;

		SDE_ERROR("failed to allocate\n");

		goto fail;

	}

	phys_enc = &cmd_enc->base;
@@ -521,7 +603,7 @@ struct sde_encoder_phys *sde_encoder_phys_cmd_init( 


	init_waitqueue_head(&cmd_enc->pp_tx_done_wq);



	DBG("Created sde_encoder_phys_cmd for intf %d", cmd_enc->intf_idx);

	SDE_DEBUG_CMDENC(cmd_enc, "created\n");



	return phys_enc;

drivers/gpu/drm/msm/sde/sde_encoder_phys_vid.c

+143 −68

File changed.

Preview size limit exceeded, changes collapsed.