1 /** 2 * udc-core.c - Core UDC Framework 3 * 4 * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com 5 * 6 * Author: Felipe Balbi <balbi@ti.com> 7 * 8 * Taken from Linux Kernel v3.19-rc1 (drivers/usb/gadget/udc-core.c) and ported 9 * to uboot. 10 * 11 * commit 02e8c96627 : usb: gadget: udc: core: prepend udc_attach_driver with 12 * usb_ 13 * 14 * SPDX-License-Identifier: GPL-2.0 15 */ 16 17 #include <linux/compat.h> 18 #include <malloc.h> 19 #include <asm/cache.h> 20 #include <asm/dma-mapping.h> 21 #include <common.h> 22 #include <dm.h> 23 #include <dm/device-internal.h> 24 #include <linux/usb/ch9.h> 25 #include <linux/usb/gadget.h> 26 27 /** 28 * struct usb_udc - describes one usb device controller 29 * @driver - the gadget driver pointer. For use by the class code 30 * @dev - the child device to the actual controller 31 * @gadget - the gadget. For use by the class code 32 * @list - for use by the udc class driver 33 * 34 * This represents the internal data structure which is used by the UDC-class 35 * to hold information about udc driver and gadget together. 36 */ 37 struct usb_udc { 38 struct usb_gadget_driver *driver; 39 struct usb_gadget *gadget; 40 struct device dev; 41 struct list_head list; 42 }; 43 44 static struct class *udc_class; 45 static LIST_HEAD(udc_list); 46 DEFINE_MUTEX(udc_lock); 47 48 /* ------------------------------------------------------------------------- */ 49 50 int usb_gadget_map_request(struct usb_gadget *gadget, 51 struct usb_request *req, int is_in) 52 { 53 if (req->length == 0) 54 return 0; 55 56 req->dma = dma_map_single(req->buf, req->length, 57 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE); 58 59 return 0; 60 } 61 EXPORT_SYMBOL_GPL(usb_gadget_map_request); 62 63 void usb_gadget_unmap_request(struct usb_gadget *gadget, 64 struct usb_request *req, int is_in) 65 { 66 if (req->length == 0) 67 return; 68 69 dma_unmap_single((void *)(uintptr_t)req->dma, req->length, 70 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE); 71 } 72 EXPORT_SYMBOL_GPL(usb_gadget_unmap_request); 73 74 /* ------------------------------------------------------------------------- */ 75 76 /** 77 * usb_gadget_giveback_request - give the request back to the gadget layer 78 * Context: in_interrupt() 79 * 80 * This is called by device controller drivers in order to return the 81 * completed request back to the gadget layer. 82 */ 83 void usb_gadget_giveback_request(struct usb_ep *ep, 84 struct usb_request *req) 85 { 86 req->complete(ep, req); 87 } 88 EXPORT_SYMBOL_GPL(usb_gadget_giveback_request); 89 90 /* ------------------------------------------------------------------------- */ 91 92 void usb_gadget_set_state(struct usb_gadget *gadget, 93 enum usb_device_state state) 94 { 95 gadget->state = state; 96 } 97 EXPORT_SYMBOL_GPL(usb_gadget_set_state); 98 99 /* ------------------------------------------------------------------------- */ 100 101 /** 102 * usb_gadget_udc_reset - notifies the udc core that bus reset occurs 103 * @gadget: The gadget which bus reset occurs 104 * @driver: The gadget driver we want to notify 105 * 106 * If the udc driver has bus reset handler, it needs to call this when the bus 107 * reset occurs, it notifies the gadget driver that the bus reset occurs as 108 * well as updates gadget state. 109 */ 110 void usb_gadget_udc_reset(struct usb_gadget *gadget, 111 struct usb_gadget_driver *driver) 112 { 113 driver->reset(gadget); 114 usb_gadget_set_state(gadget, USB_STATE_DEFAULT); 115 } 116 EXPORT_SYMBOL_GPL(usb_gadget_udc_reset); 117 118 /** 119 * usb_gadget_udc_start - tells usb device controller to start up 120 * @udc: The UDC to be started 121 * 122 * This call is issued by the UDC Class driver when it's about 123 * to register a gadget driver to the device controller, before 124 * calling gadget driver's bind() method. 125 * 126 * It allows the controller to be powered off until strictly 127 * necessary to have it powered on. 128 * 129 * Returns zero on success, else negative errno. 130 */ 131 static inline int usb_gadget_udc_start(struct usb_udc *udc) 132 { 133 return udc->gadget->ops->udc_start(udc->gadget, udc->driver); 134 } 135 136 /** 137 * usb_gadget_udc_stop - tells usb device controller we don't need it anymore 138 * @gadget: The device we want to stop activity 139 * @driver: The driver to unbind from @gadget 140 * 141 * This call is issued by the UDC Class driver after calling 142 * gadget driver's unbind() method. 143 * 144 * The details are implementation specific, but it can go as 145 * far as powering off UDC completely and disable its data 146 * line pullups. 147 */ 148 static inline void usb_gadget_udc_stop(struct usb_udc *udc) 149 { 150 udc->gadget->ops->udc_stop(udc->gadget); 151 } 152 153 /** 154 * usb_udc_release - release the usb_udc struct 155 * @dev: the dev member within usb_udc 156 * 157 * This is called by driver's core in order to free memory once the last 158 * reference is released. 159 */ 160 static void usb_udc_release(struct device *dev) 161 { 162 struct usb_udc *udc; 163 164 udc = container_of(dev, struct usb_udc, dev); 165 kfree(udc); 166 } 167 168 /** 169 * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list 170 * @parent: the parent device to this udc. Usually the controller driver's 171 * device. 172 * @gadget: the gadget to be added to the list. 173 * @release: a gadget release function. 174 * 175 * Returns zero on success, negative errno otherwise. 176 */ 177 int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget, 178 void (*release)(struct device *dev)) 179 { 180 struct usb_udc *udc; 181 int ret = -ENOMEM; 182 183 udc = kzalloc(sizeof(*udc), GFP_KERNEL); 184 if (!udc) 185 goto err1; 186 187 dev_set_name(&gadget->dev, "gadget"); 188 gadget->dev.parent = parent; 189 190 udc->dev.release = usb_udc_release; 191 udc->dev.class = udc_class; 192 udc->dev.parent = parent; 193 194 udc->gadget = gadget; 195 196 mutex_lock(&udc_lock); 197 list_add_tail(&udc->list, &udc_list); 198 199 usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED); 200 201 mutex_unlock(&udc_lock); 202 203 return 0; 204 205 err1: 206 return ret; 207 } 208 EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release); 209 210 /** 211 * usb_add_gadget_udc - adds a new gadget to the udc class driver list 212 * @parent: the parent device to this udc. Usually the controller 213 * driver's device. 214 * @gadget: the gadget to be added to the list 215 * 216 * Returns zero on success, negative errno otherwise. 217 */ 218 int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget) 219 { 220 return usb_add_gadget_udc_release(parent, gadget, NULL); 221 } 222 EXPORT_SYMBOL_GPL(usb_add_gadget_udc); 223 224 static void usb_gadget_remove_driver(struct usb_udc *udc) 225 { 226 dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n", 227 udc->driver->function); 228 229 usb_gadget_disconnect(udc->gadget); 230 udc->driver->disconnect(udc->gadget); 231 udc->driver->unbind(udc->gadget); 232 usb_gadget_udc_stop(udc); 233 234 udc->driver = NULL; 235 } 236 237 /** 238 * usb_del_gadget_udc - deletes @udc from udc_list 239 * @gadget: the gadget to be removed. 240 * 241 * This, will call usb_gadget_unregister_driver() if 242 * the @udc is still busy. 243 */ 244 void usb_del_gadget_udc(struct usb_gadget *gadget) 245 { 246 struct usb_udc *udc = NULL; 247 248 mutex_lock(&udc_lock); 249 list_for_each_entry(udc, &udc_list, list) 250 if (udc->gadget == gadget) 251 goto found; 252 253 dev_err(gadget->dev.parent, "gadget not registered.\n"); 254 mutex_unlock(&udc_lock); 255 256 return; 257 258 found: 259 dev_vdbg(gadget->dev.parent, "unregistering gadget\n"); 260 261 list_del(&udc->list); 262 mutex_unlock(&udc_lock); 263 264 if (udc->driver) 265 usb_gadget_remove_driver(udc); 266 } 267 EXPORT_SYMBOL_GPL(usb_del_gadget_udc); 268 269 /* ------------------------------------------------------------------------- */ 270 271 /** 272 * usb_gadget_udc_set_speed - tells usb device controller speed supported by 273 * current driver 274 * @udc: The device we want to set maximum speed 275 * @speed: The maximum speed to allowed to run 276 * 277 * This call is issued by the UDC Class driver before calling 278 * usb_gadget_udc_start() in order to make sure that we don't try to 279 * connect on speeds the gadget driver doesn't support. 280 */ 281 static inline void usb_gadget_udc_set_speed(struct usb_udc *udc, 282 enum usb_device_speed speed) 283 { 284 if (udc->gadget->ops->udc_set_speed) { 285 enum usb_device_speed s; 286 287 s = min(speed, udc->gadget->max_speed); 288 udc->gadget->ops->udc_set_speed(udc->gadget, s); 289 } 290 } 291 292 static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver) 293 { 294 int ret; 295 296 dev_dbg(&udc->dev, "registering UDC driver [%s]\n", 297 driver->function); 298 299 udc->driver = driver; 300 301 usb_gadget_udc_set_speed(udc, driver->speed); 302 303 ret = driver->bind(udc->gadget); 304 if (ret) 305 goto err1; 306 ret = usb_gadget_udc_start(udc); 307 if (ret) { 308 driver->unbind(udc->gadget); 309 goto err1; 310 } 311 usb_gadget_connect(udc->gadget); 312 313 return 0; 314 err1: 315 if (ret != -EISNAM) 316 dev_err(&udc->dev, "failed to start %s: %d\n", 317 udc->driver->function, ret); 318 udc->driver = NULL; 319 return ret; 320 } 321 322 int usb_gadget_probe_driver(struct usb_gadget_driver *driver) 323 { 324 struct usb_udc *udc = NULL; 325 int ret; 326 327 if (!driver || !driver->bind || !driver->setup) 328 return -EINVAL; 329 330 mutex_lock(&udc_lock); 331 list_for_each_entry(udc, &udc_list, list) { 332 /* For now we take the first one */ 333 if (!udc->driver) 334 goto found; 335 } 336 337 printf("couldn't find an available UDC\n"); 338 mutex_unlock(&udc_lock); 339 return -ENODEV; 340 found: 341 ret = udc_bind_to_driver(udc, driver); 342 mutex_unlock(&udc_lock); 343 return ret; 344 } 345 EXPORT_SYMBOL_GPL(usb_gadget_probe_driver); 346 347 int usb_gadget_register_driver(struct usb_gadget_driver *driver) 348 { 349 return usb_gadget_probe_driver(driver); 350 } 351 EXPORT_SYMBOL_GPL(usb_gadget_register_driver); 352 353 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) 354 { 355 struct usb_udc *udc = NULL; 356 int ret = -ENODEV; 357 358 if (!driver || !driver->unbind) 359 return -EINVAL; 360 361 mutex_lock(&udc_lock); 362 list_for_each_entry(udc, &udc_list, list) 363 if (udc->driver == driver) { 364 usb_gadget_remove_driver(udc); 365 usb_gadget_set_state(udc->gadget, 366 USB_STATE_NOTATTACHED); 367 ret = 0; 368 break; 369 } 370 371 mutex_unlock(&udc_lock); 372 return ret; 373 } 374 EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver); 375 376 MODULE_DESCRIPTION("UDC Framework"); 377 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>"); 378 MODULE_LICENSE("GPL v2"); 379