#include <linux/dma-mapping.h>
 #include <linux/usb/chipidea.h>
 #include <linux/clk.h>
-#include <linux/regulator/consumer.h>
 
 #include "ci.h"
 #include "ci_hdrc_imx.h"
        struct usb_phy *phy;
        struct platform_device *ci_pdev;
        struct clk *clk;
-       struct regulator *reg_vbus;
 };
 
 static const struct usbmisc_ops *usbmisc_ops;
                goto err_clk;
        }
 
-       /* we only support host now, so enable vbus here */
-       data->reg_vbus = devm_regulator_get(&pdev->dev, "vbus");
-       if (!IS_ERR(data->reg_vbus)) {
-               ret = regulator_enable(data->reg_vbus);
-               if (ret) {
-                       dev_err(&pdev->dev,
-                               "Failed to enable vbus regulator, err=%d\n",
-                               ret);
-                       goto err_clk;
-               }
-       } else {
-               data->reg_vbus = NULL;
-       }
-
        pdata.phy = data->phy;
 
        if (!pdev->dev.dma_mask)
                if (ret) {
                        dev_err(&pdev->dev,
                                "usbmisc init failed, ret=%d\n", ret);
-                       goto err;
+                       goto err_clk;
                }
        }
 
                dev_err(&pdev->dev,
                        "Can't register ci_hdrc platform device, err=%d\n",
                        ret);
-               goto err;
+               goto err_clk;
        }
 
        if (usbmisc_ops && usbmisc_ops->post) {
 
 disable_device:
        ci_hdrc_remove_device(data->ci_pdev);
-err:
-       if (data->reg_vbus)
-               regulator_disable(data->reg_vbus);
 err_clk:
        clk_disable_unprepare(data->clk);
        return ret;
        pm_runtime_disable(&pdev->dev);
        ci_hdrc_remove_device(data->ci_pdev);
 
-       if (data->reg_vbus)
-               regulator_disable(data->reg_vbus);
-
        if (data->phy)
                usb_phy_shutdown(data->phy);
 
 
 #include <linux/usb/chipidea.h>
 #include <linux/usb/of.h>
 #include <linux/phy.h>
+#include <linux/regulator/consumer.h>
 
 #include "ci.h"
 #include "udc.h"
        return ret;
 }
 
+static int ci_get_platdata(struct device *dev,
+               struct ci_hdrc_platform_data *platdata)
+{
+       /* Get the vbus regulator */
+       platdata->reg_vbus = devm_regulator_get(dev, "vbus");
+       if (PTR_ERR(platdata->reg_vbus) == -EPROBE_DEFER) {
+               return -EPROBE_DEFER;
+       } else if (PTR_ERR(platdata->reg_vbus) == -ENODEV) {
+               platdata->reg_vbus = NULL; /* no vbus regualator is needed */
+       } else if (IS_ERR(platdata->reg_vbus)) {
+               dev_err(dev, "Getting regulator error: %ld\n",
+                       PTR_ERR(platdata->reg_vbus));
+               return PTR_ERR(platdata->reg_vbus);
+       }
+
+       return 0;
+}
+
 static DEFINE_IDA(ci_ida);
 
 struct platform_device *ci_hdrc_add_device(struct device *dev,
        struct platform_device *pdev;
        int id, ret;
 
+       ret = ci_get_platdata(dev, platdata);
+       if (ret)
+               return ERR_PTR(ret);
+
        id = ida_simple_get(&ci_ida, 0, 0, GFP_KERNEL);
        if (id < 0)
                return ERR_PTR(id);
 
 #define CI_HDRC_CONTROLLER_RESET_EVENT         0
 #define CI_HDRC_CONTROLLER_STOPPED_EVENT       1
        void    (*notify_event) (struct ci_hdrc *ci, unsigned event);
+       struct regulator        *reg_vbus;
 };
 
 /* Default offset of capability registers */