Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
epautoconf.c
Go to the documentation of this file.
1 /*
2  * epautoconf.c -- endpoint autoconfiguration for usb gadget drivers
3  *
4  * Copyright (C) 2004 David Brownell
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  */
11 
12 #include <linux/kernel.h>
13 #include <linux/init.h>
14 #include <linux/types.h>
15 #include <linux/device.h>
16 
17 #include <linux/ctype.h>
18 #include <linux/string.h>
19 
20 #include <linux/usb/ch9.h>
21 #include <linux/usb/gadget.h>
22 
23 #include "gadget_chips.h"
24 
25 
26 /* we must assign addresses for configurable endpoints (like net2280) */
27 static unsigned epnum;
28 
29 // #define MANY_ENDPOINTS
30 #ifdef MANY_ENDPOINTS
31 /* more than 15 configurable endpoints */
32 static unsigned in_epnum;
33 #endif
34 
35 
36 /*
37  * This should work with endpoints from controller drivers sharing the
38  * same endpoint naming convention. By example:
39  *
40  * - ep1, ep2, ... address is fixed, not direction or type
41  * - ep1in, ep2out, ... address and direction are fixed, not type
42  * - ep1-bulk, ep2-bulk, ... address and type are fixed, not direction
43  * - ep1in-bulk, ep2out-iso, ... all three are fixed
44  * - ep-* ... no functionality restrictions
45  *
46  * Type suffixes are "-bulk", "-iso", or "-int". Numbers are decimal.
47  * Less common restrictions are implied by gadget_is_*().
48  *
49  * NOTE: each endpoint is unidirectional, as specified by its USB
50  * descriptor; and isn't specific to a configuration or altsetting.
51  */
52 static int
53 ep_matches (
54  struct usb_gadget *gadget,
55  struct usb_ep *ep,
57  struct usb_ss_ep_comp_descriptor *ep_comp
58 )
59 {
60  u8 type;
61  const char *tmp;
62  u16 max;
63 
64  int num_req_streams = 0;
65 
66  /* endpoint already claimed? */
67  if (NULL != ep->driver_data)
68  return 0;
69 
70  /* only support ep0 for portable CONTROL traffic */
72  if (USB_ENDPOINT_XFER_CONTROL == type)
73  return 0;
74 
75  /* some other naming convention */
76  if ('e' != ep->name[0])
77  return 0;
78 
79  /* type-restriction: "-iso", "-bulk", or "-int".
80  * direction-restriction: "in", "out".
81  */
82  if ('-' != ep->name[2]) {
83  tmp = strrchr (ep->name, '-');
84  if (tmp) {
85  switch (type) {
87  /* bulk endpoints handle interrupt transfers,
88  * except the toggle-quirky iso-synch kind
89  */
90  if ('s' == tmp[2]) // == "-iso"
91  return 0;
92  /* for now, avoid PXA "interrupt-in";
93  * it's documented as never using DATA1.
94  */
95  if (gadget_is_pxa (gadget)
96  && 'i' == tmp [1])
97  return 0;
98  break;
100  if ('b' != tmp[1]) // != "-bulk"
101  return 0;
102  break;
104  if ('s' != tmp[2]) // != "-iso"
105  return 0;
106  }
107  } else {
108  tmp = ep->name + strlen (ep->name);
109  }
110 
111  /* direction-restriction: "..in-..", "out-.." */
112  tmp--;
113  if (!isdigit (*tmp)) {
114  if (desc->bEndpointAddress & USB_DIR_IN) {
115  if ('n' != *tmp)
116  return 0;
117  } else {
118  if ('t' != *tmp)
119  return 0;
120  }
121  }
122  }
123 
124  /*
125  * Get the number of required streams from the EP companion
126  * descriptor and see if the EP matches it
127  */
128  if (usb_endpoint_xfer_bulk(desc)) {
129  if (ep_comp && gadget->max_speed >= USB_SPEED_SUPER) {
130  num_req_streams = ep_comp->bmAttributes & 0x1f;
131  if (num_req_streams > ep->max_streams)
132  return 0;
133  }
134 
135  }
136 
137  /*
138  * If the protocol driver hasn't yet decided on wMaxPacketSize
139  * and wants to know the maximum possible, provide the info.
140  */
141  if (desc->wMaxPacketSize == 0)
142  desc->wMaxPacketSize = cpu_to_le16(ep->maxpacket);
143 
144  /* endpoint maxpacket size is an input parameter, except for bulk
145  * where it's an output parameter representing the full speed limit.
146  * the usb spec fixes high speed bulk maxpacket at 512 bytes.
147  */
148  max = 0x7ff & usb_endpoint_maxp(desc);
149  switch (type) {
151  /* INT: limit 64 bytes full speed, 1024 high/super speed */
152  if (!gadget_is_dualspeed(gadget) && max > 64)
153  return 0;
154  /* FALLTHROUGH */
155 
157  /* ISO: limit 1023 bytes full speed, 1024 high/super speed */
158  if (ep->maxpacket < max)
159  return 0;
160  if (!gadget_is_dualspeed(gadget) && max > 1023)
161  return 0;
162 
163  /* BOTH: "high bandwidth" works only at high speed */
164  if ((desc->wMaxPacketSize & cpu_to_le16(3<<11))) {
165  if (!gadget_is_dualspeed(gadget))
166  return 0;
167  /* configure your hardware with enough buffering!! */
168  }
169  break;
170  }
171 
172  /* MATCH!! */
173 
174  /* report address */
175  desc->bEndpointAddress &= USB_DIR_IN;
176  if (isdigit (ep->name [2])) {
177  u8 num = simple_strtoul (&ep->name [2], NULL, 10);
178  desc->bEndpointAddress |= num;
179 #ifdef MANY_ENDPOINTS
180  } else if (desc->bEndpointAddress & USB_DIR_IN) {
181  if (++in_epnum > 15)
182  return 0;
183  desc->bEndpointAddress = USB_DIR_IN | in_epnum;
184 #endif
185  } else {
186  if (++epnum > 15)
187  return 0;
188  desc->bEndpointAddress |= epnum;
189  }
190 
191  /* report (variable) full speed bulk maxpacket */
192  if ((USB_ENDPOINT_XFER_BULK == type) && !ep_comp) {
193  int size = ep->maxpacket;
194 
195  /* min() doesn't work on bitfields with gcc-3.5 */
196  if (size > 64)
197  size = 64;
198  desc->wMaxPacketSize = cpu_to_le16(size);
199  }
200  ep->address = desc->bEndpointAddress;
201  return 1;
202 }
203 
204 static struct usb_ep *
205 find_ep (struct usb_gadget *gadget, const char *name)
206 {
207  struct usb_ep *ep;
208 
209  list_for_each_entry (ep, &gadget->ep_list, ep_list) {
210  if (0 == strcmp (ep->name, name))
211  return ep;
212  }
213  return NULL;
214 }
215 
261  struct usb_gadget *gadget,
262  struct usb_endpoint_descriptor *desc,
263  struct usb_ss_ep_comp_descriptor *ep_comp
264 )
265 {
266  struct usb_ep *ep;
267  u8 type;
268 
270 
271  /* First, apply chip-specific "best usage" knowledge.
272  * This might make a good usb_gadget_ops hook ...
273  */
274  if (gadget_is_net2280 (gadget) && type == USB_ENDPOINT_XFER_INT) {
275  /* ep-e, ep-f are PIO with only 64 byte fifos */
276  ep = find_ep (gadget, "ep-e");
277  if (ep && ep_matches(gadget, ep, desc, ep_comp))
278  goto found_ep;
279  ep = find_ep (gadget, "ep-f");
280  if (ep && ep_matches(gadget, ep, desc, ep_comp))
281  goto found_ep;
282 
283  } else if (gadget_is_goku (gadget)) {
284  if (USB_ENDPOINT_XFER_INT == type) {
285  /* single buffering is enough */
286  ep = find_ep(gadget, "ep3-bulk");
287  if (ep && ep_matches(gadget, ep, desc, ep_comp))
288  goto found_ep;
289  } else if (USB_ENDPOINT_XFER_BULK == type
290  && (USB_DIR_IN & desc->bEndpointAddress)) {
291  /* DMA may be available */
292  ep = find_ep(gadget, "ep2-bulk");
293  if (ep && ep_matches(gadget, ep, desc,
294  ep_comp))
295  goto found_ep;
296  }
297 
298 #ifdef CONFIG_BLACKFIN
299  } else if (gadget_is_musbhdrc(gadget)) {
300  if ((USB_ENDPOINT_XFER_BULK == type) ||
301  (USB_ENDPOINT_XFER_ISOC == type)) {
302  if (USB_DIR_IN & desc->bEndpointAddress)
303  ep = find_ep (gadget, "ep5in");
304  else
305  ep = find_ep (gadget, "ep6out");
306  } else if (USB_ENDPOINT_XFER_INT == type) {
307  if (USB_DIR_IN & desc->bEndpointAddress)
308  ep = find_ep(gadget, "ep1in");
309  else
310  ep = find_ep(gadget, "ep2out");
311  } else
312  ep = NULL;
313  if (ep && ep_matches(gadget, ep, desc, ep_comp))
314  goto found_ep;
315 #endif
316  }
317 
318  /* Second, look at endpoints until an unclaimed one looks usable */
319  list_for_each_entry (ep, &gadget->ep_list, ep_list) {
320  if (ep_matches(gadget, ep, desc, ep_comp))
321  goto found_ep;
322  }
323 
324  /* Fail */
325  return NULL;
326 found_ep:
327  ep->desc = NULL;
328  ep->comp_desc = NULL;
329  return ep;
330 }
331 
364  struct usb_gadget *gadget,
365  struct usb_endpoint_descriptor *desc
366 )
367 {
368  return usb_ep_autoconfig_ss(gadget, desc, NULL);
369 }
370 
371 
381 void usb_ep_autoconfig_reset (struct usb_gadget *gadget)
382 {
383  struct usb_ep *ep;
384 
385  list_for_each_entry (ep, &gadget->ep_list, ep_list) {
386  ep->driver_data = NULL;
387  }
388 #ifdef MANY_ENDPOINTS
389  in_epnum = 0;
390 #endif
391  epnum = 0;
392 }
393