aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/gadget
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2014-12-14 17:57:16 -0500
committerLinus Torvalds <torvalds@linux-foundation.org>2014-12-14 17:57:16 -0500
commite7cf773d431a63a2417902696fcc9e0ebdc83bbe (patch)
tree86dbdceb7d91226507a3af0d57e03b0ca664b22e /drivers/usb/gadget
parent7a02d089695a1217992434f03a78aa32bad85b5c (diff)
parent81e1dadfb5b2d47aa513ad60b1c9cf0ea17b6514 (diff)
Merge tag 'usb-3.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
Pull USB updates from Greg KH: "Here's the big set of USB and PHY patches for 3.19-rc1. The normal churn in the USB gadget area is in here, as well as xhci and other individual USB driver updates. The PHY tree is also in here, as there were dependancies on the USB tree. All of these have been in linux-next" * tag 'usb-3.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (351 commits) arm: omap3: twl: remove usb phy init data usbip: fix error handling in stub_probe() usb: gadget: udc: missing curly braces USB: mos7720: delete some unneeded code wusb: replace memset by memzero_explicit usbip: remove unneeded structure usb: xhci: fix comment for PORT_DEV_REMOVE xhci: don't use the same variable for stopped and halted rings current TD xhci: clear extra bits from slot context when setting max exit latency xhci: cleanup finish_td function USB: adutux: NULL dereferences on disconnect usb: chipidea: fix platform_no_drv_owner.cocci warnings usb: chipidea: Fixed a few typos in comments Documentation: bindings: add doc for the USB2 ChipIdea USB driver usb: chipidea: add a usb2 driver for ci13xxx usb: chipidea: fix phy handling usb: chipidea: remove duplicate dev_set_drvdata for host_start usb: chipidea: parameter 'mode' isn't needed for hw_device_reset usb: chipidea: add controller reset API usb: chipidea: remove flag CI_HDRC_REQUIRE_TRANSCEIVER ...
Diffstat (limited to 'drivers/usb/gadget')
-rw-r--r--drivers/usb/gadget/Kconfig61
-rw-r--r--drivers/usb/gadget/composite.c64
-rw-r--r--drivers/usb/gadget/configfs.c5
-rw-r--r--drivers/usb/gadget/function/Makefile4
-rw-r--r--drivers/usb/gadget/function/f_hid.c374
-rw-r--r--drivers/usb/gadget/function/f_midi.c364
-rw-r--r--drivers/usb/gadget/function/f_ncm.c3
-rw-r--r--drivers/usb/gadget/function/f_rndis.c3
-rw-r--r--drivers/usb/gadget/function/u_hid.h42
-rw-r--r--drivers/usb/gadget/function/u_midi.h40
-rw-r--r--drivers/usb/gadget/function/u_uac1.c3
-rw-r--r--drivers/usb/gadget/legacy/Kconfig2
-rw-r--r--drivers/usb/gadget/legacy/dbgp.c26
-rw-r--r--drivers/usb/gadget/legacy/gmidi.c43
-rw-r--r--drivers/usb/gadget/legacy/hid.c79
-rw-r--r--drivers/usb/gadget/legacy/printer.c65
-rw-r--r--drivers/usb/gadget/udc/Kconfig2
-rw-r--r--drivers/usb/gadget/udc/Makefile1
-rw-r--r--drivers/usb/gadget/udc/amd5536udc.c12
-rw-r--r--drivers/usb/gadget/udc/at91_udc.c89
-rw-r--r--drivers/usb/gadget/udc/atmel_usba_udc.c25
-rw-r--r--drivers/usb/gadget/udc/bcm63xx_udc.c13
-rw-r--r--drivers/usb/gadget/udc/bdc/Kconfig21
-rw-r--r--drivers/usb/gadget/udc/bdc/Makefile8
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc.h490
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_cmd.c376
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_cmd.h29
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_core.c533
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_dbg.c123
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_dbg.h37
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_ep.c2024
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_ep.h22
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_pci.c132
-rw-r--r--drivers/usb/gadget/udc/bdc/bdc_udc.c587
-rw-r--r--drivers/usb/gadget/udc/dummy_hcd.c36
-rw-r--r--drivers/usb/gadget/udc/fotg210-udc.c3
-rw-r--r--drivers/usb/gadget/udc/fsl_qe_udc.c13
-rw-r--r--drivers/usb/gadget/udc/fsl_udc_core.c19
-rw-r--r--drivers/usb/gadget/udc/fusb300_udc.c3
-rw-r--r--drivers/usb/gadget/udc/goku_udc.c6
-rw-r--r--drivers/usb/gadget/udc/gr_udc.c8
-rw-r--r--drivers/usb/gadget/udc/lpc32xx_udc.c11
-rw-r--r--drivers/usb/gadget/udc/m66592-udc.c5
-rw-r--r--drivers/usb/gadget/udc/mv_u3d_core.c5
-rw-r--r--drivers/usb/gadget/udc/mv_udc_core.c32
-rw-r--r--drivers/usb/gadget/udc/net2272.c66
-rw-r--r--drivers/usb/gadget/udc/net2280.c65
-rw-r--r--drivers/usb/gadget/udc/omap_udc.c6
-rw-r--r--drivers/usb/gadget/udc/pch_udc.c11
-rw-r--r--drivers/usb/gadget/udc/pxa25x_udc.c43
-rw-r--r--drivers/usb/gadget/udc/pxa27x_udc.c152
-rw-r--r--drivers/usb/gadget/udc/pxa27x_udc.h6
-rw-r--r--drivers/usb/gadget/udc/r8a66597-udc.c10
-rw-r--r--drivers/usb/gadget/udc/s3c-hsudc.c16
-rw-r--r--drivers/usb/gadget/udc/s3c2410_udc.c6
-rw-r--r--drivers/usb/gadget/udc/udc-core.c28
-rw-r--r--drivers/usb/gadget/udc/udc-xilinx.c3
57 files changed, 5692 insertions, 563 deletions
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index c4880fc0d86e..747ef53bda14 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -190,6 +190,12 @@ config USB_F_UAC2
190config USB_F_UVC 190config USB_F_UVC
191 tristate 191 tristate
192 192
193config USB_F_MIDI
194 tristate
195
196config USB_F_HID
197 tristate
198
193choice 199choice
194 tristate "USB Gadget Drivers" 200 tristate "USB Gadget Drivers"
195 default USB_ETH 201 default USB_ETH
@@ -362,6 +368,61 @@ config USB_CONFIGFS_F_FS
362 implemented in kernel space (for instance Ethernet, serial or 368 implemented in kernel space (for instance Ethernet, serial or
363 mass storage) and other are implemented in user space. 369 mass storage) and other are implemented in user space.
364 370
371config USB_CONFIGFS_F_UAC1
372 boolean "Audio Class 1.0"
373 depends on USB_CONFIGFS
374 depends on SND
375 select USB_LIBCOMPOSITE
376 select SND_PCM
377 select USB_F_UAC1
378 help
379 This Audio function implements 1 AudioControl interface,
380 1 AudioStreaming Interface each for USB-OUT and USB-IN.
381 This driver requires a real Audio codec to be present
382 on the device.
383
384config USB_CONFIGFS_F_UAC2
385 boolean "Audio Class 2.0"
386 depends on USB_CONFIGFS
387 depends on SND
388 select USB_LIBCOMPOSITE
389 select SND_PCM
390 select USB_F_UAC2
391 help
392 This Audio function is compatible with USB Audio Class
393 specification 2.0. It implements 1 AudioControl interface,
394 1 AudioStreaming Interface each for USB-OUT and USB-IN.
395 This driver doesn't expect any real Audio codec to be present
396 on the device - the audio streams are simply sinked to and
397 sourced from a virtual ALSA sound card created. The user-space
398 application may choose to do whatever it wants with the data
399 received from the USB Host and choose to provide whatever it
400 wants as audio data to the USB Host.
401
402config USB_CONFIGFS_F_MIDI
403 boolean "MIDI function"
404 depends on USB_CONFIGFS
405 depends on SND
406 select USB_LIBCOMPOSITE
407 select SND_RAWMIDI
408 select USB_F_MIDI
409 help
410 The MIDI Function acts as a USB Audio device, with one MIDI
411 input and one MIDI output. These MIDI jacks appear as
412 a sound "card" in the ALSA sound system. Other MIDI
413 connections can then be made on the gadget system, using
414 ALSA's aconnect utility etc.
415
416config USB_CONFIGFS_F_HID
417 boolean "HID function"
418 depends on USB_CONFIGFS
419 select USB_F_HID
420 help
421 The HID function driver provides generic emulation of USB
422 Human Interface Devices (HID).
423
424 For more information, see Documentation/usb/gadget_hid.txt.
425
365source "drivers/usb/gadget/legacy/Kconfig" 426source "drivers/usb/gadget/legacy/Kconfig"
366 427
367endchoice 428endchoice
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index f6a51fddd5b5..617835348569 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -1246,10 +1246,49 @@ EXPORT_SYMBOL_GPL(usb_string_ids_n);
1246 1246
1247static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req) 1247static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
1248{ 1248{
1249 struct usb_composite_dev *cdev;
1250
1249 if (req->status || req->actual != req->length) 1251 if (req->status || req->actual != req->length)
1250 DBG((struct usb_composite_dev *) ep->driver_data, 1252 DBG((struct usb_composite_dev *) ep->driver_data,
1251 "setup complete --> %d, %d/%d\n", 1253 "setup complete --> %d, %d/%d\n",
1252 req->status, req->actual, req->length); 1254 req->status, req->actual, req->length);
1255
1256 /*
1257 * REVIST The same ep0 requests are shared with function drivers
1258 * so they don't have to maintain the same ->complete() stubs.
1259 *
1260 * Because of that, we need to check for the validity of ->context
1261 * here, even though we know we've set it to something useful.
1262 */
1263 if (!req->context)
1264 return;
1265
1266 cdev = req->context;
1267
1268 if (cdev->req == req)
1269 cdev->setup_pending = false;
1270 else if (cdev->os_desc_req == req)
1271 cdev->os_desc_pending = false;
1272 else
1273 WARN(1, "unknown request %p\n", req);
1274}
1275
1276static int composite_ep0_queue(struct usb_composite_dev *cdev,
1277 struct usb_request *req, gfp_t gfp_flags)
1278{
1279 int ret;
1280
1281 ret = usb_ep_queue(cdev->gadget->ep0, req, gfp_flags);
1282 if (ret == 0) {
1283 if (cdev->req == req)
1284 cdev->setup_pending = true;
1285 else if (cdev->os_desc_req == req)
1286 cdev->os_desc_pending = true;
1287 else
1288 WARN(1, "unknown request %p\n", req);
1289 }
1290
1291 return ret;
1253} 1292}
1254 1293
1255static int count_ext_compat(struct usb_configuration *c) 1294static int count_ext_compat(struct usb_configuration *c)
@@ -1428,6 +1467,7 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1428 * when we delegate to it. 1467 * when we delegate to it.
1429 */ 1468 */
1430 req->zero = 0; 1469 req->zero = 0;
1470 req->context = cdev;
1431 req->complete = composite_setup_complete; 1471 req->complete = composite_setup_complete;
1432 req->length = 0; 1472 req->length = 0;
1433 gadget->ep0->driver_data = cdev; 1473 gadget->ep0->driver_data = cdev;
@@ -1624,6 +1664,7 @@ unknown:
1624 int count = 0; 1664 int count = 0;
1625 1665
1626 req = cdev->os_desc_req; 1666 req = cdev->os_desc_req;
1667 req->context = cdev;
1627 req->complete = composite_setup_complete; 1668 req->complete = composite_setup_complete;
1628 buf = req->buf; 1669 buf = req->buf;
1629 os_desc_cfg = cdev->os_desc_config; 1670 os_desc_cfg = cdev->os_desc_config;
@@ -1686,8 +1727,9 @@ unknown:
1686 break; 1727 break;
1687 } 1728 }
1688 req->length = value; 1729 req->length = value;
1730 req->context = cdev;
1689 req->zero = value < w_length; 1731 req->zero = value < w_length;
1690 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC); 1732 value = composite_ep0_queue(cdev, req, GFP_ATOMIC);
1691 if (value < 0) { 1733 if (value < 0) {
1692 DBG(cdev, "ep_queue --> %d\n", value); 1734 DBG(cdev, "ep_queue --> %d\n", value);
1693 req->status = 0; 1735 req->status = 0;
@@ -1757,8 +1799,9 @@ unknown:
1757 /* respond with data transfer before status phase? */ 1799 /* respond with data transfer before status phase? */
1758 if (value >= 0 && value != USB_GADGET_DELAYED_STATUS) { 1800 if (value >= 0 && value != USB_GADGET_DELAYED_STATUS) {
1759 req->length = value; 1801 req->length = value;
1802 req->context = cdev;
1760 req->zero = value < w_length; 1803 req->zero = value < w_length;
1761 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC); 1804 value = composite_ep0_queue(cdev, req, GFP_ATOMIC);
1762 if (value < 0) { 1805 if (value < 0) {
1763 DBG(cdev, "ep_queue --> %d\n", value); 1806 DBG(cdev, "ep_queue --> %d\n", value);
1764 req->status = 0; 1807 req->status = 0;
@@ -1893,6 +1936,7 @@ int composite_dev_prepare(struct usb_composite_driver *composite,
1893 goto fail_dev; 1936 goto fail_dev;
1894 1937
1895 cdev->req->complete = composite_setup_complete; 1938 cdev->req->complete = composite_setup_complete;
1939 cdev->req->context = cdev;
1896 gadget->ep0->driver_data = cdev; 1940 gadget->ep0->driver_data = cdev;
1897 1941
1898 cdev->driver = composite; 1942 cdev->driver = composite;
@@ -1937,6 +1981,7 @@ int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
1937 kfree(cdev->os_desc_req); 1981 kfree(cdev->os_desc_req);
1938 goto end; 1982 goto end;
1939 } 1983 }
1984 cdev->os_desc_req->context = cdev;
1940 cdev->os_desc_req->complete = composite_setup_complete; 1985 cdev->os_desc_req->complete = composite_setup_complete;
1941end: 1986end:
1942 return ret; 1987 return ret;
@@ -1951,10 +1996,16 @@ void composite_dev_cleanup(struct usb_composite_dev *cdev)
1951 kfree(uc); 1996 kfree(uc);
1952 } 1997 }
1953 if (cdev->os_desc_req) { 1998 if (cdev->os_desc_req) {
1999 if (cdev->os_desc_pending)
2000 usb_ep_dequeue(cdev->gadget->ep0, cdev->os_desc_req);
2001
1954 kfree(cdev->os_desc_req->buf); 2002 kfree(cdev->os_desc_req->buf);
1955 usb_ep_free_request(cdev->gadget->ep0, cdev->os_desc_req); 2003 usb_ep_free_request(cdev->gadget->ep0, cdev->os_desc_req);
1956 } 2004 }
1957 if (cdev->req) { 2005 if (cdev->req) {
2006 if (cdev->setup_pending)
2007 usb_ep_dequeue(cdev->gadget->ep0, cdev->req);
2008
1958 kfree(cdev->req->buf); 2009 kfree(cdev->req->buf);
1959 usb_ep_free_request(cdev->gadget->ep0, cdev->req); 2010 usb_ep_free_request(cdev->gadget->ep0, cdev->req);
1960 } 2011 }
@@ -2013,8 +2064,7 @@ fail:
2013 2064
2014/*-------------------------------------------------------------------------*/ 2065/*-------------------------------------------------------------------------*/
2015 2066
2016static void 2067void composite_suspend(struct usb_gadget *gadget)
2017composite_suspend(struct usb_gadget *gadget)
2018{ 2068{
2019 struct usb_composite_dev *cdev = get_gadget_data(gadget); 2069 struct usb_composite_dev *cdev = get_gadget_data(gadget);
2020 struct usb_function *f; 2070 struct usb_function *f;
@@ -2037,8 +2087,7 @@ composite_suspend(struct usb_gadget *gadget)
2037 usb_gadget_vbus_draw(gadget, 2); 2087 usb_gadget_vbus_draw(gadget, 2);
2038} 2088}
2039 2089
2040static void 2090void composite_resume(struct usb_gadget *gadget)
2041composite_resume(struct usb_gadget *gadget)
2042{ 2091{
2043 struct usb_composite_dev *cdev = get_gadget_data(gadget); 2092 struct usb_composite_dev *cdev = get_gadget_data(gadget);
2044 struct usb_function *f; 2093 struct usb_function *f;
@@ -2158,7 +2207,8 @@ void usb_composite_setup_continue(struct usb_composite_dev *cdev)
2158 } else if (--cdev->delayed_status == 0) { 2207 } else if (--cdev->delayed_status == 0) {
2159 DBG(cdev, "%s: Completing delayed status\n", __func__); 2208 DBG(cdev, "%s: Completing delayed status\n", __func__);
2160 req->length = 0; 2209 req->length = 0;
2161 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC); 2210 req->context = cdev;
2211 value = composite_ep0_queue(cdev, req, GFP_ATOMIC);
2162 if (value < 0) { 2212 if (value < 0) {
2163 DBG(cdev, "ep_queue --> %d\n", value); 2213 DBG(cdev, "ep_queue --> %d\n", value);
2164 req->status = 0; 2214 req->status = 0;
diff --git a/drivers/usb/gadget/configfs.c b/drivers/usb/gadget/configfs.c
index 34034333f7f6..75648145dc1b 100644
--- a/drivers/usb/gadget/configfs.c
+++ b/drivers/usb/gadget/configfs.c
@@ -271,7 +271,7 @@ static ssize_t gadget_dev_desc_UDC_store(struct gadget_info *gi,
271 ret = -EBUSY; 271 ret = -EBUSY;
272 goto err; 272 goto err;
273 } 273 }
274 ret = udc_attach_driver(name, &gi->composite.gadget_driver); 274 ret = usb_udc_attach_driver(name, &gi->composite.gadget_driver);
275 if (ret) 275 if (ret)
276 goto err; 276 goto err;
277 gi->udc_name = name; 277 gi->udc_name = name;
@@ -1453,6 +1453,9 @@ static const struct usb_gadget_driver configfs_driver_template = {
1453 .reset = composite_disconnect, 1453 .reset = composite_disconnect,
1454 .disconnect = composite_disconnect, 1454 .disconnect = composite_disconnect,
1455 1455
1456 .suspend = composite_suspend,
1457 .resume = composite_resume,
1458
1456 .max_speed = USB_SPEED_SUPER, 1459 .max_speed = USB_SPEED_SUPER,
1457 .driver = { 1460 .driver = {
1458 .owner = THIS_MODULE, 1461 .owner = THIS_MODULE,
diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
index 90701aa5a826..dd68091d92f0 100644
--- a/drivers/usb/gadget/function/Makefile
+++ b/drivers/usb/gadget/function/Makefile
@@ -38,3 +38,7 @@ usb_f_uac2-y := f_uac2.o
38obj-$(CONFIG_USB_F_UAC2) += usb_f_uac2.o 38obj-$(CONFIG_USB_F_UAC2) += usb_f_uac2.o
39usb_f_uvc-y := f_uvc.o uvc_queue.o uvc_v4l2.o uvc_video.o 39usb_f_uvc-y := f_uvc.o uvc_queue.o uvc_v4l2.o uvc_video.o
40obj-$(CONFIG_USB_F_UVC) += usb_f_uvc.o 40obj-$(CONFIG_USB_F_UVC) += usb_f_uvc.o
41usb_f_midi-y := f_midi.o
42obj-$(CONFIG_USB_F_MIDI) += usb_f_midi.o
43usb_f_hid-y := f_hid.o
44obj-$(CONFIG_USB_F_HID) += usb_f_hid.o
diff --git a/drivers/usb/gadget/function/f_hid.c b/drivers/usb/gadget/function/f_hid.c
index ea2b9c374305..6e04e302dc3a 100644
--- a/drivers/usb/gadget/function/f_hid.c
+++ b/drivers/usb/gadget/function/f_hid.c
@@ -12,6 +12,7 @@
12#include <linux/kernel.h> 12#include <linux/kernel.h>
13#include <linux/module.h> 13#include <linux/module.h>
14#include <linux/hid.h> 14#include <linux/hid.h>
15#include <linux/idr.h>
15#include <linux/cdev.h> 16#include <linux/cdev.h>
16#include <linux/mutex.h> 17#include <linux/mutex.h>
17#include <linux/poll.h> 18#include <linux/poll.h>
@@ -21,9 +22,14 @@
21#include <linux/usb/g_hid.h> 22#include <linux/usb/g_hid.h>
22 23
23#include "u_f.h" 24#include "u_f.h"
25#include "u_hid.h"
26
27#define HIDG_MINORS 4
24 28
25static int major, minors; 29static int major, minors;
26static struct class *hidg_class; 30static struct class *hidg_class;
31static DEFINE_IDA(hidg_ida);
32static DEFINE_MUTEX(hidg_ida_lock); /* protects access to hidg_ida */
27 33
28/*-------------------------------------------------------------------------*/ 34/*-------------------------------------------------------------------------*/
29/* HID gadget struct */ 35/* HID gadget struct */
@@ -161,6 +167,26 @@ static struct usb_descriptor_header *hidg_fs_descriptors[] = {
161}; 167};
162 168
163/*-------------------------------------------------------------------------*/ 169/*-------------------------------------------------------------------------*/
170/* Strings */
171
172#define CT_FUNC_HID_IDX 0
173
174static struct usb_string ct_func_string_defs[] = {
175 [CT_FUNC_HID_IDX].s = "HID Interface",
176 {}, /* end of list */
177};
178
179static struct usb_gadget_strings ct_func_string_table = {
180 .language = 0x0409, /* en-US */
181 .strings = ct_func_string_defs,
182};
183
184static struct usb_gadget_strings *ct_func_strings[] = {
185 &ct_func_string_table,
186 NULL,
187};
188
189/*-------------------------------------------------------------------------*/
164/* Char Device */ 190/* Char Device */
165 191
166static ssize_t f_hidg_read(struct file *file, char __user *buffer, 192static ssize_t f_hidg_read(struct file *file, char __user *buffer,
@@ -552,13 +578,22 @@ const struct file_operations f_hidg_fops = {
552 .llseek = noop_llseek, 578 .llseek = noop_llseek,
553}; 579};
554 580
555static int __init hidg_bind(struct usb_configuration *c, struct usb_function *f) 581static int hidg_bind(struct usb_configuration *c, struct usb_function *f)
556{ 582{
557 struct usb_ep *ep; 583 struct usb_ep *ep;
558 struct f_hidg *hidg = func_to_hidg(f); 584 struct f_hidg *hidg = func_to_hidg(f);
585 struct usb_string *us;
586 struct device *device;
559 int status; 587 int status;
560 dev_t dev; 588 dev_t dev;
561 589
590 /* maybe allocate device-global string IDs, and patch descriptors */
591 us = usb_gstrings_attach(c->cdev, ct_func_strings,
592 ARRAY_SIZE(ct_func_string_defs));
593 if (IS_ERR(us))
594 return PTR_ERR(us);
595 hidg_interface_desc.iInterface = us[CT_FUNC_HID_IDX].id;
596
562 /* allocate instance-specific interface IDs, and patch descriptors */ 597 /* allocate instance-specific interface IDs, and patch descriptors */
563 status = usb_interface_id(c, f); 598 status = usb_interface_id(c, f);
564 if (status < 0) 599 if (status < 0)
@@ -623,10 +658,16 @@ static int __init hidg_bind(struct usb_configuration *c, struct usb_function *f)
623 if (status) 658 if (status)
624 goto fail_free_descs; 659 goto fail_free_descs;
625 660
626 device_create(hidg_class, NULL, dev, NULL, "%s%d", "hidg", hidg->minor); 661 device = device_create(hidg_class, NULL, dev, NULL,
662 "%s%d", "hidg", hidg->minor);
663 if (IS_ERR(device)) {
664 status = PTR_ERR(device);
665 goto del;
666 }
627 667
628 return 0; 668 return 0;
629 669del:
670 cdev_del(&hidg->cdev);
630fail_free_descs: 671fail_free_descs:
631 usb_free_all_descriptors(f); 672 usb_free_all_descriptors(f);
632fail: 673fail:
@@ -640,116 +681,313 @@ fail:
640 return status; 681 return status;
641} 682}
642 683
643static void hidg_unbind(struct usb_configuration *c, struct usb_function *f) 684static inline int hidg_get_minor(void)
644{ 685{
645 struct f_hidg *hidg = func_to_hidg(f); 686 int ret;
646 687
647 device_destroy(hidg_class, MKDEV(major, hidg->minor)); 688 ret = ida_simple_get(&hidg_ida, 0, 0, GFP_KERNEL);
648 cdev_del(&hidg->cdev);
649 689
650 /* disable/free request and end point */ 690 return ret;
651 usb_ep_disable(hidg->in_ep); 691}
652 usb_ep_dequeue(hidg->in_ep, hidg->req);
653 kfree(hidg->req->buf);
654 usb_ep_free_request(hidg->in_ep, hidg->req);
655
656 usb_free_all_descriptors(f);
657 692
658 kfree(hidg->report_desc); 693static inline struct f_hid_opts *to_f_hid_opts(struct config_item *item)
659 kfree(hidg); 694{
695 return container_of(to_config_group(item), struct f_hid_opts,
696 func_inst.group);
660} 697}
661 698
662/*-------------------------------------------------------------------------*/ 699CONFIGFS_ATTR_STRUCT(f_hid_opts);
663/* Strings */ 700CONFIGFS_ATTR_OPS(f_hid_opts);
664 701
665#define CT_FUNC_HID_IDX 0 702static void hid_attr_release(struct config_item *item)
703{
704 struct f_hid_opts *opts = to_f_hid_opts(item);
666 705
667static struct usb_string ct_func_string_defs[] = { 706 usb_put_function_instance(&opts->func_inst);
668 [CT_FUNC_HID_IDX].s = "HID Interface", 707}
669 {}, /* end of list */
670};
671 708
672static struct usb_gadget_strings ct_func_string_table = { 709static struct configfs_item_operations hidg_item_ops = {
673 .language = 0x0409, /* en-US */ 710 .release = hid_attr_release,
674 .strings = ct_func_string_defs, 711 .show_attribute = f_hid_opts_attr_show,
712 .store_attribute = f_hid_opts_attr_store,
675}; 713};
676 714
677static struct usb_gadget_strings *ct_func_strings[] = { 715#define F_HID_OPT(name, prec, limit) \
678 &ct_func_string_table, 716static ssize_t f_hid_opts_##name##_show(struct f_hid_opts *opts, char *page)\
717{ \
718 int result; \
719 \
720 mutex_lock(&opts->lock); \
721 result = sprintf(page, "%d\n", opts->name); \
722 mutex_unlock(&opts->lock); \
723 \
724 return result; \
725} \
726 \
727static ssize_t f_hid_opts_##name##_store(struct f_hid_opts *opts, \
728 const char *page, size_t len) \
729{ \
730 int ret; \
731 u##prec num; \
732 \
733 mutex_lock(&opts->lock); \
734 if (opts->refcnt) { \
735 ret = -EBUSY; \
736 goto end; \
737 } \
738 \
739 ret = kstrtou##prec(page, 0, &num); \
740 if (ret) \
741 goto end; \
742 \
743 if (num > limit) { \
744 ret = -EINVAL; \
745 goto end; \
746 } \
747 opts->name = num; \
748 ret = len; \
749 \
750end: \
751 mutex_unlock(&opts->lock); \
752 return ret; \
753} \
754 \
755static struct f_hid_opts_attribute f_hid_opts_##name = \
756 __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR, f_hid_opts_##name##_show,\
757 f_hid_opts_##name##_store)
758
759F_HID_OPT(subclass, 8, 255);
760F_HID_OPT(protocol, 8, 255);
761F_HID_OPT(report_length, 16, 65536);
762
763static ssize_t f_hid_opts_report_desc_show(struct f_hid_opts *opts, char *page)
764{
765 int result;
766
767 mutex_lock(&opts->lock);
768 result = opts->report_desc_length;
769 memcpy(page, opts->report_desc, opts->report_desc_length);
770 mutex_unlock(&opts->lock);
771
772 return result;
773}
774
775static ssize_t f_hid_opts_report_desc_store(struct f_hid_opts *opts,
776 const char *page, size_t len)
777{
778 int ret = -EBUSY;
779 char *d;
780
781 mutex_lock(&opts->lock);
782
783 if (opts->refcnt)
784 goto end;
785 if (len > PAGE_SIZE) {
786 ret = -ENOSPC;
787 goto end;
788 }
789 d = kmemdup(page, len, GFP_KERNEL);
790 if (!d) {
791 ret = -ENOMEM;
792 goto end;
793 }
794 kfree(opts->report_desc);
795 opts->report_desc = d;
796 opts->report_desc_length = len;
797 opts->report_desc_alloc = true;
798 ret = len;
799end:
800 mutex_unlock(&opts->lock);
801 return ret;
802}
803
804static struct f_hid_opts_attribute f_hid_opts_report_desc =
805 __CONFIGFS_ATTR(report_desc, S_IRUGO | S_IWUSR,
806 f_hid_opts_report_desc_show,
807 f_hid_opts_report_desc_store);
808
809static struct configfs_attribute *hid_attrs[] = {
810 &f_hid_opts_subclass.attr,
811 &f_hid_opts_protocol.attr,
812 &f_hid_opts_report_length.attr,
813 &f_hid_opts_report_desc.attr,
679 NULL, 814 NULL,
680}; 815};
681 816
682/*-------------------------------------------------------------------------*/ 817static struct config_item_type hid_func_type = {
683/* usb_configuration */ 818 .ct_item_ops = &hidg_item_ops,
819 .ct_attrs = hid_attrs,
820 .ct_owner = THIS_MODULE,
821};
684 822
685int __init hidg_bind_config(struct usb_configuration *c, 823static inline void hidg_put_minor(int minor)
686 struct hidg_func_descriptor *fdesc, int index)
687{ 824{
688 struct f_hidg *hidg; 825 ida_simple_remove(&hidg_ida, minor);
689 int status; 826}
690 827
691 if (index >= minors) 828static void hidg_free_inst(struct usb_function_instance *f)
692 return -ENOENT; 829{
830 struct f_hid_opts *opts;
693 831
694 /* maybe allocate device-global string IDs, and patch descriptors */ 832 opts = container_of(f, struct f_hid_opts, func_inst);
695 if (ct_func_string_defs[CT_FUNC_HID_IDX].id == 0) { 833
696 status = usb_string_id(c->cdev); 834 mutex_lock(&hidg_ida_lock);
697 if (status < 0) 835
698 return status; 836 hidg_put_minor(opts->minor);
699 ct_func_string_defs[CT_FUNC_HID_IDX].id = status; 837 if (idr_is_empty(&hidg_ida.idr))
700 hidg_interface_desc.iInterface = status; 838 ghid_cleanup();
839
840 mutex_unlock(&hidg_ida_lock);
841
842 if (opts->report_desc_alloc)
843 kfree(opts->report_desc);
844
845 kfree(opts);
846}
847
848static struct usb_function_instance *hidg_alloc_inst(void)
849{
850 struct f_hid_opts *opts;
851 struct usb_function_instance *ret;
852 int status = 0;
853
854 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
855 if (!opts)
856 return ERR_PTR(-ENOMEM);
857 mutex_init(&opts->lock);
858 opts->func_inst.free_func_inst = hidg_free_inst;
859 ret = &opts->func_inst;
860
861 mutex_lock(&hidg_ida_lock);
862
863 if (idr_is_empty(&hidg_ida.idr)) {
864 status = ghid_setup(NULL, HIDG_MINORS);
865 if (status) {
866 ret = ERR_PTR(status);
867 kfree(opts);
868 goto unlock;
869 }
870 }
871
872 opts->minor = hidg_get_minor();
873 if (opts->minor < 0) {
874 ret = ERR_PTR(opts->minor);
875 kfree(opts);
876 if (idr_is_empty(&hidg_ida.idr))
877 ghid_cleanup();
878 goto unlock;
701 } 879 }
880 config_group_init_type_name(&opts->func_inst.group, "", &hid_func_type);
881
882unlock:
883 mutex_unlock(&hidg_ida_lock);
884 return ret;
885}
886
887static void hidg_free(struct usb_function *f)
888{
889 struct f_hidg *hidg;
890 struct f_hid_opts *opts;
891
892 hidg = func_to_hidg(f);
893 opts = container_of(f->fi, struct f_hid_opts, func_inst);
894 kfree(hidg->report_desc);
895 kfree(hidg);
896 mutex_lock(&opts->lock);
897 --opts->refcnt;
898 mutex_unlock(&opts->lock);
899}
900
901static void hidg_unbind(struct usb_configuration *c, struct usb_function *f)
902{
903 struct f_hidg *hidg = func_to_hidg(f);
904
905 device_destroy(hidg_class, MKDEV(major, hidg->minor));
906 cdev_del(&hidg->cdev);
907
908 /* disable/free request and end point */
909 usb_ep_disable(hidg->in_ep);
910 usb_ep_dequeue(hidg->in_ep, hidg->req);
911 kfree(hidg->req->buf);
912 usb_ep_free_request(hidg->in_ep, hidg->req);
913
914 usb_free_all_descriptors(f);
915}
916
917static struct usb_function *hidg_alloc(struct usb_function_instance *fi)
918{
919 struct f_hidg *hidg;
920 struct f_hid_opts *opts;
702 921
703 /* allocate and initialize one new instance */ 922 /* allocate and initialize one new instance */
704 hidg = kzalloc(sizeof *hidg, GFP_KERNEL); 923 hidg = kzalloc(sizeof(*hidg), GFP_KERNEL);
705 if (!hidg) 924 if (!hidg)
706 return -ENOMEM; 925 return ERR_PTR(-ENOMEM);
707 926
708 hidg->minor = index; 927 opts = container_of(fi, struct f_hid_opts, func_inst);
709 hidg->bInterfaceSubClass = fdesc->subclass; 928
710 hidg->bInterfaceProtocol = fdesc->protocol; 929 mutex_lock(&opts->lock);
711 hidg->report_length = fdesc->report_length; 930 ++opts->refcnt;
712 hidg->report_desc_length = fdesc->report_desc_length; 931
713 hidg->report_desc = kmemdup(fdesc->report_desc, 932 hidg->minor = opts->minor;
714 fdesc->report_desc_length, 933 hidg->bInterfaceSubClass = opts->subclass;
715 GFP_KERNEL); 934 hidg->bInterfaceProtocol = opts->protocol;
716 if (!hidg->report_desc) { 935 hidg->report_length = opts->report_length;
717 kfree(hidg); 936 hidg->report_desc_length = opts->report_desc_length;
718 return -ENOMEM; 937 if (opts->report_desc) {
938 hidg->report_desc = kmemdup(opts->report_desc,
939 opts->report_desc_length,
940 GFP_KERNEL);
941 if (!hidg->report_desc) {
942 kfree(hidg);
943 mutex_unlock(&opts->lock);
944 return ERR_PTR(-ENOMEM);
945 }
719 } 946 }
720 947
948 mutex_unlock(&opts->lock);
949
721 hidg->func.name = "hid"; 950 hidg->func.name = "hid";
722 hidg->func.strings = ct_func_strings;
723 hidg->func.bind = hidg_bind; 951 hidg->func.bind = hidg_bind;
724 hidg->func.unbind = hidg_unbind; 952 hidg->func.unbind = hidg_unbind;
725 hidg->func.set_alt = hidg_set_alt; 953 hidg->func.set_alt = hidg_set_alt;
726 hidg->func.disable = hidg_disable; 954 hidg->func.disable = hidg_disable;
727 hidg->func.setup = hidg_setup; 955 hidg->func.setup = hidg_setup;
956 hidg->func.free_func = hidg_free;
728 957
729 /* this could me made configurable at some point */ 958 /* this could me made configurable at some point */
730 hidg->qlen = 4; 959 hidg->qlen = 4;
731 960
732 status = usb_add_function(c, &hidg->func); 961 return &hidg->func;
733 if (status)
734 kfree(hidg);
735
736 return status;
737} 962}
738 963
739int __init ghid_setup(struct usb_gadget *g, int count) 964DECLARE_USB_FUNCTION_INIT(hid, hidg_alloc_inst, hidg_alloc);
965MODULE_LICENSE("GPL");
966MODULE_AUTHOR("Fabien Chouteau");
967
968int ghid_setup(struct usb_gadget *g, int count)
740{ 969{
741 int status; 970 int status;
742 dev_t dev; 971 dev_t dev;
743 972
744 hidg_class = class_create(THIS_MODULE, "hidg"); 973 hidg_class = class_create(THIS_MODULE, "hidg");
974 if (IS_ERR(hidg_class)) {
975 status = PTR_ERR(hidg_class);
976 hidg_class = NULL;
977 return status;
978 }
745 979
746 status = alloc_chrdev_region(&dev, 0, count, "hidg"); 980 status = alloc_chrdev_region(&dev, 0, count, "hidg");
747 if (!status) { 981 if (status) {
748 major = MAJOR(dev); 982 class_destroy(hidg_class);
749 minors = count; 983 hidg_class = NULL;
984 return status;
750 } 985 }
751 986
752 return status; 987 major = MAJOR(dev);
988 minors = count;
989
990 return 0;
753} 991}
754 992
755void ghid_cleanup(void) 993void ghid_cleanup(void)
diff --git a/drivers/usb/gadget/function/f_midi.c b/drivers/usb/gadget/function/f_midi.c
index 807b31c0edc3..a90440300735 100644
--- a/drivers/usb/gadget/function/f_midi.c
+++ b/drivers/usb/gadget/function/f_midi.c
@@ -20,6 +20,7 @@
20 */ 20 */
21 21
22#include <linux/kernel.h> 22#include <linux/kernel.h>
23#include <linux/module.h>
23#include <linux/slab.h> 24#include <linux/slab.h>
24#include <linux/device.h> 25#include <linux/device.h>
25 26
@@ -33,6 +34,7 @@
33#include <linux/usb/midi.h> 34#include <linux/usb/midi.h>
34 35
35#include "u_f.h" 36#include "u_f.h"
37#include "u_midi.h"
36 38
37MODULE_AUTHOR("Ben Williamson"); 39MODULE_AUTHOR("Ben Williamson");
38MODULE_LICENSE("GPL v2"); 40MODULE_LICENSE("GPL v2");
@@ -99,7 +101,7 @@ DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
99DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16); 101DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16);
100 102
101/* B.3.1 Standard AC Interface Descriptor */ 103/* B.3.1 Standard AC Interface Descriptor */
102static struct usb_interface_descriptor ac_interface_desc __initdata = { 104static struct usb_interface_descriptor ac_interface_desc = {
103 .bLength = USB_DT_INTERFACE_SIZE, 105 .bLength = USB_DT_INTERFACE_SIZE,
104 .bDescriptorType = USB_DT_INTERFACE, 106 .bDescriptorType = USB_DT_INTERFACE,
105 /* .bInterfaceNumber = DYNAMIC */ 107 /* .bInterfaceNumber = DYNAMIC */
@@ -110,7 +112,7 @@ static struct usb_interface_descriptor ac_interface_desc __initdata = {
110}; 112};
111 113
112/* B.3.2 Class-Specific AC Interface Descriptor */ 114/* B.3.2 Class-Specific AC Interface Descriptor */
113static struct uac1_ac_header_descriptor_1 ac_header_desc __initdata = { 115static struct uac1_ac_header_descriptor_1 ac_header_desc = {
114 .bLength = UAC_DT_AC_HEADER_SIZE(1), 116 .bLength = UAC_DT_AC_HEADER_SIZE(1),
115 .bDescriptorType = USB_DT_CS_INTERFACE, 117 .bDescriptorType = USB_DT_CS_INTERFACE,
116 .bDescriptorSubtype = USB_MS_HEADER, 118 .bDescriptorSubtype = USB_MS_HEADER,
@@ -121,7 +123,7 @@ static struct uac1_ac_header_descriptor_1 ac_header_desc __initdata = {
121}; 123};
122 124
123/* B.4.1 Standard MS Interface Descriptor */ 125/* B.4.1 Standard MS Interface Descriptor */
124static struct usb_interface_descriptor ms_interface_desc __initdata = { 126static struct usb_interface_descriptor ms_interface_desc = {
125 .bLength = USB_DT_INTERFACE_SIZE, 127 .bLength = USB_DT_INTERFACE_SIZE,
126 .bDescriptorType = USB_DT_INTERFACE, 128 .bDescriptorType = USB_DT_INTERFACE,
127 /* .bInterfaceNumber = DYNAMIC */ 129 /* .bInterfaceNumber = DYNAMIC */
@@ -132,7 +134,7 @@ static struct usb_interface_descriptor ms_interface_desc __initdata = {
132}; 134};
133 135
134/* B.4.2 Class-Specific MS Interface Descriptor */ 136/* B.4.2 Class-Specific MS Interface Descriptor */
135static struct usb_ms_header_descriptor ms_header_desc __initdata = { 137static struct usb_ms_header_descriptor ms_header_desc = {
136 .bLength = USB_DT_MS_HEADER_SIZE, 138 .bLength = USB_DT_MS_HEADER_SIZE,
137 .bDescriptorType = USB_DT_CS_INTERFACE, 139 .bDescriptorType = USB_DT_CS_INTERFACE,
138 .bDescriptorSubtype = USB_MS_HEADER, 140 .bDescriptorSubtype = USB_MS_HEADER,
@@ -387,29 +389,6 @@ static void f_midi_disable(struct usb_function *f)
387 usb_ep_disable(midi->out_ep); 389 usb_ep_disable(midi->out_ep);
388} 390}
389 391
390static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f)
391{
392 struct usb_composite_dev *cdev = f->config->cdev;
393 struct f_midi *midi = func_to_midi(f);
394 struct snd_card *card;
395
396 DBG(cdev, "unbind\n");
397
398 /* just to be sure */
399 f_midi_disable(f);
400
401 card = midi->card;
402 midi->card = NULL;
403 if (card)
404 snd_card_free(card);
405
406 kfree(midi->id);
407 midi->id = NULL;
408
409 usb_free_all_descriptors(f);
410 kfree(midi);
411}
412
413static int f_midi_snd_free(struct snd_device *device) 392static int f_midi_snd_free(struct snd_device *device)
414{ 393{
415 return 0; 394 return 0;
@@ -654,6 +633,14 @@ static struct snd_rawmidi_ops gmidi_out_ops = {
654 .trigger = f_midi_out_trigger 633 .trigger = f_midi_out_trigger
655}; 634};
656 635
636static inline void f_midi_unregister_card(struct f_midi *midi)
637{
638 if (midi->card) {
639 snd_card_free(midi->card);
640 midi->card = NULL;
641 }
642}
643
657/* register as a sound "card" */ 644/* register as a sound "card" */
658static int f_midi_register_card(struct f_midi *midi) 645static int f_midi_register_card(struct f_midi *midi)
659{ 646{
@@ -715,17 +702,13 @@ static int f_midi_register_card(struct f_midi *midi)
715 return 0; 702 return 0;
716 703
717fail: 704fail:
718 if (midi->card) { 705 f_midi_unregister_card(midi);
719 snd_card_free(midi->card);
720 midi->card = NULL;
721 }
722 return err; 706 return err;
723} 707}
724 708
725/* MIDI function driver setup/binding */ 709/* MIDI function driver setup/binding */
726 710
727static int __init 711static int f_midi_bind(struct usb_configuration *c, struct usb_function *f)
728f_midi_bind(struct usb_configuration *c, struct usb_function *f)
729{ 712{
730 struct usb_descriptor_header **midi_function; 713 struct usb_descriptor_header **midi_function;
731 struct usb_midi_in_jack_descriptor jack_in_ext_desc[MAX_PORTS]; 714 struct usb_midi_in_jack_descriptor jack_in_ext_desc[MAX_PORTS];
@@ -734,15 +717,23 @@ f_midi_bind(struct usb_configuration *c, struct usb_function *f)
734 struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc[MAX_PORTS]; 717 struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc[MAX_PORTS];
735 struct usb_composite_dev *cdev = c->cdev; 718 struct usb_composite_dev *cdev = c->cdev;
736 struct f_midi *midi = func_to_midi(f); 719 struct f_midi *midi = func_to_midi(f);
720 struct usb_string *us;
737 int status, n, jack = 1, i = 0; 721 int status, n, jack = 1, i = 0;
738 722
723 midi->gadget = cdev->gadget;
724 tasklet_init(&midi->tasklet, f_midi_in_tasklet, (unsigned long) midi);
725 status = f_midi_register_card(midi);
726 if (status < 0)
727 goto fail_register;
728
739 /* maybe allocate device-global string ID */ 729 /* maybe allocate device-global string ID */
740 if (midi_string_defs[0].id == 0) { 730 us = usb_gstrings_attach(c->cdev, midi_strings,
741 status = usb_string_id(c->cdev); 731 ARRAY_SIZE(midi_string_defs));
742 if (status < 0) 732 if (IS_ERR(us)) {
743 goto fail; 733 status = PTR_ERR(us);
744 midi_string_defs[0].id = status; 734 goto fail;
745 } 735 }
736 ac_interface_desc.iInterface = us[STRING_FUNC_IDX].id;
746 737
747 /* We have two interfaces, AudioControl and MIDIStreaming */ 738 /* We have two interfaces, AudioControl and MIDIStreaming */
748 status = usb_interface_id(c, f); 739 status = usb_interface_id(c, f);
@@ -892,6 +883,8 @@ fail_f_midi:
892 kfree(midi_function); 883 kfree(midi_function);
893 usb_free_descriptors(f->hs_descriptors); 884 usb_free_descriptors(f->hs_descriptors);
894fail: 885fail:
886 f_midi_unregister_card(midi);
887fail_register:
895 /* we might as well release our claims on endpoints */ 888 /* we might as well release our claims on endpoints */
896 if (midi->out_ep) 889 if (midi->out_ep)
897 midi->out_ep->driver_data = NULL; 890 midi->out_ep->driver_data = NULL;
@@ -903,42 +896,235 @@ fail:
903 return status; 896 return status;
904} 897}
905 898
906/** 899static inline struct f_midi_opts *to_f_midi_opts(struct config_item *item)
907 * f_midi_bind_config - add USB MIDI function to a configuration 900{
908 * @c: the configuration to supcard the USB audio function 901 return container_of(to_config_group(item), struct f_midi_opts,
909 * @index: the soundcard index to use for the ALSA device creation 902 func_inst.group);
910 * @id: the soundcard id to use for the ALSA device creation 903}
911 * @buflen: the buffer length to use 904
912 * @qlen the number of read requests to pre-allocate 905CONFIGFS_ATTR_STRUCT(f_midi_opts);
913 * Context: single threaded during gadget setup 906CONFIGFS_ATTR_OPS(f_midi_opts);
914 * 907
915 * Returns zero on success, else negative errno. 908static void midi_attr_release(struct config_item *item)
916 */ 909{
917int __init f_midi_bind_config(struct usb_configuration *c, 910 struct f_midi_opts *opts = to_f_midi_opts(item);
918 int index, char *id, 911
919 unsigned int in_ports, 912 usb_put_function_instance(&opts->func_inst);
920 unsigned int out_ports, 913}
921 unsigned int buflen, 914
922 unsigned int qlen) 915static struct configfs_item_operations midi_item_ops = {
916 .release = midi_attr_release,
917 .show_attribute = f_midi_opts_attr_show,
918 .store_attribute = f_midi_opts_attr_store,
919};
920
921#define F_MIDI_OPT(name, test_limit, limit) \
922static ssize_t f_midi_opts_##name##_show(struct f_midi_opts *opts, char *page) \
923{ \
924 int result; \
925 \
926 mutex_lock(&opts->lock); \
927 result = sprintf(page, "%d\n", opts->name); \
928 mutex_unlock(&opts->lock); \
929 \
930 return result; \
931} \
932 \
933static ssize_t f_midi_opts_##name##_store(struct f_midi_opts *opts, \
934 const char *page, size_t len) \
935{ \
936 int ret; \
937 u32 num; \
938 \
939 mutex_lock(&opts->lock); \
940 if (opts->refcnt) { \
941 ret = -EBUSY; \
942 goto end; \
943 } \
944 \
945 ret = kstrtou32(page, 0, &num); \
946 if (ret) \
947 goto end; \
948 \
949 if (test_limit && num > limit) { \
950 ret = -EINVAL; \
951 goto end; \
952 } \
953 opts->name = num; \
954 ret = len; \
955 \
956end: \
957 mutex_unlock(&opts->lock); \
958 return ret; \
959} \
960 \
961static struct f_midi_opts_attribute f_midi_opts_##name = \
962 __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR, f_midi_opts_##name##_show, \
963 f_midi_opts_##name##_store)
964
965F_MIDI_OPT(index, true, SNDRV_CARDS);
966F_MIDI_OPT(buflen, false, 0);
967F_MIDI_OPT(qlen, false, 0);
968F_MIDI_OPT(in_ports, true, MAX_PORTS);
969F_MIDI_OPT(out_ports, true, MAX_PORTS);
970
971static ssize_t f_midi_opts_id_show(struct f_midi_opts *opts, char *page)
972{
973 int result;
974
975 mutex_lock(&opts->lock);
976 result = strlcpy(page, opts->id, PAGE_SIZE);
977 mutex_unlock(&opts->lock);
978
979 return result;
980}
981
982static ssize_t f_midi_opts_id_store(struct f_midi_opts *opts,
983 const char *page, size_t len)
984{
985 int ret;
986 char *c;
987
988 mutex_lock(&opts->lock);
989 if (opts->refcnt) {
990 ret = -EBUSY;
991 goto end;
992 }
993
994 c = kstrndup(page, len, GFP_KERNEL);
995 if (!c) {
996 ret = -ENOMEM;
997 goto end;
998 }
999 if (opts->id_allocated)
1000 kfree(opts->id);
1001 opts->id = c;
1002 opts->id_allocated = true;
1003 ret = len;
1004end:
1005 mutex_unlock(&opts->lock);
1006 return ret;
1007}
1008
1009static struct f_midi_opts_attribute f_midi_opts_id =
1010 __CONFIGFS_ATTR(id, S_IRUGO | S_IWUSR, f_midi_opts_id_show,
1011 f_midi_opts_id_store);
1012
1013static struct configfs_attribute *midi_attrs[] = {
1014 &f_midi_opts_index.attr,
1015 &f_midi_opts_buflen.attr,
1016 &f_midi_opts_qlen.attr,
1017 &f_midi_opts_in_ports.attr,
1018 &f_midi_opts_out_ports.attr,
1019 &f_midi_opts_id.attr,
1020 NULL,
1021};
1022
1023static struct config_item_type midi_func_type = {
1024 .ct_item_ops = &midi_item_ops,
1025 .ct_attrs = midi_attrs,
1026 .ct_owner = THIS_MODULE,
1027};
1028
1029static void f_midi_free_inst(struct usb_function_instance *f)
1030{
1031 struct f_midi_opts *opts;
1032
1033 opts = container_of(f, struct f_midi_opts, func_inst);
1034
1035 if (opts->id_allocated)
1036 kfree(opts->id);
1037
1038 kfree(opts);
1039}
1040
1041static struct usb_function_instance *f_midi_alloc_inst(void)
1042{
1043 struct f_midi_opts *opts;
1044
1045 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1046 if (!opts)
1047 return ERR_PTR(-ENOMEM);
1048
1049 mutex_init(&opts->lock);
1050 opts->func_inst.free_func_inst = f_midi_free_inst;
1051 opts->index = SNDRV_DEFAULT_IDX1;
1052 opts->id = SNDRV_DEFAULT_STR1;
1053 opts->buflen = 256;
1054 opts->qlen = 32;
1055 opts->in_ports = 1;
1056 opts->out_ports = 1;
1057
1058 config_group_init_type_name(&opts->func_inst.group, "",
1059 &midi_func_type);
1060
1061 return &opts->func_inst;
1062}
1063
1064static void f_midi_free(struct usb_function *f)
1065{
1066 struct f_midi *midi;
1067 struct f_midi_opts *opts;
1068 int i;
1069
1070 midi = func_to_midi(f);
1071 opts = container_of(f->fi, struct f_midi_opts, func_inst);
1072 kfree(midi->id);
1073 mutex_lock(&opts->lock);
1074 for (i = opts->in_ports - 1; i >= 0; --i)
1075 kfree(midi->in_port[i]);
1076 kfree(midi);
1077 --opts->refcnt;
1078 mutex_unlock(&opts->lock);
1079}
1080
1081static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f)
1082{
1083 struct usb_composite_dev *cdev = f->config->cdev;
1084 struct f_midi *midi = func_to_midi(f);
1085 struct snd_card *card;
1086
1087 DBG(cdev, "unbind\n");
1088
1089 /* just to be sure */
1090 f_midi_disable(f);
1091
1092 card = midi->card;
1093 midi->card = NULL;
1094 if (card)
1095 snd_card_free(card);
1096
1097 usb_free_all_descriptors(f);
1098}
1099
1100static struct usb_function *f_midi_alloc(struct usb_function_instance *fi)
923{ 1101{
924 struct f_midi *midi; 1102 struct f_midi *midi;
1103 struct f_midi_opts *opts;
925 int status, i; 1104 int status, i;
926 1105
1106 opts = container_of(fi, struct f_midi_opts, func_inst);
1107
1108 mutex_lock(&opts->lock);
927 /* sanity check */ 1109 /* sanity check */
928 if (in_ports > MAX_PORTS || out_ports > MAX_PORTS) 1110 if (opts->in_ports > MAX_PORTS || opts->out_ports > MAX_PORTS) {
929 return -EINVAL; 1111 mutex_unlock(&opts->lock);
1112 return ERR_PTR(-EINVAL);
1113 }
930 1114
931 /* allocate and initialize one new instance */ 1115 /* allocate and initialize one new instance */
932 midi = kzalloc(sizeof *midi, GFP_KERNEL); 1116 midi = kzalloc(sizeof(*midi), GFP_KERNEL);
933 if (!midi) { 1117 if (!midi) {
934 status = -ENOMEM; 1118 mutex_unlock(&opts->lock);
935 goto fail; 1119 return ERR_PTR(-ENOMEM);
936 } 1120 }
937 1121
938 for (i = 0; i < in_ports; i++) { 1122 for (i = 0; i < opts->in_ports; i++) {
939 struct gmidi_in_port *port = kzalloc(sizeof(*port), GFP_KERNEL); 1123 struct gmidi_in_port *port = kzalloc(sizeof(*port), GFP_KERNEL);
1124
940 if (!port) { 1125 if (!port) {
941 status = -ENOMEM; 1126 status = -ENOMEM;
1127 mutex_unlock(&opts->lock);
942 goto setup_fail; 1128 goto setup_fail;
943 } 1129 }
944 1130
@@ -948,39 +1134,37 @@ int __init f_midi_bind_config(struct usb_configuration *c,
948 midi->in_port[i] = port; 1134 midi->in_port[i] = port;
949 } 1135 }
950 1136
951 midi->gadget = c->cdev->gadget;
952 tasklet_init(&midi->tasklet, f_midi_in_tasklet, (unsigned long) midi);
953
954 /* set up ALSA midi devices */ 1137 /* set up ALSA midi devices */
955 midi->in_ports = in_ports; 1138 midi->id = kstrdup(opts->id, GFP_KERNEL);
956 midi->out_ports = out_ports; 1139 if (opts->id && !midi->id) {
957 status = f_midi_register_card(midi); 1140 status = -ENOMEM;
958 if (status < 0) 1141 mutex_unlock(&opts->lock);
959 goto setup_fail; 1142 goto kstrdup_fail;
960 1143 }
961 midi->func.name = "gmidi function"; 1144 midi->in_ports = opts->in_ports;
962 midi->func.strings = midi_strings; 1145 midi->out_ports = opts->out_ports;
963 midi->func.bind = f_midi_bind; 1146 midi->index = opts->index;
964 midi->func.unbind = f_midi_unbind; 1147 midi->buflen = opts->buflen;
965 midi->func.set_alt = f_midi_set_alt; 1148 midi->qlen = opts->qlen;
966 midi->func.disable = f_midi_disable; 1149 ++opts->refcnt;
967 1150 mutex_unlock(&opts->lock);
968 midi->id = kstrdup(id, GFP_KERNEL); 1151
969 midi->index = index; 1152 midi->func.name = "gmidi function";
970 midi->buflen = buflen; 1153 midi->func.bind = f_midi_bind;
971 midi->qlen = qlen; 1154 midi->func.unbind = f_midi_unbind;
972 1155 midi->func.set_alt = f_midi_set_alt;
973 status = usb_add_function(c, &midi->func); 1156 midi->func.disable = f_midi_disable;
974 if (status) 1157 midi->func.free_func = f_midi_free;
975 goto setup_fail; 1158
976 1159 return &midi->func;
977 return 0; 1160
978 1161kstrdup_fail:
1162 f_midi_unregister_card(midi);
979setup_fail: 1163setup_fail:
980 for (--i; i >= 0; i--) 1164 for (--i; i >= 0; i--)
981 kfree(midi->in_port[i]); 1165 kfree(midi->in_port[i]);
982 kfree(midi); 1166 kfree(midi);
983fail: 1167 return ERR_PTR(status);
984 return status;
985} 1168}
986 1169
1170DECLARE_USB_FUNCTION_INIT(midi, f_midi_alloc_inst, f_midi_alloc);
diff --git a/drivers/usb/gadget/function/f_ncm.c b/drivers/usb/gadget/function/f_ncm.c
index 16361b0a8b46..bdcda9f5148e 100644
--- a/drivers/usb/gadget/function/f_ncm.c
+++ b/drivers/usb/gadget/function/f_ncm.c
@@ -1441,6 +1441,9 @@ static int ncm_bind(struct usb_configuration *c, struct usb_function *f)
1441 1441
1442 status = usb_assign_descriptors(f, ncm_fs_function, ncm_hs_function, 1442 status = usb_assign_descriptors(f, ncm_fs_function, ncm_hs_function,
1443 NULL); 1443 NULL);
1444 if (status)
1445 goto fail;
1446
1444 /* 1447 /*
1445 * NOTE: all that is done without knowing or caring about 1448 * NOTE: all that is done without knowing or caring about
1446 * the network link ... which is unavailable to this code 1449 * the network link ... which is unavailable to this code
diff --git a/drivers/usb/gadget/function/f_rndis.c b/drivers/usb/gadget/function/f_rndis.c
index f13fc6a58565..829edf878dac 100644
--- a/drivers/usb/gadget/function/f_rndis.c
+++ b/drivers/usb/gadget/function/f_rndis.c
@@ -375,8 +375,7 @@ static struct sk_buff *rndis_add_header(struct gether *port,
375 struct sk_buff *skb2; 375 struct sk_buff *skb2;
376 376
377 skb2 = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type)); 377 skb2 = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type));
378 if (skb2) 378 rndis_add_hdr(skb2);
379 rndis_add_hdr(skb2);
380 379
381 dev_kfree_skb(skb); 380 dev_kfree_skb(skb);
382 return skb2; 381 return skb2;
diff --git a/drivers/usb/gadget/function/u_hid.h b/drivers/usb/gadget/function/u_hid.h
new file mode 100644
index 000000000000..aaa0e368a159
--- /dev/null
+++ b/drivers/usb/gadget/function/u_hid.h
@@ -0,0 +1,42 @@
1/*
2 * u_hid.h
3 *
4 * Utility definitions for the hid function
5 *
6 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
7 * http://www.samsung.com
8 *
9 * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 */
15
16#ifndef U_HID_H
17#define U_HID_H
18
19#include <linux/usb/composite.h>
20
21struct f_hid_opts {
22 struct usb_function_instance func_inst;
23 int minor;
24 unsigned char subclass;
25 unsigned char protocol;
26 unsigned short report_length;
27 unsigned short report_desc_length;
28 unsigned char *report_desc;
29 bool report_desc_alloc;
30
31 /*
32 * Protect the data form concurrent access by read/write
33 * and create symlink/remove symlink.
34 */
35 struct mutex lock;
36 int refcnt;
37};
38
39int ghid_setup(struct usb_gadget *g, int count);
40void ghid_cleanup(void);
41
42#endif /* U_HID_H */
diff --git a/drivers/usb/gadget/function/u_midi.h b/drivers/usb/gadget/function/u_midi.h
new file mode 100644
index 000000000000..22510189758e
--- /dev/null
+++ b/drivers/usb/gadget/function/u_midi.h
@@ -0,0 +1,40 @@
1/*
2 * u_midi.h
3 *
4 * Utility definitions for the midi function
5 *
6 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
7 * http://www.samsung.com
8 *
9 * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 */
15
16#ifndef U_MIDI_H
17#define U_MIDI_H
18
19#include <linux/usb/composite.h>
20
21struct f_midi_opts {
22 struct usb_function_instance func_inst;
23 int index;
24 char *id;
25 bool id_allocated;
26 unsigned int in_ports;
27 unsigned int out_ports;
28 unsigned int buflen;
29 unsigned int qlen;
30
31 /*
32 * Protect the data form concurrent access by read/write
33 * and create symlink/remove symlink.
34 */
35 struct mutex lock;
36 int refcnt;
37};
38
39#endif /* U_MIDI_H */
40
diff --git a/drivers/usb/gadget/function/u_uac1.c b/drivers/usb/gadget/function/u_uac1.c
index a44a07f30281..53842a1b947f 100644
--- a/drivers/usb/gadget/function/u_uac1.c
+++ b/drivers/usb/gadget/function/u_uac1.c
@@ -213,9 +213,6 @@ static int gaudio_open_snd_dev(struct gaudio *card)
213 fn_cap = opts->fn_cap; 213 fn_cap = opts->fn_cap;
214 fn_cntl = opts->fn_cntl; 214 fn_cntl = opts->fn_cntl;
215 215
216 if (!card)
217 return -ENODEV;
218
219 /* Open control device */ 216 /* Open control device */
220 snd = &card->control; 217 snd = &card->control;
221 snd->filp = filp_open(fn_cntl, O_RDWR, 0); 218 snd->filp = filp_open(fn_cntl, O_RDWR, 0);
diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig
index 24392d269709..fd48ef3af4eb 100644
--- a/drivers/usb/gadget/legacy/Kconfig
+++ b/drivers/usb/gadget/legacy/Kconfig
@@ -287,6 +287,7 @@ config USB_MIDI_GADGET
287 depends on SND 287 depends on SND
288 select USB_LIBCOMPOSITE 288 select USB_LIBCOMPOSITE
289 select SND_RAWMIDI 289 select SND_RAWMIDI
290 select USB_F_MIDI
290 help 291 help
291 The MIDI Gadget acts as a USB Audio device, with one MIDI 292 The MIDI Gadget acts as a USB Audio device, with one MIDI
292 input and one MIDI output. These MIDI jacks appear as 293 input and one MIDI output. These MIDI jacks appear as
@@ -419,6 +420,7 @@ endif # TTY
419config USB_G_HID 420config USB_G_HID
420 tristate "HID Gadget" 421 tristate "HID Gadget"
421 select USB_LIBCOMPOSITE 422 select USB_LIBCOMPOSITE
423 select USB_F_HID
422 help 424 help
423 The HID gadget driver provides generic emulation of USB 425 The HID gadget driver provides generic emulation of USB
424 Human Interface Devices (HID). 426 Human Interface Devices (HID).
diff --git a/drivers/usb/gadget/legacy/dbgp.c b/drivers/usb/gadget/legacy/dbgp.c
index 1b075132f8f1..633683a72a11 100644
--- a/drivers/usb/gadget/legacy/dbgp.c
+++ b/drivers/usb/gadget/legacy/dbgp.c
@@ -237,7 +237,7 @@ static void dbgp_unbind(struct usb_gadget *gadget)
237static unsigned char tty_line; 237static unsigned char tty_line;
238#endif 238#endif
239 239
240static int __init dbgp_configure_endpoints(struct usb_gadget *gadget) 240static int dbgp_configure_endpoints(struct usb_gadget *gadget)
241{ 241{
242 int stp; 242 int stp;
243 243
@@ -273,19 +273,10 @@ static int __init dbgp_configure_endpoints(struct usb_gadget *gadget)
273 273
274 dbgp.serial->in->desc = &i_desc; 274 dbgp.serial->in->desc = &i_desc;
275 dbgp.serial->out->desc = &o_desc; 275 dbgp.serial->out->desc = &o_desc;
276 276#endif
277 if (gserial_alloc_line(&tty_line)) {
278 stp = 3;
279 goto fail_3;
280 }
281 277
282 return 0; 278 return 0;
283 279
284fail_3:
285 dbgp.o_ep->driver_data = NULL;
286#else
287 return 0;
288#endif
289fail_2: 280fail_2:
290 dbgp.i_ep->driver_data = NULL; 281 dbgp.i_ep->driver_data = NULL;
291fail_1: 282fail_1:
@@ -324,10 +315,17 @@ static int __init dbgp_bind(struct usb_gadget *gadget,
324 err = -ENOMEM; 315 err = -ENOMEM;
325 goto fail; 316 goto fail;
326 } 317 }
318
319 if (gserial_alloc_line(&tty_line)) {
320 stp = 4;
321 err = -ENODEV;
322 goto fail;
323 }
327#endif 324#endif
325
328 err = dbgp_configure_endpoints(gadget); 326 err = dbgp_configure_endpoints(gadget);
329 if (err < 0) { 327 if (err < 0) {
330 stp = 4; 328 stp = 5;
331 goto fail; 329 goto fail;
332 } 330 }
333 331
@@ -383,6 +381,10 @@ static int dbgp_setup(struct usb_gadget *gadget,
383#ifdef CONFIG_USB_G_DBGP_PRINTK 381#ifdef CONFIG_USB_G_DBGP_PRINTK
384 err = dbgp_enable_ep(); 382 err = dbgp_enable_ep();
385#else 383#else
384 err = dbgp_configure_endpoints(gadget);
385 if (err < 0) {
386 goto fail;
387 }
386 err = gserial_connect(dbgp.serial, tty_line); 388 err = gserial_connect(dbgp.serial, tty_line);
387#endif 389#endif
388 if (err < 0) 390 if (err < 0)
diff --git a/drivers/usb/gadget/legacy/gmidi.c b/drivers/usb/gadget/legacy/gmidi.c
index 3d696b86ff76..e02a095294ac 100644
--- a/drivers/usb/gadget/legacy/gmidi.c
+++ b/drivers/usb/gadget/legacy/gmidi.c
@@ -37,7 +37,7 @@
37 37
38#include "gadget_chips.h" 38#include "gadget_chips.h"
39 39
40#include "f_midi.c" 40#include "u_midi.h"
41 41
42/*-------------------------------------------------------------------------*/ 42/*-------------------------------------------------------------------------*/
43 43
@@ -115,8 +115,13 @@ static struct usb_gadget_strings *dev_strings[] = {
115 NULL, 115 NULL,
116}; 116};
117 117
118static struct usb_function_instance *fi_midi;
119static struct usb_function *f_midi;
120
118static int __exit midi_unbind(struct usb_composite_dev *dev) 121static int __exit midi_unbind(struct usb_composite_dev *dev)
119{ 122{
123 usb_put_function(f_midi);
124 usb_put_function_instance(fi_midi);
120 return 0; 125 return 0;
121} 126}
122 127
@@ -130,28 +135,54 @@ static struct usb_configuration midi_config = {
130 135
131static int __init midi_bind_config(struct usb_configuration *c) 136static int __init midi_bind_config(struct usb_configuration *c)
132{ 137{
133 return f_midi_bind_config(c, index, id, 138 int status;
134 in_ports, out_ports, 139
135 buflen, qlen); 140 f_midi = usb_get_function(fi_midi);
141 if (IS_ERR(f_midi))
142 return PTR_ERR(f_midi);
143
144 status = usb_add_function(c, f_midi);
145 if (status < 0) {
146 usb_put_function(f_midi);
147 return status;
148 }
149
150 return 0;
136} 151}
137 152
138static int __init midi_bind(struct usb_composite_dev *cdev) 153static int __init midi_bind(struct usb_composite_dev *cdev)
139{ 154{
155 struct f_midi_opts *midi_opts;
140 int status; 156 int status;
141 157
158 fi_midi = usb_get_function_instance("midi");
159 if (IS_ERR(fi_midi))
160 return PTR_ERR(fi_midi);
161
162 midi_opts = container_of(fi_midi, struct f_midi_opts, func_inst);
163 midi_opts->index = index;
164 midi_opts->id = id;
165 midi_opts->in_ports = in_ports;
166 midi_opts->out_ports = out_ports;
167 midi_opts->buflen = buflen;
168 midi_opts->qlen = qlen;
169
142 status = usb_string_ids_tab(cdev, strings_dev); 170 status = usb_string_ids_tab(cdev, strings_dev);
143 if (status < 0) 171 if (status < 0)
144 return status; 172 goto put;
145 device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; 173 device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
146 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; 174 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
147 midi_config.iConfiguration = strings_dev[STRING_DESCRIPTION_IDX].id; 175 midi_config.iConfiguration = strings_dev[STRING_DESCRIPTION_IDX].id;
148 176
149 status = usb_add_config(cdev, &midi_config, midi_bind_config); 177 status = usb_add_config(cdev, &midi_config, midi_bind_config);
150 if (status < 0) 178 if (status < 0)
151 return status; 179 goto put;
152 usb_composite_overwrite_options(cdev, &coverwrite); 180 usb_composite_overwrite_options(cdev, &coverwrite);
153 pr_info("%s\n", longname); 181 pr_info("%s\n", longname);
154 return 0; 182 return 0;
183put:
184 usb_put_function_instance(fi_midi);
185 return status;
155} 186}
156 187
157static __refdata struct usb_composite_driver midi_driver = { 188static __refdata struct usb_composite_driver midi_driver = {
diff --git a/drivers/usb/gadget/legacy/hid.c b/drivers/usb/gadget/legacy/hid.c
index 778613eb37af..633fe7e07688 100644
--- a/drivers/usb/gadget/legacy/hid.c
+++ b/drivers/usb/gadget/legacy/hid.c
@@ -17,11 +17,14 @@
17#include <linux/list.h> 17#include <linux/list.h>
18#include <linux/module.h> 18#include <linux/module.h>
19#include <linux/usb/composite.h> 19#include <linux/usb/composite.h>
20#include <linux/usb/g_hid.h>
20 21
21#include "gadget_chips.h" 22#include "gadget_chips.h"
22#define DRIVER_DESC "HID Gadget" 23#define DRIVER_DESC "HID Gadget"
23#define DRIVER_VERSION "2010/03/16" 24#define DRIVER_VERSION "2010/03/16"
24 25
26#include "u_hid.h"
27
25/*-------------------------------------------------------------------------*/ 28/*-------------------------------------------------------------------------*/
26 29
27#define HIDG_VENDOR_NUM 0x0525 /* XXX NetChip */ 30#define HIDG_VENDOR_NUM 0x0525 /* XXX NetChip */
@@ -29,17 +32,9 @@
29 32
30/*-------------------------------------------------------------------------*/ 33/*-------------------------------------------------------------------------*/
31 34
32/*
33 * kbuild is not very cooperative with respect to linking separately
34 * compiled library objects into one module. So for now we won't use
35 * separate compilation ... ensuring init/exit sections work to shrink
36 * the runtime footprint, and giving us at least some parts of what
37 * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
38 */
39#include "f_hid.c"
40
41
42struct hidg_func_node { 35struct hidg_func_node {
36 struct usb_function_instance *fi;
37 struct usb_function *f;
43 struct list_head node; 38 struct list_head node;
44 struct hidg_func_descriptor *func; 39 struct hidg_func_descriptor *func;
45}; 40};
@@ -113,8 +108,8 @@ static struct usb_gadget_strings *dev_strings[] = {
113 108
114static int __init do_config(struct usb_configuration *c) 109static int __init do_config(struct usb_configuration *c)
115{ 110{
116 struct hidg_func_node *e; 111 struct hidg_func_node *e, *n;
117 int func = 0, status = 0; 112 int status = 0;
118 113
119 if (gadget_is_otg(c->cdev->gadget)) { 114 if (gadget_is_otg(c->cdev->gadget)) {
120 c->descriptors = otg_desc; 115 c->descriptors = otg_desc;
@@ -122,11 +117,24 @@ static int __init do_config(struct usb_configuration *c)
122 } 117 }
123 118
124 list_for_each_entry(e, &hidg_func_list, node) { 119 list_for_each_entry(e, &hidg_func_list, node) {
125 status = hidg_bind_config(c, e->func, func++); 120 e->f = usb_get_function(e->fi);
126 if (status) 121 if (IS_ERR(e->f))
127 break; 122 goto put;
123 status = usb_add_function(c, e->f);
124 if (status < 0) {
125 usb_put_function(e->f);
126 goto put;
127 }
128 } 128 }
129 129
130 return 0;
131put:
132 list_for_each_entry(n, &hidg_func_list, node) {
133 if (n == e)
134 break;
135 usb_remove_function(c, n->f);
136 usb_put_function(n->f);
137 }
130 return status; 138 return status;
131} 139}
132 140
@@ -143,6 +151,8 @@ static int __init hid_bind(struct usb_composite_dev *cdev)
143{ 151{
144 struct usb_gadget *gadget = cdev->gadget; 152 struct usb_gadget *gadget = cdev->gadget;
145 struct list_head *tmp; 153 struct list_head *tmp;
154 struct hidg_func_node *n, *m;
155 struct f_hid_opts *hid_opts;
146 int status, funcs = 0; 156 int status, funcs = 0;
147 157
148 list_for_each(tmp, &hidg_func_list) 158 list_for_each(tmp, &hidg_func_list)
@@ -151,10 +161,20 @@ static int __init hid_bind(struct usb_composite_dev *cdev)
151 if (!funcs) 161 if (!funcs)
152 return -ENODEV; 162 return -ENODEV;
153 163
154 /* set up HID */ 164 list_for_each_entry(n, &hidg_func_list, node) {
155 status = ghid_setup(cdev->gadget, funcs); 165 n->fi = usb_get_function_instance("hid");
156 if (status < 0) 166 if (IS_ERR(n->fi)) {
157 return status; 167 status = PTR_ERR(n->fi);
168 goto put;
169 }
170 hid_opts = container_of(n->fi, struct f_hid_opts, func_inst);
171 hid_opts->subclass = n->func->subclass;
172 hid_opts->protocol = n->func->protocol;
173 hid_opts->report_length = n->func->report_length;
174 hid_opts->report_desc_length = n->func->report_desc_length;
175 hid_opts->report_desc = n->func->report_desc;
176 }
177
158 178
159 /* Allocate string descriptor numbers ... note that string 179 /* Allocate string descriptor numbers ... note that string
160 * contents can be overridden by the composite_dev glue. 180 * contents can be overridden by the composite_dev glue.
@@ -162,24 +182,37 @@ static int __init hid_bind(struct usb_composite_dev *cdev)
162 182
163 status = usb_string_ids_tab(cdev, strings_dev); 183 status = usb_string_ids_tab(cdev, strings_dev);
164 if (status < 0) 184 if (status < 0)
165 return status; 185 goto put;
166 device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; 186 device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
167 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; 187 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
168 188
169 /* register our configuration */ 189 /* register our configuration */
170 status = usb_add_config(cdev, &config_driver, do_config); 190 status = usb_add_config(cdev, &config_driver, do_config);
171 if (status < 0) 191 if (status < 0)
172 return status; 192 goto put;
173 193
174 usb_composite_overwrite_options(cdev, &coverwrite); 194 usb_composite_overwrite_options(cdev, &coverwrite);
175 dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n"); 195 dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
176 196
177 return 0; 197 return 0;
198
199put:
200 list_for_each_entry(m, &hidg_func_list, node) {
201 if (m == n)
202 break;
203 usb_put_function_instance(m->fi);
204 }
205 return status;
178} 206}
179 207
180static int __exit hid_unbind(struct usb_composite_dev *cdev) 208static int __exit hid_unbind(struct usb_composite_dev *cdev)
181{ 209{
182 ghid_cleanup(); 210 struct hidg_func_node *n;
211
212 list_for_each_entry(n, &hidg_func_list, node) {
213 usb_put_function(n->f);
214 usb_put_function_instance(n->fi);
215 }
183 return 0; 216 return 0;
184} 217}
185 218
@@ -260,7 +293,7 @@ module_init(hidg_init);
260 293
261static void __exit hidg_cleanup(void) 294static void __exit hidg_cleanup(void)
262{ 295{
263 platform_driver_unregister(&hidg_plat_driver);
264 usb_composite_unregister(&hidg_driver); 296 usb_composite_unregister(&hidg_driver);
297 platform_driver_unregister(&hidg_plat_driver);
265} 298}
266module_exit(hidg_cleanup); 299module_exit(hidg_cleanup);
diff --git a/drivers/usb/gadget/legacy/printer.c b/drivers/usb/gadget/legacy/printer.c
index 6474081dcbaf..90545980542f 100644
--- a/drivers/usb/gadget/legacy/printer.c
+++ b/drivers/usb/gadget/legacy/printer.c
@@ -208,6 +208,43 @@ static struct usb_descriptor_header *hs_printer_function[] = {
208 NULL 208 NULL
209}; 209};
210 210
211/*
212 * Added endpoint descriptors for 3.0 devices
213 */
214
215static struct usb_endpoint_descriptor ss_ep_in_desc = {
216 .bLength = USB_DT_ENDPOINT_SIZE,
217 .bDescriptorType = USB_DT_ENDPOINT,
218 .bmAttributes = USB_ENDPOINT_XFER_BULK,
219 .wMaxPacketSize = cpu_to_le16(1024),
220};
221
222static struct usb_ss_ep_comp_descriptor ss_ep_in_comp_desc = {
223 .bLength = sizeof(ss_ep_in_comp_desc),
224 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
225};
226
227static struct usb_endpoint_descriptor ss_ep_out_desc = {
228 .bLength = USB_DT_ENDPOINT_SIZE,
229 .bDescriptorType = USB_DT_ENDPOINT,
230 .bmAttributes = USB_ENDPOINT_XFER_BULK,
231 .wMaxPacketSize = cpu_to_le16(1024),
232};
233
234static struct usb_ss_ep_comp_descriptor ss_ep_out_comp_desc = {
235 .bLength = sizeof(ss_ep_out_comp_desc),
236 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
237};
238
239static struct usb_descriptor_header *ss_printer_function[] = {
240 (struct usb_descriptor_header *) &intf_desc,
241 (struct usb_descriptor_header *) &ss_ep_in_desc,
242 (struct usb_descriptor_header *) &ss_ep_in_comp_desc,
243 (struct usb_descriptor_header *) &ss_ep_out_desc,
244 (struct usb_descriptor_header *) &ss_ep_out_comp_desc,
245 NULL
246};
247
211static struct usb_otg_descriptor otg_descriptor = { 248static struct usb_otg_descriptor otg_descriptor = {
212 .bLength = sizeof otg_descriptor, 249 .bLength = sizeof otg_descriptor,
213 .bDescriptorType = USB_DT_OTG, 250 .bDescriptorType = USB_DT_OTG,
@@ -220,7 +257,20 @@ static const struct usb_descriptor_header *otg_desc[] = {
220}; 257};
221 258
222/* maxpacket and other transfer characteristics vary by speed. */ 259/* maxpacket and other transfer characteristics vary by speed. */
223#define ep_desc(g, hs, fs) (((g)->speed == USB_SPEED_HIGH)?(hs):(fs)) 260static inline struct usb_endpoint_descriptor *ep_desc(struct usb_gadget *gadget,
261 struct usb_endpoint_descriptor *fs,
262 struct usb_endpoint_descriptor *hs,
263 struct usb_endpoint_descriptor *ss)
264{
265 switch (gadget->speed) {
266 case USB_SPEED_SUPER:
267 return ss;
268 case USB_SPEED_HIGH:
269 return hs;
270 default:
271 return fs;
272 }
273}
224 274
225/*-------------------------------------------------------------------------*/ 275/*-------------------------------------------------------------------------*/
226 276
@@ -793,11 +843,12 @@ set_printer_interface(struct printer_dev *dev)
793{ 843{
794 int result = 0; 844 int result = 0;
795 845
796 dev->in_ep->desc = ep_desc(dev->gadget, &hs_ep_in_desc, &fs_ep_in_desc); 846 dev->in_ep->desc = ep_desc(dev->gadget, &fs_ep_in_desc, &hs_ep_in_desc,
847 &ss_ep_in_desc);
797 dev->in_ep->driver_data = dev; 848 dev->in_ep->driver_data = dev;
798 849
799 dev->out_ep->desc = ep_desc(dev->gadget, &hs_ep_out_desc, 850 dev->out_ep->desc = ep_desc(dev->gadget, &fs_ep_out_desc,
800 &fs_ep_out_desc); 851 &hs_ep_out_desc, &ss_ep_out_desc);
801 dev->out_ep->driver_data = dev; 852 dev->out_ep->driver_data = dev;
802 853
803 result = usb_ep_enable(dev->in_ep); 854 result = usb_ep_enable(dev->in_ep);
@@ -1016,9 +1067,11 @@ autoconf_fail:
1016 /* assumes that all endpoints are dual-speed */ 1067 /* assumes that all endpoints are dual-speed */
1017 hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress; 1068 hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
1018 hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress; 1069 hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
1070 ss_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
1071 ss_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
1019 1072
1020 ret = usb_assign_descriptors(f, fs_printer_function, 1073 ret = usb_assign_descriptors(f, fs_printer_function,
1021 hs_printer_function, NULL); 1074 hs_printer_function, ss_printer_function);
1022 if (ret) 1075 if (ret)
1023 return ret; 1076 return ret;
1024 1077
@@ -1253,7 +1306,7 @@ static __refdata struct usb_composite_driver printer_driver = {
1253 .name = shortname, 1306 .name = shortname,
1254 .dev = &device_desc, 1307 .dev = &device_desc,
1255 .strings = dev_strings, 1308 .strings = dev_strings,
1256 .max_speed = USB_SPEED_HIGH, 1309 .max_speed = USB_SPEED_SUPER,
1257 .bind = printer_bind, 1310 .bind = printer_bind,
1258 .unbind = printer_unbind, 1311 .unbind = printer_unbind,
1259}; 1312};
diff --git a/drivers/usb/gadget/udc/Kconfig b/drivers/usb/gadget/udc/Kconfig
index 217365d35a25..b8e213eb36cc 100644
--- a/drivers/usb/gadget/udc/Kconfig
+++ b/drivers/usb/gadget/udc/Kconfig
@@ -241,6 +241,8 @@ config USB_M66592
241 dynamically linked module called "m66592_udc" and force all 241 dynamically linked module called "m66592_udc" and force all
242 gadget drivers to also be dynamically linked. 242 gadget drivers to also be dynamically linked.
243 243
244source "drivers/usb/gadget/udc/bdc/Kconfig"
245
244# 246#
245# Controllers available only in discrete form (and all PCI controllers) 247# Controllers available only in discrete form (and all PCI controllers)
246# 248#
diff --git a/drivers/usb/gadget/udc/Makefile b/drivers/usb/gadget/udc/Makefile
index a7f4491593f1..fba2049bf985 100644
--- a/drivers/usb/gadget/udc/Makefile
+++ b/drivers/usb/gadget/udc/Makefile
@@ -30,3 +30,4 @@ obj-$(CONFIG_USB_FOTG210_UDC) += fotg210-udc.o
30obj-$(CONFIG_USB_MV_U3D) += mv_u3d_core.o 30obj-$(CONFIG_USB_MV_U3D) += mv_u3d_core.o
31obj-$(CONFIG_USB_GR_UDC) += gr_udc.o 31obj-$(CONFIG_USB_GR_UDC) += gr_udc.o
32obj-$(CONFIG_USB_GADGET_XILINX) += udc-xilinx.o 32obj-$(CONFIG_USB_GADGET_XILINX) += udc-xilinx.o
33obj-$(CONFIG_USB_BDC_UDC) += bdc/
diff --git a/drivers/usb/gadget/udc/amd5536udc.c b/drivers/usb/gadget/udc/amd5536udc.c
index 3b9d13848a4f..de7e5e2ccf1c 100644
--- a/drivers/usb/gadget/udc/amd5536udc.c
+++ b/drivers/usb/gadget/udc/amd5536udc.c
@@ -1401,9 +1401,8 @@ static int udc_wakeup(struct usb_gadget *gadget)
1401 1401
1402static int amd5536_udc_start(struct usb_gadget *g, 1402static int amd5536_udc_start(struct usb_gadget *g,
1403 struct usb_gadget_driver *driver); 1403 struct usb_gadget_driver *driver);
1404static int amd5536_udc_stop(struct usb_gadget *g, 1404static int amd5536_udc_stop(struct usb_gadget *g);
1405 struct usb_gadget_driver *driver); 1405
1406/* gadget operations */
1407static const struct usb_gadget_ops udc_ops = { 1406static const struct usb_gadget_ops udc_ops = {
1408 .wakeup = udc_wakeup, 1407 .wakeup = udc_wakeup,
1409 .get_frame = udc_get_frame, 1408 .get_frame = udc_get_frame,
@@ -1962,8 +1961,7 @@ __acquires(dev->lock)
1962} 1961}
1963 1962
1964/* Called by gadget driver to unregister itself */ 1963/* Called by gadget driver to unregister itself */
1965static int amd5536_udc_stop(struct usb_gadget *g, 1964static int amd5536_udc_stop(struct usb_gadget *g)
1966 struct usb_gadget_driver *driver)
1967{ 1965{
1968 struct udc *dev = to_amd5536_udc(g); 1966 struct udc *dev = to_amd5536_udc(g);
1969 unsigned long flags; 1967 unsigned long flags;
@@ -1971,7 +1969,7 @@ static int amd5536_udc_stop(struct usb_gadget *g,
1971 1969
1972 spin_lock_irqsave(&dev->lock, flags); 1970 spin_lock_irqsave(&dev->lock, flags);
1973 udc_mask_unused_interrupts(dev); 1971 udc_mask_unused_interrupts(dev);
1974 shutdown(dev, driver); 1972 shutdown(dev, NULL);
1975 spin_unlock_irqrestore(&dev->lock, flags); 1973 spin_unlock_irqrestore(&dev->lock, flags);
1976 1974
1977 dev->driver = NULL; 1975 dev->driver = NULL;
@@ -2873,7 +2871,7 @@ __acquires(dev->lock)
2873 dev->driver->resume(&dev->gadget); 2871 dev->driver->resume(&dev->gadget);
2874 dev->sys_suspended = 0; 2872 dev->sys_suspended = 0;
2875 } 2873 }
2876 dev->driver->disconnect(&dev->gadget); 2874 usb_gadget_udc_reset(&dev->gadget, dev->driver);
2877 spin_lock(&dev->lock); 2875 spin_lock(&dev->lock);
2878 2876
2879 /* disable ep0 to empty req queue */ 2877 /* disable ep0 to empty req queue */
diff --git a/drivers/usb/gadget/udc/at91_udc.c b/drivers/usb/gadget/udc/at91_udc.c
index 9968f5331fe4..eb2999c5d03c 100644
--- a/drivers/usb/gadget/udc/at91_udc.c
+++ b/drivers/usb/gadget/udc/at91_udc.c
@@ -840,6 +840,31 @@ static void udc_reinit(struct at91_udc *udc)
840 } 840 }
841} 841}
842 842
843static void reset_gadget(struct at91_udc *udc)
844{
845 struct usb_gadget_driver *driver = udc->driver;
846 int i;
847
848 if (udc->gadget.speed == USB_SPEED_UNKNOWN)
849 driver = NULL;
850 udc->gadget.speed = USB_SPEED_UNKNOWN;
851 udc->suspended = 0;
852
853 for (i = 0; i < NUM_ENDPOINTS; i++) {
854 struct at91_ep *ep = &udc->ep[i];
855
856 ep->stopped = 1;
857 nuke(ep, -ESHUTDOWN);
858 }
859 if (driver) {
860 spin_unlock(&udc->lock);
861 usb_gadget_udc_reset(&udc->gadget, driver);
862 spin_lock(&udc->lock);
863 }
864
865 udc_reinit(udc);
866}
867
843static void stop_activity(struct at91_udc *udc) 868static void stop_activity(struct at91_udc *udc)
844{ 869{
845 struct usb_gadget_driver *driver = udc->driver; 870 struct usb_gadget_driver *driver = udc->driver;
@@ -870,12 +895,10 @@ static void clk_on(struct at91_udc *udc)
870 return; 895 return;
871 udc->clocked = 1; 896 udc->clocked = 1;
872 897
873 if (IS_ENABLED(CONFIG_COMMON_CLK)) { 898 if (IS_ENABLED(CONFIG_COMMON_CLK))
874 clk_set_rate(udc->uclk, 48000000); 899 clk_enable(udc->uclk);
875 clk_prepare_enable(udc->uclk); 900 clk_enable(udc->iclk);
876 } 901 clk_enable(udc->fclk);
877 clk_prepare_enable(udc->iclk);
878 clk_prepare_enable(udc->fclk);
879} 902}
880 903
881static void clk_off(struct at91_udc *udc) 904static void clk_off(struct at91_udc *udc)
@@ -884,10 +907,10 @@ static void clk_off(struct at91_udc *udc)
884 return; 907 return;
885 udc->clocked = 0; 908 udc->clocked = 0;
886 udc->gadget.speed = USB_SPEED_UNKNOWN; 909 udc->gadget.speed = USB_SPEED_UNKNOWN;
887 clk_disable_unprepare(udc->fclk); 910 clk_disable(udc->fclk);
888 clk_disable_unprepare(udc->iclk); 911 clk_disable(udc->iclk);
889 if (IS_ENABLED(CONFIG_COMMON_CLK)) 912 if (IS_ENABLED(CONFIG_COMMON_CLK))
890 clk_disable_unprepare(udc->uclk); 913 clk_disable(udc->uclk);
891} 914}
892 915
893/* 916/*
@@ -984,8 +1007,8 @@ static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
984 1007
985static int at91_start(struct usb_gadget *gadget, 1008static int at91_start(struct usb_gadget *gadget,
986 struct usb_gadget_driver *driver); 1009 struct usb_gadget_driver *driver);
987static int at91_stop(struct usb_gadget *gadget, 1010static int at91_stop(struct usb_gadget *gadget);
988 struct usb_gadget_driver *driver); 1011
989static const struct usb_gadget_ops at91_udc_ops = { 1012static const struct usb_gadget_ops at91_udc_ops = {
990 .get_frame = at91_get_frame, 1013 .get_frame = at91_get_frame,
991 .wakeup = at91_wakeup, 1014 .wakeup = at91_wakeup,
@@ -1426,7 +1449,7 @@ static irqreturn_t at91_udc_irq (int irq, void *_udc)
1426 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES); 1449 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1427 VDBG("end bus reset\n"); 1450 VDBG("end bus reset\n");
1428 udc->addr = 0; 1451 udc->addr = 0;
1429 stop_activity(udc); 1452 reset_gadget(udc);
1430 1453
1431 /* enable ep0 */ 1454 /* enable ep0 */
1432 at91_udp_write(udc, AT91_UDP_CSR(0), 1455 at91_udp_write(udc, AT91_UDP_CSR(0),
@@ -1512,20 +1535,11 @@ static irqreturn_t at91_udc_irq (int irq, void *_udc)
1512 1535
1513/*-------------------------------------------------------------------------*/ 1536/*-------------------------------------------------------------------------*/
1514 1537
1515static void nop_release(struct device *dev)
1516{
1517 /* nothing to free */
1518}
1519
1520static struct at91_udc controller = { 1538static struct at91_udc controller = {
1521 .gadget = { 1539 .gadget = {
1522 .ops = &at91_udc_ops, 1540 .ops = &at91_udc_ops,
1523 .ep0 = &controller.ep[0].ep, 1541 .ep0 = &controller.ep[0].ep,
1524 .name = driver_name, 1542 .name = driver_name,
1525 .dev = {
1526 .init_name = "gadget",
1527 .release = nop_release,
1528 }
1529 }, 1543 },
1530 .ep[0] = { 1544 .ep[0] = {
1531 .ep = { 1545 .ep = {
@@ -1641,12 +1655,10 @@ static int at91_start(struct usb_gadget *gadget,
1641 udc->enabled = 1; 1655 udc->enabled = 1;
1642 udc->selfpowered = 1; 1656 udc->selfpowered = 1;
1643 1657
1644 DBG("bound to %s\n", driver->driver.name);
1645 return 0; 1658 return 0;
1646} 1659}
1647 1660
1648static int at91_stop(struct usb_gadget *gadget, 1661static int at91_stop(struct usb_gadget *gadget)
1649 struct usb_gadget_driver *driver)
1650{ 1662{
1651 struct at91_udc *udc; 1663 struct at91_udc *udc;
1652 unsigned long flags; 1664 unsigned long flags;
@@ -1659,7 +1671,6 @@ static int at91_stop(struct usb_gadget *gadget,
1659 1671
1660 udc->driver = NULL; 1672 udc->driver = NULL;
1661 1673
1662 DBG("unbound from %s\n", driver->driver.name);
1663 return 0; 1674 return 0;
1664} 1675}
1665 1676
@@ -1780,14 +1791,24 @@ static int at91udc_probe(struct platform_device *pdev)
1780 } 1791 }
1781 1792
1782 /* don't do anything until we have both gadget driver and VBUS */ 1793 /* don't do anything until we have both gadget driver and VBUS */
1794 if (IS_ENABLED(CONFIG_COMMON_CLK)) {
1795 clk_set_rate(udc->uclk, 48000000);
1796 retval = clk_prepare(udc->uclk);
1797 if (retval)
1798 goto fail1;
1799 }
1800 retval = clk_prepare(udc->fclk);
1801 if (retval)
1802 goto fail1a;
1803
1783 retval = clk_prepare_enable(udc->iclk); 1804 retval = clk_prepare_enable(udc->iclk);
1784 if (retval) 1805 if (retval)
1785 goto fail1; 1806 goto fail1b;
1786 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS); 1807 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
1787 at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff); 1808 at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
1788 /* Clear all pending interrupts - UDP may be used by bootloader. */ 1809 /* Clear all pending interrupts - UDP may be used by bootloader. */
1789 at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff); 1810 at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
1790 clk_disable_unprepare(udc->iclk); 1811 clk_disable(udc->iclk);
1791 1812
1792 /* request UDC and maybe VBUS irqs */ 1813 /* request UDC and maybe VBUS irqs */
1793 udc->udp_irq = platform_get_irq(pdev, 0); 1814 udc->udp_irq = platform_get_irq(pdev, 0);
@@ -1795,7 +1816,7 @@ static int at91udc_probe(struct platform_device *pdev)
1795 0, driver_name, udc); 1816 0, driver_name, udc);
1796 if (retval < 0) { 1817 if (retval < 0) {
1797 DBG("request irq %d failed\n", udc->udp_irq); 1818 DBG("request irq %d failed\n", udc->udp_irq);
1798 goto fail1; 1819 goto fail1c;
1799 } 1820 }
1800 if (gpio_is_valid(udc->board.vbus_pin)) { 1821 if (gpio_is_valid(udc->board.vbus_pin)) {
1801 retval = gpio_request(udc->board.vbus_pin, "udc_vbus"); 1822 retval = gpio_request(udc->board.vbus_pin, "udc_vbus");
@@ -1848,6 +1869,13 @@ fail3:
1848 gpio_free(udc->board.vbus_pin); 1869 gpio_free(udc->board.vbus_pin);
1849fail2: 1870fail2:
1850 free_irq(udc->udp_irq, udc); 1871 free_irq(udc->udp_irq, udc);
1872fail1c:
1873 clk_unprepare(udc->iclk);
1874fail1b:
1875 clk_unprepare(udc->fclk);
1876fail1a:
1877 if (IS_ENABLED(CONFIG_COMMON_CLK))
1878 clk_unprepare(udc->uclk);
1851fail1: 1879fail1:
1852 if (IS_ENABLED(CONFIG_COMMON_CLK) && !IS_ERR(udc->uclk)) 1880 if (IS_ENABLED(CONFIG_COMMON_CLK) && !IS_ERR(udc->uclk))
1853 clk_put(udc->uclk); 1881 clk_put(udc->uclk);
@@ -1896,6 +1924,11 @@ static int __exit at91udc_remove(struct platform_device *pdev)
1896 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1924 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1897 release_mem_region(res->start, resource_size(res)); 1925 release_mem_region(res->start, resource_size(res));
1898 1926
1927 if (IS_ENABLED(CONFIG_COMMON_CLK))
1928 clk_unprepare(udc->uclk);
1929 clk_unprepare(udc->fclk);
1930 clk_unprepare(udc->iclk);
1931
1899 clk_put(udc->iclk); 1932 clk_put(udc->iclk);
1900 clk_put(udc->fclk); 1933 clk_put(udc->fclk);
1901 if (IS_ENABLED(CONFIG_COMMON_CLK)) 1934 if (IS_ENABLED(CONFIG_COMMON_CLK))
diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.c b/drivers/usb/gadget/udc/atmel_usba_udc.c
index 1529926e20a0..b31747979c4a 100644
--- a/drivers/usb/gadget/udc/atmel_usba_udc.c
+++ b/drivers/usb/gadget/udc/atmel_usba_udc.c
@@ -987,8 +987,8 @@ usba_udc_set_selfpowered(struct usb_gadget *gadget, int is_selfpowered)
987 987
988static int atmel_usba_start(struct usb_gadget *gadget, 988static int atmel_usba_start(struct usb_gadget *gadget,
989 struct usb_gadget_driver *driver); 989 struct usb_gadget_driver *driver);
990static int atmel_usba_stop(struct usb_gadget *gadget, 990static int atmel_usba_stop(struct usb_gadget *gadget);
991 struct usb_gadget_driver *driver); 991
992static const struct usb_gadget_ops usba_udc_ops = { 992static const struct usb_gadget_ops usba_udc_ops = {
993 .get_frame = usba_udc_get_frame, 993 .get_frame = usba_udc_get_frame,
994 .wakeup = usba_udc_wakeup, 994 .wakeup = usba_udc_wakeup,
@@ -1007,19 +1007,10 @@ static struct usb_endpoint_descriptor usba_ep0_desc = {
1007 .bInterval = 1, 1007 .bInterval = 1,
1008}; 1008};
1009 1009
1010static void nop_release(struct device *dev)
1011{
1012
1013}
1014
1015static struct usb_gadget usba_gadget_template = { 1010static struct usb_gadget usba_gadget_template = {
1016 .ops = &usba_udc_ops, 1011 .ops = &usba_udc_ops,
1017 .max_speed = USB_SPEED_HIGH, 1012 .max_speed = USB_SPEED_HIGH,
1018 .name = "atmel_usba_udc", 1013 .name = "atmel_usba_udc",
1019 .dev = {
1020 .init_name = "gadget",
1021 .release = nop_release,
1022 },
1023}; 1014};
1024 1015
1025/* 1016/*
@@ -1685,11 +1676,10 @@ static irqreturn_t usba_udc_irq(int irq, void *devid)
1685 usba_writel(udc, INT_CLR, USBA_END_OF_RESET); 1676 usba_writel(udc, INT_CLR, USBA_END_OF_RESET);
1686 reset_all_endpoints(udc); 1677 reset_all_endpoints(udc);
1687 1678
1688 if (udc->gadget.speed != USB_SPEED_UNKNOWN 1679 if (udc->gadget.speed != USB_SPEED_UNKNOWN && udc->driver) {
1689 && udc->driver && udc->driver->disconnect) {
1690 udc->gadget.speed = USB_SPEED_UNKNOWN; 1680 udc->gadget.speed = USB_SPEED_UNKNOWN;
1691 spin_unlock(&udc->lock); 1681 spin_unlock(&udc->lock);
1692 udc->driver->disconnect(&udc->gadget); 1682 usb_gadget_udc_reset(&udc->gadget, udc->driver);
1693 spin_lock(&udc->lock); 1683 spin_lock(&udc->lock);
1694 } 1684 }
1695 1685
@@ -1791,8 +1781,6 @@ static int atmel_usba_start(struct usb_gadget *gadget,
1791 return ret; 1781 return ret;
1792 } 1782 }
1793 1783
1794 DBG(DBG_GADGET, "registered driver `%s'\n", driver->driver.name);
1795
1796 udc->vbus_prev = 0; 1784 udc->vbus_prev = 0;
1797 if (gpio_is_valid(udc->vbus_pin)) 1785 if (gpio_is_valid(udc->vbus_pin))
1798 enable_irq(gpio_to_irq(udc->vbus_pin)); 1786 enable_irq(gpio_to_irq(udc->vbus_pin));
@@ -1809,8 +1797,7 @@ static int atmel_usba_start(struct usb_gadget *gadget,
1809 return 0; 1797 return 0;
1810} 1798}
1811 1799
1812static int atmel_usba_stop(struct usb_gadget *gadget, 1800static int atmel_usba_stop(struct usb_gadget *gadget)
1813 struct usb_gadget_driver *driver)
1814{ 1801{
1815 struct usba_udc *udc = container_of(gadget, struct usba_udc, gadget); 1802 struct usba_udc *udc = container_of(gadget, struct usba_udc, gadget);
1816 unsigned long flags; 1803 unsigned long flags;
@@ -1830,8 +1817,6 @@ static int atmel_usba_stop(struct usb_gadget *gadget,
1830 clk_disable_unprepare(udc->hclk); 1817 clk_disable_unprepare(udc->hclk);
1831 clk_disable_unprepare(udc->pclk); 1818 clk_disable_unprepare(udc->pclk);
1832 1819
1833 DBG(DBG_GADGET, "unregistered driver `%s'\n", udc->driver->driver.name);
1834
1835 udc->driver = NULL; 1820 udc->driver = NULL;
1836 1821
1837 return 0; 1822 return 0;
diff --git a/drivers/usb/gadget/udc/bcm63xx_udc.c b/drivers/usb/gadget/udc/bcm63xx_udc.c
index 2235b8808700..c790918b337b 100644
--- a/drivers/usb/gadget/udc/bcm63xx_udc.c
+++ b/drivers/usb/gadget/udc/bcm63xx_udc.c
@@ -1836,8 +1836,7 @@ static int bcm63xx_udc_start(struct usb_gadget *gadget,
1836 * @gadget: USB slave device. 1836 * @gadget: USB slave device.
1837 * @driver: Driver for USB slave devices. 1837 * @driver: Driver for USB slave devices.
1838 */ 1838 */
1839static int bcm63xx_udc_stop(struct usb_gadget *gadget, 1839static int bcm63xx_udc_stop(struct usb_gadget *gadget)
1840 struct usb_gadget_driver *driver)
1841{ 1840{
1842 struct bcm63xx_udc *udc = gadget_to_udc(gadget); 1841 struct bcm63xx_udc *udc = gadget_to_udc(gadget);
1843 unsigned long flags; 1842 unsigned long flags;
@@ -1963,7 +1962,7 @@ static irqreturn_t bcm63xx_udc_ctrl_isr(int irq, void *dev_id)
1963{ 1962{
1964 struct bcm63xx_udc *udc = dev_id; 1963 struct bcm63xx_udc *udc = dev_id;
1965 u32 stat; 1964 u32 stat;
1966 bool disconnected = false; 1965 bool disconnected = false, bus_reset = false;
1967 1966
1968 stat = usbd_readl(udc, USBD_EVENT_IRQ_STATUS_REG) & 1967 stat = usbd_readl(udc, USBD_EVENT_IRQ_STATUS_REG) &
1969 usbd_readl(udc, USBD_EVENT_IRQ_MASK_REG); 1968 usbd_readl(udc, USBD_EVENT_IRQ_MASK_REG);
@@ -1991,7 +1990,7 @@ static irqreturn_t bcm63xx_udc_ctrl_isr(int irq, void *dev_id)
1991 1990
1992 udc->ep0_req_reset = 1; 1991 udc->ep0_req_reset = 1;
1993 schedule_work(&udc->ep0_wq); 1992 schedule_work(&udc->ep0_wq);
1994 disconnected = true; 1993 bus_reset = true;
1995 } 1994 }
1996 if (stat & BIT(USBD_EVENT_IRQ_SETUP)) { 1995 if (stat & BIT(USBD_EVENT_IRQ_SETUP)) {
1997 if (bcm63xx_update_link_speed(udc)) { 1996 if (bcm63xx_update_link_speed(udc)) {
@@ -2014,6 +2013,8 @@ static irqreturn_t bcm63xx_udc_ctrl_isr(int irq, void *dev_id)
2014 2013
2015 if (disconnected && udc->driver) 2014 if (disconnected && udc->driver)
2016 udc->driver->disconnect(&udc->gadget); 2015 udc->driver->disconnect(&udc->gadget);
2016 else if (bus_reset && udc->driver)
2017 usb_gadget_udc_reset(&udc->gadget, udc->driver);
2017 2018
2018 return IRQ_HANDLED; 2019 return IRQ_HANDLED;
2019} 2020}
@@ -2324,10 +2325,8 @@ static int bcm63xx_udc_probe(struct platform_device *pdev)
2324 int rc = -ENOMEM, i, irq; 2325 int rc = -ENOMEM, i, irq;
2325 2326
2326 udc = devm_kzalloc(dev, sizeof(*udc), GFP_KERNEL); 2327 udc = devm_kzalloc(dev, sizeof(*udc), GFP_KERNEL);
2327 if (!udc) { 2328 if (!udc)
2328 dev_err(dev, "cannot allocate memory\n");
2329 return -ENOMEM; 2329 return -ENOMEM;
2330 }
2331 2330
2332 platform_set_drvdata(pdev, udc); 2331 platform_set_drvdata(pdev, udc);
2333 udc->dev = dev; 2332 udc->dev = dev;
diff --git a/drivers/usb/gadget/udc/bdc/Kconfig b/drivers/usb/gadget/udc/bdc/Kconfig
new file mode 100644
index 000000000000..0d7b8c9f72fd
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/Kconfig
@@ -0,0 +1,21 @@
1config USB_BDC_UDC
2 tristate "Broadcom USB3.0 device controller IP driver(BDC)"
3 depends on USB_GADGET && HAS_DMA
4
5 help
6 BDC is Broadcom's USB3.0 device controller IP. If your SOC has a BDC IP
7 then select this driver.
8
9 Say "y" here to link the driver statically, or "m" to build a dynamically
10 linked module called "bdc".
11
12if USB_BDC_UDC
13
14comment "Platform Support"
15config USB_BDC_PCI
16 tristate "BDC support for PCIe based platforms"
17 depends on PCI
18 default USB_BDC_UDC
19 help
20 Enable support for platforms which have BDC connected through PCIe, such as Lego3 FPGA platform.
21endif
diff --git a/drivers/usb/gadget/udc/bdc/Makefile b/drivers/usb/gadget/udc/bdc/Makefile
new file mode 100644
index 000000000000..5cf6a3bcdf0f
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/Makefile
@@ -0,0 +1,8 @@
1obj-$(CONFIG_USB_BDC_UDC) += bdc.o
2bdc-y := bdc_core.o bdc_cmd.o bdc_ep.o bdc_udc.o
3
4ifneq ($(CONFIG_USB_GADGET_VERBOSE),)
5 bdc-y += bdc_dbg.o
6endif
7
8obj-$(CONFIG_USB_BDC_PCI) += bdc_pci.o
diff --git a/drivers/usb/gadget/udc/bdc/bdc.h b/drivers/usb/gadget/udc/bdc/bdc.h
new file mode 100644
index 000000000000..dc18a20bf040
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc.h
@@ -0,0 +1,490 @@
1/*
2 * bdc.h - header for the BRCM BDC USB3.0 device controller
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15#ifndef __LINUX_BDC_H__
16#define __LINUX_BDC_H__
17
18#include <linux/kernel.h>
19#include <linux/usb.h>
20#include <linux/device.h>
21#include <linux/spinlock.h>
22#include <linux/list.h>
23#include <linux/dma-mapping.h>
24#include <linux/mm.h>
25#include <linux/debugfs.h>
26#include <linux/usb/ch9.h>
27#include <linux/usb/gadget.h>
28#include <asm/unaligned.h>
29
30#define BRCM_BDC_NAME "bdc_usb3"
31#define BRCM_BDC_DESC "BDC device controller driver"
32
33#define DMA_ADDR_INVALID (~(dma_addr_t)0)
34
35/* BDC command operation timeout in usec*/
36#define BDC_CMD_TIMEOUT 1000
37/* BDC controller operation timeout in usec*/
38#define BDC_COP_TIMEOUT 500
39
40/*
41 * Maximum size of ep0 response buffer for ch9 requests,
42 * the set_sel request uses 6 so far, the max.
43*/
44#define EP0_RESPONSE_BUFF 6
45/* Start with SS as default */
46#define EP0_MAX_PKT_SIZE 512
47
48/* 64 entries in a SRR */
49#define NUM_SR_ENTRIES 64
50
51/* Num of bds per table */
52#define NUM_BDS_PER_TABLE 32
53
54/* Num of tables in bd list for control,bulk and Int ep */
55#define NUM_TABLES 2
56
57/* Num of tables in bd list for Isoch ep */
58#define NUM_TABLES_ISOCH 6
59
60/* U1 Timeout default: 248usec */
61#define U1_TIMEOUT 0xf8
62
63/* Interrupt coalescence in usec */
64#define INT_CLS 500
65
66/* Register offsets */
67/* Configuration and Capability registers */
68#define BDC_BDCCFG0 0x00
69#define BDC_BDCCFG1 0x04
70#define BDC_BDCCAP0 0x08
71#define BDC_BDCCAP1 0x0c
72#define BDC_CMDPAR0 0x10
73#define BDC_CMDPAR1 0x14
74#define BDC_CMDPAR2 0x18
75#define BDC_CMDSC 0x1c
76#define BDC_USPC 0x20
77#define BDC_USPPMS 0x28
78#define BDC_USPPM2 0x2c
79#define BDC_SPBBAL 0x38
80#define BDC_SPBBAH 0x3c
81#define BDC_BDCSC 0x40
82#define BDC_XSFNTF 0x4c
83
84#define BDC_DVCSA 0x50
85#define BDC_DVCSB 0x54
86#define BDC_EPSTS0(n) (0x60 + (n * 0x10))
87#define BDC_EPSTS1(n) (0x64 + (n * 0x10))
88#define BDC_EPSTS2(n) (0x68 + (n * 0x10))
89#define BDC_EPSTS3(n) (0x6c + (n * 0x10))
90#define BDC_EPSTS4(n) (0x70 + (n * 0x10))
91#define BDC_EPSTS5(n) (0x74 + (n * 0x10))
92#define BDC_EPSTS6(n) (0x78 + (n * 0x10))
93#define BDC_EPSTS7(n) (0x7c + (n * 0x10))
94#define BDC_SRRBAL(n) (0x200 + (n * 0x10))
95#define BDC_SRRBAH(n) (0x204 + (n * 0x10))
96#define BDC_SRRINT(n) (0x208 + (n * 0x10))
97#define BDC_INTCTLS(n) (0x20c + (n * 0x10))
98
99/* Extended capability regs */
100#define BDC_FSCNOC 0xcd4
101#define BDC_FSCNIC 0xce4
102#define NUM_NCS(p) (p >> 28)
103
104/* Register bit fields and Masks */
105/* BDC Configuration 0 */
106#define BDC_PGS(p) (((p) & (0x7 << 8)) >> 8)
107#define BDC_SPB(p) (p & 0x7)
108
109/* BDC Capability1 */
110#define BDC_P64 (1 << 0)
111
112/* BDC Command register */
113#define BDC_CMD_FH 0xe
114#define BDC_CMD_DNC 0x6
115#define BDC_CMD_EPO 0x4
116#define BDC_CMD_BLA 0x3
117#define BDC_CMD_EPC 0x2
118#define BDC_CMD_DVC 0x1
119#define BDC_CMD_CWS (0x1 << 5)
120#define BDC_CMD_CST(p) (((p) & (0xf << 6))>>6)
121#define BDC_CMD_EPN(p) ((p & 0x1f) << 10)
122#define BDC_SUB_CMD_ADD (0x1 << 17)
123#define BDC_SUB_CMD_FWK (0x4 << 17)
124/* Reset sequence number */
125#define BDC_CMD_EPO_RST_SN (0x1 << 16)
126#define BDC_CMD_EP0_XSD (0x1 << 16)
127#define BDC_SUB_CMD_ADD_EP (0x1 << 17)
128#define BDC_SUB_CMD_DRP_EP (0x2 << 17)
129#define BDC_SUB_CMD_EP_STP (0x2 << 17)
130#define BDC_SUB_CMD_EP_STL (0x4 << 17)
131#define BDC_SUB_CMD_EP_RST (0x1 << 17)
132#define BDC_CMD_SRD (1 << 27)
133
134/* CMD completion status */
135#define BDC_CMDS_SUCC 0x1
136#define BDC_CMDS_PARA 0x3
137#define BDC_CMDS_STAT 0x4
138#define BDC_CMDS_FAIL 0x5
139#define BDC_CMDS_INTL 0x6
140#define BDC_CMDS_BUSY 0xf
141
142/* CMDSC Param 2 shifts */
143#define EPT_SHIFT 22
144#define MP_SHIFT 10
145#define MB_SHIFT 6
146#define EPM_SHIFT 4
147
148/* BDC USPSC */
149#define BDC_VBC (1 << 31)
150#define BDC_PRC (1 << 30)
151#define BDC_PCE (1 << 29)
152#define BDC_CFC (1 << 28)
153#define BDC_PCC (1 << 27)
154#define BDC_PSC (1 << 26)
155#define BDC_VBS (1 << 25)
156#define BDC_PRS (1 << 24)
157#define BDC_PCS (1 << 23)
158#define BDC_PSP(p) (((p) & (0x7 << 20))>>20)
159#define BDC_SCN (1 << 8)
160#define BDC_SDC (1 << 7)
161#define BDC_SWS (1 << 4)
162
163#define BDC_USPSC_RW (BDC_SCN|BDC_SDC|BDC_SWS|0xf)
164#define BDC_PSP(p) (((p) & (0x7 << 20))>>20)
165
166#define BDC_SPEED_FS 0x1
167#define BDC_SPEED_LS 0x2
168#define BDC_SPEED_HS 0x3
169#define BDC_SPEED_SS 0x4
170
171#define BDC_PST(p) (p & 0xf)
172#define BDC_PST_MASK 0xf
173
174/* USPPMS */
175#define BDC_U2E (0x1 << 31)
176#define BDC_U1E (0x1 << 30)
177#define BDC_U2A (0x1 << 29)
178#define BDC_PORT_W1S (0x1 << 17)
179#define BDC_U1T(p) ((p) & 0xff)
180#define BDC_U2T(p) (((p) & 0xff) << 8)
181#define BDC_U1T_MASK 0xff
182
183/* USBPM2 */
184/* Hardware LPM Enable */
185#define BDC_HLE (1 << 16)
186
187/* BDC Status and Control */
188#define BDC_COP_RST (1 << 29)
189#define BDC_COP_RUN (2 << 29)
190#define BDC_COP_STP (4 << 29)
191
192#define BDC_COP_MASK (BDC_COP_RST|BDC_COP_RUN|BDC_COP_STP)
193
194#define BDC_COS (1 << 28)
195#define BDC_CSTS(p) (((p) & (0x7 << 20)) >> 20)
196#define BDC_MASK_MCW (1 << 7)
197#define BDC_GIE (1 << 1)
198#define BDC_GIP (1 << 0)
199
200#define BDC_HLT 1
201#define BDC_NOR 2
202#define BDC_OIP 7
203
204/* Buffer descriptor and Status report bit fields and masks */
205#define BD_TYPE_BITMASK (0xf)
206#define BD_CHAIN 0xf
207
208#define BD_TFS_SHIFT 4
209#define BD_SOT (1 << 26)
210#define BD_EOT (1 << 27)
211#define BD_ISP (1 << 29)
212#define BD_IOC (1 << 30)
213#define BD_SBF (1 << 31)
214
215#define BD_INTR_TARGET(p) (((p) & 0x1f) << 27)
216
217#define BDC_SRR_RWS (1 << 4)
218#define BDC_SRR_RST (1 << 3)
219#define BDC_SRR_ISR (1 << 2)
220#define BDC_SRR_IE (1 << 1)
221#define BDC_SRR_IP (1 << 0)
222#define BDC_SRR_EPI(p) (((p) & (0xff << 24)) >> 24)
223#define BDC_SRR_DPI(p) (((p) & (0xff << 16)) >> 16)
224#define BDC_SRR_DPI_MASK 0x00ff0000
225
226#define MARK_CHAIN_BD (BD_CHAIN|BD_EOT|BD_SOT)
227
228/* Control transfer BD specific fields */
229#define BD_DIR_IN (1 << 25)
230
231#define BDC_PTC_MASK 0xf0000000
232
233/* status report defines */
234#define SR_XSF 0
235#define SR_USPC 4
236#define SR_BD_LEN(p) (p & 0xffffff)
237
238#define XSF_SUCC 0x1
239#define XSF_SHORT 0x3
240#define XSF_BABB 0x4
241#define XSF_SETUP_RECV 0x6
242#define XSF_DATA_START 0x7
243#define XSF_STATUS_START 0x8
244
245#define XSF_STS(p) (((p) >> 28) & 0xf)
246
247/* Transfer BD fields */
248#define BD_LEN(p) ((p) & 0x1ffff)
249#define BD_LTF (1 << 25)
250#define BD_TYPE_DS 0x1
251#define BD_TYPE_SS 0x2
252
253#define BDC_EP_ENABLED (1 << 0)
254#define BDC_EP_STALL (1 << 1)
255#define BDC_EP_STOP (1 << 2)
256
257/* One BD can transfer max 65536 bytes */
258#define BD_MAX_BUFF_SIZE (1 << 16)
259/* Maximum bytes in one XFR, Refer to BDC spec */
260#define MAX_XFR_LEN 16777215
261
262/* defines for Force Header command */
263#define DEV_NOTF_TYPE 6
264#define FWK_SUBTYPE 1
265#define TRA_PACKET 4
266
267#define to_bdc_ep(e) container_of(e, struct bdc_ep, usb_ep)
268#define to_bdc_req(r) container_of(r, struct bdc_req, usb_req)
269#define gadget_to_bdc(g) container_of(g, struct bdc, gadget)
270
271/* FUNCTION WAKE DEV NOTIFICATION interval, USB3 spec table 8.13 */
272#define BDC_TNOTIFY 2500 /*in ms*/
273/* Devstatus bitfields */
274#define REMOTE_WAKEUP_ISSUED (1 << 16)
275#define DEVICE_SUSPENDED (1 << 17)
276#define FUNC_WAKE_ISSUED (1 << 18)
277#define REMOTE_WAKE_ENABLE (1 << USB_DEVICE_REMOTE_WAKEUP)
278
279/* On disconnect, preserve these bits and clear rest */
280#define DEVSTATUS_CLEAR (1 << USB_DEVICE_SELF_POWERED)
281/* Hardware and software Data structures */
282
283/* Endpoint bd: buffer descriptor */
284struct bdc_bd {
285 __le32 offset[4];
286};
287
288/* Status report in Status report ring(srr) */
289struct bdc_sr {
290 __le32 offset[4];
291};
292
293/* bd_table: contigous bd's in a table */
294struct bd_table {
295 struct bdc_bd *start_bd;
296 /* dma address of start bd of table*/
297 dma_addr_t dma;
298};
299
300/*
301 * Each endpoint has a bdl(buffer descriptor list), bdl consists of 1 or more bd
302 * table's chained to each other through a chain bd, every table has equal
303 * number of bds. the software uses bdi(bd index) to refer to particular bd in
304 * the list.
305 */
306struct bd_list {
307 /* Array of bd table pointers*/
308 struct bd_table **bd_table_array;
309 /* How many tables chained to each other */
310 int num_tabs;
311 /* Max_bdi = num_tabs * num_bds_table - 1 */
312 int max_bdi;
313 /* current enq bdi from sw point of view */
314 int eqp_bdi;
315 /* current deq bdi from sw point of view */
316 int hwd_bdi;
317 /* numbers of bds per table */
318 int num_bds_table;
319};
320
321struct bdc_req;
322
323/* Representation of a transfer, one transfer can have multiple bd's */
324struct bd_transfer {
325 struct bdc_req *req;
326 /* start bd index */
327 int start_bdi;
328 /* this will be the next hw dqp when this transfer completes */
329 int next_hwd_bdi;
330 /* number of bds in this transfer */
331 int num_bds;
332};
333
334/*
335 * Representation of a gadget request, every gadget request is contained
336 * by 1 bd_transfer.
337 */
338struct bdc_req {
339 struct usb_request usb_req;
340 struct list_head queue;
341 struct bdc_ep *ep;
342 /* only one Transfer per request */
343 struct bd_transfer bd_xfr;
344 int epnum;
345};
346
347/* scratchpad buffer needed by bdc hardware */
348struct bdc_scratchpad {
349 dma_addr_t sp_dma;
350 void *buff;
351 u32 size;
352};
353
354/* endpoint representation */
355struct bdc_ep {
356 struct usb_ep usb_ep;
357 struct list_head queue;
358 struct bdc *bdc;
359 u8 ep_type;
360 u8 dir;
361 u8 ep_num;
362 const struct usb_ss_ep_comp_descriptor *comp_desc;
363 const struct usb_endpoint_descriptor *desc;
364 unsigned int flags;
365 char name[20];
366 /* endpoint bd list*/
367 struct bd_list bd_list;
368 /*
369 * HW generates extra event for multi bd tranfers, this flag helps in
370 * ignoring the extra event
371 */
372 bool ignore_next_sr;
373};
374
375/* bdc cmmand parameter structure */
376struct bdc_cmd_params {
377 u32 param2;
378 u32 param1;
379 u32 param0;
380};
381
382/* status report ring(srr), currently one srr is supported for entire system */
383struct srr {
384 struct bdc_sr *sr_bds;
385 u16 eqp_index;
386 u16 dqp_index;
387 dma_addr_t dma_addr;
388};
389
390/* EP0 states */
391enum bdc_ep0_state {
392 WAIT_FOR_SETUP = 0,
393 WAIT_FOR_DATA_START,
394 WAIT_FOR_DATA_XMIT,
395 WAIT_FOR_STATUS_START,
396 WAIT_FOR_STATUS_XMIT,
397 STATUS_PENDING
398};
399
400/* Link states */
401enum bdc_link_state {
402 BDC_LINK_STATE_U0 = 0x00,
403 BDC_LINK_STATE_U3 = 0x03,
404 BDC_LINK_STATE_RX_DET = 0x05,
405 BDC_LINK_STATE_RESUME = 0x0f
406};
407
408/* representation of bdc */
409struct bdc {
410 struct usb_gadget gadget;
411 struct usb_gadget_driver *gadget_driver;
412 struct device *dev;
413 /* device lock */
414 spinlock_t lock;
415
416 /* num of endpoints for a particular instantiation of IP */
417 unsigned int num_eps;
418 /*
419 * Array of ep's, it uses the same index covention as bdc hw i.e.
420 * 1 for ep0, 2 for 1out,3 for 1in ....
421 */
422 struct bdc_ep **bdc_ep_array;
423 void __iomem *regs;
424 struct bdc_scratchpad scratchpad;
425 u32 sp_buff_size;
426 /* current driver supports 1 status ring */
427 struct srr srr;
428 /* Last received setup packet */
429 struct usb_ctrlrequest setup_pkt;
430 struct bdc_req ep0_req;
431 struct bdc_req status_req;
432 enum bdc_ep0_state ep0_state;
433 bool delayed_status;
434 bool zlp_needed;
435 bool reinit;
436 bool pullup;
437 /* Bits 0-15 are standard and 16-31 for proprietary information */
438 u32 devstatus;
439 int irq;
440 void *mem;
441 u32 dev_addr;
442 /* DMA pools */
443 struct dma_pool *bd_table_pool;
444 u8 test_mode;
445 /* array of callbacks for various status report handlers */
446 void (*sr_handler[2])(struct bdc *, struct bdc_sr *);
447 /* ep0 callback handlers */
448 void (*sr_xsf_ep0[3])(struct bdc *, struct bdc_sr *);
449 /* ep0 response buffer for ch9 requests like GET_STATUS and SET_SEL */
450 unsigned char ep0_response_buff[EP0_RESPONSE_BUFF];
451 /*
452 * Timer to check if host resumed transfer after bdc sent Func wake
453 * notification packet after a remote wakeup. if not, then resend the
454 * Func Wake packet every 2.5 secs. Refer to USB3 spec section 8.5.6.4
455 */
456 struct delayed_work func_wake_notify;
457};
458
459static inline u32 bdc_readl(void __iomem *base, u32 offset)
460{
461 return readl(base + offset);
462}
463
464static inline void bdc_writel(void __iomem *base, u32 offset, u32 value)
465{
466 writel(value, base + offset);
467}
468
469/* Buffer descriptor list operations */
470void bdc_notify_xfr(struct bdc *, u32);
471void bdc_softconn(struct bdc *);
472void bdc_softdisconn(struct bdc *);
473int bdc_run(struct bdc *);
474int bdc_stop(struct bdc *);
475int bdc_reset(struct bdc *);
476int bdc_udc_init(struct bdc *);
477void bdc_udc_exit(struct bdc *);
478int bdc_reinit(struct bdc *);
479
480/* Status report handlers */
481/* Upstream port status change sr */
482void bdc_sr_uspc(struct bdc *, struct bdc_sr *);
483/* transfer sr */
484void bdc_sr_xsf(struct bdc *, struct bdc_sr *);
485/* EP0 XSF handlers */
486void bdc_xsf_ep0_setup_recv(struct bdc *, struct bdc_sr *);
487void bdc_xsf_ep0_data_start(struct bdc *, struct bdc_sr *);
488void bdc_xsf_ep0_status_start(struct bdc *, struct bdc_sr *);
489
490#endif /* __LINUX_BDC_H__ */
diff --git a/drivers/usb/gadget/udc/bdc/bdc_cmd.c b/drivers/usb/gadget/udc/bdc/bdc_cmd.c
new file mode 100644
index 000000000000..6a4155c4bd86
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_cmd.c
@@ -0,0 +1,376 @@
1/*
2 * bdc_cmd.c - BRCM BDC USB3.0 device controller
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14#include <linux/scatterlist.h>
15#include <linux/slab.h>
16
17#include "bdc.h"
18#include "bdc_cmd.h"
19#include "bdc_dbg.h"
20
21/* Issues a cmd to cmd processor and waits for cmd completion */
22static int bdc_issue_cmd(struct bdc *bdc, u32 cmd_sc, u32 param0,
23 u32 param1, u32 param2)
24{
25 u32 timeout = BDC_CMD_TIMEOUT;
26 u32 cmd_status;
27 u32 temp;
28
29 bdc_writel(bdc->regs, BDC_CMDPAR0, param0);
30 bdc_writel(bdc->regs, BDC_CMDPAR1, param1);
31 bdc_writel(bdc->regs, BDC_CMDPAR2, param2);
32
33 /* Issue the cmd */
34 /* Make sure the cmd params are written before asking HW to exec cmd */
35 wmb();
36 bdc_writel(bdc->regs, BDC_CMDSC, cmd_sc | BDC_CMD_CWS | BDC_CMD_SRD);
37 do {
38 temp = bdc_readl(bdc->regs, BDC_CMDSC);
39 dev_dbg_ratelimited(bdc->dev, "cmdsc=%x", temp);
40 cmd_status = BDC_CMD_CST(temp);
41 if (cmd_status != BDC_CMDS_BUSY) {
42 dev_dbg(bdc->dev,
43 "command completed cmd_sts:%x\n", cmd_status);
44 return cmd_status;
45 }
46 udelay(1);
47 } while (timeout--);
48
49 dev_err(bdc->dev,
50 "command operation timedout cmd_status=%d\n", cmd_status);
51
52 return cmd_status;
53}
54
55/* Submits cmd and analyze the return value of bdc_issue_cmd */
56static int bdc_submit_cmd(struct bdc *bdc, u32 cmd_sc,
57 u32 param0, u32 param1, u32 param2)
58{
59 u32 temp, cmd_status;
60 int reset_bdc = 0;
61 int ret;
62
63 temp = bdc_readl(bdc->regs, BDC_CMDSC);
64 dev_dbg(bdc->dev,
65 "%s:CMDSC:%08x cmdsc:%08x param0=%08x param1=%08x param2=%08x\n",
66 __func__, temp, cmd_sc, param0, param1, param2);
67
68 cmd_status = BDC_CMD_CST(temp);
69 if (cmd_status == BDC_CMDS_BUSY) {
70 dev_err(bdc->dev, "command processor busy: %x\n", cmd_status);
71 return -EBUSY;
72 }
73 ret = bdc_issue_cmd(bdc, cmd_sc, param0, param1, param2);
74 switch (ret) {
75 case BDC_CMDS_SUCC:
76 dev_dbg(bdc->dev, "command completed successfully\n");
77 ret = 0;
78 break;
79
80 case BDC_CMDS_PARA:
81 dev_err(bdc->dev, "command parameter error\n");
82 ret = -EINVAL;
83 break;
84
85 case BDC_CMDS_STAT:
86 dev_err(bdc->dev, "Invalid device/ep state\n");
87 ret = -EINVAL;
88 break;
89
90 case BDC_CMDS_FAIL:
91 dev_err(bdc->dev, "Command failed?\n");
92 ret = -EAGAIN;
93 break;
94
95 case BDC_CMDS_INTL:
96 dev_err(bdc->dev, "BDC Internal error\n");
97 reset_bdc = 1;
98 ret = -ECONNRESET;
99 break;
100
101 case BDC_CMDS_BUSY:
102 dev_err(bdc->dev,
103 "command timedout waited for %dusec\n",
104 BDC_CMD_TIMEOUT);
105 reset_bdc = 1;
106 ret = -ECONNRESET;
107 break;
108 default:
109 dev_dbg(bdc->dev, "Unknown command completion code:%x\n", ret);
110 }
111
112 return ret;
113}
114
115/* Deconfigure the endpoint from HW */
116int bdc_dconfig_ep(struct bdc *bdc, struct bdc_ep *ep)
117{
118 u32 cmd_sc;
119
120 cmd_sc = BDC_SUB_CMD_DRP_EP|BDC_CMD_EPN(ep->ep_num)|BDC_CMD_EPC;
121 dev_dbg(bdc->dev, "%s ep->ep_num =%d cmd_sc=%x\n", __func__,
122 ep->ep_num, cmd_sc);
123
124 return bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0);
125}
126
127/* Reinitalize the bdlist after config ep command */
128static void ep_bd_list_reinit(struct bdc_ep *ep)
129{
130 struct bdc *bdc = ep->bdc;
131 struct bdc_bd *bd;
132
133 ep->bd_list.eqp_bdi = 0;
134 ep->bd_list.hwd_bdi = 0;
135 bd = ep->bd_list.bd_table_array[0]->start_bd;
136 dev_dbg(bdc->dev, "%s ep:%p bd:%p\n", __func__, ep, bd);
137 memset(bd, 0, sizeof(struct bdc_bd));
138 bd->offset[3] |= cpu_to_le32(BD_SBF);
139}
140
141/* Configure an endpoint */
142int bdc_config_ep(struct bdc *bdc, struct bdc_ep *ep)
143{
144 const struct usb_ss_ep_comp_descriptor *comp_desc;
145 const struct usb_endpoint_descriptor *desc;
146 u32 param0, param1, param2, cmd_sc;
147 u32 mps, mbs, mul, si;
148 int ret;
149
150 desc = ep->desc;
151 comp_desc = ep->comp_desc;
152 cmd_sc = mul = mbs = param2 = 0;
153 param0 = lower_32_bits(ep->bd_list.bd_table_array[0]->dma);
154 param1 = upper_32_bits(ep->bd_list.bd_table_array[0]->dma);
155 cpu_to_le32s(&param0);
156 cpu_to_le32s(&param1);
157
158 dev_dbg(bdc->dev, "%s: param0=%08x param1=%08x",
159 __func__, param0, param1);
160 si = desc->bInterval;
161 si = clamp_val(si, 1, 16) - 1;
162
163 mps = usb_endpoint_maxp(desc);
164 mps &= 0x7ff;
165 param2 |= mps << MP_SHIFT;
166 param2 |= usb_endpoint_type(desc) << EPT_SHIFT;
167
168 switch (bdc->gadget.speed) {
169 case USB_SPEED_SUPER:
170 if (usb_endpoint_xfer_int(desc) ||
171 usb_endpoint_xfer_isoc(desc)) {
172 param2 |= si;
173 if (usb_endpoint_xfer_isoc(desc) && comp_desc)
174 mul = comp_desc->bmAttributes;
175
176 }
177 param2 |= mul << EPM_SHIFT;
178 if (comp_desc)
179 mbs = comp_desc->bMaxBurst;
180 param2 |= mbs << MB_SHIFT;
181 break;
182
183 case USB_SPEED_HIGH:
184 if (usb_endpoint_xfer_isoc(desc) ||
185 usb_endpoint_xfer_int(desc)) {
186 param2 |= si;
187
188 mbs = (usb_endpoint_maxp(desc) & 0x1800) >> 11;
189 param2 |= mbs << MB_SHIFT;
190 }
191 break;
192
193 case USB_SPEED_FULL:
194 case USB_SPEED_LOW:
195 /* the hardware accepts SI in 125usec range */
196 if (usb_endpoint_xfer_isoc(desc))
197 si += 3;
198
199 /*
200 * FS Int endpoints can have si of 1-255ms but the controller
201 * accepts 2^bInterval*125usec, so convert ms to nearest power
202 * of 2
203 */
204 if (usb_endpoint_xfer_int(desc))
205 si = fls(desc->bInterval * 8) - 1;
206
207 param2 |= si;
208 break;
209 default:
210 dev_err(bdc->dev, "UNKNOWN speed ERR\n");
211 return -EINVAL;
212 }
213
214 cmd_sc |= BDC_CMD_EPC|BDC_CMD_EPN(ep->ep_num)|BDC_SUB_CMD_ADD_EP;
215
216 dev_dbg(bdc->dev, "cmd_sc=%x param2=%08x\n", cmd_sc, param2);
217 ret = bdc_submit_cmd(bdc, cmd_sc, param0, param1, param2);
218 if (ret) {
219 dev_err(bdc->dev, "command failed :%x\n", ret);
220 return ret;
221 }
222 ep_bd_list_reinit(ep);
223
224 return ret;
225}
226
227/*
228 * Change the HW deq pointer, if this command is successful, HW will start
229 * fetching the next bd from address dma_addr.
230 */
231int bdc_ep_bla(struct bdc *bdc, struct bdc_ep *ep, dma_addr_t dma_addr)
232{
233 u32 param0, param1;
234 u32 cmd_sc = 0;
235
236 dev_dbg(bdc->dev, "%s: add=%08llx\n", __func__,
237 (unsigned long long)(dma_addr));
238 param0 = lower_32_bits(dma_addr);
239 param1 = upper_32_bits(dma_addr);
240 cpu_to_le32s(&param0);
241 cpu_to_le32s(&param1);
242
243 cmd_sc |= BDC_CMD_EPN(ep->ep_num)|BDC_CMD_BLA;
244 dev_dbg(bdc->dev, "cmd_sc=%x\n", cmd_sc);
245
246 return bdc_submit_cmd(bdc, cmd_sc, param0, param1, 0);
247}
248
249/* Set the address sent bu Host in SET_ADD request */
250int bdc_address_device(struct bdc *bdc, u32 add)
251{
252 u32 cmd_sc = 0;
253 u32 param2;
254
255 dev_dbg(bdc->dev, "%s: add=%d\n", __func__, add);
256 cmd_sc |= BDC_SUB_CMD_ADD|BDC_CMD_DVC;
257 param2 = add & 0x7f;
258
259 return bdc_submit_cmd(bdc, cmd_sc, 0, 0, param2);
260}
261
262/* Send a Function Wake notification packet using FH command */
263int bdc_function_wake_fh(struct bdc *bdc, u8 intf)
264{
265 u32 param0, param1;
266 u32 cmd_sc = 0;
267
268 param0 = param1 = 0;
269 dev_dbg(bdc->dev, "%s intf=%d\n", __func__, intf);
270 cmd_sc |= BDC_CMD_FH;
271 param0 |= TRA_PACKET;
272 param0 |= (bdc->dev_addr << 25);
273 param1 |= DEV_NOTF_TYPE;
274 param1 |= (FWK_SUBTYPE<<4);
275 dev_dbg(bdc->dev, "param0=%08x param1=%08x\n", param0, param1);
276
277 return bdc_submit_cmd(bdc, cmd_sc, param0, param1, 0);
278}
279
280/* Send a Function Wake notification packet using DNC command */
281int bdc_function_wake(struct bdc *bdc, u8 intf)
282{
283 u32 cmd_sc = 0;
284 u32 param2 = 0;
285
286 dev_dbg(bdc->dev, "%s intf=%d", __func__, intf);
287 param2 |= intf;
288 cmd_sc |= BDC_SUB_CMD_FWK|BDC_CMD_DNC;
289
290 return bdc_submit_cmd(bdc, cmd_sc, 0, 0, param2);
291}
292
293/* Stall the endpoint */
294int bdc_ep_set_stall(struct bdc *bdc, int epnum)
295{
296 u32 cmd_sc = 0;
297
298 dev_dbg(bdc->dev, "%s epnum=%d\n", __func__, epnum);
299 /* issue a stall endpoint command */
300 cmd_sc |= BDC_SUB_CMD_EP_STL | BDC_CMD_EPN(epnum) | BDC_CMD_EPO;
301
302 return bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0);
303}
304
305/* resets the endpoint, called when host sends CLEAR_FEATURE(HALT) */
306int bdc_ep_clear_stall(struct bdc *bdc, int epnum)
307{
308 struct bdc_ep *ep;
309 u32 cmd_sc = 0;
310 int ret;
311
312 dev_dbg(bdc->dev, "%s: epnum=%d\n", __func__, epnum);
313 ep = bdc->bdc_ep_array[epnum];
314 /*
315 * If we are not in stalled then stall Endpoint and issue clear stall,
316 * his will reset the seq number for non EP0.
317 */
318 if (epnum != 1) {
319 /* if the endpoint it not stallled */
320 if (!(ep->flags & BDC_EP_STALL)) {
321 ret = bdc_ep_set_stall(bdc, epnum);
322 if (ret)
323 return ret;
324 }
325 }
326 /* Preserve the seq number for ep0 only */
327 if (epnum != 1)
328 cmd_sc |= BDC_CMD_EPO_RST_SN;
329
330 /* issue a reset endpoint command */
331 cmd_sc |= BDC_SUB_CMD_EP_RST | BDC_CMD_EPN(epnum) | BDC_CMD_EPO;
332
333 ret = bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0);
334 if (ret) {
335 dev_err(bdc->dev, "command failed:%x\n", ret);
336 return ret;
337 }
338 bdc_notify_xfr(bdc, epnum);
339
340 return ret;
341}
342
343/* Stop the endpoint, called when software wants to dequeue some request */
344int bdc_stop_ep(struct bdc *bdc, int epnum)
345{
346 struct bdc_ep *ep;
347 u32 cmd_sc = 0;
348 int ret;
349
350 ep = bdc->bdc_ep_array[epnum];
351 dev_dbg(bdc->dev, "%s: ep:%s ep->flags:%08x\n", __func__,
352 ep->name, ep->flags);
353 /* Endpoint has to be in running state to execute stop ep command */
354 if (!(ep->flags & BDC_EP_ENABLED)) {
355 dev_err(bdc->dev, "stop endpoint called for disabled ep\n");
356 return -EINVAL;
357 }
358 if ((ep->flags & BDC_EP_STALL) || (ep->flags & BDC_EP_STOP))
359 return 0;
360
361 /* issue a stop endpoint command */
362 cmd_sc |= BDC_CMD_EP0_XSD | BDC_SUB_CMD_EP_STP
363 | BDC_CMD_EPN(epnum) | BDC_CMD_EPO;
364
365 ret = bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0);
366 if (ret) {
367 dev_err(bdc->dev,
368 "stop endpoint command didn't complete:%d ep:%s\n",
369 ret, ep->name);
370 return ret;
371 }
372 ep->flags |= BDC_EP_STOP;
373 bdc_dump_epsts(bdc);
374
375 return ret;
376}
diff --git a/drivers/usb/gadget/udc/bdc/bdc_cmd.h b/drivers/usb/gadget/udc/bdc/bdc_cmd.h
new file mode 100644
index 000000000000..61d0e3bf9853
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_cmd.h
@@ -0,0 +1,29 @@
1/*
2 * bdc_cmd.h - header for the BDC debug functions
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14#ifndef __LINUX_BDC_CMD_H__
15#define __LINUX_BDC_CMD_H__
16
17/* Command operations */
18int bdc_address_device(struct bdc *, u32);
19int bdc_config_ep(struct bdc *, struct bdc_ep *);
20int bdc_dconfig_ep(struct bdc *, struct bdc_ep *);
21int bdc_stop_ep(struct bdc *, int);
22int bdc_ep_set_stall(struct bdc *, int);
23int bdc_ep_clear_stall(struct bdc *, int);
24int bdc_ep_set_halt(struct bdc_ep *, u32 , int);
25int bdc_ep_bla(struct bdc *, struct bdc_ep *, dma_addr_t);
26int bdc_function_wake(struct bdc*, u8);
27int bdc_function_wake_fh(struct bdc*, u8);
28
29#endif /* __LINUX_BDC_CMD_H__ */
diff --git a/drivers/usb/gadget/udc/bdc/bdc_core.c b/drivers/usb/gadget/udc/bdc/bdc_core.c
new file mode 100644
index 000000000000..c6dfef8c7bbc
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_core.c
@@ -0,0 +1,533 @@
1/*
2 * bdc_core.c - BRCM BDC USB3.0 device controller core operations
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/slab.h>
17#include <linux/spinlock.h>
18#include <linux/platform_device.h>
19#include <linux/interrupt.h>
20#include <linux/ioport.h>
21#include <linux/io.h>
22#include <linux/list.h>
23#include <linux/delay.h>
24#include <linux/dma-mapping.h>
25#include <linux/dmapool.h>
26#include <linux/of.h>
27#include <linux/moduleparam.h>
28#include <linux/usb/ch9.h>
29#include <linux/usb/gadget.h>
30
31#include "bdc.h"
32#include "bdc_dbg.h"
33
34/* Poll till controller status is not OIP */
35static int poll_oip(struct bdc *bdc, int usec)
36{
37 u32 status;
38 /* Poll till STS!= OIP */
39 while (usec) {
40 status = bdc_readl(bdc->regs, BDC_BDCSC);
41 if (BDC_CSTS(status) != BDC_OIP) {
42 dev_dbg(bdc->dev,
43 "poll_oip complete status=%d",
44 BDC_CSTS(status));
45 return 0;
46 }
47 udelay(10);
48 usec -= 10;
49 }
50 dev_err(bdc->dev, "Err: operation timedout BDCSC: 0x%08x\n", status);
51
52 return -ETIMEDOUT;
53}
54
55/* Stop the BDC controller */
56int bdc_stop(struct bdc *bdc)
57{
58 int ret;
59 u32 temp;
60
61 dev_dbg(bdc->dev, "%s ()\n\n", __func__);
62 temp = bdc_readl(bdc->regs, BDC_BDCSC);
63 /* Check if BDC is already halted */
64 if (BDC_CSTS(temp) == BDC_HLT) {
65 dev_vdbg(bdc->dev, "BDC already halted\n");
66 return 0;
67 }
68 temp &= ~BDC_COP_MASK;
69 temp |= BDC_COS|BDC_COP_STP;
70 bdc_writel(bdc->regs, BDC_BDCSC, temp);
71
72 ret = poll_oip(bdc, BDC_COP_TIMEOUT);
73 if (ret)
74 dev_err(bdc->dev, "bdc stop operation failed");
75
76 return ret;
77}
78
79/* Issue a reset to BDC controller */
80int bdc_reset(struct bdc *bdc)
81{
82 u32 temp;
83 int ret;
84
85 dev_dbg(bdc->dev, "%s ()\n", __func__);
86 /* First halt the controller */
87 ret = bdc_stop(bdc);
88 if (ret)
89 return ret;
90
91 temp = bdc_readl(bdc->regs, BDC_BDCSC);
92 temp &= ~BDC_COP_MASK;
93 temp |= BDC_COS|BDC_COP_RST;
94 bdc_writel(bdc->regs, BDC_BDCSC, temp);
95 ret = poll_oip(bdc, BDC_COP_TIMEOUT);
96 if (ret)
97 dev_err(bdc->dev, "bdc reset operation failed");
98
99 return ret;
100}
101
102/* Run the BDC controller */
103int bdc_run(struct bdc *bdc)
104{
105 u32 temp;
106 int ret;
107
108 dev_dbg(bdc->dev, "%s ()\n", __func__);
109 temp = bdc_readl(bdc->regs, BDC_BDCSC);
110 /* if BDC is already in running state then do not do anything */
111 if (BDC_CSTS(temp) == BDC_NOR) {
112 dev_warn(bdc->dev, "bdc is already in running state\n");
113 return 0;
114 }
115 temp &= ~BDC_COP_MASK;
116 temp |= BDC_COP_RUN;
117 temp |= BDC_COS;
118 bdc_writel(bdc->regs, BDC_BDCSC, temp);
119 ret = poll_oip(bdc, BDC_COP_TIMEOUT);
120 if (ret) {
121 dev_err(bdc->dev, "bdc run operation failed:%d", ret);
122 return ret;
123 }
124 temp = bdc_readl(bdc->regs, BDC_BDCSC);
125 if (BDC_CSTS(temp) != BDC_NOR) {
126 dev_err(bdc->dev, "bdc not in normal mode after RUN op :%d\n",
127 BDC_CSTS(temp));
128 return -ESHUTDOWN;
129 }
130
131 return 0;
132}
133
134/*
135 * Present the termination to the host, typically called from upstream port
136 * event with Vbus present =1
137 */
138void bdc_softconn(struct bdc *bdc)
139{
140 u32 uspc;
141
142 uspc = bdc_readl(bdc->regs, BDC_USPC);
143 uspc &= ~BDC_PST_MASK;
144 uspc |= BDC_LINK_STATE_RX_DET;
145 uspc |= BDC_SWS;
146 dev_dbg(bdc->dev, "%s () uspc=%08x\n", __func__, uspc);
147 bdc_writel(bdc->regs, BDC_USPC, uspc);
148}
149
150/* Remove the termination */
151void bdc_softdisconn(struct bdc *bdc)
152{
153 u32 uspc;
154
155 uspc = bdc_readl(bdc->regs, BDC_USPC);
156 uspc |= BDC_SDC;
157 uspc &= ~BDC_SCN;
158 dev_dbg(bdc->dev, "%s () uspc=%x\n", __func__, uspc);
159 bdc_writel(bdc->regs, BDC_USPC, uspc);
160}
161
162/* Set up the scratchpad buffer array and scratchpad buffers, if needed. */
163static int scratchpad_setup(struct bdc *bdc)
164{
165 int sp_buff_size;
166 u32 low32;
167 u32 upp32;
168
169 sp_buff_size = BDC_SPB(bdc_readl(bdc->regs, BDC_BDCCFG0));
170 dev_dbg(bdc->dev, "%s() sp_buff_size=%d\n", __func__, sp_buff_size);
171 if (!sp_buff_size) {
172 dev_dbg(bdc->dev, "Scratchpad buffer not needed\n");
173 return 0;
174 }
175 /* Refer to BDC spec, Table 4 for description of SPB */
176 sp_buff_size = 1 << (sp_buff_size + 5);
177 dev_dbg(bdc->dev, "Allocating %d bytes for scratchpad\n", sp_buff_size);
178 bdc->scratchpad.buff = dma_zalloc_coherent(bdc->dev, sp_buff_size,
179 &bdc->scratchpad.sp_dma, GFP_KERNEL);
180
181 if (!bdc->scratchpad.buff)
182 goto fail;
183
184 bdc->sp_buff_size = sp_buff_size;
185 bdc->scratchpad.size = sp_buff_size;
186 low32 = lower_32_bits(bdc->scratchpad.sp_dma);
187 upp32 = upper_32_bits(bdc->scratchpad.sp_dma);
188 cpu_to_le32s(&low32);
189 cpu_to_le32s(&upp32);
190 bdc_writel(bdc->regs, BDC_SPBBAL, low32);
191 bdc_writel(bdc->regs, BDC_SPBBAH, upp32);
192 return 0;
193
194fail:
195 bdc->scratchpad.buff = NULL;
196
197 return -ENOMEM;
198}
199
200/* Allocate the status report ring */
201static int setup_srr(struct bdc *bdc, int interrupter)
202{
203 dev_dbg(bdc->dev, "%s() NUM_SR_ENTRIES:%d\n", __func__, NUM_SR_ENTRIES);
204 /* Reset the SRR */
205 bdc_writel(bdc->regs, BDC_SRRINT(0), BDC_SRR_RWS | BDC_SRR_RST);
206 bdc->srr.dqp_index = 0;
207 /* allocate the status report descriptors */
208 bdc->srr.sr_bds = dma_zalloc_coherent(
209 bdc->dev,
210 NUM_SR_ENTRIES * sizeof(struct bdc_bd),
211 &bdc->srr.dma_addr,
212 GFP_KERNEL);
213 if (!bdc->srr.sr_bds)
214 return -ENOMEM;
215
216 return 0;
217}
218
219/* Initialize the HW regs and internal data structures */
220static void bdc_mem_init(struct bdc *bdc, bool reinit)
221{
222 u8 size = 0;
223 u32 usb2_pm;
224 u32 low32;
225 u32 upp32;
226 u32 temp;
227
228 dev_dbg(bdc->dev, "%s ()\n", __func__);
229 bdc->ep0_state = WAIT_FOR_SETUP;
230 bdc->dev_addr = 0;
231 bdc->srr.eqp_index = 0;
232 bdc->srr.dqp_index = 0;
233 bdc->zlp_needed = false;
234 bdc->delayed_status = false;
235
236 bdc_writel(bdc->regs, BDC_SPBBAL, bdc->scratchpad.sp_dma);
237 /* Init the SRR */
238 temp = BDC_SRR_RWS | BDC_SRR_RST;
239 /* Reset the SRR */
240 bdc_writel(bdc->regs, BDC_SRRINT(0), temp);
241 dev_dbg(bdc->dev, "bdc->srr.sr_bds =%p\n", bdc->srr.sr_bds);
242 temp = lower_32_bits(bdc->srr.dma_addr);
243 size = fls(NUM_SR_ENTRIES) - 2;
244 temp |= size;
245 dev_dbg(bdc->dev, "SRRBAL[0]=%08x NUM_SR_ENTRIES:%d size:%d\n",
246 temp, NUM_SR_ENTRIES, size);
247
248 low32 = lower_32_bits(temp);
249 upp32 = upper_32_bits(bdc->srr.dma_addr);
250 cpu_to_le32s(&low32);
251 cpu_to_le32s(&upp32);
252
253 /* Write the dma addresses into regs*/
254 bdc_writel(bdc->regs, BDC_SRRBAL(0), low32);
255 bdc_writel(bdc->regs, BDC_SRRBAH(0), upp32);
256
257 temp = bdc_readl(bdc->regs, BDC_SRRINT(0));
258 temp |= BDC_SRR_IE;
259 temp &= ~(BDC_SRR_RST | BDC_SRR_RWS);
260 bdc_writel(bdc->regs, BDC_SRRINT(0), temp);
261
262 /* Set the Interrupt Coalescence ~500 usec */
263 temp = bdc_readl(bdc->regs, BDC_INTCTLS(0));
264 temp &= ~0xffff;
265 temp |= INT_CLS;
266 bdc_writel(bdc->regs, BDC_INTCTLS(0), temp);
267
268 usb2_pm = bdc_readl(bdc->regs, BDC_USPPM2);
269 dev_dbg(bdc->dev, "usb2_pm=%08x", usb2_pm);
270 /* Enable hardware LPM Enable */
271 usb2_pm |= BDC_HLE;
272 bdc_writel(bdc->regs, BDC_USPPM2, usb2_pm);
273
274 /* readback for debug */
275 usb2_pm = bdc_readl(bdc->regs, BDC_USPPM2);
276 dev_dbg(bdc->dev, "usb2_pm=%08x\n", usb2_pm);
277
278 /* Disable any unwanted SR's on SRR */
279 temp = bdc_readl(bdc->regs, BDC_BDCSC);
280 /* We don't want Microframe counter wrap SR */
281 temp |= BDC_MASK_MCW;
282 bdc_writel(bdc->regs, BDC_BDCSC, temp);
283
284 /*
285 * In some error cases, driver has to reset the entire BDC controller
286 * in that case reinit is passed as 1
287 */
288 if (reinit) {
289 /* Enable interrupts */
290 temp = bdc_readl(bdc->regs, BDC_BDCSC);
291 temp |= BDC_GIE;
292 bdc_writel(bdc->regs, BDC_BDCSC, temp);
293 /* Init scratchpad to 0 */
294 memset(bdc->scratchpad.buff, 0, bdc->sp_buff_size);
295 /* Initialize SRR to 0 */
296 memset(bdc->srr.sr_bds, 0,
297 NUM_SR_ENTRIES * sizeof(struct bdc_bd));
298 } else {
299 /* One time initiaization only */
300 /* Enable status report function pointers */
301 bdc->sr_handler[0] = bdc_sr_xsf;
302 bdc->sr_handler[1] = bdc_sr_uspc;
303
304 /* EP0 status report function pointers */
305 bdc->sr_xsf_ep0[0] = bdc_xsf_ep0_setup_recv;
306 bdc->sr_xsf_ep0[1] = bdc_xsf_ep0_data_start;
307 bdc->sr_xsf_ep0[2] = bdc_xsf_ep0_status_start;
308 }
309}
310
311/* Free the dynamic memory */
312static void bdc_mem_free(struct bdc *bdc)
313{
314 dev_dbg(bdc->dev, "%s\n", __func__);
315 /* Free SRR */
316 if (bdc->srr.sr_bds)
317 dma_free_coherent(bdc->dev,
318 NUM_SR_ENTRIES * sizeof(struct bdc_bd),
319 bdc->srr.sr_bds, bdc->srr.dma_addr);
320
321 /* Free scratchpad */
322 if (bdc->scratchpad.buff)
323 dma_free_coherent(bdc->dev, bdc->sp_buff_size,
324 bdc->scratchpad.buff, bdc->scratchpad.sp_dma);
325
326 /* Destroy the dma pools */
327 if (bdc->bd_table_pool)
328 dma_pool_destroy(bdc->bd_table_pool);
329
330 /* Free the bdc_ep array */
331 kfree(bdc->bdc_ep_array);
332
333 bdc->srr.sr_bds = NULL;
334 bdc->scratchpad.buff = NULL;
335 bdc->bd_table_pool = NULL;
336 bdc->bdc_ep_array = NULL;
337}
338
339/*
340 * bdc reinit gives a controller reset and reinitialize the registers,
341 * called from disconnect/bus reset scenario's, to ensure proper HW cleanup
342 */
343int bdc_reinit(struct bdc *bdc)
344{
345 int ret;
346
347 dev_dbg(bdc->dev, "%s\n", __func__);
348 ret = bdc_stop(bdc);
349 if (ret)
350 goto out;
351
352 ret = bdc_reset(bdc);
353 if (ret)
354 goto out;
355
356 /* the reinit flag is 1 */
357 bdc_mem_init(bdc, true);
358 ret = bdc_run(bdc);
359out:
360 bdc->reinit = false;
361
362 return ret;
363}
364
365/* Allocate all the dyanmic memory */
366static int bdc_mem_alloc(struct bdc *bdc)
367{
368 u32 page_size;
369 unsigned int num_ieps, num_oeps;
370
371 dev_dbg(bdc->dev,
372 "%s() NUM_BDS_PER_TABLE:%d\n", __func__,
373 NUM_BDS_PER_TABLE);
374 page_size = BDC_PGS(bdc_readl(bdc->regs, BDC_BDCCFG0));
375 /* page size is 2^pgs KB */
376 page_size = 1 << page_size;
377 /* KB */
378 page_size <<= 10;
379 dev_dbg(bdc->dev, "page_size=%d\n", page_size);
380
381 /* Create a pool of bd tables */
382 bdc->bd_table_pool =
383 dma_pool_create("BDC BD tables", bdc->dev, NUM_BDS_PER_TABLE * 16,
384 16, page_size);
385
386 if (!bdc->bd_table_pool)
387 goto fail;
388
389 if (scratchpad_setup(bdc))
390 goto fail;
391
392 /* read from regs */
393 num_ieps = NUM_NCS(bdc_readl(bdc->regs, BDC_FSCNIC));
394 num_oeps = NUM_NCS(bdc_readl(bdc->regs, BDC_FSCNOC));
395 /* +2: 1 for ep0 and the other is rsvd i.e. bdc_ep[0] is rsvd */
396 bdc->num_eps = num_ieps + num_oeps + 2;
397 dev_dbg(bdc->dev,
398 "ieps:%d eops:%d num_eps:%d\n",
399 num_ieps, num_oeps, bdc->num_eps);
400 /* allocate array of ep pointers */
401 bdc->bdc_ep_array = kcalloc(bdc->num_eps, sizeof(struct bdc_ep *),
402 GFP_KERNEL);
403 if (!bdc->bdc_ep_array)
404 goto fail;
405
406 dev_dbg(bdc->dev, "Allocating sr report0\n");
407 if (setup_srr(bdc, 0))
408 goto fail;
409
410 return 0;
411fail:
412 dev_warn(bdc->dev, "Couldn't initialize memory\n");
413 bdc_mem_free(bdc);
414
415 return -ENOMEM;
416}
417
418/* opposite to bdc_hw_init */
419static void bdc_hw_exit(struct bdc *bdc)
420{
421 dev_dbg(bdc->dev, "%s ()\n", __func__);
422 bdc_mem_free(bdc);
423}
424
425/* Initialize the bdc HW and memory */
426static int bdc_hw_init(struct bdc *bdc)
427{
428 int ret;
429
430 dev_dbg(bdc->dev, "%s ()\n", __func__);
431 ret = bdc_reset(bdc);
432 if (ret) {
433 dev_err(bdc->dev, "err resetting bdc abort bdc init%d\n", ret);
434 return ret;
435 }
436 ret = bdc_mem_alloc(bdc);
437 if (ret) {
438 dev_err(bdc->dev, "Mem alloc failed, aborting\n");
439 return -ENOMEM;
440 }
441 bdc_mem_init(bdc, 0);
442 bdc_dbg_regs(bdc);
443 dev_dbg(bdc->dev, "HW Init done\n");
444
445 return 0;
446}
447
448static int bdc_probe(struct platform_device *pdev)
449{
450 struct bdc *bdc;
451 struct resource *res;
452 int ret = -ENOMEM;
453 int irq;
454 u32 temp;
455 struct device *dev = &pdev->dev;
456
457 dev_dbg(dev, "%s()\n", __func__);
458 bdc = devm_kzalloc(dev, sizeof(*bdc), GFP_KERNEL);
459 if (!bdc)
460 return -ENOMEM;
461
462 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
463 bdc->regs = devm_ioremap_resource(dev, res);
464 if (IS_ERR(bdc->regs)) {
465 dev_err(dev, "ioremap error\n");
466 return -ENOMEM;
467 }
468 irq = platform_get_irq(pdev, 0);
469 if (irq < 0) {
470 dev_err(dev, "platform_get_irq failed:%d\n", irq);
471 return irq;
472 }
473 spin_lock_init(&bdc->lock);
474 platform_set_drvdata(pdev, bdc);
475 bdc->irq = irq;
476 bdc->dev = dev;
477 dev_dbg(bdc->dev, "bdc->regs: %p irq=%d\n", bdc->regs, bdc->irq);
478
479 temp = bdc_readl(bdc->regs, BDC_BDCSC);
480 if ((temp & BDC_P64) &&
481 !dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64))) {
482 dev_dbg(bdc->dev, "Using 64-bit address\n");
483 } else {
484 ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
485 if (ret) {
486 dev_err(bdc->dev, "No suitable DMA config available, abort\n");
487 return -ENOTSUPP;
488 }
489 dev_dbg(bdc->dev, "Using 32-bit address\n");
490 }
491 ret = bdc_hw_init(bdc);
492 if (ret) {
493 dev_err(bdc->dev, "BDC init failure:%d\n", ret);
494 return ret;
495 }
496 ret = bdc_udc_init(bdc);
497 if (ret) {
498 dev_err(bdc->dev, "BDC Gadget init failure:%d\n", ret);
499 goto cleanup;
500 }
501 return 0;
502
503cleanup:
504 bdc_hw_exit(bdc);
505
506 return ret;
507}
508
509static int bdc_remove(struct platform_device *pdev)
510{
511 struct bdc *bdc;
512
513 bdc = platform_get_drvdata(pdev);
514 dev_dbg(bdc->dev, "%s ()\n", __func__);
515 bdc_udc_exit(bdc);
516 bdc_hw_exit(bdc);
517
518 return 0;
519}
520
521static struct platform_driver bdc_driver = {
522 .driver = {
523 .name = BRCM_BDC_NAME,
524 .owner = THIS_MODULE
525 },
526 .probe = bdc_probe,
527 .remove = bdc_remove,
528};
529
530module_platform_driver(bdc_driver);
531MODULE_AUTHOR("Ashwini Pahuja <ashwini.linux@gmail.com>");
532MODULE_LICENSE("GPL");
533MODULE_DESCRIPTION(BRCM_BDC_DESC);
diff --git a/drivers/usb/gadget/udc/bdc/bdc_dbg.c b/drivers/usb/gadget/udc/bdc/bdc_dbg.c
new file mode 100644
index 000000000000..5945dbc47825
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_dbg.c
@@ -0,0 +1,123 @@
1/*
2 * bdc_dbg.c - BRCM BDC USB3.0 device controller debug functions
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15#include "bdc.h"
16#include "bdc_dbg.h"
17
18void bdc_dbg_regs(struct bdc *bdc)
19{
20 u32 temp;
21
22 dev_vdbg(bdc->dev, "bdc->regs:%p\n", bdc->regs);
23 temp = bdc_readl(bdc->regs, BDC_BDCCFG0);
24 dev_vdbg(bdc->dev, "bdccfg0:0x%08x\n", temp);
25 temp = bdc_readl(bdc->regs, BDC_BDCCFG1);
26 dev_vdbg(bdc->dev, "bdccfg1:0x%08x\n", temp);
27 temp = bdc_readl(bdc->regs, BDC_BDCCAP0);
28 dev_vdbg(bdc->dev, "bdccap0:0x%08x\n", temp);
29 temp = bdc_readl(bdc->regs, BDC_BDCCAP1);
30 dev_vdbg(bdc->dev, "bdccap1:0x%08x\n", temp);
31 temp = bdc_readl(bdc->regs, BDC_USPC);
32 dev_vdbg(bdc->dev, "uspc:0x%08x\n", temp);
33 temp = bdc_readl(bdc->regs, BDC_DVCSA);
34 dev_vdbg(bdc->dev, "dvcsa:0x%08x\n", temp);
35 temp = bdc_readl(bdc->regs, BDC_DVCSB);
36 dev_vdbg(bdc->dev, "dvcsb:0x%x08\n", temp);
37}
38
39void bdc_dump_epsts(struct bdc *bdc)
40{
41 u32 temp;
42
43 temp = bdc_readl(bdc->regs, BDC_EPSTS0(0));
44 dev_vdbg(bdc->dev, "BDC_EPSTS0:0x%08x\n", temp);
45
46 temp = bdc_readl(bdc->regs, BDC_EPSTS1(0));
47 dev_vdbg(bdc->dev, "BDC_EPSTS1:0x%x\n", temp);
48
49 temp = bdc_readl(bdc->regs, BDC_EPSTS2(0));
50 dev_vdbg(bdc->dev, "BDC_EPSTS2:0x%08x\n", temp);
51
52 temp = bdc_readl(bdc->regs, BDC_EPSTS3(0));
53 dev_vdbg(bdc->dev, "BDC_EPSTS3:0x%08x\n", temp);
54
55 temp = bdc_readl(bdc->regs, BDC_EPSTS4(0));
56 dev_vdbg(bdc->dev, "BDC_EPSTS4:0x%08x\n", temp);
57
58 temp = bdc_readl(bdc->regs, BDC_EPSTS5(0));
59 dev_vdbg(bdc->dev, "BDC_EPSTS5:0x%08x\n", temp);
60
61 temp = bdc_readl(bdc->regs, BDC_EPSTS6(0));
62 dev_vdbg(bdc->dev, "BDC_EPSTS6:0x%08x\n", temp);
63
64 temp = bdc_readl(bdc->regs, BDC_EPSTS7(0));
65 dev_vdbg(bdc->dev, "BDC_EPSTS7:0x%08x\n", temp);
66}
67
68void bdc_dbg_srr(struct bdc *bdc, u32 srr_num)
69{
70 struct bdc_sr *sr;
71 dma_addr_t addr;
72 int i;
73
74 sr = bdc->srr.sr_bds;
75 addr = bdc->srr.dma_addr;
76 dev_vdbg(bdc->dev, "bdc_dbg_srr sr:%p dqp_index:%d\n",
77 sr, bdc->srr.dqp_index);
78 for (i = 0; i < NUM_SR_ENTRIES; i++) {
79 sr = &bdc->srr.sr_bds[i];
80 dev_vdbg(bdc->dev, "%llx %08x %08x %08x %08x\n",
81 (unsigned long long)addr,
82 le32_to_cpu(sr->offset[0]),
83 le32_to_cpu(sr->offset[1]),
84 le32_to_cpu(sr->offset[2]),
85 le32_to_cpu(sr->offset[3]));
86 addr += sizeof(*sr);
87 }
88}
89
90void bdc_dbg_bd_list(struct bdc *bdc, struct bdc_ep *ep)
91{
92 struct bd_list *bd_list = &ep->bd_list;
93 struct bd_table *bd_table;
94 struct bdc_bd *bd;
95 int tbi, bdi, gbdi;
96 dma_addr_t dma;
97
98 gbdi = 0;
99 dev_vdbg(bdc->dev,
100 "Dump bd list for %s epnum:%d\n",
101 ep->name, ep->ep_num);
102
103 dev_vdbg(bdc->dev,
104 "tabs:%d max_bdi:%d eqp_bdi:%d hwd_bdi:%d num_bds_table:%d\n",
105 bd_list->num_tabs, bd_list->max_bdi, bd_list->eqp_bdi,
106 bd_list->hwd_bdi, bd_list->num_bds_table);
107
108 for (tbi = 0; tbi < bd_list->num_tabs; tbi++) {
109 bd_table = bd_list->bd_table_array[tbi];
110 for (bdi = 0; bdi < bd_list->num_bds_table; bdi++) {
111 bd = bd_table->start_bd + bdi;
112 dma = bd_table->dma + (sizeof(struct bdc_bd) * bdi);
113 dev_vdbg(bdc->dev,
114 "tbi:%2d bdi:%2d gbdi:%2d virt:%p phys:%llx %08x %08x %08x %08x\n",
115 tbi, bdi, gbdi++, bd, (unsigned long long)dma,
116 le32_to_cpu(bd->offset[0]),
117 le32_to_cpu(bd->offset[1]),
118 le32_to_cpu(bd->offset[2]),
119 le32_to_cpu(bd->offset[3]));
120 }
121 dev_vdbg(bdc->dev, "\n\n");
122 }
123}
diff --git a/drivers/usb/gadget/udc/bdc/bdc_dbg.h b/drivers/usb/gadget/udc/bdc/bdc_dbg.h
new file mode 100644
index 000000000000..338a6c701315
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_dbg.h
@@ -0,0 +1,37 @@
1/*
2 * bdc_dbg.h - header for the BDC debug functions
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14#ifndef __LINUX_BDC_DBG_H__
15#define __LINUX_BDC_DBG_H__
16
17#include "bdc.h"
18
19#ifdef CONFIG_USB_GADGET_VERBOSE
20void bdc_dbg_bd_list(struct bdc *, struct bdc_ep*);
21void bdc_dbg_srr(struct bdc *, u32);
22void bdc_dbg_regs(struct bdc *);
23void bdc_dump_epsts(struct bdc *);
24#else
25static inline void bdc_dbg_regs(struct bdc *bdc)
26{ }
27
28static inline void bdc_dbg_srr(struct bdc *bdc, u32 srr_num)
29{ }
30
31static inline void bdc_dbg_bd_list(struct bdc *bdc, struct bdc_ep *ep)
32{ }
33
34static inline void bdc_dump_epsts(struct bdc *bdc)
35{ }
36#endif /* CONFIG_USB_GADGET_VERBOSE */
37#endif /* __LINUX_BDC_DBG_H__ */
diff --git a/drivers/usb/gadget/udc/bdc/bdc_ep.c b/drivers/usb/gadget/udc/bdc/bdc_ep.c
new file mode 100644
index 000000000000..ff67ceac77c4
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_ep.c
@@ -0,0 +1,2024 @@
1/*
2 * bdc_ep.c - BRCM BDC USB3.0 device controller endpoint related functions
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * Based on drivers under drivers/usb/
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 *
15 */
16#include <linux/module.h>
17#include <linux/pci.h>
18#include <linux/dma-mapping.h>
19#include <linux/kernel.h>
20#include <linux/delay.h>
21#include <linux/dmapool.h>
22#include <linux/ioport.h>
23#include <linux/sched.h>
24#include <linux/slab.h>
25#include <linux/errno.h>
26#include <linux/init.h>
27#include <linux/timer.h>
28#include <linux/list.h>
29#include <linux/interrupt.h>
30#include <linux/moduleparam.h>
31#include <linux/device.h>
32#include <linux/usb/ch9.h>
33#include <linux/usb/gadget.h>
34#include <linux/usb/otg.h>
35#include <linux/pm.h>
36#include <linux/io.h>
37#include <linux/irq.h>
38#include <asm/unaligned.h>
39#include <linux/platform_device.h>
40#include <linux/usb/composite.h>
41
42#include "bdc.h"
43#include "bdc_ep.h"
44#include "bdc_cmd.h"
45#include "bdc_dbg.h"
46
47static const char * const ep0_state_string[] = {
48 "WAIT_FOR_SETUP",
49 "WAIT_FOR_DATA_START",
50 "WAIT_FOR_DATA_XMIT",
51 "WAIT_FOR_STATUS_START",
52 "WAIT_FOR_STATUS_XMIT",
53 "STATUS_PENDING"
54};
55
56/* Free the bdl during ep disable */
57static void ep_bd_list_free(struct bdc_ep *ep, u32 num_tabs)
58{
59 struct bd_list *bd_list = &ep->bd_list;
60 struct bdc *bdc = ep->bdc;
61 struct bd_table *bd_table;
62 int index;
63
64 dev_dbg(bdc->dev, "%s ep:%s num_tabs:%d\n",
65 __func__, ep->name, num_tabs);
66
67 if (!bd_list->bd_table_array) {
68 dev_dbg(bdc->dev, "%s already freed\n", ep->name);
69 return;
70 }
71 for (index = 0; index < num_tabs; index++) {
72 /*
73 * check if the bd_table struct is allocated ?
74 * if yes, then check if bd memory has been allocated, then
75 * free the dma_pool and also the bd_table struct memory
76 */
77 bd_table = bd_list->bd_table_array[index];
78 dev_dbg(bdc->dev, "bd_table:%p index:%d\n", bd_table, index);
79 if (!bd_table) {
80 dev_dbg(bdc->dev, "bd_table not allocated\n");
81 continue;
82 }
83 if (!bd_table->start_bd) {
84 dev_dbg(bdc->dev, "bd dma pool not allocted\n");
85 continue;
86 }
87
88 dev_dbg(bdc->dev,
89 "Free dma pool start_bd:%p dma:%llx\n",
90 bd_table->start_bd,
91 (unsigned long long)bd_table->dma);
92
93 dma_pool_free(bdc->bd_table_pool,
94 bd_table->start_bd,
95 bd_table->dma);
96 /* Free the bd_table structure */
97 kfree(bd_table);
98 }
99 /* Free the bd table array */
100 kfree(ep->bd_list.bd_table_array);
101}
102
103/*
104 * chain the tables, by insteting a chain bd at the end of prev_table, pointing
105 * to next_table
106 */
107static inline void chain_table(struct bd_table *prev_table,
108 struct bd_table *next_table,
109 u32 bd_p_tab)
110{
111 /* Chain the prev table to next table */
112 prev_table->start_bd[bd_p_tab-1].offset[0] =
113 cpu_to_le32(lower_32_bits(next_table->dma));
114
115 prev_table->start_bd[bd_p_tab-1].offset[1] =
116 cpu_to_le32(upper_32_bits(next_table->dma));
117
118 prev_table->start_bd[bd_p_tab-1].offset[2] =
119 0x0;
120
121 prev_table->start_bd[bd_p_tab-1].offset[3] =
122 cpu_to_le32(MARK_CHAIN_BD);
123}
124
125/* Allocate the bdl for ep, during config ep */
126static int ep_bd_list_alloc(struct bdc_ep *ep)
127{
128 struct bd_table *prev_table = NULL;
129 int index, num_tabs, bd_p_tab;
130 struct bdc *bdc = ep->bdc;
131 struct bd_table *bd_table;
132 dma_addr_t dma;
133
134 if (usb_endpoint_xfer_isoc(ep->desc))
135 num_tabs = NUM_TABLES_ISOCH;
136 else
137 num_tabs = NUM_TABLES;
138
139 bd_p_tab = NUM_BDS_PER_TABLE;
140 /* if there is only 1 table in bd list then loop chain to self */
141 dev_dbg(bdc->dev,
142 "%s ep:%p num_tabs:%d\n",
143 __func__, ep, num_tabs);
144
145 /* Allocate memory for table array */
146 ep->bd_list.bd_table_array = kzalloc(
147 num_tabs * sizeof(struct bd_table *),
148 GFP_ATOMIC);
149 if (!ep->bd_list.bd_table_array)
150 return -ENOMEM;
151
152 /* Allocate memory for each table */
153 for (index = 0; index < num_tabs; index++) {
154 /* Allocate memory for bd_table structure */
155 bd_table = kzalloc(sizeof(struct bd_table), GFP_ATOMIC);
156 if (!bd_table)
157 goto fail;
158
159 bd_table->start_bd = dma_pool_alloc(bdc->bd_table_pool,
160 GFP_ATOMIC,
161 &dma);
162 if (!bd_table->start_bd)
163 goto fail;
164
165 bd_table->dma = dma;
166
167 dev_dbg(bdc->dev,
168 "index:%d start_bd:%p dma=%08llx prev_table:%p\n",
169 index, bd_table->start_bd,
170 (unsigned long long)bd_table->dma, prev_table);
171
172 ep->bd_list.bd_table_array[index] = bd_table;
173 memset(bd_table->start_bd, 0, bd_p_tab * sizeof(struct bdc_bd));
174 if (prev_table)
175 chain_table(prev_table, bd_table, bd_p_tab);
176
177 prev_table = bd_table;
178 }
179 chain_table(prev_table, ep->bd_list.bd_table_array[0], bd_p_tab);
180 /* Memory allocation is successful, now init the internal fields */
181 ep->bd_list.num_tabs = num_tabs;
182 ep->bd_list.max_bdi = (num_tabs * bd_p_tab) - 1;
183 ep->bd_list.num_tabs = num_tabs;
184 ep->bd_list.num_bds_table = bd_p_tab;
185 ep->bd_list.eqp_bdi = 0;
186 ep->bd_list.hwd_bdi = 0;
187
188 return 0;
189fail:
190 /* Free the bd_table_array, bd_table struct, bd's */
191 ep_bd_list_free(ep, num_tabs);
192
193 return -ENOMEM;
194}
195
196/* returns how many bd's are need for this transfer */
197static inline int bd_needed_req(struct bdc_req *req)
198{
199 int bd_needed = 0;
200 int remaining;
201
202 /* 1 bd needed for 0 byte transfer */
203 if (req->usb_req.length == 0)
204 return 1;
205
206 /* remaining bytes after tranfering all max BD size BD's */
207 remaining = req->usb_req.length % BD_MAX_BUFF_SIZE;
208 if (remaining)
209 bd_needed++;
210
211 /* How many maximum BUFF size BD's ? */
212 remaining = req->usb_req.length / BD_MAX_BUFF_SIZE;
213 bd_needed += remaining;
214
215 return bd_needed;
216}
217
218/* returns the bd index(bdi) corresponding to bd dma address */
219static int bd_add_to_bdi(struct bdc_ep *ep, dma_addr_t bd_dma_addr)
220{
221 struct bd_list *bd_list = &ep->bd_list;
222 dma_addr_t dma_first_bd, dma_last_bd;
223 struct bdc *bdc = ep->bdc;
224 struct bd_table *bd_table;
225 bool found = false;
226 int tbi, bdi;
227
228 dma_first_bd = dma_last_bd = 0;
229 dev_dbg(bdc->dev, "%s %llx\n",
230 __func__, (unsigned long long)bd_dma_addr);
231 /*
232 * Find in which table this bd_dma_addr belongs?, go through the table
233 * array and compare addresses of first and last address of bd of each
234 * table
235 */
236 for (tbi = 0; tbi < bd_list->num_tabs; tbi++) {
237 bd_table = bd_list->bd_table_array[tbi];
238 dma_first_bd = bd_table->dma;
239 dma_last_bd = bd_table->dma +
240 (sizeof(struct bdc_bd) *
241 (bd_list->num_bds_table - 1));
242 dev_dbg(bdc->dev, "dma_first_bd:%llx dma_last_bd:%llx\n",
243 (unsigned long long)dma_first_bd,
244 (unsigned long long)dma_last_bd);
245 if (bd_dma_addr >= dma_first_bd && bd_dma_addr <= dma_last_bd) {
246 found = true;
247 break;
248 }
249 }
250 if (unlikely(!found)) {
251 dev_err(bdc->dev, "%s FATAL err, bd not found\n", __func__);
252 return -EINVAL;
253 }
254 /* Now we know the table, find the bdi */
255 bdi = (bd_dma_addr - dma_first_bd) / sizeof(struct bdc_bd);
256
257 /* return the global bdi, to compare with ep eqp_bdi */
258 return (bdi + (tbi * bd_list->num_bds_table));
259}
260
261/* returns the table index(tbi) of the given bdi */
262static int bdi_to_tbi(struct bdc_ep *ep, int bdi)
263{
264 int tbi;
265
266 tbi = bdi / ep->bd_list.num_bds_table;
267 dev_vdbg(ep->bdc->dev,
268 "bdi:%d num_bds_table:%d tbi:%d\n",
269 bdi, ep->bd_list.num_bds_table, tbi);
270
271 return tbi;
272}
273
274/* Find the bdi last bd in the transfer */
275static inline int find_end_bdi(struct bdc_ep *ep, int next_hwd_bdi)
276{
277 int end_bdi;
278
279 end_bdi = next_hwd_bdi - 1;
280 if (end_bdi < 0)
281 end_bdi = ep->bd_list.max_bdi - 1;
282 else if ((end_bdi % (ep->bd_list.num_bds_table-1)) == 0)
283 end_bdi--;
284
285 return end_bdi;
286}
287
288/*
289 * How many transfer bd's are available on this ep bdl, chain bds are not
290 * counted in available bds
291 */
292static int bd_available_ep(struct bdc_ep *ep)
293{
294 struct bd_list *bd_list = &ep->bd_list;
295 int available1, available2;
296 struct bdc *bdc = ep->bdc;
297 int chain_bd1, chain_bd2;
298 int available_bd = 0;
299
300 available1 = available2 = chain_bd1 = chain_bd2 = 0;
301 /* if empty then we have all bd's available - number of chain bd's */
302 if (bd_list->eqp_bdi == bd_list->hwd_bdi)
303 return bd_list->max_bdi - bd_list->num_tabs;
304
305 /*
306 * Depending upon where eqp and dqp pointers are, caculate number
307 * of avaialble bd's
308 */
309 if (bd_list->hwd_bdi < bd_list->eqp_bdi) {
310 /* available bd's are from eqp..max_bds + 0..dqp - chain_bds */
311 available1 = bd_list->max_bdi - bd_list->eqp_bdi;
312 available2 = bd_list->hwd_bdi;
313 chain_bd1 = available1 / bd_list->num_bds_table;
314 chain_bd2 = available2 / bd_list->num_bds_table;
315 dev_vdbg(bdc->dev, "chain_bd1:%d chain_bd2:%d\n",
316 chain_bd1, chain_bd2);
317 available_bd = available1 + available2 - chain_bd1 - chain_bd2;
318 } else {
319 /* available bd's are from eqp..dqp - number of chain bd's */
320 available1 = bd_list->hwd_bdi - bd_list->eqp_bdi;
321 /* if gap between eqp and dqp is less than NUM_BDS_PER_TABLE */
322 if ((bd_list->hwd_bdi - bd_list->eqp_bdi)
323 <= bd_list->num_bds_table) {
324 /* If there any chain bd in between */
325 if (!(bdi_to_tbi(ep, bd_list->hwd_bdi)
326 == bdi_to_tbi(ep, bd_list->eqp_bdi))) {
327 available_bd = available1 - 1;
328 }
329 } else {
330 chain_bd1 = available1 / bd_list->num_bds_table;
331 available_bd = available1 - chain_bd1;
332 }
333 }
334 /*
335 * we need to keep one extra bd to check if ring is full or empty so
336 * reduce by 1
337 */
338 available_bd--;
339 dev_vdbg(bdc->dev, "available_bd:%d\n", available_bd);
340
341 return available_bd;
342}
343
344/* Notify the hardware after queueing the bd to bdl */
345void bdc_notify_xfr(struct bdc *bdc, u32 epnum)
346{
347 struct bdc_ep *ep = bdc->bdc_ep_array[epnum];
348
349 dev_vdbg(bdc->dev, "%s epnum:%d\n", __func__, epnum);
350 /*
351 * We don't have anyway to check if ep state is running,
352 * except the software flags.
353 */
354 if (unlikely(ep->flags & BDC_EP_STOP))
355 ep->flags &= ~BDC_EP_STOP;
356
357 bdc_writel(bdc->regs, BDC_XSFNTF, epnum);
358}
359
360/* returns the bd corresponding to bdi */
361static struct bdc_bd *bdi_to_bd(struct bdc_ep *ep, int bdi)
362{
363 int tbi = bdi_to_tbi(ep, bdi);
364 int local_bdi = 0;
365
366 local_bdi = bdi - (tbi * ep->bd_list.num_bds_table);
367 dev_vdbg(ep->bdc->dev,
368 "%s bdi:%d local_bdi:%d\n",
369 __func__, bdi, local_bdi);
370
371 return (ep->bd_list.bd_table_array[tbi]->start_bd + local_bdi);
372}
373
374/* Advance the enqueue pointer */
375static void ep_bdlist_eqp_adv(struct bdc_ep *ep)
376{
377 ep->bd_list.eqp_bdi++;
378 /* if it's chain bd, then move to next */
379 if (((ep->bd_list.eqp_bdi + 1) % ep->bd_list.num_bds_table) == 0)
380 ep->bd_list.eqp_bdi++;
381
382 /* if the eqp is pointing to last + 1 then move back to 0 */
383 if (ep->bd_list.eqp_bdi == (ep->bd_list.max_bdi + 1))
384 ep->bd_list.eqp_bdi = 0;
385}
386
387/* Setup the first bd for ep0 transfer */
388static int setup_first_bd_ep0(struct bdc *bdc, struct bdc_req *req, u32 *dword3)
389{
390 u16 wValue;
391 u32 req_len;
392
393 req->ep->dir = 0;
394 req_len = req->usb_req.length;
395 switch (bdc->ep0_state) {
396 case WAIT_FOR_DATA_START:
397 *dword3 |= BD_TYPE_DS;
398 if (bdc->setup_pkt.bRequestType & USB_DIR_IN)
399 *dword3 |= BD_DIR_IN;
400
401 /* check if zlp will be needed */
402 wValue = le16_to_cpu(bdc->setup_pkt.wValue);
403 if ((wValue > req_len) &&
404 (req_len % bdc->gadget.ep0->maxpacket == 0)) {
405 dev_dbg(bdc->dev, "ZLP needed wVal:%d len:%d MaxP:%d\n",
406 wValue, req_len,
407 bdc->gadget.ep0->maxpacket);
408 bdc->zlp_needed = true;
409 }
410 break;
411
412 case WAIT_FOR_STATUS_START:
413 *dword3 |= BD_TYPE_SS;
414 if (!le16_to_cpu(bdc->setup_pkt.wLength) ||
415 !(bdc->setup_pkt.bRequestType & USB_DIR_IN))
416 *dword3 |= BD_DIR_IN;
417 break;
418 default:
419 dev_err(bdc->dev,
420 "Unknown ep0 state for queueing bd ep0_state:%s\n",
421 ep0_state_string[bdc->ep0_state]);
422 return -EINVAL;
423 }
424
425 return 0;
426}
427
428/* Setup the bd dma descriptor for a given request */
429static int setup_bd_list_xfr(struct bdc *bdc, struct bdc_req *req, int num_bds)
430{
431 dma_addr_t buf_add = req->usb_req.dma;
432 u32 maxp, tfs, dword2, dword3;
433 struct bd_transfer *bd_xfr;
434 struct bd_list *bd_list;
435 struct bdc_ep *ep;
436 struct bdc_bd *bd;
437 int ret, bdnum;
438 u32 req_len;
439
440 ep = req->ep;
441 bd_list = &ep->bd_list;
442 bd_xfr = &req->bd_xfr;
443 bd_xfr->req = req;
444 bd_xfr->start_bdi = bd_list->eqp_bdi;
445 bd = bdi_to_bd(ep, bd_list->eqp_bdi);
446 req_len = req->usb_req.length;
447 maxp = usb_endpoint_maxp(ep->desc) & 0x7ff;
448 tfs = roundup(req->usb_req.length, maxp);
449 tfs = tfs/maxp;
450 dev_vdbg(bdc->dev, "%s ep:%s num_bds:%d tfs:%d r_len:%d bd:%p\n",
451 __func__, ep->name, num_bds, tfs, req_len, bd);
452
453 for (bdnum = 0; bdnum < num_bds; bdnum++) {
454 dword2 = dword3 = 0;
455 /* First bd */
456 if (!bdnum) {
457 dword3 |= BD_SOT|BD_SBF|(tfs<<BD_TFS_SHIFT);
458 dword2 |= BD_LTF;
459 /* format of first bd for ep0 is different than other */
460 if (ep->ep_num == 1) {
461 ret = setup_first_bd_ep0(bdc, req, &dword3);
462 if (ret)
463 return ret;
464 }
465 }
466 if (!req->ep->dir)
467 dword3 |= BD_ISP;
468
469 if (req_len > BD_MAX_BUFF_SIZE) {
470 dword2 |= BD_MAX_BUFF_SIZE;
471 req_len -= BD_MAX_BUFF_SIZE;
472 } else {
473 /* this should be the last bd */
474 dword2 |= req_len;
475 dword3 |= BD_IOC;
476 dword3 |= BD_EOT;
477 }
478 /* Currently only 1 INT target is supported */
479 dword2 |= BD_INTR_TARGET(0);
480 bd = bdi_to_bd(ep, ep->bd_list.eqp_bdi);
481 if (unlikely(!bd)) {
482 dev_err(bdc->dev, "Err bd pointing to wrong addr\n");
483 return -EINVAL;
484 }
485 /* write bd */
486 bd->offset[0] = cpu_to_le32(lower_32_bits(buf_add));
487 bd->offset[1] = cpu_to_le32(upper_32_bits(buf_add));
488 bd->offset[2] = cpu_to_le32(dword2);
489 bd->offset[3] = cpu_to_le32(dword3);
490 /* advance eqp pointer */
491 ep_bdlist_eqp_adv(ep);
492 /* advance the buff pointer */
493 buf_add += BD_MAX_BUFF_SIZE;
494 dev_vdbg(bdc->dev, "buf_add:%08llx req_len:%d bd:%p eqp:%d\n",
495 (unsigned long long)buf_add, req_len, bd,
496 ep->bd_list.eqp_bdi);
497 bd = bdi_to_bd(ep, ep->bd_list.eqp_bdi);
498 bd->offset[3] = cpu_to_le32(BD_SBF);
499 }
500 /* clear the STOP BD fetch bit from the first bd of this xfr */
501 bd = bdi_to_bd(ep, bd_xfr->start_bdi);
502 bd->offset[3] &= cpu_to_le32(~BD_SBF);
503 /* the new eqp will be next hw dqp */
504 bd_xfr->num_bds = num_bds;
505 bd_xfr->next_hwd_bdi = ep->bd_list.eqp_bdi;
506 /* everything is written correctly before notifying the HW */
507 wmb();
508
509 return 0;
510}
511
512/* Queue the xfr */
513static int bdc_queue_xfr(struct bdc *bdc, struct bdc_req *req)
514{
515 int num_bds, bd_available;
516 struct bdc_ep *ep;
517 int ret;
518
519 ep = req->ep;
520 dev_dbg(bdc->dev, "%s req:%p\n", __func__, req);
521 dev_dbg(bdc->dev, "eqp_bdi:%d hwd_bdi:%d\n",
522 ep->bd_list.eqp_bdi, ep->bd_list.hwd_bdi);
523
524 num_bds = bd_needed_req(req);
525 bd_available = bd_available_ep(ep);
526
527 /* how many bd's are avaialble on ep */
528 if (num_bds > bd_available)
529 return -ENOMEM;
530
531 ret = setup_bd_list_xfr(bdc, req, num_bds);
532 if (ret)
533 return ret;
534 list_add_tail(&req->queue, &ep->queue);
535 bdc_dbg_bd_list(bdc, ep);
536 bdc_notify_xfr(bdc, ep->ep_num);
537
538 return 0;
539}
540
541/* callback to gadget layer when xfr completes */
542static void bdc_req_complete(struct bdc_ep *ep, struct bdc_req *req,
543 int status)
544{
545 struct bdc *bdc = ep->bdc;
546
547 if (req == NULL || &req->queue == NULL || &req->usb_req == NULL)
548 return;
549
550 dev_dbg(bdc->dev, "%s ep:%s status:%d\n", __func__, ep->name, status);
551 list_del(&req->queue);
552 req->usb_req.status = status;
553 usb_gadget_unmap_request(&bdc->gadget, &req->usb_req, ep->dir);
554 if (req->usb_req.complete) {
555 spin_unlock(&bdc->lock);
556 usb_gadget_giveback_request(&ep->usb_ep, &req->usb_req);
557 spin_lock(&bdc->lock);
558 }
559}
560
561/* Disable the endpoint */
562int bdc_ep_disable(struct bdc_ep *ep)
563{
564 struct bdc_req *req;
565 struct bdc *bdc;
566 int ret;
567
568 ret = 0;
569 bdc = ep->bdc;
570 dev_dbg(bdc->dev, "%s() ep->ep_num=%d\n", __func__, ep->ep_num);
571 /* Stop the endpoint */
572 ret = bdc_stop_ep(bdc, ep->ep_num);
573
574 /*
575 * Intentionally don't check the ret value of stop, it can fail in
576 * disconnect scenarios, continue with dconfig
577 */
578 /* de-queue any pending requests */
579 while (!list_empty(&ep->queue)) {
580 req = list_entry(ep->queue.next, struct bdc_req,
581 queue);
582 bdc_req_complete(ep, req, -ESHUTDOWN);
583 }
584 /* deconfigure the endpoint */
585 ret = bdc_dconfig_ep(bdc, ep);
586 if (ret)
587 dev_warn(bdc->dev,
588 "dconfig fail but continue with memory free");
589
590 ep->flags = 0;
591 /* ep0 memory is not freed, but reused on next connect sr */
592 if (ep->ep_num == 1)
593 return 0;
594
595 /* Free the bdl memory */
596 ep_bd_list_free(ep, ep->bd_list.num_tabs);
597 ep->desc = NULL;
598 ep->comp_desc = NULL;
599 ep->usb_ep.desc = NULL;
600 ep->ep_type = 0;
601
602 return ret;
603}
604
605/* Enable the ep */
606int bdc_ep_enable(struct bdc_ep *ep)
607{
608 struct bdc *bdc;
609 int ret = 0;
610
611 bdc = ep->bdc;
612 dev_dbg(bdc->dev, "%s NUM_TABLES:%d %d\n",
613 __func__, NUM_TABLES, NUM_TABLES_ISOCH);
614
615 ret = ep_bd_list_alloc(ep);
616 if (ret) {
617 dev_err(bdc->dev, "ep bd list allocation failed:%d\n", ret);
618 return -ENOMEM;
619 }
620 bdc_dbg_bd_list(bdc, ep);
621 /* only for ep0: config ep is called for ep0 from connect event */
622 ep->flags |= BDC_EP_ENABLED;
623 if (ep->ep_num == 1)
624 return ret;
625
626 /* Issue a configure endpoint command */
627 ret = bdc_config_ep(bdc, ep);
628 if (ret)
629 return ret;
630
631 ep->usb_ep.maxpacket = usb_endpoint_maxp(ep->desc);
632 ep->usb_ep.desc = ep->desc;
633 ep->usb_ep.comp_desc = ep->comp_desc;
634 ep->ep_type = usb_endpoint_type(ep->desc);
635 ep->flags |= BDC_EP_ENABLED;
636
637 return 0;
638}
639
640/* EP0 related code */
641
642/* Queue a status stage BD */
643static int ep0_queue_status_stage(struct bdc *bdc)
644{
645 struct bdc_req *status_req;
646 struct bdc_ep *ep;
647
648 status_req = &bdc->status_req;
649 ep = bdc->bdc_ep_array[1];
650 status_req->ep = ep;
651 status_req->usb_req.length = 0;
652 status_req->usb_req.status = -EINPROGRESS;
653 status_req->usb_req.actual = 0;
654 status_req->usb_req.complete = NULL;
655 bdc_queue_xfr(bdc, status_req);
656
657 return 0;
658}
659
660/* Queue xfr on ep0 */
661static int ep0_queue(struct bdc_ep *ep, struct bdc_req *req)
662{
663 struct bdc *bdc;
664 int ret;
665
666 bdc = ep->bdc;
667 dev_dbg(bdc->dev, "%s()\n", __func__);
668 req->usb_req.actual = 0;
669 req->usb_req.status = -EINPROGRESS;
670 req->epnum = ep->ep_num;
671
672 if (bdc->delayed_status) {
673 bdc->delayed_status = false;
674 /* if status stage was delayed? */
675 if (bdc->ep0_state == WAIT_FOR_STATUS_START) {
676 /* Queue a status stage BD */
677 ep0_queue_status_stage(bdc);
678 bdc->ep0_state = WAIT_FOR_STATUS_XMIT;
679 return 0;
680 }
681 } else {
682 /*
683 * if delayed status is false and 0 length transfer is requested
684 * i.e. for status stage of some setup request, then just
685 * return from here the status stage is queued independently
686 */
687 if (req->usb_req.length == 0)
688 return 0;
689
690 }
691 ret = usb_gadget_map_request(&bdc->gadget, &req->usb_req, ep->dir);
692 if (ret) {
693 dev_err(bdc->dev, "dma mapping failed %s\n", ep->name);
694 return ret;
695 }
696
697 return bdc_queue_xfr(bdc, req);
698}
699
700/* Queue data stage */
701static int ep0_queue_data_stage(struct bdc *bdc)
702{
703 struct usb_request *ep0_usb_req;
704 struct bdc_ep *ep;
705
706 dev_dbg(bdc->dev, "%s\n", __func__);
707 ep0_usb_req = &bdc->ep0_req.usb_req;
708 ep = bdc->bdc_ep_array[1];
709 bdc->ep0_req.ep = ep;
710 bdc->ep0_req.usb_req.complete = NULL;
711
712 return ep0_queue(ep, &bdc->ep0_req);
713}
714
715/* Queue req on ep */
716static int ep_queue(struct bdc_ep *ep, struct bdc_req *req)
717{
718 struct bdc *bdc;
719 int ret = 0;
720
721 bdc = ep->bdc;
722 if (!req || !ep || !ep->usb_ep.desc)
723 return -EINVAL;
724
725 req->usb_req.actual = 0;
726 req->usb_req.status = -EINPROGRESS;
727 req->epnum = ep->ep_num;
728
729 ret = usb_gadget_map_request(&bdc->gadget, &req->usb_req, ep->dir);
730 if (ret) {
731 dev_err(bdc->dev, "dma mapping failed\n");
732 return ret;
733 }
734
735 return bdc_queue_xfr(bdc, req);
736}
737
738/* Dequeue a request from ep */
739static int ep_dequeue(struct bdc_ep *ep, struct bdc_req *req)
740{
741 int start_bdi, end_bdi, tbi, eqp_bdi, curr_hw_dqpi;
742 bool start_pending, end_pending;
743 bool first_remove = false;
744 struct bdc_req *first_req;
745 struct bdc_bd *bd_start;
746 struct bd_table *table;
747 dma_addr_t next_bd_dma;
748 u64 deq_ptr_64 = 0;
749 struct bdc *bdc;
750 u32 tmp_32;
751 int ret;
752
753 bdc = ep->bdc;
754 start_pending = end_pending = false;
755 eqp_bdi = ep->bd_list.eqp_bdi - 1;
756
757 if (eqp_bdi < 0)
758 eqp_bdi = ep->bd_list.max_bdi;
759
760 start_bdi = req->bd_xfr.start_bdi;
761 end_bdi = find_end_bdi(ep, req->bd_xfr.next_hwd_bdi);
762
763 dev_dbg(bdc->dev, "%s ep:%s start:%d end:%d\n",
764 __func__, ep->name, start_bdi, end_bdi);
765 dev_dbg(bdc->dev, "ep_dequeue ep=%p ep->desc=%p\n",
766 ep, (void *)ep->usb_ep.desc);
767 /* Stop the ep to see where the HW is ? */
768 ret = bdc_stop_ep(bdc, ep->ep_num);
769 /* if there is an issue with stopping ep, then no need to go further */
770 if (ret)
771 return 0;
772
773 /*
774 * After endpoint is stopped, there can be 3 cases, the request
775 * is processed, pending or in the middle of processing
776 */
777
778 /* The current hw dequeue pointer */
779 tmp_32 = bdc_readl(bdc->regs, BDC_EPSTS0(0));
780 deq_ptr_64 = tmp_32;
781 tmp_32 = bdc_readl(bdc->regs, BDC_EPSTS0(1));
782 deq_ptr_64 |= ((u64)tmp_32 << 32);
783
784 /* we have the dma addr of next bd that will be fetched by hardware */
785 curr_hw_dqpi = bd_add_to_bdi(ep, deq_ptr_64);
786 if (curr_hw_dqpi < 0)
787 return curr_hw_dqpi;
788
789 /*
790 * curr_hw_dqpi points to actual dqp of HW and HW owns bd's from
791 * curr_hw_dqbdi..eqp_bdi.
792 */
793
794 /* Check if start_bdi and end_bdi are in range of HW owned BD's */
795 if (curr_hw_dqpi > eqp_bdi) {
796 /* there is a wrap from last to 0 */
797 if (start_bdi >= curr_hw_dqpi || start_bdi <= eqp_bdi) {
798 start_pending = true;
799 end_pending = true;
800 } else if (end_bdi >= curr_hw_dqpi || end_bdi <= eqp_bdi) {
801 end_pending = true;
802 }
803 } else {
804 if (start_bdi >= curr_hw_dqpi) {
805 start_pending = true;
806 end_pending = true;
807 } else if (end_bdi >= curr_hw_dqpi) {
808 end_pending = true;
809 }
810 }
811 dev_dbg(bdc->dev,
812 "start_pending:%d end_pending:%d speed:%d\n",
813 start_pending, end_pending, bdc->gadget.speed);
814
815 /* If both start till end are processes, we cannot deq req */
816 if (!start_pending && !end_pending)
817 return -EINVAL;
818
819 /*
820 * if ep_dequeue is called after disconnect then just return
821 * success from here
822 */
823 if (bdc->gadget.speed == USB_SPEED_UNKNOWN)
824 return 0;
825 tbi = bdi_to_tbi(ep, req->bd_xfr.next_hwd_bdi);
826 table = ep->bd_list.bd_table_array[tbi];
827 next_bd_dma = table->dma +
828 sizeof(struct bdc_bd)*(req->bd_xfr.next_hwd_bdi -
829 tbi * ep->bd_list.num_bds_table);
830
831 first_req = list_first_entry(&ep->queue, struct bdc_req,
832 queue);
833
834 if (req == first_req)
835 first_remove = true;
836
837 /*
838 * Due to HW limitation we need to bypadd chain bd's and issue ep_bla,
839 * incase if start is pending this is the first request in the list
840 * then issue ep_bla instead of marking as chain bd
841 */
842 if (start_pending && !first_remove) {
843 /*
844 * Mark the start bd as Chain bd, and point the chain
845 * bd to next_bd_dma
846 */
847 bd_start = bdi_to_bd(ep, start_bdi);
848 bd_start->offset[0] = cpu_to_le32(lower_32_bits(next_bd_dma));
849 bd_start->offset[1] = cpu_to_le32(upper_32_bits(next_bd_dma));
850 bd_start->offset[2] = 0x0;
851 bd_start->offset[3] = cpu_to_le32(MARK_CHAIN_BD);
852 bdc_dbg_bd_list(bdc, ep);
853 } else if (end_pending) {
854 /*
855 * The transfer is stopped in the middle, move the
856 * HW deq pointer to next_bd_dma
857 */
858 ret = bdc_ep_bla(bdc, ep, next_bd_dma);
859 if (ret) {
860 dev_err(bdc->dev, "error in ep_bla:%d\n", ret);
861 return ret;
862 }
863 }
864
865 return 0;
866}
867
868/* Halt/Clear the ep based on value */
869static int ep_set_halt(struct bdc_ep *ep, u32 value)
870{
871 struct bdc *bdc;
872 int ret;
873
874 bdc = ep->bdc;
875 dev_dbg(bdc->dev, "%s ep:%s value=%d\n", __func__, ep->name, value);
876
877 if (value) {
878 dev_dbg(bdc->dev, "Halt\n");
879 if (ep->ep_num == 1)
880 bdc->ep0_state = WAIT_FOR_SETUP;
881
882 ret = bdc_ep_set_stall(bdc, ep->ep_num);
883 if (ret)
884 dev_err(bdc->dev, "failed to %s STALL on %s\n",
885 value ? "set" : "clear", ep->name);
886 else
887 ep->flags |= BDC_EP_STALL;
888 } else {
889 /* Clear */
890 dev_dbg(bdc->dev, "Before Clear\n");
891 ret = bdc_ep_clear_stall(bdc, ep->ep_num);
892 if (ret)
893 dev_err(bdc->dev, "failed to %s STALL on %s\n",
894 value ? "set" : "clear", ep->name);
895 else
896 ep->flags &= ~BDC_EP_STALL;
897 dev_dbg(bdc->dev, "After Clear\n");
898 }
899
900 return ret;
901}
902
903/* Free all the ep */
904void bdc_free_ep(struct bdc *bdc)
905{
906 struct bdc_ep *ep;
907 u8 epnum;
908
909 dev_dbg(bdc->dev, "%s\n", __func__);
910 for (epnum = 1; epnum < bdc->num_eps; epnum++) {
911 ep = bdc->bdc_ep_array[epnum];
912 if (!ep)
913 continue;
914
915 if (ep->flags & BDC_EP_ENABLED)
916 ep_bd_list_free(ep, ep->bd_list.num_tabs);
917
918 /* ep0 is not in this gadget list */
919 if (epnum != 1)
920 list_del(&ep->usb_ep.ep_list);
921
922 kfree(ep);
923 }
924}
925
926/* USB2 spec, section 7.1.20 */
927static int bdc_set_test_mode(struct bdc *bdc)
928{
929 u32 usb2_pm;
930
931 usb2_pm = bdc_readl(bdc->regs, BDC_USPPM2);
932 usb2_pm &= ~BDC_PTC_MASK;
933 dev_dbg(bdc->dev, "%s\n", __func__);
934 switch (bdc->test_mode) {
935 case TEST_J:
936 case TEST_K:
937 case TEST_SE0_NAK:
938 case TEST_PACKET:
939 case TEST_FORCE_EN:
940 usb2_pm |= bdc->test_mode << 28;
941 break;
942 default:
943 return -EINVAL;
944 }
945 dev_dbg(bdc->dev, "usb2_pm=%08x", usb2_pm);
946 bdc_writel(bdc->regs, BDC_USPPM2, usb2_pm);
947
948 return 0;
949}
950
951/*
952 * Helper function to handle Transfer status report with status as either
953 * success or short
954 */
955static void handle_xsr_succ_status(struct bdc *bdc, struct bdc_ep *ep,
956 struct bdc_sr *sreport)
957{
958 int short_bdi, start_bdi, end_bdi, max_len_bds, chain_bds;
959 struct bd_list *bd_list = &ep->bd_list;
960 int actual_length, length_short;
961 struct bd_transfer *bd_xfr;
962 struct bdc_bd *short_bd;
963 struct bdc_req *req;
964 u64 deq_ptr_64 = 0;
965 int status = 0;
966 int sr_status;
967 u32 tmp_32;
968
969 dev_dbg(bdc->dev, "%s ep:%p\n", __func__, ep);
970 bdc_dbg_srr(bdc, 0);
971 /* do not process thie sr if ignore flag is set */
972 if (ep->ignore_next_sr) {
973 ep->ignore_next_sr = false;
974 return;
975 }
976
977 if (unlikely(list_empty(&ep->queue))) {
978 dev_warn(bdc->dev, "xfr srr with no BD's queued\n");
979 return;
980 }
981 req = list_entry(ep->queue.next, struct bdc_req,
982 queue);
983
984 bd_xfr = &req->bd_xfr;
985 sr_status = XSF_STS(le32_to_cpu(sreport->offset[3]));
986
987 /*
988 * sr_status is short and this transfer has more than 1 bd then it needs
989 * special handling, this is only applicable for bulk and ctrl
990 */
991 if (sr_status == XSF_SHORT && bd_xfr->num_bds > 1) {
992 /*
993 * This is multi bd xfr, lets see which bd
994 * caused short transfer and how many bytes have been
995 * transferred so far.
996 */
997 tmp_32 = le32_to_cpu(sreport->offset[0]);
998 deq_ptr_64 = tmp_32;
999 tmp_32 = le32_to_cpu(sreport->offset[1]);
1000 deq_ptr_64 |= ((u64)tmp_32 << 32);
1001 short_bdi = bd_add_to_bdi(ep, deq_ptr_64);
1002 if (unlikely(short_bdi < 0))
1003 dev_warn(bdc->dev, "bd doesn't exist?\n");
1004
1005 start_bdi = bd_xfr->start_bdi;
1006 /*
1007 * We know the start_bdi and short_bdi, how many xfr
1008 * bds in between
1009 */
1010 if (start_bdi <= short_bdi) {
1011 max_len_bds = short_bdi - start_bdi;
1012 if (max_len_bds <= bd_list->num_bds_table) {
1013 if (!(bdi_to_tbi(ep, start_bdi) ==
1014 bdi_to_tbi(ep, short_bdi)))
1015 max_len_bds--;
1016 } else {
1017 chain_bds = max_len_bds/bd_list->num_bds_table;
1018 max_len_bds -= chain_bds;
1019 }
1020 } else {
1021 /* there is a wrap in the ring within a xfr */
1022 chain_bds = (bd_list->max_bdi - start_bdi)/
1023 bd_list->num_bds_table;
1024 chain_bds += short_bdi/bd_list->num_bds_table;
1025 max_len_bds = bd_list->max_bdi - start_bdi;
1026 max_len_bds += short_bdi;
1027 max_len_bds -= chain_bds;
1028 }
1029 /* max_len_bds is the number of full length bds */
1030 end_bdi = find_end_bdi(ep, bd_xfr->next_hwd_bdi);
1031 if (!(end_bdi == short_bdi))
1032 ep->ignore_next_sr = true;
1033
1034 actual_length = max_len_bds * BD_MAX_BUFF_SIZE;
1035 short_bd = bdi_to_bd(ep, short_bdi);
1036 /* length queued */
1037 length_short = le32_to_cpu(short_bd->offset[2]) & 0x1FFFFF;
1038 /* actual length trensfered */
1039 length_short -= SR_BD_LEN(le32_to_cpu(sreport->offset[2]));
1040 actual_length += length_short;
1041 req->usb_req.actual = actual_length;
1042 } else {
1043 req->usb_req.actual = req->usb_req.length -
1044 SR_BD_LEN(le32_to_cpu(sreport->offset[2]));
1045 dev_dbg(bdc->dev,
1046 "len=%d actual=%d bd_xfr->next_hwd_bdi:%d\n",
1047 req->usb_req.length, req->usb_req.actual,
1048 bd_xfr->next_hwd_bdi);
1049 }
1050
1051 /* Update the dequeue pointer */
1052 ep->bd_list.hwd_bdi = bd_xfr->next_hwd_bdi;
1053 if (req->usb_req.actual < req->usb_req.length) {
1054 dev_dbg(bdc->dev, "short xfr on %d\n", ep->ep_num);
1055 if (req->usb_req.short_not_ok)
1056 status = -EREMOTEIO;
1057 }
1058 bdc_req_complete(ep, bd_xfr->req, status);
1059}
1060
1061/* EP0 setup related packet handlers */
1062
1063/*
1064 * Setup packet received, just store the packet and process on next DS or SS
1065 * started SR
1066 */
1067void bdc_xsf_ep0_setup_recv(struct bdc *bdc, struct bdc_sr *sreport)
1068{
1069 struct usb_ctrlrequest *setup_pkt;
1070 u32 len;
1071
1072 dev_dbg(bdc->dev,
1073 "%s ep0_state:%s\n",
1074 __func__, ep0_state_string[bdc->ep0_state]);
1075 /* Store received setup packet */
1076 setup_pkt = &bdc->setup_pkt;
1077 memcpy(setup_pkt, &sreport->offset[0], sizeof(*setup_pkt));
1078 len = le16_to_cpu(setup_pkt->wLength);
1079 if (!len)
1080 bdc->ep0_state = WAIT_FOR_STATUS_START;
1081 else
1082 bdc->ep0_state = WAIT_FOR_DATA_START;
1083
1084
1085 dev_dbg(bdc->dev,
1086 "%s exit ep0_state:%s\n",
1087 __func__, ep0_state_string[bdc->ep0_state]);
1088}
1089
1090/* Stall ep0 */
1091static void ep0_stall(struct bdc *bdc)
1092{
1093 struct bdc_ep *ep = bdc->bdc_ep_array[1];
1094 struct bdc_req *req;
1095
1096 dev_dbg(bdc->dev, "%s\n", __func__);
1097 bdc->delayed_status = false;
1098 ep_set_halt(ep, 1);
1099
1100 /* de-queue any pendig requests */
1101 while (!list_empty(&ep->queue)) {
1102 req = list_entry(ep->queue.next, struct bdc_req,
1103 queue);
1104 bdc_req_complete(ep, req, -ESHUTDOWN);
1105 }
1106}
1107
1108/* SET_ADD handlers */
1109static int ep0_set_address(struct bdc *bdc, struct usb_ctrlrequest *ctrl)
1110{
1111 enum usb_device_state state = bdc->gadget.state;
1112 int ret = 0;
1113 u32 addr;
1114
1115 addr = le16_to_cpu(ctrl->wValue);
1116 dev_dbg(bdc->dev,
1117 "%s addr:%d dev state:%d\n",
1118 __func__, addr, state);
1119
1120 if (addr > 127)
1121 return -EINVAL;
1122
1123 switch (state) {
1124 case USB_STATE_DEFAULT:
1125 case USB_STATE_ADDRESS:
1126 /* Issue Address device command */
1127 ret = bdc_address_device(bdc, addr);
1128 if (ret)
1129 return ret;
1130
1131 if (addr)
1132 usb_gadget_set_state(&bdc->gadget, USB_STATE_ADDRESS);
1133 else
1134 usb_gadget_set_state(&bdc->gadget, USB_STATE_DEFAULT);
1135
1136 bdc->dev_addr = addr;
1137 break;
1138 default:
1139 dev_warn(bdc->dev,
1140 "SET Address in wrong device state %d\n",
1141 state);
1142 ret = -EINVAL;
1143 }
1144
1145 return ret;
1146}
1147
1148/* Handler for SET/CLEAR FEATURE requests for device */
1149static int ep0_handle_feature_dev(struct bdc *bdc, u16 wValue,
1150 u16 wIndex, bool set)
1151{
1152 enum usb_device_state state = bdc->gadget.state;
1153 u32 usppms = 0;
1154
1155 dev_dbg(bdc->dev, "%s set:%d dev state:%d\n",
1156 __func__, set, state);
1157 switch (wValue) {
1158 case USB_DEVICE_REMOTE_WAKEUP:
1159 dev_dbg(bdc->dev, "USB_DEVICE_REMOTE_WAKEUP\n");
1160 if (set)
1161 bdc->devstatus |= REMOTE_WAKE_ENABLE;
1162 else
1163 bdc->devstatus &= ~REMOTE_WAKE_ENABLE;
1164 break;
1165
1166 case USB_DEVICE_TEST_MODE:
1167 dev_dbg(bdc->dev, "USB_DEVICE_TEST_MODE\n");
1168 if ((wIndex & 0xFF) ||
1169 (bdc->gadget.speed != USB_SPEED_HIGH) || !set)
1170 return -EINVAL;
1171
1172 bdc->test_mode = wIndex >> 8;
1173 break;
1174
1175 case USB_DEVICE_U1_ENABLE:
1176 dev_dbg(bdc->dev, "USB_DEVICE_U1_ENABLE\n");
1177
1178 if (bdc->gadget.speed != USB_SPEED_SUPER ||
1179 state != USB_STATE_CONFIGURED)
1180 return -EINVAL;
1181
1182 usppms = bdc_readl(bdc->regs, BDC_USPPMS);
1183 if (set) {
1184 /* clear previous u1t */
1185 usppms &= ~BDC_U1T(BDC_U1T_MASK);
1186 usppms |= BDC_U1T(U1_TIMEOUT);
1187 usppms |= BDC_U1E | BDC_PORT_W1S;
1188 bdc->devstatus |= (1 << USB_DEV_STAT_U1_ENABLED);
1189 } else {
1190 usppms &= ~BDC_U1E;
1191 usppms |= BDC_PORT_W1S;
1192 bdc->devstatus &= ~(1 << USB_DEV_STAT_U1_ENABLED);
1193 }
1194 bdc_writel(bdc->regs, BDC_USPPMS, usppms);
1195 break;
1196
1197 case USB_DEVICE_U2_ENABLE:
1198 dev_dbg(bdc->dev, "USB_DEVICE_U2_ENABLE\n");
1199
1200 if (bdc->gadget.speed != USB_SPEED_SUPER ||
1201 state != USB_STATE_CONFIGURED)
1202 return -EINVAL;
1203
1204 usppms = bdc_readl(bdc->regs, BDC_USPPMS);
1205 if (set) {
1206 usppms |= BDC_U2E;
1207 usppms |= BDC_U2A;
1208 bdc->devstatus |= (1 << USB_DEV_STAT_U2_ENABLED);
1209 } else {
1210 usppms &= ~BDC_U2E;
1211 usppms &= ~BDC_U2A;
1212 bdc->devstatus &= ~(1 << USB_DEV_STAT_U2_ENABLED);
1213 }
1214 bdc_writel(bdc->regs, BDC_USPPMS, usppms);
1215 break;
1216
1217 case USB_DEVICE_LTM_ENABLE:
1218 dev_dbg(bdc->dev, "USB_DEVICE_LTM_ENABLE?\n");
1219 if (bdc->gadget.speed != USB_SPEED_SUPER ||
1220 state != USB_STATE_CONFIGURED)
1221 return -EINVAL;
1222 break;
1223 default:
1224 dev_err(bdc->dev, "Unknown wValue:%d\n", wValue);
1225 return -EOPNOTSUPP;
1226 } /* USB_RECIP_DEVICE end */
1227
1228 return 0;
1229}
1230
1231/* SET/CLEAR FEATURE handler */
1232static int ep0_handle_feature(struct bdc *bdc,
1233 struct usb_ctrlrequest *setup_pkt, bool set)
1234{
1235 enum usb_device_state state = bdc->gadget.state;
1236 struct bdc_ep *ep;
1237 u16 wValue;
1238 u16 wIndex;
1239 int epnum;
1240
1241 wValue = le16_to_cpu(setup_pkt->wValue);
1242 wIndex = le16_to_cpu(setup_pkt->wIndex);
1243
1244 dev_dbg(bdc->dev,
1245 "%s wValue=%d wIndex=%d devstate=%08x speed=%d set=%d",
1246 __func__, wValue, wIndex, state,
1247 bdc->gadget.speed, set);
1248
1249 switch (setup_pkt->bRequestType & USB_RECIP_MASK) {
1250 case USB_RECIP_DEVICE:
1251 return ep0_handle_feature_dev(bdc, wValue, wIndex, set);
1252 case USB_RECIP_INTERFACE:
1253 dev_dbg(bdc->dev, "USB_RECIP_INTERFACE\n");
1254 /* USB3 spec, sec 9.4.9 */
1255 if (wValue != USB_INTRF_FUNC_SUSPEND)
1256 return -EINVAL;
1257 /* USB3 spec, Table 9-8 */
1258 if (set) {
1259 if (wIndex & USB_INTRF_FUNC_SUSPEND_RW) {
1260 dev_dbg(bdc->dev, "SET REMOTE_WAKEUP\n");
1261 bdc->devstatus |= REMOTE_WAKE_ENABLE;
1262 } else {
1263 dev_dbg(bdc->dev, "CLEAR REMOTE_WAKEUP\n");
1264 bdc->devstatus &= ~REMOTE_WAKE_ENABLE;
1265 }
1266 }
1267 break;
1268
1269 case USB_RECIP_ENDPOINT:
1270 dev_dbg(bdc->dev, "USB_RECIP_ENDPOINT\n");
1271 if (wValue != USB_ENDPOINT_HALT)
1272 return -EINVAL;
1273
1274 epnum = wIndex & USB_ENDPOINT_NUMBER_MASK;
1275 if (epnum) {
1276 if ((wIndex & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
1277 epnum = epnum * 2 + 1;
1278 else
1279 epnum *= 2;
1280 } else {
1281 epnum = 1; /*EP0*/
1282 }
1283 /*
1284 * If CLEAR_FEATURE on ep0 then don't do anything as the stall
1285 * condition on ep0 has already been cleared when SETUP packet
1286 * was received.
1287 */
1288 if (epnum == 1 && !set) {
1289 dev_dbg(bdc->dev, "ep0 stall already cleared\n");
1290 return 0;
1291 }
1292 dev_dbg(bdc->dev, "epnum=%d\n", epnum);
1293 ep = bdc->bdc_ep_array[epnum];
1294 if (!ep)
1295 return -EINVAL;
1296
1297 return ep_set_halt(ep, set);
1298 default:
1299 dev_err(bdc->dev, "Unknown recipient\n");
1300 return -EINVAL;
1301 }
1302
1303 return 0;
1304}
1305
1306/* GET_STATUS request handler */
1307static int ep0_handle_status(struct bdc *bdc,
1308 struct usb_ctrlrequest *setup_pkt)
1309{
1310 enum usb_device_state state = bdc->gadget.state;
1311 struct bdc_ep *ep;
1312 u16 usb_status = 0;
1313 u32 epnum;
1314 u16 wIndex;
1315
1316 /* USB2.0 spec sec 9.4.5 */
1317 if (state == USB_STATE_DEFAULT)
1318 return -EINVAL;
1319 wIndex = le16_to_cpu(setup_pkt->wIndex);
1320 dev_dbg(bdc->dev, "%s\n", __func__);
1321 usb_status = bdc->devstatus;
1322 switch (setup_pkt->bRequestType & USB_RECIP_MASK) {
1323 case USB_RECIP_DEVICE:
1324 dev_dbg(bdc->dev,
1325 "USB_RECIP_DEVICE devstatus:%08x\n",
1326 bdc->devstatus);
1327 /* USB3 spec, sec 9.4.5 */
1328 if (bdc->gadget.speed == USB_SPEED_SUPER)
1329 usb_status &= ~REMOTE_WAKE_ENABLE;
1330 break;
1331
1332 case USB_RECIP_INTERFACE:
1333 dev_dbg(bdc->dev, "USB_RECIP_INTERFACE\n");
1334 if (bdc->gadget.speed == USB_SPEED_SUPER) {
1335 /*
1336 * This should come from func for Func remote wkup
1337 * usb_status |=1;
1338 */
1339 if (bdc->devstatus & REMOTE_WAKE_ENABLE)
1340 usb_status |= REMOTE_WAKE_ENABLE;
1341 } else {
1342 usb_status = 0;
1343 }
1344
1345 break;
1346
1347 case USB_RECIP_ENDPOINT:
1348 dev_dbg(bdc->dev, "USB_RECIP_ENDPOINT\n");
1349 epnum = wIndex & USB_ENDPOINT_NUMBER_MASK;
1350 if (epnum) {
1351 if ((wIndex & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
1352 epnum = epnum*2 + 1;
1353 else
1354 epnum *= 2;
1355 } else {
1356 epnum = 1; /* EP0 */
1357 }
1358
1359 ep = bdc->bdc_ep_array[epnum];
1360 if (!ep) {
1361 dev_err(bdc->dev, "ISSUE, GET_STATUS for invalid EP ?");
1362 return -EINVAL;
1363 }
1364 if (ep->flags & BDC_EP_STALL)
1365 usb_status |= 1 << USB_ENDPOINT_HALT;
1366
1367 break;
1368 default:
1369 dev_err(bdc->dev, "Unknown recipient for get_status\n");
1370 return -EINVAL;
1371 }
1372 /* prepare a data stage for GET_STATUS */
1373 dev_dbg(bdc->dev, "usb_status=%08x\n", usb_status);
1374 *(__le16 *)bdc->ep0_response_buff = cpu_to_le16(usb_status);
1375 bdc->ep0_req.usb_req.length = 2;
1376 bdc->ep0_req.usb_req.buf = &bdc->ep0_response_buff;
1377 ep0_queue_data_stage(bdc);
1378
1379 return 0;
1380}
1381
1382static void ep0_set_sel_cmpl(struct usb_ep *_ep, struct usb_request *_req)
1383{
1384 /* ep0_set_sel_cmpl */
1385}
1386
1387/* Queue data stage to handle 6 byte SET_SEL request */
1388static int ep0_set_sel(struct bdc *bdc,
1389 struct usb_ctrlrequest *setup_pkt)
1390{
1391 struct bdc_ep *ep;
1392 u16 wLength;
1393 u16 wValue;
1394
1395 dev_dbg(bdc->dev, "%s\n", __func__);
1396 wValue = le16_to_cpu(setup_pkt->wValue);
1397 wLength = le16_to_cpu(setup_pkt->wLength);
1398 if (unlikely(wLength != 6)) {
1399 dev_err(bdc->dev, "%s Wrong wLength:%d\n", __func__, wLength);
1400 return -EINVAL;
1401 }
1402 ep = bdc->bdc_ep_array[1];
1403 bdc->ep0_req.ep = ep;
1404 bdc->ep0_req.usb_req.length = 6;
1405 bdc->ep0_req.usb_req.buf = bdc->ep0_response_buff;
1406 bdc->ep0_req.usb_req.complete = ep0_set_sel_cmpl;
1407 ep0_queue_data_stage(bdc);
1408
1409 return 0;
1410}
1411
1412/*
1413 * Queue a 0 byte bd only if wLength is more than the length and and length is
1414 * a multiple of MaxPacket then queue 0 byte BD
1415 */
1416static int ep0_queue_zlp(struct bdc *bdc)
1417{
1418 int ret;
1419
1420 dev_dbg(bdc->dev, "%s\n", __func__);
1421 bdc->ep0_req.ep = bdc->bdc_ep_array[1];
1422 bdc->ep0_req.usb_req.length = 0;
1423 bdc->ep0_req.usb_req.complete = NULL;
1424 bdc->ep0_state = WAIT_FOR_DATA_START;
1425 ret = bdc_queue_xfr(bdc, &bdc->ep0_req);
1426 if (ret) {
1427 dev_err(bdc->dev, "err queueing zlp :%d\n", ret);
1428 return ret;
1429 }
1430 bdc->ep0_state = WAIT_FOR_DATA_XMIT;
1431
1432 return 0;
1433}
1434
1435/* Control request handler */
1436static int handle_control_request(struct bdc *bdc)
1437{
1438 enum usb_device_state state = bdc->gadget.state;
1439 struct usb_ctrlrequest *setup_pkt;
1440 int delegate_setup = 0;
1441 int ret = 0;
1442 int config = 0;
1443
1444 setup_pkt = &bdc->setup_pkt;
1445 dev_dbg(bdc->dev, "%s\n", __func__);
1446 if ((setup_pkt->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
1447 switch (setup_pkt->bRequest) {
1448 case USB_REQ_SET_ADDRESS:
1449 dev_dbg(bdc->dev, "USB_REQ_SET_ADDRESS\n");
1450 ret = ep0_set_address(bdc, setup_pkt);
1451 bdc->devstatus &= DEVSTATUS_CLEAR;
1452 break;
1453
1454 case USB_REQ_SET_CONFIGURATION:
1455 dev_dbg(bdc->dev, "USB_REQ_SET_CONFIGURATION\n");
1456 if (state == USB_STATE_ADDRESS) {
1457 usb_gadget_set_state(&bdc->gadget,
1458 USB_STATE_CONFIGURED);
1459 } else if (state == USB_STATE_CONFIGURED) {
1460 /*
1461 * USB2 spec sec 9.4.7, if wValue is 0 then dev
1462 * is moved to addressed state
1463 */
1464 config = le16_to_cpu(setup_pkt->wValue);
1465 if (!config)
1466 usb_gadget_set_state(
1467 &bdc->gadget,
1468 USB_STATE_ADDRESS);
1469 }
1470 delegate_setup = 1;
1471 break;
1472
1473 case USB_REQ_SET_FEATURE:
1474 dev_dbg(bdc->dev, "USB_REQ_SET_FEATURE\n");
1475 ret = ep0_handle_feature(bdc, setup_pkt, 1);
1476 break;
1477
1478 case USB_REQ_CLEAR_FEATURE:
1479 dev_dbg(bdc->dev, "USB_REQ_CLEAR_FEATURE\n");
1480 ret = ep0_handle_feature(bdc, setup_pkt, 0);
1481 break;
1482
1483 case USB_REQ_GET_STATUS:
1484 dev_dbg(bdc->dev, "USB_REQ_GET_STATUS\n");
1485 ret = ep0_handle_status(bdc, setup_pkt);
1486 break;
1487
1488 case USB_REQ_SET_SEL:
1489 dev_dbg(bdc->dev, "USB_REQ_SET_SEL\n");
1490 ret = ep0_set_sel(bdc, setup_pkt);
1491 break;
1492
1493 case USB_REQ_SET_ISOCH_DELAY:
1494 dev_warn(bdc->dev,
1495 "USB_REQ_SET_ISOCH_DELAY not handled\n");
1496 ret = 0;
1497 break;
1498 default:
1499 delegate_setup = 1;
1500 }
1501 } else {
1502 delegate_setup = 1;
1503 }
1504
1505 if (delegate_setup) {
1506 spin_unlock(&bdc->lock);
1507 ret = bdc->gadget_driver->setup(&bdc->gadget, setup_pkt);
1508 spin_lock(&bdc->lock);
1509 }
1510
1511 return ret;
1512}
1513
1514/* EP0: Data stage started */
1515void bdc_xsf_ep0_data_start(struct bdc *bdc, struct bdc_sr *sreport)
1516{
1517 struct bdc_ep *ep;
1518 int ret = 0;
1519
1520 dev_dbg(bdc->dev, "%s\n", __func__);
1521 ep = bdc->bdc_ep_array[1];
1522 /* If ep0 was stalled, the clear it first */
1523 if (ep->flags & BDC_EP_STALL) {
1524 ret = ep_set_halt(ep, 0);
1525 if (ret)
1526 goto err;
1527 }
1528 if (bdc->ep0_state != WAIT_FOR_DATA_START)
1529 dev_warn(bdc->dev,
1530 "Data stage not expected ep0_state:%s\n",
1531 ep0_state_string[bdc->ep0_state]);
1532
1533 ret = handle_control_request(bdc);
1534 if (ret == USB_GADGET_DELAYED_STATUS) {
1535 /*
1536 * The ep0 state will remain WAIT_FOR_DATA_START till
1537 * we received ep_queue on ep0
1538 */
1539 bdc->delayed_status = true;
1540 return;
1541 }
1542 if (!ret) {
1543 bdc->ep0_state = WAIT_FOR_DATA_XMIT;
1544 dev_dbg(bdc->dev,
1545 "ep0_state:%s", ep0_state_string[bdc->ep0_state]);
1546 return;
1547 }
1548err:
1549 ep0_stall(bdc);
1550}
1551
1552/* EP0: status stage started */
1553void bdc_xsf_ep0_status_start(struct bdc *bdc, struct bdc_sr *sreport)
1554{
1555 struct usb_ctrlrequest *setup_pkt;
1556 struct bdc_ep *ep;
1557 int ret = 0;
1558
1559 dev_dbg(bdc->dev,
1560 "%s ep0_state:%s",
1561 __func__, ep0_state_string[bdc->ep0_state]);
1562 ep = bdc->bdc_ep_array[1];
1563
1564 /* check if ZLP was queued? */
1565 if (bdc->zlp_needed)
1566 bdc->zlp_needed = false;
1567
1568 if (ep->flags & BDC_EP_STALL) {
1569 ret = ep_set_halt(ep, 0);
1570 if (ret)
1571 goto err;
1572 }
1573
1574 if ((bdc->ep0_state != WAIT_FOR_STATUS_START) &&
1575 (bdc->ep0_state != WAIT_FOR_DATA_XMIT))
1576 dev_err(bdc->dev,
1577 "Status stage recv but ep0_state:%s\n",
1578 ep0_state_string[bdc->ep0_state]);
1579
1580 /* check if data stage is in progress ? */
1581 if (bdc->ep0_state == WAIT_FOR_DATA_XMIT) {
1582 bdc->ep0_state = STATUS_PENDING;
1583 /* Status stage will be queued upon Data stage transmit event */
1584 dev_dbg(bdc->dev,
1585 "status started but data not transmitted yet\n");
1586 return;
1587 }
1588 setup_pkt = &bdc->setup_pkt;
1589
1590 /*
1591 * 2 stage setup then only process the setup, for 3 stage setup the date
1592 * stage is already handled
1593 */
1594 if (!le16_to_cpu(setup_pkt->wLength)) {
1595 ret = handle_control_request(bdc);
1596 if (ret == USB_GADGET_DELAYED_STATUS) {
1597 bdc->delayed_status = true;
1598 /* ep0_state will remain WAIT_FOR_STATUS_START */
1599 return;
1600 }
1601 }
1602 if (!ret) {
1603 /* Queue a status stage BD */
1604 ep0_queue_status_stage(bdc);
1605 bdc->ep0_state = WAIT_FOR_STATUS_XMIT;
1606 dev_dbg(bdc->dev,
1607 "ep0_state:%s", ep0_state_string[bdc->ep0_state]);
1608 return;
1609 }
1610err:
1611 ep0_stall(bdc);
1612}
1613
1614/* Helper function to update ep0 upon SR with xsf_succ or xsf_short */
1615static void ep0_xsf_complete(struct bdc *bdc, struct bdc_sr *sreport)
1616{
1617 dev_dbg(bdc->dev, "%s\n", __func__);
1618 switch (bdc->ep0_state) {
1619 case WAIT_FOR_DATA_XMIT:
1620 bdc->ep0_state = WAIT_FOR_STATUS_START;
1621 break;
1622 case WAIT_FOR_STATUS_XMIT:
1623 bdc->ep0_state = WAIT_FOR_SETUP;
1624 if (bdc->test_mode) {
1625 int ret;
1626
1627 dev_dbg(bdc->dev, "test_mode:%d\n", bdc->test_mode);
1628 ret = bdc_set_test_mode(bdc);
1629 if (ret < 0) {
1630 dev_err(bdc->dev, "Err in setting Test mode\n");
1631 return;
1632 }
1633 bdc->test_mode = 0;
1634 }
1635 break;
1636 case STATUS_PENDING:
1637 bdc_xsf_ep0_status_start(bdc, sreport);
1638 break;
1639
1640 default:
1641 dev_err(bdc->dev,
1642 "Unknown ep0_state:%s\n",
1643 ep0_state_string[bdc->ep0_state]);
1644
1645 }
1646}
1647
1648/* xfr completion status report handler */
1649void bdc_sr_xsf(struct bdc *bdc, struct bdc_sr *sreport)
1650{
1651 struct bdc_ep *ep;
1652 u32 sr_status;
1653 u8 ep_num;
1654
1655 ep_num = (le32_to_cpu(sreport->offset[3])>>4) & 0x1f;
1656 ep = bdc->bdc_ep_array[ep_num];
1657 if (!ep || !(ep->flags & BDC_EP_ENABLED)) {
1658 dev_err(bdc->dev, "xsf for ep not enabled\n");
1659 return;
1660 }
1661 /*
1662 * check if this transfer is after link went from U3->U0 due
1663 * to remote wakeup
1664 */
1665 if (bdc->devstatus & FUNC_WAKE_ISSUED) {
1666 bdc->devstatus &= ~(FUNC_WAKE_ISSUED);
1667 dev_dbg(bdc->dev, "%s clearing FUNC_WAKE_ISSUED flag\n",
1668 __func__);
1669 }
1670 sr_status = XSF_STS(le32_to_cpu(sreport->offset[3]));
1671 dev_dbg_ratelimited(bdc->dev, "%s sr_status=%d ep:%s\n",
1672 __func__, sr_status, ep->name);
1673
1674 switch (sr_status) {
1675 case XSF_SUCC:
1676 case XSF_SHORT:
1677 handle_xsr_succ_status(bdc, ep, sreport);
1678 if (ep_num == 1)
1679 ep0_xsf_complete(bdc, sreport);
1680 break;
1681
1682 case XSF_SETUP_RECV:
1683 case XSF_DATA_START:
1684 case XSF_STATUS_START:
1685 if (ep_num != 1) {
1686 dev_err(bdc->dev,
1687 "ep0 related packets on non ep0 endpoint");
1688 return;
1689 }
1690 bdc->sr_xsf_ep0[sr_status - XSF_SETUP_RECV](bdc, sreport);
1691 break;
1692
1693 case XSF_BABB:
1694 if (ep_num == 1) {
1695 dev_dbg(bdc->dev, "Babble on ep0 zlp_need:%d\n",
1696 bdc->zlp_needed);
1697 /*
1698 * If the last completed transfer had wLength >Data Len,
1699 * and Len is multiple of MaxPacket,then queue ZLP
1700 */
1701 if (bdc->zlp_needed) {
1702 /* queue 0 length bd */
1703 ep0_queue_zlp(bdc);
1704 return;
1705 }
1706 }
1707 dev_warn(bdc->dev, "Babble on ep not handled\n");
1708 break;
1709 default:
1710 dev_warn(bdc->dev, "sr status not handled:%x\n", sr_status);
1711 break;
1712 }
1713}
1714
1715static int bdc_gadget_ep_queue(struct usb_ep *_ep,
1716 struct usb_request *_req, gfp_t gfp_flags)
1717{
1718 struct bdc_req *req;
1719 unsigned long flags;
1720 struct bdc_ep *ep;
1721 struct bdc *bdc;
1722 int ret;
1723
1724 if (!_ep || !_ep->desc)
1725 return -ESHUTDOWN;
1726
1727 if (!_req || !_req->complete || !_req->buf)
1728 return -EINVAL;
1729
1730 ep = to_bdc_ep(_ep);
1731 req = to_bdc_req(_req);
1732 bdc = ep->bdc;
1733 dev_dbg(bdc->dev, "%s ep:%p req:%p\n", __func__, ep, req);
1734 dev_dbg(bdc->dev, "queuing request %p to %s length %d zero:%d\n",
1735 _req, ep->name, _req->length, _req->zero);
1736
1737 if (!ep->usb_ep.desc) {
1738 dev_warn(bdc->dev,
1739 "trying to queue req %p to disabled %s\n",
1740 _req, ep->name);
1741 return -ESHUTDOWN;
1742 }
1743
1744 if (_req->length > MAX_XFR_LEN) {
1745 dev_warn(bdc->dev,
1746 "req length > supported MAX:%d requested:%d\n",
1747 MAX_XFR_LEN, _req->length);
1748 return -EOPNOTSUPP;
1749 }
1750 spin_lock_irqsave(&bdc->lock, flags);
1751 if (ep == bdc->bdc_ep_array[1])
1752 ret = ep0_queue(ep, req);
1753 else
1754 ret = ep_queue(ep, req);
1755
1756 spin_unlock_irqrestore(&bdc->lock, flags);
1757
1758 return ret;
1759}
1760
1761static int bdc_gadget_ep_dequeue(struct usb_ep *_ep,
1762 struct usb_request *_req)
1763{
1764 struct bdc_req *req;
1765 unsigned long flags;
1766 struct bdc_ep *ep;
1767 struct bdc *bdc;
1768 int ret;
1769
1770 if (!_ep || !_req)
1771 return -EINVAL;
1772
1773 ep = to_bdc_ep(_ep);
1774 req = to_bdc_req(_req);
1775 bdc = ep->bdc;
1776 dev_dbg(bdc->dev, "%s ep:%s req:%p\n", __func__, ep->name, req);
1777 bdc_dbg_bd_list(bdc, ep);
1778 spin_lock_irqsave(&bdc->lock, flags);
1779 /* make sure it's still queued on this endpoint */
1780 list_for_each_entry(req, &ep->queue, queue) {
1781 if (&req->usb_req == _req)
1782 break;
1783 }
1784 if (&req->usb_req != _req) {
1785 spin_unlock_irqrestore(&bdc->lock, flags);
1786 dev_err(bdc->dev, "usb_req !=req n");
1787 return -EINVAL;
1788 }
1789 ret = ep_dequeue(ep, req);
1790 if (ret) {
1791 ret = -EOPNOTSUPP;
1792 goto err;
1793 }
1794 bdc_req_complete(ep, req, -ECONNRESET);
1795
1796err:
1797 bdc_dbg_bd_list(bdc, ep);
1798 spin_unlock_irqrestore(&bdc->lock, flags);
1799
1800 return ret;
1801}
1802
1803static int bdc_gadget_ep_set_halt(struct usb_ep *_ep, int value)
1804{
1805 unsigned long flags;
1806 struct bdc_ep *ep;
1807 struct bdc *bdc;
1808 int ret;
1809
1810 ep = to_bdc_ep(_ep);
1811 bdc = ep->bdc;
1812 dev_dbg(bdc->dev, "%s ep:%s value=%d\n", __func__, ep->name, value);
1813 spin_lock_irqsave(&bdc->lock, flags);
1814 if (usb_endpoint_xfer_isoc(ep->usb_ep.desc))
1815 ret = -EINVAL;
1816 else if (!list_empty(&ep->queue))
1817 ret = -EAGAIN;
1818 else
1819 ret = ep_set_halt(ep, value);
1820
1821 spin_unlock_irqrestore(&bdc->lock, flags);
1822
1823 return ret;
1824}
1825
1826static struct usb_request *bdc_gadget_alloc_request(struct usb_ep *_ep,
1827 gfp_t gfp_flags)
1828{
1829 struct bdc_req *req;
1830 struct bdc_ep *ep;
1831
1832 req = kzalloc(sizeof(*req), gfp_flags);
1833 if (!req)
1834 return NULL;
1835
1836 ep = to_bdc_ep(_ep);
1837 req->ep = ep;
1838 req->epnum = ep->ep_num;
1839 req->usb_req.dma = DMA_ADDR_INVALID;
1840 dev_dbg(ep->bdc->dev, "%s ep:%s req:%p\n", __func__, ep->name, req);
1841
1842 return &req->usb_req;
1843}
1844
1845static void bdc_gadget_free_request(struct usb_ep *_ep,
1846 struct usb_request *_req)
1847{
1848 struct bdc_req *req;
1849
1850 req = to_bdc_req(_req);
1851 kfree(req);
1852}
1853
1854/* endpoint operations */
1855
1856/* configure endpoint and also allocate resources */
1857static int bdc_gadget_ep_enable(struct usb_ep *_ep,
1858 const struct usb_endpoint_descriptor *desc)
1859{
1860 unsigned long flags;
1861 struct bdc_ep *ep;
1862 struct bdc *bdc;
1863 int ret;
1864
1865 if (!_ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT) {
1866 pr_debug("bdc_gadget_ep_enable invalid parameters\n");
1867 return -EINVAL;
1868 }
1869
1870 if (!desc->wMaxPacketSize) {
1871 pr_debug("bdc_gadget_ep_enable missing wMaxPacketSize\n");
1872 return -EINVAL;
1873 }
1874
1875 ep = to_bdc_ep(_ep);
1876 bdc = ep->bdc;
1877
1878 /* Sanity check, upper layer will not send enable for ep0 */
1879 if (ep == bdc->bdc_ep_array[1])
1880 return -EINVAL;
1881
1882 if (!bdc->gadget_driver
1883 || bdc->gadget.speed == USB_SPEED_UNKNOWN) {
1884 return -ESHUTDOWN;
1885 }
1886
1887 dev_dbg(bdc->dev, "%s Enabling %s\n", __func__, ep->name);
1888 spin_lock_irqsave(&bdc->lock, flags);
1889 ep->desc = desc;
1890 ep->comp_desc = _ep->comp_desc;
1891 ret = bdc_ep_enable(ep);
1892 spin_unlock_irqrestore(&bdc->lock, flags);
1893
1894 return ret;
1895}
1896
1897static int bdc_gadget_ep_disable(struct usb_ep *_ep)
1898{
1899 unsigned long flags;
1900 struct bdc_ep *ep;
1901 struct bdc *bdc;
1902 int ret;
1903
1904 if (!_ep) {
1905 pr_debug("bdc: invalid parameters\n");
1906 return -EINVAL;
1907 }
1908 ep = to_bdc_ep(_ep);
1909 bdc = ep->bdc;
1910
1911 /* Upper layer will not call this for ep0, but do a sanity check */
1912 if (ep == bdc->bdc_ep_array[1]) {
1913 dev_warn(bdc->dev, "%s called for ep0\n", __func__);
1914 return -EINVAL;
1915 }
1916 dev_dbg(bdc->dev,
1917 "%s() ep:%s ep->flags:%08x\n",
1918 __func__, ep->name, ep->flags);
1919
1920 if (!(ep->flags & BDC_EP_ENABLED)) {
1921 dev_warn(bdc->dev, "%s is already disabled\n", ep->name);
1922 return 0;
1923 }
1924 spin_lock_irqsave(&bdc->lock, flags);
1925 ret = bdc_ep_disable(ep);
1926 spin_unlock_irqrestore(&bdc->lock, flags);
1927
1928 return ret;
1929}
1930
1931static const struct usb_ep_ops bdc_gadget_ep_ops = {
1932 .enable = bdc_gadget_ep_enable,
1933 .disable = bdc_gadget_ep_disable,
1934 .alloc_request = bdc_gadget_alloc_request,
1935 .free_request = bdc_gadget_free_request,
1936 .queue = bdc_gadget_ep_queue,
1937 .dequeue = bdc_gadget_ep_dequeue,
1938 .set_halt = bdc_gadget_ep_set_halt
1939};
1940
1941/* dir = 1 is IN */
1942static int init_ep(struct bdc *bdc, u32 epnum, u32 dir)
1943{
1944 struct bdc_ep *ep;
1945
1946 dev_dbg(bdc->dev, "%s epnum=%d dir=%d\n", __func__, epnum, dir);
1947 ep = kzalloc(sizeof(*ep), GFP_KERNEL);
1948 if (!ep)
1949 return -ENOMEM;
1950
1951 ep->bdc = bdc;
1952 ep->dir = dir;
1953
1954 /* ep->ep_num is the index inside bdc_ep */
1955 if (epnum == 1) {
1956 ep->ep_num = 1;
1957 bdc->bdc_ep_array[ep->ep_num] = ep;
1958 snprintf(ep->name, sizeof(ep->name), "ep%d", epnum - 1);
1959 usb_ep_set_maxpacket_limit(&ep->usb_ep, EP0_MAX_PKT_SIZE);
1960 ep->comp_desc = NULL;
1961 bdc->gadget.ep0 = &ep->usb_ep;
1962 } else {
1963 if (dir)
1964 ep->ep_num = epnum * 2 - 1;
1965 else
1966 ep->ep_num = epnum * 2 - 2;
1967
1968 bdc->bdc_ep_array[ep->ep_num] = ep;
1969 snprintf(ep->name, sizeof(ep->name), "ep%d%s", epnum - 1,
1970 dir & 1 ? "in" : "out");
1971
1972 usb_ep_set_maxpacket_limit(&ep->usb_ep, 1024);
1973 ep->usb_ep.max_streams = 0;
1974 list_add_tail(&ep->usb_ep.ep_list, &bdc->gadget.ep_list);
1975 }
1976 ep->usb_ep.ops = &bdc_gadget_ep_ops;
1977 ep->usb_ep.name = ep->name;
1978 ep->flags = 0;
1979 ep->ignore_next_sr = false;
1980 dev_dbg(bdc->dev, "ep=%p ep->usb_ep.name=%s epnum=%d ep->epnum=%d\n",
1981 ep, ep->usb_ep.name, epnum, ep->ep_num);
1982
1983 INIT_LIST_HEAD(&ep->queue);
1984
1985 return 0;
1986}
1987
1988/* Init all ep */
1989int bdc_init_ep(struct bdc *bdc)
1990{
1991 u8 epnum;
1992 int ret;
1993
1994 dev_dbg(bdc->dev, "%s()\n", __func__);
1995 INIT_LIST_HEAD(&bdc->gadget.ep_list);
1996 /* init ep0 */
1997 ret = init_ep(bdc, 1, 0);
1998 if (ret) {
1999 dev_err(bdc->dev, "init ep ep0 fail %d\n", ret);
2000 return ret;
2001 }
2002
2003 for (epnum = 2; epnum <= bdc->num_eps / 2; epnum++) {
2004 /* OUT */
2005 ret = init_ep(bdc, epnum, 0);
2006 if (ret) {
2007 dev_err(bdc->dev,
2008 "init ep failed for:%d error: %d\n",
2009 epnum, ret);
2010 return ret;
2011 }
2012
2013 /* IN */
2014 ret = init_ep(bdc, epnum, 1);
2015 if (ret) {
2016 dev_err(bdc->dev,
2017 "init ep failed for:%d error: %d\n",
2018 epnum, ret);
2019 return ret;
2020 }
2021 }
2022
2023 return 0;
2024}
diff --git a/drivers/usb/gadget/udc/bdc/bdc_ep.h b/drivers/usb/gadget/udc/bdc/bdc_ep.h
new file mode 100644
index 000000000000..8a6b36cbf2ea
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_ep.h
@@ -0,0 +1,22 @@
1/*
2 * bdc_ep.h - header for the BDC debug functions
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14#ifndef __LINUX_BDC_EP_H__
15#define __LINUX_BDC_EP_H__
16
17int bdc_init_ep(struct bdc *);
18int bdc_ep_disable(struct bdc_ep *);
19int bdc_ep_enable(struct bdc_ep *);
20void bdc_free_ep(struct bdc *);
21
22#endif /* __LINUX_BDC_EP_H__ */
diff --git a/drivers/usb/gadget/udc/bdc/bdc_pci.c b/drivers/usb/gadget/udc/bdc/bdc_pci.c
new file mode 100644
index 000000000000..02968842b359
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_pci.c
@@ -0,0 +1,132 @@
1/*
2 * bdc_pci.c - BRCM BDC USB3.0 device controller PCI interface file.
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * Based on drivers under drivers/usb/
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 *
15 */
16
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/slab.h>
20#include <linux/pci.h>
21#include <linux/pci_ids.h>
22#include <linux/platform_device.h>
23
24#include "bdc.h"
25
26#define BDC_PCI_PID 0x1570
27
28struct bdc_pci {
29 struct device *dev;
30 struct platform_device *bdc;
31};
32
33static int bdc_setup_msi(struct pci_dev *pci)
34{
35 int ret;
36
37 ret = pci_enable_msi(pci);
38 if (ret) {
39 pr_err("failed to allocate MSI entry\n");
40 return ret;
41 }
42
43 return ret;
44}
45
46static int bdc_pci_probe(struct pci_dev *pci, const struct pci_device_id *id)
47{
48 struct resource res[2];
49 struct platform_device *bdc;
50 struct bdc_pci *glue;
51 int ret = -ENOMEM;
52
53 glue = devm_kzalloc(&pci->dev, sizeof(*glue), GFP_KERNEL);
54 if (!glue)
55 return -ENOMEM;
56
57 glue->dev = &pci->dev;
58 ret = pci_enable_device(pci);
59 if (ret) {
60 dev_err(&pci->dev, "failed to enable pci device\n");
61 return -ENODEV;
62 }
63 pci_set_master(pci);
64
65 bdc = platform_device_alloc(BRCM_BDC_NAME, PLATFORM_DEVID_AUTO);
66 if (!bdc)
67 return -ENOMEM;
68
69 memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));
70 bdc_setup_msi(pci);
71
72 res[0].start = pci_resource_start(pci, 0);
73 res[0].end = pci_resource_end(pci, 0);
74 res[0].name = BRCM_BDC_NAME;
75 res[0].flags = IORESOURCE_MEM;
76
77 res[1].start = pci->irq;
78 res[1].name = BRCM_BDC_NAME;
79 res[1].flags = IORESOURCE_IRQ;
80
81 ret = platform_device_add_resources(bdc, res, ARRAY_SIZE(res));
82 if (ret) {
83 dev_err(&pci->dev,
84 "couldn't add resources to bdc device\n");
85 return ret;
86 }
87
88 pci_set_drvdata(pci, glue);
89
90 dma_set_coherent_mask(&bdc->dev, pci->dev.coherent_dma_mask);
91
92 bdc->dev.dma_mask = pci->dev.dma_mask;
93 bdc->dev.dma_parms = pci->dev.dma_parms;
94 bdc->dev.parent = &pci->dev;
95 glue->bdc = bdc;
96
97 ret = platform_device_add(bdc);
98 if (ret) {
99 dev_err(&pci->dev, "failed to register bdc device\n");
100 platform_device_put(bdc);
101 return ret;
102 }
103
104 return 0;
105}
106
107static void bdc_pci_remove(struct pci_dev *pci)
108{
109 struct bdc_pci *glue = pci_get_drvdata(pci);
110
111 platform_device_unregister(glue->bdc);
112 pci_disable_msi(pci);
113}
114
115static struct pci_device_id bdc_pci_id_table[] = {
116 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, BDC_PCI_PID), },
117 {} /* Terminating Entry */
118};
119
120MODULE_DEVICE_TABLE(pci, bdc_pci_id_table);
121
122static struct pci_driver bdc_pci_driver = {
123 .name = "bdc-pci",
124 .id_table = bdc_pci_id_table,
125 .probe = bdc_pci_probe,
126 .remove = bdc_pci_remove,
127};
128
129MODULE_AUTHOR("Ashwini Pahuja <ashwini.linux@gmail.com>");
130MODULE_LICENSE("GPL");
131MODULE_DESCRIPTION("BRCM BDC USB3 PCI Glue layer");
132module_pci_driver(bdc_pci_driver);
diff --git a/drivers/usb/gadget/udc/bdc/bdc_udc.c b/drivers/usb/gadget/udc/bdc/bdc_udc.c
new file mode 100644
index 000000000000..3700ce70b0be
--- /dev/null
+++ b/drivers/usb/gadget/udc/bdc/bdc_udc.c
@@ -0,0 +1,587 @@
1/*
2 * bdc_udc.c - BRCM BDC USB3.0 device controller gagdet ops
3 *
4 * Copyright (C) 2014 Broadcom Corporation
5 *
6 * Author: Ashwini Pahuja
7 *
8 * Based on drivers under drivers/usb/gadget/udc/
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 *
15 */
16#include <linux/module.h>
17#include <linux/pci.h>
18#include <linux/dma-mapping.h>
19#include <linux/kernel.h>
20#include <linux/delay.h>
21#include <linux/ioport.h>
22#include <linux/sched.h>
23#include <linux/slab.h>
24#include <linux/errno.h>
25#include <linux/init.h>
26#include <linux/timer.h>
27#include <linux/list.h>
28#include <linux/interrupt.h>
29#include <linux/moduleparam.h>
30#include <linux/device.h>
31#include <linux/usb/ch9.h>
32#include <linux/usb/gadget.h>
33#include <linux/usb/otg.h>
34#include <linux/pm.h>
35#include <linux/io.h>
36#include <linux/irq.h>
37#include <asm/unaligned.h>
38#include <linux/platform_device.h>
39
40#include "bdc.h"
41#include "bdc_ep.h"
42#include "bdc_cmd.h"
43#include "bdc_dbg.h"
44
45static const struct usb_gadget_ops bdc_gadget_ops;
46
47static const char * const conn_speed_str[] = {
48 "Not connected",
49 "Full Speed",
50 "Low Speed",
51 "High Speed",
52 "Super Speed",
53};
54
55/* EP0 initial descripror */
56static struct usb_endpoint_descriptor bdc_gadget_ep0_desc = {
57 .bLength = USB_DT_ENDPOINT_SIZE,
58 .bDescriptorType = USB_DT_ENDPOINT,
59 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
60 .bEndpointAddress = 0,
61 .wMaxPacketSize = cpu_to_le16(EP0_MAX_PKT_SIZE),
62};
63
64/* Advance the srr dqp maintained by SW */
65static void srr_dqp_index_advc(struct bdc *bdc, u32 srr_num)
66{
67 struct srr *srr;
68
69 srr = &bdc->srr;
70 dev_dbg_ratelimited(bdc->dev, "srr->dqp_index:%d\n", srr->dqp_index);
71 srr->dqp_index++;
72 /* rollback to 0 if we are past the last */
73 if (srr->dqp_index == NUM_SR_ENTRIES)
74 srr->dqp_index = 0;
75}
76
77/* connect sr */
78static void bdc_uspc_connected(struct bdc *bdc)
79{
80 u32 speed, temp;
81 u32 usppms;
82 int ret;
83
84 temp = bdc_readl(bdc->regs, BDC_USPC);
85 speed = BDC_PSP(temp);
86 dev_dbg(bdc->dev, "%s speed=%x\n", __func__, speed);
87 switch (speed) {
88 case BDC_SPEED_SS:
89 bdc_gadget_ep0_desc.wMaxPacketSize =
90 cpu_to_le16(EP0_MAX_PKT_SIZE);
91 bdc->gadget.ep0->maxpacket = EP0_MAX_PKT_SIZE;
92 bdc->gadget.speed = USB_SPEED_SUPER;
93 /* Enable U1T in SS mode */
94 usppms = bdc_readl(bdc->regs, BDC_USPPMS);
95 usppms &= ~BDC_U1T(0xff);
96 usppms |= BDC_U1T(U1_TIMEOUT);
97 usppms |= BDC_PORT_W1S;
98 bdc_writel(bdc->regs, BDC_USPPMS, usppms);
99 break;
100
101 case BDC_SPEED_HS:
102 bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(64);
103 bdc->gadget.ep0->maxpacket = 64;
104 bdc->gadget.speed = USB_SPEED_HIGH;
105 break;
106
107 case BDC_SPEED_FS:
108 bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(64);
109 bdc->gadget.ep0->maxpacket = 64;
110 bdc->gadget.speed = USB_SPEED_FULL;
111 break;
112
113 case BDC_SPEED_LS:
114 bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(8);
115 bdc->gadget.ep0->maxpacket = 8;
116 bdc->gadget.speed = USB_SPEED_LOW;
117 break;
118 default:
119 dev_err(bdc->dev, "UNDEFINED SPEED\n");
120 return;
121 }
122 dev_dbg(bdc->dev, "connected at %s\n", conn_speed_str[speed]);
123 /* Now we know the speed, configure ep0 */
124 bdc->bdc_ep_array[1]->desc = &bdc_gadget_ep0_desc;
125 ret = bdc_config_ep(bdc, bdc->bdc_ep_array[1]);
126 if (ret)
127 dev_err(bdc->dev, "EP0 config failed\n");
128 bdc->bdc_ep_array[1]->usb_ep.desc = &bdc_gadget_ep0_desc;
129 bdc->bdc_ep_array[1]->flags |= BDC_EP_ENABLED;
130 usb_gadget_set_state(&bdc->gadget, USB_STATE_DEFAULT);
131}
132
133/* device got disconnected */
134static void bdc_uspc_disconnected(struct bdc *bdc, bool reinit)
135{
136 struct bdc_ep *ep;
137
138 dev_dbg(bdc->dev, "%s\n", __func__);
139 /*
140 * Only stop ep0 from here, rest of the endpoints will be disabled
141 * from gadget_disconnect
142 */
143 ep = bdc->bdc_ep_array[1];
144 if (ep && (ep->flags & BDC_EP_ENABLED))
145 /* if enabled then stop and remove requests */
146 bdc_ep_disable(ep);
147
148 if (bdc->gadget_driver && bdc->gadget_driver->disconnect) {
149 spin_unlock(&bdc->lock);
150 bdc->gadget_driver->disconnect(&bdc->gadget);
151 spin_lock(&bdc->lock);
152 }
153 /* Set Unknown speed */
154 bdc->gadget.speed = USB_SPEED_UNKNOWN;
155 bdc->devstatus &= DEVSTATUS_CLEAR;
156 bdc->delayed_status = false;
157 bdc->reinit = reinit;
158 bdc->test_mode = false;
159}
160
161/* TNotify wkaeup timer */
162static void bdc_func_wake_timer(struct work_struct *work)
163{
164 struct bdc *bdc = container_of(work, struct bdc, func_wake_notify.work);
165 unsigned long flags;
166
167 dev_dbg(bdc->dev, "%s\n", __func__);
168 spin_lock_irqsave(&bdc->lock, flags);
169 /*
170 * Check if host has started transferring on endpoints
171 * FUNC_WAKE_ISSUED is cleared when transfer has started after resume
172 */
173 if (bdc->devstatus & FUNC_WAKE_ISSUED) {
174 dev_dbg(bdc->dev, "FUNC_WAKE_ISSUED FLAG IS STILL SET\n");
175 /* flag is still set, so again send func wake */
176 bdc_function_wake_fh(bdc, 0);
177 schedule_delayed_work(&bdc->func_wake_notify,
178 msecs_to_jiffies(BDC_TNOTIFY));
179 }
180 spin_unlock_irqrestore(&bdc->lock, flags);
181}
182
183/* handler for Link state change condition */
184static void handle_link_state_change(struct bdc *bdc, u32 uspc)
185{
186 u32 link_state;
187
188 dev_dbg(bdc->dev, "Link state change");
189 link_state = BDC_PST(uspc);
190 switch (link_state) {
191 case BDC_LINK_STATE_U3:
192 if ((bdc->gadget.speed != USB_SPEED_UNKNOWN) &&
193 bdc->gadget_driver->suspend) {
194 dev_dbg(bdc->dev, "Entered Suspend mode\n");
195 spin_unlock(&bdc->lock);
196 bdc->devstatus |= DEVICE_SUSPENDED;
197 bdc->gadget_driver->suspend(&bdc->gadget);
198 spin_lock(&bdc->lock);
199 }
200 break;
201 case BDC_LINK_STATE_U0:
202 if (bdc->devstatus & REMOTE_WAKEUP_ISSUED) {
203 bdc->devstatus &= ~REMOTE_WAKEUP_ISSUED;
204 if (bdc->gadget.speed == USB_SPEED_SUPER) {
205 bdc_function_wake_fh(bdc, 0);
206 bdc->devstatus |= FUNC_WAKE_ISSUED;
207 /*
208 * Start a Notification timer and check if the
209 * Host transferred anything on any of the EPs,
210 * if not then send function wake again every
211 * TNotification secs until host initiates
212 * transfer to BDC, USB3 spec Table 8.13
213 */
214 schedule_delayed_work(
215 &bdc->func_wake_notify,
216 msecs_to_jiffies(BDC_TNOTIFY));
217 dev_dbg(bdc->dev, "sched func_wake_notify\n");
218 }
219 }
220 break;
221
222 case BDC_LINK_STATE_RESUME:
223 dev_dbg(bdc->dev, "Resumed from Suspend\n");
224 if (bdc->devstatus & DEVICE_SUSPENDED) {
225 bdc->gadget_driver->resume(&bdc->gadget);
226 bdc->devstatus &= ~DEVICE_SUSPENDED;
227 }
228 break;
229 default:
230 dev_dbg(bdc->dev, "link state:%d\n", link_state);
231 }
232}
233
234/* something changes on upstream port, handle it here */
235void bdc_sr_uspc(struct bdc *bdc, struct bdc_sr *sreport)
236{
237 u32 clear_flags = 0;
238 u32 uspc;
239 bool connected = false;
240 bool disconn = false;
241
242 uspc = bdc_readl(bdc->regs, BDC_USPC);
243 dev_dbg(bdc->dev, "%s uspc=0x%08x\n", __func__, uspc);
244
245 /* Port connect changed */
246 if (uspc & BDC_PCC) {
247 /* Vbus not present, and not connected to Downstream port */
248 if ((uspc & BDC_VBC) && !(uspc & BDC_VBS) && !(uspc & BDC_PCS))
249 disconn = true;
250 else if ((uspc & BDC_PCS) && !BDC_PST(uspc))
251 connected = true;
252 }
253
254 /* Change in VBus and VBus is present */
255 if ((uspc & BDC_VBC) && (uspc & BDC_VBS)) {
256 if (bdc->pullup) {
257 dev_dbg(bdc->dev, "Do a softconnect\n");
258 /* Attached state, do a softconnect */
259 bdc_softconn(bdc);
260 usb_gadget_set_state(&bdc->gadget, USB_STATE_POWERED);
261 }
262 clear_flags = BDC_VBC;
263 } else if ((uspc & BDC_PRS) || (uspc & BDC_PRC) || disconn) {
264 /* Hot reset, warm reset, 2.0 bus reset or disconn */
265 dev_dbg(bdc->dev, "Port reset or disconn\n");
266 bdc_uspc_disconnected(bdc, disconn);
267 clear_flags = BDC_PCC|BDC_PCS|BDC_PRS|BDC_PRC;
268 } else if ((uspc & BDC_PSC) && (uspc & BDC_PCS)) {
269 /* Change in Link state */
270 handle_link_state_change(bdc, uspc);
271 clear_flags = BDC_PSC|BDC_PCS;
272 }
273
274 /*
275 * In SS we might not have PRC bit set before connection, but in 2.0
276 * the PRC bit is set before connection, so moving this condition out
277 * of bus reset to handle both SS/2.0 speeds.
278 */
279 if (connected) {
280 /* This is the connect event for U0/L0 */
281 dev_dbg(bdc->dev, "Connected\n");
282 bdc_uspc_connected(bdc);
283 bdc->devstatus &= ~(DEVICE_SUSPENDED);
284 }
285 uspc = bdc_readl(bdc->regs, BDC_USPC);
286 uspc &= (~BDC_USPSC_RW);
287 dev_dbg(bdc->dev, "uspc=%x\n", uspc);
288 bdc_writel(bdc->regs, BDC_USPC, clear_flags);
289}
290
291/* Main interrupt handler for bdc */
292static irqreturn_t bdc_udc_interrupt(int irq, void *_bdc)
293{
294 u32 eqp_index, dqp_index, sr_type, srr_int;
295 struct bdc_sr *sreport;
296 struct bdc *bdc = _bdc;
297 u32 status;
298 int ret;
299
300 spin_lock(&bdc->lock);
301 status = bdc_readl(bdc->regs, BDC_BDCSC);
302 if (!(status & BDC_GIP)) {
303 spin_unlock(&bdc->lock);
304 return IRQ_NONE;
305 }
306 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0));
307 /* Check if the SRR IP bit it set? */
308 if (!(srr_int & BDC_SRR_IP)) {
309 dev_warn(bdc->dev, "Global irq pending but SRR IP is 0\n");
310 spin_unlock(&bdc->lock);
311 return IRQ_NONE;
312 }
313 eqp_index = BDC_SRR_EPI(srr_int);
314 dqp_index = BDC_SRR_DPI(srr_int);
315 dev_dbg(bdc->dev,
316 "%s eqp_index=%d dqp_index=%d srr.dqp_index=%d\n\n",
317 __func__, eqp_index, dqp_index, bdc->srr.dqp_index);
318
319 /* check for ring empty condition */
320 if (eqp_index == dqp_index) {
321 dev_dbg(bdc->dev, "SRR empty?\n");
322 spin_unlock(&bdc->lock);
323 return IRQ_HANDLED;
324 }
325
326 while (bdc->srr.dqp_index != eqp_index) {
327 sreport = &bdc->srr.sr_bds[bdc->srr.dqp_index];
328 /* sreport is read before using it */
329 rmb();
330 sr_type = le32_to_cpu(sreport->offset[3]) & BD_TYPE_BITMASK;
331 dev_dbg_ratelimited(bdc->dev, "sr_type=%d\n", sr_type);
332 switch (sr_type) {
333 case SR_XSF:
334 bdc->sr_handler[0](bdc, sreport);
335 break;
336
337 case SR_USPC:
338 bdc->sr_handler[1](bdc, sreport);
339 break;
340 default:
341 dev_warn(bdc->dev, "SR:%d not handled\n", sr_type);
342 }
343 /* Advance the srr dqp index */
344 srr_dqp_index_advc(bdc, 0);
345 }
346 /* update the hw dequeue pointer */
347 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0));
348 srr_int &= ~BDC_SRR_DPI_MASK;
349 srr_int &= ~(BDC_SRR_RWS|BDC_SRR_RST|BDC_SRR_ISR);
350 srr_int |= ((bdc->srr.dqp_index) << 16);
351 srr_int |= BDC_SRR_IP;
352 bdc_writel(bdc->regs, BDC_SRRINT(0), srr_int);
353 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0));
354 if (bdc->reinit) {
355 ret = bdc_reinit(bdc);
356 if (ret)
357 dev_err(bdc->dev, "err in bdc reinit\n");
358 }
359
360 spin_unlock(&bdc->lock);
361
362 return IRQ_HANDLED;
363}
364
365/* Gadget ops */
366static int bdc_udc_start(struct usb_gadget *gadget,
367 struct usb_gadget_driver *driver)
368{
369 struct bdc *bdc = gadget_to_bdc(gadget);
370 unsigned long flags;
371 int ret = 0;
372
373 dev_dbg(bdc->dev, "%s()\n", __func__);
374 spin_lock_irqsave(&bdc->lock, flags);
375 if (bdc->gadget_driver) {
376 dev_err(bdc->dev, "%s is already bound to %s\n",
377 bdc->gadget.name,
378 bdc->gadget_driver->driver.name);
379 ret = -EBUSY;
380 goto err;
381 }
382 /*
383 * Run the controller from here and when BDC is connected to
384 * Host then driver will receive a USPC SR with VBUS present
385 * and then driver will do a softconnect.
386 */
387 ret = bdc_run(bdc);
388 if (ret) {
389 dev_err(bdc->dev, "%s bdc run fail\n", __func__);
390 goto err;
391 }
392 bdc->gadget_driver = driver;
393 bdc->gadget.dev.driver = &driver->driver;
394err:
395 spin_unlock_irqrestore(&bdc->lock, flags);
396
397 return ret;
398}
399
400static int bdc_udc_stop(struct usb_gadget *gadget)
401{
402 struct bdc *bdc = gadget_to_bdc(gadget);
403 unsigned long flags;
404
405 dev_dbg(bdc->dev, "%s()\n", __func__);
406 spin_lock_irqsave(&bdc->lock, flags);
407 bdc_stop(bdc);
408 bdc->gadget_driver = NULL;
409 bdc->gadget.dev.driver = NULL;
410 spin_unlock_irqrestore(&bdc->lock, flags);
411
412 return 0;
413}
414
415static int bdc_udc_pullup(struct usb_gadget *gadget, int is_on)
416{
417 struct bdc *bdc = gadget_to_bdc(gadget);
418 unsigned long flags;
419 u32 uspc;
420
421 dev_dbg(bdc->dev, "%s() is_on:%d\n", __func__, is_on);
422 if (!gadget)
423 return -EINVAL;
424
425 spin_lock_irqsave(&bdc->lock, flags);
426 if (!is_on) {
427 bdc_softdisconn(bdc);
428 bdc->pullup = false;
429 } else {
430 /*
431 * For a self powered device, we need to wait till we receive
432 * a VBUS change and Vbus present event, then if pullup flag
433 * is set, then only we present the Termintation.
434 */
435 bdc->pullup = true;
436 /*
437 * Check if BDC is already connected to Host i.e Vbus=1,
438 * if yes, then present TERM now, this is typical for bus
439 * powered devices.
440 */
441 uspc = bdc_readl(bdc->regs, BDC_USPC);
442 if (uspc & BDC_VBS)
443 bdc_softconn(bdc);
444 }
445 spin_unlock_irqrestore(&bdc->lock, flags);
446
447 return 0;
448}
449
450static int bdc_udc_set_selfpowered(struct usb_gadget *gadget,
451 int is_self)
452{
453 struct bdc *bdc = gadget_to_bdc(gadget);
454 unsigned long flags;
455
456 dev_dbg(bdc->dev, "%s()\n", __func__);
457 spin_lock_irqsave(&bdc->lock, flags);
458 if (!is_self)
459 bdc->devstatus |= 1 << USB_DEVICE_SELF_POWERED;
460 else
461 bdc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
462
463 spin_unlock_irqrestore(&bdc->lock, flags);
464
465 return 0;
466}
467
468static int bdc_udc_wakeup(struct usb_gadget *gadget)
469{
470 struct bdc *bdc = gadget_to_bdc(gadget);
471 unsigned long flags;
472 u8 link_state;
473 u32 uspc;
474 int ret = 0;
475
476 dev_dbg(bdc->dev,
477 "%s() bdc->devstatus=%08x\n",
478 __func__, bdc->devstatus);
479
480 if (!(bdc->devstatus & REMOTE_WAKE_ENABLE))
481 return -EOPNOTSUPP;
482
483 spin_lock_irqsave(&bdc->lock, flags);
484 uspc = bdc_readl(bdc->regs, BDC_USPC);
485 link_state = BDC_PST(uspc);
486 dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc);
487 if (link_state != BDC_LINK_STATE_U3) {
488 dev_warn(bdc->dev,
489 "can't wakeup from link state %d\n",
490 link_state);
491 ret = -EINVAL;
492 goto out;
493 }
494 if (bdc->gadget.speed == USB_SPEED_SUPER)
495 bdc->devstatus |= REMOTE_WAKEUP_ISSUED;
496
497 uspc &= ~BDC_PST_MASK;
498 uspc &= (~BDC_USPSC_RW);
499 uspc |= BDC_PST(BDC_LINK_STATE_U0);
500 uspc |= BDC_SWS;
501 bdc_writel(bdc->regs, BDC_USPC, uspc);
502 uspc = bdc_readl(bdc->regs, BDC_USPC);
503 link_state = BDC_PST(uspc);
504 dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc);
505out:
506 spin_unlock_irqrestore(&bdc->lock, flags);
507
508 return ret;
509}
510
511static const struct usb_gadget_ops bdc_gadget_ops = {
512 .wakeup = bdc_udc_wakeup,
513 .set_selfpowered = bdc_udc_set_selfpowered,
514 .pullup = bdc_udc_pullup,
515 .udc_start = bdc_udc_start,
516 .udc_stop = bdc_udc_stop,
517};
518
519/* Init the gadget interface and register the udc */
520int bdc_udc_init(struct bdc *bdc)
521{
522 u32 temp;
523 int ret;
524
525 dev_dbg(bdc->dev, "%s()\n", __func__);
526 bdc->gadget.ops = &bdc_gadget_ops;
527 bdc->gadget.max_speed = USB_SPEED_SUPER;
528 bdc->gadget.speed = USB_SPEED_UNKNOWN;
529 bdc->gadget.dev.parent = bdc->dev;
530
531 bdc->gadget.sg_supported = false;
532
533
534 bdc->gadget.name = BRCM_BDC_NAME;
535 ret = devm_request_irq(bdc->dev, bdc->irq, bdc_udc_interrupt,
536 IRQF_SHARED , BRCM_BDC_NAME, bdc);
537 if (ret) {
538 dev_err(bdc->dev,
539 "failed to request irq #%d %d\n",
540 bdc->irq, ret);
541 return ret;
542 }
543
544 ret = bdc_init_ep(bdc);
545 if (ret) {
546 dev_err(bdc->dev, "bdc init ep fail: %d\n", ret);
547 return ret;
548 }
549
550 ret = usb_add_gadget_udc(bdc->dev, &bdc->gadget);
551 if (ret) {
552 dev_err(bdc->dev, "failed to register udc\n");
553 goto err0;
554 }
555 usb_gadget_set_state(&bdc->gadget, USB_STATE_NOTATTACHED);
556 bdc->bdc_ep_array[1]->desc = &bdc_gadget_ep0_desc;
557 /*
558 * Allocate bd list for ep0 only, ep0 will be enabled on connect
559 * status report when the speed is known
560 */
561 ret = bdc_ep_enable(bdc->bdc_ep_array[1]);
562 if (ret) {
563 dev_err(bdc->dev, "fail to enable %s\n",
564 bdc->bdc_ep_array[1]->name);
565 goto err1;
566 }
567 INIT_DELAYED_WORK(&bdc->func_wake_notify, bdc_func_wake_timer);
568 /* Enable Interrupts */
569 temp = bdc_readl(bdc->regs, BDC_BDCSC);
570 temp |= BDC_GIE;
571 bdc_writel(bdc->regs, BDC_BDCSC, temp);
572 return 0;
573err1:
574 usb_del_gadget_udc(&bdc->gadget);
575err0:
576 bdc_free_ep(bdc);
577
578 return ret;
579}
580
581void bdc_udc_exit(struct bdc *bdc)
582{
583 dev_dbg(bdc->dev, "%s()\n", __func__);
584 bdc_ep_disable(bdc->bdc_ep_array[1]);
585 usb_del_gadget_udc(&bdc->gadget);
586 bdc_free_ep(bdc);
587}
diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c
index 81dc5959e36b..1c69c760408e 100644
--- a/drivers/usb/gadget/udc/dummy_hcd.c
+++ b/drivers/usb/gadget/udc/dummy_hcd.c
@@ -367,19 +367,22 @@ static void set_link_state(struct dummy_hcd *dum_hcd)
367 dum_hcd->active) 367 dum_hcd->active)
368 dum_hcd->resuming = 0; 368 dum_hcd->resuming = 0;
369 369
370 /* if !connected or reset */ 370 /* Currently !connected or in reset */
371 if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0 || 371 if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0 ||
372 (dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) { 372 (dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) {
373 /* 373 unsigned disconnect = USB_PORT_STAT_CONNECTION &
374 * We're connected and not reset (reset occurred now), 374 dum_hcd->old_status & (~dum_hcd->port_status);
375 * and driver attached - disconnect! 375 unsigned reset = USB_PORT_STAT_RESET &
376 */ 376 (~dum_hcd->old_status) & dum_hcd->port_status;
377 if ((dum_hcd->old_status & USB_PORT_STAT_CONNECTION) != 0 && 377
378 (dum_hcd->old_status & USB_PORT_STAT_RESET) == 0 && 378 /* Report reset and disconnect events to the driver */
379 dum->driver) { 379 if (dum->driver && (disconnect || reset)) {
380 stop_activity(dum); 380 stop_activity(dum);
381 spin_unlock(&dum->lock); 381 spin_unlock(&dum->lock);
382 dum->driver->disconnect(&dum->gadget); 382 if (reset)
383 usb_gadget_udc_reset(&dum->gadget, dum->driver);
384 else
385 dum->driver->disconnect(&dum->gadget);
383 spin_lock(&dum->lock); 386 spin_lock(&dum->lock);
384 } 387 }
385 } else if (dum_hcd->active != dum_hcd->old_active) { 388 } else if (dum_hcd->active != dum_hcd->old_active) {
@@ -851,8 +854,7 @@ static int dummy_pullup(struct usb_gadget *_gadget, int value)
851 854
852static int dummy_udc_start(struct usb_gadget *g, 855static int dummy_udc_start(struct usb_gadget *g,
853 struct usb_gadget_driver *driver); 856 struct usb_gadget_driver *driver);
854static int dummy_udc_stop(struct usb_gadget *g, 857static int dummy_udc_stop(struct usb_gadget *g);
855 struct usb_gadget_driver *driver);
856 858
857static const struct usb_gadget_ops dummy_ops = { 859static const struct usb_gadget_ops dummy_ops = {
858 .get_frame = dummy_g_get_frame, 860 .get_frame = dummy_g_get_frame,
@@ -908,23 +910,16 @@ static int dummy_udc_start(struct usb_gadget *g,
908 */ 910 */
909 911
910 dum->devstatus = 0; 912 dum->devstatus = 0;
911
912 dum->driver = driver; 913 dum->driver = driver;
913 dev_dbg(udc_dev(dum), "binding gadget driver '%s'\n", 914
914 driver->driver.name);
915 return 0; 915 return 0;
916} 916}
917 917
918static int dummy_udc_stop(struct usb_gadget *g, 918static int dummy_udc_stop(struct usb_gadget *g)
919 struct usb_gadget_driver *driver)
920{ 919{
921 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g); 920 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
922 struct dummy *dum = dum_hcd->dum; 921 struct dummy *dum = dum_hcd->dum;
923 922
924 if (driver)
925 dev_dbg(udc_dev(dum), "unregister gadget driver '%s'\n",
926 driver->driver.name);
927
928 dum->driver = NULL; 923 dum->driver = NULL;
929 924
930 return 0; 925 return 0;
@@ -2370,7 +2365,6 @@ static void dummy_stop(struct usb_hcd *hcd)
2370 2365
2371 dum = hcd_to_dummy_hcd(hcd)->dum; 2366 dum = hcd_to_dummy_hcd(hcd)->dum;
2372 device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs); 2367 device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs);
2373 usb_gadget_unregister_driver(dum->driver);
2374 dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n"); 2368 dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
2375} 2369}
2376 2370
diff --git a/drivers/usb/gadget/udc/fotg210-udc.c b/drivers/usb/gadget/udc/fotg210-udc.c
index 1d315921bf34..1ca52e11eb98 100644
--- a/drivers/usb/gadget/udc/fotg210-udc.c
+++ b/drivers/usb/gadget/udc/fotg210-udc.c
@@ -1053,8 +1053,7 @@ static void fotg210_init(struct fotg210_udc *fotg210)
1053 iowrite32(value, fotg210->reg + FOTG210_DMISGR0); 1053 iowrite32(value, fotg210->reg + FOTG210_DMISGR0);
1054} 1054}
1055 1055
1056static int fotg210_udc_stop(struct usb_gadget *g, 1056static int fotg210_udc_stop(struct usb_gadget *g)
1057 struct usb_gadget_driver *driver)
1058{ 1057{
1059 struct fotg210_udc *fotg210 = gadget_to_fotg210(g); 1058 struct fotg210_udc *fotg210 = gadget_to_fotg210(g);
1060 unsigned long flags; 1059 unsigned long flags;
diff --git a/drivers/usb/gadget/udc/fsl_qe_udc.c b/drivers/usb/gadget/udc/fsl_qe_udc.c
index dd18ea38e391..d201f9a89ce3 100644
--- a/drivers/usb/gadget/udc/fsl_qe_udc.c
+++ b/drivers/usb/gadget/udc/fsl_qe_udc.c
@@ -1887,8 +1887,7 @@ static int qe_get_frame(struct usb_gadget *gadget)
1887 1887
1888static int fsl_qe_start(struct usb_gadget *gadget, 1888static int fsl_qe_start(struct usb_gadget *gadget,
1889 struct usb_gadget_driver *driver); 1889 struct usb_gadget_driver *driver);
1890static int fsl_qe_stop(struct usb_gadget *gadget, 1890static int fsl_qe_stop(struct usb_gadget *gadget);
1891 struct usb_gadget_driver *driver);
1892 1891
1893/* defined in usb_gadget.h */ 1892/* defined in usb_gadget.h */
1894static const struct usb_gadget_ops qe_gadget_ops = { 1893static const struct usb_gadget_ops qe_gadget_ops = {
@@ -1918,7 +1917,7 @@ static int reset_queues(struct qe_udc *udc)
1918 1917
1919 /* report disconnect; the driver is already quiesced */ 1918 /* report disconnect; the driver is already quiesced */
1920 spin_unlock(&udc->lock); 1919 spin_unlock(&udc->lock);
1921 udc->driver->disconnect(&udc->gadget); 1920 usb_gadget_udc_reset(&udc->gadget, udc->driver);
1922 spin_lock(&udc->lock); 1921 spin_lock(&udc->lock);
1923 1922
1924 return 0; 1923 return 0;
@@ -2305,13 +2304,10 @@ static int fsl_qe_start(struct usb_gadget *gadget,
2305 udc->ep0_dir = USB_DIR_OUT; 2304 udc->ep0_dir = USB_DIR_OUT;
2306 spin_unlock_irqrestore(&udc->lock, flags); 2305 spin_unlock_irqrestore(&udc->lock, flags);
2307 2306
2308 dev_info(udc->dev, "%s bind to driver %s\n", udc->gadget.name,
2309 driver->driver.name);
2310 return 0; 2307 return 0;
2311} 2308}
2312 2309
2313static int fsl_qe_stop(struct usb_gadget *gadget, 2310static int fsl_qe_stop(struct usb_gadget *gadget)
2314 struct usb_gadget_driver *driver)
2315{ 2311{
2316 struct qe_udc *udc; 2312 struct qe_udc *udc;
2317 struct qe_ep *loop_ep; 2313 struct qe_ep *loop_ep;
@@ -2336,8 +2332,6 @@ static int fsl_qe_stop(struct usb_gadget *gadget,
2336 2332
2337 udc->driver = NULL; 2333 udc->driver = NULL;
2338 2334
2339 dev_info(udc->dev, "unregistered gadget driver '%s'\r\n",
2340 driver->driver.name);
2341 return 0; 2335 return 0;
2342} 2336}
2343 2337
@@ -2538,7 +2532,6 @@ static int qe_udc_probe(struct platform_device *ofdev)
2538 /* create a buf for ZLP send, need to remain zeroed */ 2532 /* create a buf for ZLP send, need to remain zeroed */
2539 udc->nullbuf = devm_kzalloc(&ofdev->dev, 256, GFP_KERNEL); 2533 udc->nullbuf = devm_kzalloc(&ofdev->dev, 256, GFP_KERNEL);
2540 if (udc->nullbuf == NULL) { 2534 if (udc->nullbuf == NULL) {
2541 dev_err(udc->dev, "cannot alloc nullbuf\n");
2542 ret = -ENOMEM; 2535 ret = -ENOMEM;
2543 goto err3; 2536 goto err3;
2544 } 2537 }
diff --git a/drivers/usb/gadget/udc/fsl_udc_core.c b/drivers/usb/gadget/udc/fsl_udc_core.c
index c3620791a315..f340181da23c 100644
--- a/drivers/usb/gadget/udc/fsl_udc_core.c
+++ b/drivers/usb/gadget/udc/fsl_udc_core.c
@@ -1236,9 +1236,8 @@ static int fsl_pullup(struct usb_gadget *gadget, int is_on)
1236 1236
1237static int fsl_udc_start(struct usb_gadget *g, 1237static int fsl_udc_start(struct usb_gadget *g,
1238 struct usb_gadget_driver *driver); 1238 struct usb_gadget_driver *driver);
1239static int fsl_udc_stop(struct usb_gadget *g, 1239static int fsl_udc_stop(struct usb_gadget *g);
1240 struct usb_gadget_driver *driver); 1240
1241/* defined in gadget.h */
1242static const struct usb_gadget_ops fsl_gadget_ops = { 1241static const struct usb_gadget_ops fsl_gadget_ops = {
1243 .get_frame = fsl_get_frame, 1242 .get_frame = fsl_get_frame,
1244 .wakeup = fsl_wakeup, 1243 .wakeup = fsl_wakeup,
@@ -1772,7 +1771,7 @@ static void bus_resume(struct fsl_udc *udc)
1772} 1771}
1773 1772
1774/* Clear up all ep queues */ 1773/* Clear up all ep queues */
1775static int reset_queues(struct fsl_udc *udc) 1774static int reset_queues(struct fsl_udc *udc, bool bus_reset)
1776{ 1775{
1777 u8 pipe; 1776 u8 pipe;
1778 1777
@@ -1781,7 +1780,10 @@ static int reset_queues(struct fsl_udc *udc)
1781 1780
1782 /* report disconnect; the driver is already quiesced */ 1781 /* report disconnect; the driver is already quiesced */
1783 spin_unlock(&udc->lock); 1782 spin_unlock(&udc->lock);
1784 udc->driver->disconnect(&udc->gadget); 1783 if (bus_reset)
1784 usb_gadget_udc_reset(&udc->gadget, udc->driver);
1785 else
1786 udc->driver->disconnect(&udc->gadget);
1785 spin_lock(&udc->lock); 1787 spin_lock(&udc->lock);
1786 1788
1787 return 0; 1789 return 0;
@@ -1835,7 +1837,7 @@ static void reset_irq(struct fsl_udc *udc)
1835 udc->bus_reset = 1; 1837 udc->bus_reset = 1;
1836 /* Reset all the queues, include XD, dTD, EP queue 1838 /* Reset all the queues, include XD, dTD, EP queue
1837 * head and TR Queue */ 1839 * head and TR Queue */
1838 reset_queues(udc); 1840 reset_queues(udc, true);
1839 udc->usb_state = USB_STATE_DEFAULT; 1841 udc->usb_state = USB_STATE_DEFAULT;
1840 } else { 1842 } else {
1841 VDBG("Controller reset"); 1843 VDBG("Controller reset");
@@ -1844,7 +1846,7 @@ static void reset_irq(struct fsl_udc *udc)
1844 dr_controller_setup(udc); 1846 dr_controller_setup(udc);
1845 1847
1846 /* Reset all internal used Queues */ 1848 /* Reset all internal used Queues */
1847 reset_queues(udc); 1849 reset_queues(udc, false);
1848 1850
1849 ep0_setup(udc); 1851 ep0_setup(udc);
1850 1852
@@ -1975,8 +1977,7 @@ static int fsl_udc_start(struct usb_gadget *g,
1975} 1977}
1976 1978
1977/* Disconnect from gadget driver */ 1979/* Disconnect from gadget driver */
1978static int fsl_udc_stop(struct usb_gadget *g, 1980static int fsl_udc_stop(struct usb_gadget *g)
1979 struct usb_gadget_driver *driver)
1980{ 1981{
1981 struct fsl_ep *loop_ep; 1982 struct fsl_ep *loop_ep;
1982 unsigned long flags; 1983 unsigned long flags;
diff --git a/drivers/usb/gadget/udc/fusb300_udc.c b/drivers/usb/gadget/udc/fusb300_udc.c
index 8286df72add4..a1b33f534b52 100644
--- a/drivers/usb/gadget/udc/fusb300_udc.c
+++ b/drivers/usb/gadget/udc/fusb300_udc.c
@@ -1320,8 +1320,7 @@ static int fusb300_udc_start(struct usb_gadget *g,
1320 return 0; 1320 return 0;
1321} 1321}
1322 1322
1323static int fusb300_udc_stop(struct usb_gadget *g, 1323static int fusb300_udc_stop(struct usb_gadget *g)
1324 struct usb_gadget_driver *driver)
1325{ 1324{
1326 struct fusb300 *fusb300 = to_fusb300(g); 1325 struct fusb300 *fusb300 = to_fusb300(g);
1327 1326
diff --git a/drivers/usb/gadget/udc/goku_udc.c b/drivers/usb/gadget/udc/goku_udc.c
index bf9c5ef8b56b..5b9176e7202a 100644
--- a/drivers/usb/gadget/udc/goku_udc.c
+++ b/drivers/usb/gadget/udc/goku_udc.c
@@ -992,8 +992,7 @@ static int goku_get_frame(struct usb_gadget *_gadget)
992 992
993static int goku_udc_start(struct usb_gadget *g, 993static int goku_udc_start(struct usb_gadget *g,
994 struct usb_gadget_driver *driver); 994 struct usb_gadget_driver *driver);
995static int goku_udc_stop(struct usb_gadget *g, 995static int goku_udc_stop(struct usb_gadget *g);
996 struct usb_gadget_driver *driver);
997 996
998static const struct usb_gadget_ops goku_ops = { 997static const struct usb_gadget_ops goku_ops = {
999 .get_frame = goku_get_frame, 998 .get_frame = goku_get_frame,
@@ -1364,8 +1363,7 @@ static void stop_activity(struct goku_udc *dev)
1364 udc_enable(dev); 1363 udc_enable(dev);
1365} 1364}
1366 1365
1367static int goku_udc_stop(struct usb_gadget *g, 1366static int goku_udc_stop(struct usb_gadget *g)
1368 struct usb_gadget_driver *driver)
1369{ 1367{
1370 struct goku_udc *dev = to_goku_udc(g); 1368 struct goku_udc *dev = to_goku_udc(g);
1371 unsigned long flags; 1369 unsigned long flags;
diff --git a/drivers/usb/gadget/udc/gr_udc.c b/drivers/usb/gadget/udc/gr_udc.c
index 1b3048a6a2a3..320df9a250ff 100644
--- a/drivers/usb/gadget/udc/gr_udc.c
+++ b/drivers/usb/gadget/udc/gr_udc.c
@@ -1932,14 +1932,10 @@ static int gr_udc_start(struct usb_gadget *gadget,
1932 1932
1933 spin_unlock(&dev->lock); 1933 spin_unlock(&dev->lock);
1934 1934
1935 dev_info(dev->dev, "Started with gadget driver '%s'\n",
1936 driver->driver.name);
1937
1938 return 0; 1935 return 0;
1939} 1936}
1940 1937
1941static int gr_udc_stop(struct usb_gadget *gadget, 1938static int gr_udc_stop(struct usb_gadget *gadget)
1942 struct usb_gadget_driver *driver)
1943{ 1939{
1944 struct gr_udc *dev = to_gr_udc(gadget); 1940 struct gr_udc *dev = to_gr_udc(gadget);
1945 unsigned long flags; 1941 unsigned long flags;
@@ -1951,8 +1947,6 @@ static int gr_udc_stop(struct usb_gadget *gadget,
1951 1947
1952 spin_unlock_irqrestore(&dev->lock, flags); 1948 spin_unlock_irqrestore(&dev->lock, flags);
1953 1949
1954 dev_info(dev->dev, "Stopped\n");
1955
1956 return 0; 1950 return 0;
1957} 1951}
1958 1952
diff --git a/drivers/usb/gadget/udc/lpc32xx_udc.c b/drivers/usb/gadget/udc/lpc32xx_udc.c
index feab0bac8fdc..976529631c19 100644
--- a/drivers/usb/gadget/udc/lpc32xx_udc.c
+++ b/drivers/usb/gadget/udc/lpc32xx_udc.c
@@ -582,8 +582,7 @@ static void create_debug_file(struct lpc32xx_udc *udc)
582 582
583static void remove_debug_file(struct lpc32xx_udc *udc) 583static void remove_debug_file(struct lpc32xx_udc *udc)
584{ 584{
585 if (udc->pde) 585 debugfs_remove(udc->pde);
586 debugfs_remove(udc->pde);
587} 586}
588 587
589#else 588#else
@@ -2559,7 +2558,7 @@ static int lpc32xx_pullup(struct usb_gadget *gadget, int is_on)
2559} 2558}
2560 2559
2561static int lpc32xx_start(struct usb_gadget *, struct usb_gadget_driver *); 2560static int lpc32xx_start(struct usb_gadget *, struct usb_gadget_driver *);
2562static int lpc32xx_stop(struct usb_gadget *, struct usb_gadget_driver *); 2561static int lpc32xx_stop(struct usb_gadget *);
2563 2562
2564static const struct usb_gadget_ops lpc32xx_udc_ops = { 2563static const struct usb_gadget_ops lpc32xx_udc_ops = {
2565 .get_frame = lpc32xx_get_frame, 2564 .get_frame = lpc32xx_get_frame,
@@ -2961,15 +2960,11 @@ static int lpc32xx_start(struct usb_gadget *gadget,
2961 return 0; 2960 return 0;
2962} 2961}
2963 2962
2964static int lpc32xx_stop(struct usb_gadget *gadget, 2963static int lpc32xx_stop(struct usb_gadget *gadget)
2965 struct usb_gadget_driver *driver)
2966{ 2964{
2967 int i; 2965 int i;
2968 struct lpc32xx_udc *udc = to_udc(gadget); 2966 struct lpc32xx_udc *udc = to_udc(gadget);
2969 2967
2970 if (!driver || driver != udc->driver)
2971 return -EINVAL;
2972
2973 for (i = IRQ_USB_LP; i <= IRQ_USB_ATX; i++) 2968 for (i = IRQ_USB_LP; i <= IRQ_USB_ATX; i++)
2974 disable_irq(udc->udp_irq[i]); 2969 disable_irq(udc->udp_irq[i]);
2975 2970
diff --git a/drivers/usb/gadget/udc/m66592-udc.c b/drivers/usb/gadget/udc/m66592-udc.c
index 898565687a8c..ef3f73dd9099 100644
--- a/drivers/usb/gadget/udc/m66592-udc.c
+++ b/drivers/usb/gadget/udc/m66592-udc.c
@@ -1142,7 +1142,7 @@ static void irq_device_state(struct m66592 *m66592)
1142 m66592_write(m66592, ~M66592_DVST, M66592_INTSTS0); 1142 m66592_write(m66592, ~M66592_DVST, M66592_INTSTS0);
1143 1143
1144 if (dvsq == M66592_DS_DFLT) { /* bus reset */ 1144 if (dvsq == M66592_DS_DFLT) { /* bus reset */
1145 m66592->driver->disconnect(&m66592->gadget); 1145 usb_gadget_udc_reset(&m66592->gadget, m66592->driver);
1146 m66592_update_usb_speed(m66592); 1146 m66592_update_usb_speed(m66592);
1147 } 1147 }
1148 if (m66592->old_dvsq == M66592_DS_CNFG && dvsq != M66592_DS_CNFG) 1148 if (m66592->old_dvsq == M66592_DS_CNFG && dvsq != M66592_DS_CNFG)
@@ -1485,8 +1485,7 @@ static int m66592_udc_start(struct usb_gadget *g,
1485 return 0; 1485 return 0;
1486} 1486}
1487 1487
1488static int m66592_udc_stop(struct usb_gadget *g, 1488static int m66592_udc_stop(struct usb_gadget *g)
1489 struct usb_gadget_driver *driver)
1490{ 1489{
1491 struct m66592 *m66592 = to_m66592(g); 1490 struct m66592 *m66592 = to_m66592(g);
1492 1491
diff --git a/drivers/usb/gadget/udc/mv_u3d_core.c b/drivers/usb/gadget/udc/mv_u3d_core.c
index 046a1f808b0d..ea422ac79990 100644
--- a/drivers/usb/gadget/udc/mv_u3d_core.c
+++ b/drivers/usb/gadget/udc/mv_u3d_core.c
@@ -1266,8 +1266,7 @@ static int mv_u3d_start(struct usb_gadget *g,
1266 return 0; 1266 return 0;
1267} 1267}
1268 1268
1269static int mv_u3d_stop(struct usb_gadget *g, 1269static int mv_u3d_stop(struct usb_gadget *g)
1270 struct usb_gadget_driver *driver)
1271{ 1270{
1272 struct mv_u3d *u3d = container_of(g, struct mv_u3d, gadget); 1271 struct mv_u3d *u3d = container_of(g, struct mv_u3d, gadget);
1273 struct mv_usb_platform_data *pdata = dev_get_platdata(u3d->dev); 1272 struct mv_usb_platform_data *pdata = dev_get_platdata(u3d->dev);
@@ -1284,7 +1283,7 @@ static int mv_u3d_stop(struct usb_gadget *g,
1284 mv_u3d_controller_stop(u3d); 1283 mv_u3d_controller_stop(u3d);
1285 /* stop all usb activities */ 1284 /* stop all usb activities */
1286 u3d->gadget.speed = USB_SPEED_UNKNOWN; 1285 u3d->gadget.speed = USB_SPEED_UNKNOWN;
1287 mv_u3d_stop_activity(u3d, driver); 1286 mv_u3d_stop_activity(u3d, NULL);
1288 mv_u3d_disable(u3d); 1287 mv_u3d_disable(u3d);
1289 1288
1290 if (pdata->phy_deinit) 1289 if (pdata->phy_deinit)
diff --git a/drivers/usb/gadget/udc/mv_udc_core.c b/drivers/usb/gadget/udc/mv_udc_core.c
index 3c5db80ae325..d4edd763e963 100644
--- a/drivers/usb/gadget/udc/mv_udc_core.c
+++ b/drivers/usb/gadget/udc/mv_udc_core.c
@@ -1223,7 +1223,7 @@ static int mv_udc_pullup(struct usb_gadget *gadget, int is_on)
1223} 1223}
1224 1224
1225static int mv_udc_start(struct usb_gadget *, struct usb_gadget_driver *); 1225static int mv_udc_start(struct usb_gadget *, struct usb_gadget_driver *);
1226static int mv_udc_stop(struct usb_gadget *, struct usb_gadget_driver *); 1226static int mv_udc_stop(struct usb_gadget *);
1227/* device controller usb_gadget_ops structure */ 1227/* device controller usb_gadget_ops structure */
1228static const struct usb_gadget_ops mv_ops = { 1228static const struct usb_gadget_ops mv_ops = {
1229 1229
@@ -1307,6 +1307,23 @@ static void nuke(struct mv_ep *ep, int status)
1307 } 1307 }
1308} 1308}
1309 1309
1310static void gadget_reset(struct mv_udc *udc, struct usb_gadget_driver *driver)
1311{
1312 struct mv_ep *ep;
1313
1314 nuke(&udc->eps[0], -ESHUTDOWN);
1315
1316 list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
1317 nuke(ep, -ESHUTDOWN);
1318 }
1319
1320 /* report reset; the driver is already quiesced */
1321 if (driver) {
1322 spin_unlock(&udc->lock);
1323 usb_gadget_udc_reset(&udc->gadget, driver);
1324 spin_lock(&udc->lock);
1325 }
1326}
1310/* stop all USB activities */ 1327/* stop all USB activities */
1311static void stop_activity(struct mv_udc *udc, struct usb_gadget_driver *driver) 1328static void stop_activity(struct mv_udc *udc, struct usb_gadget_driver *driver)
1312{ 1329{
@@ -1371,8 +1388,7 @@ static int mv_udc_start(struct usb_gadget *gadget,
1371 return 0; 1388 return 0;
1372} 1389}
1373 1390
1374static int mv_udc_stop(struct usb_gadget *gadget, 1391static int mv_udc_stop(struct usb_gadget *gadget)
1375 struct usb_gadget_driver *driver)
1376{ 1392{
1377 struct mv_udc *udc; 1393 struct mv_udc *udc;
1378 unsigned long flags; 1394 unsigned long flags;
@@ -1386,7 +1402,7 @@ static int mv_udc_stop(struct usb_gadget *gadget,
1386 1402
1387 /* stop all usb activities */ 1403 /* stop all usb activities */
1388 udc->gadget.speed = USB_SPEED_UNKNOWN; 1404 udc->gadget.speed = USB_SPEED_UNKNOWN;
1389 stop_activity(udc, driver); 1405 stop_activity(udc, NULL);
1390 mv_udc_disable(udc); 1406 mv_udc_disable(udc);
1391 1407
1392 spin_unlock_irqrestore(&udc->lock, flags); 1408 spin_unlock_irqrestore(&udc->lock, flags);
@@ -1882,7 +1898,7 @@ static void irq_process_reset(struct mv_udc *udc)
1882 dev_info(&udc->dev->dev, "usb bus reset\n"); 1898 dev_info(&udc->dev->dev, "usb bus reset\n");
1883 udc->usb_state = USB_STATE_DEFAULT; 1899 udc->usb_state = USB_STATE_DEFAULT;
1884 /* reset all the queues, stop all USB activities */ 1900 /* reset all the queues, stop all USB activities */
1885 stop_activity(udc, udc->driver); 1901 gadget_reset(udc, udc->driver);
1886 } else { 1902 } else {
1887 dev_info(&udc->dev->dev, "USB reset portsc 0x%x\n", 1903 dev_info(&udc->dev->dev, "USB reset portsc 0x%x\n",
1888 readl(&udc->op_regs->portsc)); 1904 readl(&udc->op_regs->portsc));
@@ -2107,10 +2123,8 @@ static int mv_udc_probe(struct platform_device *pdev)
2107 } 2123 }
2108 2124
2109 udc = devm_kzalloc(&pdev->dev, sizeof(*udc), GFP_KERNEL); 2125 udc = devm_kzalloc(&pdev->dev, sizeof(*udc), GFP_KERNEL);
2110 if (udc == NULL) { 2126 if (udc == NULL)
2111 dev_err(&pdev->dev, "failed to allocate memory for udc\n");
2112 return -ENOMEM; 2127 return -ENOMEM;
2113 }
2114 2128
2115 udc->done = &release_done; 2129 udc->done = &release_done;
2116 udc->pdata = dev_get_platdata(&pdev->dev); 2130 udc->pdata = dev_get_platdata(&pdev->dev);
@@ -2207,7 +2221,6 @@ static int mv_udc_probe(struct platform_device *pdev)
2207 size = udc->max_eps * sizeof(struct mv_ep) *2; 2221 size = udc->max_eps * sizeof(struct mv_ep) *2;
2208 udc->eps = devm_kzalloc(&pdev->dev, size, GFP_KERNEL); 2222 udc->eps = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
2209 if (udc->eps == NULL) { 2223 if (udc->eps == NULL) {
2210 dev_err(&pdev->dev, "allocate ep memory failed\n");
2211 retval = -ENOMEM; 2224 retval = -ENOMEM;
2212 goto err_destroy_dma; 2225 goto err_destroy_dma;
2213 } 2226 }
@@ -2216,7 +2229,6 @@ static int mv_udc_probe(struct platform_device *pdev)
2216 udc->status_req = devm_kzalloc(&pdev->dev, sizeof(struct mv_req), 2229 udc->status_req = devm_kzalloc(&pdev->dev, sizeof(struct mv_req),
2217 GFP_KERNEL); 2230 GFP_KERNEL);
2218 if (!udc->status_req) { 2231 if (!udc->status_req) {
2219 dev_err(&pdev->dev, "allocate status_req memory failed\n");
2220 retval = -ENOMEM; 2232 retval = -ENOMEM;
2221 goto err_destroy_dma; 2233 goto err_destroy_dma;
2222 } 2234 }
diff --git a/drivers/usb/gadget/udc/net2272.c b/drivers/usb/gadget/udc/net2272.c
index 84d7162a8022..3a90856625f2 100644
--- a/drivers/usb/gadget/udc/net2272.c
+++ b/drivers/usb/gadget/udc/net2272.c
@@ -1169,8 +1169,7 @@ net2272_pullup(struct usb_gadget *_gadget, int is_on)
1169 1169
1170static int net2272_start(struct usb_gadget *_gadget, 1170static int net2272_start(struct usb_gadget *_gadget,
1171 struct usb_gadget_driver *driver); 1171 struct usb_gadget_driver *driver);
1172static int net2272_stop(struct usb_gadget *_gadget, 1172static int net2272_stop(struct usb_gadget *_gadget);
1173 struct usb_gadget_driver *driver);
1174 1173
1175static const struct usb_gadget_ops net2272_ops = { 1174static const struct usb_gadget_ops net2272_ops = {
1176 .get_frame = net2272_get_frame, 1175 .get_frame = net2272_get_frame,
@@ -1471,8 +1470,6 @@ static int net2272_start(struct usb_gadget *_gadget,
1471 */ 1470 */
1472 net2272_ep0_start(dev); 1471 net2272_ep0_start(dev);
1473 1472
1474 dev_dbg(dev->dev, "%s ready\n", driver->driver.name);
1475
1476 return 0; 1473 return 0;
1477} 1474}
1478 1475
@@ -1502,8 +1499,7 @@ stop_activity(struct net2272 *dev, struct usb_gadget_driver *driver)
1502 net2272_usb_reinit(dev); 1499 net2272_usb_reinit(dev);
1503} 1500}
1504 1501
1505static int net2272_stop(struct usb_gadget *_gadget, 1502static int net2272_stop(struct usb_gadget *_gadget)
1506 struct usb_gadget_driver *driver)
1507{ 1503{
1508 struct net2272 *dev; 1504 struct net2272 *dev;
1509 unsigned long flags; 1505 unsigned long flags;
@@ -1511,12 +1507,11 @@ static int net2272_stop(struct usb_gadget *_gadget,
1511 dev = container_of(_gadget, struct net2272, gadget); 1507 dev = container_of(_gadget, struct net2272, gadget);
1512 1508
1513 spin_lock_irqsave(&dev->lock, flags); 1509 spin_lock_irqsave(&dev->lock, flags);
1514 stop_activity(dev, driver); 1510 stop_activity(dev, NULL);
1515 spin_unlock_irqrestore(&dev->lock, flags); 1511 spin_unlock_irqrestore(&dev->lock, flags);
1516 1512
1517 dev->driver = NULL; 1513 dev->driver = NULL;
1518 1514
1519 dev_dbg(dev->dev, "unregistered driver '%s'\n", driver->driver.name);
1520 return 0; 1515 return 0;
1521} 1516}
1522 1517
@@ -1987,17 +1982,42 @@ net2272_handle_stat1_irqs(struct net2272 *dev, u8 stat)
1987 mask = (1 << USB_HIGH_SPEED) | (1 << USB_FULL_SPEED); 1982 mask = (1 << USB_HIGH_SPEED) | (1 << USB_FULL_SPEED);
1988 1983
1989 if (stat & tmp) { 1984 if (stat & tmp) {
1985 bool reset = false;
1986 bool disconnect = false;
1987
1988 /*
1989 * Ignore disconnects and resets if the speed hasn't been set.
1990 * VBUS can bounce and there's always an initial reset.
1991 */
1990 net2272_write(dev, IRQSTAT1, tmp); 1992 net2272_write(dev, IRQSTAT1, tmp);
1991 if ((((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) && 1993 if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
1992 ((net2272_read(dev, USBCTL1) & mask) == 0)) 1994 if ((stat & (1 << VBUS_INTERRUPT)) &&
1993 || ((net2272_read(dev, USBCTL1) & (1 << VBUS_PIN)) 1995 (net2272_read(dev, USBCTL1) &
1994 == 0)) 1996 (1 << VBUS_PIN)) == 0) {
1995 && (dev->gadget.speed != USB_SPEED_UNKNOWN)) { 1997 disconnect = true;
1996 dev_dbg(dev->dev, "disconnect %s\n", 1998 dev_dbg(dev->dev, "disconnect %s\n",
1997 dev->driver->driver.name); 1999 dev->driver->driver.name);
1998 stop_activity(dev, dev->driver); 2000 } else if ((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) &&
1999 net2272_ep0_start(dev); 2001 (net2272_read(dev, USBCTL1) & mask)
2000 return; 2002 == 0) {
2003 reset = true;
2004 dev_dbg(dev->dev, "reset %s\n",
2005 dev->driver->driver.name);
2006 }
2007
2008 if (disconnect || reset) {
2009 stop_activity(dev, dev->driver);
2010 net2272_ep0_start(dev);
2011 spin_unlock(&dev->lock);
2012 if (reset)
2013 usb_gadget_udc_reset
2014 (&dev->gadget, dev->driver);
2015 else
2016 (dev->driver->disconnect)
2017 (&dev->gadget);
2018 spin_lock(&dev->lock);
2019 return;
2020 }
2001 } 2021 }
2002 stat &= ~tmp; 2022 stat &= ~tmp;
2003 2023
@@ -2200,18 +2220,8 @@ static void
2200net2272_remove(struct net2272 *dev) 2220net2272_remove(struct net2272 *dev)
2201{ 2221{
2202 usb_del_gadget_udc(&dev->gadget); 2222 usb_del_gadget_udc(&dev->gadget);
2203
2204 /* start with the driver above us */
2205 if (dev->driver) {
2206 /* should have been done already by driver model core */
2207 dev_warn(dev->dev, "pci remove, driver '%s' is still registered\n",
2208 dev->driver->driver.name);
2209 usb_gadget_unregister_driver(dev->driver);
2210 }
2211
2212 free_irq(dev->irq, dev); 2223 free_irq(dev->irq, dev);
2213 iounmap(dev->base_addr); 2224 iounmap(dev->base_addr);
2214
2215 device_remove_file(dev->dev, &dev_attr_registers); 2225 device_remove_file(dev->dev, &dev_attr_registers);
2216 2226
2217 dev_info(dev->dev, "unbind\n"); 2227 dev_info(dev->dev, "unbind\n");
diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c
index 8d13337e2dde..d6411e0a8e03 100644
--- a/drivers/usb/gadget/udc/net2280.c
+++ b/drivers/usb/gadget/udc/net2280.c
@@ -1118,10 +1118,10 @@ static void scan_dma_completions(struct net2280_ep *ep)
1118 break; 1118 break;
1119 } else if (!ep->is_in && 1119 } else if (!ep->is_in &&
1120 (req->req.length % ep->ep.maxpacket) != 0) { 1120 (req->req.length % ep->ep.maxpacket) != 0) {
1121 tmp = readl(&ep->regs->ep_stat);
1122 if (ep->dev->quirks & PLX_SUPERSPEED) 1121 if (ep->dev->quirks & PLX_SUPERSPEED)
1123 return dma_done(ep, req, tmp, 0); 1122 return dma_done(ep, req, tmp, 0);
1124 1123
1124 tmp = readl(&ep->regs->ep_stat);
1125 /* AVOID TROUBLE HERE by not issuing short reads from 1125 /* AVOID TROUBLE HERE by not issuing short reads from
1126 * your gadget driver. That helps avoids errata 0121, 1126 * your gadget driver. That helps avoids errata 0121,
1127 * 0122, and 0124; not all cases trigger the warning. 1127 * 0122, and 0124; not all cases trigger the warning.
@@ -1548,8 +1548,7 @@ static int net2280_pullup(struct usb_gadget *_gadget, int is_on)
1548 1548
1549static int net2280_start(struct usb_gadget *_gadget, 1549static int net2280_start(struct usb_gadget *_gadget,
1550 struct usb_gadget_driver *driver); 1550 struct usb_gadget_driver *driver);
1551static int net2280_stop(struct usb_gadget *_gadget, 1551static int net2280_stop(struct usb_gadget *_gadget);
1552 struct usb_gadget_driver *driver);
1553 1552
1554static const struct usb_gadget_ops net2280_ops = { 1553static const struct usb_gadget_ops net2280_ops = {
1555 .get_frame = net2280_get_frame, 1554 .get_frame = net2280_get_frame,
@@ -2397,11 +2396,6 @@ static int net2280_start(struct usb_gadget *_gadget,
2397 2396
2398 ep0_start(dev); 2397 ep0_start(dev);
2399 2398
2400 ep_dbg(dev, "%s ready, usbctl %08x stdrsp %08x\n",
2401 driver->driver.name,
2402 readl(&dev->usb->usbctl),
2403 readl(&dev->usb->stdrsp));
2404
2405 /* pci writes may still be posted */ 2399 /* pci writes may still be posted */
2406 return 0; 2400 return 0;
2407 2401
@@ -2437,8 +2431,7 @@ static void stop_activity(struct net2280 *dev, struct usb_gadget_driver *driver)
2437 usb_reinit(dev); 2431 usb_reinit(dev);
2438} 2432}
2439 2433
2440static int net2280_stop(struct usb_gadget *_gadget, 2434static int net2280_stop(struct usb_gadget *_gadget)
2441 struct usb_gadget_driver *driver)
2442{ 2435{
2443 struct net2280 *dev; 2436 struct net2280 *dev;
2444 unsigned long flags; 2437 unsigned long flags;
@@ -2446,11 +2439,9 @@ static int net2280_stop(struct usb_gadget *_gadget,
2446 dev = container_of(_gadget, struct net2280, gadget); 2439 dev = container_of(_gadget, struct net2280, gadget);
2447 2440
2448 spin_lock_irqsave(&dev->lock, flags); 2441 spin_lock_irqsave(&dev->lock, flags);
2449 stop_activity(dev, driver); 2442 stop_activity(dev, NULL);
2450 spin_unlock_irqrestore(&dev->lock, flags); 2443 spin_unlock_irqrestore(&dev->lock, flags);
2451 2444
2452 dev->driver = NULL;
2453
2454 net2280_led_active(dev, 0); 2445 net2280_led_active(dev, 0);
2455 2446
2456 /* Disable full-speed test mode */ 2447 /* Disable full-speed test mode */
@@ -2460,8 +2451,7 @@ static int net2280_stop(struct usb_gadget *_gadget,
2460 device_remove_file(&dev->pdev->dev, &dev_attr_function); 2451 device_remove_file(&dev->pdev->dev, &dev_attr_function);
2461 device_remove_file(&dev->pdev->dev, &dev_attr_queues); 2452 device_remove_file(&dev->pdev->dev, &dev_attr_queues);
2462 2453
2463 ep_dbg(dev, "unregistered driver '%s'\n", 2454 dev->driver = NULL;
2464 driver ? driver->driver.name : "");
2465 2455
2466 return 0; 2456 return 0;
2467} 2457}
@@ -3318,17 +3308,42 @@ static void handle_stat1_irqs(struct net2280 *dev, u32 stat)
3318 * only indicates a change in the reset state). 3308 * only indicates a change in the reset state).
3319 */ 3309 */
3320 if (stat & tmp) { 3310 if (stat & tmp) {
3311 bool reset = false;
3312 bool disconnect = false;
3313
3314 /*
3315 * Ignore disconnects and resets if the speed hasn't been set.
3316 * VBUS can bounce and there's always an initial reset.
3317 */
3321 writel(tmp, &dev->regs->irqstat1); 3318 writel(tmp, &dev->regs->irqstat1);
3322 if ((((stat & BIT(ROOT_PORT_RESET_INTERRUPT)) && 3319 if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
3323 ((readl(&dev->usb->usbstat) & mask) == 0)) || 3320 if ((stat & BIT(VBUS_INTERRUPT)) &&
3324 ((readl(&dev->usb->usbctl) & 3321 (readl(&dev->usb->usbctl) &
3325 BIT(VBUS_PIN)) == 0)) && 3322 BIT(VBUS_PIN)) == 0) {
3326 (dev->gadget.speed != USB_SPEED_UNKNOWN)) { 3323 disconnect = true;
3327 ep_dbg(dev, "disconnect %s\n", 3324 ep_dbg(dev, "disconnect %s\n",
3328 dev->driver->driver.name); 3325 dev->driver->driver.name);
3329 stop_activity(dev, dev->driver); 3326 } else if ((stat & BIT(ROOT_PORT_RESET_INTERRUPT)) &&
3330 ep0_start(dev); 3327 (readl(&dev->usb->usbstat) & mask)
3331 return; 3328 == 0) {
3329 reset = true;
3330 ep_dbg(dev, "reset %s\n",
3331 dev->driver->driver.name);
3332 }
3333
3334 if (disconnect || reset) {
3335 stop_activity(dev, dev->driver);
3336 ep0_start(dev);
3337 spin_unlock(&dev->lock);
3338 if (reset)
3339 usb_gadget_udc_reset
3340 (&dev->gadget, dev->driver);
3341 else
3342 (dev->driver->disconnect)
3343 (&dev->gadget);
3344 spin_lock(&dev->lock);
3345 return;
3346 }
3332 } 3347 }
3333 stat &= ~tmp; 3348 stat &= ~tmp;
3334 3349
diff --git a/drivers/usb/gadget/udc/omap_udc.c b/drivers/usb/gadget/udc/omap_udc.c
index dcdfea46003b..534b85c07feb 100644
--- a/drivers/usb/gadget/udc/omap_udc.c
+++ b/drivers/usb/gadget/udc/omap_udc.c
@@ -1311,8 +1311,7 @@ static int omap_pullup(struct usb_gadget *gadget, int is_on)
1311 1311
1312static int omap_udc_start(struct usb_gadget *g, 1312static int omap_udc_start(struct usb_gadget *g,
1313 struct usb_gadget_driver *driver); 1313 struct usb_gadget_driver *driver);
1314static int omap_udc_stop(struct usb_gadget *g, 1314static int omap_udc_stop(struct usb_gadget *g);
1315 struct usb_gadget_driver *driver);
1316 1315
1317static const struct usb_gadget_ops omap_gadget_ops = { 1316static const struct usb_gadget_ops omap_gadget_ops = {
1318 .get_frame = omap_get_frame, 1317 .get_frame = omap_get_frame,
@@ -2102,8 +2101,7 @@ done:
2102 return status; 2101 return status;
2103} 2102}
2104 2103
2105static int omap_udc_stop(struct usb_gadget *g, 2104static int omap_udc_stop(struct usb_gadget *g)
2106 struct usb_gadget_driver *driver)
2107{ 2105{
2108 unsigned long flags; 2106 unsigned long flags;
2109 int status = -ENODEV; 2107 int status = -ENODEV;
diff --git a/drivers/usb/gadget/udc/pch_udc.c b/drivers/usb/gadget/udc/pch_udc.c
index ccbe3d4a2a50..1c7379ac2379 100644
--- a/drivers/usb/gadget/udc/pch_udc.c
+++ b/drivers/usb/gadget/udc/pch_udc.c
@@ -1240,8 +1240,8 @@ static int pch_udc_pcd_vbus_draw(struct usb_gadget *gadget, unsigned int mA)
1240 1240
1241static int pch_udc_start(struct usb_gadget *g, 1241static int pch_udc_start(struct usb_gadget *g,
1242 struct usb_gadget_driver *driver); 1242 struct usb_gadget_driver *driver);
1243static int pch_udc_stop(struct usb_gadget *g, 1243static int pch_udc_stop(struct usb_gadget *g);
1244 struct usb_gadget_driver *driver); 1244
1245static const struct usb_gadget_ops pch_udc_ops = { 1245static const struct usb_gadget_ops pch_udc_ops = {
1246 .get_frame = pch_udc_pcd_get_frame, 1246 .get_frame = pch_udc_pcd_get_frame,
1247 .wakeup = pch_udc_pcd_wakeup, 1247 .wakeup = pch_udc_pcd_wakeup,
@@ -2592,9 +2592,9 @@ static void pch_udc_svc_ur_interrupt(struct pch_udc_dev *dev)
2592 /* Complete request queue */ 2592 /* Complete request queue */
2593 empty_req_queue(ep); 2593 empty_req_queue(ep);
2594 } 2594 }
2595 if (dev->driver && dev->driver->disconnect) { 2595 if (dev->driver) {
2596 spin_unlock(&dev->lock); 2596 spin_unlock(&dev->lock);
2597 dev->driver->disconnect(&dev->gadget); 2597 usb_gadget_udc_reset(&dev->gadget, dev->driver);
2598 spin_lock(&dev->lock); 2598 spin_lock(&dev->lock);
2599 } 2599 }
2600} 2600}
@@ -3008,8 +3008,7 @@ static int pch_udc_start(struct usb_gadget *g,
3008 return 0; 3008 return 0;
3009} 3009}
3010 3010
3011static int pch_udc_stop(struct usb_gadget *g, 3011static int pch_udc_stop(struct usb_gadget *g)
3012 struct usb_gadget_driver *driver)
3013{ 3012{
3014 struct pch_udc_dev *dev = to_pch_udc(g); 3013 struct pch_udc_dev *dev = to_pch_udc(g);
3015 3014
diff --git a/drivers/usb/gadget/udc/pxa25x_udc.c b/drivers/usb/gadget/udc/pxa25x_udc.c
index 42f7eeb8ff6f..347a05b5afc1 100644
--- a/drivers/usb/gadget/udc/pxa25x_udc.c
+++ b/drivers/usb/gadget/udc/pxa25x_udc.c
@@ -998,8 +998,7 @@ static int pxa25x_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
998 998
999static int pxa25x_udc_start(struct usb_gadget *g, 999static int pxa25x_udc_start(struct usb_gadget *g,
1000 struct usb_gadget_driver *driver); 1000 struct usb_gadget_driver *driver);
1001static int pxa25x_udc_stop(struct usb_gadget *g, 1001static int pxa25x_udc_stop(struct usb_gadget *g);
1002 struct usb_gadget_driver *driver);
1003 1002
1004static const struct usb_gadget_ops pxa25x_udc_ops = { 1003static const struct usb_gadget_ops pxa25x_udc_ops = {
1005 .get_frame = pxa25x_udc_get_frame, 1004 .get_frame = pxa25x_udc_get_frame,
@@ -1135,11 +1134,7 @@ static const struct file_operations debug_fops = {
1135 dev->debugfs_udc = debugfs_create_file(dev->gadget.name, \ 1134 dev->debugfs_udc = debugfs_create_file(dev->gadget.name, \
1136 S_IRUGO, NULL, dev, &debug_fops); \ 1135 S_IRUGO, NULL, dev, &debug_fops); \
1137 } while (0) 1136 } while (0)
1138#define remove_debug_files(dev) \ 1137#define remove_debug_files(dev) debugfs_remove(dev->debugfs_udc)
1139 do { \
1140 if (dev->debugfs_udc) \
1141 debugfs_remove(dev->debugfs_udc); \
1142 } while (0)
1143 1138
1144#else /* !CONFIG_USB_GADGET_DEBUG_FILES */ 1139#else /* !CONFIG_USB_GADGET_DEBUG_FILES */
1145 1140
@@ -1285,6 +1280,33 @@ bind_fail:
1285} 1280}
1286 1281
1287static void 1282static void
1283reset_gadget(struct pxa25x_udc *dev, struct usb_gadget_driver *driver)
1284{
1285 int i;
1286
1287 /* don't disconnect drivers more than once */
1288 if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1289 driver = NULL;
1290 dev->gadget.speed = USB_SPEED_UNKNOWN;
1291
1292 /* prevent new request submissions, kill any outstanding requests */
1293 for (i = 0; i < PXA_UDC_NUM_ENDPOINTS; i++) {
1294 struct pxa25x_ep *ep = &dev->ep[i];
1295
1296 ep->stopped = 1;
1297 nuke(ep, -ESHUTDOWN);
1298 }
1299 del_timer_sync(&dev->timer);
1300
1301 /* report reset; the driver is already quiesced */
1302 if (driver)
1303 usb_gadget_udc_reset(&dev->gadget, driver);
1304
1305 /* re-init driver-visible data structures */
1306 udc_reinit(dev);
1307}
1308
1309static void
1288stop_activity(struct pxa25x_udc *dev, struct usb_gadget_driver *driver) 1310stop_activity(struct pxa25x_udc *dev, struct usb_gadget_driver *driver)
1289{ 1311{
1290 int i; 1312 int i;
@@ -1311,15 +1333,14 @@ stop_activity(struct pxa25x_udc *dev, struct usb_gadget_driver *driver)
1311 udc_reinit(dev); 1333 udc_reinit(dev);
1312} 1334}
1313 1335
1314static int pxa25x_udc_stop(struct usb_gadget*g, 1336static int pxa25x_udc_stop(struct usb_gadget*g)
1315 struct usb_gadget_driver *driver)
1316{ 1337{
1317 struct pxa25x_udc *dev = to_pxa25x(g); 1338 struct pxa25x_udc *dev = to_pxa25x(g);
1318 1339
1319 local_irq_disable(); 1340 local_irq_disable();
1320 dev->pullup = 0; 1341 dev->pullup = 0;
1321 pullup(dev); 1342 pullup(dev);
1322 stop_activity(dev, driver); 1343 stop_activity(dev, NULL);
1323 local_irq_enable(); 1344 local_irq_enable();
1324 1345
1325 if (!IS_ERR_OR_NULL(dev->transceiver)) 1346 if (!IS_ERR_OR_NULL(dev->transceiver))
@@ -1723,7 +1744,7 @@ pxa25x_udc_irq(int irq, void *_dev)
1723 /* reset driver and endpoints, 1744 /* reset driver and endpoints,
1724 * in case that's not yet done 1745 * in case that's not yet done
1725 */ 1746 */
1726 stop_activity (dev, dev->driver); 1747 reset_gadget(dev, dev->driver);
1727 1748
1728 } else { 1749 } else {
1729 DBG(DBG_VERBOSE, "USB reset end\n"); 1750 DBG(DBG_VERBOSE, "USB reset end\n");
diff --git a/drivers/usb/gadget/udc/pxa27x_udc.c b/drivers/usb/gadget/udc/pxa27x_udc.c
index 4868369eeec6..9b03fab13707 100644
--- a/drivers/usb/gadget/udc/pxa27x_udc.c
+++ b/drivers/usb/gadget/udc/pxa27x_udc.c
@@ -22,10 +22,13 @@
22#include <linux/clk.h> 22#include <linux/clk.h>
23#include <linux/irq.h> 23#include <linux/irq.h>
24#include <linux/gpio.h> 24#include <linux/gpio.h>
25#include <linux/gpio/consumer.h>
25#include <linux/slab.h> 26#include <linux/slab.h>
26#include <linux/prefetch.h> 27#include <linux/prefetch.h>
27#include <linux/byteorder/generic.h> 28#include <linux/byteorder/generic.h>
28#include <linux/platform_data/pxa2xx_udc.h> 29#include <linux/platform_data/pxa2xx_udc.h>
30#include <linux/of_device.h>
31#include <linux/of_gpio.h>
29 32
30#include <linux/usb.h> 33#include <linux/usb.h>
31#include <linux/usb/ch9.h> 34#include <linux/usb/ch9.h>
@@ -1507,18 +1510,13 @@ static struct usb_ep_ops pxa_ep_ops = {
1507 */ 1510 */
1508static void dplus_pullup(struct pxa_udc *udc, int on) 1511static void dplus_pullup(struct pxa_udc *udc, int on)
1509{ 1512{
1510 if (on) { 1513 if (udc->gpiod) {
1511 if (gpio_is_valid(udc->mach->gpio_pullup)) 1514 gpiod_set_value(udc->gpiod, on);
1512 gpio_set_value(udc->mach->gpio_pullup, 1515 } else if (udc->udc_command) {
1513 !udc->mach->gpio_pullup_inverted); 1516 if (on)
1514 if (udc->mach->udc_command) 1517 udc->udc_command(PXA2XX_UDC_CMD_CONNECT);
1515 udc->mach->udc_command(PXA2XX_UDC_CMD_CONNECT); 1518 else
1516 } else { 1519 udc->udc_command(PXA2XX_UDC_CMD_DISCONNECT);
1517 if (gpio_is_valid(udc->mach->gpio_pullup))
1518 gpio_set_value(udc->mach->gpio_pullup,
1519 udc->mach->gpio_pullup_inverted);
1520 if (udc->mach->udc_command)
1521 udc->mach->udc_command(PXA2XX_UDC_CMD_DISCONNECT);
1522 } 1520 }
1523 udc->pullup_on = on; 1521 udc->pullup_on = on;
1524} 1522}
@@ -1609,7 +1607,7 @@ static int pxa_udc_pullup(struct usb_gadget *_gadget, int is_active)
1609{ 1607{
1610 struct pxa_udc *udc = to_gadget_udc(_gadget); 1608 struct pxa_udc *udc = to_gadget_udc(_gadget);
1611 1609
1612 if (!gpio_is_valid(udc->mach->gpio_pullup) && !udc->mach->udc_command) 1610 if (!udc->gpiod && !udc->udc_command)
1613 return -EOPNOTSUPP; 1611 return -EOPNOTSUPP;
1614 1612
1615 dplus_pullup(udc, is_active); 1613 dplus_pullup(udc, is_active);
@@ -1671,8 +1669,7 @@ static int pxa_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
1671 1669
1672static int pxa27x_udc_start(struct usb_gadget *g, 1670static int pxa27x_udc_start(struct usb_gadget *g,
1673 struct usb_gadget_driver *driver); 1671 struct usb_gadget_driver *driver);
1674static int pxa27x_udc_stop(struct usb_gadget *g, 1672static int pxa27x_udc_stop(struct usb_gadget *g);
1675 struct usb_gadget_driver *driver);
1676 1673
1677static const struct usb_gadget_ops pxa_udc_ops = { 1674static const struct usb_gadget_ops pxa_udc_ops = {
1678 .get_frame = pxa_udc_get_frame, 1675 .get_frame = pxa_udc_get_frame,
@@ -1701,10 +1698,10 @@ static void udc_disable(struct pxa_udc *udc)
1701 udc_writel(udc, UDCICR1, 0); 1698 udc_writel(udc, UDCICR1, 0);
1702 1699
1703 udc_clear_mask_UDCCR(udc, UDCCR_UDE); 1700 udc_clear_mask_UDCCR(udc, UDCCR_UDE);
1704 clk_disable(udc->clk);
1705 1701
1706 ep0_idle(udc); 1702 ep0_idle(udc);
1707 udc->gadget.speed = USB_SPEED_UNKNOWN; 1703 udc->gadget.speed = USB_SPEED_UNKNOWN;
1704 clk_disable(udc->clk);
1708 1705
1709 udc->enabled = 0; 1706 udc->enabled = 0;
1710} 1707}
@@ -1757,16 +1754,16 @@ static void udc_enable(struct pxa_udc *udc)
1757 if (udc->enabled) 1754 if (udc->enabled)
1758 return; 1755 return;
1759 1756
1757 clk_enable(udc->clk);
1760 udc_writel(udc, UDCICR0, 0); 1758 udc_writel(udc, UDCICR0, 0);
1761 udc_writel(udc, UDCICR1, 0); 1759 udc_writel(udc, UDCICR1, 0);
1762 udc_clear_mask_UDCCR(udc, UDCCR_UDE); 1760 udc_clear_mask_UDCCR(udc, UDCCR_UDE);
1763 1761
1764 clk_enable(udc->clk);
1765
1766 ep0_idle(udc); 1762 ep0_idle(udc);
1767 udc->gadget.speed = USB_SPEED_FULL; 1763 udc->gadget.speed = USB_SPEED_FULL;
1768 memset(&udc->stats, 0, sizeof(udc->stats)); 1764 memset(&udc->stats, 0, sizeof(udc->stats));
1769 1765
1766 pxa_eps_setup(udc);
1770 udc_set_mask_UDCCR(udc, UDCCR_UDE); 1767 udc_set_mask_UDCCR(udc, UDCCR_UDE);
1771 ep_write_UDCCSR(&udc->pxa_ep[0], UDCCSR0_ACM); 1768 ep_write_UDCCSR(&udc->pxa_ep[0], UDCCSR0_ACM);
1772 udelay(2); 1769 udelay(2);
@@ -1859,12 +1856,11 @@ static void stop_activity(struct pxa_udc *udc, struct usb_gadget_driver *driver)
1859 * 1856 *
1860 * Returns 0 if no error, -ENODEV, -EINVAL otherwise 1857 * Returns 0 if no error, -ENODEV, -EINVAL otherwise
1861 */ 1858 */
1862static int pxa27x_udc_stop(struct usb_gadget *g, 1859static int pxa27x_udc_stop(struct usb_gadget *g)
1863 struct usb_gadget_driver *driver)
1864{ 1860{
1865 struct pxa_udc *udc = to_pxa(g); 1861 struct pxa_udc *udc = to_pxa(g);
1866 1862
1867 stop_activity(udc, driver); 1863 stop_activity(udc, NULL);
1868 udc_disable(udc); 1864 udc_disable(udc);
1869 dplus_pullup(udc, 0); 1865 dplus_pullup(udc, 0);
1870 1866
@@ -2404,6 +2400,14 @@ static struct pxa_udc memory = {
2404 } 2400 }
2405}; 2401};
2406 2402
2403#if defined(CONFIG_OF)
2404static struct of_device_id udc_pxa_dt_ids[] = {
2405 { .compatible = "marvell,pxa270-udc" },
2406 {}
2407};
2408MODULE_DEVICE_TABLE(of, udc_pxa_dt_ids);
2409#endif
2410
2407/** 2411/**
2408 * pxa_udc_probe - probes the udc device 2412 * pxa_udc_probe - probes the udc device
2409 * @_dev: platform device 2413 * @_dev: platform device
@@ -2416,81 +2420,77 @@ static int pxa_udc_probe(struct platform_device *pdev)
2416 struct resource *regs; 2420 struct resource *regs;
2417 struct pxa_udc *udc = &memory; 2421 struct pxa_udc *udc = &memory;
2418 int retval = 0, gpio; 2422 int retval = 0, gpio;
2423 struct pxa2xx_udc_mach_info *mach = dev_get_platdata(&pdev->dev);
2424 unsigned long gpio_flags;
2425
2426 if (mach) {
2427 gpio_flags = mach->gpio_pullup_inverted ? GPIOF_ACTIVE_LOW : 0;
2428 gpio = mach->gpio_pullup;
2429 if (gpio_is_valid(gpio)) {
2430 retval = devm_gpio_request_one(&pdev->dev, gpio,
2431 gpio_flags,
2432 "USB D+ pullup");
2433 if (retval)
2434 return retval;
2435 udc->gpiod = gpio_to_desc(mach->gpio_pullup);
2436 }
2437 udc->udc_command = mach->udc_command;
2438 } else {
2439 udc->gpiod = devm_gpiod_get(&pdev->dev, NULL);
2440 }
2419 2441
2420 regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); 2442 regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2421 if (!regs) 2443 udc->regs = devm_ioremap_resource(&pdev->dev, regs);
2422 return -ENXIO; 2444 if (IS_ERR(udc->regs))
2445 return PTR_ERR(udc->regs);
2423 udc->irq = platform_get_irq(pdev, 0); 2446 udc->irq = platform_get_irq(pdev, 0);
2424 if (udc->irq < 0) 2447 if (udc->irq < 0)
2425 return udc->irq; 2448 return udc->irq;
2426 2449
2427 udc->dev = &pdev->dev; 2450 udc->dev = &pdev->dev;
2428 udc->mach = dev_get_platdata(&pdev->dev);
2429 udc->transceiver = usb_get_phy(USB_PHY_TYPE_USB2); 2451 udc->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
2430 2452
2431 gpio = udc->mach->gpio_pullup; 2453 if (IS_ERR(udc->gpiod)) {
2432 if (gpio_is_valid(gpio)) { 2454 dev_err(&pdev->dev, "Couldn't find or request D+ gpio : %ld\n",
2433 retval = gpio_request(gpio, "USB D+ pullup"); 2455 PTR_ERR(udc->gpiod));
2434 if (retval == 0) 2456 return PTR_ERR(udc->gpiod);
2435 gpio_direction_output(gpio,
2436 udc->mach->gpio_pullup_inverted);
2437 }
2438 if (retval) {
2439 dev_err(&pdev->dev, "Couldn't request gpio %d : %d\n",
2440 gpio, retval);
2441 return retval;
2442 } 2457 }
2458 if (udc->gpiod)
2459 gpiod_direction_output(udc->gpiod, 0);
2460
2461 udc->clk = devm_clk_get(&pdev->dev, NULL);
2462 if (IS_ERR(udc->clk))
2463 return PTR_ERR(udc->clk);
2443 2464
2444 udc->clk = clk_get(&pdev->dev, NULL);
2445 if (IS_ERR(udc->clk)) {
2446 retval = PTR_ERR(udc->clk);
2447 goto err_clk;
2448 }
2449 retval = clk_prepare(udc->clk); 2465 retval = clk_prepare(udc->clk);
2450 if (retval) 2466 if (retval)
2451 goto err_clk_prepare; 2467 return retval;
2452
2453 retval = -ENOMEM;
2454 udc->regs = ioremap(regs->start, resource_size(regs));
2455 if (!udc->regs) {
2456 dev_err(&pdev->dev, "Unable to map UDC I/O memory\n");
2457 goto err_map;
2458 }
2459 2468
2460 udc->vbus_sensed = 0; 2469 udc->vbus_sensed = 0;
2461 2470
2462 the_controller = udc; 2471 the_controller = udc;
2463 platform_set_drvdata(pdev, udc); 2472 platform_set_drvdata(pdev, udc);
2464 udc_init_data(udc); 2473 udc_init_data(udc);
2465 pxa_eps_setup(udc);
2466 2474
2467 /* irq setup after old hardware state is cleaned up */ 2475 /* irq setup after old hardware state is cleaned up */
2468 retval = request_irq(udc->irq, pxa_udc_irq, 2476 retval = devm_request_irq(&pdev->dev, udc->irq, pxa_udc_irq,
2469 IRQF_SHARED, driver_name, udc); 2477 IRQF_SHARED, driver_name, udc);
2470 if (retval != 0) { 2478 if (retval != 0) {
2471 dev_err(udc->dev, "%s: can't get irq %i, err %d\n", 2479 dev_err(udc->dev, "%s: can't get irq %i, err %d\n",
2472 driver_name, udc->irq, retval); 2480 driver_name, udc->irq, retval);
2473 goto err_irq; 2481 goto err;
2474 } 2482 }
2475 2483
2476 retval = usb_add_gadget_udc(&pdev->dev, &udc->gadget); 2484 retval = usb_add_gadget_udc(&pdev->dev, &udc->gadget);
2477 if (retval) 2485 if (retval)
2478 goto err_add_udc; 2486 goto err;
2479 2487
2480 pxa_init_debugfs(udc); 2488 pxa_init_debugfs(udc);
2481 2489 if (should_enable_udc(udc))
2490 udc_enable(udc);
2482 return 0; 2491 return 0;
2483 2492err:
2484err_add_udc:
2485 free_irq(udc->irq, udc);
2486err_irq:
2487 iounmap(udc->regs);
2488err_map:
2489 clk_unprepare(udc->clk); 2493 clk_unprepare(udc->clk);
2490err_clk_prepare:
2491 clk_put(udc->clk);
2492 udc->clk = NULL;
2493err_clk:
2494 return retval; 2494 return retval;
2495} 2495}
2496 2496
@@ -2501,22 +2501,15 @@ err_clk:
2501static int pxa_udc_remove(struct platform_device *_dev) 2501static int pxa_udc_remove(struct platform_device *_dev)
2502{ 2502{
2503 struct pxa_udc *udc = platform_get_drvdata(_dev); 2503 struct pxa_udc *udc = platform_get_drvdata(_dev);
2504 int gpio = udc->mach->gpio_pullup;
2505 2504
2506 usb_del_gadget_udc(&udc->gadget); 2505 usb_del_gadget_udc(&udc->gadget);
2507 usb_gadget_unregister_driver(udc->driver);
2508 free_irq(udc->irq, udc);
2509 pxa_cleanup_debugfs(udc); 2506 pxa_cleanup_debugfs(udc);
2510 if (gpio_is_valid(gpio))
2511 gpio_free(gpio);
2512 2507
2513 usb_put_phy(udc->transceiver); 2508 usb_put_phy(udc->transceiver);
2514 2509
2515 udc->transceiver = NULL; 2510 udc->transceiver = NULL;
2516 the_controller = NULL; 2511 the_controller = NULL;
2517 clk_unprepare(udc->clk); 2512 clk_unprepare(udc->clk);
2518 clk_put(udc->clk);
2519 iounmap(udc->regs);
2520 2513
2521 return 0; 2514 return 0;
2522} 2515}
@@ -2546,19 +2539,11 @@ extern void pxa27x_clear_otgph(void);
2546 */ 2539 */
2547static int pxa_udc_suspend(struct platform_device *_dev, pm_message_t state) 2540static int pxa_udc_suspend(struct platform_device *_dev, pm_message_t state)
2548{ 2541{
2549 int i;
2550 struct pxa_udc *udc = platform_get_drvdata(_dev); 2542 struct pxa_udc *udc = platform_get_drvdata(_dev);
2551 struct pxa_ep *ep; 2543 struct pxa_ep *ep;
2552 2544
2553 ep = &udc->pxa_ep[0]; 2545 ep = &udc->pxa_ep[0];
2554 udc->udccsr0 = udc_ep_readl(ep, UDCCSR); 2546 udc->udccsr0 = udc_ep_readl(ep, UDCCSR);
2555 for (i = 1; i < NR_PXA_ENDPOINTS; i++) {
2556 ep = &udc->pxa_ep[i];
2557 ep->udccsr_value = udc_ep_readl(ep, UDCCSR);
2558 ep->udccr_value = udc_ep_readl(ep, UDCCR);
2559 ep_dbg(ep, "udccsr:0x%03x, udccr:0x%x\n",
2560 ep->udccsr_value, ep->udccr_value);
2561 }
2562 2547
2563 udc_disable(udc); 2548 udc_disable(udc);
2564 udc->pullup_resume = udc->pullup_on; 2549 udc->pullup_resume = udc->pullup_on;
@@ -2576,19 +2561,11 @@ static int pxa_udc_suspend(struct platform_device *_dev, pm_message_t state)
2576 */ 2561 */
2577static int pxa_udc_resume(struct platform_device *_dev) 2562static int pxa_udc_resume(struct platform_device *_dev)
2578{ 2563{
2579 int i;
2580 struct pxa_udc *udc = platform_get_drvdata(_dev); 2564 struct pxa_udc *udc = platform_get_drvdata(_dev);
2581 struct pxa_ep *ep; 2565 struct pxa_ep *ep;
2582 2566
2583 ep = &udc->pxa_ep[0]; 2567 ep = &udc->pxa_ep[0];
2584 udc_ep_writel(ep, UDCCSR, udc->udccsr0 & (UDCCSR0_FST | UDCCSR0_DME)); 2568 udc_ep_writel(ep, UDCCSR, udc->udccsr0 & (UDCCSR0_FST | UDCCSR0_DME));
2585 for (i = 1; i < NR_PXA_ENDPOINTS; i++) {
2586 ep = &udc->pxa_ep[i];
2587 udc_ep_writel(ep, UDCCSR, ep->udccsr_value);
2588 udc_ep_writel(ep, UDCCR, ep->udccr_value);
2589 ep_dbg(ep, "udccsr:0x%03x, udccr:0x%x\n",
2590 ep->udccsr_value, ep->udccr_value);
2591 }
2592 2569
2593 dplus_pullup(udc, udc->pullup_resume); 2570 dplus_pullup(udc, udc->pullup_resume);
2594 if (should_enable_udc(udc)) 2571 if (should_enable_udc(udc))
@@ -2615,6 +2592,7 @@ static struct platform_driver udc_driver = {
2615 .driver = { 2592 .driver = {
2616 .name = "pxa27x-udc", 2593 .name = "pxa27x-udc",
2617 .owner = THIS_MODULE, 2594 .owner = THIS_MODULE,
2595 .of_match_table = of_match_ptr(udc_pxa_dt_ids),
2618 }, 2596 },
2619 .probe = pxa_udc_probe, 2597 .probe = pxa_udc_probe,
2620 .remove = pxa_udc_remove, 2598 .remove = pxa_udc_remove,
diff --git a/drivers/usb/gadget/udc/pxa27x_udc.h b/drivers/usb/gadget/udc/pxa27x_udc.h
index 28f2b53530f5..11e14232794b 100644
--- a/drivers/usb/gadget/udc/pxa27x_udc.h
+++ b/drivers/usb/gadget/udc/pxa27x_udc.h
@@ -420,7 +420,8 @@ struct udc_stats {
420 * @usb_gadget: udc gadget structure 420 * @usb_gadget: udc gadget structure
421 * @driver: bound gadget (zero, g_ether, g_mass_storage, ...) 421 * @driver: bound gadget (zero, g_ether, g_mass_storage, ...)
422 * @dev: device 422 * @dev: device
423 * @mach: machine info, used to activate specific GPIO 423 * @udc_command: machine specific function to activate D+ pullup
424 * @gpiod: gpio descriptor of gpio for D+ pullup (or NULL if none)
424 * @transceiver: external transceiver to handle vbus sense and D+ pullup 425 * @transceiver: external transceiver to handle vbus sense and D+ pullup
425 * @ep0state: control endpoint state machine state 426 * @ep0state: control endpoint state machine state
426 * @stats: statistics on udc usage 427 * @stats: statistics on udc usage
@@ -446,7 +447,8 @@ struct pxa_udc {
446 struct usb_gadget gadget; 447 struct usb_gadget gadget;
447 struct usb_gadget_driver *driver; 448 struct usb_gadget_driver *driver;
448 struct device *dev; 449 struct device *dev;
449 struct pxa2xx_udc_mach_info *mach; 450 void (*udc_command)(int);
451 struct gpio_desc *gpiod;
450 struct usb_phy *transceiver; 452 struct usb_phy *transceiver;
451 453
452 enum ep0_state ep0state; 454 enum ep0_state ep0state;
diff --git a/drivers/usb/gadget/udc/r8a66597-udc.c b/drivers/usb/gadget/udc/r8a66597-udc.c
index f8186613b53e..06870da0b988 100644
--- a/drivers/usb/gadget/udc/r8a66597-udc.c
+++ b/drivers/usb/gadget/udc/r8a66597-udc.c
@@ -1345,7 +1345,7 @@ static void irq_device_state(struct r8a66597 *r8a66597)
1345 if (dvsq == DS_DFLT) { 1345 if (dvsq == DS_DFLT) {
1346 /* bus reset */ 1346 /* bus reset */
1347 spin_unlock(&r8a66597->lock); 1347 spin_unlock(&r8a66597->lock);
1348 r8a66597->driver->disconnect(&r8a66597->gadget); 1348 usb_gadget_udc_reset(&r8a66597->gadget, r8a66597->driver);
1349 spin_lock(&r8a66597->lock); 1349 spin_lock(&r8a66597->lock);
1350 r8a66597_update_usb_speed(r8a66597); 1350 r8a66597_update_usb_speed(r8a66597);
1351 } 1351 }
@@ -1763,8 +1763,7 @@ static int r8a66597_start(struct usb_gadget *gadget,
1763 return 0; 1763 return 0;
1764} 1764}
1765 1765
1766static int r8a66597_stop(struct usb_gadget *gadget, 1766static int r8a66597_stop(struct usb_gadget *gadget)
1767 struct usb_gadget_driver *driver)
1768{ 1767{
1769 struct r8a66597 *r8a66597 = gadget_to_r8a66597(gadget); 1768 struct r8a66597 *r8a66597 = gadget_to_r8a66597(gadget);
1770 unsigned long flags; 1769 unsigned long flags;
@@ -1846,10 +1845,7 @@ static int r8a66597_sudmac_ioremap(struct r8a66597 *r8a66597,
1846 1845
1847 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sudmac"); 1846 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sudmac");
1848 r8a66597->sudmac_reg = devm_ioremap_resource(&pdev->dev, res); 1847 r8a66597->sudmac_reg = devm_ioremap_resource(&pdev->dev, res);
1849 if (IS_ERR(r8a66597->sudmac_reg)) 1848 return PTR_ERR_OR_ZERO(r8a66597->sudmac_reg);
1850 return PTR_ERR(r8a66597->sudmac_reg);
1851
1852 return 0;
1853} 1849}
1854 1850
1855static int r8a66597_probe(struct platform_device *pdev) 1851static int r8a66597_probe(struct platform_device *pdev)
diff --git a/drivers/usb/gadget/udc/s3c-hsudc.c b/drivers/usb/gadget/udc/s3c-hsudc.c
index dfbf55797360..97d3a9144381 100644
--- a/drivers/usb/gadget/udc/s3c-hsudc.c
+++ b/drivers/usb/gadget/udc/s3c-hsudc.c
@@ -1172,8 +1172,6 @@ static int s3c_hsudc_start(struct usb_gadget *gadget,
1172 } 1172 }
1173 1173
1174 enable_irq(hsudc->irq); 1174 enable_irq(hsudc->irq);
1175 dev_info(hsudc->dev, "bound driver %s\n", driver->driver.name);
1176
1177 s3c_hsudc_reconfig(hsudc); 1175 s3c_hsudc_reconfig(hsudc);
1178 1176
1179 pm_runtime_get_sync(hsudc->dev); 1177 pm_runtime_get_sync(hsudc->dev);
@@ -1190,8 +1188,7 @@ err_supplies:
1190 return ret; 1188 return ret;
1191} 1189}
1192 1190
1193static int s3c_hsudc_stop(struct usb_gadget *gadget, 1191static int s3c_hsudc_stop(struct usb_gadget *gadget)
1194 struct usb_gadget_driver *driver)
1195{ 1192{
1196 struct s3c_hsudc *hsudc = to_hsudc(gadget); 1193 struct s3c_hsudc *hsudc = to_hsudc(gadget);
1197 unsigned long flags; 1194 unsigned long flags;
@@ -1199,11 +1196,7 @@ static int s3c_hsudc_stop(struct usb_gadget *gadget,
1199 if (!hsudc) 1196 if (!hsudc)
1200 return -ENODEV; 1197 return -ENODEV;
1201 1198
1202 if (!driver || driver != hsudc->driver)
1203 return -EINVAL;
1204
1205 spin_lock_irqsave(&hsudc->lock, flags); 1199 spin_lock_irqsave(&hsudc->lock, flags);
1206 hsudc->driver = NULL;
1207 hsudc->gadget.speed = USB_SPEED_UNKNOWN; 1200 hsudc->gadget.speed = USB_SPEED_UNKNOWN;
1208 s3c_hsudc_uninit_phy(); 1201 s3c_hsudc_uninit_phy();
1209 1202
@@ -1220,9 +1213,8 @@ static int s3c_hsudc_stop(struct usb_gadget *gadget,
1220 disable_irq(hsudc->irq); 1213 disable_irq(hsudc->irq);
1221 1214
1222 regulator_bulk_disable(ARRAY_SIZE(hsudc->supplies), hsudc->supplies); 1215 regulator_bulk_disable(ARRAY_SIZE(hsudc->supplies), hsudc->supplies);
1216 hsudc->driver = NULL;
1223 1217
1224 dev_info(hsudc->dev, "unregistered gadget driver '%s'\n",
1225 driver->driver.name);
1226 return 0; 1218 return 0;
1227} 1219}
1228 1220
@@ -1267,10 +1259,8 @@ static int s3c_hsudc_probe(struct platform_device *pdev)
1267 hsudc = devm_kzalloc(&pdev->dev, sizeof(struct s3c_hsudc) + 1259 hsudc = devm_kzalloc(&pdev->dev, sizeof(struct s3c_hsudc) +
1268 sizeof(struct s3c_hsudc_ep) * pd->epnum, 1260 sizeof(struct s3c_hsudc_ep) * pd->epnum,
1269 GFP_KERNEL); 1261 GFP_KERNEL);
1270 if (!hsudc) { 1262 if (!hsudc)
1271 dev_err(dev, "cannot allocate memory\n");
1272 return -ENOMEM; 1263 return -ENOMEM;
1273 }
1274 1264
1275 platform_set_drvdata(pdev, dev); 1265 platform_set_drvdata(pdev, dev);
1276 hsudc->dev = dev; 1266 hsudc->dev = dev;
diff --git a/drivers/usb/gadget/udc/s3c2410_udc.c b/drivers/usb/gadget/udc/s3c2410_udc.c
index ff423d15beff..2a8e36d31488 100644
--- a/drivers/usb/gadget/udc/s3c2410_udc.c
+++ b/drivers/usb/gadget/udc/s3c2410_udc.c
@@ -1541,8 +1541,7 @@ static int s3c2410_vbus_draw(struct usb_gadget *_gadget, unsigned ma)
1541 1541
1542static int s3c2410_udc_start(struct usb_gadget *g, 1542static int s3c2410_udc_start(struct usb_gadget *g,
1543 struct usb_gadget_driver *driver); 1543 struct usb_gadget_driver *driver);
1544static int s3c2410_udc_stop(struct usb_gadget *g, 1544static int s3c2410_udc_stop(struct usb_gadget *g);
1545 struct usb_gadget_driver *driver);
1546 1545
1547static const struct usb_gadget_ops s3c2410_ops = { 1546static const struct usb_gadget_ops s3c2410_ops = {
1548 .get_frame = s3c2410_udc_get_frame, 1547 .get_frame = s3c2410_udc_get_frame,
@@ -1683,8 +1682,7 @@ static int s3c2410_udc_start(struct usb_gadget *g,
1683 return 0; 1682 return 0;
1684} 1683}
1685 1684
1686static int s3c2410_udc_stop(struct usb_gadget *g, 1685static int s3c2410_udc_stop(struct usb_gadget *g)
1687 struct usb_gadget_driver *driver)
1688{ 1686{
1689 struct s3c2410_udc *udc = to_s3c2410(g); 1687 struct s3c2410_udc *udc = to_s3c2410(g);
1690 1688
diff --git a/drivers/usb/gadget/udc/udc-core.c b/drivers/usb/gadget/udc/udc-core.c
index f2054659f25b..e31d574d8860 100644
--- a/drivers/usb/gadget/udc/udc-core.c
+++ b/drivers/usb/gadget/udc/udc-core.c
@@ -174,8 +174,7 @@ EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
174 174
175/** 175/**
176 * usb_gadget_udc_start - tells usb device controller to start up 176 * usb_gadget_udc_start - tells usb device controller to start up
177 * @gadget: The gadget we want to get started 177 * @udc: The UDC to be started
178 * @driver: The driver we want to bind to @gadget
179 * 178 *
180 * This call is issued by the UDC Class driver when it's about 179 * This call is issued by the UDC Class driver when it's about
181 * to register a gadget driver to the device controller, before 180 * to register a gadget driver to the device controller, before
@@ -186,10 +185,9 @@ EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
186 * 185 *
187 * Returns zero on success, else negative errno. 186 * Returns zero on success, else negative errno.
188 */ 187 */
189static inline int usb_gadget_udc_start(struct usb_gadget *gadget, 188static inline int usb_gadget_udc_start(struct usb_udc *udc)
190 struct usb_gadget_driver *driver)
191{ 189{
192 return gadget->ops->udc_start(gadget, driver); 190 return udc->gadget->ops->udc_start(udc->gadget, udc->driver);
193} 191}
194 192
195/** 193/**
@@ -204,10 +202,9 @@ static inline int usb_gadget_udc_start(struct usb_gadget *gadget,
204 * far as powering off UDC completely and disable its data 202 * far as powering off UDC completely and disable its data
205 * line pullups. 203 * line pullups.
206 */ 204 */
207static inline void usb_gadget_udc_stop(struct usb_gadget *gadget, 205static inline void usb_gadget_udc_stop(struct usb_udc *udc)
208 struct usb_gadget_driver *driver)
209{ 206{
210 gadget->ops->udc_stop(gadget, driver); 207 udc->gadget->ops->udc_stop(udc->gadget);
211} 208}
212 209
213/** 210/**
@@ -328,14 +325,14 @@ EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
328static void usb_gadget_remove_driver(struct usb_udc *udc) 325static void usb_gadget_remove_driver(struct usb_udc *udc)
329{ 326{
330 dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n", 327 dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
331 udc->gadget->name); 328 udc->driver->function);
332 329
333 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE); 330 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
334 331
335 usb_gadget_disconnect(udc->gadget); 332 usb_gadget_disconnect(udc->gadget);
336 udc->driver->disconnect(udc->gadget); 333 udc->driver->disconnect(udc->gadget);
337 udc->driver->unbind(udc->gadget); 334 udc->driver->unbind(udc->gadget);
338 usb_gadget_udc_stop(udc->gadget, NULL); 335 usb_gadget_udc_stop(udc);
339 336
340 udc->driver = NULL; 337 udc->driver = NULL;
341 udc->dev.driver = NULL; 338 udc->dev.driver = NULL;
@@ -395,7 +392,7 @@ static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *dri
395 ret = driver->bind(udc->gadget, driver); 392 ret = driver->bind(udc->gadget, driver);
396 if (ret) 393 if (ret)
397 goto err1; 394 goto err1;
398 ret = usb_gadget_udc_start(udc->gadget, driver); 395 ret = usb_gadget_udc_start(udc);
399 if (ret) { 396 if (ret) {
400 driver->unbind(udc->gadget); 397 driver->unbind(udc->gadget);
401 goto err1; 398 goto err1;
@@ -414,7 +411,7 @@ err1:
414 return ret; 411 return ret;
415} 412}
416 413
417int udc_attach_driver(const char *name, struct usb_gadget_driver *driver) 414int usb_udc_attach_driver(const char *name, struct usb_gadget_driver *driver)
418{ 415{
419 struct usb_udc *udc = NULL; 416 struct usb_udc *udc = NULL;
420 int ret = -ENODEV; 417 int ret = -ENODEV;
@@ -438,7 +435,7 @@ out:
438 mutex_unlock(&udc_lock); 435 mutex_unlock(&udc_lock);
439 return ret; 436 return ret;
440} 437}
441EXPORT_SYMBOL_GPL(udc_attach_driver); 438EXPORT_SYMBOL_GPL(usb_udc_attach_driver);
442 439
443int usb_gadget_probe_driver(struct usb_gadget_driver *driver) 440int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
444{ 441{
@@ -513,11 +510,12 @@ static ssize_t usb_udc_softconn_store(struct device *dev,
513 } 510 }
514 511
515 if (sysfs_streq(buf, "connect")) { 512 if (sysfs_streq(buf, "connect")) {
516 usb_gadget_udc_start(udc->gadget, udc->driver); 513 usb_gadget_udc_start(udc);
517 usb_gadget_connect(udc->gadget); 514 usb_gadget_connect(udc->gadget);
518 } else if (sysfs_streq(buf, "disconnect")) { 515 } else if (sysfs_streq(buf, "disconnect")) {
519 usb_gadget_disconnect(udc->gadget); 516 usb_gadget_disconnect(udc->gadget);
520 usb_gadget_udc_stop(udc->gadget, udc->driver); 517 udc->driver->disconnect(udc->gadget);
518 usb_gadget_udc_stop(udc);
521 } else { 519 } else {
522 dev_err(dev, "unsupported command '%s'\n", buf); 520 dev_err(dev, "unsupported command '%s'\n", buf);
523 return -EINVAL; 521 return -EINVAL;
diff --git a/drivers/usb/gadget/udc/udc-xilinx.c b/drivers/usb/gadget/udc/udc-xilinx.c
index ed27e1687a4e..1eac56fc384d 100644
--- a/drivers/usb/gadget/udc/udc-xilinx.c
+++ b/drivers/usb/gadget/udc/udc-xilinx.c
@@ -1403,8 +1403,7 @@ err:
1403 * 1403 *
1404 * Return: zero always 1404 * Return: zero always
1405 */ 1405 */
1406static int xudc_stop(struct usb_gadget *gadget, 1406static int xudc_stop(struct usb_gadget *gadget)
1407 struct usb_gadget_driver *driver)
1408{ 1407{
1409 struct xusb_udc *udc = to_udc(gadget); 1408 struct xusb_udc *udc = to_udc(gadget);
1410 unsigned long flags; 1409 unsigned long flags;
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-31 22:45:18 -0400