usb: dwc2: rename all s3c_* to dwc2_*
authorFelipe Balbi <balbi@ti.com>
Thu, 6 Aug 2015 23:11:54 +0000 (18:11 -0500)
committerFelipe Balbi <balbi@ti.com>
Sun, 27 Sep 2015 15:54:31 +0000 (10:54 -0500)
this driver has long ago became dwc2.ko with
both peripheral and host roles, there's no point
in keeping the old function names.

Acked-by: John Youn <johnyoun@synopsys.com>
Tested-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <balbi@ti.com>
arch/arm/mach-s3c64xx/mach-crag6410.c
arch/arm/mach-s3c64xx/mach-smartq.c
arch/arm/mach-s3c64xx/mach-smdk6410.c
arch/arm/plat-samsung/devs.c
drivers/usb/dwc2/core.h
drivers/usb/dwc2/core_intr.c
drivers/usb/dwc2/debugfs.c
drivers/usb/dwc2/gadget.c
drivers/usb/dwc2/hcd.c
drivers/usb/dwc2/platform.c
include/linux/platform_data/s3c-hsotg.h

index 65c426bc45f72eb530df0736493d4e4a373904cd..14bd9ae3f476a2f8c9dd8672e5e21ed9125b9ad4 100644 (file)
@@ -809,7 +809,7 @@ static const struct gpio_led_platform_data gpio_leds_pdata = {
        .num_leds = ARRAY_SIZE(gpio_leds),
 };
 
-static struct s3c_hsotg_plat crag6410_hsotg_pdata;
+static struct dwc2_hsotg_plat crag6410_hsotg_pdata;
 
 static void __init crag6410_machine_init(void)
 {
@@ -835,7 +835,7 @@ static void __init crag6410_machine_init(void)
        s3c_i2c0_set_platdata(&i2c0_pdata);
        s3c_i2c1_set_platdata(&i2c1_pdata);
        s3c_fb_set_platdata(&crag6410_lcd_pdata);
-       s3c_hsotg_set_platdata(&crag6410_hsotg_pdata);
+       dwc2_hsotg_set_platdata(&crag6410_hsotg_pdata);
 
        i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
        i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
index b3d13537a7f0b2a0ce1fb3adfcd28efce08f7c3b..719843dca510d5900a8560bacee9706650f5b2e6 100644 (file)
@@ -189,7 +189,7 @@ static struct s3c_hwmon_pdata smartq_hwmon_pdata __initdata = {
        },
 };
 
-static struct s3c_hsotg_plat smartq_hsotg_pdata;
+static struct dwc2_hsotg_plat smartq_hsotg_pdata;
 
 static int __init smartq_lcd_setup_gpio(void)
 {
@@ -382,7 +382,7 @@ void __init smartq_map_io(void)
 void __init smartq_machine_init(void)
 {
        s3c_i2c0_set_platdata(NULL);
-       s3c_hsotg_set_platdata(&smartq_hsotg_pdata);
+       dwc2_hsotg_set_platdata(&smartq_hsotg_pdata);
        s3c_hwmon_set_platdata(&smartq_hwmon_pdata);
        s3c_sdhci1_set_platdata(&smartq_internal_hsmmc_pdata);
        s3c_sdhci2_set_platdata(&smartq_internal_hsmmc_pdata);
index d590b88bd8a83a8863c0cbdf5548654ba4b99776..286c9bd676e1796154f65d08f85a899fb40f06c5 100644 (file)
@@ -628,7 +628,7 @@ static struct platform_pwm_backlight_data smdk6410_bl_data = {
        .enable_gpio = -1,
 };
 
-static struct s3c_hsotg_plat smdk6410_hsotg_pdata;
+static struct dwc2_hsotg_plat smdk6410_hsotg_pdata;
 
 static void __init smdk6410_map_io(void)
 {
@@ -659,7 +659,7 @@ static void __init smdk6410_machine_init(void)
        s3c_i2c0_set_platdata(NULL);
        s3c_i2c1_set_platdata(NULL);
        s3c_fb_set_platdata(&smdk6410_lcd_pdata);
-       s3c_hsotg_set_platdata(&smdk6410_hsotg_pdata);
+       dwc2_hsotg_set_platdata(&smdk6410_hsotg_pdata);
 
        samsung_keypad_set_platdata(&smdk6410_keypad_data);
 
index 83c7d154bde0971a3b9abeadeb6fb8bfaa93143a..82074625de5cebfc7681f72c931c90d1b7e951ac 100644 (file)
@@ -1042,11 +1042,11 @@ struct platform_device s3c_device_usb_hsotg = {
        },
 };
 
-void __init s3c_hsotg_set_platdata(struct s3c_hsotg_plat *pd)
+void __init dwc2_hsotg_set_platdata(struct dwc2_hsotg_plat *pd)
 {
-       struct s3c_hsotg_plat *npd;
+       struct dwc2_hsotg_plat *npd;
 
-       npd = s3c_set_platdata(pd, sizeof(struct s3c_hsotg_plat),
+       npd = s3c_set_platdata(pd, sizeof(struct dwc2_hsotg_plat),
                        &s3c_device_usb_hsotg);
 
        if (!npd->phy_init)
index 0ed87620941b5606b83f7e628439266ca7831e18..9655b1ec4f34c33839429ec1b7472da0b70f8eaa 100644 (file)
@@ -58,8 +58,8 @@ static inline void do_write(u32 value, void *addr)
 /* Maximum number of Endpoints/HostChannels */
 #define MAX_EPS_CHANNELS       16
 
-/* s3c-hsotg declarations */
-static const char * const s3c_hsotg_supply_names[] = {
+/* dwc2-hsotg declarations */
+static const char * const dwc2_hsotg_supply_names[] = {
        "vusb_d",               /* digital USB supply, 1.2V */
        "vusb_a",               /* analog USB supply, 1.1V */
 };
@@ -85,10 +85,10 @@ static const char * const s3c_hsotg_supply_names[] = {
 #define EP0_MPS_LIMIT   64
 
 struct dwc2_hsotg;
-struct s3c_hsotg_req;
+struct dwc2_hsotg_req;
 
 /**
- * struct s3c_hsotg_ep - driver endpoint definition.
+ * struct dwc2_hsotg_ep - driver endpoint definition.
  * @ep: The gadget layer representation of the endpoint.
  * @name: The driver generated name for the endpoint.
  * @queue: Queue of requests for this endpoint.
@@ -127,11 +127,11 @@ struct s3c_hsotg_req;
  * as in shared-fifo mode periodic in acts like a single-frame packet
  * buffer than a fifo)
  */
-struct s3c_hsotg_ep {
+struct dwc2_hsotg_ep {
        struct usb_ep           ep;
        struct list_head        queue;
        struct dwc2_hsotg       *parent;
-       struct s3c_hsotg_req    *req;
+       struct dwc2_hsotg_req    *req;
        struct dentry           *debugfs;
 
        unsigned long           total_data;
@@ -155,12 +155,12 @@ struct s3c_hsotg_ep {
 };
 
 /**
- * struct s3c_hsotg_req - data transfer request
+ * struct dwc2_hsotg_req - data transfer request
  * @req: The USB gadget request
  * @queue: The list of requests for the endpoint this is queued for.
  * @saved_req_buf: variable to save req.buf when bounce buffers are used.
  */
-struct s3c_hsotg_req {
+struct dwc2_hsotg_req {
        struct usb_request      req;
        struct list_head        queue;
        void *saved_req_buf;
@@ -693,7 +693,7 @@ struct dwc2_hsotg {
 
        struct phy *phy;
        struct usb_phy *uphy;
-       struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsotg_supply_names)];
+       struct regulator_bulk_data supplies[ARRAY_SIZE(dwc2_hsotg_supply_names)];
 
        spinlock_t lock;
        struct mutex init_mutex;
@@ -796,7 +796,7 @@ struct dwc2_hsotg {
 #if IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL) || IS_ENABLED(CONFIG_USB_DWC2_DUAL_ROLE)
        /* Gadget structures */
        struct usb_gadget_driver *driver;
-       struct s3c_hsotg_plat *plat;
+       struct dwc2_hsotg_plat *plat;
 
        u32 phyif;
        int fifo_mem;
@@ -815,8 +815,8 @@ struct dwc2_hsotg {
        unsigned int enabled:1;
        unsigned int connected:1;
        unsigned long last_rst;
-       struct s3c_hsotg_ep *eps_in[MAX_EPS_CHANNELS];
-       struct s3c_hsotg_ep *eps_out[MAX_EPS_CHANNELS];
+       struct dwc2_hsotg_ep *eps_in[MAX_EPS_CHANNELS];
+       struct dwc2_hsotg_ep *eps_out[MAX_EPS_CHANNELS];
        u32 g_using_dma;
        u32 g_rx_fifo_sz;
        u32 g_np_g_tx_fifo_sz;
@@ -1104,30 +1104,30 @@ extern u16 dwc2_get_otg_version(struct dwc2_hsotg *hsotg);
 
 /* Gadget defines */
 #if IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL) || IS_ENABLED(CONFIG_USB_DWC2_DUAL_ROLE)
-extern int s3c_hsotg_remove(struct dwc2_hsotg *hsotg);
-extern int s3c_hsotg_suspend(struct dwc2_hsotg *dwc2);
-extern int s3c_hsotg_resume(struct dwc2_hsotg *dwc2);
+extern int dwc2_hsotg_remove(struct dwc2_hsotg *hsotg);
+extern int dwc2_hsotg_suspend(struct dwc2_hsotg *dwc2);
+extern int dwc2_hsotg_resume(struct dwc2_hsotg *dwc2);
 extern int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq);
-extern void s3c_hsotg_core_init_disconnected(struct dwc2_hsotg *dwc2,
+extern void dwc2_hsotg_core_init_disconnected(struct dwc2_hsotg *dwc2,
                bool reset);
-extern void s3c_hsotg_core_connect(struct dwc2_hsotg *hsotg);
-extern void s3c_hsotg_disconnect(struct dwc2_hsotg *dwc2);
-extern int s3c_hsotg_set_test_mode(struct dwc2_hsotg *hsotg, int testmode);
+extern void dwc2_hsotg_core_connect(struct dwc2_hsotg *hsotg);
+extern void dwc2_hsotg_disconnect(struct dwc2_hsotg *dwc2);
+extern int dwc2_hsotg_set_test_mode(struct dwc2_hsotg *hsotg, int testmode);
 #define dwc2_is_device_connected(hsotg) (hsotg->connected)
 #else
-static inline int s3c_hsotg_remove(struct dwc2_hsotg *dwc2)
+static inline int dwc2_hsotg_remove(struct dwc2_hsotg *dwc2)
 { return 0; }
-static inline int s3c_hsotg_suspend(struct dwc2_hsotg *dwc2)
+static inline int dwc2_hsotg_suspend(struct dwc2_hsotg *dwc2)
 { return 0; }
-static inline int s3c_hsotg_resume(struct dwc2_hsotg *dwc2)
+static inline int dwc2_hsotg_resume(struct dwc2_hsotg *dwc2)
 { return 0; }
 static inline int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
 { return 0; }
-static inline void s3c_hsotg_core_init_disconnected(struct dwc2_hsotg *dwc2,
+static inline void dwc2_hsotg_core_init_disconnected(struct dwc2_hsotg *dwc2,
                bool reset) {}
-static inline void s3c_hsotg_core_connect(struct dwc2_hsotg *hsotg) {}
-static inline void s3c_hsotg_disconnect(struct dwc2_hsotg *dwc2) {}
-static inline int s3c_hsotg_set_test_mode(struct dwc2_hsotg *hsotg,
+static inline void dwc2_hsotg_core_connect(struct dwc2_hsotg *hsotg) {}
+static inline void dwc2_hsotg_disconnect(struct dwc2_hsotg *dwc2) {}
+static inline int dwc2_hsotg_set_test_mode(struct dwc2_hsotg *hsotg,
                                                        int testmode)
 { return 0; }
 #define dwc2_is_device_connected(hsotg) (0)
index 927be1e8b3dc93951cb78ac7665eb0aa0bedfcf8..344a859c2153e427ff7b04bdb2ea09285fda4412 100644 (file)
@@ -129,7 +129,7 @@ static void dwc2_handle_otg_intr(struct dwc2_hsotg *hsotg)
                gotgctl = readl(hsotg->regs + GOTGCTL);
 
                if (dwc2_is_device_mode(hsotg))
-                       s3c_hsotg_disconnect(hsotg);
+                       dwc2_hsotg_disconnect(hsotg);
 
                if (hsotg->op_state == OTG_STATE_B_HOST) {
                        hsotg->op_state = OTG_STATE_B_PERIPHERAL;
@@ -322,7 +322,7 @@ static void dwc2_handle_session_req_intr(struct dwc2_hsotg *hsotg)
         * Report disconnect if there is any previous session established
         */
        if (dwc2_is_device_mode(hsotg))
-               s3c_hsotg_disconnect(hsotg);
+               dwc2_hsotg_disconnect(hsotg);
 }
 
 /*
index ef2ee3d9a25d2e37a47028f53793ef077b857015..cee3d771b75eb3d0220baa6db919ec2dc2895530 100644 (file)
@@ -57,7 +57,7 @@ static ssize_t testmode_write(struct file *file, const char __user *ubuf, size_t
                testmode = 0;
 
        spin_lock_irqsave(&hsotg->lock, flags);
-       s3c_hsotg_set_test_mode(hsotg, testmode);
+       dwc2_hsotg_set_test_mode(hsotg, testmode);
        spin_unlock_irqrestore(&hsotg->lock, flags);
        return count;
 }
@@ -256,9 +256,9 @@ static const char *decode_direction(int is_in)
  */
 static int ep_show(struct seq_file *seq, void *v)
 {
-       struct s3c_hsotg_ep *ep = seq->private;
+       struct dwc2_hsotg_ep *ep = seq->private;
        struct dwc2_hsotg *hsotg = ep->parent;
-       struct s3c_hsotg_req *req;
+       struct dwc2_hsotg_req *req;
        void __iomem *regs = hsotg->regs;
        int index = ep->index;
        int show_limit = 15;
@@ -326,7 +326,7 @@ static const struct file_operations ep_fops = {
 };
 
 /**
- * s3c_hsotg_create_debug - create debugfs directory and files
+ * dwc2_hsotg_create_debug - create debugfs directory and files
  * @hsotg: The driver state
  *
  * Create the debugfs files to allow the user to get information
@@ -334,7 +334,7 @@ static const struct file_operations ep_fops = {
  * with the same name as the device itself, in case we end up
  * with multiple blocks in future systems.
  */
-static void s3c_hsotg_create_debug(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_create_debug(struct dwc2_hsotg *hsotg)
 {
        struct dentry *root;
        struct dentry *file;
@@ -360,7 +360,7 @@ static void s3c_hsotg_create_debug(struct dwc2_hsotg *hsotg)
 
        /* Create one file for each out endpoint */
        for (epidx = 0; epidx < hsotg->num_of_eps; epidx++) {
-               struct s3c_hsotg_ep *ep;
+               struct dwc2_hsotg_ep *ep;
 
                ep = hsotg->eps_out[epidx];
                if (ep) {
@@ -373,7 +373,7 @@ static void s3c_hsotg_create_debug(struct dwc2_hsotg *hsotg)
        }
        /* Create one file for each in endpoint. EP0 is handled with out eps */
        for (epidx = 1; epidx < hsotg->num_of_eps; epidx++) {
-               struct s3c_hsotg_ep *ep;
+               struct dwc2_hsotg_ep *ep;
 
                ep = hsotg->eps_in[epidx];
                if (ep) {
@@ -386,10 +386,10 @@ static void s3c_hsotg_create_debug(struct dwc2_hsotg *hsotg)
        }
 }
 #else
-static inline void s3c_hsotg_create_debug(struct dwc2_hsotg *hsotg) {}
+static inline void dwc2_hsotg_create_debug(struct dwc2_hsotg *hsotg) {}
 #endif
 
-/* s3c_hsotg_delete_debug is removed as cleanup in done in dwc2_debugfs_exit */
+/* dwc2_hsotg_delete_debug is removed as cleanup in done in dwc2_debugfs_exit */
 
 #define dump_register(nm)      \
 {                              \
@@ -737,7 +737,7 @@ int dwc2_debugfs_init(struct dwc2_hsotg *hsotg)
        }
 
        /* Add gadget debugfs nodes */
-       s3c_hsotg_create_debug(hsotg);
+       dwc2_hsotg_create_debug(hsotg);
 
        hsotg->regset = devm_kzalloc(hsotg->dev, sizeof(*hsotg->regset),
                                                                GFP_KERNEL);
index 3ee5b4c77a1f42eeecf1f222ab63e822b1530c9a..2ed9ad84d9793929338f7630b28aaff4aa44d08d 100644 (file)
 #include "hw.h"
 
 /* conversion functions */
-static inline struct s3c_hsotg_req *our_req(struct usb_request *req)
+static inline struct dwc2_hsotg_req *our_req(struct usb_request *req)
 {
-       return container_of(req, struct s3c_hsotg_req, req);
+       return container_of(req, struct dwc2_hsotg_req, req);
 }
 
-static inline struct s3c_hsotg_ep *our_ep(struct usb_ep *ep)
+static inline struct dwc2_hsotg_ep *our_ep(struct usb_ep *ep)
 {
-       return container_of(ep, struct s3c_hsotg_ep, ep);
+       return container_of(ep, struct dwc2_hsotg_ep, ep);
 }
 
 static inline struct dwc2_hsotg *to_hsotg(struct usb_gadget *gadget)
@@ -64,7 +64,7 @@ static inline void __bic32(void __iomem *ptr, u32 val)
        writel(readl(ptr) & ~val, ptr);
 }
 
-static inline struct s3c_hsotg_ep *index_to_ep(struct dwc2_hsotg *hsotg,
+static inline struct dwc2_hsotg_ep *index_to_ep(struct dwc2_hsotg *hsotg,
                                                u32 ep_index, u32 dir_in)
 {
        if (dir_in)
@@ -74,7 +74,7 @@ static inline struct s3c_hsotg_ep *index_to_ep(struct dwc2_hsotg *hsotg,
 }
 
 /* forward declaration of functions */
-static void s3c_hsotg_dump(struct dwc2_hsotg *hsotg);
+static void dwc2_hsotg_dump(struct dwc2_hsotg *hsotg);
 
 /**
  * using_dma - return the DMA status of the driver.
@@ -101,11 +101,11 @@ static inline bool using_dma(struct dwc2_hsotg *hsotg)
 }
 
 /**
- * s3c_hsotg_en_gsint - enable one or more of the general interrupt
+ * dwc2_hsotg_en_gsint - enable one or more of the general interrupt
  * @hsotg: The device state
  * @ints: A bitmask of the interrupts to enable
  */
-static void s3c_hsotg_en_gsint(struct dwc2_hsotg *hsotg, u32 ints)
+static void dwc2_hsotg_en_gsint(struct dwc2_hsotg *hsotg, u32 ints)
 {
        u32 gsintmsk = readl(hsotg->regs + GINTMSK);
        u32 new_gsintmsk;
@@ -119,11 +119,11 @@ static void s3c_hsotg_en_gsint(struct dwc2_hsotg *hsotg, u32 ints)
 }
 
 /**
- * s3c_hsotg_disable_gsint - disable one or more of the general interrupt
+ * dwc2_hsotg_disable_gsint - disable one or more of the general interrupt
  * @hsotg: The device state
  * @ints: A bitmask of the interrupts to enable
  */
-static void s3c_hsotg_disable_gsint(struct dwc2_hsotg *hsotg, u32 ints)
+static void dwc2_hsotg_disable_gsint(struct dwc2_hsotg *hsotg, u32 ints)
 {
        u32 gsintmsk = readl(hsotg->regs + GINTMSK);
        u32 new_gsintmsk;
@@ -135,7 +135,7 @@ static void s3c_hsotg_disable_gsint(struct dwc2_hsotg *hsotg, u32 ints)
 }
 
 /**
- * s3c_hsotg_ctrl_epint - enable/disable an endpoint irq
+ * dwc2_hsotg_ctrl_epint - enable/disable an endpoint irq
  * @hsotg: The device state
  * @ep: The endpoint index
  * @dir_in: True if direction is in.
@@ -144,7 +144,7 @@ static void s3c_hsotg_disable_gsint(struct dwc2_hsotg *hsotg, u32 ints)
  * Set or clear the mask for an individual endpoint's interrupt
  * request.
  */
-static void s3c_hsotg_ctrl_epint(struct dwc2_hsotg *hsotg,
+static void dwc2_hsotg_ctrl_epint(struct dwc2_hsotg *hsotg,
                                 unsigned int ep, unsigned int dir_in,
                                 unsigned int en)
 {
@@ -166,10 +166,10 @@ static void s3c_hsotg_ctrl_epint(struct dwc2_hsotg *hsotg,
 }
 
 /**
- * s3c_hsotg_init_fifo - initialise non-periodic FIFOs
+ * dwc2_hsotg_init_fifo - initialise non-periodic FIFOs
  * @hsotg: The device instance.
  */
-static void s3c_hsotg_init_fifo(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_init_fifo(struct dwc2_hsotg *hsotg)
 {
        unsigned int ep;
        unsigned int addr;
@@ -248,12 +248,12 @@ static void s3c_hsotg_init_fifo(struct dwc2_hsotg *hsotg)
  *
  * Allocate a new USB request structure appropriate for the specified endpoint
  */
-static struct usb_request *s3c_hsotg_ep_alloc_request(struct usb_ep *ep,
+static struct usb_request *dwc2_hsotg_ep_alloc_request(struct usb_ep *ep,
                                                      gfp_t flags)
 {
-       struct s3c_hsotg_req *req;
+       struct dwc2_hsotg_req *req;
 
-       req = kzalloc(sizeof(struct s3c_hsotg_req), flags);
+       req = kzalloc(sizeof(struct dwc2_hsotg_req), flags);
        if (!req)
                return NULL;
 
@@ -269,23 +269,23 @@ static struct usb_request *s3c_hsotg_ep_alloc_request(struct usb_ep *ep,
  * Returns true if the endpoint is in periodic mode, meaning it is being
  * used for an Interrupt or ISO transfer.
  */
-static inline int is_ep_periodic(struct s3c_hsotg_ep *hs_ep)
+static inline int is_ep_periodic(struct dwc2_hsotg_ep *hs_ep)
 {
        return hs_ep->periodic;
 }
 
 /**
- * s3c_hsotg_unmap_dma - unmap the DMA memory being used for the request
+ * dwc2_hsotg_unmap_dma - unmap the DMA memory being used for the request
  * @hsotg: The device state.
  * @hs_ep: The endpoint for the request
  * @hs_req: The request being processed.
  *
- * This is the reverse of s3c_hsotg_map_dma(), called for the completion
+ * This is the reverse of dwc2_hsotg_map_dma(), called for the completion
  * of a request to ensure the buffer is ready for access by the caller.
  */
-static void s3c_hsotg_unmap_dma(struct dwc2_hsotg *hsotg,
-                               struct s3c_hsotg_ep *hs_ep,
-                               struct s3c_hsotg_req *hs_req)
+static void dwc2_hsotg_unmap_dma(struct dwc2_hsotg *hsotg,
+                               struct dwc2_hsotg_ep *hs_ep,
+                               struct dwc2_hsotg_req *hs_req)
 {
        struct usb_request *req = &hs_req->req;
 
@@ -297,7 +297,7 @@ static void s3c_hsotg_unmap_dma(struct dwc2_hsotg *hsotg,
 }
 
 /**
- * s3c_hsotg_write_fifo - write packet Data to the TxFIFO
+ * dwc2_hsotg_write_fifo - write packet Data to the TxFIFO
  * @hsotg: The controller state.
  * @hs_ep: The endpoint we're going to write for.
  * @hs_req: The request to write data for.
@@ -312,9 +312,9 @@ static void s3c_hsotg_unmap_dma(struct dwc2_hsotg *hsotg,
  *
  * This routine is only needed for PIO
  */
-static int s3c_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
-                               struct s3c_hsotg_ep *hs_ep,
-                               struct s3c_hsotg_req *hs_req)
+static int dwc2_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
+                               struct dwc2_hsotg_ep *hs_ep,
+                               struct dwc2_hsotg_req *hs_req)
 {
        bool periodic = is_ep_periodic(hs_ep);
        u32 gnptxsts = readl(hsotg->regs + GNPTXSTS);
@@ -348,7 +348,7 @@ static int s3c_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
                 * previous data has been completely sent.
                 */
                if (hs_ep->fifo_load != 0) {
-                       s3c_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
+                       dwc2_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
                        return -ENOSPC;
                }
 
@@ -369,7 +369,7 @@ static int s3c_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
                        __func__, can_write);
 
                if (can_write <= 0) {
-                       s3c_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
+                       dwc2_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
                        return -ENOSPC;
                }
        } else if (hsotg->dedicated_fifos && hs_ep->index != 0) {
@@ -383,7 +383,7 @@ static int s3c_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
                                "%s: no queue slots available (0x%08x)\n",
                                __func__, gnptxsts);
 
-                       s3c_hsotg_en_gsint(hsotg, GINTSTS_NPTXFEMP);
+                       dwc2_hsotg_en_gsint(hsotg, GINTSTS_NPTXFEMP);
                        return -ENOSPC;
                }
 
@@ -414,7 +414,7 @@ static int s3c_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
 
                /* it's needed only when we do not use dedicated fifos */
                if (!hsotg->dedicated_fifos)
-                       s3c_hsotg_en_gsint(hsotg,
+                       dwc2_hsotg_en_gsint(hsotg,
                                           periodic ? GINTSTS_PTXFEMP :
                                           GINTSTS_NPTXFEMP);
        }
@@ -443,7 +443,7 @@ static int s3c_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
 
                /* it's needed only when we do not use dedicated fifos */
                if (!hsotg->dedicated_fifos)
-                       s3c_hsotg_en_gsint(hsotg,
+                       dwc2_hsotg_en_gsint(hsotg,
                                           periodic ? GINTSTS_PTXFEMP :
                                           GINTSTS_NPTXFEMP);
        }
@@ -475,7 +475,7 @@ static int s3c_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
  * Return the maximum data that can be queued in one go on a given endpoint
  * so that transfers that are too long can be split.
  */
-static unsigned get_ep_limit(struct s3c_hsotg_ep *hs_ep)
+static unsigned get_ep_limit(struct dwc2_hsotg_ep *hs_ep)
 {
        int index = hs_ep->index;
        unsigned maxsize;
@@ -508,7 +508,7 @@ static unsigned get_ep_limit(struct s3c_hsotg_ep *hs_ep)
 }
 
 /**
- * s3c_hsotg_start_req - start a USB request from an endpoint's queue
+ * dwc2_hsotg_start_req - start a USB request from an endpoint's queue
  * @hsotg: The controller state.
  * @hs_ep: The endpoint to process a request for
  * @hs_req: The request to start.
@@ -517,9 +517,9 @@ static unsigned get_ep_limit(struct s3c_hsotg_ep *hs_ep)
  * Start the given request running by setting the endpoint registers
  * appropriately, and writing any data to the FIFOs.
  */
-static void s3c_hsotg_start_req(struct dwc2_hsotg *hsotg,
-                               struct s3c_hsotg_ep *hs_ep,
-                               struct s3c_hsotg_req *hs_req,
+static void dwc2_hsotg_start_req(struct dwc2_hsotg *hsotg,
+                               struct dwc2_hsotg_ep *hs_ep,
+                               struct dwc2_hsotg_req *hs_req,
                                bool continuing)
 {
        struct usb_request *ureq = &hs_req->req;
@@ -625,7 +625,7 @@ static void s3c_hsotg_start_req(struct dwc2_hsotg *hsotg,
 
                /*
                 * write DMA address to control register, buffer already
-                * synced by s3c_hsotg_ep_queue().
+                * synced by dwc2_hsotg_ep_queue().
                 */
 
                dma_reg = dir_in ? DIEPDMA(index) : DOEPDMA(index);
@@ -659,7 +659,7 @@ static void s3c_hsotg_start_req(struct dwc2_hsotg *hsotg,
                /* set these anyway, we may need them for non-periodic in */
                hs_ep->fifo_load = 0;
 
-               s3c_hsotg_write_fifo(hsotg, hs_ep, hs_req);
+               dwc2_hsotg_write_fifo(hsotg, hs_ep, hs_req);
        }
 
        /*
@@ -685,11 +685,11 @@ static void s3c_hsotg_start_req(struct dwc2_hsotg *hsotg,
                __func__, readl(hsotg->regs + epctrl_reg));
 
        /* enable ep interrupts */
-       s3c_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 1);
+       dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 1);
 }
 
 /**
- * s3c_hsotg_map_dma - map the DMA memory being used for the request
+ * dwc2_hsotg_map_dma - map the DMA memory being used for the request
  * @hsotg: The device state.
  * @hs_ep: The endpoint the request is on.
  * @req: The request being processed.
@@ -700,11 +700,11 @@ static void s3c_hsotg_start_req(struct dwc2_hsotg *hsotg,
  * DMA memory, then we map the memory and mark our request to allow us to
  * cleanup on completion.
  */
-static int s3c_hsotg_map_dma(struct dwc2_hsotg *hsotg,
-                            struct s3c_hsotg_ep *hs_ep,
+static int dwc2_hsotg_map_dma(struct dwc2_hsotg *hsotg,
+                            struct dwc2_hsotg_ep *hs_ep,
                             struct usb_request *req)
 {
-       struct s3c_hsotg_req *hs_req = our_req(req);
+       struct dwc2_hsotg_req *hs_req = our_req(req);
        int ret;
 
        /* if the length is zero, ignore the DMA data */
@@ -724,8 +724,8 @@ dma_error:
        return -EIO;
 }
 
-static int s3c_hsotg_handle_unaligned_buf_start(struct dwc2_hsotg *hsotg,
-       struct s3c_hsotg_ep *hs_ep, struct s3c_hsotg_req *hs_req)
+static int dwc2_hsotg_handle_unaligned_buf_start(struct dwc2_hsotg *hsotg,
+       struct dwc2_hsotg_ep *hs_ep, struct dwc2_hsotg_req *hs_req)
 {
        void *req_buf = hs_req->req.buf;
 
@@ -755,8 +755,8 @@ static int s3c_hsotg_handle_unaligned_buf_start(struct dwc2_hsotg *hsotg,
        return 0;
 }
 
-static void s3c_hsotg_handle_unaligned_buf_complete(struct dwc2_hsotg *hsotg,
-       struct s3c_hsotg_ep *hs_ep, struct s3c_hsotg_req *hs_req)
+static void dwc2_hsotg_handle_unaligned_buf_complete(struct dwc2_hsotg *hsotg,
+       struct dwc2_hsotg_ep *hs_ep, struct dwc2_hsotg_req *hs_req)
 {
        /* If dma is not being used or buffer was aligned */
        if (!using_dma(hsotg) || !hs_req->saved_req_buf)
@@ -777,11 +777,11 @@ static void s3c_hsotg_handle_unaligned_buf_complete(struct dwc2_hsotg *hsotg,
        hs_req->saved_req_buf = NULL;
 }
 
-static int s3c_hsotg_ep_queue(struct usb_ep *ep, struct usb_request *req,
+static int dwc2_hsotg_ep_queue(struct usb_ep *ep, struct usb_request *req,
                              gfp_t gfp_flags)
 {
-       struct s3c_hsotg_req *hs_req = our_req(req);
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_req *hs_req = our_req(req);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hs = hs_ep->parent;
        bool first;
        int ret;
@@ -802,13 +802,13 @@ static int s3c_hsotg_ep_queue(struct usb_ep *ep, struct usb_request *req,
        req->actual = 0;
        req->status = -EINPROGRESS;
 
-       ret = s3c_hsotg_handle_unaligned_buf_start(hs, hs_ep, hs_req);
+       ret = dwc2_hsotg_handle_unaligned_buf_start(hs, hs_ep, hs_req);
        if (ret)
                return ret;
 
        /* if we're using DMA, sync the buffers as necessary */
        if (using_dma(hs)) {
-               ret = s3c_hsotg_map_dma(hs, hs_ep, req);
+               ret = dwc2_hsotg_map_dma(hs, hs_ep, req);
                if (ret)
                        return ret;
        }
@@ -817,51 +817,51 @@ static int s3c_hsotg_ep_queue(struct usb_ep *ep, struct usb_request *req,
        list_add_tail(&hs_req->queue, &hs_ep->queue);
 
        if (first)
-               s3c_hsotg_start_req(hs, hs_ep, hs_req, false);
+               dwc2_hsotg_start_req(hs, hs_ep, hs_req, false);
 
        return 0;
 }
 
-static int s3c_hsotg_ep_queue_lock(struct usb_ep *ep, struct usb_request *req,
+static int dwc2_hsotg_ep_queue_lock(struct usb_ep *ep, struct usb_request *req,
                              gfp_t gfp_flags)
 {
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hs = hs_ep->parent;
        unsigned long flags = 0;
        int ret = 0;
 
        spin_lock_irqsave(&hs->lock, flags);
-       ret = s3c_hsotg_ep_queue(ep, req, gfp_flags);
+       ret = dwc2_hsotg_ep_queue(ep, req, gfp_flags);
        spin_unlock_irqrestore(&hs->lock, flags);
 
        return ret;
 }
 
-static void s3c_hsotg_ep_free_request(struct usb_ep *ep,
+static void dwc2_hsotg_ep_free_request(struct usb_ep *ep,
                                      struct usb_request *req)
 {
-       struct s3c_hsotg_req *hs_req = our_req(req);
+       struct dwc2_hsotg_req *hs_req = our_req(req);
 
        kfree(hs_req);
 }
 
 /**
- * s3c_hsotg_complete_oursetup - setup completion callback
+ * dwc2_hsotg_complete_oursetup - setup completion callback
  * @ep: The endpoint the request was on.
  * @req: The request completed.
  *
  * Called on completion of any requests the driver itself
  * submitted that need cleaning up.
  */
-static void s3c_hsotg_complete_oursetup(struct usb_ep *ep,
+static void dwc2_hsotg_complete_oursetup(struct usb_ep *ep,
                                        struct usb_request *req)
 {
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hsotg = hs_ep->parent;
 
        dev_dbg(hsotg->dev, "%s: ep %p, req %p\n", __func__, ep, req);
 
-       s3c_hsotg_ep_free_request(ep, req);
+       dwc2_hsotg_ep_free_request(ep, req);
 }
 
 /**
@@ -872,10 +872,10 @@ static void s3c_hsotg_complete_oursetup(struct usb_ep *ep,
  * Convert the given wIndex into a pointer to an driver endpoint
  * structure, or return NULL if it is not a valid endpoint.
  */
-static struct s3c_hsotg_ep *ep_from_windex(struct dwc2_hsotg *hsotg,
+static struct dwc2_hsotg_ep *ep_from_windex(struct dwc2_hsotg *hsotg,
                                           u32 windex)
 {
-       struct s3c_hsotg_ep *ep;
+       struct dwc2_hsotg_ep *ep;
        int dir = (windex & USB_DIR_IN) ? 1 : 0;
        int idx = windex & 0x7F;
 
@@ -894,12 +894,12 @@ static struct s3c_hsotg_ep *ep_from_windex(struct dwc2_hsotg *hsotg,
 }
 
 /**
- * s3c_hsotg_set_test_mode - Enable usb Test Modes
+ * dwc2_hsotg_set_test_mode - Enable usb Test Modes
  * @hsotg: The driver state.
  * @testmode: requested usb test mode
  * Enable usb Test Mode requested by the Host.
  */
-int s3c_hsotg_set_test_mode(struct dwc2_hsotg *hsotg, int testmode)
+int dwc2_hsotg_set_test_mode(struct dwc2_hsotg *hsotg, int testmode)
 {
        int dctl = readl(hsotg->regs + DCTL);
 
@@ -920,7 +920,7 @@ int s3c_hsotg_set_test_mode(struct dwc2_hsotg *hsotg, int testmode)
 }
 
 /**
- * s3c_hsotg_send_reply - send reply to control request
+ * dwc2_hsotg_send_reply - send reply to control request
  * @hsotg: The device state
  * @ep: Endpoint 0
  * @buff: Buffer for request
@@ -929,8 +929,8 @@ int s3c_hsotg_set_test_mode(struct dwc2_hsotg *hsotg, int testmode)
  * Create a request and queue it on the given endpoint. This is useful as
  * an internal method of sending replies to certain control requests, etc.
  */
-static int s3c_hsotg_send_reply(struct dwc2_hsotg *hsotg,
-                               struct s3c_hsotg_ep *ep,
+static int dwc2_hsotg_send_reply(struct dwc2_hsotg *hsotg,
+                               struct dwc2_hsotg_ep *ep,
                                void *buff,
                                int length)
 {
@@ -939,7 +939,7 @@ static int s3c_hsotg_send_reply(struct dwc2_hsotg *hsotg,
 
        dev_dbg(hsotg->dev, "%s: buff %p, len %d\n", __func__, buff, length);
 
-       req = s3c_hsotg_ep_alloc_request(&ep->ep, GFP_ATOMIC);
+       req = dwc2_hsotg_ep_alloc_request(&ep->ep, GFP_ATOMIC);
        hsotg->ep0_reply = req;
        if (!req) {
                dev_warn(hsotg->dev, "%s: cannot alloc req\n", __func__);
@@ -953,12 +953,12 @@ static int s3c_hsotg_send_reply(struct dwc2_hsotg *hsotg,
         * STATUS stage.
         */
        req->zero = 0;
-       req->complete = s3c_hsotg_complete_oursetup;
+       req->complete = dwc2_hsotg_complete_oursetup;
 
        if (length)
                memcpy(req->buf, buff, length);
 
-       ret = s3c_hsotg_ep_queue(&ep->ep, req, GFP_ATOMIC);
+       ret = dwc2_hsotg_ep_queue(&ep->ep, req, GFP_ATOMIC);
        if (ret) {
                dev_warn(hsotg->dev, "%s: cannot queue req\n", __func__);
                return ret;
@@ -968,15 +968,15 @@ static int s3c_hsotg_send_reply(struct dwc2_hsotg *hsotg,
 }
 
 /**
- * s3c_hsotg_process_req_status - process request GET_STATUS
+ * dwc2_hsotg_process_req_status - process request GET_STATUS
  * @hsotg: The device state
  * @ctrl: USB control request
  */
-static int s3c_hsotg_process_req_status(struct dwc2_hsotg *hsotg,
+static int dwc2_hsotg_process_req_status(struct dwc2_hsotg *hsotg,
                                        struct usb_ctrlrequest *ctrl)
 {
-       struct s3c_hsotg_ep *ep0 = hsotg->eps_out[0];
-       struct s3c_hsotg_ep *ep;
+       struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
+       struct dwc2_hsotg_ep *ep;
        __le16 reply;
        int ret;
 
@@ -1013,7 +1013,7 @@ static int s3c_hsotg_process_req_status(struct dwc2_hsotg *hsotg,
        if (le16_to_cpu(ctrl->wLength) != 2)
                return -EINVAL;
 
-       ret = s3c_hsotg_send_reply(hsotg, ep0, &reply, 2);
+       ret = dwc2_hsotg_send_reply(hsotg, ep0, &reply, 2);
        if (ret) {
                dev_err(hsotg->dev, "%s: failed to send reply\n", __func__);
                return ret;
@@ -1022,7 +1022,7 @@ static int s3c_hsotg_process_req_status(struct dwc2_hsotg *hsotg,
        return 1;
 }
 
-static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value);
+static int dwc2_hsotg_ep_sethalt(struct usb_ep *ep, int value);
 
 /**
  * get_ep_head - return the first request on the endpoint
@@ -1030,27 +1030,27 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value);
  *
  * Get the first request on the endpoint.
  */
-static struct s3c_hsotg_req *get_ep_head(struct s3c_hsotg_ep *hs_ep)
+static struct dwc2_hsotg_req *get_ep_head(struct dwc2_hsotg_ep *hs_ep)
 {
        if (list_empty(&hs_ep->queue))
                return NULL;
 
-       return list_first_entry(&hs_ep->queue, struct s3c_hsotg_req, queue);
+       return list_first_entry(&hs_ep->queue, struct dwc2_hsotg_req, queue);
 }
 
 /**
- * s3c_hsotg_process_req_feature - process request {SET,CLEAR}_FEATURE
+ * dwc2_hsotg_process_req_feature - process request {SET,CLEAR}_FEATURE
  * @hsotg: The device state
  * @ctrl: USB control request
  */
-static int s3c_hsotg_process_req_feature(struct dwc2_hsotg *hsotg,
+static int dwc2_hsotg_process_req_feature(struct dwc2_hsotg *hsotg,
                                         struct usb_ctrlrequest *ctrl)
 {
-       struct s3c_hsotg_ep *ep0 = hsotg->eps_out[0];
-       struct s3c_hsotg_req *hs_req;
+       struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
+       struct dwc2_hsotg_req *hs_req;
        bool restart;
        bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE);
-       struct s3c_hsotg_ep *ep;
+       struct dwc2_hsotg_ep *ep;
        int ret;
        bool halted;
        u32 recip;
@@ -1074,7 +1074,7 @@ static int s3c_hsotg_process_req_feature(struct dwc2_hsotg *hsotg,
                                return -EINVAL;
 
                        hsotg->test_mode = wIndex >> 8;
-                       ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
+                       ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
                        if (ret) {
                                dev_err(hsotg->dev,
                                        "%s: failed to send reply\n", __func__);
@@ -1098,9 +1098,9 @@ static int s3c_hsotg_process_req_feature(struct dwc2_hsotg *hsotg,
                case USB_ENDPOINT_HALT:
                        halted = ep->halted;
 
-                       s3c_hsotg_ep_sethalt(&ep->ep, set);
+                       dwc2_hsotg_ep_sethalt(&ep->ep, set);
 
-                       ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
+                       ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
                        if (ret) {
                                dev_err(hsotg->dev,
                                        "%s: failed to send reply\n", __func__);
@@ -1134,7 +1134,7 @@ static int s3c_hsotg_process_req_feature(struct dwc2_hsotg *hsotg,
                                        restart = !list_empty(&ep->queue);
                                        if (restart) {
                                                hs_req = get_ep_head(ep);
-                                               s3c_hsotg_start_req(hsotg, ep,
+                                               dwc2_hsotg_start_req(hsotg, ep,
                                                                hs_req, false);
                                        }
                                }
@@ -1152,17 +1152,17 @@ static int s3c_hsotg_process_req_feature(struct dwc2_hsotg *hsotg,
        return 1;
 }
 
-static void s3c_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg);
+static void dwc2_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg);
 
 /**
- * s3c_hsotg_stall_ep0 - stall ep0
+ * dwc2_hsotg_stall_ep0 - stall ep0
  * @hsotg: The device state
  *
  * Set stall for ep0 as response for setup request.
  */
-static void s3c_hsotg_stall_ep0(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_stall_ep0(struct dwc2_hsotg *hsotg)
 {
-       struct s3c_hsotg_ep *ep0 = hsotg->eps_out[0];
+       struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
        u32 reg;
        u32 ctrl;
 
@@ -1187,11 +1187,11 @@ static void s3c_hsotg_stall_ep0(struct dwc2_hsotg *hsotg)
          * complete won't be called, so we enqueue
          * setup request here
          */
-        s3c_hsotg_enqueue_setup(hsotg);
+        dwc2_hsotg_enqueue_setup(hsotg);
 }
 
 /**
- * s3c_hsotg_process_control - process a control request
+ * dwc2_hsotg_process_control - process a control request
  * @hsotg: The device state
  * @ctrl: The control request received
  *
@@ -1199,10 +1199,10 @@ static void s3c_hsotg_stall_ep0(struct dwc2_hsotg *hsotg)
  * needs to work out what to do next (and whether to pass it on to the
  * gadget driver).
  */
-static void s3c_hsotg_process_control(struct dwc2_hsotg *hsotg,
+static void dwc2_hsotg_process_control(struct dwc2_hsotg *hsotg,
                                      struct usb_ctrlrequest *ctrl)
 {
-       struct s3c_hsotg_ep *ep0 = hsotg->eps_out[0];
+       struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
        int ret = 0;
        u32 dcfg;
 
@@ -1233,16 +1233,16 @@ static void s3c_hsotg_process_control(struct dwc2_hsotg *hsotg,
 
                        dev_info(hsotg->dev, "new address %d\n", ctrl->wValue);
 
-                       ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
+                       ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
                        return;
 
                case USB_REQ_GET_STATUS:
-                       ret = s3c_hsotg_process_req_status(hsotg, ctrl);
+                       ret = dwc2_hsotg_process_req_status(hsotg, ctrl);
                        break;
 
                case USB_REQ_CLEAR_FEATURE:
                case USB_REQ_SET_FEATURE:
-                       ret = s3c_hsotg_process_req_feature(hsotg, ctrl);
+                       ret = dwc2_hsotg_process_req_feature(hsotg, ctrl);
                        break;
                }
        }
@@ -1263,21 +1263,21 @@ static void s3c_hsotg_process_control(struct dwc2_hsotg *hsotg,
         */
 
        if (ret < 0)
-               s3c_hsotg_stall_ep0(hsotg);
+               dwc2_hsotg_stall_ep0(hsotg);
 }
 
 /**
- * s3c_hsotg_complete_setup - completion of a setup transfer
+ * dwc2_hsotg_complete_setup - completion of a setup transfer
  * @ep: The endpoint the request was on.
  * @req: The request completed.
  *
  * Called on completion of any requests the driver itself submitted for
  * EP0 setup packets
  */
-static void s3c_hsotg_complete_setup(struct usb_ep *ep,
+static void dwc2_hsotg_complete_setup(struct usb_ep *ep,
                                     struct usb_request *req)
 {
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hsotg = hs_ep->parent;
 
        if (req->status < 0) {
@@ -1287,23 +1287,23 @@ static void s3c_hsotg_complete_setup(struct usb_ep *ep,
 
        spin_lock(&hsotg->lock);
        if (req->actual == 0)
-               s3c_hsotg_enqueue_setup(hsotg);
+               dwc2_hsotg_enqueue_setup(hsotg);
        else
-               s3c_hsotg_process_control(hsotg, req->buf);
+               dwc2_hsotg_process_control(hsotg, req->buf);
        spin_unlock(&hsotg->lock);
 }
 
 /**
- * s3c_hsotg_enqueue_setup - start a request for EP0 packets
+ * dwc2_hsotg_enqueue_setup - start a request for EP0 packets
  * @hsotg: The device state.
  *
  * Enqueue a request on EP0 if necessary to received any SETUP packets
  * received from the host.
  */
-static void s3c_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg)
 {
        struct usb_request *req = hsotg->ctrl_req;
-       struct s3c_hsotg_req *hs_req = our_req(req);
+       struct dwc2_hsotg_req *hs_req = our_req(req);
        int ret;
 
        dev_dbg(hsotg->dev, "%s: queueing setup request\n", __func__);
@@ -1311,7 +1311,7 @@ static void s3c_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg)
        req->zero = 0;
        req->length = 8;
        req->buf = hsotg->ctrl_buff;
-       req->complete = s3c_hsotg_complete_setup;
+       req->complete = dwc2_hsotg_complete_setup;
 
        if (!list_empty(&hs_req->queue)) {
                dev_dbg(hsotg->dev, "%s already queued???\n", __func__);
@@ -1322,7 +1322,7 @@ static void s3c_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg)
        hsotg->eps_out[0]->send_zlp = 0;
        hsotg->ep0_state = DWC2_EP0_SETUP;
 
-       ret = s3c_hsotg_ep_queue(&hsotg->eps_out[0]->ep, req, GFP_ATOMIC);
+       ret = dwc2_hsotg_ep_queue(&hsotg->eps_out[0]->ep, req, GFP_ATOMIC);
        if (ret < 0) {
                dev_err(hsotg->dev, "%s: failed queue (%d)\n", __func__, ret);
                /*
@@ -1332,8 +1332,8 @@ static void s3c_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg)
        }
 }
 
-static void s3c_hsotg_program_zlp(struct dwc2_hsotg *hsotg,
-                                       struct s3c_hsotg_ep *hs_ep)
+static void dwc2_hsotg_program_zlp(struct dwc2_hsotg *hsotg,
+                                       struct dwc2_hsotg_ep *hs_ep)
 {
        u32 ctrl;
        u8 index = hs_ep->index;
@@ -1359,7 +1359,7 @@ static void s3c_hsotg_program_zlp(struct dwc2_hsotg *hsotg,
 }
 
 /**
- * s3c_hsotg_complete_request - complete a request given to us
+ * dwc2_hsotg_complete_request - complete a request given to us
  * @hsotg: The device state.
  * @hs_ep: The endpoint the request was on.
  * @hs_req: The request to complete.
@@ -1371,9 +1371,9 @@ static void s3c_hsotg_program_zlp(struct dwc2_hsotg *hsotg,
  *
  * Note, expects the ep to already be locked as appropriate.
  */
-static void s3c_hsotg_complete_request(struct dwc2_hsotg *hsotg,
-                                      struct s3c_hsotg_ep *hs_ep,
-                                      struct s3c_hsotg_req *hs_req,
+static void dwc2_hsotg_complete_request(struct dwc2_hsotg *hsotg,
+                                      struct dwc2_hsotg_ep *hs_ep,
+                                      struct dwc2_hsotg_req *hs_req,
                                       int result)
 {
        bool restart;
@@ -1394,13 +1394,13 @@ static void s3c_hsotg_complete_request(struct dwc2_hsotg *hsotg,
        if (hs_req->req.status == -EINPROGRESS)
                hs_req->req.status = result;
 
-       s3c_hsotg_handle_unaligned_buf_complete(hsotg, hs_ep, hs_req);
+       dwc2_hsotg_handle_unaligned_buf_complete(hsotg, hs_ep, hs_req);
 
        hs_ep->req = NULL;
        list_del_init(&hs_req->queue);
 
        if (using_dma(hsotg))
-               s3c_hsotg_unmap_dma(hsotg, hs_ep, hs_req);
+               dwc2_hsotg_unmap_dma(hsotg, hs_ep, hs_req);
 
        /*
         * call the complete request with the locks off, just in case the
@@ -1423,13 +1423,13 @@ static void s3c_hsotg_complete_request(struct dwc2_hsotg *hsotg,
                restart = !list_empty(&hs_ep->queue);
                if (restart) {
                        hs_req = get_ep_head(hs_ep);
-                       s3c_hsotg_start_req(hsotg, hs_ep, hs_req, false);
+                       dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, false);
                }
        }
 }
 
 /**
- * s3c_hsotg_rx_data - receive data from the FIFO for an endpoint
+ * dwc2_hsotg_rx_data - receive data from the FIFO for an endpoint
  * @hsotg: The device state.
  * @ep_idx: The endpoint index for the data
  * @size: The size of data in the fifo, in bytes
@@ -1438,10 +1438,10 @@ static void s3c_hsotg_complete_request(struct dwc2_hsotg *hsotg,
  * endpoint, so sort out whether we need to read the data into a request
  * that has been made for that endpoint.
  */
-static void s3c_hsotg_rx_data(struct dwc2_hsotg *hsotg, int ep_idx, int size)
+static void dwc2_hsotg_rx_data(struct dwc2_hsotg *hsotg, int ep_idx, int size)
 {
-       struct s3c_hsotg_ep *hs_ep = hsotg->eps_out[ep_idx];
-       struct s3c_hsotg_req *hs_req = hs_ep->req;
+       struct dwc2_hsotg_ep *hs_ep = hsotg->eps_out[ep_idx];
+       struct dwc2_hsotg_req *hs_req = hs_ep->req;
        void __iomem *fifo = hsotg->regs + EPFIFO(ep_idx);
        int to_read;
        int max_req;
@@ -1492,7 +1492,7 @@ static void s3c_hsotg_rx_data(struct dwc2_hsotg *hsotg, int ep_idx, int size)
 }
 
 /**
- * s3c_hsotg_ep0_zlp - send/receive zero-length packet on control endpoint
+ * dwc2_hsotg_ep0_zlp - send/receive zero-length packet on control endpoint
  * @hsotg: The device instance
  * @dir_in: If IN zlp
  *
@@ -1503,17 +1503,17 @@ static void s3c_hsotg_rx_data(struct dwc2_hsotg *hsotg, int ep_idx, int size)
  * currently believed that we do not need to wait for any space in
  * the TxFIFO.
  */
-static void s3c_hsotg_ep0_zlp(struct dwc2_hsotg *hsotg, bool dir_in)
+static void dwc2_hsotg_ep0_zlp(struct dwc2_hsotg *hsotg, bool dir_in)
 {
        /* eps_out[0] is used in both directions */
        hsotg->eps_out[0]->dir_in = dir_in;
        hsotg->ep0_state = dir_in ? DWC2_EP0_STATUS_IN : DWC2_EP0_STATUS_OUT;
 
-       s3c_hsotg_program_zlp(hsotg, hsotg->eps_out[0]);
+       dwc2_hsotg_program_zlp(hsotg, hsotg->eps_out[0]);
 }
 
 /**
- * s3c_hsotg_handle_outdone - handle receiving OutDone/SetupDone from RXFIFO
+ * dwc2_hsotg_handle_outdone - handle receiving OutDone/SetupDone from RXFIFO
  * @hsotg: The device instance
  * @epnum: The endpoint received from
  *
@@ -1521,11 +1521,11 @@ static void s3c_hsotg_ep0_zlp(struct dwc2_hsotg *hsotg, bool dir_in)
  * transfer for an OUT endpoint has been completed, either by a short
  * packet or by the finish of a transfer.
  */
-static void s3c_hsotg_handle_outdone(struct dwc2_hsotg *hsotg, int epnum)
+static void dwc2_hsotg_handle_outdone(struct dwc2_hsotg *hsotg, int epnum)
 {
        u32 epsize = readl(hsotg->regs + DOEPTSIZ(epnum));
-       struct s3c_hsotg_ep *hs_ep = hsotg->eps_out[epnum];
-       struct s3c_hsotg_req *hs_req = hs_ep->req;
+       struct dwc2_hsotg_ep *hs_ep = hsotg->eps_out[epnum];
+       struct dwc2_hsotg_req *hs_req = hs_ep->req;
        struct usb_request *req = &hs_req->req;
        unsigned size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
        int result = 0;
@@ -1537,8 +1537,8 @@ static void s3c_hsotg_handle_outdone(struct dwc2_hsotg *hsotg, int epnum)
 
        if (epnum == 0 && hsotg->ep0_state == DWC2_EP0_STATUS_OUT) {
                dev_dbg(hsotg->dev, "zlp packet received\n");
-               s3c_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
-               s3c_hsotg_enqueue_setup(hsotg);
+               dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
+               dwc2_hsotg_enqueue_setup(hsotg);
                return;
        }
 
@@ -1562,7 +1562,7 @@ static void s3c_hsotg_handle_outdone(struct dwc2_hsotg *hsotg, int epnum)
 
        /* if there is more request to do, schedule new transfer */
        if (req->actual < req->length && size_left == 0) {
-               s3c_hsotg_start_req(hsotg, hs_ep, hs_req, true);
+               dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, true);
                return;
        }
 
@@ -1578,20 +1578,20 @@ static void s3c_hsotg_handle_outdone(struct dwc2_hsotg *hsotg, int epnum)
 
        if (epnum == 0 && hsotg->ep0_state == DWC2_EP0_DATA_OUT) {
                /* Move to STATUS IN */
-               s3c_hsotg_ep0_zlp(hsotg, true);
+               dwc2_hsotg_ep0_zlp(hsotg, true);
                return;
        }
 
-       s3c_hsotg_complete_request(hsotg, hs_ep, hs_req, result);
+       dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, result);
 }
 
 /**
- * s3c_hsotg_read_frameno - read current frame number
+ * dwc2_hsotg_read_frameno - read current frame number
  * @hsotg: The device instance
  *
  * Return the current frame number
  */
-static u32 s3c_hsotg_read_frameno(struct dwc2_hsotg *hsotg)
+static u32 dwc2_hsotg_read_frameno(struct dwc2_hsotg *hsotg)
 {
        u32 dsts;
 
@@ -1603,7 +1603,7 @@ static u32 s3c_hsotg_read_frameno(struct dwc2_hsotg *hsotg)
 }
 
 /**
- * s3c_hsotg_handle_rx - RX FIFO has data
+ * dwc2_hsotg_handle_rx - RX FIFO has data
  * @hsotg: The device instance
  *
  * The IRQ handler has detected that the RX FIFO has some data in it
@@ -1618,7 +1618,7 @@ static u32 s3c_hsotg_read_frameno(struct dwc2_hsotg *hsotg)
  * as the actual data should be sent to the memory directly and we turn
  * on the completion interrupts to get notifications of transfer completion.
  */
-static void s3c_hsotg_handle_rx(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_handle_rx(struct dwc2_hsotg *hsotg)
 {
        u32 grxstsr = readl(hsotg->regs + GRXSTSP);
        u32 epnum, status, size;
@@ -1641,55 +1641,55 @@ static void s3c_hsotg_handle_rx(struct dwc2_hsotg *hsotg)
 
        case GRXSTS_PKTSTS_OUTDONE:
                dev_dbg(hsotg->dev, "OutDone (Frame=0x%08x)\n",
-                       s3c_hsotg_read_frameno(hsotg));
+                       dwc2_hsotg_read_frameno(hsotg));
 
                if (!using_dma(hsotg))
-                       s3c_hsotg_handle_outdone(hsotg, epnum);
+                       dwc2_hsotg_handle_outdone(hsotg, epnum);
                break;
 
        case GRXSTS_PKTSTS_SETUPDONE:
                dev_dbg(hsotg->dev,
                        "SetupDone (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
-                       s3c_hsotg_read_frameno(hsotg),
+                       dwc2_hsotg_read_frameno(hsotg),
                        readl(hsotg->regs + DOEPCTL(0)));
                /*
-                * Call s3c_hsotg_handle_outdone here if it was not called from
+                * Call dwc2_hsotg_handle_outdone here if it was not called from
                 * GRXSTS_PKTSTS_OUTDONE. That is, if the core didn't
                 * generate GRXSTS_PKTSTS_OUTDONE for setup packet.
                 */
                if (hsotg->ep0_state == DWC2_EP0_SETUP)
-                       s3c_hsotg_handle_outdone(hsotg, epnum);
+                       dwc2_hsotg_handle_outdone(hsotg, epnum);
                break;
 
        case GRXSTS_PKTSTS_OUTRX:
-               s3c_hsotg_rx_data(hsotg, epnum, size);
+               dwc2_hsotg_rx_data(hsotg, epnum, size);
                break;
 
        case GRXSTS_PKTSTS_SETUPRX:
                dev_dbg(hsotg->dev,
                        "SetupRX (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
-                       s3c_hsotg_read_frameno(hsotg),
+                       dwc2_hsotg_read_frameno(hsotg),
                        readl(hsotg->regs + DOEPCTL(0)));
 
                WARN_ON(hsotg->ep0_state != DWC2_EP0_SETUP);
 
-               s3c_hsotg_rx_data(hsotg, epnum, size);
+               dwc2_hsotg_rx_data(hsotg, epnum, size);
                break;
 
        default:
                dev_warn(hsotg->dev, "%s: unknown status %08x\n",
                         __func__, grxstsr);
 
-               s3c_hsotg_dump(hsotg);
+               dwc2_hsotg_dump(hsotg);
                break;
        }
 }
 
 /**
- * s3c_hsotg_ep0_mps - turn max packet size into register setting
+ * dwc2_hsotg_ep0_mps - turn max packet size into register setting
  * @mps: The maximum packet size in bytes.
  */
-static u32 s3c_hsotg_ep0_mps(unsigned int mps)
+static u32 dwc2_hsotg_ep0_mps(unsigned int mps)
 {
        switch (mps) {
        case 64:
@@ -1708,7 +1708,7 @@ static u32 s3c_hsotg_ep0_mps(unsigned int mps)
 }
 
 /**
- * s3c_hsotg_set_ep_maxpacket - set endpoint's max-packet field
+ * dwc2_hsotg_set_ep_maxpacket - set endpoint's max-packet field
  * @hsotg: The driver state.
  * @ep: The index number of the endpoint
  * @mps: The maximum packet size in bytes
@@ -1716,10 +1716,10 @@ static u32 s3c_hsotg_ep0_mps(unsigned int mps)
  * Configure the maximum packet size for the given endpoint, updating
  * the hardware control registers to reflect this.
  */
-static void s3c_hsotg_set_ep_maxpacket(struct dwc2_hsotg *hsotg,
+static void dwc2_hsotg_set_ep_maxpacket(struct dwc2_hsotg *hsotg,
                        unsigned int ep, unsigned int mps, unsigned int dir_in)
 {
-       struct s3c_hsotg_ep *hs_ep;
+       struct dwc2_hsotg_ep *hs_ep;
        void __iomem *regs = hsotg->regs;
        u32 mpsval;
        u32 mcval;
@@ -1731,7 +1731,7 @@ static void s3c_hsotg_set_ep_maxpacket(struct dwc2_hsotg *hsotg,
 
        if (ep == 0) {
                /* EP0 is a special case */
-               mpsval = s3c_hsotg_ep0_mps(mps);
+               mpsval = dwc2_hsotg_ep0_mps(mps);
                if (mpsval > 3)
                        goto bad_mps;
                hs_ep->ep.maxpacket = mps;
@@ -1766,11 +1766,11 @@ bad_mps:
 }
 
 /**
- * s3c_hsotg_txfifo_flush - flush Tx FIFO
+ * dwc2_hsotg_txfifo_flush - flush Tx FIFO
  * @hsotg: The driver state
  * @idx: The index for the endpoint (0..15)
  */
-static void s3c_hsotg_txfifo_flush(struct dwc2_hsotg *hsotg, unsigned int idx)
+static void dwc2_hsotg_txfifo_flush(struct dwc2_hsotg *hsotg, unsigned int idx)
 {
        int timeout;
        int val;
@@ -1799,17 +1799,17 @@ static void s3c_hsotg_txfifo_flush(struct dwc2_hsotg *hsotg, unsigned int idx)
 }
 
 /**
- * s3c_hsotg_trytx - check to see if anything needs transmitting
+ * dwc2_hsotg_trytx - check to see if anything needs transmitting
  * @hsotg: The driver state
  * @hs_ep: The driver endpoint to check.
  *
  * Check to see if there is a request that has data to send, and if so
  * make an attempt to write data into the FIFO.
  */
-static int s3c_hsotg_trytx(struct dwc2_hsotg *hsotg,
-                          struct s3c_hsotg_ep *hs_ep)
+static int dwc2_hsotg_trytx(struct dwc2_hsotg *hsotg,
+                          struct dwc2_hsotg_ep *hs_ep)
 {
-       struct s3c_hsotg_req *hs_req = hs_ep->req;
+       struct dwc2_hsotg_req *hs_req = hs_ep->req;
 
        if (!hs_ep->dir_in || !hs_req) {
                /**
@@ -1817,7 +1817,7 @@ static int s3c_hsotg_trytx(struct dwc2_hsotg *hsotg,
                 * for endpoints, excepting ep0
                 */
                if (hs_ep->index != 0)
-                       s3c_hsotg_ctrl_epint(hsotg, hs_ep->index,
+                       dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index,
                                             hs_ep->dir_in, 0);
                return 0;
        }
@@ -1825,24 +1825,24 @@ static int s3c_hsotg_trytx(struct dwc2_hsotg *hsotg,
        if (hs_req->req.actual < hs_req->req.length) {
                dev_dbg(hsotg->dev, "trying to write more for ep%d\n",
                        hs_ep->index);
-               return s3c_hsotg_write_fifo(hsotg, hs_ep, hs_req);
+               return dwc2_hsotg_write_fifo(hsotg, hs_ep, hs_req);
        }
 
        return 0;
 }
 
 /**
- * s3c_hsotg_complete_in - complete IN transfer
+ * dwc2_hsotg_complete_in - complete IN transfer
  * @hsotg: The device state.
  * @hs_ep: The endpoint that has just completed.
  *
  * An IN transfer has been completed, update the transfer's state and then
  * call the relevant completion routines.
  */
-static void s3c_hsotg_complete_in(struct dwc2_hsotg *hsotg,
-                                 struct s3c_hsotg_ep *hs_ep)
+static void dwc2_hsotg_complete_in(struct dwc2_hsotg *hsotg,
+                                 struct dwc2_hsotg_ep *hs_ep)
 {
-       struct s3c_hsotg_req *hs_req = hs_ep->req;
+       struct dwc2_hsotg_req *hs_req = hs_ep->req;
        u32 epsize = readl(hsotg->regs + DIEPTSIZ(hs_ep->index));
        int size_left, size_done;
 
@@ -1854,19 +1854,19 @@ static void s3c_hsotg_complete_in(struct dwc2_hsotg *hsotg,
        /* Finish ZLP handling for IN EP0 transactions */
        if (hs_ep->index == 0 && hsotg->ep0_state == DWC2_EP0_STATUS_IN) {
                dev_dbg(hsotg->dev, "zlp packet sent\n");
-               s3c_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
+               dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
                if (hsotg->test_mode) {
                        int ret;
 
-                       ret = s3c_hsotg_set_test_mode(hsotg, hsotg->test_mode);
+                       ret = dwc2_hsotg_set_test_mode(hsotg, hsotg->test_mode);
                        if (ret < 0) {
                                dev_dbg(hsotg->dev, "Invalid Test #%d\n",
                                                hsotg->test_mode);
-                               s3c_hsotg_stall_ep0(hsotg);
+                               dwc2_hsotg_stall_ep0(hsotg);
                                return;
                        }
                }
-               s3c_hsotg_enqueue_setup(hsotg);
+               dwc2_hsotg_enqueue_setup(hsotg);
                return;
        }
 
@@ -1895,13 +1895,13 @@ static void s3c_hsotg_complete_in(struct dwc2_hsotg *hsotg,
 
        if (!size_left && hs_req->req.actual < hs_req->req.length) {
                dev_dbg(hsotg->dev, "%s trying more for req...\n", __func__);
-               s3c_hsotg_start_req(hsotg, hs_ep, hs_req, true);
+               dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, true);
                return;
        }
 
        /* Zlp for all endpoints, for ep0 only in DATA IN stage */
        if (hs_ep->send_zlp) {
-               s3c_hsotg_program_zlp(hsotg, hs_ep);
+               dwc2_hsotg_program_zlp(hsotg, hs_ep);
                hs_ep->send_zlp = 0;
                /* transfer will be completed on next complete interrupt */
                return;
@@ -1909,25 +1909,25 @@ static void s3c_hsotg_complete_in(struct dwc2_hsotg *hsotg,
 
        if (hs_ep->index == 0 && hsotg->ep0_state == DWC2_EP0_DATA_IN) {
                /* Move to STATUS OUT */
-               s3c_hsotg_ep0_zlp(hsotg, false);
+               dwc2_hsotg_ep0_zlp(hsotg, false);
                return;
        }
 
-       s3c_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
+       dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
 }
 
 /**
- * s3c_hsotg_epint - handle an in/out endpoint interrupt
+ * dwc2_hsotg_epint - handle an in/out endpoint interrupt
  * @hsotg: The driver state
  * @idx: The index for the endpoint (0..15)
  * @dir_in: Set if this is an IN endpoint
  *
  * Process and clear any interrupt pending for an individual endpoint
  */
-static void s3c_hsotg_epint(struct dwc2_hsotg *hsotg, unsigned int idx,
+static void dwc2_hsotg_epint(struct dwc2_hsotg *hsotg, unsigned int idx,
                            int dir_in)
 {
-       struct s3c_hsotg_ep *hs_ep = index_to_ep(hsotg, idx, dir_in);
+       struct dwc2_hsotg_ep *hs_ep = index_to_ep(hsotg, idx, dir_in);
        u32 epint_reg = dir_in ? DIEPINT(idx) : DOEPINT(idx);
        u32 epctl_reg = dir_in ? DIEPCTL(idx) : DOEPCTL(idx);
        u32 epsiz_reg = dir_in ? DIEPTSIZ(idx) : DOEPTSIZ(idx);
@@ -1972,17 +1972,17 @@ static void s3c_hsotg_epint(struct dwc2_hsotg *hsotg, unsigned int idx,
                 * at completing IN requests here
                 */
                if (dir_in) {
-                       s3c_hsotg_complete_in(hsotg, hs_ep);
+                       dwc2_hsotg_complete_in(hsotg, hs_ep);
 
                        if (idx == 0 && !hs_ep->req)
-                               s3c_hsotg_enqueue_setup(hsotg);
+                               dwc2_hsotg_enqueue_setup(hsotg);
                } else if (using_dma(hsotg)) {
                        /*
                         * We're using DMA, we need to fire an OutDone here
                         * as we ignore the RXFIFO.
                         */
 
-                       s3c_hsotg_handle_outdone(hsotg, idx);
+                       dwc2_hsotg_handle_outdone(hsotg, idx);
                }
        }
 
@@ -1992,7 +1992,7 @@ static void s3c_hsotg_epint(struct dwc2_hsotg *hsotg, unsigned int idx,
                if (dir_in) {
                        int epctl = readl(hsotg->regs + epctl_reg);
 
-                       s3c_hsotg_txfifo_flush(hsotg, hs_ep->fifo_index);
+                       dwc2_hsotg_txfifo_flush(hsotg, hs_ep->fifo_index);
 
                        if ((epctl & DXEPCTL_STALL) &&
                                (epctl & DXEPCTL_EPTYPE_BULK)) {
@@ -2021,7 +2021,7 @@ static void s3c_hsotg_epint(struct dwc2_hsotg *hsotg, unsigned int idx,
                        if (dir_in)
                                WARN_ON_ONCE(1);
                        else
-                               s3c_hsotg_handle_outdone(hsotg, 0);
+                               dwc2_hsotg_handle_outdone(hsotg, 0);
                }
        }
 
@@ -2047,19 +2047,19 @@ static void s3c_hsotg_epint(struct dwc2_hsotg *hsotg, unsigned int idx,
                        dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n",
                                __func__, idx);
                        if (!using_dma(hsotg))
-                               s3c_hsotg_trytx(hsotg, hs_ep);
+                               dwc2_hsotg_trytx(hsotg, hs_ep);
                }
        }
 }
 
 /**
- * s3c_hsotg_irq_enumdone - Handle EnumDone interrupt (enumeration done)
+ * dwc2_hsotg_irq_enumdone - Handle EnumDone interrupt (enumeration done)
  * @hsotg: The device state.
  *
  * Handle updating the device settings after the enumeration phase has
  * been completed.
  */
-static void s3c_hsotg_irq_enumdone(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_irq_enumdone(struct dwc2_hsotg *hsotg)
 {
        u32 dsts = readl(hsotg->regs + DSTS);
        int ep0_mps = 0, ep_mps = 8;
@@ -2113,19 +2113,19 @@ static void s3c_hsotg_irq_enumdone(struct dwc2_hsotg *hsotg)
        if (ep0_mps) {
                int i;
                /* Initialize ep0 for both in and out directions */
-               s3c_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps, 1);
-               s3c_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps, 0);
+               dwc2_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps, 1);
+               dwc2_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps, 0);
                for (i = 1; i < hsotg->num_of_eps; i++) {
                        if (hsotg->eps_in[i])
-                               s3c_hsotg_set_ep_maxpacket(hsotg, i, ep_mps, 1);
+                               dwc2_hsotg_set_ep_maxpacket(hsotg, i, ep_mps, 1);
                        if (hsotg->eps_out[i])
-                               s3c_hsotg_set_ep_maxpacket(hsotg, i, ep_mps, 0);
+                               dwc2_hsotg_set_ep_maxpacket(hsotg, i, ep_mps, 0);
                }
        }
 
        /* ensure after enumeration our EP0 is active */
 
-       s3c_hsotg_enqueue_setup(hsotg);
+       dwc2_hsotg_enqueue_setup(hsotg);
 
        dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
                readl(hsotg->regs + DIEPCTL0),
@@ -2142,34 +2142,34 @@ static void s3c_hsotg_irq_enumdone(struct dwc2_hsotg *hsotg)
  * completed with the given result code.
  */
 static void kill_all_requests(struct dwc2_hsotg *hsotg,
-                             struct s3c_hsotg_ep *ep,
+                             struct dwc2_hsotg_ep *ep,
                              int result)
 {
-       struct s3c_hsotg_req *req, *treq;
+       struct dwc2_hsotg_req *req, *treq;
        unsigned size;
 
        ep->req = NULL;
 
        list_for_each_entry_safe(req, treq, &ep->queue, queue)
-               s3c_hsotg_complete_request(hsotg, ep, req,
+               dwc2_hsotg_complete_request(hsotg, ep, req,
                                           result);
 
        if (!hsotg->dedicated_fifos)
                return;
        size = (readl(hsotg->regs + DTXFSTS(ep->index)) & 0xffff) * 4;
        if (size < ep->fifo_size)
-               s3c_hsotg_txfifo_flush(hsotg, ep->fifo_index);
+               dwc2_hsotg_txfifo_flush(hsotg, ep->fifo_index);
 }
 
 /**
- * s3c_hsotg_disconnect - disconnect service
+ * dwc2_hsotg_disconnect - disconnect service
  * @hsotg: The device state.
  *
  * The device has been disconnected. Remove all current
  * transactions and signal the gadget driver that this
  * has happened.
  */
-void s3c_hsotg_disconnect(struct dwc2_hsotg *hsotg)
+void dwc2_hsotg_disconnect(struct dwc2_hsotg *hsotg)
 {
        unsigned ep;
 
@@ -2192,13 +2192,13 @@ void s3c_hsotg_disconnect(struct dwc2_hsotg *hsotg)
 }
 
 /**
- * s3c_hsotg_irq_fifoempty - TX FIFO empty interrupt handler
+ * dwc2_hsotg_irq_fifoempty - TX FIFO empty interrupt handler
  * @hsotg: The device state:
  * @periodic: True if this is a periodic FIFO interrupt
  */
-static void s3c_hsotg_irq_fifoempty(struct dwc2_hsotg *hsotg, bool periodic)
+static void dwc2_hsotg_irq_fifoempty(struct dwc2_hsotg *hsotg, bool periodic)
 {
-       struct s3c_hsotg_ep *ep;
+       struct dwc2_hsotg_ep *ep;
        int epno, ret;
 
        /* look through for any more data to transmit */
@@ -2215,7 +2215,7 @@ static void s3c_hsotg_irq_fifoempty(struct dwc2_hsotg *hsotg, bool periodic)
                    (!periodic && ep->periodic))
                        continue;
 
-               ret = s3c_hsotg_trytx(hsotg, ep);
+               ret = dwc2_hsotg_trytx(hsotg, ep);
                if (ret < 0)
                        break;
        }
@@ -2227,12 +2227,12 @@ static void s3c_hsotg_irq_fifoempty(struct dwc2_hsotg *hsotg, bool periodic)
                        GINTSTS_RXFLVL)
 
 /**
- * s3c_hsotg_corereset - issue softreset to the core
+ * dwc2_hsotg_corereset - issue softreset to the core
  * @hsotg: The device state
  *
  * Issue a soft reset to the core, and await the core finishing it.
  */
-static int s3c_hsotg_corereset(struct dwc2_hsotg *hsotg)
+static int dwc2_hsotg_corereset(struct dwc2_hsotg *hsotg)
 {
        int timeout;
        u32 grstctl;
@@ -2275,18 +2275,18 @@ static int s3c_hsotg_corereset(struct dwc2_hsotg *hsotg)
 }
 
 /**
- * s3c_hsotg_core_init - issue softreset to the core
+ * dwc2_hsotg_core_init - issue softreset to the core
  * @hsotg: The device state
  *
  * Issue a soft reset to the core, and await the core finishing it.
  */
-void s3c_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
+void dwc2_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
                                                bool is_usb_reset)
 {
        u32 val;
 
        if (!is_usb_reset)
-               s3c_hsotg_corereset(hsotg);
+               dwc2_hsotg_corereset(hsotg);
 
        /*
         * we must now enable ep0 ready for host detection and then
@@ -2298,7 +2298,7 @@ void s3c_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
        writel(hsotg->phyif | GUSBCFG_TOUTCAL(7) |
               (val << GUSBCFG_USBTRDTIM_SHIFT), hsotg->regs + GUSBCFG);
 
-       s3c_hsotg_init_fifo(hsotg);
+       dwc2_hsotg_init_fifo(hsotg);
 
        if (!is_usb_reset)
                __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
@@ -2359,7 +2359,7 @@ void s3c_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
                readl(hsotg->regs + DOEPCTL0));
 
        /* enable in and out endpoint interrupts */
-       s3c_hsotg_en_gsint(hsotg, GINTSTS_OEPINT | GINTSTS_IEPINT);
+       dwc2_hsotg_en_gsint(hsotg, GINTSTS_OEPINT | GINTSTS_IEPINT);
 
        /*
         * Enable the RXFIFO when in slave mode, as this is how we collect
@@ -2367,11 +2367,11 @@ void s3c_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
         * things we cannot process, so do not use it.
         */
        if (!using_dma(hsotg))
-               s3c_hsotg_en_gsint(hsotg, GINTSTS_RXFLVL);
+               dwc2_hsotg_en_gsint(hsotg, GINTSTS_RXFLVL);
 
        /* Enable interrupts for EP0 in and out */
-       s3c_hsotg_ctrl_epint(hsotg, 0, 0, 1);
-       s3c_hsotg_ctrl_epint(hsotg, 0, 1, 1);
+       dwc2_hsotg_ctrl_epint(hsotg, 0, 0, 1);
+       dwc2_hsotg_ctrl_epint(hsotg, 0, 1, 1);
 
        if (!is_usb_reset) {
                __orr32(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
@@ -2390,16 +2390,16 @@ void s3c_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
        writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
               DXEPTSIZ_XFERSIZE(8), hsotg->regs + DOEPTSIZ0);
 
-       writel(s3c_hsotg_ep0_mps(hsotg->eps_out[0]->ep.maxpacket) |
+       writel(dwc2_hsotg_ep0_mps(hsotg->eps_out[0]->ep.maxpacket) |
               DXEPCTL_CNAK | DXEPCTL_EPENA |
               DXEPCTL_USBACTEP,
               hsotg->regs + DOEPCTL0);
 
        /* enable, but don't activate EP0in */
-       writel(s3c_hsotg_ep0_mps(hsotg->eps_out[0]->ep.maxpacket) |
+       writel(dwc2_hsotg_ep0_mps(hsotg->eps_out[0]->ep.maxpacket) |
               DXEPCTL_USBACTEP, hsotg->regs + DIEPCTL0);
 
-       s3c_hsotg_enqueue_setup(hsotg);
+       dwc2_hsotg_enqueue_setup(hsotg);
 
        dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
                readl(hsotg->regs + DIEPCTL0),
@@ -2417,24 +2417,24 @@ void s3c_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
        hsotg->last_rst = jiffies;
 }
 
-static void s3c_hsotg_core_disconnect(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_core_disconnect(struct dwc2_hsotg *hsotg)
 {
        /* set the soft-disconnect bit */
        __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
 }
 
-void s3c_hsotg_core_connect(struct dwc2_hsotg *hsotg)
+void dwc2_hsotg_core_connect(struct dwc2_hsotg *hsotg)
 {
        /* remove the soft-disconnect and let's go */
        __bic32(hsotg->regs + DCTL, DCTL_SFTDISCON);
 }
 
 /**
- * s3c_hsotg_irq - handle device interrupt
+ * dwc2_hsotg_irq - handle device interrupt
  * @irq: The IRQ number triggered
  * @pw: The pw value when registered the handler.
  */
-static irqreturn_t s3c_hsotg_irq(int irq, void *pw)
+static irqreturn_t dwc2_hsotg_irq(int irq, void *pw)
 {
        struct dwc2_hsotg *hsotg = pw;
        int retry_count = 8;
@@ -2454,7 +2454,7 @@ irq_retry:
        if (gintsts & GINTSTS_ENUMDONE) {
                writel(GINTSTS_ENUMDONE, hsotg->regs + GINTSTS);
 
-               s3c_hsotg_irq_enumdone(hsotg);
+               dwc2_hsotg_irq_enumdone(hsotg);
        }
 
        if (gintsts & (GINTSTS_OEPINT | GINTSTS_IEPINT)) {
@@ -2472,13 +2472,13 @@ irq_retry:
                for (ep = 0; ep < hsotg->num_of_eps && daint_out;
                                                ep++, daint_out >>= 1) {
                        if (daint_out & 1)
-                               s3c_hsotg_epint(hsotg, ep, 0);
+                               dwc2_hsotg_epint(hsotg, ep, 0);
                }
 
                for (ep = 0; ep < hsotg->num_of_eps  && daint_in;
                                                ep++, daint_in >>= 1) {
                        if (daint_in & 1)
-                               s3c_hsotg_epint(hsotg, ep, 1);
+                               dwc2_hsotg_epint(hsotg, ep, 1);
                }
        }
 
@@ -2505,7 +2505,7 @@ irq_retry:
                writel(GINTSTS_USBRST, hsotg->regs + GINTSTS);
 
                /* Report disconnection if it is not already done. */
-               s3c_hsotg_disconnect(hsotg);
+               dwc2_hsotg_disconnect(hsotg);
 
                if (usb_status & GOTGCTL_BSESVLD) {
                        if (time_after(jiffies, hsotg->last_rst +
@@ -2515,7 +2515,7 @@ irq_retry:
                                                          -ECONNRESET);
 
                                hsotg->lx_state = DWC2_L0;
-                               s3c_hsotg_core_init_disconnected(hsotg, true);
+                               dwc2_hsotg_core_init_disconnected(hsotg, true);
                        }
                }
        }
@@ -2531,8 +2531,8 @@ irq_retry:
                 * it needs re-enabling
                 */
 
-               s3c_hsotg_disable_gsint(hsotg, GINTSTS_NPTXFEMP);
-               s3c_hsotg_irq_fifoempty(hsotg, false);
+               dwc2_hsotg_disable_gsint(hsotg, GINTSTS_NPTXFEMP);
+               dwc2_hsotg_irq_fifoempty(hsotg, false);
        }
 
        if (gintsts & GINTSTS_PTXFEMP) {
@@ -2540,18 +2540,18 @@ irq_retry:
 
                /* See note in GINTSTS_NPTxFEmp */
 
-               s3c_hsotg_disable_gsint(hsotg, GINTSTS_PTXFEMP);
-               s3c_hsotg_irq_fifoempty(hsotg, true);
+               dwc2_hsotg_disable_gsint(hsotg, GINTSTS_PTXFEMP);
+               dwc2_hsotg_irq_fifoempty(hsotg, true);
        }
 
        if (gintsts & GINTSTS_RXFLVL) {
                /*
                 * note, since GINTSTS_RxFLvl doubles as FIFO-not-empty,
-                * we need to retry s3c_hsotg_handle_rx if this is still
+                * we need to retry dwc2_hsotg_handle_rx if this is still
                 * set.
                 */
 
-               s3c_hsotg_handle_rx(hsotg);
+               dwc2_hsotg_handle_rx(hsotg);
        }
 
        if (gintsts & GINTSTS_ERLYSUSP) {
@@ -2570,7 +2570,7 @@ irq_retry:
 
                writel(DCTL_CGOUTNAK, hsotg->regs + DCTL);
 
-               s3c_hsotg_dump(hsotg);
+               dwc2_hsotg_dump(hsotg);
        }
 
        if (gintsts & GINTSTS_GINNAKEFF) {
@@ -2578,7 +2578,7 @@ irq_retry:
 
                writel(DCTL_CGNPINNAK, hsotg->regs + DCTL);
 
-               s3c_hsotg_dump(hsotg);
+               dwc2_hsotg_dump(hsotg);
        }
 
        /*
@@ -2595,16 +2595,16 @@ irq_retry:
 }
 
 /**
- * s3c_hsotg_ep_enable - enable the given endpoint
+ * dwc2_hsotg_ep_enable - enable the given endpoint
  * @ep: The USB endpint to configure
  * @desc: The USB endpoint descriptor to configure with.
  *
  * This is called from the USB gadget code's usb_ep_enable().
  */
-static int s3c_hsotg_ep_enable(struct usb_ep *ep,
+static int dwc2_hsotg_ep_enable(struct usb_ep *ep,
                               const struct usb_endpoint_descriptor *desc)
 {
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hsotg = hs_ep->parent;
        unsigned long flags;
        unsigned int index = hs_ep->index;
@@ -2631,7 +2631,7 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
 
        mps = usb_endpoint_maxp(desc);
 
-       /* note, we handle this here instead of s3c_hsotg_set_ep_maxpacket */
+       /* note, we handle this here instead of dwc2_hsotg_set_ep_maxpacket */
 
        epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
        epctrl = readl(hsotg->regs + epctrl_reg);
@@ -2660,7 +2660,7 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
        epctrl |= DXEPCTL_SNAK;
 
        /* update the endpoint state */
-       s3c_hsotg_set_ep_maxpacket(hsotg, hs_ep->index, mps, dir_in);
+       dwc2_hsotg_set_ep_maxpacket(hsotg, hs_ep->index, mps, dir_in);
 
        /* default, set to non-periodic */
        hs_ep->isochronous = 0;
@@ -2752,7 +2752,7 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
                __func__, readl(hsotg->regs + epctrl_reg));
 
        /* enable the endpoint interrupt */
-       s3c_hsotg_ctrl_epint(hsotg, index, dir_in, 1);
+       dwc2_hsotg_ctrl_epint(hsotg, index, dir_in, 1);
 
 error:
        spin_unlock_irqrestore(&hsotg->lock, flags);
@@ -2760,12 +2760,12 @@ error:
 }
 
 /**
- * s3c_hsotg_ep_disable - disable given endpoint
+ * dwc2_hsotg_ep_disable - disable given endpoint
  * @ep: The endpoint to disable.
  */
-static int s3c_hsotg_ep_disable(struct usb_ep *ep)
+static int dwc2_hsotg_ep_disable(struct usb_ep *ep)
 {
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hsotg = hs_ep->parent;
        int dir_in = hs_ep->dir_in;
        int index = hs_ep->index;
@@ -2797,7 +2797,7 @@ static int s3c_hsotg_ep_disable(struct usb_ep *ep)
        writel(ctrl, hsotg->regs + epctrl_reg);
 
        /* disable endpoint interrupts */
-       s3c_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 0);
+       dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 0);
 
        /* terminate all requests with shutdown */
        kill_all_requests(hsotg, hs_ep, -ESHUTDOWN);
@@ -2811,9 +2811,9 @@ static int s3c_hsotg_ep_disable(struct usb_ep *ep)
  * @ep: The endpoint to check.
  * @test: The request to test if it is on the endpoint.
  */
-static bool on_list(struct s3c_hsotg_ep *ep, struct s3c_hsotg_req *test)
+static bool on_list(struct dwc2_hsotg_ep *ep, struct dwc2_hsotg_req *test)
 {
-       struct s3c_hsotg_req *req, *treq;
+       struct dwc2_hsotg_req *req, *treq;
 
        list_for_each_entry_safe(req, treq, &ep->queue, queue) {
                if (req == test)
@@ -2824,14 +2824,14 @@ static bool on_list(struct s3c_hsotg_ep *ep, struct s3c_hsotg_req *test)
 }
 
 /**
- * s3c_hsotg_ep_dequeue - dequeue given endpoint
+ * dwc2_hsotg_ep_dequeue - dequeue given endpoint
  * @ep: The endpoint to dequeue.
  * @req: The request to be removed from a queue.
  */
-static int s3c_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
+static int dwc2_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
 {
-       struct s3c_hsotg_req *hs_req = our_req(req);
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_req *hs_req = our_req(req);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hs = hs_ep->parent;
        unsigned long flags;
 
@@ -2844,20 +2844,20 @@ static int s3c_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
                return -EINVAL;
        }
 
-       s3c_hsotg_complete_request(hs, hs_ep, hs_req, -ECONNRESET);
+       dwc2_hsotg_complete_request(hs, hs_ep, hs_req, -ECONNRESET);
        spin_unlock_irqrestore(&hs->lock, flags);
 
        return 0;
 }
 
 /**
- * s3c_hsotg_ep_sethalt - set halt on a given endpoint
+ * dwc2_hsotg_ep_sethalt - set halt on a given endpoint
  * @ep: The endpoint to set halt.
  * @value: Set or unset the halt.
  */
-static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
+static int dwc2_hsotg_ep_sethalt(struct usb_ep *ep, int value)
 {
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hs = hs_ep->parent;
        int index = hs_ep->index;
        u32 epreg;
@@ -2868,7 +2868,7 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
 
        if (index == 0) {
                if (value)
-                       s3c_hsotg_stall_ep0(hs);
+                       dwc2_hsotg_stall_ep0(hs);
                else
                        dev_warn(hs->dev,
                                 "%s: can't clear halt on ep0\n", __func__);
@@ -2914,43 +2914,43 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
 }
 
 /**
- * s3c_hsotg_ep_sethalt_lock - set halt on a given endpoint with lock held
+ * dwc2_hsotg_ep_sethalt_lock - set halt on a given endpoint with lock held
  * @ep: The endpoint to set halt.
  * @value: Set or unset the halt.
  */
-static int s3c_hsotg_ep_sethalt_lock(struct usb_ep *ep, int value)
+static int dwc2_hsotg_ep_sethalt_lock(struct usb_ep *ep, int value)
 {
-       struct s3c_hsotg_ep *hs_ep = our_ep(ep);
+       struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
        struct dwc2_hsotg *hs = hs_ep->parent;
        unsigned long flags = 0;
        int ret = 0;
 
        spin_lock_irqsave(&hs->lock, flags);
-       ret = s3c_hsotg_ep_sethalt(ep, value);
+       ret = dwc2_hsotg_ep_sethalt(ep, value);
        spin_unlock_irqrestore(&hs->lock, flags);
 
        return ret;
 }
 
-static struct usb_ep_ops s3c_hsotg_ep_ops = {
-       .enable         = s3c_hsotg_ep_enable,
-       .disable        = s3c_hsotg_ep_disable,
-       .alloc_request  = s3c_hsotg_ep_alloc_request,
-       .free_request   = s3c_hsotg_ep_free_request,
-       .queue          = s3c_hsotg_ep_queue_lock,
-       .dequeue        = s3c_hsotg_ep_dequeue,
-       .set_halt       = s3c_hsotg_ep_sethalt_lock,
+static struct usb_ep_ops dwc2_hsotg_ep_ops = {
+       .enable         = dwc2_hsotg_ep_enable,
+       .disable        = dwc2_hsotg_ep_disable,
+       .alloc_request  = dwc2_hsotg_ep_alloc_request,
+       .free_request   = dwc2_hsotg_ep_free_request,
+       .queue          = dwc2_hsotg_ep_queue_lock,
+       .dequeue        = dwc2_hsotg_ep_dequeue,
+       .set_halt       = dwc2_hsotg_ep_sethalt_lock,
        /* note, don't believe we have any call for the fifo routines */
 };
 
 /**
- * s3c_hsotg_phy_enable - enable platform phy dev
+ * dwc2_hsotg_phy_enable - enable platform phy dev
  * @hsotg: The driver state
  *
  * A wrapper for platform code responsible for controlling
  * low-level USB code
  */
-static void s3c_hsotg_phy_enable(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_phy_enable(struct dwc2_hsotg *hsotg)
 {
        struct platform_device *pdev = to_platform_device(hsotg->dev);
 
@@ -2967,13 +2967,13 @@ static void s3c_hsotg_phy_enable(struct dwc2_hsotg *hsotg)
 }
 
 /**
- * s3c_hsotg_phy_disable - disable platform phy dev
+ * dwc2_hsotg_phy_disable - disable platform phy dev
  * @hsotg: The driver state
  *
  * A wrapper for platform code responsible for controlling
  * low-level USB code
  */
-static void s3c_hsotg_phy_disable(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_phy_disable(struct dwc2_hsotg *hsotg)
 {
        struct platform_device *pdev = to_platform_device(hsotg->dev);
 
@@ -2988,10 +2988,10 @@ static void s3c_hsotg_phy_disable(struct dwc2_hsotg *hsotg)
 }
 
 /**
- * s3c_hsotg_init - initalize the usb core
+ * dwc2_hsotg_init - initalize the usb core
  * @hsotg: The driver state
  */
-static void s3c_hsotg_init(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_init(struct dwc2_hsotg *hsotg)
 {
        u32 trdtim;
        /* unmask subset of endpoint interrupts */
@@ -3015,7 +3015,7 @@ static void s3c_hsotg_init(struct dwc2_hsotg *hsotg)
                readl(hsotg->regs + GRXFSIZ),
                readl(hsotg->regs + GNPTXFSIZ));
 
-       s3c_hsotg_init_fifo(hsotg);
+       dwc2_hsotg_init_fifo(hsotg);
 
        /* set the PLL on, remove the HNP/SRP and set the PHY */
        trdtim = (hsotg->phyif == GUSBCFG_PHYIF8) ? 9 : 5;
@@ -3028,14 +3028,14 @@ static void s3c_hsotg_init(struct dwc2_hsotg *hsotg)
 }
 
 /**
- * s3c_hsotg_udc_start - prepare the udc for work
+ * dwc2_hsotg_udc_start - prepare the udc for work
  * @gadget: The usb gadget state
  * @driver: The usb gadget driver
  *
  * Perform initialization to prepare udc device and driver
  * to work.
  */
-static int s3c_hsotg_udc_start(struct usb_gadget *gadget,
+static int dwc2_hsotg_udc_start(struct usb_gadget *gadget,
                           struct usb_gadget_driver *driver)
 {
        struct dwc2_hsotg *hsotg = to_hsotg(gadget);
@@ -3077,13 +3077,13 @@ static int s3c_hsotg_udc_start(struct usb_gadget *gadget,
                goto err;
        }
 
-       s3c_hsotg_phy_enable(hsotg);
+       dwc2_hsotg_phy_enable(hsotg);
        if (!IS_ERR_OR_NULL(hsotg->uphy))
                otg_set_peripheral(hsotg->uphy->otg, &hsotg->gadget);
 
        spin_lock_irqsave(&hsotg->lock, flags);
-       s3c_hsotg_init(hsotg);
-       s3c_hsotg_core_init_disconnected(hsotg, false);
+       dwc2_hsotg_init(hsotg);
+       dwc2_hsotg_core_init_disconnected(hsotg, false);
        hsotg->enabled = 0;
        spin_unlock_irqrestore(&hsotg->lock, flags);
 
@@ -3100,13 +3100,13 @@ err:
 }
 
 /**
- * s3c_hsotg_udc_stop - stop the udc
+ * dwc2_hsotg_udc_stop - stop the udc
  * @gadget: The usb gadget state
  * @driver: The usb gadget driver
  *
  * Stop udc hw block and stay tunned for future transmissions
  */
-static int s3c_hsotg_udc_stop(struct usb_gadget *gadget)
+static int dwc2_hsotg_udc_stop(struct usb_gadget *gadget)
 {
        struct dwc2_hsotg *hsotg = to_hsotg(gadget);
        unsigned long flags = 0;
@@ -3120,9 +3120,9 @@ static int s3c_hsotg_udc_stop(struct usb_gadget *gadget)
        /* all endpoints should be shutdown */
        for (ep = 1; ep < hsotg->num_of_eps; ep++) {
                if (hsotg->eps_in[ep])
-                       s3c_hsotg_ep_disable(&hsotg->eps_in[ep]->ep);
+                       dwc2_hsotg_ep_disable(&hsotg->eps_in[ep]->ep);
                if (hsotg->eps_out[ep])
-                       s3c_hsotg_ep_disable(&hsotg->eps_out[ep]->ep);
+                       dwc2_hsotg_ep_disable(&hsotg->eps_out[ep]->ep);
        }
 
        spin_lock_irqsave(&hsotg->lock, flags);
@@ -3135,7 +3135,7 @@ static int s3c_hsotg_udc_stop(struct usb_gadget *gadget)
 
        if (!IS_ERR_OR_NULL(hsotg->uphy))
                otg_set_peripheral(hsotg->uphy->otg, NULL);
-       s3c_hsotg_phy_disable(hsotg);
+       dwc2_hsotg_phy_disable(hsotg);
 
        regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies), hsotg->supplies);
 
@@ -3147,24 +3147,24 @@ static int s3c_hsotg_udc_stop(struct usb_gadget *gadget)
 }
 
 /**
- * s3c_hsotg_gadget_getframe - read the frame number
+ * dwc2_hsotg_gadget_getframe - read the frame number
  * @gadget: The usb gadget state
  *
  * Read the {micro} frame number
  */
-static int s3c_hsotg_gadget_getframe(struct usb_gadget *gadget)
+static int dwc2_hsotg_gadget_getframe(struct usb_gadget *gadget)
 {
-       return s3c_hsotg_read_frameno(to_hsotg(gadget));
+       return dwc2_hsotg_read_frameno(to_hsotg(gadget));
 }
 
 /**
- * s3c_hsotg_pullup - connect/disconnect the USB PHY
+ * dwc2_hsotg_pullup - connect/disconnect the USB PHY
  * @gadget: The usb gadget state
  * @is_on: Current state of the USB PHY
  *
  * Connect/Disconnect the USB PHY pullup
  */
-static int s3c_hsotg_pullup(struct usb_gadget *gadget, int is_on)
+static int dwc2_hsotg_pullup(struct usb_gadget *gadget, int is_on)
 {
        struct dwc2_hsotg *hsotg = to_hsotg(gadget);
        unsigned long flags = 0;
@@ -3176,11 +3176,11 @@ static int s3c_hsotg_pullup(struct usb_gadget *gadget, int is_on)
        if (is_on) {
                clk_enable(hsotg->clk);
                hsotg->enabled = 1;
-               s3c_hsotg_core_init_disconnected(hsotg, false);
-               s3c_hsotg_core_connect(hsotg);
+               dwc2_hsotg_core_init_disconnected(hsotg, false);
+               dwc2_hsotg_core_connect(hsotg);
        } else {
-               s3c_hsotg_core_disconnect(hsotg);
-               s3c_hsotg_disconnect(hsotg);
+               dwc2_hsotg_core_disconnect(hsotg);
+               dwc2_hsotg_disconnect(hsotg);
                hsotg->enabled = 0;
                clk_disable(hsotg->clk);
        }
@@ -3192,7 +3192,7 @@ static int s3c_hsotg_pullup(struct usb_gadget *gadget, int is_on)
        return 0;
 }
 
-static int s3c_hsotg_vbus_session(struct usb_gadget *gadget, int is_active)
+static int dwc2_hsotg_vbus_session(struct usb_gadget *gadget, int is_active)
 {
        struct dwc2_hsotg *hsotg = to_hsotg(gadget);
        unsigned long flags;
@@ -3211,12 +3211,12 @@ static int s3c_hsotg_vbus_session(struct usb_gadget *gadget, int is_active)
                }
                /* Kill any ep0 requests as controller will be reinitialized */
                kill_all_requests(hsotg, hsotg->eps_out[0], -ECONNRESET);
-               s3c_hsotg_core_init_disconnected(hsotg, false);
+               dwc2_hsotg_core_init_disconnected(hsotg, false);
                if (hsotg->enabled)
-                       s3c_hsotg_core_connect(hsotg);
+                       dwc2_hsotg_core_connect(hsotg);
        } else {
-               s3c_hsotg_core_disconnect(hsotg);
-               s3c_hsotg_disconnect(hsotg);
+               dwc2_hsotg_core_disconnect(hsotg);
+               dwc2_hsotg_disconnect(hsotg);
        }
 
        spin_unlock_irqrestore(&hsotg->lock, flags);
@@ -3224,13 +3224,13 @@ static int s3c_hsotg_vbus_session(struct usb_gadget *gadget, int is_active)
 }
 
 /**
- * s3c_hsotg_vbus_draw - report bMaxPower field
+ * dwc2_hsotg_vbus_draw - report bMaxPower field
  * @gadget: The usb gadget state
  * @mA: Amount of current
  *
  * Report how much power the device may consume to the phy.
  */
-static int s3c_hsotg_vbus_draw(struct usb_gadget *gadget, unsigned mA)
+static int dwc2_hsotg_vbus_draw(struct usb_gadget *gadget, unsigned mA)
 {
        struct dwc2_hsotg *hsotg = to_hsotg(gadget);
 
@@ -3239,17 +3239,17 @@ static int s3c_hsotg_vbus_draw(struct usb_gadget *gadget, unsigned mA)
        return usb_phy_set_power(hsotg->uphy, mA);
 }
 
-static const struct usb_gadget_ops s3c_hsotg_gadget_ops = {
-       .get_frame      = s3c_hsotg_gadget_getframe,
-       .udc_start              = s3c_hsotg_udc_start,
-       .udc_stop               = s3c_hsotg_udc_stop,
-       .pullup                 = s3c_hsotg_pullup,
-       .vbus_session           = s3c_hsotg_vbus_session,
-       .vbus_draw              = s3c_hsotg_vbus_draw,
+static const struct usb_gadget_ops dwc2_hsotg_gadget_ops = {
+       .get_frame      = dwc2_hsotg_gadget_getframe,
+       .udc_start              = dwc2_hsotg_udc_start,
+       .udc_stop               = dwc2_hsotg_udc_stop,
+       .pullup                 = dwc2_hsotg_pullup,
+       .vbus_session           = dwc2_hsotg_vbus_session,
+       .vbus_draw              = dwc2_hsotg_vbus_draw,
 };
 
 /**
- * s3c_hsotg_initep - initialise a single endpoint
+ * dwc2_hsotg_initep - initialise a single endpoint
  * @hsotg: The device state.
  * @hs_ep: The endpoint to be initialised.
  * @epnum: The endpoint number
@@ -3258,8 +3258,8 @@ static const struct usb_gadget_ops s3c_hsotg_gadget_ops = {
  * creation) to give to the gadget driver. Setup the endpoint name, any
  * direction information and other state that may be required.
  */
-static void s3c_hsotg_initep(struct dwc2_hsotg *hsotg,
-                                      struct s3c_hsotg_ep *hs_ep,
+static void dwc2_hsotg_initep(struct dwc2_hsotg *hsotg,
+                                      struct dwc2_hsotg_ep *hs_ep,
                                       int epnum,
                                       bool dir_in)
 {
@@ -3287,7 +3287,7 @@ static void s3c_hsotg_initep(struct dwc2_hsotg *hsotg,
        hs_ep->parent = hsotg;
        hs_ep->ep.name = hs_ep->name;
        usb_ep_set_maxpacket_limit(&hs_ep->ep, epnum ? 1024 : EP0_MPS_LIMIT);
-       hs_ep->ep.ops = &s3c_hsotg_ep_ops;
+       hs_ep->ep.ops = &dwc2_hsotg_ep_ops;
 
        if (epnum == 0) {
                hs_ep->ep.caps.type_control = true;
@@ -3317,12 +3317,12 @@ static void s3c_hsotg_initep(struct dwc2_hsotg *hsotg,
 }
 
 /**
- * s3c_hsotg_hw_cfg - read HW configuration registers
+ * dwc2_hsotg_hw_cfg - read HW configuration registers
  * @param: The device state
  *
  * Read the USB core HW configuration registers
  */
-static int s3c_hsotg_hw_cfg(struct dwc2_hsotg *hsotg)
+static int dwc2_hsotg_hw_cfg(struct dwc2_hsotg *hsotg)
 {
        u32 cfg;
        u32 ep_type;
@@ -3335,11 +3335,11 @@ static int s3c_hsotg_hw_cfg(struct dwc2_hsotg *hsotg)
        /* Add ep0 */
        hsotg->num_of_eps++;
 
-       hsotg->eps_in[0] = devm_kzalloc(hsotg->dev, sizeof(struct s3c_hsotg_ep),
+       hsotg->eps_in[0] = devm_kzalloc(hsotg->dev, sizeof(struct dwc2_hsotg_ep),
                                                                GFP_KERNEL);
        if (!hsotg->eps_in[0])
                return -ENOMEM;
-       /* Same s3c_hsotg_ep is used in both directions for ep0 */
+       /* Same dwc2_hsotg_ep is used in both directions for ep0 */
        hsotg->eps_out[0] = hsotg->eps_in[0];
 
        cfg = readl(hsotg->regs + GHWCFG1);
@@ -3348,14 +3348,14 @@ static int s3c_hsotg_hw_cfg(struct dwc2_hsotg *hsotg)
                /* Direction in or both */
                if (!(ep_type & 2)) {
                        hsotg->eps_in[i] = devm_kzalloc(hsotg->dev,
-                               sizeof(struct s3c_hsotg_ep), GFP_KERNEL);
+                               sizeof(struct dwc2_hsotg_ep), GFP_KERNEL);
                        if (!hsotg->eps_in[i])
                                return -ENOMEM;
                }
                /* Direction out or both */
                if (!(ep_type & 1)) {
                        hsotg->eps_out[i] = devm_kzalloc(hsotg->dev,
-                               sizeof(struct s3c_hsotg_ep), GFP_KERNEL);
+                               sizeof(struct dwc2_hsotg_ep), GFP_KERNEL);
                        if (!hsotg->eps_out[i])
                                return -ENOMEM;
                }
@@ -3375,10 +3375,10 @@ static int s3c_hsotg_hw_cfg(struct dwc2_hsotg *hsotg)
 }
 
 /**
- * s3c_hsotg_dump - dump state of the udc
+ * dwc2_hsotg_dump - dump state of the udc
  * @param: The device state
  */
-static void s3c_hsotg_dump(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_dump(struct dwc2_hsotg *hsotg)
 {
 #ifdef DEBUG
        struct device *dev = hsotg->dev;
@@ -3427,7 +3427,7 @@ static void s3c_hsotg_dump(struct dwc2_hsotg *hsotg)
 }
 
 #ifdef CONFIG_OF
-static void s3c_hsotg_of_probe(struct dwc2_hsotg *hsotg)
+static void dwc2_hsotg_of_probe(struct dwc2_hsotg *hsotg)
 {
        struct device_node *np = hsotg->dev->of_node;
        u32 len = 0;
@@ -3468,7 +3468,7 @@ rx_fifo:
                                                &hsotg->g_np_g_tx_fifo_sz);
 }
 #else
-static inline void s3c_hsotg_of_probe(struct dwc2_hsotg *hsotg) { }
+static inline void dwc2_hsotg_of_probe(struct dwc2_hsotg *hsotg) { }
 #endif
 
 /**
@@ -3479,7 +3479,7 @@ static inline void s3c_hsotg_of_probe(struct dwc2_hsotg *hsotg) { }
 int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
 {
        struct device *dev = hsotg->dev;
-       struct s3c_hsotg_plat *plat = dev->platform_data;
+       struct dwc2_hsotg_plat *plat = dev->platform_data;
        int epnum;
        int ret;
        int i;
@@ -3488,14 +3488,14 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
        /* Set default UTMI width */
        hsotg->phyif = GUSBCFG_PHYIF16;
 
-       s3c_hsotg_of_probe(hsotg);
+       dwc2_hsotg_of_probe(hsotg);
 
        /* Initialize to legacy fifo configuration values */
        hsotg->g_rx_fifo_sz = 2048;
        hsotg->g_np_g_tx_fifo_sz = 1024;
        memcpy(&hsotg->g_tx_fifo_sz[1], p_tx_fifo, sizeof(p_tx_fifo));
        /* Device tree specific probe */
-       s3c_hsotg_of_probe(hsotg);
+       dwc2_hsotg_of_probe(hsotg);
        /* Dump fifo information */
        dev_dbg(dev, "NonPeriodic TXFIFO size: %d\n",
                                                hsotg->g_np_g_tx_fifo_sz);
@@ -3531,7 +3531,7 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
        }
 
        hsotg->gadget.max_speed = USB_SPEED_HIGH;
-       hsotg->gadget.ops = &s3c_hsotg_gadget_ops;
+       hsotg->gadget.ops = &dwc2_hsotg_gadget_ops;
        hsotg->gadget.name = dev_name(dev);
        if (hsotg->dr_mode == USB_DR_MODE_OTG)
                hsotg->gadget.is_otg = 1;
@@ -3548,7 +3548,7 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
        /* regulators */
 
        for (i = 0; i < ARRAY_SIZE(hsotg->supplies); i++)
-               hsotg->supplies[i].supply = s3c_hsotg_supply_names[i];
+               hsotg->supplies[i].supply = dwc2_hsotg_supply_names[i];
 
        ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(hsotg->supplies),
                                 hsotg->supplies);
@@ -3566,7 +3566,7 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
        }
 
        /* usb phy enable */
-       s3c_hsotg_phy_enable(hsotg);
+       dwc2_hsotg_phy_enable(hsotg);
 
        /*
         * Force Device mode before initialization.
@@ -3581,14 +3581,14 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
         */
        msleep(25);
 
-       s3c_hsotg_corereset(hsotg);
-       ret = s3c_hsotg_hw_cfg(hsotg);
+       dwc2_hsotg_corereset(hsotg);
+       ret = dwc2_hsotg_hw_cfg(hsotg);
        if (ret) {
                dev_err(hsotg->dev, "Hardware configuration failed: %d\n", ret);
                goto err_clk;
        }
 
-       s3c_hsotg_init(hsotg);
+       dwc2_hsotg_init(hsotg);
 
        /* Switch back to default configuration */
        __bic32(hsotg->regs + GUSBCFG, GUSBCFG_FORCEDEVMODE);
@@ -3609,10 +3609,10 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
                goto err_supplies;
        }
 
-       ret = devm_request_irq(hsotg->dev, irq, s3c_hsotg_irq, IRQF_SHARED,
+       ret = devm_request_irq(hsotg->dev, irq, dwc2_hsotg_irq, IRQF_SHARED,
                                dev_name(hsotg->dev), hsotg);
        if (ret < 0) {
-               s3c_hsotg_phy_disable(hsotg);
+               dwc2_hsotg_phy_disable(hsotg);
                clk_disable_unprepare(hsotg->clk);
                regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
                                       hsotg->supplies);
@@ -3635,7 +3635,7 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
 
        /* allocate EP0 request */
 
-       hsotg->ctrl_req = s3c_hsotg_ep_alloc_request(&hsotg->eps_out[0]->ep,
+       hsotg->ctrl_req = dwc2_hsotg_ep_alloc_request(&hsotg->eps_out[0]->ep,
                                                     GFP_KERNEL);
        if (!hsotg->ctrl_req) {
                dev_err(dev, "failed to allocate ctrl req\n");
@@ -3646,15 +3646,15 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
        /* initialise the endpoints now the core has been initialised */
        for (epnum = 0; epnum < hsotg->num_of_eps; epnum++) {
                if (hsotg->eps_in[epnum])
-                       s3c_hsotg_initep(hsotg, hsotg->eps_in[epnum],
+                       dwc2_hsotg_initep(hsotg, hsotg->eps_in[epnum],
                                                                epnum, 1);
                if (hsotg->eps_out[epnum])
-                       s3c_hsotg_initep(hsotg, hsotg->eps_out[epnum],
+                       dwc2_hsotg_initep(hsotg, hsotg->eps_out[epnum],
                                                                epnum, 0);
        }
 
        /* disable power and clock */
-       s3c_hsotg_phy_disable(hsotg);
+       dwc2_hsotg_phy_disable(hsotg);
 
        ret = regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
                                    hsotg->supplies);
@@ -3667,12 +3667,12 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg, int irq)
        if (ret)
                goto err_supplies;
 
-       s3c_hsotg_dump(hsotg);
+       dwc2_hsotg_dump(hsotg);
 
        return 0;
 
 err_supplies:
-       s3c_hsotg_phy_disable(hsotg);
+       dwc2_hsotg_phy_disable(hsotg);
 err_clk:
        clk_disable_unprepare(hsotg->clk);
 
@@ -3680,10 +3680,10 @@ err_clk:
 }
 
 /**
- * s3c_hsotg_remove - remove function for hsotg driver
+ * dwc2_hsotg_remove - remove function for hsotg driver
  * @pdev: The platform information for the driver
  */
-int s3c_hsotg_remove(struct dwc2_hsotg *hsotg)
+int dwc2_hsotg_remove(struct dwc2_hsotg *hsotg)
 {
        usb_del_gadget_udc(&hsotg->gadget);
        clk_disable_unprepare(hsotg->clk);
@@ -3691,7 +3691,7 @@ int s3c_hsotg_remove(struct dwc2_hsotg *hsotg)
        return 0;
 }
 
-int s3c_hsotg_suspend(struct dwc2_hsotg *hsotg)
+int dwc2_hsotg_suspend(struct dwc2_hsotg *hsotg)
 {
        unsigned long flags;
        int ret = 0;
@@ -3709,18 +3709,18 @@ int s3c_hsotg_suspend(struct dwc2_hsotg *hsotg)
 
                spin_lock_irqsave(&hsotg->lock, flags);
                if (hsotg->enabled)
-                       s3c_hsotg_core_disconnect(hsotg);
-               s3c_hsotg_disconnect(hsotg);
+                       dwc2_hsotg_core_disconnect(hsotg);
+               dwc2_hsotg_disconnect(hsotg);
                hsotg->gadget.speed = USB_SPEED_UNKNOWN;
                spin_unlock_irqrestore(&hsotg->lock, flags);
 
-               s3c_hsotg_phy_disable(hsotg);
+               dwc2_hsotg_phy_disable(hsotg);
 
                for (ep = 0; ep < hsotg->num_of_eps; ep++) {
                        if (hsotg->eps_in[ep])
-                               s3c_hsotg_ep_disable(&hsotg->eps_in[ep]->ep);
+                               dwc2_hsotg_ep_disable(&hsotg->eps_in[ep]->ep);
                        if (hsotg->eps_out[ep])
-                               s3c_hsotg_ep_disable(&hsotg->eps_out[ep]->ep);
+                               dwc2_hsotg_ep_disable(&hsotg->eps_out[ep]->ep);
                }
 
                ret = regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
@@ -3733,7 +3733,7 @@ int s3c_hsotg_suspend(struct dwc2_hsotg *hsotg)
        return ret;
 }
 
-int s3c_hsotg_resume(struct dwc2_hsotg *hsotg)
+int dwc2_hsotg_resume(struct dwc2_hsotg *hsotg)
 {
        unsigned long flags;
        int ret = 0;
@@ -3751,12 +3751,12 @@ int s3c_hsotg_resume(struct dwc2_hsotg *hsotg)
                ret = regulator_bulk_enable(ARRAY_SIZE(hsotg->supplies),
                                            hsotg->supplies);
 
-               s3c_hsotg_phy_enable(hsotg);
+               dwc2_hsotg_phy_enable(hsotg);
 
                spin_lock_irqsave(&hsotg->lock, flags);
-               s3c_hsotg_core_init_disconnected(hsotg, false);
+               dwc2_hsotg_core_init_disconnected(hsotg, false);
                if (hsotg->enabled)
-                       s3c_hsotg_core_connect(hsotg);
+                       dwc2_hsotg_core_connect(hsotg);
                spin_unlock_irqrestore(&hsotg->lock, flags);
        }
        mutex_unlock(&hsotg->init_mutex);
index f845c41fe9e5e8c788c35d0fd7711b54debbe97e..007a3d5a064230bab011d25909bdce83d50de6ed 100644 (file)
@@ -1382,8 +1382,8 @@ static void dwc2_conn_id_status_change(struct work_struct *work)
                hsotg->op_state = OTG_STATE_B_PERIPHERAL;
                dwc2_core_init(hsotg, false, -1);
                dwc2_enable_global_interrupts(hsotg);
-               s3c_hsotg_core_init_disconnected(hsotg, false);
-               s3c_hsotg_core_connect(hsotg);
+               dwc2_hsotg_core_init_disconnected(hsotg, false);
+               dwc2_hsotg_core_connect(hsotg);
        } else {
                /* A-Device connector (Host Mode) */
                dev_dbg(hsotg->dev, "connId A\n");
index 90935304185a01ab93bb28d9ad7ac4a2b5364e6e..3d1f82def2f33f55a28b9fc73154e5b616823262 100644 (file)
@@ -130,7 +130,7 @@ static int dwc2_driver_remove(struct platform_device *dev)
        if (hsotg->hcd_enabled)
                dwc2_hcd_remove(hsotg);
        if (hsotg->gadget_enabled)
-               s3c_hsotg_remove(hsotg);
+               dwc2_hsotg_remove(hsotg);
 
        return 0;
 }
@@ -269,7 +269,7 @@ static int dwc2_driver_probe(struct platform_device *dev)
                retval = dwc2_hcd_init(hsotg, irq);
                if (retval) {
                        if (hsotg->gadget_enabled)
-                               s3c_hsotg_remove(hsotg);
+                               dwc2_hsotg_remove(hsotg);
                        return retval;
                }
                hsotg->hcd_enabled = 1;
@@ -288,7 +288,7 @@ static int __maybe_unused dwc2_suspend(struct device *dev)
        int ret = 0;
 
        if (dwc2_is_device_mode(dwc2)) {
-               ret = s3c_hsotg_suspend(dwc2);
+               ret = dwc2_hsotg_suspend(dwc2);
        } else {
                if (dwc2->lx_state == DWC2_L0)
                        return 0;
@@ -305,7 +305,7 @@ static int __maybe_unused dwc2_resume(struct device *dev)
        int ret = 0;
 
        if (dwc2_is_device_mode(dwc2)) {
-               ret = s3c_hsotg_resume(dwc2);
+               ret = dwc2_hsotg_resume(dwc2);
        } else {
                phy_power_on(dwc2->phy);
                phy_init(dwc2->phy);
index 3f1cbf95ec3ba9cd98849ae92e846cb14a19e90f..3982586ba6df43f6cf294834c3599bce2b352070 100644 (file)
 
 struct platform_device;
 
-enum s3c_hsotg_dmamode {
+enum dwc2_hsotg_dmamode {
        S3C_HSOTG_DMA_NONE,     /* do not use DMA at-all */
        S3C_HSOTG_DMA_ONLY,     /* always use DMA */
        S3C_HSOTG_DMA_DRV,      /* DMA is chosen by driver */
 };
 
 /**
- * struct s3c_hsotg_plat - platform data for high-speed otg/udc
+ * struct dwc2_hsotg_plat - platform data for high-speed otg/udc
  * @dma: Whether to use DMA or not.
  * @is_osc: The clock source is an oscillator, not a crystal
  */
-struct s3c_hsotg_plat {
-       enum s3c_hsotg_dmamode  dma;
+struct dwc2_hsotg_plat {
+       enum dwc2_hsotg_dmamode dma;
        unsigned int            is_osc:1;
        int                     phy_type;
 
@@ -37,6 +37,6 @@ struct s3c_hsotg_plat {
        int (*phy_exit)(struct platform_device *pdev, int type);
 };
 
-extern void s3c_hsotg_set_platdata(struct s3c_hsotg_plat *pd);
+extern void dwc2_hsotg_set_platdata(struct dwc2_hsotg_plat *pd);
 
 #endif /* __LINUX_USB_S3C_HSOTG_H */