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, 56 struct usb_endpoint_descriptor *desc, 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 */ 71 type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; 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) { 86 case USB_ENDPOINT_XFER_INT: 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; 99 case USB_ENDPOINT_XFER_BULK: 100 if ('b' != tmp[1]) // != "-bulk" 101 return 0; 102 break; 103 case USB_ENDPOINT_XFER_ISOC: 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) { 150 case USB_ENDPOINT_XFER_INT: 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 156 case USB_ENDPOINT_XFER_ISOC: 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 216 /** 217 * usb_ep_autoconfig_ss() - choose an endpoint matching the ep 218 * descriptor and ep companion descriptor 219 * @gadget: The device to which the endpoint must belong. 220 * @desc: Endpoint descriptor, with endpoint direction and transfer mode 221 * initialized. For periodic transfers, the maximum packet 222 * size must also be initialized. This is modified on 223 * success. 224 * @ep_comp: Endpoint companion descriptor, with the required 225 * number of streams. Will be modified when the chosen EP 226 * supports a different number of streams. 227 * 228 * This routine replaces the usb_ep_autoconfig when needed 229 * superspeed enhancments. If such enhancemnets are required, 230 * the FD should call usb_ep_autoconfig_ss directly and provide 231 * the additional ep_comp parameter. 232 * 233 * By choosing an endpoint to use with the specified descriptor, 234 * this routine simplifies writing gadget drivers that work with 235 * multiple USB device controllers. The endpoint would be 236 * passed later to usb_ep_enable(), along with some descriptor. 237 * 238 * That second descriptor won't always be the same as the first one. 239 * For example, isochronous endpoints can be autoconfigured for high 240 * bandwidth, and then used in several lower bandwidth altsettings. 241 * Also, high and full speed descriptors will be different. 242 * 243 * Be sure to examine and test the results of autoconfiguration 244 * on your hardware. This code may not make the best choices 245 * about how to use the USB controller, and it can't know all 246 * the restrictions that may apply. Some combinations of driver 247 * and hardware won't be able to autoconfigure. 248 * 249 * On success, this returns an un-claimed usb_ep, and modifies the endpoint 250 * descriptor bEndpointAddress. For bulk endpoints, the wMaxPacket value 251 * is initialized as if the endpoint were used at full speed and 252 * the bmAttribute field in the ep companion descriptor is 253 * updated with the assigned number of streams if it is 254 * different from the original value. To prevent the endpoint 255 * from being returned by a later autoconfig call, claim it by 256 * assigning ep->driver_data to some non-null value. 257 * 258 * On failure, this returns a null endpoint descriptor. 259 */ 260 struct usb_ep *usb_ep_autoconfig_ss( 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 269 type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; 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 return ep; 279 ep = find_ep (gadget, "ep-f"); 280 if (ep && ep_matches(gadget, ep, desc, ep_comp)) 281 return 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 return 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 return 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 return 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 return ep; 322 } 323 324 /* Fail */ 325 return NULL; 326 } 327 328 /** 329 * usb_ep_autoconfig() - choose an endpoint matching the 330 * descriptor 331 * @gadget: The device to which the endpoint must belong. 332 * @desc: Endpoint descriptor, with endpoint direction and transfer mode 333 * initialized. For periodic transfers, the maximum packet 334 * size must also be initialized. This is modified on success. 335 * 336 * By choosing an endpoint to use with the specified descriptor, this 337 * routine simplifies writing gadget drivers that work with multiple 338 * USB device controllers. The endpoint would be passed later to 339 * usb_ep_enable(), along with some descriptor. 340 * 341 * That second descriptor won't always be the same as the first one. 342 * For example, isochronous endpoints can be autoconfigured for high 343 * bandwidth, and then used in several lower bandwidth altsettings. 344 * Also, high and full speed descriptors will be different. 345 * 346 * Be sure to examine and test the results of autoconfiguration on your 347 * hardware. This code may not make the best choices about how to use the 348 * USB controller, and it can't know all the restrictions that may apply. 349 * Some combinations of driver and hardware won't be able to autoconfigure. 350 * 351 * On success, this returns an un-claimed usb_ep, and modifies the endpoint 352 * descriptor bEndpointAddress. For bulk endpoints, the wMaxPacket value 353 * is initialized as if the endpoint were used at full speed. To prevent 354 * the endpoint from being returned by a later autoconfig call, claim it 355 * by assigning ep->driver_data to some non-null value. 356 * 357 * On failure, this returns a null endpoint descriptor. 358 */ 359 struct usb_ep *usb_ep_autoconfig( 360 struct usb_gadget *gadget, 361 struct usb_endpoint_descriptor *desc 362 ) 363 { 364 return usb_ep_autoconfig_ss(gadget, desc, NULL); 365 } 366 367 368 /** 369 * usb_ep_autoconfig_reset - reset endpoint autoconfig state 370 * @gadget: device for which autoconfig state will be reset 371 * 372 * Use this for devices where one configuration may need to assign 373 * endpoint resources very differently from the next one. It clears 374 * state such as ep->driver_data and the record of assigned endpoints 375 * used by usb_ep_autoconfig(). 376 */ 377 void usb_ep_autoconfig_reset (struct usb_gadget *gadget) 378 { 379 struct usb_ep *ep; 380 381 list_for_each_entry (ep, &gadget->ep_list, ep_list) { 382 ep->driver_data = NULL; 383 } 384 #ifdef MANY_ENDPOINTS 385 in_epnum = 0; 386 #endif 387 epnum = 0; 388 } 389 390