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

Felipe writes:

usb: patches for v3.15

another substantial pull request with new features all over
the place.

dwc3 got a bit closer towards hibernation support with after
a few patches re-factoring code to be reused for hibernation.
Also in dwc3 two new workarounds for known silicon bugs have
been implemented, some randconfig build errors have been fixed,
and it was taught about the new generic phy layer.

MUSB on AM335x now supports isochronous transfers thanks to
George Cherian's work.

The atmel_usba driver got two crash fixes: one when no endpoint
was specified in DeviceTree data and another when stopping the UDC
in DEBUG builds.

Function FS got a much needed fix to ffs_epfile_io() which was
copying too much data to userspace in some cases.

The printer gadget got a fix for a possible deadlock and plugged
a memory leak.

Ethernet drivers now use NAPI for RX which gives improved throughput.

Other than that, the usual miscelaneous fixes, cleanups, and
the like.

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

3 files changed, 304 insertions, 21 deletions

diff --git a/drivers/usb/phy/phy-fsm-usb.c b/drivers/usb/phy/phy-fsm-usb.c
index 7aa314ef4a8a..c47e5a6edde2 100644
--- a/drivers/usb/phy/phy-fsm-usb.c
+++ b/drivers/usb/phy/phy-fsm-usb.c
@@ -317,10 +317,12 @@ int otg_statemachine(struct otg_fsm *fsm)
                         otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
                 break;
         case OTG_STATE_A_HOST:
-                if ((!fsm->a_bus_req || fsm->a_suspend_req_inf) &&
+                if (fsm->id || fsm->a_bus_drop)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                else if ((!fsm->a_bus_req || fsm->a_suspend_req_inf) &&
                                 fsm->otg->host->b_hnp_enable)
                         otg_set_state(fsm, OTG_STATE_A_SUSPEND);
-                else if (fsm->id || !fsm->b_conn || fsm->a_bus_drop)
+                else if (!fsm->b_conn)
                         otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
                 else if (!fsm->a_vbus_vld)
                         otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
@@ -346,8 +348,7 @@ int otg_statemachine(struct otg_fsm *fsm)
                         otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
                 break;
         case OTG_STATE_A_WAIT_VFALL:
-                if (fsm->a_wait_vfall_tmout || fsm->id || fsm->a_bus_req ||
-                                (!fsm->a_sess_vld && !fsm->b_conn))
+                if (fsm->a_wait_vfall_tmout)
                         otg_set_state(fsm, OTG_STATE_A_IDLE);
                 break;
         case OTG_STATE_A_VBUS_ERR:
diff --git a/drivers/usb/phy/phy-mxs-usb.c b/drivers/usb/phy/phy-mxs-usb.c
index b42897b6474c..c42bdf0c4a1f 100644
--- a/drivers/usb/phy/phy-mxs-usb.c
+++ b/drivers/usb/phy/phy-mxs-usb.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 Freescale Semiconductor, Inc.
+ * Copyright 2012-2013 Freescale Semiconductor, Inc.
  * Copyright (C) 2012 Marek Vasut <marex@denx.de>
  * on behalf of DENX Software Engineering GmbH
  *
@@ -20,6 +20,9 @@
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/io.h>
+#include <linux/of_device.h>
+#include <linux/regmap.h>
+#include <linux/mfd/syscon.h>
 
 #define DRIVER_NAME "mxs_phy"
 
@@ -28,18 +31,134 @@
 #define HW_USBPHY_CTRL_SET                      0x34
 #define HW_USBPHY_CTRL_CLR                      0x38
 
+#define HW_USBPHY_DEBUG_SET                     0x54
+#define HW_USBPHY_DEBUG_CLR                     0x58
+
+#define HW_USBPHY_IP                            0x90
+#define HW_USBPHY_IP_SET                        0x94
+#define HW_USBPHY_IP_CLR                        0x98
+
 #define BM_USBPHY_CTRL_SFTRST                   BIT(31)
 #define BM_USBPHY_CTRL_CLKGATE                  BIT(30)
+#define BM_USBPHY_CTRL_ENAUTOSET_USBCLKS        BIT(26)
+#define BM_USBPHY_CTRL_ENAUTOCLR_USBCLKGATE     BIT(25)
+#define BM_USBPHY_CTRL_ENVBUSCHG_WKUP           BIT(23)
+#define BM_USBPHY_CTRL_ENIDCHG_WKUP             BIT(22)
+#define BM_USBPHY_CTRL_ENDPDMCHG_WKUP           BIT(21)
+#define BM_USBPHY_CTRL_ENAUTOCLR_PHY_PWD        BIT(20)
+#define BM_USBPHY_CTRL_ENAUTOCLR_CLKGATE        BIT(19)
+#define BM_USBPHY_CTRL_ENAUTO_PWRON_PLL         BIT(18)
 #define BM_USBPHY_CTRL_ENUTMILEVEL3             BIT(15)
 #define BM_USBPHY_CTRL_ENUTMILEVEL2             BIT(14)
 #define BM_USBPHY_CTRL_ENHOSTDISCONDETECT       BIT(1)
 
+#define BM_USBPHY_IP_FIX                       (BIT(17) | BIT(18))
+
+#define BM_USBPHY_DEBUG_CLKGATE                 BIT(30)
+
+/* Anatop Registers */
+#define ANADIG_ANA_MISC0                        0x150
+#define ANADIG_ANA_MISC0_SET                    0x154
+#define ANADIG_ANA_MISC0_CLR                    0x158
+
+#define ANADIG_USB1_VBUS_DET_STAT               0x1c0
+#define ANADIG_USB2_VBUS_DET_STAT               0x220
+
+#define ANADIG_USB1_LOOPBACK_SET                0x1e4
+#define ANADIG_USB1_LOOPBACK_CLR                0x1e8
+#define ANADIG_USB2_LOOPBACK_SET                0x244
+#define ANADIG_USB2_LOOPBACK_CLR                0x248
+
+#define BM_ANADIG_ANA_MISC0_STOP_MODE_CONFIG    BIT(12)
+#define BM_ANADIG_ANA_MISC0_STOP_MODE_CONFIG_SL BIT(11)
+
+#define BM_ANADIG_USB1_VBUS_DET_STAT_VBUS_VALID BIT(3)
+#define BM_ANADIG_USB2_VBUS_DET_STAT_VBUS_VALID BIT(3)
+
+#define BM_ANADIG_USB1_LOOPBACK_UTMI_DIG_TST1   BIT(2)
+#define BM_ANADIG_USB1_LOOPBACK_TSTI_TX_EN      BIT(5)
+#define BM_ANADIG_USB2_LOOPBACK_UTMI_DIG_TST1   BIT(2)
+#define BM_ANADIG_USB2_LOOPBACK_TSTI_TX_EN      BIT(5)
+
+#define to_mxs_phy(p) container_of((p), struct mxs_phy, phy)
+
+/* Do disconnection between PHY and controller without vbus */
+#define MXS_PHY_DISCONNECT_LINE_WITHOUT_VBUS    BIT(0)
+
+/*
+ * The PHY will be in messy if there is a wakeup after putting
+ * bus to suspend (set portsc.suspendM) but before setting PHY to low
+ * power mode (set portsc.phcd).
+ */
+#define MXS_PHY_ABNORMAL_IN_SUSPEND             BIT(1)
+
+/*
+ * The SOF sends too fast after resuming, it will cause disconnection
+ * between host and high speed device.
+ */
+#define MXS_PHY_SENDING_SOF_TOO_FAST            BIT(2)
+
+/*
+ * IC has bug fixes logic, they include
+ * MXS_PHY_ABNORMAL_IN_SUSPEND and MXS_PHY_SENDING_SOF_TOO_FAST
+ * which are described at above flags, the RTL will handle it
+ * according to different versions.
+ */
+#define MXS_PHY_NEED_IP_FIX                     BIT(3)
+
+struct mxs_phy_data {
+        unsigned int flags;
+};
+
+static const struct mxs_phy_data imx23_phy_data = {
+        .flags = MXS_PHY_ABNORMAL_IN_SUSPEND | MXS_PHY_SENDING_SOF_TOO_FAST,
+};
+
+static const struct mxs_phy_data imx6q_phy_data = {
+        .flags = MXS_PHY_SENDING_SOF_TOO_FAST |
+                MXS_PHY_DISCONNECT_LINE_WITHOUT_VBUS |
+                MXS_PHY_NEED_IP_FIX,
+};
+
+static const struct mxs_phy_data imx6sl_phy_data = {
+        .flags = MXS_PHY_DISCONNECT_LINE_WITHOUT_VBUS |
+                MXS_PHY_NEED_IP_FIX,
+};
+
+static const struct of_device_id mxs_phy_dt_ids[] = {
+        { .compatible = "fsl,imx6sl-usbphy", .data = &imx6sl_phy_data, },
+        { .compatible = "fsl,imx6q-usbphy", .data = &imx6q_phy_data, },
+        { .compatible = "fsl,imx23-usbphy", .data = &imx23_phy_data, },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mxs_phy_dt_ids);
+
 struct mxs_phy {
         struct usb_phy phy;
         struct clk *clk;
+        const struct mxs_phy_data *data;
+        struct regmap *regmap_anatop;
+        int port_id;
 };
 
-#define to_mxs_phy(p) container_of((p), struct mxs_phy, phy)
+static inline bool is_imx6q_phy(struct mxs_phy *mxs_phy)
+{
+        return mxs_phy->data == &imx6q_phy_data;
+}
+
+static inline bool is_imx6sl_phy(struct mxs_phy *mxs_phy)
+{
+        return mxs_phy->data == &imx6sl_phy_data;
+}
+
+/*
+ * PHY needs some 32K cycles to switch from 32K clock to
+ * bus (such as AHB/AXI, etc) clock.
+ */
+static void mxs_phy_clock_switch_delay(void)
+{
+        usleep_range(300, 400);
+}
 
 static int mxs_phy_hw_init(struct mxs_phy *mxs_phy)
 {
@@ -53,19 +172,105 @@ static int mxs_phy_hw_init(struct mxs_phy *mxs_phy)
         /* Power up the PHY */
         writel(0, base + HW_USBPHY_PWD);
 
-        /* enable FS/LS device */
-        writel(BM_USBPHY_CTRL_ENUTMILEVEL2 |
-               BM_USBPHY_CTRL_ENUTMILEVEL3,
+        /*
+         * USB PHY Ctrl Setting
+         * - Auto clock/power on
+         * - Enable full/low speed support
+         */
+        writel(BM_USBPHY_CTRL_ENAUTOSET_USBCLKS |
+                BM_USBPHY_CTRL_ENAUTOCLR_USBCLKGATE |
+                BM_USBPHY_CTRL_ENAUTOCLR_PHY_PWD |
+                BM_USBPHY_CTRL_ENAUTOCLR_CLKGATE |
+                BM_USBPHY_CTRL_ENAUTO_PWRON_PLL |
+                BM_USBPHY_CTRL_ENUTMILEVEL2 |
+                BM_USBPHY_CTRL_ENUTMILEVEL3,
                base + HW_USBPHY_CTRL_SET);
 
+        if (mxs_phy->data->flags & MXS_PHY_NEED_IP_FIX)
+                writel(BM_USBPHY_IP_FIX, base + HW_USBPHY_IP_SET);
+
         return 0;
 }
 
+/* Return true if the vbus is there */
+static bool mxs_phy_get_vbus_status(struct mxs_phy *mxs_phy)
+{
+        unsigned int vbus_value;
+
+        if (mxs_phy->port_id == 0)
+                regmap_read(mxs_phy->regmap_anatop,
+                        ANADIG_USB1_VBUS_DET_STAT,
+                        &vbus_value);
+        else if (mxs_phy->port_id == 1)
+                regmap_read(mxs_phy->regmap_anatop,
+                        ANADIG_USB2_VBUS_DET_STAT,
+                        &vbus_value);
+
+        if (vbus_value & BM_ANADIG_USB1_VBUS_DET_STAT_VBUS_VALID)
+                return true;
+        else
+                return false;
+}
+
+static void __mxs_phy_disconnect_line(struct mxs_phy *mxs_phy, bool disconnect)
+{
+        void __iomem *base = mxs_phy->phy.io_priv;
+        u32 reg;
+
+        if (disconnect)
+                writel_relaxed(BM_USBPHY_DEBUG_CLKGATE,
+                        base + HW_USBPHY_DEBUG_CLR);
+
+        if (mxs_phy->port_id == 0) {
+                reg = disconnect ? ANADIG_USB1_LOOPBACK_SET
+                        : ANADIG_USB1_LOOPBACK_CLR;
+                regmap_write(mxs_phy->regmap_anatop, reg,
+                        BM_ANADIG_USB1_LOOPBACK_UTMI_DIG_TST1 |
+                        BM_ANADIG_USB1_LOOPBACK_TSTI_TX_EN);
+        } else if (mxs_phy->port_id == 1) {
+                reg = disconnect ? ANADIG_USB2_LOOPBACK_SET
+                        : ANADIG_USB2_LOOPBACK_CLR;
+                regmap_write(mxs_phy->regmap_anatop, reg,
+                        BM_ANADIG_USB2_LOOPBACK_UTMI_DIG_TST1 |
+                        BM_ANADIG_USB2_LOOPBACK_TSTI_TX_EN);
+        }
+
+        if (!disconnect)
+                writel_relaxed(BM_USBPHY_DEBUG_CLKGATE,
+                        base + HW_USBPHY_DEBUG_SET);
+
+        /* Delay some time, and let Linestate be SE0 for controller */
+        if (disconnect)
+                usleep_range(500, 1000);
+}
+
+static void mxs_phy_disconnect_line(struct mxs_phy *mxs_phy, bool on)
+{
+        bool vbus_is_on = false;
+
+        /* If the SoCs don't need to disconnect line without vbus, quit */
+        if (!(mxs_phy->data->flags & MXS_PHY_DISCONNECT_LINE_WITHOUT_VBUS))
+                return;
+
+        /* If the SoCs don't have anatop, quit */
+        if (!mxs_phy->regmap_anatop)
+                return;
+
+        vbus_is_on = mxs_phy_get_vbus_status(mxs_phy);
+
+        if (on && !vbus_is_on)
+                __mxs_phy_disconnect_line(mxs_phy, true);
+        else
+                __mxs_phy_disconnect_line(mxs_phy, false);
+
+}
+
 static int mxs_phy_init(struct usb_phy *phy)
 {
         int ret;
         struct mxs_phy *mxs_phy = to_mxs_phy(phy);
 
+        mxs_phy_clock_switch_delay();
         ret = clk_prepare_enable(mxs_phy->clk);
         if (ret)
                 return ret;
@@ -94,6 +299,7 @@ static int mxs_phy_suspend(struct usb_phy *x, int suspend)
                        x->io_priv + HW_USBPHY_CTRL_SET);
                 clk_disable_unprepare(mxs_phy->clk);
         } else {
+                mxs_phy_clock_switch_delay();
                 ret = clk_prepare_enable(mxs_phy->clk);
                 if (ret)
                         return ret;
@@ -105,11 +311,28 @@ static int mxs_phy_suspend(struct usb_phy *x, int suspend)
         return 0;
 }
 
+static int mxs_phy_set_wakeup(struct usb_phy *x, bool enabled)
+{
+        struct mxs_phy *mxs_phy = to_mxs_phy(x);
+        u32 value = BM_USBPHY_CTRL_ENVBUSCHG_WKUP |
+                        BM_USBPHY_CTRL_ENDPDMCHG_WKUP |
+                                BM_USBPHY_CTRL_ENIDCHG_WKUP;
+        if (enabled) {
+                mxs_phy_disconnect_line(mxs_phy, true);
+                writel_relaxed(value, x->io_priv + HW_USBPHY_CTRL_SET);
+        } else {
+                writel_relaxed(value, x->io_priv + HW_USBPHY_CTRL_CLR);
+                mxs_phy_disconnect_line(mxs_phy, false);
+        }
+
+        return 0;
+}
+
 static int mxs_phy_on_connect(struct usb_phy *phy,
                 enum usb_device_speed speed)
 {
-        dev_dbg(phy->dev, "%s speed device has connected\n",
-                (speed == USB_SPEED_HIGH) ? "high" : "non-high");
+        dev_dbg(phy->dev, "%s device has connected\n",
+                (speed == USB_SPEED_HIGH) ? "HS" : "FS/LS");
 
         if (speed == USB_SPEED_HIGH)
                 writel(BM_USBPHY_CTRL_ENHOSTDISCONDETECT,
@@ -121,8 +344,8 @@ static int mxs_phy_on_connect(struct usb_phy *phy,
 static int mxs_phy_on_disconnect(struct usb_phy *phy,
                 enum usb_device_speed speed)
 {
-        dev_dbg(phy->dev, "%s speed device has disconnected\n",
-                (speed == USB_SPEED_HIGH) ? "high" : "non-high");
+        dev_dbg(phy->dev, "%s device has disconnected\n",
+                (speed == USB_SPEED_HIGH) ? "HS" : "FS/LS");
 
         if (speed == USB_SPEED_HIGH)
                 writel(BM_USBPHY_CTRL_ENHOSTDISCONDETECT,
@@ -138,6 +361,9 @@ static int mxs_phy_probe(struct platform_device *pdev)
         struct clk *clk;
         struct mxs_phy *mxs_phy;
         int ret;
+        const struct of_device_id *of_id =
+                        of_match_device(mxs_phy_dt_ids, &pdev->dev);
+        struct device_node *np = pdev->dev.of_node;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         base = devm_ioremap_resource(&pdev->dev, res);
@@ -157,6 +383,22 @@ static int mxs_phy_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        /* Some SoCs don't have anatop registers */
+        if (of_get_property(np, "fsl,anatop", NULL)) {
+                mxs_phy->regmap_anatop = syscon_regmap_lookup_by_phandle
+                        (np, "fsl,anatop");
+                if (IS_ERR(mxs_phy->regmap_anatop)) {
+                        dev_dbg(&pdev->dev,
+                                "failed to find regmap for anatop\n");
+                        return PTR_ERR(mxs_phy->regmap_anatop);
+                }
+        }
+
+        ret = of_alias_get_id(np, "usbphy");
+        if (ret < 0)
+                dev_dbg(&pdev->dev, "failed to get alias id, errno %d\n", ret);
+        mxs_phy->port_id = ret;
+
         mxs_phy->phy.io_priv            = base;
         mxs_phy->phy.dev                = &pdev->dev;
         mxs_phy->phy.label              = DRIVER_NAME;
@@ -166,11 +408,15 @@ static int mxs_phy_probe(struct platform_device *pdev)
         mxs_phy->phy.notify_connect     = mxs_phy_on_connect;
         mxs_phy->phy.notify_disconnect  = mxs_phy_on_disconnect;
         mxs_phy->phy.type               = USB_PHY_TYPE_USB2;
+        mxs_phy->phy.set_wakeup         = mxs_phy_set_wakeup;
 
         mxs_phy->clk = clk;
+        mxs_phy->data = of_id->data;
 
         platform_set_drvdata(pdev, mxs_phy);
 
+        device_set_wakeup_capable(&pdev->dev, true);
+
         ret = usb_add_phy_dev(&mxs_phy->phy);
         if (ret)
                 return ret;
@@ -187,11 +433,46 @@ static int mxs_phy_remove(struct platform_device *pdev)
         return 0;
 }
 
-static const struct of_device_id mxs_phy_dt_ids[] = {
-        { .compatible = "fsl,imx23-usbphy", },
-        { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, mxs_phy_dt_ids);
+#ifdef CONFIG_PM_SLEEP
+static void mxs_phy_enable_ldo_in_suspend(struct mxs_phy *mxs_phy, bool on)
+{
+        unsigned int reg = on ? ANADIG_ANA_MISC0_SET : ANADIG_ANA_MISC0_CLR;
+
+        /* If the SoCs don't have anatop, quit */
+        if (!mxs_phy->regmap_anatop)
+                return;
+
+        if (is_imx6q_phy(mxs_phy))
+                regmap_write(mxs_phy->regmap_anatop, reg,
+                        BM_ANADIG_ANA_MISC0_STOP_MODE_CONFIG);
+        else if (is_imx6sl_phy(mxs_phy))
+                regmap_write(mxs_phy->regmap_anatop,
+                        reg, BM_ANADIG_ANA_MISC0_STOP_MODE_CONFIG_SL);
+}
+
+static int mxs_phy_system_suspend(struct device *dev)
+{
+        struct mxs_phy *mxs_phy = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                mxs_phy_enable_ldo_in_suspend(mxs_phy, true);
+
+        return 0;
+}
+
+static int mxs_phy_system_resume(struct device *dev)
+{
+        struct mxs_phy *mxs_phy = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                mxs_phy_enable_ldo_in_suspend(mxs_phy, false);
+
+        return 0;
+}
+#endif /* CONFIG_PM_SLEEP */
+
+static SIMPLE_DEV_PM_OPS(mxs_phy_pm, mxs_phy_system_suspend,
+                mxs_phy_system_resume);
 
 static struct platform_driver mxs_phy_driver = {
         .probe = mxs_phy_probe,
@@ -200,6 +481,7 @@ static struct platform_driver mxs_phy_driver = {
                 .name = DRIVER_NAME,
                 .owner  = THIS_MODULE,
                 .of_match_table = mxs_phy_dt_ids,
+                .pm = &mxs_phy_pm,
          },
 };
 
diff --git a/drivers/usb/phy/phy-rcar-gen2-usb.c b/drivers/usb/phy/phy-rcar-gen2-usb.c
index 551e0a6c0e22..388d89f6b141 100644
--- a/drivers/usb/phy/phy-rcar-gen2-usb.c
+++ b/drivers/usb/phy/phy-rcar-gen2-usb.c
@@ -177,15 +177,15 @@ static int rcar_gen2_usb_phy_probe(struct platform_device *pdev)
         struct clk *clk;
         int retval;
 
-        pdata = dev_get_platdata(&pdev->dev);
+        pdata = dev_get_platdata(dev);
         if (!pdata) {
                 dev_err(dev, "No platform data\n");
                 return -EINVAL;
         }
 
-        clk = devm_clk_get(&pdev->dev, "usbhs");
+        clk = devm_clk_get(dev, "usbhs");
         if (IS_ERR(clk)) {
-                dev_err(&pdev->dev, "Can't get the clock\n");
+                dev_err(dev, "Can't get the clock\n");
                 return PTR_ERR(clk);
         }