usb: gadget: remove global variable composite in composite.c

tjh.dev / kernel

fork atom

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork atom

usb: gadget: remove global variable composite in composite.c

This patch removes the global variable composite in composite.c.
The private data which was saved there is now passed via an additional
argument to the bind() function in struct usb_gadget_driver.

Only the "old-style" UDC drivers have to be touched here, new style are
doing it right because this change is made in udc-core.

Acked-by: Michal Nazarewicz <mina86@mina86.com>
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: Felipe Balbi <balbi@ti.com>

authored by

Sebastian Andrzej Siewior and committed by

Felipe Balbi 13 years ago ffe0b335 e220ff75

+78 -63

19 changed files

expand all collapse all

drivers

staging

ccg

composite.c

usb

gadget

amd5536udc.c

composite.c

dbgp.c

file_storage.c

fsl_udc_core.c

fusb300_udc.c

goku_udc.c

inode.c

m66592-udc.c

mv_udc_core.c

omap_udc.c

pch_udc.c

pxa25x_udc.c

pxa27x_udc.c

s3c2410_udc.c

udc-core.c

include

linux

usb

composite.h

gadget.h

+2 -1

drivers/staging/ccg/composite.c

reviewed

··· 1422 1422 return *desc; 1423 1423 } 1424 1424 1425 1425 - static int composite_bind(struct usb_gadget *gadget) 1425 1425 + static int composite_bind(struct usb_gadget *gadget, 1426 1426 + struct usb_gadget_driver *driver) 1426 1427 { 1427 1428 struct usb_composite_dev *cdev; 1428 1429 int status = -ENOMEM;

+3 -3

drivers/usb/gadget/amd5536udc.c

reviewed

··· 1401 1401 } 1402 1402 1403 1403 static int amd5536_start(struct usb_gadget_driver *driver, 1404 1404 - int (*bind)(struct usb_gadget *)); 1404 1404 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 1405 1405 static int amd5536_stop(struct usb_gadget_driver *driver); 1406 1406 /* gadget operations */ 1407 1407 static const struct usb_gadget_ops udc_ops = { ··· 1914 1914 1915 1915 /* Called by gadget driver to register itself */ 1916 1916 static int amd5536_start(struct usb_gadget_driver *driver, 1917 1917 - int (*bind)(struct usb_gadget *)) 1917 1917 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1918 1918 { 1919 1919 struct udc *dev = udc; 1920 1920 int retval; ··· 1932 1932 dev->driver = driver; 1933 1933 dev->gadget.dev.driver = &driver->driver; 1934 1934 1935 1935 - retval = bind(&dev->gadget); 1935 1935 + retval = bind(&dev->gadget, driver); 1936 1936 1937 1937 /* Some gadget drivers use both ep0 directions. 1938 1938 * NOTE: to gadget driver, ep0 is just one endpoint...

+30 -22

drivers/usb/gadget/composite.c

reviewed

··· 31 31 /* big enough to hold our biggest descriptor */ 32 32 #define USB_BUFSIZ 1024 33 33 34 34 - static struct usb_composite_driver *composite; 35 35 - 36 34 /* Some systems will need runtime overrides for the product identifiers 37 35 * published in the device descriptor, either numbers or strings or both. 38 36 * String parameters are in UTF-8 (superset of ASCII's 7 bit characters). ··· 887 889 static int get_string(struct usb_composite_dev *cdev, 888 890 void *buf, u16 language, int id) 889 891 { 892 892 + struct usb_composite_driver *composite = cdev->driver; 890 893 struct usb_configuration *c; 891 894 struct usb_function *f; 892 895 int len; ··· 1358 1359 spin_lock_irqsave(&cdev->lock, flags); 1359 1360 if (cdev->config) 1360 1361 reset_config(cdev); 1361 1361 - if (composite->disconnect) 1362 1362 - composite->disconnect(cdev); 1362 1362 + if (cdev->driver->disconnect) 1363 1363 + cdev->driver->disconnect(cdev); 1363 1364 spin_unlock_irqrestore(&cdev->lock, flags); 1364 1365 } 1365 1366 ··· 1395 1396 struct usb_configuration, list); 1396 1397 remove_config(cdev, c); 1397 1398 } 1398 1398 - if (composite->unbind) 1399 1399 - composite->unbind(cdev); 1399 1399 + if (cdev->driver->unbind) 1400 1400 + cdev->driver->unbind(cdev); 1400 1401 1401 1402 if (cdev->req) { 1402 1403 kfree(cdev->req->buf); ··· 1405 1406 device_remove_file(&gadget->dev, &dev_attr_suspended); 1406 1407 kfree(cdev); 1407 1408 set_gadget_data(gadget, NULL); 1408 1408 - composite = NULL; 1409 1409 } 1410 1410 1411 1411 static u8 override_id(struct usb_composite_dev *cdev, u8 *desc) ··· 1420 1422 return *desc; 1421 1423 } 1422 1424 1423 1423 - static int composite_bind(struct usb_gadget *gadget) 1425 1425 + static struct usb_composite_driver *to_cdriver(struct usb_gadget_driver *gdrv) 1426 1426 + { 1427 1427 + return container_of(gdrv, struct usb_composite_driver, gadget_driver); 1428 1428 + } 1429 1429 + 1430 1430 + static int composite_bind(struct usb_gadget *gadget, 1431 1431 + struct usb_gadget_driver *gdriver) 1424 1432 { 1425 1433 struct usb_composite_dev *cdev; 1434 1434 + struct usb_composite_driver *composite = to_cdriver(gdriver); 1426 1435 int status = -ENOMEM; 1427 1436 1428 1437 cdev = kzalloc(sizeof *cdev, GFP_KERNEL); ··· 1551 1546 f->suspend(f); 1552 1547 } 1553 1548 } 1554 1554 - if (composite->suspend) 1555 1555 - composite->suspend(cdev); 1549 1549 + if (cdev->driver->suspend) 1550 1550 + cdev->driver->suspend(cdev); 1556 1551 1557 1552 cdev->suspended = 1; 1558 1553 ··· 1570 1565 * suspend/resume callbacks? 1571 1566 */ 1572 1567 DBG(cdev, "resume\n"); 1573 1573 - if (composite->resume) 1574 1574 - composite->resume(cdev); 1568 1568 + if (cdev->driver->resume) 1569 1569 + cdev->driver->resume(cdev); 1575 1570 if (cdev->config) { 1576 1571 list_for_each_entry(f, &cdev->config->functions, list) { 1577 1572 if (f->resume) ··· 1589 1584 1590 1585 /*-------------------------------------------------------------------------*/ 1591 1586 1592 1592 - static struct usb_gadget_driver composite_driver = { 1587 1587 + static const struct usb_gadget_driver composite_driver_template = { 1593 1588 .bind = composite_bind, 1594 1589 .unbind = composite_unbind, 1595 1590 ··· 1625 1620 */ 1626 1621 int usb_composite_probe(struct usb_composite_driver *driver) 1627 1622 { 1628 1628 - if (!driver || !driver->dev || composite || !driver->bind) 1623 1623 + struct usb_gadget_driver *gadget_driver; 1624 1624 + 1625 1625 + if (!driver || !driver->dev || !driver->bind) 1629 1626 return -EINVAL; 1630 1627 1631 1628 if (!driver->name) 1632 1629 driver->name = "composite"; 1633 1630 if (!driver->iProduct) 1634 1631 driver->iProduct = driver->name; 1635 1635 - composite_driver.function = (char *) driver->name; 1636 1636 - composite_driver.driver.name = driver->name; 1637 1637 - composite_driver.max_speed = driver->max_speed; 1638 1638 - composite = driver; 1639 1632 1640 1640 - return usb_gadget_probe_driver(&composite_driver); 1633 1633 + driver->gadget_driver = composite_driver_template; 1634 1634 + gadget_driver = &driver->gadget_driver; 1635 1635 + 1636 1636 + gadget_driver->function = (char *) driver->name; 1637 1637 + gadget_driver->driver.name = driver->name; 1638 1638 + gadget_driver->max_speed = driver->max_speed; 1639 1639 + 1640 1640 + return usb_gadget_probe_driver(gadget_driver); 1641 1641 } 1642 1642 1643 1643 /** ··· 1654 1644 */ 1655 1645 void usb_composite_unregister(struct usb_composite_driver *driver) 1656 1646 { 1657 1657 - if (composite != driver) 1658 1658 - return; 1659 1659 - usb_gadget_unregister_driver(&composite_driver); 1647 1647 + usb_gadget_unregister_driver(&driver->gadget_driver); 1660 1648 } 1661 1649 1662 1650 /**

+2 -1

drivers/usb/gadget/dbgp.c

reviewed

··· 292 292 return -ENODEV; 293 293 } 294 294 295 295 - static int __init dbgp_bind(struct usb_gadget *gadget) 295 295 + static int __init dbgp_bind(struct usb_gadget *gadget, 296 296 + struct usb_gadget_driver *driver) 296 297 { 297 298 int err, stp; 298 299

+2 -1

drivers/usb/gadget/file_storage.c

reviewed

··· 3331 3331 } 3332 3332 3333 3333 3334 3334 - static int __init fsg_bind(struct usb_gadget *gadget) 3334 3334 + static int __init fsg_bind(struct usb_gadget *gadget, 3335 3335 + struct usb_gadget_driver *driver) 3335 3336 { 3336 3337 struct fsg_dev *fsg = the_fsg; 3337 3338 int rc;

+3 -3

drivers/usb/gadget/fsl_udc_core.c

reviewed

··· 1255 1255 } 1256 1256 1257 1257 static int fsl_start(struct usb_gadget_driver *driver, 1258 1258 - int (*bind)(struct usb_gadget *)); 1258 1258 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 1259 1259 static int fsl_stop(struct usb_gadget_driver *driver); 1260 1260 /* defined in gadget.h */ 1261 1261 static struct usb_gadget_ops fsl_gadget_ops = { ··· 1951 1951 * Called by initialization code of gadget drivers 1952 1952 *----------------------------------------------------------------*/ 1953 1953 static int fsl_start(struct usb_gadget_driver *driver, 1954 1954 - int (*bind)(struct usb_gadget *)) 1954 1954 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1955 1955 { 1956 1956 int retval = -ENODEV; 1957 1957 unsigned long flags = 0; ··· 1976 1976 spin_unlock_irqrestore(&udc_controller->lock, flags); 1977 1977 1978 1978 /* bind udc driver to gadget driver */ 1979 1979 - retval = bind(&udc_controller->gadget); 1979 1979 + retval = bind(&udc_controller->gadget, driver); 1980 1980 if (retval) { 1981 1981 VDBG("bind to %s --> %d", driver->driver.name, retval); 1982 1982 udc_controller->gadget.dev.driver = NULL;

+2 -2

drivers/usb/gadget/fusb300_udc.c

reviewed

··· 1311 1311 static struct fusb300 *the_controller; 1312 1312 1313 1313 static int fusb300_udc_start(struct usb_gadget_driver *driver, 1314 1314 - int (*bind)(struct usb_gadget *)) 1314 1314 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1315 1315 { 1316 1316 struct fusb300 *fusb300 = the_controller; 1317 1317 int retval; ··· 1339 1339 goto error; 1340 1340 } 1341 1341 1342 1342 - retval = bind(&fusb300->gadget); 1342 1342 + retval = bind(&fusb300->gadget, driver); 1343 1343 if (retval) { 1344 1344 pr_err("bind to driver error (%d)\n", retval); 1345 1345 device_del(&fusb300->gadget.dev);

+3 -3

drivers/usb/gadget/goku_udc.c

reviewed

··· 994 994 } 995 995 996 996 static int goku_start(struct usb_gadget_driver *driver, 997 997 - int (*bind)(struct usb_gadget *)); 997 997 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 998 998 static int goku_stop(struct usb_gadget_driver *driver); 999 999 1000 1000 static const struct usb_gadget_ops goku_ops = { ··· 1348 1348 * the driver might get unbound. 1349 1349 */ 1350 1350 static int goku_start(struct usb_gadget_driver *driver, 1351 1351 - int (*bind)(struct usb_gadget *)) 1351 1351 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1352 1352 { 1353 1353 struct goku_udc *dev = the_controller; 1354 1354 int retval; ··· 1368 1368 driver->driver.bus = NULL; 1369 1369 dev->driver = driver; 1370 1370 dev->gadget.dev.driver = &driver->driver; 1371 1371 - retval = bind(&dev->gadget); 1371 1371 + retval = bind(&dev->gadget, driver); 1372 1372 if (retval) { 1373 1373 DBG(dev, "bind to driver %s --> error %d\n", 1374 1374 driver->driver.name, retval);

+4 -3

drivers/usb/gadget/inode.c

reviewed

··· 1679 1679 1680 1680 static struct dev_data *the_device; 1681 1681 1682 1682 - static int 1683 1683 - gadgetfs_bind (struct usb_gadget *gadget) 1682 1682 + static int gadgetfs_bind(struct usb_gadget *gadget, 1683 1683 + struct usb_gadget_driver *driver) 1684 1684 { 1685 1685 struct dev_data *dev = the_device; 1686 1686 ··· 1773 1773 1774 1774 static void gadgetfs_nop(struct usb_gadget *arg) { } 1775 1775 1776 1776 - static int gadgetfs_probe (struct usb_gadget *gadget) 1776 1776 + static int gadgetfs_probe(struct usb_gadget *gadget, 1777 1777 + struct usb_gadget_driver *driver) 1777 1778 { 1778 1779 CHIP = gadget->name; 1779 1780 return -EISNAM;

+2 -2

drivers/usb/gadget/m66592-udc.c

reviewed

··· 1466 1466 static struct m66592 *the_controller; 1467 1467 1468 1468 static int m66592_start(struct usb_gadget_driver *driver, 1469 1469 - int (*bind)(struct usb_gadget *)) 1469 1469 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1470 1470 { 1471 1471 struct m66592 *m66592 = the_controller; 1472 1472 int retval; ··· 1492 1492 goto error; 1493 1493 } 1494 1494 1495 1495 - retval = bind(&m66592->gadget); 1495 1495 + retval = bind(&m66592->gadget, driver); 1496 1496 if (retval) { 1497 1497 pr_err("bind to driver error (%d)\n", retval); 1498 1498 device_del(&m66592->gadget.dev);

+3 -3

drivers/usb/gadget/mv_udc_core.c

reviewed

··· 1269 1269 } 1270 1270 1271 1271 static int mv_udc_start(struct usb_gadget_driver *driver, 1272 1272 - int (*bind)(struct usb_gadget *)); 1272 1272 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 1273 1273 static int mv_udc_stop(struct usb_gadget_driver *driver); 1274 1274 /* device controller usb_gadget_ops structure */ 1275 1275 static const struct usb_gadget_ops mv_ops = { ··· 1374 1374 } 1375 1375 1376 1376 static int mv_udc_start(struct usb_gadget_driver *driver, 1377 1377 - int (*bind)(struct usb_gadget *)) 1377 1377 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1378 1378 { 1379 1379 struct mv_udc *udc = the_controller; 1380 1380 int retval = 0; ··· 1399 1399 1400 1400 spin_unlock_irqrestore(&udc->lock, flags); 1401 1401 1402 1402 - retval = bind(&udc->gadget); 1402 1402 + retval = bind(&udc->gadget, driver); 1403 1403 if (retval) { 1404 1404 dev_err(&udc->dev->dev, "bind to driver %s --> %d\n", 1405 1405 driver->driver.name, retval);

+3 -3

drivers/usb/gadget/omap_udc.c

reviewed

··· 1308 1308 } 1309 1309 1310 1310 static int omap_udc_start(struct usb_gadget_driver *driver, 1311 1311 - int (*bind)(struct usb_gadget *)); 1311 1311 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 1312 1312 static int omap_udc_stop(struct usb_gadget_driver *driver); 1313 1313 1314 1314 static struct usb_gadget_ops omap_gadget_ops = { ··· 2040 2040 } 2041 2041 2042 2042 static int omap_udc_start(struct usb_gadget_driver *driver, 2043 2043 - int (*bind)(struct usb_gadget *)) 2043 2043 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 2044 2044 { 2045 2045 int status = -ENODEV; 2046 2046 struct omap_ep *ep; ··· 2082 2082 if (udc->dc_clk != NULL) 2083 2083 omap_udc_enable_clock(1); 2084 2084 2085 2085 - status = bind(&udc->gadget); 2085 2085 + status = bind(&udc->gadget, driver); 2086 2086 if (status) { 2087 2087 DBG("bind to %s --> %d\n", driver->driver.name, status); 2088 2088 udc->gadget.dev.driver = NULL;

+3 -3

drivers/usb/gadget/pch_udc.c

reviewed

··· 1236 1236 } 1237 1237 1238 1238 static int pch_udc_start(struct usb_gadget_driver *driver, 1239 1239 - int (*bind)(struct usb_gadget *)); 1239 1239 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 1240 1240 static int pch_udc_stop(struct usb_gadget_driver *driver); 1241 1241 static const struct usb_gadget_ops pch_udc_ops = { 1242 1242 .get_frame = pch_udc_pcd_get_frame, ··· 2982 2982 } 2983 2983 2984 2984 static int pch_udc_start(struct usb_gadget_driver *driver, 2985 2985 - int (*bind)(struct usb_gadget *)) 2985 2985 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 2986 2986 { 2987 2987 struct pch_udc_dev *dev = pch_udc; 2988 2988 int retval; ··· 3006 3006 dev->gadget.dev.driver = &driver->driver; 3007 3007 3008 3008 /* Invoke the bind routine of the gadget driver */ 3009 3009 - retval = bind(&dev->gadget); 3009 3009 + retval = bind(&dev->gadget, driver); 3010 3010 3011 3011 if (retval) { 3012 3012 dev_err(&dev->pdev->dev, "%s: binding to %s returning %d\n",

+3 -3

drivers/usb/gadget/pxa25x_udc.c

reviewed

··· 999 999 } 1000 1000 1001 1001 static int pxa25x_start(struct usb_gadget_driver *driver, 1002 1002 - int (*bind)(struct usb_gadget *)); 1002 1002 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 1003 1003 static int pxa25x_stop(struct usb_gadget_driver *driver); 1004 1004 1005 1005 static const struct usb_gadget_ops pxa25x_udc_ops = { ··· 1257 1257 * the driver might get unbound. 1258 1258 */ 1259 1259 static int pxa25x_start(struct usb_gadget_driver *driver, 1260 1260 - int (*bind)(struct usb_gadget *)) 1260 1260 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1261 1261 { 1262 1262 struct pxa25x_udc *dev = the_controller; 1263 1263 int retval; ··· 1285 1285 dev->gadget.dev.driver = NULL; 1286 1286 return retval; 1287 1287 } 1288 1288 - retval = bind(&dev->gadget); 1288 1288 + retval = bind(&dev->gadget, driver); 1289 1289 if (retval) { 1290 1290 DMSG("bind to driver %s --> error %d\n", 1291 1291 driver->driver.name, retval);

+3 -3

drivers/usb/gadget/pxa27x_udc.c

reviewed

··· 1672 1672 } 1673 1673 1674 1674 static int pxa27x_udc_start(struct usb_gadget_driver *driver, 1675 1675 - int (*bind)(struct usb_gadget *)); 1675 1675 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 1676 1676 static int pxa27x_udc_stop(struct usb_gadget_driver *driver); 1677 1677 1678 1678 static const struct usb_gadget_ops pxa_udc_ops = { ··· 1803 1803 * Returns 0 if no error, -EINVAL, -ENODEV, -EBUSY otherwise 1804 1804 */ 1805 1805 static int pxa27x_udc_start(struct usb_gadget_driver *driver, 1806 1806 - int (*bind)(struct usb_gadget *)) 1806 1806 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1807 1807 { 1808 1808 struct pxa_udc *udc = the_controller; 1809 1809 int retval; ··· 1826 1826 dev_err(udc->dev, "device_add error %d\n", retval); 1827 1827 goto add_fail; 1828 1828 } 1829 1829 - retval = bind(&udc->gadget); 1829 1829 + retval = bind(&udc->gadget, driver); 1830 1830 if (retval) { 1831 1831 dev_err(udc->dev, "bind to driver %s --> error %d\n", 1832 1832 driver->driver.name, retval);

+3 -3

drivers/usb/gadget/s3c2410_udc.c

reviewed

··· 1539 1539 } 1540 1540 1541 1541 static int s3c2410_udc_start(struct usb_gadget_driver *driver, 1542 1542 - int (*bind)(struct usb_gadget *)); 1542 1542 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)); 1543 1543 static int s3c2410_udc_stop(struct usb_gadget_driver *driver); 1544 1544 1545 1545 static const struct usb_gadget_ops s3c2410_ops = { ··· 1665 1665 } 1666 1666 1667 1667 static int s3c2410_udc_start(struct usb_gadget_driver *driver, 1668 1668 - int (*bind)(struct usb_gadget *)) 1668 1668 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 1669 1669 { 1670 1670 struct s3c2410_udc *udc = the_controller; 1671 1671 int retval; ··· 1705 1705 dprintk(DEBUG_NORMAL, "binding gadget driver '%s'\n", 1706 1706 driver->driver.name); 1707 1707 1708 1708 - retval = bind(&udc->gadget); 1708 1708 + retval = bind(&udc->gadget, driver); 1709 1709 if (retval) { 1710 1710 device_del(&udc->gadget.dev); 1711 1711 goto register_error;

+2 -2

drivers/usb/gadget/udc-core.c

reviewed

··· 118 118 */ 119 119 static inline int usb_gadget_start(struct usb_gadget *gadget, 120 120 struct usb_gadget_driver *driver, 121 121 - int (*bind)(struct usb_gadget *)) 121 121 + int (*bind)(struct usb_gadget *, struct usb_gadget_driver *)) 122 122 { 123 123 return gadget->ops->start(driver, bind); 124 124 } ··· 338 338 udc->dev.driver = &driver->driver; 339 339 340 340 if (udc_is_newstyle(udc)) { 341 341 - ret = driver->bind(udc->gadget); 341 341 + ret = driver->bind(udc->gadget, driver); 342 342 if (ret) 343 343 goto err1; 344 344 ret = usb_gadget_udc_start(udc->gadget, driver);

include/linux/usb/composite.h

reviewed

··· 303 303 /* global suspend hooks */ 304 304 void (*suspend)(struct usb_composite_dev *); 305 305 void (*resume)(struct usb_composite_dev *); 306 306 + struct usb_gadget_driver gadget_driver; 306 307 }; 307 308 308 309 extern int usb_composite_probe(struct usb_composite_driver *driver);

+4 -2

include/linux/usb/gadget.h

reviewed

··· 474 474 475 475 /* Those two are deprecated */ 476 476 int (*start)(struct usb_gadget_driver *, 477 477 - int (*bind)(struct usb_gadget *)); 477 477 + int (*bind)(struct usb_gadget *, 478 478 + struct usb_gadget_driver *driver)); 478 479 int (*stop)(struct usb_gadget_driver *); 479 480 }; 480 481 ··· 822 821 struct usb_gadget_driver { 823 822 char *function; 824 823 enum usb_device_speed max_speed; 825 825 - int (*bind)(struct usb_gadget *gadget); 824 824 + int (*bind)(struct usb_gadget *gadget, 825 825 + struct usb_gadget_driver *driver); 826 826 void (*unbind)(struct usb_gadget *); 827 827 int (*setup)(struct usb_gadget *, 828 828 const struct usb_ctrlrequest *);