Merge tag 'usb-for-v3.20' of git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb into usb-next

Felipe writes:

usb: patches for v3.20 merge window

Here's the big pull request for Gadgets and PHYs. It's
a total of 217 non-merge commits with pretty much everything
being touched.

The most important bits are a ton of new documentation for
almost all usb gadget functions, a new isp1760 UDC driver,
several improvements to the old net2280 UDC driver, and
some minor tracepoint improvements to dwc3.

Other than that, a big list of minor cleanups, smaller bugfixes
and new features all over the place.

Signed-off-by: Felipe Balbi <balbi@ti.com>

1 files changed, 110 insertions, 40 deletions

diff --git a/drivers/usb/phy/phy-generic.c b/drivers/usb/phy/phy-generic.c
index f1b719b45a53..70be50b734b2 100644
--- a/drivers/usb/phy/phy-generic.c
+++ b/drivers/usb/phy/phy-generic.c
@@ -27,6 +27,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/usb/gadget.h>
 #include <linux/usb/otg.h>
 #include <linux/usb/usb_phy_generic.h>
 #include <linux/slab.h>
@@ -39,6 +40,10 @@
 
 #include "phy-generic.h"
 
+#define VBUS_IRQ_FLAGS \
+        (IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | \
+                IRQF_ONESHOT)
+
 struct platform_device *usb_phy_generic_register(void)
 {
         return platform_device_register_simple("usb_phy_generic",
@@ -59,19 +64,79 @@ static int nop_set_suspend(struct usb_phy *x, int suspend)
 
 static void nop_reset_set(struct usb_phy_generic *nop, int asserted)
 {
-        int value;
+        if (!nop->gpiod_reset)
+                return;
+
+        gpiod_direction_output(nop->gpiod_reset, !asserted);
+        usleep_range(10000, 20000);
+        gpiod_set_value(nop->gpiod_reset, asserted);
+}
+
+/* interface to regulator framework */
+static void nop_set_vbus_draw(struct usb_phy_generic *nop, unsigned mA)
+{
+        struct regulator *vbus_draw = nop->vbus_draw;
+        int enabled;
+        int ret;
 
-        if (!gpio_is_valid(nop->gpio_reset))
+        if (!vbus_draw)
                 return;
 
-        value = asserted;
-        if (nop->reset_active_low)
-                value = !value;
+        enabled = nop->vbus_draw_enabled;
+        if (mA) {
+                regulator_set_current_limit(vbus_draw, 0, 1000 * mA);
+                if (!enabled) {
+                        ret = regulator_enable(vbus_draw);
+                        if (ret < 0)
+                                return;
+                        nop->vbus_draw_enabled = 1;
+                }
+        } else {
+                if (enabled) {
+                        ret = regulator_disable(vbus_draw);
+                        if (ret < 0)
+                                return;
+                        nop->vbus_draw_enabled = 0;
+                }
+        }
+        nop->mA = mA;
+}
+
+
+static irqreturn_t nop_gpio_vbus_thread(int irq, void *data)
+{
+        struct usb_phy_generic *nop = data;
+        struct usb_otg *otg = nop->phy.otg;
+        int vbus, status;
+
+        vbus = gpiod_get_value(nop->gpiod_vbus);
+        if ((vbus ^ nop->vbus) == 0)
+                return IRQ_HANDLED;
+        nop->vbus = vbus;
+
+        if (vbus) {
+                status = USB_EVENT_VBUS;
+                otg->state = OTG_STATE_B_PERIPHERAL;
+                nop->phy.last_event = status;
+                usb_gadget_vbus_connect(otg->gadget);
+
+                /* drawing a "unit load" is *always* OK, except for OTG */
+                nop_set_vbus_draw(nop, 100);
+
+                atomic_notifier_call_chain(&nop->phy.notifier, status,
+                                           otg->gadget);
+        } else {
+                nop_set_vbus_draw(nop, 0);
 
-        gpio_set_value_cansleep(nop->gpio_reset, value);
+                usb_gadget_vbus_disconnect(otg->gadget);
+                status = USB_EVENT_NONE;
+                otg->state = OTG_STATE_B_IDLE;
+                nop->phy.last_event = status;
 
-        if (!asserted)
-                usleep_range(10000, 20000);
+                atomic_notifier_call_chain(&nop->phy.notifier, status,
+                                           otg->gadget);
+        }
+        return IRQ_HANDLED;
 }
 
 int usb_gen_phy_init(struct usb_phy *phy)
@@ -143,36 +208,47 @@ int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop,
                 struct usb_phy_generic_platform_data *pdata)
 {
         enum usb_phy_type type = USB_PHY_TYPE_USB2;
-        int err;
+        int err = 0;
 
         u32 clk_rate = 0;
         bool needs_vcc = false;
 
-        nop->reset_active_low = true;   /* default behaviour */
-
         if (dev->of_node) {
                 struct device_node *node = dev->of_node;
-                enum of_gpio_flags flags = 0;
 
                 if (of_property_read_u32(node, "clock-frequency", &clk_rate))
                         clk_rate = 0;
 
                 needs_vcc = of_property_read_bool(node, "vcc-supply");
-                nop->gpio_reset = of_get_named_gpio_flags(node, "reset-gpios",
-                                                                0, &flags);
-                if (nop->gpio_reset == -EPROBE_DEFER)
-                        return -EPROBE_DEFER;
-
-                nop->reset_active_low = flags & OF_GPIO_ACTIVE_LOW;
-
+                nop->gpiod_reset = devm_gpiod_get_optional(dev, "reset");
+                err = PTR_ERR_OR_ZERO(nop->gpiod_reset);
+                if (!err) {
+                        nop->gpiod_vbus = devm_gpiod_get_optional(dev,
+                                                         "vbus-detect");
+                        err = PTR_ERR_OR_ZERO(nop->gpiod_vbus);
+                }
         } else if (pdata) {
                 type = pdata->type;
                 clk_rate = pdata->clk_rate;
                 needs_vcc = pdata->needs_vcc;
-                nop->gpio_reset = pdata->gpio_reset;
-        } else {
-                nop->gpio_reset = -1;
+                if (gpio_is_valid(pdata->gpio_reset)) {
+                        err = devm_gpio_request_one(dev, pdata->gpio_reset, 0,
+                                                    dev_name(dev));
+                        if (!err)
+                                nop->gpiod_reset =
+                                        gpio_to_desc(pdata->gpio_reset);
+                }
+                nop->gpiod_vbus = pdata->gpiod_vbus;
+        }
+
+        if (err == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+        if (err) {
+                dev_err(dev, "Error requesting RESET or VBUS GPIO\n");
+                return err;
         }
+        if (nop->gpiod_reset)
+                gpiod_direction_output(nop->gpiod_reset, 1);
 
         nop->phy.otg = devm_kzalloc(dev, sizeof(*nop->phy.otg),
                         GFP_KERNEL);
@@ -201,24 +277,6 @@ int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop,
                         return -EPROBE_DEFER;
         }
 
-        if (gpio_is_valid(nop->gpio_reset)) {
-                unsigned long gpio_flags;
-
-                /* Assert RESET */
-                if (nop->reset_active_low)
-                        gpio_flags = GPIOF_OUT_INIT_LOW;
-                else
-                        gpio_flags = GPIOF_OUT_INIT_HIGH;
-
-                err = devm_gpio_request_one(dev, nop->gpio_reset,
-                                                gpio_flags, dev_name(dev));
-                if (err) {
-                        dev_err(dev, "Error requesting RESET GPIO %d\n",
-                                        nop->gpio_reset);
-                        return err;
-                }
-        }
-
         nop->dev                = dev;
         nop->phy.dev            = nop->dev;
         nop->phy.label          = "nop-xceiv";
@@ -247,6 +305,18 @@ static int usb_phy_generic_probe(struct platform_device *pdev)
         err = usb_phy_gen_create_phy(dev, nop, dev_get_platdata(&pdev->dev));
         if (err)
                 return err;
+        if (nop->gpiod_vbus) {
+                err = devm_request_threaded_irq(&pdev->dev,
+                                                gpiod_to_irq(nop->gpiod_vbus),
+                                                NULL, nop_gpio_vbus_thread,
+                                                VBUS_IRQ_FLAGS, "vbus_detect",
+                                                nop);
+                if (err) {
+                        dev_err(&pdev->dev, "can't request irq %i, err: %d\n",
+                                gpiod_to_irq(nop->gpiod_vbus), err);
+                        return err;
+                }
+        }
 
         nop->phy.init           = usb_gen_phy_init;
         nop->phy.shutdown       = usb_gen_phy_shutdown;