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 */
35 struct f_loopback {
36 struct usb_function function;
37
38 struct usb_ep *in_ep;
39 struct usb_ep *out_ep;
40 };
41
func_to_loop(struct usb_function * f)42 static inline struct f_loopback *func_to_loop(struct usb_function *f)
43 {
44 return container_of(f, struct f_loopback, function);
45 }
46
47 static unsigned qlen = 32;
48 module_param(qlen, uint, 0);
49 MODULE_PARM_DESC(qlenn, "depth of loopback queue");
50
51 /*-------------------------------------------------------------------------*/
52
53 static 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
64 static 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
72 static 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
80 static 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
89 static 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
97 static 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
105 static 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
114 static 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
122 struct 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
130 static 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
138 struct 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
146 static 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
157 static struct usb_string strings_loopback[] = {
158 [0].s = "loop input to output",
159 { } /* end of list */
160 };
161
162 static struct usb_gadget_strings stringtab_loop = {
163 .language = 0x0409, /* en-us */
164 .strings = strings_loopback,
165 };
166
167 static struct usb_gadget_strings *loopback_strings[] = {
168 &stringtab_loop,
169 NULL,
170 };
171
172 /*-------------------------------------------------------------------------*/
173
174 static int __init
loopback_bind(struct usb_configuration * c,struct usb_function * f)175 loopback_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) {
191 autoconf_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
228 static void
loopback_unbind(struct usb_configuration * c,struct usb_function * f)229 loopback_unbind(struct usb_configuration *c, struct usb_function *f)
230 {
231 kfree(func_to_loop(f));
232 }
233
loopback_complete(struct usb_ep * ep,struct usb_request * req)234 static 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
disable_loopback(struct f_loopback * loop)284 static 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);
290 VDBG(cdev, "%s disabled\n", loop->function.name);
291 }
292
293 static int
enable_loopback(struct usb_composite_dev * cdev,struct f_loopback * loop)294 enable_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) {
319 fail0:
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);
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
loopback_set_alt(struct usb_function * f,unsigned intf,unsigned alt)351 static 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
loopback_disable(struct usb_function * f)363 static 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
loopback_bind_config(struct usb_configuration * c)372 static 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
394 static 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 */
loopback_add(struct usb_composite_dev * cdev,bool autoresume)406 int __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 }
431