if (pdata->otg_control == OTG_PHY_CONTROL) {
                val = readl(USB_OTGSC);
-               if (pdata->mode == USB_OTG) {
+               if (pdata->mode == USB_DR_MODE_OTG) {
                        ulpi_val = ULPI_INT_IDGRD | ULPI_INT_SESS_VALID;
                        val |= OTGSC_IDIE | OTGSC_BSVIE;
-               } else if (pdata->mode == USB_PERIPHERAL) {
+               } else if (pdata->mode == USB_DR_MODE_PERIPHERAL) {
                        ulpi_val = ULPI_INT_SESS_VALID;
                        val |= OTGSC_BSVIE;
                }
         * Fail host registration if this board can support
         * only peripheral configuration.
         */
-       if (motg->pdata->mode == USB_PERIPHERAL) {
+       if (motg->pdata->mode == USB_DR_MODE_PERIPHERAL) {
                dev_info(otg->phy->dev, "Host mode is not supported\n");
                return -ENODEV;
        }
         * Kick the state machine work, if peripheral is not supported
         * or peripheral is already registered with us.
         */
-       if (motg->pdata->mode == USB_HOST || otg->gadget) {
+       if (motg->pdata->mode == USB_DR_MODE_HOST || otg->gadget) {
                pm_runtime_get_sync(otg->phy->dev);
                schedule_work(&motg->sm_work);
        }
         * Fail peripheral registration if this board can support
         * only host configuration.
         */
-       if (motg->pdata->mode == USB_HOST) {
+       if (motg->pdata->mode == USB_DR_MODE_HOST) {
                dev_info(otg->phy->dev, "Peripheral mode is not supported\n");
                return -ENODEV;
        }
         * Kick the state machine work, if host is not supported
         * or host is already registered with us.
         */
-       if (motg->pdata->mode == USB_PERIPHERAL || otg->host) {
+       if (motg->pdata->mode == USB_DR_MODE_PERIPHERAL || otg->host) {
                pm_runtime_get_sync(otg->phy->dev);
                schedule_work(&motg->sm_work);
        }
        u32 otgsc = readl(USB_OTGSC);
 
        switch (pdata->mode) {
-       case USB_OTG:
+       case USB_DR_MODE_OTG:
                if (pdata->otg_control == OTG_PHY_CONTROL) {
                        if (otgsc & OTGSC_ID)
                                set_bit(ID, &motg->inputs);
                        else
                                clear_bit(B_SESS_VLD, &motg->inputs);
                } else if (pdata->otg_control == OTG_USER_CONTROL) {
-                       if (pdata->default_mode == USB_HOST) {
-                               clear_bit(ID, &motg->inputs);
-                       } else if (pdata->default_mode == USB_PERIPHERAL) {
-                               set_bit(ID, &motg->inputs);
-                               set_bit(B_SESS_VLD, &motg->inputs);
-                       } else {
                                set_bit(ID, &motg->inputs);
                                clear_bit(B_SESS_VLD, &motg->inputs);
-                       }
                }
                break;
-       case USB_HOST:
+       case USB_DR_MODE_HOST:
                clear_bit(ID, &motg->inputs);
                break;
-       case USB_PERIPHERAL:
+       case USB_DR_MODE_PERIPHERAL:
                set_bit(ID, &motg->inputs);
                if (otgsc & OTGSC_BSV)
                        set_bit(B_SESS_VLD, &motg->inputs);
        char buf[16];
        struct usb_otg *otg = motg->phy.otg;
        int status = count;
-       enum usb_mode_type req_mode;
+       enum usb_dr_mode req_mode;
 
        memset(buf, 0x00, sizeof(buf));
 
        }
 
        if (!strncmp(buf, "host", 4)) {
-               req_mode = USB_HOST;
+               req_mode = USB_DR_MODE_HOST;
        } else if (!strncmp(buf, "peripheral", 10)) {
-               req_mode = USB_PERIPHERAL;
+               req_mode = USB_DR_MODE_PERIPHERAL;
        } else if (!strncmp(buf, "none", 4)) {
-               req_mode = USB_NONE;
+               req_mode = USB_DR_MODE_UNKNOWN;
        } else {
                status = -EINVAL;
                goto out;
        }
 
        switch (req_mode) {
-       case USB_NONE:
+       case USB_DR_MODE_UNKNOWN:
                switch (otg->phy->state) {
                case OTG_STATE_A_HOST:
                case OTG_STATE_B_PERIPHERAL:
                        goto out;
                }
                break;
-       case USB_PERIPHERAL:
+       case USB_DR_MODE_PERIPHERAL:
                switch (otg->phy->state) {
                case OTG_STATE_B_IDLE:
                case OTG_STATE_A_HOST:
                        goto out;
                }
                break;
-       case USB_HOST:
+       case USB_DR_MODE_HOST:
                switch (otg->phy->state) {
                case OTG_STATE_B_IDLE:
                case OTG_STATE_B_PERIPHERAL:
        platform_set_drvdata(pdev, motg);
        device_init_wakeup(&pdev->dev, 1);
 
-       if (motg->pdata->mode == USB_OTG &&
+       if (motg->pdata->mode == USB_DR_MODE_OTG &&
                        motg->pdata->otg_control == OTG_USER_CONTROL) {
                ret = msm_otg_debugfs_init(motg);
                if (ret)
 
 #include <linux/usb/otg.h>
 #include <linux/clk.h>
 
-/**
- * Supported USB modes
- *
- * USB_PERIPHERAL       Only peripheral mode is supported.
- * USB_HOST             Only host mode is supported.
- * USB_OTG              OTG mode is supported.
- *
- */
-enum usb_mode_type {
-       USB_NONE = 0,
-       USB_PERIPHERAL,
-       USB_HOST,
-       USB_OTG,
-};
-
 /**
  * OTG control
  *
  * @power_budget: VBUS power budget in mA (0 will be treated as 500mA).
  * @mode: Supported mode (OTG/peripheral/host).
  * @otg_control: OTG switch controlled by user/Id pin
- * @default_mode: Default operational mode. Applicable only if
- *              OTG switch is controller by user.
  * @pclk_src_name: pclk is derived from ebi1_usb_clk in case of 7x27 and 8k
  *              dfab_usb_hs_clk in case of 8660 and 8960.
  */
        int *phy_init_seq;
        void (*vbus_power)(bool on);
        unsigned power_budget;
-       enum usb_mode_type mode;
+       enum usb_dr_mode mode;
        enum otg_control_type otg_control;
-       enum usb_mode_type default_mode;
        enum msm_usb_phy_type phy_type;
        void (*setup_gpio)(enum usb_otg_state state);
        char *pclk_src_name;