Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
/**
* @file chicago.cpp
*
* @brief Chicago control functions
*
* @copyright
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* @copyright
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @author Analogix, Inc
* @author Adam Munich
*/
//#############################################################################
// Pre-compiler Definitions
//-----------------------------------------------------------------------------
#include <Arduino.h>
#include <variant.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include "./chicago.h"
#include "./chicago_config.h"
#include "../I2C/i2c.h"
#include "../Debug/debug.h"
#include "../../display_settings.h"
//#############################################################################
// Pre-compiler Definitions
//-----------------------------------------------------------------------------
#define EDID_DB_MAX 4
#define DP_CABLE_IN 1
#define DP_CABLE_OUT 0
#define MIPI_PORT_LP 0
#define MIPI_PORT_HS 1
#define EDID_LENGTH 128
#define EDID_EXTERNAL_LENGTH 128
// 700ms for intel 520 DP flash issue // this is graphic card issue
// 1200ms for GTX970 draw issue // this is graphic card issue
#define GRAPHIC_CARD_DRAW_DELAY 1200
//#############################################################################
// Variable Declarations
//-----------------------------------------------------------------------------
static uint8_t edid_hdmi[EDID_LENGTH] = {
0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0xD8, 0x30, 0x75, 0x01, 0x00, 0x00, 0x00,
0x01, 0x1B, 0x01, 0x03, 0x81, 0x06, 0x05, 0x78, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x7B, 0x9A, 0x40, 0x8C, 0xB0, 0xA0, 0x10, 0x50, 0x30, 0x08,
0x81, 0x00, 0x3C, 0x32, 0x00, 0x00, 0x00, 0x10, 0x0F, 0x67, 0x40, 0x8C, 0xB0, 0xA0, 0x10, 0x50,
0x30, 0x08, 0x81, 0x00, 0x3C, 0x32, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC,
0x00, 0x41, 0x4E, 0x58, 0x37, 0x35, 0x33, 0x30, 0x20, 0x48, 0x44, 0x4D, 0x49, 0x0A, 0x01, 0x59};
static uint8_t edid_external_hdmi[EDID_EXTERNAL_LENGTH] = {
0x02, 0x03, 0x4D, 0xC2, 0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x29, 0x09, 0x07, 0x07, 0x11, 0x17, 0x50, 0x51, 0x07, 0x00, 0x83, 0x01, 0x00, 0x00, 0x76, 0x03,
0x0C, 0x00, 0x10, 0x00, 0x00, 0x44, 0x20, 0xC0, 0x84, 0x01, 0x02, 0x03, 0x04, 0x01, 0x41, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0xD8, 0x5D, 0xC4, 0x01, 0x78, 0x80, 0x00, 0x56, 0x98, 0x40,
0x60, 0xB0, 0xA0, 0x10, 0x50, 0x30, 0x08, 0x81, 0x00, 0x3C, 0x32, 0x00, 0x00, 0x00, 0x10, 0x8E,
0x65, 0x40, 0x60, 0xB0, 0xA0, 0x10, 0x50, 0x30, 0x08, 0x81, 0x00, 0x3C, 0x32, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2E};
static uint8_t edid_dp[EDID_LENGTH] = {
0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0xD8, 0x30, 0x75, 0x01, 0x00, 0x00, 0x00,
0x01, 0x1B, 0x01, 0x04, 0xA5, 0x06, 0x05, 0x78, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x56, 0x98, 0x40, 0x60, 0xB0, 0xA0, 0x10, 0x50, 0x30, 0x08,
0x81, 0x00, 0x3C, 0x32, 0x00, 0x00, 0x00, 0x10, 0x8E, 0x65, 0x40, 0x60, 0xB0, 0xA0, 0x10, 0x50,
0x30, 0x08, 0x81, 0x00, 0x3C, 0x32, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC,
0x00, 0x41, 0x4E, 0x58, 0x37, 0x35, 0x33, 0x30, 0x20, 0x44, 0x50, 0x0A, 0x20, 0x20, 0x01, 0x8C};
static uint8_t edid_external_dp[EDID_EXTERNAL_LENGTH] = {
0x02, 0x03, 0x2E, 0xC0, 0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x29, 0x09, 0x07, 0x07, 0x11, 0x17, 0x50, 0x51, 0x07, 0x00, 0x83, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E};
static uint8_t *edid_buffer;
static uint8_t *edid_external_buffer;
static ChicagoState current_state = STATE_NONE;
static ChicagoState last_state = STATE_NONE;
static uint8_t dp_cable = DP_CABLE_OUT;
static uint8_t video_stable = 0;
static uint8_t dcs_port_seq[4] = {0,2,1,3};
//uint32_t tmp_vtotal;
static uint32_t tmp_vbp, tmp_vfp, tmp_vsync, tmp_v_active;
static uint32_t tmp_hbp, tmp_hfp, tmp_hsync, tmp_h_active;
static uint32_t temp_value;
//For HPD signal
static uint8_t set_HPD;
//External interrupt flag
uint8_t intr_flag;
// for Debug Switch in EVB only
uint8_t debug_switch = 0xFF;
static uint32_t edid_resolution[EDID_DB_MAX][2];
static uint8_t edid_db_count;
//#############################################################################
// Function Definitions
//-----------------------------------------------------------------------------
/// @copydoc chicago_customized_setting
static void chicago_customized_setting(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_customized_setting(void)\n");
#endif
// REG7_0_RX_REG7
i2c_write_byte(SLAVEID_SERDES, REG7_0_RX_REG7, 0x4D); // 1.62G boosting
// REG7_1_RX_REG7
i2c_write_byte(SLAVEID_SERDES, REG7_1_RX_REG7, 0x6D); // 2.7G boosting
// REG7_2_RX_REG7
i2c_write_byte(SLAVEID_SERDES, REG7_2_RX_REG7, 0x8D);
// REG0_0_RX_REG0
i2c_write_byte(SLAVEID_SERDES, REG0_0_RX_REG0, 0x20);
// REG0_1_RX_REG0
i2c_write_byte(SLAVEID_SERDES, REG0_1_RX_REG0, 0x20);
// REG0_3_RX_REG0
i2c_write_byte(SLAVEID_SERDES, REG0_3_RX_REG0, 0xDF); // enable 6.75G
// Commented for test PATTERN mode, no need when use OCM
// Video related block auto reset disable.
//i2c_write_byte(SLAVEID_DP_TOP, ADDR_RST_SEL_0, 0xFB);
// Video power is control by software.
//i2c_write_byte(SLAVEID_DP_TOP, ADDR_PWD_SEL, 0x04);
// Video PLL related block auto reset disable
//i2c_write_byte(SLAVEID_DP_TOP, ADDR_RST_SEL_1, 0xFE);
// {0xC038, 0x4, {0x01, 0x28, 0x00, 0x00}},
i2c_write_byte4(SLAVEID_MIPI_PORT0, VID_MODE_CFG, 0x00002801);
// MIPI TX reset
i2c_write_byte4(SLAVEID_MIPI_PORT0, PWR_UP, 0x00000000);
// MIPI TX power-up,
i2c_write_byte4(SLAVEID_MIPI_PORT0, PWR_UP, 0x00000001);
// delay 5 ms
delay_ms(5);
i2c_write_byte4(SLAVEID_MIPI_PORT2, VID_MODE_CFG, 0x00002801);
// MIPI TX reset
i2c_write_byte4(SLAVEID_MIPI_PORT2, PWR_UP, 0x00000000);
// MIPI TX power-up,
i2c_write_byte4(SLAVEID_MIPI_PORT2, PWR_UP, 0x00000001);
// 24MHz
i2c_write_byte(SLAVEID_DP_TOP, ADDR_MISC_CTRL, 0x03);
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_check_ocm_status
static uint8_t chicago_check_ocm_status(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_check_ocm_status(void)\n");
#endif
uint8_t reg_temp;
// Checking OCM status
i2c_read_byte(SLAVEID_SERDES,SERDES_POWER_CONTROL,®_temp);
if((OCM_LOAD_DONE & reg_temp) == OCM_LOAD_DONE){
#ifdef DEBUG_LEVEL_2
TRACE1("%s\n", "\tOCM loaded");
#endif
return(FLAG_VALUE_ON);
}
else{
#ifdef DEBUG_LEVEL_2
TRACE1("%s\n", "\tOCM NOT loaded");
#endif
return(FLAG_VALUE_OFF);
}
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_audio_mclk_always_out
static void chicago_audio_mclk_always_out(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_audio_mclk_always_out(void)\n");
#endif
uint8_t reg_temp;
// Set Maud, (if don't set Maud in MCU, the default value in OCM is 1677)
// MCLK = Maud*240/Naud
// use default value 12.288MHz
//i2c_write_byte(SLAVEID_SPI,SW_AUD_MAUD_SVAL_7_0,0x00);
//i2c_write_byte(SLAVEID_SPI,SW_AUD_MAUD_SVAL_15_8,0x02);
//i2c_write_byte(SLAVEID_SPI,SW_AUD_MAUD_SVAL_23_16,0x00);
//i2c_write_byte(SLAVEID_SPI,SW_AUD_NAUD_SVAL_7_0,0x10);
//i2c_write_byte(SLAVEID_SPI,SW_AUD_NAUD_SVAL_15_8,0x27);
//i2c_write_byte(SLAVEID_SPI,SW_AUD_NAUD_SVAL_23_16,0x00);
// Set audio MCLK always on
i2c_read_byte(SLAVEID_SPI,MISC_NOTIFY_OCM0,®_temp);
reg_temp |= AUD_MCLK_ALWAYS_ON;
i2c_write_byte(SLAVEID_SPI,MISC_NOTIFY_OCM0,reg_temp);
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_set_panel_parameters
static void chicago_set_panel_parameters(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_set_panel_parameters(void)\n");
#endif
uint8_t reg_temp;
// write H active
i2c_write_byte(SLAVEID_SPI, SW_H_ACTIVE_L, (uint8_t)((uint32_t)PANEL_H_ACTIVE&0x00FF));
i2c_read_byte(SLAVEID_SPI, SW_H_ACTIVE_H, ®_temp);
reg_temp &= ~SW_H_ACTIVE_H_BITS;
reg_temp |= (uint8_t)(((uint32_t)PANEL_H_ACTIVE>>8)&SW_H_ACTIVE_H_BITS);
i2c_write_byte(SLAVEID_SPI, SW_H_ACTIVE_H, reg_temp);
// write HFP
i2c_write_byte(SLAVEID_SPI, SW_HFP_L, (uint8_t)((uint32_t)PANEL_HFP&0x00FF));
i2c_read_byte(SLAVEID_SPI, SW_HFP_H, ®_temp);
reg_temp &= ~SW_HFP_H_BITS;
reg_temp |= (uint8_t)(((uint32_t)PANEL_HFP>>8)&SW_HFP_H_BITS);
i2c_write_byte(SLAVEID_SPI, SW_HFP_H, reg_temp);
// write HSYNC
i2c_write_byte(SLAVEID_SPI, SW_HSYNC_L, (uint8_t)((uint32_t)PANEL_HSYNC&0x00FF));
i2c_read_byte(SLAVEID_SPI, SW_HSYNC_H, ®_temp);
reg_temp &= ~SW_HSYNC_H_BITS;
reg_temp |= (uint8_t)(((uint32_t)PANEL_HSYNC>>8)&SW_HSYNC_H_BITS);
i2c_write_byte(SLAVEID_SPI, SW_HSYNC_H, reg_temp);
// write HBP
i2c_write_byte(SLAVEID_SPI, SW_HBP_L, (uint8_t)((uint32_t)PANEL_HBP&0x00FF));
i2c_read_byte(SLAVEID_SPI, (uint16_t)SW_HBP_H, ®_temp);
reg_temp &= ~SW_HBP_H_BITS;
reg_temp |= (uint8_t)(((uint32_t)PANEL_HBP>>8)&SW_HBP_H_BITS);
i2c_write_byte(SLAVEID_SPI, SW_HBP_H, reg_temp);
// write V active
i2c_write_byte(SLAVEID_SPI, SW_V_ACTIVE_L, (uint8_t)((uint32_t)PANEL_V_ACTIVE&0x00FF));
i2c_read_byte(SLAVEID_SPI, SW_V_ACTIVE_H, ®_temp);
reg_temp &= ~SW_V_ACTIVE_H_BITS;
reg_temp |= (uint8_t)(((uint32_t)PANEL_V_ACTIVE>>8)&SW_V_ACTIVE_H_BITS);
i2c_write_byte(SLAVEID_SPI, SW_V_ACTIVE_H, reg_temp);
// write VFP
i2c_write_byte(SLAVEID_SPI, SW_VFP_L, (uint8_t)((uint32_t)PANEL_VFP&0x00FF));
i2c_read_byte(SLAVEID_SPI, SW_VFP_H, ®_temp);
reg_temp &= ~SW_VFP_H_BITS;
reg_temp |= (uint8_t)(((uint32_t)PANEL_VFP>>8)&SW_VFP_H_BITS);
i2c_write_byte(SLAVEID_SPI, SW_VFP_H, reg_temp);
// write VSYNC
i2c_write_byte(SLAVEID_SPI, SW_VSYNC_L, (uint8_t)((uint32_t)PANEL_VSYNC&0x00FF));
i2c_read_byte(SLAVEID_SPI, SW_VSYNC_H, ®_temp);
reg_temp &= ~SW_VSYNC_H_BITS;
reg_temp |= (uint8_t)(((uint32_t)PANEL_VSYNC>>8)&SW_VSYNC_H_BITS);
i2c_write_byte(SLAVEID_SPI, SW_VSYNC_H, reg_temp);
// write VBP
i2c_write_byte(SLAVEID_SPI, SW_VBP_L, (uint8_t)((uint32_t)PANEL_VBP&0x00FF));
i2c_read_byte(SLAVEID_SPI, SW_VBP_H, ®_temp);
reg_temp &= ~SW_VBP_H_BITS;
reg_temp |= (uint8_t)(((uint32_t)PANEL_VBP>>8)&SW_VBP_H_BITS);
i2c_write_byte(SLAVEID_SPI, SW_VBP_H, reg_temp);
// write Frame Rate
i2c_write_byte(SLAVEID_SPI, SW_PANEL_FRAME_RATE, (uint8_t)PANEL_FRAME_RATE);
// write SW_PANEL_INFO_0
reg_temp = 0;
// set video mode
switch(MIPI_VIDEO_MODE){
case VIDEOMODE_SIDE:
reg_temp |= (((uint8_t)(0x01)<<REG_PANEL_VIDEO_MODE_SHIFT)®_PANEL_VIDEO_MODE);
break;
case VIDEOMODE_STACKED:
reg_temp |= (((uint8_t)(0x02)<<REG_PANEL_VIDEO_MODE_SHIFT)®_PANEL_VIDEO_MODE);
break;
default:
// do not thing;
break;
}
// set MIPI lane number
switch(MIPI_LANE_NUMBER){
case 4:
case 3:
case 2:
case 1:
reg_temp |= (((uint8_t)(MIPI_LANE_NUMBER-1)<<REG_MIPI_LANE_COUNT_SHIFT)®_MIPI_LANE_COUNT);
break;
default:
// do not thing;
break;
}
// set MIPI total port
switch(MIPI_TOTAL_PORT){
case 4:
case 3:
case 2:
case 1:
reg_temp |= (((uint8_t)(MIPI_TOTAL_PORT-1)<<REG_MIPI_TOTAL_PORT_SHIFT)®_MIPI_TOTAL_PORT);
break;
default:
// do not thing;
break;
}
// set panel count
switch(PANEL_COUNT){
case 4:
case 3:
case 2:
case 1:
reg_temp |= (((uint8_t)(PANEL_COUNT-1)<<REG_PANEL_COUNT_SHIFT)®_PANEL_COUNT);
break;
default:
// do not thing;
break;
}
i2c_write_byte(SLAVEID_SPI, SW_PANEL_INFO_0, reg_temp);
// write SW_PANEL_INFO_1
i2c_read_byte(SLAVEID_SPI, SW_PANEL_INFO_1, ®_temp);
reg_temp &= ~REG_PANEL_ORDER;
switch(MIPI_DISPLAY_EYE){
case DISPLAY_RIGHT:
reg_temp |= REG_PANEL_ORDER;
break;
default:
// do not thing;
break;
}
reg_temp &= ~REG_PANEL_DSC_MODE;
switch(MIPI_DSC_STATUS){
case DSC_ONE_TO_THREE:
reg_temp |= REG_PANEL_DSC_MODE;
break;
default:
// do not thing;
break;
}
reg_temp &= ~REG_PANEL_TRANS_MODE;
switch(MIPI_TRANSMIT_MODE){
case MOD_NON_BURST_PULSES:
reg_temp |= (((uint8_t)(0x00)<<REG_PANEL_TRANS_MODE_SHIFT)®_PANEL_TRANS_MODE);
break;
case MOD_NON_BURST_EVENTS:
reg_temp |= (((uint8_t)(0x01)<<REG_PANEL_TRANS_MODE_SHIFT)®_PANEL_TRANS_MODE);
break;
case MOD_BURST:
default:
reg_temp |= (((uint8_t)(0x02)<<REG_PANEL_TRANS_MODE_SHIFT)®_PANEL_TRANS_MODE);
break;
}
// write DIP switch
reg_temp &= ~VIDEO_BIST_MODE;
//if(DIP_SWITCH_ON==(debug_switch&DS_BIST)){
#ifdef DEBUG_ENABLE_COLOR_BARS
reg_temp |= VIDEO_BIST_MODE;
#endif
//}
// Set DPHY timing that be calculated by OCM
switch(MIPI_DSC_STATUS){
case DSC_NO_DSC:
reg_temp |= SET_DPHY_TIMING;
break;
case DSC_ONE_TO_THREE:
reg_temp |= SET_DPHY_TIMING;
break;
default:
// do not thing;
break;
}
// Set all SW_PANEL_INFO_1 done
i2c_write_byte(SLAVEID_SPI, SW_PANEL_INFO_1, reg_temp);
// This bit should be set after parameters setting down !!!
i2c_read_byte(SLAVEID_SPI, MISC_NOTIFY_OCM0, ®_temp);
reg_temp |= PANEL_INFO_SET_DONE;
i2c_write_byte(SLAVEID_SPI, MISC_NOTIFY_OCM0, reg_temp);
}
//-----------------------------------------------------------------------------
/// @copydoc mipi_set_LP_HS_mode
static char mipi_set_LP_HS_mode(uint8_t mipi_port, uint8_t lp_hs){
#ifdef DEBUG_LEVEL_2
TRACE2("mipi_set_LP_HS_mode(uint8_t mipi_port=%d, uint8_t lp_hs=%d)\n", mipi_port, lp_hs);
#endif
uint8_t slave_id;
uint32_t reg_long;
switch(mipi_port) {
case 0:
slave_id = SLAVEID_MIPI_PORT0;
break;
case 1:
slave_id = SLAVEID_MIPI_PORT1;
break;
case 2:
slave_id = SLAVEID_MIPI_PORT2;
break;
case 3:
slave_id = SLAVEID_MIPI_PORT3;
break;
default:
TRACE1("%s\n", "\tMIPI port selected error!");
return RETURN_FAILURE_VALUE;
}
// Select port first
i2c_write_byte(SLAVEID_MIPI_CTRL, R_MIP_TX_SELECT,((0x10)<<(mipi_port)));
if(MIPI_PORT_LP==lp_hs){
reg_long = 0x00000001;
}else if(MIPI_PORT_HS==lp_hs){
reg_long = 0x00000000;
}else{
TRACE1("%s\n", "\tMIPI mode set error!");
return RETURN_FAILURE_VALUE;
}
i2c_write_byte4(slave_id, MODE_CFG, reg_long);
// MIPI TX reset
reg_long = 0x00000000;
i2c_write_byte4(slave_id, PWR_UP, reg_long);
// MIPI TX power-up
reg_long = 0x00000001;
i2c_write_byte4(slave_id, PWR_UP, reg_long);
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc mipi_packet_send_short
static char mipi_packet_send_short(PacketShort_t *short_packet){
#ifdef DEBUG_LEVEL_3
TRACE1("mipi_packet_send_short(PacketShort_t *short_packet=%x)\n", short_packet);
#endif
uint8_t slave_id;
uint32_t reg_long;
switch(short_packet->mipi_port) {
case 0:
slave_id = SLAVEID_MIPI_PORT0;
break;
case 1:
slave_id = SLAVEID_MIPI_PORT1;
break;
case 2:
slave_id = SLAVEID_MIPI_PORT2;
break;
case 3:
slave_id = SLAVEID_MIPI_PORT3;
break;
default:
TRACE1("%s\n", "\tMIPI port selected error!");
return RETURN_FAILURE_VALUE;
}
// Select port first
i2c_write_byte(SLAVEID_MIPI_CTRL, R_MIP_TX_SELECT,((0x10)<<(short_packet->mipi_port)));
// Write Data Type
reg_long = (((uint32_t)short_packet->data_type)&0x000000FF);
// Send other parameters
switch(short_packet->data_type) {
case DATASHORT_EoTp:
reg_long = (reg_long | (((uint32_t)0x0F)<<8));
reg_long = (reg_long | (((uint32_t)0x0F)<<16));
break;
default:
reg_long = (reg_long | (((uint32_t)short_packet->param1)<<8));
reg_long = (reg_long | (((uint32_t)short_packet->param2)<<16));
break;
}
i2c_write_byte4(slave_id, GEN_HDR, reg_long);
// Get return data for Read command
switch (short_packet->data_type) {
case DATASHORT_GEN_READ_0:
case DATASHORT_GEN_READ_1:
case DATASHORT_GEN_READ_2:
case DATASHORT_DCS_READ_0:
// Wait > 500us
delay_ms(1);
i2c_read_block(slave_id, GEN_PLD_DATA, &short_packet->pData[0], 4);
break;
default:
// Do not thing
break;
}
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
char mipi_packet_send_long(PacketLong_t *long_packet){
#ifdef DEBUG_LEVEL_3
TRACE1("mipi_packet_send_long(PacketLong_t *long_packet=%x)\n", long_packet);
#endif
uint8_t slave_id;
uint32_t div,mod,i;
uint32_t reg_long;
switch(long_packet->mipi_port) {
case 0:
slave_id = SLAVEID_MIPI_PORT0;
break;
case 1:
slave_id = SLAVEID_MIPI_PORT1;
break;
case 2:
slave_id = SLAVEID_MIPI_PORT2;
break;
case 3:
slave_id = SLAVEID_MIPI_PORT3;
break;
default:
TRACE1("\t%s\n", "MIPI port selected error!");
return RETURN_FAILURE_VALUE;
}
div = long_packet->word_count/4;
mod = long_packet->word_count%4;
// Select port first
i2c_write_byte(SLAVEID_MIPI_CTRL, R_MIP_TX_SELECT,((0x10)<<(long_packet->mipi_port)));
// Write Payload first
for(i=0; i<div; i++) {
reg_long = (((uint32_t)(long_packet->pData[i*4])) | (((uint32_t)(long_packet->pData[i*4+1]))<<8) |
(((uint32_t)(long_packet->pData[i*4+2]))<<16) | (((uint32_t)(long_packet->pData[i*4+3]))<<24) );
i2c_write_byte4(slave_id, GEN_PLD_DATA, reg_long);
}
switch(mod) {
case 3:
reg_long = (((uint32_t)(long_packet->pData[i*4])) | (((uint32_t)(long_packet->pData[i*4+1]))<<8) |
(((uint32_t)(long_packet->pData[i*4+2]))<<16) );
i2c_write_byte4(slave_id, GEN_PLD_DATA, reg_long);
break;
case 2:
reg_long = (((uint32_t)(long_packet->pData[i*4])) | (((uint32_t)(long_packet->pData[i*4+1]))<<8) );
i2c_write_byte4(slave_id, GEN_PLD_DATA, reg_long);
break;
case 1:
reg_long = ((uint32_t)(long_packet->pData[i*4]));
i2c_write_byte4(slave_id, GEN_PLD_DATA, reg_long);
break;
case 0:
// Do not thing
break;
default:
assert(0);
}
// Write long packet data type
// Write long packet word count
reg_long = (((uint32_t)(long_packet->data_type)) | (((uint32_t)(long_packet->word_count&0x00FF))<<8)
| (((uint32_t)((long_packet->word_count>>8)&0x00FF))<<16));
i2c_write_byte4(slave_id, GEN_HDR, reg_long);
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc DPCD_setting
static void DPCD_setting(void)
{
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_hpd_set
static char chicago_hpd_set(uint8_t force, uint8_t high_low){
#ifdef DEBUG_LEVEL_2
TRACE2("chicago_hpd_set(uint8_t force=%d, uint8_t high_low=%d)\n", force, high_low);
#endif
uint8_t reg_temp;
i2c_read_byte(SLAVEID_DP_IP, ADDR_SYSTEM_CTRL_0, ®_temp);
if(HDP_DATA_HIGH==high_low){ // HPD set to High
reg_temp |= FORCE_HPD_VALUE;
}else{ // HPD set to Low
reg_temp &= ~FORCE_HPD_VALUE;
}
if(HDP_FORCE==force){ // HPD force
reg_temp |= FORCE_HPD_EN;
}else{
reg_temp &= ~FORCE_HPD_EN;
}
i2c_write_byte(SLAVEID_DP_IP, ADDR_SYSTEM_CTRL_0, reg_temp);
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
char mipi_panel_power_supply(uint8_t onoff){
#ifdef DEBUG_LEVEL_2
TRACE1("mipi_panel_power_supply(uint8_t onoff=%d)\n", onoff);
#endif
if(onoff == PANEL_POWER_SUPPLY_OFF){
// Turn OFF backlight
//CHICAGO_PANEL_V33_DOWN();
//HDK_LCD_BL_OFF();
// Power Supply OFF
// RESET pin control for Sharp LS029B3SX02
CHICAGO_PANEL_V18_DOWN();
CHICAGO_PANEL_V33_DOWN();
CHICAGO_PANEL_V55_DOWN();
CHICAGO_PANEL_V55N_DOWN();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel power supplies OFF");
#endif
// Initial condition
CHICAGO_PANEL0_RESET_DOWN();
CHICAGO_PANEL1_RESET_DOWN();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel n_reset LOW");
#endif
CHICAGO_PANEL0_ENPORT_OFF();
CHICAGO_PANEL1_ENPORT_OFF();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel enport LOW");
#endif
delay_ms(2);
}
// ON --------------
else{
// Power Supply ON
// RESET pin control for Sharp LS029B3SX02
CHICAGO_PANEL_V18_DOWN();
CHICAGO_PANEL_V33_DOWN();
CHICAGO_PANEL_V55_DOWN();
CHICAGO_PANEL_V55N_DOWN();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel power supplies OFF");
#endif
// Reset Low
CHICAGO_PANEL0_RESET_DOWN();
CHICAGO_PANEL1_RESET_DOWN();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel n_reset LOW");
#endif
delay_ms(2);
// Power Supply VDDI (Typ. 1.8V)
CHICAGO_PANEL_V18_ON();
// delay more then 10ms, for HW request
delay_ms(10);
// Power Supply AVDD+ (Typ. +5.5V)
CHICAGO_PANEL_V55N_ON();
// Wait > 1ms
delay_ms(2);
// Power Supply AVDD- (Typ. -5.5V)
CHICAGO_PANEL_V55_ON();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel power supplies ON");
#endif
// Wait, >= 10ms
delay_ms(20);
/*
// Reset High
CHICAGO_PANEL0_RESET_UP();
CHICAGO_PANEL1_RESET_UP();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel n_reset HIGH");
#endif
*/
// delay more then 2ms, for HW request
delay_ms(15);
// Reset High
CHICAGO_PANEL0_RESET_UP();
CHICAGO_PANEL1_RESET_UP();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel n_reset HIGH");
#endif
// Wait, >= 10ms
delay_ms(15);
}
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc mipi_power_on_sequence
static char DCS_sleep_control(uint8_t onoff){
#ifdef DEBUG_LEVEL_2
TRACE1("mipi_power_on_sequence_dcs_sleep_control(uint8_T onoff=%d)\n", onoff);
#endif
PacketShort_t dcs;
if(onoff == PANEL_SLEEP_IN){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Sleep In");
#endif
// Panel power OFF sequence
// Sleep In
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
dcs.mipi_port = dcs_port_seq[i];
dcs.data_type = DATASHORT_DCS_WRITE_0;
dcs.param1 = DCS_enter_sleep_mode;
dcs.param2 = 0;
dcs.pData = NULL;
mipi_packet_send_short(&dcs);
delay_ms(5);
}
// Wait, > 4 frame (60Hz = 66.666ms)
delay_ms(PANEL_SLEEP_IN_DELAY);
}
else{
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Sleep Out");
#endif
// Sleep Out
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
dcs.mipi_port = dcs_port_seq[i];
dcs.data_type = DATASHORT_DCS_WRITE_0;
dcs.param1 = DCS_exit_sleep_mode;
dcs.param2 = 0;
dcs.pData = NULL;
mipi_packet_send_short(&dcs);
delay_ms(5);
}
// Wait, >= 100ms
delay_ms(PANEL_SLEEP_OUT_DELAY);
}
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
void mipi_panel_brightness(uint8_t bl){
#ifdef DEBUG_LEVEL_2
TRACE1("mipi_panel_brightness(uint8_T bl=%d)", bl);
#endif
uint8_t i;
PacketLong_t long_dcs;
uint8_t long_data[8];
#ifdef DEBUG_LEVEL_2
TRACE1("\tmipi_panel_brightness = %d\n", bl);
#endif
long_data[0] = 0xB0;
long_data[1] = 0x04;
long_data[2] = 0x00;
long_data[3] = 0x00;
for(i = 0; i < MIPI_TOTAL_PORT; i++){
long_dcs.mipi_port = dcs_port_seq[i];
long_dcs.data_type = DATALONG_GEN_WRITE;
long_dcs.word_count = 2;
long_dcs.pData = &long_data[0];
mipi_packet_send_long(&long_dcs);
}
long_data[0] = 0xD6;
long_data[1] = 0x01;
long_data[2] = 0x00;
long_data[3] = 0x00;
for(i = 0; i < MIPI_TOTAL_PORT; i++){
long_dcs.mipi_port = dcs_port_seq[i];
long_dcs.data_type = DATALONG_GEN_WRITE;
long_dcs.word_count = 2;
long_dcs.pData = &long_data[0];
mipi_packet_send_long(&long_dcs);
}
delay_ms(40);
// PWM
long_data[0] = 0xEE;
long_data[1] = 0x01;
long_data[2] = 0x32;
long_data[3] = 0x00;
long_data[4] = bl;
long_data[5] = 0x00;
long_data[6] = 0x00;
long_data[7] = 0x00;
for(i = 0; i < MIPI_TOTAL_PORT; i++){
long_dcs.mipi_port = dcs_port_seq[i];
long_dcs.data_type = DATALONG_GEN_WRITE;
long_dcs.word_count = 5;
long_dcs.pData = &long_data[0];
mipi_packet_send_long(&long_dcs);
}
delay_ms(100);
long_data[0] = 0xEF;
long_data[1] = 0x90;
long_data[2] = 0xB0;
long_data[3] = 0x00;
for(i = 0; i < MIPI_TOTAL_PORT; i++){
long_dcs.mipi_port = dcs_port_seq[i];
long_dcs.data_type = DATALONG_GEN_WRITE;
long_dcs.word_count = 3;
long_dcs.pData = &long_data[0];
mipi_packet_send_long(&long_dcs);
}
delay_ms(40);
}
//-----------------------------------------------------------------------------
void mipi_read_test(void){
// ADAM -- DISABLE???
//return;
#ifdef DEBUG_LEVEL_2
TRACE0("mipi_read_test(void)\n");
#endif
uint8_t i;
PacketShort_t dcs;
uint8_t cmd, param1, param2;
uint8_t read_buff[4];
for(i=0;i<PANEL_COUNT;i++){
dcs.mipi_port = dcs_port_seq[i];
dcs.data_type = cmd;
dcs.param1 = param1;
dcs.param2 = param2;
dcs.pData = &read_buff[0];
mipi_packet_send_short(&dcs);
}
}
//-----------------------------------------------------------------------------
/// @copydoc mipi_panel_onoff
static char DCS_display_control(uint8_t backlight){
#ifdef DEBUG_LEVEL_2
TRACE1("mipi_panel_onoff(uint8_T backlight=%d)\n", backlight);
#endif
PacketShort_t short_dcs;
if(PANEL_DISPLAY_OFF == backlight){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel 3v3 OFF");
#endif
// Turn OFF backlight
// CHICAGO_PANEL_V33_DOWN();
// HDK_LCD_BL_OFF();
// Display data transfer
// Display Off
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_0;
short_dcs.param1 = DCS_set_display_off;
short_dcs.param2 = 0;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
// Wait, >= 1 frame (60Hz = 16.666ms)
delay_ms(PANEL_DISPLAY_OFF_DELAY);
}
else{
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Panel ON");
#endif
// Display data transfer
// Display On
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFF;
short_dcs.param2 = 0x10;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_0;
short_dcs.param1 = DCS_set_display_on;
short_dcs.param2 = 0;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
// Wait, >= 40ms
delay_ms(PANEL_DISPLAY_ON_DELAY);
// turn right for BOE panel
#ifdef BOE_VS055QHM
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = DCS_set_address_mode;
short_dcs.param2 = 0x03;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
#endif
// Wait, >= 40ms
delay_ms(PANEL_DISPLAY_ON_DELAY);
// Turn ON backlight
// CHICAGO_PANEL_V33_ON();
// HDK_LCD_BL_ON();
}
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc mipi_power_off_sequence
static char mipi_power_off_sequence(void){
// PIN control for Sharp LS029B3SX02
// DCS for Sharp LS029B3SX02
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc mipi_mcu_write_done
static void mipi_mcu_write_done(void){
#ifdef DEBUG_LEVEL_2
TRACE0("mipi_mcu_write_done(void)\n");
#endif
uint8_t reg_temp;
i2c_read_byte(SLAVEID_SPI, MISC_NOTIFY_OCM0, ®_temp);
reg_temp |= MCU_LOAD_DONE;
i2c_write_byte(SLAVEID_SPI, MISC_NOTIFY_OCM0, reg_temp);
//power is controlled by software
i2c_write_byte(SLAVEID_DP_TOP, ADDR_PWD_SEL, 0xff);
//i2c_read_byte(SLAVEID_SPI, R_SPI_REG_95, ®_temp);
//reg_temp |= 0x02;
//i2c_write_byte(SLAVEID_SPI, R_SPI_REG_95, reg_temp);
}
//-----------------------------------------------------------------------------
/// @copydoc get_pixel_clock
static uint32_t get_pixel_clock(void){
#ifdef DEBUG_LEVEL_2
TRACE0("get_pixel_clock(void)\n");
#endif
uint32_t pixel_clk_full;
uint32_t h_active, hfp, hsync, hbp;
uint32_t v_active, vfp, vsync, vbp;
uint8_t temp_char;
temp_char = MIPI_VIDEO_MODE;
if(VIDEOMODE_STACKED!=temp_char){
h_active = (PANEL_H_ACTIVE*PANEL_COUNT);
hfp = (PANEL_HFP*PANEL_COUNT);
hsync = (PANEL_HSYNC*PANEL_COUNT);
hbp = (PANEL_HBP*PANEL_COUNT);;
v_active = PANEL_V_ACTIVE;
vfp = PANEL_VFP;
vsync = PANEL_VSYNC;
vbp = PANEL_VBP;
}
else{
h_active = PANEL_H_ACTIVE;
hfp = PANEL_HFP;
hsync = PANEL_HSYNC;
hbp = PANEL_HBP;;
v_active = (PANEL_V_ACTIVE*PANEL_COUNT);
vfp = (PANEL_VFP*PANEL_COUNT);
vsync = (PANEL_VSYNC*PANEL_COUNT);
vbp = (PANEL_VBP*PANEL_COUNT);
}
temp_char = MIPI_DSC_STATUS;
if(DSC_ONE_TO_THREE == temp_char){
TRACE1("\t%s\n", "DSC pixel clock");
h_active = h_active*3;
hfp = hfp*3;
hsync = hsync*3;
hbp = hbp*3;;
}
pixel_clk_full = ((uint32_t)(h_active+hfp+hsync+hbp))*((uint32_t)(v_active+vfp+vsync+vbp))*((uint32_t)PANEL_FRAME_RATE);
return((uint32_t)(pixel_clk_full/(uint32_t)10000));
}
//-----------------------------------------------------------------------------
/// @copydoc mipi_edid_write_buffer
static char mipi_edid_write_buffer(uint32_t edid_serial_number){
#ifdef DEBUG_LEVEL_2
TRACE0("mipi_edid_write_buffer(void)\n");
#endif
uint32_t checksum;
uint32_t count;
checksum = 0;
count = 0;
#ifdef EDID_AUTO_CALCULATE
uint32_t temp_int;
uint32_t hactive,hbp,hfp,hsync;
#endif
#ifdef EDID_AUTO_CALCULATE
temp_int = MIPI_DSC_STATUS;
if(DSC_ONE_TO_THREE == temp_int){
TRACE1("\t%s\n", "DSC EDID");
hactive = PANEL_H_ACTIVE*3;
hbp = PANEL_HBP*3;
hsync = PANEL_HSYNC*3;
hfp = PANEL_HFP*3;
}else{
hactive = PANEL_H_ACTIVE;
hbp = PANEL_HBP;
hsync = PANEL_HSYNC;
hfp = PANEL_HFP;
}
i2c_write_byte(SLAVEID_EDIT_BUF, count, edid_buffer[0]);
checksum = edid_buffer[0];
// Calculate the Vendor Plug-N-Play ID bytes
//(7, 6, 5, 4, 3, 2, 1, 0)
//(0, A, A, A, A, a, B, B)
//(B, B, b, C, C, C, C, c)
// 65 - 64 = 1, is A
// 90 - 64 = 26, is Z
uint8_t pip_id_byte_a = ((EDID_PNP_NAME[0] - 64) << 2) | (((EDID_PNP_NAME[1] - 64) & 0b00011000) >> 3);
uint8_t pip_id_byte_b = (((EDID_PNP_NAME[1] - 64) & 0b00000111) << 5) | (EDID_PNP_NAME[2] & 0b00011111);
edid_buffer[EDID_MANUFACTURER_ID_L] = pip_id_byte_a;
edid_buffer[EDID_MANUFACTURER_ID_H] = pip_id_byte_b;
// Calculate product ID
edid_buffer[EDID_PRODUCT_ID_L] = (EDID_PRODUCT_ID & 0x000000FF);
edid_buffer[EDID_PRODUCT_ID_H] = ((EDID_PRODUCT_ID & 0x0000FF00) >> 8);
// Calculate product serial number for EDID
edid_buffer[EDID_SERIAL_NUM_L] = (edid_serial_number & 0x000000FF);
edid_buffer[EDID_SERIAL_NUM_L + 1] = ((edid_serial_number & 0x0000FF00) >> 8);
edid_buffer[EDID_SERIAL_NUM_H] = ((edid_serial_number & 0x00FF0000) >> 16);
edid_buffer[EDID_SERIAL_NUM_H + 1] = ((edid_serial_number & 0xFF000000) >> 24);
// Calculate manufacturing week, year
const char build_year[4] = {
(__DATE__[7]), (__DATE__[8]), (__DATE__[9]), (__DATE__[10])
};
const char build_day_str[2] = {
(__DATE__[ 4]), (__DATE__[ 5])
};
const char build_month_str[3] = {
(__DATE__[ 0]), (__DATE__[1]), (__DATE__[2])
};
uint16_t build_day;
uint8_t build_month;
if(strstr((const char *)build_month_str, "Jan") != NULL){
build_month = 1;
build_day = atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Feb") != NULL){
build_month = 2;
build_day = 31 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Mar") != NULL){
build_month = 3;
build_day = 31 + 28 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Apr") != NULL){
build_month = 4;
build_day = 31 + 28 + 31 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "May") != NULL){
build_month = 5;
build_day = 31 + 28 + 31 + 30 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Jun") != NULL){
build_month = 6;
build_day = 31 + 28 + 31 + 30 + 31 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Jul") != NULL){
build_month = 7;
build_day = 31 + 28 + 31 + 30 + 31 + 30 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Aug") != NULL){
build_month = 8;
build_day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Sep") != NULL){
build_month = 9;
build_day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Oct") != NULL){
build_month = 10;
build_day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Nov") != NULL){
build_month = 11;
build_day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + atoi(build_day_str);
}
else if(strstr((const char *)build_month_str, "Dec") != NULL){
build_month = 12;
build_day = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + atoi(build_day_str);
}
uint8_t approx_build_week = build_day / 7;
uint16_t mfg_year = atoi(build_year);
edid_buffer[EDID_WEEK] = approx_build_week;
edid_buffer[EDID_YEAR] = mfg_year - 1990;
// Set the screen size
edid_buffer[21] = (EDID_SCREEN_SIZE_HORIZONTAL_CM);
edid_buffer[22] = (EDID_SCREEN_SIZE_VERTICAL_CM);
// Set the screen transfer function (gamma)
edid_buffer[23] = (EDID_SCREEN_GAMMA * 100) - 100;
// Write the first EDID data block
for(count=1; count<EDID_DB1_BASE; count++){
i2c_write_byte_keep(count, edid_buffer[count]);
checksum = (checksum + edid_buffer[count]);
}
temp_int = get_pixel_clock();
#ifdef DEBUG_LEVEL_2
TRACE1("\tPixel_clk = %d\n", (temp_int/100));
#endif
// Pixel clock
i2c_write_byte_keep(EDID_DB1_BASE+EDID_PIXEL_CLK_L, (uint8_t)(temp_int&0x00FF));
checksum = (checksum + (uint8_t)(temp_int&0x00FF));
i2c_write_byte_keep(EDID_DB1_BASE+EDID_PIXEL_CLK_H, (uint8_t)((temp_int>>8)&0x00FF));
checksum = (checksum + (uint8_t)((temp_int>>8)&0x00FF));
// H active low bit
i2c_write_byte_keep(EDID_DB1_BASE+EDID_HACTIVE_L, (uint8_t)((hactive*PANEL_COUNT)&0x00FF));
checksum = (checksum + (uint8_t)((hactive*PANEL_COUNT)&0x00FF));
// H blank (HBP+Hsync+HFP) low bit
temp_int = (hbp+hfp+hsync)*PANEL_COUNT;
i2c_write_byte_keep(EDID_DB1_BASE+EDID_HBP_L, (uint8_t)(temp_int&0x00FF));
checksum = (checksum + (uint8_t)(temp_int&0x00FF));
// H active and HBP high bit
i2c_write_byte_keep(EDID_DB1_BASE+EDID_HACT_HBP_H, (uint8_t)((((hactive*PANEL_COUNT)>>4)&0x00F0)|((temp_int>>8)&0x000F)));
checksum = (checksum + (uint8_t)((((hactive*PANEL_COUNT)>>4)&0x00F0)|((temp_int>>8)&0x000F)));
// V active low bit
i2c_write_byte_keep(EDID_DB1_BASE+EDID_VACTIVE_L, (uint8_t)(PANEL_V_ACTIVE&0x00FF));
checksum = (checksum + (uint8_t)(PANEL_V_ACTIVE&0x00FF));
// V blank (VBP+Vsync+VFP) low bit
temp_int = PANEL_VBP+PANEL_VFP+PANEL_VSYNC;
i2c_write_byte_keep(EDID_DB1_BASE+EDID_VBP_L, (uint8_t)(temp_int&0x00FF));
checksum = (checksum + (temp_int&0x00FF));
// V active and VBP high bit
i2c_write_byte_keep(EDID_DB1_BASE+EDID_VACT_VBP_H, (uint8_t)(((PANEL_V_ACTIVE>>4)&0x00F0)|((temp_int>>8)&0x000F)));
checksum = (checksum + (uint8_t)(((PANEL_V_ACTIVE>>4)&0x00F0)|((temp_int>>8)&0x000F)));
// HFP low bit
i2c_write_byte_keep(EDID_DB1_BASE+EDID_HFP_L, (uint8_t)((hfp*PANEL_COUNT)&0x00FF));
checksum = (checksum + (uint8_t)((hfp*PANEL_COUNT)&0x00FF));
// HSYNC low bit
i2c_write_byte_keep(EDID_DB1_BASE+EDID_HSYNC_L, (uint8_t)((hsync*PANEL_COUNT)&0x00FF));
checksum = (checksum + (uint8_t)((hsync*PANEL_COUNT)&0x00FF));
// VFP and VSYNC low bit
i2c_write_byte_keep(EDID_DB1_BASE+EDID_VFP_VSYNC_L, (uint8_t)(((PANEL_VFP<<4)&0x00F0)|(PANEL_VSYNC&0x000F)));
checksum = (checksum + (uint8_t)(((PANEL_VFP<<4)&0x00F0)|(PANEL_VSYNC&0x000F)));
// HFP, HSYNC, VFP, VSYNC high bit
i2c_write_byte_keep(EDID_DB1_BASE+EDID_HFP_HSYNC_VFP_VSYNC_H, \
(uint8_t)((((hfp*PANEL_COUNT)>>2)&0x00C0)|(((hsync*PANEL_COUNT)>>4)&0x0030)|((PANEL_VFP>>2)&0x00C0)|((PANEL_VSYNC>>4)&0x0003)));
checksum = (checksum + (uint8_t)((((hfp*PANEL_COUNT)>>2)&0x00C0)|(((hsync*PANEL_COUNT)>>4)&0x0030)|((PANEL_VFP>>2)&0x00C0)|((PANEL_VSYNC>>4)&0x0003)));
count = EDID_DB1_BASE+EDID_H_DISPLAY_SIZE;
// Finish writing DB1
for(; count < EDID_DB2_BASE; count++){
i2c_write_byte_keep(count, edid_buffer[count]);
checksum = (checksum + edid_buffer[count]);
}
// Fill DB2 with zeros
for(uint8_t i = 72; i < 90; i++){
edid_buffer[i] = 0;
}
// Calculate display name
if(strlen(EDID_DISPLAY_NAME) > 12){
assert(false);
}
uint8_t i = 0;
for(; i < strlen(EDID_DISPLAY_NAME); i++){
edid_buffer[EDID_DB4_BASE + 0x05 + i] = EDID_DISPLAY_NAME[i];
}
edid_buffer[EDID_DB4_BASE + 0x05 + i] = 0x0A;
for (; i < 13 ; i++){
edid_buffer[EDID_DB4_BASE + 0x05 + i] = 0x20;
}
// Write DB2
count = EDID_DB2_BASE;
for(; count < (EDID_DB3_BASE); count++){
i2c_write_byte_keep(count, edid_buffer[count]);
checksum = (checksum + edid_buffer[count]);
}
// Write DB3
count = EDID_DB3_BASE;
for(; count < (EDID_DB4_BASE); count++){
i2c_write_byte_keep(count, edid_buffer[count]);
checksum = (checksum + edid_buffer[count]);
}
// Write DB4
count = EDID_DB4_BASE;
for(; count<(EDID_DB4_BASE + EDID_DB_SIZE); count++){
i2c_write_byte_keep(count, edid_buffer[count]);
checksum = (checksum + edid_buffer[count]);
}
// Set last byte before checksum
i2c_write_byte_keep(count, edid_buffer[count]);
checksum = (checksum + edid_buffer[count]);
count++;
#else
i2c_write_byte(SLAVEID_EDIT_BUF, count, edid_buffer[0]);
checksum = edid_buffer[0];
for(count=1; count<(EDID_LENGTH-1); count++){
i2c_write_byte_keep(count, edid_buffer[count]);
checksum = (checksum + edid_buffer[count]);
}
#endif
checksum = ((0xff - (uint8_t)(checksum & 0x00FF)) + 1);
i2c_write_byte_keep(count, (uint8_t)(checksum & 0x00FF));
#ifdef DEBUG_LEVEL_2
TRACE1("\tDone, checksum = 0x%02X\n", (uint8_t)(checksum & 0x00FF));
#endif
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc mipi_edid_write_external_buffer
static char mipi_edid_write_external_buffer(void){
#ifdef DEBUG_LEVEL_2
TRACE0("mipi_edid_write_external_buffer(void)\n");
#endif
uint32_t checksum;
uint32_t count;
checksum = 0;
count = 0;
// Enable or disable audio sink support
if(EDID_HAS_AUDIO_SINK != 1){
edid_external_buffer[131 - 128] = 0x80;
for(uint8_t i = (160 - 128); i < (173 - 128); i++){
edid_external_buffer[i] = 0;
}
}
// Write first extended EDID block
i2c_write_byte(SLAVEID_EDIT_BUF, EDID_EXTERNAL_BUF, edid_external_buffer[0]);
// Calculate checksum
checksum = edid_external_buffer[0];
for(count=1; count<(EDID_EXTERNAL_LENGTH-1); count++){
i2c_write_byte_keep(EDID_EXTERNAL_BUF+count, edid_external_buffer[count]);
checksum = (checksum + edid_external_buffer[count]);
}
checksum = ((0xff-(uint8_t)(checksum&0x00FF))+1);
i2c_write_byte_keep(EDID_EXTERNAL_BUF+count, (uint8_t)(checksum&0x00FF));
#ifdef DEBUG_LEVEL_2
TRACE1("\tDone, checksum = 0x%02X \n", ((uint8_t)(checksum&0x00FF)));
#endif
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_get_edid_resolution
static void chicago_get_edid_resolution(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_get_edid_resolution(void)\n");
#endif
uint8_t i, reg_temp;
uint32_t reg_int;
edid_db_count = 0;
for(i = 0; i < EDID_DB_MAX; i++){
// read pixel clock
i2c_read_byte(SLAVEID_EDIT_BUF, (EDID_DB1_BASE+(EDID_DB_SIZE*i)), ®_temp);
reg_int = (uint32_t)reg_temp;
i2c_read_byte(SLAVEID_EDIT_BUF, (EDID_DB1_BASE+(EDID_DB_SIZE*i))+1, ®_temp);
reg_int |= (0xFF00 & ((uint32_t) reg_temp << 8));
if(reg_int != 0){
// read H active
i2c_read_byte(SLAVEID_EDIT_BUF, (EDID_DB1_BASE+(EDID_DB_SIZE*i))+EDID_HACTIVE_L, ®_temp);
reg_int = (uint32_t) reg_temp;
i2c_read_byte(SLAVEID_EDIT_BUF, (EDID_DB1_BASE+(EDID_DB_SIZE*i))+EDID_HACT_HBP_H, ®_temp);
reg_int |= (0x0F00 & ((uint32_t) reg_temp << 4));
edid_resolution[edid_db_count][0] = reg_int;
// read V active
i2c_read_byte(SLAVEID_EDIT_BUF, (EDID_DB1_BASE+(EDID_DB_SIZE*i))+EDID_VACTIVE_L, ®_temp);
reg_int = (uint32_t) reg_temp;
i2c_read_byte(SLAVEID_EDIT_BUF, (EDID_DB1_BASE+(EDID_DB_SIZE*i))+EDID_VACT_VBP_H, ®_temp);
reg_int |= (0x0F00 & ((uint32_t) reg_temp << 4));
edid_resolution[edid_db_count][1] = reg_int;
edid_db_count++;
}
}
#ifdef DEBUG_LEVEL_2
TRACE1("\tEDID DB = %d\n", edid_db_count);
for(i = 0; i < edid_db_count; i++){
TRACE2("\tH = %d, V = %d\n", edid_resolution[i][0], edid_resolution[i][1]);
}
#endif
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_check_dp_edid_resolution
static char chicago_check_dp_edid_resolution(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_check_dp_edid_resolution(void)\n");
#endif
uint8_t reg_temp;
uint32_t dp_h_active, dp_v_active;
uint8_t i;
// Read H active from DP
i2c_read_byte(SLAVEID_MAIN_LINK, ADDR_HWIDTH7_0_DBG, ®_temp);
dp_h_active = (uint32_t)reg_temp;
i2c_read_byte(SLAVEID_MAIN_LINK, ADDR_HWIDTH15_8_DBG, ®_temp);
dp_h_active |= (0x0F00 &((uint32_t)reg_temp << 8));
// read V active from DP
i2c_read_byte(SLAVEID_MAIN_LINK, ADDR_VHEIGHT7_0_DBG, ®_temp);
dp_v_active = (uint32_t)reg_temp;
i2c_read_byte(SLAVEID_MAIN_LINK, ADDR_VHEIGHT15_8_DBG, ®_temp);
dp_v_active |= (0x0F00 &((uint32_t)reg_temp << 8));
#ifdef DEBUG_LEVEL_2
TRACE2("\tDisplayPort reports H:%d, V:%d\n", dp_h_active, dp_v_active);
#endif
// compare resolution
for(i=0; i < edid_db_count; i++){
if((dp_h_active == edid_resolution[i][0]) && (dp_v_active == edid_resolution[i][1])){
return 1;
}
}
#ifdef DEBUG_LEVEL_2
TRACE2("\tResolution DOES NOT MATCH H:%s, V:%s !\n", edid_resolution[i][0], edid_resolution[i][1]);
#endif
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_check_video_stable
static uint8_t chicago_check_video_stable(void){
#ifdef DEBUG_LEVEL_3
TRACE0("chicago_check_video_stable(void)\n");
#endif
if(VIDEOSTABLE_ALL_CONDITION == video_stable){
return FLAG_VALUE_ON;
}
else{
return FLAG_VALUE_OFF;
}
}
//-----------------------------------------------------------------------------
/// @copydoc HDK_chicago_actually_check_video_stable
static uint8_t HDK_chicago_actually_check_video_stable(void){
#ifdef DEBUG_LEVEL_3
TRACE0("HDK_chicago_actually_check_video_stable(void)\n");
#endif
uint8_t reg_temp;
// Check Video format stable status
i2c_read_byte(SLAVEID_VIDEO, ADDR_VID_STABLE_DET, ®_temp);
if((reg_temp & VID_STRM_STABLE_STATUS) != 0){
return true;
}
return false;
}
//-----------------------------------------------------------------------------
/// @copydoc HDK_chicago_actually_check_video_stable
void HDK_chicago_set_vsync_out(void){
#ifdef DEBUG_LEVEL_2
TRACE0("HDK_chicago_set_vsync_out(void)\n");
#endif
uint8_t reg_temp;
// set UART_SEL to 3
i2c_read_byte(SLAVEID_SPI, R_SYS_CTRL_1, ®_temp);
reg_temp |= MSDA_UART_SEL;
i2c_write_byte(SLAVEID_SPI, R_SYS_CTRL_1, reg_temp);
// set MSDA output enable
i2c_read_byte(SLAVEID_SPI, R_PPS_REG_110, ®_temp);
reg_temp &= ~(GPIO_DATA_1_O & GPIO_DATA_0_O); // clear bits 1 and 0
reg_temp |= GPIO_OE_1; // set bit 3
i2c_write_byte(SLAVEID_SPI, R_PPS_REG_110, reg_temp);
// redirect vsync to MSDA output pin
i2c_write_byte(SLAVEID_SPI, GPIO_MAP_0, 0x79);
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_clear_video_stable
static void chicago_clear_video_stable(void){
// Clean all conditions
video_stable = 0;
}
//-----------------------------------------------------------------------------
void external_int_isr(void) {
EXT_INTR_DISABLE(); // Disable /INT0 interrupts first
EXT_INTR_EVENT_SET();
#ifdef DEBUG_INTERRUPTS
chicago_read_intr_state();
#endif
if(chicago_get_current_state() == STATE_NONE){
// Error state
EXT_INTR_EVENT_CLEAR();
EXT_INTR_ENABLE(); // Enable /INT0 interrupts
return;
}
// DP cable plug-in
if(chicago_get_current_state() == STATE_WAITCABLE){
dp_cable = DP_CABLE_IN;
return;
}
}
//-----------------------------------------------------------------------------
void chicago_read_intr_state(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_read_intr_state(void)\n");
#endif
uint8_t reg_temp;
i2c_read_byte(SLAVEID_DP_TOP,ADDR_INTR,®_temp);
TRACE1("\tADDR_INTR = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_MIPI_CTRL,R_MIP_TX_INT,®_temp);
TRACE1("\tR_MIP_TX_INT = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_MAIN_LINK,ADDR_MAIN_LINK_INTR0,®_temp);
TRACE1("\tADDR_MAIN_LINK_INTR0 = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_MAIN_LINK,ADDR_MAIN_LINK_INTR1,®_temp);
TRACE1("\tADDR_MAIN_LINK_INTR1 = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_MAIN_LINK,ADDR_MAIN_LINK_INTR2,®_temp);
TRACE1("\tADDR_MAIN_LINK_INTR2 = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_MAIN_LINK,ADDR_MAIN_LINK_STATUS_0,®_temp);
TRACE1("\tADDR_MAIN_LINK_STATUS_0 = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_DP_IP,ADDR_SYSTEM_STATUS_1,®_temp);
TRACE1("\tADDR_SYSTEM_STATUS_1 = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_DP_IP,ADDR_AUX_CH_STATUS,®_temp);
TRACE1("\tADDR_AUX_CH_STATUS = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_DP_IP,ADDR_DPIP_INTR,®_temp);
TRACE1("\tADDR_DPIP_INTR = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_AUDIO,ADDR_AUD_INTR,®_temp);
TRACE1("\tADDR_AUD_INTR = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_VIDEO,ADDR_VID_INT,®_temp);
TRACE1("\tADDR_VID_INT = %02X\n", reg_temp);
i2c_read_byte(SLAVEID_PLL,ADDR_PLL_INTR,®_temp);
TRACE1("\tADDR_PLL_INTR = %02X\n", reg_temp);
}
//-----------------------------------------------------------------------------
void HDK_chicago_clear_intr_state(uint8_t readOut){
#ifdef DEBUG_LEVEL_2
TRACE0("HDK_chicago_clear_intr_state(void)\n");
#endif
i2c_write_byte(SLAVEID_DP_TOP, ADDR_INTR, ADDR_INTR_MASK | 0x0000);
i2c_write_byte(SLAVEID_MIPI_CTRL, R_MIP_TX_INT, R_MIP_TX_INT_MASK | 0x0000);
i2c_write_byte(SLAVEID_MAIN_LINK, ADDR_MAIN_LINK_INTR0, ADDR_MAIN_LINK_INTR0_MASK | 0x0000);
i2c_write_byte(SLAVEID_MAIN_LINK, ADDR_MAIN_LINK_INTR1, ADDR_MAIN_LINK_INTR1_MASK | 0x0000);
i2c_write_byte(SLAVEID_MAIN_LINK, ADDR_MAIN_LINK_INTR2, ADDR_MAIN_LINK_INTR2_MASK | 0x0000);
i2c_write_byte(SLAVEID_MAIN_LINK, ADDR_MAIN_LINK_STATUS_0, 0x0000);
i2c_write_byte(SLAVEID_DP_IP, ADDR_SYSTEM_STATUS_1, 0x0000);
i2c_write_byte(SLAVEID_DP_IP, ADDR_AUX_CH_STATUS, 0x0000);
i2c_write_byte(SLAVEID_DP_IP, ADDR_DPIP_INTR, ADDR_DPIP_INTR_MASK | 0x0000);
i2c_write_byte(SLAVEID_AUDIO, ADDR_AUD_INTR, ADDR_DPIP_INTR_MASK | 0x0000);
i2c_write_byte(SLAVEID_VIDEO, ADDR_VID_INT, ADDR_VID_INT_MASK | 0x0000);
i2c_write_byte(SLAVEID_PLL, ADDR_PLL_INTR, ADDR_PLL_INTR_MASK | 0x0000);
if(readOut) chicago_read_intr_state();
}
//-----------------------------------------------------------------------------
/// @copydoc clear_software_int
static void clear_software_int(void){
#ifdef DEBUG_LEVEL_3
TRACE0("clear_software_int(void)\n");
#endif
uint8_t reg_temp;
i2c_read_byte(SLAVEID_DP_TOP, ADDR_SW_INTR_CTRL, ®_temp);
reg_temp &= ~SOFT_INTR;
i2c_write_byte(SLAVEID_DP_TOP, ADDR_SW_INTR_CTRL, reg_temp);
}
//-----------------------------------------------------------------------------
void chicago_interrupt_handle(void){
#ifdef DEBUG_LEVEL_3
TRACE0("chicago_interrupt_handle(void)\n");
#endif
uint8_t reg_temp;
#ifdef DEBUG_POWER_OFF_CHICAGO_WHEN_CABLE_OUT
// Check AUX status
i2c_read_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, ®_temp);
if(0 != (reg_temp & AUX_CABLE_OUT)){
#ifdef DEBUG_LEVEL_2
TRACE2("\t%s\n\t%s\n", "cable removed!", "Bridge POWERING OFF");
#endif
// bit[5] = 1, DP cable disconnect
chicago_state_change(STATE_NONE);
i2c_write_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, 0x00);
chicago_clear_video_stable();
}
#else
// Check AUX status
i2c_read_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, ®_temp);
if(0 != (reg_temp & AUX_CABLE_OUT)){
#ifdef DEBUG_LEVEL_2
TRACE2("\t%s\n\t%s\n", "cable removed!", "Bridge STAYING ON");
#endif
// Turn off backlight
DCS_display_control(PANEL_DISPLAY_OFF);
// clear AUX_CABLE_OUT
reg_temp &= ~AUX_CABLE_OUT;
i2c_write_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, reg_temp);
chicago_clear_video_stable();
}
#endif
// Check cable in
i2c_read_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, ®_temp);
if((reg_temp & AUX_CABLE_IN) != 0){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "cable inserted!");
#endif
// clear AUX_CABLE_IN
reg_temp &= ~AUX_CABLE_IN;
i2c_write_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, reg_temp);
}
// Check VIDEO M/N RE-CACULATE
i2c_read_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, ®_temp);
if((reg_temp & VIDEO_RE_CACULATE) != 0){
#ifdef DEBUG_LEVEL_3
TRACE1("\t%s\n","M/N");
#endif
// clear VIDEO_UNSTABLE
reg_temp &= ~VIDEO_RE_CACULATE;
i2c_write_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, reg_temp);
chicago_clear_video_stable();
// handle panel off first.
return;
}
// Check Video input missing
i2c_read_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, ®_temp);
if((reg_temp & VIDEO_INPUT_EMPTY) != 0){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n","Empty video stream");
#endif
// clear VIDEO_INPUT_EMPTY
reg_temp &= ~VIDEO_INPUT_EMPTY;
i2c_write_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, reg_temp);
video_stable &= ~VIDEOSTABLE_DP_SOURCE_INPUT;
// handle video missing first.
return;
}
// Check Video format stable status
i2c_read_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, ®_temp);
if((reg_temp & VIDEO_STABLE) != 0){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Video stream stable");
#endif
// clear VIDEO_STABLE
reg_temp &= ~VIDEO_STABLE;
i2c_write_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, reg_temp);
video_stable |= (VIDEOSTABLE_VIDEO_STREAM|VIDEOSTABLE_DP_SOURCE_INPUT);
#ifdef DEBUG_CHECK_DP_RESOLUTION
if(chicago_check_dp_edid_resolution() == 1){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Measured resolution matches EDID");
#endif
video_stable |= VIDEOSTABLE_DP_RESOLUTION_MATCH;
}
#endif
return;
}
// Check Audio sample rate changed
i2c_read_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, ®_temp);
if((reg_temp & AUDIO_MN_RST) != 0){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Audio MN reset");
#endif
// clear AUDIO_MN_RST
reg_temp &= ~AUDIO_MN_RST;
i2c_write_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, reg_temp);
// Do nothing
}
// Check Audio PLL RST
i2c_read_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, ®_temp);
if((reg_temp & AUDIO_PLL_RST) != 0){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Audio PLL reset");
#endif
// clear AUDIO_PLL_RST
reg_temp &= ~AUDIO_PLL_RST;
i2c_write_byte(SLAVEID_SPI, INT_NOTIFY_MCU0, reg_temp);
// Do nothing
}
// Clear interrupt
clear_software_int();
//interrupts();
EXT_INTR_EVENT_CLEAR();
EXT_INTR_ENABLE();
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_interrupt_set
static char chicago_interrupt_set(void){
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_read_chip_id
static void chicago_read_chip_id(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_read_chip_id(void)\n");
#endif
uint8_t reg_temp;
uint32_t reg_int;
i2c_read_byte(SLAVEID_SPI, CHIP_ID_HIGH, ®_temp);
reg_int = ((((uint32_t)reg_temp)<<8)&0xFF00);
i2c_read_byte(SLAVEID_SPI, CHIP_ID_LOW, ®_temp);
reg_int |= (((uint32_t)reg_temp)&0x00FF);
#ifdef DEBUG_LEVEL_2
TRACE1("\tChip ID = %04X\n", reg_int);
#endif
}
//-----------------------------------------------------------------------------
char chicago_power_supply(uint8_t onoff){
#ifdef DEBUG_LEVEL_2
TRACE1("chicago_power_supply(uint8_t onoff=%d)\n", onoff);
#endif
if(onoff == 0) {
CHICAGO_RESET_DOWN();
CHICAGO_CHIP_POWER_DOWN();
CHICAGO_V10D_DOWN();
CHICAGO_V10A_DOWN();
CHICAGO_V18D_DOWN();
CHICAGO_V18A_DOWN();
}
else {
// Turn on 1.8v first
CHICAGO_V18D_ON();
CHICAGO_V18A_ON();
// Wait >= 1ms
delay_ms(CHICAGO_POWER_V18_DELAY);
//
// Possibility?
//
//
// Turn on 1.0v
CHICAGO_V10D_ON();
CHICAGO_V10A_ON();
// Wait >= 2ms
delay_ms(CHICAGO_POWER_V10_DELAY);
}
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
char chicago_power_onoff(uint8_t onoff){
#ifdef DEBUG_LEVEL_2
TRACE1("chicago_power_onoff(uint8_t onoff=%d)\n", onoff);
#endif
if(onoff == 0) {
CHICAGO_RESET_DOWN();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Chicago n_reset LOW");
#endif
delay_ms(CHICAGO_RESET_DOWN_DELAY);
CHICAGO_CHIP_POWER_DOWN();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Chicago pwen LOW");
#endif
delay_ms(CHICAGO_CHIPPOWER_DOWN_DELAY);
}
else {
CHICAGO_CHIP_POWER_UP();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Chicago pwen HIGH");
#endif
// delay >= 20ms, for clock stable
delay_ms(CHICAGO_CHIPPOWER_UP_DELAY);
CHICAGO_RESET_UP();
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "Chicago n_reset HIGH");
#endif
// delay >= 10ms, ocm start to work
delay_ms(CHICAGO_RESET_UP_DELAY);
//chicago_read_chip_id();
}
return RETURN_NORMAL_VALUE;
}
//-----------------------------------------------------------------------------
uint8_t dp_check_cable_plug_int(void){
#ifdef DEBUG_LEVEL_2
TRACE0("dp_check_cable_plug_int(void)\n");
#endif
if(IS_CHICAGO_INT()){
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "DP cable IN");
#endif
return DP_CABLE_IN;
}
else{
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "DP cable OUT");
#endif
return DP_CABLE_OUT;
}
}
//-----------------------------------------------------------------------------
void chicago_state_change(ChicagoState state){
#ifdef DEBUG_LEVEL_2
TRACE1("chicago_state_change(ChicagoState state=%d)\n", state);
TRACE1("\t%s", "State change to ");
switch(state){
case STATE_NONE:
TRACE1("%s", "STATE_NONE");
break;
case STATE_POWEROFF:
TRACE1("%s", "STATE_POWEROFF");
break;
case STATE_WAITCABLE:
TRACE1("%s", "STATE_WAITCABLE");
break;
case STATE_CONNECTING:
TRACE1("%s", "STATE_CONNECTING");
break;
case STATE_NORMAL:
TRACE1("%s", "STATE_NORMAL");
break;
default:
TRACE1("%s", "ERROR_STATE");
break;
}
TRACE1(", %s", "last_state is ");
switch(state){
case STATE_NONE:
TRACE1("%s\n", "STATE_NONE");
break;
case STATE_POWEROFF:
TRACE1("%s\n", "STATE_POWEROFF");
break;
case STATE_WAITCABLE:
TRACE1("%s\n", "STATE_WAITCABLE");
break;
case STATE_CONNECTING:
TRACE1("%s\n", "STATE_CONNECTING");
break;
case STATE_NORMAL:
TRACE1("%s\n", "STATE_NORMAL");
break;
default:
TRACE1("%s\n", "ERROR_STATE");
break;
}
#endif
current_state = state;
}
//-----------------------------------------------------------------------------
void chicago_last_state_change(ChicagoState state){
last_state = state;
}
//-----------------------------------------------------------------------------
ChicagoState chicago_get_current_state(void){
return current_state;
}
//-----------------------------------------------------------------------------
ChicagoState chicago_get_last_state(void){
return last_state;
}
//-----------------------------------------------------------------------------
void chicago_stop_ocm(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_stop_ocm(void)\n");
#endif
uint8_t reg_temp;
// stop main OCM
i2c_read_byte(SLAVEID_SPI, OCM_DEBUG_CTRL, ®_temp);
reg_temp |= OCM_RESET;
i2c_write_byte(SLAVEID_SPI, OCM_DEBUG_CTRL, reg_temp);
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_ocm_crc_checking
static char chicago_ocm_crc_checking(void){
#ifdef DEBUG_LEVEL_2
TRACE0("chicago_ocm_crc_checking(void)\n");
#endif
uint8_t reg_temp;
if(RETURN_NORMAL_VALUE == i2c_read_byte(SLAVEID_SPI, HDCP_LOAD_STATUS, ®_temp)){
if(OCM_FW_CRC32==(OCM_FW_CRC32®_temp)){
return RETURN_NORMAL_VALUE;
}
return RETURN_FAILURE_VALUE;
}
return RETURN_FAILURE_VALUE2;
}
//-----------------------------------------------------------------------------
/// @copydoc chicago_set_display_delay_ms
static void chicago_set_display_delay_ms(void){
uint32_t reg_int;
reg_int = GRAPHIC_CARD_DRAW_DELAY;
i2c_write_byte(SLAVEID_SPI, VIDEO_STABLE_DELAY_L, (uint8_t)(reg_int&0x00FF));
i2c_write_byte(SLAVEID_SPI, VIDEO_STABLE_DELAY_H, (uint8_t)((reg_int>>8)&0x00FF));
}
//-----------------------------------------------------------------------------
/// @copydoc DSC_setting
static void DSC_setting(void){
#ifdef DEBUG_LEVEL_2
TRACE0("DSC_setting(void)\n");
#endif
#if defined(SHARP_LS029B3SX01_ONE_120Hz)
uint8_t reg_temp;
uint32_t i;
uint32_t reg_int;
// volatile uint32_t data_value,reg_temp_1=0;
// uint32_t trunk_size,slice_height,reg_temp_2=0;
//H blanking after DSC 58 *3=174=0xae
reg_int = ((PANEL_HFP + PANEL_HSYNC + PANEL_HBP)*3)*PANEL_COUNT;
reg_int = ((reg_int*12)/10)+1;
TRACE1("\tDSC setting, blank = %d\n", reg_int);
i2c_write_byte(SLAVEID_SPI, H_BLANK_L, (uint8_t)(reg_int&0x00FF));
i2c_write_byte(SLAVEID_SPI, H_BLANK_H, (uint8_t)((reg_int>>8)&0x00FF));
// Enable DSC function
i2c_read_byte(SLAVEID_SPI, R_DSC_CTRL_0, ®_temp);
reg_temp |= DSC_EN; // bit[0] = 1;
i2c_write_byte(SLAVEID_SPI, R_DSC_CTRL_0, reg_temp);
//Config PPS table
for(i = 0; i < PPS_LENGTH; i++) {
i2c_write_byte(SLAVEID_PPS, PPS_REG_0+i, pps_table[i]);
}
#endif
}
//-----------------------------------------------------------------------------
/// @copydoc DSC_PPS_enable
static void DSC_PPS_enable_and_DCS_init(void){
#ifdef DEBUG_LEVEL_2
TRACE0("DSC_PPS_enable(void)\n");
#endif
PacketShort_t short_dcs;
PacketLong_t long_dcs;
#define DCS_en
#ifdef DCS_en
uint8_t dsc_long1[5] = {
0x3B, 0x00, 0x0A, 0x00, 0x0A
};
uint8_t dsc_long2[5] = {
0xBE, 0x00, 0x0A, 0x00, 0x0A
};
uint8_t dsc_long3[5] = {
0x2B, 0x00, 0x00, 0x06, 0x40
};
TRACE1("\t%s\n", "DSC enable in.");
/* HSSRAM parameter */
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFF;
short_dcs.param2 = 0xE0;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFB;
short_dcs.param2 = 0x01;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0x53;
short_dcs.param2 = 0x22;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
/* Initial Code Release: CDM2 */
/* Command Page */
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFF;
short_dcs.param2 = 0x25;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFB;
short_dcs.param2 = 0x01;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0x65;
short_dcs.param2 = 0x01;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0x66;
short_dcs.param2 = 0x50;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0x67;
short_dcs.param2 = 0x55;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xC4;
short_dcs.param2 = 0x90;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
/* Command Page */
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFF;
short_dcs.param2 = 0x26;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFB;
short_dcs.param2 = 0x01;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0x02;
short_dcs.param2 = 0xB5;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0x4D;
short_dcs.param2 = 0x8B;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
/* Initial Code Release: CDM2 */
/* Command Page */
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFF;
short_dcs.param2 = 0x10;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xFB;
short_dcs.param2 = 0x01;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
/* User Command Set */
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xC0;
short_dcs.param2 = 0x80;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
long_dcs.mipi_port = dcs_port_seq[i];
long_dcs.data_type = DATALONG_GEN_WRITE;
long_dcs.word_count = 0x0005;
long_dcs.pData = &dsc_long1[0];
mipi_packet_send_long(&long_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
long_dcs.mipi_port = dcs_port_seq[i];
long_dcs.data_type = DATALONG_GEN_WRITE;
long_dcs.word_count = 0x0005;
long_dcs.pData = &dsc_long2[0];
mipi_packet_send_long(&long_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xBB;
short_dcs.param2 = 0x13;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0xBA;
short_dcs.param2 = 0x03;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0x35;
short_dcs.param2 = 0x00;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
short_dcs.mipi_port = dcs_port_seq[i];
short_dcs.data_type = DATASHORT_DCS_WRITE_1;
short_dcs.param1 = 0x36;
short_dcs.param2 = 0x00;
short_dcs.pData = NULL;
mipi_packet_send_short(&short_dcs);
}
for(uint8_t i = 0; i < MIPI_TOTAL_PORT; i++){
long_dcs.mipi_port = dcs_port_seq[i];
long_dcs.data_type = DATALONG_GEN_WRITE;
long_dcs.word_count = 0x0005;
long_dcs.pData = &dsc_long3[0];
mipi_packet_send_long(&long_dcs);
}
/* Backlight should be turned on here but looks like it still works if its enabled earlier */
#endif
}
//-----------------------------------------------------------------------------
void chicago_main(void){
#ifdef DEBUG_LEVEL_3
TRACE0("chicago_main(void)\n");
#endif
char return_value;
switch(current_state){
case STATE_NONE:
#ifdef DEBUG_LEVEL_3
TRACE1("\t%s\n", "STATE_NONE");
#endif
// Change last state
last_state = STATE_NONE;
// Panel power supply off, so that also turn off backlight
mipi_panel_power_supply(PANEL_POWER_SUPPLY_OFF);
// power down Chicago power first
chicago_power_supply(CHICAGO_POWER_SUPPLY_OFF);
// power down CHIP_POWER_UP and RESET
chicago_power_onoff(CHICAGO_TURN_OFF);
// Verify I2C is working
// chicago_read_chip_id();
// Clean dp cable state
dp_cable = DP_CABLE_OUT;
// Clean HPD flag
set_HPD = FLAG_VALUE_OFF;
// Disable /INT0 interrupts first
EXT_INTR_DISABLE();
delay_ms(5);
// power on Chicago power first
chicago_power_supply(CHICAGO_POWER_SUPPLY_ON);
CHICAGO_CHIP_POWER_UP();
CHICAGO_RESET_UP();
delay(10);
//if((DIP_SWITCH_ON==(debug_switch&DS_BIST)) || (DIP_SWITCH_ON==(debug_switch&DS_SCRITP_ONLY))){
#ifdef DEBUG_ENABLE_COLOR_BARS
dp_cable = DP_CABLE_IN;
#endif
//}
// Enable /INT0 interrupts first
EXT_INTR_EVENT_CLEAR();
EXT_INTR_ENABLE();
// Check current interrupt state first
if(dp_check_cable_plug_int() == DP_CABLE_IN)
{
dp_cable = DP_CABLE_IN;
}
#ifdef DEBUG_REMOVE_CABLE_DET
// don't detect cable
dp_cable = DP_CABLE_IN;
#endif
// move to next state
current_state = STATE_WAITCABLE;
break;
case STATE_WAITCABLE:
#ifdef DEBUG_LEVEL_3
TRACE1("\t%s\n", "STATE_WAITCABLE");
#endif
// adam edit
// if(0 /*DIP_SWITCH_ON==(debug_switch&DS_SCRITP_ONLY)*/){
//
// // For Debug script only
// if(STATE_NONE==last_state){
//
// // RESET and POWER UP Chicago
// chicago_power_onoff(CHICAGO_TURN_ON);
//
// // Stop OCM
// chicago_stop_ocm();
//
// // Power On panel
// mipi_panel_power_supply(PANEL_POWER_SUPPLY_ON);
//
// // Turn On backlight
// // mipi_panel_onoff(PANEL_DISPLAY_ON);
//
// // into sleep mode
// mipi_power_on_sequence(PANEL_SLEEP_IN);
//
// // Change state
// last_state = STATE_WAITCABLE;
// }
// }
// else{
// DP cable plug-in
if(dp_cable == DP_CABLE_IN)
{
if(last_state == STATE_NONE)
{
// RESET and POWER UP Chicago
chicago_power_onoff(CHICAGO_TURN_ON);
chicago_read_chip_id();
// ryan
// Set HPD to low
// chicago_hpd_set(HDP_FORCE, HDP_DATA_LOW);
return_value = chicago_ocm_crc_checking();
// checking OCM load status, if CRC32 error, re-load OCM again
if(return_value == RETURN_FAILURE_VALUE)
{
TRACE1("\t%s\n", "OCM CRC Error, reboot ANX7530");
// power down CHIP_POWER_UP and RESET
chicago_power_onoff(CHICAGO_TURN_OFF);
// power down Chicago power first
chicago_power_supply(CHICAGO_POWER_SUPPLY_OFF);
delay_ms(5);
// power on Chicago power first
chicago_power_supply(CHICAGO_POWER_SUPPLY_ON);
// RESET and POWER UP Chicago
chicago_power_onoff(CHICAGO_TURN_ON);
}
else if(return_value == RETURN_FAILURE_VALUE2)
{
TRACE1("\t%s\n", "I2C Error!!!");
}
else
{
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "OCM CRC pass.");
#endif
// Change last state
last_state = STATE_WAITCABLE;
// adam edit
// Get MIPI TX data
if(0 /*DIP_SWITCH_ON==(debug_switch&DS_EDID_SELECT)*/)
{
// EDID for HDMI
edid_buffer = &edid_hdmi[0];
edid_external_buffer = &edid_external_hdmi[0];
}
else
{
// EDID for DP
edid_buffer = &edid_dp[0];
edid_external_buffer = &edid_external_dp[0];
}
uint32_t edid_serial_number = 1024;
mipi_edid_write_buffer(edid_serial_number);
mipi_edid_write_external_buffer();
// Audio MCLK always on, sample interface
//chicago_audio_mclk_always_out();
chicago_set_panel_parameters();
HDK_chicago_set_vsync_out();
#ifdef DEBUG_CHECK_DP_RESOLUTION
chicago_get_edid_resolution();
#endif
// adam edit
if(0 /*DIP_SWITCH_ON==(debug_switch&DS_SCRITP_ONLY)*/ )
{
// Debug Script stops in current state (STATE_WAITCABLE)
}
else
{
// Normal Operation goes to next state (STATE_CONNECTING)
current_state = STATE_CONNECTING;
}
}
}
}
break;
case STATE_CONNECTING:
#ifdef DEBUG_LEVEL_3
TRACE1("\t%s\n", "STATE_CONNECTING");
#endif
if(last_state == STATE_WAITCABLE)
{
mipi_mcu_write_done();
mipi_panel_power_supply(PANEL_POWER_SUPPLY_ON);
// Turn off backlight
//DCS_display_control(PANEL_DISPLAY_OFF);
// into sleep mode
//DCS_sleep_control(PANEL_SLEEP_IN);
// clear video stable flag
chicago_clear_video_stable();
chicago_interrupt_set();
// Change last state
last_state = STATE_CONNECTING;
}
else if(last_state == STATE_CONNECTING)
{
// Set HPD
if(set_HPD == FLAG_VALUE_OFF)
{
// did not set HPD before
//if(DIP_SWITCH_ON==(debug_switch&DS_BIST)){
#ifdef DEBUG_ENABLE_COLOR_BARS
// no need to set HPD in BIST mode
set_HPD = FLAG_VALUE_ON;
#else
//}
//else{
if(chicago_check_ocm_status())
{
// OCM load done
// We can set customized setting and DPCD
// after "OCM load done" and before HPD to unforce high
// chicago_customized_setting();
DPCD_setting();
// ADAM - Is this needed?
delay_ms(200);
// Set HPD to unForce High
chicago_hpd_set(HDP_UNFORCE, HDP_DATA_HIGH);
// set flag to ON, no need to set HPD again
set_HPD = FLAG_VALUE_ON;
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "HotPlug Detect set to HIGH");
#endif
}
#endif
//}
}
// // Check Video stable
// // Broken!!!
// if(chicago_check_video_stable() == 1){
// current_state = STATE_NORMAL;
// }
if(HDK_chicago_actually_check_video_stable() == true)
{
current_state = STATE_NORMAL;
}
}
else if(last_state == STATE_NORMAL)
{
TRACE1("\t%s\n", "Panel Off");
// Turn off backlight
DCS_display_control(PANEL_DISPLAY_OFF);
// Go into sleep mode
DCS_sleep_control(PANEL_SLEEP_IN);
// power supply off panel
mipi_panel_power_supply(PANEL_POWER_SUPPLY_OFF);
// power supply on panel
mipi_panel_power_supply(PANEL_POWER_SUPPLY_ON);
last_state = STATE_CONNECTING;
}
else
{
#ifdef DEBUG_LEVEL_2
TRACE1("\t%s\n", "ERROR_STATE");
#endif
// Error state
TRACE2("\t%s: Error last state, last_state = %d", __LINE__, (uint32_t)(last_state));
last_state = STATE_CONNECTING;
current_state = STATE_NONE;
}
break;
case STATE_NORMAL:
#ifdef DEBUG_LEVEL_3
TRACE1("\t%s\n", "STATE_NORMAL");
#endif
if(last_state == STATE_CONNECTING)
{
//Serial.println("Panel ON");
last_state = STATE_NORMAL;
// Panel initialization
DSC_PPS_enable_and_DCS_init();
// Sleep control
DCS_sleep_control(PANEL_SLEEP_OUT);
//Turn on backlight
DCS_display_control(PANEL_DISPLAY_ON);
}
if(STATE_NORMAL==last_state)
{
if(chicago_check_video_stable() == 0)
{
current_state = STATE_CONNECTING;
}
}
break;
// for debug only
case STATE_POWEROFF:
#ifdef DEBUG_LEVEL_3
TRACE1("\t%s\n", "STATE_POWEROFF");
#endif
// For Debug Command Used Only
if(last_state != STATE_POWEROFF)
{
chicago_power_onoff(CHICAGO_TURN_OFF);
// power down Chicago power first
chicago_power_supply(CHICAGO_POWER_SUPPLY_OFF);
// Clean dp cable state
dp_cable = DP_CABLE_OUT;
// Disable /INT0 interrupts first
EXT_INTR_DISABLE();
// Change last state
last_state = STATE_POWEROFF;
}
break;
default:
#ifdef DEBUG_LEVEL_3
TRACE1("\t%s\n", "STATE_DEFAULT_ERROR");
#endif
TRACE1("\tError current state, current_state = %d\n", (uint32_t)(current_state));
last_state = STATE_NONE;
current_state = STATE_NONE;
break;
}
}
45e62ed2aThis file is pinned to the selected release. Download the original to open it in your design tool.