Loading...
1/*
2 * f_loopback.c - USB peripheral loopback configuration driver
3 *
4 * Copyright (C) 2003-2008 David Brownell
5 * Copyright (C) 2008 by Nokia Corporation
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22/* #define VERBOSE_DEBUG */
23
24#include <linux/slab.h>
25#include <linux/kernel.h>
26#include <linux/device.h>
27
28#include "g_zero.h"
29#include "gadget_chips.h"
30
31
32/*
33 * LOOPBACK FUNCTION ... a testing vehicle for USB peripherals,
34 *
35 * This takes messages of various sizes written OUT to a device, and loops
36 * them back so they can be read IN from it. It has been used by certain
37 * test applications. It supports limited testing of data queueing logic.
38 *
39 *
40 * This is currently packaged as a configuration driver, which can't be
41 * combined with other functions to make composite devices. However, it
42 * can be combined with other independent configurations.
43 */
44struct f_loopback {
45 struct usb_function function;
46
47 struct usb_ep *in_ep;
48 struct usb_ep *out_ep;
49};
50
51static inline struct f_loopback *func_to_loop(struct usb_function *f)
52{
53 return container_of(f, struct f_loopback, function);
54}
55
56static unsigned qlen = 32;
57module_param(qlen, uint, 0);
58MODULE_PARM_DESC(qlenn, "depth of loopback queue");
59
60/*-------------------------------------------------------------------------*/
61
62static struct usb_interface_descriptor loopback_intf = {
63 .bLength = sizeof loopback_intf,
64 .bDescriptorType = USB_DT_INTERFACE,
65
66 .bNumEndpoints = 2,
67 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
68 /* .iInterface = DYNAMIC */
69};
70
71/* full speed support: */
72
73static struct usb_endpoint_descriptor fs_loop_source_desc = {
74 .bLength = USB_DT_ENDPOINT_SIZE,
75 .bDescriptorType = USB_DT_ENDPOINT,
76
77 .bEndpointAddress = USB_DIR_IN,
78 .bmAttributes = USB_ENDPOINT_XFER_BULK,
79};
80
81static struct usb_endpoint_descriptor fs_loop_sink_desc = {
82 .bLength = USB_DT_ENDPOINT_SIZE,
83 .bDescriptorType = USB_DT_ENDPOINT,
84
85 .bEndpointAddress = USB_DIR_OUT,
86 .bmAttributes = USB_ENDPOINT_XFER_BULK,
87};
88
89static struct usb_descriptor_header *fs_loopback_descs[] = {
90 (struct usb_descriptor_header *) &loopback_intf,
91 (struct usb_descriptor_header *) &fs_loop_sink_desc,
92 (struct usb_descriptor_header *) &fs_loop_source_desc,
93 NULL,
94};
95
96/* high speed support: */
97
98static struct usb_endpoint_descriptor hs_loop_source_desc = {
99 .bLength = USB_DT_ENDPOINT_SIZE,
100 .bDescriptorType = USB_DT_ENDPOINT,
101
102 .bmAttributes = USB_ENDPOINT_XFER_BULK,
103 .wMaxPacketSize = cpu_to_le16(512),
104};
105
106static struct usb_endpoint_descriptor hs_loop_sink_desc = {
107 .bLength = USB_DT_ENDPOINT_SIZE,
108 .bDescriptorType = USB_DT_ENDPOINT,
109
110 .bmAttributes = USB_ENDPOINT_XFER_BULK,
111 .wMaxPacketSize = cpu_to_le16(512),
112};
113
114static struct usb_descriptor_header *hs_loopback_descs[] = {
115 (struct usb_descriptor_header *) &loopback_intf,
116 (struct usb_descriptor_header *) &hs_loop_source_desc,
117 (struct usb_descriptor_header *) &hs_loop_sink_desc,
118 NULL,
119};
120
121/* super speed support: */
122
123static struct usb_endpoint_descriptor ss_loop_source_desc = {
124 .bLength = USB_DT_ENDPOINT_SIZE,
125 .bDescriptorType = USB_DT_ENDPOINT,
126
127 .bmAttributes = USB_ENDPOINT_XFER_BULK,
128 .wMaxPacketSize = cpu_to_le16(1024),
129};
130
131struct usb_ss_ep_comp_descriptor ss_loop_source_comp_desc = {
132 .bLength = USB_DT_SS_EP_COMP_SIZE,
133 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
134 .bMaxBurst = 0,
135 .bmAttributes = 0,
136 .wBytesPerInterval = 0,
137};
138
139static struct usb_endpoint_descriptor ss_loop_sink_desc = {
140 .bLength = USB_DT_ENDPOINT_SIZE,
141 .bDescriptorType = USB_DT_ENDPOINT,
142
143 .bmAttributes = USB_ENDPOINT_XFER_BULK,
144 .wMaxPacketSize = cpu_to_le16(1024),
145};
146
147struct usb_ss_ep_comp_descriptor ss_loop_sink_comp_desc = {
148 .bLength = USB_DT_SS_EP_COMP_SIZE,
149 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
150 .bMaxBurst = 0,
151 .bmAttributes = 0,
152 .wBytesPerInterval = 0,
153};
154
155static struct usb_descriptor_header *ss_loopback_descs[] = {
156 (struct usb_descriptor_header *) &loopback_intf,
157 (struct usb_descriptor_header *) &ss_loop_source_desc,
158 (struct usb_descriptor_header *) &ss_loop_source_comp_desc,
159 (struct usb_descriptor_header *) &ss_loop_sink_desc,
160 (struct usb_descriptor_header *) &ss_loop_sink_comp_desc,
161 NULL,
162};
163
164/* function-specific strings: */
165
166static struct usb_string strings_loopback[] = {
167 [0].s = "loop input to output",
168 { } /* end of list */
169};
170
171static struct usb_gadget_strings stringtab_loop = {
172 .language = 0x0409, /* en-us */
173 .strings = strings_loopback,
174};
175
176static struct usb_gadget_strings *loopback_strings[] = {
177 &stringtab_loop,
178 NULL,
179};
180
181/*-------------------------------------------------------------------------*/
182
183static int __init
184loopback_bind(struct usb_configuration *c, struct usb_function *f)
185{
186 struct usb_composite_dev *cdev = c->cdev;
187 struct f_loopback *loop = func_to_loop(f);
188 int id;
189
190 /* allocate interface ID(s) */
191 id = usb_interface_id(c, f);
192 if (id < 0)
193 return id;
194 loopback_intf.bInterfaceNumber = id;
195
196 /* allocate endpoints */
197
198 loop->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_loop_source_desc);
199 if (!loop->in_ep) {
200autoconf_fail:
201 ERROR(cdev, "%s: can't autoconfigure on %s\n",
202 f->name, cdev->gadget->name);
203 return -ENODEV;
204 }
205 loop->in_ep->driver_data = cdev; /* claim */
206
207 loop->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_loop_sink_desc);
208 if (!loop->out_ep)
209 goto autoconf_fail;
210 loop->out_ep->driver_data = cdev; /* claim */
211
212 /* support high speed hardware */
213 if (gadget_is_dualspeed(c->cdev->gadget)) {
214 hs_loop_source_desc.bEndpointAddress =
215 fs_loop_source_desc.bEndpointAddress;
216 hs_loop_sink_desc.bEndpointAddress =
217 fs_loop_sink_desc.bEndpointAddress;
218 f->hs_descriptors = hs_loopback_descs;
219 }
220
221 /* support super speed hardware */
222 if (gadget_is_superspeed(c->cdev->gadget)) {
223 ss_loop_source_desc.bEndpointAddress =
224 fs_loop_source_desc.bEndpointAddress;
225 ss_loop_sink_desc.bEndpointAddress =
226 fs_loop_sink_desc.bEndpointAddress;
227 f->ss_descriptors = ss_loopback_descs;
228 }
229
230 DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
231 (gadget_is_superspeed(c->cdev->gadget) ? "super" :
232 (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
233 f->name, loop->in_ep->name, loop->out_ep->name);
234 return 0;
235}
236
237static void
238loopback_unbind(struct usb_configuration *c, struct usb_function *f)
239{
240 kfree(func_to_loop(f));
241}
242
243static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
244{
245 struct f_loopback *loop = ep->driver_data;
246 struct usb_composite_dev *cdev = loop->function.config->cdev;
247 int status = req->status;
248
249 switch (status) {
250
251 case 0: /* normal completion? */
252 if (ep == loop->out_ep) {
253 /* loop this OUT packet back IN to the host */
254 req->zero = (req->actual < req->length);
255 req->length = req->actual;
256 status = usb_ep_queue(loop->in_ep, req, GFP_ATOMIC);
257 if (status == 0)
258 return;
259
260 /* "should never get here" */
261 ERROR(cdev, "can't loop %s to %s: %d\n",
262 ep->name, loop->in_ep->name,
263 status);
264 }
265
266 /* queue the buffer for some later OUT packet */
267 req->length = buflen;
268 status = usb_ep_queue(loop->out_ep, req, GFP_ATOMIC);
269 if (status == 0)
270 return;
271
272 /* "should never get here" */
273 /* FALLTHROUGH */
274
275 default:
276 ERROR(cdev, "%s loop complete --> %d, %d/%d\n", ep->name,
277 status, req->actual, req->length);
278 /* FALLTHROUGH */
279
280 /* NOTE: since this driver doesn't maintain an explicit record
281 * of requests it submitted (just maintains qlen count), we
282 * rely on the hardware driver to clean up on disconnect or
283 * endpoint disable.
284 */
285 case -ECONNABORTED: /* hardware forced ep reset */
286 case -ECONNRESET: /* request dequeued */
287 case -ESHUTDOWN: /* disconnect from host */
288 free_ep_req(ep, req);
289 return;
290 }
291}
292
293static void disable_loopback(struct f_loopback *loop)
294{
295 struct usb_composite_dev *cdev;
296
297 cdev = loop->function.config->cdev;
298 disable_endpoints(cdev, loop->in_ep, loop->out_ep);
299 VDBG(cdev, "%s disabled\n", loop->function.name);
300}
301
302static int
303enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
304{
305 int result = 0;
306 struct usb_ep *ep;
307 struct usb_request *req;
308 unsigned i;
309
310 /* one endpoint writes data back IN to the host */
311 ep = loop->in_ep;
312 result = config_ep_by_speed(cdev->gadget, &(loop->function), ep);
313 if (result)
314 return result;
315 result = usb_ep_enable(ep);
316 if (result < 0)
317 return result;
318 ep->driver_data = loop;
319
320 /* one endpoint just reads OUT packets */
321 ep = loop->out_ep;
322 result = config_ep_by_speed(cdev->gadget, &(loop->function), ep);
323 if (result)
324 goto fail0;
325
326 result = usb_ep_enable(ep);
327 if (result < 0) {
328fail0:
329 ep = loop->in_ep;
330 usb_ep_disable(ep);
331 ep->driver_data = NULL;
332 return result;
333 }
334 ep->driver_data = loop;
335
336 /* allocate a bunch of read buffers and queue them all at once.
337 * we buffer at most 'qlen' transfers; fewer if any need more
338 * than 'buflen' bytes each.
339 */
340 for (i = 0; i < qlen && result == 0; i++) {
341 req = alloc_ep_req(ep);
342 if (req) {
343 req->complete = loopback_complete;
344 result = usb_ep_queue(ep, req, GFP_ATOMIC);
345 if (result)
346 ERROR(cdev, "%s queue req --> %d\n",
347 ep->name, result);
348 } else {
349 usb_ep_disable(ep);
350 ep->driver_data = NULL;
351 result = -ENOMEM;
352 goto fail0;
353 }
354 }
355
356 DBG(cdev, "%s enabled\n", loop->function.name);
357 return result;
358}
359
360static int loopback_set_alt(struct usb_function *f,
361 unsigned intf, unsigned alt)
362{
363 struct f_loopback *loop = func_to_loop(f);
364 struct usb_composite_dev *cdev = f->config->cdev;
365
366 /* we know alt is zero */
367 if (loop->in_ep->driver_data)
368 disable_loopback(loop);
369 return enable_loopback(cdev, loop);
370}
371
372static void loopback_disable(struct usb_function *f)
373{
374 struct f_loopback *loop = func_to_loop(f);
375
376 disable_loopback(loop);
377}
378
379/*-------------------------------------------------------------------------*/
380
381static int __init loopback_bind_config(struct usb_configuration *c)
382{
383 struct f_loopback *loop;
384 int status;
385
386 loop = kzalloc(sizeof *loop, GFP_KERNEL);
387 if (!loop)
388 return -ENOMEM;
389
390 loop->function.name = "loopback";
391 loop->function.descriptors = fs_loopback_descs;
392 loop->function.bind = loopback_bind;
393 loop->function.unbind = loopback_unbind;
394 loop->function.set_alt = loopback_set_alt;
395 loop->function.disable = loopback_disable;
396
397 status = usb_add_function(c, &loop->function);
398 if (status)
399 kfree(loop);
400 return status;
401}
402
403static struct usb_configuration loopback_driver = {
404 .label = "loopback",
405 .strings = loopback_strings,
406 .bConfigurationValue = 2,
407 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
408 /* .iConfiguration = DYNAMIC */
409};
410
411/**
412 * loopback_add - add a loopback testing configuration to a device
413 * @cdev: the device to support the loopback configuration
414 */
415int __init loopback_add(struct usb_composite_dev *cdev, bool autoresume)
416{
417 int id;
418
419 /* allocate string ID(s) */
420 id = usb_string_id(cdev);
421 if (id < 0)
422 return id;
423 strings_loopback[0].id = id;
424
425 loopback_intf.iInterface = id;
426 loopback_driver.iConfiguration = id;
427
428 /* support autoresume for remote wakeup testing */
429 if (autoresume)
430 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
431
432 /* support OTG systems */
433 if (gadget_is_otg(cdev->gadget)) {
434 loopback_driver.descriptors = otg_desc;
435 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
436 }
437
438 return usb_add_config(cdev, &loopback_driver, loopback_bind_config);
439}
1/*
2 * f_loopback.c - USB peripheral loopback configuration driver
3 *
4 * Copyright (C) 2003-2008 David Brownell
5 * Copyright (C) 2008 by Nokia Corporation
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 */
12
13/* #define VERBOSE_DEBUG */
14
15#include <linux/slab.h>
16#include <linux/kernel.h>
17#include <linux/device.h>
18
19#include "g_zero.h"
20#include "gadget_chips.h"
21
22
23/*
24 * LOOPBACK FUNCTION ... a testing vehicle for USB peripherals,
25 *
26 * This takes messages of various sizes written OUT to a device, and loops
27 * them back so they can be read IN from it. It has been used by certain
28 * test applications. It supports limited testing of data queueing logic.
29 *
30 *
31 * This is currently packaged as a configuration driver, which can't be
32 * combined with other functions to make composite devices. However, it
33 * can be combined with other independent configurations.
34 */
35struct f_loopback {
36 struct usb_function function;
37
38 struct usb_ep *in_ep;
39 struct usb_ep *out_ep;
40};
41
42static inline struct f_loopback *func_to_loop(struct usb_function *f)
43{
44 return container_of(f, struct f_loopback, function);
45}
46
47static unsigned qlen = 32;
48module_param(qlen, uint, 0);
49MODULE_PARM_DESC(qlenn, "depth of loopback queue");
50
51/*-------------------------------------------------------------------------*/
52
53static struct usb_interface_descriptor loopback_intf = {
54 .bLength = sizeof loopback_intf,
55 .bDescriptorType = USB_DT_INTERFACE,
56
57 .bNumEndpoints = 2,
58 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
59 /* .iInterface = DYNAMIC */
60};
61
62/* full speed support: */
63
64static struct usb_endpoint_descriptor fs_loop_source_desc = {
65 .bLength = USB_DT_ENDPOINT_SIZE,
66 .bDescriptorType = USB_DT_ENDPOINT,
67
68 .bEndpointAddress = USB_DIR_IN,
69 .bmAttributes = USB_ENDPOINT_XFER_BULK,
70};
71
72static struct usb_endpoint_descriptor fs_loop_sink_desc = {
73 .bLength = USB_DT_ENDPOINT_SIZE,
74 .bDescriptorType = USB_DT_ENDPOINT,
75
76 .bEndpointAddress = USB_DIR_OUT,
77 .bmAttributes = USB_ENDPOINT_XFER_BULK,
78};
79
80static struct usb_descriptor_header *fs_loopback_descs[] = {
81 (struct usb_descriptor_header *) &loopback_intf,
82 (struct usb_descriptor_header *) &fs_loop_sink_desc,
83 (struct usb_descriptor_header *) &fs_loop_source_desc,
84 NULL,
85};
86
87/* high speed support: */
88
89static struct usb_endpoint_descriptor hs_loop_source_desc = {
90 .bLength = USB_DT_ENDPOINT_SIZE,
91 .bDescriptorType = USB_DT_ENDPOINT,
92
93 .bmAttributes = USB_ENDPOINT_XFER_BULK,
94 .wMaxPacketSize = cpu_to_le16(512),
95};
96
97static struct usb_endpoint_descriptor hs_loop_sink_desc = {
98 .bLength = USB_DT_ENDPOINT_SIZE,
99 .bDescriptorType = USB_DT_ENDPOINT,
100
101 .bmAttributes = USB_ENDPOINT_XFER_BULK,
102 .wMaxPacketSize = cpu_to_le16(512),
103};
104
105static struct usb_descriptor_header *hs_loopback_descs[] = {
106 (struct usb_descriptor_header *) &loopback_intf,
107 (struct usb_descriptor_header *) &hs_loop_source_desc,
108 (struct usb_descriptor_header *) &hs_loop_sink_desc,
109 NULL,
110};
111
112/* super speed support: */
113
114static struct usb_endpoint_descriptor ss_loop_source_desc = {
115 .bLength = USB_DT_ENDPOINT_SIZE,
116 .bDescriptorType = USB_DT_ENDPOINT,
117
118 .bmAttributes = USB_ENDPOINT_XFER_BULK,
119 .wMaxPacketSize = cpu_to_le16(1024),
120};
121
122struct usb_ss_ep_comp_descriptor ss_loop_source_comp_desc = {
123 .bLength = USB_DT_SS_EP_COMP_SIZE,
124 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
125 .bMaxBurst = 0,
126 .bmAttributes = 0,
127 .wBytesPerInterval = 0,
128};
129
130static struct usb_endpoint_descriptor ss_loop_sink_desc = {
131 .bLength = USB_DT_ENDPOINT_SIZE,
132 .bDescriptorType = USB_DT_ENDPOINT,
133
134 .bmAttributes = USB_ENDPOINT_XFER_BULK,
135 .wMaxPacketSize = cpu_to_le16(1024),
136};
137
138struct usb_ss_ep_comp_descriptor ss_loop_sink_comp_desc = {
139 .bLength = USB_DT_SS_EP_COMP_SIZE,
140 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
141 .bMaxBurst = 0,
142 .bmAttributes = 0,
143 .wBytesPerInterval = 0,
144};
145
146static struct usb_descriptor_header *ss_loopback_descs[] = {
147 (struct usb_descriptor_header *) &loopback_intf,
148 (struct usb_descriptor_header *) &ss_loop_source_desc,
149 (struct usb_descriptor_header *) &ss_loop_source_comp_desc,
150 (struct usb_descriptor_header *) &ss_loop_sink_desc,
151 (struct usb_descriptor_header *) &ss_loop_sink_comp_desc,
152 NULL,
153};
154
155/* function-specific strings: */
156
157static struct usb_string strings_loopback[] = {
158 [0].s = "loop input to output",
159 { } /* end of list */
160};
161
162static struct usb_gadget_strings stringtab_loop = {
163 .language = 0x0409, /* en-us */
164 .strings = strings_loopback,
165};
166
167static struct usb_gadget_strings *loopback_strings[] = {
168 &stringtab_loop,
169 NULL,
170};
171
172/*-------------------------------------------------------------------------*/
173
174static int __init
175loopback_bind(struct usb_configuration *c, struct usb_function *f)
176{
177 struct usb_composite_dev *cdev = c->cdev;
178 struct f_loopback *loop = func_to_loop(f);
179 int id;
180
181 /* allocate interface ID(s) */
182 id = usb_interface_id(c, f);
183 if (id < 0)
184 return id;
185 loopback_intf.bInterfaceNumber = id;
186
187 /* allocate endpoints */
188
189 loop->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_loop_source_desc);
190 if (!loop->in_ep) {
191autoconf_fail:
192 ERROR(cdev, "%s: can't autoconfigure on %s\n",
193 f->name, cdev->gadget->name);
194 return -ENODEV;
195 }
196 loop->in_ep->driver_data = cdev; /* claim */
197
198 loop->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_loop_sink_desc);
199 if (!loop->out_ep)
200 goto autoconf_fail;
201 loop->out_ep->driver_data = cdev; /* claim */
202
203 /* support high speed hardware */
204 if (gadget_is_dualspeed(c->cdev->gadget)) {
205 hs_loop_source_desc.bEndpointAddress =
206 fs_loop_source_desc.bEndpointAddress;
207 hs_loop_sink_desc.bEndpointAddress =
208 fs_loop_sink_desc.bEndpointAddress;
209 f->hs_descriptors = hs_loopback_descs;
210 }
211
212 /* support super speed hardware */
213 if (gadget_is_superspeed(c->cdev->gadget)) {
214 ss_loop_source_desc.bEndpointAddress =
215 fs_loop_source_desc.bEndpointAddress;
216 ss_loop_sink_desc.bEndpointAddress =
217 fs_loop_sink_desc.bEndpointAddress;
218 f->ss_descriptors = ss_loopback_descs;
219 }
220
221 DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
222 (gadget_is_superspeed(c->cdev->gadget) ? "super" :
223 (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
224 f->name, loop->in_ep->name, loop->out_ep->name);
225 return 0;
226}
227
228static void
229loopback_unbind(struct usb_configuration *c, struct usb_function *f)
230{
231 kfree(func_to_loop(f));
232}
233
234static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
235{
236 struct f_loopback *loop = ep->driver_data;
237 struct usb_composite_dev *cdev = loop->function.config->cdev;
238 int status = req->status;
239
240 switch (status) {
241
242 case 0: /* normal completion? */
243 if (ep == loop->out_ep) {
244 /* loop this OUT packet back IN to the host */
245 req->zero = (req->actual < req->length);
246 req->length = req->actual;
247 status = usb_ep_queue(loop->in_ep, req, GFP_ATOMIC);
248 if (status == 0)
249 return;
250
251 /* "should never get here" */
252 ERROR(cdev, "can't loop %s to %s: %d\n",
253 ep->name, loop->in_ep->name,
254 status);
255 }
256
257 /* queue the buffer for some later OUT packet */
258 req->length = buflen;
259 status = usb_ep_queue(loop->out_ep, req, GFP_ATOMIC);
260 if (status == 0)
261 return;
262
263 /* "should never get here" */
264 /* FALLTHROUGH */
265
266 default:
267 ERROR(cdev, "%s loop complete --> %d, %d/%d\n", ep->name,
268 status, req->actual, req->length);
269 /* FALLTHROUGH */
270
271 /* NOTE: since this driver doesn't maintain an explicit record
272 * of requests it submitted (just maintains qlen count), we
273 * rely on the hardware driver to clean up on disconnect or
274 * endpoint disable.
275 */
276 case -ECONNABORTED: /* hardware forced ep reset */
277 case -ECONNRESET: /* request dequeued */
278 case -ESHUTDOWN: /* disconnect from host */
279 free_ep_req(ep, req);
280 return;
281 }
282}
283
284static void disable_loopback(struct f_loopback *loop)
285{
286 struct usb_composite_dev *cdev;
287
288 cdev = loop->function.config->cdev;
289 disable_endpoints(cdev, loop->in_ep, loop->out_ep, NULL, NULL);
290 VDBG(cdev, "%s disabled\n", loop->function.name);
291}
292
293static int
294enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
295{
296 int result = 0;
297 struct usb_ep *ep;
298 struct usb_request *req;
299 unsigned i;
300
301 /* one endpoint writes data back IN to the host */
302 ep = loop->in_ep;
303 result = config_ep_by_speed(cdev->gadget, &(loop->function), ep);
304 if (result)
305 return result;
306 result = usb_ep_enable(ep);
307 if (result < 0)
308 return result;
309 ep->driver_data = loop;
310
311 /* one endpoint just reads OUT packets */
312 ep = loop->out_ep;
313 result = config_ep_by_speed(cdev->gadget, &(loop->function), ep);
314 if (result)
315 goto fail0;
316
317 result = usb_ep_enable(ep);
318 if (result < 0) {
319fail0:
320 ep = loop->in_ep;
321 usb_ep_disable(ep);
322 ep->driver_data = NULL;
323 return result;
324 }
325 ep->driver_data = loop;
326
327 /* allocate a bunch of read buffers and queue them all at once.
328 * we buffer at most 'qlen' transfers; fewer if any need more
329 * than 'buflen' bytes each.
330 */
331 for (i = 0; i < qlen && result == 0; i++) {
332 req = alloc_ep_req(ep, 0);
333 if (req) {
334 req->complete = loopback_complete;
335 result = usb_ep_queue(ep, req, GFP_ATOMIC);
336 if (result)
337 ERROR(cdev, "%s queue req --> %d\n",
338 ep->name, result);
339 } else {
340 usb_ep_disable(ep);
341 ep->driver_data = NULL;
342 result = -ENOMEM;
343 goto fail0;
344 }
345 }
346
347 DBG(cdev, "%s enabled\n", loop->function.name);
348 return result;
349}
350
351static int loopback_set_alt(struct usb_function *f,
352 unsigned intf, unsigned alt)
353{
354 struct f_loopback *loop = func_to_loop(f);
355 struct usb_composite_dev *cdev = f->config->cdev;
356
357 /* we know alt is zero */
358 if (loop->in_ep->driver_data)
359 disable_loopback(loop);
360 return enable_loopback(cdev, loop);
361}
362
363static void loopback_disable(struct usb_function *f)
364{
365 struct f_loopback *loop = func_to_loop(f);
366
367 disable_loopback(loop);
368}
369
370/*-------------------------------------------------------------------------*/
371
372static int __init loopback_bind_config(struct usb_configuration *c)
373{
374 struct f_loopback *loop;
375 int status;
376
377 loop = kzalloc(sizeof *loop, GFP_KERNEL);
378 if (!loop)
379 return -ENOMEM;
380
381 loop->function.name = "loopback";
382 loop->function.descriptors = fs_loopback_descs;
383 loop->function.bind = loopback_bind;
384 loop->function.unbind = loopback_unbind;
385 loop->function.set_alt = loopback_set_alt;
386 loop->function.disable = loopback_disable;
387
388 status = usb_add_function(c, &loop->function);
389 if (status)
390 kfree(loop);
391 return status;
392}
393
394static struct usb_configuration loopback_driver = {
395 .label = "loopback",
396 .strings = loopback_strings,
397 .bConfigurationValue = 2,
398 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
399 /* .iConfiguration = DYNAMIC */
400};
401
402/**
403 * loopback_add - add a loopback testing configuration to a device
404 * @cdev: the device to support the loopback configuration
405 */
406int __init loopback_add(struct usb_composite_dev *cdev, bool autoresume)
407{
408 int id;
409
410 /* allocate string ID(s) */
411 id = usb_string_id(cdev);
412 if (id < 0)
413 return id;
414 strings_loopback[0].id = id;
415
416 loopback_intf.iInterface = id;
417 loopback_driver.iConfiguration = id;
418
419 /* support autoresume for remote wakeup testing */
420 if (autoresume)
421 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
422
423 /* support OTG systems */
424 if (gadget_is_otg(cdev->gadget)) {
425 loopback_driver.descriptors = otg_desc;
426 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
427 }
428
429 return usb_add_config(cdev, &loopback_driver, loopback_bind_config);
430}