if (USB_CTRL_MASK(USB_DEVICE_CTL1, PORT_MODE)) {
                reg = brcm_usb_readl(USB_CTRL_REG(ctrl, USB_DEVICE_CTL1));
                reg &= ~USB_CTRL_MASK(USB_DEVICE_CTL1, PORT_MODE);
-               reg |= params->mode;
+               reg |= params->port_mode;
                brcm_usb_writel(reg, USB_CTRL_REG(ctrl, USB_DEVICE_CTL1));
        }
-       switch (params->mode) {
+       switch (params->supported_port_modes) {
        case USB_CTLR_MODE_HOST:
                USB_CTRL_UNSET(ctrl, USB_PM, BDC_SOFT_RESETB);
                break;
        /* Set the PHY_MODE */
        reg = brcm_usb_readl(usb_phy + USB_PHY_UTMI_CTL_1);
        reg &= ~USB_PHY_UTMI_CTL_1_PHY_MODE_MASK;
-       reg |= params->mode << USB_PHY_UTMI_CTL_1_PHY_MODE_SHIFT;
+       reg |= params->supported_port_modes << USB_PHY_UTMI_CTL_1_PHY_MODE_SHIFT;
        brcm_usb_writel(reg, usb_phy + USB_PHY_UTMI_CTL_1);
 
        usb_init_common(params);
         * the default "Read Transaction Size" of 6 (1024 bytes).
         * Set it to 4 (256 bytes).
         */
-       if ((params->mode != USB_CTLR_MODE_HOST) && bdc_ec) {
+       if ((params->supported_port_modes != USB_CTLR_MODE_HOST) && bdc_ec) {
                reg = brcm_usb_readl(bdc_ec + BDC_EC_AXIRDA);
                reg &= ~BDC_EC_AXIRDA_RTS_MASK;
                reg |= (0x4 << BDC_EC_AXIRDA_RTS_SHIFT);
        return reg;
 }
 
-static void usb_set_dual_select(struct brcm_usb_init_params *params, int mode)
+static void usb_set_dual_select(struct brcm_usb_init_params *params)
 {
        void __iomem *ctrl = params->regs[BRCM_REGS_CTRL];
        u32 reg;
 
        reg = brcm_usb_readl(USB_CTRL_REG(ctrl, USB_DEVICE_CTL1));
        reg &= ~USB_CTRL_MASK(USB_DEVICE_CTL1, PORT_MODE);
-       reg |= mode;
+       reg |= params->port_mode;
        brcm_usb_writel(reg, USB_CTRL_REG(ctrl, USB_DEVICE_CTL1));
 }
 
 
                reg = brcm_usb_readl(USB_CTRL_REG(ctrl, USB_DEVICE_CTL1));
                reg &= ~USB_CTRL_MASK_FAMILY(params, USB_DEVICE_CTL1,
                                        PORT_MODE);
-               reg |= params->mode;
+               reg |= params->port_mode;
                brcm_usb_writel(reg, USB_CTRL_REG(ctrl, USB_DEVICE_CTL1));
        }
        if (USB_CTRL_MASK_FAMILY(params, USB_PM, BDC_SOFT_RESETB)) {
-               switch (params->mode) {
+               switch (params->supported_port_modes) {
                case USB_CTLR_MODE_HOST:
                        USB_CTRL_UNSET_FAMILY(params, USB_PM, BDC_SOFT_RESETB);
                        break;
                }
        }
        if (USB_CTRL_MASK_FAMILY(params, SETUP, CC_DRD_MODE_ENABLE)) {
-               if (params->mode == USB_CTLR_MODE_TYPEC_PD)
+               if (params->supported_port_modes == USB_CTLR_MODE_TYPEC_PD)
                        USB_CTRL_SET_FAMILY(params, SETUP, CC_DRD_MODE_ENABLE);
                else
                        USB_CTRL_UNSET_FAMILY(params, SETUP,
        return reg;
 }
 
-static void usb_set_dual_select(struct brcm_usb_init_params *params, int mode)
+static void usb_set_dual_select(struct brcm_usb_init_params *params)
 {
        void __iomem *ctrl = params->regs[BRCM_REGS_CTRL];
        u32 reg;
                reg = brcm_usb_readl(USB_CTRL_REG(ctrl, USB_DEVICE_CTL1));
                reg &= ~USB_CTRL_MASK_FAMILY(params, USB_DEVICE_CTL1,
                                        PORT_MODE);
-               reg |= mode;
+               reg |= params->port_mode;
                brcm_usb_writel(reg, USB_CTRL_REG(ctrl, USB_DEVICE_CTL1));
        }
 }
 
        void (*uninit_eohci)(struct brcm_usb_init_params *params);
        void (*uninit_xhci)(struct brcm_usb_init_params *params);
        int  (*get_dual_select)(struct brcm_usb_init_params *params);
-       void (*set_dual_select)(struct brcm_usb_init_params *params, int mode);
+       void (*set_dual_select)(struct brcm_usb_init_params *params);
 };
 
 struct  brcm_usb_init_params {
        void __iomem *regs[BRCM_REGS_MAX];
        int ioc;
        int ipp;
-       int mode;
+       int supported_port_modes;
+       int port_mode;
        u32 family_id;
        u32 product_id;
        int selected_family;
        return 0;
 }
 
-static inline void brcm_usb_set_dual_select(struct brcm_usb_init_params *ini,
-       int mode)
+static inline void brcm_usb_set_dual_select(struct brcm_usb_init_params *ini)
 {
        if (ini->ops->set_dual_select)
-               ini->ops->set_dual_select(ini, mode);
+               ini->ops->set_dual_select(ini);
 }
 
 #endif /* _USB_BRCM_COMMON_INIT_H */
 
        return sprintf(buf, "%s\n",
                value_to_name(&brcm_dr_mode_to_name[0],
                              ARRAY_SIZE(brcm_dr_mode_to_name),
-                             priv->ini.mode));
+                             priv->ini.supported_port_modes));
 }
 static DEVICE_ATTR_RO(dr_mode);
 
        res = name_to_value(&brcm_dual_mode_to_name[0],
                            ARRAY_SIZE(brcm_dual_mode_to_name), buf, &value);
        if (!res) {
-               brcm_usb_set_dual_select(&priv->ini, value);
+               priv->ini.port_mode = value;
+               brcm_usb_set_dual_select(&priv->ini);
                res = len;
        }
        mutex_unlock(&sysfs_lock);
        of_property_read_u32(dn, "brcm,ipp", &priv->ini.ipp);
        of_property_read_u32(dn, "brcm,ioc", &priv->ini.ioc);
 
-       priv->ini.mode = USB_CTLR_MODE_HOST;
+       priv->ini.supported_port_modes = USB_CTLR_MODE_HOST;
        err = of_property_read_string(dn, "dr_mode", &mode);
        if (err == 0) {
                name_to_value(&brcm_dr_mode_to_name[0],
                              ARRAY_SIZE(brcm_dr_mode_to_name),
-                       mode, &priv->ini.mode);
+                       mode, &priv->ini.supported_port_modes);
        }
+       /* Default port_mode to supported port_modes */
+       priv->ini.port_mode = priv->ini.supported_port_modes;
+
        if (of_property_read_bool(dn, "brcm,has-xhci"))
                priv->has_xhci = true;
        if (of_property_read_bool(dn, "brcm,has-eohci"))
         * Create sysfs entries for mode.
         * Remove "dual_select" attribute if not in dual mode
         */
-       if (priv->ini.mode != USB_CTLR_MODE_DRD)
+       if (priv->ini.supported_port_modes != USB_CTLR_MODE_DRD)
                brcm_usb_phy_attrs[1] = NULL;
        err = sysfs_create_group(&dev->kobj, &brcm_usb_phy_group);
        if (err)