void tegra_dc_sor_read_link_config(struct udevice *dev, u8 *link_bw, u8 *lane_count) { struct tegra_dc_sor_data *sor = dev_get_priv(dev); u32 reg_val; reg_val = tegra_sor_readl(sor, CLK_CNTRL); *link_bw = (reg_val & CLK_CNTRL_DP_LINK_SPEED_MASK) >> CLK_CNTRL_DP_LINK_SPEED_SHIFT; reg_val = tegra_sor_readl(sor, DP_LINKCTL(sor->portnum)); switch (reg_val & DP_LINKCTL_LANECOUNT_MASK) { case DP_LINKCTL_LANECOUNT_ZERO: *lane_count = 0; break; case DP_LINKCTL_LANECOUNT_ONE: *lane_count = 1; break; case DP_LINKCTL_LANECOUNT_TWO: *lane_count = 2; break; case DP_LINKCTL_LANECOUNT_FOUR: *lane_count = 4; break; default: printf("Unknown lane count\n"); } }
void tegra_dc_sor_read_link_config(struct tegra_dc_sor_data *sor, u8 *link_bw, u8 *lane_count) { u32 reg_val; reg_val = tegra_sor_readl(sor, NV_SOR_CLK_CNTRL); *link_bw = (reg_val & NV_SOR_CLK_CNTRL_DP_LINK_SPEED_MASK) >> NV_SOR_CLK_CNTRL_DP_LINK_SPEED_SHIFT; reg_val = tegra_sor_readl(sor, NV_SOR_DP_LINKCTL(sor->portnum)); switch (reg_val & NV_SOR_DP_LINKCTL_LANECOUNT_MASK) { case NV_SOR_DP_LINKCTL_LANECOUNT_ZERO: *lane_count = 0; break; case NV_SOR_DP_LINKCTL_LANECOUNT_ONE: *lane_count = 1; break; case NV_SOR_DP_LINKCTL_LANECOUNT_TWO: *lane_count = 2; break; case NV_SOR_DP_LINKCTL_LANECOUNT_FOUR: *lane_count = 4; break; default: printk(BIOS_ERR, "Unknown lane count\n"); } }
void tegra_dc_sor_set_dp_lanedata(struct tegra_dc_sor_data *sor, u32 lane, u32 pre_emphasis, u32 drive_current, u32 tx_pu) { u32 d_cur; u32 p_emp; d_cur = tegra_sor_readl(sor, NV_SOR_DC(sor->portnum)); p_emp = tegra_sor_readl(sor, NV_SOR_PR(sor->portnum)); switch (lane) { case 0: p_emp &= ~NV_SOR_PR_LANE2_DP_LANE0_MASK; p_emp |= (pre_emphasis << NV_SOR_PR_LANE2_DP_LANE0_SHIFT); d_cur &= ~NV_SOR_DC_LANE2_DP_LANE0_MASK; d_cur |= (drive_current << NV_SOR_DC_LANE2_DP_LANE0_SHIFT); break; case 1: p_emp &= ~NV_SOR_PR_LANE1_DP_LANE1_MASK; p_emp |= (pre_emphasis << NV_SOR_PR_LANE1_DP_LANE1_SHIFT); d_cur &= ~NV_SOR_DC_LANE1_DP_LANE1_MASK; d_cur |= (drive_current << NV_SOR_DC_LANE1_DP_LANE1_SHIFT); break; case 2: p_emp &= ~NV_SOR_PR_LANE0_DP_LANE2_MASK; p_emp |= (pre_emphasis << NV_SOR_PR_LANE0_DP_LANE2_SHIFT); d_cur &= ~NV_SOR_DC_LANE0_DP_LANE2_MASK; d_cur |= (drive_current << NV_SOR_DC_LANE0_DP_LANE2_SHIFT); break; case 3: p_emp &= ~NV_SOR_PR_LANE3_DP_LANE3_MASK; p_emp |= (pre_emphasis << NV_SOR_PR_LANE3_DP_LANE3_SHIFT); d_cur &= ~NV_SOR_DC_LANE3_DP_LANE3_MASK; d_cur |= (drive_current << NV_SOR_DC_LANE3_DP_LANE3_SHIFT); break; default: printk(BIOS_SPEW, "dp: sor lane count %d is invalid\n", lane); } tegra_sor_write_field(sor, NV_SOR_DP_LINKCTL(sor->portnum), NV_SOR_DP_PADCTL_TX_PU_VALUE_DEFAULT_MASK, tx_pu << NV_SOR_DP_PADCTL_TX_PU_VALUE_SHIFT); tegra_sor_writel(sor, NV_SOR_DC(sor->portnum), d_cur); tegra_sor_writel(sor, NV_SOR_PR(sor->portnum), p_emp); }
void tegra_dc_sor_set_lane_count(struct udevice *dev, u8 lane_count) { struct tegra_dc_sor_data *sor = dev_get_priv(dev); u32 reg_val; reg_val = tegra_sor_readl(sor, DP_LINKCTL(sor->portnum)); reg_val &= ~DP_LINKCTL_LANECOUNT_MASK; switch (lane_count) { case 0: break; case 1: reg_val |= DP_LINKCTL_LANECOUNT_ONE; break; case 2: reg_val |= DP_LINKCTL_LANECOUNT_TWO; break; case 4: reg_val |= DP_LINKCTL_LANECOUNT_FOUR; break; default: /* 0 should be handled earlier. */ printf("dp: Invalid lane count %d\n", lane_count); return; } tegra_sor_writel(sor, DP_LINKCTL(sor->portnum), reg_val); }
int tegra_dc_sor_set_power_state(struct tegra_dc_sor_data *sor, int pu_pd) { u32 reg_val; u32 orig_val; orig_val = tegra_sor_readl(sor, NV_SOR_PWR); reg_val = pu_pd ? NV_SOR_PWR_NORMAL_STATE_PU : NV_SOR_PWR_NORMAL_STATE_PD; /* normal state only */ if (reg_val == orig_val) return 0; /* No update needed */ reg_val |= NV_SOR_PWR_SETTING_NEW_TRIGGER; tegra_sor_writel(sor, NV_SOR_PWR, reg_val); /* Poll to confirm it is done */ if (tegra_dc_sor_poll_register(sor, NV_SOR_PWR, NV_SOR_PWR_SETTING_NEW_DEFAULT_MASK, NV_SOR_PWR_SETTING_NEW_DONE, 100, TEGRA_SOR_TIMEOUT_MS * 1000)) { printk(BIOS_ERR, "dc timeout waiting for SOR_PWR = NEW_DONE\n"); return -EFAULT; } return 0; }
void tegra_dc_sor_set_dp_linkctl(struct tegra_dc_sor_data *sor, int ena, u8 training_pattern, const struct tegra_dc_dp_link_config *cfg) { u32 reg_val; reg_val = tegra_sor_readl(sor, NV_SOR_DP_LINKCTL(sor->portnum)); if (ena) reg_val |= NV_SOR_DP_LINKCTL_ENABLE_YES; else reg_val &= NV_SOR_DP_LINKCTL_ENABLE_NO; reg_val &= ~NV_SOR_DP_LINKCTL_TUSIZE_MASK; reg_val |= (cfg->tu_size << NV_SOR_DP_LINKCTL_TUSIZE_SHIFT); if (cfg->enhanced_framing) reg_val |= NV_SOR_DP_LINKCTL_ENHANCEDFRAME_ENABLE; tegra_sor_writel(sor, NV_SOR_DP_LINKCTL(sor->portnum), reg_val); switch (training_pattern) { case trainingPattern_1: tegra_sor_writel(sor, NV_SOR_DP_TPG, 0x41414141); break; case trainingPattern_2: case trainingPattern_3: reg_val = (cfg->link_bw == NV_SOR_LINK_SPEED_G5_4) ? 0x43434343 : 0x42424242; tegra_sor_writel(sor, NV_SOR_DP_TPG, reg_val); break; default: tegra_sor_writel(sor, NV_SOR_DP_TPG, 0x50505050); break; } }
void tegra_dc_sor_attach(struct tegra_dc_sor_data *sor) { u32 reg_val; struct display_controller *disp_ctrl = (void *)sor->dc->base; tegra_dc_sor_enable_dc(sor); tegra_dc_sor_config_panel(sor, 0); WRITEL(0x9f00, &disp_ctrl->cmd.state_ctrl); WRITEL(0x9f, &disp_ctrl->cmd.state_ctrl); WRITEL(PW0_ENABLE | PW1_ENABLE | PW2_ENABLE | PW3_ENABLE | PW4_ENABLE | PM0_ENABLE | PM1_ENABLE, &disp_ctrl->cmd.disp_pow_ctrl); reg_val = tegra_sor_readl(sor, NV_SOR_TEST); if (reg_val & NV_SOR_TEST_ATTACHED_TRUE) return; tegra_sor_writel(sor, NV_SOR_SUPER_STATE1, NV_SOR_SUPER_STATE1_ATTACHED_NO); /* * Enable display2sor clock at least 2 cycles before DC start, * to clear sor internal valid signal. */ WRITEL(SOR_ENABLE, &disp_ctrl->disp.disp_win_opt); WRITEL(GENERAL_ACT_REQ, &disp_ctrl->cmd.state_ctrl); WRITEL(0, &disp_ctrl->disp.disp_win_opt); WRITEL(GENERAL_ACT_REQ, &disp_ctrl->cmd.state_ctrl); /* Attach head */ tegra_dc_sor_update(sor); tegra_sor_writel(sor, NV_SOR_SUPER_STATE1, NV_SOR_SUPER_STATE1_ATTACHED_YES); tegra_sor_writel(sor, NV_SOR_SUPER_STATE1, NV_SOR_SUPER_STATE1_ATTACHED_YES | NV_SOR_SUPER_STATE1_ASY_HEAD_OP_AWAKE | NV_SOR_SUPER_STATE1_ASY_ORMODE_NORMAL); tegra_dc_sor_super_update(sor); /* Enable dc */ reg_val = READL(&disp_ctrl->cmd.state_access); WRITEL(reg_val | WRITE_MUX_ACTIVE, &disp_ctrl->cmd.state_access); WRITEL(DISP_CTRL_MODE_C_DISPLAY, &disp_ctrl->cmd.disp_cmd); WRITEL(SOR_ENABLE, &disp_ctrl->disp.disp_win_opt); WRITEL(reg_val, &disp_ctrl->cmd.state_access); if (tegra_dc_sor_poll_register(sor, NV_SOR_TEST, NV_SOR_TEST_ACT_HEAD_OPMODE_DEFAULT_MASK, NV_SOR_TEST_ACT_HEAD_OPMODE_AWAKE, 100, TEGRA_SOR_ATTACH_TIMEOUT_MS * 1000)) printk(BIOS_ERR, "dc timeout waiting for OPMOD = AWAKE\n"); else printk(BIOS_INFO, "%s: sor is attached\n", __func__); #if DEBUG_SOR dump_sor_reg(sor); #endif }
int tegra_dc_sor_set_power_state(struct udevice *dev, int pu_pd) { struct tegra_dc_sor_data *sor = dev_get_priv(dev); u32 reg_val; u32 orig_val; orig_val = tegra_sor_readl(sor, PWR); reg_val = pu_pd ? PWR_NORMAL_STATE_PU : PWR_NORMAL_STATE_PD; /* normal state only */ if (reg_val == orig_val) return 0; /* No update needed */ reg_val |= PWR_SETTING_NEW_TRIGGER; tegra_sor_writel(sor, PWR, reg_val); /* Poll to confirm it is done */ if (tegra_dc_sor_poll_register(sor, PWR, PWR_SETTING_NEW_DEFAULT_MASK, PWR_SETTING_NEW_DONE, 100, TEGRA_SOR_TIMEOUT_MS)) { debug("dc timeout waiting for SOR_PWR = NEW_DONE\n"); return -EFAULT; } return 0; }
static void tegra_dc_sor_set_dp_mode(struct tegra_dc_sor_data *sor, const struct tegra_dc_dp_link_config *link_cfg) { u32 reg_val; tegra_dc_sor_set_link_bandwidth(sor, link_cfg->link_bw); tegra_dc_sor_set_dp_linkctl(sor, 1, training_pattern_none, link_cfg); reg_val = tegra_sor_readl(sor, NV_SOR_DP_CONFIG(sor->portnum)); reg_val &= ~NV_SOR_DP_CONFIG_WATERMARK_MASK; reg_val |= link_cfg->watermark; reg_val &= ~NV_SOR_DP_CONFIG_ACTIVESYM_COUNT_MASK; reg_val |= (link_cfg->active_count << NV_SOR_DP_CONFIG_ACTIVESYM_COUNT_SHIFT); reg_val &= ~NV_SOR_DP_CONFIG_ACTIVESYM_FRAC_MASK; reg_val |= (link_cfg->active_frac << NV_SOR_DP_CONFIG_ACTIVESYM_FRAC_SHIFT); if (link_cfg->activepolarity) reg_val |= NV_SOR_DP_CONFIG_ACTIVESYM_POLARITY_POSITIVE; else reg_val &= ~NV_SOR_DP_CONFIG_ACTIVESYM_POLARITY_POSITIVE; reg_val |= (NV_SOR_DP_CONFIG_ACTIVESYM_CNTL_ENABLE | NV_SOR_DP_CONFIG_RD_RESET_VAL_NEGATIVE); tegra_sor_writel(sor, NV_SOR_DP_CONFIG(sor->portnum), reg_val); /* program h/vblank sym */ tegra_sor_write_field(sor, NV_SOR_DP_AUDIO_HBLANK_SYMBOLS, NV_SOR_DP_AUDIO_HBLANK_SYMBOLS_MASK, link_cfg->hblank_sym); tegra_sor_write_field(sor, NV_SOR_DP_AUDIO_VBLANK_SYMBOLS, NV_SOR_DP_AUDIO_VBLANK_SYMBOLS_MASK, link_cfg->vblank_sym); }
void tegra_dc_sor_set_lane_count(struct tegra_dc_sor_data *sor, u8 lane_count) { u32 reg_val; reg_val = tegra_sor_readl(sor, NV_SOR_DP_LINKCTL(sor->portnum)); reg_val &= ~NV_SOR_DP_LINKCTL_LANECOUNT_MASK; switch (lane_count) { case 0: break; case 1: reg_val |= NV_SOR_DP_LINKCTL_LANECOUNT_ONE; break; case 2: reg_val |= NV_SOR_DP_LINKCTL_LANECOUNT_TWO; break; case 4: reg_val |= NV_SOR_DP_LINKCTL_LANECOUNT_FOUR; break; default: /* 0 should be handled earlier. */ printk(BIOS_ERR, "dp: Invalid lane count %d\n", lane_count); return; } tegra_sor_writel(sor, NV_SOR_DP_LINKCTL(sor->portnum), reg_val); }
static int tegra_dc_sor_power_dplanes(struct tegra_dc_sor_data *sor, u32 lane_count, int pu) { u32 reg_val; reg_val = tegra_sor_readl(sor, NV_SOR_DP_PADCTL(sor->portnum)); if (pu) { switch (lane_count) { case 4: reg_val |= (NV_SOR_DP_PADCTL_PD_TXD_3_NO | NV_SOR_DP_PADCTL_PD_TXD_2_NO); /* fall through */ case 2: reg_val |= NV_SOR_DP_PADCTL_PD_TXD_1_NO; case 1: reg_val |= NV_SOR_DP_PADCTL_PD_TXD_0_NO; break; default: printk(BIOS_ERR, "dp: invalid lane number %d\n", lane_count); return -1; } tegra_sor_writel(sor, NV_SOR_DP_PADCTL(sor->portnum), reg_val); tegra_dc_sor_set_lane_count(sor, lane_count); } return tegra_dc_sor_enable_lane_sequencer(sor, pu, 0); }
static int tegra_dc_sor_power_dplanes(struct udevice *dev, u32 lane_count, int pu) { struct tegra_dc_sor_data *sor = dev_get_priv(dev); u32 reg_val; reg_val = tegra_sor_readl(sor, DP_PADCTL(sor->portnum)); if (pu) { switch (lane_count) { case 4: reg_val |= (DP_PADCTL_PD_TXD_3_NO | DP_PADCTL_PD_TXD_2_NO); /* fall through */ case 2: reg_val |= DP_PADCTL_PD_TXD_1_NO; case 1: reg_val |= DP_PADCTL_PD_TXD_0_NO; break; default: debug("dp: invalid lane number %d\n", lane_count); return -1; } tegra_sor_writel(sor, DP_PADCTL(sor->portnum), reg_val); tegra_dc_sor_set_lane_count(dev, lane_count); } return tegra_dc_sor_enable_lane_sequencer(sor, pu, 0); }
static inline void tegra_sor_write_field(struct tegra_dc_sor_data *sor, u32 reg, u32 mask, u32 val) { u32 reg_val = tegra_sor_readl(sor, reg); reg_val &= ~mask; reg_val |= val; tegra_sor_writel(sor, reg, reg_val); }
void tegra_dc_sor_set_panel_power(struct udevice *dev, int power_up) { struct tegra_dc_sor_data *sor = dev_get_priv(dev); u32 reg_val; reg_val = tegra_sor_readl(sor, DP_PADCTL(sor->portnum)); if (power_up) reg_val |= DP_PADCTL_PAD_CAL_PD_POWERUP; else reg_val &= ~DP_PADCTL_PAD_CAL_PD_POWERUP; tegra_sor_writel(sor, DP_PADCTL(sor->portnum), reg_val); }
void tegra_dc_sor_set_internal_panel(struct tegra_dc_sor_data *sor, int is_int) { u32 reg_val; reg_val = tegra_sor_readl(sor, NV_SOR_DP_SPARE(sor->portnum)); if (is_int) reg_val |= NV_SOR_DP_SPARE_PANEL_INTERNAL; else reg_val &= ~NV_SOR_DP_SPARE_PANEL_INTERNAL; reg_val |= NV_SOR_DP_SPARE_SOR_CLK_SEL_MACRO_SORCLK | NV_SOR_DP_SPARE_SEQ_ENABLE_YES; tegra_sor_writel(sor, NV_SOR_DP_SPARE(sor->portnum), reg_val); }
void tegra_dc_sor_set_internal_panel(struct udevice *dev, int is_int) { struct tegra_dc_sor_data *sor = dev_get_priv(dev); u32 reg_val; reg_val = tegra_sor_readl(sor, DP_SPARE(sor->portnum)); if (is_int) reg_val |= DP_SPARE_PANEL_INTERNAL; else reg_val &= ~DP_SPARE_PANEL_INTERNAL; reg_val |= DP_SPARE_SOR_CLK_SEL_MACRO_SORCLK | DP_SPARE_SEQ_ENABLE_YES; tegra_sor_writel(sor, DP_SPARE(sor->portnum), reg_val); }
void tegra_dc_sor_set_panel_power(struct tegra_dc_sor_data *sor, int power_up) { u32 reg_val; /* !!TODO: need to enable panel power through GPIO operations */ /* Check bug 790854 for HW progress */ reg_val = tegra_sor_readl(sor, NV_SOR_DP_PADCTL(sor->portnum)); if (power_up) reg_val |= NV_SOR_DP_PADCTL_PAD_CAL_PD_POWERUP; else reg_val &= ~NV_SOR_DP_PADCTL_PAD_CAL_PD_POWERUP; tegra_sor_writel(sor, NV_SOR_DP_PADCTL(sor->portnum), reg_val); }
static int tegra_dc_sor_poll_register(struct tegra_dc_sor_data *sor, u32 reg, u32 mask, u32 exp_val, int poll_interval_us, int timeout_ms) { u32 reg_val = 0; ulong start; start = get_timer(0); do { reg_val = tegra_sor_readl(sor, reg); if (((reg_val & mask) == exp_val)) return 0; udelay(poll_interval_us); } while (get_timer(start) < timeout_ms); debug("sor_poll_register 0x%x: timeout, (reg_val)0x%08x & (mask)0x%08x != (exp_val)0x%08x\n", reg, reg_val, mask, exp_val); return -ETIMEDOUT; }
static u32 tegra_dc_sor_poll_register(struct tegra_dc_sor_data *sor, u32 reg, u32 mask, u32 exp_val, u32 poll_interval_us, u32 timeout_us) { u32 temp = timeout_us; u32 reg_val = 0; do { udelay(poll_interval_us); reg_val = tegra_sor_readl(sor, reg); if (timeout_us > poll_interval_us) timeout_us -= poll_interval_us; else break; } while ((reg_val & mask) != exp_val); if ((reg_val & mask) == exp_val) return 0; /* success */ printk(BIOS_ERR, "sor_poll_register 0x%x: timeout, " "(reg_val)0x%08x & (mask)0x%08x != (exp_val)0x%08x\n", reg, reg_val, mask, exp_val); return temp; }
int tegra_dc_sor_attach(struct udevice *dc_dev, struct udevice *dev, const struct tegra_dp_link_config *link_cfg, const struct display_timing *timing) { struct tegra_dc_sor_data *sor = dev_get_priv(dev); struct dc_ctlr *disp_ctrl; u32 reg_val; /* Use the first display controller */ debug("%s\n", __func__); disp_ctrl = (struct dc_ctlr *)dev_read_addr(dc_dev); tegra_dc_sor_enable_dc(disp_ctrl); tegra_dc_sor_config_panel(sor, 0, link_cfg, timing); writel(0x9f00, &disp_ctrl->cmd.state_ctrl); writel(0x9f, &disp_ctrl->cmd.state_ctrl); writel(PW0_ENABLE | PW1_ENABLE | PW2_ENABLE | PW3_ENABLE | PW4_ENABLE | PM0_ENABLE | PM1_ENABLE, &disp_ctrl->cmd.disp_pow_ctrl); reg_val = tegra_sor_readl(sor, TEST); if (reg_val & TEST_ATTACHED_TRUE) return -EEXIST; tegra_sor_writel(sor, SUPER_STATE1, SUPER_STATE1_ATTACHED_NO); /* * Enable display2sor clock at least 2 cycles before DC start, * to clear sor internal valid signal. */ writel(SOR_ENABLE, &disp_ctrl->disp.disp_win_opt); writel(GENERAL_ACT_REQ, &disp_ctrl->cmd.state_ctrl); writel(0, &disp_ctrl->disp.disp_win_opt); writel(GENERAL_ACT_REQ, &disp_ctrl->cmd.state_ctrl); /* Attach head */ tegra_dc_sor_update(sor); tegra_sor_writel(sor, SUPER_STATE1, SUPER_STATE1_ATTACHED_YES); tegra_sor_writel(sor, SUPER_STATE1, SUPER_STATE1_ATTACHED_YES | SUPER_STATE1_ASY_HEAD_OP_AWAKE | SUPER_STATE1_ASY_ORMODE_NORMAL); tegra_dc_sor_super_update(sor); /* Enable dc */ reg_val = readl(&disp_ctrl->cmd.state_access); writel(reg_val | WRITE_MUX_ACTIVE, &disp_ctrl->cmd.state_access); writel(CTRL_MODE_C_DISPLAY << CTRL_MODE_SHIFT, &disp_ctrl->cmd.disp_cmd); writel(SOR_ENABLE, &disp_ctrl->disp.disp_win_opt); writel(reg_val, &disp_ctrl->cmd.state_access); if (tegra_dc_sor_poll_register(sor, TEST, TEST_ACT_HEAD_OPMODE_DEFAULT_MASK, TEST_ACT_HEAD_OPMODE_AWAKE, 100, TEGRA_SOR_ATTACH_TIMEOUT_MS)) { printf("dc timeout waiting for OPMOD = AWAKE\n"); return -ETIMEDOUT; } else { debug("%s: sor is attached\n", __func__); } #if DEBUG_SOR dump_sor_reg(sor); #endif debug("%s: ret=%d\n", __func__, 0); return 0; }
/* * The SOR power sequencer does not work for t124 so SW has to * go through the power sequence manually * Power up steps from spec: * STEP PDPORT PDPLL PDBG PLLVCOD PLLCAPD E_DPD PDCAL * 1 1 1 1 1 1 1 1 * 2 1 1 1 1 1 0 1 * 3 1 1 0 1 1 0 1 * 4 1 0 0 0 0 0 1 * 5 0 0 0 0 0 0 1 */ static int tegra_dc_sor_power_up(struct udevice *dev, int is_lvds) { struct tegra_dc_sor_data *sor = dev_get_priv(dev); u32 reg; int ret; if (sor->power_is_up) return 0; /* * If for some reason it is already powered up, don't do it again. * This can happen if U-Boot is the secondary boot loader. */ reg = tegra_sor_readl(sor, DP_PADCTL(sor->portnum)); if (reg & DP_PADCTL_PD_TXD_0_NO) return 0; /* Set link bw */ tegra_dc_sor_set_link_bandwidth(dev, is_lvds ? CLK_CNTRL_DP_LINK_SPEED_LVDS : CLK_CNTRL_DP_LINK_SPEED_G1_62); /* step 1 */ tegra_sor_write_field(sor, PLL2, PLL2_AUX7_PORT_POWERDOWN_MASK | /* PDPORT */ PLL2_AUX6_BANDGAP_POWERDOWN_MASK | /* PDBG */ PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_MASK, /* PLLCAPD */ PLL2_AUX7_PORT_POWERDOWN_ENABLE | PLL2_AUX6_BANDGAP_POWERDOWN_ENABLE | PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_ENABLE); tegra_sor_write_field(sor, PLL0, PLL0_PWR_MASK | /* PDPLL */ PLL0_VCOPD_MASK, /* PLLVCOPD */ PLL0_PWR_OFF | PLL0_VCOPD_ASSERT); tegra_sor_write_field(sor, DP_PADCTL(sor->portnum), DP_PADCTL_PAD_CAL_PD_POWERDOWN, /* PDCAL */ DP_PADCTL_PAD_CAL_PD_POWERDOWN); /* step 2 */ ret = tegra_dc_sor_io_set_dpd(sor, 1); if (ret) return ret; udelay(15); /* step 3 */ tegra_sor_write_field(sor, PLL2, PLL2_AUX6_BANDGAP_POWERDOWN_MASK, PLL2_AUX6_BANDGAP_POWERDOWN_DISABLE); udelay(25); /* step 4 */ tegra_sor_write_field(sor, PLL0, PLL0_PWR_MASK | /* PDPLL */ PLL0_VCOPD_MASK, /* PLLVCOPD */ PLL0_PWR_ON | PLL0_VCOPD_RESCIND); /* PLLCAPD */ tegra_sor_write_field(sor, PLL2, PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_MASK, PLL2_AUX8_SEQ_PLLCAPPD_ENFORCE_DISABLE); udelay(225); /* step 5 PDPORT */ tegra_sor_write_field(sor, PLL2, PLL2_AUX7_PORT_POWERDOWN_MASK, PLL2_AUX7_PORT_POWERDOWN_DISABLE); sor->power_is_up = 1; return 0; }