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

Felipe writes:

usb: changes for v3.14 merge window

This pull request is quite extensive, containing
105 non-merge commits. Because of that, we describe
the changes in sections below:

New drivers:
	- Keystone PHY driver and DWC3 Glue Layer
	- Aeroflex Gaisler GRUSBDC
	- Tahvo PHY driver for N770
	- JZ4740 MUSB gluer Layer
	- Broadcom PHY Driver

Important new features:
	- MUSB DSPS learned about suspend/resume
	- New quirk_ep_out_aligned_size flag added to struct usb_gadget
	- DWC3 initializes the new quirk flag so gadget drivers can use it.
	- AM335x PHY Driver learns about remote wakeup
	- Renesas USBHS now requests DMA Engine only once
	- s3c-hsotg is now re-used on Broadcom devices
	- USB PHY layer now makes sure to initialize the notifier for all
		drivers
	- omap-control learned about TI's new AM437x devices
	- few other usb gadget/function drivers learned about the new
		configfs-based binding.

Misc Fixes and Clean Ups:
	- Several sparse fixes all over the place
	- Removal of redundant of_match_ptr()
	- r-car gen2 phy now uses usb_add_phy_dev()
	- removal of DEFINE_PCI_DEVICE_TABLE() from a few drivers
	- conversion to clk_prepare/clk_unprepare on r8a66597-udc
	- some randconfig errors and build warnings were fixed
	- removal of unnecessary lock on dwc3-omap.c

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

6 files changed, 304 insertions, 39 deletions

diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index 5e61589fc166..dba63f53906c 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -468,6 +468,8 @@ struct usb_function_instance {
         struct config_group group;
         struct list_head cfs_list;
         struct usb_function_driver *fd;
+        int (*set_inst_name)(struct usb_function_instance *inst,
+                              const char *name);
         void (*free_func_inst)(struct usb_function_instance *inst);
 };
 
diff --git a/include/linux/usb/functionfs.h b/include/linux/usb/functionfs.h
index 65d0a88dbc67..71190663f1ee 100644
--- a/include/linux/usb/functionfs.h
+++ b/include/linux/usb/functionfs.h
@@ -3,34 +3,4 @@
 
 #include <uapi/linux/usb/functionfs.h>
 
-
-struct ffs_data;
-struct usb_composite_dev;
-struct usb_configuration;
-
-
-static int  functionfs_init(void) __attribute__((warn_unused_result));
-static void functionfs_cleanup(void);
-
-static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev)
-        __attribute__((warn_unused_result, nonnull));
-static void functionfs_unbind(struct ffs_data *ffs)
-        __attribute__((nonnull));
-
-static int functionfs_bind_config(struct usb_composite_dev *cdev,
-                                  struct usb_configuration *c,
-                                  struct ffs_data *ffs)
-        __attribute__((warn_unused_result, nonnull));
-
-
-static int functionfs_ready_callback(struct ffs_data *ffs)
-        __attribute__((warn_unused_result, nonnull));
-static void functionfs_closed_callback(struct ffs_data *ffs)
-        __attribute__((nonnull));
-static void *functionfs_acquire_dev_callback(const char *dev_name)
-        __attribute__((warn_unused_result, nonnull));
-static void functionfs_release_dev_callback(struct ffs_data *ffs_data)
-        __attribute__((nonnull));
-
-
 #endif
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 942ef5e053bf..c3a61853cd13 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -148,6 +148,9 @@ struct usb_ep_ops {
  * @maxpacket:The maximum packet size used on this endpoint.  The initial
  *      value can sometimes be reduced (hardware allowing), according to
  *      the endpoint descriptor used to configure the endpoint.
+ * @maxpacket_limit:The maximum packet size value which can be handled by this
+ *      endpoint. It's set once by UDC driver when endpoint is initialized, and
+ *      should not be changed. Should not be confused with maxpacket.
  * @max_streams: The maximum number of streams supported
  *      by this EP (0 - 16, actual number is 2^n)
  * @mult: multiplier, 'mult' value for SS Isoc EPs
@@ -171,6 +174,7 @@ struct usb_ep {
         const struct usb_ep_ops *ops;
         struct list_head        ep_list;
         unsigned                maxpacket:16;
+        unsigned                maxpacket_limit:16;
         unsigned                max_streams:16;
         unsigned                mult:2;
         unsigned                maxburst:5;
@@ -182,6 +186,21 @@ struct usb_ep {
 /*-------------------------------------------------------------------------*/
 
 /**
+ * usb_ep_set_maxpacket_limit - set maximum packet size limit for endpoint
+ * @ep:the endpoint being configured
+ * @maxpacket_limit:value of maximum packet size limit
+ *
+ * This function shoud be used only in UDC drivers to initialize endpoint
+ * (usually in probe function).
+ */
+static inline void usb_ep_set_maxpacket_limit(struct usb_ep *ep,
+                                              unsigned maxpacket_limit)
+{
+        ep->maxpacket_limit = maxpacket_limit;
+        ep->maxpacket = maxpacket_limit;
+}
+
+/**
  * usb_ep_enable - configure endpoint, making it usable
  * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
  *      drivers discover endpoints through the ep_list of a usb_gadget.
@@ -485,6 +504,11 @@ struct usb_gadget_ops {
  * @max_speed: Maximal speed the UDC can handle.  UDC must support this
  *      and all slower speeds.
  * @state: the state we are now (attached, suspended, configured, etc)
+ * @name: Identifies the controller hardware type.  Used in diagnostics
+ *      and sometimes configuration.
+ * @dev: Driver model state for this abstract device.
+ * @out_epnum: last used out ep number
+ * @in_epnum: last used in ep number
  * @sg_supported: true if we can handle scatter-gather
  * @is_otg: True if the USB device port uses a Mini-AB jack, so that the
  *      gadget driver must provide a USB OTG descriptor.
@@ -497,11 +521,8 @@ struct usb_gadget_ops {
  *      only supports HNP on a different root port.
  * @b_hnp_enable: OTG device feature flag, indicating that the A-Host
  *      enabled HNP support.
- * @name: Identifies the controller hardware type.  Used in diagnostics
- *      and sometimes configuration.
- * @dev: Driver model state for this abstract device.
- * @out_epnum: last used out ep number
- * @in_epnum: last used in ep number
+ * @quirk_ep_out_aligned_size: epout requires buffer size to be aligned to
+ *      MaxPacketSize.
  *
  * Gadgets have a mostly-portable "gadget driver" implementing device
  * functions, handling all usb configurations and interfaces.  Gadget
@@ -530,16 +551,18 @@ struct usb_gadget {
         enum usb_device_speed           speed;
         enum usb_device_speed           max_speed;
         enum usb_device_state           state;
+        const char                      *name;
+        struct device                   dev;
+        unsigned                        out_epnum;
+        unsigned                        in_epnum;
+
         unsigned                        sg_supported:1;
         unsigned                        is_otg:1;
         unsigned                        is_a_peripheral:1;
         unsigned                        b_hnp_enable:1;
         unsigned                        a_hnp_support:1;
         unsigned                        a_alt_hnp_support:1;
-        const char                      *name;
-        struct device                   dev;
-        unsigned                        out_epnum;
-        unsigned                        in_epnum;
+        unsigned                        quirk_ep_out_aligned_size:1;
 };
 #define work_to_gadget(w)       (container_of((w), struct usb_gadget, work))
 
@@ -558,6 +581,23 @@ static inline struct usb_gadget *dev_to_usb_gadget(struct device *dev)
 
 
 /**
+ * usb_ep_align_maybe - returns @len aligned to ep's maxpacketsize if gadget
+ *      requires quirk_ep_out_aligned_size, otherwise reguens len.
+ * @g: controller to check for quirk
+ * @ep: the endpoint whose maxpacketsize is used to align @len
+ * @len: buffer size's length to align to @ep's maxpacketsize
+ *
+ * This helper is used in case it's required for any reason to check and maybe
+ * align buffer's size to an ep's maxpacketsize.
+ */
+static inline size_t
+usb_ep_align_maybe(struct usb_gadget *g, struct usb_ep *ep, size_t len)
+{
+        return !g->quirk_ep_out_aligned_size ? len :
+                        round_up(len, (size_t)ep->desc->wMaxPacketSize);
+}
+
+/**
  * gadget_is_dualspeed - return true iff the hardware handles high speed
  * @g: controller that might support both high and full speeds
  */
diff --git a/include/linux/usb/musb.h b/include/linux/usb/musb.h
index eb505250940a..a4ee1b582183 100644
--- a/include/linux/usb/musb.h
+++ b/include/linux/usb/musb.h
@@ -76,6 +76,9 @@ struct musb_hdrc_config {
         unsigned        dma:1 __deprecated; /* supports DMA */
         unsigned        vendor_req:1 __deprecated; /* vendor registers required */
 
+        /* need to explicitly de-assert the port reset after resume? */
+        unsigned        host_port_deassert_reset_at_resume:1;
+
         u8              num_eps;        /* number of endpoints _with_ ep0 */
         u8              dma_channels __deprecated; /* number of dma channels */
         u8              dyn_fifo_size;  /* dynamic size in bytes */
diff --git a/include/linux/usb/omap_control_usb.h b/include/linux/usb/omap_control_usb.h
index 596b01918813..69ae383ee3cc 100644
--- a/include/linux/usb/omap_control_usb.h
+++ b/include/linux/usb/omap_control_usb.h
@@ -24,6 +24,7 @@ enum omap_control_usb_type {
         OMAP_CTRL_TYPE_USB2,    /* USB2_PHY, power down in CONTROL_DEV_CONF */
         OMAP_CTRL_TYPE_PIPE3,   /* PIPE3 PHY, DPLL & seperate Rx/Tx power */
         OMAP_CTRL_TYPE_DRA7USB2, /* USB2 PHY, power and power_aux e.g. DRA7 */
+        OMAP_CTRL_TYPE_AM437USB2, /* USB2 PHY, power e.g. AM437x */
 };
 
 struct omap_control_usb {
@@ -64,6 +65,11 @@ enum omap_control_usb_mode {
 
 #define OMAP_CTRL_USB2_PHY_PD           BIT(28)
 
+#define AM437X_CTRL_USB2_PHY_PD         BIT(0)
+#define AM437X_CTRL_USB2_OTG_PD         BIT(1)
+#define AM437X_CTRL_USB2_OTGVDET_EN     BIT(19)
+#define AM437X_CTRL_USB2_OTGSESSEND_EN  BIT(20)
+
 #if IS_ENABLED(CONFIG_OMAP_CONTROL_USB)
 extern void omap_control_usb_phy_power(struct device *dev, int on);
 extern void omap_control_usb_set_mode(struct device *dev,
diff --git a/include/linux/usb/otg-fsm.h b/include/linux/usb/otg-fsm.h
new file mode 100644
index 000000000000..b6ba1bfb86f2
--- /dev/null
+++ b/include/linux/usb/otg-fsm.h
@@ -0,0 +1,244 @@
+/* Copyright (C) 2007,2008 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the  GNU General Public License along
+ * with this program; if not, write  to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LINUX_USB_OTG_FSM_H
+#define __LINUX_USB_OTG_FSM_H
+
+#include <linux/mutex.h>
+#include <linux/errno.h>
+
+#undef VERBOSE
+
+#ifdef VERBOSE
+#define VDBG(fmt, args...) pr_debug("[%s]  " fmt , \
+                                 __func__, ## args)
+#else
+#define VDBG(stuff...)  do {} while (0)
+#endif
+
+#ifdef VERBOSE
+#define MPC_LOC printk("Current Location [%s]:[%d]\n", __FILE__, __LINE__)
+#else
+#define MPC_LOC do {} while (0)
+#endif
+
+#define PROTO_UNDEF     (0)
+#define PROTO_HOST      (1)
+#define PROTO_GADGET    (2)
+
+enum otg_fsm_timer {
+        /* Standard OTG timers */
+        A_WAIT_VRISE,
+        A_WAIT_VFALL,
+        A_WAIT_BCON,
+        A_AIDL_BDIS,
+        B_ASE0_BRST,
+        A_BIDL_ADIS,
+
+        /* Auxiliary timers */
+        B_SE0_SRP,
+        B_SRP_FAIL,
+        A_WAIT_ENUM,
+
+        NUM_OTG_FSM_TIMERS,
+};
+
+/* OTG state machine according to the OTG spec */
+struct otg_fsm {
+        /* Input */
+        int id;
+        int adp_change;
+        int power_up;
+        int test_device;
+        int a_bus_drop;
+        int a_bus_req;
+        int a_srp_det;
+        int a_vbus_vld;
+        int b_conn;
+        int a_bus_resume;
+        int a_bus_suspend;
+        int a_conn;
+        int b_bus_req;
+        int b_se0_srp;
+        int b_ssend_srp;
+        int b_sess_vld;
+        /* Auxilary inputs */
+        int a_sess_vld;
+        int b_bus_resume;
+        int b_bus_suspend;
+
+        /* Output */
+        int data_pulse;
+        int drv_vbus;
+        int loc_conn;
+        int loc_sof;
+        int adp_prb;
+        int adp_sns;
+
+        /* Internal variables */
+        int a_set_b_hnp_en;
+        int b_srp_done;
+        int b_hnp_enable;
+        int a_clr_err;
+
+        /* Informative variables */
+        int a_bus_drop_inf;
+        int a_bus_req_inf;
+        int a_clr_err_inf;
+        int b_bus_req_inf;
+        /* Auxilary informative variables */
+        int a_suspend_req_inf;
+
+        /* Timeout indicator for timers */
+        int a_wait_vrise_tmout;
+        int a_wait_vfall_tmout;
+        int a_wait_bcon_tmout;
+        int a_aidl_bdis_tmout;
+        int b_ase0_brst_tmout;
+        int a_bidl_adis_tmout;
+
+        struct otg_fsm_ops *ops;
+        struct usb_otg *otg;
+
+        /* Current usb protocol used: 0:undefine; 1:host; 2:client */
+        int protocol;
+        struct mutex lock;
+};
+
+struct otg_fsm_ops {
+        void    (*chrg_vbus)(struct otg_fsm *fsm, int on);
+        void    (*drv_vbus)(struct otg_fsm *fsm, int on);
+        void    (*loc_conn)(struct otg_fsm *fsm, int on);
+        void    (*loc_sof)(struct otg_fsm *fsm, int on);
+        void    (*start_pulse)(struct otg_fsm *fsm);
+        void    (*start_adp_prb)(struct otg_fsm *fsm);
+        void    (*start_adp_sns)(struct otg_fsm *fsm);
+        void    (*add_timer)(struct otg_fsm *fsm, enum otg_fsm_timer timer);
+        void    (*del_timer)(struct otg_fsm *fsm, enum otg_fsm_timer timer);
+        int     (*start_host)(struct otg_fsm *fsm, int on);
+        int     (*start_gadget)(struct otg_fsm *fsm, int on);
+};
+
+
+static inline int otg_chrg_vbus(struct otg_fsm *fsm, int on)
+{
+        if (!fsm->ops->chrg_vbus)
+                return -EOPNOTSUPP;
+        fsm->ops->chrg_vbus(fsm, on);
+        return 0;
+}
+
+static inline int otg_drv_vbus(struct otg_fsm *fsm, int on)
+{
+        if (!fsm->ops->drv_vbus)
+                return -EOPNOTSUPP;
+        if (fsm->drv_vbus != on) {
+                fsm->drv_vbus = on;
+                fsm->ops->drv_vbus(fsm, on);
+        }
+        return 0;
+}
+
+static inline int otg_loc_conn(struct otg_fsm *fsm, int on)
+{
+        if (!fsm->ops->loc_conn)
+                return -EOPNOTSUPP;
+        if (fsm->loc_conn != on) {
+                fsm->loc_conn = on;
+                fsm->ops->loc_conn(fsm, on);
+        }
+        return 0;
+}
+
+static inline int otg_loc_sof(struct otg_fsm *fsm, int on)
+{
+        if (!fsm->ops->loc_sof)
+                return -EOPNOTSUPP;
+        if (fsm->loc_sof != on) {
+                fsm->loc_sof = on;
+                fsm->ops->loc_sof(fsm, on);
+        }
+        return 0;
+}
+
+static inline int otg_start_pulse(struct otg_fsm *fsm)
+{
+        if (!fsm->ops->start_pulse)
+                return -EOPNOTSUPP;
+        if (!fsm->data_pulse) {
+                fsm->data_pulse = 1;
+                fsm->ops->start_pulse(fsm);
+        }
+        return 0;
+}
+
+static inline int otg_start_adp_prb(struct otg_fsm *fsm)
+{
+        if (!fsm->ops->start_adp_prb)
+                return -EOPNOTSUPP;
+        if (!fsm->adp_prb) {
+                fsm->adp_sns = 0;
+                fsm->adp_prb = 1;
+                fsm->ops->start_adp_prb(fsm);
+        }
+        return 0;
+}
+
+static inline int otg_start_adp_sns(struct otg_fsm *fsm)
+{
+        if (!fsm->ops->start_adp_sns)
+                return -EOPNOTSUPP;
+        if (!fsm->adp_sns) {
+                fsm->adp_sns = 1;
+                fsm->ops->start_adp_sns(fsm);
+        }
+        return 0;
+}
+
+static inline int otg_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer timer)
+{
+        if (!fsm->ops->add_timer)
+                return -EOPNOTSUPP;
+        fsm->ops->add_timer(fsm, timer);
+        return 0;
+}
+
+static inline int otg_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer timer)
+{
+        if (!fsm->ops->del_timer)
+                return -EOPNOTSUPP;
+        fsm->ops->del_timer(fsm, timer);
+        return 0;
+}
+
+static inline int otg_start_host(struct otg_fsm *fsm, int on)
+{
+        if (!fsm->ops->start_host)
+                return -EOPNOTSUPP;
+        return fsm->ops->start_host(fsm, on);
+}
+
+static inline int otg_start_gadget(struct otg_fsm *fsm, int on)
+{
+        if (!fsm->ops->start_gadget)
+                return -EOPNOTSUPP;
+        return fsm->ops->start_gadget(fsm, on);
+}
+
+int otg_statemachine(struct otg_fsm *fsm);
+
+#endif /* __LINUX_USB_OTG_FSM_H */