void srcif_hybrid_fsm_goto_rst_all()
{
int data32 = 0;
LOGD(TAG_VPP, "hybrid fsm reset all\n");
Wr(SRCIF_WRAP_CTRL1 , (Rd(SRCIF_WRAP_CTRL1) | 0x10));
Wr(SRCIF_WRAP_CTRL1 , (Rd(SRCIF_WRAP_CTRL1) & 0xffffffef));
}
void u_boot_init_lvds()
{
int j;
int m = 10, n = 34;
unsigned long reverse = simple_strtoul(getenv ("port_reverse"), NULL, 16);
if(reverse == 1) {
port_reverse = 1;
}
//GPIOX_54 LVDS power off
set_gpio_val(GPIOX_bank_bit32_63(54), GPIOX_bit_bit32_63(54), 0);
set_gpio_mode(GPIOX_bank_bit32_63(54), GPIOX_bit_bit32_63(54), 0);
//GPIOX_54 LVDS power on
set_gpio_val(GPIOX_bank_bit32_63(54), GPIOX_bit_bit32_63(54), 1);
set_gpio_mode(GPIOX_bank_bit32_63(54), GPIOX_bit_bit32_63(54), 0);
for (j=0; j<n; j++)
udelay(1000);
Wr(REG_LVDS_PHY_CNTL4, Rd(REG_LVDS_PHY_CNTL4)|0xfff); //LVDS_MDR_PU
Wr(REG_LVDS_PHY_CNTL5, Rd(REG_LVDS_PHY_CNTL5)|(0xf<<11)); //LVDS_REFCTL<4:0>=<01111>
Wr(REG_LVDS_PHY_CNTL0,0xfff); //LVDS_PDN_A*=1, LVDS_PDN_B*=1
/*for (j=0; j<m; j++)
udelay(1000);*/
//GPIOB_6 Backlight power on
set_gpio_val(GPIOB_bank_bit0_7(6), GPIOB_bank_bit0_7(6), 0);
set_gpio_mode(GPIOB_bank_bit0_7(6), GPIOB_bank_bit0_7(6), 0);
lvds_set_current_vmode(VMODE_LVDS_1080P);
}
static int lvds_suspend(void)
{
int j;
long m = 250, n= 200;
if (pdata->lvds_backlight_power_off)
pdata->lvds_backlight_power_off();
for (j=0; j<n; j++)
udelay(1000);
Wr(REG_LVDS_PHY_CNTL4, Rd(REG_LVDS_PHY_CNTL4)&(~0xfff));//LVDS_MDR_PU
Wr(REG_LVDS_PHY_CNTL5, Rd(REG_LVDS_PHY_CNTL5)&(~(0xc<<11))); //LVDS_REFCTL<3:2> = 0
Wr(REG_LVDS_PHY_CNTL0,0); //LVDS_PDN_A*=0, LVDS_PDN_B*=0
lvds_init_flag = 0;
for (j=0; j<m; j++)
udelay(1000);
if (pdata->lvds_panel_power_off)
pdata->lvds_panel_power_off();
printk("vout lvds suspend\n");
return 0;
}
void Camera::lookAt(const Point<double> &target)
{
Vd dir = ~Vd(target-origin);
double len = sqrt(dir.x * dir.x + dir.y * dir.y);
double pitch = atan2(dir.z, len);
double pan = atan2(dir.x, dir.y);
objective = Qd(Rd(-pitch, Vd(1, 0, 0))) * Qd(Rd(pan, Vd(0, 0, 1)));
}
// -----------------------------------------------------------------
// clk_util_set_video_clock()
//
// This function sets the "master clock" in the video clock
// module $clk_rst_tst/rtl/crt_video
//
// wire cntl_sclk_n = hi_video_clk_cntl[10];
// wire [1:0] cntl_vclk3_mux = hi_video_clk_cntl[9:8];
// wire [1:0] cntl_vclk2_mux = hi_video_clk_cntl[7:6];
// wire [1:0] cntl_vclk1_mux = hi_video_clk_cntl[5:4];
// wire [3:0] cntl_xd = hi_video_clk_cntl[3:0];
static void clk_util_set_video_clock( unsigned long hiu_reg, unsigned long xd )
{
// switch video clock to sclk_n and enable the PLL
Wr( HHI_VID_CLK_CNTL, Rd(HHI_VID_CLK_CNTL) & ~(1 << 10) ); // Switch to the SCLK
// delay 2uS to allow the sync mux to switch over
Wr( ISA_TIMERE, 0);
while( Rd(ISA_TIMERE) < 2 ) {}
// Bring out of reset but keep bypassed to allow to stablize
//Wr( HHI_VID_PLL_CNTL, (0 << 15) | (0 << 14) | (hiu_reg & 0x3FFF) );
Wr( HHI_VID_PLL_CNTL, hiu_reg );
// Setup external divider in $clk_rst_tst/rtl/crt_video.v
// wire [3:0] cntl_div_by_1 = hi_vid_clk_cntl[3:0]; // for LVDS we can divide by 1 (pll direct)
// wire cntl_vclk_gate = hi_vid_clk_cntl[0]; // needed to mux divide by 1
//
// wire [7:0] cntl_xd = hi_vid_clk_div[7:0];
if( xd == 1 ) {
// Set divide by 1 in crt_video
Wr( HHI_VID_CLK_CNTL, Rd(HHI_VID_CLK_CNTL) | (0xF << 0) );
} else {
Wr( HHI_VID_CLK_CNTL, (Rd(HHI_VID_CLK_CNTL) & ~(0xF << 0)) ); // disable divide by 1 control
}
Wr( HHI_VID_CLK_DIV, (Rd(HHI_VID_CLK_DIV) & ~(0xFF << 0)) | (xd-1) ); // setup the XD divider value
// delay 5uS
Wr( ISA_TIMERE, 0);
while( Rd(ISA_TIMERE) < 5 ) {}
Wr( HHI_VID_CLK_CNTL, Rd(HHI_VID_CLK_CNTL) | (1 << 10) ); // Switch to the PLL
// delay 2uS
Wr( ISA_TIMERE, 0);
while( Rd(ISA_TIMERE) < 2 ) {}
}
void Controller::frame()
{
if (move[dirY] != 0.0) moveY(move[dirY]);
if (move[dirZ] != 0.0) moveZ(move[dirZ]);
if (look[dirX] != 0.0) lookX(look[dirX]);
if (look[dirY] != 0.0) lookY(look[dirY]);
if (look[dirZ] != 0.0) lookZ(look[dirZ]);
if (move[dirY] != 0.0)
{
if ((move[dirX] < 0.0 && move[dirY] > 0.0)
|| (move[dirX] > 0.0 && move[dirY] < 0.0))
player->rotation = player->rotation * Rd(-0.05,Vd(0,0,1));
else if ((move[dirX] > 0.0 && move[dirY] > 0.0)
|| (move[dirX] < 0.0 && move[dirY] < 0.0))
player->rotation = player->rotation * Rd(0.05,Vd(0,0,1));
else
{
Vd camv = camAngle*Vd(0,1,0);
Vd plav = player->rotation*Vd(0,1,0);
camv.z = 0; camv = ~camv;
plav.z = 0; plav = ~plav;
double angle = atan2(camv.y - plav.y, camv.x - plav.x);
double angle2 = (angle < 0? -angle : angle);
double axis = angle2 > 0.5*Pi ^ angle > 0? 1 : -1;
angle2 = angle2 > 0.5*Pi ? Pi - angle2 : angle2;
angle2 = angle2 < 0.05? angle2 : 0.05;
if (axis != 0)
player->rotation = player->rotation * Rd(-angle2,Vd(0,0,axis));
}
}
Vector<double> vec = (-player->rotation * Vector<double>(0,1,0));
vec.z = 0;
vec = ~vec;
double yaw = atan2(vec.x, vec.y);
target = player->origin + Pd(.75 * sin(yaw - .25*Pi), .75 * cos(yaw-.25*Pi), 2);
vec = ~(camAngle * Vector<double>(0,1,0));
if (firstPerson)
{
camera.lookAt(camera.origin + (vec * 5.0));
}
else
{
camera.lookAt(target);
}
Objects::Player * p = TO(Objects::Player,player);
p->velocity = Vd(0,MoveSpeed,0);
}
static void SetPtPk(Rd *Pt,const int *dfon,int nn)
{ // P0 P1 et P2 , P1b
const int d= E::Rd::d;
int k=0;
if(dfon[0])
{
for(int i=0;i<=d;++i)
Pt[k++]=Rd();
for(int i=0;i<d;++i)
Pt[i+1][i]=1.;
}
if(dfon[1]&& d !=1)
for(int i=0;i<E::ne;++i)
Pt[k++] = (Pt[E::nvedge[i][0]]+Pt[E::nvedge[i][1]])*0.5;
if(dfon[d]==1)
Pt[k++]=Rd::diag(1./(d+1));
if(nn != k)
{
cout << nn << " == " << k << " d = "<< d << " " << dfon[0]<< dfon[1]<<dfon[2]<<dfon[3]<<" "<< E::ne << endl;
assert(nn==k);
}
if(verbosity>9)
cout << " Pk = " << KN_<Rd>(Pt,nn)<<"\n";
}
void FsGuiColorDialog::UpdateRGBSliderFromCurrentColor(void)
{
auto col=GetCurrentColor();
redSlider->SetPosition(col.Rd());
greenSlider->SetPosition(col.Gd());
blueSlider->SetPosition(col.Bd());
}
void srcif_pure_sw_ptn()
{
static int do_ptn_flag = 1;
if(do_ptn_flag == 0){
srcif_pure_ptn_flag = 1;
return;
}
if(do_ptn_flag){
int data32 = 0;
Wr(SRCIF_WRAP_CTRL , 0x00000020);
//step 1, rst fifo, vmux, gate vpu, force fifo_en, vmux_en, vmux_sel
Wr(SRCIF_WRAP_CTRL , 0x0802aaa0);
delay_us(1);
//step 2, clock mux to ptn
Wr(SRCIF_WRAP_CTRL , 0x0812aaa0);
delay_us(1);
//step 3, Need a wait pll lock here
//step 4, release rst of vmux, en vpu_clk_en
Wr(SRCIF_WRAP_CTRL , 0x0c12aba0);
delay_us(1);
//step 5, enable ptn_en, vmux_en
Wr(SRCIF_WRAP_CTRL , 0x0c12bbe0);
Wr(VP_CTRL , Rd(VP_CTRL) | 0x2);
delay_us(1);
}
do_ptn_flag = 0;
}
void Controller::lookZ(double speed)
{
speed *= LookSpeed;
speed *= FRATE;
Qd buffer = camAngle;//Used to rollback if out of bounds
Vector<double> mystery = ~(camAngle * Vector<double>(0,1,0));
double mysteryYaw = atan2(mystery.x, mystery.y);
camAngle = Qd(Rd(speed, Vd(cos(mysteryYaw),-sin(mysteryYaw),0))) * camAngle;
if((camAngle*Vector<double>(0,1,0)).z > 0.99 || (camAngle*Vector<double>(0,1,0)).z < -0.99){
camAngle = buffer;
return;
}
Vector<double> vec = ~(camAngle * Vector<double>(0,1,0));
if (firstPerson == true)
{
camera.origin = player->origin + Pd(0,0,2.5) + vec;
camera.lookAt(camera.origin + (vec * 5.0));
}
else
{
camera.origin = target - (vec * zoom);
camera.lookAt(target);
}
}
BufferOffset Assembler::LogicalImmediate(const Register& rd, const Register& rn,
unsigned n, unsigned imm_s, unsigned imm_r, LogicalOp op)
{
unsigned reg_size = rd.size();
Instr dest_reg = (op == ANDS) ? Rd(rd) : RdSP(rd);
return Emit(SF(rd) | LogicalImmediateFixed | op | BitN(n, reg_size) |
ImmSetBits(imm_s, reg_size) | ImmRotate(imm_r, reg_size) | dest_reg | Rn(rn));
}
void Droppable::preRender(){
Object::preRender();
int timelived = Video::ElapsedTime() - dropped;
if(timelived >= ttl){
done = true;
return;
}
rotation = rotation * Rd(0.02, Vd(0,0,1));
}
BufferOffset Assembler::DataProcShiftedRegister(const Register& rd, const Register& rn,
const Operand& operand, FlagsUpdate S, Instr op)
{
VIXL_ASSERT(operand.IsShiftedRegister());
VIXL_ASSERT(rn.Is64Bits() || (rn.Is32Bits() && is_uint5(operand.shift_amount())));
return Emit(SF(rd) | op | Flags(S) |
ShiftDP(operand.shift()) | ImmDPShift(operand.shift_amount()) |
Rm(operand.reg()) | Rn(rn) | Rd(rd));
}
void set_ddr_clock(struct ddr_set * timing_reg)
{
/*
#ifdef ENABLE_POWER_SAVING
APB_Wr(PCTL_DLLCR_ADDR, APB_Rd(PCTL_DLLCR_ADDR)|(7<<2));
#endif
*/
M6_PLL_RESET(HHI_DDR_PLL_CNTL);
Wr(HHI_DDR_PLL_CNTL2,M6_DDR_PLL_CNTL_2);
Wr(HHI_DDR_PLL_CNTL3,M6_DDR_PLL_CNTL_3);
Wr(HHI_DDR_PLL_CNTL4,M6_DDR_PLL_CNTL_4);
#ifdef CONFIG_CMD_DDR_TEST
if((Rd(PREG_STICKY_REG0) & 0xffff) == 0x2012){
zqcr = (Rd(PREG_STICKY_REG0) >> 16);
Wr(HHI_DDR_PLL_CNTL, Rd(PREG_STICKY_REG1));
Wr(PREG_STICKY_REG0, 0);
Wr(PREG_STICKY_REG1, 0);
}
Spectrum DipoleSubsurfaceIntegrator::Li(const Scene *scene, const Renderer *renderer,
const RayDifferential &ray, const Intersection &isect,
const Sample *sample, RNG &rng, MemoryArena &arena) const {
Spectrum L(0.);
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
Spectrum rho_dr = Spectrum(1.0f);
// Evaluate BSSRDF and possibly compute subsurface scattering
BSSRDF *bssrdf = isect.GetBSSRDF(ray, arena);
if (bssrdf && octree) {
Spectrum sigma_a = bssrdf->sigma_a();
Spectrum sigmap_s = bssrdf->sigma_prime_s();
Spectrum sigmap_t = sigmap_s + sigma_a;
if (!sigmap_t.IsBlack()) {
// Use hierarchical integration to evaluate reflection from dipole model
PBRT_SUBSURFACE_STARTED_OCTREE_LOOKUP(const_cast<Point *>(&p));
DiffusionReflectance Rd(sigma_a, sigmap_s, bssrdf->eta());
Spectrum Mo = octree->Mo(octreeBounds, p, Rd, maxError);
FresnelDielectric fresnel(1.f, bssrdf->eta());
Spectrum Ft = Spectrum(1.f) - fresnel.Evaluate(AbsDot(wo, n));
float Fdt = 1.f - Fdr(bssrdf->eta());
// modulate SSS contribution by rho_dr
//L += (INV_PI * Ft) * (Fdt * Mo);
rho_dr = wet->integrate_BRDF(bsdf, ray.d, 10, BxDFType(BSDF_REFLECTION | BSDF_GLOSSY));
L += (INV_PI * Ft) * (Fdt * Mo) * (Spectrum(1.0f) - rho_dr);
//L += (INV_PI * Ft) * (Fdt * Mo) * (Spectrum(0.0f));
PBRT_SUBSURFACE_FINISHED_OCTREE_LOOKUP();
}
}
L += UniformSampleAllLights(scene, renderer, arena, p, n,
wo, isect.rayEpsilon, ray.time, bsdf, sample, rng, lightSampleOffsets,
bsdfSampleOffsets);
if (ray.depth < maxSpecularDepth) {
// Trace rays for specular reflection and refraction.
//TODO: this has no effect?
L += SpecularReflect(ray, bsdf, rng, isect, renderer, scene,
sample, arena);
L += SpecularTransmit(ray, bsdf, rng, isect,
renderer, scene, sample, arena);
}
return L;
}
void BkgShapeBinnedExtractor::FillHists()
/////////////////////////////////////////
{
int Nbins = bins.size();
std::cout << "Number of bins = " << Nbins << std::endl;
Bkg2DFit* RB2DF = new Bkg2DFit(m_tree,bins[0],m_ParamFile);
//---- Fill data histogram ----//
int entries = (int)m_tree->GetEntriesFast();
TreeReader Rd(m_tree);
for( int entry=0 ; entry< entries ; entry++ ){
Rd.GetEntry(entry);
double Iso_L = Rd.GetVariable("Iso_L");
double Iso_SL = Rd.GetVariable("Iso_SL");
int Tight_L = Rd.GetVariable("IsTight_L");
int Tight_SL = Rd.GetVariable("IsTight_SL");
double mgg = Rd.GetVariable("mgg");
hmgg->Fill(mgg);
if( Tight_L==1 && Tight_SL==1 &&
Iso_L < 5 && Iso_SL<5 )
hmgg_iso->Fill(mgg);
}
for(int ibin=0 ; ibin < Nbins ; ibin++){
bool do1Dfits = true;
bool do2Dfits = true;
bool doSplot = false;
RB2DF->Init(bins[ibin],m_ParamFile);
RB2DF->Fitter(do1Dfits,do2Dfits,doSplot);
RB2DF->PlotResults();
hmgg_tot->SetBinContent(ibin+1,RB2DF->GetSumofYields_NoIso());
hmgg_tot->SetBinError(ibin+1,RB2DF->GetSumofYieldsError_NoIso());
hmgg_gg->SetBinContent(ibin+1,RB2DF->GetNgamgamYield_NoIso());
hmgg_gg->SetBinError(ibin+1,RB2DF->GetNgamgamYieldError_NoIso());
hmgg_gj->SetBinContent(ibin+1,RB2DF->GetNgamjetYield_NoIso());
hmgg_gj->SetBinError(ibin+1,RB2DF->GetNgamjetYieldError_NoIso());
hmgg_jg->SetBinContent(ibin+1,RB2DF->GetNjetgamYield_NoIso());
hmgg_jg->SetBinError(ibin+1,RB2DF->GetNjetgamYieldError_NoIso());
hmgg_jj->SetBinContent(ibin+1,RB2DF->GetNjetjetYield_NoIso());
hmgg_jj->SetBinError(ibin+1,RB2DF->GetNjetjetYieldError_NoIso());
//---------------------------------------------------------------
hmgg_tot_iso->SetBinContent(ibin+1,RB2DF->GetSumofYields());
hmgg_tot_iso->SetBinError(ibin+1,RB2DF->GetSumofYieldsError());
hmgg_gg_iso->SetBinContent(ibin+1,RB2DF->GetNgamgamYield());
hmgg_gg_iso->SetBinError(ibin+1,RB2DF->GetNgamgamYieldError());
hmgg_gj_iso->SetBinContent(ibin+1,RB2DF->GetNgamjetYield());
hmgg_gj_iso->SetBinError(ibin+1,RB2DF->GetNgamjetYieldError());
hmgg_jg_iso->SetBinContent(ibin+1,RB2DF->GetNjetgamYield());
hmgg_jg_iso->SetBinError(ibin+1,RB2DF->GetNjetgamYieldError());
hmgg_jj_iso->SetBinContent(ibin+1,RB2DF->GetNjetjetYield());
hmgg_jj_iso->SetBinError(ibin+1,RB2DF->GetNjetjetYieldError());
//---------------------------------------------------------------
}
delete RB2DF;
}
static void build_Rd_table(ScatterSettings *ss)
{
float r;
int i, size = RD_TABLE_SIZE+1;
ss->tableRd= MEM_mallocN(sizeof(float)*size, "scatterTableRd");
ss->tableRd2= MEM_mallocN(sizeof(float)*size, "scatterTableRd");
for (i= 0; i < size; i++) {
r= i*(RD_TABLE_RANGE/RD_TABLE_SIZE);
/*if (r < ss->invsigma_t_*ss->invsigma_t_)
r= ss->invsigma_t_*ss->invsigma_t_;*/
ss->tableRd[i]= Rd(ss, sqrt(r));
r= i*(RD_TABLE_RANGE_2/RD_TABLE_SIZE);
/*if (r < ss->invsigma_t_)
r= ss->invsigma_t_;*/
ss->tableRd2[i]= Rd(ss, r);
}
}
u32 VSYNCOSD_RD_MPEG_REG(unsigned long addr)
{
int i;
if(rdma_enable)
{
for(i=(item_count -1); i>=0; i--)
{
if(addr==rdma_table[i].addr)
return rdma_table[i].val;
}
}
return Rd(addr);
}
static int lvds_resume(void)
{
int j;
int m = 200, n = 300;
if (pdata->lvds_panel_power_on)
pdata->lvds_panel_power_on();
for (j=0; j<n; j++)
udelay(1000);
Wr(REG_LVDS_PHY_CNTL4, Rd(REG_LVDS_PHY_CNTL4)|0xfff); //LVDS_MDR_PU
Wr(REG_LVDS_PHY_CNTL5, Rd(REG_LVDS_PHY_CNTL5)|(0xf<<11)); //LVDS_REFCTL<4:0>=<01111>
Wr(REG_LVDS_PHY_CNTL0,0xfff); //LVDS_PDN_A*=1, LVDS_PDN_B*=1
for (j=0; j<m; j++)
udelay(1000);
if (pdata->lvds_backlight_power_on)
pdata->lvds_backlight_power_on();
printk("vout lvds resume\n");
return 0;
}
// -----------------------------------------
// clk_util_lvds_set_clk_div()
// -----------------------------------------
// This task is used to setup the LVDS dividers.
//
// Dual Pixel Mode
// clk_util_lvds_set_clk_div( 2, // unsigned long divn_sel, // select divide by 3.5
// 7, // unsigned long divn_tcnt, // ignored
// 0 ); // unsigned long div2_en, // divide by 1 for LVDS
//
// Single Pixel Mode
// clk_util_lvds_set_clk_div( 1, // unsigned long divn_sel, // select divide by N
// 7, // unsigned long divn_tcnt, // divide by 7
// 0 ); // unsigned long div2_en, // divide by 1 for LVDS
static void clk_util_lvds_set_clk_div( unsigned long divn_sel,
unsigned long divn_tcnt,
unsigned long div2_en )
{
// assign lvds_div_phy_clk_en = tst_lvds_tmode ? 1'b1 : phy_clk_cntl[10];
// assign lvds_div_div2_sel = tst_lvds_tmode ? atest_i[5] : phy_clk_cntl[9];
// assign lvds_div_sel = tst_lvds_tmode ? atest_i[7:6] : phy_clk_cntl[8:7];
// assign lvds_div_tcnt = tst_lvds_tmode ? 3'd6 : phy_clk_cntl[6:4];
// If dividing by 1, just select the divide by 1 path
if( divn_tcnt == 1 ) {
divn_sel = 0;
}
Wr( REG_LVDS_PHY_CLK_CNTL, ((Rd(REG_LVDS_PHY_CLK_CNTL) & ~((0x3 << 7) | (1 << 9) | (0x7 << 4))) | ((1 << 10) | (divn_sel << 7) | (div2_en << 9) | (((divn_tcnt-1)&0x7) << 4))) );
}
void Controller::lookX(double speed)
{
speed *= -LookSpeed;
speed *= FRATE;
camAngle = Qd(Rd(speed, Vd(0,0,1))) * camAngle;
Vector<double> vec = ~(camAngle * Vector<double>(0,1,0));
if (firstPerson == true)
{
camera.origin = player->origin + Pd(0,0,2.5) + vec;
camera.lookAt(camera.origin + (vec * 5.0));
}
else
{
camera.origin = target - (vec * zoom);
camera.lookAt(target);
}
}
void init_lvds_phy(void)
{
unsigned tmp_add_data;
Wr(REG_LVDS_PHY_CNTL4, Rd(REG_LVDS_PHY_CNTL4)|0xfff);
Wr(REG_LVDS_PHY_CNTL3, 0x3f);
tmp_add_data = 0;
tmp_add_data |= 0xf<<0; //LVDS_PREM_CTL<3:0>=<1111>
tmp_add_data |= 0x3 << 4; //LVDS_SWING_CTL<3:0>=<0011>
tmp_add_data |= 0x2<<8 ; //LVDS_VCM_CTL<2:0>=<010>
tmp_add_data |= 0xf<<11; //LVDS_REFCTL<4:0>=<01111>
Wr(REG_LVDS_PHY_CNTL5, tmp_add_data);
Wr(REG_LVDS_PHY_CNTL0,0xfff);
Wr(REG_LVDS_PHY_CNTL1,0xfff);
Wr(REG_LVDS_PHY_CNTL2,0xfff);
Wr(REG_LVDS_PHY_CNTL6,0xcccc);
Wr(REG_LVDS_PHY_CNTL7,0xcccc);
Wr(REG_LVDS_PHY_CNTL8,0xcccc);
}
void srcif_fsm_no_mute_stbl()
{
Wr(SRCIF_WRAP_CTRL1, (Rd(SRCIF_WRAP_CTRL1) & 0xffbfffff));
}
void srcif_fsm_mute_stbl()
{
Wr(SRCIF_WRAP_CTRL1, (Rd(SRCIF_WRAP_CTRL1) | 0x400000));
}
void disassembler::Ry(const x86_insn *insn)
{
if (insn->os_64) Rq(insn);
else Rd(insn);
}
void srcif_fsm_clk_freerun()
{
Wr(SRCIF_WRAP_CTRL, (Rd(SRCIF_WRAP_CTRL) | 0x40000));
}
void srcif_hybrid_fsm_ctrl()
{
int data32 = 0;
//check status register
data32 = Rd(SRCIF_WRAP_STATUS);
LOGD(TAG_VPP, "status = %x\n",data32);
LOGD(TAG_VPP, "state = %x\n",data32 & 0x7);
if ((data32 & 0x7) == 0x0) {
LOGD(TAG_VPP, "state: st_idle\n");
}
else if ((data32 & 0x7) == 0x1) {
delay_us(100);
LOGD(TAG_VPP, "state: st_rst_all, goto st_clk_mux\n");
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) & 0xffffffdf);
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) | 0x20);
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) & 0xffffffdf);
}
else if ((data32 & 0x7) == 0x2) {
LOGD(TAG_VPP, "state: st_mux_clk\n");
data32 = Rd(SRCIF_WRAP_STATUS);
while ((data32 & 0x400) != 0x400) {
delay_us(1);
data32 = Rd(SRCIF_WRAP_STATUS);
}
if ((data32 & 0x0800) == 0x0800) {
LOGD(TAG_VPP, "state: st_mux_clk, stbl , goto st_hdmi\n");
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) & 0xffffff7f);
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) | 0x80);
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) & 0xffffff7f);
}
else {
LOGD(TAG_VPP, "state: st_clk_mux, un stbl , goto st_ptn\n");
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) & 0xffffffbf);
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) | 0x40);
Wr(SRCIF_WRAP_CTRL1,Rd(SRCIF_WRAP_CTRL1) & 0xffffffbf);
}
}
else if ((data32 & 0x7) == 0x3) {
LOGD(TAG_VPP, "state: st_hdmi\n");
}
else if ((data32 & 0x7) == 0x4) {
LOGD(TAG_VPP, "state: st_ptn\n");
}
}
void srcif_fsm_fc_stbl()
{
Wr(SRCIF_WRAP_CTRL , (Rd(SRCIF_WRAP_CTRL) | 0xc00000));
}
void srcif_fsm_stbl_from_hdmi()
{
Wr(SRCIF_WRAP_CTRL , (Rd(SRCIF_WRAP_CTRL) && 0xff3fffff));
}
void srcif_fsm_fc_unstbl()
{
Wr(SRCIF_WRAP_CTRL , ((Rd(SRCIF_WRAP_CTRL) & 0xff3fffff)| 0x80800000));
}
