Merge commit 'main-jb-2012.08.03-B4' into t114-0806
[linux-2.6.git] / arch / arm / mach-tegra / tegra3_usb_phy.c
index 874bb13..e609720 100644 (file)
@@ -29,6 +29,7 @@
 #include <mach/clk.h>
 #include <mach/iomap.h>
 #include <mach/pinmux.h>
+#include <mach/pinmux-tegra30.h>
 #include "tegra_usb_phy.h"
 #include "gpio-names.h"
 #include "fuse.h"
 #define PHY_DBG(stuff...)      do {} while (0)
 #endif
 
+/* define HSIC phy params */
+#define HSIC_SYNC_START_DELAY          9
+#define HSIC_IDLE_WAIT_DELAY           17
+#define HSIC_ELASTIC_UNDERRUN_LIMIT    16
+#define HSIC_ELASTIC_OVERRUN_LIMIT     16
 
 static u32 utmip_rctrl_val, utmip_tctrl_val;
 static DEFINE_SPINLOCK(utmip_pad_lock);
@@ -742,13 +748,14 @@ static void utmip_phy_disable_pmc_bus_ctrl(struct tegra_usb_phy *phy)
 
        val = readl(pmc_base + PMC_TRIGGERS);
        val |= UTMIP_CLR_WALK_PTR(inst);
+       val |= UTMIP_CLR_WAKE_ALARM(inst);
        writel(val, pmc_base + PMC_TRIGGERS);
 
        phy->remote_wakeup = false;
        PHY_DBG("%s DISABLE_PMC inst = %d\n", __func__, inst);
 }
 
-bool utmi_phy_remotewake_detected(struct tegra_usb_phy *phy)
+static bool utmi_phy_remotewake_detected(struct tegra_usb_phy *phy)
 {
        void __iomem *pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
        void __iomem *base = phy->regs;
@@ -988,7 +995,8 @@ static int usb_phy_bringup_host_controller(struct tegra_usb_phy *phy)
                /* Program the field PTC based on the saved speed mode */
                val = readl(base + USB_PORTSC);
                val &= ~USB_PORTSC_PTC(~0);
-               if (phy->port_speed == USB_PHY_PORT_SPEED_HIGH)
+               if ((phy->port_speed == USB_PHY_PORT_SPEED_HIGH) ||
+                       (phy->pdata->phy_intf == TEGRA_USB_PHY_INTF_HSIC))
                        val |= USB_PORTSC_PTC(5);
                else if (phy->port_speed == USB_PHY_PORT_SPEED_FULL)
                        val |= USB_PORTSC_PTC(6);
@@ -1222,11 +1230,13 @@ static int utmi_phy_irq(struct tegra_usb_phy *phy)
        void __iomem *base = phy->regs;
        unsigned long val = 0;
 
-       DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
-       DBG("USB_USBSTS[0x%x] USB_PORTSC[0x%x]\n",
+       if (phy->phy_clk_on) {
+               DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
+               DBG("USB_USBSTS[0x%x] USB_PORTSC[0x%x]\n",
                        readl(base + USB_USBSTS), readl(base + USB_PORTSC));
-       DBG("USB_USBMODE[0x%x] USB_USBCMD[0x%x]\n",
+               DBG("USB_USBMODE[0x%x] USB_USBCMD[0x%x]\n",
                        readl(base + USB_USBMODE), readl(base + USB_USBCMD));
+       }
 
        usb_phy_fence_read(phy);
        /* check if there is any remote wake event */
@@ -1246,6 +1256,8 @@ static int utmi_phy_irq(struct tegra_usb_phy *phy)
                        val = readl(base + USB_PORTSC);
                        val &= ~(USB_PORTSC_WKCN | USB_PORTSC_RWC_BITS);
                        writel(val , (base + USB_PORTSC));
+               } else if (!phy->phy_clk_on) {
+                       return IRQ_NONE;
                }
        }
 
@@ -1357,6 +1369,17 @@ static int utmi_phy_post_resume(struct tegra_usb_phy *phy)
        return 0;
 }
 
+static int phy_post_suspend(struct tegra_usb_phy *phy)
+{
+
+       DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
+       /* Need a 4ms delay for controller to suspend */
+       mdelay(4);
+
+       return 0;
+
+}
+
 static int utmi_phy_pre_resume(struct tegra_usb_phy *phy, bool remote_wakeup)
 {
        unsigned long val;
@@ -1744,7 +1767,7 @@ static int utmi_phy_resume(struct tegra_usb_phy *phy)
        return status;
 }
 
-bool utmi_phy_charger_detect(struct tegra_usb_phy *phy)
+static bool utmi_phy_charger_detect(struct tegra_usb_phy *phy)
 {
        unsigned long val;
        void __iomem *base = phy->regs;
@@ -1805,6 +1828,31 @@ static void uhsic_powerup_pmc_wake_detect(struct tegra_usb_phy *phy)
        mdelay(1);
 }
 
+static void uhsic_powerdown_pmc_wake_detect(struct tegra_usb_phy *phy)
+{
+       unsigned long val;
+       void __iomem *pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
+
+       DBG("%s:%d\n", __func__, __LINE__);
+
+       /* turn off pad detectors for HSIC*/
+       val = readl(pmc_base + PMC_USB_AO);
+       val |= (HSIC_RESERVED_P0 | STROBE_VAL_PD_P0 | DATA_VAL_PD_P0);
+       writel(val, pmc_base + PMC_USB_AO);
+
+       /* enable pull downs on HSIC PMC */
+       val = UHSIC_STROBE_RPD_A | UHSIC_DATA_RPD_A | UHSIC_STROBE_RPD_B |
+               UHSIC_DATA_RPD_B | UHSIC_STROBE_RPD_C | UHSIC_DATA_RPD_C |
+               UHSIC_STROBE_RPD_D | UHSIC_DATA_RPD_D;
+       writel(val, pmc_base + PMC_SLEEPWALK_UHSIC);
+
+       /* Turn over pad configuration to PMC */
+       val = readl(pmc_base + PMC_SLEEP_CFG);
+       val &= ~UHSIC_WAKE_VAL_P0(~0);
+       val |= UHSIC_WAKE_VAL_P0(WAKE_VAL_NONE) | UHSIC_MASTER_ENABLE_P0;
+       writel(val, pmc_base + PMC_SLEEP_CFG);
+}
+
 static void uhsic_setup_pmc_wake_detect(struct tegra_usb_phy *phy)
 {
        unsigned long val;
@@ -1839,6 +1887,30 @@ static void uhsic_setup_pmc_wake_detect(struct tegra_usb_phy *phy)
        val |= UHSIC_PWR;
        writel(val, pmc_base + PMC_UTMIP_MASTER_CONFIG);
 
+       /* Make sure nothing is happening on the line with respect to PMC */
+       val = readl(pmc_base + PMC_UTMIP_UHSIC_FAKE);
+       val &= ~UHSIC_STROBE_VAL;
+       val &= ~UHSIC_DATA_VAL;
+       writel(val, pmc_base + PMC_UTMIP_UHSIC_FAKE);
+
+       /* Clear walk enable */
+       val = readl(pmc_base + PMC_SLEEPWALK_CFG);
+       val &= ~UHSIC_LINEVAL_WALK_EN;
+       writel(val, pmc_base + PMC_SLEEPWALK_CFG);
+
+       /* Make sure wake value for line is none */
+       val = readl(pmc_base + PMC_SLEEP_CFG);
+       val &= ~UHSIC_WAKE_VAL(WAKE_VAL_ANY);
+       val |= UHSIC_WAKE_VAL(WAKE_VAL_NONE);
+       writel(val, pmc_base + PMC_SLEEP_CFG);
+
+       /* turn on pad detectors */
+       val = readl(pmc_base + PMC_USB_AO);
+       val &= ~(STROBE_VAL_PD_P0 | DATA_VAL_PD_P0);
+       writel(val, pmc_base + PMC_USB_AO);
+
+       /* Add small delay before usb detectors provide stable line values */
+       udelay(1);
 
        /* Enable which type of event can trigger a walk,
        * in this case usb_line_wake */
@@ -1855,19 +1927,16 @@ static void uhsic_setup_pmc_wake_detect(struct tegra_usb_phy *phy)
        val |=  UHSIC_DATA_RPD_A;
        val &= ~UHSIC_STROBE_RPD_A;
        val |=  UHSIC_STROBE_RPU_A;
-       writel(val, pmc_base + PMC_SLEEPWALK_UHSIC);
 
        val &= ~UHSIC_DATA_RPD_B;
        val |=  UHSIC_DATA_RPU_B;
        val &= ~UHSIC_STROBE_RPU_B;
        val |=  UHSIC_STROBE_RPD_B;
-       writel(val, pmc_base + PMC_SLEEPWALK_UHSIC);
 
        val &= ~UHSIC_DATA_RPD_C;
        val |=  UHSIC_DATA_RPU_C;
        val &= ~UHSIC_STROBE_RPU_C;
        val |=  UHSIC_STROBE_RPD_C;
-       writel(val, pmc_base + PMC_SLEEPWALK_UHSIC);
 
        val &= ~UHSIC_DATA_RPD_D;
        val |=  UHSIC_DATA_RPU_D;
@@ -1875,19 +1944,21 @@ static void uhsic_setup_pmc_wake_detect(struct tegra_usb_phy *phy)
        val |=  UHSIC_STROBE_RPD_D;
        writel(val, pmc_base + PMC_SLEEPWALK_UHSIC);
 
-       /* turn on pad detectors */
-       val = readl(pmc_base + PMC_USB_AO);
-       val &= ~(STROBE_VAL_PD_P0 | DATA_VAL_PD_P0);
-       writel(val, pmc_base + PMC_USB_AO);
-       /* Add small delay before usb detectors provide stable line values */
-       udelay(1);
-
        phy->remote_wakeup = false;
 
-       /* Turn over pad configuration to PMC  for line wake events*/
+       /* Setting Wake event*/
        val = readl(pmc_base + PMC_SLEEP_CFG);
-       val &= ~UHSIC_WAKE_VAL(~0);
+       val &= ~UHSIC_WAKE_VAL(WAKE_VAL_ANY);
        val |= UHSIC_WAKE_VAL(WAKE_VAL_SD10);
+       writel(val, pmc_base + PMC_SLEEP_CFG);
+
+       /* Clear the walk pointers and wake alarm */
+       val = readl(pmc_base + PMC_TRIGGERS);
+       val |= UHSIC_CLR_WAKE_ALARM_P0 | UHSIC_CLR_WALK_PTR_P0;
+       writel(val, pmc_base + PMC_TRIGGERS);
+
+       /* Turn over pad configuration to PMC  for line wake events*/
+       val = readl(pmc_base + PMC_SLEEP_CFG);
        val |= UHSIC_MASTER_ENABLE;
        writel(val, pmc_base + PMC_SLEEP_CFG);
 
@@ -1906,14 +1977,10 @@ static void uhsic_phy_disable_pmc_bus_ctrl(struct tegra_usb_phy *phy)
 
        DBG("%s (%d)\n", __func__, __LINE__);
        val = readl(pmc_base + PMC_SLEEP_CFG);
-       val &= ~UHSIC_WAKE_VAL(0x0);
+       val &= ~UHSIC_WAKE_VAL(WAKE_VAL_ANY);
        val |= UHSIC_WAKE_VAL(WAKE_VAL_NONE);
        writel(val, pmc_base + PMC_SLEEP_CFG);
 
-       val = readl(pmc_base + PMC_TRIGGERS);
-       val |= UHSIC_CLR_WAKE_ALARM_P0 | UHSIC_CLR_WALK_PTR_P0;
-       writel(val, pmc_base + PMC_TRIGGERS);
-
        val = readl(base + UHSIC_PMC_WAKEUP0);
        val &= ~EVENT_INT_ENB;
        writel(val, base + UHSIC_PMC_WAKEUP0);
@@ -1928,6 +1995,10 @@ static void uhsic_phy_disable_pmc_bus_ctrl(struct tegra_usb_phy *phy)
        val |= (STROBE_VAL_PD_P0 | DATA_VAL_PD_P0);
        writel(val, pmc_base + PMC_USB_AO);
 
+       val = readl(pmc_base + PMC_TRIGGERS);
+       val |= (UHSIC_CLR_WALK_PTR_P0 | UHSIC_CLR_WAKE_ALARM_P0);
+       writel(val, pmc_base + PMC_TRIGGERS);
+
        phy->remote_wakeup = false;
 }
 
@@ -1942,12 +2013,12 @@ static bool uhsic_phy_remotewake_detected(struct tegra_usb_phy *phy)
                val = readl(pmc_base + UTMIP_UHSIC_STATUS);
                if (UHSIC_WAKE_ALARM & val) {
                        val = readl(pmc_base + PMC_SLEEP_CFG);
-                       val &= ~UHSIC_WAKE_VAL(0x0);
+                       val &= ~UHSIC_WAKE_VAL(WAKE_VAL_ANY);
                        val |= UHSIC_WAKE_VAL(WAKE_VAL_NONE);
                        writel(val, pmc_base + PMC_SLEEP_CFG);
 
                        val = readl(pmc_base + PMC_TRIGGERS);
-                       val |= UHSIC_CLR_WAKE_ALARM_P0 | UHSIC_CLR_WALK_PTR_P0;
+                       val |= UHSIC_CLR_WAKE_ALARM_P0;
                        writel(val, pmc_base + PMC_TRIGGERS);
 
                        val = readl(base + UHSIC_PMC_WAKEUP0);
@@ -1997,6 +2068,7 @@ static void uhsic_phy_restore_start(struct tegra_usb_phy *phy)
        /* check whether we wake up from the remote resume */
        if (UHSIC_WALK_PTR_VAL & val) {
                phy->remote_wakeup = true;
+               pr_info("%s: uhsic remote wakeup detected\n", __func__);
        } else {
                if (!((UHSIC_STROBE_VAL_P0 | UHSIC_DATA_VAL_P0) & val)) {
                                uhsic_phy_disable_pmc_bus_ctrl(phy);
@@ -2014,7 +2086,7 @@ static void uhsic_phy_restore_end(struct tegra_usb_phy *phy)
 
        unsigned long val;
        void __iomem *base = phy->regs;
-       int wait_time_us = 3000; /* FPR should be set by this time */
+       int wait_time_us = 25000; /* FPR should be set by this time */
 
        DBG("%s(%d)\n", __func__, __LINE__);
 
@@ -2030,7 +2102,8 @@ static void uhsic_phy_restore_end(struct tegra_usb_phy *phy)
                                return;
                        }
                        wait_time_us--;
-               } while (!(val & USB_PORTSC_RESUME));
+               } while (val & (USB_PORTSC_RESUME | USB_PORTSC_SUSP));
+
                /* wait for 25 ms to port resume complete */
                msleep(25);
                /* disable PMC master control */
@@ -2060,10 +2133,58 @@ static void uhsic_phy_restore_end(struct tegra_usb_phy *phy)
        }
 }
 
+static int hsic_rail_enable(struct tegra_usb_phy *phy)
+{
+       int ret;
+
+       if (phy->hsic_reg == NULL) {
+               phy->hsic_reg = regulator_get(NULL, "avdd_hsic");
+               if (IS_ERR_OR_NULL(phy->hsic_reg)) {
+                       pr_err("HSIC: Could not get regulator avdd_hsic\n");
+                       phy->hsic_reg = NULL;
+                       return PTR_ERR(phy->hsic_reg);
+               }
+       }
+
+       ret = regulator_enable(phy->hsic_reg);
+       if (ret < 0) {
+               pr_err("%s avdd_hsic could not be enabled\n", __func__);
+               return ret;
+       }
+
+       return 0;
+}
+
+static int hsic_rail_disable(struct tegra_usb_phy *phy)
+{
+       int ret;
+
+       if (phy->hsic_reg == NULL) {
+               pr_warn("%s: unbalanced disable\n", __func__);
+               return -EIO;
+       }
+
+       ret = regulator_disable(phy->hsic_reg);
+       if (ret < 0) {
+               pr_err("HSIC regulator avdd_hsic cannot be disabled\n");
+               return ret;
+       }
+
+       return 0;
+}
+
 static int uhsic_phy_open(struct tegra_usb_phy *phy)
 {
        unsigned long parent_rate;
        int i;
+       int ret;
+
+       phy->hsic_reg = NULL;
+       ret = hsic_rail_enable(phy);
+       if (ret < 0) {
+               pr_err("%s avdd_hsic could not be enabled\n", __func__);
+               return ret;
+       }
 
        DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
        parent_rate = clk_get_rate(clk_get_parent(phy->pllu_clk));
@@ -2083,6 +2204,18 @@ static int uhsic_phy_open(struct tegra_usb_phy *phy)
        return 0;
 }
 
+static void uhsic_phy_close(struct tegra_usb_phy *phy)
+{
+       int ret;
+
+       DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
+       uhsic_powerdown_pmc_wake_detect(phy);
+
+       ret = hsic_rail_disable(phy);
+       if (ret < 0)
+               pr_err("%s avdd_hsic could not be disabled\n", __func__);
+}
+
 static int uhsic_phy_irq(struct tegra_usb_phy *phy)
 {
        usb_phy_fence_read(phy);
@@ -2096,7 +2229,6 @@ static int uhsic_phy_power_on(struct tegra_usb_phy *phy)
 {
        unsigned long val;
        void __iomem *base = phy->regs;
-       struct tegra_hsic_config *config = &phy->pdata->u_cfg.hsic;
 
        DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
 
@@ -2122,13 +2254,13 @@ static int uhsic_phy_power_on(struct tegra_usb_phy *phy)
        writel(val, base + USB_SUSP_CTRL);
 
        val = readl(base + UHSIC_HSRX_CFG0);
-       val |= UHSIC_IDLE_WAIT(config->idle_wait_delay);
-       val |= UHSIC_ELASTIC_UNDERRUN_LIMIT(config->elastic_underrun_limit);
-       val |= UHSIC_ELASTIC_OVERRUN_LIMIT(config->elastic_overrun_limit);
+       val |= UHSIC_IDLE_WAIT(HSIC_IDLE_WAIT_DELAY);
+       val |= UHSIC_ELASTIC_UNDERRUN_LIMIT(HSIC_ELASTIC_UNDERRUN_LIMIT);
+       val |= UHSIC_ELASTIC_OVERRUN_LIMIT(HSIC_ELASTIC_OVERRUN_LIMIT);
        writel(val, base + UHSIC_HSRX_CFG0);
 
        val = readl(base + UHSIC_HSRX_CFG1);
-       val |= UHSIC_HS_SYNC_START_DLY(config->sync_start_delay);
+       val |= UHSIC_HS_SYNC_START_DLY(HSIC_SYNC_START_DELAY);
        writel(val, base + UHSIC_HSRX_CFG1);
 
        /* WAR HSIC TX */
@@ -2198,6 +2330,15 @@ static int uhsic_phy_power_on(struct tegra_usb_phy *phy)
        phy->phy_clk_on = true;
        phy->hw_accessible = true;
 
+       if (phy->pmc_sleepwalk) {
+               DBG("%s(%d) inst:[%d] restore phy\n", __func__, __LINE__,
+                                       phy->inst);
+               uhsic_phy_restore_start(phy);
+               usb_phy_bringup_host_controller(phy);
+               uhsic_phy_restore_end(phy);
+               phy->pmc_sleepwalk = false;
+       }
+
        return 0;
 }
 
@@ -2219,19 +2360,27 @@ static int uhsic_phy_power_off(struct tegra_usb_phy *phy)
        /* Disable interrupts */
        writel(0, base + USB_USBINTR);
 
-       uhsic_setup_pmc_wake_detect(phy);
+       if (phy->pmc_sleepwalk == false) {
+               uhsic_setup_pmc_wake_detect(phy);
+               phy->pmc_sleepwalk = true;
+       }
 
        val = readl(base + HOSTPC1_DEVLC);
        val |= HOSTPC1_DEVLC_PHCD;
        writel(val, base + HOSTPC1_DEVLC);
 
+       /* Remove power downs for HSIC from PADS CFG1 register */
+       val = readl(base + UHSIC_PADS_CFG1);
+       val |= (UHSIC_PD_BG |UHSIC_PD_TRK | UHSIC_PD_RX |
+                       UHSIC_PD_ZI | UHSIC_PD_TX);
+       writel(val, base + UHSIC_PADS_CFG1);
        phy->phy_clk_on = false;
        phy->hw_accessible = false;
 
        return 0;
 }
 
-int uhsic_phy_bus_port_power(struct tegra_usb_phy *phy)
+static int uhsic_phy_bus_port_power(struct tegra_usb_phy *phy)
 {
        unsigned long val;
        void __iomem *base = phy->regs;
@@ -2368,10 +2517,6 @@ int uhsic_phy_resume(struct tegra_usb_phy *phy)
 {
        DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
 
-       uhsic_phy_restore_start(phy);
-       usb_phy_bringup_host_controller(phy);
-       uhsic_phy_restore_end(phy);
-
        return 0;
 }
 
@@ -2558,7 +2703,16 @@ static int ulpi_null_phy_init(struct tegra_usb_phy *phy)
 
 static int ulpi_null_phy_irq(struct tegra_usb_phy *phy)
 {
+       unsigned long val;
+       void __iomem *base = phy->regs;
+
        usb_phy_fence_read(phy);
+       if (phy->bus_reseting){
+               val = readl(base + USB_USBCMD);
+               val |= USB_USBCMD_RS;
+               writel(val, base + USB_USBCMD);
+               phy->bus_reseting = false;
+       }
        return IRQ_HANDLED;
 }
 
@@ -2584,6 +2738,23 @@ static int ulpi_null_phy_cmd_reset(struct tegra_usb_phy *phy)
        return 0;
 }
 
+static int ulpi_phy_bus_reset(struct tegra_usb_phy *phy)
+{
+       unsigned long val;
+       void __iomem *base = phy->regs;
+
+       DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
+
+       /*DISABLE RUN BIT */
+
+       val = readl(base + USB_USBCMD);
+       val &= ~USB_USBCMD_RS;
+       writel(val, base + USB_USBCMD);
+       phy->bus_reseting = true;
+
+       return 0;
+}
+
 static int ulpi_null_phy_restore(struct tegra_usb_phy *phy)
 {
        struct tegra_ulpi_config *config = &phy->pdata->u_cfg.ulpi;
@@ -2756,14 +2927,14 @@ static int ulpi_null_phy_power_on(struct tegra_usb_phy *phy)
        }
        udelay(10);
 
+       phy->bus_reseting = false;
        phy->phy_clk_on = true;
        phy->hw_accessible = true;
 
        return 0;
 }
 
-static int ulpi_null_phy_pre_resume(struct tegra_usb_phy *phy,
-                                   bool remote_wakeup)
+static int ulpi_null_phy_pre_resume(struct tegra_usb_phy *phy, bool remote_wakeup)
 {
        DBG("%s(%d) inst:[%d]\n", __func__, __LINE__, phy->inst);
        ulpi_null_phy_obs_read();
@@ -2814,10 +2985,12 @@ static struct tegra_usb_phy_ops utmi_phy_ops = {
        .resume = utmi_phy_resume,
        .post_resume    = utmi_phy_post_resume,
        .charger_detect = utmi_phy_charger_detect,
+       .post_suspend   = phy_post_suspend,
 };
 
 static struct tegra_usb_phy_ops uhsic_phy_ops = {
        .open           = uhsic_phy_open,
+       .close          = uhsic_phy_close,
        .irq            = uhsic_phy_irq,
        .power_on       = uhsic_phy_power_on,
        .power_off      = uhsic_phy_power_off,
@@ -2826,6 +2999,7 @@ static struct tegra_usb_phy_ops uhsic_phy_ops = {
        .post_resume = uhsic_phy_post_resume,
        .port_power = uhsic_phy_bus_port_power,
        .bus_reset      = uhsic_phy_bus_reset,
+       .post_suspend   = phy_post_suspend,
 };
 
 static struct tegra_usb_phy_ops ulpi_null_phy_ops = {
@@ -2839,6 +3013,8 @@ static struct tegra_usb_phy_ops ulpi_null_phy_ops = {
        .resume = ulpi_null_phy_resume,
        .post_resume = ulpi_null_phy_post_resume,
        .reset          = ulpi_null_phy_cmd_reset,
+       .post_suspend   = phy_post_suspend,
+       .bus_reset      = ulpi_phy_bus_reset,
 };
 
 static struct tegra_usb_phy_ops ulpi_link_phy_ops;