1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * epautoconf.c -- endpoint autoconfiguration for usb gadget drivers 4 * 5 * Copyright (C) 2004 David Brownell 6 * 7 * Ported to U-Boot by: Thomas Smits <ts.smits@gmail.com> and 8 * Remy Bohmer <linux@bohmer.net> 9 */ 10 11 #include <common.h> 12 #include <linux/usb/ch9.h> 13 #include <linux/errno.h> 14 #include <linux/usb/gadget.h> 15 #include <asm/unaligned.h> 16 #include "gadget_chips.h" 17 18 #define isdigit(c) ('0' <= (c) && (c) <= '9') 19 20 /* we must assign addresses for configurable endpoints (like net2280) */ 21 static unsigned epnum; 22 23 /* #define MANY_ENDPOINTS */ 24 #ifdef MANY_ENDPOINTS 25 /* more than 15 configurable endpoints */ 26 static unsigned in_epnum; 27 #endif 28 29 30 /* 31 * This should work with endpoints from controller drivers sharing the 32 * same endpoint naming convention. By example: 33 * 34 * - ep1, ep2, ... address is fixed, not direction or type 35 * - ep1in, ep2out, ... address and direction are fixed, not type 36 * - ep1-bulk, ep2-bulk, ... address and type are fixed, not direction 37 * - ep1in-bulk, ep2out-iso, ... all three are fixed 38 * - ep-* ... no functionality restrictions 39 * 40 * Type suffixes are "-bulk", "-iso", or "-int". Numbers are decimal. 41 * Less common restrictions are implied by gadget_is_*(). 42 * 43 * NOTE: each endpoint is unidirectional, as specified by its USB 44 * descriptor; and isn't specific to a configuration or altsetting. 45 */ 46 static int ep_matches( 47 struct usb_gadget *gadget, 48 struct usb_ep *ep, 49 struct usb_endpoint_descriptor *desc 50 ) 51 { 52 u8 type; 53 const char *tmp; 54 u16 max; 55 56 /* endpoint already claimed? */ 57 if (NULL != ep->driver_data) 58 return 0; 59 60 /* only support ep0 for portable CONTROL traffic */ 61 type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; 62 if (USB_ENDPOINT_XFER_CONTROL == type) 63 return 0; 64 65 /* some other naming convention */ 66 if ('e' != ep->name[0]) 67 return 0; 68 69 /* type-restriction: "-iso", "-bulk", or "-int". 70 * direction-restriction: "in", "out". 71 */ 72 if ('-' != ep->name[2]) { 73 tmp = strrchr(ep->name, '-'); 74 if (tmp) { 75 switch (type) { 76 case USB_ENDPOINT_XFER_INT: 77 /* bulk endpoints handle interrupt transfers, 78 * except the toggle-quirky iso-synch kind 79 */ 80 if ('s' == tmp[2]) /* == "-iso" */ 81 return 0; 82 /* for now, avoid PXA "interrupt-in"; 83 * it's documented as never using DATA1. 84 */ 85 if (gadget_is_pxa(gadget) 86 && 'i' == tmp[1]) 87 return 0; 88 break; 89 case USB_ENDPOINT_XFER_BULK: 90 if ('b' != tmp[1]) /* != "-bulk" */ 91 return 0; 92 break; 93 case USB_ENDPOINT_XFER_ISOC: 94 if ('s' != tmp[2]) /* != "-iso" */ 95 return 0; 96 } 97 } else { 98 tmp = ep->name + strlen(ep->name); 99 } 100 101 /* direction-restriction: "..in-..", "out-.." */ 102 tmp--; 103 if (!isdigit(*tmp)) { 104 if (desc->bEndpointAddress & USB_DIR_IN) { 105 if ('n' != *tmp) 106 return 0; 107 } else { 108 if ('t' != *tmp) 109 return 0; 110 } 111 } 112 } 113 114 /* endpoint maxpacket size is an input parameter, except for bulk 115 * where it's an output parameter representing the full speed limit. 116 * the usb spec fixes high speed bulk maxpacket at 512 bytes. 117 */ 118 max = 0x7ff & le16_to_cpu(get_unaligned(&desc->wMaxPacketSize)); 119 switch (type) { 120 case USB_ENDPOINT_XFER_INT: 121 /* INT: limit 64 bytes full speed, 1024 high speed */ 122 if (!gadget->is_dualspeed && max > 64) 123 return 0; 124 /* FALLTHROUGH */ 125 126 case USB_ENDPOINT_XFER_ISOC: 127 /* ISO: limit 1023 bytes full speed, 1024 high speed */ 128 if (ep->maxpacket < max) 129 return 0; 130 if (!gadget->is_dualspeed && max > 1023) 131 return 0; 132 133 /* BOTH: "high bandwidth" works only at high speed */ 134 if ((get_unaligned(&desc->wMaxPacketSize) & 135 __constant_cpu_to_le16(3<<11))) { 136 if (!gadget->is_dualspeed) 137 return 0; 138 /* configure your hardware with enough buffering!! */ 139 } 140 break; 141 } 142 143 /* MATCH!! */ 144 145 /* report address */ 146 if (isdigit(ep->name[2])) { 147 u8 num = simple_strtoul(&ep->name[2], NULL, 10); 148 desc->bEndpointAddress |= num; 149 #ifdef MANY_ENDPOINTS 150 } else if (desc->bEndpointAddress & USB_DIR_IN) { 151 if (++in_epnum > 15) 152 return 0; 153 desc->bEndpointAddress = USB_DIR_IN | in_epnum; 154 #endif 155 } else { 156 if (++epnum > 15) 157 return 0; 158 desc->bEndpointAddress |= epnum; 159 } 160 161 /* report (variable) full speed bulk maxpacket */ 162 if (USB_ENDPOINT_XFER_BULK == type) { 163 int size = ep->maxpacket; 164 165 /* min() doesn't work on bitfields with gcc-3.5 */ 166 if (size > 64) 167 size = 64; 168 put_unaligned(cpu_to_le16(size), &desc->wMaxPacketSize); 169 } 170 return 1; 171 } 172 173 static struct usb_ep * 174 find_ep(struct usb_gadget *gadget, const char *name) 175 { 176 struct usb_ep *ep; 177 178 list_for_each_entry(ep, &gadget->ep_list, ep_list) { 179 if (0 == strcmp(ep->name, name)) 180 return ep; 181 } 182 return NULL; 183 } 184 185 /** 186 * usb_ep_autoconfig - choose an endpoint matching the descriptor 187 * @gadget: The device to which the endpoint must belong. 188 * @desc: Endpoint descriptor, with endpoint direction and transfer mode 189 * initialized. For periodic transfers, the maximum packet 190 * size must also be initialized. This is modified on success. 191 * 192 * By choosing an endpoint to use with the specified descriptor, this 193 * routine simplifies writing gadget drivers that work with multiple 194 * USB device controllers. The endpoint would be passed later to 195 * usb_ep_enable(), along with some descriptor. 196 * 197 * That second descriptor won't always be the same as the first one. 198 * For example, isochronous endpoints can be autoconfigured for high 199 * bandwidth, and then used in several lower bandwidth altsettings. 200 * Also, high and full speed descriptors will be different. 201 * 202 * Be sure to examine and test the results of autoconfiguration on your 203 * hardware. This code may not make the best choices about how to use the 204 * USB controller, and it can't know all the restrictions that may apply. 205 * Some combinations of driver and hardware won't be able to autoconfigure. 206 * 207 * On success, this returns an un-claimed usb_ep, and modifies the endpoint 208 * descriptor bEndpointAddress. For bulk endpoints, the wMaxPacket value 209 * is initialized as if the endpoint were used at full speed. To prevent 210 * the endpoint from being returned by a later autoconfig call, claim it 211 * by assigning ep->driver_data to some non-null value. 212 * 213 * On failure, this returns a null endpoint descriptor. 214 */ 215 struct usb_ep *usb_ep_autoconfig( 216 struct usb_gadget *gadget, 217 struct usb_endpoint_descriptor *desc 218 ) 219 { 220 struct usb_ep *ep = NULL; 221 u8 type; 222 223 type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; 224 225 /* First, apply chip-specific "best usage" knowledge. 226 * This might make a good usb_gadget_ops hook ... 227 */ 228 if (gadget_is_net2280(gadget) && type == USB_ENDPOINT_XFER_INT) { 229 /* ep-e, ep-f are PIO with only 64 byte fifos */ 230 ep = find_ep(gadget, "ep-e"); 231 if (ep && ep_matches(gadget, ep, desc)) 232 return ep; 233 ep = find_ep(gadget, "ep-f"); 234 if (ep && ep_matches(gadget, ep, desc)) 235 return ep; 236 237 } else if (gadget_is_goku(gadget)) { 238 if (USB_ENDPOINT_XFER_INT == type) { 239 /* single buffering is enough */ 240 ep = find_ep(gadget, "ep3-bulk"); 241 if (ep && ep_matches(gadget, ep, desc)) 242 return ep; 243 } else if (USB_ENDPOINT_XFER_BULK == type 244 && (USB_DIR_IN & desc->bEndpointAddress)) { 245 /* DMA may be available */ 246 ep = find_ep(gadget, "ep2-bulk"); 247 if (ep && ep_matches(gadget, ep, desc)) 248 return ep; 249 } 250 251 } else if (gadget_is_sh(gadget) && USB_ENDPOINT_XFER_INT == type) { 252 /* single buffering is enough; maybe 8 byte fifo is too */ 253 ep = find_ep(gadget, "ep3in-bulk"); 254 if (ep && ep_matches(gadget, ep, desc)) 255 return ep; 256 257 } else if (gadget_is_mq11xx(gadget) && USB_ENDPOINT_XFER_INT == type) { 258 ep = find_ep(gadget, "ep1-bulk"); 259 if (ep && ep_matches(gadget, ep, desc)) 260 return ep; 261 } else if (gadget_is_dwc3(gadget)) { 262 const char *name = NULL; 263 /* 264 * First try standard, common configuration: ep1in-bulk, 265 * ep2out-bulk, ep3in-int to match other udc drivers to avoid 266 * confusion in already deployed software (endpoint numbers 267 * hardcoded in userspace software/drivers) 268 */ 269 if ((desc->bEndpointAddress & USB_DIR_IN) && 270 type == USB_ENDPOINT_XFER_BULK) 271 name = "ep1in"; 272 else if ((desc->bEndpointAddress & USB_DIR_IN) == 0 && 273 type == USB_ENDPOINT_XFER_BULK) 274 name = "ep2out"; 275 else if ((desc->bEndpointAddress & USB_DIR_IN) && 276 type == USB_ENDPOINT_XFER_INT) 277 name = "ep3in"; 278 279 if (name) 280 ep = find_ep(gadget, name); 281 if (ep && ep_matches(gadget, ep, desc)) 282 return ep; 283 } 284 285 /* Second, look at endpoints until an unclaimed one looks usable */ 286 list_for_each_entry(ep, &gadget->ep_list, ep_list) { 287 if (ep_matches(gadget, ep, desc)) 288 return ep; 289 } 290 291 /* Fail */ 292 return NULL; 293 } 294 295 /** 296 * usb_ep_autoconfig_reset - reset endpoint autoconfig state 297 * @gadget: device for which autoconfig state will be reset 298 * 299 * Use this for devices where one configuration may need to assign 300 * endpoint resources very differently from the next one. It clears 301 * state such as ep->driver_data and the record of assigned endpoints 302 * used by usb_ep_autoconfig(). 303 */ 304 void usb_ep_autoconfig_reset(struct usb_gadget *gadget) 305 { 306 struct usb_ep *ep; 307 308 list_for_each_entry(ep, &gadget->ep_list, ep_list) { 309 ep->driver_data = NULL; 310 } 311 #ifdef MANY_ENDPOINTS 312 in_epnum = 0; 313 #endif 314 epnum = 0; 315 } 316