1015 lines
27 KiB
C
1015 lines
27 KiB
C
/*
|
|
* Copyright © 2010 Intel Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Authors:
|
|
* jim liu <jim.liu@intel.com>
|
|
* Jackie Li<yaodong.li@intel.com>
|
|
*/
|
|
|
|
#include "mdfld_dsi_output.h"
|
|
#include "mdfld_dsi_dbi.h"
|
|
#include "mdfld_dsi_dpi.h"
|
|
#include "mdfld_output.h"
|
|
#include <asm/intel_scu_ipc.h>
|
|
#include "mdfld_dsi_pkg_sender.h"
|
|
#include <linux/pm_runtime.h>
|
|
#include <linux/moduleparam.h>
|
|
|
|
#define MDFLD_DSI_BRIGHTNESS_MAX_LEVEL 100
|
|
|
|
static int CABC_control = 1;
|
|
static int LABC_control = 1;
|
|
|
|
module_param (CABC_control, int, 0644);
|
|
module_param (LABC_control, int, 0644);
|
|
|
|
/**
|
|
* make these MCS command global
|
|
* we don't need 'movl' everytime we send them.
|
|
* FIXME: these datas were provided by OEM, we should get them from GCT.
|
|
**/
|
|
static u32 mdfld_dbi_mcs_hysteresis[] = {
|
|
0x42000f57, 0x8c006400, 0xff00bf00, 0xffffffff,
|
|
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
|
|
0x38000aff, 0x82005000, 0xff00ab00, 0xffffffff,
|
|
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
|
|
0x000000ff,
|
|
};
|
|
|
|
static u32 mdfld_dbi_mcs_display_profile[] = {
|
|
0x50281450, 0x0000c882, 0x00000000, 0x00000000,
|
|
0x00000000,
|
|
};
|
|
|
|
static u32 mdfld_dbi_mcs_kbbc_profile[] = {
|
|
0x00ffcc60, 0x00000000, 0x00000000, 0x00000000,
|
|
};
|
|
|
|
static u32 mdfld_dbi_mcs_gamma_profile[] = {
|
|
0x81111158, 0x88888888, 0x88888888,
|
|
};
|
|
|
|
/*
|
|
* write hysteresis values.
|
|
*/
|
|
static void mdfld_dsi_write_hysteresis (struct mdfld_dsi_config *dsi_config,
|
|
int pipe)
|
|
{
|
|
struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config);
|
|
|
|
if(!sender) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
mdfld_dsi_send_mcs_long_hs(sender,
|
|
mdfld_dbi_mcs_hysteresis,
|
|
17,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
}
|
|
|
|
/*
|
|
* write display profile values.
|
|
*/
|
|
static void mdfld_dsi_write_display_profile(struct mdfld_dsi_config *dsi_config, int pipe)
|
|
{
|
|
struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config);
|
|
|
|
if(!sender) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
mdfld_dsi_send_mcs_long_hs(sender,
|
|
mdfld_dbi_mcs_display_profile,
|
|
5,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
}
|
|
|
|
/*
|
|
* write KBBC profile values.
|
|
*/
|
|
static void mdfld_dsi_write_kbbc_profile (struct mdfld_dsi_config * dsi_config, int pipe)
|
|
{
|
|
struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config);
|
|
|
|
if(!sender) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
mdfld_dsi_send_mcs_long_hs(sender,
|
|
mdfld_dbi_mcs_kbbc_profile,
|
|
4,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
}
|
|
|
|
/*
|
|
* write gamma setting.
|
|
*/
|
|
static void mdfld_dsi_write_gamma_setting (struct mdfld_dsi_config *dsi_config, int pipe)
|
|
{
|
|
struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config);
|
|
|
|
if(!sender) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
mdfld_dsi_send_mcs_long_hs(sender,
|
|
mdfld_dbi_mcs_gamma_profile,
|
|
3,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
}
|
|
|
|
/*
|
|
* Check and see if the generic control or data buffer is empty and ready.
|
|
*/
|
|
void mdfld_dsi_gen_fifo_ready (struct drm_device *dev, u32 gen_fifo_stat_reg, u32 fifo_stat)
|
|
{
|
|
u32 GEN_BF_time_out_count = 0;
|
|
|
|
/* Check MIPI Adatper command registers */
|
|
for (GEN_BF_time_out_count = 0; GEN_BF_time_out_count < GEN_FB_TIME_OUT; GEN_BF_time_out_count++)
|
|
{
|
|
if ((REG_READ(gen_fifo_stat_reg) & fifo_stat) == fifo_stat)
|
|
break;
|
|
udelay (100);
|
|
}
|
|
|
|
if (GEN_BF_time_out_count == GEN_FB_TIME_OUT)
|
|
dev_err(dev->dev,
|
|
"mdfld_dsi_gen_fifo_ready, Timeout. gen_fifo_stat_reg = 0x%x. \n",
|
|
gen_fifo_stat_reg);
|
|
}
|
|
|
|
/*
|
|
* Manage the DSI MIPI keyboard and display brightness.
|
|
* FIXME: this is exported to OSPM code. should work out an specific
|
|
* display interface to OSPM.
|
|
*/
|
|
void mdfld_dsi_brightness_init(struct mdfld_dsi_config *dsi_config, int pipe)
|
|
{
|
|
struct mdfld_dsi_pkg_sender *sender = mdfld_dsi_get_pkg_sender(dsi_config);
|
|
struct drm_device *dev = sender->dev;
|
|
struct drm_psb_private *dev_priv = dev->dev_private;
|
|
u32 gen_ctrl_val;
|
|
|
|
if(!sender) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
/* Set default display backlight value to 85% (0xd8)*/
|
|
mdfld_dsi_send_mcs_short_hs(sender,
|
|
write_display_brightness,
|
|
0xd8,
|
|
1,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
|
|
/* Set minimum brightness setting of CABC function to 20% (0x33)*/
|
|
mdfld_dsi_send_mcs_short_hs(sender,
|
|
write_cabc_min_bright,
|
|
0x33,
|
|
1,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
|
|
mdfld_dsi_write_hysteresis(dsi_config, pipe);
|
|
mdfld_dsi_write_display_profile (dsi_config, pipe);
|
|
mdfld_dsi_write_kbbc_profile (dsi_config, pipe);
|
|
mdfld_dsi_write_gamma_setting (dsi_config, pipe);
|
|
|
|
/* Enable backlight or/and LABC */
|
|
gen_ctrl_val = BRIGHT_CNTL_BLOCK_ON | DISPLAY_DIMMING_ON| BACKLIGHT_ON;
|
|
if (LABC_control == 1 || CABC_control == 1)
|
|
gen_ctrl_val |= DISPLAY_DIMMING_ON| DISPLAY_BRIGHTNESS_AUTO | GAMMA_AUTO;
|
|
|
|
if (LABC_control == 1)
|
|
gen_ctrl_val |= AMBIENT_LIGHT_SENSE_ON;
|
|
|
|
dev_priv->mipi_ctrl_display = gen_ctrl_val;
|
|
|
|
mdfld_dsi_send_mcs_short_hs(sender,
|
|
write_ctrl_display,
|
|
(u8)gen_ctrl_val,
|
|
1,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
|
|
if (CABC_control == 0)
|
|
return;
|
|
mdfld_dsi_send_mcs_short_hs(sender,
|
|
write_ctrl_cabc,
|
|
UI_IMAGE,
|
|
1,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
}
|
|
|
|
/*
|
|
* Manage the mipi display brightness.
|
|
* TODO: refine this interface later
|
|
*/
|
|
void mdfld_dsi_brightness_control(struct drm_device *dev, int pipe, int level)
|
|
{
|
|
struct mdfld_dsi_pkg_sender *sender;
|
|
struct drm_psb_private *dev_priv;
|
|
struct mdfld_dsi_config *dsi_config;
|
|
u32 gen_ctrl_val;
|
|
int p_type;
|
|
|
|
if (!dev || (pipe != 0 && pipe != 2)) {
|
|
dev_err(dev->dev, "Invalid parameter\n");
|
|
return;
|
|
}
|
|
|
|
p_type = mdfld_get_panel_type(dev, 0);
|
|
|
|
dev_priv = dev->dev_private;
|
|
|
|
if(pipe)
|
|
dsi_config = dev_priv->dsi_configs[1];
|
|
else
|
|
dsi_config = dev_priv->dsi_configs[0];
|
|
|
|
sender = mdfld_dsi_get_pkg_sender(dsi_config);
|
|
|
|
if(!sender) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
|
|
gen_ctrl_val = ((level * 0xff) / MDFLD_DSI_BRIGHTNESS_MAX_LEVEL) & 0xff;
|
|
|
|
dev_dbg(dev->dev,
|
|
"pipe = %d, gen_ctrl_val = %d. \n", pipe, gen_ctrl_val);
|
|
|
|
if(p_type == TMD_VID || p_type == TMD_CMD){
|
|
/* Set display backlight value */
|
|
mdfld_dsi_send_mcs_short_hs(sender,
|
|
tmd_write_display_brightness,
|
|
(u8)gen_ctrl_val,
|
|
1,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
} else {
|
|
/* Set display backlight value */
|
|
mdfld_dsi_send_mcs_short_hs(sender,
|
|
write_display_brightness,
|
|
(u8)gen_ctrl_val,
|
|
1,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
|
|
|
|
/* Enable backlight control */
|
|
if (level == 0)
|
|
gen_ctrl_val = 0;
|
|
else
|
|
gen_ctrl_val = dev_priv->mipi_ctrl_display;
|
|
|
|
mdfld_dsi_send_mcs_short_hs(sender,
|
|
write_ctrl_display,
|
|
(u8)gen_ctrl_val,
|
|
1,
|
|
MDFLD_DSI_SEND_PACKAGE);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* shut down DSI controller
|
|
*/
|
|
void mdfld_dsi_controller_shutdown(struct mdfld_dsi_config * dsi_config, int pipe)
|
|
{
|
|
struct drm_device * dev;
|
|
u32 reg_offset = pipe ? MIPIC_REG_OFFSET : 0;
|
|
int retry = 100;
|
|
|
|
if (!dsi_config) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
|
|
dev = dsi_config->dev;
|
|
|
|
if (!gma_power_begin(dev, true)) {
|
|
dev_err(dev->dev, "hw begin failed\n");
|
|
return;
|
|
}
|
|
|
|
if(!(REG_READ(MIPIA_DEVICE_READY_REG + reg_offset) & DSI_DEVICE_READY))
|
|
goto shutdown_out;
|
|
|
|
/* Send shut down package, clean packet send bit first */
|
|
if(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) & DSI_INTR_STATE_SPL_PKG_SENT) {
|
|
REG_WRITE((MIPIA_INTR_STAT_REG + reg_offset),
|
|
(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) | DSI_INTR_STATE_SPL_PKG_SENT));
|
|
}
|
|
|
|
/*send shut down package in HS*/
|
|
REG_WRITE((MIPIA_DPI_CONTROL_REG + reg_offset), DSI_DPI_CTRL_HS_SHUTDOWN);
|
|
|
|
|
|
/*
|
|
* make sure shut down is sent.
|
|
* FIXME: add max retry counter
|
|
*/
|
|
while(!(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) & DSI_INTR_STATE_SPL_PKG_SENT)) {
|
|
retry--;
|
|
|
|
if(!retry) {
|
|
dev_err(dev->dev, "timeout\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*sleep 1 ms to ensure shutdown finished*/
|
|
msleep(100);
|
|
|
|
/*un-ready device*/
|
|
REG_WRITE((MIPIA_DEVICE_READY_REG + reg_offset),
|
|
(REG_READ(MIPIA_DEVICE_READY_REG + reg_offset) & ~DSI_DEVICE_READY));
|
|
|
|
shutdown_out:
|
|
gma_power_end(dev);
|
|
}
|
|
|
|
void mdfld_dsi_controller_startup(struct mdfld_dsi_config * dsi_config, int pipe)
|
|
{
|
|
struct drm_device * dev;
|
|
u32 reg_offset = pipe ? MIPIC_REG_OFFSET : 0;
|
|
int retry = 100;
|
|
|
|
|
|
if (!dsi_config) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
|
|
dev = dsi_config->dev;
|
|
dev_dbg(dev->dev, "starting up DSI controller on pipe %d...\n", pipe);
|
|
|
|
if (!gma_power_begin(dev, true)) {
|
|
dev_err(dev->dev, "hw begin failed\n");
|
|
return;
|
|
}
|
|
|
|
if((REG_READ(MIPIA_DEVICE_READY_REG + reg_offset) & DSI_DEVICE_READY))
|
|
goto startup_out;
|
|
|
|
/*if config DPI, turn on DPI interface*/
|
|
if(dsi_config->type == MDFLD_DSI_ENCODER_DPI) {
|
|
if(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) & DSI_INTR_STATE_SPL_PKG_SENT) {
|
|
REG_WRITE((MIPIA_INTR_STAT_REG + reg_offset), DSI_INTR_STATE_SPL_PKG_SENT);
|
|
}
|
|
|
|
REG_WRITE((MIPIA_DPI_CONTROL_REG + reg_offset), DSI_DPI_CTRL_HS_TURN_ON);
|
|
|
|
/*
|
|
* make sure shut down is sent.
|
|
* FIXME: add max retry counter
|
|
*/
|
|
while(!(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) & DSI_INTR_STATE_SPL_PKG_SENT)) {
|
|
retry--;
|
|
if(!retry) {
|
|
dev_err(dev->dev, "timeout\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
msleep(100);
|
|
}
|
|
|
|
/*set device ready*/
|
|
REG_WRITE((MIPIA_DEVICE_READY_REG + reg_offset),
|
|
(REG_READ(MIPIA_DEVICE_READY_REG + reg_offset) | DSI_DEVICE_READY));
|
|
|
|
startup_out:
|
|
gma_power_end(dev);
|
|
}
|
|
|
|
|
|
static int mdfld_dsi_get_panel_status(struct mdfld_dsi_config *dsi_config,
|
|
u8 dcs,
|
|
u32 *data,
|
|
u8 transmission)
|
|
{
|
|
struct mdfld_dsi_pkg_sender *sender
|
|
= mdfld_dsi_get_pkg_sender(dsi_config);
|
|
|
|
if (!sender || !data) {
|
|
DRM_ERROR("Invalid parameter\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (transmission == MDFLD_DSI_HS_TRANSMISSION)
|
|
return mdfld_dsi_read_mcs_hs(sender, dcs, data, 1);
|
|
else if (transmission == MDFLD_DSI_LP_TRANSMISSION)
|
|
return mdfld_dsi_read_mcs_lp(sender, dcs, data, 1);
|
|
else
|
|
return -EINVAL;
|
|
}
|
|
|
|
int mdfld_dsi_get_power_mode(struct mdfld_dsi_config *dsi_config,
|
|
u32 *mode,
|
|
u8 transmission)
|
|
{
|
|
if (!dsi_config || !mode) {
|
|
DRM_ERROR("Invalid parameter\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return mdfld_dsi_get_panel_status(dsi_config, 0x0a, mode, transmission);
|
|
}
|
|
|
|
int mdfld_dsi_get_diagnostic_result(struct mdfld_dsi_config *dsi_config,
|
|
u32 *result,
|
|
u8 transmission)
|
|
{
|
|
if (!dsi_config || !result) {
|
|
DRM_ERROR("Invalid parameter\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return mdfld_dsi_get_panel_status(dsi_config, 0x0f, result,
|
|
transmission);
|
|
}
|
|
|
|
/*
|
|
* NOTE: this function was used by OSPM.
|
|
* TODO: will be removed later, should work out display interfaces for OSPM
|
|
*/
|
|
void mdfld_dsi_controller_init(struct mdfld_dsi_config * dsi_config, int pipe)
|
|
{
|
|
if(!dsi_config || ((pipe != 0) && (pipe != 2))) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
|
|
if(dsi_config->type)
|
|
mdfld_dsi_dpi_controller_init(dsi_config, pipe);
|
|
else
|
|
mdfld_dsi_controller_dbi_init(dsi_config, pipe);
|
|
}
|
|
|
|
static void mdfld_dsi_connector_save(struct drm_connector * connector)
|
|
{
|
|
}
|
|
|
|
static void mdfld_dsi_connector_restore(struct drm_connector * connector)
|
|
{
|
|
}
|
|
|
|
static enum drm_connector_status mdfld_dsi_connector_detect(struct drm_connector * connector, bool force)
|
|
{
|
|
struct psb_intel_output *psb_output
|
|
= to_psb_intel_output(connector);
|
|
struct mdfld_dsi_connector *dsi_connector
|
|
= MDFLD_DSI_CONNECTOR(psb_output);
|
|
return dsi_connector->status;
|
|
}
|
|
|
|
static int mdfld_dsi_connector_set_property(struct drm_connector *connector,
|
|
struct drm_property *property,
|
|
uint64_t value)
|
|
{
|
|
struct drm_encoder *encoder = connector->encoder;
|
|
|
|
if (!strcmp(property->name, "scaling mode") && encoder) {
|
|
struct psb_intel_crtc * psb_crtc = to_psb_intel_crtc(encoder->crtc);
|
|
bool bTransitionFromToCentered;
|
|
uint64_t curValue;
|
|
|
|
if (!psb_crtc)
|
|
goto set_prop_error;
|
|
|
|
switch (value) {
|
|
case DRM_MODE_SCALE_FULLSCREEN:
|
|
break;
|
|
case DRM_MODE_SCALE_NO_SCALE:
|
|
break;
|
|
case DRM_MODE_SCALE_ASPECT:
|
|
break;
|
|
default:
|
|
goto set_prop_error;
|
|
}
|
|
|
|
if (drm_connector_property_get_value(connector, property, &curValue))
|
|
goto set_prop_error;
|
|
|
|
if (curValue == value)
|
|
goto set_prop_done;
|
|
|
|
if (drm_connector_property_set_value(connector, property, value))
|
|
goto set_prop_error;
|
|
|
|
bTransitionFromToCentered = (curValue == DRM_MODE_SCALE_NO_SCALE) ||
|
|
(value == DRM_MODE_SCALE_NO_SCALE);
|
|
|
|
if (psb_crtc->saved_mode.hdisplay != 0 &&
|
|
psb_crtc->saved_mode.vdisplay != 0) {
|
|
if (bTransitionFromToCentered) {
|
|
if (!drm_crtc_helper_set_mode(encoder->crtc, &psb_crtc->saved_mode,
|
|
encoder->crtc->x, encoder->crtc->y, encoder->crtc->fb))
|
|
goto set_prop_error;
|
|
} else {
|
|
struct drm_encoder_helper_funcs *pEncHFuncs = encoder->helper_private;
|
|
pEncHFuncs->mode_set(encoder, &psb_crtc->saved_mode,
|
|
&psb_crtc->saved_adjusted_mode);
|
|
}
|
|
}
|
|
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
|
|
} else if (!strcmp(property->name, "backlight") && encoder) {
|
|
struct drm_psb_private *dev_priv = encoder->dev->dev_private;
|
|
struct backlight_device *psb_bd = dev_priv->backlight_device;
|
|
dev_dbg(encoder->dev->dev, "backlight level = %d\n", (int)value);
|
|
if (drm_connector_property_set_value(connector, property, value))
|
|
goto set_prop_error;
|
|
else {
|
|
dev_dbg(encoder->dev->dev,
|
|
"set brightness to %d", (int)value);
|
|
if (psb_bd) {
|
|
psb_bd->props.brightness = value;
|
|
backlight_update_status(psb_bd);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
set_prop_done:
|
|
return 0;
|
|
set_prop_error:
|
|
return -1;
|
|
}
|
|
|
|
static void mdfld_dsi_connector_destroy(struct drm_connector *connector)
|
|
{
|
|
struct psb_intel_output * psb_output = to_psb_intel_output(connector);
|
|
struct mdfld_dsi_connector * dsi_connector = MDFLD_DSI_CONNECTOR(psb_output);
|
|
struct mdfld_dsi_pkg_sender * sender;
|
|
|
|
if(!dsi_connector)
|
|
return;
|
|
|
|
drm_sysfs_connector_remove(connector);
|
|
drm_connector_cleanup(connector);
|
|
|
|
sender = dsi_connector->pkg_sender;
|
|
|
|
mdfld_dsi_pkg_sender_destroy(sender);
|
|
|
|
kfree(dsi_connector);
|
|
}
|
|
|
|
static int mdfld_dsi_connector_get_modes(struct drm_connector * connector)
|
|
{
|
|
struct psb_intel_output * psb_output = to_psb_intel_output(connector);
|
|
struct mdfld_dsi_connector * dsi_connector = MDFLD_DSI_CONNECTOR(psb_output);
|
|
struct mdfld_dsi_config * dsi_config = mdfld_dsi_get_config(dsi_connector);
|
|
struct drm_display_mode * fixed_mode = dsi_config->fixed_mode;
|
|
struct drm_display_mode * dup_mode = NULL;
|
|
struct drm_device * dev = connector->dev;
|
|
|
|
connector->display_info.min_vfreq = 0;
|
|
connector->display_info.max_vfreq = 200;
|
|
connector->display_info.min_hfreq = 0;
|
|
connector->display_info.max_hfreq = 200;
|
|
|
|
if(fixed_mode) {
|
|
dev_dbg(dev->dev, "fixed_mode %dx%d\n",
|
|
fixed_mode->hdisplay, fixed_mode->vdisplay);
|
|
|
|
dup_mode = drm_mode_duplicate(dev, fixed_mode);
|
|
drm_mode_probed_add(connector, dup_mode);
|
|
return 1;
|
|
}
|
|
dev_err(dev->dev, "Didn't get any modes!\n");
|
|
return 0;
|
|
}
|
|
|
|
static int mdfld_dsi_connector_mode_valid(struct drm_connector * connector, struct drm_display_mode * mode)
|
|
{
|
|
struct psb_intel_output * psb_output = to_psb_intel_output(connector);
|
|
struct mdfld_dsi_connector * dsi_connector = MDFLD_DSI_CONNECTOR(psb_output);
|
|
struct mdfld_dsi_config * dsi_config = mdfld_dsi_get_config(dsi_connector);
|
|
struct drm_display_mode * fixed_mode = dsi_config->fixed_mode;
|
|
|
|
dev_dbg(connector->dev->dev, "mode %p, fixed mode %p\n",
|
|
mode, fixed_mode);
|
|
|
|
if(mode->flags & DRM_MODE_FLAG_DBLSCAN)
|
|
return MODE_NO_DBLESCAN;
|
|
|
|
if(mode->flags & DRM_MODE_FLAG_INTERLACE)
|
|
return MODE_NO_INTERLACE;
|
|
|
|
/**
|
|
* FIXME: current DC has no fitting unit, reject any mode setting request
|
|
* will figure out a way to do up-scaling(pannel fitting) later.
|
|
**/
|
|
if(fixed_mode) {
|
|
if(mode->hdisplay != fixed_mode->hdisplay)
|
|
return MODE_PANEL;
|
|
|
|
if(mode->vdisplay != fixed_mode->vdisplay)
|
|
return MODE_PANEL;
|
|
}
|
|
dev_dbg(connector->dev->dev, "mode ok\n");
|
|
|
|
return MODE_OK;
|
|
}
|
|
|
|
static void mdfld_dsi_connector_dpms(struct drm_connector *connector, int mode)
|
|
{
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
struct drm_device * dev = connector->dev;
|
|
struct drm_psb_private * dev_priv = dev->dev_private;
|
|
bool panel_on, panel_on2;
|
|
#endif
|
|
/* First, execute DPMS */
|
|
drm_helper_connector_dpms(connector, mode);
|
|
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
if(mdfld_panel_dpi(dev)) {
|
|
/* DPI panel */
|
|
panel_on = dev_priv->dpi_panel_on;
|
|
panel_on2 = dev_priv->dpi_panel_on2;
|
|
} else {
|
|
/* DBI panel */
|
|
panel_on = dev_priv->dbi_panel_on;
|
|
panel_on2 = dev_priv->dbi_panel_on2;
|
|
}
|
|
|
|
/* Then check all display panels + monitors status */
|
|
/* Make sure that the Display (B) sub-system status isn't i3 when
|
|
* R/W the DC register, otherwise "Fabric error" issue would occur
|
|
* during S0i3 state. */
|
|
if(!panel_on && !panel_on2 && !(REG_READ(HDMIB_CONTROL)
|
|
& HDMIB_PORT_EN)) {
|
|
/* Request rpm idle */
|
|
if(dev_priv->rpm_enabled)
|
|
pm_request_idle(&dev->pdev->dev);
|
|
}
|
|
/*
|
|
* if rpm wasn't enabled yet, try to allow it
|
|
* FIXME: won't enable rpm for DPI since DPI
|
|
* CRTC setting is a little messy now.
|
|
* Enable it later!
|
|
*/
|
|
#if 0
|
|
if(!dev_priv->rpm_enabled && !mdfld_panel_dpi(dev))
|
|
ospm_runtime_pm_allow(dev);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
static struct drm_encoder *mdfld_dsi_connector_best_encoder(
|
|
struct drm_connector *connector)
|
|
{
|
|
struct psb_intel_output * psb_output = to_psb_intel_output(connector);
|
|
struct mdfld_dsi_connector * dsi_connector = MDFLD_DSI_CONNECTOR(psb_output);
|
|
struct mdfld_dsi_config * dsi_config = mdfld_dsi_get_config(dsi_connector);
|
|
struct mdfld_dsi_encoder * encoder = NULL;
|
|
|
|
if(dsi_config->type == MDFLD_DSI_ENCODER_DBI)
|
|
encoder = dsi_config->encoders[MDFLD_DSI_ENCODER_DBI];
|
|
else if (dsi_config->type == MDFLD_DSI_ENCODER_DPI)
|
|
encoder = dsi_config->encoders[MDFLD_DSI_ENCODER_DPI];
|
|
|
|
dev_dbg(connector->dev->dev, "get encoder %p\n", encoder);
|
|
|
|
if(!encoder) {
|
|
dev_err(connector->dev->dev,
|
|
"Invalid encoder for type %d\n", dsi_config->type);
|
|
return NULL;
|
|
}
|
|
dsi_config->encoder = encoder;
|
|
return &encoder->base;
|
|
}
|
|
|
|
/* DSI connector funcs */
|
|
static const struct drm_connector_funcs mdfld_dsi_connector_funcs = {
|
|
.dpms = /*drm_helper_connector_dpms*/mdfld_dsi_connector_dpms,
|
|
.save = mdfld_dsi_connector_save,
|
|
.restore = mdfld_dsi_connector_restore,
|
|
.detect = mdfld_dsi_connector_detect,
|
|
.fill_modes = drm_helper_probe_single_connector_modes,
|
|
.set_property = mdfld_dsi_connector_set_property,
|
|
.destroy = mdfld_dsi_connector_destroy,
|
|
};
|
|
|
|
/* DSI connector helper funcs */
|
|
static const struct drm_connector_helper_funcs mdfld_dsi_connector_helper_funcs = {
|
|
.get_modes = mdfld_dsi_connector_get_modes,
|
|
.mode_valid = mdfld_dsi_connector_mode_valid,
|
|
.best_encoder = mdfld_dsi_connector_best_encoder,
|
|
};
|
|
|
|
static int mdfld_dsi_get_default_config(struct drm_device * dev,
|
|
struct mdfld_dsi_config * config, int pipe)
|
|
{
|
|
if(!dev || !config) {
|
|
WARN_ON(1);
|
|
return -EINVAL;
|
|
}
|
|
|
|
config->bpp = 24;
|
|
config->type = mdfld_panel_dpi(dev);
|
|
config->lane_count = 2;
|
|
config->channel_num = 0;
|
|
/*NOTE: video mode is ignored when type is MDFLD_DSI_ENCODER_DBI*/
|
|
if (mdfld_get_panel_type(dev, pipe) == TMD_VID) {
|
|
config->video_mode = MDFLD_DSI_VIDEO_NON_BURST_MODE_SYNC_PULSE;
|
|
} else {
|
|
config->video_mode = MDFLD_DSI_VIDEO_BURST_MODE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Returns the panel fixed mode from configuration.
|
|
*/
|
|
struct drm_display_mode *
|
|
mdfld_dsi_get_configuration_mode(struct mdfld_dsi_config * dsi_config, int pipe)
|
|
{
|
|
struct drm_device *dev = dsi_config->dev;
|
|
struct drm_display_mode *mode;
|
|
struct drm_psb_private *dev_priv = dev->dev_private;
|
|
struct mrst_timing_info *ti = &dev_priv->gct_data.DTD;
|
|
bool use_gct = false;
|
|
|
|
mode = kzalloc(sizeof(*mode), GFP_KERNEL);
|
|
if (!mode) {
|
|
dev_err(dev->dev, "Out of memory for mode\n");
|
|
return NULL;
|
|
}
|
|
if (use_gct) {
|
|
dev_dbg(dev->dev, "gct find MIPI panel.\n");
|
|
|
|
mode->hdisplay = (ti->hactive_hi << 8) | ti->hactive_lo;
|
|
mode->vdisplay = (ti->vactive_hi << 8) | ti->vactive_lo;
|
|
mode->hsync_start = mode->hdisplay + \
|
|
((ti->hsync_offset_hi << 8) | \
|
|
ti->hsync_offset_lo);
|
|
mode->hsync_end = mode->hsync_start + \
|
|
((ti->hsync_pulse_width_hi << 8) | \
|
|
ti->hsync_pulse_width_lo);
|
|
mode->htotal = mode->hdisplay + ((ti->hblank_hi << 8) | \
|
|
ti->hblank_lo);
|
|
mode->vsync_start = \
|
|
mode->vdisplay + ((ti->vsync_offset_hi << 8) | \
|
|
ti->vsync_offset_lo);
|
|
mode->vsync_end = \
|
|
mode->vsync_start + ((ti->vsync_pulse_width_hi << 8) | \
|
|
ti->vsync_pulse_width_lo);
|
|
mode->vtotal = mode->vdisplay + \
|
|
((ti->vblank_hi << 8) | ti->vblank_lo);
|
|
mode->clock = ti->pixel_clock * 10;
|
|
} else {
|
|
if(dsi_config->type == MDFLD_DSI_ENCODER_DPI) {
|
|
if (mdfld_get_panel_type(dev, pipe) == TMD_VID) {
|
|
mode->hdisplay = 480;
|
|
mode->vdisplay = 854;
|
|
mode->hsync_start = 487;
|
|
mode->hsync_end = 490;
|
|
mode->htotal = 499;
|
|
mode->vsync_start = 861;
|
|
mode->vsync_end = 865;
|
|
mode->vtotal = 873;
|
|
mode->clock = 33264;
|
|
} else {
|
|
mode->hdisplay = 864;
|
|
mode->vdisplay = 480;
|
|
mode->hsync_start = 873;
|
|
mode->hsync_end = 876;
|
|
mode->htotal = 887;
|
|
mode->vsync_start = 487;
|
|
mode->vsync_end = 490;
|
|
mode->vtotal = 499;
|
|
mode->clock = 33264;
|
|
}
|
|
} else if(dsi_config->type == MDFLD_DSI_ENCODER_DBI) {
|
|
mode->hdisplay = 864;
|
|
mode->vdisplay = 480;
|
|
mode->hsync_start = 872;
|
|
mode->hsync_end = 876;
|
|
mode->htotal = 884;
|
|
mode->vsync_start = 482;
|
|
mode->vsync_end = 494;
|
|
mode->vtotal = 486;
|
|
mode->clock = 25777;
|
|
|
|
}
|
|
}
|
|
|
|
drm_mode_set_name(mode);
|
|
drm_mode_set_crtcinfo(mode, 0);
|
|
|
|
mode->type |= DRM_MODE_TYPE_PREFERRED;
|
|
|
|
return mode;
|
|
}
|
|
|
|
int mdfld_dsi_panel_reset(int pipe)
|
|
{
|
|
unsigned gpio;
|
|
int ret = 0;
|
|
|
|
switch (pipe) {
|
|
case 0:
|
|
gpio = 128;
|
|
break;
|
|
case 2:
|
|
gpio = 34;
|
|
break;
|
|
default:
|
|
DRM_ERROR("Invalid output\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = gpio_request(gpio, "gfx");
|
|
if (ret) {
|
|
DRM_ERROR("gpio_rqueset failed\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = gpio_direction_output(gpio, 1);
|
|
if (ret) {
|
|
DRM_ERROR("gpio_direction_output failed\n");
|
|
goto gpio_error;
|
|
}
|
|
|
|
gpio_get_value(128);
|
|
|
|
gpio_error:
|
|
if (gpio_is_valid(gpio))
|
|
gpio_free(gpio);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* MIPI output init
|
|
* @dev drm device
|
|
* @pipe pipe number. 0 or 2
|
|
* @config
|
|
*
|
|
* Do the initialization of a MIPI output, including create DRM mode objects
|
|
* initialization of DSI output on @pipe
|
|
*/
|
|
void mdfld_dsi_output_init(struct drm_device *dev,
|
|
int pipe,
|
|
struct mdfld_dsi_config *config,
|
|
struct panel_funcs* p_cmd_funcs,
|
|
struct panel_funcs* p_vid_funcs)
|
|
{
|
|
struct mdfld_dsi_config * dsi_config;
|
|
struct mdfld_dsi_connector * dsi_connector;
|
|
struct psb_intel_output * psb_output;
|
|
struct drm_connector * connector;
|
|
struct mdfld_dsi_encoder * encoder;
|
|
struct drm_psb_private * dev_priv = dev->dev_private;
|
|
struct panel_info dsi_panel_info;
|
|
u32 width_mm, height_mm;
|
|
|
|
dev_dbg(dev->dev, "init DSI output on pipe %d\n", pipe);
|
|
|
|
if(!dev || ((pipe != 0) && (pipe != 2))) {
|
|
WARN_ON(1);
|
|
return;
|
|
}
|
|
|
|
/*create a new connetor*/
|
|
dsi_connector = kzalloc(sizeof(struct mdfld_dsi_connector), GFP_KERNEL);
|
|
if(!dsi_connector) {
|
|
DRM_ERROR("No memory");
|
|
return;
|
|
}
|
|
|
|
dsi_connector->pipe = pipe;
|
|
|
|
/*set DSI config*/
|
|
if(config) {
|
|
dsi_config = config;
|
|
} else {
|
|
dsi_config = kzalloc(sizeof(struct mdfld_dsi_config), GFP_KERNEL);
|
|
if(!dsi_config) {
|
|
dev_err(dev->dev,
|
|
"cannot allocate memory for DSI config\n");
|
|
goto dsi_init_err0;
|
|
}
|
|
|
|
mdfld_dsi_get_default_config(dev, dsi_config, pipe);
|
|
}
|
|
|
|
dsi_connector->private = dsi_config;
|
|
|
|
dsi_config->changed = 1;
|
|
dsi_config->dev = dev;
|
|
|
|
/* Init fixed mode basing on DSI config type */
|
|
if(dsi_config->type == MDFLD_DSI_ENCODER_DBI) {
|
|
dsi_config->fixed_mode = p_cmd_funcs->get_config_mode(dev);
|
|
if(p_cmd_funcs->get_panel_info(dev, pipe, &dsi_panel_info))
|
|
goto dsi_init_err0;
|
|
} else if(dsi_config->type == MDFLD_DSI_ENCODER_DPI) {
|
|
dsi_config->fixed_mode = p_vid_funcs->get_config_mode(dev);
|
|
if(p_vid_funcs->get_panel_info(dev, pipe, &dsi_panel_info))
|
|
goto dsi_init_err0;
|
|
}
|
|
|
|
width_mm = dsi_panel_info.width_mm;
|
|
height_mm = dsi_panel_info.height_mm;
|
|
|
|
dsi_config->mode = dsi_config->fixed_mode;
|
|
dsi_config->connector = dsi_connector;
|
|
|
|
if(!dsi_config->fixed_mode) {
|
|
dev_err(dev->dev, "No pannel fixed mode was found\n");
|
|
goto dsi_init_err0;
|
|
}
|
|
|
|
if(pipe && dev_priv->dsi_configs[0]) {
|
|
dsi_config->dvr_ic_inited = 0;
|
|
dev_priv->dsi_configs[1] = dsi_config;
|
|
} else if(pipe == 0) {
|
|
dsi_config->dvr_ic_inited = 1;
|
|
dev_priv->dsi_configs[0] = dsi_config;
|
|
} else {
|
|
dev_err(dev->dev, "Trying to init MIPI1 before MIPI0\n");
|
|
goto dsi_init_err0;
|
|
}
|
|
|
|
/*init drm connector object*/
|
|
psb_output = &dsi_connector->base;
|
|
|
|
psb_output->type = (pipe == 0) ? INTEL_OUTPUT_MIPI : INTEL_OUTPUT_MIPI2;
|
|
|
|
connector = &psb_output->base;
|
|
/* Revisit type if MIPI/HDMI bridges ever appear on Medfield */
|
|
drm_connector_init(dev, connector, &mdfld_dsi_connector_funcs,
|
|
DRM_MODE_CONNECTOR_LVDS);
|
|
drm_connector_helper_add(connector, &mdfld_dsi_connector_helper_funcs);
|
|
|
|
connector->display_info.subpixel_order = SubPixelHorizontalRGB;
|
|
connector->display_info.width_mm = width_mm;
|
|
connector->display_info.height_mm = height_mm;
|
|
connector->interlace_allowed = false;
|
|
connector->doublescan_allowed = false;
|
|
|
|
/* Attach properties */
|
|
drm_connector_attach_property(connector, dev->mode_config.scaling_mode_property, DRM_MODE_SCALE_FULLSCREEN);
|
|
drm_connector_attach_property(connector, dev_priv->backlight_property, MDFLD_DSI_BRIGHTNESS_MAX_LEVEL);
|
|
|
|
/* Init DSI package sender on this output */
|
|
if (mdfld_dsi_pkg_sender_init(dsi_connector, pipe)) {
|
|
DRM_ERROR("Package Sender initialization failed on pipe %d\n", pipe);
|
|
goto dsi_init_err0;
|
|
}
|
|
|
|
/* Init DBI & DPI encoders */
|
|
if (p_cmd_funcs) {
|
|
encoder = mdfld_dsi_dbi_init(dev, dsi_connector, p_cmd_funcs);
|
|
if(!encoder) {
|
|
dev_err(dev->dev, "Create DBI encoder failed\n");
|
|
goto dsi_init_err1;
|
|
}
|
|
encoder->private = dsi_config;
|
|
dsi_config->encoders[MDFLD_DSI_ENCODER_DBI] = encoder;
|
|
}
|
|
|
|
if(p_vid_funcs) {
|
|
encoder = mdfld_dsi_dpi_init(dev, dsi_connector, p_vid_funcs);
|
|
if(!encoder) {
|
|
dev_err(dev->dev, "Create DPI encoder failed\n");
|
|
goto dsi_init_err1;
|
|
}
|
|
encoder->private = dsi_config;
|
|
dsi_config->encoders[MDFLD_DSI_ENCODER_DPI] = encoder;
|
|
}
|
|
|
|
drm_sysfs_connector_add(connector);
|
|
return;
|
|
|
|
/*TODO: add code to destroy outputs on error*/
|
|
dsi_init_err1:
|
|
/*destroy sender*/
|
|
mdfld_dsi_pkg_sender_destroy(dsi_connector->pkg_sender);
|
|
|
|
drm_connector_cleanup(connector);
|
|
kfree(dsi_config->fixed_mode);
|
|
kfree(dsi_config);
|
|
dsi_init_err0:
|
|
kfree(dsi_connector);
|
|
}
|