C++ PSB_DEBUG_ENTRY函数代码示例

void mdfld_panel_generic_dsi_dbi_mode_set(struct drm_encoder *encoder,
				struct drm_display_mode *mode,
				struct drm_display_mode *adjusted_mode)
{
	struct drm_device *dev = encoder->dev;
	struct drm_psb_private *dev_priv =
		(struct drm_psb_private *)dev->dev_private;
	struct mdfld_dsi_encoder *dsi_encoder = MDFLD_DSI_ENCODER(encoder);
	struct mdfld_dsi_config *dsi_config =
		mdfld_dsi_encoder_get_config(dsi_encoder);
	struct mdfld_dsi_connector *dsi_connector = dsi_config->connector;
	int pipe = dsi_connector->pipe;
	int err = 0;

	PSB_DEBUG_ENTRY("type %s\n", (pipe == 2) ? "MIPI2" : "MIPI");
	PSB_DEBUG_ENTRY("h %d v %d\n", mode->hdisplay, mode->vdisplay);

	/* TODO: this looks ugly, try to move it to CRTC mode setting */
	if (pipe == 2)
		dev_priv->pipeconf2 |= PIPEACONF_DSR;
	else
		dev_priv->pipeconf |= PIPEACONF_DSR;

	if (err)
		DRM_ERROR("mode set failed\n");
	else
		PSB_DEBUG_ENTRY("mode set done successfully\n");

	return;
}

void mdfld_dsi_dpi_set_color_mode(struct mdfld_dsi_config *dsi_config , bool on)
{
	struct mdfld_dsi_pkg_sender *sender =
		mdfld_dsi_get_pkg_sender(dsi_config);
	int err;
	u32  spk_pkg =  (on == true) ? MDFLD_DSI_DPI_SPK_COLOR_MODE_ON :
		MDFLD_DSI_DPI_SPK_COLOR_MODE_OFF;


	PSB_DEBUG_ENTRY("Turn  color mode %s  pkg value= %d...\n",
			(on ? "on" : "off"), spk_pkg);

	if (!sender) {
		DRM_ERROR("Failed to get DSI packet sender\n");
		return ;
	}

	/*send turn on/off color mode packet*/
	err = mdfld_dsi_send_dpi_spk_pkg_hs(sender,
			spk_pkg);
	if (err) {
		DRM_ERROR("Failed to send turn on packet\n");
		return ;
	}
	PSB_DEBUG_ENTRY("Turn  color mode %s successful.\n",
			(on ? "on" : "off"));
	return;
}

static int
mdfld_h8c7_get_power_state(struct mdfld_dsi_config *dsi_config,
				int pipe)
{
	struct mdfld_dsi_hw_registers *regs;
	struct mdfld_dsi_hw_context *ctx;
	struct drm_device *dev;
	int	powerstatus = 0;

	PSB_DEBUG_ENTRY("Getting power state...");

	if (!dsi_config)
		return -EINVAL;

	regs = &dsi_config->regs;
	ctx = &dsi_config->dsi_hw_context;
	dev = dsi_config->dev;

	/* for get date from panel side is not easy,
	so here use display side setting to judge
	wheather panel have enabled or not */
	if ((REG_READ(regs->dpll_reg) & BIT31) &&
		(REG_READ(regs->pipeconf_reg) & BIT30) &&
		(REG_READ(regs->mipi_reg) & BIT31))
		powerstatus = MDFLD_DSI_PANEL_POWER_ON;
	else
		powerstatus = MDFLD_DSI_PANEL_POWER_OFF;

	PSB_DEBUG_ENTRY("Getting power state...%s",
		powerstatus ? "OFF" : "ON");
	return powerstatus;
}

static
void mdfld_dsi_dpi_dpms(struct drm_encoder *encoder, int mode)
{
    struct mdfld_dsi_encoder *dsi_encoder;
    struct mdfld_dsi_config *dsi_config;
    struct drm_device *dev;
    struct drm_psb_private *dev_priv;

    if (!(drm_psb_use_cases_control & PSB_DPMS_ENABLE))
        return;

    dsi_encoder = MDFLD_DSI_ENCODER(encoder);
    dsi_config = mdfld_dsi_encoder_get_config(dsi_encoder);
    dev = dsi_config->dev;
    dev_priv = dev->dev_private;

    PSB_DEBUG_ENTRY(
        "%s\n", (mode == DRM_MODE_DPMS_ON ? "on" : "off"));
    if (!gbdispstatus) {
        PSB_DEBUG_ENTRY(
            "panel in suspend status, skip turn on/off from DMPS");
        return ;
    }

    mutex_lock(&dev_priv->dpms_mutex);
    dev_priv->dpms_on_off = true;
    if (mode == DRM_MODE_DPMS_ON)
        mdfld_dsi_dpi_set_power(encoder, true);
    else
        mdfld_dsi_dpi_set_power(encoder, false);
    dev_priv->dpms_on_off = false;
    mutex_unlock(&dev_priv->dpms_mutex);
}

int mdfld_dsi_dsr_update_panel_fb(struct mdfld_dsi_config *dsi_config)
{
	struct mdfld_dsi_dsr *dsr;
	struct mdfld_dsi_pkg_sender *sender;
	int err = 0;

	if (!dsi_config) {
		DRM_ERROR("Invalid parameter\n");
		return -EINVAL;
	}

	dsr = dsi_config->dsr;

	if (!IS_ANN(dev)) {
		/*if no dsr attached, return 0*/
		if (!dsr)
			return 0;
	}

	PSB_DEBUG_ENTRY("\n");

	if (dsi_config->type == MDFLD_DSI_ENCODER_DPI)
		return 0;
	mutex_lock(&dsi_config->context_lock);

	if (!dsi_config->dsi_hw_context.panel_on) {
		PSB_DEBUG_ENTRY(
		"if screen off, update fb is not allowed\n");
		err = -EINVAL;
		goto update_fb_out;
	}

	/*no pending fb updates, go ahead to send out write_mem_start*/
	PSB_DEBUG_ENTRY("send out write_mem_start\n");
	sender = mdfld_dsi_get_pkg_sender(dsi_config);
	if (!sender) {
		DRM_ERROR("No sender\n");
		err = -EINVAL;
		goto update_fb_out;
	}

	err = mdfld_dsi_send_dcs(sender, write_mem_start,
				NULL, 0, CMD_DATA_SRC_PIPE,
				MDFLD_DSI_SEND_PACKAGE);
	if (err) {
		DRM_ERROR("Failed to send write_mem_start");
		err = -EINVAL;
		goto update_fb_out;
	}

	/*clear free count*/
	dsr->free_count = 0;

update_fb_out:
	mutex_unlock(&dsi_config->context_lock);
	return err;
}

int psb_set_brightness(struct backlight_device *bd)
{
	struct drm_device *dev =
	    (struct drm_device *)bl_get_data(psb_backlight_device);
	struct drm_psb_private *dev_priv =
	    (struct drm_psb_private *)dev->dev_private;
	int level;

	if (bd != NULL)
		level = bd->props.brightness;
	else
		level = lastFailedBrightness;

	DRM_DEBUG_DRIVER("backlight level set to %d\n", level);
	PSB_DEBUG_ENTRY("[DISPLAY] %s: level is %d\n", __func__, level);	//DIV5-MM-DISPLAY-NC-LCM_INIT-00

	/* Perform value bounds checking */
	if (level < BRIGHTNESS_MIN_LEVEL)
		level = BRIGHTNESS_MIN_LEVEL;

	lastFailedBrightness = -1;

	if (IS_FLDS(dev)) {
		u32 adjusted_level = 0;

		/* Adjust the backlight level with the percent in
		 * dev_priv->blc_adj2;
		 */
		adjusted_level = level * dev_priv->blc_adj2;
		adjusted_level = adjusted_level / BLC_ADJUSTMENT_MAX / 100;
		dev_priv->brightness_adjusted = adjusted_level;

#ifndef CONFIG_MID_DSI_DPU
		if (!(dev_priv->dsr_fb_update & MDFLD_DSR_MIPI_CONTROL)
				&& (dev_priv->dbi_panel_on
					|| dev_priv->dbi_panel_on2)) {
			mdfld_dsi_dbi_exit_dsr(dev,
					MDFLD_DSR_MIPI_CONTROL,
					0, 0);
			PSB_DEBUG_ENTRY
				("Out of DSR before set brightness to %d.\n",
				 adjusted_level);
		}
#endif

		PSB_DEBUG_BL("Adjusted Backlight value: %d\n", adjusted_level);
		mdfld_dsi_brightness_control(dev, 0, adjusted_level);
		mdfld_dsi_brightness_control(dev, 2, adjusted_level);
	}

	/* cache the brightness for later use */
	psb_brightness = level;
	return 0;
}

/*
 * Calculate the dpi time basing on a given drm mode @mode
 * return 0 on success.
 * FIXME: I was using proposed mode value for calculation, may need to
 * use crtc mode values later
 */
int mdfld_dsi_dpi_timing_calculation(struct drm_display_mode *mode,
                                     struct mdfld_dsi_dpi_timing *dpi_timing,
                                     int num_lane, int bpp)
{
    int pclk_hsync, pclk_hfp, pclk_hbp, pclk_hactive;
    int pclk_vsync, pclk_vfp, pclk_vbp, pclk_vactive;

    if(!mode || !dpi_timing) {
        DRM_ERROR("Invalid parameter\n");
        return -EINVAL;
    }

    PSB_DEBUG_ENTRY("pclk %d, hdisplay %d, hsync_start %d, hsync_end %d, htotal %d\n",
                    mode->clock, mode->hdisplay, mode->hsync_start,
                    mode->hsync_end, mode->htotal);
    PSB_DEBUG_ENTRY("vdisplay %d, vsync_start %d, vsync_end %d, vtotal %d\n",
                    mode->vdisplay, mode->vsync_start,
                    mode->vsync_end, mode->vtotal);

    pclk_hactive = mode->hdisplay;
    pclk_hfp = mode->hsync_start - mode->hdisplay;
    pclk_hsync = mode->hsync_end - mode->hsync_start;
    pclk_hbp = mode->htotal - mode->hsync_end;

    pclk_vactive = mode->vdisplay;
    pclk_vfp = mode->vsync_start - mode->vdisplay;
    pclk_vsync = mode->vsync_end - mode->vsync_start;
    pclk_vbp = mode->vtotal - mode->vsync_end;

    /*
     * byte clock counts were calculated by following formula
     * bclock_count = pclk_count * bpp / num_lane / 8
     */
    dpi_timing->hsync_count = mdfld_dsi_dpi_to_byte_clock_count(pclk_hsync, num_lane, bpp);
    dpi_timing->hbp_count = mdfld_dsi_dpi_to_byte_clock_count(pclk_hbp, num_lane, bpp);
    dpi_timing->hfp_count = mdfld_dsi_dpi_to_byte_clock_count(pclk_hfp, num_lane, bpp);
    dpi_timing->hactive_count = mdfld_dsi_dpi_to_byte_clock_count(pclk_hactive, num_lane, bpp);

    dpi_timing->vsync_count = mdfld_dsi_dpi_to_byte_clock_count(pclk_vsync, num_lane, bpp);
    dpi_timing->vbp_count = mdfld_dsi_dpi_to_byte_clock_count(pclk_vbp, num_lane, bpp);
    dpi_timing->vfp_count = mdfld_dsi_dpi_to_byte_clock_count(pclk_vfp, num_lane, bpp);

    PSB_DEBUG_ENTRY("DPI timings: %d, %d, %d, %d, %d, %d, %d\n",
                    dpi_timing->hsync_count, dpi_timing->hbp_count,
                    dpi_timing->hfp_count, dpi_timing->hactive_count,
                    dpi_timing->vsync_count, dpi_timing->vbp_count,
                    dpi_timing->vfp_count);

    return 0;
}

/**
 * init dsr structure
 */
int mdfld_dsi_dsr_init(struct mdfld_dsi_config *dsi_config)
{
	struct mdfld_dsi_dsr *dsr;

	PSB_DEBUG_ENTRY("\n");

	if (!dsi_config) {
		DRM_ERROR("Invalid parameter\n");
		return -EINVAL;
	}

	/*check panel type*/
	if (dsi_config->type == MDFLD_DSI_ENCODER_DPI) {
		DRM_INFO("%s: Video mode panel, disabling DSR\n", __func__);
		return 0;
	}

	dsr = kzalloc(sizeof(struct mdfld_dsi_dsr), GFP_KERNEL);
	if (!dsr) {
		DRM_ERROR("No memory\n");
		return -ENOMEM;
	}

	/*init reference count*/
	dsr->ref_count = 0;

	/*init free count*/
	dsr->free_count = 0;

	/*init dsr enabled*/
	dsr->dsr_enabled = 0;

	/*set dsr state*/
	dsr->dsr_state = DSR_INIT;

	/*init power on/off works*/
	INIT_WORK(&dsr->power_off_work, dsr_power_off_work);
	INIT_WORK(&dsr->power_on_work, dsr_power_on_work);

	/*init dsi config*/
	dsr->dsi_config = dsi_config;

	dsi_config->dsr = dsr;

	PSB_DEBUG_ENTRY("successfully\n");

	return 0;
}

static struct drm_display_mode *sharp5_cmd_get_config_mode(void)
{
	struct drm_display_mode *mode;

	PSB_DEBUG_ENTRY("\n");

	mode = kzalloc(sizeof(*mode), GFP_KERNEL);
	if (!mode)
		return NULL;

	mode->hdisplay = 1080;
	mode->hsync_start = 1168;
	mode->hsync_end = 1200;
	mode->htotal = 1496;

	mode->vdisplay = 1920;
	mode->vsync_start = 1923;
	mode->vsync_end = 1926;
	mode->vtotal = 1987;

	mode->vrefresh = 60;
	mode->clock =  mode->vrefresh * mode->vtotal * mode->htotal / 1000;
	mode->type |= DRM_MODE_TYPE_PREFERRED;

	drm_mode_set_name(mode);
	drm_mode_set_crtcinfo(mode, 0);

	return mode;
}

static void sharp5_cmd_controller_init(struct mdfld_dsi_config *dsi_config)
{
	struct mdfld_dsi_hw_context *hw_ctx =
				&dsi_config->dsi_hw_context;

	PSB_DEBUG_ENTRY("\n");

	/*reconfig lane configuration*/
	dsi_config->lane_count = 4;
	dsi_config->lane_config = MDFLD_DSI_DATA_LANE_4_0;
	hw_ctx->cck_div = 1;
	hw_ctx->pll_bypass_mode = 0;

	hw_ctx->mipi_control = 0x0;
	hw_ctx->intr_en = 0xFFFFFFFF;
	hw_ctx->hs_tx_timeout = 0xFFFFFF;
	hw_ctx->lp_rx_timeout = 0xFFFFFF;
	hw_ctx->device_reset_timer = 0xffff;
	hw_ctx->turn_around_timeout = 0x14;
	hw_ctx->high_low_switch_count = 0x2B;
	hw_ctx->clk_lane_switch_time_cnt =  0x2b0014;
	hw_ctx->lp_byteclk = 0x6;
	hw_ctx->dphy_param = 0x2a18681f;
	hw_ctx->eot_disable = 0x0;
	hw_ctx->init_count = 0xf0;
	hw_ctx->dbi_bw_ctrl = 1100;
	hw_ctx->hs_ls_dbi_enable = 0x0;
	hw_ctx->dsi_func_prg = ((DBI_DATA_WIDTH_OPT2 << 13) |
				dsi_config->lane_count);

	hw_ctx->mipi = PASS_FROM_SPHY_TO_AFE |
			BANDGAP_CHICKEN_BIT |
		TE_TRIGGER_GPIO_PIN;
	hw_ctx->video_mode_format = 0xf;
}

static
bool mdfld_generic_dsi_dbi_mode_fixup(struct drm_encoder *encoder,
		const struct drm_display_mode *mode,
		struct drm_display_mode *adjusted_mode)
{
	struct mdfld_dsi_encoder *dsi_encoder = MDFLD_DSI_ENCODER(encoder);
	struct mdfld_dsi_dbi_output *dbi_output =
		MDFLD_DSI_DBI_OUTPUT(dsi_encoder);
	struct drm_display_mode *fixed_mode = dbi_output->panel_fixed_mode;

	PSB_DEBUG_ENTRY("\n");

	if (fixed_mode) {
		adjusted_mode->hdisplay = fixed_mode->hdisplay;
		adjusted_mode->hsync_start = fixed_mode->hsync_start;
		adjusted_mode->hsync_end = fixed_mode->hsync_end;
		adjusted_mode->htotal = fixed_mode->htotal;
		adjusted_mode->vdisplay = fixed_mode->vdisplay;
		adjusted_mode->vsync_start = fixed_mode->vsync_start;
		adjusted_mode->vsync_end = fixed_mode->vsync_end;
		adjusted_mode->vtotal = fixed_mode->vtotal;
		adjusted_mode->clock = fixed_mode->clock;
		drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
	}

	return true;
}

static
void mdfld_generic_dsi_dbi_restore(struct drm_encoder *encoder)
{
	struct mdfld_dsi_encoder *dsi_encoder;
	struct mdfld_dsi_config *dsi_config;
	struct drm_device *dev;
	int pipe;

	PSB_DEBUG_ENTRY("\n");

	if (!encoder)
		return;

	dsi_encoder = MDFLD_DSI_ENCODER(encoder);
	dsi_config = mdfld_dsi_encoder_get_config(dsi_encoder);
	dev = dsi_config->dev;
	pipe = mdfld_dsi_encoder_get_pipe(dsi_encoder);

	DCLockMutex();
	mdfld_generic_dsi_dbi_set_power(encoder, true);

	DCAttachPipe(pipe);
	DC_MRFLD_onPowerOn(pipe);
	DCUnLockMutex();
}

static
void mdfld_generic_dsi_dbi_save(struct drm_encoder *encoder)
{
	struct mdfld_dsi_encoder *dsi_encoder;
	struct mdfld_dsi_config *dsi_config;
	struct drm_device *dev;
	int pipe;

	PSB_DEBUG_ENTRY("\n");

	if (!encoder)
		return;

	dsi_encoder = MDFLD_DSI_ENCODER(encoder);
	dsi_config = mdfld_dsi_encoder_get_config(dsi_encoder);
	dev = dsi_config->dev;
	pipe = mdfld_dsi_encoder_get_pipe(dsi_encoder);

	DCLockMutex();
	mdfld_generic_dsi_dbi_set_power(encoder, false);

	drm_handle_vblank(dev, pipe);

	/* Turn off vsync (TE) interrupt. */
	drm_vblank_off(dev, pipe);

	/* Make the pending flip request as completed. */
	DCUnAttachPipe(pipe);
	DC_MRFLD_onPowerOff(pipe);
	DCUnLockMutex();
}

static int mdfld_dsi_sharp25x16_set_brightness(struct mdfld_dsi_config *dsi_config,
		int level)
{
	struct mdfld_dsi_pkg_sender *sender =
		mdfld_dsi_get_pkg_sender(dsi_config);
	struct drm_device *dev = dsi_config->dev;
	u8 duty_val = 0;

	PSB_DEBUG_ENTRY("level = %d\n", level);

	if (!sender) {
		DRM_ERROR("Failed to get DSI packet sender\n");
		return -EINVAL;
	}

	duty_val = (0xFF * level) / 255;
	if (duty_val < 12)
		duty_val = 0;
	sharp_set_brightness[2] = duty_val;
	mdfld_dsi_send_gen_long_hs(sender, sharp_set_brightness,
				3,
				MDFLD_DSI_SEND_PACKAGE);

	REG_WRITE(MIPIA_HS_GEN_CTRL_REG, 5);
	return 0;
}

static
int mdfld_dsi_h8c7_cmd_panel_reset(struct mdfld_dsi_config *dsi_config)
{
	static int mipi_reset_gpio;
	int ret = 0;

	PSB_DEBUG_ENTRY("\n");

	if (mipi_reset_gpio == 0) {
		ret = get_gpio_by_name("mipi-reset");
		if (ret < 0) {
			DRM_ERROR("Faild to get panel reset gpio, " \
				  "use default reset pin\n");
			ret = 128;
		}

		mipi_reset_gpio = ret;

		ret = gpio_request(mipi_reset_gpio, "mipi_display");
		if (ret) {
			DRM_ERROR("Faild to request panel reset gpio\n");
			return -EINVAL;
		}

		gpio_direction_output(mipi_reset_gpio, 0);
	}

	gpio_set_value_cansleep(mipi_reset_gpio, 0);
	mdelay(11);

	gpio_set_value_cansleep(mipi_reset_gpio, 1);
	mdelay(5);

	return 0;
}