#include <linux/ioport.h>
 #include <linux/types.h>
 #include <linux/errno.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/init.h>
-#include <linux/timer.h>
 #include <linux/list.h>
 #include <linux/interrupt.h>
 #include <linux/proc_fs.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
-#include <asm/irq.h>
 #include <asm/system.h>
 #include <asm/unaligned.h>
 #include <asm/dma.h>
-#include <asm/cacheflush.h>
 
 #include "fsl_usb2_udc.h"
 
 static const char driver_name[] = "fsl-usb2-udc";
 static const char driver_desc[] = DRIVER_DESC;
 
-volatile static struct usb_dr_device *dr_regs = NULL;
-volatile static struct usb_sys_interface *usb_sys_regs = NULL;
+static struct usb_dr_device *dr_regs;
+static struct usb_sys_interface *usb_sys_regs;
 
 /* it is initialized in probe()  */
 static struct fsl_udc *udc_controller = NULL;
        /* nuke all pending requests (does flush) */
        nuke(ep, -ESHUTDOWN);
 
-       ep->desc = 0;
+       ep->desc = NULL;
        ep->stopped = 1;
        spin_unlock_irqrestore(&udc->lock, flags);
 
 {
        u32 speed;
 
-       if (udc->bus_reset)
-               udc->bus_reset = 0;
-
        /* Bus resetting is finished */
        if (!(fsl_readl(&dr_regs->portsc1) & PORTSCX_PORT_RESET)) {
                /* Get the speed */
 
        if (fsl_readl(&dr_regs->portsc1) & PORTSCX_PORT_RESET) {
                VDBG("Bus reset");
-               /* Bus is reseting */
-               udc->bus_reset = 1;
                /* Reset all the queues, include XD, dTD, EP queue
                 * head and TR Queue */
                reset_queues(udc);
        /* lock is needed but whether should use this lock or another */
        spin_lock_irqsave(&udc_controller->lock, flags);
 
-       driver->driver.bus = 0;
+       driver->driver.bus = NULL;
        /* hook up the driver */
        udc_controller->driver = driver;
        udc_controller->gadget.dev.driver = &driver->driver;
        retval = driver->bind(&udc_controller->gadget);
        if (retval) {
                VDBG("bind to %s --> %d", driver->driver.name, retval);
-               udc_controller->gadget.dev.driver = 0;
-               udc_controller->driver = 0;
+               udc_controller->gadget.dev.driver = NULL;
+               udc_controller->driver = NULL;
                goto out;
        }
 
                return -EINVAL;
 
        if (udc_controller->transceiver)
-               (void)otg_set_peripheral(udc_controller->transceiver, 0);
+               otg_set_peripheral(udc_controller->transceiver, NULL);
 
        /* stop DR, disable intr */
        dr_controller_stop(udc_controller);
 
        /* unbind gadget and unhook driver. */
        driver->unbind(&udc_controller->gadget);
-       udc_controller->gadget.dev.driver = 0;
-       udc_controller->driver = 0;
+       udc_controller->gadget.dev.driver = NULL;
+       udc_controller->driver = NULL;
 
        printk("unregistered gadget driver '%s'\r\n", driver->driver.name);
        return 0;
 
 /* Controller dma boundary */
 #define UDC_DMA_BOUNDARY                       0x1000
 
-/* -----------------------------------------------------------------------*/
-/* ##### enum data
-*/
-typedef enum {
-       e_ULPI,
-       e_UTMI_8BIT,
-       e_UTMI_16BIT,
-       e_SERIAL
-} e_PhyInterface;
-
 /*-------------------------------------------------------------------------*/
 
 /* ### driver private data
 #define EP_DIR_OUT     0
 
 struct fsl_udc {
-
        struct usb_gadget gadget;
        struct usb_gadget_driver *driver;
+       struct completion *done;        /* to make sure release() is done */
        struct fsl_ep *eps;
        unsigned int max_ep;
        unsigned int irq;
        size_t ep_qh_size;              /* size after alignment adjustment*/
        dma_addr_t ep_qh_dma;           /* dma address of QH */
 
-       u32 max_pipes;          /* Device max pipes */
-       u32 max_use_endpts;     /* Max endpointes to be used */
-       u32 bus_reset;          /* Device is bus reseting */
+       u32 max_pipes;          /* Device max pipes */
        u32 resume_state;       /* USB state to resume */
        u32 usb_state;          /* USB current state */
-       u32 usb_next_state;     /* USB next state */
        u32 ep0_state;          /* Endpoint zero state */
        u32 ep0_dir;            /* Endpoint zero direction: can be
                                   USB_DIR_IN or USB_DIR_OUT */
-       u32 usb_sof_count;      /* SOF count */
-       u32 errors;             /* USB ERRORs count */
        u8 device_address;      /* Device USB address */
-
-       struct completion *done;        /* to make sure release() is done */
 };
 
 /*-------------------------------------------------------------------------*/