1 files changed, 312 insertions, 11 deletions

diff --git a/drivers/usb/gadget/pch_udc.c b/drivers/usb/gadget/pch_udc.c
index a3fcaae4bc2a..65307064a6fd 100644
--- a/drivers/usb/gadget/pch_udc.c
+++ b/drivers/usb/gadget/pch_udc.c
@@ -15,6 +15,14 @@
 #include <linux/interrupt.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/gpio.h>
+#include <linux/irq.h>
+
+/* GPIO port for VBUS detecting */
+static int vbus_gpio_port = -1;         /* GPIO port number (-1:Not used) */
+
+#define PCH_VBUS_PERIOD         3000    /* VBUS polling period (msec) */
+#define PCH_VBUS_INTERVAL       10      /* VBUS polling interval (msec) */
 
 /* Address offset of Registers */
 #define UDC_EP_REG_SHIFT        0x20    /* Offset to next EP */
@@ -296,6 +304,21 @@ struct pch_udc_ep {
 };
 
 /**
+ * struct pch_vbus_gpio_data - Structure holding GPIO informaton
+ *                                      for detecting VBUS
+ * @port:               gpio port number
+ * @intr:               gpio interrupt number
+ * @irq_work_fall       Structure for WorkQueue
+ * @irq_work_rise       Structure for WorkQueue
+ */
+struct pch_vbus_gpio_data {
+        int                     port;
+        int                     intr;
+        struct work_struct      irq_work_fall;
+        struct work_struct      irq_work_rise;
+};
+
+/**
  * struct pch_udc_dev - Structure holding complete information
  *                      of the PCH USB device
  * @gadget:             gadget driver data
@@ -311,6 +334,7 @@ struct pch_udc_ep {
  * @registered:         driver regsitered with system
  * @suspended:          driver in suspended state
  * @connected:          gadget driver associated
+ * @vbus_session:       required vbus_session state
  * @set_cfg_not_acked:  pending acknowledgement 4 setup
  * @waiting_zlp_ack:    pending acknowledgement 4 ZLP
  * @data_requests:      DMA pool for data requests
@@ -322,6 +346,7 @@ struct pch_udc_ep {
  * @base_addr:          for mapped device memory
  * @irq:                IRQ line for the device
  * @cfg_data:           current cfg, intf, and alt in use
+ * @vbus_gpio:          GPIO informaton for detecting VBUS
  */
 struct pch_udc_dev {
         struct usb_gadget               gadget;
@@ -337,6 +362,7 @@ struct pch_udc_dev {
                         registered:1,
                         suspended:1,
                         connected:1,
+                        vbus_session:1,
                         set_cfg_not_acked:1,
                         waiting_zlp_ack:1;
         struct pci_pool         *data_requests;
@@ -347,7 +373,8 @@ struct pch_udc_dev {
         unsigned long                   phys_addr;
         void __iomem                    *base_addr;
         unsigned                        irq;
-        struct pch_udc_cfg_data cfg_data;
+        struct pch_udc_cfg_data         cfg_data;
+        struct pch_vbus_gpio_data       vbus_gpio;
 };
 
 #define PCH_UDC_PCI_BAR                 1
@@ -554,6 +581,29 @@ static void pch_udc_clear_disconnect(struct pch_udc_dev *dev)
 }
 
 /**
+ * pch_udc_reconnect() - This API initializes usb device controller,
+ *                                              and clear the disconnect status.
+ * @dev:                Reference to pch_udc_regs structure
+ */
+static void pch_udc_init(struct pch_udc_dev *dev);
+static void pch_udc_reconnect(struct pch_udc_dev *dev)
+{
+        pch_udc_init(dev);
+
+        /* enable device interrupts */
+        /* pch_udc_enable_interrupts() */
+        pch_udc_bit_clr(dev, UDC_DEVIRQMSK_ADDR,
+                        UDC_DEVINT_UR | UDC_DEVINT_ENUM);
+
+        /* Clear the disconnect */
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD);
+        mdelay(1);
+        /* Resume USB signalling */
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+}
+
+/**
  * pch_udc_vbus_session() - set or clearr the disconnect status.
  * @dev:        Reference to pch_udc_regs structure
  * @is_active:  Parameter specifying the action
@@ -563,10 +613,18 @@ static void pch_udc_clear_disconnect(struct pch_udc_dev *dev)
 static inline void pch_udc_vbus_session(struct pch_udc_dev *dev,
                                           int is_active)
 {
-        if (is_active)
-                pch_udc_clear_disconnect(dev);
-        else
+        if (is_active) {
+                pch_udc_reconnect(dev);
+                dev->vbus_session = 1;
+        } else {
+                if (dev->driver && dev->driver->disconnect) {
+                        spin_unlock(&dev->lock);
+                        dev->driver->disconnect(&dev->gadget);
+                        spin_lock(&dev->lock);
+                }
                 pch_udc_set_disconnect(dev);
+                dev->vbus_session = 0;
+        }
 }
 
 /**
@@ -1126,7 +1184,17 @@ static int pch_udc_pcd_pullup(struct usb_gadget *gadget, int is_on)
         if (!gadget)
                 return -EINVAL;
         dev = container_of(gadget, struct pch_udc_dev, gadget);
-        pch_udc_vbus_session(dev, is_on);
+        if (is_on) {
+                pch_udc_reconnect(dev);
+        } else {
+                if (dev->driver && dev->driver->disconnect) {
+                        spin_unlock(&dev->lock);
+                        dev->driver->disconnect(&dev->gadget);
+                        spin_lock(&dev->lock);
+                }
+                pch_udc_set_disconnect(dev);
+        }
+
         return 0;
 }
 
@@ -1183,6 +1251,188 @@ static const struct usb_gadget_ops pch_udc_ops = {
 };
 
 /**
+ * pch_vbus_gpio_get_value() - This API gets value of GPIO port as VBUS status.
+ * @dev:        Reference to the driver structure
+ *
+ * Return value:
+ *      1: VBUS is high
+ *      0: VBUS is low
+ *     -1: It is not enable to detect VBUS using GPIO
+ */
+static int pch_vbus_gpio_get_value(struct pch_udc_dev *dev)
+{
+        int vbus = 0;
+
+        if (dev->vbus_gpio.port)
+                vbus = gpio_get_value(dev->vbus_gpio.port) ? 1 : 0;
+        else
+                vbus = -1;
+
+        return vbus;
+}
+
+/**
+ * pch_vbus_gpio_work_fall() - This API keeps watch on VBUS becoming Low.
+ *                             If VBUS is Low, disconnect is processed
+ * @irq_work:   Structure for WorkQueue
+ *
+ */
+static void pch_vbus_gpio_work_fall(struct work_struct *irq_work)
+{
+        struct pch_vbus_gpio_data *vbus_gpio = container_of(irq_work,
+                struct pch_vbus_gpio_data, irq_work_fall);
+        struct pch_udc_dev *dev =
+                container_of(vbus_gpio, struct pch_udc_dev, vbus_gpio);
+        int vbus_saved = -1;
+        int vbus;
+        int count;
+
+        if (!dev->vbus_gpio.port)
+                return;
+
+        for (count = 0; count < (PCH_VBUS_PERIOD / PCH_VBUS_INTERVAL);
+                count++) {
+                vbus = pch_vbus_gpio_get_value(dev);
+
+                if ((vbus_saved == vbus) && (vbus == 0)) {
+                        dev_dbg(&dev->pdev->dev, "VBUS fell");
+                        if (dev->driver
+                                && dev->driver->disconnect) {
+                                dev->driver->disconnect(
+                                        &dev->gadget);
+                        }
+                        if (dev->vbus_gpio.intr)
+                                pch_udc_init(dev);
+                        else
+                                pch_udc_reconnect(dev);
+                        return;
+                }
+                vbus_saved = vbus;
+                mdelay(PCH_VBUS_INTERVAL);
+        }
+}
+
+/**
+ * pch_vbus_gpio_work_rise() - This API checks VBUS is High.
+ *                             If VBUS is High, connect is processed
+ * @irq_work:   Structure for WorkQueue
+ *
+ */
+static void pch_vbus_gpio_work_rise(struct work_struct *irq_work)
+{
+        struct pch_vbus_gpio_data *vbus_gpio = container_of(irq_work,
+                struct pch_vbus_gpio_data, irq_work_rise);
+        struct pch_udc_dev *dev =
+                container_of(vbus_gpio, struct pch_udc_dev, vbus_gpio);
+        int vbus;
+
+        if (!dev->vbus_gpio.port)
+                return;
+
+        mdelay(PCH_VBUS_INTERVAL);
+        vbus = pch_vbus_gpio_get_value(dev);
+
+        if (vbus == 1) {
+                dev_dbg(&dev->pdev->dev, "VBUS rose");
+                pch_udc_reconnect(dev);
+                return;
+        }
+}
+
+/**
+ * pch_vbus_gpio_irq() - IRQ handler for GPIO intrerrupt for changing VBUS
+ * @irq:        Interrupt request number
+ * @dev:        Reference to the device structure
+ *
+ * Return codes:
+ *      0: Success
+ *      -EINVAL: GPIO port is invalid or can't be initialized.
+ */
+static irqreturn_t pch_vbus_gpio_irq(int irq, void *data)
+{
+        struct pch_udc_dev *dev = (struct pch_udc_dev *)data;
+
+        if (!dev->vbus_gpio.port || !dev->vbus_gpio.intr)
+                return IRQ_NONE;
+
+        if (pch_vbus_gpio_get_value(dev))
+                schedule_work(&dev->vbus_gpio.irq_work_rise);
+        else
+                schedule_work(&dev->vbus_gpio.irq_work_fall);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * pch_vbus_gpio_init() - This API initializes GPIO port detecting VBUS.
+ * @dev:        Reference to the driver structure
+ * @vbus_gpio   Number of GPIO port to detect gpio
+ *
+ * Return codes:
+ *      0: Success
+ *      -EINVAL: GPIO port is invalid or can't be initialized.
+ */
+static int pch_vbus_gpio_init(struct pch_udc_dev *dev, int vbus_gpio_port)
+{
+        int err;
+        int irq_num = 0;
+
+        dev->vbus_gpio.port = 0;
+        dev->vbus_gpio.intr = 0;
+
+        if (vbus_gpio_port <= -1)
+                return -EINVAL;
+
+        err = gpio_is_valid(vbus_gpio_port);
+        if (!err) {
+                pr_err("%s: gpio port %d is invalid\n",
+                        __func__, vbus_gpio_port);
+                return -EINVAL;
+        }
+
+        err = gpio_request(vbus_gpio_port, "pch_vbus");
+        if (err) {
+                pr_err("%s: can't request gpio port %d, err: %d\n",
+                        __func__, vbus_gpio_port, err);
+                return -EINVAL;
+        }
+
+        dev->vbus_gpio.port = vbus_gpio_port;
+        gpio_direction_input(vbus_gpio_port);
+        INIT_WORK(&dev->vbus_gpio.irq_work_fall, pch_vbus_gpio_work_fall);
+
+        irq_num = gpio_to_irq(vbus_gpio_port);
+        if (irq_num > 0) {
+                irq_set_irq_type(irq_num, IRQ_TYPE_EDGE_BOTH);
+                err = request_irq(irq_num, pch_vbus_gpio_irq, 0,
+                        "vbus_detect", dev);
+                if (!err) {
+                        dev->vbus_gpio.intr = irq_num;
+                        INIT_WORK(&dev->vbus_gpio.irq_work_rise,
+                                pch_vbus_gpio_work_rise);
+                } else {
+                        pr_err("%s: can't request irq %d, err: %d\n",
+                                __func__, irq_num, err);
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * pch_vbus_gpio_free() - This API frees resources of GPIO port
+ * @dev:        Reference to the driver structure
+ */
+static void pch_vbus_gpio_free(struct pch_udc_dev *dev)
+{
+        if (dev->vbus_gpio.intr)
+                free_irq(dev->vbus_gpio.intr, dev);
+
+        if (dev->vbus_gpio.port)
+                gpio_free(dev->vbus_gpio.port);
+}
+
+/**
  * complete_req() - This API is invoked from the driver when processing
  *                      of a request is complete
  * @ep:         Reference to the endpoint structure
@@ -1493,6 +1743,7 @@ static int pch_udc_pcd_ep_disable(struct usb_ep *usbep)
         pch_udc_ep_disable(ep);
         pch_udc_disable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         INIT_LIST_HEAD(&ep->queue);
         spin_unlock_irqrestore(&ep->dev->lock, iflags);
         return 0;
@@ -2335,8 +2586,11 @@ static void pch_udc_svc_ur_interrupt(struct pch_udc_dev *dev)
                 /* Complete request queue */
                 empty_req_queue(ep);
         }
-        if (dev->driver && dev->driver->disconnect)
+        if (dev->driver && dev->driver->disconnect) {
+                spin_unlock(&dev->lock);
                 dev->driver->disconnect(&dev->gadget);
+                spin_lock(&dev->lock);
+        }
 }
 
 /**
@@ -2371,6 +2625,11 @@ static void pch_udc_svc_enum_interrupt(struct pch_udc_dev *dev)
         pch_udc_set_dma(dev, DMA_DIR_TX);
         pch_udc_set_dma(dev, DMA_DIR_RX);
         pch_udc_ep_set_rrdy(&(dev->ep[UDC_EP0OUT_IDX]));
+
+        /* enable device interrupts */
+        pch_udc_enable_interrupts(dev, UDC_DEVINT_UR | UDC_DEVINT_US |
+                                        UDC_DEVINT_ES | UDC_DEVINT_ENUM |
+                                        UDC_DEVINT_SI | UDC_DEVINT_SC);
 }
 
 /**
@@ -2459,12 +2718,18 @@ static void pch_udc_svc_cfg_interrupt(struct pch_udc_dev *dev)
  */
 static void pch_udc_dev_isr(struct pch_udc_dev *dev, u32 dev_intr)
 {
+        int vbus;
+
         /* USB Reset Interrupt */
-        if (dev_intr & UDC_DEVINT_UR)
+        if (dev_intr & UDC_DEVINT_UR) {
                 pch_udc_svc_ur_interrupt(dev);
+                dev_dbg(&dev->pdev->dev, "USB_RESET\n");
+        }
         /* Enumeration Done Interrupt */
-        if (dev_intr & UDC_DEVINT_ENUM)
+        if (dev_intr & UDC_DEVINT_ENUM) {
                 pch_udc_svc_enum_interrupt(dev);
+                dev_dbg(&dev->pdev->dev, "USB_ENUM\n");
+        }
         /* Set Interface Interrupt */
         if (dev_intr & UDC_DEVINT_SI)
                 pch_udc_svc_intf_interrupt(dev);
@@ -2472,8 +2737,30 @@ static void pch_udc_dev_isr(struct pch_udc_dev *dev, u32 dev_intr)
         if (dev_intr & UDC_DEVINT_SC)
                 pch_udc_svc_cfg_interrupt(dev);
         /* USB Suspend interrupt */
-        if (dev_intr & UDC_DEVINT_US)
+        if (dev_intr & UDC_DEVINT_US) {
+                if (dev->driver
+                        && dev->driver->suspend) {
+                        spin_unlock(&dev->lock);
+                        dev->driver->suspend(&dev->gadget);
+                        spin_lock(&dev->lock);
+                }
+
+                vbus = pch_vbus_gpio_get_value(dev);
+                if ((dev->vbus_session == 0)
+                        && (vbus != 1)) {
+                        if (dev->driver && dev->driver->disconnect) {
+                                spin_unlock(&dev->lock);
+                                dev->driver->disconnect(&dev->gadget);
+                                spin_lock(&dev->lock);
+                        }
+                        pch_udc_reconnect(dev);
+                } else if ((dev->vbus_session == 0)
+                        && (vbus == 1)
+                        && !dev->vbus_gpio.intr)
+                        schedule_work(&dev->vbus_gpio.irq_work_fall);
+
                 dev_dbg(&dev->pdev->dev, "USB_SUSPEND\n");
+        }
         /* Clear the SOF interrupt, if enabled */
         if (dev_intr & UDC_DEVINT_SOF)
                 dev_dbg(&dev->pdev->dev, "SOF\n");
@@ -2499,6 +2786,14 @@ static irqreturn_t pch_udc_isr(int irq, void *pdev)
         dev_intr = pch_udc_read_device_interrupts(dev);
         ep_intr = pch_udc_read_ep_interrupts(dev);
 
+        /* For a hot plug, this find that the controller is hung up. */
+        if (dev_intr == ep_intr)
+                if (dev_intr == pch_udc_readl(dev, UDC_DEVCFG_ADDR)) {
+                        dev_dbg(&dev->pdev->dev, "UDC: Hung up\n");
+                        /* The controller is reset */
+                        pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR);
+                        return IRQ_HANDLED;
+                }
         if (dev_intr)
                 /* Clear device interrupts */
                 pch_udc_write_device_interrupts(dev, dev_intr);
@@ -2625,6 +2920,7 @@ static int pch_udc_pcd_init(struct pch_udc_dev *dev)
 {
         pch_udc_init(dev);
         pch_udc_pcd_reinit(dev);
+        pch_vbus_gpio_init(dev, vbus_gpio_port);
         return 0;
 }
 
@@ -2725,7 +3021,8 @@ static int pch_udc_start(struct usb_gadget_driver *driver,
         pch_udc_setup_ep0(dev);
 
         /* clear SD */
-        pch_udc_clear_disconnect(dev);
+        if ((pch_vbus_gpio_get_value(dev) != 0) || !dev->vbus_gpio.intr)
+                pch_udc_clear_disconnect(dev);
 
         dev->connected = 1;
         return 0;
@@ -2803,6 +3100,8 @@ static void pch_udc_remove(struct pci_dev *pdev)
                                  UDC_EP0OUT_BUFF_SIZE * 4, DMA_FROM_DEVICE);
         kfree(dev->ep0out_buf);
 
+        pch_vbus_gpio_free(dev);
+
         pch_udc_exit(dev);
 
         if (dev->irq_registered)
@@ -2912,8 +3211,10 @@ static int pch_udc_probe(struct pci_dev *pdev,
         }
         pch_udc = dev;
         /* initialize the hardware */
-        if (pch_udc_pcd_init(dev))
+        if (pch_udc_pcd_init(dev)) {
+                retval = -ENODEV;
                 goto finished;
+        }
         if (request_irq(pdev->irq, pch_udc_isr, IRQF_SHARED, KBUILD_MODNAME,
                         dev)) {
                 dev_err(&pdev->dev, "%s: request_irq(%d) fail\n", __func__,