static int utmip_pad_open(struct tegra_usb_phy *phy)
 {
-       phy->pad_clk = devm_clk_get(phy->dev, "utmi-pads");
+       phy->pad_clk = devm_clk_get(phy->u_phy.dev, "utmi-pads");
        if (IS_ERR(phy->pad_clk)) {
                pr_err("%s: can't get utmip pad clock\n", __func__);
                return PTR_ERR(phy->pad_clk);
 
        ret = gpio_direction_output(phy->reset_gpio, 0);
        if (ret < 0) {
-               dev_err(phy->dev, "gpio %d not set to 0\n", phy->reset_gpio);
+               dev_err(phy->u_phy.dev, "gpio %d not set to 0\n",
+                       phy->reset_gpio);
                return ret;
        }
        msleep(5);
        ret = gpio_direction_output(phy->reset_gpio, 1);
        if (ret < 0) {
-               dev_err(phy->dev, "gpio %d not set to 1\n", phy->reset_gpio);
+               dev_err(phy->u_phy.dev, "gpio %d not set to 1\n",
+                       phy->reset_gpio);
                return ret;
        }
 
 {
        int err;
 
-       phy->clk = devm_clk_get(phy->dev, "ulpi-link");
+       phy->clk = devm_clk_get(phy->u_phy.dev, "ulpi-link");
        if (IS_ERR(phy->clk)) {
                pr_err("%s: can't get ulpi clock\n", __func__);
                return PTR_ERR(phy->clk);
        }
 
-       err = devm_gpio_request(phy->dev, phy->reset_gpio, "ulpi_phy_reset_b");
+       err = devm_gpio_request(phy->u_phy.dev, phy->reset_gpio,
+               "ulpi_phy_reset_b");
        if (err < 0) {
-               dev_err(phy->dev, "request failed for gpio: %d\n",
+               dev_err(phy->u_phy.dev, "request failed for gpio: %d\n",
                       phy->reset_gpio);
                return err;
        }
 
        err = gpio_direction_output(phy->reset_gpio, 0);
        if (err < 0) {
-               dev_err(phy->dev, "gpio %d direction not set to output\n",
+               dev_err(phy->u_phy.dev, "gpio %d direction not set to output\n",
                       phy->reset_gpio);
                return err;
        }
 
        phy->ulpi = otg_ulpi_create(&ulpi_viewport_access_ops, 0);
        if (!phy->ulpi) {
-               dev_err(phy->dev, "otg_ulpi_create returned NULL\n");
+               dev_err(phy->u_phy.dev, "otg_ulpi_create returned NULL\n");
                err = -ENOMEM;
                return err;
        }
        int i;
        int err;
 
-       phy->pll_u = devm_clk_get(phy->dev, "pll_u");
+       phy->pll_u = devm_clk_get(phy->u_phy.dev, "pll_u");
        if (IS_ERR(phy->pll_u)) {
                pr_err("Can't get pll_u clock\n");
                return PTR_ERR(phy->pll_u);
        if (!IS_ERR(phy->vbus)) {
                err = regulator_enable(phy->vbus);
                if (err) {
-                       dev_err(phy->dev,
+                       dev_err(phy->u_phy.dev,
                                "failed to enable usb vbus regulator: %d\n",
                                err);
                        goto fail;
                tegra_phy->vbus = ERR_PTR(-ENODEV);
        }
 
-       tegra_phy->dev = &pdev->dev;
+       tegra_phy->u_phy.dev = &pdev->dev;
        err = tegra_usb_phy_init(tegra_phy);
        if (err < 0)
                return err;
        struct tegra_usb_phy *tegra_phy = dev_get_drvdata(dev);
        struct device_node *dn = data;
 
-       return (tegra_phy->dev->of_node == dn) ? 1 : 0;
+       return (tegra_phy->u_phy.dev->of_node == dn) ? 1 : 0;
 }
 
 struct usb_phy *tegra_usb_get_phy(struct device_node *dn)