diff options
author | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2015-03-24 17:57:49 -0400 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2015-03-24 17:57:49 -0400 |
commit | 1c41a9570a02cec80be5fb4f7f9cf206220d84a5 (patch) | |
tree | 21eeee43b0cb88415ea809bfab3f2b432fd5ac45 /drivers/usb/gadget | |
parent | cd0e075784f4bce97b4ed47d4b354f045e895546 (diff) | |
parent | 3e457371f436e89ce9239674828f9729a36b2595 (diff) |
Merge tag 'usb-for-v4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb into usb-next
Felipe writes:
usb: patches for v4.1 merge window
As usual, a big pile of commits. This time a total
of 111 non-merge commits.
Other than the usual set of cleanups and non-critical
fixes, we have some interesting work for AM335x's MUSB
babble recovery. Now that takes a lot less time and we
don't have to Reset MUSB all the time.
The printer gadget has been converted to configfs interface
and the atmel udc has learned suspend/resume with wakeup.
Signed-off-by: Felipe Balbi <balbi@ti.com>
Diffstat (limited to 'drivers/usb/gadget')
-rw-r--r-- | drivers/usb/gadget/Kconfig | 17 | ||||
-rw-r--r-- | drivers/usb/gadget/composite.c | 17 | ||||
-rw-r--r-- | drivers/usb/gadget/function/Makefile | 2 | ||||
-rw-r--r-- | drivers/usb/gadget/function/f_hid.c | 1 | ||||
-rw-r--r-- | drivers/usb/gadget/function/f_mass_storage.c | 2 | ||||
-rw-r--r-- | drivers/usb/gadget/function/f_printer.c | 1471 | ||||
-rw-r--r-- | drivers/usb/gadget/function/u_printer.h | 37 | ||||
-rw-r--r-- | drivers/usb/gadget/function/u_serial.c | 2 | ||||
-rw-r--r-- | drivers/usb/gadget/legacy/Kconfig | 1 | ||||
-rw-r--r-- | drivers/usb/gadget/legacy/printer.c | 1239 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/atmel_usba_udc.c | 212 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/atmel_usba_udc.h | 26 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/dummy_hcd.c | 2 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/goku_udc.c | 233 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/lpc32xx_udc.c | 15 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/net2280.c | 182 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/net2280.h | 2 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/pxa27x_udc.c | 132 | ||||
-rw-r--r-- | drivers/usb/gadget/udc/udc-core.c | 68 |
19 files changed, 2126 insertions, 1535 deletions
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig index b454d05be583..bcf83c0a6e62 100644 --- a/drivers/usb/gadget/Kconfig +++ b/drivers/usb/gadget/Kconfig | |||
@@ -196,6 +196,9 @@ config USB_F_MIDI | |||
196 | config USB_F_HID | 196 | config USB_F_HID |
197 | tristate | 197 | tristate |
198 | 198 | ||
199 | config USB_F_PRINTER | ||
200 | tristate | ||
201 | |||
199 | choice | 202 | choice |
200 | tristate "USB Gadget Drivers" | 203 | tristate "USB Gadget Drivers" |
201 | default USB_ETH | 204 | default USB_ETH |
@@ -434,6 +437,20 @@ config USB_CONFIGFS_F_UVC | |||
434 | device. It provides a userspace API to process UVC control requests | 437 | device. It provides a userspace API to process UVC control requests |
435 | and stream video data to the host. | 438 | and stream video data to the host. |
436 | 439 | ||
440 | config USB_CONFIGFS_F_PRINTER | ||
441 | bool "Printer function" | ||
442 | select USB_F_PRINTER | ||
443 | depends on USB_CONFIGFS | ||
444 | help | ||
445 | The Printer function channels data between the USB host and a | ||
446 | userspace program driving the print engine. The user space | ||
447 | program reads and writes the device file /dev/g_printer<X> to | ||
448 | receive or send printer data. It can use ioctl calls to | ||
449 | the device file to get or set printer status. | ||
450 | |||
451 | For more information, see Documentation/usb/gadget_printer.txt | ||
452 | which includes sample code for accessing the device file. | ||
453 | |||
437 | source "drivers/usb/gadget/legacy/Kconfig" | 454 | source "drivers/usb/gadget/legacy/Kconfig" |
438 | 455 | ||
439 | endchoice | 456 | endchoice |
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c index 13adfd1a3f54..4e3447bbd097 100644 --- a/drivers/usb/gadget/composite.c +++ b/drivers/usb/gadget/composite.c | |||
@@ -1161,11 +1161,11 @@ static struct usb_gadget_string_container *copy_gadget_strings( | |||
1161 | * This function will create a deep copy of usb_gadget_strings and usb_string | 1161 | * This function will create a deep copy of usb_gadget_strings and usb_string |
1162 | * and attach it to the cdev. The actual string (usb_string.s) will not be | 1162 | * and attach it to the cdev. The actual string (usb_string.s) will not be |
1163 | * copied but only a referenced will be made. The struct usb_gadget_strings | 1163 | * copied but only a referenced will be made. The struct usb_gadget_strings |
1164 | * array may contain multiple languges and should be NULL terminated. | 1164 | * array may contain multiple languages and should be NULL terminated. |
1165 | * The ->language pointer of each struct usb_gadget_strings has to contain the | 1165 | * The ->language pointer of each struct usb_gadget_strings has to contain the |
1166 | * same amount of entries. | 1166 | * same amount of entries. |
1167 | * For instance: sp[0] is en-US, sp[1] is es-ES. It is expected that the first | 1167 | * For instance: sp[0] is en-US, sp[1] is es-ES. It is expected that the first |
1168 | * usb_string entry of es-ES containts the translation of the first usb_string | 1168 | * usb_string entry of es-ES contains the translation of the first usb_string |
1169 | * entry of en-US. Therefore both entries become the same id assign. | 1169 | * entry of en-US. Therefore both entries become the same id assign. |
1170 | */ | 1170 | */ |
1171 | struct usb_string *usb_gstrings_attach(struct usb_composite_dev *cdev, | 1171 | struct usb_string *usb_gstrings_attach(struct usb_composite_dev *cdev, |
@@ -1472,6 +1472,13 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl) | |||
1472 | req->length = 0; | 1472 | req->length = 0; |
1473 | gadget->ep0->driver_data = cdev; | 1473 | gadget->ep0->driver_data = cdev; |
1474 | 1474 | ||
1475 | /* | ||
1476 | * Don't let non-standard requests match any of the cases below | ||
1477 | * by accident. | ||
1478 | */ | ||
1479 | if ((ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD) | ||
1480 | goto unknown; | ||
1481 | |||
1475 | switch (ctrl->bRequest) { | 1482 | switch (ctrl->bRequest) { |
1476 | 1483 | ||
1477 | /* we handle all standard USB descriptors */ | 1484 | /* we handle all standard USB descriptors */ |
@@ -1751,6 +1758,10 @@ unknown: | |||
1751 | * take such requests too, if that's ever needed: to work | 1758 | * take such requests too, if that's ever needed: to work |
1752 | * in config 0, etc. | 1759 | * in config 0, etc. |
1753 | */ | 1760 | */ |
1761 | list_for_each_entry(f, &cdev->config->functions, list) | ||
1762 | if (f->req_match && f->req_match(f, ctrl)) | ||
1763 | goto try_fun_setup; | ||
1764 | f = NULL; | ||
1754 | switch (ctrl->bRequestType & USB_RECIP_MASK) { | 1765 | switch (ctrl->bRequestType & USB_RECIP_MASK) { |
1755 | case USB_RECIP_INTERFACE: | 1766 | case USB_RECIP_INTERFACE: |
1756 | if (!cdev->config || intf >= MAX_CONFIG_INTERFACES) | 1767 | if (!cdev->config || intf >= MAX_CONFIG_INTERFACES) |
@@ -1768,7 +1779,7 @@ unknown: | |||
1768 | f = NULL; | 1779 | f = NULL; |
1769 | break; | 1780 | break; |
1770 | } | 1781 | } |
1771 | 1782 | try_fun_setup: | |
1772 | if (f && f->setup) | 1783 | if (f && f->setup) |
1773 | value = f->setup(f, ctrl); | 1784 | value = f->setup(f, ctrl); |
1774 | else { | 1785 | else { |
diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile index f71b1aaa0edf..bd7def576955 100644 --- a/drivers/usb/gadget/function/Makefile +++ b/drivers/usb/gadget/function/Makefile | |||
@@ -42,3 +42,5 @@ usb_f_midi-y := f_midi.o | |||
42 | obj-$(CONFIG_USB_F_MIDI) += usb_f_midi.o | 42 | obj-$(CONFIG_USB_F_MIDI) += usb_f_midi.o |
43 | usb_f_hid-y := f_hid.o | 43 | usb_f_hid-y := f_hid.o |
44 | obj-$(CONFIG_USB_F_HID) += usb_f_hid.o | 44 | obj-$(CONFIG_USB_F_HID) += usb_f_hid.o |
45 | usb_f_printer-y := f_printer.o | ||
46 | obj-$(CONFIG_USB_F_PRINTER) += usb_f_printer.o | ||
diff --git a/drivers/usb/gadget/function/f_hid.c b/drivers/usb/gadget/function/f_hid.c index a2612fb79eff..13dfc9915b1d 100644 --- a/drivers/usb/gadget/function/f_hid.c +++ b/drivers/usb/gadget/function/f_hid.c | |||
@@ -908,7 +908,6 @@ static void hidg_unbind(struct usb_configuration *c, struct usb_function *f) | |||
908 | 908 | ||
909 | /* disable/free request and end point */ | 909 | /* disable/free request and end point */ |
910 | usb_ep_disable(hidg->in_ep); | 910 | usb_ep_disable(hidg->in_ep); |
911 | usb_ep_dequeue(hidg->in_ep, hidg->req); | ||
912 | kfree(hidg->req->buf); | 911 | kfree(hidg->req->buf); |
913 | usb_ep_free_request(hidg->in_ep, hidg->req); | 912 | usb_ep_free_request(hidg->in_ep, hidg->req); |
914 | 913 | ||
diff --git a/drivers/usb/gadget/function/f_mass_storage.c b/drivers/usb/gadget/function/f_mass_storage.c index 49a2f19c2b87..3cc109f3c9c8 100644 --- a/drivers/usb/gadget/function/f_mass_storage.c +++ b/drivers/usb/gadget/function/f_mass_storage.c | |||
@@ -1085,7 +1085,7 @@ static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh) | |||
1085 | if (!curlun) { /* Unsupported LUNs are okay */ | 1085 | if (!curlun) { /* Unsupported LUNs are okay */ |
1086 | common->bad_lun_okay = 1; | 1086 | common->bad_lun_okay = 1; |
1087 | memset(buf, 0, 36); | 1087 | memset(buf, 0, 36); |
1088 | buf[0] = 0x7f; /* Unsupported, no device-type */ | 1088 | buf[0] = TYPE_NO_LUN; /* Unsupported, no device-type */ |
1089 | buf[4] = 31; /* Additional length */ | 1089 | buf[4] = 31; /* Additional length */ |
1090 | return 36; | 1090 | return 36; |
1091 | } | 1091 | } |
diff --git a/drivers/usb/gadget/function/f_printer.c b/drivers/usb/gadget/function/f_printer.c new file mode 100644 index 000000000000..44173df27273 --- /dev/null +++ b/drivers/usb/gadget/function/f_printer.c | |||
@@ -0,0 +1,1471 @@ | |||
1 | /* | ||
2 | * f_printer.c - USB printer function driver | ||
3 | * | ||
4 | * Copied from drivers/usb/gadget/legacy/printer.c, | ||
5 | * which was: | ||
6 | * | ||
7 | * printer.c -- Printer gadget driver | ||
8 | * | ||
9 | * Copyright (C) 2003-2005 David Brownell | ||
10 | * Copyright (C) 2006 Craig W. Nadler | ||
11 | * | ||
12 | * This program is free software; you can redistribute it and/or modify | ||
13 | * it under the terms of the GNU General Public License as published by | ||
14 | * the Free Software Foundation; either version 2 of the License, or | ||
15 | * (at your option) any later version. | ||
16 | */ | ||
17 | |||
18 | #include <linux/module.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/mutex.h> | ||
25 | #include <linux/errno.h> | ||
26 | #include <linux/init.h> | ||
27 | #include <linux/idr.h> | ||
28 | #include <linux/timer.h> | ||
29 | #include <linux/list.h> | ||
30 | #include <linux/interrupt.h> | ||
31 | #include <linux/device.h> | ||
32 | #include <linux/moduleparam.h> | ||
33 | #include <linux/fs.h> | ||
34 | #include <linux/poll.h> | ||
35 | #include <linux/types.h> | ||
36 | #include <linux/ctype.h> | ||
37 | #include <linux/cdev.h> | ||
38 | |||
39 | #include <asm/byteorder.h> | ||
40 | #include <linux/io.h> | ||
41 | #include <linux/irq.h> | ||
42 | #include <linux/uaccess.h> | ||
43 | #include <asm/unaligned.h> | ||
44 | |||
45 | #include <linux/usb/ch9.h> | ||
46 | #include <linux/usb/composite.h> | ||
47 | #include <linux/usb/gadget.h> | ||
48 | #include <linux/usb/g_printer.h> | ||
49 | |||
50 | #include "u_printer.h" | ||
51 | |||
52 | #define PNP_STRING_LEN 1024 | ||
53 | #define PRINTER_MINORS 4 | ||
54 | #define GET_DEVICE_ID 0 | ||
55 | #define GET_PORT_STATUS 1 | ||
56 | #define SOFT_RESET 2 | ||
57 | |||
58 | static int major, minors; | ||
59 | static struct class *usb_gadget_class; | ||
60 | static DEFINE_IDA(printer_ida); | ||
61 | static DEFINE_MUTEX(printer_ida_lock); /* protects access do printer_ida */ | ||
62 | |||
63 | /*-------------------------------------------------------------------------*/ | ||
64 | |||
65 | struct printer_dev { | ||
66 | spinlock_t lock; /* lock this structure */ | ||
67 | /* lock buffer lists during read/write calls */ | ||
68 | struct mutex lock_printer_io; | ||
69 | struct usb_gadget *gadget; | ||
70 | s8 interface; | ||
71 | struct usb_ep *in_ep, *out_ep; | ||
72 | |||
73 | struct list_head rx_reqs; /* List of free RX structs */ | ||
74 | struct list_head rx_reqs_active; /* List of Active RX xfers */ | ||
75 | struct list_head rx_buffers; /* List of completed xfers */ | ||
76 | /* wait until there is data to be read. */ | ||
77 | wait_queue_head_t rx_wait; | ||
78 | struct list_head tx_reqs; /* List of free TX structs */ | ||
79 | struct list_head tx_reqs_active; /* List of Active TX xfers */ | ||
80 | /* Wait until there are write buffers available to use. */ | ||
81 | wait_queue_head_t tx_wait; | ||
82 | /* Wait until all write buffers have been sent. */ | ||
83 | wait_queue_head_t tx_flush_wait; | ||
84 | struct usb_request *current_rx_req; | ||
85 | size_t current_rx_bytes; | ||
86 | u8 *current_rx_buf; | ||
87 | u8 printer_status; | ||
88 | u8 reset_printer; | ||
89 | int minor; | ||
90 | struct cdev printer_cdev; | ||
91 | u8 printer_cdev_open; | ||
92 | wait_queue_head_t wait; | ||
93 | unsigned q_len; | ||
94 | char *pnp_string; /* We don't own memory! */ | ||
95 | struct usb_function function; | ||
96 | }; | ||
97 | |||
98 | static inline struct printer_dev *func_to_printer(struct usb_function *f) | ||
99 | { | ||
100 | return container_of(f, struct printer_dev, function); | ||
101 | } | ||
102 | |||
103 | /*-------------------------------------------------------------------------*/ | ||
104 | |||
105 | /* | ||
106 | * DESCRIPTORS ... most are static, but strings and (full) configuration | ||
107 | * descriptors are built on demand. | ||
108 | */ | ||
109 | |||
110 | /* holds our biggest descriptor */ | ||
111 | #define USB_DESC_BUFSIZE 256 | ||
112 | #define USB_BUFSIZE 8192 | ||
113 | |||
114 | static struct usb_interface_descriptor intf_desc = { | ||
115 | .bLength = sizeof(intf_desc), | ||
116 | .bDescriptorType = USB_DT_INTERFACE, | ||
117 | .bNumEndpoints = 2, | ||
118 | .bInterfaceClass = USB_CLASS_PRINTER, | ||
119 | .bInterfaceSubClass = 1, /* Printer Sub-Class */ | ||
120 | .bInterfaceProtocol = 2, /* Bi-Directional */ | ||
121 | .iInterface = 0 | ||
122 | }; | ||
123 | |||
124 | static struct usb_endpoint_descriptor fs_ep_in_desc = { | ||
125 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
126 | .bDescriptorType = USB_DT_ENDPOINT, | ||
127 | .bEndpointAddress = USB_DIR_IN, | ||
128 | .bmAttributes = USB_ENDPOINT_XFER_BULK | ||
129 | }; | ||
130 | |||
131 | static struct usb_endpoint_descriptor fs_ep_out_desc = { | ||
132 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
133 | .bDescriptorType = USB_DT_ENDPOINT, | ||
134 | .bEndpointAddress = USB_DIR_OUT, | ||
135 | .bmAttributes = USB_ENDPOINT_XFER_BULK | ||
136 | }; | ||
137 | |||
138 | static struct usb_descriptor_header *fs_printer_function[] = { | ||
139 | (struct usb_descriptor_header *) &intf_desc, | ||
140 | (struct usb_descriptor_header *) &fs_ep_in_desc, | ||
141 | (struct usb_descriptor_header *) &fs_ep_out_desc, | ||
142 | NULL | ||
143 | }; | ||
144 | |||
145 | /* | ||
146 | * usb 2.0 devices need to expose both high speed and full speed | ||
147 | * descriptors, unless they only run at full speed. | ||
148 | */ | ||
149 | |||
150 | static struct usb_endpoint_descriptor hs_ep_in_desc = { | ||
151 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
152 | .bDescriptorType = USB_DT_ENDPOINT, | ||
153 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
154 | .wMaxPacketSize = cpu_to_le16(512) | ||
155 | }; | ||
156 | |||
157 | static struct usb_endpoint_descriptor hs_ep_out_desc = { | ||
158 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
159 | .bDescriptorType = USB_DT_ENDPOINT, | ||
160 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
161 | .wMaxPacketSize = cpu_to_le16(512) | ||
162 | }; | ||
163 | |||
164 | static struct usb_qualifier_descriptor dev_qualifier = { | ||
165 | .bLength = sizeof(dev_qualifier), | ||
166 | .bDescriptorType = USB_DT_DEVICE_QUALIFIER, | ||
167 | .bcdUSB = cpu_to_le16(0x0200), | ||
168 | .bDeviceClass = USB_CLASS_PRINTER, | ||
169 | .bNumConfigurations = 1 | ||
170 | }; | ||
171 | |||
172 | static struct usb_descriptor_header *hs_printer_function[] = { | ||
173 | (struct usb_descriptor_header *) &intf_desc, | ||
174 | (struct usb_descriptor_header *) &hs_ep_in_desc, | ||
175 | (struct usb_descriptor_header *) &hs_ep_out_desc, | ||
176 | NULL | ||
177 | }; | ||
178 | |||
179 | /* | ||
180 | * Added endpoint descriptors for 3.0 devices | ||
181 | */ | ||
182 | |||
183 | static struct usb_endpoint_descriptor ss_ep_in_desc = { | ||
184 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
185 | .bDescriptorType = USB_DT_ENDPOINT, | ||
186 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
187 | .wMaxPacketSize = cpu_to_le16(1024), | ||
188 | }; | ||
189 | |||
190 | static struct usb_ss_ep_comp_descriptor ss_ep_in_comp_desc = { | ||
191 | .bLength = sizeof(ss_ep_in_comp_desc), | ||
192 | .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, | ||
193 | }; | ||
194 | |||
195 | static struct usb_endpoint_descriptor ss_ep_out_desc = { | ||
196 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
197 | .bDescriptorType = USB_DT_ENDPOINT, | ||
198 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
199 | .wMaxPacketSize = cpu_to_le16(1024), | ||
200 | }; | ||
201 | |||
202 | static struct usb_ss_ep_comp_descriptor ss_ep_out_comp_desc = { | ||
203 | .bLength = sizeof(ss_ep_out_comp_desc), | ||
204 | .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, | ||
205 | }; | ||
206 | |||
207 | static struct usb_descriptor_header *ss_printer_function[] = { | ||
208 | (struct usb_descriptor_header *) &intf_desc, | ||
209 | (struct usb_descriptor_header *) &ss_ep_in_desc, | ||
210 | (struct usb_descriptor_header *) &ss_ep_in_comp_desc, | ||
211 | (struct usb_descriptor_header *) &ss_ep_out_desc, | ||
212 | (struct usb_descriptor_header *) &ss_ep_out_comp_desc, | ||
213 | NULL | ||
214 | }; | ||
215 | |||
216 | /* maxpacket and other transfer characteristics vary by speed. */ | ||
217 | static inline struct usb_endpoint_descriptor *ep_desc(struct usb_gadget *gadget, | ||
218 | struct usb_endpoint_descriptor *fs, | ||
219 | struct usb_endpoint_descriptor *hs, | ||
220 | struct usb_endpoint_descriptor *ss) | ||
221 | { | ||
222 | switch (gadget->speed) { | ||
223 | case USB_SPEED_SUPER: | ||
224 | return ss; | ||
225 | case USB_SPEED_HIGH: | ||
226 | return hs; | ||
227 | default: | ||
228 | return fs; | ||
229 | } | ||
230 | } | ||
231 | |||
232 | /*-------------------------------------------------------------------------*/ | ||
233 | |||
234 | static struct usb_request * | ||
235 | printer_req_alloc(struct usb_ep *ep, unsigned len, gfp_t gfp_flags) | ||
236 | { | ||
237 | struct usb_request *req; | ||
238 | |||
239 | req = usb_ep_alloc_request(ep, gfp_flags); | ||
240 | |||
241 | if (req != NULL) { | ||
242 | req->length = len; | ||
243 | req->buf = kmalloc(len, gfp_flags); | ||
244 | if (req->buf == NULL) { | ||
245 | usb_ep_free_request(ep, req); | ||
246 | return NULL; | ||
247 | } | ||
248 | } | ||
249 | |||
250 | return req; | ||
251 | } | ||
252 | |||
253 | static void | ||
254 | printer_req_free(struct usb_ep *ep, struct usb_request *req) | ||
255 | { | ||
256 | if (ep != NULL && req != NULL) { | ||
257 | kfree(req->buf); | ||
258 | usb_ep_free_request(ep, req); | ||
259 | } | ||
260 | } | ||
261 | |||
262 | /*-------------------------------------------------------------------------*/ | ||
263 | |||
264 | static void rx_complete(struct usb_ep *ep, struct usb_request *req) | ||
265 | { | ||
266 | struct printer_dev *dev = ep->driver_data; | ||
267 | int status = req->status; | ||
268 | unsigned long flags; | ||
269 | |||
270 | spin_lock_irqsave(&dev->lock, flags); | ||
271 | |||
272 | list_del_init(&req->list); /* Remode from Active List */ | ||
273 | |||
274 | switch (status) { | ||
275 | |||
276 | /* normal completion */ | ||
277 | case 0: | ||
278 | if (req->actual > 0) { | ||
279 | list_add_tail(&req->list, &dev->rx_buffers); | ||
280 | DBG(dev, "G_Printer : rx length %d\n", req->actual); | ||
281 | } else { | ||
282 | list_add(&req->list, &dev->rx_reqs); | ||
283 | } | ||
284 | break; | ||
285 | |||
286 | /* software-driven interface shutdown */ | ||
287 | case -ECONNRESET: /* unlink */ | ||
288 | case -ESHUTDOWN: /* disconnect etc */ | ||
289 | VDBG(dev, "rx shutdown, code %d\n", status); | ||
290 | list_add(&req->list, &dev->rx_reqs); | ||
291 | break; | ||
292 | |||
293 | /* for hardware automagic (such as pxa) */ | ||
294 | case -ECONNABORTED: /* endpoint reset */ | ||
295 | DBG(dev, "rx %s reset\n", ep->name); | ||
296 | list_add(&req->list, &dev->rx_reqs); | ||
297 | break; | ||
298 | |||
299 | /* data overrun */ | ||
300 | case -EOVERFLOW: | ||
301 | /* FALLTHROUGH */ | ||
302 | |||
303 | default: | ||
304 | DBG(dev, "rx status %d\n", status); | ||
305 | list_add(&req->list, &dev->rx_reqs); | ||
306 | break; | ||
307 | } | ||
308 | |||
309 | wake_up_interruptible(&dev->rx_wait); | ||
310 | spin_unlock_irqrestore(&dev->lock, flags); | ||
311 | } | ||
312 | |||
313 | static void tx_complete(struct usb_ep *ep, struct usb_request *req) | ||
314 | { | ||
315 | struct printer_dev *dev = ep->driver_data; | ||
316 | |||
317 | switch (req->status) { | ||
318 | default: | ||
319 | VDBG(dev, "tx err %d\n", req->status); | ||
320 | /* FALLTHROUGH */ | ||
321 | case -ECONNRESET: /* unlink */ | ||
322 | case -ESHUTDOWN: /* disconnect etc */ | ||
323 | break; | ||
324 | case 0: | ||
325 | break; | ||
326 | } | ||
327 | |||
328 | spin_lock(&dev->lock); | ||
329 | /* Take the request struct off the active list and put it on the | ||
330 | * free list. | ||
331 | */ | ||
332 | list_del_init(&req->list); | ||
333 | list_add(&req->list, &dev->tx_reqs); | ||
334 | wake_up_interruptible(&dev->tx_wait); | ||
335 | if (likely(list_empty(&dev->tx_reqs_active))) | ||
336 | wake_up_interruptible(&dev->tx_flush_wait); | ||
337 | |||
338 | spin_unlock(&dev->lock); | ||
339 | } | ||
340 | |||
341 | /*-------------------------------------------------------------------------*/ | ||
342 | |||
343 | static int | ||
344 | printer_open(struct inode *inode, struct file *fd) | ||
345 | { | ||
346 | struct printer_dev *dev; | ||
347 | unsigned long flags; | ||
348 | int ret = -EBUSY; | ||
349 | |||
350 | dev = container_of(inode->i_cdev, struct printer_dev, printer_cdev); | ||
351 | |||
352 | spin_lock_irqsave(&dev->lock, flags); | ||
353 | |||
354 | if (!dev->printer_cdev_open) { | ||
355 | dev->printer_cdev_open = 1; | ||
356 | fd->private_data = dev; | ||
357 | ret = 0; | ||
358 | /* Change the printer status to show that it's on-line. */ | ||
359 | dev->printer_status |= PRINTER_SELECTED; | ||
360 | } | ||
361 | |||
362 | spin_unlock_irqrestore(&dev->lock, flags); | ||
363 | |||
364 | DBG(dev, "printer_open returned %x\n", ret); | ||
365 | return ret; | ||
366 | } | ||
367 | |||
368 | static int | ||
369 | printer_close(struct inode *inode, struct file *fd) | ||
370 | { | ||
371 | struct printer_dev *dev = fd->private_data; | ||
372 | unsigned long flags; | ||
373 | |||
374 | spin_lock_irqsave(&dev->lock, flags); | ||
375 | dev->printer_cdev_open = 0; | ||
376 | fd->private_data = NULL; | ||
377 | /* Change printer status to show that the printer is off-line. */ | ||
378 | dev->printer_status &= ~PRINTER_SELECTED; | ||
379 | spin_unlock_irqrestore(&dev->lock, flags); | ||
380 | |||
381 | DBG(dev, "printer_close\n"); | ||
382 | |||
383 | return 0; | ||
384 | } | ||
385 | |||
386 | /* This function must be called with interrupts turned off. */ | ||
387 | static void | ||
388 | setup_rx_reqs(struct printer_dev *dev) | ||
389 | { | ||
390 | struct usb_request *req; | ||
391 | |||
392 | while (likely(!list_empty(&dev->rx_reqs))) { | ||
393 | int error; | ||
394 | |||
395 | req = container_of(dev->rx_reqs.next, | ||
396 | struct usb_request, list); | ||
397 | list_del_init(&req->list); | ||
398 | |||
399 | /* The USB Host sends us whatever amount of data it wants to | ||
400 | * so we always set the length field to the full USB_BUFSIZE. | ||
401 | * If the amount of data is more than the read() caller asked | ||
402 | * for it will be stored in the request buffer until it is | ||
403 | * asked for by read(). | ||
404 | */ | ||
405 | req->length = USB_BUFSIZE; | ||
406 | req->complete = rx_complete; | ||
407 | |||
408 | /* here, we unlock, and only unlock, to avoid deadlock. */ | ||
409 | spin_unlock(&dev->lock); | ||
410 | error = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC); | ||
411 | spin_lock(&dev->lock); | ||
412 | if (error) { | ||
413 | DBG(dev, "rx submit --> %d\n", error); | ||
414 | list_add(&req->list, &dev->rx_reqs); | ||
415 | break; | ||
416 | } | ||
417 | /* if the req is empty, then add it into dev->rx_reqs_active. */ | ||
418 | else if (list_empty(&req->list)) | ||
419 | list_add(&req->list, &dev->rx_reqs_active); | ||
420 | } | ||
421 | } | ||
422 | |||
423 | static ssize_t | ||
424 | printer_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr) | ||
425 | { | ||
426 | struct printer_dev *dev = fd->private_data; | ||
427 | unsigned long flags; | ||
428 | size_t size; | ||
429 | size_t bytes_copied; | ||
430 | struct usb_request *req; | ||
431 | /* This is a pointer to the current USB rx request. */ | ||
432 | struct usb_request *current_rx_req; | ||
433 | /* This is the number of bytes in the current rx buffer. */ | ||
434 | size_t current_rx_bytes; | ||
435 | /* This is a pointer to the current rx buffer. */ | ||
436 | u8 *current_rx_buf; | ||
437 | |||
438 | if (len == 0) | ||
439 | return -EINVAL; | ||
440 | |||
441 | DBG(dev, "printer_read trying to read %d bytes\n", (int)len); | ||
442 | |||
443 | mutex_lock(&dev->lock_printer_io); | ||
444 | spin_lock_irqsave(&dev->lock, flags); | ||
445 | |||
446 | /* We will use this flag later to check if a printer reset happened | ||
447 | * after we turn interrupts back on. | ||
448 | */ | ||
449 | dev->reset_printer = 0; | ||
450 | |||
451 | setup_rx_reqs(dev); | ||
452 | |||
453 | bytes_copied = 0; | ||
454 | current_rx_req = dev->current_rx_req; | ||
455 | current_rx_bytes = dev->current_rx_bytes; | ||
456 | current_rx_buf = dev->current_rx_buf; | ||
457 | dev->current_rx_req = NULL; | ||
458 | dev->current_rx_bytes = 0; | ||
459 | dev->current_rx_buf = NULL; | ||
460 | |||
461 | /* Check if there is any data in the read buffers. Please note that | ||
462 | * current_rx_bytes is the number of bytes in the current rx buffer. | ||
463 | * If it is zero then check if there are any other rx_buffers that | ||
464 | * are on the completed list. We are only out of data if all rx | ||
465 | * buffers are empty. | ||
466 | */ | ||
467 | if ((current_rx_bytes == 0) && | ||
468 | (likely(list_empty(&dev->rx_buffers)))) { | ||
469 | /* Turn interrupts back on before sleeping. */ | ||
470 | spin_unlock_irqrestore(&dev->lock, flags); | ||
471 | |||
472 | /* | ||
473 | * If no data is available check if this is a NON-Blocking | ||
474 | * call or not. | ||
475 | */ | ||
476 | if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) { | ||
477 | mutex_unlock(&dev->lock_printer_io); | ||
478 | return -EAGAIN; | ||
479 | } | ||
480 | |||
481 | /* Sleep until data is available */ | ||
482 | wait_event_interruptible(dev->rx_wait, | ||
483 | (likely(!list_empty(&dev->rx_buffers)))); | ||
484 | spin_lock_irqsave(&dev->lock, flags); | ||
485 | } | ||
486 | |||
487 | /* We have data to return then copy it to the caller's buffer.*/ | ||
488 | while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers))) | ||
489 | && len) { | ||
490 | if (current_rx_bytes == 0) { | ||
491 | req = container_of(dev->rx_buffers.next, | ||
492 | struct usb_request, list); | ||
493 | list_del_init(&req->list); | ||
494 | |||
495 | if (req->actual && req->buf) { | ||
496 | current_rx_req = req; | ||
497 | current_rx_bytes = req->actual; | ||
498 | current_rx_buf = req->buf; | ||
499 | } else { | ||
500 | list_add(&req->list, &dev->rx_reqs); | ||
501 | continue; | ||
502 | } | ||
503 | } | ||
504 | |||
505 | /* Don't leave irqs off while doing memory copies */ | ||
506 | spin_unlock_irqrestore(&dev->lock, flags); | ||
507 | |||
508 | if (len > current_rx_bytes) | ||
509 | size = current_rx_bytes; | ||
510 | else | ||
511 | size = len; | ||
512 | |||
513 | size -= copy_to_user(buf, current_rx_buf, size); | ||
514 | bytes_copied += size; | ||
515 | len -= size; | ||
516 | buf += size; | ||
517 | |||
518 | spin_lock_irqsave(&dev->lock, flags); | ||
519 | |||
520 | /* We've disconnected or reset so return. */ | ||
521 | if (dev->reset_printer) { | ||
522 | list_add(¤t_rx_req->list, &dev->rx_reqs); | ||
523 | spin_unlock_irqrestore(&dev->lock, flags); | ||
524 | mutex_unlock(&dev->lock_printer_io); | ||
525 | return -EAGAIN; | ||
526 | } | ||
527 | |||
528 | /* If we not returning all the data left in this RX request | ||
529 | * buffer then adjust the amount of data left in the buffer. | ||
530 | * Othewise if we are done with this RX request buffer then | ||
531 | * requeue it to get any incoming data from the USB host. | ||
532 | */ | ||
533 | if (size < current_rx_bytes) { | ||
534 | current_rx_bytes -= size; | ||
535 | current_rx_buf += size; | ||
536 | } else { | ||
537 | list_add(¤t_rx_req->list, &dev->rx_reqs); | ||
538 | current_rx_bytes = 0; | ||
539 | current_rx_buf = NULL; | ||
540 | current_rx_req = NULL; | ||
541 | } | ||
542 | } | ||
543 | |||
544 | dev->current_rx_req = current_rx_req; | ||
545 | dev->current_rx_bytes = current_rx_bytes; | ||
546 | dev->current_rx_buf = current_rx_buf; | ||
547 | |||
548 | spin_unlock_irqrestore(&dev->lock, flags); | ||
549 | mutex_unlock(&dev->lock_printer_io); | ||
550 | |||
551 | DBG(dev, "printer_read returned %d bytes\n", (int)bytes_copied); | ||
552 | |||
553 | if (bytes_copied) | ||
554 | return bytes_copied; | ||
555 | else | ||
556 | return -EAGAIN; | ||
557 | } | ||
558 | |||
559 | static ssize_t | ||
560 | printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr) | ||
561 | { | ||
562 | struct printer_dev *dev = fd->private_data; | ||
563 | unsigned long flags; | ||
564 | size_t size; /* Amount of data in a TX request. */ | ||
565 | size_t bytes_copied = 0; | ||
566 | struct usb_request *req; | ||
567 | |||
568 | DBG(dev, "printer_write trying to send %d bytes\n", (int)len); | ||
569 | |||
570 | if (len == 0) | ||
571 | return -EINVAL; | ||
572 | |||
573 | mutex_lock(&dev->lock_printer_io); | ||
574 | spin_lock_irqsave(&dev->lock, flags); | ||
575 | |||
576 | /* Check if a printer reset happens while we have interrupts on */ | ||
577 | dev->reset_printer = 0; | ||
578 | |||
579 | /* Check if there is any available write buffers */ | ||
580 | if (likely(list_empty(&dev->tx_reqs))) { | ||
581 | /* Turn interrupts back on before sleeping. */ | ||
582 | spin_unlock_irqrestore(&dev->lock, flags); | ||
583 | |||
584 | /* | ||
585 | * If write buffers are available check if this is | ||
586 | * a NON-Blocking call or not. | ||
587 | */ | ||
588 | if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) { | ||
589 | mutex_unlock(&dev->lock_printer_io); | ||
590 | return -EAGAIN; | ||
591 | } | ||
592 | |||
593 | /* Sleep until a write buffer is available */ | ||
594 | wait_event_interruptible(dev->tx_wait, | ||
595 | (likely(!list_empty(&dev->tx_reqs)))); | ||
596 | spin_lock_irqsave(&dev->lock, flags); | ||
597 | } | ||
598 | |||
599 | while (likely(!list_empty(&dev->tx_reqs)) && len) { | ||
600 | |||
601 | if (len > USB_BUFSIZE) | ||
602 | size = USB_BUFSIZE; | ||
603 | else | ||
604 | size = len; | ||
605 | |||
606 | req = container_of(dev->tx_reqs.next, struct usb_request, | ||
607 | list); | ||
608 | list_del_init(&req->list); | ||
609 | |||
610 | req->complete = tx_complete; | ||
611 | req->length = size; | ||
612 | |||
613 | /* Check if we need to send a zero length packet. */ | ||
614 | if (len > size) | ||
615 | /* They will be more TX requests so no yet. */ | ||
616 | req->zero = 0; | ||
617 | else | ||
618 | /* If the data amount is not a multiple of the | ||
619 | * maxpacket size then send a zero length packet. | ||
620 | */ | ||
621 | req->zero = ((len % dev->in_ep->maxpacket) == 0); | ||
622 | |||
623 | /* Don't leave irqs off while doing memory copies */ | ||
624 | spin_unlock_irqrestore(&dev->lock, flags); | ||
625 | |||
626 | if (copy_from_user(req->buf, buf, size)) { | ||
627 | list_add(&req->list, &dev->tx_reqs); | ||
628 | mutex_unlock(&dev->lock_printer_io); | ||
629 | return bytes_copied; | ||
630 | } | ||
631 | |||
632 | bytes_copied += size; | ||
633 | len -= size; | ||
634 | buf += size; | ||
635 | |||
636 | spin_lock_irqsave(&dev->lock, flags); | ||
637 | |||
638 | /* We've disconnected or reset so free the req and buffer */ | ||
639 | if (dev->reset_printer) { | ||
640 | list_add(&req->list, &dev->tx_reqs); | ||
641 | spin_unlock_irqrestore(&dev->lock, flags); | ||
642 | mutex_unlock(&dev->lock_printer_io); | ||
643 | return -EAGAIN; | ||
644 | } | ||
645 | |||
646 | if (usb_ep_queue(dev->in_ep, req, GFP_ATOMIC)) { | ||
647 | list_add(&req->list, &dev->tx_reqs); | ||
648 | spin_unlock_irqrestore(&dev->lock, flags); | ||
649 | mutex_unlock(&dev->lock_printer_io); | ||
650 | return -EAGAIN; | ||
651 | } | ||
652 | |||
653 | list_add(&req->list, &dev->tx_reqs_active); | ||
654 | |||
655 | } | ||
656 | |||
657 | spin_unlock_irqrestore(&dev->lock, flags); | ||
658 | mutex_unlock(&dev->lock_printer_io); | ||
659 | |||
660 | DBG(dev, "printer_write sent %d bytes\n", (int)bytes_copied); | ||
661 | |||
662 | if (bytes_copied) | ||
663 | return bytes_copied; | ||
664 | else | ||
665 | return -EAGAIN; | ||
666 | } | ||
667 | |||
668 | static int | ||
669 | printer_fsync(struct file *fd, loff_t start, loff_t end, int datasync) | ||
670 | { | ||
671 | struct printer_dev *dev = fd->private_data; | ||
672 | struct inode *inode = file_inode(fd); | ||
673 | unsigned long flags; | ||
674 | int tx_list_empty; | ||
675 | |||
676 | mutex_lock(&inode->i_mutex); | ||
677 | spin_lock_irqsave(&dev->lock, flags); | ||
678 | tx_list_empty = (likely(list_empty(&dev->tx_reqs))); | ||
679 | spin_unlock_irqrestore(&dev->lock, flags); | ||
680 | |||
681 | if (!tx_list_empty) { | ||
682 | /* Sleep until all data has been sent */ | ||
683 | wait_event_interruptible(dev->tx_flush_wait, | ||
684 | (likely(list_empty(&dev->tx_reqs_active)))); | ||
685 | } | ||
686 | mutex_unlock(&inode->i_mutex); | ||
687 | |||
688 | return 0; | ||
689 | } | ||
690 | |||
691 | static unsigned int | ||
692 | printer_poll(struct file *fd, poll_table *wait) | ||
693 | { | ||
694 | struct printer_dev *dev = fd->private_data; | ||
695 | unsigned long flags; | ||
696 | int status = 0; | ||
697 | |||
698 | mutex_lock(&dev->lock_printer_io); | ||
699 | spin_lock_irqsave(&dev->lock, flags); | ||
700 | setup_rx_reqs(dev); | ||
701 | spin_unlock_irqrestore(&dev->lock, flags); | ||
702 | mutex_unlock(&dev->lock_printer_io); | ||
703 | |||
704 | poll_wait(fd, &dev->rx_wait, wait); | ||
705 | poll_wait(fd, &dev->tx_wait, wait); | ||
706 | |||
707 | spin_lock_irqsave(&dev->lock, flags); | ||
708 | if (likely(!list_empty(&dev->tx_reqs))) | ||
709 | status |= POLLOUT | POLLWRNORM; | ||
710 | |||
711 | if (likely(dev->current_rx_bytes) || | ||
712 | likely(!list_empty(&dev->rx_buffers))) | ||
713 | status |= POLLIN | POLLRDNORM; | ||
714 | |||
715 | spin_unlock_irqrestore(&dev->lock, flags); | ||
716 | |||
717 | return status; | ||
718 | } | ||
719 | |||
720 | static long | ||
721 | printer_ioctl(struct file *fd, unsigned int code, unsigned long arg) | ||
722 | { | ||
723 | struct printer_dev *dev = fd->private_data; | ||
724 | unsigned long flags; | ||
725 | int status = 0; | ||
726 | |||
727 | DBG(dev, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code, arg); | ||
728 | |||
729 | /* handle ioctls */ | ||
730 | |||
731 | spin_lock_irqsave(&dev->lock, flags); | ||
732 | |||
733 | switch (code) { | ||
734 | case GADGET_GET_PRINTER_STATUS: | ||
735 | status = (int)dev->printer_status; | ||
736 | break; | ||
737 | case GADGET_SET_PRINTER_STATUS: | ||
738 | dev->printer_status = (u8)arg; | ||
739 | break; | ||
740 | default: | ||
741 | /* could not handle ioctl */ | ||
742 | DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n", | ||
743 | code); | ||
744 | status = -ENOTTY; | ||
745 | } | ||
746 | |||
747 | spin_unlock_irqrestore(&dev->lock, flags); | ||
748 | |||
749 | return status; | ||
750 | } | ||
751 | |||
752 | /* used after endpoint configuration */ | ||
753 | static const struct file_operations printer_io_operations = { | ||
754 | .owner = THIS_MODULE, | ||
755 | .open = printer_open, | ||
756 | .read = printer_read, | ||
757 | .write = printer_write, | ||
758 | .fsync = printer_fsync, | ||
759 | .poll = printer_poll, | ||
760 | .unlocked_ioctl = printer_ioctl, | ||
761 | .release = printer_close, | ||
762 | .llseek = noop_llseek, | ||
763 | }; | ||
764 | |||
765 | /*-------------------------------------------------------------------------*/ | ||
766 | |||
767 | static int | ||
768 | set_printer_interface(struct printer_dev *dev) | ||
769 | { | ||
770 | int result = 0; | ||
771 | |||
772 | dev->in_ep->desc = ep_desc(dev->gadget, &fs_ep_in_desc, &hs_ep_in_desc, | ||
773 | &ss_ep_in_desc); | ||
774 | dev->in_ep->driver_data = dev; | ||
775 | |||
776 | dev->out_ep->desc = ep_desc(dev->gadget, &fs_ep_out_desc, | ||
777 | &hs_ep_out_desc, &ss_ep_out_desc); | ||
778 | dev->out_ep->driver_data = dev; | ||
779 | |||
780 | result = usb_ep_enable(dev->in_ep); | ||
781 | if (result != 0) { | ||
782 | DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result); | ||
783 | goto done; | ||
784 | } | ||
785 | |||
786 | result = usb_ep_enable(dev->out_ep); | ||
787 | if (result != 0) { | ||
788 | DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result); | ||
789 | goto done; | ||
790 | } | ||
791 | |||
792 | done: | ||
793 | /* on error, disable any endpoints */ | ||
794 | if (result != 0) { | ||
795 | (void) usb_ep_disable(dev->in_ep); | ||
796 | (void) usb_ep_disable(dev->out_ep); | ||
797 | dev->in_ep->desc = NULL; | ||
798 | dev->out_ep->desc = NULL; | ||
799 | } | ||
800 | |||
801 | /* caller is responsible for cleanup on error */ | ||
802 | return result; | ||
803 | } | ||
804 | |||
805 | static void printer_reset_interface(struct printer_dev *dev) | ||
806 | { | ||
807 | if (dev->interface < 0) | ||
808 | return; | ||
809 | |||
810 | DBG(dev, "%s\n", __func__); | ||
811 | |||
812 | if (dev->in_ep->desc) | ||
813 | usb_ep_disable(dev->in_ep); | ||
814 | |||
815 | if (dev->out_ep->desc) | ||
816 | usb_ep_disable(dev->out_ep); | ||
817 | |||
818 | dev->in_ep->desc = NULL; | ||
819 | dev->out_ep->desc = NULL; | ||
820 | dev->interface = -1; | ||
821 | } | ||
822 | |||
823 | /* Change our operational Interface. */ | ||
824 | static int set_interface(struct printer_dev *dev, unsigned number) | ||
825 | { | ||
826 | int result = 0; | ||
827 | |||
828 | /* Free the current interface */ | ||
829 | printer_reset_interface(dev); | ||
830 | |||
831 | result = set_printer_interface(dev); | ||
832 | if (result) | ||
833 | printer_reset_interface(dev); | ||
834 | else | ||
835 | dev->interface = number; | ||
836 | |||
837 | if (!result) | ||
838 | INFO(dev, "Using interface %x\n", number); | ||
839 | |||
840 | return result; | ||
841 | } | ||
842 | |||
843 | static void printer_soft_reset(struct printer_dev *dev) | ||
844 | { | ||
845 | struct usb_request *req; | ||
846 | |||
847 | INFO(dev, "Received Printer Reset Request\n"); | ||
848 | |||
849 | if (usb_ep_disable(dev->in_ep)) | ||
850 | DBG(dev, "Failed to disable USB in_ep\n"); | ||
851 | if (usb_ep_disable(dev->out_ep)) | ||
852 | DBG(dev, "Failed to disable USB out_ep\n"); | ||
853 | |||
854 | if (dev->current_rx_req != NULL) { | ||
855 | list_add(&dev->current_rx_req->list, &dev->rx_reqs); | ||
856 | dev->current_rx_req = NULL; | ||
857 | } | ||
858 | dev->current_rx_bytes = 0; | ||
859 | dev->current_rx_buf = NULL; | ||
860 | dev->reset_printer = 1; | ||
861 | |||
862 | while (likely(!(list_empty(&dev->rx_buffers)))) { | ||
863 | req = container_of(dev->rx_buffers.next, struct usb_request, | ||
864 | list); | ||
865 | list_del_init(&req->list); | ||
866 | list_add(&req->list, &dev->rx_reqs); | ||
867 | } | ||
868 | |||
869 | while (likely(!(list_empty(&dev->rx_reqs_active)))) { | ||
870 | req = container_of(dev->rx_buffers.next, struct usb_request, | ||
871 | list); | ||
872 | list_del_init(&req->list); | ||
873 | list_add(&req->list, &dev->rx_reqs); | ||
874 | } | ||
875 | |||
876 | while (likely(!(list_empty(&dev->tx_reqs_active)))) { | ||
877 | req = container_of(dev->tx_reqs_active.next, | ||
878 | struct usb_request, list); | ||
879 | list_del_init(&req->list); | ||
880 | list_add(&req->list, &dev->tx_reqs); | ||
881 | } | ||
882 | |||
883 | if (usb_ep_enable(dev->in_ep)) | ||
884 | DBG(dev, "Failed to enable USB in_ep\n"); | ||
885 | if (usb_ep_enable(dev->out_ep)) | ||
886 | DBG(dev, "Failed to enable USB out_ep\n"); | ||
887 | |||
888 | wake_up_interruptible(&dev->rx_wait); | ||
889 | wake_up_interruptible(&dev->tx_wait); | ||
890 | wake_up_interruptible(&dev->tx_flush_wait); | ||
891 | } | ||
892 | |||
893 | /*-------------------------------------------------------------------------*/ | ||
894 | |||
895 | static bool gprinter_req_match(struct usb_function *f, | ||
896 | const struct usb_ctrlrequest *ctrl) | ||
897 | { | ||
898 | struct printer_dev *dev = func_to_printer(f); | ||
899 | u16 w_index = le16_to_cpu(ctrl->wIndex); | ||
900 | u16 w_value = le16_to_cpu(ctrl->wValue); | ||
901 | u16 w_length = le16_to_cpu(ctrl->wLength); | ||
902 | |||
903 | if ((ctrl->bRequestType & USB_RECIP_MASK) != USB_RECIP_INTERFACE || | ||
904 | (ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS) | ||
905 | return false; | ||
906 | |||
907 | switch (ctrl->bRequest) { | ||
908 | case GET_DEVICE_ID: | ||
909 | w_index >>= 8; | ||
910 | if (w_length <= PNP_STRING_LEN && | ||
911 | (USB_DIR_IN & ctrl->bRequestType)) | ||
912 | break; | ||
913 | return false; | ||
914 | case GET_PORT_STATUS: | ||
915 | if (!w_value && w_length == 1 && | ||
916 | (USB_DIR_IN & ctrl->bRequestType)) | ||
917 | break; | ||
918 | return false; | ||
919 | case SOFT_RESET: | ||
920 | if (!w_value && !w_length && | ||
921 | !(USB_DIR_IN & ctrl->bRequestType)) | ||
922 | break; | ||
923 | /* fall through */ | ||
924 | default: | ||
925 | return false; | ||
926 | } | ||
927 | return w_index == dev->interface; | ||
928 | } | ||
929 | |||
930 | /* | ||
931 | * The setup() callback implements all the ep0 functionality that's not | ||
932 | * handled lower down. | ||
933 | */ | ||
934 | static int printer_func_setup(struct usb_function *f, | ||
935 | const struct usb_ctrlrequest *ctrl) | ||
936 | { | ||
937 | struct printer_dev *dev = func_to_printer(f); | ||
938 | struct usb_composite_dev *cdev = f->config->cdev; | ||
939 | struct usb_request *req = cdev->req; | ||
940 | int value = -EOPNOTSUPP; | ||
941 | u16 wIndex = le16_to_cpu(ctrl->wIndex); | ||
942 | u16 wValue = le16_to_cpu(ctrl->wValue); | ||
943 | u16 wLength = le16_to_cpu(ctrl->wLength); | ||
944 | |||
945 | DBG(dev, "ctrl req%02x.%02x v%04x i%04x l%d\n", | ||
946 | ctrl->bRequestType, ctrl->bRequest, wValue, wIndex, wLength); | ||
947 | |||
948 | switch (ctrl->bRequestType&USB_TYPE_MASK) { | ||
949 | case USB_TYPE_CLASS: | ||
950 | switch (ctrl->bRequest) { | ||
951 | case GET_DEVICE_ID: /* Get the IEEE-1284 PNP String */ | ||
952 | /* Only one printer interface is supported. */ | ||
953 | if ((wIndex>>8) != dev->interface) | ||
954 | break; | ||
955 | |||
956 | value = (dev->pnp_string[0] << 8) | dev->pnp_string[1]; | ||
957 | memcpy(req->buf, dev->pnp_string, value); | ||
958 | DBG(dev, "1284 PNP String: %x %s\n", value, | ||
959 | &dev->pnp_string[2]); | ||
960 | break; | ||
961 | |||
962 | case GET_PORT_STATUS: /* Get Port Status */ | ||
963 | /* Only one printer interface is supported. */ | ||
964 | if (wIndex != dev->interface) | ||
965 | break; | ||
966 | |||
967 | *(u8 *)req->buf = dev->printer_status; | ||
968 | value = min_t(u16, wLength, 1); | ||
969 | break; | ||
970 | |||
971 | case SOFT_RESET: /* Soft Reset */ | ||
972 | /* Only one printer interface is supported. */ | ||
973 | if (wIndex != dev->interface) | ||
974 | break; | ||
975 | |||
976 | printer_soft_reset(dev); | ||
977 | |||
978 | value = 0; | ||
979 | break; | ||
980 | |||
981 | default: | ||
982 | goto unknown; | ||
983 | } | ||
984 | break; | ||
985 | |||
986 | default: | ||
987 | unknown: | ||
988 | VDBG(dev, | ||
989 | "unknown ctrl req%02x.%02x v%04x i%04x l%d\n", | ||
990 | ctrl->bRequestType, ctrl->bRequest, | ||
991 | wValue, wIndex, wLength); | ||
992 | break; | ||
993 | } | ||
994 | /* host either stalls (value < 0) or reports success */ | ||
995 | if (value >= 0) { | ||
996 | req->length = value; | ||
997 | req->zero = value < wLength; | ||
998 | value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC); | ||
999 | if (value < 0) { | ||
1000 | ERROR(dev, "%s:%d Error!\n", __func__, __LINE__); | ||
1001 | req->status = 0; | ||
1002 | } | ||
1003 | } | ||
1004 | return value; | ||
1005 | } | ||
1006 | |||
1007 | static int printer_func_bind(struct usb_configuration *c, | ||
1008 | struct usb_function *f) | ||
1009 | { | ||
1010 | struct usb_gadget *gadget = c->cdev->gadget; | ||
1011 | struct printer_dev *dev = func_to_printer(f); | ||
1012 | struct device *pdev; | ||
1013 | struct usb_composite_dev *cdev = c->cdev; | ||
1014 | struct usb_ep *in_ep; | ||
1015 | struct usb_ep *out_ep = NULL; | ||
1016 | struct usb_request *req; | ||
1017 | dev_t devt; | ||
1018 | int id; | ||
1019 | int ret; | ||
1020 | u32 i; | ||
1021 | |||
1022 | id = usb_interface_id(c, f); | ||
1023 | if (id < 0) | ||
1024 | return id; | ||
1025 | intf_desc.bInterfaceNumber = id; | ||
1026 | |||
1027 | /* finish hookup to lower layer ... */ | ||
1028 | dev->gadget = gadget; | ||
1029 | |||
1030 | /* all we really need is bulk IN/OUT */ | ||
1031 | in_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_in_desc); | ||
1032 | if (!in_ep) { | ||
1033 | autoconf_fail: | ||
1034 | dev_err(&cdev->gadget->dev, "can't autoconfigure on %s\n", | ||
1035 | cdev->gadget->name); | ||
1036 | return -ENODEV; | ||
1037 | } | ||
1038 | in_ep->driver_data = in_ep; /* claim */ | ||
1039 | |||
1040 | out_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_out_desc); | ||
1041 | if (!out_ep) | ||
1042 | goto autoconf_fail; | ||
1043 | out_ep->driver_data = out_ep; /* claim */ | ||
1044 | |||
1045 | /* assumes that all endpoints are dual-speed */ | ||
1046 | hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress; | ||
1047 | hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress; | ||
1048 | ss_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress; | ||
1049 | ss_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress; | ||
1050 | |||
1051 | ret = usb_assign_descriptors(f, fs_printer_function, | ||
1052 | hs_printer_function, ss_printer_function); | ||
1053 | if (ret) | ||
1054 | return ret; | ||
1055 | |||
1056 | dev->in_ep = in_ep; | ||
1057 | dev->out_ep = out_ep; | ||
1058 | |||
1059 | ret = -ENOMEM; | ||
1060 | for (i = 0; i < dev->q_len; i++) { | ||
1061 | req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL); | ||
1062 | if (!req) | ||
1063 | goto fail_tx_reqs; | ||
1064 | list_add(&req->list, &dev->tx_reqs); | ||
1065 | } | ||
1066 | |||
1067 | for (i = 0; i < dev->q_len; i++) { | ||
1068 | req = printer_req_alloc(dev->out_ep, USB_BUFSIZE, GFP_KERNEL); | ||
1069 | if (!req) | ||
1070 | goto fail_rx_reqs; | ||
1071 | list_add(&req->list, &dev->rx_reqs); | ||
1072 | } | ||
1073 | |||
1074 | /* Setup the sysfs files for the printer gadget. */ | ||
1075 | devt = MKDEV(major, dev->minor); | ||
1076 | pdev = device_create(usb_gadget_class, NULL, devt, | ||
1077 | NULL, "g_printer%d", dev->minor); | ||
1078 | if (IS_ERR(pdev)) { | ||
1079 | ERROR(dev, "Failed to create device: g_printer\n"); | ||
1080 | ret = PTR_ERR(pdev); | ||
1081 | goto fail_rx_reqs; | ||
1082 | } | ||
1083 | |||
1084 | /* | ||
1085 | * Register a character device as an interface to a user mode | ||
1086 | * program that handles the printer specific functionality. | ||
1087 | */ | ||
1088 | cdev_init(&dev->printer_cdev, &printer_io_operations); | ||
1089 | dev->printer_cdev.owner = THIS_MODULE; | ||
1090 | ret = cdev_add(&dev->printer_cdev, devt, 1); | ||
1091 | if (ret) { | ||
1092 | ERROR(dev, "Failed to open char device\n"); | ||
1093 | goto fail_cdev_add; | ||
1094 | } | ||
1095 | |||
1096 | return 0; | ||
1097 | |||
1098 | fail_cdev_add: | ||
1099 | device_destroy(usb_gadget_class, devt); | ||
1100 | |||
1101 | fail_rx_reqs: | ||
1102 | while (!list_empty(&dev->rx_reqs)) { | ||
1103 | req = container_of(dev->rx_reqs.next, struct usb_request, list); | ||
1104 | list_del(&req->list); | ||
1105 | printer_req_free(dev->out_ep, req); | ||
1106 | } | ||
1107 | |||
1108 | fail_tx_reqs: | ||
1109 | while (!list_empty(&dev->tx_reqs)) { | ||
1110 | req = container_of(dev->tx_reqs.next, struct usb_request, list); | ||
1111 | list_del(&req->list); | ||
1112 | printer_req_free(dev->in_ep, req); | ||
1113 | } | ||
1114 | |||
1115 | return ret; | ||
1116 | |||
1117 | } | ||
1118 | |||
1119 | static int printer_func_set_alt(struct usb_function *f, | ||
1120 | unsigned intf, unsigned alt) | ||
1121 | { | ||
1122 | struct printer_dev *dev = func_to_printer(f); | ||
1123 | int ret = -ENOTSUPP; | ||
1124 | |||
1125 | if (!alt) | ||
1126 | ret = set_interface(dev, intf); | ||
1127 | |||
1128 | return ret; | ||
1129 | } | ||
1130 | |||
1131 | static void printer_func_disable(struct usb_function *f) | ||
1132 | { | ||
1133 | struct printer_dev *dev = func_to_printer(f); | ||
1134 | unsigned long flags; | ||
1135 | |||
1136 | DBG(dev, "%s\n", __func__); | ||
1137 | |||
1138 | spin_lock_irqsave(&dev->lock, flags); | ||
1139 | printer_reset_interface(dev); | ||
1140 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1141 | } | ||
1142 | |||
1143 | static inline struct f_printer_opts | ||
1144 | *to_f_printer_opts(struct config_item *item) | ||
1145 | { | ||
1146 | return container_of(to_config_group(item), struct f_printer_opts, | ||
1147 | func_inst.group); | ||
1148 | } | ||
1149 | |||
1150 | CONFIGFS_ATTR_STRUCT(f_printer_opts); | ||
1151 | CONFIGFS_ATTR_OPS(f_printer_opts); | ||
1152 | |||
1153 | static void printer_attr_release(struct config_item *item) | ||
1154 | { | ||
1155 | struct f_printer_opts *opts = to_f_printer_opts(item); | ||
1156 | |||
1157 | usb_put_function_instance(&opts->func_inst); | ||
1158 | } | ||
1159 | |||
1160 | static struct configfs_item_operations printer_item_ops = { | ||
1161 | .release = printer_attr_release, | ||
1162 | .show_attribute = f_printer_opts_attr_show, | ||
1163 | .store_attribute = f_printer_opts_attr_store, | ||
1164 | }; | ||
1165 | |||
1166 | static ssize_t f_printer_opts_pnp_string_show(struct f_printer_opts *opts, | ||
1167 | char *page) | ||
1168 | { | ||
1169 | int result; | ||
1170 | |||
1171 | mutex_lock(&opts->lock); | ||
1172 | result = strlcpy(page, opts->pnp_string + 2, PNP_STRING_LEN - 2); | ||
1173 | mutex_unlock(&opts->lock); | ||
1174 | |||
1175 | return result; | ||
1176 | } | ||
1177 | |||
1178 | static ssize_t f_printer_opts_pnp_string_store(struct f_printer_opts *opts, | ||
1179 | const char *page, size_t len) | ||
1180 | { | ||
1181 | int result, l; | ||
1182 | |||
1183 | mutex_lock(&opts->lock); | ||
1184 | result = strlcpy(opts->pnp_string + 2, page, PNP_STRING_LEN - 2); | ||
1185 | l = strlen(opts->pnp_string + 2) + 2; | ||
1186 | opts->pnp_string[0] = (l >> 8) & 0xFF; | ||
1187 | opts->pnp_string[1] = l & 0xFF; | ||
1188 | mutex_unlock(&opts->lock); | ||
1189 | |||
1190 | return result; | ||
1191 | } | ||
1192 | |||
1193 | static struct f_printer_opts_attribute f_printer_opts_pnp_string = | ||
1194 | __CONFIGFS_ATTR(pnp_string, S_IRUGO | S_IWUSR, | ||
1195 | f_printer_opts_pnp_string_show, | ||
1196 | f_printer_opts_pnp_string_store); | ||
1197 | |||
1198 | static ssize_t f_printer_opts_q_len_show(struct f_printer_opts *opts, | ||
1199 | char *page) | ||
1200 | { | ||
1201 | int result; | ||
1202 | |||
1203 | mutex_lock(&opts->lock); | ||
1204 | result = sprintf(page, "%d\n", opts->q_len); | ||
1205 | mutex_unlock(&opts->lock); | ||
1206 | |||
1207 | return result; | ||
1208 | } | ||
1209 | |||
1210 | static ssize_t f_printer_opts_q_len_store(struct f_printer_opts *opts, | ||
1211 | const char *page, size_t len) | ||
1212 | { | ||
1213 | int ret; | ||
1214 | u16 num; | ||
1215 | |||
1216 | mutex_lock(&opts->lock); | ||
1217 | if (opts->refcnt) { | ||
1218 | ret = -EBUSY; | ||
1219 | goto end; | ||
1220 | } | ||
1221 | |||
1222 | ret = kstrtou16(page, 0, &num); | ||
1223 | if (ret) | ||
1224 | goto end; | ||
1225 | |||
1226 | opts->q_len = (unsigned)num; | ||
1227 | ret = len; | ||
1228 | end: | ||
1229 | mutex_unlock(&opts->lock); | ||
1230 | return ret; | ||
1231 | } | ||
1232 | |||
1233 | static struct f_printer_opts_attribute f_printer_opts_q_len = | ||
1234 | __CONFIGFS_ATTR(q_len, S_IRUGO | S_IWUSR, f_printer_opts_q_len_show, | ||
1235 | f_printer_opts_q_len_store); | ||
1236 | |||
1237 | static struct configfs_attribute *printer_attrs[] = { | ||
1238 | &f_printer_opts_pnp_string.attr, | ||
1239 | &f_printer_opts_q_len.attr, | ||
1240 | NULL, | ||
1241 | }; | ||
1242 | |||
1243 | static struct config_item_type printer_func_type = { | ||
1244 | .ct_item_ops = &printer_item_ops, | ||
1245 | .ct_attrs = printer_attrs, | ||
1246 | .ct_owner = THIS_MODULE, | ||
1247 | }; | ||
1248 | |||
1249 | static inline int gprinter_get_minor(void) | ||
1250 | { | ||
1251 | return ida_simple_get(&printer_ida, 0, 0, GFP_KERNEL); | ||
1252 | } | ||
1253 | |||
1254 | static inline void gprinter_put_minor(int minor) | ||
1255 | { | ||
1256 | ida_simple_remove(&printer_ida, minor); | ||
1257 | } | ||
1258 | |||
1259 | static int gprinter_setup(int); | ||
1260 | static void gprinter_cleanup(void); | ||
1261 | |||
1262 | static void gprinter_free_inst(struct usb_function_instance *f) | ||
1263 | { | ||
1264 | struct f_printer_opts *opts; | ||
1265 | |||
1266 | opts = container_of(f, struct f_printer_opts, func_inst); | ||
1267 | |||
1268 | mutex_lock(&printer_ida_lock); | ||
1269 | |||
1270 | gprinter_put_minor(opts->minor); | ||
1271 | if (idr_is_empty(&printer_ida.idr)) | ||
1272 | gprinter_cleanup(); | ||
1273 | |||
1274 | mutex_unlock(&printer_ida_lock); | ||
1275 | |||
1276 | kfree(opts); | ||
1277 | } | ||
1278 | |||
1279 | static struct usb_function_instance *gprinter_alloc_inst(void) | ||
1280 | { | ||
1281 | struct f_printer_opts *opts; | ||
1282 | struct usb_function_instance *ret; | ||
1283 | int status = 0; | ||
1284 | |||
1285 | opts = kzalloc(sizeof(*opts), GFP_KERNEL); | ||
1286 | if (!opts) | ||
1287 | return ERR_PTR(-ENOMEM); | ||
1288 | |||
1289 | mutex_init(&opts->lock); | ||
1290 | opts->func_inst.free_func_inst = gprinter_free_inst; | ||
1291 | ret = &opts->func_inst; | ||
1292 | |||
1293 | mutex_lock(&printer_ida_lock); | ||
1294 | |||
1295 | if (idr_is_empty(&printer_ida.idr)) { | ||
1296 | status = gprinter_setup(PRINTER_MINORS); | ||
1297 | if (status) { | ||
1298 | ret = ERR_PTR(status); | ||
1299 | kfree(opts); | ||
1300 | goto unlock; | ||
1301 | } | ||
1302 | } | ||
1303 | |||
1304 | opts->minor = gprinter_get_minor(); | ||
1305 | if (opts->minor < 0) { | ||
1306 | ret = ERR_PTR(opts->minor); | ||
1307 | kfree(opts); | ||
1308 | if (idr_is_empty(&printer_ida.idr)) | ||
1309 | gprinter_cleanup(); | ||
1310 | goto unlock; | ||
1311 | } | ||
1312 | config_group_init_type_name(&opts->func_inst.group, "", | ||
1313 | &printer_func_type); | ||
1314 | |||
1315 | unlock: | ||
1316 | mutex_unlock(&printer_ida_lock); | ||
1317 | return ret; | ||
1318 | } | ||
1319 | |||
1320 | static void gprinter_free(struct usb_function *f) | ||
1321 | { | ||
1322 | struct printer_dev *dev = func_to_printer(f); | ||
1323 | struct f_printer_opts *opts; | ||
1324 | |||
1325 | opts = container_of(f->fi, struct f_printer_opts, func_inst); | ||
1326 | kfree(dev); | ||
1327 | mutex_lock(&opts->lock); | ||
1328 | --opts->refcnt; | ||
1329 | mutex_unlock(&opts->lock); | ||
1330 | } | ||
1331 | |||
1332 | static void printer_func_unbind(struct usb_configuration *c, | ||
1333 | struct usb_function *f) | ||
1334 | { | ||
1335 | struct printer_dev *dev; | ||
1336 | struct usb_request *req; | ||
1337 | |||
1338 | dev = func_to_printer(f); | ||
1339 | |||
1340 | device_destroy(usb_gadget_class, MKDEV(major, dev->minor)); | ||
1341 | |||
1342 | /* Remove Character Device */ | ||
1343 | cdev_del(&dev->printer_cdev); | ||
1344 | |||
1345 | /* we must already have been disconnected ... no i/o may be active */ | ||
1346 | WARN_ON(!list_empty(&dev->tx_reqs_active)); | ||
1347 | WARN_ON(!list_empty(&dev->rx_reqs_active)); | ||
1348 | |||
1349 | /* Free all memory for this driver. */ | ||
1350 | while (!list_empty(&dev->tx_reqs)) { | ||
1351 | req = container_of(dev->tx_reqs.next, struct usb_request, | ||
1352 | list); | ||
1353 | list_del(&req->list); | ||
1354 | printer_req_free(dev->in_ep, req); | ||
1355 | } | ||
1356 | |||
1357 | if (dev->current_rx_req != NULL) | ||
1358 | printer_req_free(dev->out_ep, dev->current_rx_req); | ||
1359 | |||
1360 | while (!list_empty(&dev->rx_reqs)) { | ||
1361 | req = container_of(dev->rx_reqs.next, | ||
1362 | struct usb_request, list); | ||
1363 | list_del(&req->list); | ||
1364 | printer_req_free(dev->out_ep, req); | ||
1365 | } | ||
1366 | |||
1367 | while (!list_empty(&dev->rx_buffers)) { | ||
1368 | req = container_of(dev->rx_buffers.next, | ||
1369 | struct usb_request, list); | ||
1370 | list_del(&req->list); | ||
1371 | printer_req_free(dev->out_ep, req); | ||
1372 | } | ||
1373 | usb_free_all_descriptors(f); | ||
1374 | } | ||
1375 | |||
1376 | static struct usb_function *gprinter_alloc(struct usb_function_instance *fi) | ||
1377 | { | ||
1378 | struct printer_dev *dev; | ||
1379 | struct f_printer_opts *opts; | ||
1380 | |||
1381 | opts = container_of(fi, struct f_printer_opts, func_inst); | ||
1382 | |||
1383 | mutex_lock(&opts->lock); | ||
1384 | if (opts->minor >= minors) { | ||
1385 | mutex_unlock(&opts->lock); | ||
1386 | return ERR_PTR(-ENOENT); | ||
1387 | } | ||
1388 | |||
1389 | dev = kzalloc(sizeof(*dev), GFP_KERNEL); | ||
1390 | if (!dev) { | ||
1391 | mutex_unlock(&opts->lock); | ||
1392 | return ERR_PTR(-ENOMEM); | ||
1393 | } | ||
1394 | |||
1395 | ++opts->refcnt; | ||
1396 | dev->minor = opts->minor; | ||
1397 | dev->pnp_string = opts->pnp_string; | ||
1398 | dev->q_len = opts->q_len; | ||
1399 | mutex_unlock(&opts->lock); | ||
1400 | |||
1401 | dev->function.name = "printer"; | ||
1402 | dev->function.bind = printer_func_bind; | ||
1403 | dev->function.setup = printer_func_setup; | ||
1404 | dev->function.unbind = printer_func_unbind; | ||
1405 | dev->function.set_alt = printer_func_set_alt; | ||
1406 | dev->function.disable = printer_func_disable; | ||
1407 | dev->function.req_match = gprinter_req_match; | ||
1408 | dev->function.free_func = gprinter_free; | ||
1409 | |||
1410 | INIT_LIST_HEAD(&dev->tx_reqs); | ||
1411 | INIT_LIST_HEAD(&dev->rx_reqs); | ||
1412 | INIT_LIST_HEAD(&dev->rx_buffers); | ||
1413 | INIT_LIST_HEAD(&dev->tx_reqs_active); | ||
1414 | INIT_LIST_HEAD(&dev->rx_reqs_active); | ||
1415 | |||
1416 | spin_lock_init(&dev->lock); | ||
1417 | mutex_init(&dev->lock_printer_io); | ||
1418 | init_waitqueue_head(&dev->rx_wait); | ||
1419 | init_waitqueue_head(&dev->tx_wait); | ||
1420 | init_waitqueue_head(&dev->tx_flush_wait); | ||
1421 | |||
1422 | dev->interface = -1; | ||
1423 | dev->printer_cdev_open = 0; | ||
1424 | dev->printer_status = PRINTER_NOT_ERROR; | ||
1425 | dev->current_rx_req = NULL; | ||
1426 | dev->current_rx_bytes = 0; | ||
1427 | dev->current_rx_buf = NULL; | ||
1428 | |||
1429 | return &dev->function; | ||
1430 | } | ||
1431 | |||
1432 | DECLARE_USB_FUNCTION_INIT(printer, gprinter_alloc_inst, gprinter_alloc); | ||
1433 | MODULE_LICENSE("GPL"); | ||
1434 | MODULE_AUTHOR("Craig Nadler"); | ||
1435 | |||
1436 | static int gprinter_setup(int count) | ||
1437 | { | ||
1438 | int status; | ||
1439 | dev_t devt; | ||
1440 | |||
1441 | usb_gadget_class = class_create(THIS_MODULE, "usb_printer_gadget"); | ||
1442 | if (IS_ERR(usb_gadget_class)) { | ||
1443 | status = PTR_ERR(usb_gadget_class); | ||
1444 | usb_gadget_class = NULL; | ||
1445 | pr_err("unable to create usb_gadget class %d\n", status); | ||
1446 | return status; | ||
1447 | } | ||
1448 | |||
1449 | status = alloc_chrdev_region(&devt, 0, count, "USB printer gadget"); | ||
1450 | if (status) { | ||
1451 | pr_err("alloc_chrdev_region %d\n", status); | ||
1452 | class_destroy(usb_gadget_class); | ||
1453 | usb_gadget_class = NULL; | ||
1454 | return status; | ||
1455 | } | ||
1456 | |||
1457 | major = MAJOR(devt); | ||
1458 | minors = count; | ||
1459 | |||
1460 | return status; | ||
1461 | } | ||
1462 | |||
1463 | static void gprinter_cleanup(void) | ||
1464 | { | ||
1465 | if (major) { | ||
1466 | unregister_chrdev_region(MKDEV(major, 0), minors); | ||
1467 | major = minors = 0; | ||
1468 | } | ||
1469 | class_destroy(usb_gadget_class); | ||
1470 | usb_gadget_class = NULL; | ||
1471 | } | ||
diff --git a/drivers/usb/gadget/function/u_printer.h b/drivers/usb/gadget/function/u_printer.h new file mode 100644 index 000000000000..0e2c49d4274e --- /dev/null +++ b/drivers/usb/gadget/function/u_printer.h | |||
@@ -0,0 +1,37 @@ | |||
1 | /* | ||
2 | * u_printer.h | ||
3 | * | ||
4 | * Utility definitions for the printer function | ||
5 | * | ||
6 | * Copyright (c) 2015 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_PRINTER_H | ||
17 | #define U_PRINTER_H | ||
18 | |||
19 | #include <linux/usb/composite.h> | ||
20 | |||
21 | #define PNP_STRING_LEN 1024 | ||
22 | |||
23 | struct f_printer_opts { | ||
24 | struct usb_function_instance func_inst; | ||
25 | int minor; | ||
26 | char pnp_string[PNP_STRING_LEN]; | ||
27 | unsigned q_len; | ||
28 | |||
29 | /* | ||
30 | * Protect the data from concurrent access by read/write | ||
31 | * and create symlink/remove symlink | ||
32 | */ | ||
33 | struct mutex lock; | ||
34 | int refcnt; | ||
35 | }; | ||
36 | |||
37 | #endif /* U_PRINTER_H */ | ||
diff --git a/drivers/usb/gadget/function/u_serial.c b/drivers/usb/gadget/function/u_serial.c index 491082aaf103..89179ab20c10 100644 --- a/drivers/usb/gadget/function/u_serial.c +++ b/drivers/usb/gadget/function/u_serial.c | |||
@@ -912,7 +912,7 @@ static int gs_put_char(struct tty_struct *tty, unsigned char ch) | |||
912 | unsigned long flags; | 912 | unsigned long flags; |
913 | int status; | 913 | int status; |
914 | 914 | ||
915 | pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %pf\n", | 915 | pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %ps\n", |
916 | port->port_num, tty, ch, __builtin_return_address(0)); | 916 | port->port_num, tty, ch, __builtin_return_address(0)); |
917 | 917 | ||
918 | spin_lock_irqsave(&port->port_lock, flags); | 918 | spin_lock_irqsave(&port->port_lock, flags); |
diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig index 113c87e22117..d5a7102de696 100644 --- a/drivers/usb/gadget/legacy/Kconfig +++ b/drivers/usb/gadget/legacy/Kconfig | |||
@@ -301,6 +301,7 @@ config USB_MIDI_GADGET | |||
301 | config USB_G_PRINTER | 301 | config USB_G_PRINTER |
302 | tristate "Printer Gadget" | 302 | tristate "Printer Gadget" |
303 | select USB_LIBCOMPOSITE | 303 | select USB_LIBCOMPOSITE |
304 | select USB_F_PRINTER | ||
304 | help | 305 | help |
305 | The Printer Gadget channels data between the USB host and a | 306 | The Printer Gadget channels data between the USB host and a |
306 | userspace program driving the print engine. The user space | 307 | userspace program driving the print engine. The user space |
diff --git a/drivers/usb/gadget/legacy/printer.c b/drivers/usb/gadget/legacy/printer.c index 90545980542f..d5b6ee725a2a 100644 --- a/drivers/usb/gadget/legacy/printer.c +++ b/drivers/usb/gadget/legacy/printer.c | |||
@@ -12,29 +12,7 @@ | |||
12 | 12 | ||
13 | #include <linux/module.h> | 13 | #include <linux/module.h> |
14 | #include <linux/kernel.h> | 14 | #include <linux/kernel.h> |
15 | #include <linux/delay.h> | ||
16 | #include <linux/ioport.h> | ||
17 | #include <linux/sched.h> | ||
18 | #include <linux/slab.h> | ||
19 | #include <linux/mutex.h> | ||
20 | #include <linux/errno.h> | ||
21 | #include <linux/init.h> | ||
22 | #include <linux/timer.h> | ||
23 | #include <linux/list.h> | ||
24 | #include <linux/interrupt.h> | ||
25 | #include <linux/device.h> | ||
26 | #include <linux/moduleparam.h> | ||
27 | #include <linux/fs.h> | ||
28 | #include <linux/poll.h> | ||
29 | #include <linux/types.h> | ||
30 | #include <linux/ctype.h> | ||
31 | #include <linux/cdev.h> | ||
32 | |||
33 | #include <asm/byteorder.h> | 15 | #include <asm/byteorder.h> |
34 | #include <linux/io.h> | ||
35 | #include <linux/irq.h> | ||
36 | #include <linux/uaccess.h> | ||
37 | #include <asm/unaligned.h> | ||
38 | 16 | ||
39 | #include <linux/usb/ch9.h> | 17 | #include <linux/usb/ch9.h> |
40 | #include <linux/usb/composite.h> | 18 | #include <linux/usb/composite.h> |
@@ -46,50 +24,12 @@ | |||
46 | USB_GADGET_COMPOSITE_OPTIONS(); | 24 | USB_GADGET_COMPOSITE_OPTIONS(); |
47 | 25 | ||
48 | #define DRIVER_DESC "Printer Gadget" | 26 | #define DRIVER_DESC "Printer Gadget" |
49 | #define DRIVER_VERSION "2007 OCT 06" | 27 | #define DRIVER_VERSION "2015 FEB 17" |
50 | 28 | ||
51 | static DEFINE_MUTEX(printer_mutex); | ||
52 | static const char shortname [] = "printer"; | 29 | static const char shortname [] = "printer"; |
53 | static const char driver_desc [] = DRIVER_DESC; | 30 | static const char driver_desc [] = DRIVER_DESC; |
54 | 31 | ||
55 | static dev_t g_printer_devno; | 32 | #include "u_printer.h" |
56 | |||
57 | static struct class *usb_gadget_class; | ||
58 | |||
59 | /*-------------------------------------------------------------------------*/ | ||
60 | |||
61 | struct printer_dev { | ||
62 | spinlock_t lock; /* lock this structure */ | ||
63 | /* lock buffer lists during read/write calls */ | ||
64 | struct mutex lock_printer_io; | ||
65 | struct usb_gadget *gadget; | ||
66 | s8 interface; | ||
67 | struct usb_ep *in_ep, *out_ep; | ||
68 | |||
69 | struct list_head rx_reqs; /* List of free RX structs */ | ||
70 | struct list_head rx_reqs_active; /* List of Active RX xfers */ | ||
71 | struct list_head rx_buffers; /* List of completed xfers */ | ||
72 | /* wait until there is data to be read. */ | ||
73 | wait_queue_head_t rx_wait; | ||
74 | struct list_head tx_reqs; /* List of free TX structs */ | ||
75 | struct list_head tx_reqs_active; /* List of Active TX xfers */ | ||
76 | /* Wait until there are write buffers available to use. */ | ||
77 | wait_queue_head_t tx_wait; | ||
78 | /* Wait until all write buffers have been sent. */ | ||
79 | wait_queue_head_t tx_flush_wait; | ||
80 | struct usb_request *current_rx_req; | ||
81 | size_t current_rx_bytes; | ||
82 | u8 *current_rx_buf; | ||
83 | u8 printer_status; | ||
84 | u8 reset_printer; | ||
85 | struct cdev printer_cdev; | ||
86 | struct device *pdev; | ||
87 | u8 printer_cdev_open; | ||
88 | wait_queue_head_t wait; | ||
89 | struct usb_function function; | ||
90 | }; | ||
91 | |||
92 | static struct printer_dev usb_printer_gadget; | ||
93 | 33 | ||
94 | /*-------------------------------------------------------------------------*/ | 34 | /*-------------------------------------------------------------------------*/ |
95 | 35 | ||
@@ -120,6 +60,9 @@ module_param(qlen, uint, S_IRUGO|S_IWUSR); | |||
120 | 60 | ||
121 | #define QLEN qlen | 61 | #define QLEN qlen |
122 | 62 | ||
63 | static struct usb_function_instance *fi_printer; | ||
64 | static struct usb_function *f_printer; | ||
65 | |||
123 | /*-------------------------------------------------------------------------*/ | 66 | /*-------------------------------------------------------------------------*/ |
124 | 67 | ||
125 | /* | 68 | /* |
@@ -127,10 +70,6 @@ module_param(qlen, uint, S_IRUGO|S_IWUSR); | |||
127 | * descriptors are built on demand. | 70 | * descriptors are built on demand. |
128 | */ | 71 | */ |
129 | 72 | ||
130 | /* holds our biggest descriptor */ | ||
131 | #define USB_DESC_BUFSIZE 256 | ||
132 | #define USB_BUFSIZE 8192 | ||
133 | |||
134 | static struct usb_device_descriptor device_desc = { | 73 | static struct usb_device_descriptor device_desc = { |
135 | .bLength = sizeof device_desc, | 74 | .bLength = sizeof device_desc, |
136 | .bDescriptorType = USB_DT_DEVICE, | 75 | .bDescriptorType = USB_DT_DEVICE, |
@@ -143,108 +82,6 @@ static struct usb_device_descriptor device_desc = { | |||
143 | .bNumConfigurations = 1 | 82 | .bNumConfigurations = 1 |
144 | }; | 83 | }; |
145 | 84 | ||
146 | static struct usb_interface_descriptor intf_desc = { | ||
147 | .bLength = sizeof intf_desc, | ||
148 | .bDescriptorType = USB_DT_INTERFACE, | ||
149 | .bNumEndpoints = 2, | ||
150 | .bInterfaceClass = USB_CLASS_PRINTER, | ||
151 | .bInterfaceSubClass = 1, /* Printer Sub-Class */ | ||
152 | .bInterfaceProtocol = 2, /* Bi-Directional */ | ||
153 | .iInterface = 0 | ||
154 | }; | ||
155 | |||
156 | static struct usb_endpoint_descriptor fs_ep_in_desc = { | ||
157 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
158 | .bDescriptorType = USB_DT_ENDPOINT, | ||
159 | .bEndpointAddress = USB_DIR_IN, | ||
160 | .bmAttributes = USB_ENDPOINT_XFER_BULK | ||
161 | }; | ||
162 | |||
163 | static struct usb_endpoint_descriptor fs_ep_out_desc = { | ||
164 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
165 | .bDescriptorType = USB_DT_ENDPOINT, | ||
166 | .bEndpointAddress = USB_DIR_OUT, | ||
167 | .bmAttributes = USB_ENDPOINT_XFER_BULK | ||
168 | }; | ||
169 | |||
170 | static struct usb_descriptor_header *fs_printer_function[] = { | ||
171 | (struct usb_descriptor_header *) &intf_desc, | ||
172 | (struct usb_descriptor_header *) &fs_ep_in_desc, | ||
173 | (struct usb_descriptor_header *) &fs_ep_out_desc, | ||
174 | NULL | ||
175 | }; | ||
176 | |||
177 | /* | ||
178 | * usb 2.0 devices need to expose both high speed and full speed | ||
179 | * descriptors, unless they only run at full speed. | ||
180 | */ | ||
181 | |||
182 | static struct usb_endpoint_descriptor hs_ep_in_desc = { | ||
183 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
184 | .bDescriptorType = USB_DT_ENDPOINT, | ||
185 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
186 | .wMaxPacketSize = cpu_to_le16(512) | ||
187 | }; | ||
188 | |||
189 | static struct usb_endpoint_descriptor hs_ep_out_desc = { | ||
190 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
191 | .bDescriptorType = USB_DT_ENDPOINT, | ||
192 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
193 | .wMaxPacketSize = cpu_to_le16(512) | ||
194 | }; | ||
195 | |||
196 | static struct usb_qualifier_descriptor dev_qualifier = { | ||
197 | .bLength = sizeof dev_qualifier, | ||
198 | .bDescriptorType = USB_DT_DEVICE_QUALIFIER, | ||
199 | .bcdUSB = cpu_to_le16(0x0200), | ||
200 | .bDeviceClass = USB_CLASS_PRINTER, | ||
201 | .bNumConfigurations = 1 | ||
202 | }; | ||
203 | |||
204 | static struct usb_descriptor_header *hs_printer_function[] = { | ||
205 | (struct usb_descriptor_header *) &intf_desc, | ||
206 | (struct usb_descriptor_header *) &hs_ep_in_desc, | ||
207 | (struct usb_descriptor_header *) &hs_ep_out_desc, | ||
208 | NULL | ||
209 | }; | ||
210 | |||
211 | /* | ||
212 | * Added endpoint descriptors for 3.0 devices | ||
213 | */ | ||
214 | |||
215 | static 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 | |||
222 | static 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 | |||
227 | static 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 | |||
234 | static 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 | |||
239 | static 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 | |||
248 | static struct usb_otg_descriptor otg_descriptor = { | 85 | static struct usb_otg_descriptor otg_descriptor = { |
249 | .bLength = sizeof otg_descriptor, | 86 | .bLength = sizeof otg_descriptor, |
250 | .bDescriptorType = USB_DT_OTG, | 87 | .bDescriptorType = USB_DT_OTG, |
@@ -256,29 +93,13 @@ static const struct usb_descriptor_header *otg_desc[] = { | |||
256 | NULL, | 93 | NULL, |
257 | }; | 94 | }; |
258 | 95 | ||
259 | /* maxpacket and other transfer characteristics vary by speed. */ | ||
260 | static 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 | } | ||
274 | |||
275 | /*-------------------------------------------------------------------------*/ | 96 | /*-------------------------------------------------------------------------*/ |
276 | 97 | ||
277 | /* descriptors that are built on-demand */ | 98 | /* descriptors that are built on-demand */ |
278 | 99 | ||
279 | static char product_desc [40] = DRIVER_DESC; | 100 | static char product_desc [40] = DRIVER_DESC; |
280 | static char serial_num [40] = "1"; | 101 | static char serial_num [40] = "1"; |
281 | static char pnp_string [1024] = | 102 | static char pnp_string[PNP_STRING_LEN] = |
282 | "XXMFG:linux;MDL:g_printer;CLS:PRINTER;SN:1;"; | 103 | "XXMFG:linux;MDL:g_printer;CLS:PRINTER;SN:1;"; |
283 | 104 | ||
284 | /* static strings, in UTF-8 */ | 105 | /* static strings, in UTF-8 */ |
@@ -299,921 +120,19 @@ static struct usb_gadget_strings *dev_strings[] = { | |||
299 | NULL, | 120 | NULL, |
300 | }; | 121 | }; |
301 | 122 | ||
302 | /*-------------------------------------------------------------------------*/ | ||
303 | |||
304 | static struct usb_request * | ||
305 | printer_req_alloc(struct usb_ep *ep, unsigned len, gfp_t gfp_flags) | ||
306 | { | ||
307 | struct usb_request *req; | ||
308 | |||
309 | req = usb_ep_alloc_request(ep, gfp_flags); | ||
310 | |||
311 | if (req != NULL) { | ||
312 | req->length = len; | ||
313 | req->buf = kmalloc(len, gfp_flags); | ||
314 | if (req->buf == NULL) { | ||
315 | usb_ep_free_request(ep, req); | ||
316 | return NULL; | ||
317 | } | ||
318 | } | ||
319 | |||
320 | return req; | ||
321 | } | ||
322 | |||
323 | static void | ||
324 | printer_req_free(struct usb_ep *ep, struct usb_request *req) | ||
325 | { | ||
326 | if (ep != NULL && req != NULL) { | ||
327 | kfree(req->buf); | ||
328 | usb_ep_free_request(ep, req); | ||
329 | } | ||
330 | } | ||
331 | |||
332 | /*-------------------------------------------------------------------------*/ | ||
333 | |||
334 | static void rx_complete(struct usb_ep *ep, struct usb_request *req) | ||
335 | { | ||
336 | struct printer_dev *dev = ep->driver_data; | ||
337 | int status = req->status; | ||
338 | unsigned long flags; | ||
339 | |||
340 | spin_lock_irqsave(&dev->lock, flags); | ||
341 | |||
342 | list_del_init(&req->list); /* Remode from Active List */ | ||
343 | |||
344 | switch (status) { | ||
345 | |||
346 | /* normal completion */ | ||
347 | case 0: | ||
348 | if (req->actual > 0) { | ||
349 | list_add_tail(&req->list, &dev->rx_buffers); | ||
350 | DBG(dev, "G_Printer : rx length %d\n", req->actual); | ||
351 | } else { | ||
352 | list_add(&req->list, &dev->rx_reqs); | ||
353 | } | ||
354 | break; | ||
355 | |||
356 | /* software-driven interface shutdown */ | ||
357 | case -ECONNRESET: /* unlink */ | ||
358 | case -ESHUTDOWN: /* disconnect etc */ | ||
359 | VDBG(dev, "rx shutdown, code %d\n", status); | ||
360 | list_add(&req->list, &dev->rx_reqs); | ||
361 | break; | ||
362 | |||
363 | /* for hardware automagic (such as pxa) */ | ||
364 | case -ECONNABORTED: /* endpoint reset */ | ||
365 | DBG(dev, "rx %s reset\n", ep->name); | ||
366 | list_add(&req->list, &dev->rx_reqs); | ||
367 | break; | ||
368 | |||
369 | /* data overrun */ | ||
370 | case -EOVERFLOW: | ||
371 | /* FALLTHROUGH */ | ||
372 | |||
373 | default: | ||
374 | DBG(dev, "rx status %d\n", status); | ||
375 | list_add(&req->list, &dev->rx_reqs); | ||
376 | break; | ||
377 | } | ||
378 | |||
379 | wake_up_interruptible(&dev->rx_wait); | ||
380 | spin_unlock_irqrestore(&dev->lock, flags); | ||
381 | } | ||
382 | |||
383 | static void tx_complete(struct usb_ep *ep, struct usb_request *req) | ||
384 | { | ||
385 | struct printer_dev *dev = ep->driver_data; | ||
386 | |||
387 | switch (req->status) { | ||
388 | default: | ||
389 | VDBG(dev, "tx err %d\n", req->status); | ||
390 | /* FALLTHROUGH */ | ||
391 | case -ECONNRESET: /* unlink */ | ||
392 | case -ESHUTDOWN: /* disconnect etc */ | ||
393 | break; | ||
394 | case 0: | ||
395 | break; | ||
396 | } | ||
397 | |||
398 | spin_lock(&dev->lock); | ||
399 | /* Take the request struct off the active list and put it on the | ||
400 | * free list. | ||
401 | */ | ||
402 | list_del_init(&req->list); | ||
403 | list_add(&req->list, &dev->tx_reqs); | ||
404 | wake_up_interruptible(&dev->tx_wait); | ||
405 | if (likely(list_empty(&dev->tx_reqs_active))) | ||
406 | wake_up_interruptible(&dev->tx_flush_wait); | ||
407 | |||
408 | spin_unlock(&dev->lock); | ||
409 | } | ||
410 | |||
411 | /*-------------------------------------------------------------------------*/ | ||
412 | |||
413 | static int | ||
414 | printer_open(struct inode *inode, struct file *fd) | ||
415 | { | ||
416 | struct printer_dev *dev; | ||
417 | unsigned long flags; | ||
418 | int ret = -EBUSY; | ||
419 | |||
420 | mutex_lock(&printer_mutex); | ||
421 | dev = container_of(inode->i_cdev, struct printer_dev, printer_cdev); | ||
422 | |||
423 | spin_lock_irqsave(&dev->lock, flags); | ||
424 | |||
425 | if (!dev->printer_cdev_open) { | ||
426 | dev->printer_cdev_open = 1; | ||
427 | fd->private_data = dev; | ||
428 | ret = 0; | ||
429 | /* Change the printer status to show that it's on-line. */ | ||
430 | dev->printer_status |= PRINTER_SELECTED; | ||
431 | } | ||
432 | |||
433 | spin_unlock_irqrestore(&dev->lock, flags); | ||
434 | |||
435 | DBG(dev, "printer_open returned %x\n", ret); | ||
436 | mutex_unlock(&printer_mutex); | ||
437 | return ret; | ||
438 | } | ||
439 | |||
440 | static int | ||
441 | printer_close(struct inode *inode, struct file *fd) | ||
442 | { | ||
443 | struct printer_dev *dev = fd->private_data; | ||
444 | unsigned long flags; | ||
445 | |||
446 | spin_lock_irqsave(&dev->lock, flags); | ||
447 | dev->printer_cdev_open = 0; | ||
448 | fd->private_data = NULL; | ||
449 | /* Change printer status to show that the printer is off-line. */ | ||
450 | dev->printer_status &= ~PRINTER_SELECTED; | ||
451 | spin_unlock_irqrestore(&dev->lock, flags); | ||
452 | |||
453 | DBG(dev, "printer_close\n"); | ||
454 | |||
455 | return 0; | ||
456 | } | ||
457 | |||
458 | /* This function must be called with interrupts turned off. */ | ||
459 | static void | ||
460 | setup_rx_reqs(struct printer_dev *dev) | ||
461 | { | ||
462 | struct usb_request *req; | ||
463 | |||
464 | while (likely(!list_empty(&dev->rx_reqs))) { | ||
465 | int error; | ||
466 | |||
467 | req = container_of(dev->rx_reqs.next, | ||
468 | struct usb_request, list); | ||
469 | list_del_init(&req->list); | ||
470 | |||
471 | /* The USB Host sends us whatever amount of data it wants to | ||
472 | * so we always set the length field to the full USB_BUFSIZE. | ||
473 | * If the amount of data is more than the read() caller asked | ||
474 | * for it will be stored in the request buffer until it is | ||
475 | * asked for by read(). | ||
476 | */ | ||
477 | req->length = USB_BUFSIZE; | ||
478 | req->complete = rx_complete; | ||
479 | |||
480 | /* here, we unlock, and only unlock, to avoid deadlock. */ | ||
481 | spin_unlock(&dev->lock); | ||
482 | error = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC); | ||
483 | spin_lock(&dev->lock); | ||
484 | if (error) { | ||
485 | DBG(dev, "rx submit --> %d\n", error); | ||
486 | list_add(&req->list, &dev->rx_reqs); | ||
487 | break; | ||
488 | } | ||
489 | /* if the req is empty, then add it into dev->rx_reqs_active. */ | ||
490 | else if (list_empty(&req->list)) { | ||
491 | list_add(&req->list, &dev->rx_reqs_active); | ||
492 | } | ||
493 | } | ||
494 | } | ||
495 | |||
496 | static ssize_t | ||
497 | printer_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr) | ||
498 | { | ||
499 | struct printer_dev *dev = fd->private_data; | ||
500 | unsigned long flags; | ||
501 | size_t size; | ||
502 | size_t bytes_copied; | ||
503 | struct usb_request *req; | ||
504 | /* This is a pointer to the current USB rx request. */ | ||
505 | struct usb_request *current_rx_req; | ||
506 | /* This is the number of bytes in the current rx buffer. */ | ||
507 | size_t current_rx_bytes; | ||
508 | /* This is a pointer to the current rx buffer. */ | ||
509 | u8 *current_rx_buf; | ||
510 | |||
511 | if (len == 0) | ||
512 | return -EINVAL; | ||
513 | |||
514 | DBG(dev, "printer_read trying to read %d bytes\n", (int)len); | ||
515 | |||
516 | mutex_lock(&dev->lock_printer_io); | ||
517 | spin_lock_irqsave(&dev->lock, flags); | ||
518 | |||
519 | /* We will use this flag later to check if a printer reset happened | ||
520 | * after we turn interrupts back on. | ||
521 | */ | ||
522 | dev->reset_printer = 0; | ||
523 | |||
524 | setup_rx_reqs(dev); | ||
525 | |||
526 | bytes_copied = 0; | ||
527 | current_rx_req = dev->current_rx_req; | ||
528 | current_rx_bytes = dev->current_rx_bytes; | ||
529 | current_rx_buf = dev->current_rx_buf; | ||
530 | dev->current_rx_req = NULL; | ||
531 | dev->current_rx_bytes = 0; | ||
532 | dev->current_rx_buf = NULL; | ||
533 | |||
534 | /* Check if there is any data in the read buffers. Please note that | ||
535 | * current_rx_bytes is the number of bytes in the current rx buffer. | ||
536 | * If it is zero then check if there are any other rx_buffers that | ||
537 | * are on the completed list. We are only out of data if all rx | ||
538 | * buffers are empty. | ||
539 | */ | ||
540 | if ((current_rx_bytes == 0) && | ||
541 | (likely(list_empty(&dev->rx_buffers)))) { | ||
542 | /* Turn interrupts back on before sleeping. */ | ||
543 | spin_unlock_irqrestore(&dev->lock, flags); | ||
544 | |||
545 | /* | ||
546 | * If no data is available check if this is a NON-Blocking | ||
547 | * call or not. | ||
548 | */ | ||
549 | if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) { | ||
550 | mutex_unlock(&dev->lock_printer_io); | ||
551 | return -EAGAIN; | ||
552 | } | ||
553 | |||
554 | /* Sleep until data is available */ | ||
555 | wait_event_interruptible(dev->rx_wait, | ||
556 | (likely(!list_empty(&dev->rx_buffers)))); | ||
557 | spin_lock_irqsave(&dev->lock, flags); | ||
558 | } | ||
559 | |||
560 | /* We have data to return then copy it to the caller's buffer.*/ | ||
561 | while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers))) | ||
562 | && len) { | ||
563 | if (current_rx_bytes == 0) { | ||
564 | req = container_of(dev->rx_buffers.next, | ||
565 | struct usb_request, list); | ||
566 | list_del_init(&req->list); | ||
567 | |||
568 | if (req->actual && req->buf) { | ||
569 | current_rx_req = req; | ||
570 | current_rx_bytes = req->actual; | ||
571 | current_rx_buf = req->buf; | ||
572 | } else { | ||
573 | list_add(&req->list, &dev->rx_reqs); | ||
574 | continue; | ||
575 | } | ||
576 | } | ||
577 | |||
578 | /* Don't leave irqs off while doing memory copies */ | ||
579 | spin_unlock_irqrestore(&dev->lock, flags); | ||
580 | |||
581 | if (len > current_rx_bytes) | ||
582 | size = current_rx_bytes; | ||
583 | else | ||
584 | size = len; | ||
585 | |||
586 | size -= copy_to_user(buf, current_rx_buf, size); | ||
587 | bytes_copied += size; | ||
588 | len -= size; | ||
589 | buf += size; | ||
590 | |||
591 | spin_lock_irqsave(&dev->lock, flags); | ||
592 | |||
593 | /* We've disconnected or reset so return. */ | ||
594 | if (dev->reset_printer) { | ||
595 | list_add(¤t_rx_req->list, &dev->rx_reqs); | ||
596 | spin_unlock_irqrestore(&dev->lock, flags); | ||
597 | mutex_unlock(&dev->lock_printer_io); | ||
598 | return -EAGAIN; | ||
599 | } | ||
600 | |||
601 | /* If we not returning all the data left in this RX request | ||
602 | * buffer then adjust the amount of data left in the buffer. | ||
603 | * Othewise if we are done with this RX request buffer then | ||
604 | * requeue it to get any incoming data from the USB host. | ||
605 | */ | ||
606 | if (size < current_rx_bytes) { | ||
607 | current_rx_bytes -= size; | ||
608 | current_rx_buf += size; | ||
609 | } else { | ||
610 | list_add(¤t_rx_req->list, &dev->rx_reqs); | ||
611 | current_rx_bytes = 0; | ||
612 | current_rx_buf = NULL; | ||
613 | current_rx_req = NULL; | ||
614 | } | ||
615 | } | ||
616 | |||
617 | dev->current_rx_req = current_rx_req; | ||
618 | dev->current_rx_bytes = current_rx_bytes; | ||
619 | dev->current_rx_buf = current_rx_buf; | ||
620 | |||
621 | spin_unlock_irqrestore(&dev->lock, flags); | ||
622 | mutex_unlock(&dev->lock_printer_io); | ||
623 | |||
624 | DBG(dev, "printer_read returned %d bytes\n", (int)bytes_copied); | ||
625 | |||
626 | if (bytes_copied) | ||
627 | return bytes_copied; | ||
628 | else | ||
629 | return -EAGAIN; | ||
630 | } | ||
631 | |||
632 | static ssize_t | ||
633 | printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr) | ||
634 | { | ||
635 | struct printer_dev *dev = fd->private_data; | ||
636 | unsigned long flags; | ||
637 | size_t size; /* Amount of data in a TX request. */ | ||
638 | size_t bytes_copied = 0; | ||
639 | struct usb_request *req; | ||
640 | |||
641 | DBG(dev, "printer_write trying to send %d bytes\n", (int)len); | ||
642 | |||
643 | if (len == 0) | ||
644 | return -EINVAL; | ||
645 | |||
646 | mutex_lock(&dev->lock_printer_io); | ||
647 | spin_lock_irqsave(&dev->lock, flags); | ||
648 | |||
649 | /* Check if a printer reset happens while we have interrupts on */ | ||
650 | dev->reset_printer = 0; | ||
651 | |||
652 | /* Check if there is any available write buffers */ | ||
653 | if (likely(list_empty(&dev->tx_reqs))) { | ||
654 | /* Turn interrupts back on before sleeping. */ | ||
655 | spin_unlock_irqrestore(&dev->lock, flags); | ||
656 | |||
657 | /* | ||
658 | * If write buffers are available check if this is | ||
659 | * a NON-Blocking call or not. | ||
660 | */ | ||
661 | if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) { | ||
662 | mutex_unlock(&dev->lock_printer_io); | ||
663 | return -EAGAIN; | ||
664 | } | ||
665 | |||
666 | /* Sleep until a write buffer is available */ | ||
667 | wait_event_interruptible(dev->tx_wait, | ||
668 | (likely(!list_empty(&dev->tx_reqs)))); | ||
669 | spin_lock_irqsave(&dev->lock, flags); | ||
670 | } | ||
671 | |||
672 | while (likely(!list_empty(&dev->tx_reqs)) && len) { | ||
673 | |||
674 | if (len > USB_BUFSIZE) | ||
675 | size = USB_BUFSIZE; | ||
676 | else | ||
677 | size = len; | ||
678 | |||
679 | req = container_of(dev->tx_reqs.next, struct usb_request, | ||
680 | list); | ||
681 | list_del_init(&req->list); | ||
682 | |||
683 | req->complete = tx_complete; | ||
684 | req->length = size; | ||
685 | |||
686 | /* Check if we need to send a zero length packet. */ | ||
687 | if (len > size) | ||
688 | /* They will be more TX requests so no yet. */ | ||
689 | req->zero = 0; | ||
690 | else | ||
691 | /* If the data amount is not a multple of the | ||
692 | * maxpacket size then send a zero length packet. | ||
693 | */ | ||
694 | req->zero = ((len % dev->in_ep->maxpacket) == 0); | ||
695 | |||
696 | /* Don't leave irqs off while doing memory copies */ | ||
697 | spin_unlock_irqrestore(&dev->lock, flags); | ||
698 | |||
699 | if (copy_from_user(req->buf, buf, size)) { | ||
700 | list_add(&req->list, &dev->tx_reqs); | ||
701 | mutex_unlock(&dev->lock_printer_io); | ||
702 | return bytes_copied; | ||
703 | } | ||
704 | |||
705 | bytes_copied += size; | ||
706 | len -= size; | ||
707 | buf += size; | ||
708 | |||
709 | spin_lock_irqsave(&dev->lock, flags); | ||
710 | |||
711 | /* We've disconnected or reset so free the req and buffer */ | ||
712 | if (dev->reset_printer) { | ||
713 | list_add(&req->list, &dev->tx_reqs); | ||
714 | spin_unlock_irqrestore(&dev->lock, flags); | ||
715 | mutex_unlock(&dev->lock_printer_io); | ||
716 | return -EAGAIN; | ||
717 | } | ||
718 | |||
719 | if (usb_ep_queue(dev->in_ep, req, GFP_ATOMIC)) { | ||
720 | list_add(&req->list, &dev->tx_reqs); | ||
721 | spin_unlock_irqrestore(&dev->lock, flags); | ||
722 | mutex_unlock(&dev->lock_printer_io); | ||
723 | return -EAGAIN; | ||
724 | } | ||
725 | |||
726 | list_add(&req->list, &dev->tx_reqs_active); | ||
727 | |||
728 | } | ||
729 | |||
730 | spin_unlock_irqrestore(&dev->lock, flags); | ||
731 | mutex_unlock(&dev->lock_printer_io); | ||
732 | |||
733 | DBG(dev, "printer_write sent %d bytes\n", (int)bytes_copied); | ||
734 | |||
735 | if (bytes_copied) { | ||
736 | return bytes_copied; | ||
737 | } else { | ||
738 | return -EAGAIN; | ||
739 | } | ||
740 | } | ||
741 | |||
742 | static int | ||
743 | printer_fsync(struct file *fd, loff_t start, loff_t end, int datasync) | ||
744 | { | ||
745 | struct printer_dev *dev = fd->private_data; | ||
746 | struct inode *inode = file_inode(fd); | ||
747 | unsigned long flags; | ||
748 | int tx_list_empty; | ||
749 | |||
750 | mutex_lock(&inode->i_mutex); | ||
751 | spin_lock_irqsave(&dev->lock, flags); | ||
752 | tx_list_empty = (likely(list_empty(&dev->tx_reqs))); | ||
753 | spin_unlock_irqrestore(&dev->lock, flags); | ||
754 | |||
755 | if (!tx_list_empty) { | ||
756 | /* Sleep until all data has been sent */ | ||
757 | wait_event_interruptible(dev->tx_flush_wait, | ||
758 | (likely(list_empty(&dev->tx_reqs_active)))); | ||
759 | } | ||
760 | mutex_unlock(&inode->i_mutex); | ||
761 | |||
762 | return 0; | ||
763 | } | ||
764 | |||
765 | static unsigned int | ||
766 | printer_poll(struct file *fd, poll_table *wait) | ||
767 | { | ||
768 | struct printer_dev *dev = fd->private_data; | ||
769 | unsigned long flags; | ||
770 | int status = 0; | ||
771 | |||
772 | mutex_lock(&dev->lock_printer_io); | ||
773 | spin_lock_irqsave(&dev->lock, flags); | ||
774 | setup_rx_reqs(dev); | ||
775 | spin_unlock_irqrestore(&dev->lock, flags); | ||
776 | mutex_unlock(&dev->lock_printer_io); | ||
777 | |||
778 | poll_wait(fd, &dev->rx_wait, wait); | ||
779 | poll_wait(fd, &dev->tx_wait, wait); | ||
780 | |||
781 | spin_lock_irqsave(&dev->lock, flags); | ||
782 | if (likely(!list_empty(&dev->tx_reqs))) | ||
783 | status |= POLLOUT | POLLWRNORM; | ||
784 | |||
785 | if (likely(dev->current_rx_bytes) || | ||
786 | likely(!list_empty(&dev->rx_buffers))) | ||
787 | status |= POLLIN | POLLRDNORM; | ||
788 | |||
789 | spin_unlock_irqrestore(&dev->lock, flags); | ||
790 | |||
791 | return status; | ||
792 | } | ||
793 | |||
794 | static long | ||
795 | printer_ioctl(struct file *fd, unsigned int code, unsigned long arg) | ||
796 | { | ||
797 | struct printer_dev *dev = fd->private_data; | ||
798 | unsigned long flags; | ||
799 | int status = 0; | ||
800 | |||
801 | DBG(dev, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code, arg); | ||
802 | |||
803 | /* handle ioctls */ | ||
804 | |||
805 | spin_lock_irqsave(&dev->lock, flags); | ||
806 | |||
807 | switch (code) { | ||
808 | case GADGET_GET_PRINTER_STATUS: | ||
809 | status = (int)dev->printer_status; | ||
810 | break; | ||
811 | case GADGET_SET_PRINTER_STATUS: | ||
812 | dev->printer_status = (u8)arg; | ||
813 | break; | ||
814 | default: | ||
815 | /* could not handle ioctl */ | ||
816 | DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n", | ||
817 | code); | ||
818 | status = -ENOTTY; | ||
819 | } | ||
820 | |||
821 | spin_unlock_irqrestore(&dev->lock, flags); | ||
822 | |||
823 | return status; | ||
824 | } | ||
825 | |||
826 | /* used after endpoint configuration */ | ||
827 | static const struct file_operations printer_io_operations = { | ||
828 | .owner = THIS_MODULE, | ||
829 | .open = printer_open, | ||
830 | .read = printer_read, | ||
831 | .write = printer_write, | ||
832 | .fsync = printer_fsync, | ||
833 | .poll = printer_poll, | ||
834 | .unlocked_ioctl = printer_ioctl, | ||
835 | .release = printer_close, | ||
836 | .llseek = noop_llseek, | ||
837 | }; | ||
838 | |||
839 | /*-------------------------------------------------------------------------*/ | ||
840 | |||
841 | static int | ||
842 | set_printer_interface(struct printer_dev *dev) | ||
843 | { | ||
844 | int result = 0; | ||
845 | |||
846 | dev->in_ep->desc = ep_desc(dev->gadget, &fs_ep_in_desc, &hs_ep_in_desc, | ||
847 | &ss_ep_in_desc); | ||
848 | dev->in_ep->driver_data = dev; | ||
849 | |||
850 | dev->out_ep->desc = ep_desc(dev->gadget, &fs_ep_out_desc, | ||
851 | &hs_ep_out_desc, &ss_ep_out_desc); | ||
852 | dev->out_ep->driver_data = dev; | ||
853 | |||
854 | result = usb_ep_enable(dev->in_ep); | ||
855 | if (result != 0) { | ||
856 | DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result); | ||
857 | goto done; | ||
858 | } | ||
859 | |||
860 | result = usb_ep_enable(dev->out_ep); | ||
861 | if (result != 0) { | ||
862 | DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result); | ||
863 | goto done; | ||
864 | } | ||
865 | |||
866 | done: | ||
867 | /* on error, disable any endpoints */ | ||
868 | if (result != 0) { | ||
869 | (void) usb_ep_disable(dev->in_ep); | ||
870 | (void) usb_ep_disable(dev->out_ep); | ||
871 | dev->in_ep->desc = NULL; | ||
872 | dev->out_ep->desc = NULL; | ||
873 | } | ||
874 | |||
875 | /* caller is responsible for cleanup on error */ | ||
876 | return result; | ||
877 | } | ||
878 | |||
879 | static void printer_reset_interface(struct printer_dev *dev) | ||
880 | { | ||
881 | if (dev->interface < 0) | ||
882 | return; | ||
883 | |||
884 | DBG(dev, "%s\n", __func__); | ||
885 | |||
886 | if (dev->in_ep->desc) | ||
887 | usb_ep_disable(dev->in_ep); | ||
888 | |||
889 | if (dev->out_ep->desc) | ||
890 | usb_ep_disable(dev->out_ep); | ||
891 | |||
892 | dev->in_ep->desc = NULL; | ||
893 | dev->out_ep->desc = NULL; | ||
894 | dev->interface = -1; | ||
895 | } | ||
896 | |||
897 | /* Change our operational Interface. */ | ||
898 | static int set_interface(struct printer_dev *dev, unsigned number) | ||
899 | { | ||
900 | int result = 0; | ||
901 | |||
902 | /* Free the current interface */ | ||
903 | printer_reset_interface(dev); | ||
904 | |||
905 | result = set_printer_interface(dev); | ||
906 | if (result) | ||
907 | printer_reset_interface(dev); | ||
908 | else | ||
909 | dev->interface = number; | ||
910 | |||
911 | if (!result) | ||
912 | INFO(dev, "Using interface %x\n", number); | ||
913 | |||
914 | return result; | ||
915 | } | ||
916 | |||
917 | static void printer_soft_reset(struct printer_dev *dev) | ||
918 | { | ||
919 | struct usb_request *req; | ||
920 | |||
921 | INFO(dev, "Received Printer Reset Request\n"); | ||
922 | |||
923 | if (usb_ep_disable(dev->in_ep)) | ||
924 | DBG(dev, "Failed to disable USB in_ep\n"); | ||
925 | if (usb_ep_disable(dev->out_ep)) | ||
926 | DBG(dev, "Failed to disable USB out_ep\n"); | ||
927 | |||
928 | if (dev->current_rx_req != NULL) { | ||
929 | list_add(&dev->current_rx_req->list, &dev->rx_reqs); | ||
930 | dev->current_rx_req = NULL; | ||
931 | } | ||
932 | dev->current_rx_bytes = 0; | ||
933 | dev->current_rx_buf = NULL; | ||
934 | dev->reset_printer = 1; | ||
935 | |||
936 | while (likely(!(list_empty(&dev->rx_buffers)))) { | ||
937 | req = container_of(dev->rx_buffers.next, struct usb_request, | ||
938 | list); | ||
939 | list_del_init(&req->list); | ||
940 | list_add(&req->list, &dev->rx_reqs); | ||
941 | } | ||
942 | |||
943 | while (likely(!(list_empty(&dev->rx_reqs_active)))) { | ||
944 | req = container_of(dev->rx_buffers.next, struct usb_request, | ||
945 | list); | ||
946 | list_del_init(&req->list); | ||
947 | list_add(&req->list, &dev->rx_reqs); | ||
948 | } | ||
949 | |||
950 | while (likely(!(list_empty(&dev->tx_reqs_active)))) { | ||
951 | req = container_of(dev->tx_reqs_active.next, | ||
952 | struct usb_request, list); | ||
953 | list_del_init(&req->list); | ||
954 | list_add(&req->list, &dev->tx_reqs); | ||
955 | } | ||
956 | |||
957 | if (usb_ep_enable(dev->in_ep)) | ||
958 | DBG(dev, "Failed to enable USB in_ep\n"); | ||
959 | if (usb_ep_enable(dev->out_ep)) | ||
960 | DBG(dev, "Failed to enable USB out_ep\n"); | ||
961 | |||
962 | wake_up_interruptible(&dev->rx_wait); | ||
963 | wake_up_interruptible(&dev->tx_wait); | ||
964 | wake_up_interruptible(&dev->tx_flush_wait); | ||
965 | } | ||
966 | |||
967 | /*-------------------------------------------------------------------------*/ | ||
968 | |||
969 | /* | ||
970 | * The setup() callback implements all the ep0 functionality that's not | ||
971 | * handled lower down. | ||
972 | */ | ||
973 | static int printer_func_setup(struct usb_function *f, | ||
974 | const struct usb_ctrlrequest *ctrl) | ||
975 | { | ||
976 | struct printer_dev *dev = container_of(f, struct printer_dev, function); | ||
977 | struct usb_composite_dev *cdev = f->config->cdev; | ||
978 | struct usb_request *req = cdev->req; | ||
979 | int value = -EOPNOTSUPP; | ||
980 | u16 wIndex = le16_to_cpu(ctrl->wIndex); | ||
981 | u16 wValue = le16_to_cpu(ctrl->wValue); | ||
982 | u16 wLength = le16_to_cpu(ctrl->wLength); | ||
983 | |||
984 | DBG(dev, "ctrl req%02x.%02x v%04x i%04x l%d\n", | ||
985 | ctrl->bRequestType, ctrl->bRequest, wValue, wIndex, wLength); | ||
986 | |||
987 | switch (ctrl->bRequestType&USB_TYPE_MASK) { | ||
988 | case USB_TYPE_CLASS: | ||
989 | switch (ctrl->bRequest) { | ||
990 | case 0: /* Get the IEEE-1284 PNP String */ | ||
991 | /* Only one printer interface is supported. */ | ||
992 | if ((wIndex>>8) != dev->interface) | ||
993 | break; | ||
994 | |||
995 | value = (pnp_string[0]<<8)|pnp_string[1]; | ||
996 | memcpy(req->buf, pnp_string, value); | ||
997 | DBG(dev, "1284 PNP String: %x %s\n", value, | ||
998 | &pnp_string[2]); | ||
999 | break; | ||
1000 | |||
1001 | case 1: /* Get Port Status */ | ||
1002 | /* Only one printer interface is supported. */ | ||
1003 | if (wIndex != dev->interface) | ||
1004 | break; | ||
1005 | |||
1006 | *(u8 *)req->buf = dev->printer_status; | ||
1007 | value = min(wLength, (u16) 1); | ||
1008 | break; | ||
1009 | |||
1010 | case 2: /* Soft Reset */ | ||
1011 | /* Only one printer interface is supported. */ | ||
1012 | if (wIndex != dev->interface) | ||
1013 | break; | ||
1014 | |||
1015 | printer_soft_reset(dev); | ||
1016 | |||
1017 | value = 0; | ||
1018 | break; | ||
1019 | |||
1020 | default: | ||
1021 | goto unknown; | ||
1022 | } | ||
1023 | break; | ||
1024 | |||
1025 | default: | ||
1026 | unknown: | ||
1027 | VDBG(dev, | ||
1028 | "unknown ctrl req%02x.%02x v%04x i%04x l%d\n", | ||
1029 | ctrl->bRequestType, ctrl->bRequest, | ||
1030 | wValue, wIndex, wLength); | ||
1031 | break; | ||
1032 | } | ||
1033 | /* host either stalls (value < 0) or reports success */ | ||
1034 | return value; | ||
1035 | } | ||
1036 | |||
1037 | static int __init printer_func_bind(struct usb_configuration *c, | ||
1038 | struct usb_function *f) | ||
1039 | { | ||
1040 | struct printer_dev *dev = container_of(f, struct printer_dev, function); | ||
1041 | struct usb_composite_dev *cdev = c->cdev; | ||
1042 | struct usb_ep *in_ep; | ||
1043 | struct usb_ep *out_ep = NULL; | ||
1044 | int id; | ||
1045 | int ret; | ||
1046 | |||
1047 | id = usb_interface_id(c, f); | ||
1048 | if (id < 0) | ||
1049 | return id; | ||
1050 | intf_desc.bInterfaceNumber = id; | ||
1051 | |||
1052 | /* all we really need is bulk IN/OUT */ | ||
1053 | in_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_in_desc); | ||
1054 | if (!in_ep) { | ||
1055 | autoconf_fail: | ||
1056 | dev_err(&cdev->gadget->dev, "can't autoconfigure on %s\n", | ||
1057 | cdev->gadget->name); | ||
1058 | return -ENODEV; | ||
1059 | } | ||
1060 | in_ep->driver_data = in_ep; /* claim */ | ||
1061 | |||
1062 | out_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_out_desc); | ||
1063 | if (!out_ep) | ||
1064 | goto autoconf_fail; | ||
1065 | out_ep->driver_data = out_ep; /* claim */ | ||
1066 | |||
1067 | /* assumes that all endpoints are dual-speed */ | ||
1068 | hs_ep_in_desc.bEndpointAddress = fs_ep_in_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; | ||
1072 | |||
1073 | ret = usb_assign_descriptors(f, fs_printer_function, | ||
1074 | hs_printer_function, ss_printer_function); | ||
1075 | if (ret) | ||
1076 | return ret; | ||
1077 | |||
1078 | dev->in_ep = in_ep; | ||
1079 | dev->out_ep = out_ep; | ||
1080 | return 0; | ||
1081 | } | ||
1082 | |||
1083 | static void printer_func_unbind(struct usb_configuration *c, | ||
1084 | struct usb_function *f) | ||
1085 | { | ||
1086 | usb_free_all_descriptors(f); | ||
1087 | } | ||
1088 | |||
1089 | static int printer_func_set_alt(struct usb_function *f, | ||
1090 | unsigned intf, unsigned alt) | ||
1091 | { | ||
1092 | struct printer_dev *dev = container_of(f, struct printer_dev, function); | ||
1093 | int ret = -ENOTSUPP; | ||
1094 | |||
1095 | if (!alt) | ||
1096 | ret = set_interface(dev, intf); | ||
1097 | |||
1098 | return ret; | ||
1099 | } | ||
1100 | |||
1101 | static void printer_func_disable(struct usb_function *f) | ||
1102 | { | ||
1103 | struct printer_dev *dev = container_of(f, struct printer_dev, function); | ||
1104 | unsigned long flags; | ||
1105 | |||
1106 | DBG(dev, "%s\n", __func__); | ||
1107 | |||
1108 | spin_lock_irqsave(&dev->lock, flags); | ||
1109 | printer_reset_interface(dev); | ||
1110 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1111 | } | ||
1112 | |||
1113 | static void printer_cfg_unbind(struct usb_configuration *c) | ||
1114 | { | ||
1115 | struct printer_dev *dev; | ||
1116 | struct usb_request *req; | ||
1117 | |||
1118 | dev = &usb_printer_gadget; | ||
1119 | |||
1120 | DBG(dev, "%s\n", __func__); | ||
1121 | |||
1122 | /* Remove sysfs files */ | ||
1123 | device_destroy(usb_gadget_class, g_printer_devno); | ||
1124 | |||
1125 | /* Remove Character Device */ | ||
1126 | cdev_del(&dev->printer_cdev); | ||
1127 | |||
1128 | /* we must already have been disconnected ... no i/o may be active */ | ||
1129 | WARN_ON(!list_empty(&dev->tx_reqs_active)); | ||
1130 | WARN_ON(!list_empty(&dev->rx_reqs_active)); | ||
1131 | |||
1132 | /* Free all memory for this driver. */ | ||
1133 | while (!list_empty(&dev->tx_reqs)) { | ||
1134 | req = container_of(dev->tx_reqs.next, struct usb_request, | ||
1135 | list); | ||
1136 | list_del(&req->list); | ||
1137 | printer_req_free(dev->in_ep, req); | ||
1138 | } | ||
1139 | |||
1140 | if (dev->current_rx_req != NULL) | ||
1141 | printer_req_free(dev->out_ep, dev->current_rx_req); | ||
1142 | |||
1143 | while (!list_empty(&dev->rx_reqs)) { | ||
1144 | req = container_of(dev->rx_reqs.next, | ||
1145 | struct usb_request, list); | ||
1146 | list_del(&req->list); | ||
1147 | printer_req_free(dev->out_ep, req); | ||
1148 | } | ||
1149 | |||
1150 | while (!list_empty(&dev->rx_buffers)) { | ||
1151 | req = container_of(dev->rx_buffers.next, | ||
1152 | struct usb_request, list); | ||
1153 | list_del(&req->list); | ||
1154 | printer_req_free(dev->out_ep, req); | ||
1155 | } | ||
1156 | } | ||
1157 | |||
1158 | static struct usb_configuration printer_cfg_driver = { | 123 | static struct usb_configuration printer_cfg_driver = { |
1159 | .label = "printer", | 124 | .label = "printer", |
1160 | .unbind = printer_cfg_unbind, | ||
1161 | .bConfigurationValue = 1, | 125 | .bConfigurationValue = 1, |
1162 | .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, | 126 | .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, |
1163 | }; | 127 | }; |
1164 | 128 | ||
1165 | static int __init printer_bind_config(struct usb_configuration *c) | 129 | static int __init printer_do_config(struct usb_configuration *c) |
1166 | { | 130 | { |
1167 | struct usb_gadget *gadget = c->cdev->gadget; | 131 | struct usb_gadget *gadget = c->cdev->gadget; |
1168 | struct printer_dev *dev; | 132 | int status = 0; |
1169 | int status = -ENOMEM; | ||
1170 | size_t len; | ||
1171 | u32 i; | ||
1172 | struct usb_request *req; | ||
1173 | 133 | ||
1174 | usb_ep_autoconfig_reset(gadget); | 134 | usb_ep_autoconfig_reset(gadget); |
1175 | 135 | ||
1176 | dev = &usb_printer_gadget; | ||
1177 | |||
1178 | dev->function.name = shortname; | ||
1179 | dev->function.bind = printer_func_bind; | ||
1180 | dev->function.setup = printer_func_setup; | ||
1181 | dev->function.unbind = printer_func_unbind; | ||
1182 | dev->function.set_alt = printer_func_set_alt; | ||
1183 | dev->function.disable = printer_func_disable; | ||
1184 | |||
1185 | status = usb_add_function(c, &dev->function); | ||
1186 | if (status) | ||
1187 | return status; | ||
1188 | |||
1189 | /* Setup the sysfs files for the printer gadget. */ | ||
1190 | dev->pdev = device_create(usb_gadget_class, NULL, g_printer_devno, | ||
1191 | NULL, "g_printer"); | ||
1192 | if (IS_ERR(dev->pdev)) { | ||
1193 | ERROR(dev, "Failed to create device: g_printer\n"); | ||
1194 | status = PTR_ERR(dev->pdev); | ||
1195 | goto fail; | ||
1196 | } | ||
1197 | |||
1198 | /* | ||
1199 | * Register a character device as an interface to a user mode | ||
1200 | * program that handles the printer specific functionality. | ||
1201 | */ | ||
1202 | cdev_init(&dev->printer_cdev, &printer_io_operations); | ||
1203 | dev->printer_cdev.owner = THIS_MODULE; | ||
1204 | status = cdev_add(&dev->printer_cdev, g_printer_devno, 1); | ||
1205 | if (status) { | ||
1206 | ERROR(dev, "Failed to open char device\n"); | ||
1207 | goto fail; | ||
1208 | } | ||
1209 | |||
1210 | if (iPNPstring) | ||
1211 | strlcpy(&pnp_string[2], iPNPstring, (sizeof pnp_string)-2); | ||
1212 | |||
1213 | len = strlen(pnp_string); | ||
1214 | pnp_string[0] = (len >> 8) & 0xFF; | ||
1215 | pnp_string[1] = len & 0xFF; | ||
1216 | |||
1217 | usb_gadget_set_selfpowered(gadget); | 136 | usb_gadget_set_selfpowered(gadget); |
1218 | 137 | ||
1219 | if (gadget_is_otg(gadget)) { | 138 | if (gadget_is_otg(gadget)) { |
@@ -1222,86 +141,64 @@ static int __init printer_bind_config(struct usb_configuration *c) | |||
1222 | printer_cfg_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; | 141 | printer_cfg_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; |
1223 | } | 142 | } |
1224 | 143 | ||
1225 | spin_lock_init(&dev->lock); | 144 | f_printer = usb_get_function(fi_printer); |
1226 | mutex_init(&dev->lock_printer_io); | 145 | if (IS_ERR(f_printer)) |
1227 | INIT_LIST_HEAD(&dev->tx_reqs); | 146 | return PTR_ERR(f_printer); |
1228 | INIT_LIST_HEAD(&dev->tx_reqs_active); | ||
1229 | INIT_LIST_HEAD(&dev->rx_reqs); | ||
1230 | INIT_LIST_HEAD(&dev->rx_reqs_active); | ||
1231 | INIT_LIST_HEAD(&dev->rx_buffers); | ||
1232 | init_waitqueue_head(&dev->rx_wait); | ||
1233 | init_waitqueue_head(&dev->tx_wait); | ||
1234 | init_waitqueue_head(&dev->tx_flush_wait); | ||
1235 | |||
1236 | dev->interface = -1; | ||
1237 | dev->printer_cdev_open = 0; | ||
1238 | dev->printer_status = PRINTER_NOT_ERROR; | ||
1239 | dev->current_rx_req = NULL; | ||
1240 | dev->current_rx_bytes = 0; | ||
1241 | dev->current_rx_buf = NULL; | ||
1242 | |||
1243 | for (i = 0; i < QLEN; i++) { | ||
1244 | req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL); | ||
1245 | if (!req) { | ||
1246 | while (!list_empty(&dev->tx_reqs)) { | ||
1247 | req = container_of(dev->tx_reqs.next, | ||
1248 | struct usb_request, list); | ||
1249 | list_del(&req->list); | ||
1250 | printer_req_free(dev->in_ep, req); | ||
1251 | } | ||
1252 | return -ENOMEM; | ||
1253 | } | ||
1254 | list_add(&req->list, &dev->tx_reqs); | ||
1255 | } | ||
1256 | |||
1257 | for (i = 0; i < QLEN; i++) { | ||
1258 | req = printer_req_alloc(dev->out_ep, USB_BUFSIZE, GFP_KERNEL); | ||
1259 | if (!req) { | ||
1260 | while (!list_empty(&dev->rx_reqs)) { | ||
1261 | req = container_of(dev->rx_reqs.next, | ||
1262 | struct usb_request, list); | ||
1263 | list_del(&req->list); | ||
1264 | printer_req_free(dev->out_ep, req); | ||
1265 | } | ||
1266 | return -ENOMEM; | ||
1267 | } | ||
1268 | list_add(&req->list, &dev->rx_reqs); | ||
1269 | } | ||
1270 | |||
1271 | /* finish hookup to lower layer ... */ | ||
1272 | dev->gadget = gadget; | ||
1273 | 147 | ||
1274 | INFO(dev, "%s, version: " DRIVER_VERSION "\n", driver_desc); | 148 | status = usb_add_function(c, f_printer); |
1275 | return 0; | 149 | if (status < 0) |
150 | usb_put_function(f_printer); | ||
1276 | 151 | ||
1277 | fail: | ||
1278 | printer_cfg_unbind(c); | ||
1279 | return status; | 152 | return status; |
1280 | } | 153 | } |
1281 | 154 | ||
1282 | static int printer_unbind(struct usb_composite_dev *cdev) | ||
1283 | { | ||
1284 | return 0; | ||
1285 | } | ||
1286 | |||
1287 | static int __init printer_bind(struct usb_composite_dev *cdev) | 155 | static int __init printer_bind(struct usb_composite_dev *cdev) |
1288 | { | 156 | { |
1289 | int ret; | 157 | struct f_printer_opts *opts; |
158 | int ret, len; | ||
159 | |||
160 | fi_printer = usb_get_function_instance("printer"); | ||
161 | if (IS_ERR(fi_printer)) | ||
162 | return PTR_ERR(fi_printer); | ||
163 | |||
164 | if (iPNPstring) | ||
165 | strlcpy(&pnp_string[2], iPNPstring, PNP_STRING_LEN - 2); | ||
166 | |||
167 | len = strlen(pnp_string); | ||
168 | pnp_string[0] = (len >> 8) & 0xFF; | ||
169 | pnp_string[1] = len & 0xFF; | ||
170 | |||
171 | opts = container_of(fi_printer, struct f_printer_opts, func_inst); | ||
172 | opts->minor = 0; | ||
173 | memcpy(opts->pnp_string, pnp_string, PNP_STRING_LEN); | ||
174 | opts->q_len = QLEN; | ||
1290 | 175 | ||
1291 | ret = usb_string_ids_tab(cdev, strings); | 176 | ret = usb_string_ids_tab(cdev, strings); |
1292 | if (ret < 0) | 177 | if (ret < 0) { |
178 | usb_put_function_instance(fi_printer); | ||
1293 | return ret; | 179 | return ret; |
180 | } | ||
1294 | device_desc.iManufacturer = strings[USB_GADGET_MANUFACTURER_IDX].id; | 181 | device_desc.iManufacturer = strings[USB_GADGET_MANUFACTURER_IDX].id; |
1295 | device_desc.iProduct = strings[USB_GADGET_PRODUCT_IDX].id; | 182 | device_desc.iProduct = strings[USB_GADGET_PRODUCT_IDX].id; |
1296 | device_desc.iSerialNumber = strings[USB_GADGET_SERIAL_IDX].id; | 183 | device_desc.iSerialNumber = strings[USB_GADGET_SERIAL_IDX].id; |
1297 | 184 | ||
1298 | ret = usb_add_config(cdev, &printer_cfg_driver, printer_bind_config); | 185 | ret = usb_add_config(cdev, &printer_cfg_driver, printer_do_config); |
1299 | if (ret) | 186 | if (ret) { |
187 | usb_put_function_instance(fi_printer); | ||
1300 | return ret; | 188 | return ret; |
189 | } | ||
1301 | usb_composite_overwrite_options(cdev, &coverwrite); | 190 | usb_composite_overwrite_options(cdev, &coverwrite); |
1302 | return ret; | 191 | return ret; |
1303 | } | 192 | } |
1304 | 193 | ||
194 | static int __exit printer_unbind(struct usb_composite_dev *cdev) | ||
195 | { | ||
196 | usb_put_function(f_printer); | ||
197 | usb_put_function_instance(fi_printer); | ||
198 | |||
199 | return 0; | ||
200 | } | ||
201 | |||
1305 | static __refdata struct usb_composite_driver printer_driver = { | 202 | static __refdata struct usb_composite_driver printer_driver = { |
1306 | .name = shortname, | 203 | .name = shortname, |
1307 | .dev = &device_desc, | 204 | .dev = &device_desc, |
@@ -1311,47 +208,7 @@ static __refdata struct usb_composite_driver printer_driver = { | |||
1311 | .unbind = printer_unbind, | 208 | .unbind = printer_unbind, |
1312 | }; | 209 | }; |
1313 | 210 | ||
1314 | static int __init | 211 | module_usb_composite_driver(printer_driver); |
1315 | init(void) | ||
1316 | { | ||
1317 | int status; | ||
1318 | |||
1319 | usb_gadget_class = class_create(THIS_MODULE, "usb_printer_gadget"); | ||
1320 | if (IS_ERR(usb_gadget_class)) { | ||
1321 | status = PTR_ERR(usb_gadget_class); | ||
1322 | pr_err("unable to create usb_gadget class %d\n", status); | ||
1323 | return status; | ||
1324 | } | ||
1325 | |||
1326 | status = alloc_chrdev_region(&g_printer_devno, 0, 1, | ||
1327 | "USB printer gadget"); | ||
1328 | if (status) { | ||
1329 | pr_err("alloc_chrdev_region %d\n", status); | ||
1330 | class_destroy(usb_gadget_class); | ||
1331 | return status; | ||
1332 | } | ||
1333 | |||
1334 | status = usb_composite_probe(&printer_driver); | ||
1335 | if (status) { | ||
1336 | class_destroy(usb_gadget_class); | ||
1337 | unregister_chrdev_region(g_printer_devno, 1); | ||
1338 | pr_err("usb_gadget_probe_driver %x\n", status); | ||
1339 | } | ||
1340 | |||
1341 | return status; | ||
1342 | } | ||
1343 | module_init(init); | ||
1344 | |||
1345 | static void __exit | ||
1346 | cleanup(void) | ||
1347 | { | ||
1348 | mutex_lock(&usb_printer_gadget.lock_printer_io); | ||
1349 | usb_composite_unregister(&printer_driver); | ||
1350 | unregister_chrdev_region(g_printer_devno, 1); | ||
1351 | class_destroy(usb_gadget_class); | ||
1352 | mutex_unlock(&usb_printer_gadget.lock_printer_io); | ||
1353 | } | ||
1354 | module_exit(cleanup); | ||
1355 | 212 | ||
1356 | MODULE_DESCRIPTION(DRIVER_DESC); | 213 | MODULE_DESCRIPTION(DRIVER_DESC); |
1357 | MODULE_AUTHOR("Craig Nadler"); | 214 | MODULE_AUTHOR("Craig Nadler"); |
diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.c b/drivers/usb/gadget/udc/atmel_usba_udc.c index d79cb35dbf8a..4c01953a0869 100644 --- a/drivers/usb/gadget/udc/atmel_usba_udc.c +++ b/drivers/usb/gadget/udc/atmel_usba_udc.c | |||
@@ -152,7 +152,7 @@ static int regs_dbg_open(struct inode *inode, struct file *file) | |||
152 | 152 | ||
153 | spin_lock_irq(&udc->lock); | 153 | spin_lock_irq(&udc->lock); |
154 | for (i = 0; i < inode->i_size / 4; i++) | 154 | for (i = 0; i < inode->i_size / 4; i++) |
155 | data[i] = __raw_readl(udc->regs + i * 4); | 155 | data[i] = usba_io_readl(udc->regs + i * 4); |
156 | spin_unlock_irq(&udc->lock); | 156 | spin_unlock_irq(&udc->lock); |
157 | 157 | ||
158 | file->private_data = data; | 158 | file->private_data = data; |
@@ -1249,7 +1249,7 @@ static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep, | |||
1249 | if (crq->wLength != cpu_to_le16(sizeof(status))) | 1249 | if (crq->wLength != cpu_to_le16(sizeof(status))) |
1250 | goto stall; | 1250 | goto stall; |
1251 | ep->state = DATA_STAGE_IN; | 1251 | ep->state = DATA_STAGE_IN; |
1252 | __raw_writew(status, ep->fifo); | 1252 | usba_io_writew(status, ep->fifo); |
1253 | usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY); | 1253 | usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY); |
1254 | break; | 1254 | break; |
1255 | } | 1255 | } |
@@ -1739,7 +1739,72 @@ static irqreturn_t usba_udc_irq(int irq, void *devid) | |||
1739 | return IRQ_HANDLED; | 1739 | return IRQ_HANDLED; |
1740 | } | 1740 | } |
1741 | 1741 | ||
1742 | static irqreturn_t usba_vbus_irq(int irq, void *devid) | 1742 | static int start_clock(struct usba_udc *udc) |
1743 | { | ||
1744 | int ret; | ||
1745 | |||
1746 | if (udc->clocked) | ||
1747 | return 0; | ||
1748 | |||
1749 | ret = clk_prepare_enable(udc->pclk); | ||
1750 | if (ret) | ||
1751 | return ret; | ||
1752 | ret = clk_prepare_enable(udc->hclk); | ||
1753 | if (ret) { | ||
1754 | clk_disable_unprepare(udc->pclk); | ||
1755 | return ret; | ||
1756 | } | ||
1757 | |||
1758 | udc->clocked = true; | ||
1759 | return 0; | ||
1760 | } | ||
1761 | |||
1762 | static void stop_clock(struct usba_udc *udc) | ||
1763 | { | ||
1764 | if (!udc->clocked) | ||
1765 | return; | ||
1766 | |||
1767 | clk_disable_unprepare(udc->hclk); | ||
1768 | clk_disable_unprepare(udc->pclk); | ||
1769 | |||
1770 | udc->clocked = false; | ||
1771 | } | ||
1772 | |||
1773 | static int usba_start(struct usba_udc *udc) | ||
1774 | { | ||
1775 | unsigned long flags; | ||
1776 | int ret; | ||
1777 | |||
1778 | ret = start_clock(udc); | ||
1779 | if (ret) | ||
1780 | return ret; | ||
1781 | |||
1782 | spin_lock_irqsave(&udc->lock, flags); | ||
1783 | toggle_bias(udc, 1); | ||
1784 | usba_writel(udc, CTRL, USBA_ENABLE_MASK); | ||
1785 | usba_int_enb_set(udc, USBA_END_OF_RESET); | ||
1786 | spin_unlock_irqrestore(&udc->lock, flags); | ||
1787 | |||
1788 | return 0; | ||
1789 | } | ||
1790 | |||
1791 | static void usba_stop(struct usba_udc *udc) | ||
1792 | { | ||
1793 | unsigned long flags; | ||
1794 | |||
1795 | spin_lock_irqsave(&udc->lock, flags); | ||
1796 | udc->gadget.speed = USB_SPEED_UNKNOWN; | ||
1797 | reset_all_endpoints(udc); | ||
1798 | |||
1799 | /* This will also disable the DP pullup */ | ||
1800 | toggle_bias(udc, 0); | ||
1801 | usba_writel(udc, CTRL, USBA_DISABLE_MASK); | ||
1802 | spin_unlock_irqrestore(&udc->lock, flags); | ||
1803 | |||
1804 | stop_clock(udc); | ||
1805 | } | ||
1806 | |||
1807 | static irqreturn_t usba_vbus_irq_thread(int irq, void *devid) | ||
1743 | { | 1808 | { |
1744 | struct usba_udc *udc = devid; | 1809 | struct usba_udc *udc = devid; |
1745 | int vbus; | 1810 | int vbus; |
@@ -1747,35 +1812,22 @@ static irqreturn_t usba_vbus_irq(int irq, void *devid) | |||
1747 | /* debounce */ | 1812 | /* debounce */ |
1748 | udelay(10); | 1813 | udelay(10); |
1749 | 1814 | ||
1750 | spin_lock(&udc->lock); | 1815 | mutex_lock(&udc->vbus_mutex); |
1751 | |||
1752 | /* May happen if Vbus pin toggles during probe() */ | ||
1753 | if (!udc->driver) | ||
1754 | goto out; | ||
1755 | 1816 | ||
1756 | vbus = vbus_is_present(udc); | 1817 | vbus = vbus_is_present(udc); |
1757 | if (vbus != udc->vbus_prev) { | 1818 | if (vbus != udc->vbus_prev) { |
1758 | if (vbus) { | 1819 | if (vbus) { |
1759 | toggle_bias(udc, 1); | 1820 | usba_start(udc); |
1760 | usba_writel(udc, CTRL, USBA_ENABLE_MASK); | ||
1761 | usba_int_enb_set(udc, USBA_END_OF_RESET); | ||
1762 | } else { | 1821 | } else { |
1763 | udc->gadget.speed = USB_SPEED_UNKNOWN; | 1822 | usba_stop(udc); |
1764 | reset_all_endpoints(udc); | 1823 | |
1765 | toggle_bias(udc, 0); | 1824 | if (udc->driver->disconnect) |
1766 | usba_writel(udc, CTRL, USBA_DISABLE_MASK); | ||
1767 | if (udc->driver->disconnect) { | ||
1768 | spin_unlock(&udc->lock); | ||
1769 | udc->driver->disconnect(&udc->gadget); | 1825 | udc->driver->disconnect(&udc->gadget); |
1770 | spin_lock(&udc->lock); | ||
1771 | } | ||
1772 | } | 1826 | } |
1773 | udc->vbus_prev = vbus; | 1827 | udc->vbus_prev = vbus; |
1774 | } | 1828 | } |
1775 | 1829 | ||
1776 | out: | 1830 | mutex_unlock(&udc->vbus_mutex); |
1777 | spin_unlock(&udc->lock); | ||
1778 | |||
1779 | return IRQ_HANDLED; | 1831 | return IRQ_HANDLED; |
1780 | } | 1832 | } |
1781 | 1833 | ||
@@ -1787,55 +1839,47 @@ static int atmel_usba_start(struct usb_gadget *gadget, | |||
1787 | unsigned long flags; | 1839 | unsigned long flags; |
1788 | 1840 | ||
1789 | spin_lock_irqsave(&udc->lock, flags); | 1841 | spin_lock_irqsave(&udc->lock, flags); |
1790 | |||
1791 | udc->devstatus = 1 << USB_DEVICE_SELF_POWERED; | 1842 | udc->devstatus = 1 << USB_DEVICE_SELF_POWERED; |
1792 | udc->driver = driver; | 1843 | udc->driver = driver; |
1793 | spin_unlock_irqrestore(&udc->lock, flags); | 1844 | spin_unlock_irqrestore(&udc->lock, flags); |
1794 | 1845 | ||
1795 | ret = clk_prepare_enable(udc->pclk); | 1846 | mutex_lock(&udc->vbus_mutex); |
1796 | if (ret) | ||
1797 | return ret; | ||
1798 | ret = clk_prepare_enable(udc->hclk); | ||
1799 | if (ret) { | ||
1800 | clk_disable_unprepare(udc->pclk); | ||
1801 | return ret; | ||
1802 | } | ||
1803 | 1847 | ||
1804 | udc->vbus_prev = 0; | ||
1805 | if (gpio_is_valid(udc->vbus_pin)) | 1848 | if (gpio_is_valid(udc->vbus_pin)) |
1806 | enable_irq(gpio_to_irq(udc->vbus_pin)); | 1849 | enable_irq(gpio_to_irq(udc->vbus_pin)); |
1807 | 1850 | ||
1808 | /* If Vbus is present, enable the controller and wait for reset */ | 1851 | /* If Vbus is present, enable the controller and wait for reset */ |
1809 | spin_lock_irqsave(&udc->lock, flags); | 1852 | udc->vbus_prev = vbus_is_present(udc); |
1810 | if (vbus_is_present(udc) && udc->vbus_prev == 0) { | 1853 | if (udc->vbus_prev) { |
1811 | toggle_bias(udc, 1); | 1854 | ret = usba_start(udc); |
1812 | usba_writel(udc, CTRL, USBA_ENABLE_MASK); | 1855 | if (ret) |
1813 | usba_int_enb_set(udc, USBA_END_OF_RESET); | 1856 | goto err; |
1814 | } | 1857 | } |
1815 | spin_unlock_irqrestore(&udc->lock, flags); | ||
1816 | 1858 | ||
1859 | mutex_unlock(&udc->vbus_mutex); | ||
1817 | return 0; | 1860 | return 0; |
1861 | |||
1862 | err: | ||
1863 | if (gpio_is_valid(udc->vbus_pin)) | ||
1864 | disable_irq(gpio_to_irq(udc->vbus_pin)); | ||
1865 | |||
1866 | mutex_unlock(&udc->vbus_mutex); | ||
1867 | |||
1868 | spin_lock_irqsave(&udc->lock, flags); | ||
1869 | udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED); | ||
1870 | udc->driver = NULL; | ||
1871 | spin_unlock_irqrestore(&udc->lock, flags); | ||
1872 | return ret; | ||
1818 | } | 1873 | } |
1819 | 1874 | ||
1820 | static int atmel_usba_stop(struct usb_gadget *gadget) | 1875 | static int atmel_usba_stop(struct usb_gadget *gadget) |
1821 | { | 1876 | { |
1822 | struct usba_udc *udc = container_of(gadget, struct usba_udc, gadget); | 1877 | struct usba_udc *udc = container_of(gadget, struct usba_udc, gadget); |
1823 | unsigned long flags; | ||
1824 | 1878 | ||
1825 | if (gpio_is_valid(udc->vbus_pin)) | 1879 | if (gpio_is_valid(udc->vbus_pin)) |
1826 | disable_irq(gpio_to_irq(udc->vbus_pin)); | 1880 | disable_irq(gpio_to_irq(udc->vbus_pin)); |
1827 | 1881 | ||
1828 | spin_lock_irqsave(&udc->lock, flags); | 1882 | usba_stop(udc); |
1829 | udc->gadget.speed = USB_SPEED_UNKNOWN; | ||
1830 | reset_all_endpoints(udc); | ||
1831 | spin_unlock_irqrestore(&udc->lock, flags); | ||
1832 | |||
1833 | /* This will also disable the DP pullup */ | ||
1834 | toggle_bias(udc, 0); | ||
1835 | usba_writel(udc, CTRL, USBA_DISABLE_MASK); | ||
1836 | |||
1837 | clk_disable_unprepare(udc->hclk); | ||
1838 | clk_disable_unprepare(udc->pclk); | ||
1839 | 1883 | ||
1840 | udc->driver = NULL; | 1884 | udc->driver = NULL; |
1841 | 1885 | ||
@@ -2057,6 +2101,7 @@ static int usba_udc_probe(struct platform_device *pdev) | |||
2057 | return PTR_ERR(hclk); | 2101 | return PTR_ERR(hclk); |
2058 | 2102 | ||
2059 | spin_lock_init(&udc->lock); | 2103 | spin_lock_init(&udc->lock); |
2104 | mutex_init(&udc->vbus_mutex); | ||
2060 | udc->pdev = pdev; | 2105 | udc->pdev = pdev; |
2061 | udc->pclk = pclk; | 2106 | udc->pclk = pclk; |
2062 | udc->hclk = hclk; | 2107 | udc->hclk = hclk; |
@@ -2111,17 +2156,17 @@ static int usba_udc_probe(struct platform_device *pdev) | |||
2111 | 2156 | ||
2112 | if (gpio_is_valid(udc->vbus_pin)) { | 2157 | if (gpio_is_valid(udc->vbus_pin)) { |
2113 | if (!devm_gpio_request(&pdev->dev, udc->vbus_pin, "atmel_usba_udc")) { | 2158 | if (!devm_gpio_request(&pdev->dev, udc->vbus_pin, "atmel_usba_udc")) { |
2114 | ret = devm_request_irq(&pdev->dev, | 2159 | irq_set_status_flags(gpio_to_irq(udc->vbus_pin), |
2115 | gpio_to_irq(udc->vbus_pin), | 2160 | IRQ_NOAUTOEN); |
2116 | usba_vbus_irq, 0, | 2161 | ret = devm_request_threaded_irq(&pdev->dev, |
2162 | gpio_to_irq(udc->vbus_pin), NULL, | ||
2163 | usba_vbus_irq_thread, IRQF_ONESHOT, | ||
2117 | "atmel_usba_udc", udc); | 2164 | "atmel_usba_udc", udc); |
2118 | if (ret) { | 2165 | if (ret) { |
2119 | udc->vbus_pin = -ENODEV; | 2166 | udc->vbus_pin = -ENODEV; |
2120 | dev_warn(&udc->pdev->dev, | 2167 | dev_warn(&udc->pdev->dev, |
2121 | "failed to request vbus irq; " | 2168 | "failed to request vbus irq; " |
2122 | "assuming always on\n"); | 2169 | "assuming always on\n"); |
2123 | } else { | ||
2124 | disable_irq(gpio_to_irq(udc->vbus_pin)); | ||
2125 | } | 2170 | } |
2126 | } else { | 2171 | } else { |
2127 | /* gpio_request fail so use -EINVAL for gpio_is_valid */ | 2172 | /* gpio_request fail so use -EINVAL for gpio_is_valid */ |
@@ -2132,6 +2177,7 @@ static int usba_udc_probe(struct platform_device *pdev) | |||
2132 | ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget); | 2177 | ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget); |
2133 | if (ret) | 2178 | if (ret) |
2134 | return ret; | 2179 | return ret; |
2180 | device_init_wakeup(&pdev->dev, 1); | ||
2135 | 2181 | ||
2136 | usba_init_debugfs(udc); | 2182 | usba_init_debugfs(udc); |
2137 | for (i = 1; i < udc->num_ep; i++) | 2183 | for (i = 1; i < udc->num_ep; i++) |
@@ -2147,6 +2193,7 @@ static int __exit usba_udc_remove(struct platform_device *pdev) | |||
2147 | 2193 | ||
2148 | udc = platform_get_drvdata(pdev); | 2194 | udc = platform_get_drvdata(pdev); |
2149 | 2195 | ||
2196 | device_init_wakeup(&pdev->dev, 0); | ||
2150 | usb_del_gadget_udc(&udc->gadget); | 2197 | usb_del_gadget_udc(&udc->gadget); |
2151 | 2198 | ||
2152 | for (i = 1; i < udc->num_ep; i++) | 2199 | for (i = 1; i < udc->num_ep; i++) |
@@ -2156,10 +2203,65 @@ static int __exit usba_udc_remove(struct platform_device *pdev) | |||
2156 | return 0; | 2203 | return 0; |
2157 | } | 2204 | } |
2158 | 2205 | ||
2206 | #ifdef CONFIG_PM | ||
2207 | static int usba_udc_suspend(struct device *dev) | ||
2208 | { | ||
2209 | struct usba_udc *udc = dev_get_drvdata(dev); | ||
2210 | |||
2211 | /* Not started */ | ||
2212 | if (!udc->driver) | ||
2213 | return 0; | ||
2214 | |||
2215 | mutex_lock(&udc->vbus_mutex); | ||
2216 | |||
2217 | if (!device_may_wakeup(dev)) { | ||
2218 | usba_stop(udc); | ||
2219 | goto out; | ||
2220 | } | ||
2221 | |||
2222 | /* | ||
2223 | * Device may wake up. We stay clocked if we failed | ||
2224 | * to request vbus irq, assuming always on. | ||
2225 | */ | ||
2226 | if (gpio_is_valid(udc->vbus_pin)) { | ||
2227 | usba_stop(udc); | ||
2228 | enable_irq_wake(gpio_to_irq(udc->vbus_pin)); | ||
2229 | } | ||
2230 | |||
2231 | out: | ||
2232 | mutex_unlock(&udc->vbus_mutex); | ||
2233 | return 0; | ||
2234 | } | ||
2235 | |||
2236 | static int usba_udc_resume(struct device *dev) | ||
2237 | { | ||
2238 | struct usba_udc *udc = dev_get_drvdata(dev); | ||
2239 | |||
2240 | /* Not started */ | ||
2241 | if (!udc->driver) | ||
2242 | return 0; | ||
2243 | |||
2244 | if (device_may_wakeup(dev) && gpio_is_valid(udc->vbus_pin)) | ||
2245 | disable_irq_wake(gpio_to_irq(udc->vbus_pin)); | ||
2246 | |||
2247 | /* If Vbus is present, enable the controller and wait for reset */ | ||
2248 | mutex_lock(&udc->vbus_mutex); | ||
2249 | udc->vbus_prev = vbus_is_present(udc); | ||
2250 | if (udc->vbus_prev) | ||
2251 | usba_start(udc); | ||
2252 | mutex_unlock(&udc->vbus_mutex); | ||
2253 | |||
2254 | return 0; | ||
2255 | } | ||
2256 | #endif | ||
2257 | |||
2258 | static SIMPLE_DEV_PM_OPS(usba_udc_pm_ops, usba_udc_suspend, usba_udc_resume); | ||
2259 | |||
2159 | static struct platform_driver udc_driver = { | 2260 | static struct platform_driver udc_driver = { |
2160 | .remove = __exit_p(usba_udc_remove), | 2261 | .remove = __exit_p(usba_udc_remove), |
2161 | .driver = { | 2262 | .driver = { |
2162 | .name = "atmel_usba_udc", | 2263 | .name = "atmel_usba_udc", |
2264 | .pm = &usba_udc_pm_ops, | ||
2163 | .of_match_table = of_match_ptr(atmel_udc_dt_ids), | 2265 | .of_match_table = of_match_ptr(atmel_udc_dt_ids), |
2164 | }, | 2266 | }, |
2165 | }; | 2267 | }; |
diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.h b/drivers/usb/gadget/udc/atmel_usba_udc.h index 497cd18836f3..ea448a344767 100644 --- a/drivers/usb/gadget/udc/atmel_usba_udc.h +++ b/drivers/usb/gadget/udc/atmel_usba_udc.h | |||
@@ -191,18 +191,28 @@ | |||
191 | | USBA_BF(name, value)) | 191 | | USBA_BF(name, value)) |
192 | 192 | ||
193 | /* Register access macros */ | 193 | /* Register access macros */ |
194 | #ifdef CONFIG_AVR32 | ||
195 | #define usba_io_readl __raw_readl | ||
196 | #define usba_io_writel __raw_writel | ||
197 | #define usba_io_writew __raw_writew | ||
198 | #else | ||
199 | #define usba_io_readl readl_relaxed | ||
200 | #define usba_io_writel writel_relaxed | ||
201 | #define usba_io_writew writew_relaxed | ||
202 | #endif | ||
203 | |||
194 | #define usba_readl(udc, reg) \ | 204 | #define usba_readl(udc, reg) \ |
195 | __raw_readl((udc)->regs + USBA_##reg) | 205 | usba_io_readl((udc)->regs + USBA_##reg) |
196 | #define usba_writel(udc, reg, value) \ | 206 | #define usba_writel(udc, reg, value) \ |
197 | __raw_writel((value), (udc)->regs + USBA_##reg) | 207 | usba_io_writel((value), (udc)->regs + USBA_##reg) |
198 | #define usba_ep_readl(ep, reg) \ | 208 | #define usba_ep_readl(ep, reg) \ |
199 | __raw_readl((ep)->ep_regs + USBA_EPT_##reg) | 209 | usba_io_readl((ep)->ep_regs + USBA_EPT_##reg) |
200 | #define usba_ep_writel(ep, reg, value) \ | 210 | #define usba_ep_writel(ep, reg, value) \ |
201 | __raw_writel((value), (ep)->ep_regs + USBA_EPT_##reg) | 211 | usba_io_writel((value), (ep)->ep_regs + USBA_EPT_##reg) |
202 | #define usba_dma_readl(ep, reg) \ | 212 | #define usba_dma_readl(ep, reg) \ |
203 | __raw_readl((ep)->dma_regs + USBA_DMA_##reg) | 213 | usba_io_readl((ep)->dma_regs + USBA_DMA_##reg) |
204 | #define usba_dma_writel(ep, reg, value) \ | 214 | #define usba_dma_writel(ep, reg, value) \ |
205 | __raw_writel((value), (ep)->dma_regs + USBA_DMA_##reg) | 215 | usba_io_writel((value), (ep)->dma_regs + USBA_DMA_##reg) |
206 | 216 | ||
207 | /* Calculate base address for a given endpoint or DMA controller */ | 217 | /* Calculate base address for a given endpoint or DMA controller */ |
208 | #define USBA_EPT_BASE(x) (0x100 + (x) * 0x20) | 218 | #define USBA_EPT_BASE(x) (0x100 + (x) * 0x20) |
@@ -313,6 +323,9 @@ struct usba_udc { | |||
313 | /* Protect hw registers from concurrent modifications */ | 323 | /* Protect hw registers from concurrent modifications */ |
314 | spinlock_t lock; | 324 | spinlock_t lock; |
315 | 325 | ||
326 | /* Mutex to prevent concurrent start or stop */ | ||
327 | struct mutex vbus_mutex; | ||
328 | |||
316 | void __iomem *regs; | 329 | void __iomem *regs; |
317 | void __iomem *fifo; | 330 | void __iomem *fifo; |
318 | 331 | ||
@@ -328,6 +341,7 @@ struct usba_udc { | |||
328 | struct clk *hclk; | 341 | struct clk *hclk; |
329 | struct usba_ep *usba_ep; | 342 | struct usba_ep *usba_ep; |
330 | bool bias_pulse_needed; | 343 | bool bias_pulse_needed; |
344 | bool clocked; | ||
331 | 345 | ||
332 | u16 devstatus; | 346 | u16 devstatus; |
333 | 347 | ||
diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c index 8dda48445f6f..7592db7824c6 100644 --- a/drivers/usb/gadget/udc/dummy_hcd.c +++ b/drivers/usb/gadget/udc/dummy_hcd.c | |||
@@ -2631,7 +2631,7 @@ static int __init init(void) | |||
2631 | return -EINVAL; | 2631 | return -EINVAL; |
2632 | 2632 | ||
2633 | if (mod_data.num < 1 || mod_data.num > MAX_NUM_UDC) { | 2633 | if (mod_data.num < 1 || mod_data.num > MAX_NUM_UDC) { |
2634 | pr_err("Number of emulated UDC must be in range of 1…%d\n", | 2634 | pr_err("Number of emulated UDC must be in range of 1...%d\n", |
2635 | MAX_NUM_UDC); | 2635 | MAX_NUM_UDC); |
2636 | return -EINVAL; | 2636 | return -EINVAL; |
2637 | } | 2637 | } |
diff --git a/drivers/usb/gadget/udc/goku_udc.c b/drivers/usb/gadget/udc/goku_udc.c index 5b9176e7202a..9e8d842e8c08 100644 --- a/drivers/usb/gadget/udc/goku_udc.c +++ b/drivers/usb/gadget/udc/goku_udc.c | |||
@@ -1024,35 +1024,79 @@ static const char proc_node_name [] = "driver/udc"; | |||
1024 | static void dump_intmask(struct seq_file *m, const char *label, u32 mask) | 1024 | static void dump_intmask(struct seq_file *m, const char *label, u32 mask) |
1025 | { | 1025 | { |
1026 | /* int_status is the same format ... */ | 1026 | /* int_status is the same format ... */ |
1027 | seq_printf(m, | 1027 | seq_printf(m, "%s %05X =" FOURBITS EIGHTBITS EIGHTBITS "\n", |
1028 | "%s %05X =" FOURBITS EIGHTBITS EIGHTBITS "\n", | 1028 | label, mask, |
1029 | label, mask, | 1029 | (mask & INT_PWRDETECT) ? " power" : "", |
1030 | (mask & INT_PWRDETECT) ? " power" : "", | 1030 | (mask & INT_SYSERROR) ? " sys" : "", |
1031 | (mask & INT_SYSERROR) ? " sys" : "", | 1031 | (mask & INT_MSTRDEND) ? " in-dma" : "", |
1032 | (mask & INT_MSTRDEND) ? " in-dma" : "", | 1032 | (mask & INT_MSTWRTMOUT) ? " wrtmo" : "", |
1033 | (mask & INT_MSTWRTMOUT) ? " wrtmo" : "", | 1033 | |
1034 | 1034 | (mask & INT_MSTWREND) ? " out-dma" : "", | |
1035 | (mask & INT_MSTWREND) ? " out-dma" : "", | 1035 | (mask & INT_MSTWRSET) ? " wrset" : "", |
1036 | (mask & INT_MSTWRSET) ? " wrset" : "", | 1036 | (mask & INT_ERR) ? " err" : "", |
1037 | (mask & INT_ERR) ? " err" : "", | 1037 | (mask & INT_SOF) ? " sof" : "", |
1038 | (mask & INT_SOF) ? " sof" : "", | 1038 | |
1039 | 1039 | (mask & INT_EP3NAK) ? " ep3nak" : "", | |
1040 | (mask & INT_EP3NAK) ? " ep3nak" : "", | 1040 | (mask & INT_EP2NAK) ? " ep2nak" : "", |
1041 | (mask & INT_EP2NAK) ? " ep2nak" : "", | 1041 | (mask & INT_EP1NAK) ? " ep1nak" : "", |
1042 | (mask & INT_EP1NAK) ? " ep1nak" : "", | 1042 | (mask & INT_EP3DATASET) ? " ep3" : "", |
1043 | (mask & INT_EP3DATASET) ? " ep3" : "", | 1043 | |
1044 | 1044 | (mask & INT_EP2DATASET) ? " ep2" : "", | |
1045 | (mask & INT_EP2DATASET) ? " ep2" : "", | 1045 | (mask & INT_EP1DATASET) ? " ep1" : "", |
1046 | (mask & INT_EP1DATASET) ? " ep1" : "", | 1046 | (mask & INT_STATUSNAK) ? " ep0snak" : "", |
1047 | (mask & INT_STATUSNAK) ? " ep0snak" : "", | 1047 | (mask & INT_STATUS) ? " ep0status" : "", |
1048 | (mask & INT_STATUS) ? " ep0status" : "", | 1048 | |
1049 | 1049 | (mask & INT_SETUP) ? " setup" : "", | |
1050 | (mask & INT_SETUP) ? " setup" : "", | 1050 | (mask & INT_ENDPOINT0) ? " ep0" : "", |
1051 | (mask & INT_ENDPOINT0) ? " ep0" : "", | 1051 | (mask & INT_USBRESET) ? " reset" : "", |
1052 | (mask & INT_USBRESET) ? " reset" : "", | 1052 | (mask & INT_SUSPEND) ? " suspend" : ""); |
1053 | (mask & INT_SUSPEND) ? " suspend" : ""); | 1053 | } |
1054 | |||
1055 | static const char *udc_ep_state(enum ep0state state) | ||
1056 | { | ||
1057 | switch (state) { | ||
1058 | case EP0_DISCONNECT: | ||
1059 | return "ep0_disconnect"; | ||
1060 | case EP0_IDLE: | ||
1061 | return "ep0_idle"; | ||
1062 | case EP0_IN: | ||
1063 | return "ep0_in"; | ||
1064 | case EP0_OUT: | ||
1065 | return "ep0_out"; | ||
1066 | case EP0_STATUS: | ||
1067 | return "ep0_status"; | ||
1068 | case EP0_STALL: | ||
1069 | return "ep0_stall"; | ||
1070 | case EP0_SUSPEND: | ||
1071 | return "ep0_suspend"; | ||
1072 | } | ||
1073 | |||
1074 | return "ep0_?"; | ||
1054 | } | 1075 | } |
1055 | 1076 | ||
1077 | static const char *udc_ep_status(u32 status) | ||
1078 | { | ||
1079 | switch (status & EPxSTATUS_EP_MASK) { | ||
1080 | case EPxSTATUS_EP_READY: | ||
1081 | return "ready"; | ||
1082 | case EPxSTATUS_EP_DATAIN: | ||
1083 | return "packet"; | ||
1084 | case EPxSTATUS_EP_FULL: | ||
1085 | return "full"; | ||
1086 | case EPxSTATUS_EP_TX_ERR: /* host will retry */ | ||
1087 | return "tx_err"; | ||
1088 | case EPxSTATUS_EP_RX_ERR: | ||
1089 | return "rx_err"; | ||
1090 | case EPxSTATUS_EP_BUSY: /* ep0 only */ | ||
1091 | return "busy"; | ||
1092 | case EPxSTATUS_EP_STALL: | ||
1093 | return "stall"; | ||
1094 | case EPxSTATUS_EP_INVALID: /* these "can't happen" */ | ||
1095 | return "invalid"; | ||
1096 | } | ||
1097 | |||
1098 | return "?"; | ||
1099 | } | ||
1056 | 1100 | ||
1057 | static int udc_proc_read(struct seq_file *m, void *v) | 1101 | static int udc_proc_read(struct seq_file *m, void *v) |
1058 | { | 1102 | { |
@@ -1068,29 +1112,18 @@ static int udc_proc_read(struct seq_file *m, void *v) | |||
1068 | tmp = readl(®s->power_detect); | 1112 | tmp = readl(®s->power_detect); |
1069 | is_usb_connected = tmp & PW_DETECT; | 1113 | is_usb_connected = tmp & PW_DETECT; |
1070 | seq_printf(m, | 1114 | seq_printf(m, |
1071 | "%s - %s\n" | 1115 | "%s - %s\n" |
1072 | "%s version: %s %s\n" | 1116 | "%s version: %s %s\n" |
1073 | "Gadget driver: %s\n" | 1117 | "Gadget driver: %s\n" |
1074 | "Host %s, %s\n" | 1118 | "Host %s, %s\n" |
1075 | "\n", | 1119 | "\n", |
1076 | pci_name(dev->pdev), driver_desc, | 1120 | pci_name(dev->pdev), driver_desc, |
1077 | driver_name, DRIVER_VERSION, dmastr(), | 1121 | driver_name, DRIVER_VERSION, dmastr(), |
1078 | dev->driver ? dev->driver->driver.name : "(none)", | 1122 | dev->driver ? dev->driver->driver.name : "(none)", |
1079 | is_usb_connected | 1123 | is_usb_connected |
1080 | ? ((tmp & PW_PULLUP) ? "full speed" : "powered") | 1124 | ? ((tmp & PW_PULLUP) ? "full speed" : "powered") |
1081 | : "disconnected", | 1125 | : "disconnected", |
1082 | ({const char *state; | 1126 | udc_ep_state(dev->ep0state)); |
1083 | switch(dev->ep0state){ | ||
1084 | case EP0_DISCONNECT: state = "ep0_disconnect"; break; | ||
1085 | case EP0_IDLE: state = "ep0_idle"; break; | ||
1086 | case EP0_IN: state = "ep0_in"; break; | ||
1087 | case EP0_OUT: state = "ep0_out"; break; | ||
1088 | case EP0_STATUS: state = "ep0_status"; break; | ||
1089 | case EP0_STALL: state = "ep0_stall"; break; | ||
1090 | case EP0_SUSPEND: state = "ep0_suspend"; break; | ||
1091 | default: state = "ep0_?"; break; | ||
1092 | } state; }) | ||
1093 | ); | ||
1094 | 1127 | ||
1095 | dump_intmask(m, "int_status", readl(®s->int_status)); | 1128 | dump_intmask(m, "int_status", readl(®s->int_status)); |
1096 | dump_intmask(m, "int_enable", readl(®s->int_enable)); | 1129 | dump_intmask(m, "int_enable", readl(®s->int_enable)); |
@@ -1099,31 +1132,30 @@ static int udc_proc_read(struct seq_file *m, void *v) | |||
1099 | goto done; | 1132 | goto done; |
1100 | 1133 | ||
1101 | /* registers for (active) device and ep0 */ | 1134 | /* registers for (active) device and ep0 */ |
1102 | if (seq_printf(m, "\nirqs %lu\ndataset %02x " | 1135 | seq_printf(m, "\nirqs %lu\ndataset %02x single.bcs %02x.%02x state %x addr %u\n", |
1103 | "single.bcs %02x.%02x state %x addr %u\n", | 1136 | dev->irqs, readl(®s->DataSet), |
1104 | dev->irqs, readl(®s->DataSet), | 1137 | readl(®s->EPxSingle), readl(®s->EPxBCS), |
1105 | readl(®s->EPxSingle), readl(®s->EPxBCS), | 1138 | readl(®s->UsbState), |
1106 | readl(®s->UsbState), | 1139 | readl(®s->address)); |
1107 | readl(®s->address)) < 0) | 1140 | if (seq_has_overflowed(m)) |
1108 | goto done; | 1141 | goto done; |
1109 | 1142 | ||
1110 | tmp = readl(®s->dma_master); | 1143 | tmp = readl(®s->dma_master); |
1111 | if (seq_printf(m, | 1144 | seq_printf(m, "dma %03X =" EIGHTBITS "%s %s\n", |
1112 | "dma %03X =" EIGHTBITS "%s %s\n", tmp, | 1145 | tmp, |
1113 | (tmp & MST_EOPB_DIS) ? " eopb-" : "", | 1146 | (tmp & MST_EOPB_DIS) ? " eopb-" : "", |
1114 | (tmp & MST_EOPB_ENA) ? " eopb+" : "", | 1147 | (tmp & MST_EOPB_ENA) ? " eopb+" : "", |
1115 | (tmp & MST_TIMEOUT_DIS) ? " tmo-" : "", | 1148 | (tmp & MST_TIMEOUT_DIS) ? " tmo-" : "", |
1116 | (tmp & MST_TIMEOUT_ENA) ? " tmo+" : "", | 1149 | (tmp & MST_TIMEOUT_ENA) ? " tmo+" : "", |
1117 | 1150 | ||
1118 | (tmp & MST_RD_EOPB) ? " eopb" : "", | 1151 | (tmp & MST_RD_EOPB) ? " eopb" : "", |
1119 | (tmp & MST_RD_RESET) ? " in_reset" : "", | 1152 | (tmp & MST_RD_RESET) ? " in_reset" : "", |
1120 | (tmp & MST_WR_RESET) ? " out_reset" : "", | 1153 | (tmp & MST_WR_RESET) ? " out_reset" : "", |
1121 | (tmp & MST_RD_ENA) ? " IN" : "", | 1154 | (tmp & MST_RD_ENA) ? " IN" : "", |
1122 | 1155 | ||
1123 | (tmp & MST_WR_ENA) ? " OUT" : "", | 1156 | (tmp & MST_WR_ENA) ? " OUT" : "", |
1124 | (tmp & MST_CONNECTION) | 1157 | (tmp & MST_CONNECTION) ? "ep1in/ep2out" : "ep1out/ep2in"); |
1125 | ? "ep1in/ep2out" | 1158 | if (seq_has_overflowed(m)) |
1126 | : "ep1out/ep2in") < 0) | ||
1127 | goto done; | 1159 | goto done; |
1128 | 1160 | ||
1129 | /* dump endpoint queues */ | 1161 | /* dump endpoint queues */ |
@@ -1135,44 +1167,23 @@ static int udc_proc_read(struct seq_file *m, void *v) | |||
1135 | continue; | 1167 | continue; |
1136 | 1168 | ||
1137 | tmp = readl(ep->reg_status); | 1169 | tmp = readl(ep->reg_status); |
1138 | if (seq_printf(m, | 1170 | seq_printf(m, "%s %s max %u %s, irqs %lu, status %02x (%s) " FOURBITS "\n", |
1139 | "%s %s max %u %s, irqs %lu, " | 1171 | ep->ep.name, |
1140 | "status %02x (%s) " FOURBITS "\n", | 1172 | ep->is_in ? "in" : "out", |
1141 | ep->ep.name, | 1173 | ep->ep.maxpacket, |
1142 | ep->is_in ? "in" : "out", | 1174 | ep->dma ? "dma" : "pio", |
1143 | ep->ep.maxpacket, | 1175 | ep->irqs, |
1144 | ep->dma ? "dma" : "pio", | 1176 | tmp, udc_ep_status(tmp), |
1145 | ep->irqs, | 1177 | (tmp & EPxSTATUS_TOGGLE) ? "data1" : "data0", |
1146 | tmp, ({ char *s; | 1178 | (tmp & EPxSTATUS_SUSPEND) ? " suspend" : "", |
1147 | switch (tmp & EPxSTATUS_EP_MASK) { | 1179 | (tmp & EPxSTATUS_FIFO_DISABLE) ? " disable" : "", |
1148 | case EPxSTATUS_EP_READY: | 1180 | (tmp & EPxSTATUS_STAGE_ERROR) ? " ep0stat" : ""); |
1149 | s = "ready"; break; | 1181 | if (seq_has_overflowed(m)) |
1150 | case EPxSTATUS_EP_DATAIN: | ||
1151 | s = "packet"; break; | ||
1152 | case EPxSTATUS_EP_FULL: | ||
1153 | s = "full"; break; | ||
1154 | case EPxSTATUS_EP_TX_ERR: // host will retry | ||
1155 | s = "tx_err"; break; | ||
1156 | case EPxSTATUS_EP_RX_ERR: | ||
1157 | s = "rx_err"; break; | ||
1158 | case EPxSTATUS_EP_BUSY: /* ep0 only */ | ||
1159 | s = "busy"; break; | ||
1160 | case EPxSTATUS_EP_STALL: | ||
1161 | s = "stall"; break; | ||
1162 | case EPxSTATUS_EP_INVALID: // these "can't happen" | ||
1163 | s = "invalid"; break; | ||
1164 | default: | ||
1165 | s = "?"; break; | ||
1166 | } s; }), | ||
1167 | (tmp & EPxSTATUS_TOGGLE) ? "data1" : "data0", | ||
1168 | (tmp & EPxSTATUS_SUSPEND) ? " suspend" : "", | ||
1169 | (tmp & EPxSTATUS_FIFO_DISABLE) ? " disable" : "", | ||
1170 | (tmp & EPxSTATUS_STAGE_ERROR) ? " ep0stat" : "" | ||
1171 | ) < 0) | ||
1172 | goto done; | 1182 | goto done; |
1173 | 1183 | ||
1174 | if (list_empty(&ep->queue)) { | 1184 | if (list_empty(&ep->queue)) { |
1175 | if (seq_puts(m, "\t(nothing queued)\n") < 0) | 1185 | seq_puts(m, "\t(nothing queued)\n"); |
1186 | if (seq_has_overflowed(m)) | ||
1176 | goto done; | 1187 | goto done; |
1177 | continue; | 1188 | continue; |
1178 | } | 1189 | } |
@@ -1187,10 +1198,10 @@ static int udc_proc_read(struct seq_file *m, void *v) | |||
1187 | } else | 1198 | } else |
1188 | tmp = req->req.actual; | 1199 | tmp = req->req.actual; |
1189 | 1200 | ||
1190 | if (seq_printf(m, | 1201 | seq_printf(m, "\treq %p len %u/%u buf %p\n", |
1191 | "\treq %p len %u/%u buf %p\n", | 1202 | &req->req, tmp, req->req.length, |
1192 | &req->req, tmp, req->req.length, | 1203 | req->req.buf); |
1193 | req->req.buf) < 0) | 1204 | if (seq_has_overflowed(m)) |
1194 | goto done; | 1205 | goto done; |
1195 | } | 1206 | } |
1196 | } | 1207 | } |
diff --git a/drivers/usb/gadget/udc/lpc32xx_udc.c b/drivers/usb/gadget/udc/lpc32xx_udc.c index 27fd41333f71..3b6a7852822d 100644 --- a/drivers/usb/gadget/udc/lpc32xx_udc.c +++ b/drivers/usb/gadget/udc/lpc32xx_udc.c | |||
@@ -1803,23 +1803,14 @@ static int lpc32xx_ep_queue(struct usb_ep *_ep, | |||
1803 | req = container_of(_req, struct lpc32xx_request, req); | 1803 | req = container_of(_req, struct lpc32xx_request, req); |
1804 | ep = container_of(_ep, struct lpc32xx_ep, ep); | 1804 | ep = container_of(_ep, struct lpc32xx_ep, ep); |
1805 | 1805 | ||
1806 | if (!_req || !_req->complete || !_req->buf || | 1806 | if (!_ep || !_req || !_req->complete || !_req->buf || |
1807 | !list_empty(&req->queue)) | 1807 | !list_empty(&req->queue)) |
1808 | return -EINVAL; | 1808 | return -EINVAL; |
1809 | 1809 | ||
1810 | udc = ep->udc; | 1810 | udc = ep->udc; |
1811 | 1811 | ||
1812 | if (!_ep) { | 1812 | if (udc->gadget.speed == USB_SPEED_UNKNOWN) |
1813 | dev_dbg(udc->dev, "invalid ep\n"); | 1813 | return -EPIPE; |
1814 | return -EINVAL; | ||
1815 | } | ||
1816 | |||
1817 | |||
1818 | if ((!udc) || (!udc->driver) || | ||
1819 | (udc->gadget.speed == USB_SPEED_UNKNOWN)) { | ||
1820 | dev_dbg(udc->dev, "invalid device\n"); | ||
1821 | return -EINVAL; | ||
1822 | } | ||
1823 | 1814 | ||
1824 | if (ep->lep) { | 1815 | if (ep->lep) { |
1825 | struct lpc32xx_usbd_dd_gad *dd; | 1816 | struct lpc32xx_usbd_dd_gad *dd; |
diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c index d2c0bf65e345..9871b90195ad 100644 --- a/drivers/usb/gadget/udc/net2280.c +++ b/drivers/usb/gadget/udc/net2280.c | |||
@@ -80,6 +80,13 @@ static const char *const ep_name[] = { | |||
80 | "ep-e", "ep-f", "ep-g", "ep-h", | 80 | "ep-e", "ep-f", "ep-g", "ep-h", |
81 | }; | 81 | }; |
82 | 82 | ||
83 | /* Endpoint names for usb3380 advance mode */ | ||
84 | static const char *const ep_name_adv[] = { | ||
85 | ep0name, | ||
86 | "ep1in", "ep2out", "ep3in", "ep4out", | ||
87 | "ep1out", "ep2in", "ep3out", "ep4in", | ||
88 | }; | ||
89 | |||
83 | /* mode 0 == ep-{a,b,c,d} 1K fifo each | 90 | /* mode 0 == ep-{a,b,c,d} 1K fifo each |
84 | * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable | 91 | * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable |
85 | * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable | 92 | * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable |
@@ -138,31 +145,44 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) | |||
138 | u32 max, tmp; | 145 | u32 max, tmp; |
139 | unsigned long flags; | 146 | unsigned long flags; |
140 | static const u32 ep_key[9] = { 1, 0, 1, 0, 1, 1, 0, 1, 0 }; | 147 | static const u32 ep_key[9] = { 1, 0, 1, 0, 1, 1, 0, 1, 0 }; |
148 | int ret = 0; | ||
141 | 149 | ||
142 | ep = container_of(_ep, struct net2280_ep, ep); | 150 | ep = container_of(_ep, struct net2280_ep, ep); |
143 | if (!_ep || !desc || ep->desc || _ep->name == ep0name || | 151 | if (!_ep || !desc || ep->desc || _ep->name == ep0name || |
144 | desc->bDescriptorType != USB_DT_ENDPOINT) | 152 | desc->bDescriptorType != USB_DT_ENDPOINT) { |
153 | pr_err("%s: failed at line=%d\n", __func__, __LINE__); | ||
145 | return -EINVAL; | 154 | return -EINVAL; |
155 | } | ||
146 | dev = ep->dev; | 156 | dev = ep->dev; |
147 | if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) | 157 | if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) { |
148 | return -ESHUTDOWN; | 158 | ret = -ESHUTDOWN; |
159 | goto print_err; | ||
160 | } | ||
149 | 161 | ||
150 | /* erratum 0119 workaround ties up an endpoint number */ | 162 | /* erratum 0119 workaround ties up an endpoint number */ |
151 | if ((desc->bEndpointAddress & 0x0f) == EP_DONTUSE) | 163 | if ((desc->bEndpointAddress & 0x0f) == EP_DONTUSE) { |
152 | return -EDOM; | 164 | ret = -EDOM; |
165 | goto print_err; | ||
166 | } | ||
153 | 167 | ||
154 | if (dev->quirks & PLX_SUPERSPEED) { | 168 | if (dev->quirks & PLX_SUPERSPEED) { |
155 | if ((desc->bEndpointAddress & 0x0f) >= 0x0c) | 169 | if ((desc->bEndpointAddress & 0x0f) >= 0x0c) { |
156 | return -EDOM; | 170 | ret = -EDOM; |
171 | goto print_err; | ||
172 | } | ||
157 | ep->is_in = !!usb_endpoint_dir_in(desc); | 173 | ep->is_in = !!usb_endpoint_dir_in(desc); |
158 | if (dev->enhanced_mode && ep->is_in && ep_key[ep->num]) | 174 | if (dev->enhanced_mode && ep->is_in && ep_key[ep->num]) { |
159 | return -EINVAL; | 175 | ret = -EINVAL; |
176 | goto print_err; | ||
177 | } | ||
160 | } | 178 | } |
161 | 179 | ||
162 | /* sanity check ep-e/ep-f since their fifos are small */ | 180 | /* sanity check ep-e/ep-f since their fifos are small */ |
163 | max = usb_endpoint_maxp(desc) & 0x1fff; | 181 | max = usb_endpoint_maxp(desc) & 0x1fff; |
164 | if (ep->num > 4 && max > 64 && (dev->quirks & PLX_LEGACY)) | 182 | if (ep->num > 4 && max > 64 && (dev->quirks & PLX_LEGACY)) { |
165 | return -ERANGE; | 183 | ret = -ERANGE; |
184 | goto print_err; | ||
185 | } | ||
166 | 186 | ||
167 | spin_lock_irqsave(&dev->lock, flags); | 187 | spin_lock_irqsave(&dev->lock, flags); |
168 | _ep->maxpacket = max & 0x7ff; | 188 | _ep->maxpacket = max & 0x7ff; |
@@ -192,7 +212,8 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) | |||
192 | (dev->gadget.speed == USB_SPEED_HIGH && max != 512) || | 212 | (dev->gadget.speed == USB_SPEED_HIGH && max != 512) || |
193 | (dev->gadget.speed == USB_SPEED_FULL && max > 64)) { | 213 | (dev->gadget.speed == USB_SPEED_FULL && max > 64)) { |
194 | spin_unlock_irqrestore(&dev->lock, flags); | 214 | spin_unlock_irqrestore(&dev->lock, flags); |
195 | return -ERANGE; | 215 | ret = -ERANGE; |
216 | goto print_err; | ||
196 | } | 217 | } |
197 | } | 218 | } |
198 | ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC); | 219 | ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC); |
@@ -271,7 +292,11 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) | |||
271 | 292 | ||
272 | /* pci writes may still be posted */ | 293 | /* pci writes may still be posted */ |
273 | spin_unlock_irqrestore(&dev->lock, flags); | 294 | spin_unlock_irqrestore(&dev->lock, flags); |
274 | return 0; | 295 | return ret; |
296 | |||
297 | print_err: | ||
298 | dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, ret); | ||
299 | return ret; | ||
275 | } | 300 | } |
276 | 301 | ||
277 | static int handshake(u32 __iomem *ptr, u32 mask, u32 done, int usec) | 302 | static int handshake(u32 __iomem *ptr, u32 mask, u32 done, int usec) |
@@ -426,9 +451,10 @@ static int net2280_disable(struct usb_ep *_ep) | |||
426 | unsigned long flags; | 451 | unsigned long flags; |
427 | 452 | ||
428 | ep = container_of(_ep, struct net2280_ep, ep); | 453 | ep = container_of(_ep, struct net2280_ep, ep); |
429 | if (!_ep || !ep->desc || _ep->name == ep0name) | 454 | if (!_ep || !ep->desc || _ep->name == ep0name) { |
455 | pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep); | ||
430 | return -EINVAL; | 456 | return -EINVAL; |
431 | 457 | } | |
432 | spin_lock_irqsave(&ep->dev->lock, flags); | 458 | spin_lock_irqsave(&ep->dev->lock, flags); |
433 | nuke(ep); | 459 | nuke(ep); |
434 | 460 | ||
@@ -458,8 +484,10 @@ static struct usb_request | |||
458 | struct net2280_ep *ep; | 484 | struct net2280_ep *ep; |
459 | struct net2280_request *req; | 485 | struct net2280_request *req; |
460 | 486 | ||
461 | if (!_ep) | 487 | if (!_ep) { |
488 | pr_err("%s: Invalid ep\n", __func__); | ||
462 | return NULL; | 489 | return NULL; |
490 | } | ||
463 | ep = container_of(_ep, struct net2280_ep, ep); | 491 | ep = container_of(_ep, struct net2280_ep, ep); |
464 | 492 | ||
465 | req = kzalloc(sizeof(*req), gfp_flags); | 493 | req = kzalloc(sizeof(*req), gfp_flags); |
@@ -491,8 +519,11 @@ static void net2280_free_request(struct usb_ep *_ep, struct usb_request *_req) | |||
491 | struct net2280_request *req; | 519 | struct net2280_request *req; |
492 | 520 | ||
493 | ep = container_of(_ep, struct net2280_ep, ep); | 521 | ep = container_of(_ep, struct net2280_ep, ep); |
494 | if (!_ep || !_req) | 522 | if (!_ep || !_req) { |
523 | dev_err(&ep->dev->pdev->dev, "%s: Inavlid ep=%p or req=%p\n", | ||
524 | __func__, _ep, _req); | ||
495 | return; | 525 | return; |
526 | } | ||
496 | 527 | ||
497 | req = container_of(_req, struct net2280_request, req); | 528 | req = container_of(_req, struct net2280_request, req); |
498 | WARN_ON(!list_empty(&req->queue)); | 529 | WARN_ON(!list_empty(&req->queue)); |
@@ -896,35 +927,44 @@ net2280_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags) | |||
896 | struct net2280_ep *ep; | 927 | struct net2280_ep *ep; |
897 | struct net2280 *dev; | 928 | struct net2280 *dev; |
898 | unsigned long flags; | 929 | unsigned long flags; |
930 | int ret = 0; | ||
899 | 931 | ||
900 | /* we always require a cpu-view buffer, so that we can | 932 | /* we always require a cpu-view buffer, so that we can |
901 | * always use pio (as fallback or whatever). | 933 | * always use pio (as fallback or whatever). |
902 | */ | 934 | */ |
903 | req = container_of(_req, struct net2280_request, req); | ||
904 | if (!_req || !_req->complete || !_req->buf || | ||
905 | !list_empty(&req->queue)) | ||
906 | return -EINVAL; | ||
907 | if (_req->length > (~0 & DMA_BYTE_COUNT_MASK)) | ||
908 | return -EDOM; | ||
909 | ep = container_of(_ep, struct net2280_ep, ep); | 935 | ep = container_of(_ep, struct net2280_ep, ep); |
910 | if (!_ep || (!ep->desc && ep->num != 0)) | 936 | if (!_ep || (!ep->desc && ep->num != 0)) { |
937 | pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep); | ||
911 | return -EINVAL; | 938 | return -EINVAL; |
939 | } | ||
940 | req = container_of(_req, struct net2280_request, req); | ||
941 | if (!_req || !_req->complete || !_req->buf || | ||
942 | !list_empty(&req->queue)) { | ||
943 | ret = -EINVAL; | ||
944 | goto print_err; | ||
945 | } | ||
946 | if (_req->length > (~0 & DMA_BYTE_COUNT_MASK)) { | ||
947 | ret = -EDOM; | ||
948 | goto print_err; | ||
949 | } | ||
912 | dev = ep->dev; | 950 | dev = ep->dev; |
913 | if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) | 951 | if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) { |
914 | return -ESHUTDOWN; | 952 | ret = -ESHUTDOWN; |
953 | goto print_err; | ||
954 | } | ||
915 | 955 | ||
916 | /* FIXME implement PIO fallback for ZLPs with DMA */ | 956 | /* FIXME implement PIO fallback for ZLPs with DMA */ |
917 | if (ep->dma && _req->length == 0) | 957 | if (ep->dma && _req->length == 0) { |
918 | return -EOPNOTSUPP; | 958 | ret = -EOPNOTSUPP; |
959 | goto print_err; | ||
960 | } | ||
919 | 961 | ||
920 | /* set up dma mapping in case the caller didn't */ | 962 | /* set up dma mapping in case the caller didn't */ |
921 | if (ep->dma) { | 963 | if (ep->dma) { |
922 | int ret; | ||
923 | |||
924 | ret = usb_gadget_map_request(&dev->gadget, _req, | 964 | ret = usb_gadget_map_request(&dev->gadget, _req, |
925 | ep->is_in); | 965 | ep->is_in); |
926 | if (ret) | 966 | if (ret) |
927 | return ret; | 967 | goto print_err; |
928 | } | 968 | } |
929 | 969 | ||
930 | ep_vdbg(dev, "%s queue req %p, len %d buf %p\n", | 970 | ep_vdbg(dev, "%s queue req %p, len %d buf %p\n", |
@@ -1013,7 +1053,11 @@ done: | |||
1013 | spin_unlock_irqrestore(&dev->lock, flags); | 1053 | spin_unlock_irqrestore(&dev->lock, flags); |
1014 | 1054 | ||
1015 | /* pci writes may still be posted */ | 1055 | /* pci writes may still be posted */ |
1016 | return 0; | 1056 | return ret; |
1057 | |||
1058 | print_err: | ||
1059 | dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, ret); | ||
1060 | return ret; | ||
1017 | } | 1061 | } |
1018 | 1062 | ||
1019 | static inline void | 1063 | static inline void |
@@ -1134,8 +1178,11 @@ static int net2280_dequeue(struct usb_ep *_ep, struct usb_request *_req) | |||
1134 | int stopped; | 1178 | int stopped; |
1135 | 1179 | ||
1136 | ep = container_of(_ep, struct net2280_ep, ep); | 1180 | ep = container_of(_ep, struct net2280_ep, ep); |
1137 | if (!_ep || (!ep->desc && ep->num != 0) || !_req) | 1181 | if (!_ep || (!ep->desc && ep->num != 0) || !_req) { |
1182 | pr_err("%s: Invalid ep=%p or ep->desc or req=%p\n", | ||
1183 | __func__, _ep, _req); | ||
1138 | return -EINVAL; | 1184 | return -EINVAL; |
1185 | } | ||
1139 | 1186 | ||
1140 | spin_lock_irqsave(&ep->dev->lock, flags); | 1187 | spin_lock_irqsave(&ep->dev->lock, flags); |
1141 | stopped = ep->stopped; | 1188 | stopped = ep->stopped; |
@@ -1157,6 +1204,8 @@ static int net2280_dequeue(struct usb_ep *_ep, struct usb_request *_req) | |||
1157 | } | 1204 | } |
1158 | if (&req->req != _req) { | 1205 | if (&req->req != _req) { |
1159 | spin_unlock_irqrestore(&ep->dev->lock, flags); | 1206 | spin_unlock_irqrestore(&ep->dev->lock, flags); |
1207 | dev_err(&ep->dev->pdev->dev, "%s: Request mismatch\n", | ||
1208 | __func__); | ||
1160 | return -EINVAL; | 1209 | return -EINVAL; |
1161 | } | 1210 | } |
1162 | 1211 | ||
@@ -1214,20 +1263,28 @@ net2280_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged) | |||
1214 | int retval = 0; | 1263 | int retval = 0; |
1215 | 1264 | ||
1216 | ep = container_of(_ep, struct net2280_ep, ep); | 1265 | ep = container_of(_ep, struct net2280_ep, ep); |
1217 | if (!_ep || (!ep->desc && ep->num != 0)) | 1266 | if (!_ep || (!ep->desc && ep->num != 0)) { |
1267 | pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep); | ||
1218 | return -EINVAL; | 1268 | return -EINVAL; |
1219 | if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) | 1269 | } |
1220 | return -ESHUTDOWN; | 1270 | if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) { |
1271 | retval = -ESHUTDOWN; | ||
1272 | goto print_err; | ||
1273 | } | ||
1221 | if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03) | 1274 | if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03) |
1222 | == USB_ENDPOINT_XFER_ISOC) | 1275 | == USB_ENDPOINT_XFER_ISOC) { |
1223 | return -EINVAL; | 1276 | retval = -EINVAL; |
1277 | goto print_err; | ||
1278 | } | ||
1224 | 1279 | ||
1225 | spin_lock_irqsave(&ep->dev->lock, flags); | 1280 | spin_lock_irqsave(&ep->dev->lock, flags); |
1226 | if (!list_empty(&ep->queue)) | 1281 | if (!list_empty(&ep->queue)) { |
1227 | retval = -EAGAIN; | 1282 | retval = -EAGAIN; |
1228 | else if (ep->is_in && value && net2280_fifo_status(_ep) != 0) | 1283 | goto print_unlock; |
1284 | } else if (ep->is_in && value && net2280_fifo_status(_ep) != 0) { | ||
1229 | retval = -EAGAIN; | 1285 | retval = -EAGAIN; |
1230 | else { | 1286 | goto print_unlock; |
1287 | } else { | ||
1231 | ep_vdbg(ep->dev, "%s %s %s\n", _ep->name, | 1288 | ep_vdbg(ep->dev, "%s %s %s\n", _ep->name, |
1232 | value ? "set" : "clear", | 1289 | value ? "set" : "clear", |
1233 | wedged ? "wedge" : "halt"); | 1290 | wedged ? "wedge" : "halt"); |
@@ -1251,6 +1308,12 @@ net2280_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged) | |||
1251 | spin_unlock_irqrestore(&ep->dev->lock, flags); | 1308 | spin_unlock_irqrestore(&ep->dev->lock, flags); |
1252 | 1309 | ||
1253 | return retval; | 1310 | return retval; |
1311 | |||
1312 | print_unlock: | ||
1313 | spin_unlock_irqrestore(&ep->dev->lock, flags); | ||
1314 | print_err: | ||
1315 | dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, retval); | ||
1316 | return retval; | ||
1254 | } | 1317 | } |
1255 | 1318 | ||
1256 | static int net2280_set_halt(struct usb_ep *_ep, int value) | 1319 | static int net2280_set_halt(struct usb_ep *_ep, int value) |
@@ -1260,8 +1323,10 @@ static int net2280_set_halt(struct usb_ep *_ep, int value) | |||
1260 | 1323 | ||
1261 | static int net2280_set_wedge(struct usb_ep *_ep) | 1324 | static int net2280_set_wedge(struct usb_ep *_ep) |
1262 | { | 1325 | { |
1263 | if (!_ep || _ep->name == ep0name) | 1326 | if (!_ep || _ep->name == ep0name) { |
1327 | pr_err("%s: Invalid ep=%p or ep0\n", __func__, _ep); | ||
1264 | return -EINVAL; | 1328 | return -EINVAL; |
1329 | } | ||
1265 | return net2280_set_halt_and_wedge(_ep, 1, 1); | 1330 | return net2280_set_halt_and_wedge(_ep, 1, 1); |
1266 | } | 1331 | } |
1267 | 1332 | ||
@@ -1271,14 +1336,22 @@ static int net2280_fifo_status(struct usb_ep *_ep) | |||
1271 | u32 avail; | 1336 | u32 avail; |
1272 | 1337 | ||
1273 | ep = container_of(_ep, struct net2280_ep, ep); | 1338 | ep = container_of(_ep, struct net2280_ep, ep); |
1274 | if (!_ep || (!ep->desc && ep->num != 0)) | 1339 | if (!_ep || (!ep->desc && ep->num != 0)) { |
1340 | pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep); | ||
1275 | return -ENODEV; | 1341 | return -ENODEV; |
1276 | if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) | 1342 | } |
1343 | if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) { | ||
1344 | dev_err(&ep->dev->pdev->dev, | ||
1345 | "%s: Invalid driver=%p or speed=%d\n", | ||
1346 | __func__, ep->dev->driver, ep->dev->gadget.speed); | ||
1277 | return -ESHUTDOWN; | 1347 | return -ESHUTDOWN; |
1348 | } | ||
1278 | 1349 | ||
1279 | avail = readl(&ep->regs->ep_avail) & (BIT(12) - 1); | 1350 | avail = readl(&ep->regs->ep_avail) & (BIT(12) - 1); |
1280 | if (avail > ep->fifo_size) | 1351 | if (avail > ep->fifo_size) { |
1352 | dev_err(&ep->dev->pdev->dev, "%s: Fifo overflow\n", __func__); | ||
1281 | return -EOVERFLOW; | 1353 | return -EOVERFLOW; |
1354 | } | ||
1282 | if (ep->is_in) | 1355 | if (ep->is_in) |
1283 | avail = ep->fifo_size - avail; | 1356 | avail = ep->fifo_size - avail; |
1284 | return avail; | 1357 | return avail; |
@@ -1289,10 +1362,16 @@ static void net2280_fifo_flush(struct usb_ep *_ep) | |||
1289 | struct net2280_ep *ep; | 1362 | struct net2280_ep *ep; |
1290 | 1363 | ||
1291 | ep = container_of(_ep, struct net2280_ep, ep); | 1364 | ep = container_of(_ep, struct net2280_ep, ep); |
1292 | if (!_ep || (!ep->desc && ep->num != 0)) | 1365 | if (!_ep || (!ep->desc && ep->num != 0)) { |
1366 | pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep); | ||
1293 | return; | 1367 | return; |
1294 | if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) | 1368 | } |
1369 | if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) { | ||
1370 | dev_err(&ep->dev->pdev->dev, | ||
1371 | "%s: Invalid driver=%p or speed=%d\n", | ||
1372 | __func__, ep->dev->driver, ep->dev->gadget.speed); | ||
1295 | return; | 1373 | return; |
1374 | } | ||
1296 | 1375 | ||
1297 | writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat); | 1376 | writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat); |
1298 | (void) readl(&ep->regs->ep_rsp); | 1377 | (void) readl(&ep->regs->ep_rsp); |
@@ -1977,7 +2056,7 @@ static void usb_reinit_338x(struct net2280 *dev) | |||
1977 | for (i = 0; i < dev->n_ep; i++) { | 2056 | for (i = 0; i < dev->n_ep; i++) { |
1978 | struct net2280_ep *ep = &dev->ep[i]; | 2057 | struct net2280_ep *ep = &dev->ep[i]; |
1979 | 2058 | ||
1980 | ep->ep.name = ep_name[i]; | 2059 | ep->ep.name = dev->enhanced_mode ? ep_name_adv[i] : ep_name[i]; |
1981 | ep->dev = dev; | 2060 | ep->dev = dev; |
1982 | ep->num = i; | 2061 | ep->num = i; |
1983 | 2062 | ||
@@ -1989,11 +2068,9 @@ static void usb_reinit_338x(struct net2280 *dev) | |||
1989 | ep->regs = (struct net2280_ep_regs __iomem *) | 2068 | ep->regs = (struct net2280_ep_regs __iomem *) |
1990 | (((void __iomem *)&dev->epregs[ne[i]]) + | 2069 | (((void __iomem *)&dev->epregs[ne[i]]) + |
1991 | ep_reg_addr[i]); | 2070 | ep_reg_addr[i]); |
1992 | ep->fiforegs = &dev->fiforegs[i]; | ||
1993 | } else { | 2071 | } else { |
1994 | ep->cfg = &dev->epregs[i]; | 2072 | ep->cfg = &dev->epregs[i]; |
1995 | ep->regs = &dev->epregs[i]; | 2073 | ep->regs = &dev->epregs[i]; |
1996 | ep->fiforegs = &dev->fiforegs[i]; | ||
1997 | } | 2074 | } |
1998 | 2075 | ||
1999 | ep->fifo_size = (i != 0) ? 2048 : 512; | 2076 | ep->fifo_size = (i != 0) ? 2048 : 512; |
@@ -2186,7 +2263,6 @@ static int net2280_start(struct usb_gadget *_gadget, | |||
2186 | dev->ep[i].irqs = 0; | 2263 | dev->ep[i].irqs = 0; |
2187 | 2264 | ||
2188 | /* hook up the driver ... */ | 2265 | /* hook up the driver ... */ |
2189 | dev->softconnect = 1; | ||
2190 | driver->driver.bus = NULL; | 2266 | driver->driver.bus = NULL; |
2191 | dev->driver = driver; | 2267 | dev->driver = driver; |
2192 | 2268 | ||
@@ -3052,6 +3128,8 @@ next_endpoints: | |||
3052 | BIT(PCI_RETRY_ABORT_INTERRUPT)) | 3128 | BIT(PCI_RETRY_ABORT_INTERRUPT)) |
3053 | 3129 | ||
3054 | static void handle_stat1_irqs(struct net2280 *dev, u32 stat) | 3130 | static void handle_stat1_irqs(struct net2280 *dev, u32 stat) |
3131 | __releases(dev->lock) | ||
3132 | __acquires(dev->lock) | ||
3055 | { | 3133 | { |
3056 | struct net2280_ep *ep; | 3134 | struct net2280_ep *ep; |
3057 | u32 tmp, num, mask, scratch; | 3135 | u32 tmp, num, mask, scratch; |
@@ -3373,8 +3451,6 @@ static int net2280_probe(struct pci_dev *pdev, const struct pci_device_id *id) | |||
3373 | u32 usbstat; | 3451 | u32 usbstat; |
3374 | dev->usb_ext = (struct usb338x_usb_ext_regs __iomem *) | 3452 | dev->usb_ext = (struct usb338x_usb_ext_regs __iomem *) |
3375 | (base + 0x00b4); | 3453 | (base + 0x00b4); |
3376 | dev->fiforegs = (struct usb338x_fifo_regs __iomem *) | ||
3377 | (base + 0x0500); | ||
3378 | dev->llregs = (struct usb338x_ll_regs __iomem *) | 3454 | dev->llregs = (struct usb338x_ll_regs __iomem *) |
3379 | (base + 0x0700); | 3455 | (base + 0x0700); |
3380 | dev->ll_lfps_regs = (struct usb338x_ll_lfps_regs __iomem *) | 3456 | dev->ll_lfps_regs = (struct usb338x_ll_lfps_regs __iomem *) |
diff --git a/drivers/usb/gadget/udc/net2280.h b/drivers/usb/gadget/udc/net2280.h index ac8d5a20a378..4dff60d34f73 100644 --- a/drivers/usb/gadget/udc/net2280.h +++ b/drivers/usb/gadget/udc/net2280.h | |||
@@ -96,7 +96,6 @@ struct net2280_ep { | |||
96 | struct net2280_ep_regs __iomem *regs; | 96 | struct net2280_ep_regs __iomem *regs; |
97 | struct net2280_dma_regs __iomem *dma; | 97 | struct net2280_dma_regs __iomem *dma; |
98 | struct net2280_dma *dummy; | 98 | struct net2280_dma *dummy; |
99 | struct usb338x_fifo_regs __iomem *fiforegs; | ||
100 | dma_addr_t td_dma; /* of dummy */ | 99 | dma_addr_t td_dma; /* of dummy */ |
101 | struct net2280 *dev; | 100 | struct net2280 *dev; |
102 | unsigned long irqs; | 101 | unsigned long irqs; |
@@ -181,7 +180,6 @@ struct net2280 { | |||
181 | struct net2280_dma_regs __iomem *dma; | 180 | struct net2280_dma_regs __iomem *dma; |
182 | struct net2280_dep_regs __iomem *dep; | 181 | struct net2280_dep_regs __iomem *dep; |
183 | struct net2280_ep_regs __iomem *epregs; | 182 | struct net2280_ep_regs __iomem *epregs; |
184 | struct usb338x_fifo_regs __iomem *fiforegs; | ||
185 | struct usb338x_ll_regs __iomem *llregs; | 183 | struct usb338x_ll_regs __iomem *llregs; |
186 | struct usb338x_ll_lfps_regs __iomem *ll_lfps_regs; | 184 | struct usb338x_ll_lfps_regs __iomem *ll_lfps_regs; |
187 | struct usb338x_ll_tsn_regs __iomem *ll_tsn_regs; | 185 | struct usb338x_ll_tsn_regs __iomem *ll_tsn_regs; |
diff --git a/drivers/usb/gadget/udc/pxa27x_udc.c b/drivers/usb/gadget/udc/pxa27x_udc.c index f0ae143dab6d..b51226abade6 100644 --- a/drivers/usb/gadget/udc/pxa27x_udc.c +++ b/drivers/usb/gadget/udc/pxa27x_udc.c | |||
@@ -93,50 +93,46 @@ static void handle_ep(struct pxa_ep *ep); | |||
93 | static int state_dbg_show(struct seq_file *s, void *p) | 93 | static int state_dbg_show(struct seq_file *s, void *p) |
94 | { | 94 | { |
95 | struct pxa_udc *udc = s->private; | 95 | struct pxa_udc *udc = s->private; |
96 | int pos = 0, ret; | ||
97 | u32 tmp; | 96 | u32 tmp; |
98 | 97 | ||
99 | ret = -ENODEV; | ||
100 | if (!udc->driver) | 98 | if (!udc->driver) |
101 | goto out; | 99 | return -ENODEV; |
102 | 100 | ||
103 | /* basic device status */ | 101 | /* basic device status */ |
104 | pos += seq_printf(s, DRIVER_DESC "\n" | 102 | seq_printf(s, DRIVER_DESC "\n" |
105 | "%s version: %s\nGadget driver: %s\n", | 103 | "%s version: %s\n" |
106 | driver_name, DRIVER_VERSION, | 104 | "Gadget driver: %s\n", |
107 | udc->driver ? udc->driver->driver.name : "(none)"); | 105 | driver_name, DRIVER_VERSION, |
106 | udc->driver ? udc->driver->driver.name : "(none)"); | ||
108 | 107 | ||
109 | tmp = udc_readl(udc, UDCCR); | 108 | tmp = udc_readl(udc, UDCCR); |
110 | pos += seq_printf(s, | 109 | seq_printf(s, |
111 | "udccr=0x%0x(%s%s%s%s%s%s%s%s%s%s), " | 110 | "udccr=0x%0x(%s%s%s%s%s%s%s%s%s%s), con=%d,inter=%d,altinter=%d\n", |
112 | "con=%d,inter=%d,altinter=%d\n", tmp, | 111 | tmp, |
113 | (tmp & UDCCR_OEN) ? " oen":"", | 112 | (tmp & UDCCR_OEN) ? " oen":"", |
114 | (tmp & UDCCR_AALTHNP) ? " aalthnp":"", | 113 | (tmp & UDCCR_AALTHNP) ? " aalthnp":"", |
115 | (tmp & UDCCR_AHNP) ? " rem" : "", | 114 | (tmp & UDCCR_AHNP) ? " rem" : "", |
116 | (tmp & UDCCR_BHNP) ? " rstir" : "", | 115 | (tmp & UDCCR_BHNP) ? " rstir" : "", |
117 | (tmp & UDCCR_DWRE) ? " dwre" : "", | 116 | (tmp & UDCCR_DWRE) ? " dwre" : "", |
118 | (tmp & UDCCR_SMAC) ? " smac" : "", | 117 | (tmp & UDCCR_SMAC) ? " smac" : "", |
119 | (tmp & UDCCR_EMCE) ? " emce" : "", | 118 | (tmp & UDCCR_EMCE) ? " emce" : "", |
120 | (tmp & UDCCR_UDR) ? " udr" : "", | 119 | (tmp & UDCCR_UDR) ? " udr" : "", |
121 | (tmp & UDCCR_UDA) ? " uda" : "", | 120 | (tmp & UDCCR_UDA) ? " uda" : "", |
122 | (tmp & UDCCR_UDE) ? " ude" : "", | 121 | (tmp & UDCCR_UDE) ? " ude" : "", |
123 | (tmp & UDCCR_ACN) >> UDCCR_ACN_S, | 122 | (tmp & UDCCR_ACN) >> UDCCR_ACN_S, |
124 | (tmp & UDCCR_AIN) >> UDCCR_AIN_S, | 123 | (tmp & UDCCR_AIN) >> UDCCR_AIN_S, |
125 | (tmp & UDCCR_AAISN) >> UDCCR_AAISN_S); | 124 | (tmp & UDCCR_AAISN) >> UDCCR_AAISN_S); |
126 | /* registers for device and ep0 */ | 125 | /* registers for device and ep0 */ |
127 | pos += seq_printf(s, "udcicr0=0x%08x udcicr1=0x%08x\n", | 126 | seq_printf(s, "udcicr0=0x%08x udcicr1=0x%08x\n", |
128 | udc_readl(udc, UDCICR0), udc_readl(udc, UDCICR1)); | 127 | udc_readl(udc, UDCICR0), udc_readl(udc, UDCICR1)); |
129 | pos += seq_printf(s, "udcisr0=0x%08x udcisr1=0x%08x\n", | 128 | seq_printf(s, "udcisr0=0x%08x udcisr1=0x%08x\n", |
130 | udc_readl(udc, UDCISR0), udc_readl(udc, UDCISR1)); | 129 | udc_readl(udc, UDCISR0), udc_readl(udc, UDCISR1)); |
131 | pos += seq_printf(s, "udcfnr=%d\n", udc_readl(udc, UDCFNR)); | 130 | seq_printf(s, "udcfnr=%d\n", udc_readl(udc, UDCFNR)); |
132 | pos += seq_printf(s, "irqs: reset=%lu, suspend=%lu, resume=%lu, " | 131 | seq_printf(s, "irqs: reset=%lu, suspend=%lu, resume=%lu, reconfig=%lu\n", |
133 | "reconfig=%lu\n", | 132 | udc->stats.irqs_reset, udc->stats.irqs_suspend, |
134 | udc->stats.irqs_reset, udc->stats.irqs_suspend, | 133 | udc->stats.irqs_resume, udc->stats.irqs_reconfig); |
135 | udc->stats.irqs_resume, udc->stats.irqs_reconfig); | 134 | |
136 | 135 | return 0; | |
137 | ret = 0; | ||
138 | out: | ||
139 | return ret; | ||
140 | } | 136 | } |
141 | 137 | ||
142 | static int queues_dbg_show(struct seq_file *s, void *p) | 138 | static int queues_dbg_show(struct seq_file *s, void *p) |
@@ -144,75 +140,67 @@ static int queues_dbg_show(struct seq_file *s, void *p) | |||
144 | struct pxa_udc *udc = s->private; | 140 | struct pxa_udc *udc = s->private; |
145 | struct pxa_ep *ep; | 141 | struct pxa_ep *ep; |
146 | struct pxa27x_request *req; | 142 | struct pxa27x_request *req; |
147 | int pos = 0, i, maxpkt, ret; | 143 | int i, maxpkt; |
148 | 144 | ||
149 | ret = -ENODEV; | ||
150 | if (!udc->driver) | 145 | if (!udc->driver) |
151 | goto out; | 146 | return -ENODEV; |
152 | 147 | ||
153 | /* dump endpoint queues */ | 148 | /* dump endpoint queues */ |
154 | for (i = 0; i < NR_PXA_ENDPOINTS; i++) { | 149 | for (i = 0; i < NR_PXA_ENDPOINTS; i++) { |
155 | ep = &udc->pxa_ep[i]; | 150 | ep = &udc->pxa_ep[i]; |
156 | maxpkt = ep->fifo_size; | 151 | maxpkt = ep->fifo_size; |
157 | pos += seq_printf(s, "%-12s max_pkt=%d %s\n", | 152 | seq_printf(s, "%-12s max_pkt=%d %s\n", |
158 | EPNAME(ep), maxpkt, "pio"); | 153 | EPNAME(ep), maxpkt, "pio"); |
159 | 154 | ||
160 | if (list_empty(&ep->queue)) { | 155 | if (list_empty(&ep->queue)) { |
161 | pos += seq_printf(s, "\t(nothing queued)\n"); | 156 | seq_puts(s, "\t(nothing queued)\n"); |
162 | continue; | 157 | continue; |
163 | } | 158 | } |
164 | 159 | ||
165 | list_for_each_entry(req, &ep->queue, queue) { | 160 | list_for_each_entry(req, &ep->queue, queue) { |
166 | pos += seq_printf(s, "\treq %p len %d/%d buf %p\n", | 161 | seq_printf(s, "\treq %p len %d/%d buf %p\n", |
167 | &req->req, req->req.actual, | 162 | &req->req, req->req.actual, |
168 | req->req.length, req->req.buf); | 163 | req->req.length, req->req.buf); |
169 | } | 164 | } |
170 | } | 165 | } |
171 | 166 | ||
172 | ret = 0; | 167 | return 0; |
173 | out: | ||
174 | return ret; | ||
175 | } | 168 | } |
176 | 169 | ||
177 | static int eps_dbg_show(struct seq_file *s, void *p) | 170 | static int eps_dbg_show(struct seq_file *s, void *p) |
178 | { | 171 | { |
179 | struct pxa_udc *udc = s->private; | 172 | struct pxa_udc *udc = s->private; |
180 | struct pxa_ep *ep; | 173 | struct pxa_ep *ep; |
181 | int pos = 0, i, ret; | 174 | int i; |
182 | u32 tmp; | 175 | u32 tmp; |
183 | 176 | ||
184 | ret = -ENODEV; | ||
185 | if (!udc->driver) | 177 | if (!udc->driver) |
186 | goto out; | 178 | return -ENODEV; |
187 | 179 | ||
188 | ep = &udc->pxa_ep[0]; | 180 | ep = &udc->pxa_ep[0]; |
189 | tmp = udc_ep_readl(ep, UDCCSR); | 181 | tmp = udc_ep_readl(ep, UDCCSR); |
190 | pos += seq_printf(s, "udccsr0=0x%03x(%s%s%s%s%s%s%s)\n", tmp, | 182 | seq_printf(s, "udccsr0=0x%03x(%s%s%s%s%s%s%s)\n", |
191 | (tmp & UDCCSR0_SA) ? " sa" : "", | 183 | tmp, |
192 | (tmp & UDCCSR0_RNE) ? " rne" : "", | 184 | (tmp & UDCCSR0_SA) ? " sa" : "", |
193 | (tmp & UDCCSR0_FST) ? " fst" : "", | 185 | (tmp & UDCCSR0_RNE) ? " rne" : "", |
194 | (tmp & UDCCSR0_SST) ? " sst" : "", | 186 | (tmp & UDCCSR0_FST) ? " fst" : "", |
195 | (tmp & UDCCSR0_DME) ? " dme" : "", | 187 | (tmp & UDCCSR0_SST) ? " sst" : "", |
196 | (tmp & UDCCSR0_IPR) ? " ipr" : "", | 188 | (tmp & UDCCSR0_DME) ? " dme" : "", |
197 | (tmp & UDCCSR0_OPC) ? " opc" : ""); | 189 | (tmp & UDCCSR0_IPR) ? " ipr" : "", |
190 | (tmp & UDCCSR0_OPC) ? " opc" : ""); | ||
198 | for (i = 0; i < NR_PXA_ENDPOINTS; i++) { | 191 | for (i = 0; i < NR_PXA_ENDPOINTS; i++) { |
199 | ep = &udc->pxa_ep[i]; | 192 | ep = &udc->pxa_ep[i]; |
200 | tmp = i? udc_ep_readl(ep, UDCCR) : udc_readl(udc, UDCCR); | 193 | tmp = i? udc_ep_readl(ep, UDCCR) : udc_readl(udc, UDCCR); |
201 | pos += seq_printf(s, "%-12s: " | 194 | seq_printf(s, "%-12s: IN %lu(%lu reqs), OUT %lu(%lu reqs), irqs=%lu, udccr=0x%08x, udccsr=0x%03x, udcbcr=%d\n", |
202 | "IN %lu(%lu reqs), OUT %lu(%lu reqs), " | 195 | EPNAME(ep), |
203 | "irqs=%lu, udccr=0x%08x, udccsr=0x%03x, " | 196 | ep->stats.in_bytes, ep->stats.in_ops, |
204 | "udcbcr=%d\n", | 197 | ep->stats.out_bytes, ep->stats.out_ops, |
205 | EPNAME(ep), | 198 | ep->stats.irqs, |
206 | ep->stats.in_bytes, ep->stats.in_ops, | 199 | tmp, udc_ep_readl(ep, UDCCSR), |
207 | ep->stats.out_bytes, ep->stats.out_ops, | 200 | udc_ep_readl(ep, UDCBCR)); |
208 | ep->stats.irqs, | ||
209 | tmp, udc_ep_readl(ep, UDCCSR), | ||
210 | udc_ep_readl(ep, UDCBCR)); | ||
211 | } | 201 | } |
212 | 202 | ||
213 | ret = 0; | 203 | return 0; |
214 | out: | ||
215 | return ret; | ||
216 | } | 204 | } |
217 | 205 | ||
218 | static int eps_dbg_open(struct inode *inode, struct file *file) | 206 | static int eps_dbg_open(struct inode *inode, struct file *file) |
diff --git a/drivers/usb/gadget/udc/udc-core.c b/drivers/usb/gadget/udc/udc-core.c index 5a81cb086b99..d69c35558f68 100644 --- a/drivers/usb/gadget/udc/udc-core.c +++ b/drivers/usb/gadget/udc/udc-core.c | |||
@@ -35,6 +35,8 @@ | |||
35 | * @dev - the child device to the actual controller | 35 | * @dev - the child device to the actual controller |
36 | * @gadget - the gadget. For use by the class code | 36 | * @gadget - the gadget. For use by the class code |
37 | * @list - for use by the udc class driver | 37 | * @list - for use by the udc class driver |
38 | * @vbus - for udcs who care about vbus status, this value is real vbus status; | ||
39 | * for udcs who do not care about vbus status, this value is always true | ||
38 | * | 40 | * |
39 | * This represents the internal data structure which is used by the UDC-class | 41 | * This represents the internal data structure which is used by the UDC-class |
40 | * to hold information about udc driver and gadget together. | 42 | * to hold information about udc driver and gadget together. |
@@ -44,6 +46,7 @@ struct usb_udc { | |||
44 | struct usb_gadget *gadget; | 46 | struct usb_gadget *gadget; |
45 | struct device dev; | 47 | struct device dev; |
46 | struct list_head list; | 48 | struct list_head list; |
49 | bool vbus; | ||
47 | }; | 50 | }; |
48 | 51 | ||
49 | static struct class *udc_class; | 52 | static struct class *udc_class; |
@@ -128,21 +131,11 @@ EXPORT_SYMBOL_GPL(usb_gadget_giveback_request); | |||
128 | 131 | ||
129 | static void usb_gadget_state_work(struct work_struct *work) | 132 | static void usb_gadget_state_work(struct work_struct *work) |
130 | { | 133 | { |
131 | struct usb_gadget *gadget = work_to_gadget(work); | 134 | struct usb_gadget *gadget = work_to_gadget(work); |
132 | struct usb_udc *udc = NULL; | 135 | struct usb_udc *udc = gadget->udc; |
133 | |||
134 | mutex_lock(&udc_lock); | ||
135 | list_for_each_entry(udc, &udc_list, list) | ||
136 | if (udc->gadget == gadget) | ||
137 | goto found; | ||
138 | mutex_unlock(&udc_lock); | ||
139 | |||
140 | return; | ||
141 | |||
142 | found: | ||
143 | mutex_unlock(&udc_lock); | ||
144 | 136 | ||
145 | sysfs_notify(&udc->dev.kobj, NULL, "state"); | 137 | if (udc) |
138 | sysfs_notify(&udc->dev.kobj, NULL, "state"); | ||
146 | } | 139 | } |
147 | 140 | ||
148 | void usb_gadget_set_state(struct usb_gadget *gadget, | 141 | void usb_gadget_set_state(struct usb_gadget *gadget, |
@@ -155,6 +148,34 @@ EXPORT_SYMBOL_GPL(usb_gadget_set_state); | |||
155 | 148 | ||
156 | /* ------------------------------------------------------------------------- */ | 149 | /* ------------------------------------------------------------------------- */ |
157 | 150 | ||
151 | static void usb_udc_connect_control(struct usb_udc *udc) | ||
152 | { | ||
153 | if (udc->vbus) | ||
154 | usb_gadget_connect(udc->gadget); | ||
155 | else | ||
156 | usb_gadget_disconnect(udc->gadget); | ||
157 | } | ||
158 | |||
159 | /** | ||
160 | * usb_udc_vbus_handler - updates the udc core vbus status, and try to | ||
161 | * connect or disconnect gadget | ||
162 | * @gadget: The gadget which vbus change occurs | ||
163 | * @status: The vbus status | ||
164 | * | ||
165 | * The udc driver calls it when it wants to connect or disconnect gadget | ||
166 | * according to vbus status. | ||
167 | */ | ||
168 | void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status) | ||
169 | { | ||
170 | struct usb_udc *udc = gadget->udc; | ||
171 | |||
172 | if (udc) { | ||
173 | udc->vbus = status; | ||
174 | usb_udc_connect_control(udc); | ||
175 | } | ||
176 | } | ||
177 | EXPORT_SYMBOL_GPL(usb_udc_vbus_handler); | ||
178 | |||
158 | /** | 179 | /** |
159 | * usb_gadget_udc_reset - notifies the udc core that bus reset occurs | 180 | * usb_gadget_udc_reset - notifies the udc core that bus reset occurs |
160 | * @gadget: The gadget which bus reset occurs | 181 | * @gadget: The gadget which bus reset occurs |
@@ -278,6 +299,7 @@ int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget, | |||
278 | goto err3; | 299 | goto err3; |
279 | 300 | ||
280 | udc->gadget = gadget; | 301 | udc->gadget = gadget; |
302 | gadget->udc = udc; | ||
281 | 303 | ||
282 | mutex_lock(&udc_lock); | 304 | mutex_lock(&udc_lock); |
283 | list_add_tail(&udc->list, &udc_list); | 305 | list_add_tail(&udc->list, &udc_list); |
@@ -287,6 +309,7 @@ int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget, | |||
287 | goto err4; | 309 | goto err4; |
288 | 310 | ||
289 | usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED); | 311 | usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED); |
312 | udc->vbus = true; | ||
290 | 313 | ||
291 | mutex_unlock(&udc_lock); | 314 | mutex_unlock(&udc_lock); |
292 | 315 | ||
@@ -348,21 +371,14 @@ static void usb_gadget_remove_driver(struct usb_udc *udc) | |||
348 | */ | 371 | */ |
349 | void usb_del_gadget_udc(struct usb_gadget *gadget) | 372 | void usb_del_gadget_udc(struct usb_gadget *gadget) |
350 | { | 373 | { |
351 | struct usb_udc *udc = NULL; | 374 | struct usb_udc *udc = gadget->udc; |
352 | 375 | ||
353 | mutex_lock(&udc_lock); | 376 | if (!udc) |
354 | list_for_each_entry(udc, &udc_list, list) | 377 | return; |
355 | if (udc->gadget == gadget) | ||
356 | goto found; | ||
357 | |||
358 | dev_err(gadget->dev.parent, "gadget not registered.\n"); | ||
359 | mutex_unlock(&udc_lock); | ||
360 | |||
361 | return; | ||
362 | 378 | ||
363 | found: | ||
364 | dev_vdbg(gadget->dev.parent, "unregistering gadget\n"); | 379 | dev_vdbg(gadget->dev.parent, "unregistering gadget\n"); |
365 | 380 | ||
381 | mutex_lock(&udc_lock); | ||
366 | list_del(&udc->list); | 382 | list_del(&udc->list); |
367 | mutex_unlock(&udc_lock); | 383 | mutex_unlock(&udc_lock); |
368 | 384 | ||
@@ -397,7 +413,7 @@ static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *dri | |||
397 | driver->unbind(udc->gadget); | 413 | driver->unbind(udc->gadget); |
398 | goto err1; | 414 | goto err1; |
399 | } | 415 | } |
400 | usb_gadget_connect(udc->gadget); | 416 | usb_udc_connect_control(udc); |
401 | 417 | ||
402 | kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE); | 418 | kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE); |
403 | return 0; | 419 | return 0; |